legacyver 2.1.0 → 2.1.2

package/src/parser/ast/typescript.js

@@ -1,250 +1,16 @@
-/**
- * TypeScript AST parser using web-tree-sitter.
- * Extends JS parser with TypeScript grammar and type annotations.
- */
-
-import { initTreeSitter, loadLanguage, createParser } from './tree-sitter-init.js';
-import { parseGeneric } from './generic.js';
-
-let tsParser = null;
-let tsInitialized = false;
-
-async function ensureParser() {
-  if (tsInitialized) return tsParser;
-  tsInitialized = true;
-
-  const Parser = await initTreeSitter();
-  if (!Parser) return null;
-
-  const language = await loadLanguage('typescript');
-  if (!language) return null;
-
-  tsParser = createParser(language);
-  return tsParser;
-}
+'use strict';
 
 /**
- * Parse a TypeScript file and extract structural facts.
- * @param {string} source - Raw file content
- * @param {string} relativePath - Relative file path
- * @returns {Promise<import('../../parser/index.js').FileFacts>}
+ * TypeScript parser — extends JS parser, handles type annotations.
  */
-export async function parseTypeScript(source, relativePath) {
-  const parser = await ensureParser();
-
-  if (!parser) {
-    return parseGeneric(source, relativePath, 'typescript');
-  }
-
-  const tree = parser.parse(source);
-  const rootNode = tree.rootNode;
-
-  const functions = [];
-  const classes = [];
-  const imports = [];
-  const exports = [];
-  const lines = source.split('\n');
-  const linesOfCode = lines.filter((l) => l.trim().length > 0).length;
-
-  walkNode(rootNode, { functions, classes, imports, exports, source, lines });
-
-  return {
-    relativePath,
-    language: 'typescript',
-    linesOfCode,
-    parserType: 'tree-sitter',
-    functions,
-    classes,
-    imports,
-    exports: exports.map((e) => e.name || e),
-    callsTo: [],
-    calledBy: [],
-    hash: '',
-  };
-}
-
-function walkNode(node, ctx) {
-  switch (node.type) {
-    case 'function_declaration':
-      extractFunction(node, ctx, false);
-      break;
-    case 'export_statement':
-      handleExport(node, ctx);
-      break;
-    case 'import_statement':
-      extractImport(node, ctx);
-      break;
-    case 'class_declaration':
-      extractClass(node, ctx);
-      break;
-    case 'lexical_declaration':
-    case 'variable_declaration':
-      extractVariableDeclaration(node, ctx);
-      break;
-    case 'interface_declaration':
-    case 'type_alias_declaration':
-      // Track type exports
-      break;
-  }
-
-  for (let i = 0; i < node.childCount; i++) {
-    walkNode(node.child(i), ctx);
-  }
-}
-
-function extractFunction(node, ctx, isExported) {
-  const nameNode = node.childForFieldName('name');
-  const paramsNode = node.childForFieldName('parameters');
-  const returnTypeNode = node.childForFieldName('return_type');
-  const isAsync = node.text.startsWith('async');
+const { parse: parseJS } = require('./javascript');
 
-  if (nameNode) {
-    ctx.functions.push({
-      name: nameNode.text,
-      params: extractTypedParams(paramsNode),
-      returnType: returnTypeNode ? returnTypeNode.text.replace(/^:\s*/, '') : null,
-      isExported,
-      isAsync,
-      lineStart: node.startPosition.row + 1,
-      lineEnd: node.endPosition.row + 1,
-      calls: [],
-    });
-  }
+function parse(sourceText, relativePath) {
+  const result = parseJS(sourceText, relativePath);
+  result.language = 'typescript';
+  // TypeScript annotations are partially handled in the JS parser already
+  // (the regex catches `: Type` patterns in params and return types)
+  return result;
 }
 
-function extractClass(node, ctx) {
-  const nameNode = node.childForFieldName('name');
-  const bodyNode = node.childForFieldName('body');
-
-  let superclass = null;
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child.type === 'class_heritage') {
-      const extendsClause = child.text;
-      const match = extendsClause.match(/extends\s+(\w+)/);
-      if (match) superclass = match[1];
-    }
-  }
-
-  if (nameNode) {
-    const methods = [];
-    if (bodyNode) {
-      for (let i = 0; i < bodyNode.childCount; i++) {
-        const child = bodyNode.child(i);
-        if (child.type === 'method_definition' || child.type === 'public_field_definition') {
-          const methodName = child.childForFieldName('name');
-          if (methodName) methods.push(methodName.text);
-        }
-      }
-    }
-
-    ctx.classes.push({
-      name: nameNode.text,
-      methods,
-      extends: superclass,
-    });
-  }
-}
-
-function extractImport(node, ctx) {
-  const sourceNode = node.childForFieldName('source');
-  if (!sourceNode) return;
-
-  const module = sourceNode.text.replace(/['"]/g, '');
-  const specifiers = [];
-
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child.type === 'import_clause') {
-      for (let j = 0; j < child.childCount; j++) {
-        const clauseChild = child.child(j);
-        if (clauseChild.type === 'identifier') {
-          specifiers.push(clauseChild.text);
-        } else if (clauseChild.type === 'named_imports') {
-          for (let k = 0; k < clauseChild.childCount; k++) {
-            const importSpec = clauseChild.child(k);
-            if (importSpec.type === 'import_specifier') {
-              const name = importSpec.childForFieldName('name');
-              if (name) specifiers.push(name.text);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  ctx.imports.push({ module, specifiers });
-}
-
-function handleExport(node, ctx) {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child.type === 'function_declaration') {
-      extractFunction(child, ctx, true);
-      const nameNode = child.childForFieldName('name');
-      if (nameNode) ctx.exports.push({ name: nameNode.text });
-    } else if (child.type === 'class_declaration') {
-      extractClass(child, ctx);
-      const nameNode = child.childForFieldName('name');
-      if (nameNode) ctx.exports.push({ name: nameNode.text });
-    } else if (child.type === 'lexical_declaration') {
-      extractVariableDeclaration(child, ctx);
-      for (let j = 0; j < child.childCount; j++) {
-        const decl = child.child(j);
-        if (decl.type === 'variable_declarator') {
-          const nameNode = decl.childForFieldName('name');
-          if (nameNode) ctx.exports.push({ name: nameNode.text });
-        }
-      }
-    } else if (child.type === 'interface_declaration' || child.type === 'type_alias_declaration') {
-      const nameNode = child.childForFieldName('name');
-      if (nameNode) ctx.exports.push({ name: nameNode.text });
-    }
-  }
-}
-
-function extractVariableDeclaration(node, ctx) {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child.type === 'variable_declarator') {
-      const nameNode = child.childForFieldName('name');
-      const valueNode = child.childForFieldName('value');
-      if (nameNode && valueNode) {
-        if (valueNode.type === 'arrow_function' || valueNode.type === 'function') {
-          const paramsNode = valueNode.childForFieldName('parameters');
-          const returnTypeNode = valueNode.childForFieldName('return_type');
-          const isAsync = valueNode.text.startsWith('async');
-          ctx.functions.push({
-            name: nameNode.text,
-            params: extractTypedParams(paramsNode),
-            returnType: returnTypeNode ? returnTypeNode.text.replace(/^:\s*/, '') : null,
-            isExported: false,
-            isAsync,
-            lineStart: node.startPosition.row + 1,
-            lineEnd: node.endPosition.row + 1,
-            calls: [],
-          });
-        }
-      }
-    }
-  }
-}
-
-function extractTypedParams(paramsNode) {
-  if (!paramsNode) return [];
-  const params = [];
-  for (let i = 0; i < paramsNode.childCount; i++) {
-    const child = paramsNode.child(i);
-    if (child.type === 'required_parameter' || child.type === 'optional_parameter') {
-      const nameNode = child.childForFieldName('pattern') || child.childForFieldName('name');
-      const typeNode = child.childForFieldName('type');
-      params.push({
-        name: nameNode ? nameNode.text : child.text,
-        type: typeNode ? typeNode.text.replace(/^:\s*/, '') : null,
-      });
-    } else if (child.type === 'identifier') {
-      params.push({ name: child.text, type: null });
-    }
-  }
-  return params;
-}
+module.exports = { parse };

package/src/parser/body-extractor.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const MAX_BODY_LINES = 60;
+
+/**
+ * Extract body snippet from source text given line start/end positions.
+ * Returns null for simple functions (complexityScore <= 3).
+ * @param {string} sourceText
+ * @param {number} lineStart  1-indexed
+ * @param {number} lineEnd    1-indexed
+ * @param {number} complexityScore
+ * @returns {{ bodySnippet: string|null, bodySnippetTruncated: boolean }}
+ */
+function extractBodySnippet(sourceText, lineStart, lineEnd, complexityScore) {
+  if (complexityScore <= 3) {
+    return { bodySnippet: null, bodySnippetTruncated: false };
+  }
+
+  if (!sourceText || lineStart == null || lineEnd == null) {
+    return { bodySnippet: null, bodySnippetTruncated: false };
+  }
+
+  const lines = sourceText.split('\n');
+  const startIdx = Math.max(0, (lineStart || 1) - 1);
+  const endIdx = Math.min(lines.length, lineEnd || lines.length);
+  const bodyLines = lines.slice(startIdx, endIdx);
+
+  let truncated = false;
+  let snippet;
+  if (bodyLines.length > MAX_BODY_LINES) {
+    snippet = bodyLines.slice(0, MAX_BODY_LINES).join('\n');
+    truncated = true;
+  } else {
+    snippet = bodyLines.join('\n');
+  }
+
+  return { bodySnippet: snippet, bodySnippetTruncated: truncated };
+}
+
+module.exports = { extractBodySnippet };

package/src/parser/call-graph.js

@@ -1,86 +1,69 @@
-/**
- * Call graph resolver.
- * Post-processes all FileFacts:
- * - Resolves relative import paths to file paths
- * - Populates calledBy arrays on referenced files
- */
-
-import { dirname, join, normalize } from 'node:path';
+'use strict';
 
 /**
- * Resolve call graph across all file facts.
- * @param {import('./index.js').FileFacts[]} allFacts
- * @returns {import('./index.js').FileFacts[]} Facts with callsTo/calledBy populated
+ * Build cross-file call graph by resolving import paths.
  */
-export function resolveCallGraph(allFacts) {
-  // Build a map of relative paths for lookup
-  const pathMap = new Map();
+function buildCallGraph(allFacts) {
+  const fileMap = new Map();
   for (const facts of allFacts) {
-    pathMap.set(normalize(facts.relativePath), facts);
-    // Also index without extension for resolution
-    const withoutExt = facts.relativePath.replace(/\.\w+$/, '');
-    pathMap.set(normalize(withoutExt), facts);
+    fileMap.set(facts.relativePath, facts);
   }
 
-  // Resolve imports to file paths
   for (const facts of allFacts) {
-    const callsTo = new Set();
+    facts.callsTo = [];
+    facts.calledBy = [];
+  }
 
-    for (const imp of facts.imports) {
-      // Skip external modules (no ./ or ../ prefix and no file extension)
-      if (!imp.module.startsWith('.') && !imp.module.startsWith('/')) {
-        continue;
+  for (const facts of allFacts) {
+    for (const imp of (facts.imports || [])) {
+      const resolved = resolveImport(imp.module, facts.relativePath, fileMap);
+      if (resolved && !facts.callsTo.includes(resolved)) {
+        facts.callsTo.push(resolved);
+        const target = fileMap.get(resolved);
+        if (target && !target.calledBy.includes(facts.relativePath)) {
+          target.calledBy.push(facts.relativePath);
+        }
       }
+    }
 
-      // Resolve relative import
-      const importerDir = dirname(facts.relativePath);
-      const resolved = normalize(join(importerDir, imp.module));
-
-      // Try exact match and common extensions
-      const candidates = [
-        resolved,
-        resolved + '.js',
-        resolved + '.ts',
-        resolved + '.tsx',
-        resolved + '.jsx',
-        resolved + '.mjs',
-        resolved + '.py',
-        resolved + '.java',
-        resolved + '.go',
-        join(resolved, 'index.js'),
-        join(resolved, 'index.ts'),
-      ];
-
-      for (const candidate of candidates) {
-        const normalizedCandidate = normalize(candidate);
-        if (pathMap.has(normalizedCandidate)) {
-          callsTo.add(pathMap.get(normalizedCandidate).relativePath);
-          break;
+    // Laravel: resolve controller references from route laravelContext
+    if (facts.laravelContext && facts.laravelContext.type === 'route_file') {
+      for (const route of (facts.laravelContext.routes || [])) {
+        if (route.controller) {
+          // Try to find a matching controller file
+          for (const [relPath] of fileMap) {
+            if (relPath.includes(route.controller)) {
+              if (!facts.callsTo.includes(relPath)) facts.callsTo.push(relPath);
+              const target = fileMap.get(relPath);
+              if (target && !target.calledBy.includes(facts.relativePath)) {
+                target.calledBy.push(facts.relativePath);
+              }
+            }
+          }
         }
       }
     }
-
-    facts.callsTo = [...callsTo];
   }
 
-  // Build calledBy from callsTo
-  const calledByMap = new Map();
-  for (const facts of allFacts) {
-    calledByMap.set(facts.relativePath, new Set());
-  }
+  return allFacts;
+}
 
-  for (const facts of allFacts) {
-    for (const target of facts.callsTo) {
-      if (calledByMap.has(target)) {
-        calledByMap.get(target).add(facts.relativePath);
-      }
-    }
-  }
+function resolveImport(modulePath, fromPath, fileMap) {
+  if (!modulePath.startsWith('.')) return null;
 
-  for (const facts of allFacts) {
-    const callers = calledByMap.get(facts.relativePath);
-    facts.calledBy = callers ? [...callers] : [];
-  }
+  const fromDir = fromPath.includes('/') ? fromPath.split('/').slice(0, -1).join('/') : '';
+  const candidates = [
+    `${fromDir}/${modulePath}`,
+    `${fromDir}/${modulePath}.js`,
+    `${fromDir}/${modulePath}.ts`,
+    `${fromDir}/${modulePath}/index.js`,
+    `${fromDir}/${modulePath}/index.ts`,
+  ].map(p => p.replace(/^\//, '').replace(/\/\//g, '/'));
 
-  return allFacts;
+  for (const candidate of candidates) {
+    if (fileMap.has(candidate)) return candidate;
+  }
+  return null;
 }
+
+module.exports = { buildCallGraph };

package/src/parser/complexity-scorer.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * Complexity scorer — given function/method facts + body text,
+ * computes a complexityScore and classifies it.
+ */
+
+const DOMAIN_PATTERNS = require('./pattern-detector');
+
+/**
+ * Score a function based on its body text using heuristics.
+ * @param {string} bodyText  raw source of the function body
+ * @returns {{ complexityScore: number, complexityClass: string, detectedPatterns: string[] }}
+ */
+function scoreComplexity(bodyText) {
+  if (!bodyText) {
+    return { complexityScore: 0, complexityClass: 'simple', detectedPatterns: [] };
+  }
+
+  let score = 0;
+
+  // Binary/ternary operators
+  const arithmeticOps = (bodyText.match(/[\+\-\*\/\%\*\*\?\?]/g) || []).length;
+  score += Math.min(arithmeticOps, 5); // cap to avoid noise
+
+  // Conditional branches
+  const ifCount = (bodyText.match(/\bif\s*\(/g) || []).length;
+  const elseIfCount = (bodyText.match(/\belse\s+if\s*\(/g) || []).length;
+  const switchCase = (bodyText.match(/\bcase\b/g) || []).length;
+  const ternary = (bodyText.match(/\?[^:]/g) || []).length;
+  score += ifCount + elseIfCount + switchCase + ternary;
+
+  // Loop constructs
+  const forCount = (bodyText.match(/\bfor\s*\(/g) || []).length;
+  const foreachCount = (bodyText.match(/\bforeach\s*\(/g) || []).length;
+  const whileCount = (bodyText.match(/\bwhile\s*\(/g) || []).length;
+  const doCount = (bodyText.match(/\bdo\s*\{/g) || []).length;
+  score += forCount + foreachCount + whileCount + doCount;
+
+  // Nesting depth beyond level 1
+  let depth = 0;
+  let maxDepth = 0;
+  for (const ch of bodyText) {
+    if (ch === '{') { depth++; if (depth > maxDepth) maxDepth = depth; }
+    else if (ch === '}') { depth--; }
+  }
+  if (maxDepth > 1) score += maxDepth - 1;
+
+  // Domain patterns
+  const detectedPatterns = DOMAIN_PATTERNS.detectPatterns(bodyText);
+  score += detectedPatterns.length * 2;
+
+  const complexityClass =
+    score <= 3 ? 'simple' : score <= 8 ? 'moderate' : 'complex';
+
+  return { complexityScore: score, complexityClass, detectedPatterns };
+}
+
+module.exports = { scoreComplexity };

package/src/parser/index.js

@@ -1,106 +1,81 @@
-/**
- * Language-aware parser dispatcher.
- * Maps language string to correct AST parser.
- * Falls back to generic.js on unsupported language or Tree-sitter parse failure.
- */
+'use strict';
 
-import { readFileSync } from 'node:fs';
-import { parseJavaScript } from './ast/javascript.js';
-import { parseTypeScript } from './ast/typescript.js';
-import { parsePython } from './ast/python.js';
-import { parseJava } from './ast/java.js';
-import { parseGo } from './ast/go.js';
-import { parseGeneric } from './ast/generic.js';
-import { logger } from '../utils/logger.js';
+const path = require('path');
+const { readFileSync } = require('fs');
+const logger = require('../utils/logger');
 
-/**
- * @typedef {object} FileFacts
- * @property {string} relativePath
- * @property {string} language
- * @property {number} linesOfCode
- * @property {string} parserType - "tree-sitter" or "generic"
- * @property {Array} functions
- * @property {Array} classes
- * @property {Array} imports
- * @property {string[]} exports
- * @property {string[]} callsTo
- * @property {string[]} calledBy
- * @property {string} hash
- */
-
-const LANGUAGE_PARSERS = {
-  javascript: parseJavaScript,
-  typescript: parseTypeScript,
-  python: parsePython,
-  java: parseJava,
-  go: parseGo,
+const PARSERS = {
+  javascript: () => require('./ast/javascript'),
+  typescript: () => require('./ast/typescript'),
+  python: () => require('./ast/python'),
+  java: () => require('./ast/java'),
+  go: () => require('./ast/go'),
+  php: () => require('./ast/php'),
 };
 
 /**
- * Parse a single file and return FileFacts.
- * @param {import('../crawler/manifest.js').FileManifest} fileManifest
- * @param {string} targetDir - Base directory
- * @returns {Promise<FileFacts>}
+ * Dispatch parsing to the appropriate language parser.
+ * @param {import('../crawler/index').FileManifest} fileManifest
+ * @param {Object} meta  project metadata (includes framework)
+ * @returns {Object} FileFacts
  */
-export async function parseFile(fileManifest, targetDir) {
-  const { relativePath, absolutePath, language, hash } = fileManifest;
+function parseFile(fileManifest, meta) {
+  const { absolutePath, relativePath, language } = fileManifest;
 
-  let source;
+  let sourceText;
   try {
-    source = readFileSync(absolutePath, 'utf-8');
-  } catch (err) {
-    logger.warn(`Cannot read ${relativePath}: ${err.message}`);
-    return createEmptyFacts(relativePath, language, hash);
+    sourceText = readFileSync(absolutePath, 'utf8');
+  } catch (e) {
+    logger.warn(`Could not read file: ${relativePath}`);
+    return null;
   }
 
-  const parser = LANGUAGE_PARSERS[language];
-
-  if (!parser) {
-    logger.debug(`No specialized parser for "${language}", using generic: ${relativePath}`);
-    const facts = parseGeneric(source, relativePath, language);
-    facts.hash = hash;
-    return facts;
+  let facts;
+  if (language && PARSERS[language]) {
+    try {
+      const parser = PARSERS[language]();
+      facts = parser.parse(sourceText, relativePath);
+    } catch (e) {
+      logger.warn(`AST parse failed for ${relativePath}: ${e.message}. Falling back to generic.`);
+      facts = require('./ast/generic').parse(sourceText, relativePath, language);
+    }
+  } else {
+    facts = require('./ast/generic').parse(sourceText, relativePath, language);
   }
 
-  try {
-    const facts = await parser(source, relativePath);
-    facts.hash = hash;
-    return facts;
-  } catch (err) {
-    logger.warn(`Parser error for ${relativePath}: ${err.message}. Falling back to generic.`);
-    const facts = parseGeneric(source, relativePath, language);
-    facts.hash = hash;
-    return facts;
+  if (!facts) return null;
+
+  facts.hash = fileManifest.hash;
+
+  // Laravel enrichment
+  if (language === 'php' && meta && meta.framework === 'laravel') {
+    const { enrich } = require('./ast/laravel/index');
+    facts = enrich(sourceText, facts);
   }
+
+  return facts;
 }
 
 /**
- * Parse all files in the manifest.
- * @param {import('../crawler/manifest.js').FileManifest[]} manifest
- * @param {string} targetDir
- * @returns {Promise<FileFacts[]>}
+ * Parse all files and assemble the PKG.
+ * @param {import('../crawler/index').FileManifest[]} files
+ * @param {Object} meta
+ * @param {Object} config
+ * @returns {Object} PKG
  */
-export async function parseAll(manifest, targetDir) {
-  const results = [];
-  for (const file of manifest) {
-    const facts = await parseFile(file, targetDir);
-    results.push(facts);
+async function parseFiles(files, meta, config) {
+  const allFacts = [];
+
+  for (const file of files) {
+    const facts = parseFile(file, meta);
+    if (facts) allFacts.push(facts);
   }
-  return results;
-}
 
-function createEmptyFacts(relativePath, language, hash) {
-  return {
-    relativePath,
-    language,
-    linesOfCode: 0,
-    parserType: 'none',
-    functions: [],
-    classes: [],
-    imports: [],
-    exports: [],
-    callsTo: [],
-    calledBy: [],
-    hash,
-  };
+  const { buildCallGraph } = require('./call-graph');
+  const factsWithGraph = buildCallGraph(allFacts);
+
+  const { buildPKG } = require('./pkg-builder');
+  return buildPKG(factsWithGraph, meta);
 }
+
+module.exports = { parseFile, parseFiles };