@danielblomma/cortex-mcp 0.4.5 → 1.0.0

package/scaffold/mcp/src/searchCore.ts

@@ -0,0 +1,274 @@
+import type { SearchEntity } from "./types.js";
+
+const SQL_ENTITY_KINDS = new Set(["procedure", "view", "function", "table", "trigger"]);
+const SQL_LIKE_EXTENSIONS = [".sql"];
+const CONFIG_LIKE_EXTENSIONS = [".config"];
+const RESOURCE_LIKE_EXTENSIONS = [".resx"];
+const SETTINGS_LIKE_EXTENSIONS = [".settings"];
+const CONFIG_ENVIRONMENT_TOKENS = [
+  "release",
+  "debug",
+  "prod",
+  "production",
+  "staging",
+  "stage",
+  "dev",
+  "development",
+  "test",
+  "qa",
+  "uat"
+];
+
+const QUERY_TOKEN_EXPANSIONS: Record<string, string[]> = {
+  semantisk: ["semantic"],
+  sökning: ["search"],
+  sokning: ["search"],
+  regel: ["rule"],
+  regler: ["rules"],
+  relaterad: ["related"],
+  meddelande: ["message"],
+  avvikelse: ["deviation"]
+};
+
+export function normalizeText(value: string): string {
+  return value.normalize("NFKC").toLowerCase();
+}
+
+export function tokenize(value: string): string[] {
+  return normalizeText(value)
+    .split(/[^\p{L}\p{N}]+/gu)
+    .map((part) => part.trim())
+    .filter((part) => part.length >= 2);
+}
+
+export function expandQueryTokens(tokens: string[]): string[] {
+  const expanded = new Set<string>(tokens);
+  for (const token of tokens) {
+    const aliases = QUERY_TOKEN_EXPANSIONS[token];
+    if (!aliases) {
+      continue;
+    }
+    for (const alias of aliases) {
+      expanded.add(alias);
+    }
+  }
+  return Array.from(expanded);
+}
+
+function daysSince(isoDate: string): 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));
+}
+
+export function recencyScore(isoDate: string): number {
+  const days = daysSince(isoDate);
+  return 1 / (1 + days / 30);
+}
+
+export function semanticScore(queryTokens: string[], queryPhrase: string, text: string): number {
+  if (queryTokens.length === 0) {
+    return 0;
+  }
+
+  const textTokenSet = new Set(tokenize(text));
+  if (textTokenSet.size === 0) {
+    return 0;
+  }
+
+  let matched = 0;
+  for (const token of queryTokens) {
+    if (textTokenSet.has(token)) {
+      matched += 1;
+    }
+  }
+
+  const overlap = matched / queryTokens.length;
+  if (overlap <= 0) {
+    return 0;
+  }
+
+  const normalizedText = normalizeText(text);
+  const phraseBonus = queryPhrase && normalizedText.includes(queryPhrase) ? 0.15 : 0;
+  return Math.min(1, overlap * 0.85 + phraseBonus);
+}
+
+function queryHasAnyToken(queryTokens: string[], candidates: string[]): boolean {
+  return candidates.some((candidate) => queryTokens.includes(candidate));
+}
+
+function pathHasExtension(pathValue: string, extensions: string[]): boolean {
+  const normalizedPath = normalizeText(pathValue);
+  return extensions.some((extension) => normalizedPath.endsWith(extension));
+}
+
+export function legacyDataAccessBoost(entity: SearchEntity, queryTokens: string[], queryPhrase: string): number {
+  const normalizedKind = normalizeText(entity.kind);
+  const wantsSql =
+    queryHasAnyToken(queryTokens, [
+      "sql",
+      "database",
+      "db",
+      "provider",
+      "providername",
+      "sqlclient",
+      "sqlserver",
+      "oracle",
+      "postgres",
+      "postgresql",
+      "pgsql",
+      "mysql",
+      "sqlite",
+      "stored",
+      "procedure",
+      "proc",
+      "query",
+      "queries",
+      "view",
+      "table",
+      "trigger",
+      "report",
+      "reporting",
+      "data",
+      "dataflow"
+    ]) || queryPhrase.includes("stored procedure");
+  const wantsConfig =
+    queryHasAnyToken(queryTokens, [
+      "config",
+      "configuration",
+      "connection",
+      "connectionstring",
+      "connectionstrings",
+      "appsettings",
+      "setting",
+      "settings"
+    ]) || queryPhrase.includes("connection string");
+  const wantsResource = queryHasAnyToken(queryTokens, ["resource", "resources", "resx"]);
+  const wantsSettings = queryHasAnyToken(queryTokens, ["setting", "settings", "appsettings"]);
+  const wantsConfigTransform =
+    queryHasAnyToken(queryTokens, [...CONFIG_ENVIRONMENT_TOKENS, "transform", "xdt", "override"]) ||
+    queryPhrase.includes("web.release.config") ||
+    queryPhrase.includes("web.debug.config");
+  const wantsMachineConfig = queryHasAnyToken(queryTokens, ["machine", "machineconfig"]);
+  const wantsImpact = queryHasAnyToken(queryTokens, [
+    "impact",
+    "affect",
+    "affected",
+    "affects",
+    "change",
+    "changes",
+    "changing",
+    "override",
+    "overrides"
+  ]);
+
+  let boost = 0;
+
+  if (entity.entity_type === "Chunk") {
+    if (normalizedKind === "connection_string" && (wantsConfig || wantsSql)) {
+      boost += 0.16;
+    } else if (
+      normalizedKind === "database_target" &&
+      (wantsConfig ||
+        wantsSql ||
+        queryHasAnyToken(queryTokens, [
+          "database",
+          "server",
+          "catalog",
+          "provider",
+          "providername",
+          "sqlclient",
+          "sqlserver",
+          "oracle",
+          "postgres",
+          "postgresql",
+          "pgsql",
+          "mysql",
+          "sqlite"
+        ]))
+    ) {
+      boost += 0.18;
+    } else if (normalizedKind === "app_setting" && (wantsConfig || wantsSettings)) {
+      boost += 0.12;
+    } else if (normalizedKind === "resource_entry" && (wantsResource || wantsSql)) {
+      boost += 0.1;
+    } else if (normalizedKind === "setting_entry" && (wantsSettings || wantsConfig || wantsSql)) {
+      boost += 0.1;
+    } else if (SQL_ENTITY_KINDS.has(normalizedKind) && wantsSql) {
+      boost += 0.12;
+    }
+    if (
+      wantsImpact &&
+      (normalizedKind === "connection_string" ||
+        normalizedKind === "database_target" ||
+        normalizedKind === "app_setting" ||
+        SQL_ENTITY_KINDS.has(normalizedKind))
+    ) {
+      boost += 0.08;
+    }
+  }
+
+  if (entity.entity_type === "File") {
+    if (pathHasExtension(entity.path, SQL_LIKE_EXTENSIONS) && wantsSql) {
+      boost += 0.04;
+    }
+    if (pathHasExtension(entity.path, CONFIG_LIKE_EXTENSIONS) && wantsConfig) {
+      boost += 0.06;
+    }
+    if (
+      pathHasExtension(entity.path, CONFIG_LIKE_EXTENSIONS) &&
+      wantsConfigTransform &&
+      CONFIG_ENVIRONMENT_TOKENS.some((token) => normalizeText(entity.path).includes(`.${token}.config`))
+    ) {
+      boost += 0.12;
+    }
+    if (
+      pathHasExtension(entity.path, CONFIG_LIKE_EXTENSIONS) &&
+      wantsMachineConfig &&
+      normalizeText(entity.path).endsWith("machine.config")
+    ) {
+      boost += 0.12;
+    }
+    if (
+      pathHasExtension(entity.path, CONFIG_LIKE_EXTENSIONS) &&
+      wantsImpact &&
+      (wantsConfig || wantsConfigTransform || wantsSql)
+    ) {
+      boost += 0.08;
+    }
+    if (pathHasExtension(entity.path, RESOURCE_LIKE_EXTENSIONS) && (wantsResource || wantsSql)) {
+      boost += 0.05;
+    }
+    if (pathHasExtension(entity.path, SETTINGS_LIKE_EXTENSIONS) && (wantsSettings || wantsConfig)) {
+      boost += 0.05;
+    }
+  }
+
+  return boost;
+}
+
+export function cosineSimilarity(a: number[], b: number[]): number {
+  if (a.length === 0 || b.length === 0 || a.length !== b.length) {
+    return 0;
+  }
+
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let index = 0; index < a.length; index += 1) {
+    const av = a[index];
+    const bv = b[index];
+    dot += av * bv;
+    normA += av * av;
+    normB += bv * bv;
+  }
+
+  if (normA === 0 || normB === 0) {
+    return 0;
+  }
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}

