swarm-code 0.1.0

package/dist/worktree/manager.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Git worktree manager — creates isolated worktrees for thread execution.
+ *
+ * Phase 2 enhancements:
+ *   - Mutex on create() to prevent branch name races under concurrency
+ *   - Retry logic for git worktree add (transient lock file contention)
+ *
+ * Lifecycle:
+ *   1. create() — git worktree add -b swarm/<id> <path> HEAD
+ *   2. Agent runs in worktree directory
+ *   3. getDiff() — capture changes
+ *   4. commit() — commit changes in worktree
+ *   5. destroy() — git worktree remove + branch cleanup
+ */
+import type { WorktreeInfo } from "../core/types.js";
+export declare class WorktreeManager {
+    private repoRoot;
+    private baseDir;
+    private worktrees;
+    private createMutex;
+    constructor(repoRoot: string, baseDir?: string);
+    /** Ensure we're in a git repo and the base directory exists. */
+    init(): Promise<void>;
+    /**
+     * Create a new worktree for a thread.
+     * Serialized via mutex to prevent branch name races.
+     * Retries on transient lock-file contention.
+     */
+    create(threadId: string): Promise<WorktreeInfo>;
+    private createWorktreeWithRetry;
+    /** Get the git diff of uncommitted changes in a worktree. */
+    getDiff(threadId: string): Promise<string>;
+    /** Get diff stats (short summary). */
+    getDiffStats(threadId: string): Promise<string>;
+    /** Get list of changed files. */
+    getChangedFiles(threadId: string): Promise<string[]>;
+    /** Commit all changes in a worktree. */
+    commit(threadId: string, message: string): Promise<boolean>;
+    /** Destroy a worktree and optionally its branch. */
+    destroy(threadId: string, deleteBranch?: boolean): Promise<void>;
+    /** Get info for a thread's worktree. */
+    getWorktreeInfo(threadId: string): WorktreeInfo | undefined;
+    /** Cleanup all worktrees. Resilient — continues past individual failures. */
+    destroyAll(): Promise<void>;
+}

package/dist/worktree/manager.js

