@rce-mcp/retrieval-core 0.1.0 → 0.1.2

package/test/mcp-search-quality.regression.test.ts

@@ -0,0 +1,322 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { SqliteIndexRepository, SqliteQueryCache } from "@rce-mcp/data-plane";
+import { RetrievalCore } from "../src/index.js";
+
+function firstRank(results: Array<{ path: string }>, path: string): number {
+  const index = results.findIndex((row) => row.path === path);
+  return index >= 0 ? index + 1 : Number.POSITIVE_INFINITY;
+}
+
+function buildLongCircuitBreakerFixture(): string {
+  const lines: string[] = [
+    "export interface RiskState {",
+    "  accountId: string;",
+    "  pnlSeries: number[];",
+    "  window: number[];",
+    "}",
+    "",
+    "const HARD_DRAWDOWN_LIMIT_BPS = 650;",
+    "const RISK_ACCUMULATOR_LIMIT = 25_000;",
+    "",
+    "function calculateDrawdownBps(values: number[], checksum: number): number {",
+    "  return values.length > 0 ? Math.max(...values) + (checksum % 7) : checksum % 7;",
+    "}",
+    "",
+    "function captureWindowChecksum(values: number[]): number {",
+    "  return values.reduce((sum, value) => sum + value, 0);",
+    "}",
+    "",
+    "function publishTripEvent(input: { reason: string; drawdownBps: number; riskAccumulator: number }) {",
+    "  return { eventId: `${input.reason}-${input.drawdownBps}-${input.riskAccumulator}` };",
+    "}",
+    "",
+    "function freezeOrderEntry(accountId: string, eventId: string): void {",
+    "  void accountId;",
+    "  void eventId;",
+    "}",
+    "",
+    "function recordTripAuditLog(accountId: string, eventId: string, checksum: number): string {",
+    "  void accountId;",
+    "  void eventId;",
+    "  return `${eventId}-${checksum}`;",
+    "}",
+    "",
+    "export function evaluateCircuitBreaker(state: RiskState): boolean {",
+    "  const startWindowChecksum = captureWindowChecksum(state.window);",
+    "  const drawdownBps = calculateDrawdownBps(state.pnlSeries, startWindowChecksum);",
+    "  const circuitActivationSeed = state.window.length + state.accountId.length;",
+    "  let riskAccumulator = 0;"
+  ];
+  for (let i = 0; i < 35; i += 1) {
+    lines.push(`  riskAccumulator += state.window[${i}] ?? 0;`);
+  }
+  lines.push(
+    "  const shouldTrip = drawdownBps >= HARD_DRAWDOWN_LIMIT_BPS || riskAccumulator >= RISK_ACCUMULATOR_LIMIT;",
+    "  if (!shouldTrip) {",
+    "    return false;",
+    "  }",
+    "  const tripEvent = publishTripEvent({",
+    "    reason: 'hard-drawdown',",
+    "    drawdownBps,",
+    "    riskAccumulator",
+    "  });",
+    "  const tripAuditDigest = recordTripAuditLog(state.accountId, tripEvent.eventId, startWindowChecksum);",
+    "  freezeOrderEntry(state.accountId, tripAuditDigest);",
+    "  return true;",
+    "}"
+  );
+  return lines.join("\n");
+}
+
+describe("mcp search quality regressions", () => {
+  const dirs: string[] = [];
+
+  afterEach(async () => {
+    while (dirs.length > 0) {
+      const dir = dirs.pop();
+      if (dir) {
+        await rm(dir, { recursive: true, force: true });
+      }
+    }
+  });
+
+  it("keeps MCP enforcement/config targets in top results and suppresses guidance noise", async () => {
+    const root = await mkdtemp(join(tmpdir(), "rce-mcp-quality-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "mcp-quality.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-mcp",
+      tenant_id: "tenant-mcp",
+      name: "mcp",
+      project_root_path: "/workspace/mcp"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    try {
+      await core.indexArtifact({
+        tenant_id: "tenant-mcp",
+        workspace_id: "ws-mcp",
+        index_version: "idx-mcp-v1",
+        files: [
+          {
+            path: "apps/mcp-api/src/server.ts",
+            language: "typescript",
+            content: `
+              export function resolveMcpAuthContext() {}
+              export function assertSessionMatchesAuth() {}
+              export function enforceMcpTenantBinding() {}
+              export function streamableHttpMcpRoute() {}
+            `
+          },
+          {
+            path: "apps/mcp-api/src/state.ts",
+            language: "typescript",
+            content: `
+              export const RCE_MCP_TOKEN_BINDINGS_JSON = "RCE_MCP_TOKEN_BINDINGS_JSON";
+              export function parseMcpTokenBindingsJson(raw: string) { return raw; }
+              export function resolveMcpAuthConfigFromEnv() { return { tenant_id: "t", workspace_id: "w", project_root_path: "/p" }; }
+            `
+          },
+          {
+            path: "apps/mcp-api/src/mcp-stdio.ts",
+            language: "typescript",
+            content: `
+              export function bootstrapRemoteProxy() {}
+              export function runRemoteMcpStdioServer() {}
+              export const REMOTE_BINDING_FIELDS = ["workspace_id", "project_root_path"];
+            `
+          },
+          {
+            path: "apps/mcp-api/src/mcp-tool-guidance.ts",
+            language: "typescript",
+            content: `
+              // guidance-only text containing overlapping auth/config terms
+              export const GUIDE = "tenant_id workspace_id project_root_path token binding mcp security config";
+            `
+          },
+          {
+            path: "apps/mcp-api/src/tools/search-context.ts",
+            language: "typescript",
+            content: "export function searchContextTool() { return 'tool'; }"
+          },
+          {
+            path: "apps/mcp-api/src/tools/enhance-prompt.ts",
+            language: "typescript",
+            content: "export function enhancePromptTool() { return 'tool'; }"
+          },
+          {
+            path: "apps/mcp-api/src/docs/reference.md",
+            language: "markdown",
+            content: "MCP docs reference for tokens, tenant_id, workspace_id, and project_root_path."
+          }
+        ]
+      });
+
+      const enforcement = await core.searchContext({
+        trace_id: "trc-mcp-enforcement",
+        tenant_id: "tenant-mcp",
+        workspace_id: "ws-mcp",
+        request: {
+          project_root_path: "/workspace/mcp",
+          query: "resolveMcpAuthContext enforceMcpTenantBinding assertSessionMatchesAuth streamable HTTP /mcp",
+          top_k: 8,
+          filters: { path_prefix: "apps/mcp-api/src" }
+        }
+      });
+
+      const config = await core.searchContext({
+        trace_id: "trc-mcp-config",
+        tenant_id: "tenant-mcp",
+        workspace_id: "ws-mcp",
+        request: {
+          project_root_path: "/workspace/mcp",
+          query: "RCE_MCP_TOKEN_BINDINGS_JSON parse token bindings tenant_id workspace_id project_root_path",
+          top_k: 6,
+          filters: { path_prefix: "apps/mcp-api/src" }
+        }
+      });
+
+      const stdio = await core.searchContext({
+        trace_id: "trc-mcp-stdio",
+        tenant_id: "tenant-mcp",
+        workspace_id: "ws-mcp",
+        request: {
+          project_root_path: "/workspace/mcp",
+          query: "mcp-stdio remote bootstrap token binding workspace_id project_root_path",
+          top_k: 6,
+          filters: { path_prefix: "apps/mcp-api/src" }
+        }
+      });
+
+      const enforcementTarget = firstRank(enforcement.results, "apps/mcp-api/src/server.ts");
+      const configTarget = firstRank(config.results, "apps/mcp-api/src/state.ts");
+      const stdioTarget = firstRank(stdio.results, "apps/mcp-api/src/mcp-stdio.ts");
+      const enforcementGuidance = firstRank(enforcement.results, "apps/mcp-api/src/mcp-tool-guidance.ts");
+      const configGuidance = firstRank(config.results, "apps/mcp-api/src/mcp-tool-guidance.ts");
+
+      expect(enforcementTarget).toBeLessThanOrEqual(3);
+      expect(configTarget).toBeLessThanOrEqual(3);
+      expect(stdioTarget).toBeLessThanOrEqual(3);
+      expect(enforcementGuidance).toBeGreaterThan(enforcementTarget);
+      expect(configGuidance).toBeGreaterThan(configTarget);
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+
+  it("returns larger, more complete snippets with upgraded chunk windows", async () => {
+    const root = await mkdtemp(join(tmpdir(), "rce-mcp-snippet-quality-"));
+    dirs.push(root);
+    const sqlitePath = join(root, "mcp-snippet-quality.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-snippet-legacy",
+      tenant_id: "tenant-snippet",
+      name: "snippet-quality-legacy",
+      project_root_path: "/workspace/snippet-legacy"
+    });
+    await repo.upsertWorkspace({
+      workspace_id: "ws-snippet-upgraded",
+      tenant_id: "tenant-snippet",
+      name: "snippet-quality-upgraded",
+      project_root_path: "/workspace/snippet-upgraded"
+    });
+
+    const cache = new SqliteQueryCache(sqlitePath);
+    const legacyCore = new RetrievalCore(repo, cache, {
+      chunkingConfig: {
+        strategy: "sliding",
+        target_chunk_tokens: 220,
+        chunk_overlap_tokens: 40
+      }
+    });
+    const upgradedCore = new RetrievalCore(repo, cache, {
+      chunkingConfig: {
+        strategy: "sliding",
+        target_chunk_tokens: 420,
+        chunk_overlap_tokens: 90
+      }
+    });
+
+    try {
+      const files = [
+        {
+          path: "packages/shared/src/risk/circuit-breaker.ts",
+          language: "typescript",
+          content: buildLongCircuitBreakerFixture()
+        },
+        {
+          path: "docs/risk-architecture.md",
+          language: "markdown",
+          content: "High-level risk architecture notes: circuit breaker policy, drawdown thresholds, and account controls."
+        }
+      ] as const;
+
+      await legacyCore.indexArtifact({
+        tenant_id: "tenant-snippet",
+        workspace_id: "ws-snippet-legacy",
+        index_version: "idx-snippet-legacy-v1",
+        files: [...files]
+      });
+      await upgradedCore.indexArtifact({
+        tenant_id: "tenant-snippet",
+        workspace_id: "ws-snippet-upgraded",
+        index_version: "idx-snippet-upgraded-v1",
+        files: [...files]
+      });
+
+      const query = "evaluateCircuitBreaker circuitActivationSeed tripAuditDigest freezeOrderEntry hard drawdown";
+      const legacyRetrieval = await legacyCore.searchContext({
+        trace_id: "trc-snippet-completeness-legacy",
+        tenant_id: "tenant-snippet",
+        workspace_id: "ws-snippet-legacy",
+        request: {
+          project_root_path: "/workspace/snippet-legacy",
+          query,
+          top_k: 5
+        }
+      });
+      const upgradedRetrieval = await upgradedCore.searchContext({
+        trace_id: "trc-snippet-completeness-upgraded",
+        tenant_id: "tenant-snippet",
+        workspace_id: "ws-snippet-upgraded",
+        request: {
+          project_root_path: "/workspace/snippet-upgraded",
+          query,
+          top_k: 5
+        }
+      });
+
+      const targetPath = "packages/shared/src/risk/circuit-breaker.ts";
+      const legacyTop = legacyRetrieval.results.find((row) => row.path === targetPath);
+      const upgradedTop = upgradedRetrieval.results.find((row) => row.path === targetPath);
+      expect(legacyTop).toBeDefined();
+      expect(upgradedTop).toBeDefined();
+
+      const legacySpan = (legacyTop?.end_line ?? 0) - (legacyTop?.start_line ?? 0);
+      const upgradedSpan = (upgradedTop?.end_line ?? 0) - (upgradedTop?.start_line ?? 0);
+      expect(upgradedSpan).toBeGreaterThan(legacySpan);
+      expect((upgradedTop?.snippet.length ?? 0)).toBeGreaterThan(legacyTop?.snippet.length ?? 0);
+
+      const tokenCoverage = (snippet: string | undefined): number =>
+        ["circuitActivationSeed", "tripAuditDigest", "freezeOrderEntry"].filter((token) => snippet?.includes(token))
+          .length;
+      expect(tokenCoverage(upgradedTop?.snippet)).toBeGreaterThanOrEqual(tokenCoverage(legacyTop?.snippet));
+      expect(tokenCoverage(upgradedTop?.snippet)).toBeGreaterThanOrEqual(2);
+    } finally {
+      cache.close();
+      repo.close();
+    }
+  });
+});

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

@@ -5,6 +5,7 @@ import { afterEach, describe, expect, it } from "vitest";
 import {
   RemoteSyncHttpResponseError,
   buildRemoteSyncDeltaFromState,
+  collectProjectFileStats,
   runRemoteDeltaSync,
   type RemoteSyncStateFile
 } from "../src/index.js";
@@ -29,6 +30,56 @@ afterEach(async () => {
 });
 
 describe("runRemoteDeltaSync", () => {
+  it("excludes .tmp directories from remote sync deltas", async () => {
+    const root = await createProject();
+    await mkdir(join(root, ".tmp", "cache"), { recursive: true });
+    await writeFile(join(root, "src", "keep.ts"), "export const KEEP = true;\n");
+    await writeFile(join(root, ".tmp", "cache", "noise.ts"), "export const NOISE = true;\n");
+
+    const result = await buildRemoteSyncDeltaFromState({
+      project_root_path: root,
+      force_full_upsert: true
+    });
+
+    expect(result.delta.upsert_files.map((file) => file.path)).toEqual(["src/keep.ts"]);
+    expect(Object.keys(result.next_files)).toEqual(["src/keep.ts"]);
+  });
+
+  it("applies .contextignore and .rceignore patterns to remote sync deltas", async () => {
+    const root = await createProject();
+    await mkdir(join(root, "src", "generated"), { recursive: true });
+    await mkdir(join(root, "generated"), { recursive: true });
+    await mkdir(join(root, "build"), { recursive: true });
+
+    await writeFile(
+      join(root, ".contextignore"),
+      "# comments and blank lines are ignored\n\n**/generated/**\n"
+    );
+    await writeFile(join(root, ".rceignore"), "build/\n");
+    await writeFile(join(root, "src", "keep.ts"), "export const KEEP = true;\n");
+    await writeFile(join(root, "src", "generated", "types.ts"), "export const GENERATED = true;\n");
+    await writeFile(join(root, "generated", "root.ts"), "export const ROOT_GENERATED = true;\n");
+    await writeFile(join(root, "build", "bundle.ts"), "export const BUNDLE = true;\n");
+
+    const result = await buildRemoteSyncDeltaFromState({
+      project_root_path: root,
+      force_full_upsert: true
+    });
+
+    expect(result.delta.upsert_files.map((file) => file.path)).toEqual(["src/keep.ts"]);
+    expect(Object.keys(result.next_files)).toEqual(["src/keep.ts"]);
+  });
+
+  it("maps .mjs and .cjs files to javascript 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");
+
+    const stats = await collectProjectFileStats(root);
+    expect(stats.get("src/runtime.mjs")?.language).toBe("javascript");
+    expect(stats.get("src/loader.cjs")?.language).toBe("javascript");
+  });
+
   it("applies add/modify/delete changes incrementally", async () => {
     const root = await createProject();
     await writeFile(join(root, "src", "a.ts"), "export const A = 1;\n");