openmatrix 0.1.56 → 0.1.58

package/dist/cli/commands/research.js

@@ -0,0 +1,270 @@
+"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.researchCommand = void 0;
+// src/cli/commands/research.ts
+const commander_1 = require("commander");
+const gitignore_js_1 = require("../../utils/gitignore.js");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+/**
+ * 生成并行研究 Agent 配置
+ */
+function generateAgents(topic, domain, aspects) {
+    return [
+        {
+            role: 'domain_researcher',
+            focus: `搜索 ${domain} 领域的核心概念、行业标准、最佳实践。关键词: ${aspects.slice(0, 4).join(', ')}`,
+            status: 'pending'
+        },
+        {
+            role: 'tech_explorer',
+            focus: `搜索 ${domain} 的主流技术方案、开源项目、技术栈选择、架构模式`,
+            status: 'pending'
+        },
+        {
+            role: 'scenario_analyst',
+            focus: `结合用户具体需求 "${topic}"，分析实际应用场景、常见挑战、经验教训`,
+            status: 'pending'
+        }
+    ];
+}
+exports.researchCommand = new commander_1.Command('research')
+    .description('领域调研和问题探索 - 为后续任务提供知识基础')
+    .argument('[topic]', '研究主题')
+    .option('--json', '输出 JSON 格式 (供 Skill 解析)')
+    .option('--confirm', '确认进入深度研究 (从 Skill 传入)')
+    .option('--complete', '标记研究完成，生成报告和任务上下文')
+    .option('--results <json>', '研究结果 JSON (从 Skill 传入)')
+    .action(async (topic, options) => {
+    const basePath = process.cwd();
+    const omPath = path.join(basePath, '.openmatrix');
+    const researchPath = path.join(omPath, 'research');
+    const knowledgePath = path.join(researchPath, 'knowledge');
+    // 确保目录存在
+    await fs.mkdir(omPath, { recursive: true });
+    await fs.mkdir(researchPath, { recursive: true });
+    await fs.mkdir(knowledgePath, { recursive: true });
+    // 确保 .openmatrix 被 git 忽略
+    await (0, gitignore_js_1.ensureOpenmatrixGitignore)(basePath);
+    const sessionPath = path.join(researchPath, 'session.json');
+    // ========== --complete 模式: 研究完成，汇总结果 ==========
+    if (options.complete) {
+        try {
+            const sessionData = await fs.readFile(sessionPath, 'utf-8');
+            const session = JSON.parse(sessionData);
+            // 如果传入了结果，合并
+            if (options.results) {
+                try {
+                    const results = JSON.parse(options.results);
+                    if (results.agents)
+                        session.agents = results.agents;
+                    if (results.report)
+                        session.report = results.report;
+                    if (results.knowledge)
+                        session.knowledge = [...session.knowledge, ...results.knowledge];
+                    if (results.context)
+                        session.context = results.context;
+                    if (results.domainQuestions)
+                        session.domainQuestions = results.domainQuestions;
+                    if (results.answers)
+                        session.answers = { ...session.answers, ...results.answers };
+                }
+                catch {
+                    // 忽略解析错误
+                }
+            }
+            session.status = 'completed';
+            session.completedAt = new Date().toISOString();
+            await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+            // 写入研究报告
+            if (session.report) {
+                await fs.writeFile(path.join(researchPath, 'RESEARCH.md'), session.report, 'utf-8');
+            }
+            // 写入知识条目
+            for (let i = 0; i < session.knowledge.length; i++) {
+                await fs.writeFile(path.join(knowledgePath, `finding-${i + 1}.md`), session.knowledge[i], 'utf-8');
+            }
+            // 写入任务上下文 (供 start 使用)
+            const taskContext = session.context || { goals: [], constraints: [], deliverables: [] };
+            await fs.writeFile(path.join(researchPath, 'context.json'), JSON.stringify({
+                topic: session.topic,
+                domain: session.domain,
+                ...taskContext,
+                reportPath: '.openmatrix/research/RESEARCH.md',
+                knowledgePath: '.openmatrix/research/knowledge/'
+            }, null, 2), 'utf-8');
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'completed',
+                    message: '研究完成',
+                    topic: session.topic,
+                    domain: session.domain,
+                    report: session.report,
+                    knowledge: session.knowledge,
+                    context: taskContext,
+                    reportPath: '.openmatrix/research/RESEARCH.md',
+                    hint: '研究结果已保存，可以使用 /om:start 开始执行任务'
+                }));
+            }
+            else {
+                console.log('研究完成!');
+                console.log(`   主题: ${session.topic}`);
+                console.log(`   领域: ${session.domain}`);
+                console.log(`   知识条目: ${session.knowledge.length} 个`);
+                console.log('\n使用 /om:start 基于研究结果开始任务');
+            }
+            return;
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'error', message: '没有进行中的研究会话' }));
+            }
+            else {
+                console.log('没有进行中的研究会话');
+                console.log('   使用 openmatrix research <topic> 开始新的研究');
+            }
+            return;
+        }
+    }
+    // ========== --confirm 模式: 用户确认后进入深度研究 ==========
+    if (options.confirm) {
+        try {
+            const sessionData = await fs.readFile(sessionPath, 'utf-8');
+            const session = JSON.parse(sessionData);
+            if (session.status !== 'preview') {
+                if (options.json) {
+                    console.log(JSON.stringify({ status: 'error', message: `当前状态为 ${session.status}，无法确认` }));
+                }
+                else {
+                    console.log(`当前状态为 ${session.status}，无法确认`);
+                }
+                return;
+            }
+            // 生成研究 Agent
+            const agents = generateAgents(session.topic, session.domain, session.aspects);
+            session.status = 'researching';
+            session.agents = agents;
+            await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'researching',
+                    message: '开始深度研究',
+                    topic: session.topic,
+                    domain: session.domain,
+                    aspects: session.aspects,
+                    agents: agents.map(a => ({ role: a.role, focus: a.focus, status: a.status })),
+                    hint: '使用 Agent 工具并行执行研究'
+                }));
+            }
+            else {
+                console.log('\n开始深度研究...\n');
+                console.log(`  主题: ${session.topic}`);
+                console.log(`  领域: ${session.domain}`);
+                console.log('\n研究 Agent:');
+                agents.forEach((a, i) => {
+                    console.log(`  ${i + 1}. [${a.role}] ${a.focus}`);
+                });
+            }
+            return;
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'error', message: '没有待确认的研究会话' }));
+            }
+            else {
+                console.log('没有待确认的研究会话');
+            }
+            return;
+        }
+    }
+    // ========== 初始模式: 创建会话，等待 AI 分析 ==========
+    let researchTopic = topic;
+    if (!researchTopic) {
+        const defaultPath = path.join(basePath, 'RESEARCH.md');
+        try {
+            const content = await fs.readFile(defaultPath, 'utf-8');
+            const lines = content.split('\n');
+            for (const line of lines) {
+                const match = line.match(/^#\s+(.+)$/);
+                if (match) {
+                    researchTopic = match[1].trim();
+                    break;
+                }
+            }
+            if (!researchTopic)
+                researchTopic = content.slice(0, 100).trim();
+            if (!options.json)
+                console.log(`读取研究文件: ${defaultPath}`);
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'error', message: '请提供研究主题' }));
+            }
+            else {
+                console.log('请提供研究主题');
+                console.log('   用法: openmatrix research <topic>');
+                console.log('   或创建 RESEARCH.md 文件');
+            }
+            return;
+        }
+    }
+    // 创建初始会话 - 领域信息由 Agent 分析后更新
+    const session = {
+        status: 'initialized',
+        topic: researchTopic,
+        domain: '',
+        aspects: [],
+        estimatedQuestions: 0,
+        agents: [],
+        domainQuestions: [],
+        answers: {},
+        knowledge: [],
+        createdAt: new Date().toISOString()
+    };
+    await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+    if (options.json) {
+        console.log(JSON.stringify({
+            status: 'initialized',
+            message: '研究会话已创建，需要 AI 分析领域',
+            topic: researchTopic,
+            hint: '请使用 Agent 分析主题，识别领域和调研方向，然后更新会话并展示给用户确认'
+        }));
+    }
+    else {
+        console.log(`\n研究主题: ${researchTopic}`);
+        console.log('使用 /om:research 技能启动 AI 分析');
+    }
+});