package/scaffold/mcp/src/searchResults.ts

@@ -0,0 +1,133 @@
+import type { RankingWeights, SearchEntity } from "./types.js";
+
+function isWindowChunkId(id: string): boolean {
+  return id.includes(":window:");
+}
+
+function baseChunkId(id: string): string {
+  const markerIndex = id.indexOf(":window:");
+  return markerIndex === -1 ? id : id.slice(0, markerIndex);
+}
+
+function baseChunkLabel(label: string): string {
+  const markerIndex = label.indexOf("#window");
+  return markerIndex === -1 ? label : label.slice(0, markerIndex);
+}
+
+export function buildSearchResults(params: {
+  candidates: SearchEntity[];
+  degreeByEntity: Map<string, number>;
+  queryTokens: string[];
+  queryPhrase: string;
+  ranking: RankingWeights;
+  includeScores: boolean;
+  includeMatchedRules: boolean;
+  includeContent: boolean;
+  queryVector: number[] | null;
+  embeddingVectors: Map<string, number[]>;
+  topK: number;
+  minLexicalRelevance: number;
+  minVectorRelevance: number;
+  semanticScorer: (queryTokens: string[], queryPhrase: string, text: string) => number;
+  vectorScorer: (a: number[], b: number[]) => number;
+  recencyScorer: (isoDate: string) => number;
+  legacyDataAccessBooster: (entity: SearchEntity, queryTokens: string[], queryPhrase: string) => number;
+}): Record<string, unknown>[] {
+  const rawResults = params.candidates
+    .map((entity) => {
+      const lexicalSemantic = params.semanticScorer(params.queryTokens, params.queryPhrase, entity.text);
+      const entityVector = params.embeddingVectors.get(entity.id);
+      const vectorSemantic =
+        params.queryVector && entityVector
+          ? Math.max(0, Math.min(1, params.vectorScorer(params.queryVector, entityVector)))
+          : 0;
+      const hasRelevanceSignal =
+        lexicalSemantic >= params.minLexicalRelevance || vectorSemantic >= params.minVectorRelevance;
+      if (!hasRelevanceSignal) {
+        return null;
+      }
+
+      const semantic =
+        vectorSemantic > 0 ? vectorSemantic * 0.75 + lexicalSemantic * 0.25 : lexicalSemantic;
+      const graphScore = Math.min(1, (params.degreeByEntity.get(entity.id) ?? 0) / 4);
+      const trustScore = Math.max(0, Math.min(1, entity.trust_level / 100));
+      const dateScore = params.recencyScorer(entity.updated_at);
+
+      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.legacyDataAccessBooster(entity, params.queryTokens, params.queryPhrase);
+
+      if (entity.source_of_truth) {
+        score += 0.1 * semantic;
+      }
+
+      return {
+        id: entity.id,
+        entity_type: entity.entity_type,
+        kind: entity.kind,
+        title: entity.label,
+        path: entity.path || undefined,
+        source_of_truth: entity.source_of_truth,
+        status: entity.status,
+        updated_at: entity.updated_at,
+        excerpt: entity.snippet,
+        ...(params.includeScores
+          ? {
+              score: Number(score.toFixed(4)),
+              semantic_score: Number(semantic.toFixed(4)),
+              embedding_score: Number(vectorSemantic.toFixed(4)),
+              lexical_score: Number(lexicalSemantic.toFixed(4)),
+              graph_score: Number(graphScore.toFixed(4))
+            }
+          : {}),
+        ...(params.includeMatchedRules
+          ? {
+              matched_rules: entity.matched_rules
+            }
+          : {}),
+        ...(params.includeContent
+          ? {
+              content: entity.content
+            }
+          : {})
+      };
+    })
+    .filter((result): result is NonNullable<typeof result> => result !== null)
+    .sort((a, b) => Number(b.score ?? 0) - Number(a.score ?? 0));
+
+  const chunkCandidatesById = new Map(
+    params.candidates.filter((entity) => entity.entity_type === "Chunk").map((entity) => [entity.id, entity])
+  );
+  const normalizedById = new Map<string, (typeof rawResults)[number]>();
+
+  for (const result of rawResults) {
+    if (result.entity_type !== "Chunk" || !isWindowChunkId(String(result.id))) {
+      if (!normalizedById.has(String(result.id))) {
+        normalizedById.set(String(result.id), result);
+      }
+      continue;
+    }
+
+    const canonicalId = baseChunkId(String(result.id));
+    const baseChunk = chunkCandidatesById.get(canonicalId);
+    const normalizedResult = baseChunk
+      ? {
+          ...result,
+          id: canonicalId,
+          title: baseChunkLabel(baseChunk.label),
+          path: baseChunk.path || undefined
+        }
+      : result;
+    const existing = normalizedById.get(String(normalizedResult.id));
+    if (!existing || Number(normalizedResult.score ?? 0) > Number(existing.score ?? 0)) {
+      normalizedById.set(String(normalizedResult.id), normalizedResult);
+    }
+  }
+
+  return [...normalizedById.values()]
+    .sort((a, b) => Number(b.score ?? 0) - Number(a.score ?? 0))
+    .slice(0, params.topK);
+}

