@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/ephemeral.test.js

@@ -1,111 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-describe("Ephemeral Sandbox (P5.6-ADV-02)", () => {
-    let tmpDir;
-    beforeEach(() => {
-        tmpDir = path.join(os.tmpdir(), `unerr-ephemeral-${Date.now()}`);
-        fs.mkdirSync(tmpDir, { recursive: true });
-    });
-    afterEach(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    it("connect --ephemeral creates ephemeral repo config", () => {
-        // Simulate ephemeral repo creation: a config with ephemeral: true and a TTL
-        const unerrDir = path.join(tmpDir, ".unerr");
-        fs.mkdirSync(unerrDir, { recursive: true });
-        const ttlHours = 24;
-        const expiresAt = new Date(Date.now() + ttlHours * 60 * 60 * 1000).toISOString();
-        const ephemeralConfig = {
-            repoId: "eph-repo-123",
-            orgId: "org-1",
-            branch: "main",
-            ephemeral: true,
-            expiresAt,
-        };
-        fs.writeFileSync(path.join(unerrDir, "config.json"), `${JSON.stringify(ephemeralConfig, null, 2)}\n`);
-        const raw = fs.readFileSync(path.join(unerrDir, "config.json"), "utf-8");
-        const config = JSON.parse(raw);
-        expect(config.ephemeral).toBe(true);
-        expect(config.repoId).toBe("eph-repo-123");
-        expect(new Date(config.expiresAt).getTime()).toBeGreaterThan(Date.now());
-    });
-    it("promote converts ephemeral to permanent config", () => {
-        const unerrDir = path.join(tmpDir, ".unerr");
-        fs.mkdirSync(unerrDir, { recursive: true });
-        // Start with ephemeral config
-        const ephemeralConfig = {
-            repoId: "eph-repo-456",
-            orgId: "org-1",
-            branch: "main",
-            ephemeral: true,
-            expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
-        };
-        const configPath = path.join(unerrDir, "config.json");
-        fs.writeFileSync(configPath, JSON.stringify(ephemeralConfig, null, 2));
-        // Simulate "promote" — remove ephemeral flag and expiry
-        const raw = fs.readFileSync(configPath, "utf-8");
-        const config = JSON.parse(raw);
-        config.ephemeral = undefined;
-        config.expiresAt = undefined;
-        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-        const promoted = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-        expect(promoted.repoId).toBe("eph-repo-456");
-        expect(promoted.ephemeral).toBeUndefined();
-        expect(promoted.expiresAt).toBeUndefined();
-    });
-    it("ephemeral repo has TTL that can be checked", () => {
-        const ttlHours = 2;
-        const expiresAt = new Date(Date.now() + ttlHours * 60 * 60 * 1000);
-        // Check if expired
-        const isExpired = expiresAt.getTime() < Date.now();
-        expect(isExpired).toBe(false);
-        // Simulate an already-expired ephemeral repo
-        const pastExpiry = new Date(Date.now() - 1000);
-        const isPastExpired = pastExpiry.getTime() < Date.now();
-        expect(isPastExpired).toBe(true);
-    });
-    it("ephemeral config includes all required fields", () => {
-        const ephemeralConfig = {
-            repoId: "eph-repo-789",
-            orgId: "org-1",
-            branch: "main",
-            ephemeral: true,
-            expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
-        };
-        // Validate required fields
-        expect(ephemeralConfig.repoId).toBeTruthy();
-        expect(ephemeralConfig.orgId).toBeTruthy();
-        expect(ephemeralConfig.branch).toBeTruthy();
-        expect(ephemeralConfig.ephemeral).toBe(true);
-        expect(ephemeralConfig.expiresAt).toBeTruthy();
-    });
-    it("expired ephemeral repos are detectable for cleanup", () => {
-        // Simulate multiple ephemeral configs, some expired
-        const configs = [
-            {
-                repoId: "eph-1",
-                expiresAt: new Date(Date.now() + 1000).toISOString(),
-                ephemeral: true,
-            },
-            {
-                repoId: "eph-2",
-                expiresAt: new Date(Date.now() - 1000).toISOString(),
-                ephemeral: true,
-            },
-            {
-                repoId: "eph-3",
-                expiresAt: new Date(Date.now() - 5000).toISOString(),
-                ephemeral: true,
-            },
-            { repoId: "perm-1", ephemeral: false, expiresAt: undefined },
-        ];
-        const expired = configs.filter((c) => c.ephemeral &&
-            c.expiresAt &&
-            new Date(c.expiresAt).getTime() < Date.now());
-        expect(expired.length).toBe(2);
-        expect(expired.map((c) => c.repoId)).toContain("eph-2");
-        expect(expired.map((c) => c.repoId)).toContain("eph-3");
-    });
-});

package/dist/__tests__/exploration-cost.test.js

@@ -1,93 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { estimateExplorationCost } from "../intelligence/exploration-cost.js";
-describe("exploration-cost — MCP tool alias resolution", () => {
-    it("get_references resolves to find_callers rule (not DEFAULT_RULE)", () => {
-        const aliased = estimateExplorationCost("get_references", 5);
-        const target = estimateExplorationCost("find_callers", 5);
-        expect(aliased.tokensWithout).toBe(target.tokensWithout);
-        expect(aliased.counterfactualMethod).toBe(target.counterfactualMethod);
-    });
-    it("search_code resolves to search_entities rule", () => {
-        const aliased = estimateExplorationCost("search_code", 8);
-        const target = estimateExplorationCost("search_entities", 8);
-        expect(aliased.tokensWithout).toBe(target.tokensWithout);
-        expect(aliased.counterfactualMethod).toBe(target.counterfactualMethod);
-    });
-    it("get_conventions resolves to show_conventions rule", () => {
-        const aliased = estimateExplorationCost("get_conventions", 0, 12);
-        const target = estimateExplorationCost("show_conventions", 0, 12);
-        expect(aliased.tokensWithout).toBe(target.tokensWithout);
-    });
-    it("get_critical_nodes resolves to risk_assessment rule", () => {
-        const aliased = estimateExplorationCost("get_critical_nodes", 4);
-        const target = estimateExplorationCost("risk_assessment", 4);
-        expect(aliased.tokensWithout).toBe(target.tokensWithout);
-    });
-    it("get_cross_boundary_links resolves to risk_assessment rule", () => {
-        const aliased = estimateExplorationCost("get_cross_boundary_links", 6);
-        const target = estimateExplorationCost("risk_assessment", 6);
-        expect(aliased.tokensWithout).toBe(target.tokensWithout);
-    });
-    it("file_connections resolves to risk_assessment rule", () => {
-        const aliased = estimateExplorationCost("file_connections", 3);
-        const target = estimateExplorationCost("risk_assessment", 3);
-        expect(aliased.tokensWithout).toBe(target.tokensWithout);
-    });
-    it("file_outline falls through to DEFAULT_RULE (returns N entities, not 1)", () => {
-        // Intentionally NOT aliased: get_entity assumes 1 returned entity and yields
-        // negative savings as resultSize grows. DEFAULT_RULE scales positively with N.
-        const result = estimateExplorationCost("file_outline", 15);
-        // DEFAULT_RULE: 150 + ceil(15/2)*400 = 150 + 8*400 = 3350
-        expect(result.tokensWithout).toBe(150 + 8 * 400);
-        expect(result.counterfactualMethod).toBe("generic file exploration");
-    });
-    it("get_imports resolves to find_callers rule", () => {
-        const aliased = estimateExplorationCost("get_imports", 10);
-        const target = estimateExplorationCost("find_callers", 10);
-        expect(aliased.tokensWithout).toBe(target.tokensWithout);
-    });
-    it("get_test_coverage resolves to find_callers rule", () => {
-        const aliased = estimateExplorationCost("get_test_coverage", 7);
-        const target = estimateExplorationCost("find_callers", 7);
-        expect(aliased.tokensWithout).toBe(target.tokensWithout);
-    });
-    it("get_file resolves to get_entity rule", () => {
-        const aliased = estimateExplorationCost("get_file", 1);
-        const target = estimateExplorationCost("get_entity", 1);
-        expect(aliased.tokensWithout).toBe(target.tokensWithout);
-    });
-    it("file_read falls through to DEFAULT_RULE (has its own dedicated mechanism)", () => {
-        // file_read is tracked via mechanism="file_read" with full-file counterfactual.
-        // Letting it also alias graph_query would double-count. Keep it on DEFAULT_RULE
-        // so graph_query events fire (when positive) without inheriting get_entity math.
-        const result = estimateExplorationCost("file_read", 4);
-        // DEFAULT_RULE: 150 + ceil(4/2)*400 = 150 + 2*400 = 950
-        expect(result.tokensWithout).toBe(150 + 2 * 400);
-        expect(result.counterfactualMethod).toBe("generic file exploration");
-    });
-    it("get_project_stats resolves to health_grade rule", () => {
-        const aliased = estimateExplorationCost("get_project_stats", 0, 50);
-        const target = estimateExplorationCost("health_grade", 0, 50);
-        expect(aliased.tokensWithout).toBe(target.tokensWithout);
-    });
-    it("legacy keys still resolve directly (not regressed by alias layer)", () => {
-        // blast_radius and find_callers are still used internally — must remain stable
-        const blast = estimateExplorationCost("blast_radius", 4);
-        expect(blast.counterfactualMethod).toContain("read each caller file");
-        const callers = estimateExplorationCost("find_callers", 4);
-        expect(callers.counterfactualMethod).toContain("grep + read");
-    });
-    it("unknown tool name still falls through to DEFAULT_RULE", () => {
-        const result = estimateExplorationCost("totally_unknown_tool", 4);
-        // DEFAULT_RULE: fileMultiplier = ceil(resultSize / 2) = 2, tokensPerFile = 400, baseTokens = 150
-        expect(result.tokensWithout).toBe(150 + 2 * 400);
-        expect(result.counterfactualMethod).toBe("generic file exploration");
-    });
-    it("aliased tools beat DEFAULT_RULE on at least one shape", () => {
-        // search_code with 10 results: search_entities gives 200 + min(10,20)*500 = 5200
-        // DEFAULT_RULE would give 150 + ceil(10/2)*400 = 2150
-        // Confirms the alias is actually changing the calculation
-        const aliased = estimateExplorationCost("search_code", 10);
-        expect(aliased.tokensWithout).toBe(200 + 10 * 500);
-    });
-});

package/dist/__tests__/fact-generator.test.js

@@ -1,197 +0,0 @@
-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 { generateFromCausalBridge, generateFromConventions, generateFromNegativeKnowledge, generateFromSessionAnalysis, } from "../intelligence/fact-generator.js";
-import { initFactsSchema } from "../intelligence/facts-schema.js";
-import { TemporalFactStore } from "../intelligence/temporal-facts.js";
-async function createTestDb() {
-    const cozoModule = await import("cozo-node");
-    const CozoDbConstructor = cozoModule.default
-        ? cozoModule.default.CozoDb
-        : cozoModule.CozoDb;
-    return new CozoDbConstructor("mem", "");
-}
-function makeSessionRecord(overrides = {}) {
-    return {
-        session_id: `sess-${Math.random().toString(36).slice(2, 8)}`,
-        written_at: new Date().toISOString(),
-        started_at: new Date(Date.now() - 3600000).toISOString(),
-        ended_at: new Date().toISOString(),
-        duration_ms: 3600000,
-        tool_calls: 20,
-        chains: 5,
-        files_modified: ["src/proxy.ts", "src/auth.ts"],
-        entities_touched: ["src/proxy.ts::startProxy"],
-        tools_used: { get_function: 10, file_read: 10 },
-        feature_areas: ["src/proxy"],
-        facts_recorded: 0,
-        facts_surfaced: [],
-        revert_count: 0,
-        rot_score: 0.1,
-        token_estimate: 10000,
-        branch: "main",
-        ...overrides,
-    };
-}
-describe("fact-generator", () => {
-    let db;
-    let store;
-    let testDir;
-    beforeEach(async () => {
-        db = await createTestDb();
-        await initFactsSchema(db);
-        store = TemporalFactStore.fromDb(db);
-        testDir = join(tmpdir(), `unerr-factgen-${Date.now()}`);
-        mkdirSync(testDir, { recursive: true });
-    });
-    afterEach(() => {
-        try {
-            rmSync(testDir, { recursive: true, force: true });
-        }
-        catch {
-            // best-effort
-        }
-    });
-    describe("generateFromConventions", () => {
-        it("creates facts for conventions with >70% adherence", async () => {
-            const conventions = [
-                {
-                    key: "conv-1",
-                    kind: "naming",
-                    name: "camelCase functions",
-                    detail: "^[a-z][a-zA-Z]*$",
-                    exemplarKeys: ["src/proxy/startProxy.ts"],
-                    frequency: 20,
-                    confidence: 0.85,
-                },
-            ];
-            const result = await generateFromConventions(store, conventions);
-            expect(result.created).toBe(1);
-            expect(result.source).toBe("convention_detector");
-            expect(result.details[0]).toContain("camelCase functions");
-        });
-        it("skips conventions below 70% adherence", async () => {
-            const conventions = [
-                {
-                    key: "conv-low",
-                    kind: "naming",
-                    name: "snake_case",
-                    detail: ".*",
-                    exemplarKeys: [],
-                    frequency: 10,
-                    confidence: 0.5,
-                },
-            ];
-            const result = await generateFromConventions(store, conventions);
-            expect(result.created).toBe(0);
-        });
-        it("skips conventions with too few entities", async () => {
-            const conventions = [
-                {
-                    key: "conv-few",
-                    kind: "structure",
-                    name: "rare pattern",
-                    detail: ".*",
-                    exemplarKeys: [],
-                    frequency: 2,
-                    confidence: 0.95,
-                },
-            ];
-            const result = await generateFromConventions(store, conventions);
-            expect(result.created).toBe(0);
-        });
-    });
-    describe("generateFromNegativeKnowledge", () => {
-        it("creates negative facts from correction entries", async () => {
-            const corrections = [
-                {
-                    id: "corr-1",
-                    entityKey: "src/auth.ts",
-                    pattern: "modified-then-reverted",
-                    reason: "File src/auth.ts was modified and reverted. The approach was incorrect.",
-                    detectedAt: new Date().toISOString(),
-                    rewindEntryId: "rewind-001",
-                    confidence: 0.7,
-                },
-            ];
-            const result = await generateFromNegativeKnowledge(store, corrections);
-            expect(result.created).toBe(1);
-            expect(result.source).toBe("negative_knowledge");
-            const recalled = await store.recallByScope("src/auth.ts", 0);
-            expect(recalled.length).toBe(1);
-            expect(recalled[0].fact_type).toBe("negative");
-        });
-    });
-    describe("generateFromCausalBridge", () => {
-        it("creates episodic facts for survived changes", async () => {
-            const events = [
-                {
-                    session_id: "sess-1",
-                    entity_key: "src/proxy.ts::startProxy",
-                    action: "survived",
-                    branch: "main",
-                    timestamp: Date.now() - 86400000,
-                },
-            ];
-            const result = await generateFromCausalBridge(store, events);
-            expect(result.created).toBe(1);
-            expect(result.details[0]).toContain("survived");
-        });
-        it("creates negative facts for reverted changes", async () => {
-            const events = [
-                {
-                    session_id: "sess-2",
-                    entity_key: "src/config.ts",
-                    action: "reverted",
-                    branch: "main",
-                    timestamp: Date.now() - 86400000,
-                },
-            ];
-            const result = await generateFromCausalBridge(store, events);
-            expect(result.created).toBe(1);
-            expect(result.details[0]).toContain("reverted");
-            const recalled = await store.recallByScope("src/config.ts", 0);
-            expect(recalled[0].fact_type).toBe("negative");
-        });
-    });
-    describe("generateFromSessionAnalysis", () => {
-        it("detects hot files from multiple sessions", async () => {
-            const sessionsDir = join(testDir, "sessions");
-            mkdirSync(sessionsDir, { recursive: true });
-            for (let i = 0; i < 5; i++) {
-                const record = makeSessionRecord({
-                    session_id: `s${i}`,
-                    files_modified: ["src/proxy.ts", "src/auth.ts", `src/other${i}.ts`],
-                });
-                writeFileSync(join(sessionsDir, `s${i}.jsonl`), `${JSON.stringify(record)}\n`, "utf-8");
-            }
-            const result = await generateFromSessionAnalysis(store, testDir);
-            expect(result.created).toBeGreaterThan(0);
-            expect(result.details.some((d) => d.includes("src/proxy.ts"))).toBe(true);
-        });
-        it("detects high-revert files", async () => {
-            const sessionsDir = join(testDir, "sessions");
-            mkdirSync(sessionsDir, { recursive: true });
-            for (let i = 0; i < 5; i++) {
-                const record = makeSessionRecord({
-                    session_id: `s${i}`,
-                    files_modified: ["src/fragile.ts"],
-                    revert_count: i < 3 ? 1 : 0, // 3 out of 5 sessions have reverts
-                });
-                writeFileSync(join(sessionsDir, `s${i}.jsonl`), `${JSON.stringify(record)}\n`, "utf-8");
-            }
-            const result = await generateFromSessionAnalysis(store, testDir);
-            const fragileDetail = result.details.find((d) => d.includes("src/fragile.ts"));
-            expect(fragileDetail).toBeDefined();
-        });
-        it("returns empty when fewer than 3 sessions", async () => {
-            const sessionsDir = join(testDir, "sessions");
-            mkdirSync(sessionsDir, { recursive: true });
-            const record = makeSessionRecord();
-            writeFileSync(join(sessionsDir, "s1.jsonl"), `${JSON.stringify(record)}\n`, "utf-8");
-            const result = await generateFromSessionAnalysis(store, testDir);
-            expect(result.created).toBe(0);
-        });
-    });
-});

package/dist/__tests__/file-l0-graph.test.js

@@ -1,244 +0,0 @@
-/**
- * Sprint R.10: File-as-L0 Graph Enrichment Tests
- *
- * Verifies:
- *   - File entities created for every indexed file
- *   - Contains edges from file→entity guarantee zero orphans
- *   - File→file import edges created from cross-file resolution
- *   - Co-change edge computation from git history
- *   - Community detection handles weighted contains edges
- *   - Blast radius falls back to file siblings when no callers exist
- *   - File-level queries (getFileEntities, getFileNeighbors) work correctly
- */
-import { describe, expect, it } from "vitest";
-import { resolveCrossFileEdges } from "../intelligence/indexer/cross-file-resolver.js";
-import { computeCoChangeEdges } from "../intelligence/indexer/git-cochange.js";
-import { resolveImportSourceToFile } from "../intelligence/local-indexer.js";
-describe("Sprint R: File-as-L0 Graph Enrichment", () => {
-    describe("R.3: Cross-file resolver emits file import edges", () => {
-        it("produces file→file import edges alongside entity resolution", () => {
-            const fileResults = new Map([
-                [
-                    "src/a.ts",
-                    {
-                        entities: [
-                            {
-                                key: "src/a.ts::fnA",
-                                name: "fnA",
-                                exported: true,
-                                kind: "function",
-                                file_path: "src/a.ts",
-                            },
-                        ],
-                        edges: [
-                            {
-                                from_key: "src/a.ts::fnA",
-                                to_key: "unresolved:fnB",
-                                type: "calls",
-                                file_path: "src/a.ts",
-                                line: 5,
-                            },
-                        ],
-                        imports: [
-                            {
-                                source: "src/b.ts",
-                                symbols: ["fnB"],
-                                isDefault: false,
-                                isNamespace: false,
-                                localName: undefined,
-                                line: 1,
-                            },
-                        ],
-                    },
-                ],
-                [
-                    "src/b.ts",
-                    {
-                        entities: [
-                            {
-                                key: "src/b.ts::fnB",
-                                name: "fnB",
-                                exported: true,
-                                kind: "function",
-                                file_path: "src/b.ts",
-                            },
-                        ],
-                        edges: [],
-                        imports: [],
-                    },
-                ],
-            ]);
-            const result = resolveCrossFileEdges(fileResults);
-            // Should have file→file import edges
-            expect(result.fileImportEdges.length).toBeGreaterThan(0);
-            const fileEdge = result.fileImportEdges.find((e) => e.from_key === "file:src/a.ts" && e.to_key === "file:src/b.ts");
-            expect(fileEdge).toBeDefined();
-            expect(fileEdge.type).toBe("imports");
-        });
-        it("deduplicates file import edges (multiple imports from same file)", () => {
-            const fileResults = new Map([
-                [
-                    "src/a.ts",
-                    {
-                        entities: [
-                            {
-                                key: "src/a.ts::fnA",
-                                name: "fnA",
-                                exported: true,
-                                kind: "function",
-                                file_path: "src/a.ts",
-                            },
-                        ],
-                        edges: [],
-                        imports: [
-                            {
-                                source: "src/b.ts",
-                                symbols: ["fnB"],
-                                isDefault: false,
-                                isNamespace: false,
-                                localName: undefined,
-                                line: 1,
-                            },
-                            {
-                                source: "src/b.ts",
-                                symbols: ["fnC"],
-                                isDefault: false,
-                                isNamespace: false,
-                                localName: undefined,
-                                line: 1,
-                            },
-                        ],
-                    },
-                ],
-                [
-                    "src/b.ts",
-                    {
-                        entities: [
-                            {
-                                key: "src/b.ts::fnB",
-                                name: "fnB",
-                                exported: true,
-                                kind: "function",
-                                file_path: "src/b.ts",
-                            },
-                            {
-                                key: "src/b.ts::fnC",
-                                name: "fnC",
-                                exported: true,
-                                kind: "function",
-                                file_path: "src/b.ts",
-                            },
-                        ],
-                        edges: [],
-                        imports: [],
-                    },
-                ],
-            ]);
-            const result = resolveCrossFileEdges(fileResults);
-            // Only one file→file edge despite two import declarations
-            const fileEdges = result.fileImportEdges.filter((e) => e.from_key === "file:src/a.ts" && e.to_key === "file:src/b.ts");
-            expect(fileEdges).toHaveLength(1);
-        });
-    });
-    describe("R.4: Git co-change computation", () => {
-        it("computes co-change edges from the current repo", () => {
-            // This test runs against the actual unerr-cli repo
-            const edges = computeCoChangeEdges(process.cwd(), 50, 10, 2);
-            // Should find at least some co-change pairs in a real repo
-            expect(edges.length).toBeGreaterThanOrEqual(0);
-            // If there are results, verify structure
-            if (edges.length > 0) {
-                const first = edges[0];
-                expect(first.from_file).toBeTruthy();
-                expect(first.to_file).toBeTruthy();
-                expect(first.co_occurrences).toBeGreaterThanOrEqual(2);
-                expect(first.correlation).toBeGreaterThan(0);
-                expect(first.correlation).toBeLessThanOrEqual(1);
-            }
-        });
-        it("returns empty for non-git directory", () => {
-            const edges = computeCoChangeEdges("/tmp", 50, 10, 2);
-            expect(edges).toHaveLength(0);
-        });
-    });
-    describe("R.1/R.2: File entity and contains edge verification (integration)", () => {
-        it("ingestIndexResult creates file entities for each unique file path", async () => {
-            // This is a unit-level check of the ingest function's contract
-            // Full integration test requires CozoDB instance
-            const { basename } = await import("node:path");
-            // Verify the file key convention
-            const filePath = "src/utils/exec.ts";
-            const fileKey = `file:${filePath}`;
-            expect(fileKey).toBe("file:src/utils/exec.ts");
-            expect(basename(filePath)).toBe("exec.ts");
-        });
-        it("file entity keys use file: prefix to avoid collisions", () => {
-            // Entity keys use filepath::name format (e.g., "src/a.ts::fnA")
-            // File keys use file:filepath format (e.g., "file:src/a.ts")
-            const entityKey = "src/a.ts::fnA";
-            const fileKey = "file:src/a.ts";
-            // They must not collide
-            expect(entityKey).not.toBe(fileKey);
-            expect(fileKey.startsWith("file:")).toBe(true);
-            expect(entityKey.startsWith("file:")).toBe(false);
-        });
-    });
-    describe("R.3 Multi-language: resolveImportSourceToFile", () => {
-        const projectFiles = new Set([
-            "src/utils/helper.ts",
-            "src/utils/index.ts",
-            "src/commands/status.ts",
-            "app/models/user.py",
-            "app/models/__init__.py",
-            "app/services/auth.py",
-            "pkg/handlers/auth.go",
-            "pkg/models/user.go",
-            "internal/db/connection.go",
-            "com/example/service/UserService.java",
-            "com/example/models/User.java",
-            "src/module/sub.rs",
-            "src/module/mod.rs",
-            "src/lib.rs",
-            "lib/models/user.rb",
-            "lib/services/auth.rb",
-            "Services/UserService.cs",
-            "Models/User.cs",
-        ]);
-        it("resolves TS/JS relative imports", () => {
-            expect(resolveImportSourceToFile("./helper", "src/utils/status.ts", projectFiles)).toBe("src/utils/helper.ts");
-            expect(resolveImportSourceToFile("../commands/status", "src/utils/helper.ts", projectFiles)).toBe("src/commands/status.ts");
-            // Index file resolution (../utils from commands/ → src/utils/index.ts)
-            expect(resolveImportSourceToFile("../utils", "src/commands/status.ts", projectFiles)).toBe("src/utils/index.ts");
-        });
-        it("resolves Python dotted module paths", () => {
-            expect(resolveImportSourceToFile("models.user", "app/services/auth.py", projectFiles)).toBe("app/models/user.py");
-            // __init__.py as directory index
-            expect(resolveImportSourceToFile("models", "app/services/auth.py", projectFiles)).toBe("app/models/__init__.py");
-        });
-        it("resolves Go package paths by suffix matching", () => {
-            expect(resolveImportSourceToFile("github.com/myapp/pkg/handlers", "cmd/main.go", projectFiles)).toBe("pkg/handlers/auth.go");
-        });
-        it("resolves Java dot-separated package paths", () => {
-            expect(resolveImportSourceToFile("com.example.models.User", "com/example/service/UserService.java", projectFiles)).toBe("com/example/models/User.java");
-        });
-        it("resolves Rust crate paths", () => {
-            expect(resolveImportSourceToFile("crate::module::sub", "src/lib.rs", projectFiles)).toBe("src/module/sub.rs");
-            // Rust mod.rs as directory index
-            expect(resolveImportSourceToFile("crate::module", "src/lib.rs", projectFiles)).toBe("src/module/mod.rs");
-        });
-        it("resolves Ruby require paths", () => {
-            expect(resolveImportSourceToFile("models/user", "lib/services/auth.rb", projectFiles)).toBe("lib/models/user.rb");
-        });
-        it("resolves C# namespace paths", () => {
-            expect(resolveImportSourceToFile("Models.User", "Services/UserService.cs", projectFiles)).toBe("Models/User.cs");
-        });
-        it("returns null for external/unresolvable imports", () => {
-            // npm package
-            expect(resolveImportSourceToFile("lodash", "src/utils/helper.ts", projectFiles)).toBeNull();
-            // Python stdlib
-            expect(resolveImportSourceToFile("os.path", "app/services/auth.py", projectFiles)).toBeNull();
-            // Go stdlib
-            expect(resolveImportSourceToFile("fmt", "pkg/handlers/auth.go", projectFiles)).toBeNull();
-        });
-    });
-});