openmatrix 0.1.23 → 0.1.25

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

@@ -20,10 +20,24 @@ export interface ProjectContext {
     packageManager: 'npm' | 'yarn' | 'pnpm' | 'pip' | 'go-mod' | 'cargo' | 'unknown';
     dependencies: Record<string, string>;
 }
+/**
+ * 任务理解
+ */
+export interface TaskUnderstanding {
+    taskType: 'feature' | 'bugfix' | 'refactor' | 'docs' | 'test' | 'config' | 'unknown';
+    taskTypeLabel: string;
+    scope: string[];
+    scopeLabel: string;
+    complexity: 'simple' | 'medium' | 'complex';
+    complexityLabel: string;
+    estimatedCommits: string;
+    suggestions: string[];
+}
 /**
  * 分析结果
  */
 export interface AnalysisResult {
+    understanding: TaskUnderstanding;
     inferences: QuestionInference[];
     questionsToAsk: string[];
     skippedQuestions: string[];
@@ -51,6 +65,26 @@ export declare class SmartQuestionAnalyzer {
      * 获取项目上下文
      */
     getProjectContext(): Promise<ProjectContext>;
+    /**
+     * 分析任务理解
+     */
+    private analyzeTaskUnderstanding;
+    /**
+     * 检测任务类型
+     */
+    private detectTaskType;
+    /**
+     * 检测影响范围
+     */
+    private detectScope;
+    /**
+     * 检测复杂度
+     */
+    private detectComplexity;
+    /**
+     * 生成建议
+     */
+    private generateSuggestions;
     /**
      * 推断问题答案
      */

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

@@ -58,9 +58,11 @@ class SmartQuestionAnalyzer {
     async analyze(taskDescription, parsedTask) {
         // 1. 获取项目上下文
         const projectContext = await this.getProjectContext();
-        // 2. 执行推断
+        // 2. 分析任务理解
+        const understanding = this.analyzeTaskUnderstanding(taskDescription, projectContext);
+        // 3. 执行推断
         const inferences = this.inferAnswers(taskDescription, projectContext);
-        // 3. 筛选需要提问的问题
+        // 4. 筛选需要提问的问题
         const questionsToAsk = inferences
             .filter(i => i.confidence === 'low' || !i.inferredAnswer)
             .map(i => i.questionId);
@@ -68,6 +70,7 @@ class SmartQuestionAnalyzer {
             .filter(i => i.confidence !== 'low' && i.inferredAnswer)
             .map(i => i.questionId);
         return {
+            understanding,
             inferences,
             questionsToAsk,
             skippedQuestions,
@@ -160,6 +163,190 @@ 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 simpleLength = desc.length < 50;
+        // 复杂任务判断
+        const complexKeywords = /(系统|架构|模块|集成|完整|从零|重构|优化整体)/i;
+        const multiScope = scope.areas.length >= 3;
+        // Bug 修复通常是简单的
+        if (taskType.type === 'bugfix') {
+            if (simpleKeywords.test(desc) || simpleLength) {
+                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' };
+        }
+        // 新功能
+        if (taskType.type === 'feature') {
+            if (simpleLength && scope.areas.length <= 1) {
+                return { level: 'simple', label: '简单', estimatedCommits: '预计 1-2 个 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' };
+        }
+        // 重构
+        if (taskType.type === 'refactor') {
+            if (multiScope) {
+                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 = [];
+        // 根据任务类型建议
+        switch (taskType.type) {
+            case 'bugfix':
+                suggestions.push('直接修复，无需 TDD');
+                suggestions.push('使用 fast 模式');
+                break;
+            case 'feature':
+                if (complexity.level === 'complex') {
+                    suggestions.push('建议先头脑风暴，明确需求');
+                    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:
+                suggestions.push('根据实际情况选择模式');
+        }
+        return suggestions;
+    }
     /**
      * 推断问题答案
      */
@@ -388,7 +575,21 @@ class SmartQuestionAnalyzer {
      * 生成推断摘要
      */
     generateSummary(result) {
-        const lines = ['📊 AI 推断结果:\n'];
+        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📊 配置推断:');
         for (const inference of result.inferences) {
             const icon = inference.confidence === 'high' ? '✅' :
                 inference.confidence === 'medium' ? '🤔' : '❓';
@@ -396,15 +597,12 @@ class SmartQuestionAnalyzer {
                 ? inference.inferredAnswer.join(', ')
                 : inference.inferredAnswer || '待确认';
             lines.push(`${icon} ${inference.questionId}: ${answer}`);
-            if (inference.reason) {
-                lines.push(`   └─ ${inference.reason}`);
-            }
         }
         if (result.questionsToAsk.length > 0) {
-            lines.push(`\n❓ 需要确认的问题: ${result.questionsToAsk.join(', ')}`);
+            lines.push(`\n❓ 需要确认: ${result.questionsToAsk.join(', ')}`);
         }
         else {
-            lines.push('\n✅ 所有问题已推断，无需额外确认');
+            lines.push('\n✅ 配置已推断，可直接执行');
         }
         return lines.join('\n');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmatrix",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "AI Agent task orchestration system with Claude Code Skills integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/skills/openmatrix.md

@@ -1,167 +1,140 @@
----
-name: openmatrix
-description: "TRIGGER for ANY implementation task. User wants to build/create/add/fix/implement/refactor something? This is the DEFAULT. Examples: 'add feature', 'fix bug', 'implement login', 'refactor code', 'create command'. ALWAYS prefer this over direct coding."
-priority: critical
-always_load: true
----
-
-<EXTREMELY-IMPORTANT>
-This skill MUST be invoked when the user describes ANY work to be done.
-
-**If you're unsure whether to invoke → INVOKE IT.**
-
-**If user mentions: add/create/implement/fix/build/make/write/develop/refactor/optimize/update/modify/change → INVOKE THIS SKILL.**
-
-**Direct coding without OpenMatrix is ONLY allowed for:**
-- Simple one-line fixes (typos, variable names)
-- Answering questions (no code changes needed)
-- Information retrieval (reading files, explaining code)
-
-Everything else → smart selection between `/om:brainstorm` and `/om:start`.
-</EXTREMELY-IMPORTANT>
-
-<objective>
-Automatically detect when user wants to accomplish a development task and intelligently choose between brainstorm (for complex tasks) or start (for simple tasks).
-</objective>
-
-<process>
-1. **检测用户输入**
-   - 用户直接发送任务描述（不带命令前缀）
-   - 分析是否为开发任务（写代码/改代码/做东西）
-
-2. **判断任务复杂度**
-
-   **复杂任务** (满足任一条件):
-   - 新功能开发: "实现用户登录" / "添加支付功能"
-   - 多模块改动: "重构用户系统" / "优化整体性能"
-   - 架构相关: "搭建框架" / "从零开始"
-   - 关键词: "系统" / "架构" / "模块" / "集成" / "完整"
-
-   **简单任务** (满足任一条件):
-   - Bug 修复: "修复登录bug" / "解决样式问题"
-   - 小改动: "修改文案" / "改变量名"
-   - 单一功能: "添加一个按钮" / "写个工具函数"
-   - 关键词: "修复" / "解决" / "改" / "调整" / "简单"
-
-3. **智能选择执行路径**
-
-   ```
-   复杂任务 → 调用 /om:brainstorm
-   简单任务 → 调用 /om:start
-   不确定   → 默认 /om:brainstorm (宁可多问)
-   ```
-
-4. **执行选择的命令**
-   - 调用 Skill 工具执行对应的 skill
-</process>
-
-<trigger-conditions>
-## AUTO-INVOKE RULES (Mandatory)
-
-**Invoke IMMEDIATELY when user input contains ANY of these patterns:**
-
-### Action Verbs (触发词)
-| Chinese | English | Action |
-|---------|---------|--------|
-| 实现/开发/做/写 | implement/build/create/make/write | → Smart Select |
-| 添加/增加/加 | add/append | → Smart Select |
-| 修复/解决/改 | fix/resolve/repair | → Smart Select |
-| 重构/优化/改进 | refactor/optimize/improve | → Smart Select |
-| 更新/修改/改 | update/modify/change | → Smart Select |
-
-### Context Patterns (触发场景)
-- **Feature requests**: "用户登录" / "支付功能" / "API接口"
-- **Bug reports**: "报错" / "不工作" / "有问题" / "崩溃"
-- **Code changes**: "这段代码" / "这个文件" / "那个模块"
-- **Multi-step tasks**: "先做A" / "然后B" / "最后C"
-- **System building**: "做一个系统" / "搭建框架" / "从零开始"
-
-### The 3-Second Test
-```
-用户输入 → 能在3秒内判断是"要做事情"吗?
-  ↓ Yes                           ↓ No
-Smart Select                    直接回答
-```
-</trigger-conditions>
-
-<smart-selection>
-## 智能选择：Brainstorm vs Start
-
-**根据任务复杂度自动选择执行路径：**
-
-### 🧠 复杂任务 → `/om:brainstorm`
-**触发条件 (满足任一):**
-- 新功能开发: "实现用户登录" / "添加支付功能" / "开发 API"
-- 多模块改动: "重构用户系统" / "优化整体性能"
-- 架构相关: "搭建框架" / "从零开始" / "设计架构"
-- 不确定因素: 需要技术选型、涉及多种方案选择
-- 关键词: "系统" / "架构" / "模块" / "集成" / "完整" / "从零"
-
-### 🚀 简单任务 → `/om:start`
-**触发条件 (满足任一):**
-- Bug 修复: "修复登录bug" / "解决样式问题" / "改个报错"
-- 小改动: "修改文案" / "改变量名" / "调整配置"
-- 单一功能: "添加一个按钮" / "写个工具函数"
-- 明确需求: 需求清晰，无需额外探索
-- 关键词: "修复" / "解决" / "改" / "调整" / "小" / "简单"
-
-### 选择流程
-```
-用户输入任务描述
-       │
-       ▼
-┌─────────────────────┐
-│ 分析任务复杂度        │
-└──────────┬──────────┘
-           │
-     ┌─────┴─────┐
-     │           │
-  复杂任务     简单任务
-     │           │
-     ▼           ▼
-/om:brainstorm  /om:start
-```
-
-### 判断示例
-| 用户输入 | 复杂度 | 执行路径 |
-|---------|--------|---------|
-| "实现用户登录功能" | 复杂 | `/om:brainstorm` |
-| "做一个完整的支付系统" | 复杂 | `/om:brainstorm` |
-| "从零搭建后台管理" | 复杂 | `/om:brainstorm` |
-| "修复登录页面的样式问题" | 简单 | `/om:start` |
-| "改一下这个变量名" | 简单 | `/om:start` |
-| "添加一个测试用例" | 简单 | `/om:start` |
-| "重构这个模块" | 中等 | `/om:brainstorm` (保守选择) |
-| "优化性能" | 中等 | `/om:brainstorm` (保守选择) |
-
-**不确定时的默认选择: `/om:brainstorm`** (宁可多问，不可漏问)
-</smart-selection>
-
-<exclusions>
-## When NOT to Invoke (Rare Cases)
-
-**Do NOT invoke ONLY when:**
-- Pure question: "怎么实现?" / "如何配置?" / "what is..." / "为什么"
-- Information request: "显示配置" / "列出文件" / "show me..." / "看一下"
-- Status check: "状态" / "进度" / "status"
-- Casual chat: "你好" / "谢谢" / "hello"
-
-**Key Test:**
-```
-用户要我写代码/改代码/做东西吗?
-  ↓ Yes → Smart Select (brainstorm/start)
-  ↓ No  → 直接回答
-```
-
-**When in doubt → INVOKE. It handles both simple and complex tasks.**
-</exclusions>
-
-<examples>
-| User Input | Complexity | Action |
-|------------|------------|--------|
-| `实现用户登录功能` | 复杂 | → `/om:brainstorm` |
-| `做一个完整的订单系统` | 复杂 | → `/om:brainstorm` |
-| `修复登录页面的样式问题` | 简单 | → `/om:start` |
-| `改一下这个变量名` | 简单 | → `/om:start` |
-| `重构用户模块` | 中等 | → `/om:brainstorm` |
-| `怎么实现登录?` | - | ❌ Question, not task |
+---
+name: openmatrix
+description: "TRIGGER for ANY implementation task. User wants to build/create/add/fix/implement/refactor something? This is the DEFAULT. Examples: 'add feature', 'fix bug', 'implement login', 'refactor code', 'create command'. ALWAYS prefer this over direct coding."
+priority: critical
+always_load: true
+---
+
+<EXTREMELY-IMPORTANT>
+This skill MUST be invoked when the user describes ANY work to be done.
+
+**If you're unsure whether to invoke → INVOKE IT.**
+
+**If user mentions: add/create/implement/fix/build/make/write/develop/refactor/optimize/update/modify/change → INVOKE THIS SKILL.**
+
+**Direct coding without OpenMatrix is ONLY allowed for:**
+- Simple one-line fixes (typos, variable names)
+- Answering questions (no code changes needed)
+- Information retrieval (reading files, explaining code)
+
+Everything else → analyze and execute.
+</EXTREMELY-IMPORTANT>
+
+<objective>
+用户想要完成开发任务时，自动分析任务，展示理解，推荐执行方式，确认后开始执行。
+</objective>
+
+<process>
+1. **分析任务并展示理解**
+
+   调用 CLI 分析任务:
+   ```bash
+   openmatrix analyze --json
+   ```
+
+   **展示 AI 的理解和推荐:**
+   ```
+   🔍 我理解的任务:
+
+   📋 类型: Bug 修复
+   📁 范围: 前端样式
+   ⚡ 复杂度: 简单 (预计 1 个 commit)
+
+   💡 推荐执行方式:
+      • 直接修复，无需 TDD
+      • 使用 fast 模式
+   ```
+
+2. **用户确认**
+
+   使用 AskUserQuestion 让用户选择:
+   ```typescript
+   AskUserQuestion({
+     questions: [{
+       question: "以上理解正确吗？",
+       header: "确认",
+       options: [
+         { label: "✅ 确认执行", description: "使用推荐配置开始执行" },
+         { label: "📝 补充说明", description: "提供更多任务细节" },
+         { label: "⚙️ 调整配置", description: "修改质量级别、文档等配置" },
+         { label: "🧠 先头脑风暴", description: "复杂任务，需要先探索需求" }
+       ],
+       multiSelect: false
+     }]
+   })
+   ```
+
+3. **根据选择执行**
+
+   **选择"确认执行"**:
+   - 直接调用 `/om:start`，使用推荐配置，无需再问问题
+
+   **选择"补充说明"**:
+   - 询问详情后重新分析
+
+   **选择"调整配置"**:
+   - 调用 `/om:start`，进入配置流程
+
+   **选择"先头脑风暴"**:
+   - 调用 `/om:brainstorm`
+</process>
+
+<trigger-conditions>
+## AUTO-INVOKE RULES (Mandatory)
+
+**Invoke IMMEDIATELY when user input contains ANY of these patterns:**
+
+### Action Verbs (触发词)
+| Chinese | English | Action |
+|---------|---------|--------|
+| 实现/开发/做/写 | implement/build/create/make/write | → Analyze |
+| 添加/增加/加 | add/append | → Analyze |
+| 修复/解决/改 | fix/resolve/repair | → Analyze |
+| 重构/优化/改进 | refactor/optimize/improve | → Analyze |
+| 更新/修改/改 | update/modify/change | → Analyze |
+
+### Context Patterns (触发场景)
+- **Feature requests**: "用户登录" / "支付功能" / "API接口"
+- **Bug reports**: "报错" / "不工作" / "有问题" / "崩溃"
+- **Code changes**: "这段代码" / "这个文件" / "那个模块"
+- **Multi-step tasks**: "先做A" / "然后B" / "最后C"
+- **System building**: "做一个系统" / "搭建框架" / "从零开始"
+
+### The 3-Second Test
+```
+用户输入 → 能在3秒内判断是"要做事情"吗?
+  ↓ Yes                           ↓ No
+Analyze & Execute                 直接回答
+```
+</trigger-conditions>
+
+<exclusions>
+## When NOT to Invoke (Rare Cases)
+
+**Do NOT invoke ONLY when:**
+- Pure question: "怎么实现?" / "如何配置?" / "what is..." / "为什么"
+- Information request: "显示配置" / "列出文件" / "show me..." / "看一下"
+- Status check: "状态" / "进度" / "status"
+- Casual chat: "你好" / "谢谢" / "hello"
+
+**Key Test:**
+```
+用户要我写代码/改代码/做东西吗?
+  ↓ Yes → Analyze & Execute
+  ↓ No  → 直接回答
+```
+
+**When in doubt → INVOKE.**
+</exclusions>
+
+<arguments>
+$ARGUMENTS
+</arguments>
+
+<examples>
+| User Input | Action |
+|------------|--------|
+| `实现用户登录功能` | → 分析 → 展示理解 → 确认 → 执行 |
+| `修复登录页面的样式问题` | → 分析 → 展示理解 → 确认 → 执行 |
+| `怎么实现登录?` | ❌ Question, not task |
+</examples>