openmatrix 0.2.27 → 0.2.28

package/dist/orchestrator/git-commit-manager.d.ts

@@ -1,4 +1,5 @@
 import type { Task } from '../types/index.js';
+import { WorktreeSyncManager } from '../utils/worktree-sync.js';
 export interface CommitInfo {
     taskId: string;
     taskTitle: string;
@@ -25,6 +26,7 @@ export declare class GitCommitManager {
     private repoPath;
     private gitRoot;
     private enabled;
+    private worktreeSyncManager;
     constructor(repoPath?: string);
     /**
      * 获取 git 仓库根目录（支持 .git 在父级目录的情况）
@@ -107,4 +109,15 @@ export declare class GitCommitManager {
      * 提交验收阶段完成
      */
     commitAcceptComplete(task: Task, runId: string): Promise<CommitResult>;
+    /**
+     * 同步 worktree 改动到主工作树
+     *
+     * 当 Agent 在 worktree 中工作时，改动会提交到 worktree 的分支。
+     * 此方法将这些改动同步回主工作树，确保提交可见。
+     */
+    private syncWorktreeChanges;
+    /**
+     * 获取 WorktreeSyncManager 实例（供外部调用）
+     */
+    getWorktreeSyncManager(): WorktreeSyncManager;
 }

package/dist/orchestrator/git-commit-manager.js

@@ -41,6 +41,7 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs/promises"));
 const gitignore_js_1 = require("../utils/gitignore.js");
 const error_handler_js_1 = require("../utils/error-handler.js");
+const worktree_sync_js_1 = require("../utils/worktree-sync.js");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 /**
  * GitCommitManager - Git 自动提交管理器
@@ -54,8 +55,10 @@ class GitCommitManager {
     repoPath;
     gitRoot = null;
     enabled = true;
+    worktreeSyncManager;
     constructor(repoPath = process.cwd()) {
         this.repoPath = repoPath;
+        this.worktreeSyncManager = new worktree_sync_js_1.WorktreeSyncManager(repoPath);
     }
     /**
      * 获取 git 仓库根目录（支持 .git 在父级目录的情况）
@@ -329,6 +332,8 @@ class GitCommitManager {
             }
             // 确保 .gitignore 中包含 .openmatrix（写入到 git 根目录）
             await (0, gitignore_js_1.ensureOpenmatrixGitignore)(this.repoPath);
+            // 🔄 同步 worktree 改动到主工作树（关键步骤）
+            await this.syncWorktreeChanges();
             // 获取未提交的文件（用于生成 commit message，在 git add 之前获取）
             const files = await this.getUncommittedFiles();
             if (files.length === 0) {
@@ -449,5 +454,57 @@ class GitCommitManager {
             impactScope: []
         });
     }
+    /**
+     * 同步 worktree 改动到主工作树
+     *
+     * 当 Agent 在 worktree 中工作时，改动会提交到 worktree 的分支。
+     * 此方法将这些改动同步回主工作树，确保提交可见。
+     */
+    async syncWorktreeChanges() {
+        try {
+            // 检查是否有 Agent worktree
+            const hasChanges = await this.worktreeSyncManager.hasUnsyncedChanges();
+            if (!hasChanges) {
+                console.log('✅ 未检测到 worktree 改动，跳过同步');
+                return;
+            }
+            console.log('🔄 检测到 worktree 改动，开始同步...');
+            // 执行完整同步
+            const { syncResults, cleanupResults } = await this.worktreeSyncManager.fullSync();
+            // 输出同步结果
+            for (const result of syncResults) {
+                if (result.success && result.syncedFiles.length > 0) {
+                    console.log(`✅ 同步成功: ${result.syncedFiles.length} 个文件`);
+                    console.log(`   文件: ${result.syncedFiles.slice(0, 5).join(', ')}${result.syncedFiles.length > 5 ? '...' : ''}`);
+                    if (result.commitHash) {
+                        console.log(`   来源提交: ${result.commitHash}`);
+                    }
+                }
+                else if (result.error) {
+                    console.log(`⚠️ 同步跳过: ${result.error}`);
+                }
+            }
+            // 输出清理结果
+            for (const cleanup of cleanupResults) {
+                if (cleanup.success) {
+                    console.log(`🧹 清理 worktree: ${cleanup.path}`);
+                }
+                else {
+                    console.log(`⚠️ 清理失败: ${cleanup.path}`);
+                }
+            }
+        }
+        catch (error) {
+            // 同步失败不应该阻止提交，但需要记录警告
+            console.warn('⚠️ Worktree 同步失败:', error instanceof Error ? error.message : String(error));
+            (0, error_handler_js_1.logError)(error, { operation: 'syncWorktreeChanges', file: this.repoPath });
+        }
+    }
+    /**
+     * 获取 WorktreeSyncManager 实例（供外部调用）
+     */
+    getWorktreeSyncManager() {
+        return this.worktreeSyncManager;
+    }
 }
 exports.GitCommitManager = GitCommitManager;

