openmatrix 0.1.61 → 0.1.63

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

@@ -193,18 +193,18 @@ class InteractiveQuestionGenerator {
      */
     generateBaseQuestions(task) {
         const questions = [];
-        // 1. 核心目标
+        // 1. 任务目标
         questions.push({
             id: 'objective',
-            question: '这个任务的主要目标是什么？',
+            question: '这个任务的核心目标是什么？想要解决什么问题？',
             type: 'single',
             required: true,
             category: 'objective',
             priority: 1,
             options: [
-                { key: 'new_feature', label: '实现新功能', description: '添加新的功能特性' },
-                { key: 'bug_fix', label: '修复 Bug', description: '修复已知问题' },
-                { key: 'refactor', label: '重构优化', description: '改进代码结构或性能' },
+                { key: 'new_feature', label: '实现新功能', description: '添加新的功能特性，扩展系统能力' },
+                { key: 'bug_fix', label: '修复问题', description: '修复 Bug 或解决已知问题' },
+                { key: 'refactor', label: '重构优化', description: '改进代码结构、性能或可维护性' },
                 { key: 'other', label: '其他', description: '其他类型任务' }
             ],
             followUpCondition: {
@@ -221,14 +221,28 @@ class InteractiveQuestionGenerator {
                 ]
             }
         });
-        // 2. 技术栈
+        // 2. 质量级别
+        questions.push({
+            id: 'quality_level',
+            question: '选择质量门禁级别（决定测试覆盖、Lint、安全扫描等要求）',
+            type: 'single',
+            required: true,
+            category: 'quality',
+            priority: 2,
+            options: [
+                { key: 'strict', label: 'strict', description: 'TDD + 80% 覆盖率 + 严格 Lint + 安全扫描 — 生产级代码' },
+                { key: 'balanced', label: 'balanced (推荐)', description: '60% 覆盖率 + Lint + 安全扫描 — 日常开发' },
+                { key: 'fast', label: 'fast', description: '无质量门禁 — 快速原型/验证' }
+            ]
+        });
+        // 3. 技术栈
         questions.push({
             id: 'tech_stack',
             question: '使用什么技术栈？',
             type: 'multiple',
             required: true,
             category: 'technical',
-            priority: 2,
+            priority: 3,
             options: [
                 { key: 'typescript', label: 'TypeScript', description: '类型安全的 JavaScript' },
                 { key: 'javascript', label: 'JavaScript', description: '标准 JavaScript' },
@@ -247,64 +261,33 @@ class InteractiveQuestionGenerator {
                         type: 'text',
                         required: true,
                         category: 'technical',
-                        priority: 2.5
+                        priority: 3.5
                     }
                 ]
             }
         });
-        // 3. 数据存储
-        questions.push({
-            id: 'data_storage',
-            question: '需要什么类型的存储？',
-            type: 'single',
-            required: true,
-            category: 'technical',
-            priority: 3,
-            options: [
-                { key: 'postgresql', label: 'PostgreSQL', description: '关系型数据库' },
-                { key: 'mongodb', label: 'MongoDB', description: '文档数据库' },
-                { key: 'sqlite', label: 'SQLite', description: '本地数据库' },
-                { key: 'none', label: '无需存储', description: '不需要数据持久化' }
-            ]
-        });
-        // 4. 认证方式
+        // 4. 执行模式
         questions.push({
-            id: 'auth_method',
-            question: '需要用户认证吗？',
+            id: 'execution_mode',
+            question: '选择执行模式（控制 AI 执行过程中的审批节点）',
             type: 'single',
             required: true,
-            category: 'technical',
+            category: 'quality',
             priority: 4,
             options: [
-                { key: 'jwt', label: 'JWT Token', description: '无状态认证' },
-                { key: 'oauth', label: 'OAuth 2.0', description: '第三方授权' },
-                { key: 'session', label: 'Session Cookie', description: '传统会话' },
-                { key: 'none', label: '无需认证', description: '无用户系统' }
+                { key: 'auto', label: 'auto (推荐)', description: '全自动执行，无需人工审批，遇到阻塞自动 Meeting' },
+                { key: 'confirm-key', label: 'confirm-key', description: '关键节点审批（计划、合并、部署）' },
+                { key: 'confirm-all', label: 'confirm-all', description: '每个阶段都需人工确认' }
             ]
         });
-        // 5. API 风格
-        questions.push({
-            id: 'api_style',
-            question: 'API 采用什么风格？',
-            type: 'single',
-            required: true,
-            category: 'technical',
-            priority: 5,
-            options: [
-                { key: 'rest', label: 'RESTful', description: 'REST API' },
-                { key: 'graphql', label: 'GraphQL', description: 'GraphQL API' },
-                { key: 'grpc', label: 'gRPC', description: '高性能 RPC' },
-                { key: 'mixed', label: '混合', description: '多种风格混合' }
-            ]
-        });
-        // 6. 测试要求
+        // 5. 测试覆盖率
         questions.push({
             id: 'test_coverage',
             question: '测试覆盖率要求？',
             type: 'single',
             required: true,
             category: 'quality',
-            priority: 6,
+            priority: 5,
             options: [
                 { key: 'high', label: '>80% (严格)', description: '完整单元测试和集成测试' },
                 { key: 'medium', label: '>60% (标准)', description: '核心功能测试' },
@@ -312,14 +295,14 @@ class InteractiveQuestionGenerator {
                 { key: 'none', label: '无要求', description: '不需要测试' }
             ]
         });
-        // 7. 文档要求
+        // 6. 文档要求
         questions.push({
-            id: 'doc_level',
+            id: 'documentation_level',
             question: '需要什么级别的文档？',
             type: 'single',
             required: true,
             category: 'quality',
-            priority: 7,
+            priority: 6,
             options: [
                 { key: 'full', label: '完整文档', description: 'API + 使用指南 + 架构' },
                 { key: 'basic', label: '基础文档', description: 'README + API' },
@@ -327,6 +310,49 @@ class InteractiveQuestionGenerator {
                 { key: 'none', label: '无需文档', description: '不生成文档' }
             ]
         });
+        // 7. E2E 测试
+        questions.push({
+            id: 'e2e_tests',
+            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: '仅进行单元测试和集成测试，节省时间' }
+            ]
+        });
+        // 8. 风险评估
+        questions.push({
+            id: 'risks',
+            question: '这个任务可能面临哪些风险或挑战？',
+            type: 'multiple',
+            required: true,
+            category: 'risk',
+            priority: 8,
+            options: [
+                { key: 'technical', label: '技术风险', description: '技术实现存在不确定性' },
+                { key: 'time', label: '时间风险', description: '需要在短时间内完成' },
+                { key: 'compatibility', label: '兼容性风险', description: '可能影响现有功能' },
+                { key: 'none', label: '无明显风险', description: '任务清晰，风险可控' }
+            ]
+        });
+        // 9. 验收标准
+        questions.push({
+            id: 'acceptance',
+            question: '如何判断任务完成？有哪些验收标准？',
+            type: 'multiple',
+            required: true,
+            category: 'scope',
+            priority: 9,
+            options: [
+                { key: 'functional', label: '功能完整', description: '所有功能按预期工作' },
+                { key: 'tested', label: '测试覆盖', description: '有足够的测试覆盖' },
+                { key: 'performance', label: '性能达标', description: '满足性能要求' },
+                { key: 'documented', label: '文档完善', description: '有完整的使用文档' }
+            ]
+        });
         return questions;
     }
     /**

package/dist/orchestrator/scheduler.d.ts

@@ -12,6 +12,7 @@ export interface TaskAssignment {
 }
 export declare class Scheduler {
     private stateManager;
+    private stateMachine;
     private config;
     private runningTasks;
     constructor(stateManager: StateManager, config?: Partial<SchedulerConfig>);
@@ -27,6 +28,10 @@ export declare class Scheduler {
      * 获取优先级权重
      */
     private getPriorityWeight;
