openmatrix 0.1.17 → 0.1.18

package/dist/cli/commands/analyze.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const analyzeCommand: Command;

package/dist/cli/commands/analyze.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeCommand = void 0;
+// src/cli/commands/analyze.ts
+const commander_1 = require("commander");
+const smart_question_analyzer_js_1 = require("../../orchestrator/smart-question-analyzer.js");
+exports.analyzeCommand = new commander_1.Command('analyze')
+    .description('智能分析任务，推断配置，返回需要确认的问题列表')
+    .argument('[task]', '任务描述')
+    .option('--json', '输出 JSON 格式')
+    .action(async (task, options) => {
+    const analyzer = new smart_question_analyzer_js_1.SmartQuestionAnalyzer(process.cwd());
+    if (!task) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                status: 'error',
+                message: '请提供任务描述'
+            }));
+        }
+        else {
+            console.log('❌ 请提供任务描述');
+            console.log('   用法: openmatrix analyze "实现用户登录功能"');
+        }
+        return;
+    }
+    try {
+        const result = await analyzer.analyze(task);
+        if (options.json) {
+            // 输出 JSON 格式 (供 Skill 解析)
+            const output = result;
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            // 输出人类可读格式
+            console.log('\n' + analyzer.generateSummary(result));
+        }
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                status: 'error',
+                message: error instanceof Error ? error.message : '分析失败'
+            }));
+        }
+        else {
+            console.log('❌ 分析失败:', error instanceof Error ? error.message : '未知错误');
+        }
+    }
+});

package/dist/cli/index.js

@@ -12,6 +12,7 @@ const meeting_js_1 = require("./commands/meeting.js");
 const auto_js_1 = require("./commands/auto.js");
 const install_skills_js_1 = require("./commands/install-skills.js");
 const check_js_1 = require("./commands/check.js");
+const analyze_js_1 = require("./commands/analyze.js");
 const program = new commander_1.Command();
 program
     .name('openmatrix')
@@ -28,5 +29,6 @@ program.addCommand(meeting_js_1.meetingCommand);
 program.addCommand(auto_js_1.autoCommand);
 program.addCommand(install_skills_js_1.installSkillsCommand);
 program.addCommand(check_js_1.checkCommand);
+program.addCommand(analyze_js_1.analyzeCommand);
 // 默认帮助
 program.parse();

package/dist/orchestrator/interactive-question-generator.d.ts

