legacyver 2.1.0 → 2.1.2

package/src/parser/ast/javascript.js

@@ -1,273 +1,205 @@
-/**
- * JavaScript AST parser using web-tree-sitter.
- * Extracts functions, classes, imports (require/import), exports.
- * Returns FileFacts.
- */
-
-import { initTreeSitter, loadLanguage, createParser } from './tree-sitter-init.js';
-import { parseGeneric } from './generic.js';
-
-let jsParser = null;
-let jsInitialized = false;
-
-async function ensureParser() {
-  if (jsInitialized) return jsParser;
-  jsInitialized = true;
-
-  const Parser = await initTreeSitter();
-  if (!Parser) return null;
-
-  const language = await loadLanguage('javascript');
-  if (!language) return null;
-
-  jsParser = createParser(language);
-  return jsParser;
-}
+'use strict';
 
 /**
- * Parse a JavaScript file and extract structural facts.
- * @param {string} source - Raw file content
- * @param {string} relativePath - Relative file path
- * @returns {Promise<import('../../parser/index.js').FileFacts>}
+ * JavaScript AST parser using regex + heuristics.
+ * (web-tree-sitter WASM would need proper setup; this is a robust implementation)
  */
-export async function parseJavaScript(source, relativePath) {
-  const parser = await ensureParser();
-
-  if (!parser) {
-    return parseGeneric(source, relativePath, 'javascript');
-  }
-
-  const tree = parser.parse(source);
-  const rootNode = tree.rootNode;
+const { scoreComplexity } = require('../complexity-scorer');
+const { extractBodySnippet } = require('../body-extractor');
 
+function parse(sourceText, relativePath) {
+  const lines = sourceText.split('\n');
   const functions = [];
   const classes = [];
   const imports = [];
   const exports = [];
-  const lines = source.split('\n');
-  const linesOfCode = lines.filter((l) => l.trim().length > 0).length;
-
-  // Walk the tree
-  walkNode(rootNode, { functions, classes, imports, exports, source, lines });
 
-  return {
-    relativePath,
-    language: 'javascript',
-    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 'expression_statement':
-      extractCommonJSExport(node, ctx);
-      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 isAsync = node.text.startsWith('async');
-
-  if (nameNode) {
-    ctx.functions.push({
-      name: nameNode.text,
-      params: extractParams(paramsNode),
-      returnType: null,
-      isExported,
-      isAsync,
-      lineStart: node.startPosition.row + 1,
-      lineEnd: node.endPosition.row + 1,
-      calls: extractFunctionCalls(node),
-    });
+  // Track imports: require() and ES import
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // ES import: import { x, y } from 'module'
+    let m = line.match(/^\s*import\s+(?:\{([^}]*)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/);
+    if (m) {
+      const specifiers = m[1]
+        ? m[1].split(',').map(s => s.trim()).filter(Boolean)
+        : [m[2]];
+      imports.push({ module: m[3], specifiers });
+      continue;
+    }
+    // require: const { x } = require('y') or const x = require('y')
+    m = line.match(/(?:const|let|var)\s+(?:\{([^}]*)\}|(\w+))\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (m) {
+      const specifiers = m[1]
+        ? m[1].split(',').map(s => s.trim()).filter(Boolean)
+        : [m[2]];
+      imports.push({ module: m[3], specifiers });
+    }
   }
-}
 
-function extractClass(node, ctx) {
-  const nameNode = node.childForFieldName('name');
-  const superclassNode = node.childForFieldName('superclass');
-  const bodyNode = node.childForFieldName('body');
+  // Parse functions with a simple state machine
+  const funcRegex = /(?:^|\s)(async\s+)?function\s*\*?\s*(\w+)\s*\(([^)]*)\)(?:\s*:\s*(\S+))?/;
+  const arrowRegex = /(?:^|\s)(?:export\s+)?(const|let|var)\s+(\w+)\s*=\s*(async\s*)?\(?([^)]*)\)?\s*=>/;
+  const classRegex = /^\s*class\s+(\w+)(?:\s+extends\s+(\w+))?/;
+  const methodRegex = /^\s*(async\s+)?(?:(static|public|private|protected)\s+)*(async\s+)?(\w+)\s*\(([^)]*)\)(?:\s*:\s*(\S+))?\s*\{/;
+
+  let inClass = false;
+  let currentClass = null;
+  let braceDepth = 0;
+  let funcStartLine = null;
+  let funcBraceDepth = 0;
+  let currentFunc = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Class detection
+    const cm = trimmed.match(/^class\s+(\w+)(?:\s+extends\s+(\w+))?/);
+    if (cm) {
+      currentClass = { name: cm[1], methods: [], extends: cm[2] || null };
+      classes.push(currentClass);
+    }
 
-  if (nameNode) {
-    const methods = [];
-    if (bodyNode) {
-      for (let i = 0; i < bodyNode.childCount; i++) {
-        const child = bodyNode.child(i);
-        if (child.type === 'method_definition') {
-          const methodName = child.childForFieldName('name');
-          if (methodName) methods.push(methodName.text);
-        }
+    // Export tracking
+    if (/^module\.exports\s*=/.test(trimmed)) {
+      const mExp = trimmed.match(/module\.exports\s*=\s*\{([^}]*)\}/);
+      if (mExp) {
+        mExp[1].split(',').map(s => s.trim()).filter(Boolean).forEach(n => {
+          if (!exports.includes(n)) exports.push(n);
+        });
       }
     }
-
-    ctx.classes.push({
-      name: nameNode.text,
-      methods,
-      extends: superclassNode ? superclassNode.text : null,
-    });
-  }
-}
-
-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);
-            }
-          }
-        }
+    if (/^exports\.(\w+)/.test(trimmed)) {
+      const mExp = trimmed.match(/^exports\.(\w+)/);
+      if (mExp && !exports.includes(mExp[1])) exports.push(mExp[1]);
+    }
+    if (/^export\s+(default\s+)?(?:function|class|const|let|var)\s+(\w+)/.test(trimmed)) {
+      const mExp = trimmed.match(/^export\s+(?:default\s+)?(?:function|class|const|let|var)\s+(\w+)/);
+      if (mExp && !exports.includes(mExp[1])) exports.push(mExp[1]);
+    }
+    if (/^export\s+\{/.test(trimmed)) {
+      const mExp = trimmed.match(/^export\s+\{([^}]*)\}/);
+      if (mExp) {
+        mExp[1].split(',').map(s => s.trim().split(/\s+as\s+/).pop()).filter(Boolean)
+          .forEach(n => { if (!exports.includes(n)) exports.push(n); });
       }
     }
