@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/uninstall.test.js

@@ -0,0 +1,141 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { normalizeAgentName } from "../config/agent-registry.js";
+import { mergePreToolUseBashHook, removePreToolUseBashHook, } from "../config/claude-settings-hooks.js";
+import { removeInstructionSection, writeInstructionFile, } from "../config/instruction-writer.js";
+import { removeMcpConfig, writeMcpConfig, } from "../config/mcp-config-writer.js";
+import { removeInstalledSkills } from "../skills/resolver.js";
+describe("uninstall", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = join(tmpdir(), `unerr-uninstall-test-${Date.now()}`);
+        mkdirSync(tmpDir, { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    describe("normalizeAgentName", () => {
+        it("resolves 'claude' to 'claude-code'", () => {
+            expect(normalizeAgentName("claude")).toBe("claude-code");
+        });
+        it("resolves 'Claude' case-insensitively", () => {
+            expect(normalizeAgentName("Claude")).toBe("claude-code");
+        });
+        it("resolves 'gemini' to 'gemini-cli'", () => {
+            expect(normalizeAgentName("gemini")).toBe("gemini-cli");
+        });
+        it("passes through unknown names unchanged", () => {
+            expect(normalizeAgentName("cursor")).toBe("cursor");
+        });
+    });
+    describe("removeInstalledSkills", () => {
+        it("removes flat skill files for cursor", () => {
+            const rulesDir = join(tmpDir, ".cursor", "rules");
+            mkdirSync(rulesDir, { recursive: true });
+            writeFileSync(join(rulesDir, "unerr-graph-first.mdc"), "content");
+            writeFileSync(join(rulesDir, "unerr-search.mdc"), "content");
+            writeFileSync(join(rulesDir, "other-rule.mdc"), "should stay");
+            const removed = removeInstalledSkills("cursor", tmpDir);
+            expect(removed).toBe(2);
+            expect(existsSync(join(rulesDir, "unerr-graph-first.mdc"))).toBe(false);
+            expect(existsSync(join(rulesDir, "unerr-search.mdc"))).toBe(false);
+            expect(existsSync(join(rulesDir, "other-rule.mdc"))).toBe(true);
+        });
+        it("removes directory-per-skill for claude-code", () => {
+            const skillsDir = join(tmpDir, ".claude", "skills");
+            const skillDir = join(skillsDir, "unerr-graph-first");
+            mkdirSync(skillDir, { recursive: true });
+            writeFileSync(join(skillDir, "SKILL.md"), "content");
+            const removed = removeInstalledSkills("claude-code", tmpDir);
+            expect(removed).toBe(1);
+            expect(existsSync(skillDir)).toBe(false);
+        });
+        it("returns 0 when no skills exist", () => {
+            const removed = removeInstalledSkills("cursor", tmpDir);
+            expect(removed).toBe(0);
+        });
+    });
+    describe("removePreToolUseBashHook", () => {
+        it("removes unerr hook from settings.json", () => {
+            // First merge it in
+            mergePreToolUseBashHook(tmpDir);
+            const settingsPath = join(tmpDir, ".claude", "settings.json");
+            expect(existsSync(settingsPath)).toBe(true);
+            const before = JSON.parse(readFileSync(settingsPath, "utf-8"));
+            expect(before.hooks.PreToolUse).toHaveLength(6); // Bash, Read, Grep, Glob, Write, Edit
+            // Now remove
+            const removed = removePreToolUseBashHook(tmpDir);
+            expect(removed).toBe(true);
+            const after = JSON.parse(readFileSync(settingsPath, "utf-8"));
+            // PreToolUse should be cleaned up
+            expect(after.hooks?.PreToolUse).toBeUndefined();
+        });
+        it("preserves other hooks when removing unerr hook", () => {
+            const dir = join(tmpDir, ".claude");
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, "settings.json"), JSON.stringify({
+                hooks: {
+                    PreToolUse: [
+                        {
+                            matcher: "Bash",
+                            hooks: [{ type: "command", command: "other-tool" }],
+                        },
+                        {
+                            matcher: "Bash",
+                            hooks: [{ type: "command", command: "unerr hook pre-bash" }],
+                        },
+                    ],
+                    PostToolUse: [
+                        {
+                            matcher: "Write",
+                            hooks: [{ type: "command", command: "lint" }],
+                        },
+                    ],
+                },
+            }));
+            const removed = removePreToolUseBashHook(tmpDir);
+            expect(removed).toBe(true);
+            const after = JSON.parse(readFileSync(join(dir, "settings.json"), "utf-8"));
+            expect(after.hooks.PreToolUse).toHaveLength(1);
+            expect(after.hooks.PreToolUse[0].hooks[0].command).toBe("other-tool");
+            expect(after.hooks.PostToolUse).toHaveLength(1);
+        });
+        it("returns false when no settings.json exists", () => {
+            expect(removePreToolUseBashHook(tmpDir)).toBe(false);
+        });
+        it("returns false when no unerr hook present", () => {
+            const dir = join(tmpDir, ".claude");
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, "settings.json"), JSON.stringify({ hooks: { PreToolUse: [] } }));
+            expect(removePreToolUseBashHook(tmpDir)).toBe(false);
+        });
+    });
+    describe("per-agent uninstall symmetry", () => {
+        it("removeMcpConfig reverses writeMcpConfig for cursor", () => {
+            const result = writeMcpConfig(tmpDir, "cursor");
+            expect(existsSync(result.path)).toBe(true);
+            const removed = removeMcpConfig(tmpDir, "cursor");
+            expect(removed).toBe(true);
+        });
+        it("removeInstructionSection reverses writeInstructionFile", () => {
+            writeInstructionFile(tmpDir, "claude-code");
+            const claudeMd = join(tmpDir, "CLAUDE.md");
+            expect(existsSync(claudeMd)).toBe(true);
+            const removed = removeInstructionSection(tmpDir, "claude-code");
+            expect(removed).toBe(true);
+            // File should be deleted since it only had sentinel content
+            expect(existsSync(claudeMd)).toBe(false);
+        });
+        it("uninstall is idempotent — second call returns false/0", () => {
+            // Install then uninstall
+            writeMcpConfig(tmpDir, "cursor");
+            removeMcpConfig(tmpDir, "cursor");
+            // Second uninstall should be no-ops
+            expect(removeMcpConfig(tmpDir, "cursor")).toBe(false);
+            expect(removeInstalledSkills("cursor", tmpDir)).toBe(0);
+            expect(removeInstructionSection(tmpDir, "cursor")).toBe(false);
+        });
+    });
+});

