@n-dx/core 0.1.0

package/packages/sourcevision/dist/analyzers/__tests__/zones.test.js

@@ -0,0 +1,836 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { buildUndirectedGraph, deriveZoneId, deriveZoneName, analyzeZones, enrichZonesWithAI, assignByProximity, computeStructureHash, generateStructuralInsights, computeAttemptConfigs, extractFindings, } from "../zones.js";
+import { execFileSync } from "node:child_process";
+vi.mock("node:child_process", async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, execFileSync: vi.fn(actual.execFileSync) };
+});
+const mockedExecFileSync = vi.mocked(execFileSync);
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeFileEntry(path, overrides) {
+    return {
+        path,
+        size: 100,
+        language: "TypeScript",
+        lineCount: 10,
+        hash: "abc123",
+        role: "source",
+        category: "misc",
+        ...overrides,
+    };
+}
+function makeInventory(files) {
+    return {
+        files,
+        summary: {
+            totalFiles: files.length,
+            totalLines: files.reduce((s, f) => s + f.lineCount, 0),
+            byLanguage: {},
+            byRole: {},
+            byCategory: {},
+        },
+    };
+}
+function makeEdge(from, to, symbols = ["default"]) {
+    return { from, to, type: "static", symbols };
+}
+function makeImports(edges) {
+    return {
+        edges,
+        external: [],
+        summary: {
+            totalEdges: edges.length,
+            totalExternal: 0,
+            circularCount: 0,
+            circulars: [],
+            mostImported: [],
+            avgImportsPerFile: 0,
+        },
+    };
+}
+// ── buildUndirectedGraph ────────────────────────────────────────────────────
+describe("buildUndirectedGraph", () => {
+    it("creates bidirectional edges with symbol-count weights", () => {
+        const graph = buildUndirectedGraph([
+            makeEdge("a.ts", "b.ts", ["foo", "bar"]),
+        ]);
+        expect(graph.get("a.ts")?.get("b.ts")).toBe(2);
+        expect(graph.get("b.ts")?.get("a.ts")).toBe(2);
+    });
+    it("sums weights for multiple edges between same pair", () => {
+        const graph = buildUndirectedGraph([
+            makeEdge("a.ts", "b.ts", ["foo"]),
+            makeEdge("b.ts", "a.ts", ["bar", "baz"]),
+        ]);
+        expect(graph.get("a.ts")?.get("b.ts")).toBe(3);
+        expect(graph.get("b.ts")?.get("a.ts")).toBe(3);
+    });
+    it("uses min weight of 1 for empty symbols", () => {
+        const graph = buildUndirectedGraph([
+            makeEdge("a.ts", "b.ts", []),
+        ]);
+        expect(graph.get("a.ts")?.get("b.ts")).toBe(1);
+    });
+    it("returns empty graph for empty input", () => {
+        const graph = buildUndirectedGraph([]);
+        expect(graph.size).toBe(0);
+    });
+});
+// ── deriveZoneId ────────────────────────────────────────────────────────────
+describe("deriveZoneId", () => {
+    it("uses most common directory segment", () => {
+        expect(deriveZoneId([
+            "src/schema/v1.ts",
+            "src/schema/validate.ts",
+            "src/schema/index.ts",
+        ])).toBe("schema");
+    });
+    it("returns 'root' for root-level files", () => {
+        expect(deriveZoneId(["package.json", "tsconfig.json"])).toBe("root");
+    });
+    it("skips generic segments like src, lib, app", () => {
+        expect(deriveZoneId(["src/analyzers/foo.ts", "src/analyzers/bar.ts"])).toBe("analyzers");
+    });
+    it("normalizes underscores to hyphens", () => {
+        expect(deriveZoneId(["src/my_module/a.ts"])).toBe("my-module");
+    });
+    it("handles mixed root and nested files", () => {
+        expect(deriveZoneId([
+            "README.md",
+            "src/schema/v1.ts",
+            "src/schema/v2.ts",
+        ])).toBe("schema");
+    });
+});
+// ── deriveZoneName ──────────────────────────────────────────────────────────
+describe("deriveZoneName", () => {
+    it("title-cases single word", () => {
+        expect(deriveZoneName("schema")).toBe("Schema");
+    });
+    it("title-cases hyphenated words", () => {
+        expect(deriveZoneName("detail-panel")).toBe("Detail Panel");
+    });
+    it("handles single-char segments", () => {
+        expect(deriveZoneName("a-b")).toBe("A B");
+    });
+});
+// ── Integration: analyzeZones ───────────────────────────────────────────────
+describe("analyzeZones", () => {
+    it("returns no zones and all unzoned for empty import graph", () => {
+        const inventory = makeInventory([
+            makeFileEntry("README.md", { role: "docs" }),
+            makeFileEntry("package.json", { role: "config" }),
+        ]);
+        const imports = makeImports([]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        expect(result.zones).toHaveLength(0);
+        expect(result.crossings).toHaveLength(0);
+        expect(result.unzoned).toContain("README.md");
+        expect(result.unzoned).toContain("package.json");
+    });
+    it("detects two disconnected clusters as separate zones", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/a/x.ts"),
+            makeFileEntry("src/a/y.ts"),
+            makeFileEntry("src/a/z.ts"),
+            makeFileEntry("src/b/p.ts"),
+            makeFileEntry("src/b/q.ts"),
+            makeFileEntry("src/b/r.ts"),
+        ]);
+        const imports = makeImports([
+            // Cluster A: fully connected
+            makeEdge("src/a/x.ts", "src/a/y.ts"),
+            makeEdge("src/a/y.ts", "src/a/z.ts"),
+            makeEdge("src/a/x.ts", "src/a/z.ts"),
+            // Cluster B: fully connected
+            makeEdge("src/b/p.ts", "src/b/q.ts"),
+            makeEdge("src/b/q.ts", "src/b/r.ts"),
+            makeEdge("src/b/p.ts", "src/b/r.ts"),
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        expect(result.zones.length).toBe(2);
+        expect(result.crossings).toHaveLength(0);
+        // Each zone should have 3 files
+        for (const zone of result.zones) {
+            expect(zone.files).toHaveLength(3);
+        }
+    });
+    it("puts all interconnected files in one zone with cohesion=1, coupling=0", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/m/a.ts"),
+            makeFileEntry("src/m/b.ts"),
+            makeFileEntry("src/m/c.ts"),
+        ]);
+        const imports = makeImports([
+            makeEdge("src/m/a.ts", "src/m/b.ts"),
+            makeEdge("src/m/b.ts", "src/m/c.ts"),
+            makeEdge("src/m/a.ts", "src/m/c.ts"),
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        expect(result.zones).toHaveLength(1);
+        expect(result.zones[0].cohesion).toBe(1);
+        expect(result.zones[0].coupling).toBe(0);
+    });
+    it("populates crossings for cross-zone edges", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/a/x.ts"),
+            makeFileEntry("src/a/y.ts"),
+            makeFileEntry("src/a/z.ts"),
+            makeFileEntry("src/b/p.ts"),
+            makeFileEntry("src/b/q.ts"),
+            makeFileEntry("src/b/r.ts"),
+        ]);
+        const imports = makeImports([
+            // Cluster A
+            makeEdge("src/a/x.ts", "src/a/y.ts"),
+            makeEdge("src/a/y.ts", "src/a/z.ts"),
+            makeEdge("src/a/x.ts", "src/a/z.ts"),
+            // Cluster B
+            makeEdge("src/b/p.ts", "src/b/q.ts"),
+            makeEdge("src/b/q.ts", "src/b/r.ts"),
+            makeEdge("src/b/p.ts", "src/b/r.ts"),
+            // Cross-zone edge
+            makeEdge("src/a/x.ts", "src/b/p.ts"),
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        expect(result.crossings.length).toBeGreaterThan(0);
+        expect(result.crossings.some((c) => c.fromZone !== c.toZone)).toBe(true);
+        // Both zones should have coupling > 0
+        for (const zone of result.zones) {
+            expect(zone.coupling).toBeGreaterThanOrEqual(0);
+        }
+    });
+    it("puts non-import files in unzoned", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/m/a.ts"),
+            makeFileEntry("src/m/b.ts"),
+            makeFileEntry("src/m/c.ts"),
+            makeFileEntry("README.md", { role: "docs" }),
+            makeFileEntry(".gitignore", { role: "config" }),
+        ]);
+        const imports = makeImports([
+            makeEdge("src/m/a.ts", "src/m/b.ts"),
+            makeEdge("src/m/b.ts", "src/m/c.ts"),
+            makeEdge("src/m/a.ts", "src/m/c.ts"),
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        expect(result.unzoned).toContain("README.md");
+        expect(result.unzoned).toContain(".gitignore");
+    });
+    it("merges small communities into neighbors", () => {
+        const inventory = makeInventory([
+            // Big cluster
+            makeFileEntry("src/core/a.ts"),
+            makeFileEntry("src/core/b.ts"),
+            makeFileEntry("src/core/c.ts"),
+            makeFileEntry("src/core/d.ts"),
+            // Tiny "cluster" of 1 connected to core
+            makeFileEntry("src/util/helper.ts"),
+        ]);
+        const imports = makeImports([
+            makeEdge("src/core/a.ts", "src/core/b.ts"),
+            makeEdge("src/core/b.ts", "src/core/c.ts"),
+            makeEdge("src/core/c.ts", "src/core/d.ts"),
+            makeEdge("src/core/a.ts", "src/core/d.ts"),
+            // helper connects to core
+            makeEdge("src/util/helper.ts", "src/core/a.ts"),
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        // The small community (helper) should be merged into core
+        // so we should have 1 zone containing all 5 files
+        expect(result.zones).toHaveLength(1);
+        expect(result.zones[0].files).toHaveLength(5);
+    });
+    it("identifies entry points as files imported from other zones", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/a/x.ts"),
+            makeFileEntry("src/a/y.ts"),
+            makeFileEntry("src/a/z.ts"),
+            makeFileEntry("src/b/p.ts"),
+            makeFileEntry("src/b/q.ts"),
+            makeFileEntry("src/b/r.ts"),
+        ]);
+        const imports = makeImports([
+            makeEdge("src/a/x.ts", "src/a/y.ts"),
+            makeEdge("src/a/y.ts", "src/a/z.ts"),
+            makeEdge("src/a/x.ts", "src/a/z.ts"),
+            makeEdge("src/b/p.ts", "src/b/q.ts"),
+            makeEdge("src/b/q.ts", "src/b/r.ts"),
+            makeEdge("src/b/p.ts", "src/b/r.ts"),
+            // Cross-zone: a/x imports b/p
+            makeEdge("src/a/x.ts", "src/b/p.ts"),
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        if (result.zones.length === 2) {
+            // The zone containing b/p.ts should list it as an entry point
+            const bZone = result.zones.find((z) => z.files.includes("src/b/p.ts"));
+            expect(bZone?.entryPoints).toContain("src/b/p.ts");
+        }
+    });
+    it("is deterministic across multiple runs", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/a/x.ts"),
+            makeFileEntry("src/a/y.ts"),
+            makeFileEntry("src/a/z.ts"),
+            makeFileEntry("src/b/p.ts"),
+            makeFileEntry("src/b/q.ts"),
+            makeFileEntry("src/b/r.ts"),
+        ]);
+        const imports = makeImports([
+            makeEdge("src/a/x.ts", "src/a/y.ts"),
+            makeEdge("src/a/y.ts", "src/a/z.ts"),
+            makeEdge("src/b/p.ts", "src/b/q.ts"),
+            makeEdge("src/b/q.ts", "src/b/r.ts"),
+            makeEdge("src/a/x.ts", "src/b/p.ts"),
+        ]);
+        const run1 = analyzeZones(inventory, imports, { enrich: false });
+        const run2 = analyzeZones(inventory, imports, { enrich: false });
+        expect(run1).toEqual(run2);
+    });
+});
+// ── assignByProximity ────────────────────────────────────────────────────────
+describe("assignByProximity", () => {
+    it("assigns files to the zone sharing their directory", () => {
+        const zones = [
+            {
+                id: "core",
+                name: "Core",
+                description: "",
+                files: ["src/core/a.ts", "src/core/b.ts", "src/core/c.ts"],
+                entryPoints: [],
+                cohesion: 1,
+                coupling: 0,
+            },
+        ];
+        const { zones: expanded, remaining } = assignByProximity(zones, [
+            "src/core/README.md",
+            "src/core/styles.css",
+        ]);
+        expect(expanded[0].files).toContain("src/core/README.md");
+        expect(expanded[0].files).toContain("src/core/styles.css");
+        expect(remaining).toHaveLength(0);
+    });
+    it("walks up directory tree to find a match", () => {
+        const zones = [
+            {
+                id: "api",
+                name: "Api",
+                description: "",
+                files: ["src/api/routes.ts"],
+                entryPoints: [],
+                cohesion: 1,
+                coupling: 0,
+            },
+        ];
+        const { zones: expanded, remaining } = assignByProximity(zones, [
+            "src/api/handlers/health.ts",
+        ]);
+        // health.ts is in src/api/handlers/, walks up to src/api/ which matches
+        expect(expanded[0].files).toContain("src/api/handlers/health.ts");
+        expect(remaining).toHaveLength(0);
+    });
+    it("leaves root files unzoned when no zone matches", () => {
+        const zones = [
+            {
+                id: "core",
+                name: "Core",
+                description: "",
+                files: ["src/core/a.ts"],
+                entryPoints: [],
+                cohesion: 1,
+                coupling: 0,
+            },
+        ];
+        const { remaining } = assignByProximity(zones, [
+            "package.json",
+            "README.md",
+        ]);
+        expect(remaining).toContain("package.json");
+        expect(remaining).toContain("README.md");
+    });
+});
+// ── computeStructureHash ────────────────────────────────────────────────────
+describe("computeStructureHash", () => {
+    it("produces the same hash for the same zone files", () => {
+        const zones = [
+            { id: "a", name: "", description: "", files: ["x.ts", "y.ts"], entryPoints: [], cohesion: 1, coupling: 0 },
+        ];
+        expect(computeStructureHash(zones)).toBe(computeStructureHash(zones));
+    });
+    it("produces different hashes for different zone files", () => {
+        const z1 = [
+            { id: "a", name: "", description: "", files: ["x.ts"], entryPoints: [], cohesion: 1, coupling: 0 },
+        ];
+        const z2 = [
+            { id: "a", name: "", description: "", files: ["y.ts"], entryPoints: [], cohesion: 1, coupling: 0 },
+        ];
+        expect(computeStructureHash(z1)).not.toBe(computeStructureHash(z2));
+    });
+    it("is independent of zone ID or name (only file groupings matter)", () => {
+        const z1 = [
+            { id: "a", name: "A", description: "", files: ["x.ts", "y.ts"], entryPoints: [], cohesion: 1, coupling: 0 },
+        ];
+        const z2 = [
+            { id: "renamed", name: "Renamed", description: "", files: ["x.ts", "y.ts"], entryPoints: [], cohesion: 1, coupling: 0 },
+        ];
+        expect(computeStructureHash(z1)).toBe(computeStructureHash(z2));
+    });
+});
+// ── generateStructuralInsights ──────────────────────────────────────────────
+describe("generateStructuralInsights", () => {
+    it("generates high-cohesion insight", () => {
+        const zones = [
+            { id: "core", name: "Core", description: "", files: ["a.ts", "b.ts", "c.ts"], entryPoints: [], cohesion: 0.9, coupling: 0.1 },
+        ];
+        const { zoneInsights } = generateStructuralInsights(zones, [], makeImports([]), 10);
+        expect(zoneInsights.get("core").some((i) => i.includes("High cohesion"))).toBe(true);
+    });
+    it("generates low-cohesion warning for large zones", () => {
+        const zones = [
+            { id: "misc", name: "Misc", description: "", files: ["a.ts", "b.ts", "c.ts", "d.ts"], entryPoints: [], cohesion: 0.3, coupling: 0.2 },
+        ];
+        const { zoneInsights } = generateStructuralInsights(zones, [], makeImports([]), 10);
+        expect(zoneInsights.get("misc").some((i) => i.includes("Low cohesion"))).toBe(true);
+    });
+    it("generates hub file insight for files imported across 3+ zones", () => {
+        const crossings = [
+            { from: "a/x.ts", to: "shared/hub.ts", fromZone: "zone-a", toZone: "shared" },
+            { from: "b/x.ts", to: "shared/hub.ts", fromZone: "zone-b", toZone: "shared" },
+            { from: "c/x.ts", to: "shared/hub.ts", fromZone: "zone-c", toZone: "shared" },
+        ];
+        const zones = [
+            { id: "shared", name: "", description: "", files: ["shared/hub.ts"], entryPoints: [], cohesion: 1, coupling: 0 },
+        ];
+        const { globalInsights } = generateStructuralInsights(zones, crossings, makeImports([]), 10);
+        expect(globalInsights.some((i) => i.includes("Hub") && i.includes("shared/hub.ts"))).toBe(true);
+    });
+    it("detects bidirectional coupling", () => {
+        const crossings = [
+            { from: "a/x.ts", to: "b/y.ts", fromZone: "alpha", toZone: "beta" },
+            { from: "b/z.ts", to: "a/w.ts", fromZone: "beta", toZone: "alpha" },
+        ];
+        const zones = [
+            { id: "alpha", name: "", description: "", files: ["a/x.ts", "a/w.ts"], entryPoints: [], cohesion: 1, coupling: 0.5 },
+            { id: "beta", name: "", description: "", files: ["b/y.ts", "b/z.ts"], entryPoints: [], cohesion: 1, coupling: 0.5 },
+        ];
+        const { globalInsights } = generateStructuralInsights(zones, crossings, makeImports([]), 10);
+        expect(globalInsights.some((i) => i.includes("Bidirectional"))).toBe(true);
+    });
+});
+// ── enrichZonesWithAI ──────────────────────────────────────────────────────
+describe("enrichZonesWithAI", () => {
+    afterEach(() => {
+        mockedExecFileSync.mockReset();
+    });
+    const sampleZones = [
+        {
+            id: "analyzers",
+            name: "Analyzers",
+            description: "3 files, primarily TypeScript",
+            files: ["src/analyzers/a.ts", "src/analyzers/b.ts", "src/analyzers/c.ts"],
+            entryPoints: ["src/analyzers/a.ts"],
+            cohesion: 0.8,
+            coupling: 0.2,
+        },
+        {
+            id: "schema",
+            name: "Schema",
+            description: "2 files, primarily TypeScript",
+            files: ["src/schema/v1.ts", "src/schema/validate.ts"],
+            entryPoints: ["src/schema/v1.ts"],
+            cohesion: 1,
+            coupling: 0.1,
+        },
+    ];
+    const sampleCrossings = [
+        { from: "src/analyzers/a.ts", to: "src/schema/v1.ts", fromZone: "analyzers", toZone: "schema" },
+    ];
+    const sampleInventory = makeInventory([
+        makeFileEntry("src/analyzers/a.ts"),
+        makeFileEntry("src/analyzers/b.ts"),
+        makeFileEntry("src/analyzers/c.ts"),
+        makeFileEntry("src/schema/v1.ts"),
+        makeFileEntry("src/schema/validate.ts"),
+    ]);
+    const sampleImports = makeImports([
+        makeEdge("src/analyzers/a.ts", "src/schema/v1.ts"),
+    ]);
+    function makePass1Response() {
+        return JSON.stringify({
+            zones: [
+                {
+                    algorithmicId: "analyzers",
+                    id: "code-analysis",
+                    name: "Code Analysis",
+                    description: "Core analysis pipeline",
+                    insights: ["Uses visitor pattern for AST traversal"],
+                },
+                {
+                    algorithmicId: "schema",
+                    id: "data-schema",
+                    name: "Data Schema",
+                    description: "Schema definitions and validation",
+                    insights: ["Well-isolated with clean boundary"],
+                },
+            ],
+            insights: ["Clean layered architecture: schema → analyzers"],
+        });
+    }
+    it("pass 1: replaces id/name/description and returns AI insights", () => {
+        mockedExecFileSync.mockImplementationOnce(() => Buffer.from("/usr/local/bin/claude\n"));
+        mockedExecFileSync.mockImplementationOnce(() => makePass1Response());
+        const result = enrichZonesWithAI(sampleZones, sampleCrossings, sampleInventory, sampleImports);
+        expect(result.pass).toBe(1);
+        expect(result.zones).toHaveLength(2);
+        expect(result.zones[0].id).toBe("code-analysis");
+        expect(result.zones[0].name).toBe("Code Analysis");
+        expect(result.zones[0].description).toBe("Core analysis pipeline");
+        // Structural data preserved
+        expect(result.zones[0].files).toEqual(sampleZones[0].files);
+        expect(result.zones[0].cohesion).toBe(0.8);
+        expect(result.zones[0].coupling).toBe(0.2);
+        // AI insights extracted
+        expect(result.newZoneInsights.get("code-analysis")).toEqual([
+            "Uses visitor pattern for AST traversal",
+        ]);
+        expect(result.newGlobalInsights).toEqual([
+            "Clean layered architecture: schema → analyzers",
+        ]);
+    });
+    it("handles AI response wrapped in markdown fences", () => {
+        mockedExecFileSync.mockImplementationOnce(() => Buffer.from("/usr/local/bin/claude\n"));
+        mockedExecFileSync.mockImplementationOnce(() => "```json\n" + makePass1Response() + "\n```");
+        const result = enrichZonesWithAI(sampleZones, sampleCrossings, sampleInventory, sampleImports);
+        expect(result.zones[0].id).toBe("code-analysis");
+        expect(result.zones[1].id).toBe("data-schema");
+    });
+    it("returns zones unchanged when claude CLI not found", () => {
+        mockedExecFileSync.mockImplementationOnce(() => {
+            throw new Error("not found");
+        });
+        const result = enrichZonesWithAI(sampleZones, sampleCrossings, sampleInventory, sampleImports);
+        expect(result.zones).toEqual(sampleZones);
+        expect(result.pass).toBe(0);
+    });
+    it("returns zones unchanged on invalid JSON response after all retries", () => {
+        mockedExecFileSync.mockImplementationOnce(() => Buffer.from("/usr/local/bin/claude\n"));
+        // All 3 retry attempts return invalid JSON
+        mockedExecFileSync.mockImplementationOnce(() => "This is not valid JSON");
+        mockedExecFileSync.mockImplementationOnce(() => "Still not JSON");
+        mockedExecFileSync.mockImplementationOnce(() => "Nope");
+        const result = enrichZonesWithAI(sampleZones, sampleCrossings, sampleInventory, sampleImports);
+        expect(result.zones).toEqual(sampleZones);
+        expect(result.pass).toBe(0);
+    });
+    it("returns zones unchanged when response has empty zones array", () => {
+        mockedExecFileSync.mockImplementationOnce(() => Buffer.from("/usr/local/bin/claude\n"));
+        const emptyResponse = JSON.stringify({ zones: [], insights: [] });
+        mockedExecFileSync.mockImplementationOnce(() => emptyResponse);
+        mockedExecFileSync.mockImplementationOnce(() => emptyResponse);
+        mockedExecFileSync.mockImplementationOnce(() => emptyResponse);
+        const result = enrichZonesWithAI(sampleZones, sampleCrossings, sampleInventory, sampleImports);
+        expect(result.zones).toEqual(sampleZones);
+        expect(result.pass).toBe(0);
+    });
+    it("applies partial results when response has fewer zones", () => {
+        mockedExecFileSync.mockImplementationOnce(() => Buffer.from("/usr/local/bin/claude\n"));
+        mockedExecFileSync.mockImplementationOnce(() => JSON.stringify({
+            zones: [{ algorithmicId: "analyzers", id: "analysis-core", name: "Analysis Core", description: "Core analysis", insights: [] }],
+            insights: [],
+        }));
+        const result = enrichZonesWithAI(sampleZones, sampleCrossings, sampleInventory, sampleImports);
+        // First zone matched by algorithmicId and enriched
+        expect(result.zones[0].id).toBe("analysis-core");
+        expect(result.zones[0].name).toBe("Analysis Core");
+        // Second zone kept as-is (no match)
+        expect(result.zones[1].id).toBe("schema");
+        expect(result.zones[1].name).toBe("Schema");
+        expect(result.pass).toBe(1);
+    });
+    it("returns zones unchanged when all claude calls throw", () => {
+        mockedExecFileSync.mockImplementationOnce(() => Buffer.from("/usr/local/bin/claude\n"));
+        const throwErr = () => { const e = new Error("timed out"); e.killed = true; throw e; };
+        mockedExecFileSync.mockImplementationOnce(throwErr);
+        mockedExecFileSync.mockImplementationOnce(throwErr);
+        mockedExecFileSync.mockImplementationOnce(throwErr);
+        const result = enrichZonesWithAI(sampleZones, sampleCrossings, sampleInventory, sampleImports);
+        expect(result.zones).toEqual(sampleZones);
+        expect(result.pass).toBe(0);
+    });
+    it("does not retry on auth errors", () => {
+        mockedExecFileSync.mockImplementationOnce(() => Buffer.from("/usr/local/bin/claude\n"));
+        mockedExecFileSync.mockImplementationOnce(() => {
+            const e = new Error("unauthorized");
+            e.stderr = Buffer.from("Not logged in. Run claude login first.");
+            throw e;
+        });
+        const result = enrichZonesWithAI(sampleZones, sampleCrossings, sampleInventory, sampleImports);
+        expect(result.zones).toEqual(sampleZones);
+        expect(result.pass).toBe(0);
+        // Only 2 calls total: which + 1 claude call (no retries)
+        expect(mockedExecFileSync).toHaveBeenCalledTimes(2);
+    });
+    it("succeeds on retry after initial failure", () => {
+        mockedExecFileSync.mockImplementationOnce(() => Buffer.from("/usr/local/bin/claude\n"));
+        // First attempt fails
+        mockedExecFileSync.mockImplementationOnce(() => "not json");
+        // Second attempt succeeds
+        mockedExecFileSync.mockImplementationOnce(() => makePass1Response());
+        const result = enrichZonesWithAI(sampleZones, sampleCrossings, sampleInventory, sampleImports);
+        expect(result.zones[0].id).toBe("code-analysis");
+        expect(result.pass).toBe(1);
+    });
+    it("pass 2+: preserves previous AI names and returns only new insights", () => {
+        const previousZones = {
+            zones: [
+                { ...sampleZones[0], id: "code-analysis", name: "Code Analysis", description: "Pipeline" },
+                { ...sampleZones[1], id: "data-schema", name: "Data Schema", description: "Schemas" },
+            ],
+            crossings: sampleCrossings,
+            unzoned: [],
+            enrichmentPass: 1,
+            structureHash: "abc",
+        };
+        const pass2Response = JSON.stringify({
+            zones: [
+                { id: "code-analysis", newInsights: ["Tightly coupled with schema"] },
+                { id: "data-schema", newInsights: [] },
+            ],
+            insights: ["Consider extracting shared types"],
+        });
+        mockedExecFileSync.mockImplementationOnce(() => Buffer.from("/usr/local/bin/claude\n"));
+        mockedExecFileSync.mockImplementationOnce(() => pass2Response);
+        const result = enrichZonesWithAI(sampleZones, sampleCrossings, sampleInventory, sampleImports, previousZones);
+        expect(result.pass).toBe(2);
+        // Preserved previous names
+        expect(result.zones[0].id).toBe("code-analysis");
+        expect(result.zones[0].name).toBe("Code Analysis");
+        // Only new insights returned
+        expect(result.newZoneInsights.get("code-analysis")).toEqual([
+            "Tightly coupled with schema",
+        ]);
+        expect(result.newGlobalInsights).toEqual([
+            "Consider extracting shared types",
+        ]);
+    });
+});
+// ── analyzeZones with insights ──────────────────────────────────────────────
+describe("analyzeZones insights", () => {
+    it("generates structural insights without AI", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/a/x.ts"),
+            makeFileEntry("src/a/y.ts"),
+            makeFileEntry("src/a/z.ts"),
+        ]);
+        const imports = makeImports([
+            makeEdge("src/a/x.ts", "src/a/y.ts"),
+            makeEdge("src/a/y.ts", "src/a/z.ts"),
+            makeEdge("src/a/x.ts", "src/a/z.ts"),
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        expect(result.zones).toHaveLength(1);
+        // Should have structural insights even without AI
+        expect(result.zones[0].insights).toBeDefined();
+        expect(result.zones[0].insights.some((i) => i.includes("cohesion"))).toBe(true);
+        // Should have structureHash
+        expect(result.structureHash).toBeDefined();
+    });
+    it("assigns proximity files to reduce unzoned count", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/m/a.ts"),
+            makeFileEntry("src/m/b.ts"),
+            makeFileEntry("src/m/c.ts"),
+            makeFileEntry("src/m/README.md", { role: "docs" }),
+            makeFileEntry("src/m/styles.css", { language: "CSS", role: "other" }),
+        ]);
+        const imports = makeImports([
+            makeEdge("src/m/a.ts", "src/m/b.ts"),
+            makeEdge("src/m/b.ts", "src/m/c.ts"),
+            makeEdge("src/m/a.ts", "src/m/c.ts"),
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        // README.md and styles.css should be assigned to the zone by proximity
+        expect(result.zones[0].files).toContain("src/m/README.md");
+        expect(result.zones[0].files).toContain("src/m/styles.css");
+        expect(result.unzoned).not.toContain("src/m/README.md");
+        expect(result.unzoned).not.toContain("src/m/styles.css");
+    });
+});
+// ── computeAttemptConfigs ──────────────────────────────────────────────────
+describe("computeAttemptConfigs", () => {
+    it("returns minimum 120s base for small projects", () => {
+        const configs = computeAttemptConfigs(10, 2);
+        expect(configs[0].timeout).toBe(120_000);
+        expect(configs).toHaveLength(3);
+    });
+    it("scales with file count and zone count", () => {
+        const configs = computeAttemptConfigs(250, 15);
+        // 250 * 400 + 15 * 5000 = 100000 + 75000 = 175000
+        expect(configs[0].timeout).toBe(175_000);
+        expect(configs[1].timeout).toBe(Math.round(175_000 * 1.5));
+        expect(configs[2].timeout).toBe(175_000 * 2);
+    });
+    it("caps at 600s", () => {
+        const configs = computeAttemptConfigs(2000, 50);
+        expect(configs[0].timeout).toBe(600_000);
+        expect(configs[1].timeout).toBe(600_000);
+        expect(configs[2].timeout).toBe(600_000);
+    });
+    it("has progressively simpler maxFiles", () => {
+        const configs = computeAttemptConfigs(100, 5);
+        expect(configs[0].maxFiles).toBe(8);
+        expect(configs[1].maxFiles).toBe(3);
+        expect(configs[2].maxFiles).toBe(0);
+    });
+});
+// ── extractFindings ────────────────────────────────────────────────────────
+describe("extractFindings", () => {
+    it("extracts new-format findings from top-level array", () => {
+        const parsed = {
+            findings: [
+                { type: "pattern", scope: "global", text: "MVC pattern detected", severity: "info" },
+                { type: "relationship", scope: "api", text: "API depends on core" },
+            ],
+            zones: [],
+            insights: [],
+        };
+        const findings = extractFindings(parsed, 2, ["pattern", "relationship"]);
+        expect(findings).toHaveLength(2);
+        expect(findings[0].type).toBe("pattern");
+        expect(findings[0].pass).toBe(2);
+        expect(findings[0].severity).toBe("info");
+        expect(findings[1].type).toBe("relationship");
+        expect(findings[1].scope).toBe("api");
+    });
+    it("extracts findings from per-zone arrays", () => {
+        const parsed = {
+            zones: [
+                {
+                    id: "auth",
+                    findings: [
+                        { type: "anti-pattern", scope: "auth", text: "God class detected", severity: "warning" },
+                    ],
+                },
+            ],
+            insights: [],
+        };
+        const findings = extractFindings(parsed, 3, ["anti-pattern"]);
+        expect(findings).toHaveLength(1);
+        expect(findings[0].type).toBe("anti-pattern");
+        expect(findings[0].scope).toBe("auth");
+        expect(findings[0].severity).toBe("warning");
+    });
+    it("falls back to legacy insights when no findings present", () => {
+        const parsed = {
+            zones: [
+                { id: "core", insights: ["High cohesion zone"] },
+                { id: "util", insights: ["Helper functions"] },
+            ],
+            insights: ["Clean architecture"],
+        };
+        const findings = extractFindings(parsed, 1, ["observation"]);
+        expect(findings).toHaveLength(3);
+        expect(findings[0].type).toBe("observation");
+        expect(findings[0].scope).toBe("global");
+        expect(findings[0].text).toBe("Clean architecture");
+        expect(findings[1].scope).toBe("core");
+        expect(findings[2].scope).toBe("util");
+    });
+    it("falls back to legacy newInsights for pass 2+", () => {
+        const parsed = {
+            zones: [
+                { id: "core", newInsights: ["Needs refactoring"] },
+            ],
+            insights: [],
+        };
+        const findings = extractFindings(parsed, 2, ["pattern"]);
+        expect(findings).toHaveLength(1);
+        expect(findings[0].type).toBe("pattern");
+        expect(findings[0].scope).toBe("core");
+        expect(findings[0].text).toBe("Needs refactoring");
+    });
+    it("uses expected type as default for invalid finding types", () => {
+        const parsed = {
+            findings: [
+                { type: "invalid-type", scope: "global", text: "some finding" },
+            ],
+            zones: [],
+        };
+        const findings = extractFindings(parsed, 1, ["observation"]);
+        expect(findings[0].type).toBe("observation");
+    });
+    it("handles related array and filters non-strings", () => {
+        const parsed = {
+            findings: [
+                { type: "pattern", scope: "global", text: "test", related: ["a.ts", 42, "b.ts"] },
+            ],
+            zones: [],
+        };
+        const findings = extractFindings(parsed, 1, ["pattern"]);
+        expect(findings[0].related).toEqual(["a.ts", "b.ts"]);
+    });
+});
+// ── analyzeZones with findings ──────────────────────────────────────────────
+describe("analyzeZones findings", () => {
+    it("produces structural findings at pass 0 with enrich: false", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/a/x.ts"),
+            makeFileEntry("src/a/y.ts"),
+            makeFileEntry("src/a/z.ts"),
+        ]);
+        const imports = makeImports([
+            makeEdge("src/a/x.ts", "src/a/y.ts"),
+            makeEdge("src/a/y.ts", "src/a/z.ts"),
+            makeEdge("src/a/x.ts", "src/a/z.ts"),
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        // Should have findings array with pass 0 observations
+        expect(result.findings).toBeDefined();
+        expect(result.findings.length).toBeGreaterThan(0);
+        expect(result.findings.every((f) => f.pass === 0)).toBe(true);
+        expect(result.findings.every((f) => f.type === "observation")).toBe(true);
+    });
+    it("populates both findings and insights for backward compat", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/a/x.ts"),
+            makeFileEntry("src/a/y.ts"),
+            makeFileEntry("src/a/z.ts"),
+        ]);
+        const imports = makeImports([
+            makeEdge("src/a/x.ts", "src/a/y.ts"),
+            makeEdge("src/a/y.ts", "src/a/z.ts"),
+            makeEdge("src/a/x.ts", "src/a/z.ts"),
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        // Both old insights and new findings should be populated
+        expect(result.zones[0].insights).toBeDefined();
+        expect(result.findings).toBeDefined();
+        // Insights text should appear in findings text
+        for (const insight of result.zones[0].insights) {
+            expect(result.findings.some((f) => f.text === insight)).toBe(true);
+        }
+    });
+    it("structural findings have severity based on content", () => {
+        const inventory = makeInventory([
+            makeFileEntry("src/a/x.ts"),
+            makeFileEntry("src/a/y.ts"),
+            makeFileEntry("src/a/z.ts"),
+            makeFileEntry("src/a/w.ts"),
+            makeFileEntry("src/a/v.ts"),
+        ]);
+        const imports = makeImports([
+            makeEdge("src/a/x.ts", "src/a/y.ts"),
+            makeEdge("src/a/y.ts", "src/a/z.ts"),
+            makeEdge("src/a/z.ts", "src/a/w.ts"),
+            makeEdge("src/a/w.ts", "src/a/v.ts"),
+            // Only some internal edges → low cohesion
+        ]);
+        const result = analyzeZones(inventory, imports, { enrich: false });
+        if (result.findings) {
+            for (const f of result.findings) {
+                expect(["info", "warning", "critical"]).toContain(f.severity);
+            }
+        }
+    });
+});
+//# sourceMappingURL=zones.test.js.map