@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/health-map-data.test.js

@@ -1,173 +0,0 @@
-// @ts-nocheck — test file
-/**
- * HealthMapData tests — health score computation and tree building.
- */
-import { describe, expect, it, vi } from "vitest";
-import { HealthMapData } from "../intelligence/health-map-data.js";
-function createMockGraph(entities = [], conventions = []) {
-    return {
-        getLocalProjectStats: vi.fn(() => Promise.resolve({ entity_count: entities.length, edge_count: 0 })),
-        getCriticalNodes: vi.fn(() => Promise.resolve(entities)),
-        getEntitiesByFile: vi.fn((filePath) => Promise.resolve(entities.filter((e) => e.file_path === filePath))),
-        getConventions: vi.fn(() => Promise.resolve(conventions)),
-    };
-}
-function createMockFactStore(projectFacts = [], fileFacts = []) {
-    return {
-        recallByScope: vi.fn(() => Promise.resolve(projectFacts)),
-        recallForFile: vi.fn(() => Promise.resolve(fileFacts)),
-    };
-}
-const ENTITY_A = {
-    key: "src/a.ts::funcA",
-    kind: "function",
-    name: "funcA",
-    file_path: "src/a.ts",
-    start_line: 1,
-    end_line: 10,
-    signature: "function funcA()",
-    body: "",
-    fan_in: 5,
-    fan_out: 3,
-    risk_level: "medium",
-    community: 0,
-};
-const ENTITY_B = {
-    key: "src/b.ts::funcB",
-    kind: "function",
-    name: "funcB",
-    file_path: "src/b.ts",
-    start_line: 1,
-    end_line: 20,
-    signature: "function funcB()",
-    body: "",
-    fan_in: 2,
-    fan_out: 1,
-    risk_level: "low",
-    community: 0,
-};
-const ENTITY_C = {
-    key: "src/a.ts::funcC",
-    kind: "function",
-    name: "funcC",
-    file_path: "src/a.ts",
-    start_line: 12,
-    end_line: 25,
-    signature: "function funcC()",
-    body: "",
-    fan_in: 15,
-    fan_out: 10,
-    risk_level: "high",
-    community: 1,
-};
-describe("HealthMapData", () => {
-    describe("buildTree", () => {
-        it("returns a root node with children grouped by directory", async () => {
-            const graph = createMockGraph([ENTITY_A, ENTITY_B, ENTITY_C]);
-            const healthMap = new HealthMapData(graph, null);
-            const tree = await healthMap.buildTree();
-            expect(tree.path).toBe(".");
-            expect(tree.children).toBeDefined();
-            expect(tree.children.length).toBeGreaterThan(0);
-            expect(tree.entity_count).toBe(3);
-        });
-        it("computes health scores between 0 and 1", async () => {
-            const graph = createMockGraph([ENTITY_A, ENTITY_B]);
-            const healthMap = new HealthMapData(graph, null);
-            const tree = await healthMap.buildTree();
-            expect(tree.health_score).toBeGreaterThanOrEqual(0);
-            expect(tree.health_score).toBeLessThanOrEqual(1);
-        });
-        it("assigns risk levels based on health score", async () => {
-            const graph = createMockGraph([ENTITY_A]);
-            const healthMap = new HealthMapData(graph, null);
-            const tree = await healthMap.buildTree();
-            expect(["low", "medium", "high", "critical"]).toContain(tree.risk_level);
-        });
-        it("includes coupling counts from fact store", async () => {
-            const graph = createMockGraph([ENTITY_A, ENTITY_B]);
-            const factStore = createMockFactStore([
-                {
-                    fact_id: "1",
-                    fact_type: "semantic",
-                    subject: "coupling:src/a.ts↔src/b.ts",
-                    content: "Often changed together",
-                    effective_confidence: 0.7,
-                    source: "session_analysis",
-                },
-            ]);
-            const healthMap = new HealthMapData(graph, factStore);
-            const tree = await healthMap.buildTree();
-            // Both files should have coupling_count >= 1
-            const srcDir = tree.children?.find((c) => c.name === "src");
-            expect(srcDir).toBeDefined();
-            expect(srcDir.metrics.coupling_count).toBeGreaterThanOrEqual(1);
-        });
-        it("filters by rootPath when provided", async () => {
-            const graph = createMockGraph([
-                ENTITY_A,
-                { ...ENTITY_B, file_path: "lib/b.ts", key: "lib/b.ts::funcB" },
-            ]);
-            const healthMap = new HealthMapData(graph, null);
-            const tree = await healthMap.buildTree("src");
-            expect(tree.entity_count).toBe(1);
-        });
-        it("handles empty graph gracefully", async () => {
-            const graph = createMockGraph([]);
-            const healthMap = new HealthMapData(graph, null);
-            const tree = await healthMap.buildTree();
-            expect(tree.entity_count).toBe(0);
-            expect(tree.children).toEqual([]);
-        });
-        it("high risk entities lower the health score", async () => {
-            const graph1 = createMockGraph([ENTITY_B]); // low risk
-            const graph2 = createMockGraph([ENTITY_C]); // high risk
-            const map1 = new HealthMapData(graph1, null);
-            const map2 = new HealthMapData(graph2, null);
-            const tree1 = await map1.buildTree();
-            const tree2 = await map2.buildTree();
-            expect(tree1.health_score).toBeGreaterThan(tree2.health_score);
-        });
-    });
-    describe("getFileHealth", () => {
-        it("returns health for a specific file", async () => {
-            const graph = createMockGraph([ENTITY_A, ENTITY_C]);
-            const healthMap = new HealthMapData(graph, null);
-            const result = await healthMap.getFileHealth("src/a.ts");
-            expect(result).not.toBeNull();
-            expect(result.path).toBe("src/a.ts");
-            expect(result.entity_count).toBe(2);
-            expect(result.health_score).toBeGreaterThanOrEqual(0);
-            expect(result.health_score).toBeLessThanOrEqual(1);
-        });
-        it("returns null for unknown file", async () => {
-            const graph = createMockGraph([ENTITY_A]);
-            const healthMap = new HealthMapData(graph, null);
-            const result = await healthMap.getFileHealth("src/unknown.ts");
-            expect(result).toBeNull();
-        });
-        it("includes change frequency from episodic facts", async () => {
-            const graph = createMockGraph([ENTITY_A]);
-            const factStore = createMockFactStore([], [
-                {
-                    fact_id: "1",
-                    fact_type: "episodic",
-                    subject: "src/a.ts",
-                    content: "Modified",
-                    effective_confidence: 0.8,
-                },
-                {
-                    fact_id: "2",
-                    fact_type: "episodic",
-                    subject: "src/a.ts",
-                    content: "Modified again",
-                    effective_confidence: 0.7,
-                },
-            ]);
-            const healthMap = new HealthMapData(graph, factStore);
-            const result = await healthMap.getFileHealth("src/a.ts");
-            expect(result).not.toBeNull();
-            expect(result.metrics.change_frequency).toBe(2);
-        });
-    });
-});

