openmatrix 0.1.17 → 0.1.19

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/commands/check-gitignore.d.ts

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

package/dist/cli/commands/check-gitignore.js

@@ -0,0 +1,361 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkGitignoreCommand = void 0;
+// src/cli/commands/check-gitignore.ts
+const commander_1 = require("commander");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * 项目类型对应的 gitignore 条目
+ */
+const GITIGNORE_TEMPLATES = {
+    nodejs: [
+        'node_modules/',
+        'dist/',
+        'build/',
+        '.npm/',
+        '*.log',
+        'npm-debug.log*',
+        'yarn-debug.log*',
+        'yarn-error.log*'
+    ],
+    typescript: [
+        '*.tsbuildinfo',
+        '.tsbuildinfo'
+    ],
+    python: [
+        '__pycache__/',
+        '*.py[cod]',
+        '*$py.class',
+        '.venv/',
+        'venv/',
+        'ENV/',
+        '.pytest_cache/',
+        '.mypy_cache/',
+        '*.egg-info/',
+        'dist/',
+        'build/'
+    ],
+    java: [
+        'target/',
+        '.gradle/',
+        'build/',
+        '*.class',
+        '*.jar',
+        '*.war'
+    ],
+    go: [
+        'vendor/',
+        'bin/',
+        '*.exe',
+        '*.exe~',
+        '*.dll',
+        '*.so',
+        '*.dylib'
+    ],
+    rust: [
+        'target/',
+        'Cargo.lock'
+    ],
+    dotnet: [
+        'bin/',
+        'obj/',
+        '*.nupkg',
+        '*.snupkg'
+    ],
+    php: [
+        'vendor/',
+        'composer.lock'
+    ],
+    dart: [
+        '.dart_tool/',
+        '.packages',
+        'build/',
+        '.pub/',
+        'pubspec.lock'
+    ],
+    common: [
+        '.env',
+        '.env.local',
+        '.env.*.local',
+        '.DS_Store',
+        'Thumbs.db',
+        '*.swp',
+        '*.swo',
+        '*~',
+        '.idea/',
+        '.vscode/',
+        '*.iml'
+    ]
+};
+/**
+ * 根据项目类型检测需要的 gitignore 条目
+ */
+async function detectProjectType(projectRoot) {
+    const types = [];
+    // 检查 package.json
+    try {
+        const packageJsonPath = path.join(projectRoot, 'package.json');
+        const content = await fs.readFile(packageJsonPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        types.push('nodejs');
+        // 检查 TypeScript
+        if (pkg.devDependencies?.typescript || pkg.dependencies?.typescript) {
+            types.push('typescript');
+        }
+    }
+    catch {
+        // 不是 Node.js 项目
+    }
+    // 检查 Python
+    try {
+        await fs.access(path.join(projectRoot, 'pyproject.toml'));
+        types.push('python');
+    }
+    catch { }
+    try {
+        await fs.access(path.join(projectRoot, 'requirements.txt'));
+        if (!types.includes('python'))
+            types.push('python');
+    }
+    catch { }
+    // 检查 Java
+    try {
+        await fs.access(path.join(projectRoot, 'pom.xml'));
+        types.push('java');
+    }
+    catch { }
+    try {
+        await fs.access(path.join(projectRoot, 'build.gradle'));
+        if (!types.includes('java'))
+            types.push('java');
+    }
+    catch { }
+    // 检查 Go
+    try {
+        await fs.access(path.join(projectRoot, 'go.mod'));
+        types.push('go');
+    }
+    catch { }
+    // 检查 Rust
+    try {
+        await fs.access(path.join(projectRoot, 'Cargo.toml'));
+        types.push('rust');
+    }
+    catch { }
+    // 检查 .NET
+    try {
+        const files = await fs.readdir(projectRoot);
+        if (files.some(f => f.endsWith('.sln') || f.endsWith('.csproj'))) {
+            types.push('dotnet');
+        }
+    }
+    catch { }
+    // 检查 PHP
+    try {
+        await fs.access(path.join(projectRoot, 'composer.json'));
+        types.push('php');
+    }
+    catch { }
+    // 检查 Dart
+    try {
+        await fs.access(path.join(projectRoot, 'pubspec.yaml'));
+        types.push('dart');
+    }
+    catch { }
+    // 始终添加通用条目
+    types.push('common');
+    return types;
+}
+/**
+ * 获取所有需要的 gitignore 条目
+ */
+function getRequiredEntries(projectTypes) {
+    const entries = new Set();
+    for (const type of projectTypes) {
+        const template = GITIGNORE_TEMPLATES[type];
+        if (template) {
+            for (const entry of template) {
+                entries.add(entry);
+            }
+        }
+    }
+    return entries;
+}
+/**
+ * 解析现有 gitignore 内容
+ */
+function parseGitignore(content) {
+    const entries = new Set();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // 跳过注释和空行
+        if (trimmed && !trimmed.startsWith('#')) {
+            entries.add(trimmed);
+        }
+    }
+    return entries;
+}
+exports.checkGitignoreCommand = new commander_1.Command('check-gitignore')
+    .description('检查并自动补充 .gitignore 文件')
+    .option('--json', '输出 JSON 格式')
+    .option('--dry-run', '仅显示会添加的内容，不实际修改')
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    try {
+        // 检测项目类型
+        const projectTypes = await detectProjectType(projectRoot);
+        const requiredEntries = getRequiredEntries(projectTypes);
+        // 读取现有 gitignore
+        let existingEntries = new Set();
+        let exists = false;
+        try {
+            const content = await fs.readFile(gitignorePath, 'utf-8');
+            existingEntries = parseGitignore(content);
+            exists = true;
+        }
+        catch {
+            // 文件不存在
+        }
+        // 计算缺失的条目
+        const missingEntries = [];
+        for (const entry of requiredEntries) {
+            if (!existingEntries.has(entry)) {
+                missingEntries.push(entry);
+            }
+        }
+        // JSON 输出
+        if (options.json) {
+            console.log(JSON.stringify({
+                exists,
+                projectTypes,
+                missingEntries,
+                totalRequired: requiredEntries.size,
+                totalExisting: existingEntries.size
+            }, null, 2));
+            return;
+        }
+        // 没有缺失条目
+        if (missingEntries.length === 0) {
+            console.log(chalk_1.default.green('✅ .gitignore 已完善，无需修改\n'));
+            return;
+        }
+        // Dry run 模式
+        if (options.dryRun) {
+            console.log(chalk_1.default.cyan('🔍 检测到以下缺失条目:\n'));
+            for (const entry of missingEntries) {
+                console.log(chalk_1.default.gray(`  + ${entry}`));
+            }
+            return;
+        }
+        // 自动补充
+        const newContent = generateGitignoreContent(missingEntries);
+        if (exists) {
+            // 追加到现有文件
+            await fs.appendFile(gitignorePath, `\n${newContent}`);
+            console.log(chalk_1.default.green(`✅ 已向 .gitignore 添加 ${missingEntries.length} 个条目:\n`));
+        }
+        else {
+            // 创建新文件
+            await fs.writeFile(gitignorePath, newContent);
+            console.log(chalk_1.default.green(`✅ 已创建 .gitignore，包含 ${missingEntries.length} 个条目:\n`));
+        }
+        for (const entry of missingEntries) {
+            console.log(chalk_1.default.gray(`  + ${entry}`));
+        }
+        console.log();
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(JSON.stringify({ error: String(error) }));
+        }
+        else {
+            console.error(chalk_1.default.red('❌ 检查失败:'), error);
+        }
+        process.exit(1);
+    }
+});
+/**
+ * 生成 gitignore 内容
+ */
+function generateGitignoreContent(entries) {
+    const timestamp = new Date().toISOString().split('T')[0];
+    // 按类型分组
+    const groups = {
+        'Dependencies': [],
+        'Build': [],
+        'Environment': [],
+        'IDE': [],
+        'OS': [],
+        'Other': []
+    };
+    for (const entry of entries) {
+        if (entry.includes('node_modules') || entry.includes('vendor') || entry.includes('.venv')) {
+            groups['Dependencies'].push(entry);
+        }
+        else if (entry.includes('dist') || entry.includes('build') || entry.includes('target')) {
+            groups['Build'].push(entry);
+        }
+        else if (entry.includes('.env')) {
+            groups['Environment'].push(entry);
+        }
+        else if (entry.includes('.idea') || entry.includes('.vscode') || entry.includes('.iml')) {
+            groups['IDE'].push(entry);
+        }
+        else if (entry.includes('.DS_Store') || entry.includes('Thumbs.db')) {
+            groups['OS'].push(entry);
+        }
+        else {
+            groups['Other'].push(entry);
+        }
+    }
+    let content = `\n# Auto-generated by OpenMatrix (${timestamp})\n`;
+    for (const [group, items] of Object.entries(groups)) {
+        if (items.length > 0) {
+            content += `\n# ${group}\n`;
+            for (const item of items) {
+                content += `${item}\n`;
+            }
+        }
+    }
+    return content;
+}

