swarm-code 0.1.0

package/dist/core/runtime.py

@@ -0,0 +1,335 @@
+"""
+Swarm Runtime — Python-side helpers for the swarm-cli orchestrator.
+
+Extends the RLM runtime with thread spawning primitives:
+  - `thread(task, context, agent, model, files)`: spawn a coding agent thread
+  - `async_thread(...)`: async version for asyncio.gather()
+  - `merge_threads()`: merge all completed thread branches
+
+Communication protocol (line-delimited JSON over stdio):
+  -> stdout: {"type":"llm_query","sub_context":"...","instruction":"...","id":"..."}
+  <- stdin:  {"type":"llm_result","id":"...","result":"..."}
+  -> stdout: {"type":"thread_request","id":"...","task":"...","context":"...","agent_backend":"...","model":"...","files":[]}
+  <- stdin:  {"type":"thread_result","id":"...","result":"...","success":true,"files_changed":[],"duration_ms":0}
+  -> stdout: {"type":"merge_request","id":"..."}
+  <- stdin:  {"type":"merge_result","id":"...","result":"...","success":true}
+  -> stdout: {"type":"exec_done","stdout":"...","stderr":"...","has_final":bool,"final_value":"..."|null}
+"""
+
+import json
+import sys
+import uuid
+import io
+import traceback
+import asyncio
+import threading
+import queue
+
+# Real stdio handles — saved before exec() can redirect sys.stdout/sys.stderr.
+_real_stdout = sys.stdout
+_real_stdin = sys.stdin
+
+# Lock for stdout writes only
+_write_lock = threading.Lock()
+
+# Per-request events and results for concurrent llm_query/thread calls
+_pending_results: dict[str, threading.Event] = {}
+_result_store: dict[str, str] = {}
+
+# Queue for commands (exec, set_context, etc.) dispatched by the reader thread
+_command_queue: queue.Queue = queue.Queue()
+
+# Will be set by the TypeScript host before each execution
+context: str = ""
+
+# Sentinel — when set to a non-None value, the loop terminates
+__final_result__ = None
+
+# User execution namespace — isolates LLM code from REPL internals
+_user_ns: dict = {}
+
+
+def FINAL(x):
+    """Set the final answer as a string and terminate the RLM loop."""
+    global __final_result__
+    if __final_result__ is not None:
+        print(f"[Warning] FINAL() called again — overwriting previous answer", file=sys.stderr)
+    __final_result__ = str(x)
+
+
+def FINAL_VAR(x):
+    """Set the final answer from a variable and terminate the RLM loop."""
+    global __final_result__
+    if __final_result__ is not None and x is not None:
+        print(f"[Warning] FINAL_VAR() called again — overwriting previous answer", file=sys.stderr)
+    __final_result__ = str(x) if x is not None else None
+
+
+def _stdin_reader_loop() -> None:
+    """Dedicated thread: reads all stdin lines and dispatches them.
+
+    - llm_result/thread_result/merge_result messages go to waiting threads
+    - All other messages (exec, set_context, etc.) go to _command_queue
+    """
+    while True:
+        try:
+            line = _real_stdin.readline()
+        except Exception:
+            break
+        if not line:
+            # stdin closed — wake all pending threads and signal main loop
+            for event in list(_pending_results.values()):
+                event.set()
+            _command_queue.put(None)
+            break
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            msg = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        msg_type = msg.get("type")
+        if msg_type in ("llm_result", "thread_result", "merge_result"):
+            rid = msg.get("id", "")
+            if rid in _pending_results:
+                _result_store[rid] = json.dumps(msg) if msg_type != "llm_result" else msg.get("result", "")
+                _pending_results[rid].set()
+        elif msg_type == "shutdown":
+            _command_queue.put(None)
+            break
+        else:
+            _command_queue.put(msg)
+
+
+def llm_query(sub_context: str, instruction: str = "") -> str:
+    """Send a sub-context and instruction to the parent LLM and return the response."""
+    if not instruction:
+        instruction = ""
+
+    request_id = uuid.uuid4().hex[:12]
+    event = threading.Event()
+    _pending_results[request_id] = event
+
+    request = {
+        "type": "llm_query",
+        "sub_context": sub_context,
+        "instruction": instruction,
+        "id": request_id,
+    }
+    with _write_lock:
+        _real_stdout.write(json.dumps(request) + "\n")
+        _real_stdout.flush()
+
+    event.wait()
+    _pending_results.pop(request_id, None)
+    result = _result_store.pop(request_id, None)
+    if result is None:
+        raise RuntimeError("Host process disconnected during llm_query — stdin closed")
+    return result
+
+
+async def async_llm_query(sub_context: str, instruction: str = "") -> str:
+    """Async wrapper around llm_query for use with asyncio.gather()."""
+    return await asyncio.get_event_loop().run_in_executor(None, llm_query, sub_context, instruction)
+
+
+def thread(task: str, context: str = "", agent: str = "opencode", model: str = "", files=None) -> str:
+    """Spawn a coding agent thread in an isolated git worktree.
+
+    Args:
+        task: What the agent should do (be specific)
+        context: Additional context to pass to the agent
+        agent: Agent backend name ("opencode", "direct-llm", etc.)
+        model: Model ID in provider/model-id format (e.g., "anthropic/claude-sonnet-4-6")
+        files: List of relevant file paths (hints for the agent)
+
+    Returns:
+        Compressed result string with status, files changed, diff, and output summary.
+    """
+    if files is None:
+        files = []
+
+    request_id = uuid.uuid4().hex[:12]
+    event = threading.Event()
+    _pending_results[request_id] = event
+
+    request = {
+        "type": "thread_request",
+        "id": request_id,
+        "task": task,
+        "context": context,
+        "agent_backend": agent,
+        "model": model,
+        "files": files,
+    }
+    with _write_lock:
+        _real_stdout.write(json.dumps(request) + "\n")
+        _real_stdout.flush()
+
+    event.wait()
+    _pending_results.pop(request_id, None)
+
+    raw = _result_store.pop(request_id, None)
+    if raw is None:
+        raise RuntimeError("Host process disconnected during thread() — stdin closed")
+    try:
+        result_msg = json.loads(raw)
+        return result_msg.get("result", raw)
+    except (json.JSONDecodeError, AttributeError):
+        return raw
+
+
+async def async_thread(task: str, context: str = "", agent: str = "opencode", model: str = "", files=None) -> str:
+    """Async version of thread() for use with asyncio.gather().
+
+    Usage:
+        import asyncio
+        results = await asyncio.gather(
+            async_thread("fix auth", files=["src/auth.ts"]),
+            async_thread("fix routing", files=["src/router.ts"]),
+        )
+    """
+    if files is None:
+        files = []
+    return await asyncio.get_event_loop().run_in_executor(
+        None, lambda: thread(task, context, agent, model, files)
+    )
+
+
+def merge_threads() -> str:
+    """Merge all completed thread branches back into the main branch.
+
+    Returns:
+        Merge status string.
+    """
+    request_id = uuid.uuid4().hex[:12]
+    event = threading.Event()
+    _pending_results[request_id] = event
+
+    request = {
+        "type": "merge_request",
+        "id": request_id,
+    }
+    with _write_lock:
+        _real_stdout.write(json.dumps(request) + "\n")
+        _real_stdout.flush()
+
+    event.wait()
+    _pending_results.pop(request_id, None)
+
+    raw = _result_store.pop(request_id, None)
+    if raw is None:
+        raise RuntimeError("Host process disconnected during merge_threads() — stdin closed")
+    try:
+        result_msg = json.loads(raw)
+        return result_msg.get("result", raw)
+    except (json.JSONDecodeError, AttributeError):
+        return raw
+
+
+def _runtime_symbols() -> dict:
+    """Return the dict of runtime symbols injected into the user namespace."""
+    return {
+        '__builtins__': __builtins__,
+        'context': context,
+        'llm_query': llm_query,
+        'async_llm_query': async_llm_query,
+        'thread': thread,
+        'async_thread': async_thread,
+        'merge_threads': merge_threads,
+        'FINAL': FINAL,
+        'FINAL_VAR': FINAL_VAR,
+    }
+
+
+def _refresh_user_ns() -> None:
+    """Ensure the user namespace has the latest runtime symbols."""
+    _user_ns.update(_runtime_symbols())
+
+
+def _execute_code(code: str) -> None:
+    """Execute a code snippet in an isolated namespace, capturing output."""
+    global __final_result__
+    _refresh_user_ns()
+    captured_stdout = io.StringIO()
+    captured_stderr = io.StringIO()
+    old_stdout = sys.stdout
+    old_stderr = sys.stderr
+
+    try:
+        sys.stdout = captured_stdout
+        sys.stderr = captured_stderr
+        try:
+            compiled = compile(code, "<repl>", "exec")
+            exec(compiled, _user_ns)
+        except SyntaxError as e:
+            if "await" in str(code):
+                _protected = set(_runtime_symbols().keys())
+                async_code = "async def __async_exec__():\n"
+                for line in code.split("\n"):
+                    async_code += f"    {line}\n"
+                async_code += "    return {k: v for k, v in locals().items()}\n"
+                async_code += "\nimport asyncio as _asyncio\n"
+                async_code += "_async_locals = _asyncio.run(__async_exec__())\n"
+                async_code += f"globals().update({{k: v for k, v in _async_locals.items() if k not in {_protected!r}}})\n"
+                exec(compile(async_code, "<repl>", "exec"), _user_ns)
+            else:
+                raise e
+    except Exception:
+        traceback.print_exc(file=captured_stderr)
+    finally:
+        sys.stdout = old_stdout
+        sys.stderr = old_stderr
+
+    stdout_val = captured_stdout.getvalue()
+    stderr_val = captured_stderr.getvalue()
+
+    result = {
+        "type": "exec_done",
+        "stdout": stdout_val,
+        "stderr": stderr_val,
+        "has_final": __final_result__ is not None,
+        "final_value": str(__final_result__) if __final_result__ is not None else None,
+    }
+    with _write_lock:
+        _real_stdout.write(json.dumps(result) + "\n")
+        _real_stdout.flush()
+
+
+def _main_loop() -> None:
+    """Process commands from the queue (fed by the stdin reader thread)."""
+    while True:
+        msg = _command_queue.get()
+        if msg is None:
+            break
+
+        if msg.get("type") == "exec":
+            _execute_code(msg.get("code", ""))
+        elif msg.get("type") == "set_context":
+            global context
+            context = msg.get("value", "")
+            ack = {"type": "context_set"}
+            with _write_lock:
+                _real_stdout.write(json.dumps(ack) + "\n")
+                _real_stdout.flush()
+        elif msg.get("type") == "reset_final":
+            global __final_result__
+            __final_result__ = None
+            ack = {"type": "final_reset"}
+            with _write_lock:
+                _real_stdout.write(json.dumps(ack) + "\n")
+                _real_stdout.flush()
+
+
+if __name__ == "__main__":
+    ready = {"type": "ready"}
+    _real_stdout.write(json.dumps(ready) + "\n")
+    _real_stdout.flush()
+
+    # Start dedicated stdin reader thread
+    reader = threading.Thread(target=_stdin_reader_loop, daemon=True)
+    reader.start()
+
+    _main_loop()