package/dist/utils/gitignore.js

@@ -124,6 +124,8 @@ const GITIGNORE_TEMPLATES = {
     ],
     openmatrix: [
         '.openmatrix/',
+        '.claude/worktrees/',
+        '.playwright-mcp/',
     ],
 };
 /**

package/dist/utils/worktree-sync.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Worktree 同步结果
+ */
+export interface WorktreeSyncResult {
+    success: boolean;
+    syncedFiles: string[];
+    commitHash?: string;
+    branch?: string;
+    error?: string;
+}
+/**
+ * Worktree 信息
+ */
+export interface WorktreeInfo {
+    path: string;
+    branch: string;
+    commit: string;
+    isMain: boolean;
+}
+/**
+ * WorktreeSyncManager - 管理 Git Worktree 同步
+ *
+ * 当 Agent 在 worktree 中工作时，改动会提交到 worktree 的分支。
+ * 此类负责将这些改动同步回主工作树。
+ *
+ * 同步策略：
+ * 1. 检测 Agent 创建的 worktree
+ * 2. 获取 worktree 中的提交和改动文件
+ * 3. 将改动文件复制到主工作树（或 cherry-pick 提交）
+ * 4. 清理临时 worktree
+ */
+export declare class WorktreeSyncManager {
+    private repoPath;
+    private gitRoot;
+    constructor(repoPath?: string);
+    /**
+     * 获取 git 仓库根目录
+     */
+    private getGitRoot;
+    /**
+     * 列出所有 worktree
+     */
+    listWorktrees(): Promise<WorktreeInfo[]>;
+    /**
+     * 获取 Agent worktree 目录
+     *
+     * Claude Code 创建的 worktree 通常在 .claude/worktrees/ 目录下
+     */
+    getAgentWorktrees(): Promise<WorktreeInfo[]>;
+    /**
+     * 获取 worktree 相对于主工作树的改动
+     */
+    getWorktreeChanges(worktreePath: string): Promise<string[]>;
+    /**
+     * 获取 worktree 中最新提交的改动文件
+     */
+    getLatestCommitChanges(worktreePath: string): Promise<string[]>;
+    /**
+     * 同步 worktree 改动到主工作树
+     *
+     * 策略：
+     * 1. 获取 worktree 中已提交但未同步的改动
+     * 2. 将改动文件复制到主工作树
+     * 3. 在主工作树中暂存这些文件
+     *
+     * @param worktreePath worktree 路径（可选，不提供则自动检测所有 Agent worktree）
+     */
+    syncWorktreeToMain(worktreePath?: string): Promise<WorktreeSyncResult[]>;
+    /**
+     * Cherry-pick worktree 的提交到主工作树
+     *
+     * 替代方案：直接 cherry-pick worktree 的提交
+     * 适用于：改动较大、需要保留完整提交历史的场景
+     */
+    cherryPickWorktreeCommit(worktreePath: string): Promise<WorktreeSyncResult>;
+    /**
+     * 清理已同步的 worktree
+     */
+    cleanupWorktree(worktreePath: string): Promise<boolean>;
+    /**
+     * 完整的同步流程
+     *
+     * 1. 检测所有 Agent worktree
+     * 2. 同步改动到主工作树
+     * 3. 清理 worktree
+     *
+     * @returns 同步结果
+     */
+    fullSync(): Promise<{
+        syncResults: WorktreeSyncResult[];
+        cleanupResults: {
+            path: string;
+            success: boolean;
+        }[];
+    }>;
+    /**
+     * 检查是否有未同步的 worktree 改动
+     */
+    hasUnsyncedChanges(): Promise<boolean>;
+}