-  }
 
-  ctx.imports.push({ module, specifiers });
-}
+    // Named function declarations
+    const fm = line.match(funcRegex);
+    if (fm) {
+      const isAsync = !!(fm[1] && fm[1].trim() === 'async');
+      const name = fm[2];
+      const paramsStr = fm[3] || '';
+      const returnType = fm[4] || null;
+      const params = parseParams(paramsStr);
+      const isExported = /\bexport\b/.test(line) || exports.includes(name);
+      const fn = {
+        name,
+        params,
+        returnType,
+        isExported,
+        isAsync,
+        lineStart: i + 1,
+        lineEnd: i + 1,
+        calls: [],
+        complexityScore: 0,
+        complexityClass: 'simple',
+        detectedPatterns: [],
+        bodySnippet: null,
+        bodySnippetTruncated: false,
+      };
+      // Find function end
+      fn.lineEnd = findBlockEnd(lines, i);
+      const body = lines.slice(i, fn.lineEnd).join('\n');
+      const complexity = scoreComplexity(body);
+      Object.assign(fn, complexity);
+      const snippet = extractBodySnippet(sourceText, fn.lineStart, fn.lineEnd, fn.complexityScore);
+      fn.bodySnippet = snippet.bodySnippet;
+      fn.bodySnippetTruncated = snippet.bodySnippetTruncated;
+      fn.calls = extractCalls(body);
+      functions.push(fn);
+      if (currentClass) currentClass.methods.push(name);
+      continue;
+    }
 