package/dist/core/types.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Shared type definitions for swarm-code.
+ */
+/** Token usage reported by the agent (when available). */
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+export interface AgentResult {
+    success: boolean;
+    output: string;
+    filesChanged: string[];
+    diff: string;
+    durationMs: number;
+    error?: string;
+    /** Actual token usage from the agent (if reported). */
+    usage?: TokenUsage;
+}
+export interface AgentRunOptions {
+    task: string;
+    workDir: string;
+    model?: string;
+    files?: string[];
+    signal?: AbortSignal;
+    onOutput?: (chunk: string) => void;
+}
+export interface AgentProvider {
+    readonly name: string;
+    readonly isAvailable: () => Promise<boolean>;
+    run(options: AgentRunOptions): Promise<AgentResult>;
+}
+export type ThreadStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+export type ThreadProgressPhase = "queued" | "creating_worktree" | "agent_running" | "capturing_diff" | "compressing" | "completed" | "failed" | "cancelled" | "retrying";
+export interface ThreadConfig {
+    id: string;
+    task: string;
+    context: string;
+    agent: {
+        backend: string;
+        model: string;
+    };
+    files?: string[];
+}
+export interface ThreadState {
+    id: string;
+    config: ThreadConfig;
+    status: ThreadStatus;
+    phase: ThreadProgressPhase;
+    worktreePath?: string;
+    branchName?: string;
+    result?: CompressedResult;
+    startedAt?: number;
+    completedAt?: number;
+    error?: string;
+    attempt: number;
+    maxAttempts: number;
+    estimatedCostUsd: number;
+}
+export interface CompressedResult {
+    success: boolean;
+    summary: string;
+    filesChanged: string[];
+    diffStats: string;
+    durationMs: number;
+    estimatedCostUsd: number;
+    /** Actual token usage (when available from agent). */
+    usage?: TokenUsage;
+    /** Whether cost is based on real usage or estimates. */
+    costIsEstimate?: boolean;
+}
+export interface WorktreeInfo {
+    id: string;
+    path: string;
+    branch: string;
+}
+export interface MergeResult {
+    success: boolean;
+    branch: string;
+    conflicts: string[];
+    conflictDiff: string;
+    message: string;
+}
+export interface BudgetState {
+    totalSpentUsd: number;
+    threadCosts: Map<string, number>;
+    sessionLimitUsd: number;
+    perThreadLimitUsd: number;
+    /** Total tokens consumed across all threads. */
+    totalTokens: {
+        input: number;
+        output: number;
+    };
+    /** Number of threads with actual (non-estimated) cost data. */
+    actualCostThreads: number;
+    /** Number of threads with estimated cost data. */
+    estimatedCostThreads: number;
+}
+/** Rough per-1M-token pricing for cost estimation. */
+export declare const MODEL_PRICING: Record<string, {
+    input: number;
+    output: number;
+}>;
+export type { ModelSlots, SwarmConfig } from "../config.js";
+export interface ThreadRequestMessage {
+    type: "thread_request";
+    id: string;
+    task: string;
+    context: string;
+    agent_backend: string;
+    model: string;
+    files: string[];
+}
+export interface ThreadResultMessage {
+    type: "thread_result";
+    id: string;
+    result: string;
+    success: boolean;
+    files_changed: string[];
+    duration_ms: number;
+}
+export interface MergeRequestMessage {
+    type: "merge_request";
+    id: string;
+}
+export interface MergeResultMessage {
+    type: "merge_result";
+    id: string;
+    result: string;
+    success: boolean;
+}

