@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/signal-show-store.test.js

@@ -1,108 +0,0 @@
-/**
- * Multi-session concurrency contract for SignalShowStore.
- *
- * Two stores against the same facts.db with different session IDs simulate
- * two parallel `unerr --mcp` instances (e.g. Cursor + Claude Code in the same
- * repo). Verified properties:
- *
- *   1. Per-session writes never overwrite each other (per-session rows in
- *      the (signal_id, session_id) key).
- *   2. Aggregate count seen by either store after a flush+refresh tick is
- *      the SUM of both sessions' counts — no lost updates.
- *   3. Cross-session last_shown timestamp is MAX over all sessions, so the
- *      dedup window in fact-ranking sees the most recent show.
- *   4. Time-decay reduces effective count for stale shows.
- */
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { initFactsSchema, openFactsDb } from "../intelligence/facts-schema.js";
-import { SignalShowStore } from "../intelligence/signal-show-store.js";
-describe("SignalShowStore — multi-session contract", () => {
-    let projectRoot;
-    let dbA;
-    let dbB;
-    beforeEach(async () => {
-        projectRoot = mkdtempSync(join(tmpdir(), "unerr-show-store-"));
-        // Two distinct CozoDB handles pointing at the same SQLite file —
-        // simulates two `unerr --mcp` processes in the same repo.
-        const aR = await openFactsDb(projectRoot);
-        await initFactsSchema(aR.db);
-        dbA = aR.db;
-        const bR = await openFactsDb(projectRoot);
-        await initFactsSchema(bR.db);
-        dbB = bR.db;
-    });
-    afterEach(() => {
-        rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it("never returns the local session's own count in the others snapshot (no double-count after flush)", async () => {
-        const a = new SignalShowStore(dbA, "session-A", { flushIntervalMs: 60000 });
-        await a.start();
-        a.recordShown("sig-1", "src/foo.ts");
-        a.recordShown("sig-1", "src/foo.ts");
-        await a.flush();
-        // Tick (refresh) without recording — others snapshot should NOT include
-        // session-A's own row.
-        await a.tick();
-        expect(a.getEffectiveShowCount("sig-1")).toBeGreaterThan(0);
-        // In-memory mineCount is 2; others contribution is 0; so effective ≈ 2
-        // (modulo tiny decay from the few ms elapsed).
-        expect(a.getEffectiveShowCount("sig-1")).toBeCloseTo(2, 0);
-        await a.close();
-    });
-    it("session B sees session A's shows after a flush+refresh tick", async () => {
-        const a = new SignalShowStore(dbA, "session-A", { flushIntervalMs: 60000 });
-        const b = new SignalShowStore(dbB, "session-B", { flushIntervalMs: 60000 });
-        await a.start();
-        await b.start();
-        a.recordShown("sig-X", "src/foo.ts");
-        a.recordShown("sig-X", "src/foo.ts");
-        a.recordShown("sig-X", "src/foo.ts");
-        await a.flush();
-        // Before B refreshes, it sees nothing.
-        expect(b.getEffectiveShowCount("sig-X")).toBe(0);
-        await b.tick();
-        expect(b.getEffectiveShowCount("sig-X")).toBeCloseTo(3, 0);
-        // Now both increment further; aggregate keeps summing.
-        b.recordShown("sig-X", "src/foo.ts");
-        await b.flush();
-        await a.tick();
-        // A sees B's 1 + its own 3 = 4
-        expect(a.getEffectiveShowCount("sig-X")).toBeCloseTo(4, 0);
-        await Promise.all([a.close(), b.close()]);
-    });
-    it("getLastShownMs returns MAX across sessions", async () => {
-        const a = new SignalShowStore(dbA, "session-A", { flushIntervalMs: 60000 });
-        const b = new SignalShowStore(dbB, "session-B", { flushIntervalMs: 60000 });
-        await a.start();
-        await b.start();
-        const t0 = Date.now();
-        a.recordShown("sig-Y", "", t0);
-        await a.flush();
-        await b.tick();
-        expect(b.getLastShownMs("sig-Y")).toBe(t0);
-        const t1 = t0 + 5000;
-        b.recordShown("sig-Y", "", t1);
-        expect(b.getLastShownMs("sig-Y")).toBe(t1);
-        await b.flush();
-        await a.tick();
-        expect(a.getLastShownMs("sig-Y")).toBe(t1);
-        await Promise.all([a.close(), b.close()]);
-    });
-    it("time-decays the effective count toward 0 over 24h", async () => {
-        const a = new SignalShowStore(dbA, "session-A", {
-            flushIntervalMs: 60000,
-            decayWindowMs: 24 * 60 * 60 * 1000,
-        });
-        await a.start();
-        const old = Date.now() - 48 * 60 * 60 * 1000; // 2 days ago
-        a.recordShown("sig-old", "", old);
-        // After 2× decay window, effective count ≈ count × e^-2 ≈ 0.135
-        const eff = a.getEffectiveShowCount("sig-old");
-        expect(eff).toBeLessThan(0.2);
-        expect(eff).toBeGreaterThan(0.1);
-        await a.close();
-    });
-});

package/dist/__tests__/smart-truncate.test.js

@@ -1,215 +0,0 @@
-/**
- * Leapfrog Sprint C TEST: Structural-priority truncation.
- *
- * Tests the smartTruncate() module against the spec:
- *   - Priority order: metadata → imports → signatures → bodies
- *   - Small entities returned in full (no truncation)
- *   - Large entities truncated at appropriate level
- *   - Truncation markers include token_budget hint
- *   - Never cuts mid-line (SC-12)
- *   - estimateTokens() uses 4 chars/token
- *   - truncateResultList() for array-returning tools
- */
-import { describe, expect, it } from "vitest";
-import { estimateTokens, smartTruncate, truncateResultList, } from "../intelligence/smart-truncate.js";
-describe("estimateTokens", () => {
-    it("returns 0 for empty string", () => {
-        expect(estimateTokens("")).toBe(0);
-    });
-    it("uses 4 chars per token", () => {
-        expect(estimateTokens("abcd")).toBe(1);
-        expect(estimateTokens("abcdefgh")).toBe(2);
-        expect(estimateTokens("a")).toBe(1);
-    });
-    it("rounds up fractional tokens", () => {
-        expect(estimateTokens("abcde")).toBe(2); // 5/4 = 1.25 → 2
-    });
-});
-describe("smartTruncate", () => {
-    const smallMetadata = "name: login\nkind: function\nfile: src/auth.ts";
-    const smallImports = 'import { hash } from "bcrypt";\nimport { db } from "./db";';
-    const smallSignature = "function login(email: string, password: string): Promise<User>";
-    const smallBody = "  const user = await db.findUser(email);\n  if (!user) throw new Error('not found');\n  return user;";
-    it("returns full content when everything fits within budget", () => {
-        const result = smartTruncate({
-            metadata: smallMetadata,
-            imports: smallImports,
-            signatures: smallSignature,
-            bodies: smallBody,
-            budget: 5000,
-        });
-        expect(result.truncated).toBe(false);
-        expect(result.truncation_level).toBe("full");
-        expect(result.content).toContain(smallMetadata);
-        expect(result.content).toContain(smallImports);
-        expect(result.content).toContain(smallSignature);
-        expect(result.content).toContain(smallBody);
-        expect(result.tokens_used).toBeLessThanOrEqual(result.tokens_budget);
-    });
-    it("small entity (100 tokens) → full content, truncated: false", () => {
-        const result = smartTruncate({
-            metadata: "name: x",
-            imports: "",
-            signatures: "function x(): void",
-            bodies: "return;",
-            budget: 2000,
-        });
-        expect(result.truncated).toBe(false);
-        expect(result.truncation_level).toBe("full");
-        expect(result.tokens_used).toBeLessThan(100);
-    });
-    it("large entity (10K tokens) with budget 500 → truncated", () => {
-        const largeBodies = Array.from({ length: 500 }, (_, i) => `  const line${i} = processItem(items[${i}]);`).join("\n");
-        const result = smartTruncate({
-            metadata: smallMetadata,
-            imports: smallImports,
-            signatures: smallSignature,
-            bodies: largeBodies,
-            budget: 500,
-        });
-        expect(result.truncated).toBe(true);
-        expect(result.truncation_level === "signatures_only" ||
-            result.truncation_level === "signatures_and_bodies" ||
-            result.truncation_level === "metadata_only").toBe(true);
-        expect(result.content).toContain("lines omitted");
-        expect(result.full_tokens_estimate).toBeGreaterThan(500);
-        expect(result.tokens_used).toBeLessThanOrEqual(result.tokens_budget + 50);
-    });
-    it("budget 50K → full content even for large entities", () => {
-        const largeBodies = Array.from({ length: 200 }, (_, i) => `  const line${i} = processItem(items[${i}]);`).join("\n");
-        const result = smartTruncate({
-            metadata: smallMetadata,
-            imports: smallImports,
-            signatures: smallSignature,
-            bodies: largeBodies,
-            budget: 50000,
-        });
-        expect(result.truncated).toBe(false);
-        expect(result.truncation_level).toBe("full");
-        expect(result.content).toContain(largeBodies);
-    });
-    it("never cuts mid-line (SC-12)", () => {
-        const bodies = Array.from({ length: 100 }, (_, i) => `  const longVariableName${i} = someVeryLongFunctionCall(param1, param2, param3);`).join("\n");
-        const result = smartTruncate({
-            metadata: smallMetadata,
-            imports: "",
-            signatures: "",
-            bodies,
-            budget: 300,
-        });
-        if (result.truncated) {
-            const lines = result.content.split("\n");
-            for (const line of lines) {
-                if (line.startsWith("//"))
-                    continue;
-                if (line.trim() === "")
-                    continue;
-                expect(line.endsWith(";") ||
-                    line.startsWith("name:") ||
-                    line.startsWith("kind:") ||
-                    line.startsWith("file:")).toBe(true);
-            }
-        }
-    });
-    it("truncation marker includes full_tokens_estimate for re-request", () => {
-        const largeBodies = "x\n".repeat(5000);
-        const result = smartTruncate({
-            metadata: "name: big",
-            imports: "",
-            signatures: "",
-            bodies: largeBodies,
-            budget: 200,
-        });
-        expect(result.truncated).toBe(true);
-        expect(result.content).toContain("token_budget:");
-        expect(result.full_tokens_estimate).toBeGreaterThan(200);
-    });
-    it("handles empty sections gracefully", () => {
-        const result = smartTruncate({
-            metadata: "name: empty",
-            imports: "",
-            signatures: "",
-            bodies: "",
-            budget: 2000,
-        });
-        expect(result.truncated).toBe(false);
-        expect(result.truncation_level).toBe("full");
-        expect(result.content).toBe("name: empty");
-    });
-    it("metadata always included even when budget is very small", () => {
-        const result = smartTruncate({
-            metadata: "name: critical\nkind: function\nrisk: high",
-            imports: 'import { x } from "y";',
-            signatures: "function critical(): void",
-            bodies: "return expensiveComputation();",
-            budget: 100,
-        });
-        expect(result.content).toContain("name: critical");
-    });
-    it("priority order: metadata first, then imports, then signatures, then bodies", () => {
-        const result = smartTruncate({
-            metadata: "META_MARKER",
-            imports: "IMPORT_MARKER",
-            signatures: "SIG_MARKER",
-            bodies: "BODY_MARKER",
-            budget: 5000,
-        });
-        const metaIdx = result.content.indexOf("META_MARKER");
-        const importIdx = result.content.indexOf("IMPORT_MARKER");
-        const sigIdx = result.content.indexOf("SIG_MARKER");
-        const bodyIdx = result.content.indexOf("BODY_MARKER");
-        expect(metaIdx).toBeLessThan(importIdx);
-        expect(importIdx).toBeLessThan(sigIdx);
-        expect(sigIdx).toBeLessThan(bodyIdx);
-    });
-    it("enforces minimum budget of 100", () => {
-        const result = smartTruncate({
-            metadata: "name: test",
-            imports: "",
-            signatures: "",
-            bodies: "",
-            budget: 10,
-        });
-        expect(result.tokens_budget).toBe(100);
-    });
-    it("performance: handles 10K-line entity under 5ms", () => {
-        const bigBodies = Array.from({ length: 10000 }, (_, i) => `  const line${i} = processItem(items[${i}], options);`).join("\n");
-        const t0 = performance.now();
-        const result = smartTruncate({
-            metadata: smallMetadata,
-            imports: smallImports,
-            signatures: smallSignature,
-            bodies: bigBodies,
-            budget: 2000,
-        });
-        const elapsed = performance.now() - t0;
-        expect(elapsed).toBeLessThan(50);
-        expect(result.truncated).toBe(true);
-    });
-});
-describe("truncateResultList", () => {
-    it("keeps all items when under budget", () => {
-        const items = [{ name: "a" }, { name: "b" }, { name: "c" }];
-        const result = truncateResultList(items, 5000, (i) => JSON.stringify(i));
-        expect(result.items).toHaveLength(3);
-        expect(result.truncated).toBe(false);
-        expect(result.total).toBe(3);
-    });
-    it("truncates items when over budget", () => {
-        const items = Array.from({ length: 100 }, (_, i) => ({
-            name: `entity_${i}`,
-            file_path: `src/module${i}/handler.ts`,
-            signature: `function entity_${i}(): Promise<Result>`,
-        }));
-        const result = truncateResultList(items, 200, (i) => JSON.stringify(i));
-        expect(result.items.length).toBeLessThan(100);
-        expect(result.truncated).toBe(true);
-        expect(result.total).toBe(100);
-    });
-    it("always includes at least one item", () => {
-        const items = [{ name: "big_entity", description: "x".repeat(10000) }];
-        const result = truncateResultList(items, 100, (i) => JSON.stringify(i));
-        expect(result.items).toHaveLength(1);
-        expect(result.total).toBe(1);
-    });
-});

package/dist/__tests__/snapshot-v2.test.js

@@ -1,113 +0,0 @@
-/**
- * Phase 10b TEST-06: v2 snapshot envelope tests.
- */
-import { describe, expect, it } from "vitest";
-describe("SnapshotEnvelope v2", () => {
-    it("supports version 2 with rules and patterns", () => {
-        const envelope = {
-            version: 2,
-            repoId: "repo-1",
-            orgId: "org-1",
-            entities: [
-                {
-                    key: "fn1",
-                    kind: "function",
-                    name: "doStuff",
-                    file_path: "src/index.ts",
-                },
-            ],
-            edges: [{ from_key: "fn1", to_key: "fn2", type: "calls" }],
-            rules: [
-                {
-                    key: "rule-1",
-                    name: "No eval",
-                    scope: "repo",
-                    severity: "error",
-                    engine: "structural",
-                    query: "call_expression",
-                    message: "Do not use eval()",
-                    file_glob: "**/*.ts",
-                    enabled: true,
-                    repo_id: "repo-1",
-                },
-            ],
-            patterns: [
-                {
-                    key: "pat-1",
-                    name: "Error boundary",
-                    kind: "structural",
-                    frequency: 12,
-                    confidence: 0.85,
-                    exemplar_keys: ["src/App.tsx:5", "src/Layout.tsx:10"],
-                    promoted_rule_key: "",
-                },
-            ],
-            generatedAt: new Date().toISOString(),
-        };
-        expect(envelope.version).toBe(2);
-        expect(envelope.rules?.length).toBe(1);
-        expect(envelope.patterns?.length).toBe(1);
-        expect(envelope.rules?.[0]?.engine).toBe("structural");
-        expect(envelope.patterns?.[0]?.exemplar_keys).toHaveLength(2);
-    });
-    it("v1 envelope has no rules/patterns", () => {
-        const envelope = {
-            version: 1,
-            repoId: "repo-1",
-            orgId: "org-1",
-            entities: [],
-            edges: [],
-            generatedAt: new Date().toISOString(),
-        };
-        expect(envelope.version).toBe(1);
-        expect(envelope.rules).toBeUndefined();
-        expect(envelope.patterns).toBeUndefined();
-    });
-    it("v2 envelope with empty rules/patterns is valid", () => {
-        const envelope = {
-            version: 2,
-            repoId: "repo-1",
-            orgId: "org-1",
-            entities: [],
-            edges: [],
-            rules: [],
-            patterns: [],
-            generatedAt: new Date().toISOString(),
-        };
-        expect(envelope.version).toBe(2);
-        expect(envelope.rules).toHaveLength(0);
-        expect(envelope.patterns).toHaveLength(0);
-    });
-    it("CompactRule has all required fields", () => {
-        const rule = {
-            key: "rule-1",
-            name: "Test",
-            scope: "workspace",
-            severity: "info",
-            engine: "naming",
-            query: "^[A-Z]",
-            message: "Must be PascalCase",
-            file_glob: "src/**/*.ts",
-            enabled: true,
-            repo_id: "repo-1",
-        };
-        expect(rule.key).toBe("rule-1");
-        expect(rule.scope).toBe("workspace");
-        expect(rule.engine).toBe("naming");
-    });
-    it("CompactPattern has all required fields", () => {
-        const pattern = {
-            key: "pat-1",
-            name: "Singleton pattern",
-            kind: "structural",
-            frequency: 8,
-            confidence: 0.92,
-            exemplar_keys: ["a:1", "b:2", "c:3"],
-            promoted_rule_key: "rule-singleton",
-        };
-        expect(pattern.key).toBe("pat-1");
-        expect(pattern.confidence).toBeGreaterThan(0.9);
-        expect(pattern.exemplar_keys).toHaveLength(3);
-        expect(pattern.promoted_rule_key).toBe("rule-singleton");
-    });
-});

package/dist/__tests__/sprint-l1-local-mode.test.js

@@ -1,130 +0,0 @@
-/**
- * Sprint L1: Network Firewall & Local LLM Config Tests
- *
- * Tests:
- *   1. NetworkFirewall seal/unseal/block behavior
- *   2. LocalLlmConfigSchema validation
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// ── 2. NetworkFirewall ───────────────────────────────────────────
-describe("NetworkFirewall", () => {
-    let originalFetch;
-    beforeEach(() => {
-        originalFetch = globalThis.fetch;
-    });
-    afterEach(async () => {
-        const { unseal } = await import("../proxy/network-firewall.js");
-        unseal();
-        // Restore original fetch in case unseal didn't fully clean up
-        globalThis.fetch = originalFetch;
-    });
-    it("seal() replaces globalThis.fetch", async () => {
-        const { seal, isSealed } = await import("../proxy/network-firewall.js");
-        expect(isSealed()).toBe(false);
-        seal();
-        expect(isSealed()).toBe(true);
-        expect(globalThis.fetch).not.toBe(originalFetch);
-    });
-    it("unseal() restores original fetch", async () => {
-        const { seal, unseal, isSealed } = await import("../proxy/network-firewall.js");
-        seal();
-        expect(isSealed()).toBe(true);
-        unseal();
-        expect(isSealed()).toBe(false);
-    });
-    it("blocks non-localhost fetch calls when sealed", async () => {
-        const { seal, getBlockedCount, resetBlockedCount } = await import("../proxy/network-firewall.js");
-        resetBlockedCount();
-        seal();
-        await expect(fetch("https://api.example.com/data")).rejects.toThrow(/NetworkFirewall/);
-        expect(getBlockedCount()).toBe(1);
-    });
-    it("allows localhost fetch calls when sealed", async () => {
-        const { seal } = await import("../proxy/network-firewall.js");
-        // Replace original fetch with a mock that returns a response
-        const mockFetch = vi.fn().mockResolvedValue(new Response("ok"));
-        globalThis.fetch = mockFetch;
-        // Re-import to capture the mock as originalFetch
-        // Since the module caches originalFetch at import time, we need to
-        // test with the actual seal behavior — localhost calls pass through
-        // to whatever originalFetch was at module load time.
-        // Instead, test that non-localhost is blocked and localhost is not.
-        const { unseal: unsealFirst } = await import("../proxy/network-firewall.js");
-        unsealFirst();
-        // After unseal, fetch should work normally for localhost
-        globalThis.fetch = mockFetch;
-        await fetch("http://localhost:3000/test");
-        expect(mockFetch).toHaveBeenCalled();
-    });
-    it("blocks multiple calls and tracks count", async () => {
-        const { seal, getBlockedCount, resetBlockedCount } = await import("../proxy/network-firewall.js");
-        resetBlockedCount();
-        seal();
-        const urls = [
-            "https://app.unerr.dev/api/health",
-            "https://api.anthropic.com/v1/messages",
-            "https://cloud.example.com/sync",
-        ];
-        for (const url of urls) {
-            await expect(fetch(url)).rejects.toThrow(/NetworkFirewall/);
-        }
-        expect(getBlockedCount()).toBe(3);
-    });
-    it("allowlists BYO-LLM base URLs", async () => {
-        const { seal, unseal, getBlockedCount, resetBlockedCount } = await import("../proxy/network-firewall.js");
-        unseal();
-        resetBlockedCount();
-        // Seal with an allowlisted custom LAN endpoint
-        seal(["http://my-gpu-box.local:11434"]);
-        // .local domains should pass through (they're localhost-ish)
-        // Non-allowlisted external should still be blocked
-        await expect(fetch("https://api.openai.com/v1/chat")).rejects.toThrow(/NetworkFirewall/);
-        expect(getBlockedCount()).toBe(1);
-    });
-    it("seal() is idempotent", async () => {
-        const { seal, isSealed, unseal } = await import("../proxy/network-firewall.js");
-        unseal();
-        seal();
-        const fetchAfterFirstSeal = globalThis.fetch;
-        seal(); // second call should be no-op
-        expect(globalThis.fetch).toBe(fetchAfterFirstSeal);
-        expect(isSealed()).toBe(true);
-    });
-});
-// ── 4. LocalLlmConfigSchema ─────────────────────────────────────
-describe("LocalLlmConfigSchema", () => {
-    it("parses defaults correctly", async () => {
-        const { LocalLlmConfigSchema } = await import("../config/settings.js");
-        const config = LocalLlmConfigSchema.parse({});
-        expect(config.provider).toBe("ollama");
-        expect(config.embeddingModel).toBe("nomic-embed-text");
-        expect(config.chatModel).toBe("llama3");
-        expect(config.maxConcurrency).toBe(2);
-        expect(config.embeddingDimensions).toBe(384);
-    });
-    it("accepts all valid providers", async () => {
-        const { LocalLlmConfigSchema } = await import("../config/settings.js");
-        for (const provider of [
-            "ollama",
-            "lm-studio",
-            "openai-compatible",
-            "anthropic-direct",
-        ]) {
-            const config = LocalLlmConfigSchema.parse({ provider });
-            expect(config.provider).toBe(provider);
-        }
-    });
-    it("rejects invalid provider", async () => {
-        const { LocalLlmConfigSchema } = await import("../config/settings.js");
-        expect(() => LocalLlmConfigSchema.parse({ provider: "gpt4all" })).toThrow();
-    });
-    it("accepts optional baseUrl and apiKey", async () => {
-        const { LocalLlmConfigSchema } = await import("../config/settings.js");
-        const config = LocalLlmConfigSchema.parse({
-            baseUrl: "http://localhost:11434",
-            apiKey: "sk-test-123",
-        });
-        expect(config.baseUrl).toBe("http://localhost:11434");
-        expect(config.apiKey).toBe("sk-test-123");
-    });
-});