@unerr-ai/unerr 0.1.0 → 0.1.2

package/dist/__tests__/check-commit.test.js

@@ -0,0 +1,258 @@
+/**
+ * Tests for pre-commit convention check (Sprint 4, Task 4.2).
+ *
+ * Tests the blocking mode detection algorithm, config gating logic,
+ * staged file filtering, graph loading graceful degradation,
+ * and violation evaluation pipeline.
+ */
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+describe("Check-Commit Hook", () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `unerr-test-check-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("pre-commit hook script is valid shell with shebang and non-blocking exit", () => {
+        const hookScript = `#!/bin/sh
+# unerr pre-commit convention check
+if command -v unerr &> /dev/null; then
+  unerr check-commit 2>/dev/null
+fi
+# Non-blocking — always allow commit
+exit 0
+`;
+        expect(hookScript.startsWith("#!/bin/sh")).toBe(true);
+        expect(hookScript.trimEnd().endsWith("exit 0")).toBe(true);
+        expect(hookScript).toContain("unerr check-commit");
+        // Stderr redirect ensures no noise in git output
+        expect(hookScript).toContain("2>/dev/null");
+        // command -v check ensures graceful degradation when unerr not installed
+        expect(hookScript).toContain("command -v unerr");
+    });
+    describe("blocking mode detection algorithm", () => {
+        it("defaults to non-blocking when no settings exist", () => {
+            const settingsPath = join(tempDir, ".unerr", "settings.json");
+            expect(existsSync(settingsPath)).toBe(false);
+            const optsBlocking = undefined;
+            let blockingMode = optsBlocking ?? false;
+            if (!blockingMode && existsSync(settingsPath)) {
+                blockingMode = true;
+            }
+            expect(blockingMode).toBe(false);
+        });
+        it("reads blocking=true from settings.json when CLI flag not set", () => {
+            const settingsDir = join(tempDir, ".unerr");
+            mkdirSync(settingsDir, { recursive: true });
+            writeFileSync(join(settingsDir, "settings.json"), JSON.stringify({ hooks: { precommit: { blocking: true } } }));
+            const settingsPath = join(settingsDir, "settings.json");
+            let blockingMode = false;
+            if (!blockingMode && existsSync(settingsPath)) {
+                const settings = JSON.parse(require("node:fs").readFileSync(settingsPath, "utf-8"));
+                blockingMode = settings.hooks?.precommit?.blocking ?? false;
+            }
+            expect(blockingMode).toBe(true);
+        });
+        it("CLI --blocking flag takes precedence over settings.json", () => {
+            const settingsDir = join(tempDir, ".unerr");
+            mkdirSync(settingsDir, { recursive: true });
+            writeFileSync(join(settingsDir, "settings.json"), JSON.stringify({ hooks: { precommit: { blocking: false } } }));
+            const optsBlocking = true;
+            let blockingMode = optsBlocking ?? false;
+            const settingsPath = join(settingsDir, "settings.json");
+            if (!blockingMode && existsSync(settingsPath)) {
+                blockingMode = false;
+            }
+            expect(blockingMode).toBe(true);
+        });
+        it("handles malformed settings.json without crashing", () => {
+            const settingsDir = join(tempDir, ".unerr");
+            mkdirSync(settingsDir, { recursive: true });
+            writeFileSync(join(settingsDir, "settings.json"), "NOT VALID JSON!!!");
+            const settingsPath = join(settingsDir, "settings.json");
+            let blockingMode = false;
+            if (!blockingMode && existsSync(settingsPath)) {
+                try {
+                    const settings = JSON.parse(require("node:fs").readFileSync(settingsPath, "utf-8"));
+                    blockingMode = settings.hooks?.precommit?.blocking ?? false;
+                }
+                catch {
+                    // Should catch and keep blockingMode false
+                }
+            }
+            expect(blockingMode).toBe(false);
+        });
+        it("handles settings.json with missing hooks section", () => {
+            const settingsDir = join(tempDir, ".unerr");
+            mkdirSync(settingsDir, { recursive: true });
+            writeFileSync(join(settingsDir, "settings.json"), JSON.stringify({ theme: "dark" }));
+            const settingsPath = join(settingsDir, "settings.json");
+            let blockingMode = false;
+            if (!blockingMode && existsSync(settingsPath)) {
+                const settings = JSON.parse(require("node:fs").readFileSync(settingsPath, "utf-8"));
+                blockingMode = settings.hooks?.precommit?.blocking ?? false;
+            }
+            expect(blockingMode).toBe(false);
+        });
+    });
+    describe("config gating", () => {
+        it("skips when no .unerr/config.json exists", () => {
+            const configPath = join(tempDir, ".unerr", "config.json");
+            expect(existsSync(configPath)).toBe(false);
+        });
+        it("proceeds when .unerr/config.json exists with repoId", () => {
+            const unerrDir = join(tempDir, ".unerr");
+            mkdirSync(unerrDir, { recursive: true });
+            writeFileSync(join(unerrDir, "config.json"), JSON.stringify({
+                repoId: "test-repo",
+            }));
+            const configPath = join(unerrDir, "config.json");
+            expect(existsSync(configPath)).toBe(true);
+            const config = JSON.parse(require("node:fs").readFileSync(configPath, "utf-8"));
+            expect(config.repoId).toBe("test-repo");
+        });
+        it("skips when config.json has no repoId", () => {
+            const unerrDir = join(tempDir, ".unerr");
+            mkdirSync(unerrDir, { recursive: true });
+            writeFileSync(join(unerrDir, "config.json"), JSON.stringify({ orgId: "org-1" }));
+            const config = JSON.parse(require("node:fs").readFileSync(join(unerrDir, "config.json"), "utf-8"));
+            expect(config.repoId).toBeUndefined();
+        });
+        it("skips when config.json is malformed", () => {
+            const unerrDir = join(tempDir, ".unerr");
+            mkdirSync(unerrDir, { recursive: true });
+            writeFileSync(join(unerrDir, "config.json"), "{invalid json}}}");
+            let repoId;
+            try {
+                const config = JSON.parse(require("node:fs").readFileSync(join(unerrDir, "config.json"), "utf-8"));
+                repoId = config.repoId;
+            }
+            catch {
+                repoId = undefined;
+            }
+            expect(repoId).toBeUndefined();
+        });
+    });
+    describe("staged file filtering", () => {
+        const SUPPORTED_EXTENSIONS = new Set([
+            ".ts",
+            ".tsx",
+            ".js",
+            ".jsx",
+            ".py",
+            ".go",
+        ]);
+        it("filters to supported file extensions", () => {
+            const stagedFiles = [
+                "src/index.ts",
+                "README.md",
+                "src/app.tsx",
+                "package.json",
+                "main.go",
+                "script.py",
+                "image.png",
+                "style.css",
+            ];
+            const checkable = stagedFiles.filter((f) => {
+                const ext = f.slice(f.lastIndexOf("."));
+                return SUPPORTED_EXTENSIONS.has(ext);
+            });
+            expect(checkable).toEqual([
+                "src/index.ts",
+                "src/app.tsx",
+                "main.go",
+                "script.py",
+            ]);
+        });
+        it("returns empty array when no supported files staged", () => {
+            const stagedFiles = ["README.md", "package.json", "image.png"];
+            const checkable = stagedFiles.filter((f) => {
+                const ext = f.slice(f.lastIndexOf("."));
+                return SUPPORTED_EXTENSIONS.has(ext);
+            });
+            expect(checkable).toHaveLength(0);
+        });
+        it("handles files with multiple dots correctly", () => {
+            const stagedFiles = ["src/app.test.ts", "config.prod.json", "lib.d.ts"];
+            const checkable = stagedFiles.filter((f) => {
+                const ext = f.slice(f.lastIndexOf("."));
+                return SUPPORTED_EXTENSIONS.has(ext);
+            });
+            expect(checkable).toEqual(["src/app.test.ts", "lib.d.ts"]);
+        });
+    });
+    describe("violation display logic", () => {
+        it("counts errors and warnings separately", () => {
+            const violations = [
+                { severity: "error", message: "bad naming" },
+                { severity: "warning", message: "could improve" },
+                { severity: "error", message: "missing type" },
+                { severity: "info", message: "suggestion" },
+            ];
+            const errorCount = violations.filter((v) => v.severity === "error").length;
+            const warningCount = violations.filter((v) => v.severity === "warning").length;
+            expect(errorCount).toBe(2);
+            expect(warningCount).toBe(1);
+        });
+        it("formats violation summary correctly", () => {
+            const totalViolations = 5;
+            const errorCount = 2;
+            const warningCount = 3;
+            const errorSuffix = errorCount > 0
+                ? ` (${errorCount} error${errorCount !== 1 ? "s" : ""})`
+                : "";
+            const warnSuffix = warningCount > 0
+                ? ` (${warningCount} warning${warningCount !== 1 ? "s" : ""})`
+                : "";
+            const summary = `${totalViolations} violation${totalViolations !== 1 ? "s" : ""} found${errorSuffix}${warnSuffix}`;
+            expect(summary).toBe("5 violations found (2 errors) (3 warnings)");
+        });
+        it("handles singular forms correctly", () => {
+            const count = 1;
+            const errCount = 1;
+            const summary = `${count} violation${count !== 1 ? "s" : ""} found (${errCount} error${errCount !== 1 ? "s" : ""})`;
+            expect(summary).toBe("1 violation found (1 error)");
+        });
+    });
+    describe("graph loading graceful degradation", () => {
+        it("returns null when manifest does not exist", () => {
+            const manifestPath = join(tempDir, "manifests", "test-repo.json");
+            expect(existsSync(manifestPath)).toBe(false);
+        });
+        it("returns null when snapshot file does not exist", () => {
+            const manifestsDir = join(tempDir, "manifests");
+            mkdirSync(manifestsDir, { recursive: true });
+            writeFileSync(join(manifestsDir, "test-repo.json"), JSON.stringify({ entityCount: 100, edgeCount: 200 }));
+            const snapshotsDir = join(tempDir, "snapshots");
+            const gzPath = join(snapshotsDir, "test-repo.msgpack.gz");
+            const rawPath = join(snapshotsDir, "test-repo.msgpack");
+            expect(existsSync(gzPath)).toBe(false);
+            expect(existsSync(rawPath)).toBe(false);
+        });
+    });
+    describe("exit code logic", () => {
+        it("exit 0 in non-blocking mode with violations", () => {
+            const blockingMode = false;
+            const hasViolations = true;
+            const exitCode = blockingMode && hasViolations ? 1 : 0;
+            expect(exitCode).toBe(0);
+        });
+        it("exit 1 in blocking mode with violations", () => {
+            const blockingMode = true;
+            const hasViolations = true;
+            const exitCode = blockingMode && hasViolations ? 1 : 0;
+            expect(exitCode).toBe(1);
+        });
+        it("exit 0 in blocking mode without violations", () => {
+            const blockingMode = true;
+            const hasViolations = false;
+            const exitCode = blockingMode && hasViolations ? 1 : 0;
+            expect(exitCode).toBe(0);
+        });
+    });
+});

package/dist/__tests__/checksum.test.js

@@ -0,0 +1,34 @@
+import { createHash } from "node:crypto";
+import { describe, expect, it } from "vitest";
+describe("checksum verification", () => {
+    function computeChecksum(buf) {
+        return createHash("sha256").update(buf).digest("hex");
+    }
+    it("produces 64-char hex string", () => {
+        const buf = Buffer.from("hello world");
+        const checksum = computeChecksum(buf);
+        expect(checksum).toMatch(/^[0-9a-f]{64}$/);
+    });
+    it("is deterministic", () => {
+        const buf = Buffer.from("test data");
+        expect(computeChecksum(buf)).toBe(computeChecksum(buf));
+    });
+    it("detects tampered buffer", () => {
+        const original = Buffer.from("original data");
+        const originalChecksum = computeChecksum(original);
+        const tampered = Buffer.from("tampered data");
+        const tamperedChecksum = computeChecksum(tampered);
+        expect(originalChecksum).not.toBe(tamperedChecksum);
+    });
+    it("matches known SHA-256 value", () => {
+        // SHA-256 of empty string is well-known
+        const empty = Buffer.from("");
+        const checksum = computeChecksum(empty);
+        expect(checksum).toBe("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
+    });
+    it("handles large buffers", () => {
+        const largeBuf = Buffer.alloc(1024 * 1024, 0x42); // 1MB of 'B'
+        const checksum = computeChecksum(largeBuf);
+        expect(checksum).toMatch(/^[0-9a-f]{64}$/);
+    });
+});

package/dist/__tests__/commit-watcher.test.js

@@ -0,0 +1,154 @@
+/**
+ * P10-TEST-06 (partial): Commit watcher tests — HEAD polling, commit association.
+ */
+import { execSync } from "node:child_process";
+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 { CommitWatcher } from "../tracking/commit-watcher.js";
+import { IntentCorrelator } from "../tracking/intent-correlator.js";
+import { ShadowLedger } from "../tracking/shadow-ledger.js";
+let tempDir;
+let unerrDir;
+let repoDir;
+function initGitRepo() {
+    repoDir = join(tempDir, "repo");
+    mkdirSync(repoDir, { recursive: true });
+    execSync("git init", { cwd: repoDir, stdio: "pipe" });
+    execSync("git config user.email 'test@test.com'", {
+        cwd: repoDir,
+        stdio: "pipe",
+    });
+    execSync("git config user.name 'Test'", { cwd: repoDir, stdio: "pipe" });
+    writeFileSync(join(repoDir, "README.md"), "# Test");
+    execSync("git add -A", { cwd: repoDir, stdio: "pipe" });
+    execSync("git commit -m 'initial'", { cwd: repoDir, stdio: "pipe" });
+}
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-commit-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+    initGitRepo();
+    unerrDir = join(repoDir, ".unerr");
+    mkdirSync(unerrDir, { recursive: true });
+});
+afterEach(() => {
+    try {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+    catch {
+        /* ignore */
+    }
+});
+describe("CommitWatcher", () => {
+    it("captures initial HEAD SHA on start", async () => {
+        const correlator = new IntentCorrelator(unerrDir);
+        const watcher = new CommitWatcher(correlator, { cwd: repoDir });
+        await watcher.start();
+        const headSha = execSync("git rev-parse HEAD", {
+            cwd: repoDir,
+            encoding: "utf-8",
+        }).trim();
+        expect(watcher.getLastHeadSha()).toBe(headSha);
+        watcher.stop();
+    });
+    it("detects new commit and extracts changed files", async () => {
+        const correlator = new IntentCorrelator(unerrDir);
+        const commits = [];
+        const watcher = new CommitWatcher(correlator, {
+            cwd: repoDir,
+            onCommit: (sha, files, associated) => {
+                commits.push({ sha, files, associated });
+            },
+        });
+        await watcher.start();
+        mkdirSync(join(repoDir, "src"), { recursive: true });
+        writeFileSync(join(repoDir, "src", "auth.ts"), "export function login() {}");
+        execSync("git add -A", { cwd: repoDir, stdio: "pipe" });
+        execSync("git commit -m 'add auth'", { cwd: repoDir, stdio: "pipe" });
+        await watcher.poll();
+        expect(commits).toHaveLength(1);
+        expect(commits[0]?.files).toContain("src/auth.ts");
+        const newHead = execSync("git rev-parse HEAD", {
+            cwd: repoDir,
+            encoding: "utf-8",
+        }).trim();
+        expect(commits[0]?.sha).toBe(newHead);
+        watcher.stop();
+    });
+    it("associates pending correlations on commit", async () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", { key: "abc" }, { found: true }, "main", "aaa");
+        correlator.onSyncLocalDiff(ledger, {
+            prompt: "Fix auth",
+            files: [{ path: "src/auth.ts", content: "..." }],
+        });
+        expect(correlator.getPendingCount()).toBe(1);
+        const watcher = new CommitWatcher(correlator, { cwd: repoDir });
+        await watcher.start();
+        mkdirSync(join(repoDir, "src"), { recursive: true });
+        writeFileSync(join(repoDir, "src", "auth.ts"), "export function login() {}");
+        execSync("git add -A", { cwd: repoDir, stdio: "pipe" });
+        execSync("git commit -m 'add auth'", { cwd: repoDir, stdio: "pipe" });
+        await watcher.poll();
+        expect(correlator.getPendingCount()).toBe(0);
+        expect(correlator.getCommittedUnflushed()).toHaveLength(1);
+        expect(correlator.getCommittedUnflushed()[0]?.commitSha).toBeTruthy();
+        watcher.stop();
+    });
+    it("does not fire callback when HEAD unchanged", async () => {
+        const correlator = new IntentCorrelator(unerrDir);
+        let callCount = 0;
+        const watcher = new CommitWatcher(correlator, {
+            cwd: repoDir,
+            onCommit: () => {
+                callCount++;
+            },
+        });
+        await watcher.start();
+        await watcher.poll();
+        await watcher.poll();
+        expect(callCount).toBe(0);
+        watcher.stop();
+    });
+    it("handles non-git directory gracefully", async () => {
+        const nonGitDir = join(tempDir, "not-a-repo");
+        mkdirSync(nonGitDir, { recursive: true });
+        const nonGitUnerrDir = join(nonGitDir, ".unerr");
+        mkdirSync(nonGitUnerrDir, { recursive: true });
+        const correlator = new IntentCorrelator(nonGitUnerrDir);
+        const watcher = new CommitWatcher(correlator, { cwd: nonGitDir });
+        await watcher.start();
+        await watcher.poll();
+        expect(watcher.getLastHeadSha()).toBeNull();
+        watcher.stop();
+    });
+    it("skips non-overlapping files during association", async () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", {}, {}, "main", "aaa");
+        correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "src/billing.ts", content: "..." }],
+        });
+        const watcher = new CommitWatcher(correlator, { cwd: repoDir });
+        await watcher.start();
+        writeFileSync(join(repoDir, "config.json"), "{}");
+        execSync("git add -A", { cwd: repoDir, stdio: "pipe" });
+        execSync("git commit -m 'add config'", { cwd: repoDir, stdio: "pipe" });
+        await watcher.poll();
+        expect(correlator.getPendingCount()).toBe(1);
+        expect(correlator.getCommittedUnflushed()).toHaveLength(0);
+        watcher.stop();
+    });
+    it("stop prevents further polling", async () => {
+        const correlator = new IntentCorrelator(unerrDir);
+        const watcher = new CommitWatcher(correlator, {
+            cwd: repoDir,
+            pollIntervalMs: 10,
+        });
+        await watcher.start();
+        watcher.stop();
+        expect(watcher.getLastHeadSha()).toBeTruthy();
+    });
+});

package/dist/__tests__/community-detection.test.js

@@ -0,0 +1,179 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { clearCommunityCache, detectCommunities, needsRecomputation, } from "../intelligence/community-detector.js";
+import { entityKey } from "../intelligence/indexer/entity-key.js";
+beforeEach(() => {
+    clearCommunityCache();
+});
+function makeEntity(name, filePath) {
+    return {
+        key: entityKey(filePath, "function", name, ""),
+        kind: "function",
+        name,
+        file_path: filePath,
+        start_line: 1,
+        end_line: 10,
+        signature: `${name}()`,
+        body_hash: "hash",
+        exported: true,
+        parent_key: null,
+        language: "typescript",
+        is_async: false,
+        parameter_count: 0,
+        doc: null,
+    };
+}
+describe("Community Detection (M.1-M.3)", () => {
+    it("detects distinct clusters in a graph", async () => {
+        const entities = [
+            makeEntity("authLogin", "src/auth/login.ts"),
+            makeEntity("authLogout", "src/auth/logout.ts"),
+            makeEntity("authValidate", "src/auth/validate.ts"),
+            makeEntity("payProcess", "src/payments/process.ts"),
+            makeEntity("payRefund", "src/payments/refund.ts"),
+            makeEntity("payCharge", "src/payments/charge.ts"),
+        ];
+        const edges = [
+            {
+                from_key: entities[0].key,
+                to_key: entities[1].key,
+                type: "calls",
+                file_path: "a.ts",
+                line: 1,
+            },
+            {
+                from_key: entities[0].key,
+                to_key: entities[2].key,
+                type: "calls",
+                file_path: "a.ts",
+                line: 2,
+            },
+            {
+                from_key: entities[1].key,
+                to_key: entities[2].key,
+                type: "calls",
+                file_path: "a.ts",
+                line: 3,
+            },
+            {
+                from_key: entities[3].key,
+                to_key: entities[4].key,
+                type: "calls",
+                file_path: "b.ts",
+                line: 1,
+            },
+            {
+                from_key: entities[3].key,
+                to_key: entities[5].key,
+                type: "calls",
+                file_path: "b.ts",
+                line: 2,
+            },
+            {
+                from_key: entities[4].key,
+                to_key: entities[5].key,
+                type: "calls",
+                file_path: "b.ts",
+                line: 3,
+            },
+        ];
+        const result = await await detectCommunities(entities, edges);
+        expect(result.communities.length).toBeGreaterThanOrEqual(2);
+        expect(result.assignments.size).toBe(6);
+    });
+    it("produces community profiles with files and kinds", async () => {
+        const entities = [
+            makeEntity("fn1", "src/auth/a.ts"),
+            makeEntity("fn2", "src/auth/b.ts"),
+        ];
+        const edges = [
+            {
+                from_key: entities[0].key,
+                to_key: entities[1].key,
+                type: "calls",
+                file_path: "a.ts",
+                line: 1,
+            },
+        ];
+        const result = await await detectCommunities(entities, edges);
+        expect(result.communities.length).toBeGreaterThanOrEqual(1);
+        const profile = result.communities[0];
+        expect(profile.entityCount).toBeGreaterThan(0);
+        expect(profile.files.length).toBeGreaterThan(0);
+        expect(profile.dominantKinds.length).toBeGreaterThan(0);
+    });
+    it("infers community name from directory", async () => {
+        const entities = [
+            makeEntity("login", "src/auth/login.ts"),
+            makeEntity("logout", "src/auth/logout.ts"),
+            makeEntity("validate", "src/auth/validate.ts"),
+        ];
+        const edges = [
+            {
+                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: "a.ts",
+                line: 2,
+            },
+        ];
+        const result = await await detectCommunities(entities, edges);
+        const authCommunity = result.communities.find((c) => c.name === "auth");
+        expect(authCommunity).toBeDefined();
+    });
+    it("handles empty graph", async () => {
+        const result = await detectCommunities([], []);
+        expect(result.communities).toHaveLength(0);
+        expect(result.modularity).toBe(0);
+    });
+    it("computes cohesion and coupling", async () => {
+        const entities = [
+            makeEntity("a", "src/mod/a.ts"),
+            makeEntity("b", "src/mod/b.ts"),
+            makeEntity("external", "src/other/c.ts"),
+        ];
+        const edges = [
+            {
+                from_key: entities[0].key,
+                to_key: entities[1].key,
+                type: "calls",
+                file_path: "a.ts",
+                line: 1,
+            },
+            {
+                from_key: entities[0].key,
+                to_key: entities[2].key,
+                type: "calls",
+                file_path: "a.ts",
+                line: 2,
+            },
+        ];
+        const result = await await detectCommunities(entities, edges);
+        for (const community of result.communities) {
+            expect(community.cohesion).toBeGreaterThanOrEqual(0);
+            expect(community.coupling).toBeGreaterThanOrEqual(0);
+        }
+    });
+});
+describe("Community Recomputation (M.6)", () => {
+    it("triggers recomputation when no cache", async () => {
+        expect(needsRecomputation(100)).toBe(true);
+    });
+    it("skips recomputation when below threshold", async () => {
+        const entities = Array.from({ length: 100 }, (_, i) => makeEntity(`fn${i}`, `src/f${i}.ts`));
+        const edges = [];
+        await detectCommunities(entities, edges);
+        expect(needsRecomputation(105)).toBe(false);
+    });
+    it("triggers recomputation when >10% change", async () => {
+        const entities = Array.from({ length: 100 }, (_, i) => makeEntity(`fn${i}`, `src/f${i}.ts`));
+        detectCommunities(entities, []);
+        expect(needsRecomputation(115)).toBe(true);
+    });
+});