swarm-code 0.1.0

package/dist/agents/opencode.js

@@ -0,0 +1,571 @@
+/**
+ * OpenCode agent backend.
+ *
+ * Three execution modes (in priority order):
+ *   1. Server mode: Connects to a managed `opencode serve` instance via HTTP API.
+ *      Avoids cold-start overhead. Server is shared across threads.
+ *   2. Attach mode: Uses `opencode run --attach <url>` to connect to a running server.
+ *      Falls back here if direct HTTP API call fails.
+ *   3. Subprocess mode: Cold-starts `opencode run --format json` per invocation.
+ *      Always-available fallback.
+ *
+ * The server pool manages lifecycle of `opencode serve` processes, starting them
+ * lazily and shutting them down when the session ends.
+ */
+import { spawn } from "node:child_process";
+import * as http from "node:http";
+import * as os from "node:os";
+import { registerAgent } from "./provider.js";
+// ── Helpers ──────────────────────────────────────────────────────────────────
+async function commandExists(cmd) {
+    return new Promise((resolve) => {
+        const proc = spawn("which", [cmd], { stdio: "pipe" });
+        proc.on("close", (code) => resolve(code === 0));
+        proc.on("error", () => resolve(false));
+    });
+}
+/** Extract JSON object from mixed stdout (may contain non-JSON lines before/after). */
+function extractJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        /* mixed output — try extraction */
+    }
+    const firstBrace = raw.indexOf("{");
+    const lastBrace = raw.lastIndexOf("}");
+    if (firstBrace === -1 || lastBrace === -1 || lastBrace <= firstBrace)
+        return null;
+    try {
+        return JSON.parse(raw.slice(firstBrace, lastBrace + 1));
+    }
+    catch {
+        return null;
+    }
+}
+/** Extract output text, file changes, and token usage from parsed JSON. */
+function extractFromParsed(parsed) {
+    if (parsed.error) {
+        return { output: parsed.error, filesChanged: [], error: parsed.error };
+    }
+    let output = "";
+    const filesChanged = [];
+    if (parsed.messages) {
+        const assistantMsgs = parsed.messages.filter((m) => m.role === "assistant");
+        if (assistantMsgs.length > 0) {
+            output = assistantMsgs[assistantMsgs.length - 1].content;
+        }
+        for (const msg of parsed.messages) {
+            if (msg.tool_calls) {
+                for (const tc of msg.tool_calls) {
+                    if (tc.name === "write" || tc.name === "edit") {
+                        const filePath = tc.input.file_path || tc.input.path;
+                        if (typeof filePath === "string") {
+                            filesChanged.push(filePath);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Extract token usage from various possible locations
+    let usage;
+    const u = (parsed.usage || parsed.total_usage);
+    if (u) {
+        const inputTokens = u.input_tokens ?? u.prompt_tokens ?? 0;
+        const outputTokens = u.output_tokens ?? u.completion_tokens ?? 0;
+        if (inputTokens > 0 || outputTokens > 0) {
+            usage = {
+                inputTokens,
+                outputTokens,
+                totalTokens: u.total_tokens || inputTokens + outputTokens,
+            };
+        }
+    }
+    return { output, filesChanged: [...new Set(filesChanged)], usage };
+}
+/** Whitelist of env vars safe to pass to agent subprocess. */
+function buildAgentEnv() {
+    const homeDir = os.homedir();
+    return {
+        PATH: process.env.PATH,
+        HOME: homeDir,
+        USERPROFILE: homeDir,
+        SHELL: process.env.SHELL,
+        TERM: process.env.TERM,
+        LANG: process.env.LANG,
+        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+        OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+        GEMINI_API_KEY: process.env.GEMINI_API_KEY,
+        GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME,
+        GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL,
+        GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME,
+        GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL,
+        ...(process.env.SystemRoot ? { SystemRoot: process.env.SystemRoot } : {}),
+        ...(process.env.SYSTEMROOT ? { SYSTEMROOT: process.env.SYSTEMROOT } : {}),
+    };
+}
+/**
+ * Manages a pool of `opencode serve` processes.
+ * One server per unique working directory (worktree).
+ * Servers are started lazily and reused across thread invocations.
+ */
+class OpenCodeServerPool {
+    servers = new Map();
+    pendingStarts = new Map();
+    nextPort = 14096; // Start from a high port to avoid conflicts
+    shuttingDown = false;
+    /**
+     * Get or create a server for the given working directory.
+     * Returns the server URL if successful, null if server mode is unavailable.
+     * Uses pendingStarts to prevent race conditions from concurrent getServer() calls.
+     */
+    async getServer(cwd) {
+        if (this.shuttingDown)
+            return null;
+        const existing = this.servers.get(cwd);
+        if (existing) {
+            // Wait for it to be ready
+            try {
+                await existing.readyPromise;
+                // Verify still alive
+                if (existing.process.exitCode === null) {
+                    return existing.url;
+                }
+                // Dead — clean up and retry
+                this.servers.delete(cwd);
+            }
+            catch {
+                this.servers.delete(cwd);
+            }
+        }
+        // Prevent concurrent startServer for the same cwd
+        const pending = this.pendingStarts.get(cwd);
+        if (pending)
+            return pending;
+        const startPromise = this.startServer(cwd).finally(() => {
+            this.pendingStarts.delete(cwd);
+        });
+        this.pendingStarts.set(cwd, startPromise);
+        return startPromise;
+    }
+    async startServer(cwd) {
+        const port = this.nextPort++;
+        const hostname = "127.0.0.1";
+        let resolveReady;
+        let rejectReady;
+        const readyPromise = new Promise((resolve, reject) => {
+            resolveReady = resolve;
+            rejectReady = reject;
+        });
+        const proc = spawn("opencode", ["serve", "--port", String(port), "--hostname", hostname], {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: buildAgentEnv(),
+        });
+        const server = {
+            process: proc,
+            url: `http://${hostname}:${port}`,
+            port,
+            cwd,
+            ready: false,
+            readyPromise,
+        };
+        this.servers.set(cwd, server);
+        // Listen for stderr to detect "listening on" or ready signal
+        let stderr = "";
+        proc.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on("error", () => {
+            rejectReady(new Error("Failed to start opencode serve"));
+            this.servers.delete(cwd);
+        });
+        proc.on("exit", () => {
+            if (!server.ready) {
+                rejectReady(new Error(`opencode serve exited early: ${stderr.slice(0, 200)}`));
+            }
+            this.servers.delete(cwd);
+        });
+        // Poll for health endpoint readiness (up to 10s)
+        const startTime = Date.now();
+        const maxWait = 10000;
+        const pollInterval = 200;
+        while (Date.now() - startTime < maxWait) {
+            if (proc.exitCode !== null) {
+                rejectReady(new Error("opencode serve exited during startup"));
+                return null;
+            }
+            try {
+                const healthy = await this.healthCheck(server.url);
+                if (healthy) {
+                    server.ready = true;
+                    resolveReady();
+                    return server.url;
+                }
+            }
+            catch {
+                // Not ready yet
+            }
+            await new Promise((r) => setTimeout(r, pollInterval));
+        }
+        // Timeout — kill and return null (will fall back to subprocess mode)
+        this.killServer(server);
+        rejectReady(new Error("opencode serve startup timeout"));
+        return null;
+    }
+    healthCheck(baseUrl) {
+        return new Promise((resolve) => {
+            const req = http.get(`${baseUrl}/global/health`, { timeout: 2000 }, (res) => {
+                let body = "";
+                res.on("data", (d) => {
+                    body += d;
+                });
+                res.on("end", () => {
+                    try {
+                        const data = JSON.parse(body);
+                        resolve(data.healthy === true);
+                    }
+                    catch {
+                        resolve(false);
+                    }
+                });
+            });
+            req.on("error", () => resolve(false));
+            req.on("timeout", () => {
+                req.destroy();
+                resolve(false);
+            });
+        });
+    }
+    killServer(server) {
+        try {
+            server.process.kill("SIGTERM");
+            setTimeout(() => {
+                try {
+                    if (server.process.exitCode === null)
+                        server.process.kill("SIGKILL");
+                }
+                catch {
+                    /* ok */
+                }
+            }, 3000);
+        }
+        catch {
+            /* already dead */
+        }
+        this.servers.delete(server.cwd);
+    }
+    /** Shut down all managed servers. */
+    async shutdown() {
+        this.shuttingDown = true;
+        for (const [, server] of this.servers) {
+            this.killServer(server);
+        }
+        this.servers.clear();
+    }
+    get activeCount() {
+        return this.servers.size;
+    }
+}
+// Module-level server pool (shared across all opencode agent invocations)
+const serverPool = new OpenCodeServerPool();
+// ── HTTP API execution ───────────────────────────────────────────────────────
+/**
+ * Execute a task via the OpenCode HTTP API (server mode).
+ * Creates a session, sends the message, waits for response.
+ */
+async function runViaHttpApi(serverUrl, task, model, signal) {
+    try {
+        // 1. Create session
+        const sessionRes = await httpPost(`${serverUrl}/session`, {});
+        if (!sessionRes || !sessionRes.id)
+            return null;
+        const sessionId = sessionRes.id;
+        // 2. Send message
+        const msgBody = {
+            parts: [{ type: "text", text: task }],
+        };
+        if (model)
+            msgBody.model = model;
+        const msgRes = await httpPost(`${serverUrl}/session/${sessionId}/message`, msgBody, signal);
+        if (!msgRes)
+            return null;
+        // 3. Extract output from response
+        let output = "";
+        const filesChanged = [];
+        if (msgRes.parts) {
+            for (const part of msgRes.parts) {
+                if (part.type === "text" && typeof part.text === "string") {
+                    output += part.text;
+                }
+                if (part.type === "tool_use" || part.type === "tool_call") {
+                    const name = part.name;
+                    const input = part.input;
+                    if ((name === "write" || name === "edit") && input) {
+                        const fp = input.file_path || input.path;
+                        if (typeof fp === "string")
+                            filesChanged.push(fp);
+                    }
+                }
+            }
+        }
+        // Also check info.content for assistant messages
+        const info = msgRes.info;
+        if (info?.content && typeof info.content === "string") {
+            if (!output)
+                output = info.content;
+        }
+        // Extract token usage from response (may be in usage, total_usage, or info.usage)
+        let usage;
+        const u = (msgRes.usage ?? msgRes.total_usage ?? info?.usage);
+        if (u) {
+            const inputTokens = u.input_tokens ?? u.prompt_tokens ?? 0;
+            const outputTokens = u.output_tokens ?? u.completion_tokens ?? 0;
+            if (inputTokens > 0 || outputTokens > 0) {
+                usage = {
+                    inputTokens,
+                    outputTokens,
+                    totalTokens: u.total_tokens ?? inputTokens + outputTokens,
+                };
+            }
+        }
+        return { output, filesChanged: [...new Set(filesChanged)], sessionId: sessionId, usage };
+    }
+    catch {
+        return null;
+    }
+}
+function httpPost(url, body, signal) {
+    return new Promise((resolve) => {
+        const data = JSON.stringify(body);
+        const parsed = new URL(url);
+        const req = http.request({
+            hostname: parsed.hostname,
+            port: parsed.port,
+            path: parsed.pathname,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(data),
+            },
+            timeout: 300000, // 5 min for long tasks
+        }, (res) => {
+            let responseBody = "";
+            res.on("data", (d) => {
+                responseBody += d;
+            });
+            res.on("end", () => {
+                // Reject non-2xx status codes
+                const status = res.statusCode ?? 0;
+                if (status < 200 || status >= 300) {
+                    resolve(null);
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(responseBody));
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on("error", () => resolve(null));
+        req.on("timeout", () => {
+            req.destroy();
+            resolve(null);
+        });
+        if (signal) {
+            const onAbort = () => req.destroy();
+            if (signal.aborted) {
+                req.destroy();
+                resolve(null);
+                return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+            req.on("close", () => signal.removeEventListener("abort", onAbort));
+        }
+        req.write(data);
+        req.end();
+    });
+}
+// ── Attach mode execution ────────────────────────────────────────────────────
+/**
+ * Execute via `opencode run --attach <url>` — connects to a running server
+ * but uses the CLI's output parsing.
+ */
+function runViaAttach(serverUrl, task, workDir, model, signal, onOutput) {
+    const startTime = Date.now();
+    const args = ["run", "--attach", serverUrl, "--format", "json"];
+    if (model)
+        args.push("--model", model);
+    args.push(task);
+    return runSubprocess(args, workDir, startTime, signal, onOutput);
+}
+// ── Subprocess mode execution ────────────────────────────────────────────────
+/**
+ * Execute via cold-start `opencode run` subprocess.
+ * Always-available fallback.
+ */
+function runViaSubprocess(task, workDir, model, signal, onOutput) {
+    const startTime = Date.now();
+    const args = ["run", "--format", "json"];
+    if (model)
+        args.push("--model", model);
+    args.push(task);
+    return runSubprocess(args, workDir, startTime, signal, onOutput);
+}
+/** Shared subprocess runner for both attach and cold-start modes. */
+function runSubprocess(args, workDir, startTime, signal, onOutput) {
+    return new Promise((resolve) => {
+        const proc = spawn("opencode", args, {
+            cwd: workDir,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: buildAgentEnv(),
+        });
+        let stdout = "";
+        let stderr = "";
+        let resolved = false;
+        const doResolve = (result) => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve(result);
+        };
+        proc.stdout?.on("data", (chunk) => {
+            const text = chunk.toString();
+            stdout += text;
+            onOutput?.(text);
+        });
+        proc.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        if (signal) {
+            const onAbort = () => {
+                proc.kill("SIGTERM");
+                const killTimer = setTimeout(() => {
+                    try {
+                        if (proc.exitCode === null)
+                            proc.kill("SIGKILL");
+                    }
+                    catch {
+                        /* dead */
+                    }
+                }, 3000);
+                proc.on("exit", () => clearTimeout(killTimer));
+            };
+            if (signal.aborted) {
+                onAbort();
+            }
+            else {
+                signal.addEventListener("abort", onAbort, { once: true });
+                proc.on("exit", () => signal.removeEventListener("abort", onAbort));
+            }
+        }
+        proc.on("close", (code) => {
+            const durationMs = Date.now() - startTime;
+            let filesChanged = [];
+            let output = stdout;
+            const parsed = extractJson(stdout);
+            let usage;
+            if (parsed) {
+                const extracted = extractFromParsed(parsed);
+                if (extracted.error) {
+                    doResolve({
+                        success: false,
+                        output: extracted.error,
+                        filesChanged: [],
+                        diff: "",
+                        durationMs,
+                        error: extracted.error,
+                        usage: extracted.usage,
+                    });
+                    return;
+                }
+                if (extracted.output)
+                    output = extracted.output;
+                filesChanged = extracted.filesChanged;
+                usage = extracted.usage;
+            }
+            doResolve({
+                success: code === 0,
+                output,
+                filesChanged,
+                diff: "",
+                durationMs,
+                error: code !== 0 ? `opencode exited with code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}` : undefined,
+                usage,
+            });
+        });
+        proc.on("error", (err) => {
+            doResolve({
+                success: false,
+                output: "",
+                filesChanged: [],
+                diff: "",
+                durationMs: Date.now() - startTime,
+                error: `Failed to spawn opencode: ${err.message}`,
+            });
+        });
+    });
+}
+// ── Provider ─────────────────────────────────────────────────────────────────
+// Whether server mode is enabled (set via enableServerMode)
+let _serverModeEnabled = false;
+/** Enable server mode for the OpenCode agent. Call before spawning threads. */
+export function enableServerMode() {
+    _serverModeEnabled = true;
+}
+/** Disable server mode and shut down all managed servers. */
+export async function disableServerMode() {
+    _serverModeEnabled = false;
+    await serverPool.shutdown();
+}
+/** Get the number of active server instances. */
+export function getActiveServerCount() {
+    return serverPool.activeCount;
+}
+const openCodeProvider = {
+    name: "opencode",
+    async isAvailable() {
+        return commandExists("opencode");
+    },
+    async run(options) {
+        const { task, workDir, model, signal, onOutput } = options;
+        const startTime = Date.now();
+        // Strategy 1: Server mode (HTTP API)
+        if (_serverModeEnabled) {
+            try {
+                const serverUrl = await serverPool.getServer(workDir);
+                if (serverUrl) {
+                    const apiResult = await runViaHttpApi(serverUrl, task, model, signal);
+                    if (apiResult) {
+                        return {
+                            success: true,
+                            output: apiResult.output,
+                            filesChanged: apiResult.filesChanged,
+                            diff: "",
+                            durationMs: Date.now() - startTime,
+                            usage: apiResult.usage,
+                        };
+                    }
+                    // API call failed — try attach mode with the same server
+                    try {
+                        return await runViaAttach(serverUrl, task, workDir, model, signal, onOutput);
+                    }
+                    catch {
+                        // Fall through to subprocess
+                    }
+                }
+            }
+            catch {
+                // Server mode unavailable — fall through
+            }
+        }
+        // Strategy 2: Subprocess mode (always-available fallback)
+        return runViaSubprocess(task, workDir, model, signal, onOutput);
+    },
+};
+registerAgent(openCodeProvider);
+export default openCodeProvider;
+//# sourceMappingURL=opencode.js.map

package/dist/agents/provider.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Agent provider interface and registry.
+ *
+ * Each agent backend (OpenCode, Claude Code, etc.) implements AgentProvider.
+ * The registry maps backend names to providers.
+ */
+import type { AgentProvider } from "../core/types.js";
+export declare function registerAgent(provider: AgentProvider): void;
+export declare function getAgent(name: string): AgentProvider;
+export declare function listAgents(): string[];
+export declare function getAvailableAgents(): Promise<string[]>;

package/dist/agents/provider.js

@@ -0,0 +1,31 @@
+/**
+ * Agent provider interface and registry.
+ *
+ * Each agent backend (OpenCode, Claude Code, etc.) implements AgentProvider.
+ * The registry maps backend names to providers.
+ */
+const registry = new Map();
+export function registerAgent(provider) {
+    registry.set(provider.name, provider);
+}
+export function getAgent(name) {
+    const provider = registry.get(name);
+    if (!provider) {
+        const available = [...registry.keys()].join(", ");
+        throw new Error(`Unknown agent backend "${name}". Available: ${available || "none"}`);
+    }
+    return provider;
+}
+export function listAgents() {
+    return [...registry.keys()];
+}
+export async function getAvailableAgents() {
+    const results = [];
+    for (const [name, provider] of registry) {
+        if (await provider.isAvailable()) {
+            results.push(name);
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=provider.js.map

package/dist/cli.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env tsx
+/**
+ * Standalone RLM CLI — run Recursive Language Model queries from the terminal.
+ *
+ * Usage:
+ *   npx tsx src/cli.ts --file large-file.txt "What are the main themes?"
+ *   npx tsx src/cli.ts --url https://example.com/big.txt "Summarize this"
+ *   cat data.txt | npx tsx src/cli.ts --stdin "Count the errors"
+ *
+ * Environment (pick one):
+ *   ANTHROPIC_API_KEY — for Anthropic models
+ *   OPENAI_API_KEY    — for OpenAI models
+ *   GEMINI_API_KEY    — for Google models
+ */
+import "./env.js";