package/dist/__tests__/helpers/mcp-harness.js

@@ -1,45 +0,0 @@
-/**
- * MCP Test Harness — in-process MCP client/server for integration testing.
- *
- * Uses the MCP SDK's InMemoryTransport to create a linked pair of transports
- * that communicate within the same process. No stdio, no ports, no forks.
- *
- * Usage:
- *   const harness = await createMcpHarness();
- *   const tools = await harness.listTools();
- *   const result = await harness.callTool("get_function", { key: "src/foo.ts::myFn" });
- *   await harness.close();
- */
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-/**
- * Create an in-process MCP test harness with linked client/server.
- *
- * The `setupServer` callback is where you register tool handlers
- * (ListToolsRequestSchema, CallToolRequestSchema) on the server.
- * This mirrors the real proxy's MCP setup from proxy.ts.
- */
-export async function createMcpHarness(options = {}) {
-    const { serverName = "unerr-test", serverVersion = "0.0.1", setupServer, } = options;
-    const server = new Server({ name: serverName, version: serverVersion }, { capabilities: { tools: {} } });
-    if (setupServer) {
-        await setupServer(server);
-    }
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-    const client = new Client({ name: "mcp-test-client", version: "0.0.1" }, { capabilities: {} });
-    await server.connect(serverTransport);
-    await client.connect(clientTransport);
-    const listTools = async () => {
-        const response = await client.listTools();
-        return response.tools;
-    };
-    const callTool = async (name, args = {}) => {
-        return await client.callTool({ name, arguments: args });
-    };
-    const close = async () => {
-        await client.close();
-        await server.close();
-    };
-    return { client, server, listTools, callTool, close };
-}

