@aiready/core 0.23.1 → 0.23.3

package/dist/index.mjs

@@ -38,12 +38,13 @@ import {
   getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingSlug,
   getRatingWithContext,
   getRecommendedThreshold,
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-5HIXDC3X.mjs";
+} from "./chunk-NGHT7JOG.mjs";
 
 // src/types/contract.ts
 function validateSpokeOutput(toolName, output) {
@@ -439,8 +440,15 @@ 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";
+import chalk from "chalk";
 function resolveOutputPath(userPath, defaultFilename, workingDir = process.cwd()) {
   let outputPath;
   if (userPath) {
@@ -508,25 +516,180 @@ function emitProgress(processed, total, toolId, message, onProgress, throttleCou
     onProgress(processed, total, `${message} (${processed}/${total})`);
   }
 }
-function getSeverityColor(severity, chalk) {
+function getSeverityColor(severity, chalkInstance = chalk) {
   switch (severity.toLowerCase()) {
     case "critical":
     case "high-risk":
     case "blind-risk":
-      return chalk.red;
+      return chalkInstance.red;
     case "major":
     case "moderate-risk":
-      return chalk.yellow;
+      return chalkInstance.yellow;
     case "minor":
     case "safe":
-      return chalk.green;
+      return chalkInstance.green;
+    case "info":
+      return chalkInstance.blue;
+    default:
+      return chalkInstance.white;
+  }
+}
+function getSeverityValue(s) {
+  if (!s) return 0;
+  switch (s.toLowerCase()) {
+    case "critical":
+      return 4;
+    case "major":
+      return 3;
+    case "minor":
+      return 2;
     case "info":
-      return chalk.blue;
+      return 1;
+    default:
+      return 0;
+  }
+}
+function getSeverityLevel(s) {
+  return getSeverityValue(s);
+}
+function getSeverityBadge(severity, chalkInstance = chalk) {
+  const val = getSeverityValue(
+    typeof severity === "string" ? severity : severity
+  );
+  switch (val) {
+    case 4:
+      return chalkInstance.bgRed.white.bold(" CRITICAL ");
+    case 3:
+      return chalkInstance.bgYellow.black.bold(" MAJOR ");
+    case 2:
+      return chalkInstance.bgBlue.white.bold(" MINOR ");
+    case 1:
+      return chalkInstance.bgCyan.black(" INFO ");
+    default:
+      return chalkInstance.bgCyan.black(" INFO ");
+  }
+}
+function getSeverityEnum(s) {
+  const level = getSeverityLevel(s);
+  switch (level) {
+    case 4:
+      return "critical";
+    case 3:
+      return "major";
+    case 2:
+      return "minor";
+    case 1:
+      return "info";
     default:
-      return chalk.white;
+      return "info";
+  }
+}
+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";
 
@@ -653,8 +816,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.)
@@ -865,6 +1030,101 @@ var TypeScriptParser = class {
   }
 };
 
+// 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/tree-sitter-utils.ts
 import * as Parser from "web-tree-sitter";
 import * as path from "path";
@@ -953,11 +1213,9 @@ async function setupParser(language) {
   }
 }
 
-// src/parsers/python-parser.ts
-var PythonParser = class {
+// src/parsers/base-parser.ts
+var BaseLanguageParser = class {
   constructor() {
-    this.language = "python" /* Python */;
-    this.extensions = [".py"];
     this.parser = null;
     this.initialized = false;
   }
@@ -966,48 +1224,18 @@ var PythonParser = class {
    */
   async initialize() {
     if (this.initialized) return;
-    this.parser = await setupParser("python");
-    this.initialized = true;
+    try {
+      this.parser = await setupParser(this.getParserName());
+      this.initialized = true;
+    } catch (error) {
+      console.warn(`Failed to initialize ${this.language} parser:`, error);
+    }
   }
   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;
-        }
-      }
-      for (const child of n.children) {
-        walk(child);
-      }
-    };
-    if (body) walk(body);
-    return metadata;
-  }
   parse(code, filePath) {
     if (!this.initialized || !this.parser) {
       return this.parseRegex(code, filePath);
@@ -1017,19 +1245,42 @@ var PythonParser = class {
       if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
         return this.parseRegex(code, filePath);
       }
-      const rootNode = tree.rootNode;
-      const imports = this.extractImportsAST(rootNode);
-      const exports = this.extractExportsAST(rootNode, code);
+      const imports = this.extractImportsAST(tree.rootNode);
+      const exports = this.extractExportsAST(tree.rootNode, code);
       return {
         exports,
         imports,
-        language: "python" /* Python */,
+        language: this.language,
         warnings: []
       };
     } catch (error) {
+      console.warn(
+        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
+      );
       return this.parseRegex(code, filePath);
     }
   }
