@danielblomma/cortex-mcp 1.3.1 → 1.4.0

package/scaffold/scripts/parsers/bash-treesitter.mjs

@@ -0,0 +1,229 @@
+/**
+ * Tree-sitter Bash parser for Cortex.
+ *
+ * Extracts `function_definition` nodes as chunks — both
+ * `function foo { ... }` and `foo() { ... }` styles are handled by
+ * tree-sitter-bash as the same node type.
+ *
+ * Imports cover `source path.sh` and `. path.sh` commands at program
+ * scope. Dynamic path expressions like `. "$(dirname "$0")/lib.sh"`
+ * are skipped — only static `word` arguments are extracted, since
+ * anything else can't be resolved at parse time.
+ *
+ * Call extraction captures the `command_name` of every `command`
+ * node, filtered against a large list of shell builtins and
+ * ubiquitous system commands so the call graph reflects user-defined
+ * function calls rather than shell plumbing.
+ *
+ * Naming:
+ *   top-level function:  name = "deploy"
+ *   nested function:     name = "inner"  (shell has no real nesting scope)
+ *
+ * exported: true iff the function name does NOT start with an
+ * underscore. Shell has no export/import model per se; this mirrors
+ * the convention used by Python and Ruby parsers.
+ *
+ * parseCode is async; the WASM grammar is lazily loaded on first call
+ * and cached for subsequent calls.
+ */
+
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import {
+  dedupe,
+  initTreeSitter,
+  lineRangeOf,
+  loadGrammar,
+  parseSource,
+  runQuery
+} from "./tree-sitter/base.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const QUERY_DIR = path.join(__dirname, "tree-sitter", "queries");
+
+let BASH_LANG = null;
+let langPromise = null;
+
+async function ensureLanguage() {
+  if (BASH_LANG) return BASH_LANG;
+  if (!langPromise) {
+    langPromise = (async () => {
+      await initTreeSitter();
+      BASH_LANG = await loadGrammar("bash");
+      return BASH_LANG;
+    })();
+  }
+  await langPromise;
+  return BASH_LANG;
+}
+
+export async function isAvailable() {
+  try {
+    await ensureLanguage();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const CHUNK_QUERY = fs.readFileSync(path.join(QUERY_DIR, "bash.chunks.scm"), "utf8");
+const CALL_QUERY = fs.readFileSync(path.join(QUERY_DIR, "bash.calls.scm"), "utf8");
+const IMPORT_QUERY = fs.readFileSync(path.join(QUERY_DIR, "bash.imports.scm"), "utf8");
+
+const LOADER_COMMANDS = new Set(["source", "."]);
+
+// Shell builtins and ubiquitous system commands. Filtered out of the
+// call graph so it reflects user-defined function calls, not shell
+// plumbing. Keeping this list deliberately broad — the goal is graph
+// signal-to-noise, not exhaustive coverage.
+const CALL_FILTER = new Set([
+  // Builtins
+  "echo", "printf", "read", "test", "[", "[[", "true", "false",
+  "exit", "return", "break", "continue", "shift", "trap",
+  "export", "unset", "set", "local", "declare", "readonly", "typeset",
+  "let", "eval", "exec", "source", ".", "alias", "unalias", "type",
+  "command", "builtin", "hash", "help", "jobs", "fg", "bg", "kill",
+  "pwd", "cd", "pushd", "popd", "dirs", "umask", "ulimit",
+  "getopts", "shopt", "enable", "history", "fc", "logout", "suspend",
+  "wait", "times", "login", "complete", "compgen",
+  // Common system commands
+  "ls", "cat", "grep", "sed", "awk", "cut", "sort", "uniq", "wc",
+  "head", "tail", "tee", "find", "xargs", "tr", "rev",
+  "cp", "mv", "rm", "mkdir", "rmdir", "ln", "touch", "chmod", "chown",
+  "tar", "gzip", "gunzip", "zip", "unzip", "curl", "wget",
+  "git", "docker", "kubectl", "make", "npm", "yarn",
+  "python", "python3", "node", "ruby", "go", "bash", "sh", "zsh",
+  "env", "which", "whereis", "whoami", "id", "uname", "hostname",
+  "date", "sleep", "ps", "top", "df", "du", "mount", "umount",
+  "ssh", "scp", "rsync", "ping", "netstat", "ifconfig", "ip",
+  "basename", "dirname", "realpath", "readlink", "file", "stat",
+  "awk", "perl", "dd"
+]);
+
+function normalizeWhitespace(value) {
+  return String(value).replace(/\s+/g, " ").trim();
+}
+
+function signatureOfDecl(node) {
+  const braceIndex = node.text.indexOf("{");
+  if (braceIndex === -1) return normalizeWhitespace(node.text);
+  return normalizeWhitespace(node.text.slice(0, braceIndex));
+}
+
+function collectCallsInNode(node) {
+  const captures = runQuery(BASH_LANG, CALL_QUERY, node);
+  const names = captures
+    .filter((c) => c.name === "call.name")
+    .map((c) => c.node.text)
+    .filter((name) => {
+      if (!name) return false;
+      if (CALL_FILTER.has(name)) return false;
+      // Strip absolute paths to compare: /usr/bin/foo -> foo
+      const trimmed = name.includes("/") ? name.slice(name.lastIndexOf("/") + 1) : name;
+      if (CALL_FILTER.has(trimmed)) return false;
+      return true;
+    });
+  return dedupe(names);
+}
+
+function collectImports(rootNode) {
+  const captures = runQuery(BASH_LANG, IMPORT_QUERY, rootNode);
+  const imports = [];
+  for (const cap of captures) {
+    if (cap.name !== "import.cmd") continue;
+    const cmd = cap.node;
+
+    // Only top-level sourcing counts as an "import" — nested
+    // source-calls inside function bodies are conditional runtime
+    // behavior rather than declared dependencies.
+    let ancestor = cmd.parent;
+    let isTopLevel = true;
+    while (ancestor) {
+      if (
+        ancestor.type === "function_definition" ||
+        ancestor.type === "compound_statement" ||
+        ancestor.type === "subshell"
+      ) {
+        isTopLevel = false;
+        break;
+      }
+      ancestor = ancestor.parent;
+    }
+    if (!isTopLevel) continue;
+
+    const nameNode = cmd.childForFieldName("name") ?? cmd.namedChild(0);
+    if (!nameNode) continue;
+    const commandText = nameNode.text;
+    if (!LOADER_COMMANDS.has(commandText)) continue;
+
+    // First static `word` argument is the sourced path. Dynamic
+    // expressions (strings, substitutions) are skipped.
+    for (let i = 0; i < cmd.namedChildCount; i += 1) {
+      const child = cmd.namedChild(i);
+      if (child === nameNode) continue;
+      if (child.type === "word") {
+        imports.push(child.text);
+        break;
+      }
+    }
+  }
+  return dedupe(imports);
+}
+
+function buildFunctionChunk(node, imports, language) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const name = nameNode.text;
+  const { startLine, endLine } = lineRangeOf(node);
+  return {
+    name,
+    kind: "function",
+    signature: signatureOfDecl(node),
+    body: node.text,
+    startLine,
+    endLine,
+    language,
+    exported: !name.startsWith("_"),
+    calls: collectCallsInNode(node),
+    imports
+  };
+}
+
+export async function parseCode(code, filePath, language = "bash") {
+  await ensureLanguage();
+  const { tree } = parseSource(BASH_LANG, code);
+  const root = tree.rootNode;
+  const imports = collectImports(root);
+
+  const captures = runQuery(BASH_LANG, CHUNK_QUERY, root);
+  const declCaptures = captures.filter((c) => c.name.endsWith(".decl"));
+
+  const chunks = [];
+  for (const cap of declCaptures) {
+    const chunk = buildFunctionChunk(cap.node, imports, language);
+    if (chunk) chunks.push(chunk);
+  }
+
+  const seen = new Set();
+  const deduped = chunks.filter((chunk) => {
+    const key = `${chunk.kind}|${chunk.name}|${chunk.startLine}|${chunk.endLine}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  return { chunks: deduped, errors: [] };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const target = process.argv[2];
+  if (!target) {
+    console.error("Usage: bash-treesitter.mjs <file.sh>");
+    process.exit(1);
+  }
+  const code = fs.readFileSync(target, "utf8");
+  const result = await parseCode(code, target, "bash");
+  console.log(JSON.stringify(result, null, 2));
+}

package/scaffold/scripts/parsers/cpp-dispatch.mjs

@@ -0,0 +1,56 @@
+/**
+ * C/C++ parser dispatcher.
+ *
+ * Selects between the tree-sitter parser (default, no runtime deps)
+ * and the legacy clang-bridge parser based on the CORTEX_CPP_PARSER
+ * environment variable. Selection is deferred until the first parseCode
+ * call so no WASM is loaded if the project contains no C/C++ files.
+ *
+ *   CORTEX_CPP_PARSER=clang        → always use clang-bridge
+ *   CORTEX_CPP_PARSER=tree-sitter  → force tree-sitter (error if unavailable)
+ *   unset / other                  → tree-sitter with clang auto-fallback
+ */
+
+const choice = process.env.CORTEX_CPP_PARSER;
+
+let activeParser = null;
+let resolvePromise = null;
+
+function availabilityOf(parser) {
+  if (typeof parser.isAvailable === "function") return parser.isAvailable;
+  if (typeof parser.isCppParserAvailable === "function") return parser.isCppParserAvailable;
+  return () => typeof parser.parseCode === "function";
+}
+
+async function resolveParser() {
+  if (activeParser) return activeParser;
+  if (resolvePromise) return resolvePromise;
+  resolvePromise = (async () => {
+    if (choice === "clang") {
+      activeParser = await import("./cpp.mjs");
+    } else if (choice === "tree-sitter") {
+      activeParser = await import("./cpp-treesitter.mjs");
+    } else {
+      const ts = await import("./cpp-treesitter.mjs");
+      if (await ts.isAvailable()) {
+        activeParser = ts;
+      } else {
+        activeParser = await import("./cpp.mjs");
+      }
+    }
+    return activeParser;
+  })();
+  return resolvePromise;
+}
+
+export async function parseCode(code, filePath, language = "cpp") {
+  const parser = await resolveParser();
+  return parser.parseCode(code, filePath, language);
+}
+
+export async function isCppParserAvailable() {
+  const parser = await resolveParser();
+  const check = availabilityOf(parser);
+  const result = check();
+  return result && typeof result.then === "function" ? await result : result;
+}

package/scaffold/scripts/parsers/cpp-treesitter.mjs

@@ -0,0 +1,333 @@
+/**
+ * Tree-sitter C/C++ parser for Cortex.
+ *
+ * Uses tree-sitter-cpp (a superset that parses C correctly) as a
+ * single grammar for .c, .h, .cpp, .cc, .hpp, .hh files. This removes
+ * the clang runtime dependency that the legacy cpp.mjs parser required.
+ *
+ * Chunk shape matches the Cortex convention. Methods and nested types
+ * are qualified by their enclosing class/struct/union/namespace path
+ * using `::` as the separator, matching C++ source syntax.
+ *
+ * Naming:
+ *   free function:         name = "add"
+ *   method in class body:  name = "Foo::bar"
+ *   out-of-class method:   name = "Foo::bar"   (def like `Foo::bar()`)
+ *   nested class:          name = "Outer::Inner"
+ *   namespace function:    name = "app::handler"
+ *   namespace class:       name = "app::Service"
+ *
+ * parseCode is async; the WASM grammar is lazily loaded on first call
+ * and cached for subsequent calls.
+ */
+
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import {
+  dedupe,
+  initTreeSitter,
+  lineRangeOf,
+  loadGrammar,
+  parseSource,
+  runQuery
+} from "./tree-sitter/base.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const QUERY_DIR = path.join(__dirname, "tree-sitter", "queries");
+
+let CPP_LANG = null;
+let langPromise = null;
+
+async function ensureLanguage() {
+  if (CPP_LANG) return CPP_LANG;
+  if (!langPromise) {
+    langPromise = (async () => {
+      await initTreeSitter();
+      CPP_LANG = await loadGrammar("cpp");
+      return CPP_LANG;
+    })();
+  }
+  await langPromise;
+  return CPP_LANG;
+}
+
+const CHUNK_QUERY = fs.readFileSync(path.join(QUERY_DIR, "cpp.chunks.scm"), "utf8");
+const CALL_QUERY = fs.readFileSync(path.join(QUERY_DIR, "cpp.calls.scm"), "utf8");
+const IMPORT_QUERY = fs.readFileSync(path.join(QUERY_DIR, "cpp.imports.scm"), "utf8");
+
+// Calls that are control-flow, builtins, or stdlib logging noise —
+// kept out of the graph so real function-to-function edges stand out.
+const CALL_FILTER = new Set([
+  "sizeof", "alignof", "typeid", "decltype", "typeof",
+  "static_cast", "dynamic_cast", "reinterpret_cast", "const_cast",
+  "printf", "fprintf", "sprintf", "snprintf", "puts",
+  "malloc", "free", "calloc", "realloc", "memcpy", "memset", "memmove"
+]);
+
+function normalizeWhitespace(value) {
+  return String(value).replace(/\s+/g, " ").trim();
+}
+
+function signatureOfDecl(node) {
+  const braceIndex = node.text.indexOf("{");
+  const semiIndex = node.text.indexOf(";");
+  const end = braceIndex === -1 ? semiIndex : (semiIndex === -1 ? braceIndex : Math.min(braceIndex, semiIndex));
+  if (end === -1) return normalizeWhitespace(node.text);
+  return normalizeWhitespace(node.text.slice(0, end));
+}
+
+function collectCallsInNode(node) {
+  const captures = runQuery(CPP_LANG, CALL_QUERY, node);
+  const names = captures
+    .filter((c) => c.name === "call.name")
+    .map((c) => c.node.text)
+    .filter((name) => name && !CALL_FILTER.has(name));
+  return dedupe(names);
+}
+
+function collectImports(rootNode) {
+  const captures = runQuery(CPP_LANG, IMPORT_QUERY, rootNode);
+  const imports = [];
+  for (const cap of captures) {
+    if (cap.name !== "include.decl") continue;
+    const decl = cap.node;
+    for (let i = 0; i < decl.namedChildCount; i += 1) {
+      const child = decl.namedChild(i);
+      if (child.type === "system_lib_string") {
+        // <vector> — strip angle brackets
+        const text = child.text;
+        imports.push(text.startsWith("<") && text.endsWith(">") ? text.slice(1, -1) : text);
+      } else if (child.type === "string_literal") {
+        // "local.h" — walk for string_content
+        for (let j = 0; j < child.namedChildCount; j += 1) {
+          const inner = child.namedChild(j);
+          if (inner.type === "string_content") {
+            imports.push(inner.text);
+            break;
+          }
+        }
+      }
+    }
+  }
+  return dedupe(imports);
+}
+
+/**
+ * Walk up the tree and collect names of enclosing classes, structs,
+ * unions, and namespaces. Nested namespaces like `namespace a::b`
+ * contribute both `a` and `b` to the path.
+ */
+function enclosingScopePath(node) {
+  const parts = [];
+  let cur = node.parent;
+  while (cur && cur.type !== "translation_unit") {
+    if (
+      cur.type === "class_specifier" ||
+      cur.type === "struct_specifier" ||
+      cur.type === "union_specifier"
+    ) {
+      const nameNode = cur.childForFieldName("name");
+      if (nameNode) parts.unshift(nameNode.text);
+    } else if (cur.type === "namespace_definition") {
+      parts.unshift(...namespaceDefinitionNames(cur));
+    }
+    cur = cur.parent;
+  }
+  return parts;
+}
+
+function namespaceDefinitionNames(nsNode) {
+  const names = [];
+  // Could have a single namespace_identifier OR a nested_namespace_specifier
+  for (let i = 0; i < nsNode.namedChildCount; i += 1) {
+    const child = nsNode.namedChild(i);
+    if (child.type === "namespace_identifier") {
+      names.push(child.text);
+    } else if (child.type === "nested_namespace_specifier") {
+      for (let j = 0; j < child.namedChildCount; j += 1) {
+        const inner = child.namedChild(j);
+        if (inner.type === "namespace_identifier") names.push(inner.text);
+      }
+    }
+  }
+  return names;
+}
+
+/**
+ * Extract the function name and any qualifying path from a
+ * function_definition's function_declarator. Returns { name, isMethod }.
+ *
+ * - identifier inside declarator → free function, name = identifier
+ * - field_identifier inside declarator (in class body) → method,
+ *   name = field identifier, qualifies with enclosing class
+ * - qualified_identifier (like `Foo::bar`) → out-of-class method,
+ *   name encoded as `Foo::bar` directly
+ */
+function functionNameFrom(fnDefNode) {
+  let declarator = null;
+  for (let i = 0; i < fnDefNode.namedChildCount; i += 1) {
+    const child = fnDefNode.namedChild(i);
+    if (child.type === "function_declarator") {
+      declarator = child;
+      break;
+    }
+    if (child.type === "pointer_declarator" || child.type === "reference_declarator") {
+      for (let j = 0; j < child.namedChildCount; j += 1) {
+        const inner = child.namedChild(j);
+        if (inner.type === "function_declarator") {
+          declarator = inner;
+          break;
+        }
+      }
+      if (declarator) break;
+    }
+  }
+  if (!declarator) return null;
+
+  for (let i = 0; i < declarator.namedChildCount; i += 1) {
+    const child = declarator.namedChild(i);
+    if (child.type === "identifier") {
+      return { name: child.text, qualifiedForm: null };
+    }
+    if (child.type === "field_identifier") {
+      return { name: child.text, qualifiedForm: null };
+    }
+    if (child.type === "qualified_identifier") {
+      return { name: null, qualifiedForm: child.text };
+    }
+  }
+  return null;
+}
+
+function buildFunctionChunk(node, imports, language) {
+  const nameInfo = functionNameFrom(node);
+  if (!nameInfo) return null;
+
+  let qualifiedName;
+  let kind;
+
+  if (nameInfo.qualifiedForm) {
+    qualifiedName = nameInfo.qualifiedForm;
+    kind = "method";
+  } else {
+    const scope = enclosingScopePath(node);
+    const baseName = nameInfo.name;
+    if (scope.length > 0) {
+      qualifiedName = `${scope.join("::")}::${baseName}`;
+      kind = "method";
+    } else {
+      qualifiedName = baseName;
+      kind = "function";
+    }
+  }
+
+  const { startLine, endLine } = lineRangeOf(node);
+  return {
+    name: qualifiedName,
+    kind,
+    signature: signatureOfDecl(node),
+    body: node.text,
+    startLine,
+    endLine,
+    language,
+    exported: true,
+    calls: collectCallsInNode(node),
+    imports
+  };
+}
+
+function buildTypeChunk(node, kind, language) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const baseName = nameNode.text;
+  const scope = enclosingScopePath(node);
+  const qualifiedName = scope.length > 0 ? `${scope.join("::")}::${baseName}` : baseName;
+  const { startLine, endLine } = lineRangeOf(node);
+  return {
+    name: qualifiedName,
+    kind,
+    signature: signatureOfDecl(node),
+    body: node.text,
+    startLine,
+    endLine,
+    language,
+    exported: true,
+    calls: [],
+    imports: []
+  };
+}
+
+function buildNamespaceChunk(node, language) {
+  const names = namespaceDefinitionNames(node);
+  if (names.length === 0) return null;
+  const scope = enclosingScopePath(node);
+  const fullPath = [...scope, ...names].join("::");
+  const { startLine, endLine } = lineRangeOf(node);
+  return {
+    name: fullPath,
+    kind: "namespace",
+    signature: signatureOfDecl(node),
+    body: node.text,
+    startLine,
+    endLine,
+    language,
+    exported: true,
+    calls: [],
+    imports: []
+  };
+}
+
+export async function parseCode(code, filePath, language = "cpp") {
+  await ensureLanguage();
+  const { tree } = parseSource(CPP_LANG, code);
+  const root = tree.rootNode;
+  const imports = collectImports(root);
+
+  const captures = runQuery(CPP_LANG, CHUNK_QUERY, root);
+  const declCaptures = captures.filter((c) => c.name.endsWith(".decl"));
+
+  const chunks = [];
+  for (const cap of declCaptures) {
+    const kindTag = cap.name.split(".")[0];
+    let chunk = null;
+    if (kindTag === "fn") chunk = buildFunctionChunk(cap.node, imports, language);
+    else if (kindTag === "class") chunk = buildTypeChunk(cap.node, "class", language);
+    else if (kindTag === "struct") chunk = buildTypeChunk(cap.node, "struct", language);
+    else if (kindTag === "union") chunk = buildTypeChunk(cap.node, "union", language);
+    else if (kindTag === "enum") chunk = buildTypeChunk(cap.node, "enum", language);
+    else if (kindTag === "namespace") chunk = buildNamespaceChunk(cap.node, language);
+    if (chunk) chunks.push(chunk);
+  }
+
+  const seen = new Set();
+  const deduped = chunks.filter((chunk) => {
+    const key = `${chunk.kind}|${chunk.name}|${chunk.startLine}|${chunk.endLine}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  return { chunks: deduped, errors: [] };
+}
+
+export async function isAvailable() {
+  try {
+    await ensureLanguage();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const target = process.argv[2];
+  if (!target) {
+    console.error("Usage: cpp-treesitter.mjs <file.{c,cpp,h,hpp}>");
+    process.exit(1);
+  }
+  const code = fs.readFileSync(target, "utf8");
+  const result = await parseCode(code, target, target.endsWith(".c") || target.endsWith(".h") ? "c" : "cpp");
+  console.log(JSON.stringify(result, null, 2));
+}