carto-md 2.0.7 → 2.0.9

package/src/extractors/imports.js

@@ -51,6 +51,10 @@ function extractImports(content, filePath, projectRoot) {
     return extractJavaImports(content, filePath, projectRoot);
   } else if (ext === '.rb') {
     return extractRubyImports(content, filePath, projectRoot);
+  } else if (['.cpp', '.cc', '.cxx', '.c', '.h', '.hpp', '.hh', '.hxx'].includes(ext)) {
+    return extractCppImports(content, filePath, projectRoot);
+  } else if (ext === '.cs') {
+    return extractCsharpImports(content, filePath, projectRoot);
   }
 
   // Resolve and deduplicate
@@ -650,3 +654,175 @@ function _resolveRubyPath(reqPath, baseDir, projectRoot) {
   }
   return null;
 }
+
+
+// ─── C / C++ imports ──────────────────────────────────────────────────────────
+
+/**
+ * extractCppImports(content, filePath, projectRoot) → Array<string>
+ *
+ * Resolves #include directives to actual files in the project.
+ *
+ *   #include "foo.h"      → resolved relative to current file's dir,
+ *                           then common include search dirs.
+ *   #include <foo>        → skipped (system header, external).
+ *
+ * Uses tree-sitter-cpp when available, otherwise falls back to a
+ * simple regex over the source.
+ */
+function extractCppImports(content, filePath, projectRoot) {
+  const results = new Set();
+  const fileDir = path.dirname(filePath);
+  const ext = path.extname(filePath);
+
+  // Pull raw includes via tree-sitter when available; fall back to regex.
+  let rawImports = [];
+  try {
+    const tsParser = require('./tree-sitter-parser');
+    if (tsParser.isAvailable()) {
+      rawImports = tsParser.extractImports(content, ext);
+    }
+  } catch { /* tree-sitter unavailable */ }
+
+  if (rawImports.length === 0) {
+    const re = /^\s*#\s*include\s+(?:"([^"]+)"|<([^>]+)>)/gm;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      // m[1] is quoted form, m[2] is angle-bracket form. Keep both shapes
+      // so the system-header filter below can drop the angle ones.
+      if (m[1]) rawImports.push(m[1]);
+      else if (m[2]) rawImports.push('<' + m[2] + '>');
+    }
+  }
+
+  for (const raw of rawImports) {
+    // Drop system headers (angle brackets). Tree-sitter returns these as
+    // "<string>" wrappers; the regex form we just constructed does too.
+    if (raw.startsWith('<') && raw.endsWith('>')) continue;
+    // Defensive: a tree-sitter grammar quirk could leak the wrappers in.
+    if (raw.startsWith('"') && raw.endsWith('"')) {
+      const inner = raw.slice(1, -1);
+      _tryResolveCppInclude(inner, fileDir, projectRoot, results);
+      continue;
+    }
+    _tryResolveCppInclude(raw, fileDir, projectRoot, results);
+  }
+
+  return [...results].sort();
+}
+
+function _tryResolveCppInclude(includePath, fileDir, projectRoot, results) {
+  // Search order: relative to current file, then common include roots.
+  const candidates = [
+    path.resolve(fileDir, includePath),
+    path.join(projectRoot, 'include', includePath),
+    path.join(projectRoot, 'src', 'include', includePath),
+    path.join(projectRoot, 'src', includePath),
+    path.join(projectRoot, includePath),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c) && fs.statSync(c).isFile()) {
+      results.add(path.relative(projectRoot, c));
+      return;
+    }
+  }
+}
+
+// ─── C# imports ───────────────────────────────────────────────────────────────
+
+// Cache: projectRoot → Map<namespace, Array<relativeFilePath>>
+const _csNamespaceCache = new Map();
+
+/**
+ * Build a namespace → files map by scanning every .cs file in the project
+ * once. Cached per projectRoot. This is the only reliable way to resolve
+ * `using A.B.C;` in C# because (unlike Java) namespace and folder structure
+ * are decoupled — a namespace can span many files in many directories.
+ */
+function _getCsharpNamespaceMap(projectRoot) {
+  if (_csNamespaceCache.has(projectRoot)) return _csNamespaceCache.get(projectRoot);
+  const map = new Map();
+
+  const SKIP_DIRS = new Set(['node_modules', 'bin', 'obj', 'packages', '.git', 'dist', 'build']);
+  const walk = (dir) => {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+    for (const e of entries) {
+      if (e.name.startsWith('.')) continue;
+      if (e.isDirectory()) {
+        if (!SKIP_DIRS.has(e.name)) walk(path.join(dir, e.name));
+        continue;
+      }
+      if (!e.isFile() || !e.name.endsWith('.cs')) continue;
+      const full = path.join(dir, e.name);
+      let c;
+      try { c = fs.readFileSync(full, 'utf-8'); } catch { continue; }
+      // Match both file-scoped (`namespace Foo;`) and block-scoped (`namespace Foo {`).
+      const m = c.match(/^\s*namespace\s+([\w.]+)\s*[;{]/m);
+      if (!m) continue;
+      const ns = m[1];
+      const rel = path.relative(projectRoot, full);
+      if (!map.has(ns)) map.set(ns, []);
+      map.get(ns).push(rel);
+    }
+  };
+
+  walk(projectRoot);
+  _csNamespaceCache.set(projectRoot, map);
+  return map;
+}
+
+/**
+ * extractCsharpImports(content, filePath, projectRoot) → Array<string>
+ *
+ * Resolves `using Foo.Bar.Baz;` to project files that declare the
+ * matching namespace. Skips standard library namespaces (System.*,
+ * Microsoft.*, etc.) — those produce only noise.
+ */
+function extractCsharpImports(content, filePath, projectRoot) {
+  const results = new Set();
+  const nsMap = _getCsharpNamespaceMap(projectRoot);
+
+  // System namespaces and well-known third-party prefixes that almost never
+  // resolve to project files. We still check the map (a project could ship a
+  // Microsoft.* namespace), but skip the FS fallback for these.
+  const EXTERNAL_PREFIXES = ['System', 'Microsoft', 'Windows', 'Newtonsoft', 'Xunit', 'NUnit', 'Mono'];
+
+  const re = /^\s*using\s+(?:static\s+)?([\w.]+)\s*;/gm;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    const ns = m[1];
+    const isExternal = EXTERNAL_PREFIXES.includes(ns.split('.')[0]);
+
+    // Primary path: namespace map lookup. Works regardless of folder layout.
+    const matched = nsMap.get(ns);
+    if (matched) {
+      for (const f of matched) results.add(f);
+      continue;
+    }
+
+    if (isExternal) continue;
+
+    // Fallback: filename convention (Foo.Bar.Baz → Foo/Bar/Baz.cs).
+    const parts = ns.split('.');
+    const asFile = parts.join(path.sep) + '.cs';
+    const candidates = [
+      path.join(projectRoot, 'src', asFile),
+      path.join(projectRoot, asFile),
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) {
+        results.add(path.relative(projectRoot, c));
+        break;
+      }
+    }
+  }
+
+  // Drop self-import — a file's `namespace X;` can match itself when the
+  // file imports its own namespace via `using X;`.
+  const selfRel = path.relative(projectRoot, filePath);
+  results.delete(selfRel);
+
+  return [...results].sort();
+}

