@danielblomma/cortex-mcp 0.4.0

package/scaffold/scripts/ingest.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+CONTEXT_DIR="$REPO_ROOT/.context"
+
+printf "[ingest] repo: %s\n" "$REPO_ROOT"
+printf "[ingest] config: %s\n" "$CONTEXT_DIR/config.yaml"
+
+if [[ ! -f "$CONTEXT_DIR/config.yaml" ]]; then
+  echo "[ingest] missing .context/config.yaml"
+  exit 1
+fi
+
+if ! command -v node >/dev/null 2>&1; then
+  echo "[ingest] Node.js is required but not found on PATH"
+  exit 1
+fi
+
+node "$REPO_ROOT/scripts/ingest.mjs" "$@"

package/scaffold/scripts/install-git-hooks.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+HOOKS_DIR="$REPO_ROOT/.githooks"
+
+if [[ ! -d "$HOOKS_DIR" ]]; then
+  echo "[hooks] missing $HOOKS_DIR"
+  exit 1
+fi
+
+chmod +x \
+  "$HOOKS_DIR/post-merge" \
+  "$HOOKS_DIR/post-checkout" \
+  "$HOOKS_DIR/_cortex-update-runner.sh"
+
+git -C "$REPO_ROOT" config core.hooksPath .githooks
+
+echo "[hooks] installed core.hooksPath=.githooks"
+echo "[hooks] post-merge + post-checkout now trigger background cortex update"
+echo "[hooks] logs: .context/hooks/update.log"

package/scaffold/scripts/load-kuzu.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+echo "[graph-load] warning: load-kuzu.sh is deprecated; using RyuGraph loader"
+"$REPO_ROOT/scripts/load-ryu.sh" "$@"

package/scaffold/scripts/load-ryu.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+MCP_DIR="$REPO_ROOT/mcp"
+
+if [[ ! -f "$MCP_DIR/package.json" ]]; then
+  echo "[graph-load] missing $MCP_DIR/package.json"
+  exit 1
+fi
+
+if [[ ! -d "$MCP_DIR/node_modules" ]]; then
+  echo "[graph-load] node_modules missing in mcp/"
+  echo "[graph-load] run: cd mcp && NPM_CONFIG_CACHE=$MCP_DIR/.npm-cache npm install"
+  exit 1
+fi
+
+NPM_CONFIG_CACHE="$MCP_DIR/.npm-cache" npm --prefix "$MCP_DIR" run graph:load -- "$@"

package/scaffold/scripts/parsers/javascript.mjs

