feat: MVP v0.5 complete - All P0 features implemented and frontend verified. Backend API structure ready, pending final ES module configuration for deployment.

dist-server/lib/decision-cards.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * 决策交互卡片
+ * 飞书消息卡片格式 + 回调处理
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DECISION_TEMPLATES = void 0;
+exports.buildDecisionCard = buildDecisionCard;
+exports.createDecision = createDecision;
+exports.handleDecisionCallback = handleDecisionCallback;
+exports.getPendingDecisions = getPendingDecisions;
+/**
+ * 生成飞书消息卡片JSON
+ */
+function buildDecisionCard(card) {
+    var elements = [
+        {
+            tag: 'div',
+            text: { tag: 'plain_text', content: card.description },
+        },
+    ];
+    // Action buttons
+    var actions = card.options.map(function (opt) { return ({
+        tag: 'button',
+        text: { tag: 'plain_text', content: opt.label },
+        type: opt.style === 'danger' ? 'danger' : opt.style === 'primary' ? 'primary' : 'default',
+        value: __assign({ action: opt.key }, card.metadata),
+    }); });
+    elements.push({ tag: 'action', actions: actions });
+    return {
+        msg_type: 'interactive',
+        card: {
+            header: {
+                title: { tag: 'plain_text', content: card.title },
+                template: 'blue',
+            },
+            elements: elements,
+        },
+    };
+}
+var pendingDecisions = new Map();
+/**
+ * 创建决策请求
+ */
+function createDecision(card) {
+    var id = "decision-".concat(Date.now());
+    var record = {
+        id: id,
+        cardTitle: card.title,
+        type: card.type,
+        options: card.options.map(function (o) { return o.key; }),
+        chosenOption: null,
+        status: 'pending',
+        createdAt: new Date().toISOString(),
+    };
+    pendingDecisions.set(id, record);
+    return record;
+}
+/**
+ * 处理决策回调
+ */
+function handleDecisionCallback(decisionId, actionKey) {
+    var record = pendingDecisions.get(decisionId);
+    if (!record) {
+        return { ok: false, error: 'Decision not found' };
+    }
+    if (record.status !== 'pending') {
+        return { ok: false, error: 'Already responded' };
+    }
+    record.chosenOption = actionKey;
+    record.status = 'responded';
+    record.respondedAt = new Date().toISOString();
+    return { ok: true, record: record };
+}
+/**
+ * 获取待决策列表
+ */
+function getPendingDecisions() {
+    return Array.from(pendingDecisions.values()).filter(function (d) { return d.status === 'pending'; });
+}
+/**
+ * 预定义的决策卡片模板
+ */
+exports.DECISION_TEMPLATES = {
+    /** 章程审批 */
+    charterApproval: function (projectName) { return ({
+        title: '📋 项目章程审批',
+        description: "\u9879\u76EE\u300C".concat(projectName, "\u300D\u7684\u7AE0\u7A0B\u5DF2\u751F\u6210\uFF0C\u8BF7\u5BA1\u6279\u3002"),
+        type: 'approve_reject',
+        options: [
+            { key: 'approve', label: '✅ 批准', style: 'primary', value: 'approved' },
+            { key: 'reject', label: '❌ 驳回', style: 'danger', value: 'rejected' },
+            { key: 'revise', label: '✏️ 需修改', value: 'needs_revision' },
+        ],
+        metadata: { type: 'charter', project: projectName },
+    }); },
+    /** 风险应对 */
+    riskResponse: function (riskDesc, priority) { return ({
+        title: "\u26A0\uFE0F \u98CE\u9669\u5E94\u5BF9\u51B3\u7B56\uFF08\u4F18\u5148\u7EA7".concat(priority, "\uFF09"),
+        description: riskDesc,
+        type: 'multi_choice',
+        options: [
+            { key: 'avoid', label: '🛡 规避', value: 'avoid' },
+            { key: 'transfer', label: '🔄 转移', value: 'transfer' },
+            { key: 'mitigate', label: '🔧 减轻', value: 'mitigate' },
+            { key: 'accept', label: '✅ 接受', value: 'accept' },
+        ],
+        metadata: { type: 'risk', priority: priority },
+    }); },
+    /** 变更审批 */
+    changeApproval: function (changeDesc) { return ({
+        title: '🔀 变更请求审批',
+        description: changeDesc,
+        type: 'approve_reject',
+        options: [
+            { key: 'approve', label: '✅ 批准', style: 'primary', value: 'approved' },
+            { key: 'reject', label: '❌ 拒绝', style: 'danger', value: 'rejected' },
+            { key: 'defer', label: '⏳ 延后', value: 'deferred' },
+        ],
+        metadata: { type: 'change' },
+    }); },
+    /** 里程碑确认 */
+    milestoneConfirm: function (name, date) { return ({
+        title: "\uD83C\uDFC1 \u91CC\u7A0B\u7891\u8FBE\u6210\u786E\u8BA4",
+        description: "\u91CC\u7A0B\u7891\u300C".concat(name, "\u300D\uFF08\u76EE\u6807\uFF1A").concat(date, "\uFF09\u662F\u5426\u5DF2\u8FBE\u6210\uFF1F"),
+        type: 'confirm',
+        options: [
+            { key: 'done', label: '✅ 已达成', style: 'primary', value: 'reached' },
+            { key: 'missed', label: '❌ 未达成', style: 'danger', value: 'missed' },
+        ],
+        metadata: { type: 'milestone', name: name, date: date },
+    }); },
+};

