@aiready/core 0.23.0 → 0.23.2

package/dist/index.mjs

@@ -321,7 +321,8 @@ async function scanFiles(options) {
   const files = await glob(include, {
     cwd: rootDir,
     ignore: finalExclude,
-    absolute: true
+    absolute: true,
+    nodir: true
   });
   const gitignoreFiles = await glob("**/.gitignore", {
     cwd: rootDir,
@@ -438,8 +439,14 @@ function isSourceFile(filePath) {
 }
 
 // src/utils/cli-helpers.ts
-import { writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
+import {
+  writeFileSync,
+  mkdirSync,
+  existsSync as existsSync2,
+  readdirSync,
+  statSync
+} from "fs";
+import { join as join2, dirname as dirname2, resolve as resolvePath } from "path";
 function resolveOutputPath(userPath, defaultFilename, workingDir = process.cwd()) {
   let outputPath;
   if (userPath) {
@@ -525,6 +532,111 @@ function getSeverityColor(severity, chalk) {
       return chalk.white;
   }
 }
+function findLatestReport(dirPath) {
+  const aireadyDir = resolvePath(dirPath, ".aiready");
+  if (!existsSync2(aireadyDir)) {
+    return null;
+  }
+  let files = readdirSync(aireadyDir).filter(
+    (f) => f.startsWith("aiready-report-") && f.endsWith(".json")
+  );
+  if (files.length === 0) {
+    files = readdirSync(aireadyDir).filter(
+      (f) => f.startsWith("aiready-scan-") && f.endsWith(".json")
+    );
+  }
+  if (files.length === 0) {
+    return null;
+  }
+  const sortedFiles = files.map((f) => ({
+    name: f,
+    path: resolvePath(aireadyDir, f),
+    mtime: statSync(resolvePath(aireadyDir, f)).mtime
+  })).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  return sortedFiles[0].path;
+}
+function findLatestScanReport(scanReportsDir, reportFilePrefix) {
+  try {
+    let reportFiles = [];
+    if (existsSync2(scanReportsDir)) {
+      const files = readdirSync(scanReportsDir);
+      if (files.length > 0) {
+        const prefixRegex = new RegExp(`^${reportFilePrefix}\\d+\\.json$`);
+        reportFiles = files.filter((file) => prefixRegex.test(file));
+      }
+    }
+    if (reportFiles.length === 0) return null;
+    reportFiles.sort((a, b) => {
+      const idA = parseInt(a.match(/\d+/)?.[0] || "0", 10);
+      const idB = parseInt(b.match(/\d+/)?.[0] || "0", 10);
+      return idB - idA;
+    });
+    return join2(scanReportsDir, reportFiles[0]);
+  } catch (e) {
+    console.error("Error while finding latest scan report:", e);
+    return null;
+  }
+}
+
+// src/utils/provider-utils.ts
+function groupIssuesByFile(issues) {
+  const fileIssuesMap = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const file = issue.location?.file ?? "unknown";
+    if (!fileIssuesMap.has(file)) fileIssuesMap.set(file, []);
+    fileIssuesMap.get(file).push(issue);
+  }
+  return Array.from(fileIssuesMap.entries()).map(([fileName, issueList]) => ({
+    fileName,
+    issues: issueList,
+    metrics: {}
+  }));
+}
+function buildSimpleProviderScore(toolName, summary, rawData = {}) {
+  return {
+    toolName,
+    score: summary.score ?? 0,
+    rawMetrics: { ...summary, ...rawData },
+    factors: [],
+    recommendations: (summary.recommendations ?? []).map((action) => ({
+      action,
+      estimatedImpact: 5,
+      priority: "medium"
+    }))
+  };
+}
+function buildSpokeOutput(toolName, version, summary, results, metadata = {}) {
+  return SpokeOutputSchema.parse({
+    results,
+    summary,
+    metadata: {
+      toolName,
+      version,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...metadata
+    }
+  });
+}
+function createProvider(config) {
+  return {
+    id: config.id,
+    alias: config.alias,
+    defaultWeight: config.defaultWeight,
+    async analyze(options) {
+      const report = await config.analyzeReport(options);
+      return buildSpokeOutput(
+        config.id,
+        config.version,
+        config.getSummary(report),
+        config.getResults(report),
+        config.getMetadata?.(report) ?? {}
+      );
+    },
+    score(output, options) {
+      return config.score(output, options);
+    }
+  };
+}
 
 // src/utils/ast-parser.ts
 import { parse as parse2 } from "@typescript-eslint/typescript-estree";
@@ -652,8 +764,10 @@ var TypeScriptParser = class {
       // camelCase for variables and functions
       variablePattern: /^[a-z][a-zA-Z0-9]*$/,
       functionPattern: /^[a-z][a-zA-Z0-9]*$/,
-      // PascalCase for classes
+      // PascalCase for classes, types and interfaces
       classPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      typePattern: /^[A-Z][a-zA-Z0-9]*$/,
+      interfacePattern: /^[A-Z][a-zA-Z0-9]*$/,
       // UPPER_CASE for constants
       constantPattern: /^[A-Z][A-Z0-9_]*$/,
       // Common exceptions (React hooks, etc.)
@@ -952,6 +1066,101 @@ async function setupParser(language) {
   }
 }
 
+// src/parsers/metadata-utils.ts
+function analyzeNodeMetadata(node, code, options) {
+  const metadata = {
+    isPure: true,
+    hasSideEffects: false
+  };
+  try {
+    let prev = node.previousSibling || null;
+    while (prev && /comment/i.test(prev.type)) {
+      const text = prev.text || "";
+      if (text.trim().startsWith("/**") || text.trim().startsWith("/*")) {
+        metadata.documentation = {
+          content: text.replace(/^[/*]+|[/*]+$/g, "").trim(),
+          type: "comment"
+        };
+        break;
+      }
+      if (text.trim().startsWith("///")) {
+        metadata.documentation = {
+          content: text.replace(/^\/\/\//, "").trim(),
+          type: "xml-doc"
+        };
+        break;
+      }
+      if (text.trim().startsWith("//")) {
+        metadata.documentation = {
+          content: text.replace(/^\/\//, "").trim(),
+          type: "comment"
+        };
+        break;
+      }
+      prev = prev.previousSibling;
+    }
+    if (node.type === "function_definition") {
+      const body2 = node.childForFieldName ? node.childForFieldName("body") : node.children.find((c) => c.type === "block");
+      if (body2 && body2.children.length > 0) {
+        const firstStmt = body2.children[0];
+        if (firstStmt.type === "expression_statement" && firstStmt.firstChild?.type === "string") {
+          metadata.documentation = {
+            content: firstStmt.firstChild.text.replace(/['"`]/g, "").trim(),
+            type: "docstring"
+          };
+        }
+      }
+    }
+  } catch {
+  }
+  const defaultSignatures = [
+    "console.",
+    "fmt.",
+    "panic(",
+    "os.Exit",
+    "log.",
+    "Console.Write",
+    "File.Write",
+    "System.out",
+    "System.err",
+    "Files.write",
+    "process.exit",
+    "exit("
+  ];
+  const signatures = Array.from(
+    /* @__PURE__ */ new Set([...options?.sideEffectSignatures || [], ...defaultSignatures])
+  );
+  const walk = (n) => {
+    try {
+      const t = n.type || "";
+      if (/assign|assignment|assignment_statement|assignment_expression|throw|throw_statement|send_statement|global_statement|nonlocal_statement/i.test(
+        t
+      )) {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
+      }
+      const text = n.text || "";
+      for (const s of signatures) {
+        if (text.includes(s)) {
+          metadata.isPure = false;
+          metadata.hasSideEffects = true;
+          break;
+        }
+      }
+      for (let i = 0; i < n.childCount; i++) {
+        const c = n.child(i);
+        if (c) walk(c);
+      }
+    } catch {
+    }
+  };
+  const body = node.childForFieldName?.("body") || node.children.find(
+    (c) => /body|block|class_body|declaration_list|function_body/.test(c.type)
+  );
+  if (body) walk(body);
+  return metadata;
+}
+
 // src/parsers/python-parser.ts
 var PythonParser = class {
   constructor() {
@@ -974,38 +1183,9 @@ var PythonParser = class {
     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;
-        }
-      }
-      for (const child of n.children) {
-        walk(child);
-      }
-    };
-    if (body) walk(body);
-    return metadata;
+    return analyzeNodeMetadata(node, code, {
+      sideEffectSignatures: ["print(", "input(", "open("]
+    });
   }
   parse(code, filePath) {
     if (!this.initialized || !this.parser) {
@@ -1354,6 +1534,113 @@ var PythonParser = class {
   }
 };
 
+// src/parsers/shared-parser-utils.ts
+var SIDE_EFFECT_KEYWORDS = [
+  "print(",
+  "console.",
+  "System.out",
+  "System.err",
+  "fmt.",
+  "File.Write",
+  "Files.write",
+  "os.Exit",
+  "panic(",
+  "throw ",
+  "Logging.",
+  "log."
+];
+function analyzeGeneralMetadata(node, code, options = {}) {
+  const metadata = {
+    isPure: true,
+    hasSideEffects: false
+  };
+  try {
+    let prev = node.previousSibling || null;
+    while (prev && /comment/i.test(prev.type)) {
+      const text = prev.text || "";
+      if (text.trim().startsWith("/**")) {
+        metadata.documentation = {
+          content: text.replace(/^[/*]+|[/*]+$/g, "").trim(),
+          type: "jsdoc"
+        };
+        break;
+      }
+      if (text.trim().startsWith("///")) {
+        metadata.documentation = {
+          content: text.replace(/^\/\/\//, "").trim(),
+          type: "xml-doc"
+        };
+        break;
+      }
+      if (text.trim().startsWith("//")) {
+        metadata.documentation = {
+          content: text.replace(/^\/\//, "").trim(),
+          type: "comment"
+        };
+        break;
+      }
+      prev = prev.previousSibling;
+    }
+  } catch {
+  }
+  const signatures = [
+    ...SIDE_EFFECT_KEYWORDS,
+    ...options.sideEffectSignatures || []
+  ];
+  const walk = (n) => {
+    if (/assign|assignment|assignment_statement|assignment_expression/i.test(
+      n.type
+    )) {
+      metadata.isPure = false;
+      metadata.hasSideEffects = true;
+    }
+    const text = n.text;
+    for (const sig of signatures) {
+      if (text.includes(sig)) {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
+        break;
+      }
+    }
+    if (!metadata.hasSideEffects) {
+      for (let i = 0; i < n.childCount; i++) {
+        const child = n.child(i);
+        if (child) walk(child);
+      }
+    }
+  };
+  walk(node);
+  return metadata;
+}
+function extractParameterNames(node) {
+  const params = [];
+  const candidates = [
+    // common field name
+    node.childForFieldName ? node.childForFieldName("parameters") : null,
+    node.childForFieldName ? node.childForFieldName("parameter_list") : null,
+    node.children.find((c) => c.type === "parameter_list") || null,
+    node.children.find((c) => c.type === "parameters") || null,
+    node.children.find((c) => c.type === "formal_parameters") || null,
+    node.children.find((c) => c.type === "formal_parameter") || null
+  ];
+  const list = candidates.find(Boolean);
+  if (!list) return params;
+  for (const child of list.children) {
+    if (!child) continue;
+    const id = child.childForFieldName?.("name") || child.children.find(
+      (c) => [
+        "identifier",
+        "variable_name",
+        "name",
+        "parameter",
+        "formal_parameter"
+      ].includes(c.type)
+    ) || (child.type === "identifier" ? child : void 0);
+    if (id && typeof id.text === "string") params.push(id.text);
+  }
+  return params;
+}
+
 // src/parsers/java-parser.ts
 var JavaParser = class {
   constructor() {
@@ -1376,47 +1663,14 @@ var JavaParser = class {
     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;
-      }
-      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 (n.type === "throw_statement") {
-        metadata.isPure = false;
-        metadata.hasSideEffects = true;
-      }
-      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;
+    return analyzeGeneralMetadata(node, code, {
+      sideEffectSignatures: [
+        "System.out",
+        "System.err",
+        "Files.write",
+        "Logging."
+      ]
+    });
   }
   parse(code, filePath) {
     if (!this.initialized || !this.parser) {
@@ -1516,7 +1770,7 @@ var JavaParser = class {
     const imports = [];
     for (const node of rootNode.children) {
       if (node.type === "import_declaration") {
-        let sourceArr = [];
+        const sourceArr = [];
         let isStatic = false;
         let isWildcard = false;
         for (const child of node.children) {
@@ -1614,14 +1868,7 @@ var JavaParser = class {
     }
   }
   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";
-    });
+    return extractParameterNames(node);
   }
   getNamingConventions() {
     return {
@@ -1659,47 +1906,9 @@ var CSharpParser = class {
     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;
-      }
-      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 (n.type === "throw_statement") {
-        metadata.isPure = false;
-        metadata.hasSideEffects = true;
-      }
-      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;
+    return analyzeGeneralMetadata(node, code, {
+      sideEffectSignatures: ["Console.Write", "File.Write", "Logging."]
+    });
   }
   parse(code, filePath) {
     if (!this.initialized || !this.parser) {
@@ -1904,19 +2113,7 @@ var CSharpParser = class {
     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;
+    return extractParameterNames(node);
   }
   getNamingConventions() {
     return {
@@ -1953,40 +2150,9 @@ var GoParser = class {
     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;
-      }
-      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;
-        }
-      }
-      for (let i = 0; i < n.childCount; i++) {
-        const child = n.child(i);
-        if (child) walk(child);
-      }
-    };
-    const body = node.childForFieldName("body");
-    if (body) walk(body);
-    return metadata;
+    return analyzeGeneralMetadata(node, code, {
+      sideEffectSignatures: ["<-", "fmt.Print", "fmt.Fprintf", "os.Exit"]
+    });
   }
   parse(code, filePath) {
     if (!this.initialized || !this.parser) {
@@ -2208,17 +2374,7 @@ var GoParser = class {
     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;
+    return extractParameterNames(node);
   }
   getNamingConventions() {
     return {
@@ -2568,34 +2724,47 @@ var CONFIG_FILES = [
 async function loadConfig(rootDir) {
   let currentDir = resolve(rootDir);
   while (true) {
+    const foundConfigs = [];
     for (const configFile of CONFIG_FILES) {
+      if (existsSync4(join4(currentDir, configFile))) {
+        foundConfigs.push(configFile);
+      }
+    }
+    if (foundConfigs.length > 0) {
+      if (foundConfigs.length > 1) {
+        console.warn(
+          `\u26A0\uFE0F Multiple configuration files found in ${currentDir}: ${foundConfigs.join(
+            ", "
+          )}. Using ${foundConfigs[0]}.`
+        );
+      } else {
+      }
+      const configFile = foundConfigs[0];
       const configPath = join4(currentDir, configFile);
-      if (existsSync4(configPath)) {
+      try {
+        let config;
+        if (configFile.endsWith(".js")) {
+          const fileUrl = pathToFileURL(configPath).href;
+          const module = await import(`${fileUrl}?t=${Date.now()}`);
+          config = module.default || module;
+        } else {
+          const content = readFileSync(configPath, "utf-8");
+          config = JSON.parse(content);
+        }
+        if (typeof config !== "object" || config === null) {
+          throw new Error("Config must be an object");
+        }
+        return config;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const e = new Error(
+          `Failed to load config from ${configPath}: ${errorMessage}`
+        );
         try {
-          let config;
-          if (configFile.endsWith(".js")) {
-            const fileUrl = pathToFileURL(configPath).href;
-            const module = await import(`${fileUrl}?t=${Date.now()}`);
-            config = module.default || module;
-          } else {
-            const content = readFileSync(configPath, "utf-8");
-            config = JSON.parse(content);
-          }
-          if (typeof config !== "object" || config === null) {
-            throw new Error("Config must be an object");
-          }
-          return config;
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          const e = new Error(
-            `Failed to load config from ${configPath}: ${errorMessage}`
-          );
-          try {
-            e.cause = error instanceof Error ? error : void 0;
-          } catch {
-          }
-          throw e;
+          e.cause = error instanceof Error ? error : void 0;
+        } catch {
         }
+        throw e;
       }
     }
     const parent = dirname4(currentDir);
@@ -3085,6 +3254,24 @@ function collectFutureProofRecommendations(params) {
   }
   return recommendations;
 }
+function collectBaseFutureProofRecommendations(params) {
+  const recommendations = [];
+  for (const rec of params.patternEntropy.recommendations) {
+    recommendations.push({
+      action: rec,
+      estimatedImpact: 5,
+      priority: "medium"
+    });
+  }
+  if (params.conceptCohesion.rating === "poor") {
+    recommendations.push({
+      action: "Improve concept cohesion by grouping related exports",
+      estimatedImpact: 8,
+      priority: "high"
+    });
+  }
+  return recommendations;
+}
 
 // src/metrics/cognitive-load.ts
 function calculateCognitiveLoad(params) {
@@ -3775,21 +3962,10 @@ function calculateFutureProofScore(params) {
       description: params.conceptCohesion.rating
     }
   ];
-  const recommendations = [];
-  for (const rec of params.patternEntropy.recommendations) {
-    recommendations.push({
-      action: rec,
-      estimatedImpact: 5,
-      priority: "medium"
-    });
-  }
-  if (params.conceptCohesion.rating === "poor") {
-    recommendations.push({
-      action: "Improve concept cohesion by grouping related exports",
-      estimatedImpact: 8,
-      priority: "high"
-    });
-  }
+  const recommendations = collectBaseFutureProofRecommendations({
+    patternEntropy: params.patternEntropy,
+    conceptCohesion: params.conceptCohesion
+  });
   const semanticDistanceAvg = params.semanticDistances?.length ? params.semanticDistances.reduce((s, d) => s + d.distance, 0) / params.semanticDistances.length : 0;
   return {
     toolName: "future-proof",
@@ -4121,6 +4297,8 @@ export {
   TypeScriptParser,
   UnifiedReportSchema,
   VAGUE_FILE_NAMES,
+  buildSimpleProviderScore,
+  buildSpokeOutput,
   calculateAgentGrounding,
   calculateAiSignalClarity,
   calculateBusinessROI,
@@ -4144,6 +4322,7 @@ export {
   calculateTestabilityIndex,
   calculateTokenBudget,
   clearHistory,
+  createProvider,
   emitAnnotation,
   emitIssuesAsAnnotations,
   emitProgress,
@@ -4152,6 +4331,8 @@ export {
   exportHistory,
   extractFunctions,
   extractImports,
+  findLatestReport,
+  findLatestScanReport,
   formatAcceptanceRate,
   formatCost,
   formatHours,
@@ -4178,6 +4359,7 @@ export {
   getSupportedLanguages,
   getToolWeight,
   getWasmPath,
+  groupIssuesByFile,
   handleCLIError,
   handleJSONOutput,
   initTreeSitter,