package/dist/__tests__/helpers/mcp-harness.test.js

@@ -1,68 +0,0 @@
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { describe, expect, it } from "vitest";
-import { createMcpHarness } from "./mcp-harness.js";
-describe("MCP Test Harness", () => {
-    it("creates a linked client/server pair", async () => {
-        const harness = await createMcpHarness();
-        expect(harness.client).toBeDefined();
-        expect(harness.server).toBeDefined();
-        await harness.close();
-    });
-    it("lists tools from a configured server", async () => {
-        const harness = await createMcpHarness({
-            setupServer: (server) => {
-                server.setRequestHandler(ListToolsRequestSchema, async () => ({
-                    tools: [
-                        {
-                            name: "test_tool",
-                            description: "A test tool",
-                            inputSchema: {
-                                type: "object",
-                                properties: {
-                                    input: { type: "string" },
-                                },
-                                required: ["input"],
-                            },
-                        },
-                    ],
-                }));
-            },
-        });
-        const tools = await harness.listTools();
-        expect(tools).toHaveLength(1);
-        expect(tools[0]?.name).toBe("test_tool");
-        await harness.close();
-    });
-    it("calls a tool and receives a response", async () => {
-        const harness = await createMcpHarness({
-            setupServer: (server) => {
-                server.setRequestHandler(ListToolsRequestSchema, async () => ({
-                    tools: [
-                        {
-                            name: "echo",
-                            description: "Echoes input",
-                            inputSchema: {
-                                type: "object",
-                                properties: {
-                                    message: { type: "string" },
-                                },
-                                required: ["message"],
-                            },
-                        },
-                    ],
-                }));
-                server.setRequestHandler(CallToolRequestSchema, async (request) => {
-                    const args = request.params.arguments;
-                    return {
-                        content: [{ type: "text", text: `Echo: ${args.message}` }],
-                    };
-                });
-            },
-        });
-        const result = await harness.callTool("echo", { message: "hello" });
-        const content = result.content;
-        expect(content).toHaveLength(1);
-        expect(content[0]?.text).toBe("Echo: hello");
-        await harness.close();
-    });
-});

package/dist/__tests__/hook-dedup.test.js

