openmatrix 0.1.49 → 0.1.50

package/dist/orchestrator/task-planner.js

@@ -4,45 +4,49 @@ exports.TaskPlanner = void 0;
 /**
  * TaskPlanner - 任务拆解器
  *
- * 1. 按 goals 拆分为多个 coder + tester 任务对
- * 2. goals 为空时退化为 3 任务模式 (planner → coder → tester)
- * 3. 自动注入用户上下文和验收标准
+ * 增强版特性:
+ * 1. 更细粒度的任务拆分 (每个目标拆分为设计+实现+测试)
+ * 2. 测试任务配对 (每个开发任务自动生成对应测试任务)
+ * 3. 验收标准注入 (从用户回答中提取)
+ * 4. 用户上下文注入 (将用户回答注入任务描述)
+ * 5. 依赖关系分析 (自动分析任务间依赖)
  */
 class TaskPlanner {
+    userAnswers;
+    constructor(userAnswers) {
+        this.userAnswers = userAnswers || {};
+    }
     /**
-     * Break down a parsed task into sub-tasks
+     * 设置用户回答
      */
-    breakdown(parsedTask, answers) {
-        const userContext = this.extractUserContext(answers);
-        // 有 goals → 按 goals 拆分多任务
-        if (parsedTask.goals.length > 0) {
-            return this.breakdownByGoals(parsedTask, userContext, answers);
-        }
-        // 无 goals → 退化为 planner → coder → tester 三任务
-        return this.breakdownFallback(parsedTask, userContext, answers);
+    setUserAnswers(answers) {
+        this.userAnswers = answers;
     }
     /**
-     * 按 goals 拆分: 每个 goal 一个 coder + 一个 tester
+     * Break down a parsed task into sub-tasks
+     *
+     * 增强版: 生成更细粒度的任务，包含设计、开发、测试配对
      */
-    breakdownByGoals(parsedTask, userContext, answers) {
+    breakdown(parsedTask, answers) {
         const breakdowns = [];
         const seenTitles = new Set();
-        // 0. 设计阶段 (多 goal 时)
+        const userContext = this.extractUserContext(answers);
+        // 0. 设计阶段任务
         if (parsedTask.goals.length > 1) {
             breakdowns.push({
                 taskId: this.generateTaskId(),
                 title: '架构设计和任务规划',
-                description: `分析需求，设计整体架构，规划实现方案
-
-## 用户需求
-${userContext.objective || parsedTask.title}
-
-## 技术栈
-${userContext.techStack?.join(', ') || '未指定'}
-
-## 输出
-- 架构设计文档
-- 接口定义
+                description: `分析需求，设计整体架构，规划实现方案
+
+## 用户需求
+${userContext.objective || '未指定'}
+
+## 技术栈
+${userContext.techStack?.join(', ') || '未指定'}
+
+## 输出
+- 架构设计文档
+- 接口定义
 - 任务依赖图`,
                 priority: 'P0',
                 dependencies: [],
@@ -57,37 +61,41 @@ ${userContext.techStack?.join(', ') || '未指定'}
                 ]
             });
         }
-        // 1. 为每个 goal 创建 coder + tester 任务对
+        // 1. 为每个目标创建细粒度任务
         const devTaskIds = [];
         for (let i = 0; i < parsedTask.goals.length; i++) {
             const goal = parsedTask.goals[i];
-            if (seenTitles.has(goal))
+            // 跳过重复项
+            if (seenTitles.has(goal)) {
                 continue;
+            }
             seenTitles.add(goal);
+            // 创建开发任务
             const devTaskId = this.generateTaskId();
             devTaskIds.push(devTaskId);
-            // 开发任务
+            const acceptanceCriteria = this.generateAcceptanceCriteria(goal, userContext);
             breakdowns.push({
                 taskId: devTaskId,
                 title: `实现: ${goal}`,
                 description: this.buildTaskDescription(goal, userContext, answers),
                 priority: this.determinePriority(i),
                 dependencies: i === 0 && parsedTask.goals.length > 1
-                    ? [breakdowns[0].taskId]
-                    : (i > 0 ? [devTaskIds[i - 1]] : []),
+                    ? [breakdowns[0].taskId] // 依赖设计任务
+                    : (i > 0 ? [devTaskIds[i - 1]] : []), // 依赖前一个开发任务
                 estimatedComplexity: this.estimateComplexity(goal),
                 assignedAgent: 'coder',
                 phase: 'develop',
-                acceptanceCriteria: this.generateAcceptanceCriteria(goal, userContext)
+                acceptanceCriteria,
+                testTaskId: undefined // 稍后关联
             });
-            // 配对的测试任务
+            // 为每个开发任务创建配对的测试任务
             const testTaskId = this.generateTaskId();
             breakdowns.push({
                 taskId: testTaskId,
                 title: `测试: ${goal}`,
                 description: this.buildTestDescription(goal, devTaskId, userContext),
                 priority: this.determinePriority(i),
-                dependencies: [devTaskId],
+                dependencies: [devTaskId], // 测试依赖开发任务
                 estimatedComplexity: 'medium',
                 assignedAgent: 'tester',
                 phase: 'verify',
@@ -98,23 +106,23 @@ ${userContext.techStack?.join(', ') || '未指定'}
                     '所有测试通过'
                 ]
             });
-            // 关联测试任务
+            // 关联测试任务 ID
             breakdowns[breakdowns.length - 2].testTaskId = testTaskId;
         }
-        // 2. 代码审查 (有开发任务时)
-        if (devTaskIds.length > 1) {
+        // 2. 代码审查任务 (仅在有开发任务时创建)
+        if (devTaskIds.length > 0) {
             breakdowns.push({
                 taskId: this.generateTaskId(),
                 title: '代码审查',
-                description: `对所有开发任务进行代码审查
-
-## 审查范围
-${devTaskIds.map(id => `- ${id}`).join('\n')}
-
-## 审查要点
-- 代码质量
-- 安全性
-- 性能
+                description: `对所有开发任务进行代码审查
+
+## 审查范围
+${devTaskIds.map(id => `- ${id}`).join('\n')}
+
+## 审查要点
+- 代码质量
+- 安全性
+- 性能
 - 最佳实践`,
                 priority: 'P1',
                 dependencies: devTaskIds,
@@ -129,188 +137,270 @@ ${devTaskIds.map(id => `- ${id}`).join('\n')}
                 ]
             });
         }
-        return breakdowns;
-    }
-    /**
-     * 无 goals 时的退化模式: planner → coder → tester
-     * 把 rawContent 整体交给 planner 分析，生成 PLAN.md
-     * coder 基于 PLAN.md 实现
-     */
-    breakdownFallback(parsedTask, userContext, answers) {
-        const planTaskId = this.generateTaskId();
-        const devTaskId = this.generateTaskId();
-        const testTaskId = this.generateTaskId();
-        // 组装完整上下文
-        const contextParts = [];
-        contextParts.push(`## 原始需求\n${parsedTask.rawContent || parsedTask.description || parsedTask.title}`);
-        if (userContext.objective)
-            contextParts.push(`## 核心目标\n${userContext.objective}`);
-        if (userContext.techStack?.length)
-            contextParts.push(`## 技术栈\n${userContext.techStack.join(', ')}`);
-        if (parsedTask.constraints.length)
-            contextParts.push(`## 约束\n${parsedTask.constraints.map(c => `- ${c}`).join('\n')}`);
-        const brainstormKeys = ['brainstormAnswers', 'insights', 'designNotes'];
-        for (const key of brainstormKeys) {
-            if (answers[key])
-                contextParts.push(`## ${key}\n${answers[key]}`);
-        }
-        const fullContext = contextParts.join('\n\n');
-        return [
-            {
-                taskId: planTaskId,
-                title: `${parsedTask.title} - 需求分析与规划`,
-                description: `分析需求并制定实现计划。
-
-${fullContext}
-
-## 你的任务
-1. 深入理解需求
-2. 设计实现方案
-3. 将需求拆解为具体步骤
-
-## 输出: PLAN.md
-在 .openmatrix/plan/ 目录创建 PLAN.md，格式:
-
-# 实现计划
-
-## 架构设计
-(整体方案)
-
-## 实现步骤
-### 步骤 1: (标题)
-- 描述: (具体做什么)
-- 文件: (涉及哪些文件)
-- 验收: (怎么判断完成)
-
-### 步骤 2: (标题)
-...
-
-## 注意事项
-- (风险、约束等)`,
-                priority: 'P0',
-                dependencies: [],
-                estimatedComplexity: 'high',
-                assignedAgent: 'planner',
-                phase: 'design',
-                acceptanceCriteria: [
-                    'PLAN.md 已创建在 .openmatrix/plan/',
-                    '实现步骤清晰可执行',
-                    '每步有明确的文件和验收标准'
-                ]
-            },
-            {
-                taskId: devTaskId,
-                title: `${parsedTask.title} - 开发实现`,
-                description: `根据 PLAN.md 实现功能。
-
-${fullContext}
-
-## 执行方式
-1. 先读取 .openmatrix/plan/PLAN.md
-2. 按照步骤逐一实现
-3. 每完成一个步骤，验证对应的验收标准
-
-## 输出
-- 完整的功能代码
-- 必要的配置文件`,
+        // 3. 集成测试任务 (如果有多个交付物)
+        if (parsedTask.deliverables.length > 1) {
+            breakdowns.push({
+                taskId: this.generateTaskId(),
+                title: '集成测试',
+                description: `验证所有交付物正确集成
+
+## 交付物
+${parsedTask.deliverables.map(d => `- ${d}`).join('\n')}
+
+## 测试范围
+- 模块间接口
+- 端到端流程
+- 数据流验证`,
                 priority: 'P1',
-                dependencies: [planTaskId],
-                estimatedComplexity: 'high',
-                assignedAgent: 'coder',
-                phase: 'develop',
+                dependencies: devTaskIds,
+                estimatedComplexity: 'medium',
+                assignedAgent: 'tester',
+                phase: 'verify',
                 acceptanceCriteria: [
-                    'PLAN.md 中所有步骤已实现',
-                    '代码可编译运行',
-                    '无严重 bug'
+                    '所有模块正确集成',
+                    '端到端流程通过',
+                    '接口兼容性验证',
+                    '集成测试报告完整'
                 ]
-            },
-            {
-                taskId: testTaskId,
-                title: `${parsedTask.title} - 验证`,
-                description: `验证实现是否满足需求。
-
-## 原始需求
-${parsedTask.rawContent || parsedTask.title}
-
-## 验证方式
-1. 读取 PLAN.md 中的验收标准
-2. 逐一验证每个步骤
-3. 运行测试（如有）
-4. 检查代码质量`,
-                priority: 'P1',
-                dependencies: [devTaskId],
-                estimatedComplexity: 'medium',
+            });
+        }
+        // 4. E2E 测试任务 (如果启用，作为 verify 阶段的一部分)
+        if (userContext.e2eTests) {
+            const e2eTaskId = this.generateTaskId();
+            const e2eType = userContext.e2eType || 'web';
+            // E2E 测试依赖所有开发任务和单元测试任务
+            const allTestDependencies = [...devTaskIds];
+            breakdowns.forEach(b => {
+                if (b.phase === 'verify' && b.title.startsWith('测试:')) {
+                    allTestDependencies.push(b.taskId);
+                }
+            });
+            breakdowns.push({
+                taskId: e2eTaskId,
+                title: '端到端(E2E)测试',
+                description: this.buildE2ETestDescription(e2eType, parsedTask, userContext),
+                priority: 'P0', // E2E 测试是关键任务
+                dependencies: allTestDependencies, // 依赖所有开发任务和单元测试
+                estimatedComplexity: 'high',
                 assignedAgent: 'tester',
                 phase: 'verify',
                 acceptanceCriteria: [
-                    '所有功能正常运行',
-                    'PLAN.md 中验收标准全部通过',
-                    '无严重代码问题'
+                    '所有 E2E 测试用例通过',
+                    '关键用户流程验证完成',
+                    '跨浏览器/设备兼容性验证',
+                    'E2E 测试报告已生成',
+                    '无阻塞级别的缺陷'
                 ]
-            }
-        ];
+            });
+        }
+        // 5. 文档任务 (如果需要)
+        if (userContext.documentationLevel && userContext.documentationLevel !== '无需文档') {
+            breakdowns.push({
+                taskId: this.generateTaskId(),
+                title: '文档编写',
+                description: `编写项目文档
+
+## 文档级别
+${userContext.documentationLevel}
+
+## 文档内容
+- README 更新
+- API 文档
+- 使用说明`,
+                priority: 'P2',
+                dependencies: devTaskIds,
+                estimatedComplexity: 'low',
+                assignedAgent: 'executor',
+                phase: 'accept',
+                acceptanceCriteria: [
+                    'README 已更新',
+                    'API 文档完整',
+                    '使用说明清晰'
+                ]
+            });
+        }
+        return breakdowns;
     }
-    // --- 工具方法 ---
+    /**
+     * 提取用户上下文
+     */
     extractUserContext(answers) {
+        const e2eAnswer = answers['E2E测试'] || answers['e2eTests'] || answers['e2e'];
+        const e2eTypeAnswer = answers['E2E类型'] || answers['e2eType'];
         return {
             objective: answers['目标'] || answers['objective'],
             techStack: this.parseArrayAnswer(answers['技术栈'] || answers['techStack']),
             testCoverage: answers['测试'] || answers['testCoverage'],
             documentationLevel: answers['文档'] || answers['documentationLevel'],
+            e2eTests: e2eAnswer === 'true' || e2eAnswer === '✅ 启用 E2E 测试' || e2eAnswer === '是',
+            e2eType: e2eTypeAnswer || 'web',
             additionalContext: answers
         };
     }
+    /**
+     * 解析数组类型的回答
+     */
     parseArrayAnswer(answer) {
         if (!answer)
             return [];
+        // 处理逗号分隔或换行分隔的答案
         return answer.split(/[,，\n]/).map(s => s.trim()).filter(Boolean);
     }
+    /**
+     * 构建任务描述 (注入用户上下文)
+     */
     buildTaskDescription(goal, userContext, answers) {
         const parts = [];
         parts.push(`## 任务目标\n${goal}\n`);
-        if (userContext.objective)
+        if (userContext.objective) {
             parts.push(`## 整体目标\n${userContext.objective}\n`);
-        if (userContext.techStack?.length) {
+        }
+        if (userContext.techStack && userContext.techStack.length > 0) {
             parts.push(`## 技术栈要求\n${userContext.techStack.map(t => `- ${t}`).join('\n')}\n`);
         }
+        // 注入所有用户回答
         const relevantAnswers = Object.entries(answers).filter(([key]) => !['目标', '技术栈', '测试', '文档', 'objective', 'techStack', 'testCoverage', 'documentationLevel'].includes(key));
         if (relevantAnswers.length > 0) {
             parts.push(`## 其他要求\n${relevantAnswers.map(([k, v]) => `- ${k}: ${v}`).join('\n')}\n`);
         }
-        parts.push(`## 输出要求
-- 完成功能实现
-- 代码可编译
-- 遵循项目规范
+        parts.push(`## 输出要求
+- 完成功能实现
+- 代码可编译
+- 遵循项目规范
 - 添加必要注释`);
         return parts.join('\n');
     }
+    /**
+     * 构建测试任务描述
+     */
     buildTestDescription(goal, devTaskId, userContext) {
         const coverage = this.parseCoverage(userContext.testCoverage || '60%');
-        return `## 测试目标
-为 "${goal}" 编写测试用例
-
-## 关联开发任务
-${devTaskId}
-
-## 测试要求
-- 单元测试覆盖率 >= ${coverage}%
-- 测试正常流程
-- 测试边界情况
-- 测试异常处理
-
-## 测试文件
-- 创建 \`.test.ts\` 或 \`.spec.ts\` 文件
-- 放置在与源文件相同目录或 \`tests/\` 目录
-
-## 输出
-- 测试文件
-- 测试报告
+        return `## 测试目标
+为 "${goal}" 编写测试用例
+
+## 关联开发任务
+${devTaskId}
+
+## 测试要求
+- 单元测试覆盖率 >= ${coverage}%
+- 测试正常流程
+- 测试边界情况
+- 测试异常处理
+
+## 测试文件
+- 创建 \`.test.ts\` 或 \`.spec.ts\` 文件
+- 放置在与源文件相同目录或 \`tests/\` 目录
+
+## 输出
+- 测试文件
+- 测试报告
 - 覆盖率报告`;
     }
+    /**
+     * 构建 E2E 测试任务描述
+     */
+    buildE2ETestDescription(e2eType, parsedTask, userContext) {
+        const typeConfig = this.getE2ETypeConfig(e2eType);
+        return `## E2E 测试目标
+执行完整的端到端测试，验证关键用户流程
+
+## 应用类型
+${typeConfig.description}
+
+## 测试框架
+${typeConfig.frameworks.map(f => `- ${f}`).join('\n')}
+
+## 测试范围
+${parsedTask.goals.map((g, i) => `${i + 1}. ${g}`).join('\n')}
+
+## 关键用户流程
+根据应用功能，测试以下流程:
+${this.generateUserFlows(parsedTask, e2eType)}
+
+## 测试环境
+${typeConfig.environments.map(e => `- ${e}`).join('\n')}
+
+## 测试要求
+1. **关键路径覆盖**: 所有核心用户流程必须有 E2E 测试
+2. **断言完整**: 每个测试步骤必须有明确的断言
+3. **等待策略**: 使用合理的等待机制，避免硬编码延迟
+4. **数据隔离**: 测试数据独立，不影响其他测试
+5. **清理机制**: 测试后清理创建的数据
+
+## 输出要求
+- E2E 测试文件 (tests/e2e/*.spec.ts)
+- 测试执行报告
+- 截图/录像 (失败时)
+- 测试覆盖率报告 (如有)
+
+## 运行命令
+\`\`\`bash
+${typeConfig.runCommand}
+\`\`\`
+
+## 验收标准
+- [ ] 所有 E2E 测试用例通过
+- [ ] 关键用户流程验证完成
+- [ ] 跨浏览器/设备兼容性验证
+- [ ] E2E 测试报告已生成
+- [ ] 无阻塞级别的缺陷`;
+    }
+    /**
+     * 获取 E2E 测试类型配置
+     */
+    getE2ETypeConfig(type) {
+        const configs = {
+            web: {
+                description: 'Web 应用 (浏览器)',
+                frameworks: ['Playwright (推荐)', 'Cypress', 'Selenium WebDriver', 'Puppeteer'],
+                environments: ['Chrome', 'Firefox', 'Safari', 'Edge', 'Mobile Viewports'],
+                runCommand: 'npx playwright test --reporter=html'
+            },
+            mobile: {
+                description: '移动应用 (iOS/Android)',
+                frameworks: ['Appium', 'Detox (React Native)', 'XCUITest (iOS)', 'Espresso (Android)'],
+                environments: ['iOS Simulator', 'Android Emulator', 'Real Devices'],
+                runCommand: 'npx appium --base-path /wd/hub && npm run test:e2e'
+            },
+            gui: {
+                description: 'GUI 桌面应用 (Electron/Native)',
+                frameworks: ['Playwright for Electron', 'Spectron (Electron)', 'Robot Framework', 'PyAutoGUI'],
+                environments: ['Windows', 'macOS', 'Linux'],
+                runCommand: 'npm run test:e2e'
+            }
+        };
+        return configs[type];
+    }
+    /**
+     * 生成用户流程测试用例
+     */
+    generateUserFlows(parsedTask, type) {
+        const flows = [];
+        const goals = parsedTask.goals;
+        // 根据目标生成用户流程
+        goals.forEach((goal, i) => {
+            flows.push(`\n### 流程 ${i + 1}: ${goal}`);
+            flows.push('```gherkin');
+            flows.push(`Feature: ${goal}`);
+            flows.push('');
+            flows.push('  Scenario: 正常流程');
+            flows.push(`    Given 用户已启动应用`);
+            flows.push(`    When 用户执行 "${goal}" 操作`);
+            flows.push(`    Then 操作成功完成`);
+            flows.push('```');
+        });
+        return flows.join('\n');
+    }
+    /**
+     * 解析覆盖率数值
+     */
     parseCoverage(coverageStr) {
         const match = coverageStr.match(/(\d+)/);
         return match ? parseInt(match[1], 10) : 60;
     }
+    /**
+     * 生成验收标准
+     */
     generateAcceptanceCriteria(goal, userContext) {
         const criteria = [
             `功能 "${goal}" 已实现`,
@@ -318,11 +408,14 @@ ${devTaskId}
             '代码符合项目规范',
             '必要的注释已添加'
         ];
-        if (userContext.testCoverage)
+        if (userContext.testCoverage) {
             criteria.push(`测试覆盖率 >= ${userContext.testCoverage}`);
-        if (userContext.techStack?.length)
+        }
+        if (userContext.techStack?.length) {
             criteria.push(`使用指定技术栈: ${userContext.techStack.join(', ')}`);
-        criteria.push('无安全隐患', '边界情况已处理');
+        }
+        criteria.push('无安全隐患');
+        criteria.push('边界情况已处理');
         return criteria;
     }
     generateTaskId() {
@@ -331,6 +424,7 @@ ${devTaskId}
         return `TASK-${timestamp}${rand}`;
     }
     determinePriority(goalIndex) {
+        // First goal is highest priority
         if (goalIndex === 0)
             return 'P1';
         return 'P2';

package/dist/storage/state-manager.d.ts

@@ -13,7 +13,6 @@ export declare class StateManager {
         timeout: number;
         dependencies: string[];
         assignedAgent: string;
-        id?: string;
     }): Promise<Task>;
     getTask(taskId: string): Promise<Task | null>;
     updateTask(taskId: string, updates: Partial<Task>): Promise<void>;

package/dist/storage/state-manager.js

@@ -53,7 +53,7 @@ class StateManager {
         this.stateCache = newState;
     }
     async createTask(input) {
-        const taskId = input.id || this.generateTaskId();
+        const taskId = this.generateTaskId();
         const now = new Date().toISOString();
         const task = {
             id: taskId,