@danielblomma/cortex-mcp 1.3.1 → 1.4.0

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

@@ -0,0 +1,283 @@
+/**
+ * Tree-sitter Go parser for Cortex.
+ *
+ * Extracts function_declaration, method_declaration (with receiver),
+ * and type_declaration (struct/interface/type alias) as chunks.
+ *
+ * Naming:
+ *   top-level function:   name = "Parse"
+ *   method on T:          name = "T.Method"
+ *   method on *T:         name = "T.Method"   (pointer vs value unified)
+ *   struct type:          name = "Config"     (kind = "struct")
+ *   interface type:       name = "Handler"    (kind = "interface")
+ *   other type:           name = "UserID"     (kind = "type")
+ *
+ * Exported: true when the name starts with an upper-case letter (Go convention).
+ *
+ * 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 GO_LANG = null;
+let langPromise = null;
+
+async function ensureLanguage() {
+  if (GO_LANG) return GO_LANG;
+  if (!langPromise) {
+    langPromise = (async () => {
+      await initTreeSitter();
+      GO_LANG = await loadGrammar("go");
+      return GO_LANG;
+    })();
+  }
+  await langPromise;
+  return GO_LANG;
+}
+
+export async function isAvailable() {
+  try {
+    await ensureLanguage();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const CHUNK_QUERY = fs.readFileSync(path.join(QUERY_DIR, "go.chunks.scm"), "utf8");
+const CALL_QUERY = fs.readFileSync(path.join(QUERY_DIR, "go.calls.scm"), "utf8");
+const IMPORT_QUERY = fs.readFileSync(path.join(QUERY_DIR, "go.imports.scm"), "utf8");
+
+const CALL_FILTER = new Set([
+  "make", "new", "len", "cap", "append", "copy", "delete",
+  "panic", "recover", "print", "println", "close",
+  "int", "int32", "int64", "float32", "float64", "string",
+  "byte", "rune", "bool", "complex", "real", "imag"
+]);
+
+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 unquoteStringLiteral(text) {
+  if (text.length >= 2 && (text.startsWith('"') || text.startsWith("`"))) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function isExported(name) {
+  if (!name || name.length === 0) return false;
+  const first = name[0];
+  return first >= "A" && first <= "Z";
+}
+
+function collectImports(rootNode) {
+  const captures = runQuery(GO_LANG, IMPORT_QUERY, rootNode);
+  const imports = captures
+    .filter((c) => c.name === "import.path")
+    .map((c) => unquoteStringLiteral(c.node.text));
+  return dedupe(imports);
+}
+
+function collectCallsInNode(node) {
+  const captures = runQuery(GO_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);
+}
+
+/**
+ * Return the receiver type name for a method_declaration, ignoring
+ * pointer-vs-value distinction. `func (r *Foo) M()` and `func (r Foo) M()`
+ * both return "Foo".
+ */
+function receiverTypeOf(methodNode) {
+  // First parameter_list is the receiver — walk for pointer_type or type_identifier.
+  for (let i = 0; i < methodNode.namedChildCount; i += 1) {
+    const child = methodNode.namedChild(i);
+    if (child.type !== "parameter_list") continue;
+    for (let j = 0; j < child.namedChildCount; j += 1) {
+      const param = child.namedChild(j);
+      if (param.type !== "parameter_declaration") continue;
+      for (let k = 0; k < param.namedChildCount; k += 1) {
+        const typeNode = param.namedChild(k);
+        if (typeNode.type === "pointer_type") {
+          for (let m = 0; m < typeNode.namedChildCount; m += 1) {
+            const inner = typeNode.namedChild(m);
+            if (inner.type === "type_identifier") return inner.text;
+          }
+        }
+        if (typeNode.type === "type_identifier") return typeNode.text;
+        // generic receivers look like generic_type with inner type_identifier
+        if (typeNode.type === "generic_type") {
+          for (let m = 0; m < typeNode.namedChildCount; m += 1) {
+            const inner = typeNode.namedChild(m);
+            if (inner.type === "type_identifier") return inner.text;
+          }
+        }
+      }
+    }
+    break;
+  }
+  return "";
+}
+
+/**
+ * Classify a type_declaration's kind. Inspects the body of the type_spec
+ * (or type_alias) child to decide: struct, interface, or generic "type".
+ */
+function typeKindOf(declNode) {
+  for (let i = 0; i < declNode.namedChildCount; i += 1) {
+    const spec = declNode.namedChild(i);
+    if (spec.type !== "type_spec" && spec.type !== "type_alias") continue;
+    for (let j = 0; j < spec.namedChildCount; j += 1) {
+      const child = spec.namedChild(j);
+      if (child.type === "struct_type") return "struct";
+      if (child.type === "interface_type") return "interface";
+    }
+  }
+  return "type";
+}
+
+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: isExported(name),
+    calls: collectCallsInNode(node),
+    imports
+  };
+}
+
+function buildMethodChunk(node, imports, language) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const methodName = nameNode.text;
+  const receiver = receiverTypeOf(node);
+  const qualifiedName = receiver ? `${receiver}.${methodName}` : methodName;
+  const { startLine, endLine } = lineRangeOf(node);
+  return {
+    name: qualifiedName,
+    kind: "method",
+    signature: signatureOfDecl(node),
+    body: node.text,
+    startLine,
+    endLine,
+    language,
+    exported: isExported(methodName),
+    calls: collectCallsInNode(node),
+    imports
+  };
+}
+
+function buildTypeChunk(node, nameNode, language) {
+  const name = nameNode.text;
+  const kind = typeKindOf(node);
+  const { startLine, endLine } = lineRangeOf(node);
+  return {
+    name,
+    kind,
+    signature: signatureOfDecl(node),
+    body: node.text,
+    startLine,
+    endLine,
+    language,
+    exported: isExported(name),
+    calls: [],
+    imports: []
+  };
+}
+
+export async function parseCode(code, filePath, language = "go") {
+  await ensureLanguage();
+  const { tree } = parseSource(GO_LANG, code);
+  const root = tree.rootNode;
+  const imports = collectImports(root);
+
+  const captures = runQuery(GO_LANG, CHUNK_QUERY, root);
+  const declCaptures = captures.filter((c) => c.name.endsWith(".decl"));
+
+  const nameCaptures = captures.filter((c) => c.name.endsWith(".name"));
+
+  const chunks = [];
+  for (const cap of declCaptures) {
+    const kind = cap.name.split(".")[0];
+    if (kind === "fn") {
+      const chunk = buildFunctionChunk(cap.node, imports, language);
+      if (chunk) chunks.push(chunk);
+    } else if (kind === "method") {
+      const chunk = buildMethodChunk(cap.node, imports, language);
+      if (chunk) chunks.push(chunk);
+    } else if (kind === "type") {
+      let nameNode = null;
+      let smallest = Infinity;
+      for (const nc of nameCaptures) {
+        if (nc.name !== "type.name") continue;
+        if (nc.node.startIndex < cap.node.startIndex) continue;
+        if (nc.node.endIndex > cap.node.endIndex) continue;
+        const size = nc.node.endIndex - nc.node.startIndex;
+        if (size < smallest) {
+          smallest = size;
+          nameNode = nc.node;
+        }
+      }
+      if (!nameNode) continue;
+      const chunk = buildTypeChunk(cap.node, nameNode, 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: go-treesitter.mjs <file.go>");
+    process.exit(1);
+  }
+  const code = fs.readFileSync(target, "utf8");
+  const result = await parseCode(code, target, "go");
+  console.log(JSON.stringify(result, null, 2));
+}

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

@@ -0,0 +1,250 @@
+/**
+ * Tree-sitter Java parser for Cortex.
+ *
+ * Extracts class/interface/enum/record declarations, methods, and
+ * constructors as chunks. Methods and constructors are qualified by
+ * the enclosing type path, so `Outer.Inner.deep()` becomes
+ * "Outer.Inner.deep" and `Svc(int n)` becomes "Svc.ctor".
+ *
+ * Naming conventions (match other Cortex parsers):
+ *   class/interface/enum/record:  name = "Foo"
+ *   nested type:                  name = "Outer.Inner"
+ *   method:                       name = "Class.method"
+ *   method in nested:             name = "Outer.Inner.method"
+ *   constructor:                  name = "Class.ctor"  (matches C# style)
+ *
+ * exported: true when modifiers include `public`. Package-private and
+ * protected count as not-exported for Cortex's find-callers purposes.
+ *
+ * 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 JAVA_LANG = null;
+let langPromise = null;
+
+async function ensureLanguage() {
+  if (JAVA_LANG) return JAVA_LANG;
+  if (!langPromise) {
+    langPromise = (async () => {
+      await initTreeSitter();
+      JAVA_LANG = await loadGrammar("java");
+      return JAVA_LANG;
+    })();
+  }
+  await langPromise;
+  return JAVA_LANG;
+}
+
+export async function isAvailable() {
+  try {
+    await ensureLanguage();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const CHUNK_QUERY = fs.readFileSync(path.join(QUERY_DIR, "java.chunks.scm"), "utf8");
+const CALL_QUERY = fs.readFileSync(path.join(QUERY_DIR, "java.calls.scm"), "utf8");
+const IMPORT_QUERY = fs.readFileSync(path.join(QUERY_DIR, "java.imports.scm"), "utf8");
+
+// Keywords that parse as method_invocation in some grammars but
+// aren't real call edges for our purposes.
+const CALL_FILTER = new Set([
+  "super", "this"
+]);
+
+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 hasPublicModifier(node) {
+  for (let i = 0; i < node.namedChildCount; i += 1) {
+    const child = node.namedChild(i);
+    if (child.type !== "modifiers") continue;
+    if (child.text.includes("public")) return true;
+    return false;
+  }
+  return false;
+}
+
+function enclosingTypePath(node) {
+  const path = [];
+  let cur = node.parent;
+  while (cur && cur.type !== "program") {
+    if (
+      cur.type === "class_declaration" ||
+      cur.type === "interface_declaration" ||
+      cur.type === "enum_declaration" ||
+      cur.type === "record_declaration"
+    ) {
+      const nameNode = cur.childForFieldName("name");
+      if (nameNode) path.unshift(nameNode.text);
+    }
+    cur = cur.parent;
+  }
+  return path;
+}
+
+function collectCallsInNode(node) {
+  const captures = runQuery(JAVA_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(JAVA_LANG, IMPORT_QUERY, rootNode);
+  const imports = [];
+  for (const cap of captures) {
+    if (cap.name !== "import.decl") continue;
+    const decl = cap.node;
+    // decl.text looks like `import java.util.List;` or
+    // `import static java.lang.Math.PI;` or `import java.util.*;`.
+    // Strip `import`, optional `static`, and trailing semicolon.
+    let text = decl.text.trim();
+    if (text.endsWith(";")) text = text.slice(0, -1).trim();
+    if (text.startsWith("import")) text = text.slice("import".length).trim();
+    if (text.startsWith("static ")) text = text.slice("static".length).trim();
+    imports.push(text);
+  }
+  return dedupe(imports);
+}
+
+function buildTypeChunk(node, kind, imports, language) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const baseName = nameNode.text;
+  const parentPath = enclosingTypePath(node);
+  const qualifiedName = parentPath.length > 0
+    ? `${parentPath.join(".")}.${baseName}`
+    : baseName;
+  const { startLine, endLine } = lineRangeOf(node);
+  return {
+    name: qualifiedName,
+    kind,
+    signature: signatureOfDecl(node),
+    body: node.text,
+    startLine,
+    endLine,
+    language,
+    exported: hasPublicModifier(node),
+    calls: [],
+    imports: []
+  };
+}
+
+function buildMethodChunk(node, imports, language) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const methodName = nameNode.text;
+  const parentPath = enclosingTypePath(node);
+  const qualifiedName = parentPath.length > 0
+    ? `${parentPath.join(".")}.${methodName}`
+    : methodName;
+  const { startLine, endLine } = lineRangeOf(node);
+  return {
+    name: qualifiedName,
+    kind: "method",
+    signature: signatureOfDecl(node),
+    body: node.text,
+    startLine,
+    endLine,
+    language,
+    exported: hasPublicModifier(node),
+    calls: collectCallsInNode(node),
+    imports
+  };
+}
+
+function buildConstructorChunk(node, imports, language) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const parentPath = enclosingTypePath(node);
+  const classPath = parentPath.length > 0 ? parentPath.join(".") : nameNode.text;
+  const qualifiedName = `${classPath}.ctor`;
+  const { startLine, endLine } = lineRangeOf(node);
+  return {
+    name: qualifiedName,
+    kind: "constructor",
+    signature: signatureOfDecl(node),
+    body: node.text,
+    startLine,
+    endLine,
+    language,
+    exported: hasPublicModifier(node),
+    calls: collectCallsInNode(node),
+    imports
+  };
+}
+
+export async function parseCode(code, filePath, language = "java") {
+  await ensureLanguage();
+  const { tree } = parseSource(JAVA_LANG, code);
+  const root = tree.rootNode;
+  const imports = collectImports(root);
+
+  const captures = runQuery(JAVA_LANG, CHUNK_QUERY, root);
+  const declCaptures = captures.filter((c) => c.name.endsWith(".decl"));
+
+  const chunks = [];
+  for (const cap of declCaptures) {
+    const kind = cap.name.split(".")[0];
+    let chunk = null;
+    if (kind === "class") chunk = buildTypeChunk(cap.node, "class", imports, language);
+    else if (kind === "interface") chunk = buildTypeChunk(cap.node, "interface", imports, language);
+    else if (kind === "enum") chunk = buildTypeChunk(cap.node, "enum", imports, language);
+    else if (kind === "record") chunk = buildTypeChunk(cap.node, "record", imports, language);
+    else if (kind === "method") chunk = buildMethodChunk(cap.node, imports, language);
+    else if (kind === "ctor") chunk = buildConstructorChunk(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: java-treesitter.mjs <file.java>");
+    process.exit(1);
+  }
+  const code = fs.readFileSync(target, "utf8");
+  const result = await parseCode(code, target, "java");
+  console.log(JSON.stringify(result, null, 2));
+}

package/scaffold/scripts/parsers/javascript/ast.mjs

@@ -2,12 +2,67 @@ import { Parser } from "acorn";
 import tsPlugin from "acorn-typescript";
 import { base } from "acorn-walk";
 
+const baseIdentifier = base.Identifier;
+const baseFunction = base.Function;
+const baseClass = base.Class;
+
+base.Identifier = (node, st, visit) => {
+  baseIdentifier(node, st, visit);
+  if (node.typeAnnotation) {
+    visit(node.typeAnnotation, st);
+  }
+};
+
+base.Function = (node, st, visit) => {
+  baseFunction(node, st, visit);
+  if (node.returnType) {
+    visit(node.returnType, st);
+  }
+  if (node.typeParameters) {
+    visit(node.typeParameters, st);
+  }
+};
+
+base.Class = (node, st, visit) => {
+  baseClass(node, st, visit);
+  for (const implementedType of node.implements || []) {
+    visit(implementedType, st);
+  }
+  if (node.typeParameters) {
+    visit(node.typeParameters, st);
+  }
+};
+
 const tsNodeHandlers = {
   TSAsExpression(node, st, visit) { visit(node.expression, st); },
-  TSTypeAnnotation() {},
-  TSTypeParameterInstantiation() {},
-  TSTypeParameterDeclaration() {},
-  TSTypeReference() {},
+  TSTypeAnnotation(node, st, visit) {
+    if (node.typeAnnotation) {
+      visit(node.typeAnnotation, st);
+    }
+  },
+  TSTypeParameterInstantiation(node, st, visit) {
+    for (const param of node.params || []) {
+      visit(param, st);
+    }
+  },
+  TSTypeParameterDeclaration(node, st, visit) {
+    for (const param of node.params || []) {
+      if (param.constraint) {
+        visit(param.constraint, st);
+      }
+      if (param.default) {
+        visit(param.default, st);
+      }
+    }
+  },
+  TSTypeReference(node, st, visit) {
+    if (node.typeName) {
+      visit(node.typeName, st);
+    }
+    if (node.typeParameters) {
+      visit(node.typeParameters, st);
+    }
+  },
   TSInterfaceDeclaration() {},
   TSTypeAliasDeclaration() {},
   TSEnumDeclaration() {},
@@ -17,14 +72,65 @@ const tsNodeHandlers = {
   TSMethodSignature() {},
   TSIndexSignature() {},
   TSTypeLiteral() {},
-  TSUnionType() {},
-  TSIntersectionType() {},
-  TSArrayType() {},
-  TSTupleType() {},
-  TSOptionalType() {},
-  TSRestType() {},
-  TSFunctionType() {},
-  TSConstructorType() {},
+  TSUnionType(node, st, visit) {
+    for (const typeNode of node.types || []) {
+      visit(typeNode, st);
+    }
+  },
+  TSIntersectionType(node, st, visit) {
+    for (const typeNode of node.types || []) {
+      visit(typeNode, st);
+    }
+  },
+  TSArrayType(node, st, visit) {
+    if (node.elementType) {
+      visit(node.elementType, st);
+    }
+  },
+  TSTupleType(node, st, visit) {
+    for (const elementType of node.elementTypes || []) {
+      visit(elementType, st);
+    }
+  },
+  TSOptionalType(node, st, visit) {
+    if (node.typeAnnotation) {
+      visit(node.typeAnnotation, st);
+    }
+  },
+  TSRestType(node, st, visit) {
+    if (node.typeAnnotation) {
+      visit(node.typeAnnotation, st);
+    }
+  },
+  TSFunctionType(node, st, visit) {
+    for (const param of node.params || []) {
+      visit(param, st);
+    }
+    if (node.returnType) {
+      visit(node.returnType, st);
+    }
+  },
+  TSConstructorType(node, st, visit) {
+    for (const param of node.params || []) {
+      visit(param, st);
+    }
+    if (node.returnType) {
+      visit(node.returnType, st);
+    }
+  },
+  TSExpressionWithTypeArguments(node, st, visit) {
+    if (node.expression) {
+      visit(node.expression, st);
+    }
+    if (node.typeParameters) {
+      visit(node.typeParameters, st);
+    }
+  },
+  TSParameterProperty(node, st, visit) {
+    if (node.parameter) {
+      visit(node.parameter, st);
+    }
+  },
   TSNonNullExpression(node, st, visit) { visit(node.expression, st); },
   TSInstantiationExpression(node, st, visit) { visit(node.expression, st); }
 };

package/scaffold/scripts/parsers/javascript/chunks.mjs

@@ -376,6 +376,10 @@ function findLeadingCommentStart(code, node) {
 }
 
 function formatParameterName(param) {
+  if (param.type === "TSParameterProperty") {
+    return formatParameterName(param.parameter);
+  }
+
   if (param.type === "Identifier") {
     return param.name;
   }

package/scaffold/scripts/parsers/javascript/patterns.mjs

@@ -4,6 +4,9 @@ export function collectPatternIdentifiers(pattern, visit) {
   }
 
   switch (pattern.type) {
+    case "TSParameterProperty":
+      collectPatternIdentifiers(pattern.parameter, visit);
+      break;
     case "Identifier":
       visit(pattern.name);
       break;
@@ -44,6 +47,9 @@ export function walkPatternExpressions(pattern, visit) {
   }
 
   switch (pattern.type) {
+    case "TSParameterProperty":
+      walkPatternExpressions(pattern.parameter, visit);
+      break;
     case "AssignmentPattern":
       walkPatternExpressions(pattern.left, visit);
       if (pattern.right) {