@danielblomma/cortex-mcp 0.4.2 → 0.6.4

package/scaffold/mcp/src/contextEntities.ts

@@ -0,0 +1,311 @@
+import type { ContextData, JsonObject, RelationRecord, 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 groupRuleLinks(relations: RelationRecord[]): Map<string, string[]> {
+  const links = new Map<string, string[]>();
+  for (const relation of relations) {
+    if (relation.relation !== "CONSTRAINS" && relation.relation !== "IMPLEMENTS") {
+      continue;
+    }
+
+    if (relation.relation === "CONSTRAINS") {
+      const list = links.get(relation.to) ?? [];
+      list.push(relation.from);
+      links.set(relation.to, list);
+    } else {
+      const list = links.get(relation.from) ?? [];
+      list.push(relation.to);
+      links.set(relation.from, list);
+    }
+  }
+  return links;
+}
+
+function buildRelationSearchSignals(data: ContextData): Map<string, string> {
+  const labelsById = new Map<string, string>();
+  for (const document of data.documents) {
+    labelsById.set(document.id, document.path);
+  }
+  for (const chunk of data.chunks) {
+    labelsById.set(chunk.id, chunk.name || chunk.id);
+  }
+  for (const module of data.modules) {
+    labelsById.set(module.id, module.name || module.path);
+  }
+  for (const project of data.projects) {
+    labelsById.set(project.id, project.name || project.path);
+  }
+
+  const supportedRelations = new Set([
+    "CALLS_SQL",
+    "USES_CONFIG_KEY",
+    "USES_RESOURCE_KEY",
+    "USES_SETTING_KEY",
+    "USES_CONFIG",
+    "TRANSFORMS_CONFIG"
+  ]);
+  const signalsByEntity = new Map<string, string[]>();
+
+  for (const relation of data.relations) {
+    if (!supportedRelations.has(relation.relation)) {
+      continue;
+    }
+    const sourceLabel = labelsById.get(relation.from) ?? relation.from;
+    const targetLabel = labelsById.get(relation.to) ?? relation.to;
+    const outgoingSignal = [relation.relation.toLowerCase(), relation.note, targetLabel].filter(Boolean).join(" ");
+    const incomingSignal = ["affected_by", relation.relation.toLowerCase(), relation.note, sourceLabel]
+      .filter(Boolean)
+      .join(" ");
+    const outgoing = signalsByEntity.get(relation.from) ?? [];
+    outgoing.push(outgoingSignal);
+    signalsByEntity.set(relation.from, outgoing);
+    const incoming = signalsByEntity.get(relation.to) ?? [];
+    incoming.push(incomingSignal);
+    signalsByEntity.set(relation.to, incoming);
+  }
+
+  return new Map([...signalsByEntity.entries()].map(([id, parts]) => [id, parts.join("\n")]));
+}
+
+export function buildSearchEntities(data: ContextData, includeContent: boolean): SearchEntity[] {
+  const entities: SearchEntity[] = [];
+  const fileRuleLinks = groupRuleLinks(data.relations);
+  const relationSignals = buildRelationSearchSignals(data);
+  const adrPathSet = new Set(
+    data.adrs
+      .map((adr) => adr.path.trim().toLowerCase())
+      .filter((adrPath) => adrPath.length > 0)
+  );
+
+  for (const document of data.documents) {
+    const normalizedPath = document.path.trim().toLowerCase();
+    if (document.kind === "ADR" && adrPathSet.has(normalizedPath)) {
+      continue;
+    }
+
+    entities.push({
+      id: document.id,
+      entity_type: "File",
+      kind: document.kind,
+      label: document.path,
+      path: document.path,
+      text: `${document.path}\n${document.excerpt}\n${document.content}\n${relationSignals.get(document.id) ?? ""}`,
+      status: document.status,
+      source_of_truth: document.source_of_truth,
+      trust_level: document.trust_level,
+      updated_at: document.updated_at,
+      snippet: document.excerpt,
+      matched_rules: fileRuleLinks.get(document.id) ?? [],
+      content: includeContent ? document.content : undefined
+    });
+  }
+
+  for (const rule of data.rules) {
+    entities.push({
+      id: rule.id,
+      entity_type: "Rule",
+      kind: "RULE",
+      label: rule.title || rule.id,
+      path: "",
+      text: `${rule.id}\n${rule.title}\n${rule.body}`,
+      status: rule.status,
+      source_of_truth: rule.source_of_truth,
+      trust_level: rule.trust_level,
+      updated_at: rule.updated_at,
+      snippet: rule.body.slice(0, 500),
+      matched_rules: [rule.id],
+      content: includeContent ? rule.body : undefined
+    });
+  }
+
+  for (const adr of data.adrs) {
+    entities.push({
+      id: adr.id,
+      entity_type: "ADR",
+      kind: "ADR",
+      label: adr.title || adr.id,
+      path: adr.path,
+      text: `${adr.path}\n${adr.title}\n${adr.body}`,
+      status: adr.status,
+      source_of_truth: adr.source_of_truth,
+      trust_level: adr.trust_level,
+      updated_at: adr.decision_date,
+      snippet: adr.body.slice(0, 500),
+      matched_rules: [],
+      content: includeContent ? adr.body : undefined
+    });
+  }
+
+  const filePathById = new Map(
+    data.documents.filter((document) => document.kind === "CODE").map((document) => [document.id, document.path])
+  );
+
+  for (const chunk of data.chunks) {
+    const filePath = filePathById.get(chunk.file_id) ?? "";
+    entities.push({
+      id: chunk.id,
+      entity_type: "Chunk",
+      kind: chunk.kind || "chunk",
+      label: chunk.name || chunk.id,
+      path: filePath,
+      text: `${filePath}\n${chunk.name}\n${chunk.signature}\n${chunk.description}\n${chunk.body}\n${relationSignals.get(chunk.id) ?? ""}`,
+      status: chunk.status,
+      source_of_truth: chunk.source_of_truth,
+      trust_level: chunk.trust_level,
+      updated_at: chunk.updated_at,
+      snippet: chunk.description || chunk.body.slice(0, 500),
+      matched_rules: fileRuleLinks.get(chunk.file_id) ?? [],
+      content: includeContent ? chunk.body : undefined
+    });
+  }
+
+  for (const module of data.modules) {
+    entities.push({
+      id: module.id,
+      entity_type: "Module",
+      kind: "MODULE",
+      label: module.name,
+      path: module.path,
+      text: `${module.path}\n${module.name}\n${module.summary}\n${module.exported_symbols}`,
+      status: module.status,
+      source_of_truth: module.source_of_truth,
+      trust_level: module.trust_level,
+      updated_at: module.updated_at,
+      snippet: (module.summary || "").slice(0, 500),
+      matched_rules: [],
+      content: includeContent ? module.summary : undefined
+    });
+  }
+
+  for (const project of data.projects) {
+    entities.push({
+      id: project.id,
+      entity_type: "Project",
+      kind: project.kind.toUpperCase() || "PROJECT",
+      label: project.name || project.path,
+      path: project.path,
+      text: `${project.path}\n${project.name}\n${project.kind}\n${project.language}\n${project.target_framework}\n${project.summary}`,
+      status: project.status,
+      source_of_truth: project.source_of_truth,
+      trust_level: project.trust_level,
+      updated_at: project.updated_at,
+      snippet: (project.summary || "").slice(0, 500),
+      matched_rules: [],
+      content: includeContent ? project.summary : undefined
+    });
+  }
+
+  return entities;
+}
+
+export function buildChunkPartOfRelations(data: ContextData): RelationRecord[] {
+  const relations: RelationRecord[] = [];
+  for (const chunk of data.chunks) {
+    if (isWindowChunkId(chunk.id)) {
+      relations.push({
+        from: chunk.id,
+        to: baseChunkId(chunk.id),
+        relation: "PART_OF",
+        note: "Overlap window belongs to base chunk"
+      });
+    }
+
+    if (!chunk.file_id) {
+      continue;
+    }
+
+    relations.push({
+      from: chunk.id,
+      to: chunk.file_id,
+      relation: "PART_OF",
+      note: "Chunk belongs to file"
+    });
+  }
+  return relations;
+}
+
+export function entityCatalog(data: ContextData): Map<string, JsonObject> {
+  const catalog = new Map<string, JsonObject>();
+  const fileById = new Map(data.documents.map((document) => [document.id, document]));
+
+  for (const file of data.documents) {
+    catalog.set(file.id, {
+      id: file.id,
+      type: "File",
+      label: file.path,
+      status: file.status,
+      source_of_truth: file.source_of_truth
+    });
+  }
+
+  for (const rule of data.rules) {
+    catalog.set(rule.id, {
+      id: rule.id,
+      type: "Rule",
+      label: rule.title,
+      status: rule.status,
+      source_of_truth: rule.source_of_truth
+    });
+  }
+
+  for (const adr of data.adrs) {
+    catalog.set(adr.id, {
+      id: adr.id,
+      type: "ADR",
+      label: adr.title || adr.id,
+      status: adr.status,
+      source_of_truth: adr.source_of_truth
+    });
+  }
+
+  for (const chunk of data.chunks) {
+    const filePath = fileById.get(chunk.file_id)?.path ?? "";
+    const chunkEntity: JsonObject = {
+      id: chunk.id,
+      type: "Chunk",
+      label: chunk.name || chunk.id,
+      status: chunk.status,
+      source_of_truth: chunk.source_of_truth
+    };
+    if (filePath) {
+      chunkEntity.path = filePath;
+    }
+    catalog.set(chunk.id, chunkEntity);
+  }
+
+  for (const module of data.modules) {
+    catalog.set(module.id, {
+      id: module.id,
+      type: "Module",
+      label: module.name,
+      status: module.status,
+      source_of_truth: module.source_of_truth,
+      path: module.path
+    });
+  }
+
+  for (const project of data.projects) {
+    catalog.set(project.id, {
+      id: project.id,
+      type: "Project",
+      label: project.name || project.path,
+      status: project.status,
+      source_of_truth: project.source_of_truth,
+      path: project.path
+    });
+  }
+
+  return catalog;
+}
+
+export function buildEntitySearchMap(data: ContextData): Map<string, SearchEntity> {
+  return new Map(buildSearchEntities(data, false).map((entity) => [entity.id, entity]));
+}

package/scaffold/mcp/src/defaults.ts

@@ -0,0 +1,6 @@
+export const TRUST_DOCUMENT = 50;
+export const TRUST_CHUNK = 60;
+export const TRUST_MEMORY = 70;
+export const TRUST_CHUNK_RYUGRAPH = 80;
+export const TRUST_RULE = 95;
+export const TRUST_ADR = 95;

package/scaffold/mcp/src/embed.ts

@@ -3,6 +3,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { env, pipeline } from "@xenova/transformers";
+import { readJsonl, asString, asNumber, asBoolean } from "./jsonl.js";
+import type { JsonObject, JsonValue } from "./types.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -16,9 +18,7 @@ const MODEL_CACHE_DIR = path.join(EMBEDDINGS_DIR, "models");
 
 const DEFAULT_MODEL_ID = "Xenova/all-MiniLM-L6-v2";
 const DEFAULT_MAX_TEXT_CHARS = 7000;
-
-type JsonValue = string | number | boolean | null | JsonObject | JsonValue[];
-type JsonObject = { [key: string]: JsonValue };
+const CHUNK_BODY_PREVIEW_CHARS = 2000;
 
 type FileEntity = {
   id: string;
@@ -62,7 +62,51 @@ type AdrEntity = {
   signature: string;
 };
 
-type SearchEntity = FileEntity | RuleEntity | AdrEntity;
+// Embedding-specific entity types — intentionally different from types.ts records
+// because they carry `text` and `signature` fields used for embedding generation.
+type ModuleEntity = {
+  id: string;
+  type: "Module";
+  kind: "MODULE";
+  label: string;
+  path: string;
+  status: string;
+  source_of_truth: boolean;
+  trust_level: number;
+  updated_at: string;
+  text: string;
+  signature: string;
+};
+
+type ProjectEntity = {
+  id: string;
+  type: "Project";
+  kind: string;
+  label: string;
+  path: string;
+  status: string;
+  source_of_truth: boolean;
+  trust_level: number;
+  updated_at: string;
+  text: string;
+  signature: string;
+};
+
+type ChunkEntity = {
+  id: string;
+  type: "Chunk";
+  kind: string;
+  label: string;
+  path: string;
+  status: string;
+  source_of_truth: boolean;
+  trust_level: number;
+  updated_at: string;
+  text: string;
+  signature: string;
+};
+
+type SearchEntity = FileEntity | RuleEntity | AdrEntity | ModuleEntity | ProjectEntity | ChunkEntity;
 
 type EmbeddingRecord = {
   id: string;
@@ -87,18 +131,6 @@ function parseArgs(argv: string[]): { mode: "full" | "changed" } {
   };
 }
 
-function asString(value: JsonValue | undefined, fallback = ""): string {
-  return typeof value === "string" ? value : fallback;
-}
-
-function asNumber(value: JsonValue | undefined, fallback = 0): number {
-  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-
-function asBoolean(value: JsonValue | undefined, fallback = false): boolean {
-  return typeof value === "boolean" ? value : fallback;
-}
-
 function hashText(value: string): string {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
@@ -111,26 +143,6 @@ function clampText(value: string, maxChars: number): string {
   return value.slice(0, maxChars);
 }
 
-function readJsonl(filePath: string): JsonObject[] {
-  if (!fs.existsSync(filePath)) {
-    return [];
-  }
-
-  return fs
-    .readFileSync(filePath, "utf8")
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => {
-      try {
-        return JSON.parse(line) as JsonObject;
-      } catch {
-        return null;
-      }
-    })
-    .filter((value): value is JsonObject => value !== null);
-}
-
 function writeJsonl(filePath: string, records: EmbeddingRecord[]): void {
   const body = records.map((record) => JSON.stringify(record)).join("\n");
   fs.writeFileSync(filePath, body ? `${body}\n` : "", "utf8");
@@ -243,6 +255,110 @@ function parseAdrEntities(raw: JsonObject[], maxChars: number): AdrEntity[] {
     .filter((value): value is AdrEntity => value !== null);
 }
 
+function parseModuleEntities(raw: JsonObject[], maxChars: number): ModuleEntity[] {
+  return raw
+    .map((item) => {
+      const id = asString(item.id);
+      if (!id) {
+        return null;
+      }
+
+      const modulePath = asString(item.path);
+      const name = asString(item.name);
+      const summary = asString(item.summary);
+      const exportedSymbols = asString(item.exported_symbols);
+      const updatedAt = asString(item.updated_at);
+      const text = clampText(`${modulePath}\n${name}\n${summary}\n${exportedSymbols}`, maxChars);
+
+      return {
+        id,
+        type: "Module" as const,
+        kind: "MODULE" as const,
+        label: name || modulePath,
+        path: modulePath,
+        status: asString(item.status, "active"),
+        source_of_truth: asBoolean(item.source_of_truth, false),
+        trust_level: asNumber(item.trust_level, 75),
+        updated_at: updatedAt,
+        text,
+        signature: hashText(`module|${id}|${updatedAt}|${hashText(text)}`)
+      };
+    })
+    .filter((value): value is ModuleEntity => value !== null);
+}
+
+function parseChunkEntities(raw: JsonObject[], filePathById: Map<string, string>, maxChars: number): ChunkEntity[] {
+  return raw
+    .map((item) => {
+      const id = asString(item.id);
+      if (!id) {
+        return null;
+      }
+
+      const fileId = asString(item.file_id);
+      const filePath = filePathById.get(fileId) ?? "";
+      const name = asString(item.name);
+      const sig = asString(item.signature);
+      const description = asString(item.description);
+      const body = asString(item.body);
+      const updatedAt = asString(item.updated_at);
+      const checksum = asString(item.checksum, hashText(body));
+      const text = clampText(`${filePath}\n${name}\n${sig}\n${description}\n${body.slice(0, CHUNK_BODY_PREVIEW_CHARS)}`, maxChars);
+
+      return {
+        id,
+        type: "Chunk" as const,
+        kind: asString(item.kind, "chunk"),
+        label: name || id,
+        path: filePath,
+        status: asString(item.status, "active"),
+        source_of_truth: asBoolean(item.source_of_truth, false),
+        trust_level: asNumber(item.trust_level, 60),
+        updated_at: updatedAt,
+        text,
+        signature: hashText(`chunk|${checksum}|${updatedAt}|${hashText(text)}`)
+      };
+    })
+    .filter((value): value is ChunkEntity => value !== null);
+}
+
+function parseProjectEntities(raw: JsonObject[], maxChars: number): ProjectEntity[] {
+  return raw
+    .map((item) => {
+      const id = asString(item.id);
+      if (!id) {
+        return null;
+      }
+
+      const projectPath = asString(item.path);
+      const name = asString(item.name);
+      const kind = asString(item.kind, "project");
+      const language = asString(item.language, "dotnet");
+      const targetFramework = asString(item.target_framework);
+      const summary = asString(item.summary);
+      const updatedAt = asString(item.updated_at);
+      const text = clampText(
+        `${projectPath}\n${name}\n${kind}\n${language}\n${targetFramework}\n${summary}`,
+        maxChars
+      );
+
+      return {
+        id,
+        type: "Project" as const,
+        kind: kind.toUpperCase() || "PROJECT",
+        label: name || projectPath,
+        path: projectPath,
+        status: asString(item.status, "active"),
+        source_of_truth: asBoolean(item.source_of_truth, false),
+        trust_level: asNumber(item.trust_level, 80),
+        updated_at: updatedAt,
+        text,
+        signature: hashText(`project|${id}|${updatedAt}|${hashText(text)}`)
+      };
+    })
+    .filter((value): value is ProjectEntity => value !== null);
+}
+
 function parseExistingEmbeddings(raw: JsonObject[], modelId: string): Map<string, EmbeddingRecord> {
   const index = new Map<string, EmbeddingRecord>();
 
@@ -312,7 +428,17 @@ async function main(): Promise<void> {
   const documents = parseFileEntities(readJsonl(path.join(CACHE_DIR, "documents.jsonl")), maxTextChars);
   const rules = parseRuleEntities(readJsonl(path.join(CACHE_DIR, "entities.rule.jsonl")), maxTextChars);
   const adrs = parseAdrEntities(readJsonl(path.join(CACHE_DIR, "entities.adr.jsonl")), maxTextChars);
-  const entities: SearchEntity[] = [...documents, ...rules, ...adrs].sort((a, b) => a.id.localeCompare(b.id));
+  const modules = parseModuleEntities(readJsonl(path.join(CACHE_DIR, "entities.module.jsonl")), maxTextChars);
+  const projects = parseProjectEntities(readJsonl(path.join(CACHE_DIR, "entities.project.jsonl")), maxTextChars);
+
+  // Build file path lookup for chunk embedding text (reuse already-parsed documents)
+  const filePathById = new Map<string, string>();
+  for (const doc of documents) {
+    filePathById.set(doc.id, doc.path);
+  }
+  const chunks = parseChunkEntities(readJsonl(path.join(CACHE_DIR, "entities.chunk.jsonl")), filePathById, maxTextChars);
+
+  const entities: SearchEntity[] = [...documents, ...rules, ...adrs, ...modules, ...projects, ...chunks].sort((a, b) => a.id.localeCompare(b.id));
 
   const existing = parseExistingEmbeddings(readJsonl(EMBEDDINGS_PATH), modelId);
 

package/scaffold/mcp/src/frontmatter.ts

@@ -0,0 +1,39 @@
+export function parseFrontmatter(markdown: string): { fields: Map<string, string>; body: string } {
+  const lines = markdown.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") {
+    return { fields: new Map(), body: markdown };
+  }
+
+  const fields = new Map<string, string>();
+  let index = 1;
+  for (; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.trim() === "---") {
+      index += 1;
+      break;
+    }
+
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match) {
+      continue;
+    }
+
+    fields.set(match[1].toLowerCase(), match[2].trim());
+  }
+
+  return {
+    fields,
+    body: lines.slice(index).join("\n").trim()
+  };
+}
+
+export function parseStringList(value: string | undefined): string[] {
+  if (!value || !value.trim()) {
+    return [];
+  }
+
+  return value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}