openmatrix 0.1.61 → 0.1.63

package/dist/cli/commands/approve.js

@@ -10,6 +10,7 @@ exports.approveCommand = new commander_1.Command('approve')
     .argument('[approvalId]', '审批ID')
     .option('-d, --decision <decision>', '决策 (approve/modify/reject)')
     .option('-c, --comment <comment>', '备注说明')
+    .option('--json', '输出 JSON 格式 (供 Skill 解析)')
     .action(async (approvalId, options) => {
     const basePath = process.cwd();
     const omPath = `${basePath}/.openmatrix`;
@@ -20,23 +21,33 @@ exports.approveCommand = new commander_1.Command('approve')
     if (!approvalId) {
         const pendingApprovals = await approvalManager.getPendingApprovals();
         if (pendingApprovals.length === 0) {
-            console.log('✅ 没有待处理的审批');
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'empty', pending: [] }));
+            }
+            else {
+                console.log('✅ 没有待处理的审批');
+            }
             return;
         }
-        console.log('📋 待处理审批:\n');
-        pendingApprovals.forEach((approval, i) => {
-            const typeEmoji = {
-                plan: '📋',
-                merge: '🔀',
-                deploy: '🚀',
-                meeting: '🔴',
-                custom: '📝'
-            };
-            const emoji = typeEmoji[approval.type] || '📝';
-            console.log(`  [${i + 1}] ${emoji} ${approval.id}: ${approval.title}`);
-            console.log(`      类型: ${approval.type} | 任务: ${approval.taskId}`);
-        });
-        console.log('\n💡 使用 openmatrix approve <ID> 处理审批');
+        if (options.json) {
+            console.log(JSON.stringify({ status: 'pending', pending: pendingApprovals }));
+        }
+        else {
+            console.log('📋 待处理审批:\n');
+            pendingApprovals.forEach((approval, i) => {
+                const typeEmoji = {
+                    plan: '📋',
+                    merge: '🔀',
+                    deploy: '🚀',
+                    meeting: '🔴',
+                    custom: '📝'
+                };
+                const emoji = typeEmoji[approval.type] || '📝';
+                console.log(`  [${i + 1}] ${emoji} ${approval.id}: ${approval.title}`);
+                console.log(`      类型: ${approval.type} | 任务: ${approval.taskId}`);
+            });
+            console.log('\n💡 使用 openmatrix approve <ID> 处理审批');
+        }
         return;
     }
     // 获取审批

package/dist/cli/commands/brainstorm.js

@@ -38,6 +38,10 @@ exports.brainstormCommand = void 0;
 const commander_1 = require("commander");
 const state_manager_js_1 = require("../../storage/state-manager.js");
 const gitignore_js_1 = require("../../utils/gitignore.js");
+const smart_question_analyzer_js_1 = require("../../orchestrator/smart-question-analyzer.js");
+const interactive_question_generator_js_1 = require("../../orchestrator/interactive-question-generator.js");
+const task_parser_js_1 = require("../../orchestrator/task-parser.js");
+const answer_mapper_js_1 = require("../../orchestrator/answer-mapper.js");
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 exports.brainstormCommand = new commander_1.Command('brainstorm')
@@ -175,8 +179,8 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
             break;
         }
     }
-    // 生成头脑风暴问题
-    const questions = generateBrainstormQuestions(taskContent, taskTitle);
+    // 生成头脑风暴问题 — 使用智能管道
+    const questions = await generateSmartQuestions(taskContent, basePath);
     // 检测是否涉及垂直领域
     const domainDetection = detectVerticalDomain(taskContent);
     // 创建会话
@@ -411,3 +415,166 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
     }
     return questions;
 }
