@danielblomma/cortex-mcp 0.4.5 → 1.0.0

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

@@ -0,0 +1,388 @@
+import { ancestor as walkAncestor, simple as walkSimple } from "acorn-walk";
+
+import { WALK_BASE } from "./ast.mjs";
+
+export function discoverChunks(ast, code, language = "javascript") {
+  const chunks = [];
+  const exportedNames = collectExportedNames(ast);
+
+  function pushChunk(chunk) {
+    if (!chunk) {
+      return;
+    }
+
+    chunk.language = language;
+    if (exportedNames.has(chunk.name)) {
+      chunk.exported = true;
+    }
+    chunks.push(chunk);
+  }
+
+  walkSimple(
+    ast,
+    {
+      FunctionDeclaration(node) {
+        if (!node.id) {
+          return;
+        }
+
+        pushChunk(extractFunctionChunk(node, "function", code));
+      },
+
+      ClassDeclaration(node) {
+        if (!node.id) {
+          return;
+        }
+
+        const chunk = extractClassChunk(node, code);
+        if (chunk) {
+          pushChunk(chunk);
+
+          for (const method of extractClassMethods(node, code, language)) {
+            method.parentChunk = chunk.name;
+            chunks.push(method);
+          }
+        }
+      },
+
+      VariableDeclaration(node) {
+        for (const declarator of node.declarations || []) {
+          if (!declarator.id || declarator.id.type !== "Identifier" || !declarator.init) {
+            continue;
+          }
+
+          const isFunctionExpr =
+            declarator.init.type === "FunctionExpression" ||
+            declarator.init.type === "ArrowFunctionExpression";
+
+          if (!isFunctionExpr) {
+            continue;
+          }
+
+          const chunk = extractFunctionChunk(declarator.init, "const", code, declarator.id.name);
+          pushChunk(chunk);
+        }
+      }
+    },
+    WALK_BASE
+  );
+
+  return dedupeChunks(chunks);
+}
+
+function dedupeChunks(chunks) {
+  const seenChunks = new Map();
+
+  for (const chunk of chunks) {
+    const key = `${chunk.name}:${chunk.startLine}`;
+    const existing = seenChunks.get(key);
+    if (!existing || chunk.exported) {
+      seenChunks.set(key, chunk);
+    }
+  }
+
+  return [...seenChunks.values()];
+}
+
+function collectExportedNames(ast) {
+  const exportedNames = new Set();
+
+  walkSimple(
+    ast,
+    {
+      ExportNamedDeclaration(node) {
+        if (node.declaration) {
+          if (
+            (node.declaration.type === "FunctionDeclaration" ||
+              node.declaration.type === "ClassDeclaration") &&
+            node.declaration.id?.name
+          ) {
+            exportedNames.add(node.declaration.id.name);
+          }
+
+          if (node.declaration.type === "VariableDeclaration") {
+            for (const declarator of node.declaration.declarations || []) {
+              if (declarator.id?.type === "Identifier") {
+                exportedNames.add(declarator.id.name);
+              }
+            }
+          }
+        }
+
+        if (!node.source) {
+          for (const specifier of node.specifiers || []) {
+            if (specifier.local?.type === "Identifier") {
+              exportedNames.add(specifier.local.name);
+            }
+          }
+        }
+      },
+
+      ExportDefaultDeclaration(node) {
+        const declaration = node.declaration;
+        if (
+          (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") &&
+          declaration.id?.name
+        ) {
+          exportedNames.add(declaration.id.name);
+          return;
+        }
+
+        if (declaration.type === "Identifier") {
+          exportedNames.add(declaration.name);
+        }
+      }
+    },
+    WALK_BASE
+  );
+
+  walkAncestor(
+    ast,
+    {
+      AssignmentExpression(node, ancestors) {
+        if (isNestedInFunctionScope(ancestors)) {
+          return;
+        }
+
+        addCommonJsExportedNames(exportedNames, node);
+      }
+    },
+    WALK_BASE
+  );
+
+  return exportedNames;
+}
+
+function isNestedInFunctionScope(ancestors) {
+  return ancestors.slice(0, -1).some((node) =>
+    node.type === "FunctionDeclaration" ||
+    node.type === "FunctionExpression" ||
+    node.type === "ArrowFunctionExpression"
+  );
+}
+
+function addCommonJsExportedNames(exportedNames, assignment) {
+  const exportPath = getCommonJsExportPath(assignment.left);
+  if (!exportPath) {
+    return;
+  }
+
+  addExportedNamesFromValue(exportedNames, assignment.right);
+}
+
+function getCommonJsExportPath(node) {
+  if (!node || node.type !== "MemberExpression") {
+    return null;
+  }
+
+  const propertyName = getStaticPropertyName(node);
+  if (!propertyName) {
+    return null;
+  }
+
+  if (node.object.type === "Identifier") {
+    if (node.object.name === "exports") {
+      return ["exports", propertyName];
+    }
+
+    if (node.object.name === "module" && propertyName === "exports") {
+      return ["module", "exports"];
+    }
+  }
+
+  const objectPath = getCommonJsExportPath(node.object);
+  if (!objectPath) {
+    return null;
+  }
+
+  if (objectPath.length >= 2 && objectPath[0] === "module" && objectPath[1] === "exports") {
+    return [...objectPath, propertyName];
+  }
+
+  return null;
+}
+
+function getStaticPropertyName(node) {
+  if (!node.computed && node.property.type === "Identifier") {
+    return node.property.name;
+  }
+
+  if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") {
+    return node.property.value;
+  }
+
+  return null;
+}
+
+function addExportedNamesFromValue(exportedNames, value) {
+  if (!value) {
+    return;
+  }
+
+  if (value.type === "Identifier") {
+    exportedNames.add(value.name);
+    return;
+  }
+
+  if (value.type === "AssignmentExpression") {
+    addExportedNamesFromValue(exportedNames, value.right);
+    return;
+  }
+
+  if (value.type !== "ObjectExpression") {
+    return;
+  }
+
+  for (const property of value.properties || []) {
+    if (property.type !== "Property" || property.kind !== "init") {
+      continue;
+    }
+
+    addExportedNamesFromValue(exportedNames, property.value);
+  }
+}
+
+function extractFunctionChunk(node, kind, code, nameOverride = null) {
+  const name = nameOverride || node.id?.name;
+  if (!name) {
+    return null;
+  }
+
+  const params = (node.params || []).map(formatParameterName);
+  const bodyStart = findLeadingCommentStart(code, node);
+
+  return {
+    name,
+    kind,
+    signature: `${name}(${params.join(", ")})`,
+    body: code.slice(bodyStart, node.end),
+    startLine: node.loc.start.line,
+    endLine: node.loc.end.line,
+    callNode: node.body || node,
+    importNode: node,
+    async: node.async === true,
+    generator: node.generator === true
+  };
+}
+
+function extractClassChunk(node, code) {
+  const name = node.id?.name;
+  if (!name) {
+    return null;
+  }
+
+  const superClass = node.superClass?.name || null;
+  const bodyStart = findLeadingCommentStart(code, node);
+
+  return {
+    name,
+    kind: "class",
+    signature: superClass ? `class ${name} extends ${superClass}` : `class ${name}`,
+    body: code.slice(bodyStart, node.end),
+    startLine: node.loc.start.line,
+    endLine: node.loc.end.line,
+    callNode: node.body,
+    importNode: node,
+    superClass
+  };
+}
+
+function extractClassMethods(classNode, code, language) {
+  const methods = [];
+  const className = classNode.id?.name || "UnknownClass";
+
+  for (const member of classNode.body.body || []) {
+    if (member.type !== "MethodDefinition" || member.key.type !== "Identifier") {
+      continue;
+    }
+
+    const params = (member.value.params || []).map(formatParameterName);
+    const isStatic = member.static === true;
+    const prefix = isStatic ? "static " : "";
+    const bodyStart = findLeadingCommentStart(code, member);
+
+    methods.push({
+      name: `${className}.${member.key.name}`,
+      kind: "method",
+      signature: `${prefix}${member.key.name}(${params.join(", ")})`,
+      body: code.slice(bodyStart, member.end),
+      startLine: member.loc.start.line,
+      endLine: member.loc.end.line,
+      callNode: member.value.body,
+      importNode: member,
+      static: isStatic,
+      async: member.value.async === true,
+      generator: member.value.generator === true,
+      language
+    });
+  }
+
+  return methods;
+}
+
+function findLeadingCommentStart(code, node) {
+  let bodyStart = node.start;
+  let lineStart = code.lastIndexOf("\n", node.start - 1) + 1;
+
+  while (lineStart > 0) {
+    const previousLineEnd = lineStart - 1;
+    const previousLineStart = code.lastIndexOf("\n", previousLineEnd - 1) + 1;
+    const previousLine = code.slice(previousLineStart, previousLineEnd).replace(/\r$/, "");
+    const trimmed = previousLine.trim();
+
+    if (!trimmed) {
+      break;
+    }
+
+    if (trimmed.startsWith("//")) {
+      bodyStart = previousLineStart;
+      lineStart = previousLineStart;
+      continue;
+    }
+
+    if (trimmed.endsWith("*/")) {
+      let blockStart = previousLineStart;
+      let searchStart = previousLineStart;
+      let foundBlockStart = trimmed.startsWith("/*");
+
+      while (!foundBlockStart && searchStart > 0) {
+        const blockLineEnd = searchStart - 1;
+        const blockLineStart = code.lastIndexOf("\n", blockLineEnd - 1) + 1;
+        const blockLine = code.slice(blockLineStart, blockLineEnd).replace(/\r$/, "");
+        const blockTrimmed = blockLine.trim();
+
+        if (!blockTrimmed) {
+          return bodyStart;
+        }
+
+        blockStart = blockLineStart;
+        searchStart = blockLineStart;
+        foundBlockStart = blockTrimmed.startsWith("/*");
+      }
+
+      if (!foundBlockStart) {
+        break;
+      }
+
+      bodyStart = blockStart;
+      lineStart = blockStart;
+      continue;
+    }
+
+    break;
+  }
+
+  return bodyStart;
+}
+
+function formatParameterName(param) {
+  if (param.type === "Identifier") {
+    return param.name;
+  }
+
+  if (param.type === "RestElement" && param.argument.type === "Identifier") {
+    return `...${param.argument.name}`;
+  }
+
+  return "_";
+}

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

