openmatrix 0.1.99 → 0.2.2

package/dist/orchestrator/executor.js

@@ -7,6 +7,7 @@ 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");
+const ai_reviewer_js_1 = require("./ai-reviewer.js");
 /**
  * OrchestratorExecutor - 执行循环核心
  *
@@ -20,6 +21,7 @@ class OrchestratorExecutor {
     stateMachine;
     phaseExecutor;
     retryManager;
+    aiReviewer;
     config;
     taskTimers = new Map();
     constructor(stateManager, approvalManager, config) {
@@ -41,6 +43,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();
+        this.aiReviewer = new ai_reviewer_js_1.AIReviewer();
     }
     /**
      * 获取 PhaseExecutor 实例
@@ -101,7 +104,7 @@ class OrchestratorExecutor {
         }
         // 10. 准备 Subagent 任务
         const subagentTasks = await this.agentRunner.prepareSubagentTasks(executableTasks);
-        // 8. 更新任务状态为 scheduled 并设置超时
+        // 11. 更新任务状态为 in_progress 并设置超时
         for (const task of executableTasks) {
             await this.scheduler.markTaskStarted(task.id);
             this.setupTaskTimeout(task.id);
@@ -251,6 +254,8 @@ class OrchestratorExecutor {
     }
     /**
      * 标记任务完成
+     *
+     * 增强：对于 reviewer 任务，自动解析 Review 报告并生成修复任务
      */
     async completeTask(taskId, result) {
         const task = await this.stateManager.getTask(taskId);
@@ -297,12 +302,53 @@ class OrchestratorExecutor {
             }
             else if (currentPhase === 'accept') {
                 await this.scheduler.markTaskCompleted(taskId);
+                // Review 任务完成：自动解析报告并生成修复任务
+                if (task.assignedAgent === 'reviewer' && result.output) {
+                    return await this.processReviewResult(taskId, result.output);
+                }
             }
         }
         else {
             this.clearTaskTimeout(taskId);
             await this.scheduler.markTaskFailed(taskId, result.error || 'Unknown error');
         }