@@ -1,112 +0,0 @@
-/**
- * hook-dedup — file-based TTL dedup for PostToolUse hooks.
- *
- * The module persists to `.unerr/state/hook-recent.json` relative to CWD, so
- * tests chdir into a fresh temp dir per case and restore CWD on teardown.
- */
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { resetHookDedup, shouldEmitOnce } from "../hooks/hook-dedup.js";
-const STATE_FILE = path.join(".unerr", "state", "hook-recent.json");
-describe("hook-dedup", () => {
-    let tmpDir;
-    let prevCwd;
-    beforeEach(() => {
-        prevCwd = process.cwd();
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "unerr-hook-dedup-"));
-        process.chdir(tmpDir);
-    });
-    afterEach(() => {
-        process.chdir(prevCwd);
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    describe("shouldEmitOnce", () => {
-        it("first call returns true and persists the key", () => {
-            expect(shouldEmitOnce("Read:/a/b.ts")).toBe(true);
-            expect(fs.existsSync(STATE_FILE)).toBe(true);
-            const map = JSON.parse(fs.readFileSync(STATE_FILE, "utf8"));
-            expect(typeof map["Read:/a/b.ts"]).toBe("number");
-        });
-        it("second call within TTL returns false", () => {
-            expect(shouldEmitOnce("Read:/a/b.ts", 30_000)).toBe(true);
-            expect(shouldEmitOnce("Read:/a/b.ts", 30_000)).toBe(false);
-            expect(shouldEmitOnce("Read:/a/b.ts", 30_000)).toBe(false);
-        });
-        it("call after TTL window returns true again", () => {
-            // Tiny TTL — wait it out instead of mocking the clock.
-            expect(shouldEmitOnce("Read:/a/b.ts", 10)).toBe(true);
-            expect(shouldEmitOnce("Read:/a/b.ts", 10)).toBe(false);
-            const waitUntil = Date.now() + 25;
-            // Busy wait — short enough not to slow the suite.
-            while (Date.now() < waitUntil) {
-                /* spin */
-            }
-            expect(shouldEmitOnce("Read:/a/b.ts", 10)).toBe(true);
-        });
-        it("different keys are tracked independently", () => {
-            expect(shouldEmitOnce("Read:/a/b.ts")).toBe(true);
-            expect(shouldEmitOnce("Read:/a/c.ts")).toBe(true);
-            expect(shouldEmitOnce("Edit:/a/b.ts")).toBe(true);
-            // Each repeated within TTL is suppressed.
-            expect(shouldEmitOnce("Read:/a/b.ts")).toBe(false);
-            expect(shouldEmitOnce("Read:/a/c.ts")).toBe(false);
-            expect(shouldEmitOnce("Edit:/a/b.ts")).toBe(false);
-        });
-        it("default TTL is 30s — repeated calls suppress", () => {
-            expect(shouldEmitOnce("k1")).toBe(true);
-            // No explicit ttlMs — should use the 30s default.
-            expect(shouldEmitOnce("k1")).toBe(false);
-        });
-        it("persists timestamps across invocations (simulated via state file)", () => {
-            shouldEmitOnce("k:x", 30_000);
-            const before = JSON.parse(fs.readFileSync(STATE_FILE, "utf8"));
-            expect(before["k:x"]).toBeGreaterThan(0);
-            // A second call within TTL should NOT overwrite the timestamp (it's
-            // suppressed before the write).
-            shouldEmitOnce("k:x", 30_000);
-            const after = JSON.parse(fs.readFileSync(STATE_FILE, "utf8"));
-            expect(after["k:x"]).toBe(before["k:x"]);
-        });
-        it("degrades safely when state dir is missing", () => {
-            // No .unerr dir exists yet — first call must still return true and
-            // create the file.
-            expect(fs.existsSync(".unerr")).toBe(false);
-            expect(shouldEmitOnce("first")).toBe(true);
-            expect(fs.existsSync(STATE_FILE)).toBe(true);
-        });
-        it("degrades safely on corrupt state file (treats as empty)", () => {
-            fs.mkdirSync(path.dirname(STATE_FILE), { recursive: true });
-            fs.writeFileSync(STATE_FILE, "{ not valid json");
-            // Corrupt file should not crash; first call returns true.
-            expect(shouldEmitOnce("k")).toBe(true);
-        });
-    });
-    describe("resetHookDedup", () => {
-        it("clears the on-disk dedup file so next call emits again", () => {
-            expect(shouldEmitOnce("k", 30_000)).toBe(true);
-            expect(shouldEmitOnce("k", 30_000)).toBe(false);
-            resetHookDedup();
-            expect(shouldEmitOnce("k", 30_000)).toBe(true);
-        });
-        it("is a no-op when the state file does not exist", () => {
-            expect(() => resetHookDedup()).not.toThrow();
-        });
-    });
-    describe("prune behavior", () => {
-        it("prunes entries older than ttlMs * PRUNE_FACTOR on write", () => {
-            // Seed the state file with an old entry that should be pruned by the
-            // next write. PRUNE_FACTOR is 10, so with ttl=10ms the cutoff is 100ms
-            // before now.
-            fs.mkdirSync(path.dirname(STATE_FILE), { recursive: true });
-            const stale = Date.now() - 5_000; // 5s old — well past 100ms cutoff
-            fs.writeFileSync(STATE_FILE, JSON.stringify({ "stale:key": stale, "fresh:key": Date.now() }));
-            // Use a small TTL so PRUNE_FACTOR * ttl = 100ms cutoff.
-            shouldEmitOnce("new:key", 10);
-            const map = JSON.parse(fs.readFileSync(STATE_FILE, "utf8"));
-            expect(map["stale:key"]).toBeUndefined();
-            expect(map["new:key"]).toBeDefined();
-        });
-    });
-});

