@rce-mcp/retrieval-core 0.1.2 → 0.1.3

package/test/remote-sync.integration.test.ts

@@ -70,14 +70,18 @@ describe("runRemoteDeltaSync", () => {
     expect(Object.keys(result.next_files)).toEqual(["src/keep.ts"]);
   });
 
-  it("maps .mjs and .cjs files to javascript language metadata during scans", async () => {
+  it("maps .mjs/.cjs to javascript and .mts/.cts to typescript language metadata during scans", async () => {
     const root = await createProject();
     await writeFile(join(root, "src", "runtime.mjs"), "export const runtime = true;\n");
     await writeFile(join(root, "src", "loader.cjs"), "module.exports = { loader: true };\n");
+    await writeFile(join(root, "src", "types.mts"), "export const typed = true as const;\n");
+    await writeFile(join(root, "src", "legacy.cts"), "export = { typed: true };\n");
 
     const stats = await collectProjectFileStats(root);
     expect(stats.get("src/runtime.mjs")?.language).toBe("javascript");
     expect(stats.get("src/loader.cjs")?.language).toBe("javascript");
+    expect(stats.get("src/types.mts")?.language).toBe("typescript");
+    expect(stats.get("src/legacy.cts")?.language).toBe("typescript");
   });
 
   it("applies add/modify/delete changes incrementally", async () => {

package/test/smart-cutoff.config.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import {
+  __applySmartCutoffCandidatesForTests,
+  mergeRetrievalScoringConfig,
+  resolveRetrievalScoringProfile
+} from "../src/index.js";
+
+function sampleCandidates(scores: number[]) {
+  return scores.map((score, index) => ({
+    path: `src/candidate-${index + 1}.ts`,
+    start_line: index * 10 + 1,
+    end_line: index * 10 + 5,
+    snippet: `export const candidate${index + 1} = ${score};`,
+    score,
+    reason: "semantic match" as const
+  }));
+}
+
+describe("retrieval smart cutoff", () => {
+  it("applies delta and ratio guards after the safe-harbor minimum", () => {
+    const baseline = resolveRetrievalScoringProfile("baseline");
+    const config = mergeRetrievalScoringConfig(baseline.config, {
+      rerank: {
+        smart_cutoff_enabled: true,
+        smart_cutoff_min_k: 2,
+        smart_cutoff_max_k: 8,
+        smart_cutoff_min_score: 0.25,
+        smart_cutoff_top_ratio: 0.5,
+        smart_cutoff_delta_abs: 0.2
+      }
+    }).rerank;
+
+    const output = __applySmartCutoffCandidatesForTests({
+      config,
+      candidates: sampleCandidates([0.92, 0.88, 0.56, 0.55, 0.41])
+    });
+
+    expect(output).toHaveLength(2);
+    expect(output[0]?.score).toBe(0.92);
+    expect(output[1]?.score).toBe(0.88);
+  });
+
+  it("keeps at least min_k results even when score floors are not met", () => {
+    const baseline = resolveRetrievalScoringProfile("baseline");
+    const config = mergeRetrievalScoringConfig(baseline.config, {
+      rerank: {
+        smart_cutoff_enabled: true,
+        smart_cutoff_min_k: 2,
+        smart_cutoff_max_k: 8,
+        smart_cutoff_min_score: 0.8,
+        smart_cutoff_top_ratio: 0.95,
+        smart_cutoff_delta_abs: 0.01
+      }
+    }).rerank;
+
+    const output = __applySmartCutoffCandidatesForTests({
+      config,
+      candidates: sampleCandidates([0.91, 0.31, 0.3, 0.29])
+    });
+
+    expect(output).toHaveLength(2);
+    expect(output[0]?.score).toBe(0.91);
+    expect(output[1]?.score).toBe(0.31);
+  });
+
+  it("rejects invalid smart cutoff ranges in scoring config", () => {
+    const baseline = resolveRetrievalScoringProfile("baseline");
+
+    expect(() =>
+      mergeRetrievalScoringConfig(baseline.config, {
+        rerank: {
+          smart_cutoff_min_k: 3,
+          smart_cutoff_max_k: 2
+        }
+      })
+    ).toThrow(/smart_cutoff_max_k must be >= smart_cutoff_min_k/);
+
+    expect(() =>
+      mergeRetrievalScoringConfig(baseline.config, {
+        rerank: {
+          smart_cutoff_top_ratio: 0
+        }
+      })
+    ).toThrow(/smart_cutoff_top_ratio must be in \(0, 1\]/);
+  });
+});

package/test/snippet-integrity.config.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import {
+  DEFAULT_RETRIEVAL_SNIPPET_INTEGRITY_CONFIG,
+  mergeRetrievalSnippetIntegrityConfig
+} from "../src/index.js";
+
+describe("retrieval-core snippet integrity config validation", () => {
+  it("uses dark-launch defaults", () => {
+    expect(DEFAULT_RETRIEVAL_SNIPPET_INTEGRITY_CONFIG).toMatchObject({
+      enabled: false,
+      target_languages: ["typescript", "tsx", "javascript", "jsx"],
+      max_contiguous_gap_lines: 6,
+      marker_template_version: "v1",
+      repair_enabled: false,
+      repair_max_envelope_lines: 260,
+      repair_max_snippet_chars: 3600
+    });
+  });
+
+  it("accepts valid overrides and normalizes aliases", () => {
+    const merged = mergeRetrievalSnippetIntegrityConfig(DEFAULT_RETRIEVAL_SNIPPET_INTEGRITY_CONFIG, {
+      enabled: true,
+      target_languages: ["ts", "js", "tsx"],
+      max_contiguous_gap_lines: 10,
+      repair_enabled: true,
+      repair_max_envelope_lines: 400,
+      repair_max_snippet_chars: 4200
+    });
+    expect(merged.enabled).toBe(true);
+    expect(merged.target_languages).toEqual(["typescript", "javascript", "tsx"]);
+    expect(merged.max_contiguous_gap_lines).toBe(10);
+    expect(merged.marker_template_version).toBe("v1");
+    expect(merged.repair_enabled).toBe(true);
+    expect(merged.repair_max_envelope_lines).toBe(400);
+    expect(merged.repair_max_snippet_chars).toBe(4200);
+  });
+
+  it("rejects unsupported target languages", () => {
+    expect(() =>
+      mergeRetrievalSnippetIntegrityConfig(DEFAULT_RETRIEVAL_SNIPPET_INTEGRITY_CONFIG, {
+        target_languages: ["python"]
+      })
+    ).toThrow(/unsupported target language/);
+  });
+
+  it("rejects invalid repair caps", () => {
+    expect(() =>
+      mergeRetrievalSnippetIntegrityConfig(DEFAULT_RETRIEVAL_SNIPPET_INTEGRITY_CONFIG, {
+        repair_max_envelope_lines: 0
+      })
+    ).toThrow(/repair_max_envelope_lines must be a positive integer/);
+
+    expect(() =>
+      mergeRetrievalSnippetIntegrityConfig(DEFAULT_RETRIEVAL_SNIPPET_INTEGRITY_CONFIG, {
+        repair_max_snippet_chars: -1
+      })
+    ).toThrow(/repair_max_snippet_chars must be a positive integer/);
+  });
+});