package/src/extractors/languages/html.js

@@ -9,7 +9,10 @@ module.exports = {
       return { routes: [], models: [], functions: [], envVars: [], dbTables: [], fetches, storageKeys };
     } catch (err) {
       console.warn(`[CARTO] html plugin error on ${filename}: ${err.message}`);
-      return { routes: [], models: [], functions: [], envVars: [], dbTables: [], fetches: [], storageKeys: [] };
+      return {
+        routes: [], models: [], functions: [], envVars: [], dbTables: [], fetches: [], storageKeys: [],
+        _errors: [{ phase: 'extract', message: err.message || String(err) }],
+      };
     }
   }
 };

package/src/extractors/languages/javascript.js

@@ -94,6 +94,11 @@ module.exports = {
         storageKeys: [],
         _tsImports:  tsImports,
         _tsSymbols:  tsSymbols,
+        // Surface the parse failure as a breadcrumb so the
+        // caller can record it in extraction_errors. Before this hook,
+        // the warning only hit stderr and the file lost all of its
+        // routes and models silently.
+        _errors:     [{ phase: 'parse', message: `Babel parse: ${err.message}` }],
       };
     }
 

package/src/extractors/languages/prisma.js

@@ -20,7 +20,10 @@ module.exports = {
       };
     } catch (err) {
       console.warn(`[CARTO] prisma plugin error on ${filename}: ${err.message}`);
-      return { routes: [], models: [], functions: [], envVars: [], dbTables: [], fetches: [], storageKeys: [] };
+      return {
+        routes: [], models: [], functions: [], envVars: [], dbTables: [], fetches: [], storageKeys: [],
+        _errors: [{ phase: 'extract', message: err.message || String(err) }],
+      };
     }
   }
 };

