@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/background-indexer.test.js

@@ -0,0 +1,228 @@
+/**
+ * Sprint L11 Tests: Background indexing, partial graph serving, deferred DriftTracker.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+// ── BackgroundIndexer Tests ─────────────────────────────────────
+// Mock indexLocalProject so we don't need real CozoDB or tree-sitter
+vi.mock("../intelligence/local-indexer.js", () => ({
+    indexLocalProject: vi.fn(async (_projectRoot, _graphStore, _repoId, opts) => {
+        const phases = [
+            "discovering",
+            "extracting",
+            "resolving",
+            "populating",
+            "communities",
+            "search",
+            "snapshot",
+        ];
+        for (let i = 0; i < phases.length; i++) {
+            opts?.onProgress?.({
+                processed: i + 1,
+                total: phases.length,
+                phase: phases[i],
+                currentFile: i === 1 ? "src/index.ts" : null,
+            });
+            // Yield to event loop between phases
+            await new Promise((r) => setTimeout(r, 5));
+        }
+        return {
+            fileCount: 2,
+            entityCount: 5,
+            edgeCount: 3,
+            elapsedMs: 42,
+            communityCount: 1,
+            patternCount: 3,
+            ruleCount: 2,
+        };
+    }),
+}));
+describe("BackgroundIndexer", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("starts in idle state", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        expect(indexer.getStatus()).toBe("idle");
+        expect(indexer.isIndexing()).toBe(false);
+        expect(indexer.isComplete()).toBe(false);
+        expect(indexer.getResult()).toBeNull();
+        expect(indexer.getError()).toBeNull();
+    });
+    it("transitions to indexing state immediately after start()", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => { }, () => { });
+        expect(indexer.getStatus()).toBe("indexing");
+        expect(indexer.isIndexing()).toBe(true);
+        // Wait for completion
+        await vi.waitFor(() => {
+            expect(indexer.isComplete()).toBe(true);
+        }, { timeout: 5000 });
+    });
+    it("reports progress during indexing", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        const progressSnapshots = [];
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => { }, () => { });
+        // Poll progress a few times
+        const pollInterval = setInterval(() => {
+            const p = indexer.getProgress();
+            progressSnapshots.push({
+                processed: p.processed,
+                total: p.total,
+                phase: p.phase,
+            });
+        }, 2);
+        await vi.waitFor(() => {
+            expect(indexer.isComplete()).toBe(true);
+        }, { timeout: 5000 });
+        clearInterval(pollInterval);
+        // Should have captured at least one progress snapshot
+        expect(progressSnapshots.length).toBeGreaterThan(0);
+    });
+    it("calls onComplete with IndexResult on success", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        let completedResult = null;
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", (result) => {
+            completedResult = result;
+        }, () => { });
+        await vi.waitFor(() => {
+            expect(indexer.isComplete()).toBe(true);
+        }, { timeout: 5000 });
+        expect(completedResult).not.toBeNull();
+        expect(completedResult.fileCount).toBe(2);
+        expect(completedResult.entityCount).toBe(5);
+        expect(completedResult.elapsedMs).toBe(42);
+        // Result should also be accessible via getter
+        const storedResult = indexer.getResult();
+        expect(storedResult).toEqual(completedResult);
+    });
+    it("does not start twice if already indexing", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        let callCount = 0;
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => {
+            callCount++;
+        }, () => { });
+        // Second start should be a no-op
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => {
+            callCount++;
+        }, () => { });
+        await vi.waitFor(() => {
+            expect(indexer.isComplete()).toBe(true);
+        }, { timeout: 5000 });
+        // onComplete should have been called exactly once
+        expect(callCount).toBe(1);
+    });
+    it("getElapsedMs returns positive value after completion", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => { }, () => { });
+        await vi.waitFor(() => {
+            expect(indexer.isComplete()).toBe(true);
+        }, { timeout: 5000 });
+        expect(indexer.getElapsedMs()).toBeGreaterThan(0);
+    });
+    it("getState returns full snapshot", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const state = indexer.getState();
+        expect(state.status).toBe("idle");
+        expect(state.progress.processed).toBe(0);
+        expect(state.progress.total).toBe(0);
+        expect(state.progress.pct).toBe(0);
+        expect(state.result).toBeNull();
+        expect(state.error).toBeNull();
+        expect(state.startedAt).toBeNull();
+        expect(state.completedAt).toBeNull();
+    });
+    it("handles indexing errors gracefully", async () => {
+        // Override mock to throw
+        const { indexLocalProject } = await import("../intelligence/local-indexer.js");
+        vi.mocked(indexLocalProject).mockRejectedValueOnce(new Error("tree-sitter init failed"));
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        let errorCaught = null;
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => { }, (err) => {
+            errorCaught = err;
+        });
+        await vi.waitFor(() => {
+            expect(indexer.getStatus()).toBe("error");
+        }, { timeout: 5000 });
+        expect(errorCaught).not.toBeNull();
+        expect(errorCaught.message).toBe("tree-sitter init failed");
+        expect(indexer.getError()?.message).toBe("tree-sitter init failed");
+        expect(indexer.isComplete()).toBe(false);
+        expect(indexer.isIndexing()).toBe(false);
+    });
+});
+// ── Partial Graph Query Tests ───────────────────────────────────
+describe("QueryRouter partial graph handling", () => {
+    it("returns indexing metadata when backgroundIndexer is active", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        // Create a mock indexer that stays in "indexing" state
+        const mockIndexer = new BackgroundIndexer();
+        // Manually set state to "indexing" via Object.assign on private fields
+        Object.assign(mockIndexer, {
+            _status: "indexing",
+            _processed: 150,
+            _total: 500,
+            _phase: "extracting",
+            _currentFile: "src/service.ts",
+            _startedAt: Date.now(),
+        });
+        expect(mockIndexer.isIndexing()).toBe(true);
+        const progress = mockIndexer.getProgress();
+        expect(progress.processed).toBe(150);
+        expect(progress.total).toBe(500);
+        expect(progress.pct).toBe(30);
+        expect(progress.phase).toBe("extracting");
+        expect(progress.currentFile).toBe("src/service.ts");
+    });
+});
+// ── IndexProgressEvent Tests ────────────────────────────────────
+describe("indexLocalProject onProgress callback", () => {
+    it("calls onProgress with phase transitions via mock", async () => {
+        const { indexLocalProject } = await import("../intelligence/local-indexer.js");
+        const phases = [];
+        await indexLocalProject("/tmp/test", {}, "test-repo", {
+            onProgress: (event) => {
+                if (!phases.includes(event.phase)) {
+                    phases.push(event.phase);
+                }
+            },
+        });
+        // Should have gone through all phases (via our mock)
+        expect(phases).toContain("discovering");
+        expect(phases).toContain("extracting");
+        expect(phases).toContain("resolving");
+        expect(phases).toContain("populating");
+        expect(phases).toContain("communities");
+        expect(phases).toContain("search");
+        expect(phases).toContain("snapshot");
+    });
+    it("reports file count in extracting phase", async () => {
+        const { indexLocalProject } = await import("../intelligence/local-indexer.js");
+        let maxProcessed = 0;
+        let totalReported = 0;
+        await indexLocalProject("/tmp/test", {}, "test-repo", {
+            onProgress: (event) => {
+                if (event.phase === "extracting") {
+                    maxProcessed = Math.max(maxProcessed, event.processed);
+                    totalReported = event.total;
+                }
+            },
+        });
+        // Should have processed and reported totals
+        expect(totalReported).toBeGreaterThan(0);
+        expect(maxProcessed).toBeGreaterThan(0);
+    });
+});

package/dist/__tests__/blast-radius-engine.test.js

@@ -0,0 +1,200 @@
+/**
+ * Sprint N.7-N.8: Blast radius accuracy + performance tests.
+ */
+import { describe, expect, it } from "vitest";
+import { buildReverseAdjacency, computeBlastRadius, computeFileBlastRadius, } from "../intelligence/blast-radius.js";
+import { entityKey } from "../intelligence/indexer/entity-key.js";
+function makeEntity(name, filePath) {
+    return {
+        key: entityKey(filePath, "function", name, ""),
+        kind: "function",
+        name,
+        file_path: filePath,
+        start_line: 1,
+        end_line: 5,
+        signature: `${name}()`,
+        body_hash: "h",
+        exported: true,
+        parent_key: null,
+        language: "typescript",
+        is_async: false,
+        parameter_count: 0,
+        doc: null,
+        community: 0,
+        risk_level: "normal",
+    };
+}
+describe("Blast Radius Engine (N.1-N.5)", () => {
+    it("returns all direct callers at hop=1", () => {
+        const target = makeEntity("target", "src/core.ts");
+        const callers = Array.from({ length: 10 }, (_, i) => makeEntity(`caller${i}`, `src/caller${i}.ts`));
+        const entities = new Map([
+            [target.key, target],
+            ...callers.map((c) => [c.key, c]),
+        ]);
+        const edges = callers.map((c) => ({
+            from_key: c.key,
+            to_key: target.key,
+            type: "calls",
+            file_path: c.file_path,
+            line: 1,
+        }));
+        const adj = buildReverseAdjacency(edges);
+        const result = computeBlastRadius(target.key, entities, adj);
+        expect(result.totalAffected).toBe(10);
+        expect(result.hops.get(1)?.length).toBe(10);
+    });
+    it("traverses 3 hops transitively", () => {
+        const a = makeEntity("a", "src/a.ts");
+        const b = makeEntity("b", "src/b.ts");
+        const c = makeEntity("c", "src/c.ts");
+        const d = makeEntity("d", "src/d.ts");
+        const entities = new Map([
+            [a.key, a],
+            [b.key, b],
+            [c.key, c],
+            [d.key, d],
+        ]);
+        const edges = [
+            {
+                from_key: b.key,
+                to_key: a.key,
+                type: "calls",
+                file_path: "b.ts",
+                line: 1,
+            },
+            {
+                from_key: c.key,
+                to_key: b.key,
+                type: "calls",
+                file_path: "c.ts",
+                line: 1,
+            },
+            {
+                from_key: d.key,
+                to_key: c.key,
+                type: "calls",
+                file_path: "d.ts",
+                line: 1,
+            },
+        ];
+        const adj = buildReverseAdjacency(edges);
+        const result = computeBlastRadius(a.key, entities, adj, { maxHops: 3 });
+        expect(result.hops.get(1)?.length).toBe(1);
+        expect(result.hops.get(2)?.length).toBe(1);
+        expect(result.hops.get(3)?.length).toBe(1);
+        expect(result.totalAffected).toBe(3);
+    });
+    it("generates suggestions for critical entities", () => {
+        const target = makeEntity("hub", "src/hub.ts");
+        const critical = {
+            ...makeEntity("crit", "src/crit.ts"),
+            risk_level: "critical",
+        };
+        const entities = new Map([
+            [target.key, target],
+            [critical.key, critical],
+        ]);
+        const edges = [
+            {
+                from_key: critical.key,
+                to_key: target.key,
+                type: "calls",
+                file_path: "crit.ts",
+                line: 1,
+            },
+        ];
+        const adj = buildReverseAdjacency(edges);
+        const result = computeBlastRadius(target.key, entities, adj);
+        expect(result.riskSummary.critical).toBe(1);
+        expect(result.suggestions.some((s) => s.includes("overload") || s.includes("adapter"))).toBe(true);
+    });
+    it("file-level blast radius returns entities in other files", () => {
+        const internal1 = makeEntity("fn1", "src/target.ts");
+        const internal2 = makeEntity("fn2", "src/target.ts");
+        const external = makeEntity("caller", "src/other.ts");
+        const entities = new Map([
+            [internal1.key, internal1],
+            [internal2.key, internal2],
+            [external.key, external],
+        ]);
+        const edges = [
+            {
+                from_key: external.key,
+                to_key: internal1.key,
+                type: "calls",
+                file_path: "other.ts",
+                line: 1,
+            },
+        ];
+        const adj = buildReverseAdjacency(edges);
+        const result = computeFileBlastRadius("src/target.ts", entities, adj);
+        expect(result.totalAffected).toBe(1);
+        expect(result.affectedFiles).toContain("src/other.ts");
+        expect(result.affectedFiles).not.toContain("src/target.ts");
+    });
+    it("handles entity with no callers", () => {
+        const target = makeEntity("isolated", "src/isolated.ts");
+        const entities = new Map([[target.key, target]]);
+        const adj = buildReverseAdjacency([]);
+        const result = computeBlastRadius(target.key, entities, adj);
+        expect(result.totalAffected).toBe(0);
+        expect(result.hops.size).toBe(0);
+    });
+    it("respects maxResults limit", () => {
+        const target = makeEntity("popular", "src/pop.ts");
+        const callers = Array.from({ length: 600 }, (_, i) => makeEntity(`c${i}`, `src/c${i}.ts`));
+        const entities = new Map([
+            [target.key, target],
+            ...callers.map((c) => [c.key, c]),
+        ]);
+        const edges = callers.map((c) => ({
+            from_key: c.key,
+            to_key: target.key,
+            type: "calls",
+            file_path: c.file_path,
+            line: 1,
+        }));
+        const adj = buildReverseAdjacency(edges);
+        const result = computeBlastRadius(target.key, entities, adj, {
+            maxResults: 100,
+        });
+        expect(result.totalAffected).toBeLessThanOrEqual(100);
+    });
+    it("completes in <5ms for large graphs", () => {
+        const target = makeEntity("center", "src/center.ts");
+        const allEntities = [target];
+        const allEdges = [];
+        for (let i = 0; i < 200; i++) {
+            const hop1 = makeEntity(`h1_${i}`, `src/h1_${i}.ts`);
+            allEntities.push(hop1);
+            allEdges.push({
+                from_key: hop1.key,
+                to_key: target.key,
+                type: "calls",
+                file_path: hop1.file_path,
+                line: 1,
+            });
+            for (let j = 0; j < 5; j++) {
+                const hop2 = makeEntity(`h2_${i}_${j}`, `src/h2_${i}_${j}.ts`);
+                allEntities.push(hop2);
+                allEdges.push({
+                    from_key: hop2.key,
+                    to_key: hop1.key,
+                    type: "calls",
+                    file_path: hop2.file_path,
+                    line: 1,
+                });
+            }
+        }
+        const entities = new Map(allEntities.map((e) => [e.key, e]));
+        const adj = buildReverseAdjacency(allEdges);
+        const start = performance.now();
+        const result = computeBlastRadius(target.key, entities, adj, {
+            maxHops: 3,
+        });
+        const elapsed = performance.now() - start;
+        expect(result.totalAffected).toBeGreaterThan(100);
+        expect(elapsed).toBeLessThan(5);
+    });
+});

