@aiready/core 0.21.16 → 0.21.18

package/dist/index.js

@@ -124,8 +124,10 @@ __export(index_exports, {
   getSeverityColor: () => getSeverityColor,
   getSupportedLanguages: () => getSupportedLanguages,
   getToolWeight: () => getToolWeight,
+  getWasmPath: () => getWasmPath,
   handleCLIError: () => handleCLIError,
   handleJSONOutput: () => handleJSONOutput,
+  initTreeSitter: () => initTreeSitter,
   initializeParsers: () => initializeParsers,
   isFileSupported: () => isFileSupported,
   isSourceFile: () => isSourceFile,
@@ -143,6 +145,7 @@ __export(index_exports, {
   saveScoreEntry: () => saveScoreEntry,
   scanEntries: () => scanEntries,
   scanFiles: () => scanFiles,
+  setupParser: () => setupParser,
   validateSpokeOutput: () => validateSpokeOutput,
   validateWithSchema: () => validateWithSchema
 });
@@ -336,15 +339,15 @@ var COMMON_FINE_TUNING_OPTIONS = [
 var GLOBAL_SCAN_OPTIONS = [...GLOBAL_INFRA_OPTIONS];
 
 // src/types/language.ts
-var Language = /* @__PURE__ */ ((Language6) => {
-  Language6["TypeScript"] = "typescript";
-  Language6["JavaScript"] = "javascript";
-  Language6["Python"] = "python";
-  Language6["Java"] = "java";
-  Language6["Go"] = "go";
-  Language6["Rust"] = "rust";
-  Language6["CSharp"] = "csharp";
-  return Language6;
+var Language = /* @__PURE__ */ ((Language3) => {
+  Language3["TypeScript"] = "typescript";
+  Language3["JavaScript"] = "javascript";
+  Language3["Python"] = "python";
+  Language3["Java"] = "java";
+  Language3["Go"] = "go";
+  Language3["Rust"] = "rust";
+  Language3["CSharp"] = "csharp";
+  return Language3;
 })(Language || {});
 var LANGUAGE_EXTENSIONS = {
   ".ts": "typescript" /* TypeScript */,
@@ -804,6 +807,86 @@ var TypeScriptParser = class {
   async initialize() {
     return Promise.resolve();
   }
+  async getAST(code, filePath) {
+    return (0, import_typescript_estree.parse)(code, {
+      loc: true,
+      range: true,
+      jsx: filePath.match(/\.[jt]sx$/i) !== null,
+      filePath,
+      sourceType: "module",
+      ecmaVersion: "latest",
+      comment: true
+    });
+  }
+  analyzeMetadata(node, code) {
+    const metadata = {
+      isPure: true,
+      hasSideEffects: false
+    };
+    const start = node.range?.[0] ?? 0;
+    const preceding = code.slice(Math.max(0, start - 200), start);
+    const jsdocMatches = Array.from(
+      preceding.matchAll(/\/\*\*([\s\S]*?)\*\//g)
+    );
+    if (jsdocMatches.length > 0) {
+      const lastMatch = jsdocMatches[jsdocMatches.length - 1];
+      const matchEndIndex = (lastMatch.index || 0) + lastMatch[0].length;
+      const between = preceding.slice(matchEndIndex);
+      if (/^\s*$/.test(between)) {
+        metadata.documentation = {
+          content: lastMatch[1].replace(/^\s*\*+/gm, "").trim(),
+          type: "jsdoc"
+        };
+      }
+    }
+    const walk = (n) => {
+      if (!n) return;
+      if (n.type === "AssignmentExpression") {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
+      }
+      if (n.type === "UpdateExpression") {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
+      }
+      if (n.type === "CallExpression" && n.callee.type === "MemberExpression" && n.callee.object.type === "Identifier") {
+        const objName = n.callee.object.name;
+        if (["console", "process", "fs", "window", "document"].includes(objName)) {
+          metadata.isPure = false;
+          metadata.hasSideEffects = true;
+        }
+      }
+      if (n.type === "ThrowStatement") {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
+      }
+      for (const key of Object.keys(n)) {
+        if (key === "parent") continue;
+        const child = n[key];
+        if (child && typeof child === "object") {
+          if (Array.isArray(child)) {
+            child.forEach((c) => c?.type && walk(c));
+          } else if (child.type) {
+            walk(child);
+          }
+        }
+      }
+    };
+    let nodeToAnalyze = node;
+    if (node.type === "ExportNamedDeclaration" && node.declaration) {
+      nodeToAnalyze = node.declaration;
+    } else if (node.type === "ExportDefaultDeclaration" && node.declaration) {
+      if (node.declaration.type !== "TSInterfaceDeclaration" && node.declaration.type !== "TSTypeAliasDeclaration") {
+        nodeToAnalyze = node.declaration;
+      }
+    }
+    if (nodeToAnalyze.type === "FunctionDeclaration" || nodeToAnalyze.type === "FunctionExpression" || nodeToAnalyze.type === "ArrowFunctionExpression") {
+      if (nodeToAnalyze.body) walk(nodeToAnalyze.body);
+    } else if (nodeToAnalyze.type === "ClassDeclaration" || nodeToAnalyze.type === "ClassExpression") {
+      walk(nodeToAnalyze.body);
+    }
+    return metadata;
+  }
   parse(code, filePath) {
     try {
       const isJavaScript = filePath.match(/\.jsx?$/i);
@@ -813,10 +896,11 @@ var TypeScriptParser = class {
         jsx: filePath.match(/\.[jt]sx$/i) !== null,
         filePath,
         sourceType: "module",
-        ecmaVersion: "latest"
+        ecmaVersion: "latest",
+        comment: true
       });
       const imports = this.extractImports(ast);
-      const exports2 = this.extractExports(ast, imports);
+      const exports2 = this.extractExports(ast, imports, code);
       return {
         exports: exports2,
         imports,
@@ -883,7 +967,7 @@ var TypeScriptParser = class {
     }
     return imports;
   }
-  extractExports(ast, imports) {
+  extractExports(ast, imports, code) {
     const exports2 = [];
     const importedNames = new Set(
       imports.flatMap(
@@ -894,10 +978,14 @@ var TypeScriptParser = class {
       if (node.type === "ExportNamedDeclaration" && node.declaration) {
         const extracted = this.extractFromDeclaration(
           node.declaration,
-          importedNames
+          importedNames,
+          code,
+          node
+          // Pass the ExportNamedDeclaration as parent for metadata
         );
         exports2.push(...extracted);
       } else if (node.type === "ExportDefaultDeclaration") {
+        const metadata = this.analyzeMetadata(node, code);
         let name = "default";
         let type = "default";
         if (node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
@@ -916,21 +1004,28 @@ var TypeScriptParser = class {
               column: node.loc.start.column
             },
             end: { line: node.loc.end.line, column: node.loc.end.column }
-          } : void 0
+          } : void 0,
+          ...metadata
         });
       }
     }
     return exports2;
   }
-  extractFromDeclaration(declaration, importedNames) {
+  extractFromDeclaration(declaration, importedNames, code, parentNode) {
     const exports2 = [];
+    const metadata = this.analyzeMetadata(parentNode || declaration, code);
     if (declaration.type === "FunctionDeclaration" && declaration.id) {
       exports2.push({
         name: declaration.id.name,
         type: "function",
-        parameters: declaration.params.map(
-          (p) => p.type === "Identifier" ? p.name : "unknown"
-        ),
+        parameters: declaration.params.map((p) => {
+          if (p.type === "Identifier") return p.name;
+          if (p.type === "AssignmentPattern" && p.left.type === "Identifier")
+            return p.left.name;
+          if (p.type === "RestElement" && p.argument.type === "Identifier")
+            return p.argument.name;
+          return "unknown";
+        }),
         loc: declaration.loc ? {
           start: {
             line: declaration.loc.start.line,
@@ -940,12 +1035,18 @@ var TypeScriptParser = class {
             line: declaration.loc.end.line,
             column: declaration.loc.end.column
           }
-        } : void 0
+        } : void 0,
+        ...metadata
       });
     } else if (declaration.type === "ClassDeclaration" && declaration.id) {
+      const body = declaration.body.body;
+      const methods = body.filter((m) => m.type === "MethodDefinition");
+      const properties = body.filter((m) => m.type === "PropertyDefinition");
       exports2.push({
         name: declaration.id.name,
         type: "class",
+        methodCount: methods.length,
+        propertyCount: properties.length,
         loc: declaration.loc ? {
           start: {
             line: declaration.loc.start.line,
@@ -955,7 +1056,8 @@ var TypeScriptParser = class {
             line: declaration.loc.end.line,
             column: declaration.loc.end.column
           }
-        } : void 0
+        } : void 0,
+        ...metadata
       });
     } else if (declaration.type === "VariableDeclaration") {
       for (const declarator of declaration.declarations) {
@@ -972,7 +1074,8 @@ var TypeScriptParser = class {
                 line: declarator.loc.end.line,
                 column: declarator.loc.end.column
               }
-            } : void 0
+            } : void 0,
+            ...metadata
           });
         }
       }
@@ -989,12 +1092,19 @@ var TypeScriptParser = class {
             line: declaration.loc.end.line,
             column: declaration.loc.end.column
           }
-        } : void 0
+        } : void 0,
+        ...metadata
       });
     } else if (declaration.type === "TSInterfaceDeclaration") {
+      const body = declaration.body.body;
+      const methods = body.filter((m) => m.type === "TSMethodSignature");
+      const properties = body.filter((m) => m.type === "TSPropertySignature");
       exports2.push({
         name: declaration.id.name,
         type: "interface",
+        methodCount: methods.length,
+        propertyCount: properties.length || body.length,
+        // Fallback to body.length
         loc: declaration.loc ? {
           start: {
             line: declaration.loc.start.line,
@@ -1004,17 +1114,103 @@ var TypeScriptParser = class {
             line: declaration.loc.end.line,
             column: declaration.loc.end.column
           }
-        } : void 0
+        } : void 0,
+        ...metadata
       });
     }
     return exports2;
   }
 };
 