+    /**
+     * 通过状态机验证并执行状态转换
+     */
+    private transitionTask;
     /**
      * 标记任务开始执行
      */
@@ -48,9 +53,18 @@ export declare class Scheduler {
      */
     markTaskBlocked(taskId: string, reason: string): Promise<void>;
     /**
-     * 获取所有可并行执行的任务
+     * 获取所有可并行执行的任务（按优先级排序）
      */
     getParallelTasks(): Promise<Task[]>;
+    /**
+     * 检测循环依赖（DFS）
+     * 返回所有检测到的循环路径
+     */
+    detectCircularDependencies(tasks: Task[]): string[][];
+    /**
+     * 检测循环依赖并将相关任务标记为 blocked
+     */
+    private handleCircularDependencies;
     /**
      * 获取调度状态
      */

package/dist/orchestrator/scheduler.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Scheduler = void 0;
+const state_machine_js_1 = require("./state-machine.js");
 class Scheduler {
     stateManager;
+    stateMachine;
     config;
     runningTasks = new Set();
     constructor(stateManager, config) {
         this.stateManager = stateManager;
+        this.stateMachine = new state_machine_js_1.StateMachine();
         this.config = {
             maxConcurrentTasks: 3,
             taskTimeout: 120000,
@@ -18,6 +21,8 @@ class Scheduler {
      */
     async getNextTask() {
         const tasks = await this.stateManager.listTasks();
+        // 检测并处理循环依赖
+        await this.handleCircularDependencies(tasks);
         // 筛选可执行任务
         const executable = tasks.filter(task => this.canExecute(task, tasks));
         if (executable.length === 0) {
@@ -62,13 +67,28 @@ class Scheduler {
         };
         return weights[priority] || 0;
     }
+    /**
+     * 通过状态机验证并执行状态转换
+     */
+    async transitionTask(taskId, event, extraUpdates) {
+        const task = await this.stateManager.getTask(taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        const result = this.stateMachine.transition(task, event);
+        if (!result.success) {
+            throw new Error(`状态转换失败 [${task.id}]: ${result.error}`);
+        }
+        await this.stateManager.updateTask(taskId, {
+            status: result.toStatus,
+            ...extraUpdates
+        });
+    }
     /**
      * 标记任务开始执行
      */
     async markTaskStarted(taskId) {
         this.runningTasks.add(taskId);
-        await this.stateManager.updateTask(taskId, {
-            status: 'in_progress',
+        await this.transitionTask(taskId, 'start', {
             phases: {
                 develop: { status: 'in_progress', duration: null, startedAt: new Date().toISOString() },
                 verify: { status: 'pending', duration: null },
@@ -83,8 +103,7 @@ class Scheduler {
         this.runningTasks.delete(taskId);
         const task = await this.stateManager.getTask(taskId);
         if (task) {
-            await this.stateManager.updateTask(taskId, {
-                status: 'completed',
+            await this.transitionTask(taskId, 'accept_done', {
                 phases: {
                     ...task.phases,
                     accept: { status: 'completed', duration: 0, completedAt: new Date().toISOString() }
@@ -97,42 +116,96 @@ class Scheduler {
      */
     async markTaskFailed(taskId, error) {
         this.runningTasks.delete(taskId);
-        await this.stateManager.updateTask(taskId, {
-            status: 'failed',
+        const task = await this.stateManager.getTask(taskId);
+        const retryCount = task?.retryCount || 0;
+        await this.transitionTask(taskId, 'fail', {
             error,
-            retryCount: (await this.stateManager.getTask(taskId))?.retryCount || 0
+            retryCount
         });
     }
     /**
      * 标记任务等待确认
      */
     async markTaskWaiting(taskId) {
-        await this.stateManager.updateTask(taskId, {
-            status: 'waiting'
-        });
+        await this.transitionTask(taskId, 'wait');
     }
     /**
      * 标记任务阻塞（需要 Meeting）
      */
     async markTaskBlocked(taskId, reason) {
         this.runningTasks.delete(taskId);
-        await this.stateManager.updateTask(taskId, {
-            status: 'blocked',
+        await this.transitionTask(taskId, 'block', {
             error: reason
         });
     }
     /**
-     * 获取所有可并行执行的任务
+     * 获取所有可并行执行的任务（按优先级排序）
      */
     async getParallelTasks() {
         const tasks = await this.stateManager.listTasks();
-        const available = [];
+        // 检测并处理循环依赖
+        await this.handleCircularDependencies(tasks);
+        // 筛选可执行任务
+        const executable = tasks.filter(task => this.canExecute(task, tasks));
+        // 按优先级排序（高优先级优先）
+        executable.sort((a, b) => this.getPriorityWeight(b.priority) - this.getPriorityWeight(a.priority));
+        // 限制并发数
+        return executable.slice(0, this.config.maxConcurrentTasks);
+    }
+    /**
+     * 检测循环依赖（DFS）
+     * 返回所有检测到的循环路径
+     */
+    detectCircularDependencies(tasks) {
+        const cycles = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const dfs = (taskId, path) => {
+            visited.add(taskId);
+            recursionStack.add(taskId);
+            const task = tasks.find(t => t.id === taskId);
+            if (!task || !task.dependencies) {
+                recursionStack.delete(taskId);
+                return;
+            }
+            for (const depId of task.dependencies) {
+                if (!visited.has(depId)) {
+                    dfs(depId, [...path, depId]);
+                }
+                else if (recursionStack.has(depId)) {
+                    // 找到循环
+                    const cycleStart = path.indexOf(depId);
+                    const cycle = cycleStart >= 0
+                        ? [...path.slice(cycleStart), depId]
+                        : [taskId, depId];
+                    cycles.push(cycle);
+                }
+            }
+            recursionStack.delete(taskId);
+        };
         for (const task of tasks) {
-            if (this.canExecute(task, tasks) && available.length < this.config.maxConcurrentTasks) {
-                available.push(task);
+            if (!visited.has(task.id)) {
+                dfs(task.id, [task.id]);
+            }
+        }
+        return cycles;
+    }
+    /**
+     * 检测循环依赖并将相关任务标记为 blocked
+     */
+    async handleCircularDependencies(tasks) {
+        const cycles = this.detectCircularDependencies(tasks);
+        for (const cycle of cycles) {
+            for (const taskId of cycle) {
+                const task = tasks.find(t => t.id === taskId);
+                if (task && (task.status === 'pending' || task.status === 'retry_queue')) {
+                    await this.stateManager.updateTask(taskId, {
+                        status: 'blocked',
+                        error: `循环依赖检测: ${cycle.join(' → ')}`
+                    });
+                }
             }
         }
-        return available;
     }
     /**
      * 获取调度状态

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

@@ -75,6 +75,14 @@ export declare class SmartQuestionAnalyzer {
      * 推断执行模式
      */
     private inferExecutionMode;
+    /**
+     * 推断任务目标类型
+     */
+    private inferObjective;
+    /**
+     * 推断测试覆盖率级别
+     */
+    private inferTestCoverage;
     /**
      * 生成推断摘要
      */

package/dist/orchestrator/smart-question-analyzer.js

@@ -176,6 +176,10 @@ class SmartQuestionAnalyzer {
         inferences.push(this.inferE2ETest(desc, context));
         // 5. 推断执行模式
         inferences.push(this.inferExecutionMode(desc, context));
+        // 6. 推断任务目标类型
+        inferences.push(this.inferObjective(desc, context));
+        // 7. 推断测试覆盖率级别
+        inferences.push(this.inferTestCoverage(desc, context));
         return inferences;
     }
     /**
@@ -384,6 +388,74 @@ class SmartQuestionAnalyzer {
         inference.reason = '无法确定执行模式';
         return inference;
     }
+    /**
+     * 推断任务目标类型
+     */
+    inferObjective(desc, context) {
+        const inference = {
+            questionId: 'objective',
+            confidence: 'low',
+            reason: ''
+        };
+        if (/(fix|bug|修复|hotfix|patch)/i.test(desc)) {
+            inference.inferredAnswer = 'bug_fix';
+            inference.confidence = 'medium';
+            inference.reason = '任务描述包含修复关键词';
+        }
+        else if (/(implement|add|新功能|实现|开发|feature|新增)/i.test(desc)) {
+            inference.inferredAnswer = 'new_feature';
+            inference.confidence = 'medium';
+            inference.reason = '任务描述包含新功能关键词';
+        }
+        else if (/(refactor|优化|重构|improve|性能)/i.test(desc)) {
+            inference.inferredAnswer = 'refactor';
+            inference.confidence = 'medium';
+            inference.reason = '任务描述包含重构关键词';
+        }
+        else if (/(test|测试|coverage|覆盖)/i.test(desc)) {
+            inference.inferredAnswer = 'test';
+            inference.confidence = 'medium';
+            inference.reason = '任务描述包含测试关键词';
+        }
+        else {
+            inference.reason = '无法确定任务目标类型';
+        }
+        return inference;
+    }
+    /**
+     * 推断测试覆盖率级别
+     */
+    inferTestCoverage(desc, context) {
+        const inference = {
+            questionId: 'test_coverage',
+            confidence: 'low',
+            reason: ''
+        };
+        if (context.hasTests && /(test|测试)/i.test(desc)) {
+            inference.inferredAnswer = 'high';
+            inference.confidence = 'medium';
+            inference.reason = '项目已有测试，且任务涉及测试';
+        }
+        else if (/(implement|add|新功能|实现|feature)/i.test(desc)) {
+            inference.inferredAnswer = 'medium';
+            inference.confidence = 'low';
+            inference.reason = '新功能任务，中等测试覆盖率';
+        }
+        else if (/(fix|bug|修复)/i.test(desc)) {
+            inference.inferredAnswer = 'low';
+            inference.confidence = 'medium';
+            inference.reason = 'Bug 修复，需要回归测试但覆盖率要求不高';
+        }
+        else if (/(prototype|poc|demo|快速|原型)/i.test(desc)) {
+            inference.inferredAnswer = 'none';
+            inference.confidence = 'medium';
+            inference.reason = '原型任务，不需要测试';
+        }
+        else {
+            inference.reason = '无法确定测试覆盖率级别';
+        }
+        return inference;
+    }
     /**
      * 生成推断摘要
      */

package/dist/orchestrator/state-machine.js

@@ -7,6 +7,8 @@ const TRANSITIONS = [
     { from: 'pending', to: 'scheduled', event: 'schedule' },
     // scheduled → in_progress
     { from: 'scheduled', to: 'in_progress', event: 'start' },
+    // pending → in_progress (跳过 scheduled，直接开始)
+    { from: 'pending', to: 'in_progress', event: 'start' },
     // in_progress → verify
     { from: 'in_progress', to: 'verify', event: 'develop_done' },
     // verify → accept

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

@@ -16,7 +16,7 @@ export interface UserAnswers {
     techStack?: string[];
     testCoverage?: string;
     documentationLevel?: string;
-    additionalContext?: Record<string, string>;
+    additionalContext?: Record<string, string | string[]>;
     /** 是否启用 E2E 测试 */
     e2eTests?: boolean;
     /** E2E 测试类型 (web/mobile/gui) */

package/dist/orchestrator/task-planner.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskPlanner = void 0;
+const answer_mapper_js_1 = require("./answer-mapper.js");
 /**
  * TaskPlanner - 任务拆解器
  *
@@ -261,16 +262,21 @@ ${userContext.documentationLevel}
      * 提取用户上下文
      */
     extractUserContext(answers) {
-        const e2eAnswer = answers['E2E测试'] || answers['e2eTests'] || answers['e2e'];
-        const e2eTypeAnswer = answers['E2E类型'] || answers['e2eType'];
+        // 先翻译 brainstorm 规范键为 planner 期望的键
+        const translated = (0, answer_mapper_js_1.translateBrainstormAnswers)(answers);
+        const merged = { ...answers, ...translated };
+        // 辅助函数：提取字符串值（处理 string[] 情况）
+        const str = (v) => Array.isArray(v) ? v.join(', ') : v;
+        const e2eAnswer = str(merged['E2E测试'] || merged['e2eTests'] || merged['e2e']);
+        const e2eTypeAnswer = str(merged['E2E类型'] || merged['e2eType']);
         return {
-            objective: answers['目标'] || answers['objective'],
-            techStack: this.parseArrayAnswer(answers['技术栈'] || answers['techStack']),
-            testCoverage: answers['测试'] || answers['testCoverage'],
-            documentationLevel: answers['文档'] || answers['documentationLevel'],
+            objective: str(merged['目标'] || merged['objective']),
+            techStack: this.parseArrayAnswer(str(merged['技术栈'] || merged['techStack']) || ''),
+            testCoverage: str(merged['测试'] || merged['testCoverage']),
+            documentationLevel: str(merged['文档'] || merged['documentationLevel']),
             e2eTests: e2eAnswer === 'true' || e2eAnswer === '✅ 启用 E2E 测试' || e2eAnswer === '是',
             e2eType: e2eTypeAnswer || 'web',
-            additionalContext: answers
+            additionalContext: merged
         };
     }
     parseArrayAnswer(answer) {

package/dist/storage/state-manager.d.ts

@@ -2,7 +2,12 @@ import type { GlobalState, Task, Approval, ApprovalStatus } from '../types/index
 export declare class StateManager {
     private store;
     private stateCache;
+    private writeLock;
     constructor(basePath: string);
+    /**
+     * 串行化异步写操作，防止并发 read-modify-write 竞态
+     */
+    private withLock;
     initialize(): Promise<void>;
     getState(): Promise<GlobalState>;
     updateState(updates: Partial<GlobalState>): Promise<void>;