package/src/extractors/languages/python.js

@@ -34,7 +34,11 @@ module.exports = {
       };
     } catch (err) {
       console.warn(`[CARTO] python plugin error on ${filename}: ${err.message}`);
-      return { routes: [], models: [], functions: [], envVars: [], dbTables: [], fetches: [], storageKeys: [] };
+      return {
+        routes: [], models: [], functions: [], envVars: [], dbTables: [], fetches: [], storageKeys: [],
+        // Record the failure so it's visible in `carto check`.
+        _errors: [{ phase: 'extract', message: err.message || String(err) }],
+      };
     }
   }
 };

package/src/extractors/languages/r.js

@@ -249,7 +249,10 @@ module.exports = {
       };
     } catch (err) {
       console.warn(`[CARTO] r plugin error on ${filename}: ${err.message}`);
-      return { routes: [], models: [], functions: [], envVars: [], dbTables: [], fetches: [], storageKeys: [] };
+      return {
+        routes: [], models: [], functions: [], envVars: [], dbTables: [], fetches: [], storageKeys: [],
+        _errors: [{ phase: 'extract', message: err.message || String(err) }],
+      };
     }
   }
 };

package/src/extractors/languages/typescript.js

@@ -63,6 +63,8 @@ module.exports = {
         jobs:        extractQueueAndCron(content),
         _tsImports:  tsImports,
         _tsSymbols:  tsSymbols,
+        // Promote silent Babel failure to a breadcrumb.
+        _errors:     [{ phase: 'parse', message: `Babel parse: ${err.message}` }],
       };
     }
 

package/src/extractors/tree-sitter-parser.js

@@ -395,11 +395,26 @@ function _inferKind(nameNode, langName) {
   return 'variable';
 }
 
+/**
+ * getUnavailableLanguages() → string[]
+ * Returns language names whose grammars failed to load (or tree-sitter itself unavailable).
+ */
+function getUnavailableLanguages() {
+  if (!treeSitterAvailable) return GRAMMAR_DEFS.map(d => d.name);
+  const unavailable = [];
+  for (const def of GRAMMAR_DEFS) {
+    const ext = def.extensions[0];
+    if (!_getCompiledGrammar(ext)) unavailable.push(def.name);
+  }
+  return unavailable;
+}
+
 module.exports = {
   isAvailable,
   supportsExtension,
   extractImports,
   extractSymbols,
   extractAll,
+  getUnavailableLanguages,
   GRAMMAR_DEFS,
 };

package/src/mcp/change-plan.js

@@ -8,7 +8,7 @@
  *
  *   tokenize(intent) ──► tokens { content, verbs, paths }
  *                  └──► IDF over indexed corpus (basenames + symbol names)
