swarm-code 0.1.0

package/dist/threads/cache.js

@@ -0,0 +1,198 @@
+/**
+ * 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 { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * Compute a stable cache key from thread parameters.
+ * Normalizes inputs: trims task, sorts files, lowercases agent/model.
+ */
+function computeCacheKey(task, files, agent, model) {
+    const normalized = JSON.stringify({
+        task: task.trim(),
+        files: [...files].sort(),
+        agent: agent.toLowerCase(),
+        model: model.toLowerCase(),
+    });
+    return createHash("sha256").update(normalized).digest("hex");
+}
+export class ThreadCache {
+    cache = new Map();
+    hits = 0;
+    misses = 0;
+    totalSavedMs = 0;
+    totalSavedUsd = 0;
+    maxEntries;
+    persistDir;
+    ttlMs;
+    persistedKeys = new Set();
+    constructor(maxEntries = 100, persistDir, ttlHours = 24) {
+        this.maxEntries = maxEntries;
+        this.persistDir = persistDir;
+        this.ttlMs = ttlHours * 60 * 60 * 1000;
+    }
+    /** Initialize persistent cache — load entries from disk. */
+    async init() {
+        if (!this.persistDir)
+            return;
+        fs.mkdirSync(this.persistDir, { recursive: true });
+        let files;
+        try {
+            files = fs.readdirSync(this.persistDir).filter((f) => f.endsWith(".json"));
+        }
+        catch {
+            return;
+        }
+        const now = Date.now();
+        for (const file of files) {
+            try {
+                const filePath = path.join(this.persistDir, file);
+                const raw = fs.readFileSync(filePath, "utf-8");
+                const entry = JSON.parse(raw);
+                // Skip expired entries
+                if (now - entry.cachedAt > this.ttlMs) {
+                    fs.unlinkSync(filePath);
+                    continue;
+                }
+                // Only load successful results
+                if (!entry.result.success) {
+                    fs.unlinkSync(filePath);
+                    continue;
+                }
+                this.cache.set(entry.key, {
+                    result: entry.result,
+                    cachedAt: entry.cachedAt,
+                    hitCount: 0,
+                });
+                this.persistedKeys.add(entry.key);
+            }
+            catch {
+                // Skip corrupt files
+            }
+        }
+        // Trim to max capacity
+        while (this.cache.size > this.maxEntries) {
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.cache.delete(oldestKey);
+                this.deleteDiskEntry(oldestKey);
+            }
+        }
+    }
+    /**
+     * Look up a cached result for the given thread parameters.
+     * Returns undefined on cache miss.
+     */
+    get(task, files, agent, model) {
+        const key = computeCacheKey(task, files, agent, model);
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.misses++;
+            return undefined;
+        }
+        // Check TTL expiry
+        if (Date.now() - entry.cachedAt > this.ttlMs) {
+            this.cache.delete(key);
+            this.deleteDiskEntry(key);
+            this.misses++;
+            return undefined;
+        }
+        // Only return successful cached results
+        if (!entry.result.success) {
+            this.misses++;
+            return undefined;
+        }
+        this.hits++;
+        entry.hitCount++;
+        this.totalSavedMs += entry.result.durationMs;
+        this.totalSavedUsd += entry.result.estimatedCostUsd;
+        return entry.result;
+    }
+    /**
+     * Store a thread result in the cache.
+     * Only caches successful results — failed threads should be retried.
+     */
+    set(task, files, agent, model, result) {
+        // Don't cache failures
+        if (!result.success)
+            return;
+        // Evict oldest entry if at capacity
+        if (this.cache.size >= this.maxEntries) {
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.cache.delete(oldestKey);
+                this.deleteDiskEntry(oldestKey);
+            }
+        }
+        const key = computeCacheKey(task, files, agent, model);
+        const now = Date.now();
+        this.cache.set(key, {
+            result,
+            cachedAt: now,
+            hitCount: 0,
+        });
+        // Persist to disk
+        this.saveDiskEntry(key, result, now);
+    }
+    /** Get cache statistics. */
+    getStats() {
+        return {
+            size: this.cache.size,
+            hits: this.hits,
+            misses: this.misses,
+            totalSavedMs: this.totalSavedMs,
+            totalSavedUsd: this.totalSavedUsd,
+            persistedEntries: this.persistedKeys.size,
+        };
+    }
+    /** Clear all cached entries (in-memory and on disk). */
+    clear() {
+        if (this.persistDir) {
+            for (const key of this.cache.keys()) {
+                this.deleteDiskEntry(key);
+            }
+        }
+        this.cache.clear();
+    }
+    // ── Disk persistence ──────────────────────────────────────────────────
+    saveDiskEntry(key, result, cachedAt) {
+        if (!this.persistDir)
+            return;
+        try {
+            const entry = { key, result, cachedAt };
+            const filePath = path.join(this.persistDir, `${key}.json`);
+            fs.writeFileSync(filePath, JSON.stringify(entry), "utf-8");
+            this.persistedKeys.add(key);
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    deleteDiskEntry(key) {
+        if (!this.persistDir)
+            return;
+        try {
+            const filePath = path.join(this.persistDir, `${key}.json`);
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+                this.persistedKeys.delete(key);
+            }
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+}
+//# sourceMappingURL=cache.js.map

package/dist/threads/manager.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Thread manager — spawns and manages coding agent threads in isolated worktrees.
+ *
+ * Features:
+ *   - AsyncSemaphore for proper concurrency gating (no polling)
+ *   - AbortSignal propagation for thread cancellation
+ *   - Per-thread retry logic with exponential backoff
+ *   - Error classification: retryable (transient) vs fatal (permanent)
+ *   - Agent/model re-routing on failure (fallback to alternative combos)
+ *   - Budget tracking and enforcement
+ *   - Per-thread error isolation
+ */
+import type { BudgetState, CompressedResult, SwarmConfig, ThreadConfig, ThreadProgressPhase, ThreadState } from "../core/types.js";
+import type { EpisodicMemory } from "../memory/episodic.js";
+import { WorktreeManager } from "../worktree/manager.js";
+import { type ThreadCacheStats } from "./cache.js";
+/**
+ * Promise-based semaphore for concurrency control.
+ * acquire() resolves when a slot is available, release() frees a slot.
+ */
+export declare class AsyncSemaphore {
+    private current;
+    private readonly max;
+    private waiters;
+    constructor(max: number);
+    acquire(): Promise<void>;
+    release(): void;
+    get activeCount(): number;
+    get waitingCount(): number;
+}
+export type ThreadProgressCallback = (threadId: string, phase: ThreadProgressPhase, detail?: string) => void;
+export declare class ThreadManager {
+    private threads;
+    private totalSpawned;
+    private semaphore;
+    private worktreeManager;
+    private config;
+    private budget;
+    private threadCache;
+    private episodicMemory?;
+    private onThreadProgress?;
+    private sessionAbort?;
+    private threadAbortControllers;
+    constructor(repoRoot: string, config: SwarmConfig, onThreadProgress?: ThreadProgressCallback, sessionAbort?: AbortSignal);
+    /** Set the episodic memory store for recording thread outcomes. */
+    setEpisodicMemory(memory: EpisodicMemory): void;
+    init(): Promise<void>;
+    /**
+     * Spawn a thread — creates a worktree, runs the agent, returns compressed result.
+     * Checks the subthread cache first; on cache hit, returns immediately (Slate-style reuse).
+     * Retries up to config.thread_retries times on failure.
+     * Error-isolated: a failure here never throws — always returns a CompressedResult.
+     */
+    spawnThread(threadConfig: ThreadConfig): Promise<CompressedResult>;
+    /**
+     * Execute a single thread attempt. Acquires semaphore, creates worktree,
+     * runs agent, captures diff, compresses result.
+     */
+    private executeThread;
+    /** Cancel a specific running thread. */
+    cancelThread(threadId: string): boolean;
+    /** Cancel all running threads. */
+    cancelAll(): void;
+    /** Get all thread states. */
+    getThreads(): ThreadState[];
+    /** Get a specific thread's state. */
+    getThread(threadId: string): ThreadState | undefined;
+    /** Get the worktree manager for merge operations. */
+    getWorktreeManager(): WorktreeManager;
+    /** Get current budget state. */
+    getBudgetState(): BudgetState;
+    /** Get subthread cache stats. */
+    getCacheStats(): ThreadCacheStats;
+    /** Get concurrency stats. */
+    getConcurrencyStats(): {
+        active: number;
+        waiting: number;
+        total: number;
+        max: number;
+    };
+    /** Cleanup all worktrees. */
+    cleanup(): Promise<void>;
+    private cleanupWorktree;
+    private failResult;
+}