@unerr-ai/unerr 0.1.6 → 0.1.7

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

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

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

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

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