legacyver 2.1.0 → 2.1.2

package/src/parser/ast/go.js

@@ -1,236 +1,117 @@
-/**
- * Go AST parser using web-tree-sitter.
- * Extracts functions, structs, interfaces, import blocks.
- */
+'use strict';
 
-import { initTreeSitter, loadLanguage, createParser } from './tree-sitter-init.js';
-import { parseGeneric } from './generic.js';
-
-let goParser = null;
-let goInitialized = false;
-
-async function ensureParser() {
-  if (goInitialized) return goParser;
-  goInitialized = true;
-
-  const Parser = await initTreeSitter();
-  if (!Parser) return null;
-
-  const language = await loadLanguage('go');
-  if (!language) return null;
-
-  goParser = createParser(language);
-  return goParser;
-}
-
-/**
- * Parse a Go 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 parseGo(source, relativePath) {
-  const parser = await ensureParser();
-
-  if (!parser) {
-    return parseGeneric(source, relativePath, 'go');
-  }
-
-  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 = []; // structs/interfaces in Go
   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 });
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Imports
+    let m = trimmed.match(/^import\s+"([^"]+)"/);
+    if (m) { imports.push({ module: m[1], specifiers: [] }); continue; }
+
+    // Import blocks
+    if (trimmed === 'import (') {
+      i++;
+      while (i < lines.length && lines[i].trim() !== ')') {
+        const imp = lines[i].trim().replace(/['"]/g, '').split(/\s+/).pop();
+        if (imp) imports.push({ module: imp, specifiers: [] });
+        i++;
+      }
+      continue;
+    }
 
-  // In Go, exported names start with uppercase
-  for (const fn of functions) {
-    if (fn.name[0] === fn.name[0].toUpperCase() && fn.name[0] !== fn.name[0].toLowerCase()) {
-      fn.isExported = true;
-      exports.push(fn.name);
+    // Struct / Interface
+    m = trimmed.match(/^type\s+(\w+)\s+(struct|interface)\s*\{/);
+    if (m) {
+      classes.push({ name: m[1], methods: [], extends: null });
+      continue;
     }
-  }
-  for (const cls of classes) {
-    if (cls.name[0] === cls.name[0].toUpperCase()) {
-      exports.push(cls.name);
+
+    // Functions and methods
+    m = trimmed.match(/^func\s+(?:\((\w+)\s+\*?(\w+)\)\s+)?(\w+)\s*\(([^)]*)\)(?:\s+(?:\(([^)]*)\)|(\w+)))?\s*\{/);
+    if (m) {
+      const receiver = m[2] || null;
+      const name = m[3];
+      const paramsStr = m[4] || '';
+      const params = paramsStr.split(',').map(p => {
+        const parts = p.trim().split(/\s+/);
+        return { name: parts[0] || '', type: parts[1] || null };
+      }).filter(p => p.name);
+      const returnType = m[5] || m[6] || null;
+      const isExported = /^[A-Z]/.test(name); // Go export convention
+      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,
+        isAsync: false,
+        receiver,
+        lineStart: i + 1,
+        lineEnd,
+        calls: extractCalls(body),
+        ...complexity,
+        bodySnippet: snippet.bodySnippet,
+        bodySnippetTruncated: snippet.bodySnippetTruncated,
+      });
+      if (receiver) {
+        const cls = classes.find(c => c.name === receiver);
+        if (cls) cls.methods.push(name);
+      }
     }
   }
 
+  const exportedFns = functions.filter(f => f.isExported).map(f => f.name);
+
   return {
     relativePath,
     language: 'go',
-    linesOfCode,
-    parserType: 'tree-sitter',
+    linesOfCode: lines.length,
     functions,
     classes,
     imports,
-    exports,
+    exports: exportedFns,
     callsTo: [],
     calledBy: [],
-    hash: '',
+    hash: null,
+    parserType: 'ast',
   };
 }
 
-function walkNode(node, ctx) {
-  switch (node.type) {
-    case 'function_declaration':
-      extractFunction(node, ctx);
-      break;
-    case 'method_declaration':
-      extractMethod(node, ctx);
-      break;
-    case 'type_declaration':
-      extractTypeDecl(node, ctx);
-      break;
-    case 'import_declaration':
-      extractImport(node, ctx);
-      break;
-  }
-
-  for (let i = 0; i < node.childCount; i++) {
-    walkNode(node.child(i), ctx);
-  }
-}
-
-function extractFunction(node, ctx) {
-  const nameNode = node.childForFieldName('name');
-  const paramsNode = node.childForFieldName('parameters');
-  const resultNode = node.childForFieldName('result');
-
-  if (nameNode) {
-    ctx.functions.push({
-      name: nameNode.text,
-      params: extractParams(paramsNode),
-      returnType: resultNode ? resultNode.text : null,
-      isExported: false, // determined later by capitalization
-      isAsync: false,
-      lineStart: node.startPosition.row + 1,
-      lineEnd: node.endPosition.row + 1,
-      calls: [],
-    });
-  }
-}
-
-function extractMethod(node, ctx) {
-  const nameNode = node.childForFieldName('name');
-  const paramsNode = node.childForFieldName('parameters');
-  const resultNode = node.childForFieldName('result');
-
-  if (nameNode) {
-    // Get receiver type
-    let receiver = null;
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
-      if (child.type === 'parameter_list' && child !== paramsNode) {
-        receiver = child.text;
-        break;
+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;
       }
     }
-
-    ctx.functions.push({
-      name: nameNode.text,
-      params: extractParams(paramsNode),
-      returnType: resultNode ? resultNode.text : null,
-      isExported: false,
-      isAsync: false,
-      lineStart: node.startPosition.row + 1,
-      lineEnd: node.endPosition.row + 1,
-      calls: [],
-      receiver,
-    });
   }
+  return lines.length;
 }
 
-function extractTypeDecl(node, ctx) {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child.type === 'type_spec') {
-      const nameNode = child.childForFieldName('name');
-      const typeNode = child.childForFieldName('type');
-
-      if (nameNode && typeNode) {
-        if (typeNode.type === 'struct_type') {
-          const methods = [];
-          ctx.classes.push({
-            name: nameNode.text,
-            methods,
-            extends: null,
-            kind: 'struct',
-          });
-        } else if (typeNode.type === 'interface_type') {
-          const methods = [];
-          for (let j = 0; j < typeNode.childCount; j++) {
-            const member = typeNode.child(j);
-            if (member.type === 'method_spec') {
-              const methodName = member.childForFieldName('name');
-              if (methodName) methods.push(methodName.text);
-            }
-          }
-          ctx.classes.push({
-            name: nameNode.text,
-            methods,
-            extends: null,
-            kind: 'interface',
-          });
-        }
-      }
-    }
+function extractCalls(body) {
+  const calls = new Set();
+  const keywords = new Set(['if', 'for', 'range', 'switch', 'case', 'return', 'defer', 'go', 'select', 'func', 'var', 'const', 'type', 'struct', 'interface', 'map', 'chan', 'make', 'new', 'len', 'cap', 'append', 'copy', 'delete', 'close', 'panic', 'recover', 'print', 'println', 'error']);
+  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];
 }
 
-function extractImport(node, ctx) {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child.type === 'import_spec_list') {
-      for (let j = 0; j < child.childCount; j++) {
-        const spec = child.child(j);
-        if (spec.type === 'import_spec') {
-          const pathNode = spec.childForFieldName('path');
-          if (pathNode) {
-            ctx.imports.push({
-              module: pathNode.text.replace(/"/g, ''),
-              specifiers: [],
-            });
-          }
-        }
-      }
-    } else if (child.type === 'import_spec') {
-      const pathNode = child.childForFieldName('path');
-      if (pathNode) {
-        ctx.imports.push({
-          module: pathNode.text.replace(/"/g, ''),
-          specifiers: [],
-        });
-      }
-    } else if (child.type === 'interpreted_string_literal') {
-      ctx.imports.push({
-        module: child.text.replace(/"/g, ''),
-        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 === 'parameter_declaration') {
-      const nameNode = child.childForFieldName('name');
-      const typeNode = child.childForFieldName('type');
-      if (nameNode) {
-        params.push({
-          name: nameNode.text,
-          type: typeNode ? typeNode.text : null,
-        });
-      }
-    }
-  }
-  return params;
-}
+module.exports = { parse };

package/src/parser/ast/java.js

@@ -1,173 +1,103 @@
-/**
- * Java AST parser using web-tree-sitter.
- * Extracts methods, class hierarchy, import statements.
- */
+'use strict';
 
