@unerr-ai/unerr 0.1.6 → 0.1.8

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

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

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

@@ -1,53 +0,0 @@
-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

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

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