+  canHandle(filePath) {
+    const lowerPath = filePath.toLowerCase();
+    return this.extensions.some((ext) => lowerPath.endsWith(ext));
+  }
+};
+
+// src/parsers/python-parser.ts
+var PythonParser = class extends BaseLanguageParser {
+  constructor() {
+    super(...arguments);
+    this.language = "python" /* Python */;
+    this.extensions = [".py"];
+  }
+  getParserName() {
+    return "python";
+  }
+  analyzeMetadata(node, code) {
+    return analyzeNodeMetadata(node, code, {
+      sideEffectSignatures: ["print(", "input(", "open("]
+    });
+  }
   extractImportsAST(rootNode) {
     const imports = [];
     const processImportNode = (node) => {
@@ -1355,94 +1606,132 @@ var PythonParser = class {
   }
 };
 
-// src/parsers/java-parser.ts
-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;
-    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("/**")) {
+// 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: prev.text.replace(/[/*]/g, "").trim(),
+          content: text.replace(/^\/\/\//, "").trim(),
           type: "xml-doc"
-          // Using xml-doc as a catch-all for structured or we can add 'javadoc'
+        };
+        break;
+      }
+      if (text.trim().startsWith("//")) {
+        metadata.documentation = {
+          content: text.replace(/^\/\//, "").trim(),
+          type: "comment"
         };
         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") {
+  } 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;
       }
-      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) {
-      return this.parseRegex(code, filePath);
     }