package/dist/__tests__/hook-runner.test.js

@@ -1,253 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { claudeCodeAdapter } from "../hooks/adapters/claude-code.js";
-import { clineAdapter } from "../hooks/adapters/cline.js";
-import { cursorAdapter } from "../hooks/adapters/cursor.js";
-import { detectAdapter, enrich, nudge, passthrough, rewrite, runPostToolUseHook, runPreToolUseHook, runPromptSubmitHook, } from "../hooks/hook-runner.js";
-// ── Adapter Detection ────────────────────────────────────────────────
-describe("detectAdapter", () => {
-    it("detects Claude Code from hook_event_name", () => {
-        const payload = {
-            hook_event_name: "PreToolUse",
-            tool_input: { command: "ls" },
-        };
-        expect(detectAdapter(payload).name).toBe("claude-code");
-    });
-    it("detects Cursor from tool_name + cwd", () => {
-        const payload = {
-            tool_name: "Read",
-            tool_input: { file_path: "foo.ts" },
-            cwd: "/project",
-        };
-        expect(detectAdapter(payload).name).toBe("cursor");
-    });
-    it("detects Cline from tool + params", () => {
-        const payload = {
-            tool: "read_file",
-            params: { path: "foo.ts" },
-            event: "pre_tool",
-        };
-        expect(detectAdapter(payload).name).toBe("cline");
-    });
-    it("defaults to Claude Code for unknown payloads", () => {
-        expect(detectAdapter({}).name).toBe("claude-code");
-    });
-});
-// ── Claude Code Adapter ──────────────────────────────────────────────
-describe("claudeCodeAdapter", () => {
-    it("normalizes tool input from tool_input", () => {
-        const payload = {
-            hook_event_name: "PreToolUse",
-            tool_input: { command: "ls" },
-        };
-        const n = claudeCodeAdapter.normalize(payload);
-        expect(n.toolInput).toEqual({ command: "ls" });
-        expect(n.event).toBe("PreToolUse");
-    });
-    it("formats passthrough as {}", () => {
-        expect(claudeCodeAdapter.formatPreToolUse(passthrough())).toBe("{}");
-        expect(claudeCodeAdapter.formatPostToolUse(passthrough())).toBe("{}");
-    });
-    it("formats nudge with systemMessage", () => {
-        const result = JSON.parse(claudeCodeAdapter.formatPreToolUse(nudge("Use search_code")));
-        expect(result.hookSpecificOutput.permissionDecision).toBe("allow");
-        expect(result.hookSpecificOutput.systemMessage).toBe("Use search_code");
-    });
-    it("formats rewrite with updatedInput", () => {
-        const result = JSON.parse(claudeCodeAdapter.formatPreToolUse(rewrite({ command: "unerr exec -- ls" })));
-        expect(result.hookSpecificOutput.updatedInput).toEqual({
-            command: "unerr exec -- ls",
-        });
-        expect(result.hookSpecificOutput.permissionDecision).toBe("allow");
-    });
-    it("formats PostToolUse enrich with additionalContext", () => {
-        const result = JSON.parse(claudeCodeAdapter.formatPostToolUse(enrich("Try get_entity")));
-        expect(result.hookSpecificOutput.hookEventName).toBe("PostToolUse");
-        expect(result.hookSpecificOutput.additionalContext).toBe("Try get_entity");
-    });
-    it("formats UserPromptSubmit with additionalContext", () => {
-        const result = JSON.parse(claudeCodeAdapter.formatPromptSubmit(enrich("Use unerr tools")));
-        expect(result.hookSpecificOutput.hookEventName).toBe("UserPromptSubmit");
-        expect(result.hookSpecificOutput.additionalContext).toBe("Use unerr tools");
-    });
-});
-// ── Cursor Adapter ───────────────────────────────────────────────────
-describe("cursorAdapter", () => {
-    it("detects Cursor payload", () => {
-        expect(cursorAdapter.detect({
-            tool_name: "Read",
-            tool_input: {},
-            cwd: "/project",
-        })).toBe(true);
-        // Should NOT detect Claude Code
-        expect(cursorAdapter.detect({
-            hook_event_name: "PreToolUse",
-            tool_name: "Read",
-            cwd: "/project",
-        })).toBe(false);
-    });
-    it("normalizes tool input from tool_input field", () => {
-        const payload = {
-            tool_name: "Read",
-            tool_input: { file_path: "foo.ts" },
-            cwd: "/project",
-        };
-        const n = cursorAdapter.normalize(payload);
-        expect(n.toolInput).toEqual({ file_path: "foo.ts" });
-        expect(n.toolName).toBe("Read");
-    });
-    it("formats passthrough as { permission: allow }", () => {
-        const result = JSON.parse(cursorAdapter.formatPreToolUse(passthrough()));
-        expect(result.permission).toBe("allow");
-    });
-    it("formats nudge with agent_message", () => {
-        const result = JSON.parse(cursorAdapter.formatPreToolUse(nudge("Use file_outline")));
-        expect(result.permission).toBe("allow");
-        expect(result.agent_message).toBe("Use file_outline");
-    });
-    it("formats rewrite with updated_input", () => {
-        const result = JSON.parse(cursorAdapter.formatPreToolUse(rewrite({ command: "unerr exec -- ls" })));
-        expect(result.permission).toBe("allow");
-        expect(result.updated_input).toEqual({ command: "unerr exec -- ls" });
-    });
-    it("formats PostToolUse enrich with additional_context", () => {
-        const result = JSON.parse(cursorAdapter.formatPostToolUse(enrich("Use search_code")));
-        expect(result.additional_context).toBe("Use search_code");
-    });
-});
-// ── Cline Adapter ────────────────────────────────────────────────────
-describe("clineAdapter", () => {
-    it("detects Cline payload", () => {
-        expect(clineAdapter.detect({ tool: "read_file", params: { path: "foo.ts" } })).toBe(true);
-        // Should NOT detect Claude Code
-        expect(clineAdapter.detect({
-            tool: "read_file",
-            params: {},
-            hook_event_name: "PreToolUse",
-        })).toBe(false);
-    });
-    it("normalizes tool names from Cline format", () => {
-        const payload = {
-            tool: "read_file",
-            params: { path: "foo.ts" },
-            event: "pre_tool",
-        };
-        const n = clineAdapter.normalize(payload);
-        expect(n.toolName).toBe("Read");
-        expect(n.toolInput.file_path).toBe("foo.ts");
-        expect(n.event).toBe("PreToolUse");
-    });
-    it("normalizes search_files to Grep", () => {
-        const payload = { tool: "search_files", params: { regex: "myFunc" } };
-        const n = clineAdapter.normalize(payload);
-        expect(n.toolName).toBe("Grep");
-        expect(n.toolInput.pattern).toBe("myFunc");
-    });
-    it("formats passthrough as { allow: true }", () => {
-        const result = JSON.parse(clineAdapter.formatPreToolUse(passthrough()));
-        expect(result.allow).toBe(true);
-    });
-    it("formats nudge with context", () => {
-        const result = JSON.parse(clineAdapter.formatPreToolUse(nudge("Use graph tools")));
-        expect(result.allow).toBe(true);
-        expect(result.context).toBe("Use graph tools");
-    });
-    it("formats PostToolUse enrich with context", () => {
-        const result = JSON.parse(clineAdapter.formatPostToolUse(enrich("Try get_references")));
-        expect(result.context).toBe("Try get_references");
-    });
-    it("maps post_tool event to PostToolUse", () => {
-        const payload = {
-            tool: "execute_command",
-            params: { command: "ls" },
-            event: "post_tool",
-        };
-        const n = clineAdapter.normalize(payload);
-        expect(n.event).toBe("PostToolUse");
-        expect(n.toolName).toBe("Bash");
-    });
-});
-// ── Universal Runner ─────────────────────────────────────────────────
-describe("runPreToolUseHook", () => {
-    it("returns {} for empty stdin", () => {
-        expect(runPreToolUseHook("", () => passthrough())).toBe("{}");
-    });
-    it("returns {} for invalid JSON", () => {
-        expect(runPreToolUseHook("not json", () => passthrough())).toBe("{}");
-    });
-    it("routes Claude Code payload through handler and formats correctly", () => {
-        const stdin = JSON.stringify({
-            hook_event_name: "PreToolUse",
-            tool_input: { file_path: "src/foo.ts" },
-        });
-        const result = JSON.parse(runPreToolUseHook(stdin, () => nudge("Use file_read")));
-        expect(result.hookSpecificOutput.systemMessage).toBe("Use file_read");
-    });
-    it("routes Cursor payload through handler and formats correctly", () => {
-        const stdin = JSON.stringify({
-            tool_name: "Read",
-            tool_input: { file_path: "src/foo.ts" },
-            cwd: "/project",
-        });
-        const result = JSON.parse(runPreToolUseHook(stdin, () => nudge("Use file_read")));
-        expect(result.permission).toBe("allow");
-        expect(result.agent_message).toBe("Use file_read");
-    });
-    it("routes Cline payload through handler and formats correctly", () => {
-        const stdin = JSON.stringify({
-            tool: "read_file",
-            params: { path: "src/foo.ts" },
-            event: "pre_tool",
-        });
-        const result = JSON.parse(runPreToolUseHook(stdin, () => nudge("Use file_read")));
-        expect(result.allow).toBe(true);
-        expect(result.context).toBe("Use file_read");
-    });
-});
-describe("runPostToolUseHook", () => {
-    it("routes Claude Code enrich correctly", () => {
-        const stdin = JSON.stringify({
-            hook_event_name: "PostToolUse",
-            tool_input: { file_path: "src/foo.ts" },
-        });
-        const result = JSON.parse(runPostToolUseHook(stdin, () => enrich("Try get_references")));
-        expect(result.hookSpecificOutput.additionalContext).toBe("Try get_references");
-    });
-    it("routes Cursor enrich correctly", () => {
-        const stdin = JSON.stringify({
-            tool_name: "Read",
-            tool_input: { file_path: "src/foo.ts" },
-            cwd: "/project",
-        });
-        const result = JSON.parse(runPostToolUseHook(stdin, () => enrich("Try get_references")));
-        expect(result.additional_context).toBe("Try get_references");
-    });
-});
-describe("runPromptSubmitHook", () => {
-    it("routes prompt submit for Claude Code", () => {
-        const stdin = JSON.stringify({
-            hook_event_name: "UserPromptSubmit",
-            user_message: "Add a new function to handle auth",
-        });
-        const result = JSON.parse(runPromptSubmitHook(stdin, () => enrich("Use unerr tools")));
-        expect(result.hookSpecificOutput.hookEventName).toBe("UserPromptSubmit");
-        expect(result.hookSpecificOutput.additionalContext).toBe("Use unerr tools");
-    });
-});
-// ── Result Constructors ──────────────────────────────────────────────
-describe("result constructors", () => {
-    it("passthrough creates correct shape", () => {
-        expect(passthrough()).toEqual({ type: "passthrough" });
-    });
-    it("nudge creates correct shape", () => {
-        expect(nudge("msg")).toEqual({ type: "nudge", message: "msg" });
-    });
-    it("rewrite creates correct shape", () => {
-        expect(rewrite({ cmd: "x" })).toEqual({
-            type: "rewrite",
-            updatedInput: { cmd: "x" },
-        });
-    });
-    it("enrich creates correct shape", () => {
-        expect(enrich("ctx")).toEqual({ type: "enrich", message: "ctx" });
-    });
-});