+        return {};
+    }
+    /**
+     * 处理 Review 结果：解析报告，如有 critical/major 问题则自动创建修复任务
+     */
+    async processReviewResult(taskId, output) {
+        const report = this.aiReviewer.parseReviewResult(taskId, output);
+        const task = await this.stateManager.getTask(taskId);
+        if (!task)
+            return {};
+        // 保存 Review 报告到 artifacts
+        await this.stateManager.savePhaseResult(taskId, 'review', {
+            report,
+            taskId,
+            reviewedAt: report.reviewedAt
+        });
+        if (!this.aiReviewer.needsAutoFix(report)) {
+            console.log(`✅ Review 通过: ${taskId} — 无 critical/major 问题`);
+            return {};
+        }
+        // 生成修复任务
+        const fixTasks = this.aiReviewer.generateFixTasks(task, report, taskId);
+        const createdIds = [];
+        for (const fixTask of fixTasks) {
+            // 将生成的 taskId 转换为 StateManager 的 ID 格式
+            const created = await this.stateManager.createTask({
+                title: fixTask.title,
+                description: fixTask.description,
+                priority: fixTask.priority,
+                timeout: fixTask.timeout,
+                dependencies: fixTask.dependencies,
+                assignedAgent: fixTask.assignedAgent
+            });
+            createdIds.push(created.id);
+        }
+        console.log(`🔧 Review 发现 ${report.issues.length} 个问题，已创建 ${createdIds.length} 个修复任务`);
+        return { createdFixTasks: createdIds };
     }
     /**
      * 获取当前阶段
@@ -370,13 +416,27 @@ class OrchestratorExecutor {
      */
     async processRetries(failedTasks) {
         let retried = 0;
+        let limit;
+        try {
+            const state = await this.stateManager.getState();
+            limit = state.config.maxRetries;
+        }
+        catch {
+            limit = 3;
+        }
         for (const task of failedTasks) {
+            const currentRetryCount = task.retryCount || 0;
+            // 先检查是否还有重试次数，再决定是否加入队列
+            if (currentRetryCount >= limit) {
+                console.log(`⚠️ 任务 ${task.id} 已达到最大重试次数 (${limit})，跳过重试`);
+                continue;
+            }
             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
+                    retryCount: currentRetryCount + 1
                 });
                 await this.stateManager.updateTask(task.id, {
                     status: 'pending'

package/dist/orchestrator/interactive-question-generator.js

@@ -313,14 +313,15 @@ class InteractiveQuestionGenerator {
         // 7. E2E 测试
         questions.push({
             id: 'e2e_tests',
-            question: '是否启用端到端 (E2E) 测试？（适用于 Web/Mobile/GUI 项目，耗时较长）',
+            question: '是否需要端到端 (E2E) 测试？（适用于 Web/Mobile/GUI 项目，耗时较长）',
             type: 'single',
             required: false,
             category: 'quality',
             priority: 7,
             options: [
-                { key: 'true', label: '启用 E2E 测试', description: '使用 Playwright/Cypress 等框架进行端到端测试' },
-                { key: 'false', label: '不启用 (推荐)', description: '仅进行单元测试和集成测试，节省时间' }
+                { key: 'functional', label: '功能测试 (推荐)', description: '验证业务流程正确性，无需浏览器可视化，速度快' },
+                { key: 'visual', label: '视觉验证', description: '需要浏览器可视化验证，可检查页面样式和布局' },
+                { key: 'false', label: '不需要', description: '仅进行单元测试和集成测试，节省时间' }
             ]
         });
         // 8. 风险评估

package/dist/orchestrator/meeting-manager.js

@@ -42,24 +42,24 @@ class MeetingManager {
             type: 'meeting',
             taskId,
             title: meeting.title,
-            description: `
-## 阻塞问题描述
-
-**任务**: ${taskId}
-**原因**: ${blockingReason}
-
-## 影响范围
-
-${impactScope.map(item => `- ${item}`).join('\n')}
-
-## 需要的行动
-
-请选择以下操作之一:
-
-1. **提供信息** - 提供解决阻塞所需的信息
-2. **跳过任务** - 标记任务为可选，跳过继续执行
-3. **修改方案** - 调整任务方案或参数
-4. **取消执行** - 停止整个执行流程
+            description: `
+## 阻塞问题描述
+
+**任务**: ${taskId}
+**原因**: ${blockingReason}
+
+## 影响范围
+
+${impactScope.map(item => `- ${item}`).join('\n')}
+
+## 需要的行动
+
+请选择以下操作之一:
+
+1. **提供信息** - 提供解决阻塞所需的信息
+2. **跳过任务** - 标记任务为可选，跳过继续执行
+3. **修改方案** - 调整任务方案或参数
+4. **取消执行** - 停止整个执行流程
 `,
             content: JSON.stringify({ meetingId, blockingReason, impactScope })
         });
@@ -87,17 +87,17 @@ ${impactScope.map(item => `- ${item}`).join('\n')}
             type: 'meeting',
             taskId,
             title: meeting.title,
-            description: `
-## 决策点
-
-**任务**: ${taskId}
-**问题**: ${decision}
-
-## 可选方案
-
-${options.map((opt, i) => `${i + 1}. ${opt}`).join('\n')}
-
-请在审批时提供您的选择。
+            description: `
+## 决策点
+
+**任务**: ${taskId}
+**问题**: ${decision}
+
+## 可选方案
+
+${options.map((opt, i) => `${i + 1}. ${opt}`).join('\n')}
+
+请在审批时提供您的选择。
 `,
             content: JSON.stringify({ meetingId, decision, options })
         });
@@ -136,9 +136,10 @@ ${options.map((opt, i) => `${i + 1}. ${opt}`).join('\n')}
         await this.stateManager.saveMeeting(updatedMeeting);
         // 更新关联任务状态
         if (meeting.type === 'blocking') {
-            // 将任务从 waiting 恢复到 pending
+            // 将阻塞任务恢复到 pending，让调度器重新调度
+            // 阻塞任务可能是 waiting 或 blocked 状态
             const task = await this.stateManager.getTask(meeting.taskId);
-            if (task && task.status === 'waiting') {
+            if (task && (task.status === 'waiting' || task.status === 'blocked')) {
                 await this.stateManager.updateTask(meeting.taskId, {
                     status: 'pending',
                     error: undefined

package/dist/orchestrator/phase-executor.js

@@ -535,7 +535,7 @@ try {
   }
 } catch(e) {
   console.error('❌ Import failed:', e.message);
-  process.exit(1);
+  process.exitCode = 1;
 }
 "
 \`\`\`
@@ -740,7 +740,7 @@ for (const mod of modules) {
 }
 if (failed.length > 0) {
   console.error('Failed imports:', failed.join(', '));
-  process.exit(1);
+  process.exitCode = 1;
 }
 console.log('All module imports passed');
 "
@@ -955,7 +955,7 @@ ACCEPT_FAILED
     parseQualityReport(output) {
         const result = {
             passed: false,
-            tests: { passed: 0, failed: 0, coverage: 0 },
+            tests: { passed: 0, failed: 0, coverage: -1 }, // -1 = coverage not measured
             build: { success: false, errors: [] },
             lint: { errors: 0, warnings: 0 },
             security: { vulnerabilities: 0 },
@@ -972,7 +972,8 @@ ACCEPT_FAILED
                 if (jsonReport.tests) {
                     result.tests.passed = jsonReport.tests.passed ?? 0;
                     result.tests.failed = jsonReport.tests.failed ?? 0;
-                    result.tests.coverage = jsonReport.tests.coverage ?? 0;
+                    // -1 表示未测量覆盖率
+                    result.tests.coverage = jsonReport.tests.coverage ?? -1;
                 }
                 // 解析 build
                 if (jsonReport.build) {
@@ -1003,7 +1004,8 @@ ACCEPT_FAILED
                 // 判断是否通过
                 const qc = this.qualityConfig;
                 const testsPassed = result.tests.failed === 0;
-                const coverageOk = result.tests.coverage >= qc.minCoverage;
+                // 覆盖率 -1 表示未测量（无覆盖率输出），跳过检查
+                const coverageOk = result.tests.coverage < 0 || result.tests.coverage >= qc.minCoverage;
                 const lintOk = qc.strictLint ? result.lint.errors === 0 : true;
                 const buildOk = result.build.success;
                 const e2eOk = qc.e2eTests ? result.e2e.failed === 0 : true;
@@ -1095,7 +1097,8 @@ ACCEPT_FAILED
         // 判断是否通过
         const qc = this.qualityConfig;
         const testsPassed = result.tests.failed === 0;
-        const coverageOk = result.tests.coverage >= qc.minCoverage;
+        // 覆盖率 -1 表示未测量（regex 回退路径下未匹配到覆盖率时保持 -1）
+        const coverageOk = result.tests.coverage < 0 || result.tests.coverage >= qc.minCoverage;
         const lintOk = qc.strictLint ? result.lint.errors === 0 : true;
         const buildOk = result.build.success;
         const e2eOk = qc.e2eTests ? result.e2e.failed === 0 : true;

package/dist/orchestrator/scheduler.d.ts

@@ -14,8 +14,11 @@ export declare class Scheduler {
     private stateManager;
     private stateMachine;
     private config;
-    private runningTasks;
     constructor(stateManager: StateManager, config?: Partial<SchedulerConfig>);
+    /**
+     * 获取当前正在执行的任务数（从持久化状态读取，非内存缓存）
+     */
+    private getRunningCount;
     /**
      * 获取下一个可执行的任务
      */
@@ -33,7 +36,7 @@ export declare class Scheduler {
      */
     private transitionTask;
     /**
-     * 标记任务开始执行
+     * 标记任务开始执行（阶段感知，不重置已完成的 phase）
      */
     markTaskStarted(taskId: string): Promise<void>;
     /**
@@ -66,11 +69,10 @@ export declare class Scheduler {
      */
     private handleCircularDependencies;
     /**
-     * 获取调度状态
+     * 获取调度状态（从持久化状态读取）
      */
-    getStatus(): {
+    getStatus(): Promise<{
         running: number;
         maxConcurrent: number;
-        runningTaskIds: string[];
-    };
+    }>;
 }

package/dist/orchestrator/scheduler.js

@@ -6,7 +6,6 @@ class Scheduler {
     stateManager;
     stateMachine;
     config;
-    runningTasks = new Set();
     constructor(stateManager, config) {
         this.stateManager = stateManager;
         this.stateMachine = new state_machine_js_1.StateMachine();
@@ -16,6 +15,13 @@ class Scheduler {
             ...config
         };
     }
+    /**
+     * 获取当前正在执行的任务数（从持久化状态读取，非内存缓存）
+     */
+    async getRunningCount() {
+        const tasks = await this.stateManager.listTasks();
+        return tasks.filter(t => t.status === 'in_progress' || t.status === 'scheduled').length;
+    }
     /**
      * 获取下一个可执行的任务
      */
@@ -24,7 +30,12 @@ class Scheduler {
         // 检测并处理循环依赖
         await this.handleCircularDependencies(tasks);
         // 筛选可执行任务
-        const executable = tasks.filter(task => this.canExecute(task, tasks));
+        const executable = [];
+        for (const task of tasks) {
+            if (await this.canExecute(task, tasks)) {
+                executable.push(task);
+            }
+        }
         if (executable.length === 0) {
             return null;
         }
@@ -35,13 +46,14 @@ class Scheduler {
     /**
      * 检查任务是否可执行
      */
-    canExecute(task, allTasks) {
+    async canExecute(task, allTasks) {
         // 1. 状态必须是 pending 或 retry_queue
         if (task.status !== 'pending' && task.status !== 'retry_queue') {
             return false;
         }
-        // 2. 检查并发限制
-        if (this.runningTasks.size >= this.config.maxConcurrentTasks) {
+        // 2. 检查并发限制（从持久化状态读取）
+        const runningCount = await this.getRunningCount();
+        if (runningCount >= this.config.maxConcurrentTasks) {
             return false;
         }
         // 3. 检查依赖是否完成
@@ -84,23 +96,39 @@ class Scheduler {
         });
     }
     /**
-     * 标记任务开始执行
+     * 标记任务开始执行（阶段感知，不重置已完成的 phase）
      */
     async markTaskStarted(taskId) {
-        this.runningTasks.add(taskId);
-        await this.transitionTask(taskId, 'start', {
-            phases: {
-                develop: { status: 'in_progress', duration: null, startedAt: new Date().toISOString() },
-                verify: { status: 'pending', duration: null },
-                accept: { status: 'pending', duration: null }
+        const task = await this.stateManager.getTask(taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        const now = new Date().toISOString();
+        // 根据任务当前状态决定设置哪个 phase 为 in_progress
+        let phases = { ...task.phases };
+        if (task.status === 'pending' || task.status === 'retry_queue') {
+            // 首次开始：设置 develop 为 in_progress
+            phases.develop = { status: 'in_progress', duration: null, startedAt: now };
+            if (phases.verify.status === 'pending') {
+                phases.verify = { status: 'pending', duration: null };
             }
-        });
+            if (phases.accept.status === 'pending') {
+                phases.accept = { status: 'pending', duration: null };
+            }
+        }
+        else if (task.status === 'verify') {
+            // develop 已完成，开始 verify 阶段
+            phases.verify = { status: 'in_progress', duration: null, startedAt: now };
+        }
+        else if (task.status === 'accept') {
+            // develop + verify 已完成，开始 accept 阶段
+            phases.accept = { status: 'in_progress', duration: null, startedAt: now };
+        }
+        await this.transitionTask(taskId, 'start', { phases });
     }
     /**
      * 标记任务完成
      */
     async markTaskCompleted(taskId) {
-        this.runningTasks.delete(taskId);
         const task = await this.stateManager.getTask(taskId);
         if (task) {
             await this.transitionTask(taskId, 'accept_done', {
@@ -115,7 +143,6 @@ class Scheduler {
      * 标记任务失败
      */
     async markTaskFailed(taskId, error) {
-        this.runningTasks.delete(taskId);
         const task = await this.stateManager.getTask(taskId);
         const retryCount = task?.retryCount || 0;
         await this.transitionTask(taskId, 'fail', {
@@ -133,7 +160,6 @@ class Scheduler {
      * 标记任务阻塞（需要 Meeting）
      */
     async markTaskBlocked(taskId, reason) {
-        this.runningTasks.delete(taskId);
         await this.transitionTask(taskId, 'block', {
             error: reason
         });
@@ -146,7 +172,12 @@ class Scheduler {
         // 检测并处理循环依赖
         await this.handleCircularDependencies(tasks);
         // 筛选可执行任务
-        const executable = tasks.filter(task => this.canExecute(task, tasks));
+        const executable = [];
+        for (const task of tasks) {
+            if (await this.canExecute(task, tasks)) {
+                executable.push(task);
+            }
+        }
         // 按优先级排序（高优先级优先）
         executable.sort((a, b) => this.getPriorityWeight(b.priority) - this.getPriorityWeight(a.priority));
         // 限制并发数
@@ -208,13 +239,13 @@ class Scheduler {
         }
     }
     /**
-     * 获取调度状态
+     * 获取调度状态（从持久化状态读取）
      */
-    getStatus() {
+    async getStatus() {
+        const running = await this.getRunningCount();
         return {
-            running: this.runningTasks.size,
-            maxConcurrent: this.config.maxConcurrentTasks,
-            runningTaskIds: Array.from(this.runningTasks)
+            running,
+            maxConcurrent: this.config.maxConcurrentTasks
         };
     }
 }

package/dist/orchestrator/state-machine.js

@@ -27,8 +27,8 @@ const TRANSITIONS = [
     { from: 'accept', to: 'failed', event: 'fail' },
     // failed → retry_queue
     { from: 'failed', to: 'retry_queue', event: 'retry' },
-    // retry_queue → pending
-    { from: 'retry_queue', to: 'pending', event: 'retry' },
+    // retry_queue → pending (安全上限 100，由 executor 层控制具体 maxRetries)
+    { from: 'retry_queue', to: 'pending', event: 'retry', condition: (task) => (task.retryCount || 0) < 100 },
     // any → pending (cancel and restart)
     { from: 'scheduled', to: 'pending', event: 'cancel' },
     { from: 'blocked', to: 'pending', event: 'cancel' },

package/dist/orchestrator/task-planner.d.ts

@@ -1,4 +1,32 @@
 import type { ParsedTask, QualityConfig } from '../types/index.js';
+/**
+ * 从 plan 中解析出的结构化模块信息
+ */
+export interface PlanModule {
+    /** 模块名称，如 "用户域" */
+    name: string;
+    /** 模块描述 */
+    description: string;
+    /** 关联的表，如 ["users", "user_profiles"] */
+    tables: string[];
+    /** 模块类型 */
+    type: 'domain' | 'feature' | 'infra' | 'system';
+    /** 依赖的其他模块名称 */
+    dependsOn: string[];
+    /** 预估复杂度 */
+    complexity: 'low' | 'medium' | 'high';
+}
+/**
+ * 从 plan 中解析出的结构化信息
+ */
+export interface ParsedPlan {
+    /** 核心模块列表 */
+    modules: PlanModule[];
+    /** 技术栈摘要 */
+    techStack: string[];
+    /** 原始 plan 文本 */
+    raw: string;
+}
 export interface TaskBreakdown {
     taskId: string;
     title: string;
@@ -19,8 +47,8 @@ export interface UserAnswers {
     additionalContext?: Record<string, string | string[]>;
     /** 是否启用 E2E 测试 */
     e2eTests?: boolean;
-    /** E2E 测试类型 (web/mobile/gui) */
-    e2eType?: 'web' | 'mobile' | 'gui';
+    /** E2E 测试类型 (web/mobile/gui/visual) */
+    e2eType?: 'web' | 'mobile' | 'gui' | 'visual';
     /** 质量级别 */
     qualityLevel?: 'fast' | 'balanced' | 'strict';
 }
@@ -38,16 +66,53 @@ export interface UserAnswers {
  */
 export declare class TaskPlanner {
     private userAnswers;
-    private taskCounter;
+    /** 静态计数器，避免多实例生成重复 ID */
+    private static taskCounter;
     constructor(userAnswers?: UserAnswers);
     /**
      * 设置用户回答
      */
     setUserAnswers(answers: UserAnswers): void;
     /**
-     * Break down a parsed task into sub-tasks
+     * 解析 plan 文本，提取模块、技术栈、数据模型等结构化信息
      */
+    parsePlan(planText: string): ParsedPlan;
+    /**
+     * 分析模块间依赖关系
+     *
+     * 策略：从 plan 文本中提取 AI 明确写的依赖信息，不做架构猜测。
+     * 如果 plan 中没有指定依赖，模块之间并行执行。
+     */
+    private analyzeModuleDependencies;
+    /**
+     * 从 plan 文本中提取某个模块相关的上下文段落
+     */
+    private extractModuleContext;
+    /**
+     * 预估模块复杂度 — 基于通用架构特征，不依赖具体业务领域
+     */
+    private estimateModuleComplexity;
     breakdown(parsedTask: ParsedTask, answers: Record<string, string>, qualityConfig?: QualityConfig, plan?: string): TaskBreakdown[];
+    /**
+     * 基于 plan 解析出的模块做细粒度任务拆分
+     */
+    private breakdownByModules;
+    /**
+     * 为模块任务添加 phase 级别的跨阶段依赖
+     */
+    private enforcePhaseDependenciesForModule;
+    /**
+     * 确定模块任务优先级
+     */
+    private determineModulePriority;
+    /**
+     * 为模块生成验收标准
+     */
+    private generateModuleAcceptanceCriteria;
+    /**
+     * 按目标拆分的传统方式（fallback）
+     */
+    private breakdownByGoals;
     /**
      * 判断是否需要设计阶段
      *
@@ -84,4 +149,18 @@ export declare class TaskPlanner {
      * - other: 其他类型（配置、优化、部署等） → 单个任务
      */
     private classifyGoal;
+    /**
+     * 检测顺序阶段目标（如 "Phase 1 基础架构"、"Phase 2 AI创作核心"）
+     * 返回按阶段排序的索引列表
+     */
+    private detectSequentialPhases;
+    /**
+     * 对顺序阶段建立跨阶段依赖
+     *
+     * 当 goals 包含 "Phase 1", "Phase 2", "Phase 3" 等顺序阶段时，
+     * 后续阶段的所有开发任务必须依赖前一阶段的集成任务（或最后一个开发任务）。
+     *
+     * 这防止多个阶段同时执行导致文件冲突。
+     */
+    private enforcePhaseDependencies;
 }