@danielblomma/cortex-mcp 2.2.4 → 2.4.0

package/scaffold/scripts/doctor.sh

@@ -180,15 +180,33 @@ fi
 
 # 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();
-    try {
-      require("./.context/mcp/dist/graph.js");
-      console.log("ok " + (Date.now() - start));
-    } catch(e) {
-      console.log("fail " + e.message);
+  MCP_CHECK=$(cd "$REPO_ROOT" && node -e '
+    const { spawnSync } = require("node:child_process");
+    const timeoutMs = Number(process.env.CORTEX_DOCTOR_GRAPH_TIMEOUT_MS || 30000);
+    const probe = [
+      "const start = Date.now();",
+      "try {",
+      "  require(\"./.context/mcp/dist/graph.js\");",
+      "  console.log(\"ok \" + (Date.now() - start));",
+      "} catch (e) {",
+      "  console.log(\"fail \" + (e && e.message ? e.message : String(e)));",
+      "  process.exitCode = 1;",
+      "}"
+    ].join("\n");
+    const result = spawnSync(process.execPath, ["-e", probe], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: timeoutMs
+    });
+    if (result.error && result.error.code === "ETIMEDOUT") {
+      console.log("fail timeout after " + timeoutMs + "ms");
+    } else if (result.error) {
+      console.log("fail " + result.error.message);
+    } else {
+      const lines = String(result.stdout || "").trim().split(/\r?\n/).filter(Boolean);
+      console.log(lines[lines.length - 1] || ("fail exit " + (result.status ?? "unknown")));
     }
-  ' 2>/dev/null || echo "fail timeout")
+  ' 2>/dev/null || echo "fail graph check crashed")
   if [[ "$MCP_CHECK" == ok* ]]; then
     MS="${MCP_CHECK#ok }"
     pass "Graph module loads (${MS}ms)"

package/scaffold/scripts/ingest.mjs

@@ -457,11 +457,11 @@ function parseRules(rulesText) {
 function walkDirectory(directoryPath, files) {
   const entries = fs.readdirSync(directoryPath, { withFileTypes: true });
   for (const entry of entries) {
-    if (entry.isDirectory() && SKIP_DIRECTORIES.has(entry.name)) {
+    const absolutePath = path.join(directoryPath, entry.name);
+    if (entry.isDirectory() && shouldSkipDirectory(absolutePath, entry.name)) {
       continue;
     }
 
-    const absolutePath = path.join(directoryPath, entry.name);
     if (entry.isDirectory()) {
       walkDirectory(absolutePath, files);
       continue;
@@ -473,10 +473,40 @@ function walkDirectory(directoryPath, files) {
   }
 }
 
+function shouldSkipDirectory(absolutePath, entryName) {
+  if (entryName === "bin" && path.resolve(path.dirname(absolutePath)) === REPO_ROOT) {
+    return false;
+  }
+  return SKIP_DIRECTORIES.has(entryName);
+}
+
+function normalizeSourcePrefix(sourcePath) {
+  const source = toPosixPath(sourcePath).replace(/^\.\/+/, "").replace(/\/+$/, "");
+  return source === "." ? "" : source;
+}
+
+function normalizeRelativePath(relPath) {
+  return toPosixPath(relPath).replace(/^\.\/+/, "").replace(/\/+$/, "");
+}
+
+function hasSkippedDirectorySegment(relPath) {
+  const parts = normalizeRelativePath(relPath).split("/").filter(Boolean);
+  return parts.some((part, index) => {
+    if (part === "bin" && index === 0) {
+      return false;
+    }
+    return SKIP_DIRECTORIES.has(part);
+  });
+}
+
 function hasSourcePrefix(relPath, sourcePaths) {
+  const normalizedRelPath = normalizeRelativePath(relPath);
+  if (!normalizedRelPath || hasSkippedDirectorySegment(normalizedRelPath)) {
+    return false;
+  }
   return sourcePaths.some((sourcePath) => {
-    const source = toPosixPath(sourcePath).replace(/\/+$/, "");
-    return relPath === source || relPath.startsWith(`${source}/`);
+    const source = normalizeSourcePrefix(sourcePath);
+    return source === "" || normalizedRelPath === source || normalizedRelPath.startsWith(`${source}/`);
   });
 }
 
@@ -627,6 +657,9 @@ function collectCandidateFiles(sourcePaths, mode) {
   }
 
   for (const sourcePath of sourcePaths) {
+    if (hasSkippedDirectorySegment(sourcePath)) {
+      continue;
+    }
     const absoluteSourcePath = path.resolve(REPO_ROOT, sourcePath);
     if (!fs.existsSync(absoluteSourcePath)) {
       continue;

package/scaffold/scripts/status.sh

@@ -198,11 +198,12 @@ try {
 
 node -e '
 const path = require("node:path");
-const { execSync } = require("node:child_process");
+const { execFileSync, execSync } = require("node:child_process");
 
 const repoRoot = process.argv[1];
 const cacheDir = process.argv[2];
 const localVersionEnv = process.argv[3] || "";
+const VERSION_LOOKUP_TIMEOUT_MS = Number(process.env.CORTEX_VERSION_LOOKUP_TIMEOUT_MS || 8000);
 
 function parseVersion(value) {
   const match = String(value || "").trim().match(/^v?(\d+)\.(\d+)\.(\d+)$/);
@@ -225,7 +226,7 @@ function getLocalVersion() {
   }
 
   try {
-    const output = execSync("cortex --version", {
+    const output = execFileSync("cortex", ["--version"], {
       cwd: repoRoot,
       stdio: ["ignore", "pipe", "ignore"],
       encoding: "utf8",
@@ -282,11 +283,11 @@ try {
     const npmCache = path.join(cacheDir, "npm-cache");
     let latestRaw = "";
     try {
-      latestRaw = execSync("npm view github:DanielBlomma/cortex version --json", {
+      latestRaw = execFileSync("npm", ["view", "github:DanielBlomma/cortex", "version", "--json"], {
         cwd: repoRoot,
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf8",
-        timeout: 2500,
+        timeout: VERSION_LOOKUP_TIMEOUT_MS,
         env: { ...process.env, NPM_CONFIG_CACHE: npmCache }
       }).trim();
     } catch (error) {
@@ -317,13 +318,19 @@ try {
     process.exit(0);
   }
 
-  const hasUpdate = compareVersions(latestParsed, localParsed) > 0;
+  const comparison = compareVersions(latestParsed, localParsed);
   console.log(`[status] cortex_latest_version=${latestVersion}`);
 
-  if (hasUpdate) {
+  if (comparison > 0) {
+    console.log("[status] cortex_version_state=update-available");
     console.log("[status] cortex_update_available=yes");
     console.log("[status] run: npm i -g github:DanielBlomma/cortex");
+  } else if (comparison < 0) {
+    console.log("[status] cortex_version_state=local-newer");
+    console.log("[status] cortex_update_available=no");
+    console.log("[status] note: local Cortex is newer than the published version");
   } else {
+    console.log("[status] cortex_version_state=current");
     console.log("[status] cortex_update_available=no");
   }
 } catch (error) {