package/scaffold/mcp/src/server.ts

@@ -2,7 +2,8 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { reloadContextGraph } from "./graph.js";
-import { runContextRelated, runContextRules, runContextSearch } from "./search.js";
+import { runContextRules } from "./rules.js";
+import { runContextImpact, runContextRelated, runContextSearch } from "./search.js";
 
 type ToolPayload = Record<string, unknown>;
 
@@ -10,15 +11,97 @@ const SearchInput = z.object({
   query: z.string().min(1),
   top_k: z.number().int().positive().max(20).default(5),
   include_deprecated: z.boolean().default(false),
-  include_content: z.boolean().default(false)
+  response_preset: z.enum(["full", "compact", "minimal"]).optional(),
+  include_scores: z.boolean().optional(),
+  include_matched_rules: z.boolean().optional(),
+  include_content: z.boolean().optional()
 });
 
 const RelatedInput = z.object({
   entity_id: z.string().min(1),
   depth: z.number().int().positive().max(3).default(1),
-  include_edges: z.boolean().default(true)
+  include_edges: z.boolean().optional(),
+  response_preset: z.enum(["full", "compact", "minimal"]).optional(),
+  include_entity_metadata: z.boolean().optional()
 });
 
+const ImpactInput = z
+  .object({
+    entity_id: z.string().min(1).optional(),
+    query: z.string().min(1).optional(),
+    depth: z.number().int().positive().max(4).default(2),
+    top_k: z.number().int().positive().max(20).default(8),
+    include_edges: z.boolean().default(true),
+    response_preset: z.enum(["full", "compact", "minimal"]).optional(),
+    include_scores: z.boolean().optional(),
+    include_reasons: z.boolean().optional(),
+    verbose_paths: z.boolean().optional(),
+    max_path_hops_shown: z.number().int().positive().max(8).optional(),
+    profile: z.enum(["all", "config_only", "config_to_sql", "code_only", "sql_only"]).default("all"),
+    sort_by: z
+      .enum(["impact_score", "shortest_path", "semantic_score", "graph_score", "trust_score"])
+      .default("impact_score"),
+    relation_types: z
+      .array(
+        z.enum([
+          "CALLS",
+          "CALLS_SQL",
+          "IMPORTS",
+          "USES_CONFIG_KEY",
+          "USES_RESOURCE_KEY",
+          "USES_SETTING_KEY",
+          "USES_CONFIG",
+          "TRANSFORMS_CONFIG",
+          "PART_OF"
+        ])
+      )
+      .max(9)
+      .optional(),
+    path_must_include: z
+      .array(
+        z.enum([
+          "CALLS",
+          "CALLS_SQL",
+          "IMPORTS",
+          "USES_CONFIG_KEY",
+          "USES_RESOURCE_KEY",
+          "USES_SETTING_KEY",
+          "USES_CONFIG",
+          "TRANSFORMS_CONFIG",
+          "PART_OF"
+        ])
+      )
+      .max(9)
+      .optional(),
+    path_must_exclude: z
+      .array(
+        z.enum([
+          "CALLS",
+          "CALLS_SQL",
+          "IMPORTS",
+          "USES_CONFIG_KEY",
+          "USES_RESOURCE_KEY",
+          "USES_SETTING_KEY",
+          "USES_CONFIG",
+          "TRANSFORMS_CONFIG",
+          "PART_OF"
+        ])
+      )
+      .max(9)
+      .optional(),
+    result_domains: z
+      .array(z.enum(["code", "config", "resource", "settings", "sql", "project"]))
+      .max(6)
+      .optional(),
+    result_entity_types: z
+      .array(z.enum(["File", "Chunk", "Module", "Project", "ADR", "Rule"]))
+      .max(6)
+      .optional()
+  })
+  .refine((value) => Boolean(value.entity_id || value.query), {
+    message: "Either entity_id or query is required."
+  });
+
 const RulesInput = z.object({
   scope: z.string().optional(),
   include_inactive: z.boolean().default(false)
@@ -59,6 +142,15 @@ function registerTools(server: McpServer): void {
     async (input) => buildToolResult(await runContextRelated(RelatedInput.parse(input ?? {})))
   );
 
+  server.registerTool(
+    "context.impact",
+    {
+      description: "Traverse likely impact paths across config, code and SQL starting from an entity id or query.",
+      inputSchema: ImpactInput
+    },
+    async (input) => buildToolResult(await runContextImpact(ImpactInput.parse(input ?? {})))
+  );
+
   server.registerTool(
     "context.get_rules",
     {

package/scaffold/mcp/src/types.ts

@@ -38,10 +38,32 @@ export type AdrRecord = {
   status: string;
 };
 
+export type RelationType =
+  | "CONSTRAINS"
+  | "IMPLEMENTS"
+  | "SUPERSEDES"
+  | "DEFINES"
+  | "CALLS"
+  | "IMPORTS"
+  | "CALLS_SQL"
+  | "USES_CONFIG_KEY"
+  | "USES_RESOURCE_KEY"
+  | "USES_SETTING_KEY"
+  | "PART_OF"
+  | "CONTAINS"
+  | "CONTAINS_MODULE"
+  | "EXPORTS"
+  | "INCLUDES_FILE"
+  | "REFERENCES_PROJECT"
+  | "USES_RESOURCE"
+  | "USES_SETTING"
+  | "USES_CONFIG"
+  | "TRANSFORMS_CONFIG";
+
 export type RelationRecord = {
   from: string;
   to: string;
-  relation: "CONSTRAINS" | "IMPLEMENTS" | "SUPERSEDES" | "CALLS" | "IMPORTS" | "PART_OF";
+  relation: RelationType;
   note: string;
 };
 
@@ -52,9 +74,39 @@ export type ChunkRecord = {
   kind: string;
   signature: string;
   body: string;
+  description: string;
   start_line: number;
   end_line: number;
   language: string;
+  exported: boolean;
+  updated_at: string;
+  source_of_truth: boolean;
+  trust_level: number;
+  status: string;
+};
+
+export type ModuleRecord = {
+  id: string;
+  path: string;
+  name: string;
+  summary: string;
+  file_count: number;
+  exported_symbols: string;
+  updated_at: string;
+  source_of_truth: boolean;
+  trust_level: number;
+  status: string;
+};
+
+export type ProjectRecord = {
+  id: string;
+  path: string;
+  name: string;
+  kind: string;
+  language: string;
+  target_framework: string;
+  summary: string;
+  file_count: number;
   updated_at: string;
   source_of_truth: boolean;
   trust_level: number;
@@ -73,6 +125,8 @@ export type ContextData = {
   adrs: AdrRecord[];
   rules: RuleRecord[];
   chunks: ChunkRecord[];
+  modules: ModuleRecord[];
+  projects: ProjectRecord[];
   relations: RelationRecord[];
   ranking: RankingWeights;
   source: "cache" | "ryu";
@@ -81,7 +135,7 @@ export type ContextData = {
 
 export type SearchEntity = {
   id: string;
-  entity_type: "File" | "Rule" | "ADR" | "Chunk";
+  entity_type: "File" | "Rule" | "ADR" | "Chunk" | "Module" | "Project";
   kind: string;
   label: string;
   path: string;
@@ -105,13 +159,38 @@ export type SearchParams = {
   query: string;
   top_k: number;
   include_deprecated: boolean;
-  include_content: boolean;
+  response_preset?: "full" | "compact" | "minimal";
+  include_scores?: boolean;
+  include_matched_rules?: boolean;
+  include_content?: boolean;
 };
 
 export type RelatedParams = {
   entity_id: string;
   depth: number;
+  include_edges?: boolean;
+  response_preset?: "full" | "compact" | "minimal";
+  include_entity_metadata?: boolean;
+};
+
+export type ImpactParams = {
+  entity_id?: string;
+  query?: string;
+  depth: number;
+  top_k: number;
   include_edges: boolean;
+  response_preset?: "full" | "compact" | "minimal";
+  include_scores?: boolean;
+  include_reasons?: boolean;
+  verbose_paths?: boolean;
+  max_path_hops_shown?: number;
+  profile?: "all" | "config_only" | "config_to_sql" | "code_only" | "sql_only";
+  sort_by?: "impact_score" | "shortest_path" | "semantic_score" | "graph_score" | "trust_score";
+  relation_types?: RelationType[];
+  path_must_include?: RelationType[];
+  path_must_exclude?: RelationType[];
+  result_domains?: ("code" | "config" | "resource" | "settings" | "sql" | "project")[];
+  result_entity_types?: ("File" | "Chunk" | "Module" | "Project" | "ADR" | "Rule")[];
 };
 
 export type RulesParams = {