swarm-code 0.1.0

package/dist/swarm.js

@@ -0,0 +1,557 @@
+/**
+ * Swarm mode — orchestrates coding agents in parallel via the RLM loop.
+ *
+ * Usage: swarm --dir ./my-project "add error handling to all API routes"
+ *
+ * This module:
+ *   1. Parses swarm-specific CLI args
+ *   2. Scans the target directory to build a codebase context
+ *   3. Sets up ThreadManager + WorktreeManager
+ *   4. Runs the RLM loop with the swarm orchestrator prompt
+ *   5. Cleans up worktrees on exit
+ */
+import "./env.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+// 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");
+const { loadConfig } = await import("./config.js");
+// Register agent backends
+const opencodeMod = await import("./agents/opencode.js");
+await import("./agents/direct-llm.js");
+await import("./agents/claude-code.js");
+await import("./agents/codex.js");
+await import("./agents/aider.js");
+import { randomBytes } from "node:crypto";
+import { EpisodicMemory } from "./memory/episodic.js";
+import { buildSwarmSystemPrompt } from "./prompts/orchestrator.js";
+import { classifyTaskComplexity, describeAvailableAgents, FailureTracker, routeTask } from "./routing/model-router.js";
+import { ThreadManager } from "./threads/manager.js";
+import { renderBanner } from "./ui/banner.js";
+import { ThreadDashboard } from "./ui/dashboard.js";
+import { isJsonMode, logAnswer, logError, logRouter, logSuccess, logVerbose, logWarn, setJsonMode, setLogLevel, } from "./ui/log.js";
+import { runOnboarding } from "./ui/onboarding.js";
+// UI system
+import { Spinner } from "./ui/spinner.js";
+import { renderSummary } from "./ui/summary.js";
+import { mergeAllThreads } from "./worktree/merge.js";
+function parseSwarmArgs(args) {
+    let dir = "";
+    let orchestratorModel = "";
+    let agent = "";
+    let dryRun = false;
+    let maxBudget = null;
+    let verbose = false;
+    let quiet = false;
+    let json = false;
+    let autoRoute = false;
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            process.stderr.write(`\nUsage: swarm --dir <path> [options] "your task"\n\n`);
+            process.stderr.write(`Options:\n`);
+            process.stderr.write(`  --dir <path>           Target repository directory\n`);
+            process.stderr.write(`  --orchestrator <model> Orchestrator LLM model\n`);
+            process.stderr.write(`  --agent <backend>      Agent backend (opencode, claude, codex, aider)\n`);
+            process.stderr.write(`  --dry-run              Plan only, don't spawn threads\n`);
+            process.stderr.write(`  --max-budget <usd>     Maximum session budget\n`);
+            process.stderr.write(`  --auto-route           Enable automatic model selection\n`);
+            process.stderr.write(`  --verbose              Detailed progress output\n`);
+            process.stderr.write(`  --quiet / -q           Suppress non-essential output\n`);
+            process.stderr.write(`  --json                 Machine-readable JSON output\n\n`);
+            process.exit(0);
+        }
+        else if (arg === "--dir" && i + 1 < args.length) {
+            dir = args[++i];
+        }
+        else if (arg === "--orchestrator" && i + 1 < args.length) {
+            orchestratorModel = args[++i];
+        }
+        else if (arg === "--agent" && i + 1 < args.length) {
+            agent = args[++i];
+        }
+        else if (arg === "--dry-run") {
+            dryRun = true;
+        }
+        else if (arg === "--max-budget" && i + 1 < args.length) {
+            const rawBudget = args[++i];
+            const parsed = parseFloat(rawBudget);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                maxBudget = parsed;
+            }
+            else {
+                logWarn(`Invalid --max-budget value "${rawBudget}", ignoring`);
+            }
+        }
+        else if (arg === "--verbose") {
+            verbose = true;
+        }
+        else if (arg === "--quiet" || arg === "-q") {
+            quiet = true;
+        }
+        else if (arg === "--json") {
+            json = true;
+        }
+        else if (arg === "--auto-route") {
+            autoRoute = true;
+        }
+        else if (arg.startsWith("--")) {
+            logWarn(`Unknown flag: ${arg}`);
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    if (!dir) {
+        logError("--dir <path> is required for swarm mode", 'Usage: swarm --dir ./project "your task"');
+        process.exit(1);
+    }
+    if (positional.length === 0) {
+        logError("Query argument is required", 'Usage: swarm --dir ./project "your task description"');
+        process.exit(1);
+    }
+    return {
+        dir: path.resolve(dir),
+        orchestratorModel: orchestratorModel || process.env.RLM_MODEL || "claude-sonnet-4-6",
+        agent: agent || "",
+        dryRun,
+        maxBudget,
+        autoRoute,
+        verbose,
+        quiet,
+        json,
+        query: positional.join(" "),
+    };
+}
+// ── Codebase scanning ───────────────────────────────────────────────────────
+const SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".swarm-worktrees",
+    "coverage",
+    ".turbo",
+    ".cache",
+]);
+const SKIP_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".svg",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".mp3",
+    ".mp4",
+    ".webm",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".lock",
+    ".map",
+]);
+function scanDirectory(dir, maxFiles = 200, maxTotalSize = 2 * 1024 * 1024) {
+    const files = [];
+    let totalSize = 0;
+    function walk(currentDir, depth) {
+        if (depth > 15 || files.length >= maxFiles || totalSize >= maxTotalSize)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (files.length >= maxFiles || totalSize >= maxTotalSize)
+                return;
+            if (entry.isDirectory()) {
+                if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+                    walk(path.join(currentDir, entry.name), depth + 1);
+                }
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (SKIP_EXTENSIONS.has(ext))
+                    continue;
+                const fullPath = path.join(currentDir, entry.name);
+                try {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.size > 100 * 1024)
+                        continue;
+                    if (stat.size === 0)
+                        continue;
+                    const content = fs.readFileSync(fullPath, "utf-8");
+                    if (content.includes("\0"))
+                        continue;
+                    const relPath = path.relative(dir, fullPath);
+                    files.push({ relPath, content });
+                    totalSize += content.length;
+                }
+                catch { }
+            }
+        }
+    }
+    walk(dir, 0);
+    const parts = [];
+    parts.push(`Codebase: ${path.basename(dir)}`);
+    parts.push(`Files: ${files.length}`);
+    parts.push(`Total size: ${(totalSize / 1024).toFixed(1)}KB`);
+    parts.push("---");
+    for (const file of files) {
+        parts.push(`\n=== ${file.relPath} ===`);
+        parts.push(file.content);
+    }
+    return parts.join("\n");
+}
+// ── Model resolution ────────────────────────────────────────────────────────
+function resolveModel(modelId) {
+    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",
+    };
+    const knownProviders = new Set(Object.keys(providerKeys));
+    let model;
+    let resolvedProvider = "";
+    for (const provider of getProviders()) {
+        if (!knownProviders.has(provider))
+            continue;
+        const key = providerKeys[provider];
+        if (!process.env[key])
+            continue;
+        for (const m of getModels(provider)) {
+            if (m.id === modelId) {
+                model = m;
+                resolvedProvider = provider;
+                break;
+            }
+        }
+        if (model)
+            break;
+    }
+    if (!model) {
+        for (const provider of getProviders()) {
+            if (knownProviders.has(provider))
+                continue;
+            for (const m of getModels(provider)) {
+                if (m.id === modelId) {
+                    model = m;
+                    resolvedProvider = provider;
+                    break;
+                }
+            }
+            if (model)
+                break;
+        }
+    }
+    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;
+                        logWarn(`Using ${fallbackId} (${prov}) — model "${modelId}" not found`);
+                        break;
+                    }
+                }
+                if (model)
+                    break;
+            }
+            if (model)
+                break;
+        }
+    }
+    if (!model)
+        return null;
+    return { model, provider: resolvedProvider };
+}
+// ── Main ────────────────────────────────────────────────────────────────────
+export async function runSwarmMode(rawArgs) {
+    const args = parseSwarmArgs(rawArgs);
+    const config = loadConfig();
+    // Configure UI
+    if (args.json)
+        setJsonMode(true);
+    if (args.quiet)
+        setLogLevel("quiet");
+    else if (args.verbose)
+        setLogLevel("verbose");
+    // Verify target directory before anything else
+    if (!fs.existsSync(args.dir)) {
+        logError(`Directory "${args.dir}" does not exist`);
+        process.exit(1);
+    }
+    // First-run onboarding (after dir validation so we don't waste user's time)
+    await runOnboarding();
+    // Override config with CLI args
+    if (args.agent)
+        config.default_agent = args.agent;
+    if (args.maxBudget !== null)
+        config.max_session_budget_usd = args.maxBudget;
+    if (args.autoRoute)
+        config.auto_model_selection = true;
+    // Resolve orchestrator model
+    const resolved = resolveModel(args.orchestratorModel);
+    if (!resolved) {
+        logError(`Could not find model "${args.orchestratorModel}"`, "Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY in your .env file");
+        process.exit(1);
+    }
+    // Initialize episodic memory if enabled
+    let episodicMemory;
+    if (config.episodic_memory_enabled) {
+        episodicMemory = new EpisodicMemory(config.memory_dir);
+        await episodicMemory.init();
+    }
+    // Initialize failure tracker for session-level agent failure tracking
+    const failureTracker = new FailureTracker();
+    // Render banner
+    renderBanner({
+        dir: args.dir,
+        model: resolved.model.id,
+        provider: resolved.provider,
+        agent: config.default_agent,
+        routing: config.auto_model_selection ? "auto" : "orchestrator-driven",
+        query: args.query,
+        dryRun: args.dryRun,
+        memorySize: episodicMemory?.size,
+    });
+    // Scan codebase with spinner
+    const spinner = new Spinner();
+    spinner.start("scanning codebase");
+    const context = scanDirectory(args.dir);
+    spinner.stop();
+    logSuccess(`Scanned codebase — ${(context.length / 1024).toFixed(1)}KB context`);
+    // Start REPL
+    const repl = new PythonRepl();
+    const ac = new AbortController();
+    // Thread dashboard for live status
+    const dashboard = new ThreadDashboard();
+    // Progress callback for thread events
+    const threadProgress = (threadId, phase, detail) => {
+        if (phase === "completed" || phase === "failed" || phase === "cancelled") {
+            dashboard.complete(threadId, phase, detail);
+        }
+        else {
+            dashboard.update(threadId, phase, detail);
+        }
+    };
+    // Enable OpenCode server mode for persistent connections (reduces cold-start)
+    if (config.default_agent === "opencode" && config.opencode_server_mode) {
+        opencodeMod.enableServerMode();
+        logVerbose("OpenCode server mode enabled");
+    }
+    // Initialize thread manager
+    const threadManager = new ThreadManager(args.dir, config, threadProgress, ac.signal);
+    await threadManager.init();
+    if (episodicMemory) {
+        threadManager.setEpisodicMemory(episodicMemory);
+    }
+    const abortAndExit = () => {
+        spinner.stop();
+        dashboard.clear();
+        logWarn("Aborting...");
+        ac.abort();
+    };
+    process.on("SIGINT", abortAndExit);
+    process.on("SIGTERM", abortAndExit);
+    try {
+        await repl.start(ac.signal);
+        // Register LLM summarizer for llm-summary compression strategy
+        if (config.compression_strategy === "llm-summary") {
+            const { setSummarizer } = await import("./compression/compressor.js");
+            const { completeSimple } = await import("@mariozechner/pi-ai");
+            setSummarizer(async (text, instruction) => {
+                const response = await completeSimple(resolved.model, {
+                    systemPrompt: instruction,
+                    messages: [
+                        {
+                            role: "user",
+                            content: text,
+                            timestamp: Date.now(),
+                        },
+                    ],
+                });
+                return response.content
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("");
+            });
+        }
+        // Build system prompt
+        const agentDesc = await describeAvailableAgents();
+        let systemPrompt = buildSwarmSystemPrompt(config, agentDesc);
+        if (args.dryRun) {
+            systemPrompt +=
+                "\n\n## DRY RUN MODE\nDo NOT call thread() or async_thread(). Instead, describe what threads you WOULD spawn (task, files, model). Call FINAL() with your execution plan.";
+        }
+        // Add episodic memory hints
+        if (episodicMemory && episodicMemory.size > 0) {
+            const hints = episodicMemory.getStrategyHints(args.query);
+            if (hints) {
+                systemPrompt += `\n\n## Episodic Memory\n${hints}\nConsider these strategies when decomposing your task.`;
+            }
+        }
+        // Thread handler
+        const threadHandler = async (task, threadContext, agentBackend, model, files) => {
+            let resolvedAgent = agentBackend || config.default_agent;
+            let resolvedModel = model || config.default_model;
+            let routeSlot = "";
+            let routeComplexity = "";
+            if (config.auto_model_selection && !agentBackend && !model) {
+                const route = await routeTask(task, config, episodicMemory, failureTracker);
+                resolvedAgent = route.agent;
+                resolvedModel = route.model;
+                routeSlot = route.slot;
+                routeComplexity = classifyTaskComplexity(task);
+                logRouter(`${route.reason} [slot: ${route.slot}]`);
+            }
+            const threadId = randomBytes(6).toString("hex");
+            // Update dashboard with task info
+            dashboard.update(threadId, "queued", undefined, {
+                task,
+                agent: resolvedAgent,
+                model: resolvedModel,
+            });
+            const result = await threadManager.spawnThread({
+                id: threadId,
+                task,
+                context: threadContext,
+                agent: {
+                    backend: resolvedAgent,
+                    model: resolvedModel,
+                },
+                files,
+            });
+            // Track failure in the failure tracker for routing adjustments
+            if (!result.success) {
+                failureTracker.recordFailure(resolvedAgent, resolvedModel, task, result.summary || "unknown error");
+            }
+            // Record episode
+            if (episodicMemory && result.success && routeSlot) {
+                episodicMemory
+                    .record({
+                    task,
+                    agent: resolvedAgent,
+                    model: resolvedModel,
+                    slot: routeSlot,
+                    complexity: routeComplexity,
+                    success: true,
+                    durationMs: result.durationMs,
+                    estimatedCostUsd: result.estimatedCostUsd,
+                    filesChanged: result.filesChanged,
+                    summary: result.summary,
+                })
+                    .catch(() => { });
+            }
+            return {
+                result: result.summary,
+                success: result.success,
+                filesChanged: result.filesChanged,
+                durationMs: result.durationMs,
+            };
+        };
+        // Merge handler
+        const mergeHandler = async () => {
+            spinner.update("merging thread branches");
+            const threads = threadManager.getThreads();
+            const mergeOpts = { continueOnConflict: true };
+            const results = await mergeAllThreads(args.dir, threads, mergeOpts);
+            const merged = results.filter((r) => r.success).length;
+            const failed = results.filter((r) => !r.success).length;
+            if (failed > 0) {
+                logWarn(`Merged ${merged} branches, ${failed} failed`);
+            }
+            else if (merged > 0) {
+                logSuccess(`Merged ${merged} branches`);
+            }
+            const summary = results
+                .map((r) => (r.success ? `Merged ${r.branch}: ${r.message}` : `FAILED ${r.branch}: ${r.message}`))
+                .join("\n");
+            return {
+                result: summary || "No threads to merge",
+                success: results.every((r) => r.success),
+            };
+        };
+        // Run the orchestrator
+        spinner.start();
+        const startTime = Date.now();
+        const result = await runRlmLoop({
+            context,
+            query: args.query,
+            model: resolved.model,
+            repl,
+            signal: ac.signal,
+            systemPrompt,
+            threadHandler: args.dryRun ? undefined : threadHandler,
+            mergeHandler: args.dryRun ? undefined : mergeHandler,
+            onProgress: (info) => {
+                spinner.update(`iteration ${info.iteration}/${info.maxIterations}` +
+                    (info.subQueries > 0 ? ` · ${info.subQueries} queries` : ""));
+                logVerbose(`Iteration ${info.iteration}/${info.maxIterations} | ` +
+                    `Sub-queries: ${info.subQueries} | Phase: ${info.phase}`);
+            },
+        });
+        spinner.stop();
+        dashboard.clear();
+        const elapsed = (Date.now() - startTime) / 1000;
+        // Render summary
+        const summary = {
+            elapsed,
+            iterations: result.iterations,
+            subQueries: result.totalSubQueries,
+            completed: result.completed,
+            answer: result.answer,
+            threads: threadManager.getThreads(),
+            budget: threadManager.getBudgetState(),
+            cacheStats: threadManager.getCacheStats(),
+            episodeCount: episodicMemory?.size,
+        };
+        renderSummary(summary);
+        // Output the answer
+        if (isJsonMode()) {
+            // Already output via renderSummary
+        }
+        else {
+            process.stderr.write("\n");
+            logAnswer(result.answer);
+        }
+    }
+    finally {
+        spinner.stop();
+        dashboard.clear();
+        process.removeListener("SIGINT", abortAndExit);
+        process.removeListener("SIGTERM", abortAndExit);
+        repl.shutdown();
+        await threadManager.cleanup();
+        // Shut down any managed OpenCode server instances
+        await opencodeMod.disableServerMode();
+    }
+}
+//# sourceMappingURL=swarm.js.map