+/**
+ * 智能问题生成 — 使用 SmartQuestionAnalyzer + InteractiveQuestionGenerator
+ */
+async function generateSmartQuestions(taskContent, basePath) {
+    try {
+        // 1. 解析任务为 ParsedTask
+        const parser = new task_parser_js_1.TaskParser();
+        const parsedTask = parser.parse(taskContent);
+        // 2. 分析项目上下文 + 推断答案
+        const analyzer = new smart_question_analyzer_js_1.SmartQuestionAnalyzer(basePath);
+        const analysisResult = await analyzer.analyze(taskContent, parsedTask);
+        // 3. 映射推断结果为规范 brainstorm ID
+        const inferenceMap = (0, answer_mapper_js_1.translateAnalyzerInferences)(analysisResult.inferences);
+        // 4. 创建问题生成器 + 设置推断
+        const questionGen = new interactive_question_generator_js_1.InteractiveQuestionGenerator();
+        questionGen.setInferences(inferenceMap);
+        // 5. 生成基础问题 + 上下文问题
+        const session = questionGen.startSession(parsedTask);
+        questionGen.addContextualQuestions(parsedTask, session.questions);
+        // 6. 转换为 BrainstormQuestion[] 格式
+        const questions = session.questions
+            .filter(q => !session.skippedQuestionIds?.includes(q.id)) // 跳过高置信度推断的问题
+            .sort((a, b) => (a.priority ?? 5) - (b.priority ?? 5))
+            .map(q => ({
+            id: q.id,
+            question: q.question,
+            header: q.category,
+            options: (q.options || []).map(o => ({
+                label: o.label,
+                description: o.description || ''
+            })),
+            multiSelect: q.type === 'multiple',
+            why: ''
+        }));
+        // 7. 追加领域分析问题（底层逻辑思考）
+        const domainQuestions = generateDomainAnalysisQuestions(taskContent);
+        questions.push(...domainQuestions);
+        return questions;
+    }
+    catch (error) {
+        // Fallback: 如果智能管道出错，使用静态问题
+        console.error(`⚠️ 智能问题生成失败，使用静态问题: ${error instanceof Error ? error.message : error}`);
+        return generateBrainstormQuestions(taskContent, '');
+    }
+}
+/**
+ * 领域分析问题 — 底层逻辑思考
+ *
+ * 从任务描述中提取：
+ * 1. 核心领域实体及其关系
+ * 2. 数据流转路径
+ * 3. 关键不变量/约束
+ * 4. 核心用户场景链路
+ */
+function generateDomainAnalysisQuestions(taskContent) {
+    const questions = [];
+    const content = taskContent.toLowerCase();
+    // ===== 问题 1: 领域实体建模 =====
+    const entityHints = extractEntities(taskContent);
+    if (entityHints.length > 0) {
+        questions.push({
+            id: 'domain_entities',
+            question: `从任务描述中识别到以下核心实体，请确认或补充：\n${entityHints.map(e => `  • ${e}`).join('\n')}`,
+            header: '领域实体',
+            options: [
+                { label: '以上实体正确', description: '已覆盖核心领域实体，无需补充' },
+                { label: '需要补充实体', description: '还有重要实体未被识别，我会在"其他"中补充' },
+                { label: '需要调整实体', description: '部分实体不准确，需要修正' }
+            ],
+            multiSelect: false,
+            why: '明确领域实体是设计数据模型和 API 的基础'
+        });
+    }
+    else {
+        questions.push({
+            id: 'domain_entities',
+            question: '这个系统涉及哪些核心领域实体？它们之间是什么关系？（如 用户-订单-商品）',
+            header: '领域实体',
+            options: [
+                { label: '单一实体', description: '系统围绕一个核心实体（如用户管理）' },
+                { label: '2-3 个实体', description: '少量实体间有简单关系（如用户-文章）' },
+                { label: '多实体复杂关系', description: '多个实体间有多对多等复杂关系' },
+                { label: '我来说明', description: '在"其他"中描述具体实体' }
+            ],
+            multiSelect: false,
+            why: '明确领域实体是设计数据模型和 API 的基础'
+        });
+    }
+    // ===== 问题 2: 数据流分析 =====
+    questions.push({
+        id: 'data_flow',
+        question: '数据在系统中如何流转？（从输入到存储到输出）',
+        header: '数据流',
+        options: [
+            { label: '用户输入 → 处理 → 存储 → 展示', description: '经典 CRUD 流程（如后台管理、博客）' },
+            { label: '外部 API → 转换 → 存储 → 查询', description: '数据采集/聚合类系统' },
+            { label: '事件触发 → 处理 → 通知/存储', description: '事件驱动型（如消息队列、Webhook）' },
+            { label: '实时流处理', description: '数据持续流入，实时处理（如监控、聊天）' },
+            { label: '我来说明', description: '在"其他"中描述具体数据流' }
+        ],
+        multiSelect: false,
+        why: '数据流决定架构选型（请求驱动 vs 事件驱动 vs 流处理）'
+    });
+    // ===== 问题 3: 不变量/约束 =====
+    questions.push({
+        id: 'invariants',
+        question: '系统中存在哪些关键不变量或业务约束？（什么条件必须永远成立）',
+        header: '不变量',
+        options: [
+            { label: '数据一致性', description: '如：余额不能为负、库存不能超卖、状态只能单向流转' },
+            { label: '权限控制', description: '如：用户只能操作自己的数据、管理员才能访问后台' },
+            { label: '唯一性约束', description: '如：用户名唯一、订单号不重复、同一时间只能有一个活跃会话' },
+            { label: '无明显约束', description: '纯展示或简单计算，无严格不变量' }
+        ],
+        multiSelect: true,
+        why: '不变量决定了哪些地方需要加锁、事务、校验和防御性编程'
+    });
+    // ===== 问题 4: 核心场景链路 =====
+    questions.push({
+        id: 'core_scenarios',
+        question: '从用户视角，核心操作链路是什么？（用户会走过的关键路径）',
+        header: '场景链路',
+        options: [
+            { label: '注册→登录→使用→退出', description: '典型用户系统链路' },
+            { label: '浏览→选择→下单→支付→确认', description: '电商/交易类链路' },
+            { label: '创建→编辑→预览→发布', description: '内容管理类链路' },
+            { label: '输入→处理→查看结果', description: '工具/计算类链路' },
+            { label: '我来说明', description: '在"其他"中描述具体场景链路' }
+        ],
+        multiSelect: true,
+        why: '核心场景链路决定了 MVP 的功能范围和优先级排序'
+    });
+    return questions;
+}
+/**
+ * 从任务描述中提取可能的领域实体
+ */
+function extractEntities(taskContent) {
+    const entities = [];
+    // 中文常见领域实体
+    const zhPatterns = [
+        { pattern: /用户|账号|账户|注册|登录|权限|角色/gi, entity: '用户 (User)' },
+        { pattern: /订单|交易|购买|支付|退款|结算/gi, entity: '订单 (Order)' },
+        { pattern: /商品|产品|物品|库存|上架|下架/gi, entity: '商品 (Product)' },
+        { pattern: /文章|帖子|内容|评论|标签|分类/gi, entity: '内容 (Content)' },
+        { pattern: /任务|工单|项目|里程碑|迭代/gi, entity: '任务 (Task)' },
+        { pattern: /消息|通知|推送|邮件|短信/gi, entity: '消息 (Message)' },
+        { pattern: /文件|附件|图片|视频|媒体|上传/gi, entity: '文件 (File)' },
+        { pattern: /配置|设置|参数|选项|规则/gi, entity: '配置 (Config)' },
+        { pattern: /日志|记录|审计|追踪|监控/gi, entity: '日志 (Log)' },
+        { pattern: /数据|报表|统计|分析|仪表盘|dashboard/gi, entity: '数据 (Data)' },
+        { pattern: /API|接口|端点|路由|endpoint/gi, entity: 'API' },
+        { pattern: /数据库|存储|缓存|表|collection/gi, entity: '存储 (Storage)' },
+    ];
+    const seen = new Set();
+    for (const { pattern, entity } of zhPatterns) {
+        if (pattern.test(taskContent) && !seen.has(entity)) {
+            entities.push(entity);
+            seen.add(entity);
+        }
+    }
+    return entities;
+}

