@danielblomma/cortex-mcp 1.6.0 → 1.7.1

package/bin/cortex.mjs

@@ -149,6 +149,80 @@ function ensureScaffoldExists() {
 // Files that should never be overwritten if they already exist in the target.
 // These contain user-specific configuration that would be lost on re-init.
 const PRESERVE_FILES = new Set(["config.yaml", "enterprise.yml", "enterprise.yaml", "CLAUDE.md"]);
+const DEFAULT_SOURCE_PATHS = [
+  "src",
+  "docs",
+  "design",
+  ".context/notes",
+  ".context/decisions",
+  "README.md"
+];
+const INIT_SKIP_DIRECTORIES = new Set([
+  ".git",
+  ".idea",
+  ".vscode",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".cache",
+  ".context",
+  "scripts",
+  "mcp",
+  ".githooks",
+  "bin",
+  "obj"
+]);
+const INIT_SOURCE_EXTENSIONS = new Set([
+  ".md",
+  ".mdx",
+  ".txt",
+  ".adoc",
+  ".rst",
+  ".yaml",
+  ".yml",
+  ".json",
+  ".toml",
+  ".csv",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".java",
+  ".cs",
+  ".vb",
+  ".sln",
+  ".vbproj",
+  ".csproj",
+  ".fsproj",
+  ".props",
+  ".targets",
+  ".config",
+  ".resx",
+  ".settings",
+  ".rb",
+  ".rs",
+  ".php",
+  ".swift",
+  ".kt",
+  ".sql",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".ps1",
+  ".c",
+  ".h",
+  ".cpp",
+  ".hpp",
+  ".cc",
+  ".hh"
+]);
+const ROOT_DOC_PATHS = new Set(["docs", "design"]);
 
 function copyDirectory(sourceDir, targetDir) {
   fs.mkdirSync(targetDir, { recursive: true });
@@ -175,6 +249,147 @@ function copyDirectory(sourceDir, targetDir) {
   }
 }
 
+function toPosixPath(value) {
+  return value.split(path.sep).join("/");
+}
+
+function yamlScalar(value) {
+  return /^[A-Za-z0-9._/-]+$/.test(value) ? value : JSON.stringify(value);
+}
+
+function slugifyRepoId(value) {
+  const dashed = String(value || "")
+    .trim()
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replace(/[^A-Za-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase();
+  return dashed || "cortex";
+}
+
+function isInterestingSourceFile(fileName) {
+  const base = fileName.toLowerCase();
+  const ext = path.extname(fileName).toLowerCase();
+  return INIT_SOURCE_EXTENSIONS.has(ext) || base === "readme" || base.startsWith("readme.");
+}
+
+function directoryContainsInterestingFiles(directoryPath) {
+  const stack = [directoryPath];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const absolutePath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (INIT_SKIP_DIRECTORIES.has(entry.name)) {
+          continue;
+        }
+        stack.push(absolutePath);
+        continue;
+      }
+
+      if (entry.isFile() && isInterestingSourceFile(entry.name)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function detectInitialSourcePaths(targetDir) {
+  if (!fs.existsSync(targetDir)) {
+    return [...DEFAULT_SOURCE_PATHS];
+  }
+
+  let entries = [];
+  try {
+    entries = fs.readdirSync(targetDir, { withFileTypes: true });
+  } catch {
+    return [...DEFAULT_SOURCE_PATHS];
+  }
+
+  const codeDirs = [];
+  const docDirs = [];
+  const rootFiles = [];
+
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const absolutePath = path.join(targetDir, entry.name);
+
+    if (entry.isDirectory()) {
+      if (INIT_SKIP_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+      if (!directoryContainsInterestingFiles(absolutePath)) {
+        continue;
+      }
+
+      const bucket = ROOT_DOC_PATHS.has(entry.name) ? docDirs : codeDirs;
+      bucket.push(toPosixPath(entry.name));
+      continue;
+    }
+
+    if (entry.isFile() && isInterestingSourceFile(entry.name)) {
+      rootFiles.push(toPosixPath(entry.name));
+    }
+  }
+
+  const readmeFiles = rootFiles.filter((filePath) => /^readme(\.|$)/i.test(path.basename(filePath)));
+  const nonReadmeRootFiles = rootFiles.filter((filePath) => !readmeFiles.includes(filePath));
+  const detected = [
+    ...codeDirs,
+    ...nonReadmeRootFiles,
+    ...docDirs,
+    ".context/notes",
+    ".context/decisions",
+    ...readmeFiles
+  ];
+  const uniqueDetected = [...new Set(detected)];
+  const hasConcreteRepoContent = uniqueDetected.some((value) => !value.startsWith(".context/"));
+  return hasConcreteRepoContent ? uniqueDetected : [...DEFAULT_SOURCE_PATHS];
+}
+
+function buildInitialConfig(targetDir) {
+  const repoId = slugifyRepoId(path.basename(path.resolve(targetDir)));
+  const sourcePaths = detectInitialSourcePaths(targetDir);
+  return [
+    `repo_id: ${yamlScalar(repoId)}`,
+    "source_paths:",
+    ...sourcePaths.map((sourcePath) => `  - ${yamlScalar(sourcePath)}`),
+    "truth_order:",
+    "  - ADR",
+    "  - RULE",
+    "  - CODE",
+    "  - WIKI",
+    "ranking:",
+    "  semantic: 0.40",
+    "  graph: 0.25",
+    "  trust: 0.20",
+    "  recency: 0.15",
+    "runtime:",
+    "  top_k: 5",
+    "  include_uncertainties: true",
+    ""
+  ].join("\n");
+}
+
+function initializeScaffold(targetDir, force) {
+  const configPath = path.join(targetDir, ".context", "config.yaml");
+  const hasExistingConfig = fs.existsSync(configPath);
+  const generatedConfig = hasExistingConfig ? null : buildInitialConfig(targetDir);
+  installScaffold(targetDir, force);
+  if (!hasExistingConfig && generatedConfig) {
+    writeTextFile(configPath, generatedConfig);
+  }
+}
+
 function ensurePathWritable(targetPath, force) {
   if (!fs.existsSync(targetPath)) {
     return;
@@ -555,7 +770,7 @@ async function maybeMigrateScaffold(targetDir, command) {
 
   console.error(`[cortex] migrating scaffold in ${targetDir}`);
   ensureScaffoldExists();
-  installScaffold(targetDir, true);
+  initializeScaffold(targetDir, true);
   installAssistantHelpers(targetDir);
   await maybeInstallGitHooks(targetDir);
   await runContextCommand(targetDir, ["bootstrap"]);
@@ -590,7 +805,7 @@ async function ensureProjectInitializedForMcp(targetDir) {
     }
     ensureScaffoldExists();
     fs.mkdirSync(targetDir, { recursive: true });
-    installScaffold(targetDir, false);
+    initializeScaffold(targetDir, false);
     installAssistantHelpers(targetDir);
     await maybeInstallGitHooks(targetDir);
     console.log(`[cortex] auto-init completed in ${targetDir}`);
@@ -632,7 +847,7 @@ async function run() {
     const { target, force, bootstrap, connect, watch } = parseInitArgs(rest);
     printBanner("Cortex initializes repo-scoped context for AI coding agents.");
     fs.mkdirSync(target, { recursive: true });
-    installScaffold(target, force);
+    initializeScaffold(target, force);
     const helpers = installAssistantHelpers(target);
     await maybeInstallGitHooks(target);
 
@@ -753,4 +968,4 @@ if (invokedAsScript) {
   });
 }
 
-export { isScaffoldOutOfDate };
+export { buildInitialConfig, detectInitialSourcePaths, isScaffoldOutOfDate, slugifyRepoId };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danielblomma/cortex-mcp",
   "mcpName": "io.github.DanielBlomma/cortex",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "Local, repo-scoped context platform for coding assistants. Semantic search, graph relationships, and architectural rule context.",
   "type": "module",
   "author": "Daniel Blomma",
@@ -46,7 +46,7 @@
     "docs/MCP_MARKETPLACE.md"
   ],
   "scripts": {
-    "test": "node tests/context-regressions.test.mjs && node --test tests/ingest-units.test.mjs tests/javascript-parser.test.mjs tests/sql-parser.test.mjs tests/config-parser.test.mjs tests/resources-parser.test.mjs tests/vbnet-parser.test.mjs tests/cpp-parser.test.mjs tests/multi-level.test.mjs tests/no-legacy-paths.test.mjs tests/tree-sitter-error-reporting.test.mjs tests/tree-sitter-body-cap.test.mjs tests/tree-sitter-exported.test.mjs tests/tree-sitter-robustness.test.mjs",
+    "test": "node tests/context-regressions.test.mjs && node --test tests/ingest-units.test.mjs tests/javascript-parser.test.mjs tests/sql-parser.test.mjs tests/config-parser.test.mjs tests/resources-parser.test.mjs tests/vbnet-parser.test.mjs tests/cpp-parser.test.mjs tests/dashboard.test.mjs tests/init-config.test.mjs tests/multi-level.test.mjs tests/no-legacy-paths.test.mjs tests/tree-sitter-error-reporting.test.mjs tests/tree-sitter-body-cap.test.mjs tests/tree-sitter-exported.test.mjs tests/tree-sitter-robustness.test.mjs",
     "release:sync-version": "node scripts/sync-release-version.mjs",
     "release:check-version-sync": "node scripts/sync-release-version.mjs --check",
     "prepublishOnly": "echo 'Ready to publish to npm'"

package/scaffold/scripts/dashboard.mjs

@@ -24,11 +24,12 @@ const SUPPORTED_TEXT_EXTENSIONS = new Set([
 // Same skip dirs as ingest.mjs
 const SKIP_DIRECTORIES = new Set([
   ".git", ".idea", ".vscode", "node_modules",
-  "dist", "build", "coverage", ".next", ".cache", ".context"
+  "bin", "obj", "dist", "build", "coverage", ".next", ".cache", ".context"
 ]);
 
 const MAX_FILE_BYTES = 1024 * 1024;
 const VERSION_CHECK_TTL_MS = 10 * 60 * 1000;
+const VERSION_LOOKUP_TIMEOUT_MS = 8000;
 const VERSION_INSTALL_HINT = "npm i -g github:DanielBlomma/cortex";
 
 // ── ANSI helpers ──────────────────────────────────────────────
@@ -93,7 +94,11 @@ function walkDirectory(dirPath, files) {
     if (entry.isDirectory()) {
       walkDirectory(abs, files);
     } else if (entry.isFile()) {
-      files.push(abs);
+      if (typeof files.add === "function") {
+        files.add(abs);
+      } else {
+        files.push(abs);
+      }
     }
   }
 }
@@ -111,20 +116,20 @@ function hasSourcePrefix(relPath, sourcePaths) {
 }
 
 // ── Data: baseline scan ──────────────────────────────────────
-function scanBaseline() {
-  if (!fs.existsSync(CONFIG_PATH)) return { files: 0, lines: 0, chars: 0, tokens: 0 };
+function scanBaseline(repoRoot = REPO_ROOT, configPath = CONFIG_PATH) {
+  if (!fs.existsSync(configPath)) return { files: 0, lines: 0, chars: 0, tokens: 0 };
 
-  const configText = fs.readFileSync(CONFIG_PATH, "utf8");
-  const sourcePaths = parseSourcePaths(configText);
+  const configText = fs.readFileSync(configPath, "utf8");
+  const sourcePaths = [...new Set(parseSourcePaths(configText))];
   if (sourcePaths.length === 0) return { files: 0, lines: 0, chars: 0, tokens: 0 };
 
-  const allFiles = [];
+  const allFiles = new Set();
   for (const sp of sourcePaths) {
-    const abs = path.resolve(REPO_ROOT, sp);
+    const abs = path.resolve(repoRoot, sp);
     if (!fs.existsSync(abs)) continue;
     const stat = fs.statSync(abs);
     if (stat.isFile()) {
-      allFiles.push(abs);
+      allFiles.add(abs);
     } else if (stat.isDirectory()) {
       walkDirectory(abs, allFiles);
     }
@@ -199,6 +204,7 @@ function computeFreshness(manifest) {
   try {
     const output = execSync("git status --porcelain", {
       cwd: REPO_ROOT, stdio: ["ignore", "pipe", "ignore"], encoding: "utf8", timeout: 3000,
+      shell: true,
     });
 
     for (const rawLine of output.split(/\r?\n/)) {
@@ -264,6 +270,9 @@ function shorten(text, max = 40) {
 }
 
 function summarizeError(error) {
+  if (error && typeof error === "object" && error.code === "ETIMEDOUT") {
+    return `version check timed out after ${Math.round(VERSION_LOOKUP_TIMEOUT_MS / 1000)}s`;
+  }
   const raw = error instanceof Error ? error.message : String(error);
   return shorten(raw.split(/\r?\n/)[0].trim());
 }
@@ -280,6 +289,7 @@ function getLocalCliVersion() {
       stdio: ["ignore", "pipe", "ignore"],
       encoding: "utf8",
       timeout: 1500,
+      shell: true,
     }).trim();
     if (parseVersion(output)) {
       return output;
@@ -323,8 +333,9 @@ function getVersionStatus() {
           cwd: REPO_ROOT,
           stdio: ["ignore", "pipe", "pipe"],
           encoding: "utf8",
-          timeout: 2500,
+          timeout: VERSION_LOOKUP_TIMEOUT_MS,
           env: { ...process.env, NPM_CONFIG_CACHE: npmCache },
+          shell: true,
         }).trim();
         const parsedLatest = JSON.parse(latestRaw);
         const latest = Array.isArray(parsedLatest)
@@ -488,6 +499,7 @@ function gatherData(baselineCache) {
     },
     tokens: tokenEstimate,
     embeddings: embedModel ? { model: embedModel, count: embedCount, dimensions: embedDim } : null,
+    parserHealth: manifests.ingest?.parser_health || {},
     freshness,
     version,
     topConnected,
@@ -693,6 +705,14 @@ function render(data, isTTY) {
   } else {
     lines.push(sideBorder(`Embeddings: ${col("not generated", C.yellow)}  ${dim("Run: cortex embed")}`, w));
   }
+  if (data.parserHealth.csharp && Number(data.parserHealth.csharp.files || 0) > 0) {
+    const csharp = data.parserHealth.csharp;
+    if (!csharp.available) {
+      lines.push(sideBorder(`Parser warning (C#): ${col("unavailable", C.red)}  ${dim(csharp.reason || "install .NET SDK")}`, w));
+    } else if (csharp.chunks === 0) {
+      lines.push(sideBorder(`Parser warning (C#): ${col("0 chunks", C.yellow)}  ${dim(`${csharp.files} files indexed`)}`, w));
+    }
+  }
   lines.push(emptyLine(w));
 
   // ── TOP CONNECTED ──
@@ -788,4 +808,14 @@ function main() {
   });
 }
 
-main();
+const isMainModule = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(__filename);
+if (isMainModule) {
+  main();
+}
+
+export {
+  parseSourcePaths,
+  render,
+  scanBaseline,
+  walkDirectory
+};

package/scaffold/scripts/ingest.mjs

@@ -24,6 +24,7 @@ let parseVb6Code = null;
 let isVbNetParserAvailable = () => false;
 let isCSharpParserAvailable = () => false;
 let isCppParserAvailable = () => false;
+let getCSharpParserRuntime = () => ({ available: false, reason: "parser module not loaded" });
 
 async function loadOptionalParsers() {
   const loaders = [
@@ -37,6 +38,10 @@ async function loadOptionalParsers() {
     import("./parsers/csharp.mjs").then((module) => {
       parseCSharpCode = module.parseCode;
       parseCSharpProject = module.parseProject ?? null;
+      getCSharpParserRuntime =
+        typeof module.getCSharpParserRuntime === "function"
+          ? module.getCSharpParserRuntime
+          : () => ({ available: typeof module.parseCode === "function", reason: "runtime details unavailable" });
       isCSharpParserAvailable =
         typeof module.isCSharpParserAvailable === "function"
           ? module.isCSharpParserAvailable
@@ -472,6 +477,8 @@ const SKIP_DIRECTORIES = new Set([
   ".idea",
   ".vscode",
   "node_modules",
+  "bin",
+  "obj",
   "dist",
   "build",
   "coverage",
@@ -2675,6 +2682,8 @@ async function main() {
 
   const fileRecords = [...fileRecordMap.values()].sort((a, b) => a.path.localeCompare(b.path));
   const adrRecords = [...adrRecordMap.values()].sort((a, b) => a.path.localeCompare(b.path));
+  const csharpFileCount = fileRecords.filter((record) => path.extname(record.path).toLowerCase() === ".cs").length;
+  const csharpRuntime = csharpFileCount > 0 ? getCSharpParserRuntime() : null;
   const indexedFileIds = new Set(fileRecords.map((record) => record.id));
   const changedFileIds = new Set(
     [...candidates].map((absolutePath) => `file:${toPosixPath(path.relative(REPO_ROOT, absolutePath))}`)
@@ -3075,6 +3084,23 @@ async function main() {
     }
   }
 
+  const csharpChunkCount = chunkRecords.filter((record) => record.language === "csharp").length;
+  const parserHealth = {};
+  if (csharpFileCount > 0) {
+    parserHealth.csharp = {
+      files: csharpFileCount,
+      available: Boolean(csharpRuntime?.available),
+      reason: csharpRuntime?.available ? null : (csharpRuntime?.reason ?? "C# parser unavailable"),
+      chunks: csharpChunkCount,
+    };
+
+    if (!csharpRuntime?.available) {
+      console.log(`[ingest] warning csharp parser unavailable: ${parserHealth.csharp.reason}`);
+    } else if (csharpChunkCount === 0) {
+      console.log("[ingest] warning csharp parser produced 0 chunks across C# files");
+    }
+  }
+
   // Generate Module entities and relations
   const moduleResult = generateModules(fileRecords, chunkRecords);
   const moduleRecords = moduleResult.modules;
@@ -3512,6 +3538,7 @@ async function main() {
       relations_transforms_config: configTransformRelations.length
     },
     skipped,
+    parser_health: parserHealth,
     incremental_mode: incrementalMode,
     changed_candidates: candidates.size,
     deleted_paths: deletedRelPaths.length

package/scaffold/scripts/parsers/csharp.mjs

@@ -25,6 +25,20 @@ const DEFAULT_TARGET_FRAMEWORK = "net8.0";
 let runtimeCache = null;
 let publishCache = null;
 
+function hasGitCheckout(startDir) {
+  let current = startDir;
+  while (true) {
+    if (fs.existsSync(path.join(current, ".git"))) {
+      return true;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return false;
+    }
+    current = parent;
+  }
+}
+
 function getDotnetCommand() {
   const override = process.env.CORTEX_DOTNET_CMD;
   return override && override.trim().length > 0 ? override.trim() : DEFAULT_DOTNET_COMMAND;
@@ -74,6 +88,19 @@ function needsPublish() {
   } catch {
     return true;
   }
+
+  if (process.env.CORTEX_CSHARP_FORCE_PUBLISH === "1") {
+    return true;
+  }
+
+  // In packaged installs there is no writable git checkout, but the
+  // published DLL is already bundled. Trust it instead of forcing an
+  // unnecessary `dotnet publish`, which can fail offline and leave C#
+  // repos with 0 chunks.
+  if (!hasGitCheckout(__dirname)) {
+    return false;
+  }
+
   return getMaxSourceMtime() > dllMtime;
 }
 

package/scaffold/scripts/status.sh

@@ -24,6 +24,13 @@ console.log(`[status] files=${c.files ?? 0} adrs=${c.adrs ?? 0} rules=${c.rules
 console.log(`[status] rels constrains=${c.relations_constrains ?? 0} implements=${c.relations_implements ?? 0} supersedes=${c.relations_supersedes ?? 0}`);
 const s = data.skipped || {};
 console.log(`[status] skipped unsupported=${s.unsupported ?? 0} too_large=${s.too_large ?? s.tooLarge ?? 0} binary=${s.binary ?? 0}`);
+const parserHealth = data.parser_health || {};
+if (parserHealth.csharp) {
+  console.log(`[status] csharp_parser available=${parserHealth.csharp.available} files=${parserHealth.csharp.files ?? 0} chunks=${parserHealth.csharp.chunks ?? 0}`);
+  if (parserHealth.csharp.reason) {
+    console.log(`[status] csharp_parser_reason=${parserHealth.csharp.reason}`);
+  }
+}
 if (typeof data.incremental_mode === "boolean") {
   console.log(`[status] incremental_mode=${data.incremental_mode} changed_candidates=${data.changed_candidates ?? 0} deleted_paths=${data.deleted_paths ?? 0}`);
 }