@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/git-attribution.test.js

@@ -1,259 +0,0 @@
-/**
- * Tests for Git-Native Attribution — Phase 5.5 §1.5
- */
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { buildCommitMessageWithTrailers, buildGitNotePayload, readAttributionFromManifest, } from "../tracking/git-attribution.js";
-function makeAttribution(overrides) {
-    return {
-        sessionId: "sess-abc-123",
-        ledgerEntryIds: ["entry-1", "entry-2"],
-        prompt: "Add user authentication",
-        planSummary: "Implement OAuth2 flow with Google provider",
-        changeType: "feat",
-        featureArea: "auth/oauth",
-        agentModel: "claude-sonnet-4",
-        agentTool: "cursor",
-        filesChanged: ["src/auth/oauth.ts", "src/auth/types.ts"],
-        ...overrides,
-    };
-}
-describe("git-attribution", () => {
-    // ── buildCommitMessageWithTrailers ──────────────────────────
-    describe("buildCommitMessageWithTrailers", () => {
-        it("appends session trailer to commit message", () => {
-            const result = buildCommitMessageWithTrailers("feat: add login", makeAttribution());
-            expect(result).toContain("Unerr-Session: sess-abc-123");
-        });
-        it("includes ledger ID trailer (first entry only)", () => {
-            const result = buildCommitMessageWithTrailers("feat: add login", makeAttribution());
-            expect(result).toContain("Unerr-Ledger-Id: entry-1");
-            expect(result).not.toContain("entry-2");
-        });
-        it("includes change type trailer", () => {
-            const result = buildCommitMessageWithTrailers("feat: add login", makeAttribution());
-            expect(result).toContain("Unerr-Change-Type: feat");
-        });
-        it("includes feature area trailer", () => {
-            const result = buildCommitMessageWithTrailers("feat: add login", makeAttribution());
-            expect(result).toContain("Unerr-Feature: auth/oauth");
-        });
-        it("includes plan summary trailer", () => {
-            const result = buildCommitMessageWithTrailers("feat: add login", makeAttribution());
-            expect(result).toContain("Unerr-Plan: Implement OAuth2 flow with Google provider");
-        });
-        it("truncates plan summary to 72 chars", () => {
-            const longPlan = "A".repeat(100);
-            const result = buildCommitMessageWithTrailers("feat: add login", makeAttribution({ planSummary: longPlan }));
-            expect(result).toContain(`Unerr-Plan: ${"A".repeat(69)}...`);
-        });
-        it("does not truncate plan exactly 72 chars", () => {
-            const exactPlan = "B".repeat(72);
-            const result = buildCommitMessageWithTrailers("feat: add login", makeAttribution({ planSummary: exactPlan }));
-            expect(result).toContain(`Unerr-Plan: ${"B".repeat(72)}`);
-            expect(result).not.toContain("...");
-        });
-        it("includes agent model and tool trailers", () => {
-            const result = buildCommitMessageWithTrailers("feat: add login", makeAttribution());
-            expect(result).toContain("Unerr-Agent-Model: claude-sonnet-4");
-            expect(result).toContain("Unerr-Agent-Tool: cursor");
-        });
-        it("separates trailers from message body with blank line", () => {
-            const result = buildCommitMessageWithTrailers("feat: add login", makeAttribution());
-            expect(result).toMatch(/feat: add login\n\nUnerr-Session:/);
-        });
-        it("omits optional trailers when values are undefined", () => {
-            const result = buildCommitMessageWithTrailers("chore: cleanup", makeAttribution({
-                changeType: undefined,
-                featureArea: undefined,
-                planSummary: undefined,
-                agentModel: undefined,
-                agentTool: undefined,
-            }));
-            expect(result).toContain("Unerr-Session:");
-            expect(result).toContain("Unerr-Ledger-Id:");
-            expect(result).not.toContain("Unerr-Change-Type:");
-            expect(result).not.toContain("Unerr-Feature:");
-            expect(result).not.toContain("Unerr-Plan:");
-            expect(result).not.toContain("Unerr-Agent-Model:");
-            expect(result).not.toContain("Unerr-Agent-Tool:");
-        });
-        it("omits ledger ID trailer when no entry IDs", () => {
-            const result = buildCommitMessageWithTrailers("chore: cleanup", makeAttribution({ ledgerEntryIds: [] }));
-            expect(result).not.toContain("Unerr-Ledger-Id:");
-        });
-    });
-    // ── buildGitNotePayload ────────────────────────────────────
-    describe("buildGitNotePayload", () => {
-        it("returns version 1.0", () => {
-            const payload = buildGitNotePayload(makeAttribution());
-            expect(payload.version).toBe("1.0");
-        });
-        it("maps attribution fields to snake_case payload", () => {
-            const payload = buildGitNotePayload(makeAttribution());
-            expect(payload.session_id).toBe("sess-abc-123");
-            expect(payload.ledger_entry_ids).toEqual(["entry-1", "entry-2"]);
-            expect(payload.prompt).toBe("Add user authentication");
-            expect(payload.plan_summary).toBe("Implement OAuth2 flow with Google provider");
-            expect(payload.change_type).toBe("feat");
-            expect(payload.feature_area).toBe("auth/oauth");
-            expect(payload.agent_model).toBe("claude-sonnet-4");
-            expect(payload.agent_tool).toBe("cursor");
-            expect(payload.files_changed).toEqual([
-                "src/auth/oauth.ts",
-                "src/auth/types.ts",
-            ]);
-        });
-        it("sets entities_affected to empty array (resolved server-side)", () => {
-            const payload = buildGitNotePayload(makeAttribution());
-            expect(payload.entities_affected).toEqual([]);
-        });
-        it("includes ISO 8601 created_at timestamp", () => {
-            const before = new Date().toISOString();
-            const payload = buildGitNotePayload(makeAttribution());
-            const after = new Date().toISOString();
-            expect(payload.created_at >= before).toBe(true);
-            expect(payload.created_at <= after).toBe(true);
-        });
-        it("handles missing optional fields", () => {
-            const payload = buildGitNotePayload(makeAttribution({
-                planSummary: undefined,
-                changeType: undefined,
-                featureArea: undefined,
-                agentModel: undefined,
-                agentTool: undefined,
-            }));
-            expect(payload.plan_summary).toBeUndefined();
-            expect(payload.change_type).toBeUndefined();
-            expect(payload.feature_area).toBeUndefined();
-            expect(payload.agent_model).toBeUndefined();
-            expect(payload.agent_tool).toBeUndefined();
-        });
-        it("produces valid JSON when serialized", () => {
-            const payload = buildGitNotePayload(makeAttribution());
-            const json = JSON.stringify(payload, null, 2);
-            const parsed = JSON.parse(json);
-            expect(parsed).toHaveProperty("version", "1.0");
-            expect(parsed).toHaveProperty("session_id", "sess-abc-123");
-        });
-    });
-    // ── readAttributionFromManifest ────────────────────────────
-    describe("readAttributionFromManifest", () => {
-        let tempDir;
-        beforeEach(() => {
-            tempDir = join(tmpdir(), `unerr-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-            mkdirSync(join(tempDir, ".unerr"), { recursive: true });
-        });
-        afterEach(() => {
-            try {
-                rmSync(tempDir, { recursive: true, force: true });
-            }
-            catch {
-                /* ignore cleanup errors */
-            }
-        });
-        it("returns null when manifest does not exist", () => {
-            const result = readAttributionFromManifest(join(tmpdir(), "nonexistent"));
-            expect(result).toBeNull();
-        });
-        it("returns null when manifest has no sessionId", () => {
-            writeFileSync(join(tempDir, ".unerr", "manifest.json"), JSON.stringify({ attributions: [{ prompt: "test" }] }));
-            expect(readAttributionFromManifest(tempDir)).toBeNull();
-        });
-        it("returns null when manifest has no attributions", () => {
-            writeFileSync(join(tempDir, ".unerr", "manifest.json"), JSON.stringify({ sessionId: "sess-1", attributions: [] }));
-            expect(readAttributionFromManifest(tempDir)).toBeNull();
-        });
-        it("returns null for invalid JSON", () => {
-            writeFileSync(join(tempDir, ".unerr", "manifest.json"), "not json {{{");
-            expect(readAttributionFromManifest(tempDir)).toBeNull();
-        });
-        it("reads a single attribution", () => {
-            writeFileSync(join(tempDir, ".unerr", "manifest.json"), JSON.stringify({
-                sessionId: "sess-xyz",
-                attributions: [
-                    {
-                        prompt: "Add login",
-                        planSummary: "OAuth flow",
-                        changeType: "feat",
-                        featureArea: "auth",
-                        agentModel: "claude-sonnet-4",
-                        agentTool: "cursor",
-                        filesChanged: ["src/auth.ts"],
-                        ledgerEntryIds: ["le-1"],
-                    },
-                ],
-            }));
-            const result = readAttributionFromManifest(tempDir);
-            expect(result).not.toBeNull();
-            expect(result?.sessionId).toBe("sess-xyz");
-            expect(result?.prompt).toBe("Add login");
-            expect(result?.planSummary).toBe("OAuth flow");
-            expect(result?.changeType).toBe("feat");
-            expect(result?.featureArea).toBe("auth");
-            expect(result?.agentModel).toBe("claude-sonnet-4");
-            expect(result?.agentTool).toBe("cursor");
-            expect(result?.filesChanged).toEqual(["src/auth.ts"]);
-            expect(result?.ledgerEntryIds).toEqual(["le-1"]);
-        });
-        it("merges multiple attributions into a single context", () => {
-            writeFileSync(join(tempDir, ".unerr", "manifest.json"), JSON.stringify({
-                sessionId: "sess-multi",
-                attributions: [
-                    {
-                        prompt: "Add login",
-                        filesChanged: ["src/auth/login.ts"],
-                        ledgerEntryIds: ["le-1"],
-                        changeType: "feat",
-                    },
-                    {
-                        prompt: "Add signup",
-                        filesChanged: ["src/auth/signup.ts", "src/auth/login.ts"],
-                        ledgerEntryIds: ["le-2"],
-                        changeType: "fix",
-                        planSummary: "Fix the signup flow",
-                    },
-                ],
-            }));
-            const result = readAttributionFromManifest(tempDir);
-            expect(result).not.toBeNull();
-            expect(result?.sessionId).toBe("sess-multi");
-            // Prompts joined with arrow
-            expect(result?.prompt).toBe("Add login → Add signup");
-            // Files are deduped
-            expect(result?.filesChanged).toHaveLength(2);
-            expect(result?.filesChanged).toContain("src/auth/login.ts");
-            expect(result?.filesChanged).toContain("src/auth/signup.ts");
-            // Entry IDs are deduped
-            expect(result?.ledgerEntryIds).toEqual(["le-1", "le-2"]);
-            // Uses latest attribution's metadata
-            expect(result?.changeType).toBe("fix");
-            expect(result?.planSummary).toBe("Fix the signup flow");
-        });
-        it("deduplicates ledger entry IDs", () => {
-            writeFileSync(join(tempDir, ".unerr", "manifest.json"), JSON.stringify({
-                sessionId: "sess-dedup",
-                attributions: [
-                    { prompt: "First", ledgerEntryIds: ["le-1", "le-2"] },
-                    { prompt: "Second", ledgerEntryIds: ["le-2", "le-3"] },
-                ],
-            }));
-            const result = readAttributionFromManifest(tempDir);
-            expect(result?.ledgerEntryIds).toEqual(["le-1", "le-2", "le-3"]);
-        });
-        it("handles attributions with missing optional fields", () => {
-            writeFileSync(join(tempDir, ".unerr", "manifest.json"), JSON.stringify({
-                sessionId: "sess-minimal",
-                attributions: [{ prompt: "Just a prompt" }],
-            }));
-            const result = readAttributionFromManifest(tempDir);
-            expect(result).not.toBeNull();
-            expect(result?.sessionId).toBe("sess-minimal");
-            expect(result?.prompt).toBe("Just a prompt");
-            expect(result?.ledgerEntryIds).toEqual([]);
-            expect(result?.filesChanged).toEqual([]);
-        });
-    });
-});

package/dist/__tests__/graph-temporal-joiner.test.js

@@ -1,219 +0,0 @@
-// @ts-nocheck — test file
-/**
- * GraphTemporalJoiner tests — co-change prediction, hidden coupling detection.
- */
-import { describe, expect, it, vi } from "vitest";
-import { GraphTemporalJoiner } from "../intelligence/graph-temporal-joiner.js";
-function createMockGraph(fileEntities, callerMap, calleeMap) {
-    return {
-        getEntitiesByFile: vi.fn((filePath) => Promise.resolve(fileEntities[filePath] ?? [])),
-        getCallersOf: vi.fn((key) => Promise.resolve(callerMap[key] ?? [])),
-        getCalleesOf: vi.fn((key) => Promise.resolve(calleeMap[key] ?? [])),
-    };
-}
-function createMockFactStore(facts) {
-    return {
-        recallBySubject: vi.fn((subject) => Promise.resolve(facts.filter((f) => f.subject === subject || f.subject.startsWith(subject)))),
-        recallByScope: vi.fn((scope) => Promise.resolve(facts.filter((f) => f.scope === scope))),
-    };
-}
-describe("GraphTemporalJoiner", () => {
-    describe("predictCoChanges", () => {
-        it("returns co-changes from graph structure only", async () => {
-            const graph = createMockGraph({
-                "src/a.ts": [{ key: "fnA", file_path: "src/a.ts" }],
-            }, {
-                fnA: [
-                    { key: "fnB", file_path: "src/b.ts" },
-                    { key: "fnC", file_path: "src/c.ts" },
-                ],
-            }, { fnA: [] });
-            const joiner = new GraphTemporalJoiner(graph, null);
-            const results = await joiner.predictCoChanges("src/a.ts");
-            expect(results.length).toBeGreaterThan(0);
-            expect(results[0].file_a).toBe("src/a.ts");
-            expect(results[0].graph_coupling).toBeGreaterThan(0);
-            expect(results[0].temporal_coupling).toBe(0);
-            // With no temporal data, combined = 0.4 * graph
-            expect(results[0].combined_score).toBeGreaterThan(0);
-        });
-        it("returns co-changes from temporal data only", async () => {
-            const graph = createMockGraph({}, {}, {});
-            const factStore = createMockFactStore([
-                {
-                    fact_type: "semantic",
-                    scope: "project",
-                    subject: "coupling:src/a.ts↔src/d.ts",
-                    content: "Files co-accessed in 5 sessions",
-                    base_confidence: 0.8,
-                },
-            ]);
-            const joiner = new GraphTemporalJoiner(graph, factStore);
-            const results = await joiner.predictCoChanges("src/a.ts");
-            // Temporal-only: combined = 0.6 * 0.8 = 0.48
-            expect(results.length).toBeGreaterThan(0);
-            expect(results[0].file_b).toBe("src/d.ts");
-            expect(results[0].temporal_coupling).toBe(0.8);
-            expect(results[0].graph_coupling).toBe(0);
-            expect(results[0].combined_score).toBeCloseTo(0.48, 1);
-        });
-        it("combines graph and temporal signals", async () => {
-            const graph = createMockGraph({
-                "src/a.ts": [{ key: "fnA", file_path: "src/a.ts" }],
-            }, {
-                fnA: [{ key: "fnB", file_path: "src/b.ts" }],
-            }, { fnA: [] });
-            const factStore = createMockFactStore([
-                {
-                    fact_type: "semantic",
-                    scope: "project",
-                    subject: "coupling:src/a.ts↔src/b.ts",
-                    content: "Files co-accessed in 3 sessions",
-                    base_confidence: 0.7,
-                },
-            ]);
-            const joiner = new GraphTemporalJoiner(graph, factStore);
-            const results = await joiner.predictCoChanges("src/a.ts");
-            expect(results.length).toBe(1);
-            expect(results[0].file_b).toBe("src/b.ts");
-            expect(results[0].graph_coupling).toBeGreaterThan(0);
-            expect(results[0].temporal_coupling).toBe(0.7);
-            // Combined should be > either alone
-            expect(results[0].combined_score).toBeGreaterThan(0.6 * results[0].temporal_coupling);
-        });
-        it("filters out low-score noise (< 0.1)", async () => {
-            const graph = createMockGraph({}, {}, {});
-            const factStore = createMockFactStore([
-                {
-                    fact_type: "semantic",
-                    scope: "project",
-                    subject: "coupling:src/a.ts↔src/noise.ts",
-                    content: "1 session",
-                    base_confidence: 0.05,
-                },
-            ]);
-            const joiner = new GraphTemporalJoiner(graph, factStore);
-            const results = await joiner.predictCoChanges("src/a.ts");
-            // 0.6 * 0.05 = 0.03 < 0.1 threshold
-            expect(results).toHaveLength(0);
-        });
-        it("returns empty for files with no connections", async () => {
-            const graph = createMockGraph({}, {}, {});
-            const joiner = new GraphTemporalJoiner(graph, null);
-            const results = await joiner.predictCoChanges("src/isolated.ts");
-            expect(results).toHaveLength(0);
-        });
-        it("excludes self-references", async () => {
-            const graph = createMockGraph({
-                "src/a.ts": [{ key: "fnA", file_path: "src/a.ts" }],
-            }, {
-                fnA: [{ key: "fnA2", file_path: "src/a.ts" }],
-            }, { fnA: [] });
-            const joiner = new GraphTemporalJoiner(graph, null);
-            const results = await joiner.predictCoChanges("src/a.ts");
-            expect(results.every((r) => r.file_b !== "src/a.ts")).toBe(true);
-        });
-        it("sorts results by combined_score descending", async () => {
-            const graph = createMockGraph({
-                "src/a.ts": [{ key: "fnA", file_path: "src/a.ts" }],
-            }, {
-                fnA: [
-                    { key: "fnB", file_path: "src/b.ts" },
-                    { key: "fnC", file_path: "src/c.ts" },
-                ],
-            }, {
-                fnA: [{ key: "fnD", file_path: "src/b.ts" }],
-            });
-            const joiner = new GraphTemporalJoiner(graph, null);
-            const results = await joiner.predictCoChanges("src/a.ts");
-            for (let i = 1; i < results.length; i++) {
-                expect(results[i - 1].combined_score).toBeGreaterThanOrEqual(results[i].combined_score);
-            }
-        });
-    });
-    describe("detectHiddenCouplings", () => {
-        it("detects files with temporal coupling but no graph edges", async () => {
-            const graph = createMockGraph({}, {}, {});
-            const factStore = createMockFactStore([
-                {
-                    fact_type: "semantic",
-                    scope: "project",
-                    subject: "coupling:src/config.ts↔src/deploy.ts",
-                    content: "Files co-accessed in 5 sessions",
-                    base_confidence: 0.8,
-                },
-            ]);
-            const joiner = new GraphTemporalJoiner(graph, factStore);
-            const hidden = await joiner.detectHiddenCouplings();
-            expect(hidden).toHaveLength(1);
-            expect(hidden[0].file_a).toBe("src/config.ts");
-            expect(hidden[0].file_b).toBe("src/deploy.ts");
-            expect(hidden[0].temporal_coupling).toBe(0.8);
-            expect(hidden[0].graph_coupling).toBeLessThan(0.1);
-            expect(hidden[0].sessions_observed).toBe(5);
-            expect(hidden[0].evidence).toContain("no import/call edges");
-        });
-        it("excludes files with structural connections", async () => {
-            const graph = createMockGraph({
-                "src/a.ts": [{ key: "fnA", file_path: "src/a.ts" }],
-            }, { fnA: [{ key: "fnB", file_path: "src/b.ts" }] }, { fnA: [] });
-            const factStore = createMockFactStore([
-                {
-                    fact_type: "semantic",
-                    scope: "project",
-                    subject: "coupling:src/a.ts↔src/b.ts",
-                    content: "Files co-accessed in 4 sessions",
-                    base_confidence: 0.7,
-                },
-            ]);
-            const joiner = new GraphTemporalJoiner(graph, factStore);
-            const hidden = await joiner.detectHiddenCouplings();
-            // src/a.ts → src/b.ts has a structural connection, so NOT hidden
-            expect(hidden).toHaveLength(0);
-        });
-        it("ignores low-confidence temporal couplings", async () => {
-            const graph = createMockGraph({}, {}, {});
-            const factStore = createMockFactStore([
-                {
-                    fact_type: "semantic",
-                    scope: "project",
-                    subject: "coupling:src/x.ts↔src/y.ts",
-                    content: "1 session",
-                    base_confidence: 0.3, // Below 0.5 threshold
-                },
-            ]);
-            const joiner = new GraphTemporalJoiner(graph, factStore);
-            const hidden = await joiner.detectHiddenCouplings();
-            expect(hidden).toHaveLength(0);
-        });
-        it("returns empty when no fact store", async () => {
-            const graph = createMockGraph({}, {}, {});
-            const joiner = new GraphTemporalJoiner(graph, null);
-            const hidden = await joiner.detectHiddenCouplings();
-            expect(hidden).toHaveLength(0);
-        });
-        it("sorts by temporal_coupling descending", async () => {
-            const graph = createMockGraph({}, {}, {});
-            const factStore = createMockFactStore([
-                {
-                    fact_type: "semantic",
-                    scope: "project",
-                    subject: "coupling:src/a.ts↔src/b.ts",
-                    content: "3 sessions",
-                    base_confidence: 0.6,
-                },
-                {
-                    fact_type: "semantic",
-                    scope: "project",
-                    subject: "coupling:src/c.ts↔src/d.ts",
-                    content: "7 sessions",
-                    base_confidence: 0.9,
-                },
-            ]);
-            const joiner = new GraphTemporalJoiner(graph, factStore);
-            const hidden = await joiner.detectHiddenCouplings();
-            expect(hidden.length).toBe(2);
-            expect(hidden[0].temporal_coupling).toBeGreaterThanOrEqual(hidden[1].temporal_coupling);
-        });
-    });
-});

package/dist/__tests__/health-grade-enhanced.test.js

@@ -1,138 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { analyzeFanInDistribution, computeHealthGrade, computeTestCoverageProxy, detectCircularDeps, measureImportDepth, } from "../intelligence/health-grader.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,
-    };
-}
-describe("Health Grading (O.1-O.5)", () => {
-    it("detects circular dependencies", () => {
-        const edges = [
-            { from_key: "a", to_key: "b", type: "calls", file_path: "f.ts", line: 1 },
-            { from_key: "b", to_key: "c", type: "calls", file_path: "f.ts", line: 2 },
-            { from_key: "c", to_key: "a", type: "calls", file_path: "f.ts", line: 3 },
-        ];
-        const cycles = detectCircularDeps(edges);
-        expect(cycles.length).toBeGreaterThanOrEqual(1);
-    });
-    it("no cycles in acyclic graph", () => {
-        const edges = [
-            { from_key: "a", to_key: "b", type: "calls", file_path: "f.ts", line: 1 },
-            { from_key: "b", to_key: "c", type: "calls", file_path: "f.ts", line: 2 },
-        ];
-        const cycles = detectCircularDeps(edges);
-        expect(cycles).toHaveLength(0);
-    });
-    it("analyzes fan-in distribution", () => {
-        const edges = Array.from({ length: 50 }, (_, i) => ({
-            from_key: `caller${i}`,
-            to_key: "hub",
-            type: "calls",
-            file_path: "f.ts",
-            line: i,
-        }));
-        const analysis = analyzeFanInDistribution(edges);
-        expect(analysis.maxFanIn).toBe(50);
-        expect(analysis.avgFanIn).toBe(50);
-    });
-    it("measures import depth", () => {
-        const edges = [
-            {
-                from_key: "a",
-                to_key: "b",
-                type: "imports",
-                file_path: "a.ts",
-                line: 1,
-            },
-            {
-                from_key: "b",
-                to_key: "c",
-                type: "imports",
-                file_path: "b.ts",
-                line: 1,
-            },
-            {
-                from_key: "c",
-                to_key: "d",
-                type: "imports",
-                file_path: "c.ts",
-                line: 1,
-            },
-        ];
-        const depth = measureImportDepth(edges);
-        expect(depth).toBe(3);
-    });
-    it("computes test coverage proxy", () => {
-        const entities = [
-            makeEntity("fn", "src/auth.ts"),
-            makeEntity("test", "src/__tests__/auth.test.ts"),
-        ];
-        const ratio = computeTestCoverageProxy(entities);
-        expect(ratio).toBe(1.0);
-    });
-    it("computes composite health grade", () => {
-        const entities = Array.from({ length: 20 }, (_, i) => makeEntity(`fn${i}`, `src/f${i}.ts`));
-        const edges = [
-            {
-                from_key: entities[0].key,
-                to_key: entities[1].key,
-                type: "calls",
-                file_path: "f.ts",
-                line: 1,
-            },
-        ];
-        const report = computeHealthGrade(entities, edges);
-        expect(["A", "B", "C", "D", "F"]).toContain(report.grade);
-        expect(report.score).toBeGreaterThanOrEqual(0);
-        expect(report.score).toBeLessThanOrEqual(100);
-        expect(report.factors).toHaveLength(5);
-    });
-    it("circular deps penalize health grade", () => {
-        const entities = [
-            makeEntity("a", "a.ts"),
-            makeEntity("b", "b.ts"),
-            makeEntity("c", "c.ts"),
-        ];
-        const cycleEdges = [
-            {
-                from_key: entities[0].key,
-                to_key: entities[1].key,
-                type: "calls",
-                file_path: "a.ts",
-                line: 1,
-            },
-            {
-                from_key: entities[1].key,
-                to_key: entities[2].key,
-                type: "calls",
-                file_path: "b.ts",
-                line: 1,
-            },
-            {
-                from_key: entities[2].key,
-                to_key: entities[0].key,
-                type: "calls",
-                file_path: "c.ts",
-                line: 1,
-            },
-        ];
-        const withCycles = computeHealthGrade(entities, cycleEdges);
-        const noCycles = computeHealthGrade(entities, []);
-        expect(withCycles.score).toBeLessThan(noCycles.score);
-        expect(withCycles.circularDeps.length).toBeGreaterThan(0);
-    });
-});