package/dist/orchestrator/answer-mapper.d.ts

@@ -0,0 +1,24 @@
+import type { QuestionInference } from './smart-question-analyzer.js';
+/**
+ * 将 brainstorm 答案键翻译为 TaskPlanner 期望的键
+ *
+ * 支持两种输入:
+ * 1. 规范 ID (如 objective, quality_level) → 直接映射
+ * 2. 旧 brainstorm ID (如 core_objective, quality) → 先转规范 ID 再映射
+ */
+export declare function translateBrainstormAnswers(answers: Record<string, string | string[]>): Record<string, string | string[]>;
+/**
+ * 将 SmartQuestionAnalyzer 推理结果转换为 brainstorm 规范 ID
+ */
+export declare function translateAnalyzerInferences(inferences: QuestionInference[]): Map<string, {
+    answer: string | string[];
+    reason: string;
+}>;
+/**
+ * 从 brainstorm 答案中提取 tasks-input.json 所需的字段
+ */
+export declare function extractTasksInputFields(answers: Record<string, string | string[]>): {
+    quality?: string;
+    mode?: string;
+    e2eTests?: boolean;
+};

package/dist/orchestrator/answer-mapper.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateBrainstormAnswers = translateBrainstormAnswers;
+exports.translateAnalyzerInferences = translateAnalyzerInferences;
+exports.extractTasksInputFields = extractTasksInputFields;
+/**
+ * 答案键映射 — 统一三套 ID 体系
+ *
+ * Brainstorm 问题 ID  →  规范 ID  →  TaskPlanner 期望的键
+ */
+/** Brainstorm 旧 ID → 规范 ID */
+const BRAINSTORM_TO_CANONICAL = {
+    core_objective: 'objective',
+    user_value: 'user_value',
+    complexity: 'complexity',
+    tech_constraints: 'tech_stack',
+    risks: 'risks',
+    acceptance: 'acceptance',
+    priority: 'priority',
+    quality: 'quality_level',
+    execution_mode: 'execution_mode',
+    e2e_tests: 'e2e_tests',
+};
+/** 规范 ID → TaskPlanner extractUserContext() 期望的键 */
+const CANONICAL_TO_PLANNER = {
+    objective: { '目标': '', objective: '' },
+    tech_stack: { '技术栈': '', techStack: '' },
+    test_coverage: { '测试': '', testCoverage: '' },
+    documentation_level: { '文档': '', documentationLevel: '' },
+    e2e_tests: { 'E2E测试': '', e2eTests: '', e2e: '' },
+    e2e_type: { 'E2E类型': '', e2eType: '' },
+};
+/** Analyzer 旧 ID → 规范 ID */
+const ANALYZER_TO_CANONICAL = {
+    quality_level: 'quality_level',
+    tech_stack: 'tech_stack',
+    doc_level: 'documentation_level',
+    e2e_test: 'e2e_tests',
+    execution_mode: 'execution_mode',
+    objective: 'objective',
+    test_coverage: 'test_coverage',
+};
+/**
+ * 将 brainstorm 答案键翻译为 TaskPlanner 期望的键
+ *
+ * 支持两种输入:
+ * 1. 规范 ID (如 objective, quality_level) → 直接映射
+ * 2. 旧 brainstorm ID (如 core_objective, quality) → 先转规范 ID 再映射
+ */
+function translateBrainstormAnswers(answers) {
+    const result = {};
+    for (const [key, value] of Object.entries(answers)) {
+        // 步骤 1: 旧 brainstorm ID → 规范 ID
+        const canonical = BRAINSTORM_TO_CANONICAL[key] || key;
+        // 步骤 2: 规范 ID → planner 键
+        const plannerKeys = CANONICAL_TO_PLANNER[canonical];
+        if (plannerKeys) {
+            for (const plannerKey of Object.keys(plannerKeys)) {
+                result[plannerKey] = value;
+            }
+        }
+        // 同时保留原始键和规范 ID（向后兼容）
+        result[key] = value;
+        if (canonical !== key) {
+            result[canonical] = value;
+        }
+    }
+    return result;
+}
+/**
+ * 将 SmartQuestionAnalyzer 推理结果转换为 brainstorm 规范 ID
+ */
+function translateAnalyzerInferences(inferences) {
+    const result = new Map();
+    for (const inf of inferences) {
+        if (inf.inferredAnswer === undefined)
+            continue;
+        const canonical = ANALYZER_TO_CANONICAL[inf.questionId] || inf.questionId;
+        result.set(canonical, {
+            answer: inf.inferredAnswer,
+            reason: inf.reason
+        });
+    }
+    return result;
+}
+/**
+ * 从 brainstorm 答案中提取 tasks-input.json 所需的字段
+ */
+function extractTasksInputFields(answers) {
+    const result = {};
+    // quality_level / quality → quality 字段
+    const quality = answers['quality_level'] || answers['quality'];
+    if (typeof quality === 'string') {
+        result.quality = quality;
+    }
+    // execution_mode → mode 字段
+    const mode = answers['execution_mode'];
+    if (typeof mode === 'string') {
+        result.mode = mode;
+    }
+    // e2e_tests → e2eTests 布尔字段
+    const e2e = answers['e2e_tests'] || answers['e2eTests'] || answers['E2E测试'];
+    if (e2e !== undefined) {
+        const e2eStr = Array.isArray(e2e) ? e2e[0] : e2e;
+        result.e2eTests = e2eStr === 'true' || e2eStr === '启用 E2E 测试' || e2eStr === '是';
+    }
+    return result;
+}

