@aiready/core 0.21.14 → 0.21.16

package/dist/index.js

@@ -35,15 +35,18 @@ __export(index_exports, {
   AnalysisStatusSchema: () => AnalysisStatusSchema,
   COMMON_FINE_TUNING_OPTIONS: () => COMMON_FINE_TUNING_OPTIONS,
   CONTEXT_TIER_THRESHOLDS: () => CONTEXT_TIER_THRESHOLDS,
+  CSharpParser: () => CSharpParser,
   DEFAULT_COST_CONFIG: () => DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE: () => DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS: () => DEFAULT_TOOL_WEIGHTS,
   FRIENDLY_TOOL_NAMES: () => FRIENDLY_TOOL_NAMES,
   GLOBAL_INFRA_OPTIONS: () => GLOBAL_INFRA_OPTIONS,
   GLOBAL_SCAN_OPTIONS: () => GLOBAL_SCAN_OPTIONS,
+  GoParser: () => GoParser,
   IssueSchema: () => IssueSchema,
   IssueType: () => IssueType,
   IssueTypeSchema: () => IssueTypeSchema,
+  JavaParser: () => JavaParser,
   LANGUAGE_EXTENSIONS: () => LANGUAGE_EXTENSIONS,
   Language: () => Language,
   LocationSchema: () => LocationSchema,
@@ -333,15 +336,15 @@ var COMMON_FINE_TUNING_OPTIONS = [
 var GLOBAL_SCAN_OPTIONS = [...GLOBAL_INFRA_OPTIONS];
 
 // src/types/language.ts
-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;
+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;
 })(Language || {});
 var LANGUAGE_EXTENSIONS = {
   ".ts": "typescript" /* TypeScript */,
@@ -1030,19 +1033,23 @@ var PythonParser = class {
       const possiblePaths = [
         path.join(
           process.cwd(),
-          "node_modules/tree-sitter-python/tree-sitter-python.wasm"
+          "node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-python.wasm"
         ),
         path.join(
           __dirname,
-          "../../node_modules/tree-sitter-python/tree-sitter-python.wasm"
+          "../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-python.wasm"
         ),
         path.join(
           __dirname,
-          "../../../node_modules/tree-sitter-python/tree-sitter-python.wasm"
+          "../../../node_modules/@unit-mesh/treesitter-artifacts/wasm/tree-sitter-python.wasm"
         ),
         path.join(
           __dirname,
-          "../../../../node_modules/tree-sitter-python/tree-sitter-python.wasm"
+          "../../../../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")
       ];
@@ -1420,6 +1427,668 @@ 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 */;
+    this.extensions = [".java"];
+    this.parser = null;
+    this.initialized = false;
+  }
+  /**
+   * Initialize the tree-sitter parser
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      if (typeof Parser3.Parser.init === "function") {
+        await Parser3.Parser.init();
+      }
+      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;
+        }
+      }
+      if (!wasmPath) {
+        console.warn(
+          `Java WASM not found. Tried paths: ${possiblePaths.join(", ")}`
+        );
+        return;
+      }
+      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);
+      }
+    }
+  }
+  parse(code, filePath) {
+    if (!this.initialized || !this.parser) {
+      throw new ParseError(
+        `JavaParser not initialized for ${filePath}`,
+        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);
+      return {
+        exports: exports2,
+        imports,
+        language: "java" /* Java */,
+        warnings: []
+      };
+    } catch (error) {
+      throw new ParseError(
+        `AST parsing failed for ${filePath}: ${error.message}`,
+        filePath
+      );
+    }
+  }
+  extractImportsAST(rootNode) {
+    const imports = [];
+    for (const node of rootNode.children) {
+      if (node.type === "import_declaration") {
+        let sourceArr = [];
+        let isStatic = false;
+        let isWildcard = false;
+        for (const child of node.children) {
+          if (child.type === "static") isStatic = true;
+          if (child.type === "scoped_identifier" || child.type === "identifier") {
+            sourceArr.push(child.text);
+          }
+          if (child.type === "asterisk") isWildcard = true;
+        }
+        const source = sourceArr.join(".");
+        if (source) {
+          imports.push({
+            source: isWildcard ? `${source}.*` : source,
+            specifiers: isWildcard ? ["*"] : [source.split(".").pop() || source],
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            }
+          });
+        }
+      }
+    }
+    return imports;
+  }
+  extractExportsAST(rootNode) {
+    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);
+          exports2.push({
+            name: nameNode.text,
+            type: node.type === "class_declaration" ? "class" : "interface",
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            },
+            visibility: modifiers.includes("public") ? "public" : "private"
+          });
+          this.extractSubExports(node, nameNode.text, exports2);
+        }
+      }
+    }
+    return exports2;
+  }
+  getModifiers(node) {
+    const modifiersNode = node.children.find((c) => c.type === "modifiers");
+    if (!modifiersNode) return [];
+    return modifiersNode.children.map((c) => c.text);
+  }
+  extractSubExports(parentNode, parentName, exports2) {
+    const bodyNode = parentNode.children.find((c) => c.type === "class_body");
+    if (!bodyNode) return;
+    for (const node of bodyNode.children) {
+      if (node.type === "method_declaration") {
+        const nameNode = node.children.find((c) => c.type === "identifier");
+        const modifiers = this.getModifiers(node);
+        if (nameNode && modifiers.includes("public")) {
+          exports2.push({
+            name: nameNode.text,
+            type: "function",
+            parentClass: parentName,
+            visibility: "public",
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            },
+            parameters: this.extractParameters(node)
+          });
+        }
+      }
+    }
+  }
+  extractParameters(node) {
+    const paramsNode = node.children.find(
+      (c) => c.type === "formal_parameters"
+    );
+    if (!paramsNode) return [];
+    return paramsNode.children.filter((c) => c.type === "formal_parameter").map((c) => {
+      const idNode = c.children.find((child) => child.type === "identifier");
+      return idNode ? idNode.text : "unknown";
+    });
+  }
+  getNamingConventions() {
+    return {
+      variablePattern: /^[a-z][a-zA-Z0-9]*$/,
+      functionPattern: /^[a-z][a-zA-Z0-9]*$/,
+      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      constantPattern: /^[A-Z][A-Z0-9_]*$/,
+      exceptions: ["main", "serialVersionUID"]
+    };
+  }
+  canHandle(filePath) {
+    return filePath.toLowerCase().endsWith(".java");
+  }
+};
+
+// 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 */;
+    this.extensions = [".cs"];
+    this.parser = null;
+    this.initialized = false;
+  }
+  /**
+   * Initialize the tree-sitter parser
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      if (typeof Parser5.Parser.init === "function") {
+        await Parser5.Parser.init();
+      }
+      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;
+        }
+      }
+      if (!wasmPath) {
+        console.warn(
+          `C# WASM not found. Tried paths: ${possiblePaths.join(", ")}`
+        );
+        return;
+      }
+      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);
+    }
+  }
+  parse(code, filePath) {
+    if (!this.initialized || !this.parser) {
+      throw new ParseError(
+        `CSharpParser not initialized for ${filePath}`,
+        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);
+      return {
+        exports: exports2,
+        imports,
+        language: "csharp" /* CSharp */,
+        warnings: []
+      };
+    } catch (error) {
+      throw new ParseError(
+        `AST parsing failed for ${filePath}: ${error.message}`,
+        filePath
+      );
+    }
+  }
+  extractImportsAST(rootNode) {
+    const imports = [];
+    const findUsings = (node) => {
+      if (node.type === "using_directive") {
+        const nameNode = node.childForFieldName("name") || node.children.find(
+          (c) => c.type === "qualified_name" || c.type === "identifier"
+        );
+        if (nameNode) {
+          const aliasNode = node.childForFieldName("alias");
+          imports.push({
+            source: nameNode.text,
+            specifiers: aliasNode ? [aliasNode.text] : [nameNode.text.split(".").pop() || nameNode.text],
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            }
+          });
+        }
+      }
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child) findUsings(child);
+      }
+    };
+    findUsings(rootNode);
+    return imports;
+  }
+  extractExportsAST(rootNode) {
+    const exports2 = [];
+    const traverse = (node, currentNamespace, currentClass) => {
+      let nextNamespace = currentNamespace;
+      let nextClass = currentClass;
+      if (node.type === "namespace_declaration" || node.type === "file_scoped_namespace_declaration") {
+        const nameNode = node.childForFieldName("name") || node.children.find(
+          (c) => c.type === "identifier" || c.type === "qualified_name"
+        );
+        if (nameNode) {
+          nextNamespace = currentNamespace ? `${currentNamespace}.${nameNode.text}` : nameNode.text;
+        }
+      } else if (node.type === "class_declaration" || node.type === "interface_declaration" || node.type === "enum_declaration" || node.type === "struct_declaration" || node.type === "record_declaration") {
+        const nameNode = node.childForFieldName("name") || node.children.find((c) => c.type === "identifier");
+        if (nameNode) {
+          const modifiers = this.getModifiers(node);
+          const isPublic = modifiers.includes("public") || modifiers.includes("protected");
+          if (isPublic) {
+            const type = node.type.replace("_declaration", "");
+            const fullName = nextClass ? `${nextClass}.${nameNode.text}` : nextNamespace ? `${nextNamespace}.${nameNode.text}` : nameNode.text;
+            exports2.push({
+              name: fullName,
+              type: type === "record" ? "class" : type,
+              loc: {
+                start: {
+                  line: node.startPosition.row + 1,
+                  column: node.startPosition.column
+                },
+                end: {
+                  line: node.endPosition.row + 1,
+                  column: node.endPosition.column
+                }
+              },
+              visibility: modifiers.includes("public") ? "public" : "protected"
+            });
+            nextClass = fullName;
+          }
+        }
+      } else if (node.type === "method_declaration" || node.type === "property_declaration") {
+        const nameNode = node.childForFieldName("name") || node.children.find((c) => c.type === "identifier");
+        if (nameNode) {
+          const modifiers = this.getModifiers(node);
+          const isPublic = modifiers.includes("public") || modifiers.includes("protected");
+          if (isPublic) {
+            exports2.push({
+              name: nameNode.text,
+              type: node.type === "method_declaration" ? "function" : "property",
+              parentClass: currentClass,
+              loc: {
+                start: {
+                  line: node.startPosition.row + 1,
+                  column: node.startPosition.column
+                },
+                end: {
+                  line: node.endPosition.row + 1,
+                  column: node.endPosition.column
+                }
+              },
+              visibility: modifiers.includes("public") ? "public" : "protected",
+              parameters: node.type === "method_declaration" ? this.extractParameters(node) : void 0
+            });
+          }
+        }
+      }
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child) traverse(child, nextNamespace, nextClass);
+      }
+    };
+    traverse(rootNode);
+    return exports2;
+  }
+  getModifiers(node) {
+    const modifiers = [];
+    for (const child of node.children) {
+      if (child.type === "modifier") {
+        modifiers.push(child.text);
+      }
+    }
+    return modifiers;
+  }
+  extractParameters(node) {
+    const params = [];
+    const parameterList = node.childForFieldName("parameters") || node.children.find((c) => c.type === "parameter_list");
+    if (parameterList) {
+      for (const param of parameterList.children) {
+        if (param.type === "parameter") {
+          const nameNode = param.childForFieldName("name") || param.children.find((c) => c.type === "identifier");
+          if (nameNode) {
+            params.push(nameNode.text);
+          }
+        }
+      }
+    }
+    return params;
+  }
+  getNamingConventions() {
+    return {
+      variablePattern: /^[a-z][a-zA-Z0-9]*$/,
+      functionPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      constantPattern: /^[A-Z][a-zA-Z0-9_]*$/
+    };
+  }
+  canHandle(filePath) {
+    return filePath.toLowerCase().endsWith(".cs");
+  }
+};
+
+// 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 */;
+    this.extensions = [".go"];
+    this.parser = null;
+    this.initialized = false;
+  }
+  /**
+   * Initialize the tree-sitter parser
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      if (typeof Parser7.Parser.init === "function") {
+        await Parser7.Parser.init();
+      }
+      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 (!wasmPath) {
+        console.warn(
+          `Go WASM not found. Tried paths: ${possiblePaths.join(", ")}`
+        );
+        return;
+      }
+      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);
+    }
+  }
+  parse(code, filePath) {
+    if (!this.initialized || !this.parser) {
+      throw new ParseError(
+        `GoParser not initialized for ${filePath}`,
+        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);
+      return {
+        exports: exports2,
+        imports,
+        language: "go" /* Go */,
+        warnings: []
+      };
+    } catch (error) {
+      throw new ParseError(
+        `AST parsing failed for ${filePath}: ${error.message}`,
+        filePath
+      );
+    }
+  }
+  extractImportsAST(rootNode) {
+    const imports = [];
+    const findImports = (node) => {
+      if (node.type === "import_spec") {
+        const pathNode = node.children.find(
+          (c) => c.type === "interpreted_string_literal"
+        );
+        if (pathNode) {
+          const source = pathNode.text.replace(/"/g, "");
+          imports.push({
+            source,
+            specifiers: [source.split("/").pop() || source],
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            }
+          });
+        }
+      }
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child) findImports(child);
+      }
+    };
+    findImports(rootNode);
+    return imports;
+  }
+  extractExportsAST(rootNode) {
+    const exports2 = [];
+    const isExported = (name) => {
+      return /^[A-Z]/.test(name);
+    };
+    const traverse = (node) => {
+      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)) {
+          exports2.push({
+            name: nameNode.text,
+            type: "function",
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            },
+            visibility: "public",
+            parameters: this.extractParameters(node)
+          });
+        }
+      } 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 type = node.children.some((c) => c.type === "struct_type") ? "class" : "interface";
+          exports2.push({
+            name: nameNode.text,
+            type,
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            },
+            visibility: "public"
+          });
+        }
+      } else if (node.type === "var_spec" || node.type === "const_spec") {
+        const identifiers = node.children.filter(
+          (c) => c.type === "identifier"
+        );
+        for (const idNode of identifiers) {
+          if (isExported(idNode.text)) {
+            exports2.push({
+              name: idNode.text,
+              type: "variable",
+              loc: {
+                start: {
+                  line: idNode.startPosition.row + 1,
+                  column: idNode.startPosition.column
+                },
+                end: {
+                  line: idNode.endPosition.row + 1,
+                  column: idNode.endPosition.column
+                }
+              },
+              visibility: "public"
+            });
+          }
+        }
+      }
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child) traverse(child);
+      }
+    };
+    traverse(rootNode);
+    return exports2;
+  }
+  extractParameters(node) {
+    const params = [];
+    const parameterList = node.childForFieldName("parameters") || node.children.find((c) => c.type === "parameter_list");
+    if (parameterList) {
+      for (const param of parameterList.children) {
+        if (param.type === "parameter_declaration") {
+          const names = param.children.filter((c) => c.type === "identifier");
+          names.forEach((n) => params.push(n.text));
+        }
+      }
+    }
+    return params;
+  }
+  getNamingConventions() {
+    return {
+      variablePattern: /^[a-zA-Z][a-zA-Z0-9]*$/,
+      functionPattern: /^[a-zA-Z][a-zA-Z0-9]*$/,
+      classPattern: /^[a-zA-Z][a-zA-Z0-9]*$/,
+      constantPattern: /^[a-zA-Z_][a-zA-Z0-9_]*$/
+    };
+  }
+  canHandle(filePath) {
+    return filePath.toLowerCase().endsWith(".go");
+  }
+};
+
 // src/parsers/parser-factory.ts
 var ParserFactory = class _ParserFactory {
   constructor() {
@@ -1429,6 +2098,9 @@ var ParserFactory = class _ParserFactory {
     );
     this.registerParser(new TypeScriptParser());
     this.registerParser(new PythonParser());
+    this.registerParser(new JavaParser());
+    this.registerParser(new CSharpParser());
+    this.registerParser(new GoParser());
   }
   /**
    * Get singleton instance
@@ -1531,7 +2203,7 @@ function getSupportedLanguages() {
 // src/utils/ast-parser.ts
 function parseFileExports(code, filePath) {
   const parser = getParser(filePath);
-  if (parser && parser.language === "python" /* Python */) {
+  if (parser && (parser.language === "python" /* Python */ || parser.language === "java" /* Java */)) {
     try {
       const result = parser.parse(code, filePath);
       return {
@@ -3563,15 +4235,18 @@ function getRepoMetadata(directory) {
   AnalysisStatusSchema,
   COMMON_FINE_TUNING_OPTIONS,
   CONTEXT_TIER_THRESHOLDS,
+  CSharpParser,
   DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS,
   FRIENDLY_TOOL_NAMES,
   GLOBAL_INFRA_OPTIONS,
   GLOBAL_SCAN_OPTIONS,
+  GoParser,
   IssueSchema,
   IssueType,
   IssueTypeSchema,
+  JavaParser,
   LANGUAGE_EXTENSIONS,
   Language,
   LocationSchema,