@aiready/agent-grounding 0.13.18 → 0.13.20

package/dist/chunk-SS3ETQAF.mjs

@@ -0,0 +1,276 @@
+// src/analyzer.ts
+import {
+  scanEntries,
+  calculateAgentGrounding,
+  VAGUE_FILE_NAMES,
+  Severity,
+  IssueType,
+  emitProgress
+} from "@aiready/core";
+import { readFileSync, existsSync, statSync } from "fs";
+import { join, extname, basename, relative } from "path";
+import { parse } from "@typescript-eslint/typescript-estree";
+function analyzeFile(filePath) {
+  let code;
+  try {
+    code = readFileSync(filePath, "utf-8");
+  } catch {
+    return {
+      isBarrel: false,
+      exportedNames: [],
+      untypedExports: 0,
+      totalExports: 0,
+      domainTerms: []
+    };
+  }
+  let ast;
+  try {
+    ast = parse(code, {
+      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
+      range: false,
+      loc: false
+    });
+  } catch {
+    return {
+      isBarrel: false,
+      exportedNames: [],
+      untypedExports: 0,
+      totalExports: 0,
+      domainTerms: []
+    };
+  }
+  let isBarrel = false;
+  const exportedNames = [];
+  let untypedExports = 0;
+  let totalExports = 0;
+  const domainTerms = [];
+  for (const node of ast.body) {
+    if (node.type === "ExportAllDeclaration") {
+      isBarrel = true;
+      continue;
+    }
+    if (node.type === "ExportNamedDeclaration") {
+      totalExports++;
+      const decl = node.declaration;
+      if (decl) {
+        const name = decl.id?.name ?? decl.declarations?.[0]?.id?.name;
+        if (name) {
+          exportedNames.push(name);
+          domainTerms.push(
+            ...name.replace(/([A-Z])/g, " $1").toLowerCase().split(/\s+/).filter(Boolean)
+          );
+          const hasType = decl.returnType != null || decl.declarations?.[0]?.id?.typeAnnotation != null || decl.typeParameters != null;
+          if (!hasType) untypedExports++;
+        }
+      } else if (node.specifiers && node.specifiers.length > 0) {
+        isBarrel = true;
+      }
+    }
+    if (node.type === "ExportDefaultDeclaration") {
+      totalExports++;
+    }
+  }
+  return { isBarrel, exportedNames, untypedExports, totalExports, domainTerms };
+}
+function detectInconsistentTerms(allTerms) {
+  const termFreq = /* @__PURE__ */ new Map();
+  for (const term of allTerms) {
+    if (term.length >= 3) {
+      termFreq.set(term, (termFreq.get(term) ?? 0) + 1);
+    }
+  }
+  const orphans = [...termFreq.values()].filter((count) => count === 1).length;
+  const common = [...termFreq.values()].filter((count) => count >= 3).length;
+  const vocabularySize = termFreq.size;
+  const inconsistent = Math.max(0, orphans - common * 2);
+  return { inconsistent, vocabularySize };
+}
+async function analyzeAgentGrounding(options) {
+  const rootDir = options.rootDir;
+  const maxRecommendedDepth = options.maxRecommendedDepth ?? 4;
+  const readmeStaleDays = options.readmeStaleDays ?? 90;
+  const { files, dirs: rawDirs } = await scanEntries({
+    ...options,
+    include: options.include || ["**/*.{ts,tsx,js,jsx}"]
+  });
+  const { files: allFiles } = await scanEntries({
+    ...options,
+    include: ["**/*"]
+  });
+  const dirs = rawDirs.map((d) => ({
+    path: d,
+    depth: relative(rootDir, d).split(/[/\\]/).filter(Boolean).length
+  }));
+  const deepDirectories = dirs.filter(
+    (d) => d.depth > maxRecommendedDepth
+  ).length;
+  const additionalVague = new Set(
+    (options.additionalVagueNames ?? []).map((n) => n.toLowerCase())
+  );
+  let vagueFileNames = 0;
+  for (const f of allFiles) {
+    const base = basename(f, extname(f)).toLowerCase();
+    if (VAGUE_FILE_NAMES.has(base) || additionalVague.has(base)) {
+      vagueFileNames++;
+    }
+  }
+  const readmePath = join(rootDir, "README.md");
+  const hasRootReadme = existsSync(readmePath);
+  let readmeIsFresh = false;
+  if (hasRootReadme) {
+    try {
+      const stat = statSync(readmePath);
+      const ageDays = (Date.now() - stat.mtimeMs) / (1e3 * 60 * 60 * 24);
+      readmeIsFresh = ageDays < readmeStaleDays;
+    } catch {
+    }
+  }
+  const allDomainTerms = [];
+  let barrelExports = 0;
+  let untypedExports = 0;
+  let totalExports = 0;
+  let processed = 0;
+  for (const f of files) {
+    processed++;
+    emitProgress(
+      processed,
+      files.length,
+      "agent-grounding",
+      "analyzing files",
+      options.onProgress
+    );
+    const analysis = analyzeFile(f);
+    if (analysis.isBarrel) barrelExports++;
+    untypedExports += analysis.untypedExports;
+    totalExports += analysis.totalExports;
+    allDomainTerms.push(...analysis.domainTerms);
+  }
+  const {
+    inconsistent: inconsistentDomainTerms,
+    vocabularySize: domainVocabularySize
+  } = detectInconsistentTerms(allDomainTerms);
+  const groundingResult = calculateAgentGrounding({
+    deepDirectories,
+    totalDirectories: dirs.length,
+    vagueFileNames,
+    totalFiles: files.length,
+    hasRootReadme,
+    readmeIsFresh,
+    barrelExports,
+    untypedExports,
+    totalExports: Math.max(1, totalExports),
+    inconsistentDomainTerms,
+    domainVocabularySize: Math.max(1, domainVocabularySize)
+  });
+  const issues = [];
+  if (groundingResult.dimensions.structureClarityScore < 70) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "structure-clarity",
+      severity: Severity.Major,
+      message: `${deepDirectories} directories exceed recommended depth of ${maxRecommendedDepth} \u2014 agents struggle to navigate deep trees.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: `Flatten nested directories to ${maxRecommendedDepth} levels or fewer.`
+    });
+  }
+  if (groundingResult.dimensions.selfDocumentationScore < 70) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "self-documentation",
+      severity: Severity.Major,
+      message: `${vagueFileNames} files use vague names (utils, helpers, misc) \u2014 an agent cannot determine their purpose from the name alone.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: "Rename to domain-specific names: e.g., userAuthUtils \u2192 tokenValidator."
+    });
+  }
+  if (!hasRootReadme) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "entry-point",
+      severity: Severity.Critical,
+      message: "No root README.md found \u2014 agents have no orientation document to start from.",
+      location: { file: join(rootDir, "README.md"), line: 0 },
+      suggestion: "Add a README.md explaining the project structure, entry points, and key conventions."
+    });
+  } else if (!readmeIsFresh) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "entry-point",
+      severity: Severity.Minor,
+      message: `README.md is stale (>${readmeStaleDays} days without updates) \u2014 agents may be misled by outdated context.`,
+      location: { file: readmePath, line: 0 },
+      suggestion: "Update README.md to reflect the current codebase structure."
+    });
+  }
+  if (groundingResult.dimensions.apiClarityScore < 70) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "api-clarity",
+      severity: Severity.Major,
+      message: `${untypedExports} of ${totalExports} public exports lack TypeScript type annotations \u2014 agents cannot infer the API contract.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: "Add explicit return type and parameter annotations to all exported functions."
+    });
+  }
+  if (groundingResult.dimensions.domainConsistencyScore < 70) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "domain-consistency",
+      severity: Severity.Major,
+      message: `${inconsistentDomainTerms} domain terms appear to be used inconsistently \u2014 agents get confused when one concept has multiple names.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: "Establish a domain glossary and enforce one term per concept across the codebase."
+    });
+  }
+  return {
+    summary: {
+      filesAnalyzed: files.length,
+      directoriesAnalyzed: dirs.length,
+      score: groundingResult.score,
+      rating: groundingResult.rating,
+      dimensions: groundingResult.dimensions
+    },
+    issues,
+    rawData: {
+      deepDirectories,
+      totalDirectories: dirs.length,
+      vagueFileNames,
+      totalFiles: files.length,
+      hasRootReadme,
+      readmeIsFresh,
+      barrelExports,
+      untypedExports,
+      totalExports,
+      inconsistentDomainTerms,
+      domainVocabularySize
+    },
+    recommendations: groundingResult.recommendations
+  };
+}
+
+// src/scoring.ts
+import { ToolName, buildStandardToolScore } from "@aiready/core";
+function calculateGroundingScore(report) {
+  const { summary, rawData, recommendations } = report;
+  return buildStandardToolScore({
+    toolName: ToolName.AgentGrounding,
+    score: summary.score,
+    rawData,
+    dimensions: summary.dimensions,
+    dimensionNames: {
+      structureClarityScore: "Structure Clarity",
+      selfDocumentationScore: "Self-Documentation",
+      entryPointScore: "Entry Points",
+      apiClarityScore: "API Clarity",
+      domainConsistencyScore: "Domain Consistency"
+    },
+    recommendations,
+    recommendationImpact: 6,
+    rating: summary.rating
+  });
+}
+
+export {
+  analyzeAgentGrounding,
+  calculateGroundingScore
+};