package/dist/orchestrator/executor.d.ts

@@ -39,7 +39,9 @@ export declare class OrchestratorExecutor {
     private approvalManager;
     private stateMachine;
     private phaseExecutor;
+    private retryManager;
     private config;
+    private taskTimers;
     constructor(stateManager: StateManager, approvalManager: ApprovalManager, config?: Partial<ExecutorConfig>);
     /**
      * 获取 PhaseExecutor 实例
@@ -112,4 +114,21 @@ export declare class OrchestratorExecutor {
      * 获取 Scheduler 实例
      */
     getScheduler(): Scheduler;
+    /**
+     * 设置任务超时计时器
+     */
+    private setupTaskTimeout;
+    /**
+     * 清除任务超时计时器
+     */
+    private clearTaskTimeout;
+    /**
+     * 处理失败任务的重试
+     * @returns 成功加入重试队列的任务数量
+     */
+    private processRetries;
+    /**
+     * 销毁执行器，清理所有资源
+     */
+    destroy(): void;
 }

package/dist/orchestrator/executor.js

@@ -6,6 +6,7 @@ const scheduler_js_1 = require("./scheduler.js");
 const agent_runner_js_1 = require("../agents/agent-runner.js");
 const state_machine_js_1 = require("./state-machine.js");
 const phase_executor_js_1 = require("./phase-executor.js");