package/dist/core/types.js

@@ -0,0 +1,19 @@
+/**
+ * Shared type definitions for swarm-code.
+ */
+/** Rough per-1M-token pricing for cost estimation. */
+export const MODEL_PRICING = {
+    // Anthropic
+    "claude-sonnet-4-6": { input: 3, output: 15 },
+    "claude-opus-4-6": { input: 15, output: 75 },
+    "claude-haiku-4-5": { input: 0.8, output: 4 },
+    // OpenAI
+    "gpt-4o": { input: 2.5, output: 10 },
+    "gpt-4o-mini": { input: 0.15, output: 0.6 },
+    o3: { input: 10, output: 40 },
+    "o3-mini": { input: 1.1, output: 4.4 },
+    // Google
+    "gemini-2.5-pro": { input: 1.25, output: 10 },
+    "gemini-2.5-flash": { input: 0.15, output: 0.6 },
+};
+//# sourceMappingURL=types.js.map

package/dist/env.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Load env vars into process.env.
+ * Must be imported BEFORE any module that reads env vars (e.g. pi-ai).
+ *
+ * Priority (highest wins):
+ *   1. Shell environment variables (already in process.env)
+ *   2. .env in package root
+ *   3. ~/.rlm/credentials — persistent keys saved by first-run setup
+ */
+export {};

