@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/__tests__/ephemeral.test.js

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

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

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

@@ -0,0 +1,244 @@
+/**
+ * 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();
+        });
+    });
+});