+const retry_manager_js_1 = require("./retry-manager.js");
 /**
  * OrchestratorExecutor - 执行循环核心
  *
@@ -18,7 +19,9 @@ class OrchestratorExecutor {
     approvalManager;
     stateMachine;
     phaseExecutor;
+    retryManager;
     config;
+    taskTimers = new Map();
     constructor(stateManager, approvalManager, config) {
         this.stateManager = stateManager;
         this.approvalManager = approvalManager;
@@ -37,6 +40,7 @@ class OrchestratorExecutor {
         });
         this.stateMachine = new state_machine_js_1.StateMachine();
         this.phaseExecutor = new phase_executor_js_1.PhaseExecutor(stateManager, approvalManager);
+        this.retryManager = new retry_manager_js_1.RetryManager();
     }
     /**
      * 获取 PhaseExecutor 实例
@@ -64,6 +68,18 @@ class OrchestratorExecutor {
             // 4. 检查是否有失败任务需要重试
             const failedTasks = allTasks.filter(t => t.status === 'failed');
             if (failedTasks.length > 0) {
+                // 尝试自动重试
+                const retried = await this.processRetries(failedTasks);
+                if (retried > 0) {
+                    // 有任务被重新放入队列，继续执行循环
+                    return {
+                        status: 'continue',
+                        subagentTasks: [],
+                        message: `${retried} 个失败任务已加入重试队列`,
+                        statistics: this.getStatistics(state)
+                    };
+                }
+                // 所有重试次数已耗尽
                 return this.createRetryNeededResult(failedTasks, state);
             }
             // 5. 检查是否有阻塞任务
@@ -85,9 +101,10 @@ class OrchestratorExecutor {
         }
         // 10. 准备 Subagent 任务
         const subagentTasks = await this.agentRunner.prepareSubagentTasks(executableTasks);
-        // 8. 更新任务状态为 scheduled
+        // 8. 更新任务状态为 scheduled 并设置超时
         for (const task of executableTasks) {
             await this.scheduler.markTaskStarted(task.id);
+            this.setupTaskTimeout(task.id);
         }
         return {
             status: 'continue',
@@ -241,6 +258,8 @@ class OrchestratorExecutor {
             throw new Error(`Task ${taskId} not found`);
         }
         if (result.success) {
+            // 清除超时计时器
+            this.clearTaskTimeout(taskId);
             // 更新阶段状态
             const currentPhase = this.getCurrentPhase(task);
             const updatedPhases = { ...task.phases };
@@ -281,6 +300,7 @@ class OrchestratorExecutor {
             }
         }
         else {
+            this.clearTaskTimeout(taskId);
             await this.scheduler.markTaskFailed(taskId, result.error || 'Unknown error');
         }
     }
@@ -321,5 +341,60 @@ class OrchestratorExecutor {
     getScheduler() {
         return this.scheduler;
     }
+    // ============ Timeout Management ============
+    /**
+     * 设置任务超时计时器
+     */
+    setupTaskTimeout(taskId) {
+        const timer = setTimeout(async () => {
+            console.error(`⏰ 任务超时: ${taskId} (${this.config.taskTimeout / 1000}s)`);
+            this.taskTimers.delete(taskId);
+            await this.scheduler.markTaskFailed(taskId, `Task timed out after ${this.config.taskTimeout / 1000}s`);
+        }, this.config.taskTimeout);
+        this.taskTimers.set(taskId, timer);
+    }
+    /**
+     * 清除任务超时计时器
+     */
+    clearTaskTimeout(taskId) {
+        const timer = this.taskTimers.get(taskId);
+        if (timer) {
+            clearTimeout(timer);
+            this.taskTimers.delete(taskId);
+        }
+    }
+    // ============ Retry Management ============
+    /**
+     * 处理失败任务的重试
+     * @returns 成功加入重试队列的任务数量
+     */
+    async processRetries(failedTasks) {
+        let retried = 0;
+        for (const task of failedTasks) {
+            this.retryManager.addToQueue(task.id, task.error || 'Unknown error');
+            if (this.retryManager.shouldRetry(task.id)) {
+                // 将任务从 failed 转为 retry_queue 再转为 pending
+                await this.stateManager.updateTask(task.id, {
+                    status: 'retry_queue',
+                    retryCount: (task.retryCount || 0) + 1
+                });
+                await this.stateManager.updateTask(task.id, {
+                    status: 'pending'
+                });
+                this.retryManager.removeFromQueue(task.id);
+                retried++;
+            }
+        }
+        return retried;
+    }
+    /**
+     * 销毁执行器，清理所有资源
+     */
+    destroy() {
+        for (const timer of this.taskTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.taskTimers.clear();
+    }
 }
 exports.OrchestratorExecutor = OrchestratorExecutor;