openmatrix 0.2.15 → 0.2.17

package/dist/orchestrator/executor.d.ts

@@ -4,6 +4,7 @@ import type { SubagentTask } from '../types/index.js';
 import { StateManager } from '../storage/state-manager.js';
 import { ApprovalManager } from './approval-manager.js';
 import { PhaseExecutor } from './phase-executor.js';
+import type { AmbiguityReport } from '../types/index.js';
 export interface ExecutorConfig {
     maxConcurrent: number;
     taskTimeout: number;
@@ -16,7 +17,7 @@ export interface ExecutorStatus {
     waitingApprovals: number;
 }
 export interface ExecutionResult {
-    status: 'continue' | 'waiting_approval' | 'completed' | 'failed';
+    status: 'continue' | 'waiting_approval' | 'completed' | 'failed' | 'ambiguity_ask_user';
     subagentTasks: SubagentTask[];
     message: string;
     statistics: {
@@ -26,6 +27,8 @@ export interface ExecutionResult {
         pending: number;
         failed: number;
     };
+    /** 歧义报告 (仅 status 为 'ambiguity_ask_user' 时存在) */
+    ambiguityReport?: AmbiguityReport;
 }
 /**
  * OrchestratorExecutor - 执行循环核心
@@ -41,6 +44,7 @@ export declare class OrchestratorExecutor {
     private phaseExecutor;
     private retryManager;
     private aiReviewer;
+    private meetingManager;
     private config;
     private taskTimers;
     constructor(stateManager: StateManager, approvalManager: ApprovalManager, config?: Partial<ExecutorConfig>);
@@ -94,7 +98,9 @@ export declare class OrchestratorExecutor {
     /**
      * 标记任务完成
      *
-     * 增强：对于 reviewer 任务，自动解析 Review 报告并生成修复任务
+     * 增强：
+     * 1. 对于 reviewer 任务，自动解析 Review 报告并生成修复任务
+     * 2. 解析歧义报告并根据执行模式处理
      */
     completeTask(taskId: string, result: {
         success: boolean;
@@ -102,6 +108,10 @@ export declare class OrchestratorExecutor {
         error?: string;
     }): Promise<{
         createdFixTasks?: string[];
+        ambiguityResult?: {
+            status: 'ambiguity_ask_user' | 'ambiguity_handled';
+            report: AmbiguityReport;
+        };
     }>;
     /**
      * 处理 Review 结果：解析报告，如有 critical/major 问题则自动创建修复任务
@@ -111,6 +121,26 @@ export declare class OrchestratorExecutor {
      * 获取当前阶段
      */
     private getCurrentPhase;
+    /**
+     * 解析歧义报告
+     *
+     * 从 Agent 输出中提取歧义报告 JSON
+     * 支持多种标记格式：
+     * - <ambiguity_report>...</ambiguity_report>
+     * - AMBIGUITY_REPORT: {...}
+     * - 直接 JSON 块
+     */
+    private parseAmbiguityReport;
+    /**
+     * 处理歧义
+     *
+     * 根据执行模式和严重程度选择处理策略：
+     * - auto 模式：所有歧义写入 Meeting，继续执行
+     * - 其他模式：
+     *   - Critical/High：返回 ambiguity_ask_user 状态，让 Skill 层用 AskUserQuestion 处理
+     *   - Medium/Low：写入 Meeting，继续执行
+     */
+    private handleAmbiguity;
     /**
      * 获取执行器状态
      */

package/dist/orchestrator/executor.js

@@ -8,6 +8,7 @@ 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");
+const meeting_manager_js_1 = require("./meeting-manager.js");
 const logger_js_1 = require("../utils/logger.js");
 /**
  * OrchestratorExecutor - 执行循环核心
@@ -23,11 +24,13 @@ class OrchestratorExecutor {
     phaseExecutor;
     retryManager;
     aiReviewer;
+    meetingManager;
     config;
     taskTimers = new Map();
     constructor(stateManager, approvalManager, config) {
         this.stateManager = stateManager;
         this.approvalManager = approvalManager;
+        this.meetingManager = new meeting_manager_js_1.MeetingManager(stateManager, approvalManager);
         // 从 state.config 读取 taskTimeout，如果未定义则使用默认值
         const stateConfig = stateManager.getState().then(s => s.config).catch(() => null);
         const defaultTaskTimeout = 600000; // 10 分钟（毫秒）
@@ -265,13 +268,25 @@ class OrchestratorExecutor {
     /**
      * 标记任务完成
      *
-     * 增强：对于 reviewer 任务，自动解析 Review 报告并生成修复任务
+     * 增强：
+     * 1. 对于 reviewer 任务，自动解析 Review 报告并生成修复任务
+     * 2. 解析歧义报告并根据执行模式处理
      */
     async completeTask(taskId, result) {
         const task = await this.stateManager.getTask(taskId);
         if (!task) {
             throw new Error(`Task ${taskId} not found`);
         }
+        // 检查输出中是否包含歧义报告（仅匹配 XML 标签作为唯一触发标记）
+        if (result.output?.includes('<ambiguity_report>')) {
+            const ambiguityReport = this.parseAmbiguityReport(taskId, result.output);
+            if (ambiguityReport?.hasAmbiguity) {
+                const ambiguityResult = await this.handleAmbiguity(task, ambiguityReport);
+                if (ambiguityResult) {
+                    return { ambiguityResult };
+                }
+            }
+        }
         if (result.success) {
             // 清除超时计时器
             this.clearTaskTimeout(taskId);
@@ -370,6 +385,109 @@ class OrchestratorExecutor {
             return 'verify';
         return 'accept';
     }
+    // ============ Ambiguity Management ============
+    /**
+     * 解析歧义报告
+     *
+     * 从 Agent 输出中提取歧义报告 JSON
+     * 支持多种标记格式：
+     * - <ambiguity_report>...</ambiguity_report>
+     * - AMBIGUITY_REPORT: {...}
+     * - 直接 JSON 块
+     */
+    parseAmbiguityReport(taskId, output) {
+        try {
+            // 尝试提取 XML 标记格式
+            const xmlMatch = output.match(/<ambiguity_report>([\s\S]*?)<\/ambiguity_report>/);
+            if (xmlMatch) {
+                const jsonStr = xmlMatch[1].trim();
+                const report = JSON.parse(jsonStr);
+                return { ...report, taskId };
+            }
+            // 尝试提取 AMBIGUITY_REPORT: 格式
+            const prefixMatch = output.match(/AMBIGUITY_REPORT:\s*([\s\S]*?)(?:\n\n|\n---|$)/);
+            if (prefixMatch) {
+                const jsonStr = prefixMatch[1].trim();
+                const report = JSON.parse(jsonStr);
+                return { ...report, taskId };
+            }
+            // 尝试查找包含 hasAmbiguity 的 JSON 块（平衡括号匹配，作为最后兜底）
+            const hasAmbiguityIdx = output.indexOf('"hasAmbiguity"');
+            if (hasAmbiguityIdx !== -1) {
+                // 向前扫描找到深度为 1 的最外层 {
+                let start = -1;
+                let depth = 0;
+                for (let i = hasAmbiguityIdx; i >= 0; i--) {
+                    if (output[i] === '}')
+                        depth++;
+                    else if (output[i] === '{') {
+                        depth--;
+                        if (depth < 0) {
+                            start = i;
+                            break;
+                        }
+                    }
+                }
+                if (start !== -1) {
+                    let d = 0;
+                    let end = -1;
+                    for (let i = start; i < output.length; i++) {
+                        if (output[i] === '{')
+                            d++;
+                        else if (output[i] === '}') {
+                            d--;
+                            if (d === 0) {
+                                end = i;
+                                break;
+                            }
+                        }
+                    }
+                    if (end !== -1) {
+                        const report = JSON.parse(output.slice(start, end + 1));
+                        return { ...report, taskId };
+                    }
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn(`⚠️ 解析歧义报告失败: ${taskId}`, error);
+            return null;
+        }
+    }
+    /**
+     * 处理歧义
+     *
+     * 根据执行模式和严重程度选择处理策略：
+     * - auto 模式：所有歧义写入 Meeting，继续执行
+     * - 其他模式：
+     *   - Critical/High：返回 ambiguity_ask_user 状态，让 Skill 层用 AskUserQuestion 处理
+     *   - Medium/Low：写入 Meeting，继续执行
+     */
+    async handleAmbiguity(task, report) {
+        const state = await this.stateManager.getState();
+        const mode = state.config.approvalPoints.length === 0 ? 'auto' : 'interactive';
+        console.log(`🔍 检测到歧义: ${task.id} - 最高严重程度: ${report.maxSeverity || 'unknown'}`);
+        // auto 模式：所有歧义写入 Meeting，继续执行
+        if (mode === 'auto') {
+            await this.meetingManager.createAmbiguityMeeting(task.id, report);
+            console.log(`📝 [auto模式] 歧义已写入 Meeting，继续执行`);
+            return { status: 'ambiguity_handled', report };
+        }
+        // 其他模式：根据严重程度处理
+        const severity = report.maxSeverity;
+        if (severity === 'critical' || severity === 'high') {
+            // Critical/High: 返回特殊状态让 Skill 层用 AskUserQuestion 处理
+            console.log(`⚠️ [interactive模式] Critical/High 歧义，需用户确认`);
+            return { status: 'ambiguity_ask_user', report };
+        }
+        else {
+            // Medium/Low: 写入 Meeting，继续执行
+            await this.meetingManager.createAmbiguityMeeting(task.id, report);
+            console.log(`📝 [interactive模式] Medium/Low 歧义已写入 Meeting，继续执行`);
+            return { status: 'ambiguity_handled', report };
+        }
+    }
     /**
      * 获取执行器状态
      */

package/dist/orchestrator/meeting-manager.d.ts

@@ -1,6 +1,6 @@
 import { StateManager } from '../storage/state-manager.js';
 import { ApprovalManager } from './approval-manager.js';
-import type { Approval, Meeting } from '../types/index.js';
+import type { Approval, Meeting, AmbiguityReport } from '../types/index.js';
 /**
  * MeetingManager - Meeting 管理器
  *
@@ -28,6 +28,21 @@ export declare class MeetingManager {
         meeting: Meeting;
         approval: Approval;
     }>;
+    /**
+     * 获取严重程度对应的图标和标题前缀
+     */
+    private getSeverityPrefix;
+    /**
+     * 格式化歧义报告为 Markdown 描述
+     */
+    private formatAmbiguityReport;
+    /**
+     * 创建歧义 Meeting
+     */
+    createAmbiguityMeeting(taskId: string, ambiguityReport: AmbiguityReport): Promise<{
+        meeting: Meeting;
+        approval: Approval;
+    }>;
     /**
      * 开始 Meeting
      */

package/dist/orchestrator/meeting-manager.js

@@ -104,6 +104,119 @@ ${options.map((opt, i) => `${i + 1}. ${opt}`).join('\n')}
         });
         return { meeting, approval };
     }
+    /**
+     * 获取严重程度对应的图标和标题前缀
+     */
+    getSeverityPrefix(severity) {
+        const prefixes = {
+            critical: '🔴 Critical',
+            high: '🟠 High',
+            medium: '🟡 Medium',
+            low: '🟢 Low'
+        };
+        return prefixes[severity];
+    }
+    /**
+     * 格式化歧义报告为 Markdown 描述
+     */
+    formatAmbiguityReport(report) {
+        const lines = [];
+        lines.push('## 歧义检测结果');
+        lines.push('');
+        lines.push(`**检测阶段**: ${report.detectionPhase === 'pre_execution' ? '执行前' : '执行中'}`);
+        lines.push(`**检测时间**: ${report.detectedAt}`);
+        lines.push(`**歧义数量**: ${report.ambiguities.length}`);
+        if (report.maxSeverity) {
+            lines.push(`**最高严重程度**: ${this.getSeverityPrefix(report.maxSeverity)}`);
+        }
+        lines.push('');
+        lines.push('## 歧义详情');
+        lines.push('');
+        for (const ambiguity of report.ambiguities) {
+            const severityIcon = this.getSeverityPrefix(ambiguity.severity);
+            lines.push(`### ${severityIcon} ${ambiguity.type}`);
+            lines.push('');
+            lines.push(`**描述**: ${ambiguity.description}`);
+            lines.push('');
+            if (ambiguity.impactScope.length > 0) {
+                lines.push('**影响范围**:');
+                for (const scope of ambiguity.impactScope) {
+                    lines.push(`- ${scope}`);
+                }
+                lines.push('');
+            }
+            if (ambiguity.possibleSolutions && ambiguity.possibleSolutions.length > 0) {
+                lines.push('**可能的解决方案**:');
+                for (let i = 0; i < ambiguity.possibleSolutions.length; i++) {
+                    lines.push(`${i + 1}. ${ambiguity.possibleSolutions[i]}`);
+                }
+                lines.push('');
+            }
+            if (ambiguity.relatedFiles && ambiguity.relatedFiles.length > 0) {
+                lines.push(`**相关文件**: ${ambiguity.relatedFiles.join(', ')}`);
+                lines.push('');
+            }
+            if (ambiguity.relatedTaskIds && ambiguity.relatedTaskIds.length > 0) {
+                lines.push(`**相关任务**: ${ambiguity.relatedTaskIds.join(', ')}`);
+                lines.push('');
+            }
+        }
+        if (report.suggestedStrategy) {
+            lines.push('## 建议处理策略');
+            lines.push('');
+            const strategyMap = {
+                ask_immediate: '立即提问 (ask_immediate)',
+                write_meeting: '写入 Meeting (write_meeting)',
+                continue: '继续执行 (continue)'
+            };
+            lines.push(strategyMap[report.suggestedStrategy] || report.suggestedStrategy);
+            lines.push('');
+        }
+        if (report.suggestedQuestions && report.suggestedQuestions.length > 0) {
+            lines.push('## 建议的问题');
+            lines.push('');
+            for (let i = 0; i < report.suggestedQuestions.length; i++) {
+                lines.push(`${i + 1}. ${report.suggestedQuestions[i]}`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * 创建歧义 Meeting
+     */
+    async createAmbiguityMeeting(taskId, ambiguityReport) {
+        const meetingId = `meeting-${Date.now().toString(36)}`;
+        const now = new Date().toISOString();
+        // 根据最高严重程度生成标题
+        const severity = ambiguityReport.maxSeverity || 'medium';
+        const severityPrefix = this.getSeverityPrefix(severity);
+        const titleSummary = ambiguityReport.ambiguities[0]?.description.slice(0, 50) || '歧义检测';
+        const meeting = {
+            id: meetingId,
+            type: 'ambiguity',
+            status: 'pending',
+            taskId,
+            title: `${severityPrefix}: ${titleSummary}...`,
+            description: `任务 ${taskId} 检测到歧义，需要用户确认处理方式`,
+            impactScope: ambiguityReport.ambiguities.flatMap(a => a.impactScope),
+            participants: ['user'],
+            createdAt: now,
+            ambiguityReport,
+            suggestedQuestions: ambiguityReport.suggestedQuestions
+        };
+        // 保存 Meeting
+        await this.stateManager.saveMeeting(meeting);
+        // 创建审批
+        const approval = await this.approvalManager.createApproval({
+            type: 'meeting',
+            taskId,
+            title: meeting.title,
+            description: this.formatAmbiguityReport(ambiguityReport),
+            content: JSON.stringify({ meetingId, ambiguityReport })
+        });
+        return { meeting, approval };
+    }
     /**
      * 开始 Meeting
      */

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

@@ -93,6 +93,7 @@ export declare class PhaseExecutor {
      * 设置自动模式
      */
     setAutoMode(auto: boolean): void;
+    disableGitCommit(): void;
     /**
      * 获取自动模式状态
      */

package/dist/orchestrator/phase-executor.js

@@ -55,6 +55,9 @@ class PhaseExecutor {
     setAutoMode(auto) {
         this.isAutoMode = auto;
     }
+    disableGitCommit() {
+        this.gitCommitManager.setEnabled(false);
+    }
     /**
      * 获取自动模式状态
      */

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

@@ -58,9 +58,14 @@ class SmartQuestionAnalyzer {
     async analyze(taskDescription, parsedTask) {
         // 1. 获取项目上下文
         const projectContext = await this.getProjectContext();
-        // 2. 执行推断
-        const inferences = this.inferAnswers(taskDescription, projectContext);
-        // 3. 筛选需要提问的问题
+        // 2. 如果 parsedTask 有 goalTypes，优先使用
+        let goalTypeOverride;
+        if (parsedTask?.goalTypes && parsedTask.goalTypes.length > 0) {
+            goalTypeOverride = parsedTask.goalTypes[0];
+        }
+        // 3. 执行推断
+        const inferences = this.inferAnswers(taskDescription, projectContext, goalTypeOverride);
+        // 4. 筛选需要提问的问题
         const questionsToAsk = inferences
             .filter(i => i.confidence === 'low' || !i.inferredAnswer)
             .map(i => i.questionId);
@@ -163,7 +168,7 @@ class SmartQuestionAnalyzer {
     /**
      * 推断问题答案
      */
-    inferAnswers(taskDescription, context) {
+    inferAnswers(taskDescription, context, goalTypeOverride) {
         const inferences = [];
         const desc = taskDescription.toLowerCase();
         // 1. 推断质量级别
@@ -180,6 +185,15 @@ class SmartQuestionAnalyzer {
         inferences.push(this.inferObjective(desc, context));
         // 7. 推断测试覆盖率级别
         inferences.push(this.inferTestCoverage(desc, context));
+        // 8. 如果有 goalTypeOverride，覆盖 objective 推断
+        if (goalTypeOverride) {
+            const objectiveInference = inferences.find(i => i.questionId === 'objective');
+            if (objectiveInference) {
+                objectiveInference.inferredAnswer = goalTypeOverride;
+                objectiveInference.confidence = 'high';
+                objectiveInference.reason = '来自 AI 任务解析的目标类型标注';
+            }
+        }
         return inferences;
     }
     /**
@@ -336,6 +350,13 @@ class SmartQuestionAnalyzer {
             confidence: 'low',
             reason: ''
         };
+        // 文档/skill 文件 -> 不需要 E2E
+        if (/(skill|\.md|文档|readme|document|说明|指南)/i.test(desc)) {
+            inference.inferredAnswer = 'false';
+            inference.confidence = 'high';
+            inference.reason = '文档或 skill 文件修改不需要 E2E 测试';
+            return inference;
+        }
         // CLI/后端 -> 不需要 E2E
         if (/(cli|api|backend|后端|命令行)/i.test(desc) && !context.hasFrontend) {
             inference.inferredAnswer = 'false';
@@ -397,23 +418,30 @@ class SmartQuestionAnalyzer {
             confidence: 'low',
             reason: ''
         };
+        // 文档类任务 -> documentation
+        if (/(文档|document|readme|skill|\.md|说明|指南)/i.test(desc)) {
+            inference.inferredAnswer = 'documentation';
+            inference.confidence = 'high';
+            inference.reason = '任务涉及文档或 skill 文件';
+            return inference;
+        }
         if (/(fix|bug|修复|hotfix|patch)/i.test(desc)) {
-            inference.inferredAnswer = 'bug_fix';
+            inference.inferredAnswer = 'development';
             inference.confidence = 'medium';
-            inference.reason = '任务描述包含修复关键词';
+            inference.reason = '任务描述包含修复关键词（bug 修复属于开发）';
         }
         else if (/(implement|add|新功能|实现|开发|feature|新增)/i.test(desc)) {
-            inference.inferredAnswer = 'new_feature';
+            inference.inferredAnswer = 'development';
             inference.confidence = 'medium';
             inference.reason = '任务描述包含新功能关键词';
         }
         else if (/(refactor|优化|重构|improve|性能)/i.test(desc)) {
-            inference.inferredAnswer = 'refactor';
+            inference.inferredAnswer = 'development';
             inference.confidence = 'medium';
-            inference.reason = '任务描述包含重构关键词';
+            inference.reason = '任务描述包含重构关键词（重构属于开发）';
         }
         else if (/(test|测试|coverage|覆盖)/i.test(desc)) {
-            inference.inferredAnswer = 'test';
+            inference.inferredAnswer = 'testing';
             inference.confidence = 'medium';
             inference.reason = '任务描述包含测试关键词';
         }

package/dist/orchestrator/task-planner.js

@@ -390,6 +390,8 @@ class TaskPlanner {
         }
         const coverageTarget = this.getCoverageTarget(qualityConfig, userContext);
         const globalContext = this.buildGlobalContext(parsedTask, userContext, plan);
+        // 提取 planMetadata 用于测试任务描述注入
+        const planMetadata = this.extractPlanMetadata(plan);
         // 1. 为每个模块创建开发 + 测试任务对
         const devTaskIds = [];
         const moduleIdToTaskIds = new Map();
@@ -434,7 +436,7 @@ class TaskPlanner {
             breakdowns.push({
                 taskId: testTaskId,
                 title: `测试: ${mod.name}`,
-                description: `## 测试目标\n为 "${mod.name}" 模块编写测试用例\n\n${globalContext}\n\n## 关联开发任务\n${modTaskId}\n\n## 测试要求\n- 单元测试覆盖率 >= ${coverageTarget}%\n- 测试正常流程\n- 测试边界情况\n- 测试异常处理\n\n## 输出\n- 测试文件\n- 测试报告\n- 覆盖率报告`,
+                description: this.buildTestDescription(mod.name, modTaskId, coverageTarget, globalContext, planMetadata),
                 priority: this.determineModulePriority(mod, parsedPlan.modules.indexOf(mod)),
                 dependencies: [modTaskId],
                 estimatedComplexity: 'medium',
@@ -757,7 +759,7 @@ ${globalContext}
                 breakdowns.push({
                     taskId: testTaskId,
                     title: `测试: ${goal}`,
-                    description: this.buildTestDescription(goal, devTaskId, coverageTarget, globalContext),
+                    description: this.buildTestDescription(goal, devTaskId, coverageTarget, globalContext, planMetadata),
                     priority: this.determinePriority(i),
                     dependencies: [devTaskId],
                     estimatedComplexity: 'medium',
@@ -1104,16 +1106,25 @@ ${userContext.documentationLevel}
 - 添加必要注释`;
         return desc;
     }
-    buildTestDescription(goal, devTaskId, coverageTarget, globalContext) {
-        return `## 测试目标
+    buildTestDescription(goal, devTaskId, coverageTarget, globalContext, planMetadata) {
+        let desc = `## 测试目标
 为 "${goal}" 编写测试用例
 
 ${globalContext}
 
 ## 关联开发任务
-${devTaskId}
-
-## 测试要求
+${devTaskId}`;
+        // 注入 plan 提取的关键信息（参考 buildTaskDescription）
+        if (planMetadata && planMetadata.interfaces.length > 0) {
+            desc += `\n\n## 相关接口/API\n${planMetadata.interfaces.slice(0, 10).map(i => `- ${i}`).join('\n')}`;
+        }
+        if (planMetadata && planMetadata.dataModels.length > 0) {
+            desc += `\n\n## 相关数据模型\n${planMetadata.dataModels.slice(0, 10).map(d => `- ${d}`).join('\n')}`;
+        }
+        if (planMetadata && planMetadata.keyDecisions.length > 0) {
+            desc += `\n\n## 关键决策参考\n${planMetadata.keyDecisions.slice(0, 5).map(d => `- ${d}`).join('\n')}`;
+        }
+        desc += `\n\n## 测试要求
 - 单元测试覆盖率 >= ${coverageTarget}%
 - 测试正常流程
 - 测试边界情况
@@ -1127,6 +1138,7 @@ ${devTaskId}
 - 测试文件
 - 测试报告
 - 覆盖率报告`;
+        return desc;
     }
     buildE2ETestDescription(e2eType, parsedTask, userContext) {
         const typeConfig = this.getE2ETypeConfig(e2eType);