@danielblomma/cortex-mcp 2.1.4 → 2.2.0

package/scaffold/mcp/src/cli/query.ts

@@ -0,0 +1,455 @@
+import { runContextRules } from "../rules.js";
+import { runContextImpact, runContextRelated, runContextSearch } from "../search.js";
+import type {
+  ImpactParams,
+  RelatedParams,
+  RelationType,
+  RulesParams,
+  SearchParams,
+  ToolPayload,
+} from "../types.js";
+
+type Flags = Record<string, string | boolean>;
+
+type ParsedArgs = {
+  flags: Flags;
+  rest: string[];
+};
+
+type JsonEnvelope = {
+  ok: boolean;
+  command: string;
+  input?: Record<string, unknown>;
+  context_source?: unknown;
+  warning?: unknown;
+  data?: ToolPayload;
+  error?: {
+    code: string;
+    message: string;
+  };
+};
+
+const QUERY_COMMANDS = new Set(["search", "related", "impact", "rules", "explain"]);
+
+const ENTITY_ID_PREFIXES = [
+  "file:",
+  "chunk:",
+  "rule:",
+  "adr:",
+  "module:",
+  "project:",
+];
+
+export async function runQueryCommand(args: string[]): Promise<void> {
+  const command = args[0] ?? "help";
+  const rest = args.slice(1);
+
+  if (command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+
+  if (!QUERY_COMMANDS.has(command)) {
+    throw new Error(`Unknown query command: ${command}`);
+  }
+
+  const json = wantsJson(rest);
+  try {
+    switch (command) {
+      case "search":
+        return await runSearch(rest);
+      case "related":
+        return await runRelated(rest);
+      case "impact":
+        return await runImpact(rest);
+      case "rules":
+        return await runRules(rest);
+      case "explain":
+        return await runExplain(rest);
+      default:
+        throw new Error(`Unknown query command: ${command}`);
+    }
+  } catch (error) {
+    if (!json) {
+      throw error;
+    }
+    emitJson({
+      ok: false,
+      command,
+      error: {
+        code: "INVALID_ARGS",
+        message: error instanceof Error ? error.message : String(error),
+      },
+    });
+    process.exitCode = 1;
+  }
+}
+
+function printHelp(): void {
+  const lines = [
+    "Usage:",
+    "  cortex search <query> [--top-k <n>] [--preset <full|compact|minimal>] [--include-content] [--json]",
+    "  cortex related <entity-id> [--depth <n>] [--edges] [--metadata] [--json]",
+    "  cortex impact <query-or-entity-id> [--entity-id <id>] [--query <q>] [--depth <n>] [--top-k <n>] [--json]",
+    "  cortex rules [--scope <scope>] [--include-inactive] [--json]",
+    "  cortex explain <query-or-entity-id> [--top-k <n>] [--json]",
+    "",
+    "These commands read the local Cortex graph and emit MCP-equivalent data with --json.",
+  ];
+  process.stdout.write(lines.join("\n") + "\n");
+}
+
+function parseArgs(args: string[]): ParsedArgs {
+  const flags: Flags = {};
+  const rest: string[] = [];
+  let i = 0;
+
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "--") {
+      rest.push(...args.slice(i + 1));
+      break;
+    }
+
+    if (arg.startsWith("--")) {
+      const name = arg.slice(2);
+      const next = args[i + 1];
+      if (next === undefined || next.startsWith("--")) {
+        flags[name] = true;
+        i += 1;
+        continue;
+      }
+      flags[name] = next;
+      i += 2;
+      continue;
+    }
+
+    rest.push(arg);
+    i += 1;
+  }
+
+  return { flags, rest };
+}
+
+function wantsJson(args: string[]): boolean {
+  return args.includes("--json");
+}
+
+function isFlagEnabled(flags: Flags, name: string): boolean {
+  return flags[name] === true;
+}
+
+function optionalString(flags: Flags, name: string): string | undefined {
+  const value = flags[name];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function parsePositiveIntFlag(
+  flags: Flags,
+  name: string,
+  defaultValue: number,
+  max: number,
+): number {
+  const raw = flags[name];
+  if (raw === undefined) {
+    return defaultValue;
+  }
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    throw new Error(`--${name} requires a numeric value`);
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > max) {
+    throw new Error(`--${name} must be an integer from 1 to ${max}`);
+  }
+  return parsed;
+}
+
+function parsePreset(flags: Flags): "full" | "compact" | "minimal" | undefined {
+  const value = optionalString(flags, "preset") ?? optionalString(flags, "response-preset");
+  if (value === undefined) {
+    return undefined;
+  }
+  if (value === "full" || value === "compact" || value === "minimal") {
+    return value;
+  }
+  throw new Error("--preset must be one of full, compact, minimal");
+}
+
+function parseCsvFlag<T extends string>(
+  flags: Flags,
+  name: string,
+  allowed: readonly T[],
+): T[] | undefined {
+  const raw = optionalString(flags, name);
+  if (!raw) {
+    return undefined;
+  }
+  const allowedSet = new Set<string>(allowed);
+  const parsed = raw.split(",").map((value) => value.trim()).filter(Boolean);
+  for (const value of parsed) {
+    if (!allowedSet.has(value)) {
+      throw new Error(`--${name} contains unsupported value: ${value}`);
+    }
+  }
+  return parsed as T[];
+}
+
+function positionalText(rest: string[], label: string): string {
+  const value = rest.join(" ").trim();
+  if (!value) {
+    throw new Error(`${label} is required`);
+  }
+  return value;
+}
+
+function emitJson(value: JsonEnvelope): void {
+  process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+
+function emitEnvelope(command: string, input: Record<string, unknown>, data: ToolPayload): void {
+  emitJson({
+    ok: true,
+    command,
+    input,
+    context_source: data.context_source,
+    warning: data.warning,
+    data,
+  });
+}
+
+function printSummary(command: string, data: ToolPayload): void {
+  const source = data.context_source ? ` context_source=${String(data.context_source)}` : "";
+  const warning = data.warning ? ` warning=${String(data.warning)}` : "";
+
+  if (Array.isArray(data.results)) {
+    process.stdout.write(`${command}: ${data.results.length} results${source}${warning}\n`);
+    for (const result of data.results.slice(0, 10)) {
+      printEntityLine(result);
+    }
+    return;
+  }
+
+  if (Array.isArray(data.related)) {
+    process.stdout.write(`${command}: ${data.related.length} related${source}${warning}\n`);
+    for (const result of data.related.slice(0, 10)) {
+      printEntityLine(result);
+    }
+    return;
+  }
+
+  if (Array.isArray(data.rules)) {
+    process.stdout.write(`${command}: ${data.rules.length} rules${source}${warning}\n`);
+    for (const rule of data.rules.slice(0, 10)) {
+      if (rule && typeof rule === "object") {
+        const row = rule as Record<string, unknown>;
+        process.stdout.write(`- ${String(row.id ?? "")} priority=${String(row.priority ?? "")} scope=${String(row.scope ?? "")}\n`);
+      }
+    }
+    return;
+  }
+
+  process.stdout.write(`${command}: ok${source}${warning}\n`);
+}
+
+function printEntityLine(value: unknown): void {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  const row = value as Record<string, unknown>;
+  const title = row.title ?? row.label ?? row.id ?? "";
+  const path = row.path ? ` ${String(row.path)}` : "";
+  process.stdout.write(`- ${String(title)}${path}\n`);
+}
+
+async function runSearch(args: string[]): Promise<void> {
+  const { flags, rest } = parseArgs(args);
+  const query = optionalString(flags, "query") ?? positionalText(rest, "query");
+  const input: SearchParams = {
+    query,
+    top_k: parsePositiveIntFlag(flags, "top-k", 5, 20),
+    include_deprecated: isFlagEnabled(flags, "include-deprecated"),
+    response_preset: parsePreset(flags),
+    include_scores: isFlagEnabled(flags, "scores") || isFlagEnabled(flags, "include-scores") || undefined,
+    include_matched_rules:
+      isFlagEnabled(flags, "matched-rules") || isFlagEnabled(flags, "include-matched-rules") || undefined,
+    include_content: isFlagEnabled(flags, "include-content") || undefined,
+  };
+  const data = await runContextSearch(input);
+  if (isFlagEnabled(flags, "json")) {
+    emitEnvelope("search", input, data);
+    return;
+  }
+  printSummary("search", data);
+}
+
+async function runRelated(args: string[]): Promise<void> {
+  const { flags, rest } = parseArgs(args);
+  const entityId = optionalString(flags, "entity-id") ?? positionalText(rest, "entity-id");
+  const input: RelatedParams = {
+    entity_id: entityId,
+    depth: parsePositiveIntFlag(flags, "depth", 1, 3),
+    include_edges: isFlagEnabled(flags, "edges") || isFlagEnabled(flags, "include-edges") || undefined,
+    response_preset: parsePreset(flags),
+    include_entity_metadata:
+      isFlagEnabled(flags, "metadata") || isFlagEnabled(flags, "include-entity-metadata") || undefined,
+  };
+  const data = await runContextRelated(input);
+  if (isFlagEnabled(flags, "json")) {
+    emitEnvelope("related", input, data);
+    return;
+  }
+  printSummary("related", data);
+}
+
+async function runImpact(args: string[]): Promise<void> {
+  const { flags, rest } = parseArgs(args);
+  const explicitEntityId = optionalString(flags, "entity-id");
+  const explicitQuery = optionalString(flags, "query");
+  const positional = rest.length > 0 ? positionalText(rest, "query-or-entity-id") : undefined;
+  const seed = explicitEntityId ?? explicitQuery ?? positional;
+
+  if (!seed) {
+    throw new Error("Either --entity-id, --query, or a positional seed is required");
+  }
+
+  const relationTypes = parseCsvFlag(flags, "relation-types", [
+    "CALLS",
+    "CALLS_SQL",
+    "IMPORTS",
+    "USES_CONFIG_KEY",
+    "USES_RESOURCE_KEY",
+    "USES_SETTING_KEY",
+    "USES_CONFIG",
+    "TRANSFORMS_CONFIG",
+    "PART_OF",
+  ] as const);
+  const input: ImpactParams = {
+    depth: parsePositiveIntFlag(flags, "depth", 2, 4),
+    top_k: parsePositiveIntFlag(flags, "top-k", 8, 20),
+    include_edges: !isFlagEnabled(flags, "no-edges"),
+    response_preset: parsePreset(flags),
+    include_scores: isFlagEnabled(flags, "scores") || isFlagEnabled(flags, "include-scores") || undefined,
+    include_reasons: isFlagEnabled(flags, "reasons") || isFlagEnabled(flags, "include-reasons") || undefined,
+    verbose_paths: isFlagEnabled(flags, "verbose-paths") || undefined,
+    max_path_hops_shown: parsePositiveIntFlag(flags, "max-path-hops-shown", 3, 8),
+    profile: parseProfile(flags),
+    sort_by: parseSortBy(flags),
+    relation_types: relationTypes as RelationType[] | undefined,
+    path_must_include: parseCsvFlag(flags, "path-must-include", relationTypesAllowed()) as RelationType[] | undefined,
+    path_must_exclude: parseCsvFlag(flags, "path-must-exclude", relationTypesAllowed()) as RelationType[] | undefined,
+    result_domains: parseCsvFlag(flags, "result-domains", [
+      "code",
+      "config",
+      "resource",
+      "settings",
+      "sql",
+      "project",
+    ] as const),
+    result_entity_types: parseCsvFlag(flags, "result-entity-types", [
+      "File",
+      "Chunk",
+      "Module",
+      "Project",
+      "ADR",
+      "Rule",
+    ] as const),
+  };
+
+  if (explicitEntityId || (!explicitQuery && seedLooksLikeEntityId(seed))) {
+    input.entity_id = seed;
+  } else {
+    input.query = seed;
+  }
+
+  const data = await runContextImpact(input);
+  if (isFlagEnabled(flags, "json")) {
+    emitEnvelope("impact", input as Record<string, unknown>, data);
+    return;
+  }
+  printSummary("impact", data);
+}
+
+function relationTypesAllowed(): readonly RelationType[] {
+  return [
+    "CALLS",
+    "CALLS_SQL",
+    "IMPORTS",
+    "USES_CONFIG_KEY",
+    "USES_RESOURCE_KEY",
+    "USES_SETTING_KEY",
+    "USES_CONFIG",
+    "TRANSFORMS_CONFIG",
+    "PART_OF",
+  ];
+}
+
+function seedLooksLikeEntityId(value: string): boolean {
+  return ENTITY_ID_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
+
+function parseProfile(flags: Flags): ImpactParams["profile"] {
+  const value = optionalString(flags, "profile");
+  if (!value) {
+    return "all";
+  }
+  if (value === "all" || value === "config_only" || value === "config_to_sql" || value === "code_only" || value === "sql_only") {
+    return value;
+  }
+  throw new Error("--profile must be one of all, config_only, config_to_sql, code_only, sql_only");
+}
+
+function parseSortBy(flags: Flags): ImpactParams["sort_by"] {
+  const value = optionalString(flags, "sort-by");
+  if (!value) {
+    return "impact_score";
+  }
+  if (value === "impact_score" || value === "shortest_path" || value === "semantic_score" || value === "graph_score" || value === "trust_score") {
+    return value;
+  }
+  throw new Error("--sort-by must be one of impact_score, shortest_path, semantic_score, graph_score, trust_score");
+}
+
+async function runRules(args: string[]): Promise<void> {
+  const { flags } = parseArgs(args);
+  const input: RulesParams = {
+    scope: optionalString(flags, "scope"),
+    include_inactive: isFlagEnabled(flags, "include-inactive"),
+  };
+  const data = await runContextRules(input);
+  if (isFlagEnabled(flags, "json")) {
+    emitEnvelope("rules", input, data);
+    return;
+  }
+  printSummary("rules", data);
+}
+
+async function runExplain(args: string[]): Promise<void> {
+  const { flags, rest } = parseArgs(args);
+  const target = optionalString(flags, "id") ?? optionalString(flags, "query") ?? positionalText(rest, "query-or-entity-id");
+  const input: SearchParams = {
+    query: target,
+    top_k: parsePositiveIntFlag(flags, "top-k", 3, 20),
+    include_deprecated: isFlagEnabled(flags, "include-deprecated"),
+    response_preset: parsePreset(flags) ?? "full",
+    include_scores: true,
+    include_matched_rules: true,
+    include_content: isFlagEnabled(flags, "include-content") || undefined,
+  };
+  const search = await runContextSearch(input);
+  const data: ToolPayload = {
+    query: target,
+    entity_id: seedLooksLikeEntityId(target) ? target : undefined,
+    context_source: search.context_source,
+    warning: search.warning,
+    semantic_engine: search.semantic_engine,
+    ranking: search.ranking,
+    results: search.results,
+    explanation: "Scores and matched_rules come from the same local search ranking used by context.search.",
+  };
+
+  if (isFlagEnabled(flags, "json")) {
+    emitEnvelope("explain", input, data);
+    return;
+  }
+  printSummary("explain", data);
+}

package/scaffold/mcp/tests/query-cli.test.mjs

@@ -0,0 +1,115 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const QUERY_MODULE = fileURLToPath(new URL("../dist/cli/query.js", import.meta.url));
+
+function runQuery(args) {
+  const script = [
+    "const mod = await import(process.argv[1]);",
+    "await mod.runQueryCommand(JSON.parse(process.argv[2]));",
+  ].join("\n");
+
+  return spawnSync(
+    process.execPath,
+    [
+      "--input-type=module",
+      "-e",
+      script,
+      pathToFileURL(QUERY_MODULE).href,
+      JSON.stringify(args),
+    ],
+    { encoding: "utf8" },
+  );
+}
+
+function runJson(args, expectedStatus = 0) {
+  const result = runQuery(args);
+  assert.equal(result.status, expectedStatus, result.stderr || result.stdout);
+  return JSON.parse(result.stdout);
+}
+
+test("rules --json emits a stable envelope", () => {
+  const parsed = runJson(["rules", "--json"]);
+
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.command, "rules");
+  assert.equal(parsed.input.include_inactive, false);
+  assert.ok(["ryu", "cache"].includes(String(parsed.context_source)));
+  assert.ok(Array.isArray(parsed.data.rules));
+  assert.equal(parsed.data.count, parsed.data.rules.length);
+});
+
+test("search --json maps flags to context.search input", () => {
+  const parsed = runJson([
+    "search",
+    "rule.source_of_truth",
+    "--top-k",
+    "3",
+    "--preset",
+    "full",
+    "--scores",
+    "--matched-rules",
+    "--json",
+  ]);
+
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.command, "search");
+  assert.equal(parsed.input.query, "rule.source_of_truth");
+  assert.equal(parsed.input.top_k, 3);
+  assert.equal(parsed.input.response_preset, "full");
+  assert.equal(parsed.input.include_scores, true);
+  assert.equal(parsed.input.include_matched_rules, true);
+  assert.ok(Array.isArray(parsed.data.results));
+  assert.ok(parsed.data.results.length <= 3);
+});
+
+test("related --json preserves missing-entity runtime behavior", () => {
+  const parsed = runJson(["related", "file:no-such-file", "--json"]);
+
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.command, "related");
+  assert.equal(parsed.input.entity_id, "file:no-such-file");
+  assert.deepEqual(parsed.data.related, []);
+  assert.match(parsed.data.warning, /Entity not found/);
+});
+
+test("impact --json supports positional entity ids", () => {
+  const parsed = runJson([
+    "impact",
+    "file:bin/cortex.mjs",
+    "--depth",
+    "1",
+    "--top-k",
+    "2",
+    "--json",
+  ]);
+
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.command, "impact");
+  assert.equal(parsed.input.entity_id, "file:bin/cortex.mjs");
+  assert.equal(parsed.input.depth, 1);
+  assert.equal(parsed.input.top_k, 2);
+  assert.ok(Array.isArray(parsed.data.results));
+});
+
+test("explain --json enables scores and matched rules", () => {
+  const parsed = runJson(["explain", "rule.source_of_truth", "--json"]);
+
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.command, "explain");
+  assert.equal(parsed.input.include_scores, true);
+  assert.equal(parsed.input.include_matched_rules, true);
+  assert.equal(parsed.data.explanation.includes("context.search"), true);
+  assert.ok(Array.isArray(parsed.data.results));
+});
+
+test("json validation errors emit an error envelope", () => {
+  const parsed = runJson(["impact", "--json"], 1);
+
+  assert.equal(parsed.ok, false);
+  assert.equal(parsed.command, "impact");
+  assert.equal(parsed.error.code, "INVALID_ARGS");
+  assert.match(parsed.error.message, /Either --entity-id/);
+});