package/dist/__tests__/bridge-isolation.test.js

@@ -0,0 +1,37 @@
+/**
+ * Layer 12 DM-0 invariant: `src/proxy/bridge.ts` must remain a pure stdio↔UDS
+ * relay. It owns no intelligence — the per-repo `unerr` process does.
+ *
+ * Static-analysis test: re-grepping the bridge source on every CI run is the
+ * cheapest, hardest-to-cheat guard against accidental re-entanglement.
+ */
+import { readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+const BRIDGE_PATH = resolve(__dirname, "../proxy/bridge.ts");
+describe("bridge isolation (DM-0)", () => {
+    const source = readFileSync(BRIDGE_PATH, "utf-8");
+    it("imports nothing from src/intelligence/", () => {
+        // Match both static and dynamic imports at any depth of relative path.
+        const intelligence = /(?:from|import\()\s*["'][^"']*\/intelligence\//;
+        expect(source).not.toMatch(intelligence);
+    });
+    it("imports nothing from src/behaviors/", () => {
+        const behaviors = /(?:from|import\()\s*["'][^"']*\/behaviors\//;
+        expect(source).not.toMatch(behaviors);
+    });
+    it("imports nothing from src/tracking/", () => {
+        // Tier-2 modules (shadow ledger, token flow, persistence effectiveness)
+        // also belong on the per-repo side, not in the bridge.
+        const tracking = /(?:from|import\()\s*["'][^"']*\/tracking\//;
+        expect(source).not.toMatch(tracking);
+    });
+    it("stays under the 200-LOC budget", () => {
+        const lines = source.split("\n").length;
+        expect(lines).toBeLessThanOrEqual(200);
+    });
+    it("file is small (sanity: a relay should be a few KB, not megabytes)", () => {
+        const { size } = statSync(BRIDGE_PATH);
+        expect(size).toBeLessThan(20_000); // 20 KB ceiling
+    });
+});

package/dist/__tests__/budget-enforcer.test.js

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { enforceBudget, isStructuredContent, } from "../proxy/budget-enforcer.js";
+describe("enforceBudget", () => {
+    it("passes through content within budget", () => {
+        const content = "short content";
+        const result = enforceBudget(content, 1000);
+        expect(result.content).toBe(content);
+        expect(result.truncated).toBe(false);
+        expect(result.deliveredTokens).toBe(result.originalTokens);
+    });
+    it("truncates content exceeding budget", () => {
+        const content = Array.from({ length: 500 }, (_, i) => `Line ${i}: some content here that takes up space`).join("\n");
+        const result = enforceBudget(content, 200);
+        expect(result.truncated).toBe(true);
+        expect(result.deliveredTokens).toBeLessThan(result.originalTokens);
+        expect(result.content).toContain("[...");
+        expect(result.content).toContain("truncated");
+    });
+    it("preserves head and tail of truncated content", () => {
+        const lines = Array.from({ length: 100 }, (_, i) => `Line ${i}`);
+        const content = lines.join("\n");
+        const result = enforceBudget(content, 100);
+        expect(result.content).toContain("Line 0");
+        expect(result.content).toContain("Line 99");
+    });
+    it("uses default budget of 4000 tokens", () => {
+        const small = "hello world";
+        const result = enforceBudget(small);
+        expect(result.truncated).toBe(false);
+    });
+    it("reports original and delivered token counts", () => {
+        const content = Array.from({ length: 200 }, (_, i) => `Data line ${i} with some padding text`).join("\n");
+        const result = enforceBudget(content, 100);
+        expect(result.originalTokens).toBeGreaterThan(100);
+        expect(result.deliveredTokens).toBeLessThanOrEqual(result.originalTokens);
+    });
+});
+describe("isStructuredContent", () => {
+    it("returns true for JSON objects", () => {
+        expect(isStructuredContent('{"key": "value"}')).toBe(true);
+    });
+    it("returns true for non-string values", () => {
+        expect(isStructuredContent({ key: "value" })).toBe(true);
+        expect(isStructuredContent(42)).toBe(true);
+        expect(isStructuredContent(null)).toBe(true);
+    });
+    it("returns false for plain text", () => {
+        expect(isStructuredContent("hello world")).toBe(false);
+    });
+    it("returns false for invalid JSON", () => {
+        expect(isStructuredContent("{not valid json}")).toBe(false);
+    });
+});

package/dist/__tests__/cfg-test-detection-perf.test.js

@@ -0,0 +1,82 @@
+/**
+ * Performance benchmark: Rust #[cfg(test)] detection overhead.
+ *
+ * Verifies that AST-level test scope detection adds <50ms overhead
+ * for a representative Rust project (1000 entities across multiple files).
+ */
+import { describe, expect, it } from "vitest";
+import { extractEntities } from "../intelligence/ast-extractor.js";
+/**
+ * Generate a synthetic Rust file with N functions, some inside #[cfg(test)] modules.
+ */
+function generateRustFile(fnCount, withCfgTest) {
+    const lines = [];
+    const prodCount = Math.floor(fnCount * 0.7);
+    const testCount = fnCount - prodCount;
+    // Production functions
+    for (let i = 0; i < prodCount; i++) {
+        lines.push(`pub fn prod_fn_${i}(x: i32) -> i32 {`);
+        lines.push(`    x + ${i}`);
+        lines.push("}");
+        lines.push("");
+    }
+    if (withCfgTest) {
+        lines.push("#[cfg(test)]");
+        lines.push("mod tests {");
+        for (let i = 0; i < testCount; i++) {
+            lines.push("    #[test]");
+            lines.push(`    fn test_fn_${i}() {`);
+            lines.push(`        assert_eq!(prod_fn_${i}(1), ${i + 1});`);
+            lines.push("    }");
+            lines.push("");
+        }
+        lines.push("}");
+    }
+    return lines.join("\n");
+}
+describe("Rust #[cfg(test)] detection performance", () => {
+    it("extracts entities from 50 Rust files (1000+ entities) in <50ms", () => {
+        // Generate 50 files × 20 functions each = 1000 entities
+        const files = [];
+        for (let i = 0; i < 50; i++) {
+            files.push({
+                content: generateRustFile(20, i % 2 === 0), // Half have cfg(test)
+                path: `src/module_${i}.rs`,
+            });
+        }
+        const start = performance.now();
+        let totalEntities = 0;
+        let testEntities = 0;
+        for (const file of files) {
+            const entities = extractEntities(file.content, file.path);
+            totalEntities += entities.length;
+            testEntities += entities.filter((e) => e.is_test).length;
+        }
+        const elapsed = performance.now() - start;
+        // Should extract a meaningful number of entities
+        expect(totalEntities).toBeGreaterThan(500);
+        // Performance: regex extraction of 1000+ entities must be <50ms
+        expect(elapsed).toBeLessThan(50);
+        // Verify test detection works (files with cfg(test) modules produce test entities via regex)
+        // Note: regex-based extraction doesn't detect cfg(test) — only tree-sitter AST does.
+        // The regex path relies on file-level isTestFile() for is_test marking.
+        // This benchmark validates that regex extraction overhead is negligible.
+        console.error(`  Extracted ${totalEntities} entities (${testEntities} marked test) from ${files.length} files in ${elapsed.toFixed(2)}ms`);
+    });
+    it("regex extraction adds negligible overhead for is_test field", () => {
+        const content = generateRustFile(100, true);
+        // Warm up
+        extractEntities(content, "src/lib.rs");
+        // Benchmark: 100 iterations
+        const iterations = 100;
+        const start = performance.now();
+        for (let i = 0; i < iterations; i++) {
+            extractEntities(content, `src/mod_${i}.rs`);
+        }
+        const elapsed = performance.now() - start;
+        const perFile = elapsed / iterations;
+        // Each file extraction should be <0.5ms (regex is fast)
+        expect(perFile).toBeLessThan(0.5);
+        console.error(`  Per-file extraction: ${perFile.toFixed(3)}ms (${iterations} iterations, ${elapsed.toFixed(2)}ms total)`);
+    });
+});