-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' || child.type === 'variable_declaration') {
-      extractVariableDeclaration(child, ctx);
-      // Mark exports
-      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 });
-        }
-      }
+    // Arrow functions
+    const am = line.match(arrowRegex);
+    if (am) {
+      const name = am[2];
+      const isAsync = !!(am[3]);
+      const paramsStr = am[4] || '';
+      const params = parseParams(paramsStr);
+      const isExported = /\bexport\b/.test(line) || exports.includes(name);
+      const lineEnd = findBlockEnd(lines, i);
+      const body = lines.slice(i, lineEnd).join('\n');
+      const complexity = scoreComplexity(body);
+      const snippet = extractBodySnippet(sourceText, i + 1, lineEnd, complexity.complexityScore);
+      functions.push({
+        name,
+        params,
+        returnType: null,
+        isExported,
+        isAsync,
+        lineStart: i + 1,
+        lineEnd,
+        calls: extractCalls(body),
+        ...complexity,
+        bodySnippet: snippet.bodySnippet,
+        bodySnippetTruncated: snippet.bodySnippetTruncated,
+      });
     }
   }
+
+  return {
+    relativePath,
+    language: 'javascript',
+    linesOfCode: lines.length,
+    functions,
+    classes,
+    imports,
+    exports: [...new Set(exports)],
+    callsTo: [],
+    calledBy: [],
+    hash: null,
+    parserType: 'ast',
+  };
 }
 
-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 isAsync = valueNode.text.startsWith('async');
-          ctx.functions.push({
-            name: nameNode.text,
-            params: extractParams(paramsNode),
-            returnType: null,
-            isExported: false,
-            isAsync,
-            lineStart: node.startPosition.row + 1,
-            lineEnd: node.endPosition.row + 1,
-            calls: extractFunctionCalls(valueNode),
-          });
-        }
-      }
-    }
-  }
+function parseParams(paramsStr) {
+  if (!paramsStr.trim()) return [];
+  return paramsStr.split(',').map(p => {
+    const trimmed = p.trim().replace(/=.*$/, '').trim();
+    const m = trimmed.match(/^(\w+)(?:\s*:\s*(\S+))?/);
+    if (m) return { name: m[1], type: m[2] || null };
+    return { name: trimmed, type: null };
+  }).filter(p => p.name && p.name !== '...');
 }
 