- *                  └──► 4-tier anchor selection
+ *                  └──► 4-stage anchor selection
  *                          A. route path/method        (searchRoutes)
  *                          B. file path tokens         (pathTokens × IDF)
  *                          C. exported symbol names    (camelTokens × IDF)
@@ -169,9 +169,9 @@ function computeIdf(store) {
  *       symbols: [{ name, path, tokenSet }] }
  *
  * Memoized on the store object. On a 5K-file repo this saves ~30ms per
- * `planChange` call (without it, p95 on cal.com sat at 60ms — over the
- * spec's 50ms target). Re-indexing creates a new store instance, so
- * the cache lives only as long as the index it was built from.
+ * `planChange` call (without it, p95 on cal.com sat at 60ms, over the
+ * 50ms target). Re-indexing creates a new store instance, so the cache
+ * lives only as long as the index it was built from.
  */
 const CACHE_KEY = '__cartoChangePlanCache';
 
@@ -257,7 +257,7 @@ function selectAnchors(store, tokens, idf, maxAnchors = 8) {
   // Reuse the cached corpus index — saves ~30ms p95 on cal.com.
   const corpus = buildCorpusIndex(store);
 
-  // ── Tier A — route path/method ────────────────────────────────────
+  // ── Stage A — route path/method ───────────────────────────────────
   // Use searchRoutes for each detected URL-path-like token. Filter by
   // verb when one was extracted.
   const routesSeen = new Set();
@@ -304,7 +304,7 @@ function selectAnchors(store, tokens, idf, maxAnchors = 8) {
     }
   }
 
-  // ── Tier B — file path tokens (IDF-weighted) ──────────────────────
+  // ── Stage B — file path tokens (IDF-weighted) ─────────────────────
   for (const f of corpus.files) {
     let score = 0;
     const hits = [];
@@ -339,7 +339,7 @@ function selectAnchors(store, tokens, idf, maxAnchors = 8) {
     }
   }
 
-  // ── Tier C — exported symbol names (camelCase split + IDF) ────────
+  // ── Stage C — exported symbol names (camelCase split + IDF) ───────
   for (const s of corpus.symbols) {
     let score = 0;
     const hits = [];
@@ -360,7 +360,7 @@ function selectAnchors(store, tokens, idf, maxAnchors = 8) {
     }
   }
 
-  // ── Tier D — domain name match ────────────────────────────────────
+  // ── Stage D — domain name match ───────────────────────────────────
   let domains = [];
   try { domains = store.getDomainsList() || []; } catch { domains = []; }
   for (const d of domains) {

package/src/mcp/diff-parser.js

@@ -0,0 +1,246 @@
+'use strict';
+
+/**
+ * Minimal unified-diff parser.
+ *
+ * Zero deps, zero allocations beyond the result rows. Handles the subset
+ * of unified diff that GitHub PRs, `git diff`, and `git format-patch`
+ * actually emit:
+ *
+ *   - Per-file headers: `--- a/path`  /  `+++ b/path`
+ *   - File-mode markers: `new file mode`, `deleted file mode`, `rename from`,
+ *     `rename to`. We surface `kind` ∈ { 'modify' | 'add' | 'delete' | 'rename' }.
+ *   - Hunk headers: `@@ -from,len +to,len @@ optional context`
+ *   - Body lines: `+added`, `-removed`, ` context`, `\\ No newline at EOF`
+ *   - `Binary files ... differ` lines — we skip the whole file.
+ *
+ * Out of scope:
+ *   - Combined diffs (`@@@ ... @@@`) — git rarely emits these except for
+ *     octopus merges. We tolerate (skip) the file.
+ *   - SVN / Mercurial extension lines.
+ *
+ * Output shape — one entry per file:
+ *   {
+ *     path: string,                      // post-image path (`+++ b/...`)
+ *     oldPath: string | null,            // pre-image path (different on rename)
+ *     kind: 'modify' | 'add' | 'delete' | 'rename',
+ *     added: [{lineNo, content}],        // line numbers in the new file
+ *     removed: [{lineNo, content}],      // line numbers in the old file
+ *   }
+ *
+ * Malformed input must never throw — return whatever we parsed.
+ */
+
+function stripDiffPath(raw) {
+  if (!raw || typeof raw !== 'string') return null;
+  // Strip trailing tab/timestamp markers that some unified diffs append.
+  let p = raw.split('\t')[0].trim();
+  // Drop git's a/ or b/ prefix if present.
+  if (p.startsWith('a/') || p.startsWith('b/')) p = p.slice(2);
+  // /dev/null sentinel for new/deleted files.
+  if (p === '/dev/null') return null;
+  return p;
+}
+
+/**
+ * parseDiff(diffText) → [{ path, oldPath, kind, added, removed }]
+ *
+ * Top-level entry. Defensive against truncation, malformed hunks, or
+ * input that isn't a diff at all (returns []).
+ */
+function parseDiff(diffText) {
+  if (typeof diffText !== 'string' || diffText.length === 0) return [];
+  const lines = diffText.split(/\r?\n/);
+  const files = [];
+  let cur = null;
+  let oldLine = 0;
+  let newLine = 0;
+  let inHunk = false;
+  // `pendingMode` tracks file-mode hints between the `diff --git` header
+  // and the `---/+++` lines that finalize the entry.
+  let pendingKind = null;
+  let pendingOldPath = null;
+  let pendingNewPath = null;
+
+  function flush() {
+    // Materialise rename-only entries that never produced a `+++ ` line.
+    if (!cur && pendingKind === 'rename' && pendingOldPath && pendingNewPath) {
+      cur = {
+        path: pendingNewPath,
+        oldPath: pendingOldPath !== pendingNewPath ? pendingOldPath : null,
+        kind: 'rename',
+        added: [],
+        removed: [],
+      };
+    }
+    if (cur) files.push(cur);
+    cur = null;
+    inHunk = false;
+    pendingKind = null;
+    pendingOldPath = null;
+    pendingNewPath = null;
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // `diff --git a/foo b/bar` — start of a new file entry. Pre-resolve
+    // the rename paths from the header so we have them even if the
+    // rename has zero hunks.
+    if (line.startsWith('diff --git ')) {
+      flush();
+      pendingKind = 'modify';
+      pendingOldPath = null;
+      pendingNewPath = null;
+      const m = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+      if (m) {
+        pendingOldPath = m[1];
+        pendingNewPath = m[2];
+      }
+      continue;
+    }
+
+    if (line.startsWith('new file mode')) { pendingKind = 'add'; continue; }
+    if (line.startsWith('deleted file mode')) { pendingKind = 'delete'; continue; }
+    if (line.startsWith('rename from ')) {
+      pendingKind = 'rename';
+      pendingOldPath = line.slice('rename from '.length).trim();
+      continue;
+    }
+    if (line.startsWith('rename to ')) {
+      pendingKind = 'rename';
+      pendingNewPath = line.slice('rename to '.length).trim();
+      continue;
+    }
+
+    // Skip binary diffs — we can't validate them anyway.
+    if (line.startsWith('Binary files ') && line.endsWith(' differ')) {
+      flush();
+      continue;
+    }
+
+    if (line.startsWith('--- ')) {
+      const oldP = stripDiffPath(line.slice(4));
+      if (oldP !== null) pendingOldPath = oldP;
+      continue;
+    }
+
+    if (line.startsWith('+++ ')) {
+      // Finalize the file header. Open a new `cur` entry.
+      const newP = stripDiffPath(line.slice(4));
+      if (newP !== null) pendingNewPath = newP;
+      const path = pendingNewPath || pendingOldPath;
+      if (!path) continue;
+      cur = {
+        path,
+        oldPath: pendingOldPath !== pendingNewPath ? pendingOldPath : null,
+        kind: pendingKind || 'modify',
+        added: [],
+        removed: [],
+      };
+      // /dev/null on the old side means add; on the new side means delete.
+      if (cur.kind === 'modify') {
+        if (pendingOldPath === null && pendingNewPath !== null) cur.kind = 'add';
+        else if (pendingNewPath === null && pendingOldPath !== null) cur.kind = 'delete';
+      }
+      pendingKind = null;
+      pendingOldPath = null;
+      pendingNewPath = null;
+      inHunk = false;
+      continue;
+    }
+
+    if (!cur) continue;
+
+    // Hunk header: @@ -oldStart,oldLen +newStart,newLen @@ (lengths optional)
+    if (line.startsWith('@@')) {
+      const m = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+      if (m) {
+        oldLine = parseInt(m[1], 10);
+        newLine = parseInt(m[2], 10);
+        inHunk = true;
+      } else {
+        inHunk = false;
+      }
+      continue;
+    }
+
+    if (!inHunk) continue;
+
+    // Body lines.
+    if (line.length === 0) {
+      // A blank body line is "context" with empty content. Both old and
+      // new advance.
+      oldLine++;
+      newLine++;
+      continue;
+    }
+    const tag = line[0];
+    const content = line.slice(1);
+    if (tag === '+') {
+      cur.added.push({ lineNo: newLine, content });
+      newLine++;
+    } else if (tag === '-') {
+      cur.removed.push({ lineNo: oldLine, content });
+      oldLine++;
+    } else if (tag === ' ') {
+      oldLine++;
+      newLine++;
+    } else if (tag === '\\') {
+      // "" — no line advance.
+      continue;
+    } else {
+      // Unknown body line — be tolerant and stop hunk parsing.
+      inHunk = false;
+    }
+  }
+
+  flush();
+  return files;
+}
+
+/**
+ * extractAddedImports(file) → string[]
+ *
+ * Heuristic: scan added lines for import-style statements common across
+ * JS/TS, Python, Go, Rust, Ruby, Java. Returns the bare module / path
+ * specifier (the thing inside the quotes / after `from`/`import`/`use`).
+ *
+ * Used by validate.js to detect new cross-domain edges. Exported for
+ * test coverage. Best-effort — we'd rather miss than spuriously flag.
+ */
+function extractAddedImports(file) {
+  if (!file || !Array.isArray(file.added)) return [];
+  const out = [];
+  for (const { content } of file.added) {
+    if (!content) continue;
+    const trimmed = content.trim();
+    if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('#')) continue;
+    // ES module: import X from 'mod' / import 'mod' / import { x } from "mod"
+    let m = trimmed.match(/^import\s+(?:[^'"]*?from\s+)?['"]([^'"]+)['"]/);
+    if (m) { out.push(m[1]); continue; }
+    // CommonJS: const x = require('mod')
+    m = trimmed.match(/require\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (m) { out.push(m[1]); continue; }
+    // Dynamic import: import('mod')
+    m = trimmed.match(/^import\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (m) { out.push(m[1]); continue; }
+    // Python: from mod import x  /  import mod
+    m = trimmed.match(/^from\s+([\w.]+)\s+import\b/);
+    if (m) { out.push(m[1]); continue; }
+    m = trimmed.match(/^import\s+([\w.]+)\s*$/);
+    if (m) { out.push(m[1]); continue; }
+    // Go: import "mod"  /  multi-line import block
+    m = trimmed.match(/^import\s+['"]([^'"]+)['"]/);
+    if (m) { out.push(m[1]); continue; }
+    // Rust: use crate::a::b::c;
+    m = trimmed.match(/^use\s+([\w:]+)/);
+    if (m) { out.push(m[1]); continue; }
+    // Java: import a.b.C;
+    m = trimmed.match(/^import\s+([\w.]+);/);
+    if (m) { out.push(m[1]); continue; }
+  }
+  return out;
+}
+
+module.exports = { parseDiff, extractAddedImports, stripDiffPath };