package/scaffold/scripts/bootstrap.sh

@@ -3,7 +3,8 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-MCP_DIR="$REPO_ROOT/.context/mcp"
+CONTEXT_RUNTIME_DIR="$REPO_ROOT/.context/mcp"
+MCP_DIR="$CONTEXT_RUNTIME_DIR"
 TOTAL_STEPS=6
 STEP_INDEX=0
 
@@ -55,7 +56,7 @@ install_deps_if_changed() {
   fi
 }
 
-step "Installing MCP dependencies"
+step "Installing context runtime dependencies"
 info "note: upstream RyuGraph dependencies may print deprecation warnings during install"
 install_deps_if_changed "$MCP_DIR" "$MCP_DIR/.npm-cache"
 install_deps_if_changed "$REPO_ROOT/.context/scripts/parsers" "$REPO_ROOT/.context/scripts/parsers/.npm-cache"

package/scaffold/scripts/doctor.sh

@@ -4,7 +4,8 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
 CONTEXT_DIR="$REPO_ROOT/.context"
-MCP_DIR="$CONTEXT_DIR/mcp"
+CONTEXT_RUNTIME_DIR="$CONTEXT_DIR/mcp"
+MCP_DIR="$CONTEXT_RUNTIME_DIR"
 
 PASS=0
 FAIL=0