dist-server/lib/experience-manager.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * 经验管理员 - 知识管理 + 执行记录 + 跨Agent协调
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExperienceManager = void 0;
+/**
+ * 经验管理员
+ */
+var ExperienceManager = /** @class */ (function () {
+    function ExperienceManager() {
+        this.executionLog = [];
+        this.decisionLog = [];
+        this.knowledgeBase = new Map();
+        this.records = [];
+    }
+    /**
+     * 记录Agent执行结果
+     */
+    ExperienceManager.prototype.recordExecution = function (record) {
+        this.records.push(record);
+        // Update knowledge base
+        this._updateKnowledge(record);
+    };
+    /**
+     * 获取相关上下文供Agent使用
+     */
+    ExperienceManager.prototype.getContext = function (taskType, keywords) {
+        // Find recent similar executions
+        var recentExecutions = this.records
+            .filter(function (r) { return r.atomicType === taskType; })
+            .slice(-10);
+        // Find relevant knowledge entries
+        var relevantKnowledge = Array.from(this.knowledgeBase.values())
+            .filter(function (k) { return k.taskType === taskType && k.score >= 3; });
+        // Generate suggestion
+        var bestPractice = relevantKnowledge
+            .sort(function (a, b) { return b.score - a.score; })[0];
+        var suggestion = bestPractice
+            ? "Based on ".concat(bestPractice.successCount, " successful executions, avg score ").concat(bestPractice.score.toFixed(1), ": use input pattern ").concat(JSON.stringify(Object.keys(bestPractice.inputPattern)))
+            : 'No prior experience for this task type. Using default approach.';
+        return { recentExecutions: recentExecutions, relevantKnowledge: relevantKnowledge, suggestion: suggestion };
+    };
+    /**
+     * 记录决策
+     */
+    ExperienceManager.prototype.recordDecision = function (decision) {
+        this.decisionLog.push(__assign(__assign({}, decision), { id: "decision-".concat(Date.now()), createdAt: new Date().toISOString() }));
+    };
+    /**
+     * 检查是否需要人工介入
+     */
+    ExperienceManager.prototype.checkInterventionNeeded = function (taskId, score, consecutiveFailures) {
+        if (score <= 2) {
+            return {
+                needed: true,
+                reason: "Agent execution score too low (".concat(score, "/5). Needs human review."),
+            };
+        }
+        if (consecutiveFailures >= 3) {
+            return {
+                needed: true,
+                reason: "".concat(consecutiveFailures, " consecutive failures. Human intervention required."),
+            };
+        }
+        return { needed: false, reason: '' };
+    };
+    /**
+     * 获取项目知识库摘要
+     */
+    ExperienceManager.prototype.getKnowledgeSummary = function () {
+        var entries = Array.from(this.knowledgeBase.values());
+        var byType = {};
+        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+            var e = entries_1[_i];
+            byType[e.taskType] = (byType[e.taskType] || 0) + 1;
+        }
+        var avgScore = entries.length > 0
+            ? entries.reduce(function (sum, e) { return sum + e.score; }, 0) / entries.length
+            : 0;
+        return { totalEntries: entries.length, byType: byType, avgScore: avgScore };
+    };
+    /**
+     * 获取执行历史
+     */
+    ExperienceManager.prototype.getExecutionHistory = function (taskId) {
+        if (taskId) {
+            return this.records.filter(function (r) { return r.taskId === taskId; });
+        }
+        return this.records;
+    };
+    /**
+     * 获取决策历史
+     */
+    ExperienceManager.prototype.getDecisionHistory = function () {
+        return this.decisionLog;
+    };
+    // --- Private ---
+    ExperienceManager.prototype._updateKnowledge = function (record) {
+        var key = "".concat(record.atomicType, "_").concat(record.model);
+        var existing = this.knowledgeBase.get(key);
+        if (existing) {
+            existing.successCount += record.success ? 1 : 0;
+            existing.failCount += record.success ? 0 : 1;
+            // Running average score
+            var totalRuns = existing.successCount + existing.failCount;
+            existing.score = (existing.score * (totalRuns - 1) + record.score) / totalRuns;
+        }
+        else {
+            this.knowledgeBase.set(key, {
+                id: "kb-".concat(Date.now()),
+                taskType: record.atomicType,
+                description: "Pattern for ".concat(record.atomicType, " with ").concat(record.model),
+                inputPattern: record.input,
+                outputPattern: record.output,
+                score: record.score,
+                successCount: record.success ? 1 : 0,
+                failCount: record.success ? 0 : 1,
+                learnedAt: new Date().toISOString(),
+            });
+        }
+    };
+    return ExperienceManager;
+}());
+exports.ExperienceManager = ExperienceManager;