-    try {
-      const tree = this.parser.parse(code);
-      if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
-        return this.parseRegex(code, filePath);
+    if (!metadata.hasSideEffects) {
+      for (let i = 0; i < n.childCount; i++) {
+        const child = n.child(i);
+        if (child) walk(child);
       }
-      const rootNode = tree.rootNode;
-      const imports = this.extractImportsAST(rootNode);
-      const exports = this.extractExportsAST(rootNode, code);
-      return {
-        exports,
-        imports,
-        language: "java" /* Java */,
-        warnings: []
-      };
-    } catch (error) {
-      console.warn(
-        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
-      );
-      return this.parseRegex(code, filePath);
     }
+  };
+  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 extends BaseLanguageParser {
+  constructor() {
+    super(...arguments);
+    this.language = "java" /* Java */;
+    this.extensions = [".java"];
+  }
+  getParserName() {
+    return "java";
+  }
+  analyzeMetadata(node, code) {
+    return analyzeGeneralMetadata(node, code, {
+      sideEffectSignatures: [
+        "System.out",
+        "System.err",
+        "Files.write",
+        "Logging."
+      ]
+    });
   }
   parseRegex(code, filePath) {
     const lines = code.split("\n");
@@ -1517,7 +1806,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) {
@@ -1615,14 +1904,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 {
@@ -1639,91 +1921,19 @@ var JavaParser = class {
 };
 
 // src/parsers/csharp-parser.ts
-var CSharpParser = class {
+var CSharpParser = class extends BaseLanguageParser {
   constructor() {
+    super(...arguments);
     this.language = "csharp" /* CSharp */;
     this.extensions = [".cs"];
-    this.parser = null;
-    this.initialized = false;
   }
-  /**
-   * Initialize the tree-sitter parser
-   */
-  async initialize() {
-    if (this.initialized) return;
-    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);
+  getParserName() {
+    return "c_sharp";
   }
   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;
-  }
-  parse(code, filePath) {
-    if (!this.initialized || !this.parser) {
-      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 exports = this.extractExportsAST(rootNode, code);
-      return {
-        exports,
-        imports,
-        language: "csharp" /* CSharp */,
-        warnings: []
-      };
-    } catch (error) {
-      console.warn(
-        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
-      );
-      return this.parseRegex(code, filePath);
-    }
+    return analyzeGeneralMetadata(node, code, {
+      sideEffectSignatures: ["Console.Write", "File.Write", "Logging."]
+    });
   }
   parseRegex(code, filePath) {
     const lines = code.split("\n");
@@ -1905,19 +2115,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 {
@@ -1933,86 +2131,19 @@ var CSharpParser = class {
 };
 
 // src/parsers/go-parser.ts
-var GoParser = class {
+var GoParser = class extends BaseLanguageParser {
   constructor() {
+    super(...arguments);
     this.language = "go" /* Go */;
     this.extensions = [".go"];
-    this.parser = null;
-    this.initialized = false;
   }
-  /**
-   * Initialize the tree-sitter parser
-   */
-  async initialize() {
-    if (this.initialized) return;
-    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);
+  getParserName() {
+    return "go";
   }
   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;
-  }
-  parse(code, filePath) {
-    if (!this.initialized || !this.parser) {
-      return this.parseRegex(code, filePath);
-    }
-    try {
-      const tree = this.parser.parse(code);
-      if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
-        return this.parseRegex(code, filePath);
-      }
-      const rootNode = tree.rootNode;
-      const imports = this.extractImportsAST(rootNode);
-      const exports = this.extractExportsAST(rootNode, code);
-      return {
-        exports,
-        imports,
-        language: "go" /* Go */,
-        warnings: []
-      };
-    } catch (error) {
-      console.warn(
-        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
-      );
-      return this.parseRegex(code, filePath);
-    }
+    return analyzeGeneralMetadata(node, code, {
+      sideEffectSignatures: ["<-", "fmt.Print", "fmt.Fprintf", "os.Exit"]
+    });
   }
   parseRegex(code, filePath) {
     const lines = code.split("\n");
@@ -2209,17 +2340,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 {
@@ -2350,48 +2471,7 @@ function getSupportedLanguages() {
   return ParserFactory.getInstance().getSupportedLanguages();
 }
 
-// src/utils/ast-parser.ts
-function parseFileExports(code, filePath) {
-  const parser = getParser(filePath);
-  if (parser && parser.language !== "typescript" /* TypeScript */ && parser.language !== "javascript" /* JavaScript */) {
-    try {
-      const result = parser.parse(code, filePath);
-      return {
-        exports: result.exports.map((e) => ({
-          name: e.name,
-          type: e.type,
-          imports: e.imports || [],
-          dependencies: e.dependencies || [],
-          typeReferences: e.typeReferences || [],
-          loc: e.loc ? {
-            start: { line: e.loc.start.line, column: e.loc.start.column },
-            end: { line: e.loc.end.line, column: e.loc.end.column }
-          } : void 0
-        })),
-        imports: result.imports.map((i) => ({
-          source: i.source,
-          specifiers: i.specifiers,
-          isTypeOnly: i.isTypeOnly || false
-        }))
-      };
-    } catch (e) {
-      return { exports: [], imports: [] };
-    }
-  }
-  try {
-    const ast = parse2(code, {
-      loc: true,
-      range: true,
-      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
-      filePath
-    });
-    const imports = extractFileImports(ast);
-    const exports = extractExportsWithDependencies(ast, imports);
-    return { exports, imports };
-  } catch (error) {
-    return { exports: [], imports: [] };
-  }
-}
+// src/utils/ast-visitor.ts
 function extractFileImports(ast) {
   const imports = [];
   for (const node of ast.body) {
@@ -2449,22 +2529,23 @@ function extractExportsWithDependencies(ast, fileImports) {
   }
   return exports;
 }
-function extractFromDeclaration(declaration) {
+function extractFromDeclaration(node) {
+  if (!node) return [];
   const results = [];
-  if (declaration.type === "FunctionDeclaration" && "id" in declaration && declaration.id) {
-    results.push({ name: declaration.id.name, type: "function" });
-  } else if (declaration.type === "ClassDeclaration" && "id" in declaration && declaration.id) {
-    results.push({ name: declaration.id.name, type: "class" });
-  } else if (declaration.type === "VariableDeclaration") {
-    for (const declarator of declaration.declarations) {
-      if (declarator.id.type === "Identifier") {
-        results.push({ name: declarator.id.name, type: "const" });
+  if (node.type === "FunctionDeclaration" && node.id) {
+    results.push({ name: node.id.name, type: "function" });
+  } else if (node.type === "ClassDeclaration" && node.id) {
+    results.push({ name: node.id.name, type: "class" });
+  } else if (node.type === "VariableDeclaration") {
+    for (const decl of node.declarations) {
+      if (decl.id.type === "Identifier") {
+        results.push({ name: decl.id.name, type: "const" });
       }
     }
-  } else if (declaration.type === "TSTypeAliasDeclaration") {
-    results.push({ name: declaration.id.name, type: "type" });
-  } else if (declaration.type === "TSInterfaceDeclaration") {
-    results.push({ name: declaration.id.name, type: "interface" });
+  } else if (node.type === "TSInterfaceDeclaration" && node.id) {
+    results.push({ name: node.id.name, type: "interface" });
+  } else if (node.type === "TSTypeAliasDeclaration" && node.id) {
+    results.push({ name: node.id.name, type: "type" });
   }
   return results;
 }
@@ -2492,16 +2573,6 @@ function findUsedImports(node, importedNames) {
   visit(node);
   return Array.from(usedImports);
 }
-function calculateImportSimilarity(export1, export2) {
-  if (export1.imports.length === 0 && export2.imports.length === 0) {
-    return 1;
-  }
-  const set1 = new Set(export1.imports);
-  const set2 = new Set(export2.imports);
-  const intersection = new Set([...set1].filter((x) => set2.has(x)));
-  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
-  return intersection.size / union.size;
-}
 function extractTypeReferences(node) {
   const types = /* @__PURE__ */ new Set();
   function visit(n) {
@@ -2539,6 +2610,59 @@ function extractTypeReferences(node) {
   visit(node);
   return Array.from(types);
 }
+
+// src/utils/ast-parser.ts
+function parseFileExports(code, filePath) {
+  const parser = getParser(filePath);
+  if (parser && parser.language !== "typescript" /* TypeScript */ && parser.language !== "javascript" /* JavaScript */) {
+    try {
+      const result = parser.parse(code, filePath);
+      return {
+        exports: result.exports.map((e) => ({
+          name: e.name,
+          type: e.type,
+          imports: e.imports || [],
+          dependencies: e.dependencies || [],
+          typeReferences: e.typeReferences || [],
+          loc: e.loc ? {
+            start: { line: e.loc.start.line, column: e.loc.start.column },
+            end: { line: e.loc.end.line, column: e.loc.end.column }
+          } : void 0
+        })),
+        imports: result.imports.map((i) => ({
+          source: i.source,
+          specifiers: i.specifiers,
+          isTypeOnly: i.isTypeOnly || false
+        }))
+      };
+    } catch (e) {
+      return { exports: [], imports: [] };
+    }
+  }
+  try {
+    const ast = parse2(code, {
+      loc: true,
+      range: true,
+      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
+      filePath
+    });
+    const imports = extractFileImports(ast);
+    const exports = extractExportsWithDependencies(ast, imports);
+    return { exports, imports };
+  } catch (error) {
+    return { exports: [], imports: [] };
+  }
+}
+function calculateImportSimilarity(export1, export2) {
+  if (export1.imports.length === 0 && export2.imports.length === 0) {
+    return 1;
+  }
+  const set1 = new Set(export1.imports);
+  const set2 = new Set(export2.imports);
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
 function parseCode(code, language) {
   return null;
 }
@@ -2569,34 +2693,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 configError = 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;
+          configError.cause = error instanceof Error ? error : void 0;
+        } catch {
         }
+        throw configError;
       }
     }
     const parent = dirname4(currentDir);
@@ -2609,28 +2746,28 @@ async function loadConfig(rootDir) {
 }
 function mergeConfigWithDefaults(userConfig, defaults) {
   if (!userConfig) return defaults;
-  const result = { ...defaults };
+  const mergedConfig = { ...defaults };
   if (userConfig.scan) {
-    if (userConfig.scan.include) result.include = userConfig.scan.include;
-    if (userConfig.scan.exclude) result.exclude = userConfig.scan.exclude;
+    if (userConfig.scan.include) mergedConfig.include = userConfig.scan.include;
+    if (userConfig.scan.exclude) mergedConfig.exclude = userConfig.scan.exclude;
   }
   const toolOverrides = userConfig.tools && !Array.isArray(userConfig.tools) && typeof userConfig.tools === "object" ? userConfig.tools : userConfig.toolConfigs;
   if (toolOverrides) {
-    if (!result.toolConfigs) result.toolConfigs = {};
+    if (!mergedConfig.toolConfigs) mergedConfig.toolConfigs = {};
     for (const [toolName, toolConfig] of Object.entries(toolOverrides)) {
       if (typeof toolConfig === "object" && toolConfig !== null) {
-        result[toolName] = { ...result[toolName], ...toolConfig };
-        result.toolConfigs[toolName] = {
-          ...result.toolConfigs[toolName],
+        mergedConfig[toolName] = { ...mergedConfig[toolName], ...toolConfig };
+        mergedConfig.toolConfigs[toolName] = {
+          ...mergedConfig.toolConfigs[toolName],
           ...toolConfig
         };
       }
     }
   }
   if (userConfig.output) {
-    result.output = { ...result.output, ...userConfig.output };
+    mergedConfig.output = { ...mergedConfig.output, ...userConfig.output };
   }
-  return result;
+  return mergedConfig;
 }
 
 // src/business/pricing-models.ts
@@ -2843,7 +2980,10 @@ function predictAcceptanceRate(toolOutputs) {
       impact: Math.round((50 - aiSignalClarity.score) * 2e-3 * 100)
     });
   }
-  const totalImpact = factors.reduce((sum, f) => sum + f.impact / 100, 0);
+  const totalImpact = factors.reduce(
+    (sum, f) => sum + f.impact / 100,
+    0
+  );
   const rate = Math.max(0.05, Math.min(0.8, baseRate + totalImpact));
   let confidence = 0.35;
   if (toolOutputs.size >= 4) confidence = 0.75;
@@ -3086,6 +3226,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) {
@@ -3776,21 +3934,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",
@@ -4122,6 +4269,8 @@ export {
   TypeScriptParser,
   UnifiedReportSchema,
   VAGUE_FILE_NAMES,
+  buildSimpleProviderScore,
+  buildSpokeOutput,
   calculateAgentGrounding,
   calculateAiSignalClarity,
   calculateBusinessROI,
@@ -4145,6 +4294,7 @@ export {
   calculateTestabilityIndex,
   calculateTokenBudget,
   clearHistory,
+  createProvider,
   emitAnnotation,
   emitIssuesAsAnnotations,
   emitProgress,
@@ -4153,6 +4303,8 @@ export {
   exportHistory,
   extractFunctions,
   extractImports,
+  findLatestReport,
+  findLatestScanReport,
   formatAcceptanceRate,
   formatCost,
   formatHours,
@@ -4170,15 +4322,21 @@ export {
   getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingSlug,
   getRatingWithContext,
   getRecommendedThreshold,
   getRepoMetadata,
   getSafetyIcon,
   getScoreBar,
+  getSeverityBadge,
   getSeverityColor,
+  getSeverityEnum,
+  getSeverityLevel,
+  getSeverityValue,
   getSupportedLanguages,
   getToolWeight,
   getWasmPath,
+  groupIssuesByFile,
   handleCLIError,
   handleJSONOutput,
   initTreeSitter,