-import { initTreeSitter, loadLanguage, createParser } from './tree-sitter-init.js';
-import { parseGeneric } from './generic.js';
-
-let javaParser = null;
-let javaInitialized = false;
-
-async function ensureParser() {
-  if (javaInitialized) return javaParser;
-  javaInitialized = true;
-
-  const Parser = await initTreeSitter();
-  if (!Parser) return null;
-
-  const language = await loadLanguage('java');
-  if (!language) return null;
-
-  javaParser = createParser(language);
-  return javaParser;
-}
-
-/**
- * Parse a Java 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 parseJava(source, relativePath) {
-  const parser = await ensureParser();
-
-  if (!parser) {
-    return parseGeneric(source, relativePath, 'java');
-  }
-
-  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 });
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Imports
+    let m = trimmed.match(/^import\s+([\w.]+(?:\s*,\s*[\w.]+)*)/);
+    if (m) { m[1].split(',').forEach(imp => imports.push({ module: imp.trim(), specifiers: [] })); continue; }
+    m = trimmed.match(/^import\s+[\w.]+\.\{([^}]+)\}/);
+    if (m) { imports.push({ module: trimmed.replace(/^import\s+/, '').split('.')[0], specifiers: m[1].split(',').map(s => s.trim()) }); continue; }
+
+    // Class
+    m = trimmed.match(/^(?:public\s+|private\s+|abstract\s+)*class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?/);
+    if (m) {
+      classes.push({ name: m[1], methods: [], extends: m[2] || null });
+      continue;
+    }
+
+    // Methods
+    m = trimmed.match(/^(?:(public|private|protected|static|final|abstract|synchronized)\s+)*(?:(\w+(?:<[^>]+>)?)\s+)?(\w+)\s*\(([^)]*)\)\s*(?:throws\s+[\w,\s]+)?\s*\{/);
+    if (m && m[3] && m[3] !== 'if' && m[3] !== 'for' && m[3] !== 'while' && m[3] !== 'switch' && m[3] !== 'catch') {
+      const name = m[3];
+      const visibility = m[1] || 'package';
+      const returnType = m[2] || 'void';
+      const paramsStr = m[4] || '';
+      const params = paramsStr.split(',').map(p => {
+        const parts = p.trim().split(/\s+/);
+        return { name: parts[parts.length - 1] || '', type: parts[parts.length - 2] || null };
+      }).filter(p => p.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,
+        isExported: visibility === 'public',
+        isAsync: false,
+        lineStart: i + 1,
+        lineEnd,
+        calls: extractCalls(body),
+        ...complexity,
+        bodySnippet: snippet.bodySnippet,
+        bodySnippetTruncated: snippet.bodySnippetTruncated,
+      });
+      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: 'java',
-    linesOfCode,
-    parserType: 'tree-sitter',
+    linesOfCode: lines.length,
     functions,
     classes,
     imports,
-    exports: classes.map((c) => c.name),
+    exports: publicFns,
     callsTo: [],
     calledBy: [],
-    hash: '',
+    hash: null,
+    parserType: 'ast',
   };
 }
 
-function walkNode(node, ctx) {
-  switch (node.type) {
-    case 'class_declaration':
-      extractClass(node, ctx);
-      return; // Don't recurse further; extractClass handles methods
-    case 'import_declaration':
-      extractImport(node, ctx);
-      break;
-  }
-
-  for (let i = 0; i < node.childCount; i++) {
-    walkNode(node.child(i), ctx);
-  }
-}
-
-function extractClass(node, ctx) {
-  const nameNode = node.childForFieldName('name');
-  const superclassNode = node.childForFieldName('superclass');
-  const bodyNode = node.childForFieldName('body');
-
-  if (!nameNode) return;
-
-  const methods = [];
-  const className = nameNode.text;
-  let superclass = superclassNode ? superclassNode.text : null;
-
-  if (bodyNode) {
-    for (let i = 0; i < bodyNode.childCount; i++) {
-      const child = bodyNode.child(i);
-      if (child.type === 'method_declaration' || child.type === 'constructor_declaration') {
-        const method = extractMethod(child, className);
-        if (method) {
-          methods.push(method.name);
-          ctx.functions.push(method);
-        }
+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;
       }
     }
   }
-
-  ctx.classes.push({
-    name: className,
-    methods,
-    extends: superclass,
-  });
-}
-
-function extractMethod(node, className) {
-  const nameNode = node.childForFieldName('name');
-  const paramsNode = node.childForFieldName('parameters');
-  const typeNode = node.childForFieldName('type');
-
-  // Detect visibility
-  let visibility = 'package';
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child.type === 'modifiers') {
-      if (child.text.includes('public')) visibility = 'public';
-      else if (child.text.includes('private')) visibility = 'private';
-      else if (child.text.includes('protected')) visibility = 'protected';
-    }
-  }
-
-  const name = nameNode ? nameNode.text : (node.type === 'constructor_declaration' ? className : null);
-  if (!name) return null;
-
-  return {
-    name,
-    params: extractParams(paramsNode),
-    returnType: typeNode ? typeNode.text : (node.type === 'constructor_declaration' ? className : 'void'),
-    isExported: visibility === 'public',
-    isAsync: false,
-    lineStart: node.startPosition.row + 1,
-    lineEnd: node.endPosition.row + 1,
-    calls: [],
-    visibility,
-  };
+  return lines.length;
 }
 
-function extractImport(node, ctx) {
-  const text = node.text;
-  const match = text.match(/import\s+([\w.]+(?:\.\*)?)\s*;/);
-  if (match) {
-    const parts = match[1].split('.');
-    ctx.imports.push({
-      module: match[1],
-      specifiers: [parts[parts.length - 1]],
-    });
+function extractCalls(body) {
+  const calls = new Set();
+  const keywords = new Set(['if', 'for', 'while', 'switch', 'catch', 'new', 'return', 'throw', 'instanceof', 'class', 'void', 'int', 'long', 'double', 'float', 'boolean', 'String', 'System', 'else', 'try', 'finally']);
+  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];
 }
 
-function extractParams(paramsNode) {
-  if (!paramsNode) return [];
-  const params = [];
-  for (let i = 0; i < paramsNode.childCount; i++) {
-    const child = paramsNode.child(i);
-    if (child.type === 'formal_parameter') {
-      const nameNode = child.childForFieldName('name');
-      const typeNode = child.childForFieldName('type');
-      if (nameNode) {
-        params.push({
-          name: nameNode.text,
-          type: typeNode ? typeNode.text : null,
-        });
-      }
-    }
-  }
-  return params;
-}
+module.exports = { parse };