openmatrix 0.1.49 → 0.1.51

package/README.md

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

package/dist/agents/agent-runner.d.ts

@@ -1,4 +1,4 @@
-import type { Task, AgentType, AgentResult } from '../types/index.js';
+import type { Task, AgentType, AgentResult, SubagentTask, ClaudeCodeSubagentType } from '../types/index.js';
 import { StateManager } from '../storage/state-manager.js';
 import { ApprovalManager } from '../orchestrator/approval-manager.js';
 export interface AgentRunnerConfig {
@@ -10,31 +10,6 @@ export interface SubagentPrompt {
     context: string;
     instructions: string;
 }
-/**
- * Claude Code Subagent 类型
- */
-export type ClaudeCodeSubagentType = 'general-purpose' | 'Explore' | 'Plan';
-/**
- * Subagent 任务配置 - 用于 Agent 工具调用
- */
-export interface SubagentTask {
-    /** Subagent 类型 */
-    subagent_type: ClaudeCodeSubagentType;
-    /** 简短描述 (3-5 词) */
-    description: string;
-    /** 完整任务提示词 */
-    prompt: string;
-    /** 是否使用隔离 worktree */
-    isolation?: 'worktree';
-    /** 任务 ID (用于追踪) */
-    taskId: string;
-    /** 原始 Agent 类型 */
-    agentType: AgentType;
-    /** 超时时间 (ms) */
-    timeout: number;
-    /** 是否需要审批 */
-    needsApproval: boolean;
-}
 /**
  * 用户上下文信息
  */

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/meeting.js

@@ -38,6 +38,7 @@ exports.meetingCommand = void 0;
 const commander_1 = require("commander");
 const state_manager_js_1 = require("../../storage/state-manager.js");
 const approval_manager_js_1 = require("../../orchestrator/approval-manager.js");
+const meeting_manager_js_1 = require("../../orchestrator/meeting-manager.js");
 const path = __importStar(require("path"));
 exports.meetingCommand = new commander_1.Command('meeting')
     .description('查看和处理待确认的 Meeting')
@@ -55,23 +56,26 @@ exports.meetingCommand = new commander_1.Command('meeting')
     const stateManager = new state_manager_js_1.StateManager(omPath);
     await stateManager.initialize();
     const approvalManager = new approval_manager_js_1.ApprovalManager(stateManager);
+    const meetingManager = new meeting_manager_js_1.MeetingManager(stateManager, approvalManager);
     try {
-        // 获取所有 pending 的 meeting
+        // 获取所有 pending 的 meeting approvals
         const pendingApprovals = await stateManager.getApprovalsByStatus('pending');
-        const meetings = pendingApprovals.filter(a => a.type === 'meeting');
+        const meetingApprovals = pendingApprovals.filter(a => a.type === 'meeting');
         // 列出所有 Meeting
         if (options.list || (!meetingId && !options.skipAll)) {
-            if (meetings.length === 0) {
+            // 同时获取 MeetingManager 中的详细 Meeting 信息
+            const pendingMeetings = await meetingManager.getPendingMeetings();
+            if (meetingApprovals.length === 0 && pendingMeetings.length === 0) {
                 console.log('✅ 没有待处理的 Meeting\n');
-                console.log('当前状态:');
                 const allApprovals = await stateManager.getApprovalsByStatus('approved');
-                const meetingApprovals = allApprovals.filter(a => a.type === 'meeting');
-                console.log(`  - 已解决: ${meetingApprovals.length}`);
-                console.log(`  - 总计: ${meetingApprovals.length}`);
+                const resolvedMeetings = allApprovals.filter(a => a.type === 'meeting');
+                console.log('当前状态:');
+                console.log(`  - 已解决: ${resolvedMeetings.length}`);
+                console.log(`  - 总计: ${resolvedMeetings.length}`);
                 return;
             }
-            console.log(`\n📋 待处理 Meeting (${meetings.length}个)\n`);
-            meetings.forEach((meeting, index) => {
+            console.log(`\n📋 待处理 Meeting (${meetingApprovals.length}个)\n`);
+            meetingApprovals.forEach((meeting, index) => {
                 const icon = meeting.title.includes('决策') ? '🤔' : '🔴';
                 const shortTitle = meeting.title.slice(0, 40);
                 console.log(`  [${index + 1}] ${icon} ${meeting.id} - ${shortTitle}`);
@@ -87,8 +91,8 @@ exports.meetingCommand = new commander_1.Command('meeting')
         }
         // 批量跳过
         if (options.skipAll) {
-            console.log(`\n⏭️  批量跳过 ${meetings.length} 个 Meeting...\n`);
-            for (const meeting of meetings) {
+            console.log(`\n⏭️  批量跳过 ${meetingApprovals.length} 个 Meeting...\n`);
+            for (const meeting of meetingApprovals) {
                 await approvalManager.processDecision({
                     approvalId: meeting.id,
                     decision: 'approve',
@@ -96,6 +100,16 @@ exports.meetingCommand = new commander_1.Command('meeting')
                     decidedBy: 'user',
                     decidedAt: new Date().toISOString()
                 });
+                // 尝试通过 MeetingManager 解决关联的 Meeting
+                try {
+                    const parsed = JSON.parse(meeting.content || '{}');
+                    if (parsed.meetingId) {
+                        await meetingManager.cancelMeeting(parsed.meetingId, options.message || '批量跳过');
+                    }
+                }
+                catch {
+                    // content 可能不是 JSON，跳过 Meeting 更新
+                }
                 // 更新关联任务状态为 skipped
                 const task = await stateManager.getTask(meeting.taskId);
                 if (task) {
@@ -114,7 +128,7 @@ exports.meetingCommand = new commander_1.Command('meeting')
             console.log('❌ 请指定 Meeting ID 或使用 --list');
             return;
         }
-        const meeting = meetings.find(m => m.id === meetingId);
+        const meeting = meetingApprovals.find(m => m.id === meetingId);
         if (!meeting) {
             console.log(`❌ Meeting ${meetingId} 不存在或已处理`);
             return;
@@ -123,7 +137,7 @@ exports.meetingCommand = new commander_1.Command('meeting')
         console.log(`\n📋 Meeting: ${meeting.id}`);
         console.log(`🎯 任务: ${meeting.taskId}`);
         console.log(`\n## 详情\n`);
-        console.log(meeting.content || '无详细内容');
+        console.log(meeting.description || '无详细内容');
         console.log('');
         // 执行操作
         const action = options.action;
@@ -137,6 +151,15 @@ exports.meetingCommand = new commander_1.Command('meeting')
             console.log('  --action cancel --message "..."');
             return;
         }
+        // 解析关联的 Meeting ID
+        let internalMeetingId;
+        try {
+            const parsed = JSON.parse(meeting.content || '{}');
+            internalMeetingId = parsed.meetingId;
+        }
+        catch {
+            // content 可能不是 JSON
+        }
         switch (action) {
             case 'provide-info':
                 if (!options.info) {
@@ -150,6 +173,10 @@ exports.meetingCommand = new commander_1.Command('meeting')
                     decidedBy: 'user',
                     decidedAt: new Date().toISOString()
                 });
+                // 通过 MeetingManager 解决关联 Meeting
+                if (internalMeetingId) {
+                    await meetingManager.resolveMeeting(internalMeetingId, `提供信息: ${options.info}`);
+                }
                 console.log('✅ 信息已记录，任务将恢复执行');
                 break;
             case 'skip':
@@ -160,6 +187,9 @@ exports.meetingCommand = new commander_1.Command('meeting')
                     decidedBy: 'user',
                     decidedAt: new Date().toISOString()
                 });
+                if (internalMeetingId) {
+                    await meetingManager.cancelMeeting(internalMeetingId, options.message || '跳过');
+                }
                 // 标记任务为跳过
                 const skipTask = await stateManager.getTask(meeting.taskId);
                 if (skipTask) {
@@ -178,6 +208,9 @@ exports.meetingCommand = new commander_1.Command('meeting')
                     decidedBy: 'user',
                     decidedAt: new Date().toISOString()
                 });
+                if (internalMeetingId) {
+                    await meetingManager.resolveMeeting(internalMeetingId, '重试任务');
+                }
                 // 重置任务状态
                 await stateManager.updateTask(meeting.taskId, {
                     status: 'retry_queue',
@@ -197,6 +230,9 @@ exports.meetingCommand = new commander_1.Command('meeting')
                     decidedBy: 'user',
                     decidedAt: new Date().toISOString()
                 });
+                if (internalMeetingId) {
+                    await meetingManager.resolveMeeting(internalMeetingId, `修改方案: ${options.newPlan}`);
+                }
                 // 更新任务描述
                 const modifyTask = await stateManager.getTask(meeting.taskId);
                 if (modifyTask) {
@@ -216,6 +252,9 @@ exports.meetingCommand = new commander_1.Command('meeting')
                     decidedBy: 'user',
                     decidedAt: new Date().toISOString()
                 });
+                if (internalMeetingId) {
+                    await meetingManager.resolveMeeting(internalMeetingId, `决策: ${options.reason || '已做出决策'}`);
+                }
                 console.log('✅ 决策已记录');
                 break;
             case 'cancel':
@@ -226,6 +265,9 @@ exports.meetingCommand = new commander_1.Command('meeting')
                     decidedBy: 'user',
                     decidedAt: new Date().toISOString()
                 });
+                if (internalMeetingId) {
+                    await meetingManager.cancelMeeting(internalMeetingId, options.message || '用户取消');
+                }
                 // 标记任务为失败
                 await stateManager.updateTask(meeting.taskId, {
                     status: 'failed',