@@ -160,24 +161,24 @@ if [[ -f "$INGEST_MANIFEST" ]] && command -v git &>/dev/null && git -C "$REPO_RO
   fi
 fi
 
-# ── MCP Server ──────────────────────────────────────────
+# ── Context Runtime / MCP Server ─────────────────────────
 
 echo ""
-echo "  MCP Server"
+echo "  Context Runtime"
 
 if [[ -f "$MCP_DIR/dist/server.js" ]]; then
-  pass ".context/mcp/dist/server.js exists"
+  pass "runtime dist present (.context/mcp/dist/server.js)"
 else
-  fail ".context/mcp/dist/server.js missing — run: cd .context/mcp && npm run build"
+  fail "runtime dist missing — run: cd .context/mcp && npm run build"
 fi
 
 if [[ -d "$MCP_DIR/node_modules" ]]; then
-  pass ".context/mcp/node_modules present"
+  pass "runtime dependencies present (.context/mcp/node_modules)"
 else
-  fail ".context/mcp/node_modules missing — run: cd .context/mcp && npm install"
+  fail "runtime dependencies missing — run: cd .context/mcp && npm install"
 fi
 
-# Quick MCP import check
+# Quick runtime import check
 if [[ -f "$MCP_DIR/dist/server.js" ]] && [[ -d "$MCP_DIR/node_modules" ]]; then
   MCP_CHECK=$(cd "$REPO_ROOT" && timeout 10 node -e '
     const start = Date.now();

package/scaffold/scripts/embed.sh

@@ -3,7 +3,8 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-MCP_DIR="$REPO_ROOT/.context/mcp"
+CONTEXT_RUNTIME_DIR="$REPO_ROOT/.context/mcp"
+MCP_DIR="$CONTEXT_RUNTIME_DIR"
 
 if ! command -v npm >/dev/null 2>&1; then
   echo "[embed] npm is required but not found on PATH"
@@ -12,5 +13,5 @@ fi
 
 mkdir -p "$MCP_DIR/.npm-cache"
 
-echo "[embed] generating embeddings via .context/mcp/embed"
+echo "[embed] generating embeddings via context runtime"
 CORTEX_PROJECT_ROOT="$REPO_ROOT" NPM_CONFIG_CACHE="$MCP_DIR/.npm-cache" npm --prefix "$MCP_DIR" run embed --silent -- "$@"

package/scaffold/scripts/load-ryu.sh

@@ -3,7 +3,8 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-MCP_DIR="$REPO_ROOT/.context/mcp"
+CONTEXT_RUNTIME_DIR="$REPO_ROOT/.context/mcp"
+MCP_DIR="$CONTEXT_RUNTIME_DIR"
 
 if [[ ! -f "$MCP_DIR/package.json" ]]; then
   echo "[graph-load] missing $MCP_DIR/package.json"
@@ -11,7 +12,7 @@ if [[ ! -f "$MCP_DIR/package.json" ]]; then
 fi
 
 if [[ ! -d "$MCP_DIR/node_modules" ]]; then
-  echo "[graph-load] node_modules missing in .context/mcp/"
+  echo "[graph-load] node_modules missing in context runtime (.context/mcp compatibility path)"
   echo "[graph-load] run: cd .context/mcp && NPM_CONFIG_CACHE=$MCP_DIR/.npm-cache npm install"
   exit 1
 fi

package/scaffold/scripts/memory-compile.mjs

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseFrontmatter, parseStringList } from "../mcp/dist/frontmatter.js";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+const CONTEXT_RUNTIME_DIST = path.resolve(__dirname, "../mcp/dist");
+const { parseFrontmatter, parseStringList } = await import(
+  pathToFileURL(path.join(CONTEXT_RUNTIME_DIST, "frontmatter.js")).href
+);
 
 function normalizeForWsl(rawPath) {
   const m = rawPath.match(/^([A-Za-z]):[/\\](.*)/);