openmatrix 0.1.62 → 0.1.64

package/dist/agents/agent-runner.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRunner = void 0;
-const fs = __importStar(require("fs"));
+const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 /**
  * AgentRunner - 使用 Subagent 执行任务
@@ -57,7 +57,7 @@ class AgentRunner {
         this.approvalManager = approvalManager;
         this.config = {
             maxConcurrent: 3,
-            taskTimeout: 120000,
+            taskTimeout: 600000, // 10 分钟
             ...config
         };
     }
@@ -177,23 +177,32 @@ ${agentPrompt.instructions}
      *
      * 读取所有已完成任务的 context.md，为当前 Agent 提供前序 Agent 的决策和知识
      */
-    buildAccumulatedContext(currentTask) {
+    async buildAccumulatedContext(currentTask) {
         const omPath = path.join(process.cwd(), '.openmatrix');
         const tasksDir = path.join(omPath, 'tasks');
         try {
-            if (!fs.existsSync(tasksDir))
+            // 异步检查目录是否存在
+            try {
+                await fs.access(tasksDir);
+            }
+            catch {
                 return '';
+            }
             const contextParts = [];
-            // 读取所有已完成任务的 context.md
-            const taskDirs = fs.readdirSync(tasksDir).filter(name => name.startsWith('TASK-'));
+            // 异步读取目录
+            const taskDirs = (await fs.readdir(tasksDir)).filter(name => name.startsWith('TASK-'));
             for (const taskId of taskDirs) {
                 const contextFile = path.join(tasksDir, taskId, 'context.md');
-                if (fs.existsSync(contextFile)) {
-                    const content = fs.readFileSync(contextFile, 'utf-8').trim();
-                    if (content) {
-                        contextParts.push(`### ${taskId}\n${content}`);
+                try {
+                    const content = await fs.readFile(contextFile, 'utf-8');
+                    const trimmed = content.trim();
+                    if (trimmed) {
+                        contextParts.push(`### ${taskId}\n${trimmed}`);
                     }
                 }
+                catch {
+                    // 文件不存在或读取失败，跳过
+                }
             }
             if (contextParts.length === 0)
                 return '';

package/dist/cli/commands/brainstorm.js

@@ -389,30 +389,26 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         question: '选择执行模式（控制 AI 执行过程中的审批节点）',
         header: '执行模式',
         options: [
-            { label: 'auto (推荐)', description: '全自动执行，无需人工审批，遇到阻塞自动 Meeting' },
+            { label: '全自动执行 (推荐)', description: '全自动执行，无需人工审批，遇到阻塞自动 Meeting' },
             { label: 'confirm-key', description: '关键节点审批（计划、合并、部署）' },
             { label: 'confirm-all', description: '每个阶段都需人工确认' }
         ],
         multiSelect: false,
         why: '执行模式决定自动化程度和人工干预频率'
     });
-    // 问题 10: E2E 测试（Web/Mobile/GUI 项目）
-    if (content.includes('web') || content.includes('前端') || content.includes('页面') ||
-        content.includes('网站') || content.includes('app') || content.includes('应用') ||
-        content.includes('游戏') || content.includes('管理') || content.includes('后台') ||
-        content.includes('ui') || content.includes('mobile') || content.includes('mobile')) {
-        questions.push({
-            id: 'e2e_tests',
-            question: '是否启用端到端 (E2E) 测试？（适用于 Web/Mobile/GUI 项目，耗时较长）',
-            header: 'E2E 测试',
-            options: [
-                { label: '启用 E2E 测试', description: '使用 Playwright/Cypress 等框架进行端到端测试' },
-                { label: '不启用 (推荐)', description: '仅进行单元测试和集成测试，节省时间' }
-            ],
-            multiSelect: false,
-            why: 'E2E 测试能验证完整用户流程，但增加执行时间'
-        });
-    }
+    // 问题 10: E2E 测试（必填）
+    // E2E 测试是必问问题，由用户在问答中选择是否启用
+    questions.push({
+        id: 'e2e_tests',
+        question: '是否启用端到端 (E2E) 测试？（适用于 Web/Mobile/GUI 项目，耗时较长）',
+        header: 'E2E 测试',
+        options: [
+            { label: '启用 E2E 测试', description: '使用 Playwright/Cypress 等框架进行端到端测试' },
+            { label: '不启用 (推荐)', description: '仅进行单元测试和集成测试，节省时间' }
+        ],
+        multiSelect: false,
+        why: 'E2E 测试能验证完整用户流程，但增加执行时间'
+    });
     return questions;
 }
 /**
@@ -449,6 +445,9 @@ async function generateSmartQuestions(taskContent, basePath) {
             multiSelect: q.type === 'multiple',
             why: ''
         }));
+        // 7. 追加领域分析问题（底层逻辑思考）
+        const domainQuestions = generateDomainAnalysisQuestions(taskContent);
+        questions.push(...domainQuestions);
         return questions;
     }
     catch (error) {
@@ -457,3 +456,121 @@ async function generateSmartQuestions(taskContent, basePath) {
         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/cli/commands/complete.js

@@ -38,6 +38,7 @@ exports.completeCommand = void 0;
 const commander_1 = require("commander");
 const state_manager_js_1 = require("../../storage/state-manager.js");
 const git_commit_manager_js_1 = require("../../orchestrator/git-commit-manager.js");
+const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 exports.completeCommand = new commander_1.Command('complete')
     .description('标记任务完成并更新全局统计')
@@ -84,7 +85,13 @@ exports.completeCommand = new commander_1.Command('complete')
         completed: allTasks.filter(t => t.status === 'completed').length,
         inProgress: allTasks.filter(t => t.status === 'in_progress').length,
         failed: allTasks.filter(t => t.status === 'failed').length,
-        pending: allTasks.filter(t => t.status === 'pending' || t.status === 'scheduled').length
+        pending: allTasks.filter(t => t.status === 'pending').length,
+        scheduled: allTasks.filter(t => t.status === 'scheduled').length,
+        blocked: allTasks.filter(t => t.status === 'blocked').length,
+        waiting: allTasks.filter(t => t.status === 'waiting').length,
+        verify: allTasks.filter(t => t.status === 'verify').length,
+        accept: allTasks.filter(t => t.status === 'accept').length,
+        retry_queue: allTasks.filter(t => t.status === 'retry_queue').length
     };
     // 4. 更新全局状态
     const allDone = stats.completed + stats.failed === stats.totalTasks;
@@ -94,7 +101,33 @@ exports.completeCommand = new commander_1.Command('complete')
         currentPhase: allDone ? 'completed' : 'execution',
         ...(allDone ? { completedAt: now } : {})
     });
-    // 5. Git 自动提交
+    // 5. 写入 context.md (Agent Memory)
+    if (isSuccess) {
+        const taskDir = path.join(omPath, 'tasks', taskId);
+        const contextFile = path.join(taskDir, 'context.md');
+        try {
+            await fs.mkdir(taskDir, { recursive: true });
+            const contextContent = `## 任务：${task.id} ${task.title}
+
+### 关键决策
+- [待补充]
+
+### 创建/修改的文件
+- [待补充]
+
+### 重要发现
+- [待补充]
+
+### 对后续任务的建议
+- [待补充]
+`;
+            await fs.writeFile(contextFile, contextContent, 'utf-8');
+        }
+        catch {
+            // 忽略写入错误
+        }
+    }
+    // 6. Git 自动提交
     if (isSuccess) {
         const state = await stateManager.getState();
         const gitManager = new git_commit_manager_js_1.GitCommitManager(basePath);

package/dist/cli/commands/start.js

@@ -106,7 +106,7 @@ exports.startCommand = new commander_1.Command('start')
     // 路径 A: AI 已拆分 (--tasks-json)
     // ============================
     if (options.tasksJson) {
-        await handleTasksJson(options, stateManager, state, omPath);
+        await handleTasksJson(options, stateManager, state, omPath, basePath);
         return;
     }
     // ============================
@@ -118,13 +118,16 @@ exports.startCommand = new commander_1.Command('start')
  * 处理 AI 解析的任务 (--tasks-json)
  * AI 提供 ParsedTask 格式的结构化数据，仍由 TaskPlanner 做拆分
  */
-async function handleTasksJson(options, stateManager, state, omPath) {
+async function handleTasksJson(options, stateManager, state, omPath, basePath) {
     let tasksInput;
     try {
         // 支持 @file 语法读取文件
         let jsonStr = options.tasksJson;
         if (jsonStr.startsWith('@')) {
-            jsonStr = await fs.readFile(jsonStr.slice(1), 'utf-8');
+            const filePath = jsonStr.slice(1);
+            // 如果是相对路径，转换为绝对路径
+            const resolvedPath = path.isAbsolute(filePath) ? filePath : path.join(basePath, filePath);
+            jsonStr = await fs.readFile(resolvedPath, 'utf-8');
         }
         tasksInput = JSON.parse(jsonStr);
     }

package/dist/cli/commands/step.js

@@ -68,7 +68,13 @@ exports.stepCommand = new commander_1.Command('step')
             completed: completed,
             inProgress: allTasks.filter(t => t.status === 'in_progress').length,
             failed: allTasks.filter(t => t.status === 'failed').length,
-            pending: allTasks.filter(t => t.status === 'pending').length
+            pending: allTasks.filter(t => t.status === 'pending').length,
+            scheduled: allTasks.filter(t => t.status === 'scheduled').length,
+            blocked: allTasks.filter(t => t.status === 'blocked').length,
+            waiting: allTasks.filter(t => t.status === 'waiting').length,
+            verify: allTasks.filter(t => t.status === 'verify').length,
+            accept: allTasks.filter(t => t.status === 'accept').length,
+            retry_queue: allTasks.filter(t => t.status === 'retry_queue').length
         };
         const allDone = completed + stats.failed === total;
         await stateManager.updateState({

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,13 +19,15 @@ class OrchestratorExecutor {
     approvalManager;
     stateMachine;
     phaseExecutor;
+    retryManager;
     config;
+    taskTimers = new Map();
     constructor(stateManager, approvalManager, config) {
         this.stateManager = stateManager;
         this.approvalManager = approvalManager;
         this.config = {
             maxConcurrent: 3,
-            taskTimeout: 120000,
+            taskTimeout: 600000, // 10 分钟
             ...config
         };
         this.scheduler = new scheduler_js_1.Scheduler(stateManager, {
@@ -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;

package/dist/orchestrator/git-commit-manager.js

@@ -244,8 +244,18 @@ class GitCommitManager {
             };
             // 生成提交信息
             const commitMessage = this.generateCommitMessage(fullInfo);
-            // 添加所有文件
-            await execAsync('git add -A', { cwd: this.repoPath });
+            // 添加文件 - 使用 git add . 而不是 git add -A
+            // git add . 只添加当前目录及子目录的文件，不会添加上级目录的文件
+            // 同时通过 .gitignore 排除不需要的文件
+            await execAsync('git add .', { cwd: this.repoPath });
+            // 检查是否有文件被暂存（避免空提交）
+            const { stdout: staged } = await execAsync('git diff --cached --name-only', { cwd: this.repoPath });
+            if (!staged.trim()) {
+                return {
+                    success: false,
+                    message: 'No files to commit (all changes ignored or no changes)'
+                };
+            }
             // 使用临时文件传递 commit message（避免 Windows 下多行消息转义问题）
             const tmpFile = path.join(this.repoPath, '.git', 'COMMIT_MSG_TMP');
             await fs.writeFile(tmpFile, commitMessage, 'utf-8');

package/dist/orchestrator/phase-executor.d.ts

@@ -192,6 +192,9 @@ export declare class PhaseExecutor {
     parseBuildTestResult(output: string): BuildTestResult;
     /**
      * 解析质量报告
+     *
+     * 策略：优先解析 JSON 格式，失败时使用正则表达式回退
+     * 支持多种测试框架输出格式（Vitest, Jest, Mocha, Tape）
      */
     parseQualityReport(output: string): QualityGateResult;
     /**