@aiready/core 0.21.14 → 0.21.16

package/dist/index.mjs

@@ -708,19 +708,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")
       ];
@@ -1098,6 +1102,668 @@ var PythonParser = class {
   }
 };
 
+// src/parsers/java-parser.ts
+import * as Parser3 from "web-tree-sitter";
+import * as path2 from "path";
+import * as fs2 from "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 exports = this.extractExportsAST(rootNode);
+      return {
+        exports,
+        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 exports = [];
+    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);
+          exports.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, exports);
+        }
+      }
+    }
+    return exports;
+  }
+  getModifiers(node) {
+    const modifiersNode = node.children.find((c) => c.type === "modifiers");
+    if (!modifiersNode) return [];
+    return modifiersNode.children.map((c) => c.text);
+  }
+  extractSubExports(parentNode, parentName, exports) {
+    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")) {
+          exports.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
+import * as Parser5 from "web-tree-sitter";
+import * as path3 from "path";
+import * as fs3 from "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 exports = this.extractExportsAST(rootNode);
+      return {
+        exports,
+        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 exports = [];
+    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;
+            exports.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) {
+            exports.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 exports;
+  }
+  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
+import * as Parser7 from "web-tree-sitter";
+import * as path4 from "path";
+import * as fs4 from "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 exports = this.extractExportsAST(rootNode);
+      return {
+        exports,
+        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 exports = [];
+    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)) {
+          exports.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";
+          exports.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)) {
+            exports.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 exports;
+  }
+  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() {
@@ -1107,6 +1773,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
@@ -1209,7 +1878,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 {
@@ -1411,8 +2080,8 @@ function estimateTokens(text) {
 }
 
 // src/utils/config.ts
-import { readFileSync, existsSync as existsSync4 } from "fs";
-import { join as join4, resolve, dirname as dirname3 } from "path";
+import { readFileSync, existsSync as existsSync7 } from "fs";
+import { join as join7, resolve, dirname as dirname3 } from "path";
 import { pathToFileURL } from "url";
 var CONFIG_FILES = [
   "aiready.json",
@@ -1426,8 +2095,8 @@ async function loadConfig(rootDir) {
   let currentDir = resolve(rootDir);
   while (true) {
     for (const configFile of CONFIG_FILES) {
-      const configPath = join4(currentDir, configFile);
-      if (existsSync4(configPath)) {
+      const configPath = join7(currentDir, configFile);
+      if (existsSync7(configPath)) {
         try {
           let config;
           if (configFile.endsWith(".js")) {
@@ -2733,14 +3402,14 @@ function calculateExtendedFutureProofScore(params) {
 }
 
 // src/utils/history.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
-import { join as join5, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync2 } from "fs";
+import { join as join8, dirname as dirname4 } from "path";
 function getHistoryPath(rootDir) {
-  return join5(rootDir, ".aiready", "history.json");
+  return join8(rootDir, ".aiready", "history.json");
 }
 function loadScoreHistory(rootDir) {
   const historyPath = getHistoryPath(rootDir);
-  if (!existsSync5(historyPath)) {
+  if (!existsSync8(historyPath)) {
     return [];
   }
   try {
@@ -2754,7 +3423,7 @@ function loadScoreHistory(rootDir) {
 function saveScoreEntry(rootDir, entry) {
   const historyPath = getHistoryPath(rootDir);
   const historyDir = dirname4(historyPath);
-  if (!existsSync5(historyDir)) {
+  if (!existsSync8(historyDir)) {
     mkdirSync2(historyDir, { recursive: true });
   }
   const history = loadScoreHistory(rootDir);
@@ -2801,7 +3470,7 @@ function exportHistory(rootDir, format = "json") {
 }
 function clearHistory(rootDir) {
   const historyPath = getHistoryPath(rootDir);
-  if (existsSync5(historyPath)) {
+  if (existsSync8(historyPath)) {
     writeFileSync2(historyPath, JSON.stringify([]));
   }
 }
@@ -2883,15 +3552,18 @@ export {
   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,