package/dist/cli/commands/start.js

@@ -164,7 +164,11 @@ async function handleTasksJson(options, stateManager, state, omPath) {
     };
     // 解析质量配置
     const qualityLevel = tasksInput.quality || options.quality || 'balanced';
-    const qualityConfig = index_js_1.QUALITY_PRESETS[qualityLevel.toLowerCase()] || index_js_1.QUALITY_PRESETS.balanced;
+    const qualityConfig = { ...(index_js_1.QUALITY_PRESETS[qualityLevel.toLowerCase()] || index_js_1.QUALITY_PRESETS.balanced) };
+    // E2E 测试覆盖（用户在 Skill 问答中选择启用）
+    if (tasksInput.e2eTests) {
+        qualityConfig.e2eTests = true;
+    }
     if (!options.json) {
         console.log(`\n📋 任务: ${parsedTask.title}`);
         console.log(`   目标: ${parsedTask.goals.join(', ')}`);

package/dist/cli/index.js

@@ -15,6 +15,7 @@ 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 brainstorm_js_1 = require("./commands/brainstorm.js");
+const research_js_1 = require("./commands/research.js");
 const complete_js_1 = require("./commands/complete.js");
 const step_js_1 = require("./commands/step.js");
 const program = new commander_1.Command();
@@ -38,5 +39,6 @@ program.addCommand(check_js_1.checkCommand);
 program.addCommand(check_gitignore_js_1.checkGitignoreCommand);
 program.addCommand(analyze_js_1.analyzeCommand);
 program.addCommand(brainstorm_js_1.brainstormCommand);
+program.addCommand(research_js_1.researchCommand);
 // 默认帮助
 program.parse();

package/dist/orchestrator/phase-executor.js

@@ -702,6 +702,13 @@ ACCEPT_FAILED
                 updates.status = 'completed';
             }
             await this.stateManager.updateTask(task.id, updates);