package/dist/threads/cache.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Thread cache — caches thread results by (task, files, agent) hash.
+ *
+ * Slate's "subthread reuse" optimization: when the orchestrator spawns
+ * an identical thread (same task + same files + same agent), return the
+ * cached result instead of re-running the agent. Saves cost and time.
+ *
+ * Two modes:
+ *   1. Session-scoped (default): in-memory Map, cleared on exit.
+ *   2. Disk-persistent: reads/writes JSON files in a cache directory,
+ *      with TTL-based expiry so stale entries don't accumulate.
+ *
+ * Cache keys are SHA-256 hashes of normalized (task, files, agent, model).
+ */
+import type { CompressedResult } from "../core/types.js";
+export interface ThreadCacheEntry {
+    result: CompressedResult;
+    cachedAt: number;
+    hitCount: number;
+}
+export interface ThreadCacheStats {
+    size: number;
+    hits: number;
+    misses: number;
+    totalSavedMs: number;
+    totalSavedUsd: number;
+    persistedEntries: number;
+}
+export declare class ThreadCache {
+    private cache;
+    private hits;
+    private misses;
+    private totalSavedMs;
+    private totalSavedUsd;
+    private maxEntries;
+    private persistDir?;
+    private ttlMs;
+    private persistedKeys;
+    constructor(maxEntries?: number, persistDir?: string, ttlHours?: number);
+    /** Initialize persistent cache — load entries from disk. */
+    init(): Promise<void>;
+    /**
+     * Look up a cached result for the given thread parameters.
+     * Returns undefined on cache miss.
+     */
+    get(task: string, files: string[], agent: string, model: string): CompressedResult | undefined;
+    /**
+     * Store a thread result in the cache.
+     * Only caches successful results — failed threads should be retried.
+     */
+    set(task: string, files: string[], agent: string, model: string, result: CompressedResult): void;
+    /** Get cache statistics. */
+    getStats(): ThreadCacheStats;
+    /** Clear all cached entries (in-memory and on disk). */
+    clear(): void;
+    private saveDiskEntry;
+    private deleteDiskEntry;
+}