legacyver 2.1.0 → 2.1.2

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

@@ -0,0 +1,28 @@
+'use strict';
+
+/**
+ * Extract Service Provider specifics.
+ */
+function extract(sourceText, fileFacts) {
+  const laravelContext = { type: 'provider', registerBindings: [], bootActions: [] };
+
+  // register() method body
+  const registerFn = fileFacts.functions.find(f => f.name === 'register');
+  if (registerFn && registerFn.bodySnippet) {
+    const bindRegex = /\$this->app->(?:bind|singleton|instance|scoped)\s*\(\s*(['"])([\w\\]+)\1/g;
+    let m;
+    while ((m = bindRegex.exec(registerFn.bodySnippet)) !== null) {
+      laravelContext.registerBindings.push(m[2]);
+    }
+  }
+
+  // boot() method body
+  const bootFn = fileFacts.functions.find(f => f.name === 'boot');
+  if (bootFn && bootFn.bodySnippet) {
+    laravelContext.bootActions.push('boot() method present');
+  }
+
+  return laravelContext;
+}
+
+module.exports = { extract };

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

@@ -0,0 +1,45 @@
+'use strict';
+
+/**
+ * Extract route definitions from Laravel route files.
+ */
+function extract(sourceText) {
+  const routes = [];
+
+  // Route::METHOD('uri', [Controller::class, 'method'])->middleware(...)->name(...)
+  const routeRegex = /Route::(get|post|put|patch|delete|options|any)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(?:\[([^\]]+)\]|['"]([^'"]+)['"]|\$?(\w+))/gi;
+  let m;
+  while ((m = routeRegex.exec(sourceText)) !== null) {
+    const method = m[1].toUpperCase();
+    const uri = m[2];
+    let controller = null;
+    let action = null;
+
+    if (m[3]) {
+      // Array syntax: [Controller::class, 'method']
+      const parts = m[3].split(',').map(s => s.trim().replace(/['"]/g, '').replace(/::class$/, ''));
+      controller = parts[0] ? parts[0].split('\\').pop() : null;
+      action = parts[1] || null;
+    } else if (m[4]) {
+      // String 'Controller@method'
+      const parts = m[4].split('@');
+      controller = parts[0] ? parts[0].split('\\').pop() : null;
+      action = parts[1] || null;
+    }
+
+    // Extract middleware
+    const afterRoute = sourceText.slice(m.index, m.index + 200);
+    const middlewareMatch = afterRoute.match(/->middleware\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+    const middleware = middlewareMatch ? middlewareMatch[1] : null;
+
+    // Extract name
+    const nameMatch = afterRoute.match(/->name\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+    const name = nameMatch ? nameMatch[1] : null;
+
+    routes.push({ method, uri, controller, action, middleware, name });
+  }
+
+  return { type: 'route_file', routes };
+}
+
+module.exports = { extract };

package/src/parser/ast/php.js

@@ -0,0 +1,129 @@
+'use strict';
+
+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 = [];
+
+  // Namespace detection
+  let namespace = null;
+  const nsMatch = sourceText.match(/^namespace\s+([\w\\]+)\s*;/m);
+  if (nsMatch) namespace = nsMatch[1];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Use statements
+    let m = trimmed.match(/^use\s+([\w\\]+)(?:\s+as\s+\w+)?;/);
+    if (m) { imports.push({ module: m[1], specifiers: [] }); continue; }
+
+    // Class definition
+    m = trimmed.match(/^(?:abstract\s+|final\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s\\]+))?/);
+    if (m) {
+      const cls = { name: m[1], methods: [], extends: m[2] || null, implements: m[3] ? m[3].split(',').map(s => s.trim()) : [] };
+      classes.push(cls);
+      continue;
+    }
+
+    // Interface
+    m = trimmed.match(/^interface\s+(\w+)/);
+    if (m) {
+      classes.push({ name: m[1], methods: [], extends: null, isInterface: true });
+      continue;
+    }
+
+    // Methods
+    m = trimmed.match(/^(?:(public|protected|private)\s+)?(?:(static)\s+)?(?:(abstract|final)\s+)?(?:(async)\s+)?function\s+(\w+)\s*\(([^)]*)\)(?:\s*:\s*\??([\w\\|]+))?/);
+    if (m) {
+      const visibility = m[1] || 'public';
+      const isStatic = !!m[2];
+      const name = m[5];
+      const paramsStr = m[6] || '';
+      const returnType = m[7] || null;
+      const params = parsePhpParams(paramsStr);
+      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);
+      const fn = {
+        name,
+        params,
+        returnType,
+        isExported: visibility === 'public',
+        isStatic,
+        isAsync: !!m[4],
+        visibility,
+        lineStart: i + 1,
+        lineEnd,
+        calls: extractCalls(body),
+        ...complexity,
+        bodySnippet: snippet.bodySnippet,
+        bodySnippetTruncated: snippet.bodySnippetTruncated,
+      };
+      functions.push(fn);
+      if (classes.length > 0) classes[classes.length - 1].methods.push(name);
+    }
+  }
+
+  const publicFns = functions.filter(f => f.isExported).map(f => f.name);
+
+  return {
+    relativePath,
+    language: 'php',
+    linesOfCode: lines.length,
+    namespace,
+    functions,
+    classes,
+    imports,
+    exports: publicFns,
+    callsTo: [],
+    calledBy: [],
+    hash: null,
+    parserType: 'ast',
+    laravelContext: null,
+  };
+}
+
+function parsePhpParams(paramsStr) {
+  if (!paramsStr.trim()) return [];
+  return paramsStr.split(',').map(p => {
+    const trimmed = p.trim();
+    // Type hint + variable: e.g. "Request $request" or "?string $name = null"
+    const m = trimmed.match(/^(?:\?)?([\w\\|]+)\s+\$(\w+)/) || trimmed.match(/^\$(\w+)/);
+    if (!m) return { name: trimmed, type: null };
+    if (m[2]) return { name: '$' + m[2], type: m[1] };
+    return { name: '$' + m[1], type: null };
+  }).filter(p => p.name);
+}
+
+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 extractCalls(body) {
+  const calls = new Set();
+  const keywords = new Set(['if', 'foreach', 'for', 'while', 'switch', 'catch', 'function', 'return', 'throw', 'new', 'echo', 'print', 'empty', 'isset', 'unset', 'list', 'array', 'class', 'interface', 'abstract', 'static', 'public', 'private', 'protected', 'namespace', 'use', 'require', 'include', 'elseif', 'else', 'try', 'finally', 'match', 'fn']);
+  for (const match of body.matchAll(/\b(\w+)\s*\(/g)) {
+    const name = match[1];
+    if (!keywords.has(name) && name.length > 1) calls.add(name);
+  }
+  return [...calls];
+}
+
+module.exports = { parse };

package/src/parser/ast/python.js

@@ -1,227 +1,104 @@
-/**
- * Python AST parser using web-tree-sitter.
- * Extracts def functions, class definitions, import/from...import statements.
- */
+'use strict';
 
-import { initTreeSitter, loadLanguage, createParser } from './tree-sitter-init.js';
-import { parseGeneric } from './generic.js';
-
-let pyParser = null;
-let pyInitialized = false;
-
-async function ensureParser() {
-  if (pyInitialized) return pyParser;
-  pyInitialized = true;
-
-  const Parser = await initTreeSitter();
-  if (!Parser) return null;
-
-  const language = await loadLanguage('python');
-  if (!language) return null;
-
-  pyParser = createParser(language);
-  return pyParser;
-}
-
-/**
- * Parse a Python file and extract structural facts.
- * @param {string} source - Raw file content
- * @param {string} relativePath - Relative file path
- * @returns {Promise<import('../../parser/index.js').FileFacts>}
- */
-export async function parsePython(source, relativePath) {
-  const parser = await ensureParser();
-
-  if (!parser) {
-    return parseGeneric(source, relativePath, 'python');
-  }
-
-  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;
-
-  walkNode(rootNode, { functions, classes, imports, exports });
 
-  // In Python, top-level functions and classes are the "exports"
-  for (const fn of functions) {
-    if (!fn.name.startsWith('_')) {
-      exports.push(fn.name);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Imports
+    let m = trimmed.match(/^import\s+(\w+)$/);
+    if (m) { imports.push({ module: m[1], specifiers: [] }); continue; }
+    m = trimmed.match(/^from\s+(\S+)\s+import\s+(.+)$/);
+    if (m) {
+      const specifiers = m[2].split(',').map(s => s.trim().split(/\s+as\s+/)[0].trim());
+      imports.push({ module: m[1], specifiers });
+      continue;
     }
-  }
-  for (const cls of classes) {
-    if (!cls.name.startsWith('_')) {
-      exports.push(cls.name);
+    m = trimmed.match(/^import\s+(\S+)\s+as\s+\w+$/);
+    if (m) { imports.push({ module: m[1], specifiers: [] }); continue; }
+
+    // Class
+    m = trimmed.match(/^class\s+(\w+)/);
+    if (m) {
+      classes.push({ name: m[1], methods: [], extends: null });
+      continue;
+    }
+
+    // Function / def
+    m = trimmed.match(/^(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*(\S+))?:/);
+    if (m) {
+      const name = m[1];
+      const params = m[2].split(',').map(p => {
+        const pm = p.trim().match(/(\w+)(?:\s*:\s*(\S+?))?(?:\s*=.*)?$/);
+        return pm ? { name: pm[1], type: pm[2] || null } : { name: p.trim(), type: null };
+      }).filter(p => p.name && p.name !== 'self' && p.name !== 'cls');
+      const returnType = m[3] || null;
+      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,
+        isExported: !name.startsWith('_'),
+        isAsync: /^async\s+def/.test(trimmed),
+        lineStart: i + 1,
+        lineEnd,
+        calls: extractCalls(body),
+        ...complexity,
+        bodySnippet: snippet.bodySnippet,
+        bodySnippetTruncated: snippet.bodySnippetTruncated,
+      });
     }
   }
 
+  const publicFns = functions.filter(f => f.isExported).map(f => f.name);
+
   return {
     relativePath,
     language: 'python',
-    linesOfCode,
-    parserType: 'tree-sitter',
+    linesOfCode: lines.length,
     functions,
     classes,
     imports,
-    exports,
+    exports: publicFns,
     callsTo: [],
     calledBy: [],
-    hash: '',
+    hash: null,
+    parserType: 'ast',
   };
 }
 
-function walkNode(node, ctx) {
-  switch (node.type) {
-    case 'function_definition':
-      extractFunction(node, ctx);
-      break;
-    case 'class_definition':
-      extractClass(node, ctx);
-      break;
-    case 'import_statement':
-      extractImport(node, ctx);
-      break;
-    case 'import_from_statement':
-      extractFromImport(node, ctx);
-      break;
-  }
-
-  // Only walk top-level and class-level nodes
-  if (node.type === 'module' || node.type === 'class_definition') {
-    for (let i = 0; i < node.childCount; i++) {
-      walkNode(node.child(i), ctx);
-    }
+function findBlockEnd(lines, startIdx) {
+  const baseIndent = lines[startIdx] ? lines[startIdx].match(/^(\s*)/)[1].length : 0;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === '') continue;
+    const indent = line.match(/^(\s*)/)[1].length;
+    if (indent <= baseIndent) return i;
   }
+  return lines.length;
 }
 
-function extractFunction(node, ctx) {
-  const nameNode = node.childForFieldName('name');
-  const paramsNode = node.childForFieldName('parameters');
-  const returnTypeNode = node.childForFieldName('return_type');
-  const isAsync = node.type === 'function_definition' && node.text.startsWith('async');
-
-  if (nameNode) {
-    ctx.functions.push({
-      name: nameNode.text,
-      params: extractParams(paramsNode),
-      returnType: returnTypeNode ? returnTypeNode.text : null,
-      isExported: !nameNode.text.startsWith('_'),
-      isAsync,
-      lineStart: node.startPosition.row + 1,
-      lineEnd: node.endPosition.row + 1,
-      calls: [],
-    });
+function extractCalls(body) {
+  const calls = new Set();
+  const m = body.matchAll(/\b(\w+)\s*\(/g);
+  const keywords = new Set(['if', 'for', 'while', 'def', 'class', 'return', 'import', 'from', 'with', 'as', 'not', 'and', 'or', 'in', 'is', 'elif', 'else', 'try', 'except', 'finally', 'raise', 'del', 'lambda', 'yield', 'async', 'await', 'pass', 'break', 'continue', 'print']);
+  for (const match of m) {
+    const name = match[1];
+    if (!keywords.has(name) && name.length > 1) calls.add(name);
   }
+  return [...calls];
 }
 
-function extractClass(node, ctx) {
-  const nameNode = node.childForFieldName('name');
-  const bodyNode = node.childForFieldName('body');
-
-  let superclass = null;
-  const superclassNode = node.childForFieldName('superclasses');
-  if (superclassNode && superclassNode.childCount > 0) {
-    for (let i = 0; i < superclassNode.childCount; i++) {
-      const child = superclassNode.child(i);
-      if (child.type === 'identifier') {
-        superclass = child.text;
-        break;
-      }
-    }
-  }
-
-  if (nameNode) {
-    const methods = [];
-    if (bodyNode) {
-      for (let i = 0; i < bodyNode.childCount; i++) {
-        const child = bodyNode.child(i);
-        if (child.type === 'function_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) {
-  // import module
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child.type === 'dotted_name') {
-      ctx.imports.push({
-        module: child.text,
-        specifiers: [child.text],
-      });
-    } else if (child.type === 'aliased_import') {
-      const nameNode = child.childForFieldName('name');
-      if (nameNode) {
-        ctx.imports.push({
-          module: nameNode.text,
-          specifiers: [nameNode.text],
-        });
-      }
-    }
-  }
-}
-
-function extractFromImport(node, ctx) {
-  // from module import ...
-  const moduleNode = node.childForFieldName('module_name');
-  if (!moduleNode) return;
-
-  const specifiers = [];
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child.type === 'dotted_name' && child !== moduleNode) {
-      specifiers.push(child.text);
-    } else if (child.type === 'aliased_import') {
-      const nameNode = child.childForFieldName('name');
-      if (nameNode) specifiers.push(nameNode.text);
-    }
-  }
-
-  ctx.imports.push({
-    module: moduleNode.text,
-    specifiers,
-  });
-}
-
-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') {
-      if (child.text !== 'self' && child.text !== 'cls') {
-        params.push({ name: child.text, type: null });
-      }
-    } else if (child.type === 'typed_parameter') {
-      const nameNode = child.childCount > 0 ? child.child(0) : null;
-      const typeNode = child.childForFieldName('type');
-      if (nameNode && nameNode.text !== 'self' && nameNode.text !== 'cls') {
-        params.push({
-          name: nameNode.text,
-          type: typeNode ? typeNode.text : null,
-        });
-      }
-    } else if (child.type === 'default_parameter') {
-      const nameNode = child.childForFieldName('name');
-      if (nameNode && nameNode.text !== 'self' && nameNode.text !== 'cls') {
-        params.push({ name: nameNode.text, type: null });
-      }
-    }
-  }
-  return params;
-}
+module.exports = { parse };