package/dist/cli.js

@@ -30,68 +30,45 @@ var import_commander = require("commander");
 var import_core = require("@aiready/core");
 var import_fs = require("fs");
 var import_path = require("path");
-var import_typescript_estree = require("@typescript-eslint/typescript-estree");
-function analyzeFile(filePath) {
+async function analyzeFile(filePath) {
+  const result = {
+    isBarrel: false,
+    exportedNames: [],
+    untypedExports: 0,
+    totalExports: 0,
+    domainTerms: []
+  };
+  const parser = await (0, import_core.getParser)(filePath);
+  if (!parser) return result;
   let code;
   try {
     code = (0, import_fs.readFileSync)(filePath, "utf-8");
   } catch {
-    return {
-      isBarrel: false,
-      exportedNames: [],
-      untypedExports: 0,
-      totalExports: 0,
-      domainTerms: []
-    };
+    return result;
   }
-  let ast;
   try {
-    ast = (0, import_typescript_estree.parse)(code, {
-      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
-      range: false,
-      loc: false
-    });
-  } catch {
-    return {
-      isBarrel: false,
-      exportedNames: [],
-      untypedExports: 0,
-      totalExports: 0,
-      domainTerms: []
-    };
-  }
-  let isBarrel = false;
-  const exportedNames = [];
-  let untypedExports = 0;
-  let totalExports = 0;
-  const domainTerms = [];
-  for (const node of ast.body) {
-    if (node.type === "ExportAllDeclaration") {
-      isBarrel = true;
-      continue;
-    }
-    if (node.type === "ExportNamedDeclaration") {
-      totalExports++;
-      const decl = node.declaration;
-      if (decl) {
-        const name = decl.id?.name ?? decl.declarations?.[0]?.id?.name;
-        if (name) {
-          exportedNames.push(name);
-          domainTerms.push(
+    await parser.initialize();
+    const parseResult = parser.parse(code, filePath);
+    for (const exp of parseResult.exports) {
+      if (exp.type === "function" || exp.type === "class" || exp.type === "const") {
+        result.totalExports++;
+        const name = exp.name;
+        if (name && name !== "default") {
+          result.exportedNames.push(name);
+          result.domainTerms.push(
             ...name.replace(/([A-Z])/g, " $1").toLowerCase().split(/\s+/).filter(Boolean)
           );
-          const hasType = decl.returnType != null || decl.declarations?.[0]?.id?.typeAnnotation != null || decl.typeParameters != null;
-          if (!hasType) untypedExports++;
+          if (exp.isTyped === false) {
+            result.untypedExports++;
+          }
         }
-      } else if (node.specifiers && node.specifiers.length > 0) {
-        isBarrel = true;
       }
+      if (parseResult.exports.length > 5) result.isBarrel = true;
     }
-    if (node.type === "ExportDefaultDeclaration") {
-      totalExports++;
-    }
+  } catch (error) {
+    console.warn(`Agent Grounding: Failed to parse ${filePath}: ${error}`);
   }
-  return { isBarrel, exportedNames, untypedExports, totalExports, domainTerms };
+  return result;
 }
 function detectInconsistentTerms(allTerms) {
   const termFreq = /* @__PURE__ */ new Map();
@@ -160,7 +137,7 @@ async function analyzeAgentGrounding(options) {
       "analyzing files",
       options.onProgress
     );
-    const analysis = analyzeFile(f);
+    const analysis = await analyzeFile(f);
     if (analysis.isBarrel) barrelExports++;
     untypedExports += analysis.untypedExports;
     totalExports += analysis.totalExports;
@@ -223,11 +200,11 @@ async function analyzeAgentGrounding(options) {
       suggestion: "Update README.md to reflect the current codebase structure."
     });
   }
-  if (groundingResult.dimensions.apiClarityScore < 70) {
+  if (untypedExports > 0) {
     issues.push({
       type: import_core.IssueType.AgentNavigationFailure,
       dimension: "api-clarity",
-      severity: import_core.Severity.Major,
+      severity: groundingResult.dimensions.apiClarityScore < 70 ? import_core.Severity.Major : import_core.Severity.Minor,
       message: `${untypedExports} of ${totalExports} public exports lack TypeScript type annotations \u2014 agents cannot infer the API contract.`,
       location: { file: rootDir, line: 0 },
       suggestion: "Add explicit return type and parameter annotations to all exported functions."
@@ -273,50 +250,28 @@ async function analyzeAgentGrounding(options) {
 var import_core2 = require("@aiready/core");
 function calculateGroundingScore(report) {
   const { summary, rawData, recommendations } = report;
-  const factors = [
-    {
-      name: "Structure Clarity",
-      impact: Math.round(summary.dimensions.structureClarityScore - 50),
-      description: `${rawData.deepDirectories} of ${rawData.totalDirectories} dirs exceed recommended depth`
-    },
-    {
-      name: "Self-Documentation",
-      impact: Math.round(summary.dimensions.selfDocumentationScore - 50),
-      description: `${rawData.vagueFileNames} of ${rawData.totalFiles} files have vague names`
-    },
-    {
-      name: "Entry Points",
-      impact: Math.round(summary.dimensions.entryPointScore - 50),
-      description: rawData.hasRootReadme ? rawData.readmeIsFresh ? "README present and fresh" : "README present but stale" : "No root README"
-    },
-    {
-      name: "API Clarity",
-      impact: Math.round(summary.dimensions.apiClarityScore - 50),
-      description: `${rawData.untypedExports} of ${rawData.totalExports} exports lack type annotations`
-    },
-    {
-      name: "Domain Consistency",
-      impact: Math.round(summary.dimensions.domainConsistencyScore - 50),
-      description: `${rawData.inconsistentDomainTerms} inconsistent domain terms detected`
-    }
-  ];
-  const recs = recommendations.map(
-    (action) => ({
-      action,
-      estimatedImpact: 6,
-      priority: summary.score < 50 ? "high" : "medium"
-    })
-  );
-  return {
+  return (0, import_core2.buildStandardToolScore)({
     toolName: import_core2.ToolName.AgentGrounding,
     score: summary.score,
-    rawMetrics: {
-      ...rawData,
-      rating: summary.rating
+    rawData,
+    dimensions: {
+      structureClarityScore: summary.dimensions.structureClarityScore,
+      selfDocumentationScore: summary.dimensions.selfDocumentationScore,
+      entryPointScore: summary.dimensions.entryPointScore,
+      apiClarityScore: summary.dimensions.apiClarityScore,
+      domainConsistencyScore: summary.dimensions.domainConsistencyScore
     },
-    factors,
-    recommendations: recs
-  };
+    dimensionNames: {
+      structureClarityScore: "Structure Clarity",
+      selfDocumentationScore: "Self-Documentation",
+      entryPointScore: "Entry Points",
+      apiClarityScore: "API Clarity",
+      domainConsistencyScore: "Domain Consistency"
+    },
+    recommendations,
+    recommendationImpact: 6,
+    rating: summary.rating
+  });
 }
 
 // src/cli.ts
@@ -380,65 +335,41 @@ EXAMPLES:
     (0, import_fs2.writeFileSync)(outputPath, JSON.stringify(payload, null, 2));
     console.log(import_chalk.default.green(`\u2713 Report saved to ${outputPath}`));
   } else {
-    displayConsoleReport(report, scoring, elapsed);
+    (0, import_core3.displayStandardConsoleReport)({
+      title: "\u{1F9ED} Agent Grounding Analysis",
+      score: scoring.summary.score,
+      rating: scoring.summary.rating,
+      dimensions: [
+        {
+          name: "Structure Clarity",
+          value: scoring.summary.dimensions.structureClarityScore
+        },
+        {
+          name: "Self-Documentation",
+          value: scoring.summary.dimensions.selfDocumentationScore
+        },
+        {
+          name: "Entry Points",
+          value: scoring.summary.dimensions.entryPointScore
+        },
+        {
+          name: "API Clarity",
+          value: scoring.summary.dimensions.apiClarityScore
+        },
+        {
+          name: "Domain Consistency",
+          value: scoring.summary.dimensions.domainConsistencyScore
+        }
+      ],
+      stats: [
+        { label: "Files", value: scoring.summary.filesAnalyzed },
+        { label: "Directories", value: scoring.summary.directoriesAnalyzed }
+      ],
+      issues: report.issues,
+      recommendations: report.recommendations,
+      elapsedTime: elapsed,
+      noIssuesMessage: "\u2728 No grounding issues found \u2014 agents can navigate freely!"
+    });
   }
 });
 program.parse();
-function scoreColor(score) {
-  if (score >= 85) return import_chalk.default.green;
-  if (score >= 70) return import_chalk.default.cyan;
-  if (score >= 50) return import_chalk.default.yellow;
-  if (score >= 30) return import_chalk.default.red;
-  return import_chalk.default.bgRed.white;
-}
-function displayConsoleReport(report, scoring, elapsed) {
-  const { summary, issues, recommendations } = report;
-  console.log(import_chalk.default.bold("\n\u{1F9ED} Agent Grounding Analysis\n"));
-  console.log(
-    `Score:       ${scoreColor(summary.score)(summary.score + "/100")} (${summary.rating.toUpperCase()})`
-  );
-  console.log(
-    `Files:       ${import_chalk.default.cyan(summary.filesAnalyzed)}   Directories: ${import_chalk.default.cyan(summary.directoriesAnalyzed)}`
-  );
-  console.log(`Analysis:    ${import_chalk.default.gray(elapsed + "s")}
-`);
-  console.log(import_chalk.default.bold("\u{1F4D0} Dimension Scores\n"));
-  const dims = [
-    ["Structure Clarity", summary.dimensions.structureClarityScore],
-    ["Self-Documentation", summary.dimensions.selfDocumentationScore],
-    ["Entry Points", summary.dimensions.entryPointScore],
-    ["API Clarity", summary.dimensions.apiClarityScore],
-    ["Domain Consistency", summary.dimensions.domainConsistencyScore]
-  ];
-  for (const [name, val] of dims) {
-    const bar = "\u2588".repeat(Math.round(val / 10)).padEnd(10, "\u2591");
-    console.log(
-      `  ${String(name).padEnd(22)} ${scoreColor(val)(bar)} ${val}/100`
-    );
-  }
-  if (issues.length > 0) {
-    console.log(import_chalk.default.bold("\n\u26A0\uFE0F  Issues Found\n"));
-    for (const issue of issues) {
-      const sev = issue.severity === "critical" ? import_chalk.default.red : issue.severity === "major" ? import_chalk.default.yellow : import_chalk.default.blue;
-      console.log(`${sev(issue.severity.toUpperCase())}  ${issue.message}`);
-      if (issue.suggestion)
-        console.log(
-          `         ${import_chalk.default.dim("\u2192")} ${import_chalk.default.italic(issue.suggestion)}`
-        );
-      console.log();
-    }
-  } else {
-    console.log(
-      import_chalk.default.green(
-        "\n\u2728 No grounding issues found \u2014 agents can navigate freely!\n"
-      )
-    );
-  }
-  if (recommendations.length > 0) {
-    console.log(import_chalk.default.bold("\u{1F4A1} Recommendations\n"));
-    recommendations.forEach(
-      (rec, i) => console.log(`${i + 1}. ${rec}`)
-    );
-  }
-  console.log();
-}

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import {
   analyzeAgentGrounding,
   calculateGroundingScore
-} from "./chunk-AWAS2KB5.mjs";
+} from "./chunk-OFAWUHBZ.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -12,7 +12,8 @@ import { dirname } from "path";
 import {
   loadConfig,
   mergeConfigWithDefaults,
-  resolveOutputPath
+  resolveOutputPath,
+  displayStandardConsoleReport
 } from "@aiready/core";
 var program = new Command();
 program.name("aiready-agent-grounding").description(
@@ -70,65 +71,41 @@ EXAMPLES:
     writeFileSync(outputPath, JSON.stringify(payload, null, 2));
     console.log(chalk.green(`\u2713 Report saved to ${outputPath}`));
   } else {
-    displayConsoleReport(report, scoring, elapsed);
+    displayStandardConsoleReport({
+      title: "\u{1F9ED} Agent Grounding Analysis",
+      score: scoring.summary.score,
+      rating: scoring.summary.rating,
+      dimensions: [
+        {
+          name: "Structure Clarity",
+          value: scoring.summary.dimensions.structureClarityScore
+        },
+        {
+          name: "Self-Documentation",
+          value: scoring.summary.dimensions.selfDocumentationScore
+        },
+        {
+          name: "Entry Points",
+          value: scoring.summary.dimensions.entryPointScore
+        },
+        {
+          name: "API Clarity",
+          value: scoring.summary.dimensions.apiClarityScore
+        },
+        {
+          name: "Domain Consistency",
+          value: scoring.summary.dimensions.domainConsistencyScore
+        }
+      ],
+      stats: [
+        { label: "Files", value: scoring.summary.filesAnalyzed },
+        { label: "Directories", value: scoring.summary.directoriesAnalyzed }
+      ],
+      issues: report.issues,
+      recommendations: report.recommendations,
+      elapsedTime: elapsed,
+      noIssuesMessage: "\u2728 No grounding issues found \u2014 agents can navigate freely!"
+    });
   }
 });
 program.parse();
-function scoreColor(score) {
-  if (score >= 85) return chalk.green;
-  if (score >= 70) return chalk.cyan;
-  if (score >= 50) return chalk.yellow;
-  if (score >= 30) return chalk.red;
-  return chalk.bgRed.white;
-}
-function displayConsoleReport(report, scoring, elapsed) {
-  const { summary, issues, recommendations } = report;
-  console.log(chalk.bold("\n\u{1F9ED} Agent Grounding Analysis\n"));
-  console.log(
-    `Score:       ${scoreColor(summary.score)(summary.score + "/100")} (${summary.rating.toUpperCase()})`
-  );
-  console.log(
-    `Files:       ${chalk.cyan(summary.filesAnalyzed)}   Directories: ${chalk.cyan(summary.directoriesAnalyzed)}`
-  );
-  console.log(`Analysis:    ${chalk.gray(elapsed + "s")}
-`);
-  console.log(chalk.bold("\u{1F4D0} Dimension Scores\n"));
-  const dims = [
-    ["Structure Clarity", summary.dimensions.structureClarityScore],
-    ["Self-Documentation", summary.dimensions.selfDocumentationScore],
-    ["Entry Points", summary.dimensions.entryPointScore],
-    ["API Clarity", summary.dimensions.apiClarityScore],
-    ["Domain Consistency", summary.dimensions.domainConsistencyScore]
-  ];
-  for (const [name, val] of dims) {
-    const bar = "\u2588".repeat(Math.round(val / 10)).padEnd(10, "\u2591");
-    console.log(
-      `  ${String(name).padEnd(22)} ${scoreColor(val)(bar)} ${val}/100`
-    );
-  }
-  if (issues.length > 0) {
-    console.log(chalk.bold("\n\u26A0\uFE0F  Issues Found\n"));
-    for (const issue of issues) {
-      const sev = issue.severity === "critical" ? chalk.red : issue.severity === "major" ? chalk.yellow : chalk.blue;
-      console.log(`${sev(issue.severity.toUpperCase())}  ${issue.message}`);
-      if (issue.suggestion)
-        console.log(
-          `         ${chalk.dim("\u2192")} ${chalk.italic(issue.suggestion)}`
-        );
-      console.log();
-    }
-  } else {
-    console.log(
-      chalk.green(
-        "\n\u2728 No grounding issues found \u2014 agents can navigate freely!\n"
-      )
-    );
-  }
-  if (recommendations.length > 0) {
-    console.log(chalk.bold("\u{1F4A1} Recommendations\n"));
-    recommendations.forEach(
-      (rec, i) => console.log(`${i + 1}. ${rec}`)
-    );
-  }
-  console.log();
-}