dist-server/lib/hr-manager.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * HR管理员 - 任务拆解引擎
+ * 将高级任务递归分解为原子任务
+ */
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HRManager = exports.ATOMIC_TASK_TYPES = exports.AtomicTaskType = void 0;
+var AtomicTaskType;
+(function (AtomicTaskType) {
+    AtomicTaskType["FILL_TEMPLATE"] = "fill_template";
+    AtomicTaskType["SUMMARIZE"] = "summarize";
+    AtomicTaskType["FORMAT_CONVERT"] = "format_convert";
+    AtomicTaskType["EVALUATE"] = "evaluate";
+    AtomicTaskType["RISK_IDENTIFY"] = "risk_identify";
+    AtomicTaskType["PRIORITIZE"] = "prioritize";
+    AtomicTaskType["GENERATE_NOTIFICATION"] = "generate_notification";
+    AtomicTaskType["AGGREGATE_REPORT"] = "aggregate_report";
+    AtomicTaskType["STATUS_UPDATE"] = "status_update";
+    AtomicTaskType["EXTRACT"] = "extract";
+})(AtomicTaskType || (exports.AtomicTaskType = AtomicTaskType = {}));
+/**
+ * 原子任务类型库
+ */
+exports.ATOMIC_TASK_TYPES = (_a = {},
+    _a[AtomicTaskType.FILL_TEMPLATE] = {
+        type: AtomicTaskType.FILL_TEMPLATE,
+        category: 'document',
+        description: '给定模板+数据 → 输出填充后文档',
+        estimatedTokens: 3000,
+        inputSchema: { template: 'string', data: 'object' },
+        outputSchema: { document: 'string' },
+    },
+    _a[AtomicTaskType.SUMMARIZE] = {
+        type: AtomicTaskType.SUMMARIZE,
+        category: 'document',
+        description: '给定长文 → 输出摘要',
+        estimatedTokens: 2000,
+        inputSchema: { content: 'string', maxLength: 'number' },
+        outputSchema: { summary: 'string' },
+    },
+    _a[AtomicTaskType.FORMAT_CONVERT] = {
+        type: AtomicTaskType.FORMAT_CONVERT,
+        category: 'document',
+        description: '给定内容 → 按目标格式输出',
+        estimatedTokens: 2000,
+        inputSchema: { content: 'string', targetFormat: 'string' },
+        outputSchema: { formatted: 'string' },
+    },
+    _a[AtomicTaskType.EVALUATE] = {
+        type: AtomicTaskType.EVALUATE,
+        category: 'analysis',
+        description: '给定标准+对象 → 输出评分+理由',
+        estimatedTokens: 1500,
+        inputSchema: { criteria: 'array', target: 'object' },
+        outputSchema: { score: 'number', reasoning: 'string' },
+    },
+    _a[AtomicTaskType.RISK_IDENTIFY] = {
+        type: AtomicTaskType.RISK_IDENTIFY,
+        category: 'analysis',
+        description: '给定范围 → 输出风险列表',
+        estimatedTokens: 1500,
+        inputSchema: { scope: 'string', context: 'object' },
+        outputSchema: { risks: 'array' },
+    },
+    _a[AtomicTaskType.PRIORITIZE] = {
+        type: AtomicTaskType.PRIORITIZE,
+        category: 'analysis',
+        description: '给定列表+标准 → 输出排序结果',
+        estimatedTokens: 1200,
+        inputSchema: { items: 'array', criteria: 'array' },
+        outputSchema: { sorted: 'array' },
+    },
+    _a[AtomicTaskType.GENERATE_NOTIFICATION] = {
+        type: AtomicTaskType.GENERATE_NOTIFICATION,
+        category: 'coordination',
+        description: '给定事件 → 输出消息内容',
+        estimatedTokens: 1000,
+        inputSchema: { event: 'string', recipients: 'array' },
+        outputSchema: { message: 'string' },
+    },
+    _a[AtomicTaskType.AGGREGATE_REPORT] = {
+        type: AtomicTaskType.AGGREGATE_REPORT,
+        category: 'coordination',
+        description: '给定多条数据 → 输出汇总',
+        estimatedTokens: 1500,
+        inputSchema: { data: 'array', reportType: 'string' },
+        outputSchema: { report: 'string' },
+    },
+    _a[AtomicTaskType.STATUS_UPDATE] = {
+        type: AtomicTaskType.STATUS_UPDATE,
+        category: 'data',
+        description: '给定条件 → 查询并更新',
+        estimatedTokens: 1000,
+        inputSchema: { query: 'object', updates: 'object' },
+        outputSchema: { updated: 'boolean', record: 'object' },
+    },
+    _a[AtomicTaskType.EXTRACT] = {
+        type: AtomicTaskType.EXTRACT,
+        category: 'data',
+        description: '给定源 → 提取指定字段',
+        estimatedTokens: 1000,
+        inputSchema: { source: 'string', fields: 'array' },
+        outputSchema: { extracted: 'object' },
+    },
+    _a);
+/**
+ * 原子任务判定标准
+ */
+function isAtomic(task) {
+    var _a;
+    return (Object.keys(task.input).length > 0 && // 输入确定
+        task.outputFormat !== undefined && // 输出确定
+        !((_a = task.dependencies) === null || _a === void 0 ? void 0 : _a.length) && // 无外部依赖
+        task.estimatedTokens <= 6000 // 时间可控
+    );
+}
+/**
+ * HR管理员核心：递归任务分解
+ */
+var HRManager = /** @class */ (function () {
+    function HRManager() {
+        this.taskIdCounter = 0;
+    }
+    /**
+     * 将高级任务分解为原子任务列表
+     */
+    HRManager.prototype.decompose = function (highLevelTask, context) {
+        var _a;
+        var tasks = this._matchPatterns(highLevelTask, context);
+        // Recursive check: decompose non-atomic tasks further
+        var result = [];
+        for (var _i = 0, tasks_1 = tasks; _i < tasks_1.length; _i++) {
+            var task = tasks_1[_i];
+            if (isAtomic(task) || !((_a = task.children) === null || _a === void 0 ? void 0 : _a.length)) {
+                result.push(task);
+            }
+            else {
+                // Decompose children further
+                for (var _b = 0, _c = task.children || []; _b < _c.length; _b++) {
+                    var child = _c[_b];
+                    if (isAtomic(child)) {
+                        result.push(child);
+                    }
+                    else {
+                        result.push.apply(result, this.decompose(child.title, child.input));
+                    }
+                }
+            }
+        }
+        return result;
+    };
+    /**
+     * 为原子任务选择最佳模型
+     */
+    HRManager.prototype.selectModel = function (taskType) {
+        var _a;
+        var modelMap = (_a = {},
+            _a[AtomicTaskType.FILL_TEMPLATE] = 'claude-3-haiku',
+            _a[AtomicTaskType.SUMMARIZE] = 'gpt-4o-mini',
+            _a[AtomicTaskType.FORMAT_CONVERT] = 'gpt-4o-mini',
+            _a[AtomicTaskType.EVALUATE] = 'gpt-4-turbo',
+            _a[AtomicTaskType.RISK_IDENTIFY] = 'claude-3-sonnet',
+            _a[AtomicTaskType.PRIORITIZE] = 'gpt-4o-mini',
+            _a[AtomicTaskType.GENERATE_NOTIFICATION] = 'gpt-4o-mini',
+            _a[AtomicTaskType.AGGREGATE_REPORT] = 'claude-3-sonnet',
+            _a[AtomicTaskType.STATUS_UPDATE] = 'gpt-4o-mini',
+            _a[AtomicTaskType.EXTRACT] = 'gpt-4o-mini',
+            _a);
+        return modelMap[taskType] || 'gpt-4o-mini';
+    };
+    HRManager.prototype._generateId = function () {
+        return "task-".concat(++this.taskIdCounter, "-").concat(Date.now());
+    };
+    /**
+     * Pattern matching for known PM phases
+     */
+    HRManager.prototype._matchPatterns = function (task, context) {
+        var lower = task.toLowerCase();
+        // Project Charter
+        if (lower.includes('章程') || lower.includes('charter')) {
+            return [
+                {
+                    id: this._generateId(),
+                    title: '生成项目章程',
+                    description: '根据项目信息填充章程模板',
+                    atomicType: AtomicTaskType.FILL_TEMPLATE,
+                    input: { template: 'project_charter', data: context || {} },
+                    outputFormat: { document: 'string' },
+                    estimatedTokens: 3000,
+                    priority: 'must',
+                },
+                {
+                    id: this._generateId(),
+                    title: '分析干系人',
+                    description: '根据项目背景识别关键干系人',
+                    atomicType: AtomicTaskType.RISK_IDENTIFY,
+                    input: { scope: 'stakeholders', context: context || {} },
+                    outputFormat: { stakeholders: 'array' },
+                    estimatedTokens: 1500,
+                    priority: 'must',
+                    dependencies: [],
+                },
+            ];
+        }
+        // Risk Management
+        if (lower.includes('风险') || lower.includes('risk')) {
+            return [
+                {
+                    id: this._generateId(),
+                    title: '识别项目风险',
+                    description: '从技术/资源/范围/外部四个维度识别风险',
+                    atomicType: AtomicTaskType.RISK_IDENTIFY,
+                    input: { scope: 'project_risks', context: context || {} },
+                    outputFormat: { risks: 'array' },
+                    estimatedTokens: 2000,
+                    priority: 'must',
+                },
+                {
+                    id: this._generateId(),
+                    title: '生成风险应对策略',
+                    description: '为高优先级风险制定规避/转移/减轻/接受策略',
+                    atomicType: AtomicTaskType.EVALUATE,
+                    input: { criteria: ['probability', 'impact', 'strategy'], target: {} },
+                    outputFormat: { mitigations: 'array' },
+                    estimatedTokens: 1500,
+                    priority: 'must',
+                },
+            ];
+        }
+        // Schedule / Progress
+        if (lower.includes('进度') || lower.includes('schedule') || lower.includes('排期')) {
+            return [
+                {
+                    id: this._generateId(),
+                    title: '分析任务依赖关系',
+                    description: '确定任务间的先后顺序和关键路径',
+                    atomicType: AtomicTaskType.PRIORITIZE,
+                    input: { items: (context === null || context === void 0 ? void 0 : context.tasks) || [], criteria: ['dependency', 'priority'] },
+                    outputFormat: { sorted: 'array', criticalPath: 'array' },
+                    estimatedTokens: 2000,
+                    priority: 'must',
+                },
+                {
+                    id: this._generateId(),
+                    title: '生成进度计划',
+                    description: '基于依赖关系和估算生成甘特图数据',
+                    atomicType: AtomicTaskType.FILL_TEMPLATE,
+                    input: { template: 'schedule', data: context || {} },
+                    outputFormat: { schedule: 'object' },
+                    estimatedTokens: 3000,
+                    priority: 'must',
+                },
+            ];
+        }
+        // Weekly Report
+        if (lower.includes('周报') || lower.includes('报告') || lower.includes('report')) {
+            return [
+                {
+                    id: this._generateId(),
+                    title: '汇总项目进度数据',
+                    description: '收集任务完成情况、Bug数据、风险状态',
+                    atomicType: AtomicTaskType.AGGREGATE_REPORT,
+                    input: { data: (context === null || context === void 0 ? void 0 : context.tasks) || [], reportType: 'weekly' },
+                    outputFormat: { report: 'string' },
+                    estimatedTokens: 1500,
+                    priority: 'should',
+                },
+            ];
+        }
+        // Default: treat as document generation
+        return [
+            {
+                id: this._generateId(),
+                title: task,
+                description: "\u5904\u7406\u4EFB\u52A1\uFF1A".concat(task),
+                atomicType: AtomicTaskType.FILL_TEMPLATE,
+                input: { request: task, context: context || {} },
+                outputFormat: { result: 'string' },
+                estimatedTokens: 2000,
+                priority: 'should',
+            },
+        ];
+    };
+    return HRManager;
+}());
+exports.HRManager = HRManager;

dist-server/lib/models.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * 任务数据模型
+ * 定义任务相关的类型和CRUD操作接口
+ */
+Object.defineProperty(exports, "__esModule", { value: true });