@unerr-ai/unerr 0.1.0 → 0.1.2

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)`);
+    });
+});

package/dist/__tests__/change-narrative.test.js

@@ -0,0 +1,190 @@
+/**
+ * BA-3.5: Change Impact Narrative + Agent-as-LLM Bridge tests.
+ *
+ * Verifies:
+ *   - Narrative includes all behavior signals
+ *   - Markdown well-formed
+ *   - Risk level computed correctly
+ *   - Counterfactual framing always present
+ *   - Agent-as-LLM templates, timeout, budget, follow-through
+ */
+import { describe, expect, it } from "vitest";
+import { AgentLlmBridge } from "../behaviors/agent-llm-bridge.js";
+import { ChangeNarrativeBehavior } from "../behaviors/change-narrative.js";
+function makeCtx() {
+    return {
+        toolName: "__session_end__",
+        args: {},
+        sessionId: "test-session",
+    };
+}
+// ── Change Narrative Tests ─────────────────────────────────────
+describe("Change Impact Narrative (BA-3.2)", () => {
+    describe("Behavior Identity", () => {
+        it("has correct id and hooks", () => {
+            const narrative = new ChangeNarrativeBehavior();
+            expect(narrative.id).toBe("change_narrative");
+            expect(narrative.hooks).toContain("session_end");
+            expect(narrative.defaultLevel).toBe("suggestion");
+        });
+    });
+    describe("Empty Session", () => {
+        it("returns null when no behaviors have data", async () => {
+            const narrative = new ChangeNarrativeBehavior();
+            const output = await narrative.onSessionEnd(makeCtx());
+            expect(output).toBeNull();
+        });
+    });
+    describe("Risk Level Computation", () => {
+        it("returns low risk for clean session", async () => {
+            const narrative = new ChangeNarrativeBehavior();
+            const output = await narrative.onSessionEnd(makeCtx());
+            expect(output).toBeNull();
+        });
+    });
+    describe("Counterfactual Framing", () => {
+        it("produces counterfactual for clean sessions (no issues)", async () => {
+            const narrative = new ChangeNarrativeBehavior();
+            const output = await narrative.onSessionEnd(makeCtx());
+            if (output) {
+                const ctx = output._context?.change_narrative;
+                expect(ctx.counterfactual).toContain("Clean session");
+            }
+        });
+    });
+    describe("Markdown Output", () => {
+        it("generates well-formed markdown when behaviors have data", async () => {
+            const narrative = new ChangeNarrativeBehavior();
+            const output = await narrative.onSessionEnd(makeCtx());
+            if (output) {
+                const ctx = output._context?.change_narrative;
+                expect(ctx.markdown).toContain("## Change Impact");
+            }
+        });
+    });
+});
+// ── Agent-as-LLM Bridge Tests ──────────────────────────────────
+describe("Agent-as-LLM Bridge (BA-3.3)", () => {
+    describe("Template System", () => {
+        it("lists all available templates", () => {
+            const templates = AgentLlmBridge.getTemplates();
+            expect(templates).toContain("session_resume");
+            expect(templates).toContain("doc_generation");
+            expect(templates).toContain("loop_diagnosis");
+            expect(templates).toContain("convention_fix");
+            expect(templates).toContain("cascade_fix");
+            expect(templates).toContain("architecture_alternative");
+            expect(templates.length).toBeGreaterThanOrEqual(7);
+        });
+        it("returns template definition with prefix and maxTokens", () => {
+            const def = AgentLlmBridge.getTemplateDefinition("loop_diagnosis");
+            expect(def.prefix).toContain("Analyze why");
+            expect(def.maxTokens).toBe(500);
+            expect(def.priority).toBe("high");
+        });
+        it("creates prompt with template prefix and context", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("doc_generation", "Function processPayment(amount: number, currency: string): Promise<Receipt>");
+            expect(prompt.template).toBe("doc_generation");
+            expect(prompt.content).toContain("Generate documentation");
+            expect(prompt.content).toContain("processPayment");
+            expect(prompt.priority).toBe("low");
+        });
+    });
+    describe("Timeout Handling", () => {
+        it("defaults to 5000ms timeout", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("session_resume", "test context");
+            expect(prompt.timeoutMs).toBe(5000);
+        });
+        it("accepts custom timeout", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("session_resume", "test context", {
+                timeoutMs: 3000,
+            });
+            expect(prompt.timeoutMs).toBe(3000);
+        });
+    });
+    describe("Fallback Handling", () => {
+        it("stores fallback content", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("doc_generation", "test", {
+                fallback: "AST-based docs only",
+            });
+            expect(prompt.fallbackContent).toBe("AST-based docs only");
+        });
+        it("fallback is null by default", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("doc_generation", "test");
+            expect(prompt.fallbackContent).toBeNull();
+        });
+    });
+    describe("Injection and Budget", () => {
+        it("injects prompt and tracks it", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("loop_diagnosis", "4 failed attempts on processPayment");
+            const injected = bridge.inject(prompt);
+            expect(injected).toContain("Analyze why");
+            expect(bridge.getStats().totalInjected).toBe(1);
+        });
+        it("respects per-call prompt budget", () => {
+            const bridge = new AgentLlmBridge();
+            for (let i = 0; i < 5; i++) {
+                const prompt = bridge.createPrompt("loop_diagnosis", "x".repeat(2000));
+                bridge.inject(prompt);
+            }
+            const overBudget = bridge.createPrompt("doc_generation", "x".repeat(2000));
+            const result = bridge.inject(overBudget);
+            expect(result).toBe("");
+        });
+        it("resets budget between calls", () => {
+            const bridge = new AgentLlmBridge();
+            const longContext = "x".repeat(3800);
+            const prompt1 = bridge.createPrompt("loop_diagnosis", longContext);
+            bridge.inject(prompt1);
+            bridge.resetCallBudget();
+            const prompt2 = bridge.createPrompt("doc_generation", "short context");
+            const result = bridge.inject(prompt2);
+            expect(result.length).toBeGreaterThan(0);
+        });
+    });
+    describe("Follow-Through Tracking", () => {
+        it("starts with 0% follow-through rate", () => {
+            const bridge = new AgentLlmBridge();
+            expect(bridge.getFollowThroughRate()).toBe(0);
+        });
+        it("tracks follow-through when recorded", () => {
+            const bridge = new AgentLlmBridge();
+            const prompt = bridge.createPrompt("doc_generation", "test");
+            bridge.inject(prompt);
+            const injectionId = bridge.getLastInjectionId();
+            expect(injectionId).toBeTruthy();
+            bridge.recordFollowThrough(injectionId);
+            expect(bridge.getStats().followedThrough).toBe(1);
+        });
+        it("computes follow-through rate correctly", () => {
+            const bridge = new AgentLlmBridge();
+            const p1 = bridge.createPrompt("doc_generation", "test1");
+            bridge.inject(p1);
+            const id1 = bridge.getLastInjectionId();
+            bridge.recordFollowThrough(id1);
+            bridge.resetCallBudget();
+            const p2 = bridge.createPrompt("convention_fix", "test2");
+            bridge.inject(p2);
+            expect(bridge.getFollowThroughRate()).toBe(0.5);
+        });
+    });
+    describe("Stats", () => {
+        it("tracks injections by template type", () => {
+            const bridge = new AgentLlmBridge();
+            bridge.inject(bridge.createPrompt("doc_generation", "a"));
+            bridge.resetCallBudget();
+            bridge.inject(bridge.createPrompt("doc_generation", "b"));
+            bridge.resetCallBudget();
+            bridge.inject(bridge.createPrompt("loop_diagnosis", "c"));
+            const stats = bridge.getStats();
+            expect(stats.byTemplate.doc_generation).toBe(2);
+            expect(stats.byTemplate.loop_diagnosis).toBe(1);
+        });
+    });
+});