@danielblomma/cortex-mcp 0.4.5 → 0.6.5

package/scaffold/scripts/parsers/javascript.mjs

@@ -4,41 +4,21 @@
  * 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"]);
+let parseAst;
+let discoverChunks;
+let extractCalls;
+let collectStaticImports;
+let extractImportsForChunk;
+let fallbackParseCode = null;
+
+try {
+  ({ parseAst } = await import("./javascript/ast.mjs"));
+  ({ discoverChunks } = await import("./javascript/chunks.mjs"));
+  ({ extractCalls } = await import("./javascript/calls.mjs"));
+  ({ collectStaticImports, extractImportsForChunk } = await import("./javascript/imports.mjs"));
+} catch {
+  ({ parseCode: fallbackParseCode } = await import("../../../scripts/parsers/javascript.mjs"));
+}
 
 /**
  * Parse JavaScript/TypeScript code and extract chunks + calls
@@ -48,329 +28,26 @@ const CHUNK_KINDS = new Set(["function", "method", "class", "const", "let", "var
  * @returns {Object} { chunks: Array, errors: Array }
  */
 export function parseCode(code, filePath, language = "javascript") {
-  const chunks = [];
-  const errors = [];
-  const lines = code.split(/\r?\n/);
+  if (fallbackParseCode) {
+    return fallbackParseCode(code, filePath, language);
+  }
 
-  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
-    });
+  const { ast, errors } = parseAst(code, filePath);
+  if (!ast) {
     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);
-        }
-      }
-    },
+  const staticImports = collectStaticImports(ast);
+  const chunks = discoverChunks(ast, code, language);
 
-    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);
-    }
+    chunk.calls = extractCalls(chunk.callNode);
+    chunk.imports = extractImportsForChunk(chunk.importNode, staticImports);
+    delete chunk.callNode;
+    delete chunk.importNode;
   }
-  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();
+  return { chunks, errors };
 }
 
 // CLI interface for testing

package/scaffold/scripts/parsers/resources.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+/**
+ * .NET resources/settings parser for Cortex.
+ * Extracts .resx and .settings entries as chunks.
+ */
+
+const SQL_REFERENCE_PATTERNS = [
+  /\bexec(?:ute)?\s+([#@]?[A-Za-z0-9_[\].]+)/gi,
+  /\bfrom\s+([#@]?[A-Za-z0-9_[\].]+)/gi,
+  /\bjoin\s+([#@]?[A-Za-z0-9_[\].]+)/gi,
+  /\bupdate\s+([#@]?[A-Za-z0-9_[\].]+)/gi,
+  /\binsert\s+into\s+([#@]?[A-Za-z0-9_[\].]+)/gi,
+  /\bdelete\s+from\s+([#@]?[A-Za-z0-9_[\].]+)/gi,
+  /\bmerge\s+into\s+([#@]?[A-Za-z0-9_[\].]+)/gi
+];
+
+function countLinesBefore(text, index) {
+  let line = 1;
+  for (let i = 0; i < index; i += 1) {
+    if (text[i] === "\n") {
+      line += 1;
+    }
+  }
+  return line;
+}
+
+function decodeXmlEntities(value) {
+  return String(value)
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&");
+}
+
+function normalizeEntryKey(value) {
+  return String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+}
+
+function normalizeSqlName(value) {
+  return String(value ?? "")
+    .trim()
+    .replace(/[;"`]/g, "")
+    .replace(/\[(.+?)\]/g, "$1")
+    .replace(/\s+/g, "")
+    .replace(/^\.+|\.+$/g, "")
+    .replace(/\.\.+/g, ".")
+    .toLowerCase();
+}
+
+function extractSqlRefs(text) {
+  const refs = new Set();
+  const normalized = normalizeSqlName(text);
+  if (/^[a-z0-9_.]+$/i.test(normalized) && normalized.includes(".")) {
+    refs.add(normalized);
+  }
+
+  for (const pattern of SQL_REFERENCE_PATTERNS) {
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const name = normalizeSqlName(match[1]);
+      if (!name || name.startsWith("@") || name.startsWith("#")) {
+        continue;
+      }
+      refs.add(name);
+    }
+  }
+
+  return [...refs];
+}
+
+function parseResx(code, language) {
+  const chunks = [];
+  const pattern = /<data\b[^>]*\bname="([^"]+)"[^>]*>([\s\S]*?)<\/data>/gi;
+  let match;
+
+  while ((match = pattern.exec(code)) !== null) {
+    const originalKey = decodeXmlEntities(match[1]).trim();
+    const normalizedKey = normalizeEntryKey(originalKey);
+    if (!normalizedKey) {
+      continue;
+    }
+
+    const valueMatch = match[2].match(/<value>([\s\S]*?)<\/value>/i);
+    const value = decodeXmlEntities(valueMatch?.[1] ?? "").trim();
+    const body = match[0];
+    const startIndex = match.index ?? 0;
+    const endIndex = startIndex + body.length;
+
+    chunks.push({
+      name: `resource.${normalizedKey}`,
+      kind: "resource_entry",
+      signature: `resource ${originalKey}`.trim(),
+      body,
+      startLine: countLinesBefore(code, startIndex),
+      endLine: countLinesBefore(code, Math.max(startIndex, endIndex - 1)),
+      language,
+      resourceKey: originalKey,
+      description: value,
+      imports: [],
+      calls: extractSqlRefs(value)
+    });
+  }
+
+  return chunks;
+}
+
+function parseSettings(code, language) {
+  const chunks = [];
+  const pattern = /<Setting\b[^>]*\bName="([^"]+)"[^>]*>([\s\S]*?)<\/Setting>/gi;
+  let match;
+
+  while ((match = pattern.exec(code)) !== null) {
+    const originalKey = decodeXmlEntities(match[1]).trim();
+    const normalizedKey = normalizeEntryKey(originalKey);
+    if (!normalizedKey) {
+      continue;
+    }
+
+    const valueMatch = match[2].match(/<Value(?:\s[^>]*)?>([\s\S]*?)<\/Value>/i);
+    const value = decodeXmlEntities(valueMatch?.[1] ?? "").trim();
+    const body = match[0];
+    const startIndex = match.index ?? 0;
+    const endIndex = startIndex + body.length;
+
+    chunks.push({
+      name: `setting.${normalizedKey}`,
+      kind: "setting_entry",
+      signature: `setting ${originalKey}`.trim(),
+      body,
+      startLine: countLinesBefore(code, startIndex),
+      endLine: countLinesBefore(code, Math.max(startIndex, endIndex - 1)),
+      language,
+      resourceKey: originalKey,
+      description: value,
+      imports: [],
+      calls: extractSqlRefs(value)
+    });
+  }
+
+  return chunks;
+}
+
+export function parseCode(code, filePath, language = "resource") {
+  const chunks = language === "settings" ? parseSettings(code, language) : parseResx(code, language);
+  return { chunks, errors: [] };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const fs = await import("node:fs");
+  const filePath = process.argv[2];
+
+  if (!filePath) {
+    console.error("Usage: resources.mjs <file.{resx,settings}>");
+    process.exit(1);
+  }
+
+  const code = fs.readFileSync(filePath, "utf8");
+  const language = filePath.toLowerCase().endsWith(".settings") ? "settings" : "resource";
+  const result = parseCode(code, filePath, language);
+  console.log(JSON.stringify(result, null, 2));
+}