openmatrix 0.1.49 → 0.1.50

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

@@ -58,11 +58,9 @@ class SmartQuestionAnalyzer {
     async analyze(taskDescription, parsedTask) {
         // 1. 获取项目上下文
         const projectContext = await this.getProjectContext();
-        // 2. 分析任务理解
-        const understanding = this.analyzeTaskUnderstanding(taskDescription, projectContext);
-        // 3. 执行推断
+        // 2. 执行推断
         const inferences = this.inferAnswers(taskDescription, projectContext);
-        // 4. 筛选需要提问的问题
+        // 3. 筛选需要提问的问题
         const questionsToAsk = inferences
             .filter(i => i.confidence === 'low' || !i.inferredAnswer)
             .map(i => i.questionId);
@@ -70,7 +68,6 @@ class SmartQuestionAnalyzer {
             .filter(i => i.confidence !== 'low' && i.inferredAnswer)
             .map(i => i.questionId);
         return {
-            understanding,
             inferences,
             questionsToAsk,
             skippedQuestions,
@@ -163,199 +160,6 @@ class SmartQuestionAnalyzer {
         this.cachedContext = context;
         return context;
     }
-    /**
-     * 分析任务理解
-     */
-    analyzeTaskUnderstanding(taskDescription, context) {
-        const desc = taskDescription.toLowerCase();
-        // 1. 判断任务类型
-        const taskType = this.detectTaskType(desc);
-        // 2. 判断影响范围
-        const scope = this.detectScope(desc, context);
-        // 3. 判断复杂度
-        const complexity = this.detectComplexity(desc, taskType, scope);
-        // 4. 生成建议
-        const suggestions = this.generateSuggestions(taskType, complexity, desc);
-        return {
-            taskType: taskType.type,
-            taskTypeLabel: taskType.label,
-            scope: scope.areas,
-            scopeLabel: scope.label,
-            complexity: complexity.level,
-            complexityLabel: complexity.label,
-            estimatedCommits: complexity.estimatedCommits,
-            suggestions
-        };
-    }
-    /**
-     * 检测任务类型
-     */
-    detectTaskType(desc) {
-        // Bug 修复
-        if (/(fix|bug|修复|hotfix|patch|问题|报错|错误|异常)/i.test(desc)) {
-            return { type: 'bugfix', label: 'Bug 修复' };
-        }
-        // 重构
-        if (/(refactor|重构|优化|improve|改进)/i.test(desc)) {
-            return { type: 'refactor', label: '重构优化' };
-        }
-        // 文档
-        if (/(doc|文档|readme|文档|注释)/i.test(desc)) {
-            return { type: 'docs', label: '文档编写' };
-        }
-        // 测试
-        if (/(test|测试|单元|unit|coverage|覆盖率)/i.test(desc)) {
-            return { type: 'test', label: '测试编写' };
-        }
-        // 配置
-        if (/(config|配置|设置|setup|初始化)/i.test(desc)) {
-            return { type: 'config', label: '配置修改' };
-        }
-        // 新功能 (默认)
-        if (/(implement|add|新功能|实现|开发|feature|添加|创建)/i.test(desc)) {
-            return { type: 'feature', label: '新功能开发' };
-        }
-        return { type: 'unknown', label: '待确认' };
-    }
-    /**
-     * 检测影响范围
-     */
-    detectScope(desc, context) {
-        const areas = [];
-        // 从描述中检测
-        if (/(前端|页面|ui|样式|css|html|react|vue|component)/i.test(desc)) {
-            areas.push('前端');
-        }
-        if (/(后端|api|服务|server|接口|数据库|database)/i.test(desc)) {
-            areas.push('后端');
-        }
-        if (/(cli|命令行|终端|terminal)/i.test(desc)) {
-            areas.push('CLI');
-        }
-        if (/(测试|test|spec)/i.test(desc)) {
-            areas.push('测试');
-        }
-        if (/(文档|doc|readme)/i.test(desc)) {
-            areas.push('文档');
-        }
-        if (/(配置|config)/i.test(desc)) {
-            areas.push('配置');
-        }
-        // 从项目上下文补充
-        if (areas.length === 0) {
-            if (context.hasFrontend)
-                areas.push('前端');
-            if (context.hasBackend)
-                areas.push('后端');
-        }
-        // 默认
-        if (areas.length === 0) {
-            areas.push('代码');
-        }
-        const label = areas.join('、');
-        return { areas, label };
-    }
-    /**
-     * 检测复杂度
-     */
-    detectComplexity(desc, taskType, scope) {
-        // 简单任务关键词
-        const simpleKeywords = /(fix|bug|修复|改|调整|样式|变量名|文案|按钮|颜色|字体)/i;
-        // 复杂任务关键词 - 需要更精确
-        const complexKeywords = /(系统|架构|集成|完整|从零|优化整体|多模块|全栈)/i;
-        const multiScope = scope.areas.length >= 3;
-        // Bug 修复
-        if (taskType.type === 'bugfix') {
-            if (simpleKeywords.test(desc) || desc.length < 50) {
-                return { level: 'simple', label: '简单', estimatedCommits: '预计 1 个 commit' };
-            }
-            return { level: 'medium', label: '中等', estimatedCommits: '预计 1-2 个 commit' };
-        }
-        // 文档、配置
-        if (taskType.type === 'docs' || taskType.type === 'config') {
-            return { level: 'simple', label: '简单', estimatedCommits: '预计 1 个 commit' };
-        }
-        // 测试
-        if (taskType.type === 'test') {
-            if (multiScope) {
-                return { level: 'medium', label: '中等', estimatedCommits: '预计 2-3 个 commit' };
-            }
-            return { level: 'simple', label: '简单', estimatedCommits: '预计 1 个 commit' };
-        }
-        // 复杂关键词检测
-        if (complexKeywords.test(desc) || multiScope) {
-            return { level: 'complex', label: '复杂', estimatedCommits: '预计 3+ 个 commit' };
-        }
-        // 新功能 - 默认 medium
-        if (taskType.type === 'feature') {
-            // 只有非常简单的单文件修改才判断为 simple
-            if (desc.length < 20 && scope.areas.length === 1 && /(按钮|链接|文案|颜色)/.test(desc)) {
-                return { level: 'simple', label: '简单', estimatedCommits: '预计 1 个 commit' };
-            }
-            if (desc.length > 100 || scope.areas.length >= 2) {
-                return { level: 'medium', label: '中等', estimatedCommits: '预计 2-3 个 commit' };
-            }
-            return { level: 'medium', label: '中等', estimatedCommits: '预计 2-3 个 commit' };
-        }
-        // 重构 - 默认 medium
-        if (taskType.type === 'refactor') {
-            if (multiScope || /(整体|全部|系统)/.test(desc)) {
-                return { level: 'complex', label: '复杂', estimatedCommits: '预计 3+ 个 commit' };
-            }
-            return { level: 'medium', label: '中等', estimatedCommits: '预计 2-3 个 commit' };
-        }
-        // 默认中等
-        return { level: 'medium', label: '中等', estimatedCommits: '预计 1-2 个 commit' };
-    }
-    /**
-     * 生成建议
-     */
-    generateSuggestions(taskType, complexity, desc) {
-        const suggestions = [];
-        // 复杂任务优先建议头脑风暴
-        if (complexity.level === 'complex') {
-            suggestions.push('建议先头脑风暴，明确需求');
-        }
-        // 根据任务类型建议
-        switch (taskType.type) {
-            case 'bugfix':
-                suggestions.push('直接修复，无需 TDD');
-                suggestions.push('使用 fast 模式');
-                break;
-            case 'feature':
-                if (complexity.level === 'complex') {
-                    suggestions.push('使用 strict 模式保证质量');
-                }
-                else {
-                    suggestions.push('使用 balanced 模式');
-                }
-                break;
-            case 'refactor':
-                suggestions.push('确保测试覆盖');
-                suggestions.push('使用 balanced 模式');
-                break;
-            case 'test':
-                suggestions.push('使用 fast 或 balanced 模式');
-                break;
-            case 'docs':
-                suggestions.push('无需测试');
-                suggestions.push('使用 fast 模式');
-                break;
-            case 'config':
-                suggestions.push('注意配置安全');
-                suggestions.push('使用 fast 模式');
-                break;
-            default:
-                if (complexity.level !== 'complex') {
-                    suggestions.push('根据实际情况选择模式');
-                }
-        }
-        // 确保至少有一个建议
-        if (suggestions.length === 0) {
-            suggestions.push('建议先确认任务需求');
-        }
-        return suggestions;
-    }
     /**
      * 推断问题答案
      */
@@ -584,21 +388,7 @@ class SmartQuestionAnalyzer {
      * 生成推断摘要
      */
     generateSummary(result) {
-        const lines = [];
-        // 任务理解
-        lines.push('🔍 我理解的任务:\n');
-        lines.push(`📋 类型: ${result.understanding.taskTypeLabel}`);
-        lines.push(`📁 范围: ${result.understanding.scopeLabel}`);
-        lines.push(`⚡ 复杂度: ${result.understanding.complexityLabel} (${result.understanding.estimatedCommits})`);
-        // 建议
-        if (result.understanding.suggestions.length > 0) {
-            lines.push('\n💡 建议执行方式:');
-            for (const suggestion of result.understanding.suggestions) {
-                lines.push(`   • ${suggestion}`);
-            }
-        }
-        // 推断结果
-        lines.push('\n📊 配置推断:');
+        const lines = ['📊 AI 推断结果:\n'];
         for (const inference of result.inferences) {
             const icon = inference.confidence === 'high' ? '✅' :
                 inference.confidence === 'medium' ? '🤔' : '❓';
@@ -606,55 +396,15 @@ class SmartQuestionAnalyzer {
                 ? inference.inferredAnswer.join(', ')
                 : inference.inferredAnswer || '待确认';
             lines.push(`${icon} ${inference.questionId}: ${answer}`);
-        }
-        if (result.questionsToAsk.length > 0) {
-            lines.push(`\n❓ 需要确认: ${result.questionsToAsk.join(', ')}`);
-        }
-        else {
-            lines.push('\n✅ 配置已推断，可直接执行');
-        }
-        return lines.join('\n');
-    }
-    /**
-     * 生成 Markdown 格式输出
-     */
-    generateMarkdown(result) {
-        const lines = [];
-        lines.push('## 🔍 我理解的任务\n');
-        lines.push(`| 属性 | 值 |`);
-        lines.push(`|------|-----|`);
-        lines.push(`| 📋 类型 | ${result.understanding.taskTypeLabel} |`);
-        lines.push(`| 📁 范围 | ${result.understanding.scopeLabel} |`);
-        lines.push(`| ⚡ 复杂度 | ${result.understanding.complexityLabel} |`);
-        lines.push(`| ⏱️ 预计 | ${result.understanding.estimatedCommits} |`);
-        // 建议
-        if (result.understanding.suggestions.length > 0) {
-            lines.push('\n## 💡 建议执行方式\n');
-            for (const suggestion of result.understanding.suggestions) {
-                lines.push(`- ${suggestion}`);
+            if (inference.reason) {
+                lines.push(`   └─ ${inference.reason}`);
             }
         }
-        // 推断的配置
-        lines.push('\n## 📊 推荐配置\n');
-        lines.push(`| 配置项 | 推荐值 | 置信度 |`);
-        lines.push(`|--------|--------|--------|`);
-        for (const inference of result.inferences) {
-            const answer = Array.isArray(inference.inferredAnswer)
-                ? inference.inferredAnswer.join(', ')
-                : inference.inferredAnswer || '待确认';
-            const confidenceIcon = inference.confidence === 'high' ? '✅' :
-                inference.confidence === 'medium' ? '🤔' : '❓';
-            lines.push(`| ${inference.questionId} | ${answer} | ${confidenceIcon} |`);
-        }
-        // 需要确认的问题
         if (result.questionsToAsk.length > 0) {
-            lines.push('\n## ❓ 需要确认\n');
-            for (const q of result.questionsToAsk) {
-                lines.push(`- ${q}`);
-            }
+            lines.push(`\n❓ 需要确认的问题: ${result.questionsToAsk.join(', ')}`);
         }
         else {
-            lines.push('\n✅ **所有配置已推断，可直接执行**');
+            lines.push('\n✅ 所有问题已推断，无需额外确认');
         }
         return lines.join('\n');
     }

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

@@ -1,12 +1,4 @@
 import type { ParsedTask } from '../types/index.js';
-/**
- * TaskParser - 任务解析器
- *
- * 职责：解析用户输入的任务描述，提取结构化信息
- *
- * 注意：TaskParser 只负责格式解析，不做业务逻辑判断
- * 任务拆解的智能逻辑应该由 TaskPlanner (调用 AI) 来完成
- */
 export declare class TaskParser {
     parse(content: string): ParsedTask;
     private extractTitle;

package/dist/orchestrator/task-parser.js

@@ -1,14 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskParser = void 0;
-/**
- * TaskParser - 任务解析器
- *
- * 职责：解析用户输入的任务描述，提取结构化信息
- *
- * 注意：TaskParser 只负责格式解析，不做业务逻辑判断
- * 任务拆解的智能逻辑应该由 TaskPlanner (调用 AI) 来完成
- */
 class TaskParser {
     parse(content) {
         const title = this.extractTitle(content);
@@ -26,43 +18,38 @@ class TaskParser {
         };
     }
     extractTitle(content) {
-        // 1. 从第一个 # 标题提取
-        const headerMatch = content.match(/^#\s+(.+)$/m);
-        if (headerMatch) {
-            return headerMatch[1].trim();
-        }
-        // 2. 没有标题，取第一行非空内容（截断到 50 字符）
-        const firstLine = content.split('\n').find(l => l.trim());
-        return firstLine ? firstLine.trim().slice(0, 50) : 'Untitled Task';
+        const match = content.match(/^#\s+(.+)$/m);
+        return match ? match[1].trim() : 'Untitled Task';
     }
     extractDescription(content) {
-        // 移除标题和 sections，获取第一段
+        // Remove title and sections, get first paragraph
         let desc = content
             .replace(/^#\s+.+$/m, '')
             .replace(/^##\s+.+$/gm, '')
             .replace(/^- .+$/gm, '')
             .trim();
-        // 获取第一个非空行
+        // Get first non-empty line
         const lines = desc.split('\n').filter(l => l.trim());
         return lines.length > 0 ? lines[0].trim() : '';
     }
     extractSection(content, sectionName) {
+        // Split content into lines and find the section
         const lines = content.split('\n');
         const items = [];
         let inSection = false;
         for (const line of lines) {
-            // 检查是否进入目标 section
+            // Check if we're entering the target section
             if (line.match(new RegExp(`^##\\s+${sectionName}\\s*$`))) {
                 inSection = true;
                 continue;
             }
-            // 检查是否进入其他 section
+            // Check if we've hit another section
             if (line.match(/^##\s+/)) {
                 if (inSection)
-                    break;
+                    break; // Exit if we were in the target section
                 continue;
             }
-            // 提取列表项
+            // Extract list items if we're in the target section
             if (inSection) {
                 const itemMatch = line.match(/^-\s+(.+)$/);
                 if (itemMatch) {

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

@@ -17,34 +17,69 @@ export interface UserAnswers {
     testCoverage?: string;
     documentationLevel?: string;
     additionalContext?: Record<string, string>;
+    /** 是否启用 E2E 测试 */
+    e2eTests?: boolean;
+    /** E2E 测试类型 (web/mobile/gui) */
+    e2eType?: 'web' | 'mobile' | 'gui';
 }
 /**
  * TaskPlanner - 任务拆解器
  *
- * 1. 按 goals 拆分为多个 coder + tester 任务对
- * 2. goals 为空时退化为 3 任务模式 (planner → coder → tester)
- * 3. 自动注入用户上下文和验收标准
+ * 增强版特性:
+ * 1. 更细粒度的任务拆分 (每个目标拆分为设计+实现+测试)
+ * 2. 测试任务配对 (每个开发任务自动生成对应测试任务)
+ * 3. 验收标准注入 (从用户回答中提取)
+ * 4. 用户上下文注入 (将用户回答注入任务描述)
+ * 5. 依赖关系分析 (自动分析任务间依赖)
  */
 export declare class TaskPlanner {
+    private userAnswers;
+    constructor(userAnswers?: UserAnswers);
+    /**
+     * 设置用户回答
+     */
+    setUserAnswers(answers: UserAnswers): void;
     /**
      * Break down a parsed task into sub-tasks
+     *
+     * 增强版: 生成更细粒度的任务，包含设计、开发、测试配对
      */
     breakdown(parsedTask: ParsedTask, answers: Record<string, string>): TaskBreakdown[];
     /**
-     * 按 goals 拆分: 每个 goal 一个 coder + 一个 tester
+     * 提取用户上下文
      */
-    private breakdownByGoals;
+    private extractUserContext;
     /**
-     * 无 goals 时的退化模式: planner → coder → tester
-     * 把 rawContent 整体交给 planner 分析，生成 PLAN.md
-     * coder 基于 PLAN.md 实现
+     * 解析数组类型的回答
      */
-    private breakdownFallback;
-    private extractUserContext;
     private parseArrayAnswer;
+    /**
+     * 构建任务描述 (注入用户上下文)
+     */
     private buildTaskDescription;
+    /**
+     * 构建测试任务描述
+     */
     private buildTestDescription;
+    /**
+     * 构建 E2E 测试任务描述
+     */
+    private buildE2ETestDescription;
+    /**
+     * 获取 E2E 测试类型配置
+     */
+    private getE2ETypeConfig;
+    /**
+     * 生成用户流程测试用例
+     */
+    private generateUserFlows;
+    /**
+     * 解析覆盖率数值
+     */
     private parseCoverage;
+    /**
+     * 生成验收标准
+     */
     private generateAcceptanceCriteria;
     private generateTaskId;
     private determinePriority;