@unerr-ai/unerr 0.1.0 → 0.1.1

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

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

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

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