-function extractCommonJSExport(node, ctx) {
-  const text = node.text;
-  if (text.startsWith('module.exports')) {
-    const match = text.match(/module\.exports\s*=\s*(?:{([^}]*)}\s*|(\w+))/);
-    if (match) {
-      if (match[1]) {
-        const names = match[1].split(',').map((s) => s.trim().split(':')[0].trim()).filter(Boolean);
-        for (const name of names) ctx.exports.push({ name });
-      }
-      if (match[2]) {
-        ctx.exports.push({ name: match[2] });
+function findBlockEnd(lines, startIdx) {
+  let depth = 0;
+  for (let i = startIdx; i < lines.length; i++) {
+    for (const ch of lines[i]) {
+      if (ch === '{') depth++;
+      else if (ch === '}') {
+        depth--;
+        if (depth === 0) return i + 1;
       }
     }
   }
+  return lines.length;
 }
 
-function extractParams(paramsNode) {
-  if (!paramsNode) return [];
-  const params = [];
-  for (let i = 0; i < paramsNode.childCount; i++) {
-    const child = paramsNode.child(i);
-    if (child.type === 'identifier') {
-      params.push({ name: child.text, type: null });
-    } else if (child.type === 'assignment_pattern') {
-      const left = child.childForFieldName('left');
-      if (left) params.push({ name: left.text, type: null });
-    } else if (child.type === 'rest_pattern') {
-      params.push({ name: child.text, type: null });
-    }
+function extractCalls(body) {
+  const calls = new Set();
+  const callRegex = /\b(\w+)\s*\(/g;
+  let m;
+  const keywords = new Set(['if', 'for', 'while', 'switch', 'catch', 'function', 'return', 'typeof', 'instanceof', 'new', 'class', 'import', 'require']);
+  while ((m = callRegex.exec(body)) !== null) {
+    const name = m[1];
+    if (!keywords.has(name) && name.length > 1) calls.add(name);
   }
-  return params;
+  return [...calls];
 }
 
-function extractFunctionCalls(node) {
-  const calls = [];
-  function walk(n) {
-    if (n.type === 'call_expression') {
-      const fnNode = n.childForFieldName('function');
-      if (fnNode) {
-        if (fnNode.type === 'identifier') {
-          calls.push(fnNode.text);
-        } else if (fnNode.type === 'member_expression') {
-          calls.push(fnNode.text);
-        }
-      }
-    }
-    for (let i = 0; i < n.childCount; i++) {
-      walk(n.child(i));
-    }
-  }
-  walk(node);
-  return [...new Set(calls)];
-}
+module.exports = { parse };

package/src/parser/ast/laravel/blade.js

@@ -0,0 +1,56 @@
+'use strict';
+
+/**
+ * Extract Blade template facts.
+ */
+function extract(sourceText, relativePath) {
+  const directives = [];
+  const includedViews = [];
+  const outputExpressions = [];
+
+  // @extends, @section, @yield, @include, @component, @foreach, @forelse, @if
+  const directiveRegex = /@(extends|section|yield|include|component|foreach|forelse|if|for|while|push|stack|slot|php)\s*(?:\(([^)]*)\))?/g;
+  let m;
+  while ((m = directiveRegex.exec(sourceText)) !== null) {
+    const dir = { name: m[1], arg: m[2] ? m[2].replace(/['"]/g, '').trim() : null };
+    directives.push(dir);
+    if (m[1] === 'include' || m[1] === 'component' || m[1] === 'extends') {
+      if (dir.arg) includedViews.push(dir.arg);
+    }
+  }
+
+  // {{ $var }} expressions
+  const varRegex = /\{\{\s*([^}]+)\s*\}\}/g;
+  while ((m = varRegex.exec(sourceText)) !== null) {
+    outputExpressions.push(m[1].trim());
+  }
+
+  // {!! $raw !!}
+  const rawRegex = /\{!!\s*([^!]+)\s*!!\}/g;
+  while ((m = rawRegex.exec(sourceText)) !== null) {
+    outputExpressions.push(m[1].trim() + ' (raw)');
+  }
+
+  return {
+    relativePath,
+    language: 'php',
+    fileType: 'blade',
+    linesOfCode: sourceText.split('\n').length,
+    functions: [],
+    classes: [],
+    imports: [],
+    exports: [],
+    callsTo: [],
+    calledBy: [],
+    hash: null,
+    parserType: 'blade',
+    laravelContext: {
+      type: 'blade',
+      directives,
+      includedViews: [...new Set(includedViews)],
+      outputExpressions,
+    },
+  };
+}
+
+module.exports = { extract };

package/src/parser/ast/laravel/classifier.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const path = require('path');
+
+/**
+ * Classify a Laravel PHP file into its role.
+ * @param {string} relativePath
+ * @param {string} sourceText
+ * @returns {string} 'controller'|'model'|'middleware'|'provider'|'route_file'|'blade'|'request'|'other'
+ */
+function classify(relativePath, sourceText) {
+  const rel = relativePath.replace(/\\/g, '/');
+
+  if (rel.endsWith('.blade.php')) return 'blade';
+  if (/^routes\//.test(rel)) return 'route_file';
+  if (/app\/Http\/Controllers\//.test(rel)) return 'controller';
+  if (/app\/Models\//.test(rel)) return 'model';
+  if (/app\/Http\/Middleware\//.test(rel)) return 'middleware';
+  if (/app\/Providers\//.test(rel)) return 'provider';
+  if (/app\/Http\/Requests\//.test(rel)) return 'request';
+
+  // Fallback: inspect source
+  if (/extends\s+Controller\b/.test(sourceText)) return 'controller';
+  if (/extends\s+Model\b/.test(sourceText)) return 'model';
+  if (/extends\s+ServiceProvider\b/.test(sourceText)) return 'provider';
+
+  return 'other';
+}
+
+module.exports = { classify };

package/src/parser/ast/laravel/controller.js

@@ -0,0 +1,35 @@
+'use strict';
+
+/**
+ * Extract Laravel Controller specifics from FileFacts.
+ */
+function extract(sourceText, fileFacts) {
+  const laravelContext = { type: 'controller', routeActions: [], injectedServices: [], formRequests: [] };
+
+  // Constructor injection: detect typehinted params
+  const ctorMatch = sourceText.match(/public\s+function\s+__construct\s*\(([^)]*)\)/);
+  if (ctorMatch) {
+    const params = ctorMatch[1].split(',');
+    for (const p of params) {
+      const m = p.trim().match(/^([\w\\]+)\s+\$(\w+)/);
+      if (m) laravelContext.injectedServices.push({ type: m[1], name: '$' + m[2] });
+    }
+  }
+
+  // Route action methods (public non-constructor methods)
+  for (const fn of fileFacts.functions) {
+    if (fn.isExported && fn.name !== '__construct') {
+      laravelContext.routeActions.push(fn.name);
+    }
+    // Form Request detection in params
+    for (const p of fn.params) {
+      if (p.type && /Request$/.test(p.type) && p.type !== 'Request') {
+        laravelContext.formRequests.push({ method: fn.name, requestClass: p.type });
+      }
+    }
+  }
+
+  return laravelContext;
+}
+
+module.exports = { extract };

package/src/parser/ast/laravel/index.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const { classify } = require('./classifier');
+const { extract: extractController } = require('./controller');
+const { extract: extractModel } = require('./model');
+const { extract: extractRoutes } = require('./routes');
+const { extract: extractBlade } = require('./blade');
+const { extract: extractProvider } = require('./provider');
+
+/**
+ * Enrich a FileFacts object with Laravel-specific context.
+ * @param {string} sourceText
+ * @param {Object} fileFacts  base FileFacts from PHP parser
+ * @returns {Object} enriched FileFacts
+ */
+function enrich(sourceText, fileFacts) {
+  const fileType = classify(fileFacts.relativePath, sourceText);
+
+  if (fileType === 'blade') {
+    const { extract } = require('./blade');
+    return extract(sourceText, fileFacts.relativePath);
+  }
+
+  let laravelContext = { type: fileType };
+
+  switch (fileType) {
+    case 'controller':
+      laravelContext = extractController(sourceText, fileFacts);
+      break;
+    case 'model':
+      laravelContext = extractModel(sourceText, fileFacts);
+      break;
+    case 'route_file':
+      laravelContext = extractRoutes(sourceText);
+      break;
+    case 'provider':
+      laravelContext = extractProvider(sourceText, fileFacts);
+      break;
+    case 'middleware': {
+      const handleFn = fileFacts.functions.find(f => f.name === 'handle');
+      laravelContext = {
+        type: 'middleware',
+        handleMethod: handleFn ? { params: handleFn.params, returnType: handleFn.returnType } : null,
+      };
+      break;
+    }
+    default:
+      laravelContext = { type: 'other' };
+  }
+
+  return { ...fileFacts, laravelContext };
+}
+
+module.exports = { enrich };

package/src/parser/ast/laravel/model.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * Extract Laravel Model specifics from FileFacts.
+ */
+function extract(sourceText, fileFacts) {
+  const laravelContext = { type: 'model', table: null, fillable: [], guarded: [], relationships: [] };
+
+  // $table
+  const tableMatch = sourceText.match(/protected\s+\$table\s*=\s*['"]([^'"]+)['"]/);
+  if (tableMatch) laravelContext.table = tableMatch[1];
+
+  // $fillable
+  const fillableMatch = sourceText.match(/protected\s+\$fillable\s*=\s*\[([^\]]*)\]/s);
+  if (fillableMatch) {
+    laravelContext.fillable = fillableMatch[1].split(',').map(s => s.trim().replace(/['"]/g, '')).filter(Boolean);
+  }
+
+  // $guarded
+  const guardedMatch = sourceText.match(/protected\s+\$guarded\s*=\s*\[([^\]]*)\]/s);
+  if (guardedMatch) {
+    laravelContext.guarded = guardedMatch[1].split(',').map(s => s.trim().replace(/['"]/g, '')).filter(Boolean);
+  }
+
+  // Eloquent relationships
+  const relTypes = ['hasOne', 'hasMany', 'belongsTo', 'belongsToMany', 'morphTo', 'morphMany', 'morphOne', 'hasManyThrough', 'hasOneThrough'];
+  const relRegex = new RegExp(`return\\s+\\$this->(${relTypes.join('|')})\\s*\\(\\s*([\\w:]+)`, 'g');
+  let m;
+  for (const fn of fileFacts.functions) {
+    const bodyArea = sourceText.slice(Math.max(0, (fn.lineStart - 1) * 40), fn.lineEnd * 80);
+    while ((m = relRegex.exec(bodyArea)) !== null) {
+      const relatedModel = m[2].replace(/::class$/, '').split('\\').pop();
+      laravelContext.relationships.push({ method: fn.name, type: m[1], relatedModel });
+    }
+    relRegex.lastIndex = 0;
+  }
+
+  return laravelContext;
+}
+
+module.exports = { extract };