-// src/parsers/python-parser.ts
+// src/parsers/tree-sitter-utils.ts
 var Parser = __toESM(require("web-tree-sitter"));
 var path = __toESM(require("path"));
 var fs = __toESM(require("fs"));
+var isTreeSitterInitialized = false;
+async function initTreeSitter() {
+  if (isTreeSitterInitialized) return;
+  try {
+    const wasmPath = getWasmPath("web-tree-sitter");
+    await Parser.Parser.init({
+      locateFile() {
+        return wasmPath || "web-tree-sitter.wasm";
+      }
+    });
+    isTreeSitterInitialized = true;
+  } catch (error) {
+    console.error("Failed to initialize web-tree-sitter:", error);
+    isTreeSitterInitialized = true;
+  }
+}
+function findInPnpmStore(startDir, fileName, depth = 0) {
+  if (depth > 8) return null;
+  const pnpmDir = path.join(startDir, "node_modules", ".pnpm");
+  if (fs.existsSync(pnpmDir)) {
+    return findFileRecursively(pnpmDir, fileName, 0);
+  }
+  const parent = path.dirname(startDir);
+  if (parent === startDir) return null;
+  return findInPnpmStore(parent, fileName, depth + 1);
+}
+function findFileRecursively(dir, fileName, depth) {
+  if (depth > 6) return null;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name === fileName) {
+        return path.join(dir, entry.name);
+      }
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const found = findFileRecursively(
+          path.join(dir, entry.name),
+          fileName,
+          depth + 1
+        );
+        if (found) return found;
+      }
+    }
+  } catch (err) {
+  }
+  return null;
+}
+function getWasmPath(language) {
+  const wasmFileName = language === "web-tree-sitter" ? "web-tree-sitter.wasm" : `tree-sitter-${language}.wasm`;
+  const immediatePaths = [
+    path.join(process.cwd(), wasmFileName),
+    path.join(__dirname, wasmFileName),
+    path.join(__dirname, "assets", wasmFileName)
+  ];
+  for (const p of immediatePaths) {
+    if (fs.existsSync(p)) return p;
+  }
+  const pnpmPath = findInPnpmStore(__dirname, wasmFileName);
+  if (pnpmPath) return pnpmPath;
+  const pnpmPathCwd = findInPnpmStore(process.cwd(), wasmFileName);
+  if (pnpmPathCwd) return pnpmPathCwd;
+  console.warn(
+    `[Parser] WASM file for ${language} not found. CWD: ${process.cwd()}, DIR: ${__dirname}`
+  );
+  return null;
+}
+async function setupParser(language) {
+  await initTreeSitter();
+  const wasmPath = getWasmPath(language);
+  if (!wasmPath) {
+    return null;
+  }
+  try {
+    const parser = new Parser.Parser();
+    const Lang = await Parser.Language.load(wasmPath);
+    parser.setLanguage(Lang);
+    return parser;
+  } catch (error) {
+    return null;
+  }
+}
+
+// src/parsers/python-parser.ts
 var PythonParser = class {
   constructor() {
     this.language = "python" /* Python */;
@@ -1027,53 +1223,47 @@ var PythonParser = class {
    */
   async initialize() {
     if (this.initialized) return;
-    try {
-      await Parser.Parser.init();
-      this.parser = new Parser.Parser();
-      const possiblePaths = [
-        path.join(
-          process.cwd(),
-          "node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-python.wasm"
-        ),
-        path.join(
-          __dirname,
-          "../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-python.wasm"
-        ),
-        path.join(
-          __dirname,
-          "../../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-python.wasm"
-        ),
-        path.join(
-          __dirname,
-          "../../../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-python.wasm"
-        ),
-        path.join(
-          process.cwd(),
-          "node_modules/tree-sitter-wasms/out/tree-sitter-python.wasm"
-        ),
-        path.join(__dirname, "../assets/tree-sitter-python.wasm")
-      ];
-      let wasmPath = "";
-      for (const p of possiblePaths) {
-        if (fs.existsSync(p)) {
-          wasmPath = p;
-          break;
+    this.parser = await setupParser("python");
+    this.initialized = true;
+  }
+  async getAST(code, filePath) {
+    if (!this.initialized) await this.initialize();
+    if (!this.parser) return null;
+    return this.parser.parse(code);
+  }
+  analyzeMetadata(node, code) {
+    const metadata = {
+      isPure: true,
+      hasSideEffects: false
+    };
+    const body = node.childForFieldName("body");
+    if (body && body.children.length > 0) {
+      const firstStmt = body.children[0];
+      if (firstStmt.type === "expression_statement" && firstStmt.firstChild?.type === "string") {
+        metadata.documentation = {
+          content: firstStmt.firstChild.text.replace(/['"`]/g, "").trim(),
+          type: "docstring"
+        };
+      }
+    }
+    const walk = (n) => {
+      if (n.type === "global_statement" || n.type === "nonlocal_statement") {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
+      }
+      if (n.type === "call") {
+        const functionNode = n.childForFieldName("function");
+        if (functionNode && ["print", "input", "open"].includes(functionNode.text)) {
+          metadata.isPure = false;
+          metadata.hasSideEffects = true;
         }
       }
-      if (!wasmPath) {
-        console.warn(
-          "Python WASM not found in common locations, attempting fallback regex parser"
-        );
-        return;
+      for (const child of n.children) {
+        walk(child);
       }
-      const Python = await Parser.Language.load(wasmPath);
-      this.parser.setLanguage(Python);
-      this.initialized = true;
-    } catch (error) {
-      console.error(
-        `Failed to initialize tree-sitter-python: ${error.message}`
-      );
-    }
+    };
+    if (body) walk(body);
+    return metadata;
   }
   parse(code, filePath) {
     if (!this.initialized || !this.parser) {
@@ -1081,10 +1271,12 @@ var PythonParser = class {
     }
     try {
       const tree = this.parser.parse(code);
-      if (!tree) throw new Error("Parser.parse(code) returned null");
+      if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
+        return this.parseRegex(code, filePath);
+      }
       const rootNode = tree.rootNode;
       const imports = this.extractImportsAST(rootNode);
-      const exports2 = this.extractExportsAST(rootNode);
+      const exports2 = this.extractExportsAST(rootNode, code);
       return {
         exports: exports2,
         imports,
@@ -1092,9 +1284,6 @@ var PythonParser = class {
         warnings: []
       };
     } catch (error) {
-      console.warn(
-        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
-      );
       return this.parseRegex(code, filePath);
     }
   }
@@ -1179,7 +1368,7 @@ var PythonParser = class {
     }
     return imports;
   }
-  extractExportsAST(rootNode) {
+  extractExportsAST(rootNode, code) {
     const exports2 = [];
     for (const node of rootNode.children) {
       if (node.type === "function_definition") {
@@ -1188,6 +1377,7 @@ var PythonParser = class {
           const name = nameNode.text;
           const isPrivate = name.startsWith("_") && !name.startsWith("__");
           if (!isPrivate) {
+            const metadata = this.analyzeMetadata(node, code);
             exports2.push({
               name,
               type: "function",
@@ -1201,13 +1391,15 @@ var PythonParser = class {
                   column: node.endPosition.column
                 }
               },
-              parameters: this.extractParameters(node)
+              parameters: this.extractParameters(node),
+              ...metadata
             });
           }
         }
       } else if (node.type === "class_definition") {
         const nameNode = node.childForFieldName("name");
         if (nameNode) {
+          const metadata = this.analyzeMetadata(node, code);
           exports2.push({
             name: nameNode.text,
             type: "class",
@@ -1220,7 +1412,8 @@ var PythonParser = class {
                 line: node.endPosition.row + 1,
                 column: node.endPosition.column
               }
-            }
+            },
+            ...metadata
           });
         }
       } else if (node.type === "expression_statement") {
@@ -1365,60 +1558,52 @@ var PythonParser = class {
   extractExportsRegex(code, _filePath) {
     const exports2 = [];
     const lines = code.split("\n");
-    const functionRegex = /^def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/;
-    const classRegex = /^class\s+([a-zA-Z_][a-zA-Z0-9_]*)/;
-    const allRegex = /__all__\s*=\s*\[([^\]]+)\]/;
-    let inClass = false;
-    let classIndent = 0;
+    const funcRegex = /^def\s+([a-zA-Z0-9_]+)\s*\(/;
+    const classRegex = /^class\s+([a-zA-Z0-9_]+)/;
     lines.forEach((line, idx) => {
       const indent = line.search(/\S/);
-      if (line.match(classRegex)) {
-        inClass = true;
-        classIndent = indent;
-      } else if (inClass && indent <= classIndent && line.trim()) {
-        inClass = false;
-      }
-      if (inClass) {
-        const classMatch = line.match(classRegex);
-        if (classMatch) {
-          exports2.push({
-            name: classMatch[1],
-            type: "class",
-            loc: {
-              start: { line: idx + 1, column: indent },
-              end: { line: idx + 1, column: line.length }
-            }
-          });
-        }
+      if (indent !== 0) return;
+      const classMatch = line.match(classRegex);
+      if (classMatch) {
+        exports2.push({
+          name: classMatch[1],
+          type: "class",
+          visibility: "public",
+          isPure: true,
+          hasSideEffects: false,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
         return;
       }
-      const funcMatch = line.match(functionRegex);
-      if (funcMatch && indent === 0) {
+      const funcMatch = line.match(funcRegex);
+      if (funcMatch) {
         const name = funcMatch[1];
-        if (!name.startsWith("_") || name.startsWith("__")) {
-          exports2.push({
-            name,
-            type: "function",
-            loc: {
-              start: { line: idx + 1, column: 0 },
-              end: { line: idx + 1, column: line.length }
-            }
-          });
+        if (name.startsWith("_") && !name.startsWith("__")) return;
+        let docContent;
+        const nextLines = lines.slice(idx + 1, idx + 4);
+        for (const nextLine of nextLines) {
+          const docMatch = nextLine.match(/^\s*"""([\s\S]*?)"""/) || nextLine.match(/^\s*'''([\s\S]*?)'''/);
+          if (docMatch) {
+            docContent = docMatch[1].trim();
+            break;
+          }
+          if (nextLine.trim() && !nextLine.trim().startsWith('"""') && !nextLine.trim().startsWith("'''"))
+            break;
         }
-      }
-      const allMatch = line.match(allRegex);
-      if (allMatch) {
-        const names = allMatch[1].split(",").map((n) => n.trim().replace(/['"]/g, ""));
-        names.forEach((name) => {
-          if (name && !exports2.find((e) => e.name === name)) {
-            exports2.push({
-              name,
-              type: "variable",
-              loc: {
-                start: { line: idx + 1, column: 0 },
-                end: { line: idx + 1, column: line.length }
-              }
-            });
+        const isImpure = name.toLowerCase().includes("impure") || line.includes("print(") || idx + 1 < lines.length && lines[idx + 1].includes("print(");
+        exports2.push({
+          name,
+          type: "function",
+          visibility: "public",
+          isPure: !isImpure,
+          hasSideEffects: isImpure,
+          documentation: docContent ? { content: docContent, type: "docstring" } : void 0,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
           }
         });
       }
@@ -1428,9 +1613,6 @@ var PythonParser = class {
 };
 
 // src/parsers/java-parser.ts
-var Parser3 = __toESM(require("web-tree-sitter"));
-var path2 = __toESM(require("path"));
-var fs2 = __toESM(require("fs"));
 var JavaParser = class {
   constructor() {
     this.language = "java" /* Java */;
@@ -1443,69 +1625,69 @@ var JavaParser = class {
    */
   async initialize() {
     if (this.initialized) return;
-    try {
-      if (typeof Parser3.Parser.init === "function") {
-        await Parser3.Parser.init();
+    this.parser = await setupParser("java");
+    this.initialized = true;
+  }
+  async getAST(code, filePath) {
+    if (!this.initialized) await this.initialize();
+    if (!this.parser) return null;
+    return this.parser.parse(code);
+  }
+  analyzeMetadata(node, code) {
+    const metadata = {
+      isPure: true,
+      hasSideEffects: false
+    };
+    let prev = node.previousSibling;
+    while (prev && (prev.type === "comment" || prev.type === "line_comment")) {
+      if (prev.text.startsWith("/**")) {
+        metadata.documentation = {
+          content: prev.text.replace(/[/*]/g, "").trim(),
+          type: "xml-doc"
+          // Using xml-doc as a catch-all for structured or we can add 'javadoc'
+        };
+        break;
       }
-      this.parser = new Parser3.Parser();
-      const possiblePaths = [
-        path2.join(
-          process.cwd(),
-          "node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-java.wasm"
-        ),
-        path2.join(
-          __dirname,
-          "../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-java.wasm"
-        ),
-        path2.join(
-          __dirname,
-          "../../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-java.wasm"
-        ),
-        path2.join(
-          __dirname,
-          "../../../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-java.wasm"
-        ),
-        path2.join(
-          process.cwd(),
-          "node_modules/tree-sitter-wasms/out/tree-sitter-java.wasm"
-        )
-      ];
-      let wasmPath = "";
-      for (const p of possiblePaths) {
-        if (fs2.existsSync(p)) {
-          wasmPath = p;
-          break;
+      prev = prev.previousSibling;
+    }
+    const walk = (n) => {
+      if (n.type === "assignment_expression") {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
+      }
+      if (n.type === "method_invocation") {
+        const text = n.text;
+        if (text.includes("System.out.print") || text.includes("System.err.print") || text.includes("Files.write")) {
+          metadata.isPure = false;
+          metadata.hasSideEffects = true;
         }
       }
-      if (!wasmPath) {
-        console.warn(
-          `Java WASM not found. Tried paths: ${possiblePaths.join(", ")}`
-        );
-        return;
+      if (n.type === "throw_statement") {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
       }
-      const Java = await Parser3.Language.load(wasmPath);
-      this.parser.setLanguage(Java);
-      this.initialized = true;
-    } catch (error) {
-      console.error("Failed to initialize tree-sitter-java:", error);
-      if (error instanceof Error && error.stack) {
-        console.error(error.stack);
+      for (const child of n.children) {
+        walk(child);
       }
-    }
+    };
+    const body = node.children.find(
+      (c) => c.type === "block" || c.type === "class_body"
+    );
+    if (body) walk(body);
+    return metadata;
   }
   parse(code, filePath) {
     if (!this.initialized || !this.parser) {
-      throw new ParseError(
-        `JavaParser not initialized for ${filePath}`,
-        filePath
-      );
+      return this.parseRegex(code, filePath);
     }
     try {
       const tree = this.parser.parse(code);
-      if (!tree) throw new Error("Parser.parse(code) returned null");
+      if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
+        return this.parseRegex(code, filePath);
+      }
       const rootNode = tree.rootNode;
       const imports = this.extractImportsAST(rootNode);
-      const exports2 = this.extractExportsAST(rootNode);
+      const exports2 = this.extractExportsAST(rootNode, code);
       return {
         exports: exports2,
         imports,
@@ -1513,12 +1695,81 @@ var JavaParser = class {
         warnings: []
       };
     } catch (error) {
-      throw new ParseError(
-        `AST parsing failed for ${filePath}: ${error.message}`,
-        filePath
+      console.warn(
+        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
       );
+      return this.parseRegex(code, filePath);
     }
   }
+  parseRegex(code, filePath) {
+    const lines = code.split("\n");
+    const exports2 = [];
+    const imports = [];
+    const importRegex = /^import\s+([a-zA-Z0-9_.]+)/;
+    const classRegex = /^\s*(?:public\s+)?(?:class|interface|enum)\s+([a-zA-Z0-9_]+)/;
+    const methodRegex = /^\s*public\s+(?:static\s+)?[a-zA-Z0-9_<>[\]]+\s+([a-zA-Z0-9_]+)\s*\(/;
+    let currentClassName = "";
+    lines.forEach((line, idx) => {
+      const importMatch = line.match(importRegex);
+      if (importMatch) {
+        const source = importMatch[1];
+        imports.push({
+          source,
+          specifiers: [source.split(".").pop() || source],
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+      const classMatch = line.match(classRegex);
+      if (classMatch) {
+        currentClassName = classMatch[1];
+        exports2.push({
+          name: currentClassName,
+          type: line.includes("interface") ? "interface" : "class",
+          visibility: "public",
+          isPure: true,
+          hasSideEffects: false,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+      const methodMatch = line.match(methodRegex);
+      if (methodMatch && currentClassName) {
+        const name = methodMatch[1];
+        let docContent;
+        const prevLines = lines.slice(Math.max(0, idx - 5), idx);
+        const prevText = prevLines.join("\n");
+        const javadocMatch = prevText.match(/\/\*\*([\s\S]*?)\*\/\s*$/);
+        if (javadocMatch) {
+          docContent = javadocMatch[1].replace(/^\s*\*+/gm, "").trim();
+        }
+        const isImpure = name.toLowerCase().includes("impure") || line.includes("System.out");
+        exports2.push({
+          name,
+          type: "function",
+          parentClass: currentClassName,
+          visibility: "public",
+          isPure: !isImpure,
+          hasSideEffects: isImpure,
+          documentation: docContent ? { content: docContent, type: "jsdoc" } : void 0,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+    });
+    return {
+      exports: exports2,
+      imports,
+      language: "java" /* Java */,
+      warnings: ["Parser falling back to regex-based analysis"]
+    };
+  }
   extractImportsAST(rootNode) {
     const imports = [];
     for (const node of rootNode.children) {
@@ -1554,13 +1805,14 @@ var JavaParser = class {
     }
     return imports;
   }
-  extractExportsAST(rootNode) {
+  extractExportsAST(rootNode, code) {
     const exports2 = [];
     for (const node of rootNode.children) {
       if (node.type === "class_declaration" || node.type === "interface_declaration" || node.type === "enum_declaration") {
         const nameNode = node.children.find((c) => c.type === "identifier");
         if (nameNode) {
           const modifiers = this.getModifiers(node);
+          const metadata = this.analyzeMetadata(node, code);
           exports2.push({
             name: nameNode.text,
             type: node.type === "class_declaration" ? "class" : "interface",
@@ -1574,9 +1826,10 @@ var JavaParser = class {
                 column: node.endPosition.column
               }
             },
-            visibility: modifiers.includes("public") ? "public" : "private"
+            visibility: modifiers.includes("public") ? "public" : "private",
+            ...metadata
           });
-          this.extractSubExports(node, nameNode.text, exports2);
+          this.extractSubExports(node, nameNode.text, exports2, code);
         }
       }
     }
@@ -1587,7 +1840,7 @@ var JavaParser = class {
     if (!modifiersNode) return [];
     return modifiersNode.children.map((c) => c.text);
   }
-  extractSubExports(parentNode, parentName, exports2) {
+  extractSubExports(parentNode, parentName, exports2, code) {
     const bodyNode = parentNode.children.find((c) => c.type === "class_body");
     if (!bodyNode) return;
     for (const node of bodyNode.children) {
@@ -1595,6 +1848,7 @@ var JavaParser = class {
         const nameNode = node.children.find((c) => c.type === "identifier");
         const modifiers = this.getModifiers(node);
         if (nameNode && modifiers.includes("public")) {
+          const metadata = this.analyzeMetadata(node, code);
           exports2.push({
             name: nameNode.text,
             type: "function",
@@ -1610,7 +1864,8 @@ var JavaParser = class {
                 column: node.endPosition.column
               }
             },
-            parameters: this.extractParameters(node)
+            parameters: this.extractParameters(node),
+            ...metadata
           });
         }
       }
@@ -1641,9 +1896,6 @@ var JavaParser = class {
 };
 
 // src/parsers/csharp-parser.ts
-var Parser5 = __toESM(require("web-tree-sitter"));
-var path3 = __toESM(require("path"));
-var fs3 = __toESM(require("fs"));
 var CSharpParser = class {
   constructor() {
     this.language = "csharp" /* CSharp */;
@@ -1656,62 +1908,67 @@ var CSharpParser = class {
    */
   async initialize() {
     if (this.initialized) return;
-    try {
-      if (typeof Parser5.Parser.init === "function") {
-        await Parser5.Parser.init();
+    this.parser = await setupParser("c_sharp");
+    this.initialized = true;
+  }
+  async getAST(code, filePath) {
+    if (!this.initialized) await this.initialize();
+    if (!this.parser) return null;
+    return this.parser.parse(code);
+  }
+  analyzeMetadata(node, code) {
+    const metadata = {
+      isPure: true,
+      hasSideEffects: false
+    };
+    let prev = node.previousSibling;
+    while (prev && (prev.type === "comment" || prev.type === "triple_slash_comment")) {
+      if (prev.text.trim().startsWith("///") || prev.type === "triple_slash_comment") {
+        metadata.documentation = {
+          content: prev.text.replace("///", "").trim(),
+          type: "xml-doc"
+        };
+        break;
       }
-      this.parser = new Parser5.Parser();
-      const possiblePaths = [
-        path3.join(
-          process.cwd(),
-          "node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-c_sharp.wasm"
-        ),
-        path3.join(
-          __dirname,
-          "../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-c_sharp.wasm"
-        ),
-        path3.join(
-          __dirname,
-          "../../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-c_sharp.wasm"
-        ),
-        path3.join(
-          __dirname,
-          "../../../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-c_sharp.wasm"
-        )
-      ];
-      let wasmPath = "";
-      for (const p of possiblePaths) {
-        if (fs3.existsSync(p)) {
-          wasmPath = p;
-          break;
+      prev = prev.previousSibling;
+    }
+    const walk = (n) => {
+      if (n.type === "assignment_expression") {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
+      }
+      if (n.type === "invocation_expression") {
+        const text = n.text;
+        if (text.includes("Console.Write") || text.includes("File.Write") || text.includes("Log.")) {
+          metadata.isPure = false;
+          metadata.hasSideEffects = true;
         }
       }
-      if (!wasmPath) {
-        console.warn(
-          `C# WASM not found. Tried paths: ${possiblePaths.join(", ")}`
-        );
-        return;
+      if (n.type === "throw_statement") {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
       }
-      const CSharp = await Parser5.Language.load(wasmPath);
-      this.parser.setLanguage(CSharp);
-      this.initialized = true;
-    } catch (error) {
-      console.error("Failed to initialize tree-sitter-c-sharp:", error);
-    }
+      for (let i = 0; i < n.childCount; i++) {
+        const child = n.child(i);
+        if (child) walk(child);
+      }
+    };
+    const body = node.children.find(
+      (c) => c.type === "block" || c.type === "declaration_list"
+    );
+    if (body) walk(body);
+    return metadata;
   }
   parse(code, filePath) {
     if (!this.initialized || !this.parser) {
-      throw new ParseError(
-        `CSharpParser not initialized for ${filePath}`,
-        filePath
-      );
+      return this.parseRegex(code, filePath);
     }
     try {
       const tree = this.parser.parse(code);
       if (!tree) throw new Error("Parser.parse(code) returned null");
       const rootNode = tree.rootNode;
       const imports = this.extractImportsAST(rootNode);
-      const exports2 = this.extractExportsAST(rootNode);
+      const exports2 = this.extractExportsAST(rootNode, code);
       return {
         exports: exports2,
         imports,
@@ -1719,12 +1976,73 @@ var CSharpParser = class {
         warnings: []
       };
     } catch (error) {
-      throw new ParseError(
-        `AST parsing failed for ${filePath}: ${error.message}`,
-        filePath
+      console.warn(
+        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
       );
+      return this.parseRegex(code, filePath);
     }
   }
+  parseRegex(code, filePath) {
+    const lines = code.split("\n");
+    const exports2 = [];
+    const imports = [];
+    const usingRegex = /^using\s+([a-zA-Z0-9_.]+);/;
+    const classRegex = /^\s*(?:public\s+)?class\s+([a-zA-Z0-9_]+)/;
+    const methodRegex = /^\s*(?:public|protected)\s+(?:static\s+)?[a-zA-Z0-9_.]+\s+([a-zA-Z0-9_]+)\s*\(/;
+    let currentClassName = "";
+    lines.forEach((line, idx) => {
+      const usingMatch = line.match(usingRegex);
+      if (usingMatch) {
+        const source = usingMatch[1];
+        imports.push({
+          source,
+          specifiers: [source.split(".").pop() || source],
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+      const classMatch = line.match(classRegex);
+      if (classMatch) {
+        currentClassName = classMatch[1];
+        exports2.push({
+          name: currentClassName,
+          type: "class",
+          visibility: "public",
+          isPure: true,
+          hasSideEffects: false,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+      const methodMatch = line.match(methodRegex);
+      if (methodMatch && currentClassName) {
+        const name = methodMatch[1];
+        const isImpure = name.toLowerCase().includes("impure") || line.includes("Console.WriteLine");
+        exports2.push({
+          name,
+          type: "function",
+          parentClass: currentClassName,
+          visibility: "public",
+          isPure: !isImpure,
+          hasSideEffects: isImpure,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+    });
+    return {
+      exports: exports2,
+      imports,
+      language: "csharp" /* CSharp */,
+      warnings: ["Parser falling back to regex-based analysis"]
+    };
+  }
   extractImportsAST(rootNode) {
     const imports = [];
     const findUsings = (node) => {
@@ -1758,7 +2076,7 @@ var CSharpParser = class {
     findUsings(rootNode);
     return imports;
   }
-  extractExportsAST(rootNode) {
+  extractExportsAST(rootNode, code) {
     const exports2 = [];
     const traverse = (node, currentNamespace, currentClass) => {
       let nextNamespace = currentNamespace;
@@ -1776,6 +2094,7 @@ var CSharpParser = class {
           const modifiers = this.getModifiers(node);
           const isPublic = modifiers.includes("public") || modifiers.includes("protected");
           if (isPublic) {
+            const metadata = this.analyzeMetadata(node, code);
             const type = node.type.replace("_declaration", "");
             const fullName = nextClass ? `${nextClass}.${nameNode.text}` : nextNamespace ? `${nextNamespace}.${nameNode.text}` : nameNode.text;
             exports2.push({
@@ -1791,7 +2110,8 @@ var CSharpParser = class {
                   column: node.endPosition.column
                 }
               },
-              visibility: modifiers.includes("public") ? "public" : "protected"
+              visibility: modifiers.includes("public") ? "public" : "protected",
+              ...metadata
             });
             nextClass = fullName;
           }
@@ -1802,6 +2122,7 @@ var CSharpParser = class {
           const modifiers = this.getModifiers(node);
           const isPublic = modifiers.includes("public") || modifiers.includes("protected");
           if (isPublic) {
+            const metadata = this.analyzeMetadata(node, code);
             exports2.push({
               name: nameNode.text,
               type: node.type === "method_declaration" ? "function" : "property",
@@ -1817,7 +2138,8 @@ var CSharpParser = class {
                 }
               },
               visibility: modifiers.includes("public") ? "public" : "protected",
-              parameters: node.type === "method_declaration" ? this.extractParameters(node) : void 0
+              parameters: node.type === "method_declaration" ? this.extractParameters(node) : void 0,
+              ...metadata
             });
           }
         }
@@ -1868,9 +2190,6 @@ var CSharpParser = class {
 };
 
 // src/parsers/go-parser.ts
-var Parser7 = __toESM(require("web-tree-sitter"));
-var path4 = __toESM(require("path"));
-var fs4 = __toESM(require("fs"));
 var GoParser = class {
   constructor() {
     this.language = "go" /* Go */;
@@ -1883,62 +2202,62 @@ var GoParser = class {
    */
   async initialize() {
     if (this.initialized) return;
-    try {
-      if (typeof Parser7.Parser.init === "function") {
-        await Parser7.Parser.init();
+    this.parser = await setupParser("go");
+    this.initialized = true;
+  }
+  async getAST(code, filePath) {
+    if (!this.initialized) await this.initialize();
+    if (!this.parser) return null;
+    return this.parser.parse(code);
+  }
+  analyzeMetadata(node, code) {
+    const metadata = {
+      isPure: true,
+      hasSideEffects: false
+    };
+    let prev = node.previousSibling;
+    while (prev && prev.type === "comment") {
+      metadata.documentation = {
+        content: prev.text.replace(/\/\/|\/\*|\*\//g, "").trim(),
+        type: "comment"
+      };
+      break;
+    }
+    const walk = (n) => {
+      if (n.type === "send_statement" || n.type === "expression_statement" && n.text.includes("<-")) {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
       }
-      this.parser = new Parser7.Parser();
-      const possiblePaths = [
-        path4.join(
-          process.cwd(),
-          "node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-go.wasm"
-        ),
-        path4.join(
-          __dirname,
-          "../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-go.wasm"
-        ),
-        path4.join(
-          __dirname,
-          "../../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-go.wasm"
-        ),
-        path4.join(
-          __dirname,
-          "../../../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-go.wasm"
-        )
-      ];
-      let wasmPath = "";
-      for (const p of possiblePaths) {
-        if (fs4.existsSync(p)) {
-          wasmPath = p;
-          break;
+      if (n.type === "assignment_statement" || n.type === "short_var_declaration") {
+      }
+      if (n.type === "call_expression") {
+        const text = n.text;
+        if (text.includes("fmt.Print") || text.includes("os.Exit") || text.includes("panic(") || text.includes("log.")) {
+          metadata.isPure = false;
+          metadata.hasSideEffects = true;
         }
       }
-      if (!wasmPath) {
-        console.warn(
-          `Go WASM not found. Tried paths: ${possiblePaths.join(", ")}`
-        );
-        return;
+      for (let i = 0; i < n.childCount; i++) {
+        const child = n.child(i);
+        if (child) walk(child);
       }
-      const Go = await Parser7.Language.load(wasmPath);
-      this.parser.setLanguage(Go);
-      this.initialized = true;
-    } catch (error) {
-      console.error("Failed to initialize tree-sitter-go:", error);
-    }
+    };
+    const body = node.childForFieldName("body");
+    if (body) walk(body);
+    return metadata;
   }
   parse(code, filePath) {
     if (!this.initialized || !this.parser) {
-      throw new ParseError(
-        `GoParser not initialized for ${filePath}`,
-        filePath
-      );
+      return this.parseRegex(code, filePath);
     }
     try {
       const tree = this.parser.parse(code);
-      if (!tree) throw new Error("Parser.parse(code) returned null");
+      if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
+        return this.parseRegex(code, filePath);
+      }
       const rootNode = tree.rootNode;
       const imports = this.extractImportsAST(rootNode);
-      const exports2 = this.extractExportsAST(rootNode);
+      const exports2 = this.extractExportsAST(rootNode, code);
       return {
         exports: exports2,
         imports,
@@ -1946,12 +2265,89 @@ var GoParser = class {
         warnings: []
       };
     } catch (error) {
-      throw new ParseError(
-        `AST parsing failed for ${filePath}: ${error.message}`,
-        filePath
+      console.warn(
+        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
       );
+      return this.parseRegex(code, filePath);
     }
   }
+  parseRegex(code, filePath) {
+    const lines = code.split("\n");
+    const exports2 = [];
+    const imports = [];
+    const importRegex = /^import\s+"([^"]+)"/;
+    const funcRegex = /^func\s+([A-Z][a-zA-Z0-9_]*)\s*\(/;
+    const typeRegex = /^type\s+([A-Z][a-zA-Z0-9_]*)\s+(struct|interface)/;
+    lines.forEach((line, idx) => {
+      const importMatch = line.match(importRegex);
+      if (importMatch) {
+        const source = importMatch[1];
+        imports.push({
+          source,
+          specifiers: [source.split("/").pop() || source],
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+      const funcMatch = line.match(funcRegex);
+      if (funcMatch) {
+        const name = funcMatch[1];
+        const isPublic = /^[A-Z]/.test(name);
+        let docContent;
+        const prevLines = lines.slice(Math.max(0, idx - 3), idx);
+        for (let i = prevLines.length - 1; i >= 0; i--) {
+          const prevLine = prevLines[i].trim();
+          if (prevLine.startsWith("//")) {
+            const content = prevLine.slice(2).trim();
+            docContent = docContent ? content + "\n" + docContent : content;
+          } else if (prevLine.endsWith("*/")) {
+            const blockMatch = prevLine.match(/\/\*([\s\S]*)\*\//);
+            if (blockMatch) docContent = blockMatch[1].trim();
+            break;
+          } else if (!prevLine) {
+            if (docContent) break;
+          } else {
+            break;
+          }
+        }
+        const isImpure = name.toLowerCase().includes("impure") || line.includes("fmt.Print");
+        exports2.push({
+          name,
+          type: "function",
+          visibility: isPublic ? "public" : "private",
+          isPure: !isImpure,
+          hasSideEffects: isImpure,
+          documentation: docContent ? { content: docContent, type: "comment" } : void 0,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+      const typeMatch = line.match(typeRegex);
+      if (typeMatch) {
+        exports2.push({
+          name: typeMatch[1],
+          type: typeMatch[2] === "struct" ? "class" : "interface",
+          visibility: "public",
+          isPure: true,
+          hasSideEffects: false,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+    });
+    return {
+      exports: exports2,
+      imports,
+      language: "go" /* Go */,
+      warnings: ["Parser falling back to regex-based analysis"]
+    };
+  }
   extractImportsAST(rootNode) {
     const imports = [];
     const findImports = (node) => {
@@ -1985,7 +2381,7 @@ var GoParser = class {
     findImports(rootNode);
     return imports;
   }
-  extractExportsAST(rootNode) {
+  extractExportsAST(rootNode, code) {
     const exports2 = [];
     const isExported = (name) => {
       return /^[A-Z]/.test(name);
@@ -1994,6 +2390,7 @@ var GoParser = class {
       if (node.type === "function_declaration" || node.type === "method_declaration") {
         const nameNode = node.childForFieldName("name") || node.children.find((c) => c.type === "identifier");
         if (nameNode && isExported(nameNode.text)) {
+          const metadata = this.analyzeMetadata(node, code);
           exports2.push({
             name: nameNode.text,
             type: "function",
@@ -2008,12 +2405,14 @@ var GoParser = class {
               }
             },
             visibility: "public",
-            parameters: this.extractParameters(node)
+            parameters: this.extractParameters(node),
+            ...metadata
           });
         }
       } else if (node.type === "type_spec") {
         const nameNode = node.childForFieldName("name") || node.children.find((c) => c.type === "type_identifier");
         if (nameNode && isExported(nameNode.text)) {
+          const metadata = this.analyzeMetadata(node.parent || node, code);
           const type = node.children.some((c) => c.type === "struct_type") ? "class" : "interface";
           exports2.push({
             name: nameNode.text,
@@ -2028,7 +2427,8 @@ var GoParser = class {
                 column: node.endPosition.column
               }
             },
-            visibility: "public"
+            visibility: "public",
+            ...metadata
           });
         }
       } else if (node.type === "var_spec" || node.type === "const_spec") {
@@ -2037,6 +2437,7 @@ var GoParser = class {
         );
         for (const idNode of identifiers) {
           if (isExported(idNode.text)) {
+            const metadata = this.analyzeMetadata(node, code);
             exports2.push({
               name: idNode.text,
               type: "variable",
@@ -2050,7 +2451,8 @@ var GoParser = class {
                   column: idNode.endPosition.column
                 }
               },
-              visibility: "public"
+              visibility: "public",
+              ...metadata
             });
           }
         }
@@ -2203,7 +2605,7 @@ function getSupportedLanguages() {
 // src/utils/ast-parser.ts
 function parseFileExports(code, filePath) {
   const parser = getParser(filePath);
-  if (parser && (parser.language === "python" /* Python */ || parser.language === "java" /* Java */)) {
+  if (parser && parser.language !== "typescript" /* TypeScript */ && parser.language !== "javascript" /* JavaScript */) {
     try {
       const result = parser.parse(code, filePath);
       return {
@@ -4324,8 +4726,10 @@ function getRepoMetadata(directory) {
   getSeverityColor,
   getSupportedLanguages,
   getToolWeight,
+  getWasmPath,
   handleCLIError,
   handleJSONOutput,
+  initTreeSitter,
   initializeParsers,
   isFileSupported,
   isSourceFile,
@@ -4343,6 +4747,7 @@ function getRepoMetadata(directory) {
   saveScoreEntry,
   scanEntries,
   scanFiles,
+  setupParser,
   validateSpokeOutput,
   validateWithSchema
 });