swarm-code 0.1.0

package/dist/agents/claude-code.js

@@ -0,0 +1,216 @@
+/**
+ * Claude Code agent backend.
+ *
+ * Runs tasks via `claude -p --output-format json "prompt"` subprocess.
+ * Parses structured JSON output for results, cost, and file changes.
+ */
+import { spawn } from "node:child_process";
+import * as os from "node:os";
+import { registerAgent } from "./provider.js";
+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 result from output (may contain non-JSON lines from debug/stderr bleed). */
+function extractJson(raw) {
+    // Try direct parse first
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        /* mixed output */
+    }
+    // Try last line (claude outputs JSON as final line)
+    const lines = raw.trim().split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (line.startsWith("{")) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.type === "result")
+                    return parsed;
+            }
+            catch { }
+        }
+    }
+    // Fallback: find first { to last }
+    const firstBrace = raw.indexOf("{");
+    const lastBrace = raw.lastIndexOf("}");
+    if (firstBrace !== -1 && lastBrace > firstBrace) {
+        try {
+            return JSON.parse(raw.slice(firstBrace, lastBrace + 1));
+        }
+        catch {
+            /* give up */
+        }
+    }
+    return null;
+}
+/** 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,
+        // Claude Code uses ANTHROPIC_API_KEY
+        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+        // Git config
+        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,
+        // XDG dirs (claude may use for config)
+        XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+        XDG_DATA_HOME: process.env.XDG_DATA_HOME,
+        // Windows
+        ...(process.env.SystemRoot ? { SystemRoot: process.env.SystemRoot } : {}),
+        ...(process.env.SYSTEMROOT ? { SYSTEMROOT: process.env.SYSTEMROOT } : {}),
+    };
+}
+/** Map provider/model format to claude model flag. */
+function resolveModel(model) {
+    // Strip provider prefix if present (e.g., "anthropic/claude-sonnet-4-6" → "claude-sonnet-4-6")
+    const modelName = model.includes("/") ? model.split("/").pop() : model;
+    // Claude Code accepts short aliases
+    const aliases = {
+        "claude-sonnet-4-6": "sonnet",
+        "claude-opus-4-6": "opus",
+        "claude-haiku-4-5": "haiku",
+    };
+    return aliases[modelName] || modelName;
+}
+const claudeCodeProvider = {
+    name: "claude-code",
+    async isAvailable() {
+        return commandExists("claude");
+    },
+    async run(options) {
+        const { task, workDir, model, files, signal } = options;
+        const startTime = Date.now();
+        const args = ["-p", "--output-format", "json", "--dangerously-skip-permissions", "--no-session-persistence"];
+        if (model) {
+            args.push("--model", resolveModel(model));
+        }
+        // Build the prompt — include file hints if provided
+        let prompt = task;
+        if (files && files.length > 0) {
+            prompt += `\n\nRelevant files to focus on:\n${files.map((f) => `- ${f}`).join("\n")}`;
+        }
+        args.push(prompt);
+        return new Promise((resolve) => {
+            const proc = spawn("claude", 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;
+                options.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 {
+                            /* already 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;
+                const parsed = extractJson(stdout);
+                if (parsed) {
+                    // Extract token usage from Claude Code's structured output
+                    let usage;
+                    if (parsed.usage) {
+                        const inputTokens = parsed.usage.input_tokens ?? 0;
+                        const outputTokens = parsed.usage.output_tokens ?? 0;
+                        if (inputTokens > 0 || outputTokens > 0) {
+                            usage = {
+                                inputTokens,
+                                outputTokens,
+                                totalTokens: inputTokens + outputTokens,
+                            };
+                        }
+                    }
+                    if (parsed.is_error) {
+                        doResolve({
+                            success: false,
+                            output: parsed.result || stderr,
+                            filesChanged: [],
+                            diff: "",
+                            durationMs: parsed.duration_ms || durationMs,
+                            error: parsed.result || `Claude Code error: ${parsed.subtype}`,
+                            usage,
+                        });
+                        return;
+                    }
+                    doResolve({
+                        success: true,
+                        output: parsed.result || "",
+                        filesChanged: [], // Diff is captured separately by worktree manager
+                        diff: "",
+                        durationMs: parsed.duration_ms || durationMs,
+                        usage,
+                    });
+                    return;
+                }
+                // Fallback: no JSON parsed — use raw output
+                doResolve({
+                    success: code === 0,
+                    output: stdout || stderr,
+                    filesChanged: [],
+                    diff: "",
+                    durationMs,
+                    error: code !== 0 ? `claude exited with code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}` : undefined,
+                });
+            });
+            proc.on("error", (err) => {
+                doResolve({
+                    success: false,
+                    output: "",
+                    filesChanged: [],
+                    diff: "",
+                    durationMs: Date.now() - startTime,
+                    error: `Failed to spawn claude: ${err.message}`,
+                });
+            });
+        });
+    },
+};
+registerAgent(claudeCodeProvider);
+export default claudeCodeProvider;
+//# sourceMappingURL=claude-code.js.map

package/dist/agents/codex.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Codex CLI agent backend (OpenAI).
+ *
+ * Runs tasks via `codex exec --json --full-auto "prompt"` subprocess.
+ * Codex CLI is OpenAI's open-source coding agent.
+ *
+ * Output format: JSONL events streamed to stdout, with event types:
+ *   - thread.started, turn.started, turn.completed, turn.failed
+ *   - item.started, item.updated, item.completed
+ * Item types: assistant_message, command_execution, file_change, etc.
+ */
+import type { AgentProvider } from "../core/types.js";
+declare const codexProvider: AgentProvider;
+export default codexProvider;

package/dist/agents/codex.js

@@ -0,0 +1,193 @@
+/**
+ * Codex CLI agent backend (OpenAI).
+ *
+ * Runs tasks via `codex exec --json --full-auto "prompt"` subprocess.
+ * Codex CLI is OpenAI's open-source coding agent.
+ *
+ * Output format: JSONL events streamed to stdout, with event types:
+ *   - thread.started, turn.started, turn.completed, turn.failed
+ *   - item.started, item.updated, item.completed
+ * Item types: assistant_message, command_execution, file_change, etc.
+ */
+import { spawn } from "node:child_process";
+import * as os from "node:os";
+import { registerAgent } from "./provider.js";
+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));
+    });
+}
+/** 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,
+        // Codex uses CODEX_API_KEY or OPENAI_API_KEY
+        CODEX_API_KEY: process.env.CODEX_API_KEY || process.env.OPENAI_API_KEY,
+        OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+        OPENAI_BASE_URL: process.env.OPENAI_BASE_URL,
+        // Codex config home
+        CODEX_HOME: process.env.CODEX_HOME,
+        // Git config
+        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,
+        // Windows
+        ...(process.env.SystemRoot ? { SystemRoot: process.env.SystemRoot } : {}),
+        ...(process.env.SYSTEMROOT ? { SYSTEMROOT: process.env.SYSTEMROOT } : {}),
+    };
+}
+/** Map provider/model format to codex model flag. */
+function resolveModel(model) {
+    // Strip provider prefix (e.g., "openai/o3" → "o3")
+    return model.includes("/") ? model.split("/").pop() : model;
+}
+/** Parse JSONL output to extract result, file changes, and token usage. */
+function parseCodexJsonl(stdout) {
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    let output = "";
+    const filesChanged = [];
+    let success = true;
+    let error;
+    let totalInput = 0;
+    let totalOutput = 0;
+    for (const line of lines) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "turn.failed") {
+                success = false;
+                error = event.error || "Turn failed";
+            }
+            if (event.type === "item.completed") {
+                if (event.item_type === "assistant_message") {
+                    // Capture assistant messages
+                    const content = event.message?.content || event.content || "";
+                    if (content)
+                        output += (output ? "\n" : "") + content;
+                }
+                if (event.item_type === "file_change" && event.file_path) {
+                    filesChanged.push(event.file_path);
+                }
+            }
+            // Accumulate token usage from events
+            if (event.usage) {
+                totalInput += event.usage.input_tokens ?? 0;
+                totalOutput += event.usage.output_tokens ?? 0;
+            }
+        }
+        catch {
+            // Non-JSON line — ignore
+        }
+    }
+    let usage;
+    if (totalInput > 0 || totalOutput > 0) {
+        usage = {
+            inputTokens: totalInput,
+            outputTokens: totalOutput,
+            totalTokens: totalInput + totalOutput,
+        };
+    }
+    return { output, filesChanged: [...new Set(filesChanged)], success, error, usage };
+}
+const codexProvider = {
+    name: "codex",
+    async isAvailable() {
+        return commandExists("codex");
+    },
+    async run(options) {
+        const { task, workDir, model, files, signal } = options;
+        const startTime = Date.now();
+        const args = ["exec", "--json", "--full-auto", "--ephemeral", "--skip-git-repo-check", "--cd", workDir];
+        if (model) {
+            args.push("--model", resolveModel(model));
+        }
+        // Build the prompt — include file hints if provided
+        let prompt = task;
+        if (files && files.length > 0) {
+            prompt += `\n\nRelevant files to focus on:\n${files.map((f) => `- ${f}`).join("\n")}`;
+        }
+        args.push(prompt);
+        return new Promise((resolve) => {
+            const proc = spawn("codex", 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;
+                options.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 {
+                            /* already 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;
+                // Parse JSONL events
+                const parsed = parseCodexJsonl(stdout);
+                doResolve({
+                    success: code === 0 && parsed.success,
+                    output: parsed.output || stdout || stderr,
+                    filesChanged: parsed.filesChanged,
+                    diff: "", // Diff is captured separately by worktree manager
+                    durationMs,
+                    error: parsed.error ||
+                        (code !== 0 ? `codex exited with code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}` : undefined),
+                    usage: parsed.usage,
+                });
+            });
+            proc.on("error", (err) => {
+                doResolve({
+                    success: false,
+                    output: "",
+                    filesChanged: [],
+                    diff: "",
+                    durationMs: Date.now() - startTime,
+                    error: `Failed to spawn codex: ${err.message}`,
+                });
+            });
+        });
+    },
+};
+registerAgent(codexProvider);
+export default codexProvider;
+//# sourceMappingURL=codex.js.map

package/dist/agents/direct-llm.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Direct LLM agent backend.
+ *
+ * Preserves the original llm_query behavior — sends a prompt directly to an LLM
+ * without any coding agent wrapper. Useful for lightweight analysis tasks.
+ */
+import type { AgentProvider } from "../core/types.js";
+declare const directLlmProvider: AgentProvider;
+export default directLlmProvider;

package/dist/agents/direct-llm.js

@@ -0,0 +1,78 @@
+/**
+ * Direct LLM agent backend.
+ *
+ * Preserves the original llm_query behavior — sends a prompt directly to an LLM
+ * without any coding agent wrapper. Useful for lightweight analysis tasks.
+ */
+import { registerAgent } from "./provider.js";
+const directLlmProvider = {
+    name: "direct-llm",
+    async isAvailable() {
+        // Available if any LLM API key is set
+        return !!(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GEMINI_API_KEY);
+    },
+    async run(options) {
+        const startTime = Date.now();
+        try {
+            // Import pi-ai dynamically to avoid loading it at module level
+            const { completeSimple, getModels, getProviders } = await import("@mariozechner/pi-ai");
+            const modelId = options.model || process.env.RLM_MODEL || "claude-sonnet-4-6";
+            // Find model
+            let model;
+            for (const provider of getProviders()) {
+                for (const m of getModels(provider)) {
+                    if (m.id === modelId) {
+                        model = m;
+                        break;
+                    }
+                }
+                if (model)
+                    break;
+            }
+            if (!model) {
+                return {
+                    success: false,
+                    output: "",
+                    filesChanged: [],
+                    diff: "",
+                    durationMs: Date.now() - startTime,
+                    error: `Model "${modelId}" not found`,
+                };
+            }
+            const response = await completeSimple(model, {
+                systemPrompt: "You are a helpful assistant. Be concise and thorough.",
+                messages: [
+                    {
+                        role: "user",
+                        content: options.task,
+                        timestamp: Date.now(),
+                    },
+                ],
+            });
+            const output = response.content
+                .filter((b) => b.type === "text")
+                .map((b) => b.text)
+                .join("\n");
+            return {
+                success: true,
+                output,
+                filesChanged: [],
+                diff: "",
+                durationMs: Date.now() - startTime,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: "",
+                filesChanged: [],
+                diff: "",
+                durationMs: Date.now() - startTime,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+registerAgent(directLlmProvider);
+export default directLlmProvider;
+//# sourceMappingURL=direct-llm.js.map

package/dist/agents/mock.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Mock agent backend — for integration testing without real API keys.
+ *
+ * Simulates a coding agent by writing actual files in the work directory.
+ * Registered as "mock" in the agent registry.
+ */
+import type { AgentProvider } from "../core/types.js";
+declare const mockProvider: AgentProvider;
+export default mockProvider;

package/dist/agents/mock.js

@@ -0,0 +1,77 @@
+/**
+ * Mock agent backend — for integration testing without real API keys.
+ *
+ * Simulates a coding agent by writing actual files in the work directory.
+ * Registered as "mock" in the agent registry.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { registerAgent } from "./provider.js";
+const mockProvider = {
+    name: "mock",
+    async isAvailable() {
+        return true;
+    },
+    async run(options) {
+        const { task, workDir, signal } = options;
+        const startTime = Date.now();
+        // Check for abort
+        if (signal?.aborted) {
+            return {
+                success: false,
+                output: "Aborted",
+                filesChanged: [],
+                diff: "",
+                durationMs: Date.now() - startTime,
+                error: "Aborted before start",
+            };
+        }
+        // Simulate work delay (50ms)
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        // Check for forced failure mode
+        if (task.includes("__FAIL__")) {
+            return {
+                success: false,
+                output: "Simulated failure",
+                filesChanged: [],
+                diff: "",
+                durationMs: Date.now() - startTime,
+                error: "Mock agent forced failure",
+            };
+        }
+        // Write actual files in the work directory to simulate agent edits
+        const filesChanged = [];
+        // Create or modify a file based on the task
+        const targetFile = path.join(workDir, "hello.ts");
+        const content = `// Generated by mock agent\n// Task: ${task}\nexport function hello(): string {\n\treturn "Hello from swarm thread!";\n}\n`;
+        fs.writeFileSync(targetFile, content, "utf-8");
+        filesChanged.push("hello.ts");
+        // If task mentions "multi", create additional files
+        if (task.toLowerCase().includes("multi")) {
+            const extraFile = path.join(workDir, "utils.ts");
+            fs.writeFileSync(extraFile, `// Utility module\nexport const VERSION = "1.0.0";\n`, "utf-8");
+            filesChanged.push("utils.ts");
+        }
+        const output = [
+            "Applied edit to hello.ts",
+            `Created ${filesChanged.length} file(s)`,
+            "Result: Successfully completed task",
+        ].join("\n");
+        return {
+            success: true,
+            output,
+            filesChanged,
+            diff: "", // Diff is captured by worktree manager
+            durationMs: Date.now() - startTime,
+            // Simulate token usage for testing budget tracking
+            usage: {
+                inputTokens: 1500,
+                outputTokens: 800,
+                totalTokens: 2300,
+            },
+        };
+    },
+};
+registerAgent(mockProvider);
+export default mockProvider;
+//# sourceMappingURL=mock.js.map

package/dist/agents/opencode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 type { AgentProvider } from "../core/types.js";
+/** Enable server mode for the OpenCode agent. Call before spawning threads. */
+export declare function enableServerMode(): void;
+/** Disable server mode and shut down all managed servers. */
+export declare function disableServerMode(): Promise<void>;
+/** Get the number of active server instances. */
+export declare function getActiveServerCount(): number;
+declare const openCodeProvider: AgentProvider;
+export default openCodeProvider;