+            // 持久化 Phase 结果到磁盘
+            await this.stateManager.savePhaseResult(task.id, phase, {
+                success: true,
+                output: result.output,
+                phaseStatus: 'completed',
+                completedAt: now
+            });
             // 自动提交代码
             if (this.runId) {
                 try {
@@ -740,6 +747,13 @@ ACCEPT_FAILED
                 status: 'failed',
                 error: result.error || `${phase} phase failed`
             });
+            // 持久化失败结果
+            await this.stateManager.savePhaseResult(task.id, phase, {
+                success: false,
+                error: result.error || `${phase} phase failed`,
+                phaseStatus: 'failed',
+                failedAt: now
+            });
             return {
                 phase,
                 success: false,

package/dist/storage/state-manager.d.ts

@@ -17,6 +17,22 @@ export declare class StateManager {
     getTask(taskId: string): Promise<Task | null>;
     updateTask(taskId: string, updates: Partial<Task>): Promise<void>;
     listTasks(): Promise<Task[]>;
+    /**
+     * 保存 Phase 结果到任务子目录
+     */
+    savePhaseResult(taskId: string, phase: string, result: Record<string, unknown>): Promise<void>;
+    /**
+     * 读取 Phase 结果
+     */
+    getPhaseResult(taskId: string, phase: string): Promise<Record<string, unknown> | null>;
+    /**
+     * 保存 Agent 上下文到 context.md
+     */
+    saveTaskContext(taskId: string, content: string): Promise<void>;
+    /**
+     * 读取 Agent 上下文
+     */
+    getTaskContext(taskId: string): Promise<string | null>;
     private updateTaskStatistics;
     private generateRunId;
     private generateTaskId;

package/dist/storage/state-manager.js

@@ -74,7 +74,9 @@ class StateManager {
             createdAt: now,
             updatedAt: now
         };
-        await this.store.writeJson(`tasks/${taskId}.json`, task);
+        await this.store.writeJson(`tasks/${taskId}/task.json`, task);
+        // Create artifacts subdirectory
+        await this.store.ensureDir(`tasks/${taskId}/artifacts`);
         // Update statistics
         const state = await this.getState();
         await this.updateState({
@@ -87,7 +89,12 @@ class StateManager {
         return task;
     }
     async getTask(taskId) {
-        return await this.store.readJson(`tasks/${taskId}.json`);
+        // Try subdirectory structure first, fall back to flat file
+        let task = await this.store.readJson(`tasks/${taskId}/task.json`);
+        if (!task) {
+            task = await this.store.readJson(`tasks/${taskId}.json`);
+        }
+        return task;
     }
     async updateTask(taskId, updates) {
         const task = await this.getTask(taskId);
@@ -99,22 +106,67 @@ class StateManager {
             ...updates,
             updatedAt: new Date().toISOString()
         };
-        await this.store.writeJson(`tasks/${taskId}.json`, updatedTask);
+        // Always write to subdirectory structure
+        await this.store.writeJson(`tasks/${taskId}/task.json`, updatedTask);
         // Update statistics if status changed
         if (updates.status && updates.status !== oldStatus) {
             await this.updateTaskStatistics(oldStatus, updates.status);
         }
     }
     async listTasks() {
-        const files = await this.store.listFiles('tasks');
         const tasks = [];
-        for (const file of files) {
-            const task = await this.store.readJson(`tasks/${file}`);
+        // Read from subdirectory structure: tasks/TASK-XXX/task.json
+        const dirs = await this.store.listDirs('tasks');
+        for (const dir of dirs) {
+            const task = await this.store.readJson(`tasks/${dir}/task.json`);
             if (task)
                 tasks.push(task);
         }
+        // Also check flat files (backward compat)
+        const files = await this.store.listFiles('tasks');
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const task = await this.store.readJson(`tasks/${file}`);
+            if (task) {
+                // Avoid duplicate if already found in subdirectory
+                if (!tasks.some(t => t.id === task.id)) {
+                    tasks.push(task);
+                }
+            }
+        }
         return tasks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
     }
+    // ============ Task Artifact Methods ============
+    /**
+     * 保存 Phase 结果到任务子目录
+     */
+    async savePhaseResult(taskId, phase, result) {
+        await this.store.writeJson(`tasks/${taskId}/${phase}.json`, {
+            taskId,
+            phase,
+            timestamp: new Date().toISOString(),
+            ...result
+        });
+    }
+    /**
+     * 读取 Phase 结果
+     */
+    async getPhaseResult(taskId, phase) {
+        return await this.store.readJson(`tasks/${taskId}/${phase}.json`);
+    }
+    /**
+     * 保存 Agent 上下文到 context.md
+     */
+    async saveTaskContext(taskId, content) {
+        await this.store.writeMarkdown(`tasks/${taskId}/context.md`, content);
+    }
+    /**
+     * 读取 Agent 上下文
+     */
+    async getTaskContext(taskId) {
+        return await this.store.readMarkdown(`tasks/${taskId}/context.md`);
+    }
     async updateTaskStatistics(oldStatus, newStatus) {
         const state = await this.getState();
         const stats = { ...state.statistics };

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export type TaskStatus = 'pending' | 'scheduled' | 'in_progress' | 'blocked' | 'waiting' | 'verify' | 'accept' | 'completed' | 'failed' | 'retry_queue';
 export type TaskPriority = 'P0' | 'P1' | 'P2' | 'P3';
+export type ResearchMode = 'domain' | 'tech' | 'problem';
 export interface TaskPhase {
     status: TaskStatus;
     duration: number | null;
@@ -201,3 +202,38 @@ export interface ParsedTask {
     deliverables: string[];
     rawContent: string;
 }
+export interface ResearchAgentConfig {
+    role: string;
+    focus: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    result?: string;
+}
+export interface ResearchQuestion {
+    id: string;
+    question: string;
+    header: string;
+    options: Array<{
+        label: string;
+        description: string;
+    }>;
+    multiSelect: boolean;
+}
+export interface ResearchSession {
+    status: 'initialized' | 'preview' | 'researching' | 'questioning' | 'completed';
+    topic: string;
+    domain: string;
+    aspects: string[];
+    estimatedQuestions: number;
+    agents: ResearchAgentConfig[];
+    domainQuestions: ResearchQuestion[];
+    answers: Record<string, string | string[]>;
+    report?: string;
+    knowledge: string[];
+    context?: {
+        goals: string[];
+        constraints: string[];
+        deliverables: string[];
+    };
+    createdAt: string;
+    completedAt?: string;
+}

package/package.json

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

package/skills/brainstorm.md

@@ -25,20 +25,37 @@ description: 头脑风暴 - 探索需求和设计后再执行任务
      "status": "brainstorming",
      "message": "开始头脑风暴",
      "taskTitle": "任务标题",
-     "questions": [
-       {
-         "id": "core_objective",
-         "question": "这个任务的核心目标是什么？",
-         "header": "核心目标",
-         "options": [...],
-         "multiSelect": false
-       }
-     ],
+     "questions": [...],
+     "suggestResearch": "游戏开发",
+     "researchHint": "检测到垂直领域「游戏开发」，建议先进行领域调研",
      "hint": "请逐一回答问题，完成后再调用 --complete"
    }
    ```
 
-2. **交互式问答**
+2. **检测垂直领域** (如果 suggestResearch 存在)
+
+   如果 CLI 返回了 `suggestResearch` 字段，说明检测到垂直领域:
+
+   ```typescript
+   if (result.suggestResearch) {
+     AskUserQuestion({
+       questions: [{
+         question: `检测到垂直领域「${result.suggestResearch}」，建议先进行领域调研。\n\n领域调研可以帮助您:\n• 了解行业最佳实践\n• 获取技术方案建议\n• 生成领域专属文档 (如 GDD/PRD)\n\n是否进入领域调研？`,
+         header: "领域调研",
+         options: [
+           { label: "进入调研 (推荐)", description: "启动 /om:research 进行深度调研" },
+           { label: "跳过调研", description: "直接进行头脑风暴问答" }
+         ],
+         multiSelect: false
+       }]
+     })
+   }
+   ```
+
+   - 如果用户选择"进入调研"，调用 `/om:research`，研究完成后自动返回 start
+   - 如果用户选择"跳过调研"，继续下面的问答流程
+
+3. **交互式问答**
 
    对每个问题使用 `AskUserQuestion` 进行提问:
 
@@ -58,7 +75,7 @@ description: 头脑风暴 - 探索需求和设计后再执行任务
    - 记录可能的设计决策
    - 识别潜在风险
 
-3. **深入追问** (可选)
+4. **深入追问** (可选)
 
    如果用户选择了"其他"或回答不够清晰，进行追问:
    ```typescript
@@ -71,7 +88,7 @@ description: 头脑风暴 - 探索需求和设计后再执行任务
    })
    ```
 
-4. **总结头脑风暴结果**
+5. **总结头脑风暴结果**
 
    所有问题回答完成后，总结:
    - 核心目标
@@ -121,15 +138,64 @@ description: 头脑风暴 - 探索需求和设计后再执行任务
    })
    ```
 
-6. **自动执行 start**
+6. **智能检测 .openmatrix 状态后执行**
+
+   **先检测当前状态:**
+   ```bash
+   # 检查 .openmatrix 目录是否存在
+   ls .openmatrix/state.json 2>/dev/null
+   ```
+
+   **根据状态走不同路径:**
+
+   | .openmatrix 状态 | 处理方式 |
+   |-----------------|---------|
+   | 不存在 | 全新开始 → init → 写 tasks-input → CLI start |
+   | 存在，`status: completed` | 清理旧数据后重新开始 → 写 tasks-input → CLI start |
+   | 存在，`status: running` | 提示用户先完成或暂停当前任务 |
+   | 存在，`status: paused` | 询问用户：继续上次任务 还是 开始新任务 |
+   | 存在，`status: initialized` | 直接写 tasks-input → CLI start |
+
+   **路径 A: 全新开始 / 重新开始**
+   ```bash
+   # 初始化 (如果不存在)
+   openmatrix start --init-only
+
+   # 如果是重新开始，清理旧数据
+   # rm -rf .openmatrix/tasks/ .openmatrix/approvals/ .openmatrix/meetings/
+   ```
+
+   **将头脑风暴结论转换为 goals:**
+   ```json
+   {
+     "title": "任务标题",
+     "description": "基于头脑风暴的整体描述",
+     "goals": [
+       "目标1: 独立功能模块",
+       "目标2: 独立功能模块",
+       "..."
+     ],
+     "constraints": ["约束"],
+     "deliverables": ["交付物"],
+     "answers": { "问答答案" },
+     "quality": "strict/balanced/fast",
+     "mode": "auto",
+     "plan": "## 技术方案\n..."
+   }
+   ```
+
+   写入 `.openmatrix/tasks-input.json` 后执行:
+   ```bash
+   openmatrix start --tasks-json @.openmatrix/tasks-input.json --json
+   ```
+
+   **路径 B: 继续上次任务**
+   ```bash
+   openmatrix step --json
+   ```
+   从返回的 next task 继续执行。
 
-   如果用户选择"开始执行":
-   - 调用 CLI 标记头脑风暴完成:
-     ```bash
-     openmatrix brainstorm --complete --json
-     ```
-   - 自动调用 `/om:start` 开始执行任务
-   - 将头脑风暴收集的洞察传递给 start
+   **最终：从 CLI 返回的 `subagentTasks` 开始逐个执行 Agent**
 
 </process>