@unerr-ai/unerr 0.1.6 → 0.1.7

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

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

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