@@ -0,0 +1,266 @@
+/**
+ * Git worktree manager — creates isolated worktrees for thread execution.
+ *
+ * Phase 2 enhancements:
+ *   - Mutex on create() to prevent branch name races under concurrency
+ *   - Retry logic for git worktree add (transient lock file contention)
+ *
+ * Lifecycle:
+ *   1. create() — git worktree add -b swarm/<id> <path> HEAD
+ *   2. Agent runs in worktree directory
+ *   3. getDiff() — capture changes
+ *   4. commit() — commit changes in worktree
+ *   5. destroy() — git worktree remove + branch cleanup
+ */
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import * as path from "node:path";
+function git(args, cwd) {
+    return new Promise((resolve, reject) => {
+        execFile("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err) {
+                reject(new Error(`git ${args[0]} failed: ${stderr || err.message}`));
+            }
+            else {
+                resolve({ stdout, stderr });
+            }
+        });
+    });
+}
+/** Simple async mutex — only one holder at a time. */
+class Mutex {
+    locked = false;
+    waiters = [];
+    async acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return;
+        }
+        await new Promise((resolve) => this.waiters.push(resolve));
+        this.locked = true;
+    }
+    release() {
+        this.locked = false;
+        const next = this.waiters.shift();
+        if (next)
+            next();
+    }
+}
+const WORKTREE_CREATE_RETRIES = 3;
+const WORKTREE_RETRY_DELAY_MS = 500;
+export class WorktreeManager {
+    repoRoot;
+    baseDir;
+    worktrees = new Map();
+    createMutex = new Mutex();
+    constructor(repoRoot, baseDir = ".swarm-worktrees") {
+        this.repoRoot = repoRoot;
+        this.baseDir = path.isAbsolute(baseDir) ? baseDir : path.join(repoRoot, baseDir);
+    }
+    /** Ensure we're in a git repo and the base directory exists. */
+    async init() {
+        try {
+            await git(["rev-parse", "--git-dir"], this.repoRoot);
+        }
+        catch {
+            throw new Error(`Not a git repository: ${this.repoRoot}`);
+        }
+        if (!existsSync(this.baseDir)) {
+            mkdirSync(this.baseDir, { recursive: true });
+        }
+        // Add base dir to .gitignore if not already
+        const gitignorePath = path.join(this.repoRoot, ".gitignore");
+        const baseDirRelative = path.relative(this.repoRoot, this.baseDir);
+        try {
+            const { readFileSync, appendFileSync } = await import("node:fs");
+            let content = "";
+            if (existsSync(gitignorePath)) {
+                content = readFileSync(gitignorePath, "utf-8");
+            }
+            if (!content.includes(baseDirRelative)) {
+                appendFileSync(gitignorePath, `\n# Swarm worktrees\n${baseDirRelative}/\n`);
+            }
+        }
+        catch {
+            // Non-fatal — .gitignore might be read-only
+        }
+    }
+    /**
+     * Create a new worktree for a thread.
+     * Serialized via mutex to prevent branch name races.
+     * Retries on transient lock-file contention.
+     */
+    async create(threadId) {
+        await this.createMutex.acquire();
+        try {
+            return await this.createWorktreeWithRetry(threadId);
+        }
+        finally {
+            this.createMutex.release();
+        }
+    }
+    async createWorktreeWithRetry(threadId) {
+        const branch = `swarm/${threadId}`;
+        const wtPath = path.join(this.baseDir, `wt-${threadId}`);
+        // Remove stale worktree if it exists
+        if (existsSync(wtPath)) {
+            try {
+                await git(["worktree", "remove", "--force", wtPath], this.repoRoot);
+            }
+            catch {
+                rmSync(wtPath, { recursive: true, force: true });
+            }
+        }
+        // Delete stale branch if exists
+        try {
+            await git(["branch", "-D", branch], this.repoRoot);
+        }
+        catch {
+            // Branch didn't exist — fine
+        }
+        // Create worktree with retry for lock-file contention
+        let lastErr;
+        for (let attempt = 1; attempt <= WORKTREE_CREATE_RETRIES; attempt++) {
+            try {
+                await git(["worktree", "add", "-b", branch, wtPath, "HEAD"], this.repoRoot);
+                const info = { id: threadId, path: wtPath, branch };
+                this.worktrees.set(threadId, info);
+                return info;
+            }
+            catch (err) {
+                lastErr = err instanceof Error ? err : new Error(String(err));
+                const isLockError = lastErr.message.includes(".lock") ||
+                    lastErr.message.includes("Unable to create") ||
+                    lastErr.message.includes("index.lock");
+                if (isLockError && attempt < WORKTREE_CREATE_RETRIES) {
+                    // Wait with jitter before retrying
+                    const delay = WORKTREE_RETRY_DELAY_MS * attempt + Math.random() * 200;
+                    await new Promise((r) => setTimeout(r, delay));
+                    continue;
+                }
+                throw lastErr;
+            }
+        }
+        throw lastErr || new Error("Failed to create worktree");
+    }
+    /** Get the git diff of uncommitted changes in a worktree. */
+    async getDiff(threadId) {
+        const info = this.worktrees.get(threadId);
+        if (!info)
+            throw new Error(`No worktree for thread ${threadId}`);
+        // Stage all changes first to include new files in diff
+        try {
+            await git(["add", "-A"], info.path);
+        }
+        catch {
+            // Might be empty
+        }
+        const { stdout: fullDiff } = await git(["diff", "--cached"], info.path);
+        return fullDiff || "(no changes)";
+    }
+    /** Get diff stats (short summary). */
+    async getDiffStats(threadId) {
+        const info = this.worktrees.get(threadId);
+        if (!info)
+            throw new Error(`No worktree for thread ${threadId}`);
+        try {
+            await git(["add", "-A"], info.path);
+        }
+        catch {
+            /* empty */
+        }
+        const { stdout } = await git(["diff", "--cached", "--stat"], info.path);
+        return stdout.trim() || "(no changes)";
+    }
+    /** Get list of changed files. */
+    async getChangedFiles(threadId) {
+        const info = this.worktrees.get(threadId);
+        if (!info)
+            throw new Error(`No worktree for thread ${threadId}`);
+        try {
+            await git(["add", "-A"], info.path);
+        }
+        catch {
+            /* empty */
+        }
+        const { stdout } = await git(["diff", "--cached", "--name-only"], info.path);
+        return stdout.trim().split("\n").filter(Boolean);
+    }
+    /** Commit all changes in a worktree. */
+    async commit(threadId, message) {
+        const info = this.worktrees.get(threadId);
+        if (!info)
+            throw new Error(`No worktree for thread ${threadId}`);
+        try {
+            await git(["add", "-A"], info.path);
+            const { stdout: status } = await git(["status", "--porcelain"], info.path);
+            if (!status.trim())
+                return false; // Nothing to commit
+            await git(["commit", "-m", message], info.path);
+            return true;
+        }
+        catch (err) {
+            // Nothing to commit is fine
+            if (String(err).includes("nothing to commit"))
+                return false;
+            throw err;
+        }
+    }
+    /** Destroy a worktree and optionally its branch. */
+    async destroy(threadId, deleteBranch = false) {
+        const info = this.worktrees.get(threadId);
+        if (!info)
+            return;
+        try {
+            await git(["worktree", "remove", "--force", info.path], this.repoRoot);
+        }
+        catch {
+            // Force remove the directory if git worktree remove fails
+            if (existsSync(info.path)) {
+                rmSync(info.path, { recursive: true, force: true });
+            }
+            // Prune stale worktree entries
+            try {
+                await git(["worktree", "prune"], this.repoRoot);
+            }
+            catch {
+                /* non-fatal */
+            }
+        }
+        if (deleteBranch) {
+            try {
+                await git(["branch", "-D", info.branch], this.repoRoot);
+            }
+            catch {
+                // Branch already gone
+            }
+        }
+        this.worktrees.delete(threadId);
+    }
+    /** Get info for a thread's worktree. */
+    getWorktreeInfo(threadId) {
+        return this.worktrees.get(threadId);
+    }
+    /** Cleanup all worktrees. Resilient — continues past individual failures. */
+    async destroyAll() {
+        for (const [id] of this.worktrees) {
+            try {
+                await this.destroy(id, true);
+            }
+            catch {
+                // Continue cleaning up remaining worktrees
+            }
+        }
+        // Remove base directory if empty
+        try {
+            const { readdirSync } = await import("node:fs");
+            if (existsSync(this.baseDir) && readdirSync(this.baseDir).length === 0) {
+                rmSync(this.baseDir, { recursive: true, force: true });
+            }
+        }
+        catch {
+            /* non-fatal */
+        }
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/worktree/merge.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Merge thread branches back into the main branch.
+ *
+ * Phase 2 enhancements:
+ *   - Partial merge: continues merging non-conflicting branches after a conflict
+ *   - Conflict hunks: captures the actual diff of conflicted files
+ *   - Merge ordering: accepts optional order array from orchestrator
+ */
+import type { MergeResult, ThreadState } from "../core/types.js";
+/**
+ * Merge a single thread branch into the current branch.
+ * On conflict, captures the conflicted file list and diff hunks before aborting.
+ */
+export declare function mergeThreadBranch(repoRoot: string, branchName: string, threadId: string): Promise<MergeResult>;
+export interface MergeAllOptions {
+    /** Explicit merge order — thread IDs in desired merge sequence. */
+    order?: string[];
+    /** If true, continue merging remaining branches after a conflict (default: true). */
+    continueOnConflict?: boolean;
+}
+/**
+ * Merge all completed thread branches sequentially.
+ *
+ * Supports:
+ *   - Custom merge order via options.order
+ *   - Partial merge: by default continues past conflicts (skips conflicting branch)
+ */
+export declare function mergeAllThreads(repoRoot: string, threads: ThreadState[], options?: MergeAllOptions): Promise<MergeResult[]>;

package/dist/worktree/merge.js

@@ -0,0 +1,138 @@
+/**
+ * Merge thread branches back into the main branch.
+ *
+ * Phase 2 enhancements:
+ *   - Partial merge: continues merging non-conflicting branches after a conflict
+ *   - Conflict hunks: captures the actual diff of conflicted files
+ *   - Merge ordering: accepts optional order array from orchestrator
+ */
+import { execFile } from "node:child_process";
+function git(args, cwd) {
+    return new Promise((resolve, reject) => {
+        execFile("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err) {
+                // Include stdout in error message — git merge writes CONFLICT info to stdout
+                const detail = [stderr, stdout].filter((s) => s?.trim()).join("\n") || err.message;
+                reject(new Error(`git ${args[0]} failed: ${detail}`));
+            }
+            else {
+                resolve({ stdout, stderr });
+            }
+        });
+    });
+}
+/** Abort a merge safely, falling back to hard reset if --abort fails. */
+async function abortMergeSafe(repoRoot) {
+    try {
+        await git(["merge", "--abort"], repoRoot);
+    }
+    catch {
+        try {
+            await git(["reset", "--hard", "HEAD"], repoRoot);
+        }
+        catch {
+            /* last resort failed — repo may be in bad state */
+        }
+    }
+}
+/**
+ * Merge a single thread branch into the current branch.
+ * On conflict, captures the conflicted file list and diff hunks before aborting.
+ */
+export async function mergeThreadBranch(repoRoot, branchName, threadId) {
+    try {
+        const { stdout } = await git(["merge", "--no-ff", "-m", `swarm: merge thread ${threadId}`, branchName], repoRoot);
+        return {
+            success: true,
+            branch: branchName,
+            conflicts: [],
+            conflictDiff: "",
+            message: stdout.trim() || `Merged ${branchName}`,
+        };
+    }
+    catch (err) {
+        const errMsg = String(err);
+        // Check for merge conflicts
+        if (errMsg.includes("CONFLICT") || errMsg.includes("Merge conflict")) {
+            try {
+                // Get list of conflicted files
+                const { stdout: conflicted } = await git(["diff", "--name-only", "--diff-filter=U"], repoRoot);
+                const conflicts = conflicted.trim().split("\n").filter(Boolean);
+                // Capture the conflict diff (shows <<<<<<< markers)
+                let conflictDiff = "";
+                try {
+                    const { stdout: diff } = await git(["diff"], repoRoot);
+                    conflictDiff = diff.slice(0, 5000); // Cap at 5KB
+                }
+                catch {
+                    // diff might fail in weird states
+                }
+                // Abort the merge to restore clean state
+                await abortMergeSafe(repoRoot);
+                return {
+                    success: false,
+                    branch: branchName,
+                    conflicts,
+                    conflictDiff,
+                    message: `Merge conflicts in: ${conflicts.join(", ")}`,
+                };
+            }
+            catch {
+                await abortMergeSafe(repoRoot);
+                return {
+                    success: false,
+                    branch: branchName,
+                    conflicts: [],
+                    conflictDiff: "",
+                    message: errMsg,
+                };
+            }
+        }
+        return {
+            success: false,
+            branch: branchName,
+            conflicts: [],
+            conflictDiff: "",
+            message: errMsg,
+        };
+    }
+}
+/**
+ * Merge all completed thread branches sequentially.
+ *
+ * Supports:
+ *   - Custom merge order via options.order
+ *   - Partial merge: by default continues past conflicts (skips conflicting branch)
+ */
+export async function mergeAllThreads(repoRoot, threads, options = {}) {
+    const { order, continueOnConflict = true } = options;
+    const results = [];
+    // Filter to completed+successful threads with branches
+    const eligible = threads.filter((t) => t.status === "completed" && t.branchName && t.result?.success);
+    // Apply ordering if specified
+    let ordered;
+    if (order && order.length > 0) {
+        const orderMap = new Map(order.map((id, idx) => [id, idx]));
+        ordered = [...eligible].sort((a, b) => {
+            const aIdx = orderMap.get(a.id) ?? Infinity;
+            const bIdx = orderMap.get(b.id) ?? Infinity;
+            return aIdx - bIdx;
+        });
+    }
+    else {
+        // Default: merge in completion order (earliest first)
+        ordered = [...eligible].sort((a, b) => (a.completedAt || 0) - (b.completedAt || 0));
+    }
+    for (const thread of ordered) {
+        const result = await mergeThreadBranch(repoRoot, thread.branchName, thread.id);
+        results.push(result);
+        if (!result.success && !continueOnConflict) {
+            // Stop on first conflict (legacy behavior)
+            break;
+        }
+        // If conflict but continueOnConflict is true, we skip this branch
+        // and proceed to the next. The merge was already aborted in mergeThreadBranch.
+    }
+    return results;
+}
+//# sourceMappingURL=merge.js.map

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "swarm-code",
+  "version": "0.1.0",
+  "description": "Open-source swarm-native coding agent orchestrator — spawns parallel coding agents in isolated git worktrees, built on RLM (arXiv:2512.24601)",
+  "type": "module",
+  "bin": {
+    "swarm-code": "./bin/swarm.mjs",
+    "swarm": "./bin/swarm.mjs"
+  },
+  "main": "dist/main.js",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/core/runtime.py",
+    "bin"
+  ],
+  "scripts": {
+    "dev": "tsx src/main.ts",
+    "build": "tsc && cp src/core/runtime.py dist/core/",
+    "start": "node dist/main.js",
+    "cli": "tsx src/cli.ts",
+    "swarm": "tsx src/main.ts",
+    "bench:oolong": "tsx benchmarks/oolong_synth.ts",
+    "bench:longbench": "tsx benchmarks/longbench_narrativeqa.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "biome check src/ tests/",
+    "lint:fix": "biome check --fix src/ tests/",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "swarm",
+    "coding-agent",
+    "orchestrator",
+    "rlm",
+    "recursive-language-model",
+    "llm",
+    "cli",
+    "agent",
+    "opencode",
+    "worktree",
+    "parallel",
+    "ai"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/kingjulio8238/swarm-code#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kingjulio8238/swarm-code.git"
+  },
+  "dependencies": {
+    "@mariozechner/pi-ai": "^0.55.1",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.7",
+    "esbuild": "^0.27.3",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "overrides": {
+    "minimatch": ">=10.2.1"
+  }
+}