openmatrix 0.1.50 → 0.1.52

package/dist/orchestrator/task-planner.js

@@ -10,9 +10,12 @@ exports.TaskPlanner = void 0;
  * 3. 验收标准注入 (从用户回答中提取)
  * 4. 用户上下文注入 (将用户回答注入任务描述)
  * 5. 依赖关系分析 (自动分析任务间依赖)
+ * 6. 并行执行 (独立任务互不依赖)
+ * 7. 质量级别感知 (根据配置调整测试覆盖率)
  */
 class TaskPlanner {
     userAnswers;
+    taskCounter = 0;
     constructor(userAnswers) {
         this.userAnswers = userAnswers || {};
     }
@@ -24,29 +27,29 @@ class TaskPlanner {
     }
     /**
      * Break down a parsed task into sub-tasks
-     *
-     * 增强版: 生成更细粒度的任务，包含设计、开发、测试配对
      */
-    breakdown(parsedTask, answers) {
+    breakdown(parsedTask, answers, qualityConfig, plan) {
         const breakdowns = [];
         const seenTitles = new Set();
         const userContext = this.extractUserContext(answers);
-        // 0. 设计阶段任务
-        if (parsedTask.goals.length > 1) {
+        // 确定测试覆盖率
+        const coverageTarget = this.getCoverageTarget(qualityConfig, userContext);
+        // 构建全局上下文块（注入到每个子任务描述中，供 agent 参考）
+        const globalContext = this.buildGlobalContext(parsedTask, userContext, plan);
+        // 0. 设计阶段任务 (根据复杂度判断)
+        let designTaskId;
+        if (this.needsDesignPhase(parsedTask)) {
+            designTaskId = this.generateTaskId();
             breakdowns.push({
-                taskId: this.generateTaskId(),
+                taskId: designTaskId,
                 title: '架构设计和任务规划',
-                description: `分析需求，设计整体架构，规划实现方案
-
-## 用户需求
-${userContext.objective || '未指定'}
-
-## 技术栈
-${userContext.techStack?.join(', ') || '未指定'}
-
-## 输出
-- 架构设计文档
-- 接口定义
+                description: `分析需求，设计整体架构，规划实现方案
+
+${globalContext}
+
+## 输出
+- 架构设计文档
+- 接口定义
 - 任务依赖图`,
                 priority: 'P0',
                 dependencies: [],
@@ -61,7 +64,7 @@ ${userContext.techStack?.join(', ') || '未指定'}
                 ]
             });
         }
-        // 1. 为每个目标创建细粒度任务
+        // 1. 为每个目标创建开发+测试任务（并行，只依赖设计任务）
         const devTaskIds = [];
         for (let i = 0; i < parsedTask.goals.length; i++) {
             const goal = parsedTask.goals[i];
@@ -70,18 +73,17 @@ ${userContext.techStack?.join(', ') || '未指定'}
                 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),
+                description: this.buildTaskDescription(goal, globalContext),
                 priority: this.determinePriority(i),
-                dependencies: i === 0 && parsedTask.goals.length > 1
-                    ? [breakdowns[0].taskId] // 依赖设计任务
-                    : (i > 0 ? [devTaskIds[i - 1]] : []), // 依赖前一个开发任务
+                // 并行: 所有开发任务只依赖设计任务（如果有），互不依赖
+                dependencies: designTaskId ? [designTaskId] : [],
                 estimatedComplexity: this.estimateComplexity(goal),
                 assignedAgent: 'coder',
                 phase: 'develop',
@@ -93,14 +95,14 @@ ${userContext.techStack?.join(', ') || '未指定'}
             breakdowns.push({
                 taskId: testTaskId,
                 title: `测试: ${goal}`,
-                description: this.buildTestDescription(goal, devTaskId, userContext),
+                description: this.buildTestDescription(goal, devTaskId, coverageTarget, globalContext),
                 priority: this.determinePriority(i),
-                dependencies: [devTaskId], // 测试依赖开发任务
+                dependencies: [devTaskId], // 测试依赖对应的开发任务
                 estimatedComplexity: 'medium',
                 assignedAgent: 'tester',
                 phase: 'verify',
                 acceptanceCriteria: [
-                    `单元测试覆盖率 >= ${userContext.testCoverage || '60%'}`,
+                    `单元测试覆盖率 >= ${coverageTarget}%`,
                     '边界情况已测试',
                     '异常处理已验证',
                     '所有测试通过'
@@ -114,18 +116,20 @@ ${userContext.techStack?.join(', ') || '未指定'}
             breakdowns.push({
                 taskId: this.generateTaskId(),
                 title: '代码审查',
-                description: `对所有开发任务进行代码审查
-
-## 审查范围
-${devTaskIds.map(id => `- ${id}`).join('\n')}
-
-## 审查要点
-- 代码质量
-- 安全性
-- 性能
+                description: `对所有开发任务进行代码审查
+
+${globalContext}
+
+## 审查范围
+${devTaskIds.map(id => `- ${id}`).join('\n')}
+
+## 审查要点
+- 代码质量
+- 安全性
+- 性能
 - 最佳实践`,
                 priority: 'P1',
-                dependencies: devTaskIds,
+                dependencies: devTaskIds, // 审查依赖所有开发任务完成
                 estimatedComplexity: 'medium',
                 assignedAgent: 'reviewer',
                 phase: 'verify',
@@ -142,14 +146,13 @@ ${devTaskIds.map(id => `- ${id}`).join('\n')}
             breakdowns.push({
                 taskId: this.generateTaskId(),
                 title: '集成测试',
-                description: `验证所有交付物正确集成
-
-## 交付物
-${parsedTask.deliverables.map(d => `- ${d}`).join('\n')}
-
-## 测试范围
-- 模块间接口
-- 端到端流程
+                description: `验证所有交付物正确集成
+
+${globalContext}
+
+## 测试范围
+- 模块间接口
+- 端到端流程
 - 数据流验证`,
                 priority: 'P1',
                 dependencies: devTaskIds,
@@ -164,11 +167,10 @@ ${parsedTask.deliverables.map(d => `- ${d}`).join('\n')}
                 ]
             });
         }
-        // 4. E2E 测试任务 (如果启用，作为 verify 阶段的一部分)
+        // 4. E2E 测试任务 (如果启用)
         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('测试:')) {
@@ -179,8 +181,8 @@ ${parsedTask.deliverables.map(d => `- ${d}`).join('\n')}
                 taskId: e2eTaskId,
                 title: '端到端(E2E)测试',
                 description: this.buildE2ETestDescription(e2eType, parsedTask, userContext),
-                priority: 'P0', // E2E 测试是关键任务
-                dependencies: allTestDependencies, // 依赖所有开发任务和单元测试
+                priority: 'P0',
+                dependencies: allTestDependencies,
                 estimatedComplexity: 'high',
                 assignedAgent: 'tester',
                 phase: 'verify',
@@ -198,14 +200,14 @@ ${parsedTask.deliverables.map(d => `- ${d}`).join('\n')}
             breakdowns.push({
                 taskId: this.generateTaskId(),
                 title: '文档编写',
-                description: `编写项目文档
-
-## 文档级别
-${userContext.documentationLevel}
-
-## 文档内容
-- README 更新
-- API 文档
+                description: `编写项目文档
+
+## 文档级别
+${userContext.documentationLevel}
+
+## 文档内容
+- README 更新
+- API 文档
 - 使用说明`,
                 priority: 'P2',
                 dependencies: devTaskIds,
@@ -221,6 +223,40 @@ ${userContext.documentationLevel}
         }
         return breakdowns;
     }
+    /**
+     * 判断是否需要设计阶段
+     *
+     * 条件: 多个 goal，或 goal 包含复杂关键词
+     */
+    needsDesignPhase(parsedTask) {
+        if (parsedTask.goals.length > 1)
+            return true;
+        // 单 goal 但包含复杂关键词
+        const complexKeywords = [
+            '系统', '架构', '模块', '集成', '完整', '平台',
+            '体系', '框架', '全栈', '端到端', '多个', '一系列',
+            'system', 'architecture', 'framework', 'fullstack', 'integration'
+        ];
+        const allText = `${parsedTask.title} ${parsedTask.goals.join(' ')} ${parsedTask.description}`.toLowerCase();
+        return complexKeywords.some(kw => allText.includes(kw.toLowerCase()));
+    }
+    /**
+     * 获取测试覆盖率目标
+     */
+    getCoverageTarget(qualityConfig, userContext) {
+        // 优先使用 qualityConfig
+        if (qualityConfig) {
+            return qualityConfig.minCoverage;
+        }
+        // 其次使用用户回答
+        if (userContext?.testCoverage) {
+            const match = userContext.testCoverage.match(/(\d+)/);
+            if (match)
+                return parseInt(match[1], 10);
+        }
+        // 默认
+        return 60;
+    }
     /**
      * 提取用户上下文
      */
@@ -237,117 +273,122 @@ ${userContext.documentationLevel}
             additionalContext: answers
         };
     }
-    /**
-     * 解析数组类型的回答
-     */
     parseArrayAnswer(answer) {
         if (!answer)
             return [];
-        // 处理逗号分隔或换行分隔的答案
         return answer.split(/[,，\n]/).map(s => s.trim()).filter(Boolean);
     }
     /**
-     * 构建任务描述 (注入用户上下文)
+     * 构建全局上下文块（注入到每个子任务描述中）
      */
-    buildTaskDescription(goal, userContext, answers) {
+    buildGlobalContext(parsedTask, userContext, plan) {
         const parts = [];
-        parts.push(`## 任务目标\n${goal}\n`);
-        if (userContext.objective) {
-            parts.push(`## 整体目标\n${userContext.objective}\n`);
+        if (parsedTask.title) {
+            parts.push(`## 整体任务\n${parsedTask.title}`);
+        }
+        if (parsedTask.description) {
+            parts.push(`## 任务描述\n${parsedTask.description}`);
+        }
+        if (plan) {
+            parts.push(`## 执行计划\n${plan}`);
+        }
+        if (parsedTask.goals.length > 0) {
+            parts.push(`## 所有目标\n${parsedTask.goals.map((g, i) => `${i + 1}. ${g}`).join('\n')}`);
+        }
+        if (parsedTask.constraints.length > 0) {
+            parts.push(`## 约束条件\n${parsedTask.constraints.map(c => `- ${c}`).join('\n')}`);
+        }
+        if (parsedTask.deliverables.length > 0) {
+            parts.push(`## 交付物\n${parsedTask.deliverables.map(d => `- ${d}`).join('\n')}`);
         }
         if (userContext.techStack && userContext.techStack.length > 0) {
-            parts.push(`## 技术栈要求\n${userContext.techStack.map(t => `- ${t}`).join('\n')}\n`);
+            parts.push(`## 技术栈\n${userContext.techStack.map(t => `- ${t}`).join('\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`);
+        if (userContext.additionalContext) {
+            const relevantAnswers = Object.entries(userContext.additionalContext).filter(([key]) => !['目标', '技术栈', '测试', '文档', 'objective', 'techStack', 'testCoverage', 'documentationLevel'].includes(key));
+            if (relevantAnswers.length > 0) {
+                parts.push(`## 其他要求\n${relevantAnswers.map(([k, v]) => `- ${k}: ${v}`).join('\n')}`);
+            }
         }
-        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/\` 目录
-
-## 输出
-- 测试文件
-- 测试报告
+    buildTaskDescription(goal, globalContext) {
+        return `## 当前子任务目标\n${goal}\n\n${globalContext}\n\n## 输出要求
+- 完成功能实现
+- 代码可编译
+- 遵循项目规范
+- 添加必要注释`;
+    }
+    buildTestDescription(goal, devTaskId, coverageTarget, globalContext) {
+        return `## 测试目标
+为 "${goal}" 编写测试用例
+
+${globalContext}
+
+## 关联开发任务
+${devTaskId}
+
+## 测试要求
+- 单元测试覆盖率 >= ${coverageTarget}%
+- 测试正常流程
+- 测试边界情况
+- 测试异常处理
+
+## 测试文件
+- 创建 \`.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 测试报告已生成
+        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: {
@@ -371,13 +412,9 @@ ${typeConfig.runCommand}
         };
         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');
@@ -391,16 +428,6 @@ ${typeConfig.runCommand}
         });
         return flows.join('\n');
     }
-    /**
-     * 解析覆盖率数值
-     */
-    parseCoverage(coverageStr) {
-        const match = coverageStr.match(/(\d+)/);
-        return match ? parseInt(match[1], 10) : 60;
-    }
-    /**
-     * 生成验收标准
-     */
     generateAcceptanceCriteria(goal, userContext) {
         const criteria = [
             `功能 "${goal}" 已实现`,
@@ -419,12 +446,10 @@ ${typeConfig.runCommand}
         return criteria;
     }
     generateTaskId() {
-        const timestamp = Date.now().toString(36).toUpperCase();
-        const rand = Math.random().toString(36).slice(2, 4).toUpperCase();
-        return `TASK-${timestamp}${rand}`;
+        this.taskCounter++;
+        return `TASK-${String(this.taskCounter).padStart(3, '0')}`;
     }
     determinePriority(goalIndex) {
-        // First goal is highest priority
         if (goalIndex === 0)
             return 'P1';
         return 'P2';

package/dist/storage/state-manager.js

@@ -74,7 +74,7 @@ class StateManager {
             createdAt: now,
             updatedAt: now
         };
-        await this.store.writeJson(`tasks/${taskId}/task.json`, task);
+        await this.store.writeJson(`tasks/${taskId}.json`, task);
         // Update statistics
         const state = await this.getState();
         await this.updateState({
@@ -87,7 +87,7 @@ class StateManager {
         return task;
     }
     async getTask(taskId) {
-        return await this.store.readJson(`tasks/${taskId}/task.json`);
+        return await this.store.readJson(`tasks/${taskId}.json`);
     }
     async updateTask(taskId, updates) {
         const task = await this.getTask(taskId);
@@ -99,17 +99,17 @@ class StateManager {
             ...updates,
             updatedAt: new Date().toISOString()
         };
-        await this.store.writeJson(`tasks/${taskId}/task.json`, updatedTask);
+        await this.store.writeJson(`tasks/${taskId}.json`, updatedTask);
         // Update statistics if status changed
         if (updates.status && updates.status !== oldStatus) {
             await this.updateTaskStatistics(oldStatus, updates.status);
         }
     }
     async listTasks() {
-        const dirs = await this.store.listDirs('tasks');
+        const files = await this.store.listFiles('tasks');
         const tasks = [];
-        for (const dir of dirs) {
-            const task = await this.getTask(dir);
+        for (const file of files) {
+            const task = await this.store.readJson(`tasks/${file}`);
             if (task)
                 tasks.push(task);
         }
@@ -144,9 +144,9 @@ class StateManager {
         return `run-${date}-${rand}`;
     }
     generateTaskId() {
-        const timestamp = Date.now().toString(36).toUpperCase();
-        const rand = Math.random().toString(36).slice(2, 4).toUpperCase();
-        return `TASK-${timestamp}${rand}`;
+        const count = this.stateCache?.statistics.totalTasks ?? 0;
+        const seq = count + 1;
+        return `TASK-${String(seq).padStart(3, '0')}`;
     }
     // ============ Approval Methods ============
     async saveApproval(approval) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmatrix",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "description": "AI Agent task orchestration system with Claude Code Skills integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/skills/approve.md

@@ -152,7 +152,7 @@ description: 审批待处理项（包括计划、合并、部署、Meeting）
 
 5. **执行审批**
    ```bash
-   openmatrix approve <approvalId> --action <approve|reject|modify> [--message "备注"]
+   openmatrix approve <approvalId> -d <approve|reject|modify> [-c "备注"]
    ```
 
 6. **更新状态**
@@ -215,17 +215,17 @@ Meeting 审批需要更细致的交互:
 
 ```bash
 # 列出待审批
-openmatrix approve --list
+openmatrix approve
 
 # 处理审批
-openmatrix approve APPR-001 --action approve --message "同意此方案"
-openmatrix approve APPR-001 --action reject --message "需要重新设计"
-openmatrix approve APPR-001 --action modify --message "增加测试覆盖率要求"
-
-# Meeting 专用
-openmatrix approve APPR-002 --action provide-info --info "数据库连接字符串是..."
-openmatrix approve APPR-002 --action skip --message "此任务可选"
-openmatrix approve APPR-002 --action cancel --message "需求变更，停止执行"
+openmatrix approve APPR-001 -d approve -c "同意此方案"
+openmatrix approve APPR-001 -d reject -c "需要重新设计"
+openmatrix approve APPR-001 -d modify -c "增加测试覆盖率要求"
+
+# Meeting 专用 (使用 meeting 命令)
+openmatrix meeting APPR-002 --action provide-info --info "数据库连接字符串是..."
+openmatrix meeting APPR-002 --action skip --message "此任务可选"
+openmatrix meeting APPR-002 --action cancel --message "需求变更，停止执行"
 ```
 
 ## 与执行循环的集成