swarm-code 0.1.0

package/dist/cli.js

@@ -0,0 +1,285 @@
+#!/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";
+import * as fs from "node:fs";
+// Dynamic imports — ensures env.js has set process.env BEFORE pi-ai loads
+const { getModels, getProviders } = await import("@mariozechner/pi-ai");
+const { PythonRepl } = await import("./core/repl.js");
+const { runRlmLoop } = await import("./core/rlm.js");
+// ── Arg parsing ─────────────────────────────────────────────────────────────
+function usage() {
+    console.error(`
+swarm run — Recursive Language Model CLI (arXiv:2512.24601)
+
+USAGE
+  rlm run [OPTIONS] "<query>"
+
+OPTIONS
+  --model <id>     Model ID (default: RLM_MODEL from .env)
+  --file <path>    Read context from a file
+  --url <url>      Fetch context from a URL
+  --stdin          Read context from stdin (pipe data in)
+  --verbose        Show iteration progress
+
+EXAMPLES
+  rlm run --file big.txt "List all classes"
+  curl -s https://example.com/large.py | rlm run --stdin "Summarize"
+  rlm run --url https://raw.githubusercontent.com/.../typing.py "Count public classes"
+`.trim());
+    process.exit(1);
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let modelId;
+    let file;
+    let url;
+    let useStdin = false;
+    let verbose = false;
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--model" && i + 1 < args.length) {
+            modelId = args[++i];
+        }
+        else if (arg === "--file" && i + 1 < args.length) {
+            file = args[++i];
+        }
+        else if (arg === "--url" && i + 1 < args.length) {
+            url = args[++i];
+        }
+        else if (arg === "--stdin") {
+            useStdin = true;
+        }
+        else if (arg === "--verbose") {
+            verbose = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            usage();
+        }
+        else if (!arg.startsWith("--")) {
+            positional.push(arg);
+        }
+        else {
+            console.error(`Unknown option: ${arg}`);
+            usage();
+        }
+    }
+    if (!modelId) {
+        modelId = process.env.RLM_MODEL || "claude-sonnet-4-6";
+    }
+    if (positional.length === 0) {
+        console.error("Error: query argument is required");
+        usage();
+    }
+    const query = positional.join(" ");
+    if (!file && !url && !useStdin) {
+        console.error("Error: one of --file, --url, or --stdin is required");
+        usage();
+    }
+    return { modelId, file, url, useStdin, verbose, query };
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+const MAX_STDIN_BYTES = 50 * 1024 * 1024; // 50MB
+async function readStdin() {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of process.stdin) {
+        total += chunk.length;
+        if (total > MAX_STDIN_BYTES) {
+            throw new Error(`stdin exceeds ${MAX_STDIN_BYTES / 1024 / 1024}MB limit`);
+        }
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+const FETCH_TIMEOUT_MS = 30_000;
+const MAX_RESPONSE_BYTES = 50 * 1024 * 1024; // 50MB
+async function fetchUrl(url) {
+    const resp = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+    if (!resp.ok) {
+        throw new Error(`Failed to fetch ${url}: ${resp.status} ${resp.statusText}`);
+    }
+    const contentLength = resp.headers.get("content-length");
+    if (contentLength && parseInt(contentLength, 10) > MAX_RESPONSE_BYTES) {
+        throw new Error(`Response too large (${(parseInt(contentLength, 10) / 1024 / 1024).toFixed(1)}MB). Limit is ${MAX_RESPONSE_BYTES / 1024 / 1024}MB.`);
+    }
+    const text = await resp.text();
+    if (text.length > MAX_RESPONSE_BYTES) {
+        throw new Error(`Response too large (${(text.length / 1024 / 1024).toFixed(1)}MB). Limit is ${MAX_RESPONSE_BYTES / 1024 / 1024}MB.`);
+    }
+    return text;
+}
+// ── Main ────────────────────────────────────────────────────────────────────
+async function main() {
+    const args = parseArgs();
+    // Provider → env var mapping
+    const providerKeys = {
+        anthropic: "ANTHROPIC_API_KEY",
+        openai: "OPENAI_API_KEY",
+        google: "GEMINI_API_KEY",
+    };
+    const defaultModels = {
+        anthropic: "claude-sonnet-4-6",
+        openai: "gpt-4o",
+        google: "gemini-2.5-flash",
+    };
+    // Resolve model — ensure provider has an API key
+    // Prioritise well-known providers so e.g. "gpt-4o" picks "openai" not "azure-openai-responses"
+    let model;
+    let _resolvedProvider = "";
+    const allModelIds = [];
+    const knownProviders = new Set(Object.keys(providerKeys));
+    // First pass: only well-known providers
+    for (const provider of getProviders()) {
+        const providerModels = getModels(provider);
+        for (const m of providerModels) {
+            allModelIds.push(m.id);
+            if (!model && m.id === args.modelId && knownProviders.has(provider)) {
+                const key = providerKeys[provider];
+                if (process.env[key]) {
+                    model = m;
+                    _resolvedProvider = provider;
+                }
+            }
+        }
+    }
+    // Second pass: remaining providers (if not found above)
+    if (!model) {
+        for (const provider of getProviders()) {
+            if (knownProviders.has(provider))
+                continue;
+            for (const m of getModels(provider)) {
+                if (m.id === args.modelId) {
+                    const key = `${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+                    if (process.env[key]) {
+                        model = m;
+                        _resolvedProvider = provider;
+                        break;
+                    }
+                }
+            }
+            if (model)
+                break;
+        }
+    }
+    // Fallback: if default model's provider has no key, pick one that does
+    if (!model) {
+        for (const [prov, envKey] of Object.entries(providerKeys)) {
+            if (!process.env[envKey])
+                continue;
+            const fallbackId = defaultModels[prov];
+            if (!fallbackId)
+                continue;
+            for (const p of getProviders()) {
+                if (p !== prov)
+                    continue;
+                for (const m of getModels(p)) {
+                    if (m.id === fallbackId) {
+                        model = m;
+                        _resolvedProvider = prov;
+                        args.modelId = fallbackId;
+                        console.error(`Note: using ${fallbackId} (${prov}) — set RLM_MODEL to override`);
+                        break;
+                    }
+                }
+                if (model)
+                    break;
+            }
+            if (model)
+                break;
+        }
+    }
+    if (!model) {
+        console.error(`Error: unknown model "${args.modelId}"`);
+        console.error(`Available models: ${allModelIds.join(", ")}`);
+        process.exit(1);
+    }
+    // Load context
+    let context;
+    if (args.file) {
+        try {
+            const stat = fs.statSync(args.file);
+            if (stat.isDirectory()) {
+                console.error(`Error: "${args.file}" is a directory. Use the interactive mode (\`rlm\`) for directory loading.`);
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            console.error(`Error: could not access "${args.file}": ${err.message}`);
+            process.exit(1);
+        }
+        console.error(`Reading context from file: ${args.file}`);
+        try {
+            context = fs.readFileSync(args.file, "utf-8");
+        }
+        catch (err) {
+            console.error(`Error: could not read file "${args.file}": ${err.message}`);
+            process.exit(1);
+        }
+    }
+    else if (args.url) {
+        console.error(`Fetching context from URL: ${args.url}`);
+        context = await fetchUrl(args.url);
+    }
+    else {
+        console.error("Reading context from stdin...");
+        context = await readStdin();
+    }
+    console.error(`Context loaded: ${context.length.toLocaleString()} characters`);
+    console.error(`Model: ${model.id}`);
+    console.error(`Query: ${args.query}`);
+    console.error("---");
+    // Start REPL
+    const repl = new PythonRepl();
+    const ac = new AbortController();
+    const abortAndExit = () => {
+        console.error("\nAborting...");
+        ac.abort();
+    };
+    process.on("SIGINT", abortAndExit);
+    process.on("SIGTERM", abortAndExit);
+    try {
+        await repl.start(ac.signal);
+        const startTime = Date.now();
+        const result = await runRlmLoop({
+            context,
+            query: args.query,
+            model,
+            repl,
+            signal: ac.signal,
+            onProgress: args.verbose
+                ? (info) => {
+                    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                    console.error(`[${elapsed}s] Iteration ${info.iteration}/${info.maxIterations} | ` +
+                        `Sub-queries: ${info.subQueries} | Phase: ${info.phase}`);
+                }
+                : undefined,
+        });
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.error("---");
+        console.error(`Completed in ${elapsed}s | ${result.iterations} iterations | ${result.totalSubQueries} sub-queries | ${result.completed ? "success" : "incomplete"}`);
+        console.error("---");
+        // Write the answer to stdout (not stderr) so it can be piped
+        console.log(result.answer);
+    }
+    finally {
+        repl.shutdown();
+    }
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/compression/compressor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Context compression — compresses thread output before returning to the orchestrator.
+ *
+ * Strategies:
+ *   - structured (default): status + files + diff stats + key hunks + tail output
+ *   - diff-only: just the git diff
+ *   - truncate: raw truncation
+ *   - llm-summary: use a cheap LLM to summarize thread work
+ *
+ * Episode quality: All strategies apply filterToSuccessfulOutput() first,
+ * stripping failed attempts, retries, and error noise so the orchestrator
+ * only sees what contributed to the final result (Slate-style episodes).
+ */
+import type { SwarmConfig } from "../core/types.js";
+export interface CompressionInput {
+    agentOutput: string;
+    diff: string;
+    diffStats: string;
+    filesChanged: string[];
+    success: boolean;
+    durationMs: number;
+    error?: string;
+}
+/** Optional LLM summarizer for llm-summary strategy. */
+export type LlmSummarizer = (text: string, instruction: string) => Promise<string>;
+/** Register an LLM summarizer for the llm-summary compression strategy. */
+export declare function setSummarizer(fn: LlmSummarizer): void;
+export declare function compressResult(input: CompressionInput, strategy?: SwarmConfig["compression_strategy"], maxChars?: number): Promise<string>;

package/dist/compression/compressor.js

@@ -0,0 +1,265 @@
+/**
+ * Context compression — compresses thread output before returning to the orchestrator.
+ *
+ * Strategies:
+ *   - structured (default): status + files + diff stats + key hunks + tail output
+ *   - diff-only: just the git diff
+ *   - truncate: raw truncation
+ *   - llm-summary: use a cheap LLM to summarize thread work
+ *
+ * Episode quality: All strategies apply filterToSuccessfulOutput() first,
+ * stripping failed attempts, retries, and error noise so the orchestrator
+ * only sees what contributed to the final result (Slate-style episodes).
+ */
+// Module-level summarizer — set once by the swarm orchestrator
+let _summarizer;
+/** Register an LLM summarizer for the llm-summary compression strategy. */
+export function setSummarizer(fn) {
+    _summarizer = fn;
+}
+// ── Episode quality filter ────────────────────────────────────────────────
+/**
+ * Patterns that indicate failed attempts, retries, or noise in agent output.
+ * These lines are stripped so the orchestrator only sees successful conclusions.
+ */
+const FAILURE_NOISE_PATTERNS = [
+    // Error/retry indicators (anchored to avoid matching "Error handling added")
+    /^error: /i,
+    /^Error: /,
+    /^failed to /i,
+    /^retrying/i,
+    /^retry attempt/i,
+    /^warning: /i,
+    /^timed? ?out/i,
+    // Common agent noise: stack traces
+    /^\s+at\s+\S+\s+\(/,
+    /^Traceback \(most recent/,
+    /^\s+File ".*", line \d+/,
+    // Agent internal chatter
+    /^Thinking\.\.\./i,
+    /^Searching\.\.\./i,
+    /^Reading\.\.\./i,
+    /^Running command\.\.\./i,
+    // Reverted / undone actions (anchored to start of line)
+    /^reverted /i,
+    /^undoing /i,
+    /^rolling back/i,
+];
+/** Patterns that indicate successful, conclusive output worth keeping. */
+const SUCCESS_SIGNAL_PATTERNS = [
+    /^Applied edit to/i,
+    /^Wrote /,
+    /^Created /i,
+    /^Updated /i,
+    /^Added /i,
+    /^Removed /i,
+    /^Fixed /i,
+    /^Committing /,
+    /tests? pass/i,
+    /✓|✔|PASS/,
+    /^DONE/i,
+    /^SUCCESS/i,
+    /^Result:/i,
+    /^Summary:/i,
+    /^Completed/i,
+];
+/**
+ * Filter agent output to only include lines that contributed to the final result.
+ * Strips failed attempts, retries, stack traces, and noise.
+ * Keeps: success signals, file-change confirmations, final conclusions, and
+ * any line that doesn't match a known noise pattern.
+ *
+ * Strategy: remove known-bad lines rather than keep only known-good,
+ * so novel agent output is preserved by default.
+ */
+function filterToSuccessfulOutput(agentOutput) {
+    if (!agentOutput)
+        return agentOutput;
+    const lines = agentOutput.split("\n");
+    const filtered = [];
+    let inStackTrace = false;
+    for (const line of lines) {
+        const trimmed = line.trimStart();
+        // Detect start of stack trace blocks (test untrimmed `line` for JS stack traces with leading whitespace)
+        if (/^Traceback \(most recent/.test(trimmed) || /^\s+at\s+\S+\s+\(/.test(line)) {
+            inStackTrace = true;
+            continue;
+        }
+        // End stack trace on blank line or non-indented line
+        if (inStackTrace) {
+            if (trimmed === "" || (!trimmed.startsWith(" ") && !trimmed.startsWith("\t"))) {
+                inStackTrace = false;
+                // Still check if this line itself is noise
+            }
+            else {
+                continue; // Skip stack trace continuation
+            }
+        }
+        // Always keep lines with success signals
+        if (SUCCESS_SIGNAL_PATTERNS.some((p) => p.test(trimmed))) {
+            filtered.push(line);
+            continue;
+        }
+        // Skip lines matching failure/noise patterns
+        if (FAILURE_NOISE_PATTERNS.some((p) => p.test(trimmed))) {
+            continue;
+        }
+        // Keep everything else (default: preserve novel output)
+        filtered.push(line);
+    }
+    // Collapse runs of blank lines to max 2
+    const collapsed = [];
+    let blankRun = 0;
+    for (const line of filtered) {
+        if (line.trim() === "") {
+            blankRun++;
+            if (blankRun <= 2)
+                collapsed.push(line);
+        }
+        else {
+            blankRun = 0;
+            collapsed.push(line);
+        }
+    }
+    return collapsed.join("\n").trim();
+}
+export async function compressResult(input, strategy = "structured", maxChars = 1000) {
+    // Episode quality: filter agent output to successful conclusions only
+    const filtered = {
+        ...input,
+        agentOutput: filterToSuccessfulOutput(input.agentOutput),
+    };
+    switch (strategy) {
+        case "structured":
+            return compressStructured(filtered, maxChars);
+        case "diff-only":
+            return compressDiffOnly(filtered, maxChars);
+        case "truncate":
+            return compressTruncate(filtered, maxChars);
+        case "llm-summary":
+            return compressLlmSummary(filtered, maxChars);
+        default:
+            return compressStructured(filtered, maxChars);
+    }
+}
+function compressStructured(input, maxChars) {
+    const parts = [];
+    // Status line
+    parts.push(`Status: ${input.success ? "SUCCESS" : "FAILED"} (${(input.durationMs / 1000).toFixed(1)}s)`);
+    if (input.error) {
+        parts.push(`Error: ${input.error}`);
+    }
+    // Files changed
+    if (input.filesChanged.length > 0) {
+        parts.push(`Files changed (${input.filesChanged.length}):`);
+        for (const f of input.filesChanged.slice(0, 20)) {
+            parts.push(`  - ${f}`);
+        }
+        if (input.filesChanged.length > 20) {
+            parts.push(`  ... and ${input.filesChanged.length - 20} more`);
+        }
+    }
+    // Diff stats
+    if (input.diffStats && input.diffStats !== "(no changes)") {
+        parts.push(`\nDiff stats:\n${input.diffStats}`);
+    }
+    // Key diff hunks (first portion)
+    if (input.diff && input.diff !== "(no changes)") {
+        const diffBudget = Math.floor(maxChars * 0.4);
+        const truncatedDiff = input.diff.length > diffBudget ? `${input.diff.slice(0, diffBudget)}\n... [diff truncated]` : input.diff;
+        parts.push(`\nKey changes:\n${truncatedDiff}`);
+    }
+    // Agent output tail
+    if (input.agentOutput) {
+        const outputBudget = Math.floor(maxChars * 0.3);
+        const lines = input.agentOutput.split("\n");
+        const tail = lines.slice(-30).join("\n");
+        const truncatedOutput = tail.length > outputBudget ? tail.slice(-outputBudget) : tail;
+        parts.push(`\nAgent output (last 30 lines):\n${truncatedOutput}`);
+    }
+    const result = parts.join("\n");
+    // Final truncation safety (4x maxChars is the hard cap for combined sections)
+    if (result.length > maxChars * 4) {
+        return `${result.slice(0, maxChars * 4)}\n... [compressed output truncated]`;
+    }
+    return result;
+}
+function compressDiffOnly(input, maxChars) {
+    const status = `Status: ${input.success ? "SUCCESS" : "FAILED"} (${(input.durationMs / 1000).toFixed(1)}s)`;
+    if (!input.diff || input.diff === "(no changes)") {
+        return `${status}\n(no changes)`;
+    }
+    if (input.diff.length > maxChars * 4) {
+        return `${status}\n${input.diff.slice(0, maxChars * 4)}\n... [diff truncated]`;
+    }
+    return `${status}\n${input.diff}`;
+}
+function compressTruncate(input, maxChars) {
+    const raw = [`Status: ${input.success ? "SUCCESS" : "FAILED"}`, input.agentOutput, input.diff]
+        .filter(Boolean)
+        .join("\n\n");
+    if (raw.length > maxChars * 4) {
+        // Preserve status line at the head, truncate from the middle
+        const statusEnd = raw.indexOf("\n");
+        const statusLine = statusEnd !== -1 ? raw.slice(0, statusEnd) : "";
+        const remaining = maxChars * 4 - statusLine.length - 20;
+        return `${statusLine}\n... [truncated]\n${raw.slice(-remaining)}`;
+    }
+    return raw;
+}
+/**
+ * LLM-based compression — uses a cheap model to summarize the thread's work.
+ * Falls back to structured compression if no summarizer is registered.
+ */
+async function compressLlmSummary(input, maxChars) {
+    if (!_summarizer) {
+        // Fall back to structured if no summarizer available
+        return compressStructured(input, maxChars);
+    }
+    // Build the text to summarize
+    const parts = [];
+    parts.push(`Task outcome: ${input.success ? "SUCCESS" : "FAILED"} (${(input.durationMs / 1000).toFixed(1)}s)`);
+    if (input.error) {
+        parts.push(`Error: ${input.error}`);
+    }
+    if (input.filesChanged.length > 0) {
+        parts.push(`Files changed: ${input.filesChanged.join(", ")}`);
+    }
+    if (input.diffStats && input.diffStats !== "(no changes)") {
+        parts.push(`Diff stats:\n${input.diffStats}`);
+    }
+    // Include truncated diff for context
+    if (input.diff && input.diff !== "(no changes)") {
+        const diffSlice = input.diff.slice(0, maxChars * 2);
+        parts.push(`Diff:\n${diffSlice}`);
+    }
+    // Include truncated agent output
+    if (input.agentOutput) {
+        const outputSlice = input.agentOutput.slice(-maxChars);
+        parts.push(`Agent output (tail):\n${outputSlice}`);
+    }
+    const textToSummarize = parts.join("\n\n");
+    const instruction = [
+        "Summarize this coding agent thread result concisely.",
+        "Include: what was done, which files were changed, whether it succeeded, and any key details.",
+        `Keep the summary under ${maxChars} characters.`,
+        "Be specific about code changes — mention function names, patterns, and key decisions.",
+    ].join(" ");
+    try {
+        const summary = await _summarizer(textToSummarize, instruction);
+        // Prepend status line
+        const status = `Status: ${input.success ? "SUCCESS" : "FAILED"} (${(input.durationMs / 1000).toFixed(1)}s)`;
+        const filesLine = input.filesChanged.length > 0 ? `\nFiles: ${input.filesChanged.join(", ")}` : "";
+        const result = `${status}${filesLine}\n\n${summary}`;
+        // Safety cap
+        if (result.length > maxChars * 2) {
+            return `${result.slice(0, maxChars * 2)}\n... [summary truncated]`;
+        }
+        return result;
+    }
+    catch {
+        // Fall back to structured on LLM failure
+        return compressStructured(input, maxChars);
+    }
+}
+//# sourceMappingURL=compressor.js.map

package/dist/config.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Configuration loader for swarm-code.
+ *
+ * Reads swarm_config.yaml (or rlm_config.yaml fallback) from project root or cwd.
+ * Extends RLM config with swarm-specific fields.
+ */
+/** Named model slot overrides — lets users assign specific models per task type. */
+export interface ModelSlots {
+    execution: string;
+    search: string;
+    reasoning: string;
+    planning: string;
+}
+export interface SwarmConfig {
+    max_iterations: number;
+    max_depth: number;
+    max_sub_queries: number;
+    truncate_len: number;
+    metadata_preview_lines: number;
+    max_threads: number;
+    max_total_threads: number;
+    thread_timeout_ms: number;
+    max_thread_budget_usd: number;
+    max_session_budget_usd: number;
+    default_agent: string;
+    default_model: string;
+    auto_model_selection: boolean;
+    compression_strategy: "structured" | "llm-summary" | "diff-only" | "truncate";
+    compression_max_tokens: number;
+    worktree_base_dir: string;
+    auto_cleanup_worktrees: boolean;
+    episodic_memory_enabled: boolean;
+    memory_dir: string;
+    thread_retries: number;
+    model_slots: ModelSlots;
+    thread_cache_persist: boolean;
+    thread_cache_dir: string;
+    thread_cache_ttl_hours: number;
+    opencode_server_mode: boolean;
+}
+export type RlmConfig = SwarmConfig;
+export declare function loadConfig(cwd?: string): SwarmConfig;