@@ -0,0 +1,162 @@
+import { fullAncestor, simple as walkSimple } from "acorn-walk";
+
+import { WALK_BASE } from "./ast.mjs";
+import { collectPatternIdentifiers } from "./patterns.mjs";
+import { buildScopeGraph } from "./scope-builder.mjs";
+import { isReferenceIdentifier, resolveIdentifier } from "./scope-resolver.mjs";
+
+export function collectStaticImports(ast) {
+  const bindings = [];
+  const sideEffectImports = new Set();
+
+  for (const node of ast.body || []) {
+    if (node.type === "ImportDeclaration") {
+      if (node.source?.type === "Literal" && typeof node.source.value === "string") {
+        if ((node.specifiers || []).length === 0) {
+          sideEffectImports.add(node.source.value);
+        }
+
+        for (const specifier of node.specifiers || []) {
+          if (specifier.local?.type === "Identifier") {
+            bindings.push({
+              localName: specifier.local.name,
+              source: node.source.value
+            });
+          }
+        }
+      }
+      continue;
+    }
+
+    if (node.type === "VariableDeclaration") {
+      for (const declarator of node.declarations || []) {
+        const source = getStaticRequireImportSource(declarator.init);
+        if (!source) {
+          continue;
+        }
+
+        collectPatternIdentifiers(declarator.id, (localName) => {
+          bindings.push({ localName, source });
+        });
+      }
+      continue;
+    }
+
+    if (node.type === "ExpressionStatement") {
+      const source = getStaticRequireImportSource(node.expression);
+      if (source) {
+        sideEffectImports.add(source);
+      }
+    }
+  }
+
+  return {
+    bindings,
+    sideEffectImports: [...sideEffectImports].sort()
+  };
+}
+
+export function extractImportsForChunk(bodyNode, staticImports) {
+  const imports = new Set(extractDynamicImports(bodyNode));
+
+  for (const source of staticImports.sideEffectImports || []) {
+    imports.add(source);
+  }
+
+  for (const source of extractReferencedStaticImportSources(bodyNode, staticImports.bindings || [])) {
+    imports.add(source);
+  }
+
+  return [...imports].sort();
+}
+
+function getStaticRequireImportSource(node) {
+  if (
+    node?.type === "CallExpression" &&
+    node.callee.type === "Identifier" &&
+    node.callee.name === "require" &&
+    node.arguments[0]?.type === "Literal" &&
+    typeof node.arguments[0].value === "string"
+  ) {
+    return node.arguments[0].value;
+  }
+
+  return null;
+}
+
+function extractReferencedStaticImportSources(bodyNode, bindings) {
+  if (!bodyNode || bindings.length === 0) {
+    return [];
+  }
+
+  const importsByLocalName = new Map();
+  for (const binding of bindings) {
+    if (!importsByLocalName.has(binding.localName)) {
+      importsByLocalName.set(binding.localName, binding.source);
+    }
+  }
+
+  const scopeGraph = buildScopeGraph(bodyNode);
+  const sources = new Set();
+
+  try {
+    fullAncestor(
+      bodyNode,
+      (node, state, ancestors) => {
+        if (node.type !== "Identifier") {
+          return;
+        }
+
+        const source = importsByLocalName.get(node.name);
+        if (!source || !isReferenceIdentifier(node, ancestors)) {
+          return;
+        }
+
+        if (resolveIdentifier(node.name, ancestors, scopeGraph)) {
+          return;
+        }
+
+        sources.add(source);
+      },
+      WALK_BASE
+    );
+  } catch (error) {
+    // Ignore walk errors for incomplete ASTs.
+  }
+
+  return [...sources].sort();
+}
+
+function extractDynamicImports(bodyNode) {
+  if (!bodyNode) {
+    return [];
+  }
+
+  const imports = new Set();
+
+  try {
+    walkSimple(
+      bodyNode,
+      {
+        CallExpression(node) {
+          if (node.callee.type === "Import" && node.arguments[0]?.type === "Literal") {
+            imports.add(node.arguments[0].value);
+          }
+
+          if (
+            node.callee.type === "Identifier" &&
+            node.callee.name === "require" &&
+            node.arguments[0]?.type === "Literal"
+          ) {
+            imports.add(node.arguments[0].value);
+          }
+        }
+      },
+      WALK_BASE
+    );
+  } catch (error) {
+    // Ignore walk errors for incomplete ASTs.
+  }
+
+  return [...imports].sort();
+}

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