@@ -0,0 +1,390 @@
+#!/usr/bin/env node
+/**
+ * JavaScript/TypeScript AST Parser for Cortex
+ * Extracts functions, methods, classes and call relationships
+ */
+
+import { Parser } from "acorn";
+import tsPlugin from "acorn-typescript";
+import { simple as walkSimple, base } from "acorn-walk";
+
+// Extend acorn-walk to handle TypeScript AST nodes
+const tsNodeHandlers = {
+  TSAsExpression(node, st, c) { c(node.expression, st); },
+  TSTypeAnnotation(node, st, c) { /* skip type annotations */ },
+  TSTypeParameterInstantiation(node, st, c) { /* skip */ },
+  TSTypeParameterDeclaration(node, st, c) { /* skip */ },
+  TSTypeReference(node, st, c) { /* skip */ },
+  TSInterfaceDeclaration(node, st, c) { /* skip */ },
+  TSTypeAliasDeclaration(node, st, c) { /* skip */ },
+  TSEnumDeclaration(node, st, c) { /* skip */ },
+  TSModuleDeclaration(node, st, c) { /* skip */ },
+  TSDeclareFunction(node, st, c) { /* skip */ },
+  TSPropertySignature(node, st, c) { /* skip */ },
+  TSMethodSignature(node, st, c) { /* skip */ },
+  TSIndexSignature(node, st, c) { /* skip */ },
+  TSTypeLiteral(node, st, c) { /* skip */ },
+  TSUnionType(node, st, c) { /* skip */ },
+  TSIntersectionType(node, st, c) { /* skip */ },
+  TSArrayType(node, st, c) { /* skip */ },
+  TSTupleType(node, st, c) { /* skip */ },
+  TSOptionalType(node, st, c) { /* skip */ },
+  TSRestType(node, st, c) { /* skip */ },
+  TSFunctionType(node, st, c) { /* skip */ },
+  TSConstructorType(node, st, c) { /* skip */ },
+  TSNonNullExpression(node, st, c) { c(node.expression, st); },
+  TSInstantiationExpression(node, st, c) { c(node.expression, st); },
+};
+
+Object.assign(base, tsNodeHandlers);
+
+const CHUNK_KINDS = new Set(["function", "method", "class", "const", "let", "var"]);
+
+/**
+ * Parse JavaScript/TypeScript code and extract chunks + calls
+ * @param {string} code - Source code
+ * @param {string} filePath - File path (for error context)
+ * @param {string} language - "javascript" | "typescript" | "jsx" | "tsx"
+ * @returns {Object} { chunks: Array, errors: Array }
+ */
+export function parseCode(code, filePath, language = "javascript") {
+  const chunks = [];
+  const errors = [];
+  const lines = code.split(/\r?\n/);
+
+  let ast;
+  try {
+    const TSParser = Parser.extend(tsPlugin());
+    ast = TSParser.parse(code, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      locations: true,
+      allowHashBang: true,
+      allowImportExportEverywhere: true,
+      allowAwaitOutsideFunction: true
+    });
+  } catch (error) {
+    errors.push({
+      message: `Parse error: ${error.message}`,
+      line: error.loc?.line,
+      column: error.loc?.column
+    });
+    return { chunks: [], errors };
+  }
+
+  // Extract top-level declarations
+  walkSimple(ast, {
+    FunctionDeclaration(node) {
+      if (!node.id) return; // Skip anonymous
+      
+      const chunk = extractFunctionChunk(node, "function", lines, code);
+      if (chunk) {
+        chunk.language = language;
+        chunks.push(chunk);
+      }
+    },
+
+    ClassDeclaration(node) {
+      if (!node.id) return;
+      
+      const chunk = extractClassChunk(node, lines, code);
+      if (chunk) {
+        chunk.language = language;
+        chunks.push(chunk);
+        
+        // Extract methods as sub-chunks
+        for (const method of extractClassMethods(node, lines, code)) {
+          method.language = language;
+          method.parentChunk = chunk.name;
+          chunks.push(method);
+        }
+      }
+    },
+
+    VariableDeclaration(node) {
+      // Extract arrow functions and function expressions assigned to variables
+      for (const declarator of node.declarations) {
+        if (!declarator.id || declarator.id.type !== "Identifier") continue;
+        if (!declarator.init) continue;
+        
+        const isFunctionExpr = 
+          declarator.init.type === "FunctionExpression" ||
+          declarator.init.type === "ArrowFunctionExpression";
+        
+        if (isFunctionExpr) {
+          const chunk = extractFunctionChunk(
+            declarator.init,
+            "const",
+            lines,
+            code,
+            declarator.id.name
+          );
+          if (chunk) {
+            chunk.language = language;
+            chunks.push(chunk);
+          }
+        }
+      }
+    },
+
+    ExportNamedDeclaration(node) {
+      // Handle export function/class
+      if (node.declaration) {
+        if (node.declaration.type === "FunctionDeclaration") {
+          const chunk = extractFunctionChunk(node.declaration, "function", lines, code);
+          if (chunk) {
+            chunk.exported = true;
+            chunk.language = language;
+            chunks.push(chunk);
+          }
+        } else if (node.declaration.type === "ClassDeclaration") {
+          const chunk = extractClassChunk(node.declaration, lines, code);
+          if (chunk) {
+            chunk.exported = true;
+            chunk.language = language;
+            chunks.push(chunk);
+            
+            for (const method of extractClassMethods(node.declaration, lines, code)) {
+              method.language = language;
+              method.parentChunk = chunk.name;
+              chunks.push(method);
+            }
+          }
+        }
+      }
+    },
+
+    ExportDefaultDeclaration(node) {
+      if (node.declaration.type === "FunctionDeclaration") {
+        const chunk = extractFunctionChunk(node.declaration, "function", lines, code);
+        if (chunk) {
+          chunk.exported = true;
+          chunk.default = true;
+          chunk.language = language;
+          chunks.push(chunk);
+        }
+      } else if (node.declaration.type === "ClassDeclaration") {
+        const chunk = extractClassChunk(node.declaration, lines, code);
+        if (chunk) {
+          chunk.exported = true;
+          chunk.default = true;
+          chunk.language = language;
+          chunks.push(chunk);
+          
+          for (const method of extractClassMethods(node.declaration, lines, code)) {
+            method.language = language;
+            method.parentChunk = chunk.name;
+            chunks.push(method);
+          }
+        }
+      }
+    }
+  });
+
+  // Deduplicate chunks by name+startLine (exports can cause double extraction)
+  const seenChunks = new Map();
+  for (const chunk of chunks) {
+    const key = `${chunk.name}:${chunk.startLine}`;
+    const existing = seenChunks.get(key);
+    // Prefer exported version over non-exported
+    if (!existing || chunk.exported) {
+      seenChunks.set(key, chunk);
+    }
+  }
+  const uniqueChunks = [...seenChunks.values()];
+
+  // Extract calls for each chunk
+  for (const chunk of uniqueChunks) {
+    chunk.calls = extractCalls(chunk.bodyNode, code);
+    chunk.imports = extractImports(ast);
+    delete chunk.bodyNode; // Remove AST node (not serializable)
+  }
+
+  return { chunks: uniqueChunks, errors };
+}
+
+function extractFunctionChunk(node, kind, lines, code, nameOverride = null) {
+  const name = nameOverride || node.id?.name;
+  if (!name) return null;
+
+  const startLine = node.loc.start.line;
+  const endLine = node.loc.end.line;
+  const body = code.slice(node.start, node.end);
+  
+  const params = node.params.map(param => {
+    if (param.type === "Identifier") return param.name;
+    if (param.type === "RestElement") return `...${param.argument.name}`;
+    return "_"; // Complex patterns
+  });
+
+  const signature = `${name}(${params.join(", ")})`;
+
+  return {
+    name,
+    kind,
+    signature,
+    body,
+    startLine,
+    endLine,
+    bodyNode: node.body || node, // Keep AST for call extraction
+    async: node.async === true,
+    generator: node.generator === true
+  };
+}
+
+function extractClassChunk(node, lines, code) {
+  const name = node.id?.name;
+  if (!name) return null;
+
+  const startLine = node.loc.start.line;
+  const endLine = node.loc.end.line;
+  const body = code.slice(node.start, node.end);
+  
+  const superClass = node.superClass?.name || null;
+  const signature = superClass ? `class ${name} extends ${superClass}` : `class ${name}`;
+
+  return {
+    name,
+    kind: "class",
+    signature,
+    body,
+    startLine,
+    endLine,
+    bodyNode: node.body,
+    superClass
+  };
+}
+
+function extractClassMethods(classNode, lines, code) {
+  const methods = [];
+  const className = classNode.id?.name || "UnknownClass";
+
+  for (const member of classNode.body.body) {
+    if (member.type !== "MethodDefinition") continue;
+    if (member.key.type !== "Identifier") continue;
+
+    const methodName = member.key.name;
+    const fullName = `${className}.${methodName}`;
+    
+    const startLine = member.loc.start.line;
+    const endLine = member.loc.end.line;
+    const body = code.slice(member.start, member.end);
+    
+    const params = member.value.params.map(param => {
+      if (param.type === "Identifier") return param.name;
+      if (param.type === "RestElement") return `...${param.argument.name}`;
+      return "_";
+    });
+
+    const isStatic = member.static === true;
+    const prefix = isStatic ? "static " : "";
+    const signature = `${prefix}${methodName}(${params.join(", ")})`;
+
+    methods.push({
+      name: fullName,
+      kind: "method",
+      signature,
+      body,
+      startLine,
+      endLine,
+      bodyNode: member.value.body,
+      static: isStatic,
+      async: member.value.async === true,
+      generator: member.value.generator === true
+    });
+  }
+
+  return methods;
+}
+
+function extractCalls(bodyNode, code) {
+  if (!bodyNode) return [];
+  
+  const calls = new Set();
+
+  try {
+    walkSimple(bodyNode, {
+      CallExpression(node) {
+        const callee = node.callee;
+        
+        // Direct function call: foo()
+        if (callee.type === "Identifier") {
+          calls.add(callee.name);
+        }
+        
+        // Method call: obj.method()
+        else if (callee.type === "MemberExpression") {
+          if (callee.property.type === "Identifier") {
+            const objName = getObjectName(callee.object);
+            if (objName) {
+              calls.add(`${objName}.${callee.property.name}`);
+            } else {
+              calls.add(callee.property.name);
+            }
+          }
+        }
+      }
+    });
+  } catch (error) {
+    // Ignore walk errors (incomplete AST)
+  }
+
+  return Array.from(calls).sort();
+}
+
+function getObjectName(node) {
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+  if (node.type === "ThisExpression") {
+    return "this";
+  }
+  if (node.type === "MemberExpression" && node.property.type === "Identifier") {
+    return node.property.name;
+  }
+  return null;
+}
+
+function extractImports(ast) {
+  const imports = [];
+
+  walkSimple(ast, {
+    ImportDeclaration(node) {
+      if (node.source && node.source.type === "Literal") {
+        imports.push(node.source.value);
+      }
+    },
+    
+    CallExpression(node) {
+      // Dynamic imports: import('module')
+      if (node.callee.type === "Import" && node.arguments[0]?.type === "Literal") {
+        imports.push(node.arguments[0].value);
+      }
+      
+      // Require: require('module')
+      if (node.callee.type === "Identifier" && node.callee.name === "require") {
+        if (node.arguments[0]?.type === "Literal") {
+          imports.push(node.arguments[0].value);
+        }
+      }
+    }
+  });
+
+  return Array.from(new Set(imports)).sort();
+}
+
+// CLI interface for testing
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const fs = await import("node:fs");
+  const filePath = process.argv[2];
+  
+  if (!filePath) {
+    console.error("Usage: javascript.mjs <file.js>");
+    process.exit(1);
+  }
+
+  const code = fs.readFileSync(filePath, "utf8");
+  const result = parseCode(code, filePath, "javascript");
+  
+  console.log(JSON.stringify(result, null, 2));
+}