@@ -39,6 +39,13 @@ export interface QuestionSession {
     status: 'pending' | 'in_progress' | 'completed';
     createdAt: string;
     completedAt?: string;
+    /** 推断值 (由 SmartQuestionAnalyzer 提供) */
+    inferences?: Map<string, {
+        answer: string | string[];
+        reason: string;
+    }>;
+    /** 已跳过的问题 (使用推断值) */
+    skippedQuestionIds?: string[];
 }
 /**
  * InteractiveQuestionGenerator - 交互式问题生成器
@@ -48,9 +55,40 @@ export interface QuestionSession {
  * 2. 优先级排序 - 按重要性顺序提问
  * 3. 条件分支 - 不同回答触发不同追问
  * 4. 交互友好 - 支持单步/批量回答
+ * 5. 智能推断 - 支持预设推断值，跳过不必要的问题
  */
 export declare class InteractiveQuestionGenerator {
     private session;
+    /** 推断值 */
+    private inferences;
+    /** 需要跳过的问题 ID */
+    private skippedQuestionIds;
+    /**
+     * 设置推断值 (来自 SmartQuestionAnalyzer)
+     */
+    setInferences(inferences: Map<string, {
+        answer: string | string[];
+        reason: string;
+    }>): void;
+    /**
+     * 获取推断值
+     */
+    getInference(questionId: string): {
+        answer: string | string[];
+        reason: string;
+    } | undefined;
+    /**
+     * 检查问题是否被跳过 (使用推断值)
+     */
+    isQuestionSkipped(questionId: string): boolean;
+    /**
+     * 获取所有跳过的问题及其推断值
+     */
+    getSkippedQuestions(): Array<{
+        questionId: string;
+        answer: string | string[];
+        reason: string;
+    }>;
     /**
      * 开始新的问答会话
      */

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

@@ -9,22 +9,80 @@ exports.InteractiveQuestionGenerator = void 0;
  * 2. 优先级排序 - 按重要性顺序提问
  * 3. 条件分支 - 不同回答触发不同追问
  * 4. 交互友好 - 支持单步/批量回答
+ * 5. 智能推断 - 支持预设推断值，跳过不必要的问题
  */
 class InteractiveQuestionGenerator {
     session = null;
+    /** 推断值 */
+    inferences = new Map();
+    /** 需要跳过的问题 ID */
+    skippedQuestionIds = new Set();
+    /**
+     * 设置推断值 (来自 SmartQuestionAnalyzer)
+     */
+    setInferences(inferences) {
+        this.inferences = inferences;
+        // 高置信度的推断值可以跳过问题
+        for (const [questionId] of inferences) {
+            this.skippedQuestionIds.add(questionId);
+        }
+    }
+    /**
+     * 获取推断值
+     */
+    getInference(questionId) {
+        return this.inferences.get(questionId);
+    }
+    /**
+     * 检查问题是否被跳过 (使用推断值)
+     */
+    isQuestionSkipped(questionId) {
+        return this.skippedQuestionIds.has(questionId);
+    }
+    /**
+     * 获取所有跳过的问题及其推断值
+     */
+    getSkippedQuestions() {
+        const result = [];
+        for (const questionId of this.skippedQuestionIds) {
+            const inference = this.inferences.get(questionId);
+            if (inference) {
+                result.push({ questionId, ...inference });
+            }
+        }
+        return result;
+    }
     /**
      * 开始新的问答会话
      */
     startSession(parsedTask) {
-        const baseQuestions = this.generateBaseQuestions(parsedTask);
+        const allQuestions = this.generateBaseQuestions(parsedTask);
+        // 过滤掉已跳过的问题 (使用推断值)
+        const questionsToAsk = allQuestions.filter(q => !this.skippedQuestionIds.has(q.id));
+        // 为跳过的问题创建答案
+        const skippedAnswers = [];
+        for (const question of allQuestions) {
+            if (this.skippedQuestionIds.has(question.id)) {
+                const inference = this.inferences.get(question.id);
+                if (inference) {
+                    const answer = {
+                        questionId: question.id,
+                        selectedKeys: Array.isArray(inference.answer) ? inference.answer : [inference.answer]
+                    };
+                    skippedAnswers.push(answer);
+                }
+            }
+        }
         this.session = {
             sessionId: `qs-${Date.now().toString(36)}`,
             taskId: parsedTask.title,
-            questions: baseQuestions.sort((a, b) => a.priority - b.priority),
-            answers: [],
+            questions: questionsToAsk.sort((a, b) => a.priority - b.priority),
+            answers: skippedAnswers, // 预填充跳过问题的答案
             currentQuestionIndex: 0,
             status: 'in_progress',
-            createdAt: new Date().toISOString()
+            createdAt: new Date().toISOString(),
+            inferences: this.inferences,
+            skippedQuestionIds: Array.from(this.skippedQuestionIds)
         };
         return this.session;
     }

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

@@ -0,0 +1,82 @@
+import type { ParsedTask } from '../types/index.js';
+/**
+ * 问题推断结果
+ */
+export interface QuestionInference {
+    questionId: string;
+    inferredAnswer?: string | string[];
+    confidence: 'high' | 'medium' | 'low';
+    reason: string;
+}
+/**
+ * 项目上下文
+ */
+export interface ProjectContext {
+    projectType: 'typescript' | 'javascript' | 'python' | 'go' | 'rust' | 'java' | 'unknown';
+    frameworks: string[];
+    hasFrontend: boolean;
+    hasBackend: boolean;
+    hasTests: boolean;
+    packageManager: 'npm' | 'yarn' | 'pnpm' | 'pip' | 'go-mod' | 'cargo' | 'unknown';
+    dependencies: Record<string, string>;
+}
+/**
+ * 分析结果
+ */
+export interface AnalysisResult {
+    inferences: QuestionInference[];
+    questionsToAsk: string[];
+    skippedQuestions: string[];
+    projectContext: ProjectContext;
+}
+/**
+ * SmartQuestionAnalyzer - 智能问答分析器
+ *
+ * 根据任务描述和项目上下文智能推断问题答案，减少不必要的问答
+ *
+ * 使用方式:
+ * 1. 分析项目文件获取上下文
+ * 2. 根据任务关键词推断答案
+ * 3. 返回需要提问的问题列表
+ */
+export declare class SmartQuestionAnalyzer {
+    private projectRoot;
+    private cachedContext;
+    constructor(projectRoot?: string);
+    /**
+     * 分析任务，返回推断结果
+     */
+    analyze(taskDescription: string, parsedTask?: ParsedTask): Promise<AnalysisResult>;
+    /**
+     * 获取项目上下文
+     */
+    getProjectContext(): Promise<ProjectContext>;
+    /**
+     * 推断问题答案
+     */
+    private inferAnswers;
+    /**
+     * 推断质量级别
+     */
+    private inferQualityLevel;
+    /**
+     * 推断技术栈
+     */
+    private inferTechStack;
+    /**
+     * 推断文档级别
+     */
+    private inferDocLevel;
+    /**
+     * 推断 E2E 测试
+     */
+    private inferE2ETest;
+    /**
+     * 推断执行模式
+     */
+    private inferExecutionMode;
+    /**
+     * 生成推断摘要
+     */
+    generateSummary(result: AnalysisResult): string;
+}

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

@@ -0,0 +1,412 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartQuestionAnalyzer = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * SmartQuestionAnalyzer - 智能问答分析器
+ *
+ * 根据任务描述和项目上下文智能推断问题答案，减少不必要的问答
+ *
+ * 使用方式:
+ * 1. 分析项目文件获取上下文
+ * 2. 根据任务关键词推断答案
+ * 3. 返回需要提问的问题列表
+ */
+class SmartQuestionAnalyzer {
+    projectRoot;
+    cachedContext = null;
+    constructor(projectRoot = process.cwd()) {
+        this.projectRoot = projectRoot;
+    }
+    /**
+     * 分析任务，返回推断结果
+     */
+    async analyze(taskDescription, parsedTask) {
+        // 1. 获取项目上下文
+        const projectContext = await this.getProjectContext();
+        // 2. 执行推断
+        const inferences = this.inferAnswers(taskDescription, projectContext);
+        // 3. 筛选需要提问的问题
+        const questionsToAsk = inferences
+            .filter(i => i.confidence === 'low' || !i.inferredAnswer)
+            .map(i => i.questionId);
+        const skippedQuestions = inferences
+            .filter(i => i.confidence !== 'low' && i.inferredAnswer)
+            .map(i => i.questionId);
+        return {
+            inferences,
+            questionsToAsk,
+            skippedQuestions,
+            projectContext
+        };
+    }
+    /**
+     * 获取项目上下文
+     */
+    async getProjectContext() {
+        if (this.cachedContext) {
+            return this.cachedContext;
+        }
+        const context = {
+            projectType: 'unknown',
+            frameworks: [],
+            hasFrontend: false,
+            hasBackend: false,
+            hasTests: false,
+            packageManager: 'unknown',
+            dependencies: {}
+        };
+        // 检测项目类型和依赖
+        const packageJsonPath = path.join(this.projectRoot, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+                context.packageManager = 'npm';
+                context.dependencies = {
+                    ...packageJson.dependencies,
+                    ...packageJson.devDependencies
+                };
+                // 检测 TypeScript
+                if (context.dependencies['typescript'] || fs.existsSync(path.join(this.projectRoot, 'tsconfig.json'))) {
+                    context.projectType = 'typescript';
+                }
+                else {
+                    context.projectType = 'javascript';
+                }
+                // 检测框架
+                const frameworkDeps = {
+                    'react': 'React',
+                    'vue': 'Vue',
+                    'svelte': 'Svelte',
+                    'angular': 'Angular',
+                    'next': 'Next.js',
+                    'nuxt': 'Nuxt.js',
+                    'express': 'Express',
+                    'fastify': 'Fastify',
+                    'nestjs': 'NestJS',
+                    'koa': 'Koa',
+                    'electron': 'Electron'
+                };
+                for (const [dep, name] of Object.entries(frameworkDeps)) {
+                    if (context.dependencies[dep]) {
+                        context.frameworks.push(name);
+                    }
+                }
+                // 检测前端/后端
+                context.hasFrontend = ['react', 'vue', 'svelte', 'angular', 'next', 'nuxt', 'electron']
+                    .some(dep => context.dependencies[dep]);
+                context.hasBackend = ['express', 'fastify', 'nestjs', 'koa']
+                    .some(dep => context.dependencies[dep]);
+                // 检测测试
+                context.hasTests = ['vitest', 'jest', 'mocha', 'pytest', 'testing']
+                    .some(dep => context.dependencies[dep]) ||
+                    fs.existsSync(path.join(this.projectRoot, 'tests')) ||
+                    fs.existsSync(path.join(this.projectRoot, 'test'));
+            }
+            catch {
+                // 忽略解析错误
+            }
+        }
+        // 检测 Python 项目
+        if (fs.existsSync(path.join(this.projectRoot, 'requirements.txt')) ||
+            fs.existsSync(path.join(this.projectRoot, 'pyproject.toml'))) {
+            context.projectType = 'python';
+            context.packageManager = 'pip';
+        }
+        // 检测 Go 项目
+        if (fs.existsSync(path.join(this.projectRoot, 'go.mod'))) {
+            context.projectType = 'go';
+            context.packageManager = 'go-mod';
+        }
+        // 检测 Rust 项目
+        if (fs.existsSync(path.join(this.projectRoot, 'Cargo.toml'))) {
+            context.projectType = 'rust';
+            context.packageManager = 'cargo';
+        }
+        this.cachedContext = context;
+        return context;
+    }
+    /**
+     * 推断问题答案
+     */
+    inferAnswers(taskDescription, context) {
+        const inferences = [];
+        const desc = taskDescription.toLowerCase();
+        // 1. 推断质量级别
+        inferences.push(this.inferQualityLevel(desc, context));
+        // 2. 推断技术栈
+        inferences.push(this.inferTechStack(desc, context));
+        // 3. 推断文档级别
+        inferences.push(this.inferDocLevel(desc, context));
+        // 4. 推断 E2E 测试
+        inferences.push(this.inferE2ETest(desc, context));
+        // 5. 推断执行模式
+        inferences.push(this.inferExecutionMode(desc, context));
+        return inferences;
+    }
+    /**
+     * 推断质量级别
+     */
+    inferQualityLevel(desc, context) {
+        const inference = {
+            questionId: 'quality_level',
+            confidence: 'low',
+            reason: ''
+        };
+        // Bug 修复 -> balanced
+        if (/(fix|bug|修复|hotfix|patch|问题)/i.test(desc)) {
+            inference.inferredAnswer = 'balanced';
+            inference.confidence = 'high';
+            inference.reason = '任务涉及 Bug 修复';
+            return inference;
+        }
+        // 原型/POC -> fast
+        if (/(prototype|poc|demo|快速|原型|示例|sample)/i.test(desc)) {
+            inference.inferredAnswer = 'fast';
+            inference.confidence = 'high';
+            inference.reason = '任务涉及原型或演示';
+            return inference;
+        }
+        // 测试相关 -> strict
+        if (/(test|测试|单元|unit|coverage|覆盖率)/i.test(desc)) {
+            inference.inferredAnswer = 'strict';
+            inference.confidence = 'high';
+            inference.reason = '任务涉及测试';
+            return inference;
+        }
+        // 新功能/生产代码 -> strict
+        if (/(implement|add|新功能|实现|开发|feature|生产)/i.test(desc)) {
+            inference.inferredAnswer = 'strict';
+            inference.confidence = 'medium';
+            inference.reason = '任务涉及新功能开发';
+            return inference;
+        }
+        // 重构 -> balanced
+        if (/(refactor|优化|重构|improve)/i.test(desc)) {
+            inference.inferredAnswer = 'balanced';
+            inference.confidence = 'medium';
+            inference.reason = '任务涉及代码重构';
+            return inference;
+        }
+        inference.reason = '无法确定任务类型';
+        return inference;
+    }
+    /**
+     * 推断技术栈
+     */
+    inferTechStack(desc, context) {
+        const inference = {
+            questionId: 'tech_stack',
+            confidence: 'low',
+            reason: ''
+        };
+        const detected = [];
+        // 从项目上下文检测
+        if (context.projectType === 'typescript') {
+            detected.push('typescript');
+        }
+        else if (context.projectType === 'python') {
+            detected.push('python');
+        }
+        else if (context.projectType === 'go') {
+            detected.push('go');
+        }
+        else if (context.projectType === 'rust') {
+            detected.push('rust');
+        }
+        // 从任务描述检测
+        const techKeywords = {
+            'typescript': ['typescript', 'ts', 'tsx'],
+            'javascript': ['javascript', 'js', 'jsx'],
+            'react': ['react', 'reactjs'],
+            'vue': ['vue', 'vuejs', 'vue3'],
+            'node': ['node', 'nodejs', 'express', 'koa'],
+            'python': ['python', 'py', 'django', 'flask', 'fastapi'],
+            'go': ['golang', 'go'],
+            'rust': ['rust', 'cargo']
+        };
+        for (const [tech, keywords] of Object.entries(techKeywords)) {
+            if (keywords.some(kw => desc.includes(kw))) {
+                if (!detected.includes(tech)) {
+                    detected.push(tech);
+                }
+            }
+        }
+        // 从项目框架检测
+        for (const framework of context.frameworks) {
+            const normalized = framework.toLowerCase();
+            if (!detected.includes(normalized)) {
+                detected.push(normalized);
+            }
+        }
+        if (detected.length > 0) {
+            inference.inferredAnswer = detected;
+            inference.confidence = context.projectType !== 'unknown' ? 'high' : 'medium';
+            inference.reason = `检测到技术栈: ${detected.join(', ')}`;
+        }
+        else {
+            inference.reason = '无法检测技术栈';
+        }
+        return inference;
+    }
+    /**
+     * 推断文档级别
+     */
+    inferDocLevel(desc, context) {
+        const inference = {
+            questionId: 'doc_level',
+            confidence: 'low',
+            reason: ''
+        };
+        // Bug 修复 -> 无需文档
+        if (/(fix|bug|修复|hotfix)/i.test(desc)) {
+            inference.inferredAnswer = 'none';
+            inference.confidence = 'high';
+            inference.reason = 'Bug 修复通常不需要文档';
+            return inference;
+        }
+        // 重构 -> 最小文档
+        if (/(refactor|优化|重构)/i.test(desc)) {
+            inference.inferredAnswer = 'minimal';
+            inference.confidence = 'medium';
+            inference.reason = '重构任务通常需要最小文档';
+            return inference;
+        }
+        // API/模块/库 -> 完整文档
+        if (/(api|module|library|组件|库|sdk)/i.test(desc)) {
+            inference.inferredAnswer = 'full';
+            inference.confidence = 'medium';
+            inference.reason = 'API/模块开发需要完整文档';
+            return inference;
+        }
+        // 新功能 -> 基础文档
+        if (/(implement|add|新功能|实现|开发|feature)/i.test(desc)) {
+            inference.inferredAnswer = 'basic';
+            inference.confidence = 'medium';
+            inference.reason = '新功能开发需要基础文档';
+            return inference;
+        }
+        inference.reason = '无法确定文档需求';
+        return inference;
+    }
+    /**
+     * 推断 E2E 测试
+     */
+    inferE2ETest(desc, context) {
+        const inference = {
+            questionId: 'e2e_test',
+            confidence: 'low',
+            reason: ''
+        };
+        // CLI/后端 -> 不需要 E2E
+        if (/(cli|api|backend|后端|命令行)/i.test(desc) && !context.hasFrontend) {
+            inference.inferredAnswer = 'false';
+            inference.confidence = 'high';
+            inference.reason = 'CLI/后端任务不需要 E2E 测试';
+            return inference;
+        }
+        // 前端页面 -> 询问
+        if (context.hasFrontend || /(page|ui|前端|界面|web)/i.test(desc)) {
+            inference.confidence = 'low';
+            inference.reason = '前端任务可能需要 E2E 测试，需要用户确认';
+            return inference;
+        }
+        // 默认不需要
+        inference.inferredAnswer = 'false';
+        inference.confidence = 'medium';
+        inference.reason = '默认不需要 E2E 测试';
+        return inference;
+    }
+    /**
+     * 推断执行模式
+     */
+    inferExecutionMode(desc, context) {
+        const inference = {
+            questionId: 'execution_mode',
+            confidence: 'low',
+            reason: ''
+        };
+        // 快速原型 -> 全自动
+        if (/(prototype|poc|demo|快速|原型)/i.test(desc)) {
+            inference.inferredAnswer = 'auto';
+            inference.confidence = 'medium';
+            inference.reason = '原型任务适合全自动执行';
+            return inference;
+        }
+        // 简单修复 -> 全自动
+        if (/(fix|bug|修复|hotfix)/i.test(desc) && desc.length < 100) {
+            inference.inferredAnswer = 'auto';
+            inference.confidence = 'medium';
+            inference.reason = '简单 Bug 修复适合全自动执行';
+            return inference;
+        }
+        // 新功能 -> 每阶段确认
+        if (/(implement|add|新功能|实现|开发)/i.test(desc)) {
+            inference.inferredAnswer = 'phase';
+            inference.confidence = 'medium';
+            inference.reason = '新功能开发适合每阶段确认';
+            return inference;
+        }
+        inference.reason = '无法确定执行模式';
+        return inference;
+    }
+    /**
+     * 生成推断摘要
+     */
+    generateSummary(result) {
+        const lines = ['📊 AI 推断结果:\n'];
+        for (const inference of result.inferences) {
+            const icon = inference.confidence === 'high' ? '✅' :
+                inference.confidence === 'medium' ? '🤔' : '❓';
+            const answer = Array.isArray(inference.inferredAnswer)
+                ? 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(', ')}`);
+        }
+        else {
+            lines.push('\n✅ 所有问题已推断，无需额外确认');
+        }
+        return lines.join('\n');
+    }
+}
+exports.SmartQuestionAnalyzer = SmartQuestionAnalyzer;

package/package.json

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

package/skills/start.md

@@ -8,7 +8,7 @@ description: 启动新的任务执行周期
 </NO-OTHER-SKILLS>
 
 <objective>
-解析任务文档，通过交互式问答澄清需求（3-7个问题，支持多轮追问），确认后启动执行。
+解析任务文档，通过智能分析自动推断配置，仅对不确定的问题进行交互式问答，确认后启动执行。
 </objective>
 
 <process>
@@ -39,13 +39,48 @@ description: 启动新的任务执行周期
    - 如果 `$ARGUMENTS` 是任务描述 → 直接使用
    - 如果无参数 → **使用 AskUserQuestion 询问用户要执行的任务**
 
-5. **⚠️ 交互式问答 (必须执行)**
+5. **🔍 智能分析 (新流程)**
 
-   **重要**: 除非用户明确指定 `--skip-questions` 或提供了 `--quality` 等选项，否则必须执行交互式问答。
+   **首先调用 CLI 进行智能分析:**
+   ```bash
+   openmatrix analyze --json
+   ```
+
+   这会返回分析结果:
+   ```json
+   {
+     "inferences": [
+       { "questionId": "quality_level", "inferredAnswer": "strict", "confidence": "high", "reason": "任务涉及新功能开发" },
+       { "questionId": "tech_stack", "inferredAnswer": ["typescript", "react"], "confidence": "high", "reason": "检测到技术栈: TypeScript, React" },
+       { "questionId": "doc_level", "inferredAnswer": "basic", "confidence": "medium", "reason": "新功能开发需要基础文档" }
+     ],
+     "questionsToAsk": ["e2e_test"],
+     "skippedQuestions": ["quality_level", "tech_stack", "doc_level"],
+     "projectContext": { "projectType": "typescript", "frameworks": ["React"], "hasFrontend": true }
+   }
+   ```
+
+   **展示推断摘要:**
+   ```
+   🔍 AI 正在分析任务...
+
+   📊 推断结果:
+     ✅ 质量级别: strict (任务涉及新功能开发)
+     ✅ 技术栈: TypeScript, React (检测到技术栈)
+     ✅ 文档级别: 基础文档 (新功能开发需要基础文档)
+
+   ❓ 需要确认的问题: E2E测试
+   ```
+
+6. **⚠️ 交互式问答 (仅针对不确定的问题)**
+
+   **重要改进**: 现在只对 AI 无法推断或置信度低的问题进行问答。
+
+   **如果 `questionsToAsk` 为空**: 直接使用推断值，跳过问答。
 
-   使用 `AskUserQuestion` 工具，逐个提出以下问题：
+   **如果有需要确认的问题**: 使用 `AskUserQuestion` 逐个提问。
 
-   **问题 0: 质量级别 (最重要，第一个问)**
+   **问题 0: 质量级别** (仅当 questionsToAsk 包含 "quality_level" 时询问)
    ```typescript
    AskUserQuestion({
      questions: [{
@@ -116,7 +151,7 @@ description: 启动新的任务执行周期
    })
    ```
 
-   **问题 1: 任务目标**
+   **问题 1: 任务目标** (仅当 questionsToAsk 包含 "objective" 时询问)
    ```typescript
    AskUserQuestion({
      questions: [{
@@ -133,7 +168,7 @@ description: 启动新的任务执行周期
    })
    ```
 
-   **问题 2: 技术栈** (根据任务内容动态生成)
+   **问题 2: 技术栈** (仅当 questionsToAsk 包含 "tech_stack" 时询问，否则使用项目检测值)
    ```typescript
    AskUserQuestion({
      questions: [{
@@ -150,7 +185,7 @@ description: 启动新的任务执行周期
    })
    ```
 
-   **问题 3: 文档要求**
+   **问题 3: 文档要求** (仅当 questionsToAsk 包含 "doc_level" 时询问)
    ```typescript
    AskUserQuestion({
      questions: [{