@unerr-ai/unerr 0.1.0 → 0.1.2

package/dist/__tests__/sprint-s4-wiring.test.js

@@ -0,0 +1,213 @@
+/**
+ * Sprint S4: Token Accounting & Visibility — Integration Tests.
+ *
+ * Verifies:
+ *   - Every MCP response includes _meta.tokens_saved (combined sources)
+ *   - Every MCP response includes _meta.dollar_savings (model-priced)
+ *   - TokenCounter emits to stderr at configurable interval (default: every 5th)
+ *   - EfficiencyTracker accumulates session totals
+ *   - Session summary displays: total tokens saved, dollar savings, efficiency %
+ */
+import { describe, expect, it, vi } from "vitest";
+import { createExplorationAccumulator } from "../intelligence/exploration-cost.js";
+import { QueryRouter } from "../intelligence/query-router.js";
+import { createEfficiencyTracker } from "../proxy/efficiency-tracker.js";
+import { calculateDollarSavings } from "../proxy/model-pricing.js";
+import { createTokenCounter } from "../proxy/token-counter.js";
+function createMockGraph(overrides = {}) {
+    return {
+        getEntity: vi.fn().mockReturnValue({
+            key: "fn1",
+            name: "fn1",
+            kind: "function",
+            file_path: "src/main.ts",
+            risk_level: "normal",
+        }),
+        getBlastRadius: vi.fn().mockReturnValue({
+            direct_callers: 5,
+            direct_callees: 2,
+            transitive_count: 10,
+            is_chokepoint: false,
+            summary: "5 callers, 10 transitive dependents",
+        }),
+        getBlastRadiusEntities: vi.fn().mockReturnValue(["caller1", "caller2"]),
+        getConventionsForEntity: vi.fn().mockReturnValue([]),
+        getCorrections: vi.fn().mockReturnValue([]),
+        getCommunityForEntity: vi.fn().mockReturnValue(null),
+        getCrossCommunityEdges: vi.fn().mockReturnValue([]),
+        getEntitiesByFile: vi.fn().mockReturnValue([]),
+        queryEntities: vi.fn().mockReturnValue([]),
+        searchEntities: vi.fn().mockReturnValue([]),
+        getDriftOverlayEntity: vi.fn().mockReturnValue(null),
+        getDriftSummary: vi
+            .fn()
+            .mockReturnValue({ added: 0, modified: 0, removed: 0, total: 0 }),
+        getCriticalNodes: vi.fn().mockReturnValue([]),
+        getCrossBoundaryLinks: vi.fn().mockReturnValue([]),
+        getCallers: vi.fn().mockReturnValue([]),
+        getCallersOf: vi.fn().mockReturnValue([]),
+        getCalleesOf: vi.fn().mockReturnValue([]),
+        getCallees: vi.fn().mockReturnValue([]),
+        getImports: vi.fn().mockReturnValue([]),
+        getRules: vi.fn().mockReturnValue([]),
+        getJustificationsForEntity: vi.fn().mockReturnValue([]),
+        getDriftEntitiesForFile: vi.fn().mockReturnValue([]),
+        close: vi.fn(),
+        ...overrides,
+    };
+}
+describe("Sprint S4: Token Accounting & Visibility Wiring", () => {
+    describe("S4.1+S4.3: Combined tokens_saved on every response", () => {
+        it("tracks tokens saved from exploration cost (internal accumulator)", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            const tokenCounter = createTokenCounter({ emitEveryN: 10 });
+            const efficiencyTracker = createEfficiencyTracker();
+            router.setExplorationAccumulator(accumulator);
+            router.setTokenCounter(tokenCounter);
+            router.setEfficiencyTracker(efficiencyTracker);
+            await router.execute("get_function", { key: "fn1" });
+            // Vanity wire fields stripped; verify via internal counter.
+            expect(tokenCounter.getTotalSaved()).toBeGreaterThan(0);
+        });
+        it("feeds savings into token counter and efficiency tracker", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            const tokenCounter = createTokenCounter({ emitEveryN: 100 });
+            const efficiencyTracker = createEfficiencyTracker();
+            router.setExplorationAccumulator(accumulator);
+            router.setTokenCounter(tokenCounter);
+            router.setEfficiencyTracker(efficiencyTracker);
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn2" });
+            expect(tokenCounter.getTotalSaved()).toBeGreaterThan(0);
+            expect(tokenCounter.getCallCount()).toBe(2);
+            expect(efficiencyTracker.getSavedTokens()).toBeGreaterThan(0);
+        });
+    });
+    describe("S4.4: Dollar savings tracked internally", () => {
+        it("derivable from token counter via model pricing", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            const tokenCounter = createTokenCounter({ emitEveryN: 100 });
+            router.setExplorationAccumulator(accumulator);
+            router.setTokenCounter(tokenCounter);
+            await router.execute("get_function", { key: "fn1" });
+            // Dollar savings stripped from wire to reduce metadata overhead;
+            // dashboard derives them from the internal token counter.
+            const tokensSaved = tokenCounter.getTotalSaved();
+            expect(tokensSaved).toBeGreaterThan(0);
+            const dollars = calculateDollarSavings(tokensSaved);
+            expect(dollars).toBeGreaterThan(0);
+        });
+    });
+    describe("S4.5: Stderr live counter at configurable interval", () => {
+        it("emits to stderr every Nth response (default: 5)", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            const messages = [];
+            const tokenCounter = createTokenCounter({
+                emitEveryN: 5,
+                sink: (msg) => messages.push(msg),
+            });
+            const efficiencyTracker = createEfficiencyTracker();
+            router.setExplorationAccumulator(accumulator);
+            router.setTokenCounter(tokenCounter);
+            router.setEfficiencyTracker(efficiencyTracker);
+            // Make 5 calls to trigger the first emission
+            for (let i = 0; i < 5; i++) {
+                await router.execute("get_function", { key: `fn${i}` });
+            }
+            expect(messages.length).toBe(1);
+            expect(messages[0]).toContain("[unerr]");
+            expect(messages[0]).toContain("tokens saved");
+            expect(messages[0]).toContain("efficiency");
+        });
+        it("does not emit before reaching the interval", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            const messages = [];
+            const tokenCounter = createTokenCounter({
+                emitEveryN: 5,
+                sink: (msg) => messages.push(msg),
+            });
+            router.setExplorationAccumulator(accumulator);
+            router.setTokenCounter(tokenCounter);
+            // Make 4 calls — should NOT emit
+            for (let i = 0; i < 4; i++) {
+                await router.execute("get_function", { key: `fn${i}` });
+            }
+            expect(messages.length).toBe(0);
+        });
+    });
+    describe("S4.2: Efficiency tracker session totals", () => {
+        it("getEfficiencySnapshot returns cumulative data", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            const tokenCounter = createTokenCounter({ emitEveryN: 100 });
+            const efficiencyTracker = createEfficiencyTracker();
+            router.setExplorationAccumulator(accumulator);
+            router.setTokenCounter(tokenCounter);
+            router.setEfficiencyTracker(efficiencyTracker);
+            await router.execute("get_function", { key: "fn1" });
+            await router.execute("get_function", { key: "fn2" });
+            await router.execute("search_code", { query: "test" });
+            const snap = router.getEfficiencySnapshot();
+            expect(snap).not.toBeNull();
+            expect(snap?.totalCalls).toBe(3);
+            expect(snap?.savedTokens).toBeGreaterThan(0);
+            expect(snap?.efficiency).toBeGreaterThan(0);
+            expect(snap?.efficiency).toBeLessThanOrEqual(100);
+        });
+        it("returns null when no efficiency tracker set", () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            expect(router.getEfficiencySnapshot()).toBeNull();
+        });
+    });
+    describe("S4.6+S4.7: Session summary data", () => {
+        it("token counter provides formatted summary data", async () => {
+            const graph = createMockGraph();
+            const router = new QueryRouter(graph);
+            const accumulator = createExplorationAccumulator();
+            const tokenCounter = createTokenCounter({ emitEveryN: 100 });
+            const efficiencyTracker = createEfficiencyTracker();
+            router.setExplorationAccumulator(accumulator);
+            router.setTokenCounter(tokenCounter);
+            router.setEfficiencyTracker(efficiencyTracker);
+            for (let i = 0; i < 10; i++) {
+                await router.execute("get_function", { key: `fn${i}` });
+            }
+            // Token counter provides totals for session summary
+            expect(tokenCounter.getTotalSaved()).toBeGreaterThan(0);
+            expect(tokenCounter.getTotalProcessed()).toBeGreaterThan(0);
+            expect(tokenCounter.getEfficiency()).toBeGreaterThan(0);
+            // Efficiency tracker provides snapshot for session card
+            const snap = efficiencyTracker.getSnapshot();
+            expect(snap.totalCalls).toBe(10);
+            expect(snap.savedTokens).toBeGreaterThan(0);
+            expect(snap.avgSavingsPerCall).toBeGreaterThan(0);
+        });
+    });
+    describe("S4: Model pricing calculations", () => {
+        it("calculateDollarSavings returns positive value for saved tokens", () => {
+            const savings = calculateDollarSavings(10_000);
+            // Default model is Sonnet 4 at $3/M input tokens
+            // 10K tokens × $3/M = $0.03
+            expect(savings).toBeCloseTo(0.03, 4);
+        });
+        it("calculateDollarSavings respects model selection", () => {
+            const sonnet = calculateDollarSavings(10_000, "claude-sonnet-4-20250514");
+            const opus = calculateDollarSavings(10_000, "claude-opus-4-20250514");
+            // Opus is 5x more expensive than Sonnet
+            expect(opus).toBeGreaterThan(sonnet);
+            expect(opus).toBeCloseTo(0.15, 4);
+        });
+    });
+});