package/dist/utils/worktree-sync.js

@@ -0,0 +1,352 @@
+"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.WorktreeSyncManager = void 0;
+// src/utils/worktree-sync.ts
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const error_handler_js_1 = require("./error-handler.js");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * WorktreeSyncManager - 管理 Git Worktree 同步
+ *
+ * 当 Agent 在 worktree 中工作时，改动会提交到 worktree 的分支。
+ * 此类负责将这些改动同步回主工作树。
+ *
+ * 同步策略：
+ * 1. 检测 Agent 创建的 worktree
+ * 2. 获取 worktree 中的提交和改动文件
+ * 3. 将改动文件复制到主工作树（或 cherry-pick 提交）
+ * 4. 清理临时 worktree
+ */
+class WorktreeSyncManager {
+    repoPath;
+    gitRoot = null;
+    constructor(repoPath = process.cwd()) {
+        this.repoPath = repoPath;
+    }
+    /**
+     * 获取 git 仓库根目录
+     */
+    async getGitRoot() {
+        if (this.gitRoot)
+            return this.gitRoot;
+        try {
+            const { stdout } = await execAsync('git rev-parse --show-toplevel', { cwd: this.repoPath });
+            this.gitRoot = stdout.trim();
+        }
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'getGitRoot', file: this.repoPath });
+            this.gitRoot = this.repoPath;
+        }
+        return this.gitRoot;
+    }
+    /**
+     * 列出所有 worktree
+     */
+    async listWorktrees() {
+        try {
+            const { stdout } = await execAsync('git worktree list --porcelain', { cwd: this.repoPath });
+            const worktrees = [];
+            const lines = stdout.split('\n');
+            let current = {};
+            for (const line of lines) {
+                if (line.startsWith('worktree ')) {
+                    if (current.path) {
+                        worktrees.push({
+                            path: current.path,
+                            branch: current.branch || '',
+                            commit: current.commit || '',
+                            isMain: current.isMain || false
+                        });
+                    }
+                    current = { path: line.slice(9) };
+                    // 第一个 worktree 是主工作树
+                    current.isMain = worktrees.length === 0;
+                }
+                else if (line.startsWith('HEAD ')) {
+                    current.commit = line.slice(5);
+                }
+                else if (line.startsWith('branch ')) {
+                    current.branch = line.slice(7);
+                }
+            }
+            // 添加最后一个
+            if (current.path) {
+                worktrees.push({
+                    path: current.path,
+                    branch: current.branch || '',
+                    commit: current.commit || '',
+                    isMain: current.isMain || false
+                });
+            }
+            return worktrees;
+        }
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'listWorktrees', file: this.repoPath });
+            return [];
+        }
+    }
+    /**
+     * 获取 Agent worktree 目录
+     *
+     * Claude Code 创建的 worktree 通常在 .claude/worktrees/ 目录下
+     */
+    async getAgentWorktrees() {
+        const worktrees = await this.listWorktrees();
+        const gitRoot = await this.getGitRoot();
+        // 过滤出 Agent 创建的 worktree（通常以 agent- 开头或在 .claude/worktrees 下）
+        return worktrees.filter(w => !w.isMain &&
+            (w.path.includes('.claude/worktrees') || w.path.includes('agent-')));
+    }
+    /**
+     * 获取 worktree 相对于主工作树的改动
+     */
+    async getWorktreeChanges(worktreePath) {
+        try {
+            const gitRoot = await this.getGitRoot();
+            // 获取 worktree 相对于主分支的改动文件
+            const { stdout } = await execAsync(`git diff --name-only HEAD "${worktreePath}"`, { cwd: gitRoot });
+            return stdout.split('\n').filter(f => f.trim());
+        }
+        catch (error) {
+            // 如果上面的方法失败，尝试直接在 worktree 中获取未提交的改动
+            try {
+                const { stdout } = await execAsync('git diff --name-only HEAD', { cwd: worktreePath });
+                return stdout.split('\n').filter(f => f.trim());
+            }
+            catch (innerError) {
+                (0, error_handler_js_1.logError)(innerError, { operation: 'getWorktreeChanges', file: worktreePath });
+                return [];
+            }
+        }
+    }
+    /**
+     * 获取 worktree 中最新提交的改动文件
+     */
+    async getLatestCommitChanges(worktreePath) {
+        try {
+            // 在 worktree 中获取最新提交改动的文件
+            const { stdout } = await execAsync('git diff --name-only HEAD~1 HEAD', { cwd: worktreePath });
+            return stdout.split('\n').filter(f => f.trim());
+        }
+        catch (error) {
+            // 可能只有一个提交，尝试获取与初始提交的差异
+            try {
+                const { stdout } = await execAsync('git diff --name-only HEAD', { cwd: worktreePath });
+                return stdout.split('\n').filter(f => f.trim());
+            }
+            catch (innerError) {
+                (0, error_handler_js_1.logError)(innerError, { operation: 'getLatestCommitChanges', file: worktreePath });
+                return [];
+            }
+        }
+    }
+    /**
+     * 同步 worktree 改动到主工作树
+     *
+     * 策略：
+     * 1. 获取 worktree 中已提交但未同步的改动
+     * 2. 将改动文件复制到主工作树
+     * 3. 在主工作树中暂存这些文件
+     *
+     * @param worktreePath worktree 路径（可选，不提供则自动检测所有 Agent worktree）
+     */
+    async syncWorktreeToMain(worktreePath) {
+        const gitRoot = await this.getGitRoot();
+        const worktrees = worktreePath
+            ? [{ path: worktreePath, branch: '', commit: '', isMain: false }]
+            : await this.getAgentWorktrees();
+        if (worktrees.length === 0) {
+            return [{
+                    success: true,
+                    syncedFiles: [],
+                    error: 'No agent worktrees found'
+                }];
+        }
+        const results = [];
+        for (const wt of worktrees) {
+            try {
+                // 1. 获取改动文件
+                const changedFiles = await this.getLatestCommitChanges(wt.path);
+                if (changedFiles.length === 0) {
+                    results.push({
+                        success: true,
+                        syncedFiles: [],
+                        branch: wt.branch,
+                        error: 'No changes in worktree'
+                    });
+                    continue;
+                }
+                // 2. 复制文件到主工作树
+                const syncedFiles = [];
+                for (const file of changedFiles) {
+                    const srcPath = path.join(wt.path, file);
+                    const destPath = path.join(gitRoot, file);
+                    try {
+                        // 确保目标目录存在
+                        const destDir = path.dirname(destPath);
+                        await fs.mkdir(destDir, { recursive: true });
+                        // 复制文件
+                        await fs.copyFile(srcPath, destPath);
+                        syncedFiles.push(file);
+                    }
+                    catch (copyError) {
+                        (0, error_handler_js_1.logError)(copyError, { operation: 'copyFile', file: srcPath, metadata: { dest: destPath } });
+                    }
+                }
+                // 3. 在主工作树中暂存文件
+                if (syncedFiles.length > 0) {
+                    const filesArg = syncedFiles.map(f => `"${f}"`).join(' ');
+                    await execAsync(`git add ${filesArg}`, { cwd: gitRoot });
+                }
+                // 4. 获取 worktree 的最新提交 hash
+                let commitHash;
+                try {
+                    const { stdout } = await execAsync('git rev-parse HEAD', { cwd: wt.path });
+                    commitHash = stdout.trim();
+                }
+                catch { }
+                results.push({
+                    success: true,
+                    syncedFiles,
+                    commitHash,
+                    branch: wt.branch
+                });
+            }
+            catch (error) {
+                results.push({
+                    success: false,
+                    syncedFiles: [],
+                    branch: wt.branch,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Cherry-pick worktree 的提交到主工作树
+     *
+     * 替代方案：直接 cherry-pick worktree 的提交
+     * 适用于：改动较大、需要保留完整提交历史的场景
+     */
+    async cherryPickWorktreeCommit(worktreePath) {
+        const gitRoot = await this.getGitRoot();
+        try {
+            // 1. 获取 worktree 的最新提交 hash
+            const { stdout: commitHash } = await execAsync('git rev-parse HEAD', { cwd: worktreePath });
+            const hash = commitHash.trim();
+            // 2. 在主工作树中 cherry-pick 这个提交
+            await execAsync(`git cherry-pick ${hash} --no-commit`, { cwd: gitRoot });
+            // 3. 获取被 cherry-pick 的文件列表
+            const { stdout: files } = await execAsync('git diff --name-only --cached', { cwd: gitRoot });
+            const syncedFiles = files.split('\n').filter(f => f.trim());
+            return {
+                success: true,
+                syncedFiles,
+                commitHash: hash
+            };
+        }
+        catch (error) {
+            // Cherry-pick 可能失败（冲突），尝试放弃并返回错误
+            try {
+                await execAsync('git cherry-pick --abort', { cwd: gitRoot });
+            }
+            catch { }
+            return {
+                success: false,
+                syncedFiles: [],
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * 清理已同步的 worktree
+     */
+    async cleanupWorktree(worktreePath) {
+        try {
+            const gitRoot = await this.getGitRoot();
+            // 1. 移除 worktree
+            await execAsync(`git worktree remove "${worktreePath}" --force`, { cwd: gitRoot });
+            // 2. 清理可能的残留分支（如果是临时分支）
+            // 注意：不自动删除分支，因为可能还需要
+            return true;
+        }
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'cleanupWorktree', file: worktreePath });
+            return false;
+        }
+    }
+    /**
+     * 完整的同步流程
+     *
+     * 1. 检测所有 Agent worktree
+     * 2. 同步改动到主工作树
+     * 3. 清理 worktree
+     *
+     * @returns 同步结果
+     */
+    async fullSync() {
+        // 1. 同步
+        const syncResults = await this.syncWorktreeToMain();
+        // 2. 清理已成功同步的 worktree
+        const cleanupResults = [];
+        const worktrees = await this.getAgentWorktrees();
+        for (const wt of worktrees) {
+            const syncResult = syncResults.find(r => r.branch === wt.branch);
+            if (syncResult?.success && syncResult.syncedFiles.length > 0) {
+                const cleanupSuccess = await this.cleanupWorktree(wt.path);
+                cleanupResults.push({ path: wt.path, success: cleanupSuccess });
+            }
+        }
+        return { syncResults, cleanupResults };
+    }
+    /**
+     * 检查是否有未同步的 worktree 改动
+     */
+    async hasUnsyncedChanges() {
+        const worktrees = await this.getAgentWorktrees();
+        for (const wt of worktrees) {
+            const changes = await this.getLatestCommitChanges(wt.path);
+            if (changes.length > 0)
+                return true;
+        }
+        return false;
+    }
+}
+exports.WorktreeSyncManager = WorktreeSyncManager;

package/package.json

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

package/skills/auto.md

@@ -285,6 +285,11 @@ Agent({
 openmatrix complete TASK-XXX --success
 ```
 
+**注意**: `openmatrix complete` 会自动执行以下操作：
+1. 🔄 **同步 Worktree 改动** - 如果 Agent 在 worktree 中工作，自动将改动同步到主工作树
+2. 📝 **更新上下文** - 将执行摘要写入全局 context.md
+3. ✅ **标记完成** - 更新任务状态并触发 Git 提交
+
 3. **获取下一个任务（必须执行，防止上下文压缩丢失）:**
 ```bash
 openmatrix step --json