openmatrix 0.1.49 → 0.1.50

package/README.md

@@ -45,25 +45,21 @@
 | 用户输入 | 触发原因 |
 |---------|---------|
 | `实现用户登录功能` | 功能开发 |
-| `登录页面报错了` | Bug 修复 (隐含修复意图) |
-| `修复下这个脚本` | 包含"修复" |
+| `登录页面报错了` | Bug 修复 |
 | `性能太慢需要优化` | 性能优化 |
 | `写个单元测试` | 测试相关 |
-| `搞个后台系统` | 包含"搞" |
-| `弄个API接口` | 包含"弄" |
-| `整个配置文件` | 包含"整" |
+| `做个完整的用户系统` | 多组件任务 |
 | `从零搭建一个后台` | 多步骤项目 |
+| `前端+后端+数据库` | 全栈工作 |
 
 **关键词触发:**
 - `实现...` / `添加...` / `修复...` / `优化...` / `测试...`
-- `帮我...` / `搞个...` / `弄个...` / `整个...` / `写个...`
 - `支持...` / `需要...` / `想要...` / `要做...`
 - `implement...` / `add...` / `fix...` / `build...`
 - 任务文档路径: `docs/task.md`
-- 问题诊断: `报错了` / `不工作了` / `太慢了` (隐含修复意图)
 
 **不触发的情况:**
-- 问问题: "登录是什么?" / "为什么报错" (无行动意图)
+- 问问题: "怎么实现登录?" / "如何配置?"
 - 查信息: "显示配置" / "列出文件"
 - 导航: "打开目录" / "进入文件夹"
 

package/dist/cli/commands/analyze.js