package/dist/env.js

@@ -0,0 +1,75 @@
+/**
+ * Load env vars into process.env.
+ * Must be imported BEFORE any module that reads env vars (e.g. pi-ai).
+ *
+ * Priority (highest wins):
+ *   1. Shell environment variables (already in process.env)
+ *   2. .env in package root
+ *   3. ~/.rlm/credentials — persistent keys saved by first-run setup
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+function parseEnvFile(filePath) {
+    const vars = new Map();
+    if (!fs.existsSync(filePath))
+        return vars;
+    const content = fs.readFileSync(filePath, "utf-8");
+    for (const rawLine of content.split("\n")) {
+        let trimmed = rawLine.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        // Strip leading "export " (common in .env files)
+        if (trimmed.startsWith("export "))
+            trimmed = trimmed.slice(7);
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        // Strip matching surrounding quotes ("..." or '...')
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (key)
+            vars.set(key, value);
+    }
+    return vars;
+}
+// Collect file-based vars: credentials first, .env overwrites
+const fileVars = new Map();
+// 1. Load persistent credentials (lowest priority file)
+// Check both swarm and rlm credential locations
+const credVars = parseEnvFile(path.join(os.homedir(), ".swarm", "credentials"));
+const rlmCreds = parseEnvFile(path.join(os.homedir(), ".rlm", "credentials"));
+for (const [k, v] of rlmCreds) {
+    if (!credVars.has(k))
+        credVars.set(k, v);
+}
+for (const [k, v] of credVars)
+    fileVars.set(k, v);
+// 2. Load .env from package root (overwrites credentials)
+const __dir = path.dirname(fileURLToPath(import.meta.url));
+const dotenvVars = parseEnvFile(path.resolve(__dir, "..", ".env"));
+for (const [k, v] of dotenvVars)
+    fileVars.set(k, v);
+// 3. Apply: only set if NOT already in shell env (shell always wins)
+for (const [key, value] of fileVars) {
+    if (!process.env[key]) {
+        process.env[key] = value;
+    }
+}
+// Alias: GOOGLE_API_KEY → GEMINI_API_KEY (pi-ai expects GEMINI_API_KEY)
+// Remove GOOGLE_API_KEY after aliasing to avoid pi-ai "both set" warning
+if (process.env.GOOGLE_API_KEY) {
+    if (!process.env.GEMINI_API_KEY) {
+        process.env.GEMINI_API_KEY = process.env.GOOGLE_API_KEY;
+    }
+    delete process.env.GOOGLE_API_KEY;
+}
+// Default model
+if (!process.env.RLM_MODEL) {
+    process.env.RLM_MODEL = "claude-sonnet-4-6";
+}
+//# sourceMappingURL=env.js.map

package/dist/interactive-swarm.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Interactive swarm REPL — a persistent session for follow-up tasks,
+ * thread inspection, manual merge/reject, and live DAG visualization.
+ *
+ * Usage: swarm --dir ./project   (no query argument enters interactive mode)
+ *
+ * Commands:
+ *   <task>          Run a task through the RLM orchestrator
+ *   /threads (/t)   List all threads with status, cost, duration
+ *   /thread <id>    Show detailed info for a specific thread
+ *   /merge [id...]  Merge specific thread branches (or all if no args)
+ *   /reject <id>    Discard a thread's worktree and branch
+ *   /dag            Show thread dependency DAG with status indicators
+ *   /budget         Show budget state
+ *   /status         Overall session status
+ *   /help           Show available commands
+ *   /quit (/exit)   Cleanup and exit
+ */
+import "./env.js";
+export declare function runInteractiveSwarm(rawArgs: string[]): Promise<void>;