package/dist/cli/commands/check.js

@@ -50,7 +50,7 @@ exports.checkCommand = new commander_1.Command('check')
     .option('--categories <items>', '指定检测类别 (逗号分隔)', 'bug,quality,capability,ux,style,security,common')
     .option('--min-priority <level>', '最小优先级 (critical|high|medium|low)', 'low')
     .option('--max <number>', '最大建议数量', '50')
-    .option('--scan <dirs>', '扫描目录 (逗号分隔)', 'src,skills,tests,docs')
+    .option('--scan <dirs>', '扫描目录 (逗号分隔)', 'src,skills,docs')
     .option('--interactive', '交互式选择要执行的改进', false)
     .action(async (hint, options) => {
     const projectRoot = process.cwd();

package/dist/cli/index.js

@@ -12,6 +12,8 @@ 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 check_gitignore_js_1 = require("./commands/check-gitignore.js");
+const analyze_js_1 = require("./commands/analyze.js");
 const program = new commander_1.Command();
 program
     .name('openmatrix')
@@ -28,5 +30,7 @@ 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(check_gitignore_js_1.checkGitignoreCommand);
+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/dist/orchestrator/upgrade-detector.js

@@ -41,8 +41,8 @@ const path = __importStar(require("path"));
  * 默认配置
  */
 exports.DEFAULT_DETECTOR_CONFIG = {
-    scanDirs: ['src', 'skills', 'tests', 'docs', 'prompts', '.claude', '.cursor'],
-    excludeDirs: ['node_modules', 'dist', '.git', '.openmatrix'],
+    scanDirs: ['src', 'skills', 'docs', 'prompts', '.claude', '.cursor'],
+    excludeDirs: ['node_modules', 'dist', '.git', '.openmatrix', 'tests'],
     categories: ['bug', 'quality', 'capability', 'ux', 'style', 'security', 'common', 'prompt', 'skill', 'agent'],
     minPriority: 'low'
 };

package/package.json

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

package/skills/check.md

@@ -106,9 +106,7 @@ description: 自动检测项目可改进点并提供升级建议，用户确认
 
    ---
 
-   ## ✅ 下一步
-
-   回复 **"继续"**、**"可以"**、**"执行"** 或 **"好"** 开始自动修复这些问题。
+   **是否继续？**
    ```
 
    如果没有发现问题:
@@ -118,19 +116,7 @@ description: 自动检测项目可改进点并提供升级建议，用户确认
 
 4. **等待用户确认**
 
-   展示报告后，等待用户回复。检测用户回复中的确认词语:
-
-   **确认词语列表**:
-   - 继续、可以、执行、好、是、ok、OK、确认、同意
-   - continue、yes、ok、sure、go、do it
-   - 中文变体：行、好的、没问题、没问题啊、走起、开始吧
-
-   **取消词语列表** (用户不想执行):
-   - 不、不要、取消、算了、跳过
-   - no、skip、cancel
-
-   如果用户回复包含确认词语，立即执行下一步。
-   如果用户回复包含取消词语，结束流程。
+   展示报告后，等待用户回复。用户回复确认词语（如"是"、"继续"、"好"、"可以"等）即执行下一步。
 
 5. **调用 /om:start 执行改进**
 
@@ -165,8 +151,8 @@ $ARGUMENTS
 </arguments>
 
 <examples>
-/check                    # 自动扫描 → 展示报告 → 用户回复"继续" → 自动执行
-/check 安全               # 聚焦安全问题 → 展示报告 → 用户回复"可以" → 自动修复
+/check                    # 自动扫描 → 展示报告 → 用户回复"是" → 自动执行
+/check 安全               # 聚焦安全问题 → 展示报告 → 用户回复"继续" → 自动修复
 </examples>
 
 <notes>
@@ -180,7 +166,7 @@ $ARGUMENTS
     ├── 2. 展示报告 ──→ 输出 Markdown 格式的检测报告
     │                   (不使用交互式对话框，让用户能看到完整文档)
     │
-    ├── 3. 等待确认 ──→ 用户回复 "继续" 或 "可以"
+    ├── 3. 等待确认 ──→ 用户回复 "是" 或 "继续"
     │
     └── 4. 自动执行 ──→ 调用 /om:start
                             │
@@ -210,27 +196,5 @@ $ARGUMENTS
 1. 完整查看所有检测到的问题
 2. 仔细阅读每个问题的描述和建议
 3. 自由决定是否执行修复
-4. 简单回复"继续"即可开始执行
-
-## 确认词语检测
-
-检测用户回复中是否包含以下词语（不区分大小写）:
-
-| 中文确认 | 英文确认 |
-|---------|---------|
-| 继续 | continue |
-| 可以 | yes / ok / sure |
-| 执行 | go / do it |
-| 好 / 是 | |
-| 确认 / 同意 | |
-| 行 / 好的 | |
-| 没问题 | |
-| 走起 / 开始吧 | |
-
-用户回复示例:
-- "继续" → 执行
-- "可以，开始吧" → 执行
-- "好" → 执行
-- "先不要" → 不执行
-- "跳过" → 不执行
+4. 简单回复确认即可开始执行
 </notes>

package/skills/start.md

@@ -8,7 +8,7 @@ description: 启动新的任务执行周期
 </NO-OTHER-SKILLS>
 
 <objective>
-解析任务文档，通过交互式问答澄清需求（3-7个问题，支持多轮追问），确认后启动执行。
+解析任务文档，通过智能分析自动推断配置，仅对不确定的问题进行交互式问答，确认后启动执行。
 </objective>
 
 <process>
@@ -34,18 +34,86 @@ description: 启动新的任务执行周期
    - 检查是否有远程仓库配置:
      - 如果没有远程仓库，提示用户添加: `git remote add origin <url>`
 
-4. **解析任务输入**
+4. **智能检测 .gitignore**
+
+   检查 `.gitignore` 文件是否存在并完善:
+   ```bash
+   openmatrix check-gitignore --json
+   ```
+
+   返回结果:
+   ```json
+   {
+     "exists": true,
+     "missingEntries": ["node_modules", "dist", ".env"],
+     "suggestedContent": "# Node.js\nnode_modules/\ndist/\n\n# Environment\n.env\n.env.local"
+   }
+   ```
+
+   **如果缺少常见忽略项**:
+   - 自动补充缺失的条目到 `.gitignore`
+   - 不询问用户，静默完成
+
+   **常见忽略项清单** (按项目类型):
+
+   | 类型 | 忽略项 |
+   |------|--------|
+   | Node.js | `node_modules/`, `dist/`, `build/`, `.npm/`, `*.log` |
+   | TypeScript | `*.tsbuildinfo`, `.tsbuildinfo` |
+   | Python | `__pycache__/`, `*.pyc`, `.venv/`, `venv/`, `.pytest_cache/` |
+   | Java | `target/`, `.gradle/`, `build/`, `*.class` |
+   | Go | `vendor/`, `bin/`, `*.exe` |
+   | Rust | `target/`, `Cargo.lock` (库项目) |
+   | 通用 | `.env`, `.env.local`, `.DS_Store`, `Thumbs.db`, `*.swp` |
+   | IDE | `.idea/`, `.vscode/`, `*.iml` |
+
+5. **解析任务输入**
    - 如果 `$ARGUMENTS` 提供文件路径 → 读取文件内容
    - 如果 `$ARGUMENTS` 是任务描述 → 直接使用
    - 如果无参数 → **使用 AskUserQuestion 询问用户要执行的任务**
 
-5. **⚠️ 交互式问答 (必须执行)**
+5. **🔍 智能分析 (新流程)**
+
+   **首先调用 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 无法推断或置信度低的问题进行问答。
 
-   **重要**: 除非用户明确指定 `--skip-questions` 或提供了 `--quality` 等选项，否则必须执行交互式问答。
+   **如果 `questionsToAsk` 为空**: 直接使用推断值，跳过问答。
 
-   使用 `AskUserQuestion` 工具，逐个提出以下问题：
+   **如果有需要确认的问题**: 使用 `AskUserQuestion` 逐个提问。
 
-   **问题 0: 质量级别 (最重要，第一个问)**
+   **问题 0: 质量级别** (仅当 questionsToAsk 包含 "quality_level" 时询问)
    ```typescript
    AskUserQuestion({
      questions: [{
@@ -116,7 +184,7 @@ description: 启动新的任务执行周期
    })
    ```
 
-   **问题 1: 任务目标**
+   **问题 1: 任务目标** (仅当 questionsToAsk 包含 "objective" 时询问)
    ```typescript
    AskUserQuestion({
      questions: [{
@@ -133,7 +201,7 @@ description: 启动新的任务执行周期
    })
    ```
 
-   **问题 2: 技术栈** (根据任务内容动态生成)
+   **问题 2: 技术栈** (仅当 questionsToAsk 包含 "tech_stack" 时询问，否则使用项目检测值)
    ```typescript
    AskUserQuestion({
      questions: [{
@@ -150,7 +218,7 @@ description: 启动新的任务执行周期
    })
    ```
 
-   **问题 3: 文档要求**
+   **问题 3: 文档要求** (仅当 questionsToAsk 包含 "doc_level" 时询问)
    ```typescript
    AskUserQuestion({
      questions: [{