@minko-ai/minko 0.1.0 → 0.1.1

package/dist/agent/lanes.js

@@ -0,0 +1,511 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { minkoHome } from "../config/paths.js";
+import { WorkerRegistry } from "./workers.js";
+import { BranchLockStore } from "./branchLock.js";
+/**
+ * Git-worktree lanes: each lane is an isolated branch + directory with a
+ * writable worker. Main-tree files are never touched by the worker.
+ */
+export class LaneRegistry {
+    options;
+    workers;
+    stateDir;
+    lanes = new Map();
+    sequence = 0;
+    locks;
+    constructor(options) {
+        this.options = options;
+        this.stateDir = options.stateDir ?? path.join(minkoHome(), 'lanes');
+        this.locks = options.lockStore ?? new BranchLockStore(path.join(this.stateDir, 'locks'));
+        this.workers = new WorkerRegistry({
+            getProvider: options.getProvider,
+            getConfig: options.getConfig,
+            cwd: options.cwd,
+            approve: options.approve,
+            storeDir: path.join(this.stateDir, 'workers'),
+            approvalStore: options.approvalStore,
+        });
+        this.loadIndex();
+    }
+    create(input) {
+        const prompt = input.prompt.trim();
+        if (prompt.length === 0) {
+            throw new Error('缺少 prompt 参数');
+        }
+        const repo = git(cwdPath(this.options.cwd), ['rev-parse', '--show-toplevel']);
+        if (repo.length === 0) {
+            throw new Error('lane 需要在一个 git 仓库里运行');
+        }
+        this.sequence += 1;
+        const id = 'l-' + Date.now().toString(36) + '-' + this.sequence.toString(36);
+        const branch = 'minko/lane-' + id;
+        const repoKey = crypto.createHash('sha1').update(repo).digest('hex').slice(0, 8);
+        const dir = path.join(this.stateDir, repoKey, id);
+        fs.mkdirSync(path.dirname(dir), { recursive: true });
+        this.locks.acquire(repo, branch, 'lane:' + id);
+        try {
+            git(repo, ['worktree', 'add', '-b', branch, dir, 'HEAD']);
+        }
+        catch (error) {
+            this.locks.release(repo, branch, 'lane:' + id);
+            throw error;
+        }
+        const record = {
+            id,
+            name: input.name?.trim() || id,
+            repo,
+            branch,
+            dir,
+            createdAt: new Date().toISOString(),
+        };
+        try {
+            const worker = this.workers.create({
+                prompt: lanePrompt(record, prompt),
+                name: 'lane:' + id,
+                cwd: dir,
+                allowWrite: true,
+            });
+            record.workerId = worker.id;
+        }
+        catch (error) {
+            try {
+                git(repo, ['worktree', 'remove', '--force', dir]);
+            }
+            catch { /* best effort */ }
+            this.locks.release(repo, branch, 'lane:' + id);
+            throw error;
+        }
+        this.lanes.set(id, record);
+        this.saveIndex();
+        return this.info(record);
+    }
+    list() {
+        return [...this.lanes.values()]
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+            .map((record) => this.info(record));
+    }
+    get(id) {
+        const record = this.lanes.get(id);
+        return record ? this.info(record) : null;
+    }
+    async wait(id, timeoutMs = 300_000) {
+        const record = this.require(id);
+        if (record.workerId) {
+            await this.workers.wait(record.workerId, timeoutMs);
+        }
+        return this.info(record);
+    }
+    status(id) {
+        const record = this.require(id);
+        const info = this.info(record);
+        let worktree = '';
+        try {
+            worktree = git(record.dir, ['status', '--short']);
+        }
+        catch (error) {
+            worktree = '（无法读取 worktree：' + errorMessage(error) + '）';
+        }
+        return [
+            info.id + ' [' + info.state + '] ' + info.name,
+            '分支：' + info.branch,
+            '目录：' + info.dir,
+            info.result ? '结果：\n' + info.result : '',
+            info.error ? '错误：' + info.error : '',
+            '工作区：\n' + (worktree.trim() || '（干净）'),
+        ].filter((line) => line.length > 0).join('\n');
+    }
+    diff(id) {
+        const record = this.require(id);
+        const status = git(record.dir, ['status', '--short']);
+        const stat = git(record.dir, ['diff', '--stat']);
+        const diff = git(record.dir, ['diff']);
+        return [
+            '状态：\n' + (status.trim() || '（干净）'),
+            '差异统计：\n' + (stat.trim() || '（无）'),
+            '差异：\n' + (diff.trim() ? cap(diff.trim(), 20_000) : '（无）'),
+            '未跟踪文件不会出现在 diff 中，请看状态列表。',
+        ].join('\n\n');
+    }
+    async merge(id, options = {}) {
+        const record = this.require(id);
+        const worker = record.workerId ? this.workers.get(record.workerId) : null;
+        if (worker && (worker.state === 'running' || worker.state === 'queued')) {
+            throw new Error('lane worker 还没有完成，先 lane_wait');
+        }
+        // Commit whatever the worker wrote inside the isolated worktree.
+        const laneStatus = git(record.dir, ['status', '--porcelain']);
+        if (laneStatus.trim().length > 0) {
+            git(record.dir, ['add', '-A']);
+            git(record.dir, [
+                '-c', 'user.name=Minko',
+                '-c', 'user.email=minko@localhost',
+                'commit', '-m', 'minko lane: ' + record.name + ' (' + record.id + ')',
+            ]);
+        }
+        const target = git(record.repo, ['rev-parse', '--abbrev-ref', 'HEAD']);
+        const dirty = git(record.repo, ['status', '--porcelain']);
+        if (dirty.trim().length > 0 && options.allowDirty !== true) {
+            throw new Error('主工作区有未提交改动；先提交，或传 allow_dirty: true');
+        }
+        const ahead = Number(git(record.repo, ['rev-list', '--count', target + '..' + record.branch]));
+        if (ahead === 0) {
+            await this.cleanup(record, options.deleteBranch !== false);
+            return { branch: record.branch, mergedInto: target, noChanges: true };
+        }
+        this.locks.acquire(record.repo, target, 'lane-merge:' + record.id);
+        try {
+            const strategy = options.strategy ?? 'merge';
+            if (strategy === 'squash') {
+                git(record.repo, ['merge', '--squash', record.branch]);
+                git(record.repo, [
+                    '-c', 'user.name=Minko',
+                    '-c', 'user.email=minko@localhost',
+                    'commit', '-m', 'minko lane: ' + record.name + ' (' + record.id + ')',
+                ]);
+            }
+            else if (strategy === 'ff') {
+                git(record.repo, ['merge', '--ff-only', record.branch]);
+            }
+            else {
+                git(record.repo, [
+                    'merge', '--no-ff', record.branch,
+                    '-m', 'minko lane: ' + record.name + ' (' + record.id + ')',
+                ]);
+            }
+        }
+        catch (error) {
+            try {
+                git(record.repo, ['merge', '--abort']);
+            }
+            catch { /* nothing to abort */ }
+            throw new Error('合并失败（已 abort）：' + errorMessage(error));
+        }
+        finally {
+            this.locks.release(record.repo, target, 'lane-merge:' + record.id);
+        }
+        let commit;
+        try {
+            commit = git(record.repo, ['rev-parse', 'HEAD']);
+        }
+        catch { /* optional */ }
+        await this.cleanup(record, options.deleteBranch !== false);
+        return { branch: record.branch, mergedInto: target, commit };
+    }
+    async cleanup(record, deleteBranch) {
+        if (record.workerId) {
+            this.workers.stop(record.workerId);
+            await this.workers.wait(record.workerId, 2_000).catch(() => null);
+        }
+        try {
+            git(record.repo, ['worktree', 'remove', '--force', record.dir]);
+        }
+        catch {
+            // The merged branch is still usable; a locked worktree can be pruned later.
+        }
+        if (deleteBranch) {
+            try {
+                git(record.repo, ['branch', '-D', record.branch]);
+            }
+            catch { /* keep branch */ }
+        }
+        this.locks.release(record.repo, record.branch);
+        this.lanes.delete(record.id);
+        this.saveIndex();
+    }
+    async close(id, keepBranch = false) {
+        const record = this.lanes.get(id);
+        if (!record) {
+            return false;
+        }
+        if (record.workerId) {
+            this.workers.stop(record.workerId);
+            await this.workers.wait(record.workerId, 2_000).catch(() => null);
+        }
+        try {
+            git(record.repo, ['worktree', 'remove', '--force', record.dir]);
+        }
+        catch {
+            return false;
+        }
+        if (!keepBranch) {
+            try {
+                git(record.repo, ['branch', '-D', record.branch]);
+            }
+            catch { /* keep branch */ }
+        }
+        this.locks.release(record.repo, record.branch);
+        this.lanes.delete(id);
+        this.saveIndex();
+        return true;
+    }
+    closeAll() {
+        this.workers.stopAll();
+    }
+    info(record) {
+        const worker = record.workerId ? this.workers.get(record.workerId) : null;
+        return {
+            ...record,
+            state: worker?.state ?? 'detached',
+            result: worker?.result,
+            error: worker?.error,
+        };
+    }
+    require(id) {
+        const record = this.lanes.get(id);
+        if (!record) {
+            throw new Error('找不到 lane：' + id);
+        }
+        return record;
+    }
+    indexFile() {
+        return path.join(this.stateDir, 'index.json');
+    }
+    loadIndex() {
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.indexFile(), 'utf8'));
+            if (!Array.isArray(raw.lanes)) {
+                return;
+            }
+            for (const item of raw.lanes) {
+                if (item === null || typeof item !== 'object') {
+                    continue;
+                }
+                const record = item;
+                if (typeof record.id !== 'string' || typeof record.repo !== 'string'
+                    || typeof record.branch !== 'string' || typeof record.dir !== 'string'
+                    || typeof record.name !== 'string' || typeof record.createdAt !== 'string') {
+                    continue;
+                }
+                this.lanes.set(record.id, {
+                    id: record.id,
+                    name: record.name,
+                    repo: record.repo,
+                    branch: record.branch,
+                    dir: record.dir,
+                    createdAt: record.createdAt,
+                });
+            }
+        }
+        catch {
+            // No index yet, or it is unreadable.
+        }
+    }
+    saveIndex() {
+        try {
+            fs.mkdirSync(this.stateDir, { recursive: true });
+            fs.writeFileSync(this.indexFile(), JSON.stringify({ lanes: [...this.lanes.values()] }, null, 2), 'utf8');
+        }
+        catch {
+            // Lane state is advisory; worktrees remain usable without the index.
+        }
+    }
+}
+/** Lane tools for the main agent. Writes still go through worker approval. */
+export function createLaneTools(registry) {
+    const create = {
+        readOnly: true,
+        spec: {
+            name: 'lane_create',
+            description: '在一个独立的 git worktree/branch 里启动写入 worker。不会改动主工作区；用 lane_diff 查看改动。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    prompt: { type: 'string', description: '交给 lane worker 的任务' },
+                    name: { type: 'string', description: '便于识别的短名称' },
+                },
+                required: ['prompt'],
+                additionalProperties: false,
+            },
+        },
+        async run(args, ctx) {
+            const prompt = typeof args.prompt === 'string' ? args.prompt : '';
+            if (ctx.planMode) {
+                throw new Error('计划模式不能创建 lane；先提交计划或退出计划模式');
+            }
+            const name = typeof args.name === 'string' ? args.name : undefined;
+            const lane = registry.create({ prompt, name });
+            return '已创建 lane ' + lane.id + '（' + lane.name + '）\n'
+                + '分支：' + lane.branch + '\n目录：' + lane.dir + '\n'
+                + 'worker：' + (lane.workerId ?? '-') + '\n用 lane_wait 等待结果，lane_diff 查看改动。';
+        },
+    };
+    const list = {
+        readOnly: true,
+        spec: {
+            name: 'lane_list',
+            description: '列出当前会话的 git worktree lane 及状态。',
+            parameters: { type: 'object', properties: {}, additionalProperties: false },
+        },
+        async run() {
+            const lanes = registry.list();
+            if (lanes.length === 0) {
+                return '还没有 lane。';
+            }
+            return lanes.map((lane) => lane.id + ' [' + lane.state + '] ' + lane.name
+                + ' · ' + lane.branch).join('\n');
+        },
+    };
+    const status = {
+        readOnly: true,
+        spec: {
+            name: 'lane_status',
+            description: '查看一个 lane 的 worker 状态、结果和 worktree 文件状态。',
+            parameters: {
+                type: 'object',
+                properties: { id: { type: 'string' } },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            return registry.status(requiredId(args));
+        },
+    };
+    const wait = {
+        readOnly: true,
+        spec: {
+            name: 'lane_wait',
+            description: '等待 lane worker 完成并返回状态与结果。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    timeout_ms: { type: 'number' },
+                },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            const timeout = typeof args.timeout_ms === 'number' && args.timeout_ms > 0
+                ? Math.floor(args.timeout_ms)
+                : 120_000;
+            const lane = await registry.wait(requiredId(args), timeout);
+            return lane.id + ' [' + lane.state + '] ' + lane.name
+                + (lane.result ? '\n' + lane.result : '')
+                + (lane.error ? '\n错误：' + lane.error : '');
+        },
+    };
+    const diff = {
+        readOnly: true,
+        spec: {
+            name: 'lane_diff',
+            description: '查看 lane 里的 git 状态、差异统计和 diff。',
+            parameters: {
+                type: 'object',
+                properties: { id: { type: 'string' } },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            return registry.diff(requiredId(args));
+        },
+    };
+    const close = {
+        readOnly: true,
+        spec: {
+            name: 'lane_close',
+            description: '停止 lane worker 并删除 worktree；默认也删除分支，keep_branch=true 时保留分支供手动合并。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    keep_branch: { type: 'boolean' },
+                },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            const removed = await registry.close(requiredId(args), args.keep_branch === true);
+            if (!removed) {
+                throw new Error('删除 worktree 失败；可能有进程仍占用目录');
+            }
+            return '已关闭 lane ' + requiredId(args);
+        },
+    };
+    const merge = {
+        readOnly: false,
+        needsApproval: () => true,
+        spec: {
+            name: 'lane_merge',
+            description: '提交 lane 里的改动并合并到当前分支；冲突时自动 abort 并保留 lane。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    strategy: { type: 'string', enum: ['merge', 'squash', 'ff'] },
+                    delete_branch: { type: 'boolean', description: '合并后删除 lane 分支，默认 true' },
+                    allow_dirty: { type: 'boolean', description: '允许主工作区有未提交改动' },
+                },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            const strategy = args.strategy === 'squash' || args.strategy === 'ff'
+                ? args.strategy
+                : 'merge';
+            const result = await registry.merge(requiredId(args), {
+                strategy,
+                deleteBranch: args.delete_branch !== false,
+                allowDirty: args.allow_dirty === true,
+            });
+            if (result.noChanges) {
+                return 'lane ' + result.branch + ' 没有改动可合并，已清理。';
+            }
+            return '已合并 ' + result.branch + ' → ' + result.mergedInto
+                + (result.commit ? ' · ' + result.commit.slice(0, 10) : '');
+        },
+    };
+    return [create, list, status, wait, diff, close, merge];
+}
+function requiredId(args) {
+    const id = typeof args.id === 'string' ? args.id.trim() : '';
+    if (id.length === 0) {
+        throw new Error('缺少 id 参数');
+    }
+    return id;
+}
+function lanePrompt(record, prompt) {
+    return [
+        '【Lane 任务】你正在一个独立的 git worktree 中工作。',
+        '目录：' + record.dir,
+        '分支：' + record.branch,
+        '只修改这个目录里的文件，不要碰主工作区。',
+        '完成后总结改了哪些文件、怎么验证。',
+        '',
+        prompt,
+    ].join('\n');
+}
+function cwdPath(cwd) {
+    return path.resolve(cwd);
+}
+function git(cwd, args) {
+    try {
+        return execFileSync('git', ['-C', cwd, ...args], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 20_000,
+            windowsHide: true,
+        }).trim();
+    }
+    catch (error) {
+        const stderr = error.stderr;
+        const detail = stderr ? stderr.toString().trim() : errorMessage(error);
+        throw new Error(detail || 'git 命令失败：' + args.join(' '));
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function cap(text, max) {
+    if (text.length <= max) {
+        return text;
+    }
+    return text.slice(0, max) + '\n…（diff 过长，已截断）';
+}