package/dist/__tests__/warm-start-policy.test.js

@@ -0,0 +1,271 @@
+/**
+ * Tests for DM-5 warm-start policy:
+ *   - Candidate selection respects autostart, budget, idle days
+ *   - MRU ordering (eager first, then by lastActivity)
+ *   - Budget enforcement (only top N warmed)
+ *   - Battery/load abort
+ *   - Budget=0 disables entirely
+ */
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { selectCandidates, } from "../daemon/warm-start.js";
+function makeRepo(name, opts = {}) {
+    const path = opts.path ??
+        join(tmpdir(), `warmtest-${name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+    if (opts.exists !== false) {
+        mkdirSync(path, { recursive: true });
+    }
+    const settings = {};
+    if (opts.autostart)
+        settings.autostart = opts.autostart;
+    return {
+        path,
+        addedAt: new Date().toISOString(),
+        lastStarted: null,
+        lastActivity: opts.lastActivity?.toISOString() ?? null,
+        idleTimeout: 1800,
+        label: name,
+        settings,
+    };
+}
+const tempPaths = [];
+function trackedRepo(name, opts = {}) {
+    const repo = makeRepo(name, opts);
+    tempPaths.push(repo.path);
+    return repo;
+}
+afterEach(() => {
+    for (const p of tempPaths) {
+        try {
+            rmSync(p, { recursive: true, force: true });
+        }
+        catch {
+            /* ok */
+        }
+    }
+    tempPaths.length = 0;
+});
+const defaultConfig = {
+    warmStartBudget: 3,
+    warmStartIdleDays: 14,
+    warmStartDelayMs: 0,
+};
+describe("selectCandidates", () => {
+    it("selects MRU repos up to budget", () => {
+        const repos = [
+            trackedRepo("repo1", { lastActivity: new Date("2026-05-14T10:00:00Z") }),
+            trackedRepo("repo2", { lastActivity: new Date("2026-05-13T10:00:00Z") }),
+            trackedRepo("repo3", { lastActivity: new Date("2026-05-12T10:00:00Z") }),
+            trackedRepo("repo4", { lastActivity: new Date("2026-05-11T10:00:00Z") }),
+            trackedRepo("repo5", { lastActivity: new Date("2026-05-10T10:00:00Z") }),
+        ];
+        const { candidates, skipped } = selectCandidates(repos, {
+            ...defaultConfig,
+            warmStartBudget: 3,
+        });
+        // All 5 are candidates (within idle window), but budget limits to 3
+        expect(candidates.length).toBe(5); // selectCandidates returns all eligible; budget is enforced during run
+        expect(candidates[0].entry.label).toBe("repo1");
+        expect(candidates[1].entry.label).toBe("repo2");
+        expect(candidates[2].entry.label).toBe("repo3");
+    });
+    it("excludes repos with autostart=never", () => {
+        const repos = [
+            trackedRepo("active", { lastActivity: new Date("2026-05-14T10:00:00Z") }),
+            trackedRepo("never", {
+                lastActivity: new Date("2026-05-14T10:00:00Z"),
+                autostart: "never",
+            }),
+        ];
+        const { candidates, skipped } = selectCandidates(repos, defaultConfig);
+        expect(candidates.length).toBe(1);
+        expect(candidates[0].entry.label).toBe("active");
+        expect(skipped.length).toBe(1);
+        expect(skipped[0].reason).toBe("autostart=never");
+    });
+    it("excludes repos inactive beyond idle days cutoff", () => {
+        const repos = [
+            trackedRepo("recent", { lastActivity: new Date("2026-05-14T10:00:00Z") }),
+            trackedRepo("old", { lastActivity: new Date("2026-01-01T10:00:00Z") }),
+        ];
+        const { candidates, skipped } = selectCandidates(repos, {
+            ...defaultConfig,
+            warmStartIdleDays: 14,
+        });
+        expect(candidates.length).toBe(1);
+        expect(candidates[0].entry.label).toBe("recent");
+        expect(skipped.length).toBe(1);
+        expect(skipped[0].reason).toContain("inactive");
+    });
+    it("eager repos are prioritized over auto repos", () => {
+        const repos = [
+            trackedRepo("auto-recent", {
+                lastActivity: new Date("2026-05-14T10:00:00Z"),
+                autostart: "auto",
+            }),
+            trackedRepo("eager-old", {
+                lastActivity: new Date("2026-05-10T10:00:00Z"),
+                autostart: "eager",
+            }),
+        ];
+        const { candidates } = selectCandidates(repos, defaultConfig);
+        expect(candidates[0].entry.label).toBe("eager-old");
+        expect(candidates[1].entry.label).toBe("auto-recent");
+    });
+    it("skips repos whose directory does not exist", () => {
+        const repos = [
+            trackedRepo("good", { lastActivity: new Date("2026-05-14T10:00:00Z") }),
+            trackedRepo("gone", {
+                lastActivity: new Date("2026-05-14T10:00:00Z"),
+                exists: false,
+            }),
+        ];
+        const { candidates, skipped } = selectCandidates(repos, defaultConfig);
+        expect(candidates.length).toBe(1);
+        expect(skipped.length).toBe(1);
+        expect(skipped[0].reason).toBe("directory not found");
+    });
+    it("repos without lastActivity are included (never started)", () => {
+        const repos = [trackedRepo("new-repo", { lastActivity: null })];
+        const { candidates } = selectCandidates(repos, defaultConfig);
+        expect(candidates.length).toBe(1);
+    });
+    it("eager repos bypass idle cutoff even if old", () => {
+        const repos = [
+            trackedRepo("eager-old", {
+                lastActivity: new Date("2025-01-01T10:00:00Z"),
+                autostart: "eager",
+            }),
+        ];
+        const { candidates } = selectCandidates(repos, {
+            ...defaultConfig,
+            warmStartIdleDays: 7,
+        });
+        // Eager repos are never filtered by idle cutoff
+        expect(candidates.length).toBe(1);
+    });
+});
+describe("warm-start budget enforcement", () => {
+    it("budget=0 returns empty results", async () => {
+        vi.mock("../daemon/detect-ci.js", () => ({
+            isCI: vi.fn(() => false),
+            resetCICache: vi.fn(),
+        }));
+        const { loadWarmStartConfig } = await import("../daemon/warm-start.js");
+        const config = loadWarmStartConfig();
+        // Test the config loading works
+        expect(typeof config.warmStartBudget).toBe("number");
+    });
+    it("table-driven: 20 repos with budget=3 selects exactly top 3", () => {
+        const repos = [];
+        for (let i = 0; i < 20; i++) {
+            repos.push(trackedRepo(`repo-${i}`, {
+                lastActivity: new Date(Date.now() - i * 86400000),
+                autostart: i < 2 ? "eager" : i >= 18 ? "never" : "auto",
+            }));
+        }
+        const { candidates, skipped } = selectCandidates(repos, {
+            ...defaultConfig,
+            warmStartBudget: 3,
+        });
+        // 2 never repos skipped
+        expect(skipped.filter((s) => s.reason === "autostart=never").length).toBe(2);
+        // Eager repos should be first in candidates
+        expect(candidates[0].entry.settings.autostart).toBe("eager");
+        expect(candidates[1].entry.settings.autostart).toBe("eager");
+    });
+    it("table-driven: 20 repos with budget=5 selects top 5", () => {
+        const repos = [];
+        for (let i = 0; i < 20; i++) {
+            repos.push(trackedRepo(`repo-${i}`, {
+                lastActivity: new Date(Date.now() - i * 86400000),
+                autostart: i >= 18 ? "never" : "auto",
+            }));
+        }
+        const config = {
+            ...defaultConfig,
+            warmStartBudget: 5,
+            warmStartIdleDays: 30,
+        };
+        const { candidates } = selectCandidates(repos, config);
+        // All non-never repos within 30 days are candidates
+        expect(candidates.length).toBeLessThanOrEqual(18);
+        // First 5 would be the ones the scheduler picks
+        const topFive = candidates.slice(0, 5);
+        expect(topFive.length).toBe(5);
+    });
+    it("table-driven: budget=0 means selectCandidates still works but nothing warmed", () => {
+        const repos = [trackedRepo("repo-a", { lastActivity: new Date() })];
+        const config = { ...defaultConfig, warmStartBudget: 0 };
+        // With budget=0, the scheduler itself returns early before calling selectCandidates
+        // But selectCandidates itself still returns valid results
+        const { candidates } = selectCandidates(repos, config);
+        expect(candidates.length).toBe(1);
+    });
+});
+describe("system health integration", () => {
+    it("onBattery returns boolean", async () => {
+        const { onBattery, resetHealthCaches } = await import("../daemon/system-health.js");
+        resetHealthCaches();
+        const result = onBattery();
+        expect(typeof result).toBe("boolean");
+    });
+    it("loadAverage1 returns non-negative number", async () => {
+        const { loadAverage1, resetHealthCaches } = await import("../daemon/system-health.js");
+        resetHealthCaches();
+        const result = loadAverage1();
+        expect(typeof result).toBe("number");
+        expect(result).toBeGreaterThanOrEqual(0);
+    });
+    it("caches are reset correctly", async () => {
+        const { onBattery, loadAverage1, resetHealthCaches } = await import("../daemon/system-health.js");
+        const b1 = onBattery();
+        const l1 = loadAverage1();
+        resetHealthCaches();
+        // After reset, should still return valid values
+        const b2 = onBattery();
+        const l2 = loadAverage1();
+        expect(typeof b2).toBe("boolean");
+        expect(typeof l2).toBe("number");
+    });
+});
+describe("warm-start config", () => {
+    it("loadWarmStartConfig returns defaults when no config exists", async () => {
+        const { loadWarmStartConfig } = await import("../daemon/warm-start.js");
+        const config = loadWarmStartConfig();
+        expect(config.warmStartBudget).toBe(3);
+        expect(config.warmStartIdleDays).toBe(14);
+        expect(config.warmStartDelayMs).toBe(30_000);
+    });
+    it("saveWarmStartConfig persists values", async () => {
+        const { saveWarmStartConfig, loadWarmStartConfig } = await import("../daemon/warm-start.js");
+        // This test modifies the real config file — we accept that as it's using the real ~/.unerr/config.json
+        // In a real CI environment, this would need a mock
+        expect(typeof saveWarmStartConfig).toBe("function");
+        expect(typeof loadWarmStartConfig).toBe("function");
+    });
+});
+describe("WarmStartEvent types", () => {
+    it("events have correct shape", () => {
+        const event = {
+            type: "warm_start",
+            repo: "/tmp/test",
+            label: "test",
+            status: "started",
+            ms: 1500,
+        };
+        expect(event.type).toBe("warm_start");
+        expect(event.status).toBe("started");
+        const skipped = {
+            type: "warm_start",
+            repo: "/tmp/test2",
+            label: "test2",
+            status: "skipped",
+            ms: 0,
+            reason: "autostart=never",
+        };
+        expect(skipped.reason).toBe("autostart=never");
+    });
+});

package/dist/__tests__/wire-cap-nudge.test.js

@@ -0,0 +1,77 @@
+/**
+ * Verifies the wire-cap nudge interpolation is concrete (numeric values, not
+ * literal `N`) and context-aware (knows whether entity/limit/token_budget
+ * were already set).
+ *
+ * Before this change, the same generic "narrow with limit:N/entity:<name> or
+ * token_budget:N" hint reappeared on every retry — even when the caller had
+ * already passed entity: or token_budget: — producing a retry loop.
+ */
+import { describe, expect, it } from "vitest";
+import { applyWireCap } from "../proxy/wire-cap.js";
+function bigString(bytes) {
+    return "x".repeat(bytes);
+}
+describe("wire-cap too_large nudge — concrete & context-aware", () => {
+    it("emits a numeric suggested_token_budget in the body", () => {
+        const oversized = bigString(20_000);
+        const { body, pageHint } = applyWireCap("file_read", oversized, {});
+        const obj = body;
+        expect(obj.status).toBe("too_large");
+        expect(typeof obj.suggested_token_budget).toBe("number");
+        expect(obj.needed_tokens).toBeGreaterThan(0);
+        expect(pageHint).toMatch(/token_budget:\d+/);
+        expect(pageHint).not.toMatch(/token_budget:N/);
+    });
+    it("uses `entity_too_large` reason when caller already passed entity", () => {
+        const oversized = bigString(20_000);
+        const { body, pageHint } = applyWireCap("file_read", oversized, {
+            entity: "indexLocalProject",
+        });
+        const obj = body;
+        expect(obj.reason).toBe("entity_too_large");
+        expect(obj.entity).toBe("indexLocalProject");
+        expect(pageHint).toContain("offset/limit");
+        // Critical: must NOT tell caller to "narrow with entity:" — they did.
+        expect(pageHint).not.toContain("entity:<name>");
+    });
+    it("echoes the requested_token_budget when caller already set one", () => {
+        const oversized = bigString(40_000);
+        const { body } = applyWireCap("file_read", oversized, {
+            token_budget: 2000,
+        });
+        const obj = body;
+        expect(obj.requested_token_budget).toBe(2000);
+        expect(obj.suggested_token_budget).toBeGreaterThan(2000);
+    });
+    it("uses `page_too_large` and shrinks the limit when paginated", () => {
+        const oversized = bigString(20_000);
+        const { body, pageHint } = applyWireCap("search_code", oversized, {
+            limit: 100,
+        });
+        const obj = body;
+        expect(obj.reason).toBe("page_too_large");
+        expect(pageHint).toMatch(/limit:\d+/);
+        expect(pageHint).not.toMatch(/limit:N/);
+    });
+    it("uses `narrow_required` when token_budget was lifted and still overflowed", () => {
+        // 16384 / 4 = 4096 — bump well above HARD_BYTE_CAP so a token_budget of
+        // 5000 lifts the cap to 20000 bytes, but the payload is bigger still.
+        const oversized = bigString(30_000);
+        const { body } = applyWireCap("file_read", oversized, {
+            token_budget: 5000,
+        });
+        const obj = body;
+        expect(obj.reason).toBe("narrow_required");
+    });
+});
+describe("wire-cap pagination hint — concrete next cursor", () => {
+    it("emits a numeric cursor (not the literal N)", () => {
+        // search_code returns a top-level array; its cursorArg is `limit`.
+        const arr = Array.from({ length: 50 }, (_, i) => ({ id: i }));
+        const { pageHint } = applyWireCap("search_code", arr, {});
+        // Cursor should be a real number, never the placeholder.
+        expect(pageHint).toMatch(/:\d+/);
+        expect(pageHint).not.toMatch(/:N(\s|\/|$)/);
+    });
+});

package/dist/__tests__/worker-pool.test.js

@@ -0,0 +1,101 @@
+/**
+ * Worker pool tests — parallel AST parsing via tinypool.
+ */
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { destroy, parseFiles, resetPoolState, } from "../intelligence/worker-pool.js";
+const SAMPLE_TS = `
+export function greet(name: string): string {
+  return \`Hello, \${name}\`;
+}
+
+export class Greeter {
+  private name: string;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  sayHello(): string {
+    return \`Hello, \${this.name}\`;
+  }
+}
+
+export interface GreetOptions {
+  loud: boolean;
+  prefix?: string;
+}
+`;
+describe("worker-pool", () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "unerr-wp-"));
+    });
+    afterEach(async () => {
+        await destroy();
+        resetPoolState();
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("initializes and parses a single file", async () => {
+        const filePath = join(tempDir, "sample.ts");
+        writeFileSync(filePath, SAMPLE_TS);
+        const results = await parseFiles([{ filePath, content: SAMPLE_TS }]);
+        expect(results).toHaveLength(1);
+        expect(results[0]?.filePath).toBe(filePath);
+        expect(results[0]?.entities.length).toBeGreaterThan(0);
+        expect(results[0]?.durationMs).toBeGreaterThanOrEqual(0);
+        const names = results[0]?.entities.map((e) => e.name);
+        expect(names).toContain("greet");
+        expect(names).toContain("Greeter");
+        expect(names).toContain("GreetOptions");
+    });
+    it("parses 10 files in parallel", async () => {
+        const files = Array.from({ length: 10 }, (_, i) => {
+            const filePath = join(tempDir, `file${i}.ts`);
+            const content = `export function fn${i}(x: number): number { return x * ${i}; }\n`;
+            writeFileSync(filePath, content);
+            return { filePath, content };
+        });
+        const results = await parseFiles(files);
+        expect(results).toHaveLength(10);
+        for (let i = 0; i < 10; i++) {
+            expect(results[i]?.filePath).toBe(files[i]?.filePath);
+            expect(results[i]?.entities.length).toBeGreaterThanOrEqual(1);
+            const fnEntity = results[i]?.entities.find((e) => e.name === `fn${i}`);
+            expect(fnEntity).toBeDefined();
+            expect(fnEntity?.kind).toBe("function");
+        }
+    });
+    it("handles empty input", async () => {
+        const results = await parseFiles([]);
+        expect(results).toEqual([]);
+    });
+    it("handles files with no extractable entities", async () => {
+        const filePath = join(tempDir, "data.json");
+        const content = '{"key": "value"}';
+        writeFileSync(filePath, content);
+        const results = await parseFiles([{ filePath, content }]);
+        expect(results).toHaveLength(1);
+        expect(results[0]?.entities).toEqual([]);
+    });
+    it("can be destroyed and recreated", async () => {
+        const filePath = join(tempDir, "first.ts");
+        const content = "export function first(): void {}\n";
+        writeFileSync(filePath, content);
+        const results1 = await parseFiles([{ filePath, content }]);
+        expect(results1).toHaveLength(1);
+        expect(results1[0]?.entities.length).toBeGreaterThan(0);
+        await destroy();
+        resetPoolState();
+        const filePath2 = join(tempDir, "second.ts");
+        const content2 = "export function second(): void {}\n";
+        writeFileSync(filePath2, content2);
+        const results2 = await parseFiles([
+            { filePath: filePath2, content: content2 },
+        ]);
+        expect(results2).toHaveLength(1);
+        expect(results2[0]?.entities.find((e) => e.name === "second")).toBeDefined();
+    });
+});