@danielblomma/cortex-mcp 2.2.5 → 2.4.1

package/scaffold/mcp/src/searchCore.ts

@@ -20,6 +20,19 @@ const CONFIG_ENVIRONMENT_TOKENS = [
 ];
 
 const QUERY_TOKEN_EXPANSIONS: Record<string, string[]> = {
+  dashboard: ["status"],
+  embed: ["embedding", "embeddings"],
+  embedding: ["embed", "embeddings"],
+  embeddings: ["embed", "embedding"],
+  git: ["githooks"],
+  hook: ["hooks", "githooks"],
+  hooks: ["hook", "githooks"],
+  import: ["imports"],
+  imports: ["import"],
+  javascript: ["js"],
+  parser: ["parsers"],
+  parsers: ["parser"],
+  status: ["dashboard"],
   semantisk: ["semantic"],
   sökning: ["search"],
   sokning: ["search"],
@@ -30,15 +43,105 @@ const QUERY_TOKEN_EXPANSIONS: Record<string, string[]> = {
   avvikelse: ["deviation"]
 };
 
+const STRUCTURAL_QUERY_STOP_TOKENS = new Set([
+  "about",
+  "after",
+  "and",
+  "are",
+  "before",
+  "between",
+  "does",
+  "from",
+  "happen",
+  "happens",
+  "has",
+  "how",
+  "into",
+  "the",
+  "their",
+  "then",
+  "through",
+  "when",
+  "where",
+  "while",
+  "with",
+  "what",
+  "which",
+  "who",
+  "why"
+]);
+
+const IDENTIFIER_COMPOUND_TOKENS = new Set(["csharp", "fsharp", "graphql", "javascript", "typescript", "vbnet"]);
+const LANGUAGE_TOKEN_GROUPS = [
+  ["javascript", "typescript", "js", "ts"],
+  ["csharp", "cs"],
+  ["vbnet", "vb"],
+  ["fsharp", "fs"],
+  ["java"],
+  ["cpp"],
+  ["python", "py"],
+  ["rust", "rs"],
+  ["ruby", "rb"],
+  ["go"],
+  ["php"],
+  ["swift"],
+  ["kotlin", "kt"],
+  ["sql"]
+];
+
 export function normalizeText(value: string): string {
   return value.normalize("NFKC").toLowerCase();
 }
 
+function normalizeLanguageAliases(value: string): string {
+  return value
+    .replace(/(^|[^\p{L}\p{N}])c#(?=$|[^\p{L}\p{N}])/giu, "$1 csharp ")
+    .replace(/(^|[^\p{L}\p{N}])f#(?=$|[^\p{L}\p{N}])/giu, "$1 fsharp ")
+    .replace(/(^|[^\p{L}\p{N}])vb\.net(?=$|[^\p{L}\p{N}])/giu, "$1 vbnet ");
+}
+
+function splitIdentifierPart(part: string): string[] {
+  const split = part
+    .replace(/([\p{Ll}\p{N}])([\p{Lu}])/gu, "$1 $2")
+    .replace(/([\p{Lu}]+)([\p{Lu}][\p{Ll}])/gu, "$1 $2")
+    .split(/\s+/u)
+    .filter(Boolean);
+  if (split.length <= 1) {
+    return [];
+  }
+
+  const merged: string[] = [];
+  for (let index = 0; index < split.length; index += 1) {
+    const current = normalizeText(split[index]);
+    const next = index + 1 < split.length ? normalizeText(split[index + 1]) : "";
+    const compound = `${current}${next}`;
+    if (next && IDENTIFIER_COMPOUND_TOKENS.has(compound)) {
+      merged.push(compound);
+      index += 1;
+      continue;
+    }
+    merged.push(current);
+  }
+  return merged;
+}
+
 export function tokenize(value: string): string[] {
-  return normalizeText(value)
-    .split(/[^\p{L}\p{N}]+/gu)
-    .map((part) => part.trim())
-    .filter((part) => part.length >= 2);
+  const tokens: string[] = [];
+  for (const rawPart of normalizeLanguageAliases(value).normalize("NFKC").split(/[^\p{L}\p{N}]+/gu)) {
+    const part = rawPart.trim();
+    if (part.length < 2) {
+      continue;
+    }
+
+    const variants = [part, ...splitIdentifierPart(part)];
+    for (const variant of variants) {
+      const token = normalizeText(variant).trim();
+      if (token.length >= 2) {
+        tokens.push(token);
+      }
+    }
+  }
+  return tokens;
 }
 
 export function expandQueryTokens(tokens: string[]): string[] {
@@ -55,18 +158,69 @@ export function expandQueryTokens(tokens: string[]): string[] {
   return Array.from(expanded);
 }
 
-function daysSince(isoDate: string): number {
+function relatedQueryTokens(token: string): string[] {
+  const related = new Set<string>(QUERY_TOKEN_EXPANSIONS[token] ?? []);
+  for (const [source, aliases] of Object.entries(QUERY_TOKEN_EXPANSIONS)) {
+    if (!aliases.includes(token)) {
+      continue;
+    }
+    related.add(source);
+    for (const alias of aliases) {
+      related.add(alias);
+    }
+  }
+  return Array.from(related);
+}
+
+function queryTokenGroups(queryTokens: string[]): string[][] {
+  const inputTokens = new Set(queryTokens);
+  const visited = new Set<string>();
+  const groups: string[][] = [];
+
+  for (const token of queryTokens) {
+    if (visited.has(token)) {
+      continue;
+    }
+
+    const group = new Set<string>();
+    const queue = [token];
+    for (let index = 0; index < queue.length; index += 1) {
+      const current = queue[index];
+      if (group.has(current)) {
+        continue;
+      }
+      group.add(current);
+
+      for (const related of relatedQueryTokens(current)) {
+        group.add(related);
+        if (inputTokens.has(related) && !visited.has(related)) {
+          queue.push(related);
+        }
+      }
+    }
+
+    for (const member of group) {
+      if (inputTokens.has(member)) {
+        visited.add(member);
+      }
+    }
+    groups.push(Array.from(group));
+  }
+
+  return groups;
+}
+
+function daysSince(isoDate: string, referenceTimeMs: number): number {
   const timestamp = Date.parse(isoDate);
   if (Number.isNaN(timestamp)) {
     return 3650;
   }
 
-  const now = Date.now();
-  return Math.max(0, (now - timestamp) / (1000 * 60 * 60 * 24));
+  return Math.max(0, (referenceTimeMs - timestamp) / (1000 * 60 * 60 * 24));
 }
 
-export function recencyScore(isoDate: string): number {
-  const days = daysSince(isoDate);
+export function recencyScore(isoDate: string, referenceTimeMs = Date.now()): number {
+  const days = daysSince(isoDate, referenceTimeMs);
   return 1 / (1 + days / 30);
 }
 
@@ -80,14 +234,15 @@ export function semanticScore(queryTokens: string[], queryPhrase: string, text:
     return 0;
   }
 
+  const tokenGroups = queryTokenGroups(queryTokens);
   let matched = 0;
-  for (const token of queryTokens) {
-    if (textTokenSet.has(token)) {
+  for (const group of tokenGroups) {
+    if (group.some((token) => textTokenSet.has(token))) {
       matched += 1;
     }
   }
 
-  const overlap = matched / queryTokens.length;
+  const overlap = matched / tokenGroups.length;
   if (overlap <= 0) {
     return 0;
   }
@@ -97,6 +252,93 @@ export function semanticScore(queryTokens: string[], queryPhrase: string, text:
   return Math.min(1, overlap * 0.85 + phraseBonus);
 }
 
+function structuralQueryTokens(queryTokens: string[]): string[] {
+  return queryTokens.filter((token) => token.length >= 3 && !STRUCTURAL_QUERY_STOP_TOKENS.has(token));
+}
+
+function tokenSet(value: string): Set<string> {
+  return new Set(tokenize(value));
+}
+
+function overlapCount(queryTokens: string[], targetTokens: Set<string>): number {
+  let matched = 0;
+  for (const token of queryTokens) {
+    if (targetTokens.has(token)) {
+      matched += 1;
+    }
+  }
+  return matched;
+}
+
+function basenameWithoutExtension(pathValue: string): string {
+  const base = pathValue.split(/[\\/]/u).pop() ?? pathValue;
+  const extensionIndex = base.lastIndexOf(".");
+  return extensionIndex > 0 ? base.slice(0, extensionIndex) : base;
+}
+
+function languageGroupsForTokens(tokens: Set<string>): Set<number> {
+  const groups = new Set<number>();
+  for (let index = 0; index < LANGUAGE_TOKEN_GROUPS.length; index += 1) {
+    if (LANGUAGE_TOKEN_GROUPS[index].some((token) => tokens.has(token))) {
+      groups.add(index);
+    }
+  }
+  return groups;
+}
+
+function hasLanguageGroupOverlap(a: Set<number>, b: Set<number>): boolean {
+  for (const value of a) {
+    if (b.has(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function structuralSearchBoost(entity: SearchEntity, queryTokens: string[], queryPhrase: string): number {
+  const structuralTokens = structuralQueryTokens(queryTokens);
+  if (structuralTokens.length === 0) {
+    return 0;
+  }
+
+  const pathTokens = tokenSet(entity.path);
+  const labelTokens = tokenSet(entity.label);
+  const pathMatches = overlapCount(structuralTokens, pathTokens);
+  const basenameMatches = overlapCount(structuralTokens, tokenSet(basenameWithoutExtension(entity.path)));
+  const labelMatches = overlapCount(structuralTokens, labelTokens);
+  const kindMatches = overlapCount(structuralTokens, tokenSet(entity.kind));
+
+  let boost = 0;
+  boost += Math.min(0.1, pathMatches * 0.035);
+  boost += Math.min(0.08, basenameMatches * 0.06);
+  boost += Math.min(0.08, labelMatches * 0.04);
+  boost += Math.min(0.03, kindMatches * 0.02);
+
+  const normalizedPath = normalizeText(entity.path);
+  const normalizedLabel = normalizeText(entity.label);
+  const compactPhrase = queryPhrase.replace(/[^\p{L}\p{N}]+/gu, "");
+  if (compactPhrase.length >= 8) {
+    const compactPath = normalizedPath.replace(/[^\p{L}\p{N}]+/gu, "");
+    const compactLabel = normalizedLabel.replace(/[^\p{L}\p{N}]+/gu, "");
+    if (compactPath.includes(compactPhrase) || compactLabel.includes(compactPhrase)) {
+      boost += 0.04;
+    }
+  }
+
+  const queryLanguageGroups = languageGroupsForTokens(new Set(queryTokens));
+  const pathLanguageGroups = languageGroupsForTokens(new Set([...pathTokens, ...labelTokens]));
+  if (
+    queryLanguageGroups.size > 0 &&
+    pathLanguageGroups.size > 0 &&
+    pathTokens.has("parsers") &&
+    !hasLanguageGroupOverlap(queryLanguageGroups, pathLanguageGroups)
+  ) {
+    boost -= 0.08;
+  }
+
+  return Math.min(0.2, boost);
+}
+
 function queryHasAnyToken(queryTokens: string[], candidates: string[]): boolean {
   return candidates.some((candidate) => queryTokens.includes(candidate));
 }

package/scaffold/mcp/src/searchResults.ts

@@ -28,13 +28,25 @@ function baseChunkLabel(label: string): string {
   return markerIndex === -1 ? label : label.slice(0, markerIndex);
 }
 
+export function compareText(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function rankedResultKey(ranked: RankedSearchResult): string {
+  return `${String(ranked.result.id ?? "")}\u0000${String(ranked.result.path ?? "")}`;
+}
+
+function compareRankedResults(a: RankedSearchResult, b: RankedSearchResult): number {
+  return b.rankScore - a.rankScore || compareText(rankedResultKey(a), rankedResultKey(b));
+}
+
 function pruneRankedResults(bestById: Map<string, RankedSearchResult>, limit: number): void {
   if (bestById.size <= limit) {
     return;
   }
 
   const retained = [...bestById.entries()]
-    .sort(([, a], [, b]) => b.rankScore - a.rankScore)
+    .sort(([, a], [, b]) => compareRankedResults(a, b))
     .slice(0, limit);
   bestById.clear();
   for (const [id, result] of retained) {
@@ -42,6 +54,72 @@ function pruneRankedResults(bestById: Map<string, RankedSearchResult>, limit: nu
   }
 }
 
+function secondarySignalScale(semantic: number): number {
+  return Math.min(1, 0.15 + Math.max(0, semantic) * 0.85);
+}
+
+function isTestEvidenceEntity(entity: SearchEntity): boolean {
+  return /(^|\/)(tests?|__tests__)\//u.test(entity.path) || /\.(test|spec)\.[^.]+$/u.test(entity.path);
+}
+
+function testEvidenceBoost(entity: SearchEntity, semantic: number, lexicalSemantic: number): number {
+  if (!isTestEvidenceEntity(entity)) {
+    return 0;
+  }
+  if (semantic >= 0.5 && lexicalSemantic >= 0.4) {
+    return 0.07;
+  }
+  if (semantic >= 0.4 && lexicalSemantic >= 0.25) {
+    return 0.04;
+  }
+  return 0;
+}
+
+function resultPathKey(result: SearchResult): string {
+  const path = typeof result.path === "string" ? result.path : "";
+  return path || String(result.id ?? "");
+}
+
+function selectDiverseResults(rankedResults: RankedSearchResult[], topK: number): RankedSearchResult[] {
+  const remaining = rankedResults
+    .map((ranked) => ({ ranked }))
+    .sort((a, b) => compareRankedResults(a.ranked, b.ranked));
+  const selected: RankedSearchResult[] = [];
+  const selectedByPath = new Map<string, number>();
+
+  while (selected.length < topK && remaining.length > 0) {
+    let bestIndex = 0;
+    let bestAdjustedScore = Number.NEGATIVE_INFINITY;
+    let bestRankScore = Number.NEGATIVE_INFINITY;
+    let bestKey = "";
+
+    for (let index = 0; index < remaining.length; index += 1) {
+      const candidate = remaining[index].ranked;
+      const pathCount = selectedByPath.get(resultPathKey(candidate.result)) ?? 0;
+      const samePathPenalty = pathCount === 0 ? 0 : Math.min(0.12, pathCount * 0.04);
+      const adjustedScore = candidate.rankScore - samePathPenalty;
+      const candidateKey = rankedResultKey(candidate);
+      if (
+        adjustedScore > bestAdjustedScore ||
+        (adjustedScore === bestAdjustedScore && candidate.rankScore > bestRankScore) ||
+        (adjustedScore === bestAdjustedScore && candidate.rankScore === bestRankScore && candidateKey < bestKey)
+      ) {
+        bestIndex = index;
+        bestAdjustedScore = adjustedScore;
+        bestRankScore = candidate.rankScore;
+        bestKey = candidateKey;
+      }
+    }
+
+    const [picked] = remaining.splice(bestIndex, 1);
+    selected.push(picked.ranked);
+    const pathKey = resultPathKey(picked.ranked.result);
+    selectedByPath.set(pathKey, (selectedByPath.get(pathKey) ?? 0) + 1);
+  }
+
+  return selected;
+}
+
 function candidatesFrom(source: SearchCandidateSource): Iterable<SearchEntity> {
   return typeof source === "function" ? source() : source;
 }
@@ -63,6 +141,7 @@ export function buildSearchResultsWithStats(params: {
   semanticScorer: (queryTokens: string[], queryPhrase: string, text: string) => number;
   vectorScorer: (a: Float32Array, b: Float32Array) => number;
   recencyScorer: (isoDate: string) => number;
+  structuralSearchBooster?: (entity: SearchEntity, queryTokens: string[], queryPhrase: string) => number;
   legacyDataAccessBooster: (entity: SearchEntity, queryTokens: string[], queryPhrase: string) => number;
 }): { results: Record<string, unknown>[]; totalCandidates: number } {
   if (params.topK <= 0) {
@@ -112,7 +191,8 @@ export function buildSearchResultsWithStats(params: {
   };
 
   const resultLimit = Math.max(1, params.topK);
-  const pruneThreshold = Math.max(resultLimit * 4, 64);
+  const diversityPoolLimit = Math.max(resultLimit * 3, resultLimit);
+  const pruneThreshold = Math.max(diversityPoolLimit * 2, 64);
   const bestById = new Map<string, RankedSearchResult>();
 
   for (const entity of candidatesFrom(params.candidates)) {
@@ -134,12 +214,17 @@ export function buildSearchResultsWithStats(params: {
     const graphScore = midrankPercentile(sortedDegreesByType.get(entity.entity_type) ?? [], degree);
     const trustScore = Math.max(0, Math.min(1, entity.trust_level / 100));
     const dateScore = params.recencyScorer(entity.updated_at);
+    const structuralBoost = params.structuralSearchBooster?.(entity, params.queryTokens, params.queryPhrase) ?? 0;
+    const evidenceBoost = testEvidenceBoost(entity, semantic, lexicalSemantic);
+    const secondaryScale = secondarySignalScale(Math.max(semantic, structuralBoost));
 
     let score = 0;
     score += params.ranking.semantic * semantic;
-    score += params.ranking.graph * graphScore;
-    score += params.ranking.trust * trustScore;
-    score += params.ranking.recency * dateScore;
+    score += params.ranking.graph * graphScore * secondaryScale;
+    score += params.ranking.trust * trustScore * secondaryScale;
+    score += params.ranking.recency * dateScore * secondaryScale;
+    score += structuralBoost;
+    score += evidenceBoost;
     score += params.legacyDataAccessBooster(entity, params.queryTokens, params.queryPhrase);
 
     if (entity.source_of_truth) {
@@ -194,13 +279,15 @@ export function buildSearchResultsWithStats(params: {
     }
 
     if (bestById.size > pruneThreshold) {
-      pruneRankedResults(bestById, resultLimit);
+      pruneRankedResults(bestById, diversityPoolLimit);
     }
   }
 
-  const results = [...bestById.values()]
-    .sort((a, b) => b.rankScore - a.rankScore)
-    .slice(0, params.topK)
+  const rankedResults = [...bestById.values()]
+    .sort(compareRankedResults)
+    .slice(0, diversityPoolLimit);
+  const results = selectDiverseResults(rankedResults, params.topK)
+    .sort(compareRankedResults)
     .map((ranked) => ranked.result);
   return { results, totalCandidates };
 }

package/scaffold/mcp/src/types.ts

@@ -203,6 +203,13 @@ export type RulesParams = {
   include_inactive: boolean;
 };
 
+export type PatternEvidenceParams = {
+  target: string;
+  query?: string;
+  top_k: number;
+  include_deprecated?: boolean;
+};
+
 export type ReloadParams = {
   force: boolean;
 };

package/scaffold/mcp/tests/changed-files.test.mjs

@@ -0,0 +1,41 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { resolveChangedReviewFiles } from "../dist/enterprise/reviews/changed-files.js";
+
+function git(cwd, args) {
+  execFileSync("git", args, { cwd, stdio: "ignore" });
+}
+
+test("lists staged and untracked files in a repo without commits", () => {
+  const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-changed-files-"));
+  try {
+    git(projectRoot, ["init"]);
+    fs.writeFileSync(path.join(projectRoot, ".gitignore"), "ignored.ts\n", "utf8");
+    fs.writeFileSync(path.join(projectRoot, "staged.ts"), "export const a = 1;\n", "utf8");
+    fs.writeFileSync(path.join(projectRoot, "untracked.ts"), "export const b = 2;\n", "utf8");
+    fs.writeFileSync(path.join(projectRoot, "ignored.ts"), "ignored\n", "utf8");
+    git(projectRoot, ["add", ".gitignore", "staged.ts"]);
+
+    assert.deepEqual(resolveChangedReviewFiles(projectRoot), [
+      ".gitignore",
+      "staged.ts",
+      "untracked.ts",
+    ]);
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("returns null outside a git work tree", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-changed-files-plain-"));
+  try {
+    fs.writeFileSync(path.join(dir, "a.ts"), "export const a = 1;\n", "utf8");
+    assert.equal(resolveChangedReviewFiles(dir), null);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scaffold/mcp/tests/copilot-shim.test.mjs

@@ -80,7 +80,25 @@ test("installCopilotShim: refuses to overwrite a non-shim file at shim path", ()
       searchPath: ws.searchPath,
     });
     assert.equal(result.ok, false);
-    assert.match(result.message, /not a cortex shim/);
+    assert.match(result.message, /not a regular cortex shim/);
+  } finally {
+    fs.rmSync(ws.dir, { recursive: true, force: true });
+  }
+});
+
+test("installCopilotShim: refuses a dangling symlink without touching its target", () => {
+  const ws = makeWorkspace();
+  const target = path.join(ws.dir, "must-not-be-created");
+  try {
+    fs.symlinkSync(target, ws.shimPath);
+    const result = installCopilotShim({
+      shimPath: ws.shimPath,
+      searchPath: ws.searchPath,
+    });
+    assert.equal(result.ok, false);
+    assert.match(result.message, /regular cortex shim/);
+    assert.equal(fs.existsSync(target), false);
+    assert.equal(fs.lstatSync(ws.shimPath).isSymbolicLink(), true);
   } finally {
     fs.rmSync(ws.dir, { recursive: true, force: true });
   }

package/scaffold/mcp/tests/egress-proxy.test.mjs

@@ -237,3 +237,40 @@ test("egress proxy: stop() closes the server", async () => {
   assert.equal(proxy.isRunning(), false);
   fs.rmSync(cwd, { recursive: true, force: true });
 });
+
+test("egress proxy: an unattributed shared connection is not written into either project audit boundary", async () => {
+  const echo = await startEchoServer();
+  const projectA = makeProject();
+  const projectB = makeProject();
+  const proxy = await startEgressProxy({ port: 0, hostId: "test-host" });
+  try {
+    await new Promise((resolve, reject) => {
+      const client = net.connect(proxy.port, "127.0.0.1", () => {
+        client.write(
+          `GET http://127.0.0.1:${echo.port}/health HTTP/1.1\r\n` +
+            `Host: 127.0.0.1:${echo.port}\r\n\r\n`,
+        );
+      });
+      client.on("data", () => {
+        client.end();
+        resolve();
+      });
+      client.on("error", reject);
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    assert.equal(
+      fs.existsSync(path.join(projectA, ".context", "audit")),
+      false,
+    );
+    assert.equal(
+      fs.existsSync(path.join(projectB, ".context", "audit")),
+      false,
+    );
+  } finally {
+    await proxy.stop();
+    await new Promise((resolve) => echo.server.close(resolve));
+    fs.rmSync(projectA, { recursive: true, force: true });
+    fs.rmSync(projectB, { recursive: true, force: true });
+  }
+});