@@ -7,8 +7,7 @@ const smart_question_analyzer_js_1 = require("../../orchestrator/smart-question-
 exports.analyzeCommand = new commander_1.Command('analyze')
     .description('智能分析任务，推断配置，返回需要确认的问题列表')
     .argument('[task]', '任务描述')
-    .option('--json', '输出 JSON 格式（供程序解析）')
-    .option('--markdown', '输出 Markdown 格式（默认）')
+    .option('--json', '输出 JSON 格式')
     .action(async (task, options) => {
     const analyzer = new smart_question_analyzer_js_1.SmartQuestionAnalyzer(process.cwd());
     if (!task) {
@@ -32,8 +31,8 @@ exports.analyzeCommand = new commander_1.Command('analyze')
             console.log(JSON.stringify(output, null, 2));
         }
         else {
-            // 默认输出 Markdown 格式
-            console.log('\n' + analyzer.generateMarkdown(result));
+            // 输出人类可读格式
+            console.log('\n' + analyzer.generateSummary(result));
         }
     }
     catch (error) {

package/dist/cli/commands/brainstorm.js

@@ -79,12 +79,6 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
                 }
             }
             await fs.writeFile(brainstormPath, JSON.stringify(session, null, 2));
-            // 构建下一个步骤的命令
-            const brainstormAnswers = JSON.stringify({
-                answers: session.answers,
-                insights: session.insights,
-                designNotes: session.designNotes
-            });
             if (options.json) {
                 console.log(JSON.stringify({
                     status: 'ready_to_start',
@@ -94,23 +88,7 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
                     answers: session.answers,
                     insights: session.insights,
                     designNotes: session.designNotes,
-                    // 关键：告诉 Agent 下一步必须执行什么
-                    nextStep: {
-                        required: true,
-                        description: '必须调用此命令开始任务执行',
-                        command: 'openmatrix',
-                        args: ['start', session.taskInput.slice(0, 100)],
-                        options: {
-                            'brainstorm-answers': brainstormAnswers
-                        },
-                        hint: '使用 /om:start 开始执行任务'
-                    },
-                    // 强制执行标记 - Agent 必须执行 nextStep
-                    _meta: {
-                        requiresAction: true,
-                        actionType: 'cli_command',
-                        blocking: true
-                    }
+                    hint: '使用 /om:start 开始执行任务'
                 }));
             }
             else {
@@ -238,71 +216,71 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
 });
 /**
  * 根据任务内容生成头脑风暴问题
- *
- * 基于"底层逻辑"方法论，不使用固定模板
  */
 function generateBrainstormQuestions(taskContent, taskTitle) {
     const questions = [];
-    // ========== 第一层：价值逻辑 ==========
-    // 1. 核心目标
+    const content = taskContent.toLowerCase();
+    // 问题 1: 核心目标
     questions.push({
         id: 'core_objective',
         question: '这个任务的核心目标是什么？想要解决什么问题？',
         header: '核心目标',
         options: [
-            { label: '创建新系统', description: '从零开始构建新的系统或应用' },
-            { label: '添加新功能', description: '在现有系统上增加新能力' },
-            { label: '修复问题', description: '解决 Bug 或已知问题' },
-            { label: '优化改进', description: '提升性能、体验或代码质量' }
+            { label: '实现新功能', description: '添加新的功能特性，扩展系统能力' },
+            { label: '修复问题', description: '修复 Bug 或解决已知问题' },
+            { label: '重构优化', description: '改进代码结构、性能或可维护性' },
+            { label: '技术探索', description: '探索新技术方案，验证可行性' }
         ],
         multiSelect: false,
-        why: '明确核心目标有助于选择正确的实现策略'
+        why: '明确核心目标有助于选择正确的实现策略和质量标准'
     });
-    // 2. 用户价值
+    // 问题 2: 用户价值
     questions.push({
         id: 'user_value',
-        question: '这个任务为谁创造价值？最终用户是谁？',
+        question: '这个任务为用户带来什么价值？最终用户是谁？',
         header: '用户价值',
         options: [
-            { label: '终端用户', description: '产品的最终使用者，需要良好体验' },
-            { label: '开发者', description: '技术用户，需要清晰的 API 和文档' },
-            { label: '团队内部', description: '内部工具，追求效率' },
-            { label: '业务方', description: '满足业务需求，关注指标' }
+            { label: '开发者', description: '主要用户是开发者，需要清晰的 API 和文档' },
+            { label: '终端用户', description: '主要用户是终端用户，需要良好的用户体验' },
+            { label: '运维人员', description: '主要用户是运维，需要稳定性和可观测性' },
+            { label: '内部团队', description: '主要用户是内部团队，需要高效协作支持' }
         ],
         multiSelect: false,
-        why: '了解目标用户有助于设计合适的方案'
+        why: '了解目标用户有助于设计合适的接口和交互方式'
     });
-    // ========== 第二层：架构逻辑 ==========
-    // 3. 复杂度评估
-    questions.push({
-        id: 'complexity',
-        question: '这个任务的复杂度如何？涉及哪些关键组件？',
-        header: '复杂度',
-        options: [
-            { label: '简单', description: '单一功能，少量代码' },
-            { label: '中等', description: '多个组件协作，有依赖关系' },
-            { label: '复杂', description: '涉及架构设计，需要仔细规划' },
-            { label: '非常复杂', description: '大型系统，需要分阶段实施' }
-        ],
-        multiSelect: false,
-        why: '复杂度决定是否需要分阶段实施'
-    });
-    // 4. 技术约束
-    questions.push({
-        id: 'tech_constraints',
-        question: '有哪些技术约束或偏好？',
-        header: '技术约束',
-        options: [
-            { label: '使用现有技术栈', description: '不引入新依赖' },
-            { label: '可以引入新技术', description: '允许引入新的库或框架' },
-            { label: '需要技术调研', description: '技术选型待定，先调研' },
-            { label: '无特殊约束', description: '自由选择最合适的方案' }
-        ],
-        multiSelect: false,
-        why: '技术约束影响实现方案选择'
-    });
-    // ========== 第三层：风险逻辑 ==========
-    // 5. 风险识别
+    // 问题 3: 实现复杂度 - 如果任务内容包含复杂关键词
+    if (content.includes('架构') || content.includes('系统') || content.includes('集成') || content.includes('多个')) {
+        questions.push({
+            id: 'complexity',
+            question: '这个任务的实现复杂度如何？需要哪些关键组件？',
+            header: '复杂度',
+            options: [
+                { label: '简单', description: '单一功能，少量代码修改' },
+                { label: '中等', description: '需要多个组件协作，有依赖关系' },
+                { label: '复杂', description: '涉及架构调整，需要仔细规划' },
+                { label: '非常复杂', description: '大型重构或新系统，需要分阶段实施' }
+            ],
+            multiSelect: false,
+            why: '复杂度评估有助于决定是否需要分阶段实施和额外的设计审查'
+        });
+    }
+    // 问题 4: 技术约束 - 如果涉及技术选型
+    if (content.includes('技术') || content.includes('框架') || content.includes('库')) {
+        questions.push({
+            id: 'tech_constraints',
+            question: '有哪些技术约束或偏好？需要使用/避免什么技术？',
+            header: '技术约束',
+            options: [
+                { label: '使用现有技术栈', description: '复用项目已有的技术选择' },
+                { label: '引入新技术', description: '需要引入新的库或框架' },
+                { label: '保持技术中立', description: '不引入新依赖，使用原生方案' },
+                { label: '需要技术调研', description: '技术选型不确定，需要先调研' }
+            ],
+            multiSelect: false,
+            why: '技术约束影响实现方案和后续维护成本'
+        });
+    }
+    // 问题 5: 风险评估
     questions.push({
         id: 'risks',
         question: '这个任务可能面临哪些风险或挑战？',
@@ -316,7 +294,7 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         multiSelect: true,
         why: '识别风险有助于提前规划应对策略'
     });
-    // 6. 验收标准
+    // 问题 6: 验收标准
     questions.push({
         id: 'acceptance',
         question: '如何判断任务完成？有哪些验收标准？',
@@ -330,15 +308,15 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         multiSelect: true,
         why: '明确的验收标准有助于判断任务完成度'
     });
-    // 7. 优先级
+    // 问题 7: 实现优先级
     questions.push({
         id: 'priority',
-        question: '这个任务的优先级如何？实施策略是什么？',
+        question: '这个任务的优先级如何？是否需要 MVP 版本？',
         header: '优先级',
         options: [
             { label: '高优先级', description: '需要尽快完成，影响其他工作' },
             { label: '中优先级', description: '计划内任务，按正常节奏推进' },
-            { label: '低优先级', description: '可延后处理' },
+            { label: '低优先级', description: '可延后处理，有更重要的任务' },
             { label: '需要 MVP', description: '先实现最小可用版本，再迭代' }
         ],
         multiSelect: false,

package/dist/cli/commands/start.js

@@ -58,7 +58,6 @@ exports.startCommand = new commander_1.Command('start')
     .option('-q, --quality <level>', '质量级别 (strict|balanced|fast)')
     .option('-t, --tech-stack <stack>', '技术栈 (逗号分隔，如 "TypeScript,Vue.js,PostgreSQL")')
     .option('--docs <level>', '文档级别 (full|basic|minimal|none)')
-    .option('--brainstorm-answers <json>', '从 brainstorm 传递的答案 JSON')
     .action(async (input, options) => {
     const basePath = process.cwd();
     const omPath = path.join(basePath, '.openmatrix');
@@ -102,178 +101,68 @@ exports.startCommand = new commander_1.Command('start')
         }
         return;
     }
-    // 检查 brainstorm 状态 (状态校验)
-    const brainstormPath = path.join(omPath, 'brainstorm', 'session.json');
-    try {
-        const brainstormContent = await fs.readFile(brainstormPath, 'utf-8');
-        const brainstormSession = JSON.parse(brainstormContent);
-        if (brainstormSession.status === 'brainstorming') {
-            // 检查是否有未回答的问题
-            const answeredCount = Object.keys(brainstormSession.answers || {}).length;
-            const totalQuestions = brainstormSession.questions?.length || 0;
-            if (answeredCount < totalQuestions && !options.brainstormAnswers) {
-                // brainstorm 未完成，且没有传递答案
-                if (options.json) {
-                    console.log(JSON.stringify({
-                        status: 'error',
-                        code: 'BRAINSTORM_INCOMPLETE',
-                        message: '头脑风暴未完成',
-                        details: {
-                            taskTitle: brainstormSession.taskTitle,
-                            answeredCount,
-                            totalQuestions,
-                            missingQuestions: brainstormSession.questions
-                                ?.filter((q) => !brainstormSession.answers?.[q.id])
-                                ?.map((q) => ({ question: q.question, header: q.header })) || []
-                        },
-                        hint: '请先完成头脑风暴: /om:brainstorm，或传递 --brainstorm-answers 参数'
-                    }));
-                }
-                else {
-                    console.log('⚠️  头脑风暴未完成!');
-                    console.log(`   任务: ${brainstormSession.taskTitle}`);
-                    console.log(`   进度: ${answeredCount}/${totalQuestions} 问题已回答`);
-                    console.log('\n   未回答的问题:');
-                    brainstormSession.questions
-                        ?.filter((q) => !brainstormSession.answers?.[q.id])
-                        ?.forEach((q, i) => {
-                        console.log(`   ${i + 1}. [${q.header}] ${q.question}`);
-                    });
-                    console.log('\n   💡 请先完成头脑风暴: /om:brainstorm');
-                    console.log('   或传递 --brainstorm-answers 参数跳过此检查');
-                }
-                return;
-            }
-        }
-        else if (brainstormSession.status === 'ready_to_start' || brainstormSession.status === 'completed') {
-            // 头脑风暴已完成，自动使用保存的答案（如果没有显式传递）
-            if (!options.brainstormAnswers && brainstormSession.answers) {
-                // 自动使用保存的 brainstorm 答案
-                options.brainstormAnswers = JSON.stringify({
-                    answers: brainstormSession.answers,
-                    insights: brainstormSession.insights || [],
-                    designNotes: brainstormSession.designNotes || []
-                });
-                if (!options.json) {
-                    console.log('📋 自动使用已完成的头脑风暴结果');
-                }
-            }
-        }
-    }
-    catch {
-        // brainstorm 文件不存在，继续执行
-    }
     // 构建任务内容
     let taskContent = input;
-    let titleOverride = options.title; // 保存标题覆盖选项
-    // 如果输入是文件路径，先读取文件内容
-    if (taskContent && taskContent.endsWith('.md')) {
+    // 如果提供了 --title 和 --description，构建任务内容
+    if (options.title || options.description) {
+        const title = options.title || '未命名任务';
+        const description = options.description || '';
+        const techStack = options.techStack ? `\n\n技术栈: ${options.techStack}` : '';
+        const docs = options.docs ? `\n文档要求: ${options.docs}` : '';
+        taskContent = `# ${title}\n\n${description}${techStack}${docs}`;
+    }
+    // 如果没有任务内容，尝试读取默认文件
+    if (!taskContent) {
+        const defaultPath = path.join(basePath, 'TASK.md');
         try {
-            taskContent = await fs.readFile(taskContent, 'utf-8');
+            taskContent = await fs.readFile(defaultPath, 'utf-8');
             if (!options.json) {
-                console.log(`📄 读取任务文件: ${input}`);
+                console.log(`📄 读取任务文件: ${defaultPath}`);
             }
         }
         catch {
             if (options.json) {
                 console.log(JSON.stringify({
                     status: 'error',
-                    message: `无法读取文件: ${input}`
+                    message: '请提供任务文件路径或描述'
                 }));
             }
             else {
-                console.log(`❌ 无法读取文件: ${input}`);
+                console.log('❌ 请提供任务文件路径或描述');
+                console.log('   用法: openmatrix start <task.md>');
+                console.log('   或创建 TASK.md 文件');
+                console.log('   或使用 --title 和 --description 选项');
             }
             return;
         }
     }
-    else if (!taskContent) {
-        // 如果没有任务内容，尝试读取默认文件
-        const defaultPath = path.join(basePath, 'TASK.md');
+    else if (taskContent.endsWith('.md')) {
+        // 读取文件
         try {
-            taskContent = await fs.readFile(defaultPath, 'utf-8');
+            taskContent = await fs.readFile(taskContent, 'utf-8');
             if (!options.json) {
-                console.log(`📄 读取任务文件: ${defaultPath}`);
+                console.log(`📄 读取任务文件: ${input}`);
             }
         }
         catch {
-            // 如果没有默认文件，使用 --title 和 --description 构建
-            if (options.title || options.description) {
-                const title = options.title || '未命名任务';
-                const description = options.description || '';
-                const techStack = options.techStack ? `\n\n技术栈: ${options.techStack}` : '';
-                const docs = options.docs ? `\n文档要求: ${options.docs}` : '';
-                taskContent = `# ${title}\n\n${description}${techStack}${docs}`;
-                titleOverride = undefined; // 内容已包含标题，不需要覆盖
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'error',
+                    message: `无法读取文件: ${input}`
+                }));
             }
             else {
-                if (options.json) {
-                    console.log(JSON.stringify({
-                        status: 'error',
-                        message: '请提供任务文件路径或描述'
-                    }));
-                }
-                else {
-                    console.log('❌ 请提供任务文件路径或描述');
-                    console.log('   用法: openmatrix start <task.md>');
-                    console.log('   或创建 TASK.md 文件');
-                    console.log('   或使用 --title 和 --description 选项');
-                }
-                return;
-            }
-        }
-    }
-    else if (!taskContent.endsWith('.md') && !taskContent.includes('\n')) {
-        // 如果输入是单行文本，可能是文件路径或简短描述
-        // 检查是否是文件
-        const possiblePath = path.join(basePath, taskContent);
-        try {
-            taskContent = await fs.readFile(possiblePath, 'utf-8');
-            if (!options.json) {
-                console.log(`📄 读取任务文件: ${possiblePath}`);
-            }
-        }
-        catch {
-            // 不是文件，作为描述处理
-            if (options.title || options.description) {
-                const title = options.title || '未命名任务';
-                const description = options.description || taskContent;
-                const techStack = options.techStack ? `\n\n技术栈: ${options.techStack}` : '';
-                const docs = options.docs ? `\n文档要求: ${options.docs}` : '';
-                taskContent = `# ${title}\n\n${description}${techStack}${docs}`;
-                titleOverride = undefined;
+                console.log(`❌ 无法读取文件: ${input}`);
             }
+            return;
         }
     }
-    // 如果有标题覆盖，更新任务内容中的标题
-    if (titleOverride && taskContent) {
-        // 替换第一个 # 标题
-        taskContent = taskContent.replace(/^#\s+.+$/m, `# ${titleOverride}`);
-    }
     // 解析任务
     if (!options.json) {
         console.log('\n🔍 解析任务...');
     }
     const parser = new task_parser_js_1.TaskParser();
     const parsedTask = parser.parse(taskContent);
-    // 解析 brainstorm 答案 (如果有)
-    let brainstormContext = {};
-    if (options.brainstormAnswers) {
-        try {
-            brainstormContext = JSON.parse(options.brainstormAnswers);
-            if (!options.json) {
-                console.log('\n🧠 使用 brainstorm 收集的信息:');
-                if (brainstormContext.answers) {
-                    Object.entries(brainstormContext.answers).forEach(([key, value]) => {
-                        console.log(`   - ${key}: ${Array.isArray(value) ? value.join(', ') : value}`);
-                    });
-                }
-            }
-        }
-        catch {
-            // 忽略解析错误
-        }
-    }
     if (!options.json) {
         console.log(`\n📋 任务: ${parsedTask.title}`);
         console.log(`   目标: ${parsedTask.goals.join(', ')}`);
@@ -283,27 +172,7 @@ exports.startCommand = new commander_1.Command('start')
         console.log('\n🔧 拆解任务...');
     }
     const planner = new task_planner_js_1.TaskPlanner();
-    // 构建 planner 上下文，包含 brainstorm 信息
-    // 注意: TaskPlanner.breakdown 需要 Record<string, string> 类型
-    const plannerContext = {};
-    if (brainstormContext.answers) {
-        plannerContext.brainstormAnswers = JSON.stringify(brainstormContext.answers);
-    }
-    if (brainstormContext.insights && brainstormContext.insights.length > 0) {
-        plannerContext.insights = brainstormContext.insights.join('; ');
-    }
-    if (brainstormContext.designNotes && brainstormContext.designNotes.length > 0) {
-        plannerContext.designNotes = brainstormContext.designNotes.join('; ');
-    }
-    // 添加技术栈信息
-    if (options.techStack) {
-        plannerContext.techStack = options.techStack;
-    }
-    // 添加质量级别
-    if (options.quality) {
-        plannerContext.qualityLevel = options.quality;
-    }
-    const subTasks = planner.breakdown(parsedTask, plannerContext);
+    const subTasks = planner.breakdown(parsedTask, {});
     // 创建任务到状态管理器
     for (const subTask of subTasks) {
         await stateManager.createTask({
@@ -313,8 +182,7 @@ exports.startCommand = new commander_1.Command('start')
             timeout: subTask.estimatedComplexity === 'high' ? 300000 :
                 subTask.estimatedComplexity === 'medium' ? 180000 : 120000,
             dependencies: subTask.dependencies,
-            assignedAgent: subTask.assignedAgent,
-            id: subTask.taskId
+            assignedAgent: subTask.assignedAgent
         });
     }
     // 确定执行模式

package/dist/cli/index.js

@@ -15,8 +15,6 @@ const check_js_1 = require("./commands/check.js");
 const check_gitignore_js_1 = require("./commands/check-gitignore.js");
 const analyze_js_1 = require("./commands/analyze.js");
 const brainstorm_js_1 = require("./commands/brainstorm.js");
-const complete_js_1 = require("./commands/complete.js");
-const step_js_1 = require("./commands/step.js");
 const program = new commander_1.Command();
 program
     .name('openmatrix')
@@ -36,7 +34,5 @@ program.addCommand(check_js_1.checkCommand);
 program.addCommand(check_gitignore_js_1.checkGitignoreCommand);
 program.addCommand(analyze_js_1.analyzeCommand);
 program.addCommand(brainstorm_js_1.brainstormCommand);
-program.addCommand(complete_js_1.completeCommand);
-program.addCommand(step_js_1.stepCommand);
 // 默认帮助
 program.parse();

package/dist/orchestrator/smart-question-analyzer.d.ts

@@ -20,24 +20,10 @@ export interface ProjectContext {
     packageManager: 'npm' | 'yarn' | 'pnpm' | 'pip' | 'go-mod' | 'cargo' | 'unknown';
     dependencies: Record<string, string>;
 }
-/**
- * 任务理解
- */
-export interface TaskUnderstanding {
-    taskType: 'feature' | 'bugfix' | 'refactor' | 'docs' | 'test' | 'config' | 'unknown';
-    taskTypeLabel: string;
-    scope: string[];
-    scopeLabel: string;
-    complexity: 'simple' | 'medium' | 'complex';
-    complexityLabel: string;
-    estimatedCommits: string;
-    suggestions: string[];
-}
 /**
  * 分析结果
  */
 export interface AnalysisResult {
-    understanding: TaskUnderstanding;
     inferences: QuestionInference[];
     questionsToAsk: string[];
     skippedQuestions: string[];
@@ -65,26 +51,6 @@ export declare class SmartQuestionAnalyzer {
      * 获取项目上下文
      */
     getProjectContext(): Promise<ProjectContext>;
-    /**
-     * 分析任务理解
-     */
-    private analyzeTaskUnderstanding;
-    /**
-     * 检测任务类型
-     */
-    private detectTaskType;
-    /**
-     * 检测影响范围
-     */
-    private detectScope;
-    /**
-     * 检测复杂度
-     */
-    private detectComplexity;
-    /**
-     * 生成建议
-     */
-    private generateSuggestions;
     /**
      * 推断问题答案
      */
@@ -113,8 +79,4 @@ export declare class SmartQuestionAnalyzer {
      * 生成推断摘要
      */
     generateSummary(result: AnalysisResult): string;
-    /**
-     * 生成 Markdown 格式输出
-     */
-    generateMarkdown(result: AnalysisResult): string;
 }