@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/uninstall.test.js

@@ -1,141 +0,0 @@
-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

@@ -1,271 +0,0 @@
-/**
- * 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

@@ -1,77 +0,0 @@
-/**
- * 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

@@ -1,101 +0,0 @@
-/**
- * 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();
-    });
-});