@@ -0,0 +1,82 @@
+export function collectPatternIdentifiers(pattern, visit) {
+  if (!pattern) {
+    return;
+  }
+
+  switch (pattern.type) {
+    case "Identifier":
+      visit(pattern.name);
+      break;
+    case "AssignmentPattern":
+      collectPatternIdentifiers(pattern.left, visit);
+      break;
+    case "ArrayPattern":
+      for (const element of pattern.elements || []) {
+        if (element) {
+          collectPatternIdentifiers(element, visit);
+        }
+      }
+      break;
+    case "ObjectPattern":
+      for (const property of pattern.properties || []) {
+        if (!property) {
+          continue;
+        }
+
+        if (property.type === "Property") {
+          collectPatternIdentifiers(property.value, visit);
+        } else if (property.type === "RestElement") {
+          collectPatternIdentifiers(property.argument, visit);
+        }
+      }
+      break;
+    case "RestElement":
+      collectPatternIdentifiers(pattern.argument, visit);
+      break;
+    default:
+      break;
+  }
+}
+
+export function walkPatternExpressions(pattern, visit) {
+  if (!pattern) {
+    return;
+  }
+
+  switch (pattern.type) {
+    case "AssignmentPattern":
+      walkPatternExpressions(pattern.left, visit);
+      if (pattern.right) {
+        visit(pattern.right);
+      }
+      break;
+    case "ArrayPattern":
+      for (const element of pattern.elements || []) {
+        if (element) {
+          walkPatternExpressions(element, visit);
+        }
+      }
+      break;
+    case "ObjectPattern":
+      for (const property of pattern.properties || []) {
+        if (!property) {
+          continue;
+        }
+
+        if (property.type === "Property") {
+          if (property.computed) {
+            visit(property.key);
+          }
+          walkPatternExpressions(property.value, visit);
+        } else if (property.type === "RestElement") {
+          walkPatternExpressions(property.argument, visit);
+        }
+      }
+      break;
+    case "RestElement":
+      walkPatternExpressions(pattern.argument, visit);
+      break;
+    default:
+      break;
+  }
+}

package/scaffold/scripts/parsers/javascript/scope-analysis.mjs

@@ -0,0 +1,3 @@
+export { collectPatternIdentifiers, walkPatternExpressions } from "./patterns.mjs";
+export { buildScopeGraph } from "./scope-builder.mjs";
+export { isReferenceIdentifier, resolveIdentifier } from "./scope-resolver.mjs";