package/dist/__tests__/sprint-s6-hooks.test.js

@@ -0,0 +1,222 @@
+/**
+ * Sprint S6: CLI Hooks Integration — Integration Tests.
+ *
+ * Verifies:
+ *   - Auto-detection identifies installed AI tools by directory presence
+ *   - `unerr init` installs Claude Code hook at correct path
+ *   - `unerr init` writes MCP config for detected tools
+ *   - `compress-output` command accepts graph risk map
+ *   - `unerr uninstall` removes hooks cleanly
+ *   - Hook status appears in status output data
+ *   - Existing tests still pass
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { runInit } from "../commands/init.js";
+import { installClaudeHook, isClaudeHookInstalled, removeClaudeHook, } from "../config/hook-installer.js";
+import { isConfigured, removeMcpConfig, writeMcpConfig, } from "../config/mcp-config-writer.js";
+import { detectTools, formatDetectedTools } from "../config/tool-detector.js";
+function makeTmpDir() {
+    const dir = join(tmpdir(), `unerr-s6-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+describe("Sprint S6: CLI Hooks Integration", () => {
+    describe("S6.1: AI Tool Auto-Detection", () => {
+        it("detects Claude Code by .claude/ directory", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".claude"), { recursive: true });
+            const tools = detectTools(cwd);
+            expect(tools.some((t) => t.ide === "claude-code")).toBe(true);
+        });
+        it("detects Cursor by .cursor/ directory", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".cursor"), { recursive: true });
+            const tools = detectTools(cwd);
+            expect(tools.some((t) => t.ide === "cursor")).toBe(true);
+        });
+        it("detects VS Code by .vscode/ directory", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".vscode"), { recursive: true });
+            const tools = detectTools(cwd);
+            expect(tools.some((t) => t.ide === "vscode")).toBe(true);
+        });
+        it("detects Windsurf by .windsurf/ directory", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".windsurf"), { recursive: true });
+            const tools = detectTools(cwd);
+            expect(tools.some((t) => t.ide === "windsurf")).toBe(true);
+        });
+        it("detects multiple tools simultaneously", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".claude"), { recursive: true });
+            mkdirSync(join(cwd, ".cursor"), { recursive: true });
+            mkdirSync(join(cwd, ".vscode"), { recursive: true });
+            const tools = detectTools(cwd);
+            expect(tools.length).toBe(3);
+            expect(tools.map((t) => t.ide).sort()).toEqual([
+                "claude-code",
+                "cursor",
+                "vscode",
+            ]);
+        });
+        it("returns empty array when no tools found", () => {
+            const cwd = makeTmpDir();
+            const tools = detectTools(cwd);
+            expect(tools).toEqual([]);
+        });
+        it("formatDetectedTools returns readable string", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".claude"), { recursive: true });
+            mkdirSync(join(cwd, ".cursor"), { recursive: true });
+            const tools = detectTools(cwd);
+            const formatted = formatDetectedTools(tools);
+            expect(formatted).toContain("Claude Code");
+            expect(formatted).toContain("Cursor");
+        });
+    });
+    describe("S6.2: Hook installation via init", () => {
+        it("installs Claude Code PostToolUse hook at correct path", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".claude"), { recursive: true });
+            const result = runInit(cwd);
+            const hookPath = join(cwd, ".claude", "hooks", "PostToolUse.sh");
+            expect(existsSync(hookPath)).toBe(true);
+            expect(result.hooksInstalled.length).toBeGreaterThan(0);
+            expect(result.hooksInstalled[0]).toContain("Claude Code hook");
+        });
+        it("skips hook if already installed", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".claude", "hooks"), { recursive: true });
+            writeFileSync(join(cwd, ".claude", "hooks", "PostToolUse.sh"), "#!/bin/bash\n# existing");
+            const result = runInit(cwd);
+            expect(result.skipped.some((s) => s.includes("already installed"))).toBe(true);
+        });
+        it("hook content references unerr compress-output", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".claude"), { recursive: true });
+            installClaudeHook(cwd);
+            const hookContent = readFileSync(join(cwd, ".claude", "hooks", "PostToolUse.sh"), "utf-8");
+            expect(hookContent).toContain("compress-output");
+            expect(hookContent).toContain("unerr");
+        });
+    });
+    describe("S6.3: MCP config writing via init", () => {
+        it("writes .cursor/mcp.json for Cursor project", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".cursor"), { recursive: true });
+            const result = runInit(cwd);
+            const configPath = join(cwd, ".cursor", "mcp.json");
+            expect(existsSync(configPath)).toBe(true);
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            expect(config.mcpServers.unerr).toBeDefined();
+            expect(config.mcpServers.unerr.command).toBe("unerr");
+            expect(config.mcpServers.unerr.args).toContain("--mcp");
+            expect(result.configsWritten.length).toBeGreaterThan(0);
+        });
+        it("writes .mcp.json for Claude Code project", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".claude"), { recursive: true });
+            const result = runInit(cwd);
+            const configPath = join(cwd, ".mcp.json");
+            expect(existsSync(configPath)).toBe(true);
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            expect(config.mcpServers.unerr).toBeDefined();
+        });
+        it("merges into existing config without overwriting", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".cursor"), { recursive: true });
+            const existingConfig = {
+                mcpServers: { other: { command: "other-tool", args: [] } },
+            };
+            writeFileSync(join(cwd, ".cursor", "mcp.json"), JSON.stringify(existingConfig));
+            runInit(cwd);
+            const config = JSON.parse(readFileSync(join(cwd, ".cursor", "mcp.json"), "utf-8"));
+            expect(config.mcpServers.other).toBeDefined();
+            expect(config.mcpServers.unerr).toBeDefined();
+        });
+        it("skips if unerr already configured", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".cursor"), { recursive: true });
+            const existingConfig = {
+                mcpServers: {
+                    unerr: { command: "npx", args: ["@unerr/unerr", "--mcp"] },
+                },
+            };
+            writeFileSync(join(cwd, ".cursor", "mcp.json"), JSON.stringify(existingConfig));
+            const result = runInit(cwd);
+            expect(result.skipped.some((s) => s.includes("already configured"))).toBe(true);
+        });
+    });
+    describe("S6.4: compress-output uses graph risk map", () => {
+        it("compressOutput accepts entityRiskMap parameter", async () => {
+            const { compressOutput } = await import("../proxy/output-compressor.js");
+            const riskMap = new Map([
+                [
+                    "src/main.ts",
+                    { riskLevel: "high", fanIn: 10, isChokepoint: true },
+                ],
+            ]);
+            const result = compressOutput("diff --git a/src/main.ts b/src/main.ts\n+++ changed\n- old\n+ new\n", {
+                tokenBudget: 2000,
+                entityRiskMap: riskMap,
+            });
+            expect(result.output).toBeDefined();
+            expect(result.originalTokens).toBeGreaterThan(0);
+        });
+        it("compressOutput works without entityRiskMap", async () => {
+            const { compressOutput } = await import("../proxy/output-compressor.js");
+            const result = compressOutput("test output\nline 2\nline 3", {
+                tokenBudget: 2000,
+            });
+            expect(result.output).toBeDefined();
+        });
+    });
+    describe("S6.5: Hook uninstall", () => {
+        it("removes Claude Code hook cleanly", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".claude", "hooks"), { recursive: true });
+            writeFileSync(join(cwd, ".claude", "hooks", "PostToolUse.sh"), "#!/bin/bash\n");
+            expect(isClaudeHookInstalled(cwd)).toBe(true);
+            const removed = removeClaudeHook(cwd);
+            expect(removed).toBe(true);
+            expect(isClaudeHookInstalled(cwd)).toBe(false);
+        });
+        it("removeMcpConfig removes unerr entry from config", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".cursor"), { recursive: true });
+            const config = {
+                mcpServers: {
+                    unerr: { command: "npx", args: [] },
+                    other: { command: "x", args: [] },
+                },
+            };
+            writeFileSync(join(cwd, ".cursor", "mcp.json"), JSON.stringify(config));
+            const removed = removeMcpConfig(cwd, "cursor");
+            expect(removed).toBe(true);
+            const updated = JSON.parse(readFileSync(join(cwd, ".cursor", "mcp.json"), "utf-8"));
+            expect(updated.mcpServers.unerr).toBeUndefined();
+            expect(updated.mcpServers.other).toBeDefined();
+        });
+    });
+    describe("S6.6: Hook status in status output", () => {
+        it("isClaudeHookInstalled returns true when hook exists", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".claude", "hooks"), { recursive: true });
+            writeFileSync(join(cwd, ".claude", "hooks", "PostToolUse.sh"), "#!/bin/bash\n");
+            expect(isClaudeHookInstalled(cwd)).toBe(true);
+        });
+        it("isConfigured returns true when MCP config has unerr entry", () => {
+            const cwd = makeTmpDir();
+            mkdirSync(join(cwd, ".cursor"), { recursive: true });
+            writeMcpConfig(cwd, "cursor");
+            expect(isConfigured(cwd, "cursor")).toBe(true);
+        });
+        it("isConfigured returns false when no config exists", () => {
+            const cwd = makeTmpDir();
+            expect(isConfigured(cwd, "cursor")).toBe(false);
+        });
+    });
+});