package/scaffold/scripts/parsers/package-lock.json

@@ -0,0 +1,51 @@
+{
+  "name": "parsers",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "parsers",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "acorn": "^8.16.0",
+        "acorn-typescript": "^1.4.13",
+        "acorn-walk": "^8.3.5"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.16.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
+      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-typescript": {
+      "version": "1.4.13",
+      "resolved": "https://registry.npmjs.org/acorn-typescript/-/acorn-typescript-1.4.13.tgz",
+      "integrity": "sha512-xsc9Xv0xlVfwp2o7sQ+GCQ1PgbkdcpWdTzrwXxO3xDMTAywVS3oXVOcOHuRjAPkS4P9b+yc/qNF15460v+jp4Q==",
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": ">=8.9.0"
+      }
+    },
+    "node_modules/acorn-walk": {
+      "version": "8.3.5",
+      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.5.tgz",
+      "integrity": "sha512-HEHNfbars9v4pgpW6SO1KSPkfoS0xVOM/9UzkJltjlsHZmJasxg8aXkuZa7SMf8vKGIBhpUsPluQSqhJFCqebw==",
+      "license": "MIT",
+      "dependencies": {
+        "acorn": "^8.11.0"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    }
+  }
+}

package/scaffold/scripts/parsers/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "parsers",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "acorn": "^8.16.0",
+    "acorn-typescript": "^1.4.13",
+    "acorn-walk": "^8.3.5"
+  }
+}