swarm-code 0.1.5 → 0.1.6

package/dist/config.js

@@ -23,7 +23,7 @@ const DEFAULTS = {
     max_session_budget_usd: 10.0,
     default_agent: "opencode",
     default_model: "anthropic/claude-sonnet-4-6",
-    auto_model_selection: false,
+    auto_model_selection: true,
     compression_strategy: "structured",
     compression_max_tokens: 1000,
     worktree_base_dir: ".swarm-worktrees",

package/dist/hooks/runner.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Hook runner — executes user-defined commands at lifecycle points.
+ *
+ * Hooks provide deterministic control flow (not LLM-decided).
+ * They run shell commands and surface only errors — success is silent.
+ *
+ * Lifecycle points:
+ *   - post_thread: After a thread commits (before compression)
+ *   - post_merge: After merge_threads() completes
+ *   - post_session: When the session ends
+ */
+export interface HookConfig {
+    command: string;
+    on_failure: "warn" | "block";
+}
+export interface HooksConfig {
+    post_thread: HookConfig[];
+    post_merge: HookConfig[];
+    post_session: HookConfig[];
+}
+export interface HookResult {
+    success: boolean;
+    output: string;
+    command: string;
+}
+/**
+ * Load hooks from swarm_config.yaml hooks section, or from .swarm/hooks.yaml.
+ */
+export declare function loadHooks(projectDir: string): HooksConfig;
+/**
+ * Run hooks for a lifecycle point.
+ * Returns results for each hook. On "block" failure, throws.
+ * Success output is swallowed — only errors are surfaced.
+ */
+export declare function runHooks(hooks: HookConfig[], cwd: string, label: string): HookResult[];

package/dist/hooks/runner.js

@@ -0,0 +1,95 @@
+/**
+ * Hook runner — executes user-defined commands at lifecycle points.
+ *
+ * Hooks provide deterministic control flow (not LLM-decided).
+ * They run shell commands and surface only errors — success is silent.
+ *
+ * Lifecycle points:
+ *   - post_thread: After a thread commits (before compression)
+ *   - post_merge: After merge_threads() completes
+ *   - post_session: When the session ends
+ */
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+const DEFAULT_HOOKS = {
+    post_thread: [],
+    post_merge: [],
+    post_session: [],
+};
+/**
+ * Load hooks from swarm_config.yaml hooks section, or from .swarm/hooks.yaml.
+ */
+export function loadHooks(projectDir) {
+    const hooksFile = path.join(projectDir, ".swarm", "hooks.yaml");
+    if (!fs.existsSync(hooksFile))
+        return { ...DEFAULT_HOOKS };
+    try {
+        const raw = fs.readFileSync(hooksFile, "utf-8");
+        return parseHooksYaml(raw);
+    }
+    catch {
+        return { ...DEFAULT_HOOKS };
+    }
+}
+function parseHooksYaml(raw) {
+    const hooks = { post_thread: [], post_merge: [], post_session: [] };
+    let currentSection = null;
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        if (trimmed === "post_thread:" || trimmed === "post_merge:" || trimmed === "post_session:") {
+            currentSection = trimmed.replace(":", "");
+            continue;
+        }
+        if (currentSection && trimmed.startsWith("- command:")) {
+            const command = trimmed
+                .replace("- command:", "")
+                .trim()
+                .replace(/^["']|["']$/g, "");
+            if (command) {
+                hooks[currentSection].push({ command, on_failure: "warn" });
+            }
+        }
+        if (currentSection && trimmed.startsWith("on_failure:")) {
+            const val = trimmed.replace("on_failure:", "").trim();
+            const last = hooks[currentSection][hooks[currentSection].length - 1];
+            if (last && (val === "warn" || val === "block")) {
+                last.on_failure = val;
+            }
+        }
+    }
+    return hooks;
+}
+/**
+ * Run hooks for a lifecycle point.
+ * Returns results for each hook. On "block" failure, throws.
+ * Success output is swallowed — only errors are surfaced.
+ */
+export function runHooks(hooks, cwd, label) {
+    const results = [];
+    for (const hook of hooks) {
+        try {
+            execSync(hook.command, {
+                cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                timeout: 60_000,
+                encoding: "utf-8",
+            });
+            // Success — silent (context-efficient per harness engineering best practice)
+            results.push({ success: true, output: "", command: hook.command });
+        }
+        catch (err) {
+            const stderr = err.stderr || err.stdout || err.message || "unknown error";
+            // Only surface error output
+            const output = `[${label}] Hook failed: ${hook.command}\n${stderr}`.trim();
+            results.push({ success: false, output, command: hook.command });
+            if (hook.on_failure === "block") {
+                throw new Error(output);
+            }
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=runner.js.map

package/dist/interactive-swarm.js

@@ -80,8 +80,7 @@ function parseInteractiveArgs(args) {
         // Silently ignore unknown flags and positional args
     }
     if (!dir) {
-        logError("--dir <path> is required for interactive swarm mode");
-        process.exit(1);
+        dir = process.cwd();
     }
     return {
         dir: path.resolve(dir),

package/dist/main.d.ts

@@ -10,6 +10,6 @@
  *   swarm run                    → single-shot RLM CLI run
  *   swarm viewer                 → browse trajectory files
  *   swarm benchmark              → run benchmarks
- *   swarm                        → interactive terminal (RLM mode, default)
+ *   swarm                        → interactive REPL (uses current directory)
  */
 export declare function buildHelp(): string;

package/dist/main.js

@@ -10,7 +10,7 @@
  *   swarm run                    → single-shot RLM CLI run
  *   swarm viewer                 → browse trajectory files
  *   swarm benchmark              → run benchmarks
- *   swarm                        → interactive terminal (RLM mode, default)
+ *   swarm                        → interactive REPL (uses current directory)
  */
 import { bold, coral, cyan, dim, isTTY, symbols, termWidth, yellow } from "./ui/theme.js";
 export function buildHelp() {
@@ -45,8 +45,10 @@ export function buildHelp() {
     lines.push(`    ${yellow("swarm mcp")}                       ${dim("Start MCP server (stdio)")}`);
     lines.push(`    ${yellow("swarm mcp")} --dir ./project       ${dim("Start with default directory")}`);
     lines.push("");
+    lines.push(`  ${bold("INTERACTIVE")} ${dim("(default — uses current directory)")}`);
+    lines.push(`    ${yellow("swarm")}                          ${dim("Interactive REPL in current dir")}`);
+    lines.push("");
     lines.push(`  ${bold("RLM MODE")} ${dim("(text processing, inherited from rlm-cli)")}`);
-    lines.push(`    ${yellow("swarm")}                          ${dim("Interactive terminal (default)")}`);
     lines.push(`    ${yellow("swarm run")} [options] "<query>"  ${dim("Run a single query")}`);
     lines.push(`    ${yellow("swarm viewer")}                    ${dim("Browse saved trajectory files")}`);
     lines.push(`    ${yellow("swarm benchmark")} <name> [--idx]  ${dim("Run benchmark")}`);
@@ -125,13 +127,14 @@ async function main() {
         }
         return;
     }
-    const command = args[0] || "interactive";
+    const command = args[0] || "";
+    // Default: no command → interactive swarm mode using current directory
+    if (!command || command === "interactive" || command === "i") {
+        const { runInteractiveSwarm } = await import("./interactive-swarm.js");
+        await runInteractiveSwarm(["--dir", process.cwd(), ...args.slice(command ? 1 : 0)]);
+        return;
+    }
     switch (command) {
-        case "interactive":
-        case "i": {
-            await import("./interactive.js");
-            break;
-        }
         case "viewer":
         case "view": {
             process.argv = [process.argv[0], process.argv[1], ...args.slice(1)];

package/dist/prompts/orchestrator.js

@@ -56,11 +56,11 @@ ${agentDescriptions}
 
 1. **Analyze first**: Use \`llm_query()\` or direct Python to understand the codebase/task
 2. **Decompose**: Break the task into independent, parallelizable units
-3. **Extract context**: For each thread, extract ONLY the relevant code/context — don't send everything
+3. **Extract context**: For each thread, extract ONLY the relevant code/context — don't send everything. Keep thread context under 5000 chars; agents have access to the full worktree
 4. **Spawn threads**: Use \`async_thread()\` + \`asyncio.gather()\` for parallel work
 5. **Inspect results**: Check each thread's result for success/failure
 6. **Merge**: Call \`merge_threads()\` to integrate changes
-7. **Verify**: Optionally spawn a test thread to verify the merged result
+7. **Verify**: ALWAYS spawn a verification thread after merging — run the project's test/typecheck/lint commands. If verification fails, fix before calling FINAL()
 8. **Report**: Call \`FINAL()\` with a summary
 
 ## Episode Quality & Caching
@@ -77,7 +77,8 @@ ${agentDescriptions}
 4. Use \`print()\` for intermediate output visible in the next iteration
 5. Max ${config.max_threads} concurrent threads, ${config.max_total_threads} total per session
 6. Thread timeout: ${config.thread_timeout_ms / 1000}s per thread
-7. Don't call FINAL prematurely — verify thread results first
+7. Don't call FINAL prematurely — verify thread results first. Always run verification after merge.
+8. Prefer cheap models for sub-agent threads (haiku, gpt-4o-mini) — save premium models for complex work
 8. The REPL persists state — variables survive across iterations
 
 ## Examples

package/dist/swarm.js

@@ -25,6 +25,7 @@ await import("./agents/claude-code.js");
 await import("./agents/codex.js");
 await import("./agents/aider.js");
 import { randomBytes } from "node:crypto";
+import { loadHooks, runHooks } from "./hooks/runner.js";
 import { EpisodicMemory } from "./memory/episodic.js";
 import { buildSwarmSystemPrompt } from "./prompts/orchestrator.js";
 import { classifyTaskComplexity, describeAvailableAgents, FailureTracker, routeTask } from "./routing/model-router.js";
@@ -296,6 +297,7 @@ function resolveModel(modelId) {
 export async function runSwarmMode(rawArgs) {
     const args = parseSwarmArgs(rawArgs);
     const config = loadConfig();
+    const hooks = loadHooks(args.dir);
     // Configure UI
     if (args.json)
         setJsonMode(true);
@@ -420,6 +422,12 @@ export async function runSwarmMode(rawArgs) {
         }
         // Thread handler
         const threadHandler = async (task, threadContext, agentBackend, model, files) => {
+            // Context-size guard: warn and truncate if orchestrator sends too much context
+            const MAX_THREAD_CONTEXT = 50_000;
+            if (threadContext.length > MAX_THREAD_CONTEXT) {
+                logWarn(`Thread context too large (${(threadContext.length / 1024).toFixed(0)}KB) — truncating to ${MAX_THREAD_CONTEXT / 1000}KB. Agents have full worktree access; pass only relevant excerpts.`);
+                threadContext = `${threadContext.slice(0, MAX_THREAD_CONTEXT)}\n\n[... truncated — ${threadContext.length - MAX_THREAD_CONTEXT} chars removed ...]`;
+            }
             let resolvedAgent = agentBackend || config.default_agent;
             let resolvedModel = model || config.default_model;
             let routeSlot = "";
@@ -449,6 +457,18 @@ export async function runSwarmMode(rawArgs) {
                 },
                 files,
             });
+            // Run post-thread hooks (typecheck, lint, etc.) — success is silent, only errors surface
+            if (result.success && hooks.post_thread.length > 0) {
+                try {
+                    const worktreePath = path.join(args.dir, config.worktree_base_dir, `wt-${threadId}`);
+                    if (fs.existsSync(worktreePath)) {
+                        runHooks(hooks.post_thread, worktreePath, "post_thread");
+                    }
+                }
+                catch (hookErr) {
+                    logWarn(`Post-thread hook failed: ${hookErr.message}`);
+                }
+            }
             // Track failure in the failure tracker for routing adjustments
             if (!result.success) {
                 failureTracker.recordFailure(resolvedAgent, resolvedModel, task, result.summary || "unknown error");
@@ -494,6 +514,26 @@ export async function runSwarmMode(rawArgs) {
             const summary = results
                 .map((r) => (r.success ? `Merged ${r.branch}: ${r.message}` : `FAILED ${r.branch}: ${r.message}`))
                 .join("\n");
+            // Run post-merge hooks (tests, etc.) — success is silent
+            if (merged > 0 && hooks.post_merge.length > 0) {
+                try {
+                    const hookResults = runHooks(hooks.post_merge, args.dir, "post_merge");
+                    const hookFailures = hookResults.filter((r) => !r.success);
+                    if (hookFailures.length > 0) {
+                        const hookOutput = hookFailures.map((r) => r.output).join("\n");
+                        return {
+                            result: `${summary}\n\nPost-merge verification failed:\n${hookOutput}`,
+                            success: false,
+                        };
+                    }
+                }
+                catch (hookErr) {
+                    return {
+                        result: `${summary}\n\nPost-merge hook blocked: ${hookErr.message}`,
+                        success: false,
+                    };
+                }
+            }
             return {
                 result: summary || "No threads to merge",
                 success: results.every((r) => r.success),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarm-code",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Open-source swarm-native coding agent orchestrator — spawns parallel coding agents in isolated git worktrees, built on RLM (arXiv:2512.24601)",
   "type": "module",
   "bin": {