@aiready/cli 0.14.25 → 0.14.26

package/dist/cli.js

@@ -33,7 +33,7 @@ var import_url = require("url");
 var import_chalk6 = __toESM(require("chalk"));
 var import_fs4 = require("fs");
 var import_path4 = require("path");
-var import_core9 = require("@aiready/core");
+var import_core10 = require("@aiready/core");
 
 // src/utils/index.ts
 var import_core2 = require("@aiready/core");
@@ -45,8 +45,8 @@ var import_chalk = __toESM(require("chalk"));
 var import_core = require("@aiready/core");
 async function warnIfGraphCapExceeded(report, dirPath) {
   try {
-    const { loadConfig: loadConfig4 } = await import("@aiready/core");
-    void loadConfig4;
+    const { loadConfig: loadConfig2 } = await import("@aiready/core");
+    void loadConfig2;
     let graphConfig = { maxNodes: 400, maxEdges: 600 };
     const configPath = (0, import_path.resolve)(dirPath, "aiready.json");
     if ((0, import_fs.existsSync)(configPath)) {
@@ -409,6 +409,62 @@ var import_core6 = require("@aiready/core");
 // src/commands/scan-helpers.ts
 var import_chalk4 = __toESM(require("chalk"));
 var import_core5 = require("@aiready/core");
+async function executeToolAction(directory, options, config) {
+  console.log(import_chalk4.default.blue(`${config.emoji} ${config.label}...
+`));
+  const startTime = Date.now();
+  try {
+    const { resolvedDir, finalOptions: baseOptions } = await (0, import_core5.prepareActionConfig)(
+      directory,
+      config.defaults,
+      config.getCliOptions(options)
+    );
+    let finalOptions = baseOptions;
+    if (config.preAnalyze) {
+      finalOptions = await config.preAnalyze(resolvedDir, finalOptions);
+    }
+    const { analyze, generateSummary, calculateScore } = await config.importTool();
+    const results = await analyze(finalOptions);
+    const elapsedTime = (0, import_core5.getElapsedTime)(startTime);
+    const summary = generateSummary(results);
+    let toolScore;
+    if (options.score && calculateScore) {
+      const resultsAny = results;
+      const scoreData = resultsAny.duplicates || resultsAny.issues || results;
+      const filesCount = resultsAny.length || resultsAny.summary?.filesAnalyzed || resultsAny.summary?.totalFiles;
+      toolScore = calculateScore(scoreData, filesCount);
+    }
+    const { format: outputFormat, file: userOutputFile } = (0, import_core5.resolveOutputFormat)(
+      options,
+      finalOptions
+    );
+    const outputData = (0, import_core5.formatStandardReport)({
+      results,
+      summary,
+      elapsedTime,
+      score: toolScore
+    });
+    if (outputFormat === "json") {
+      (0, import_core5.handleStandardJSONOutput)({
+        outputData,
+        outputFile: userOutputFile,
+        resolvedDir
+      });
+    } else {
+      config.renderConsole({
+        results,
+        summary,
+        elapsedTime,
+        score: toolScore,
+        finalOptions
+      });
+    }
+    return outputData;
+  } catch (error) {
+    (0, import_core5.handleCLIError)(error, config.label);
+    return void 0;
+  }
+}
 function getProfileTools(profile) {
   switch (profile.toLowerCase()) {
     case "agentic":
@@ -532,9 +588,9 @@ async function resolveScanConfig(resolvedDir, options) {
 var import_chalk5 = __toESM(require("chalk"));
 var import_fs3 = require("fs");
 var import_path3 = require("path");
-var import_core8 = require("@aiready/core");
+var import_core9 = require("@aiready/core");
 
-// src/index.ts
+// src/orchestrator.ts
 var import_core7 = require("@aiready/core");
 var TOOL_PACKAGE_MAP = {
   [import_core7.ToolName.PatternDetect]: "@aiready/pattern-detect",
@@ -558,216 +614,257 @@ var TOOL_PACKAGE_MAP = {
   "deps-health": "@aiready/deps",
   "change-amp": "@aiready/change-amplification"
 };
-function sanitizeConfigRecursive(obj) {
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
-  const sanitized = {};
-  const infraToStrip = [
-    "rootDir",
-    "onProgress",
-    "progressCallback",
-    "streamResults",
-    "batchSize",
-    "useSmartDefaults"
-  ];
-  for (const [key, value] of Object.entries(obj)) {
-    if (infraToStrip.includes(key)) continue;
-    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-      sanitized[key] = sanitizeConfigRecursive(value);
-    } else {
-      sanitized[key] = value;
-    }
+var UnifiedOrchestrator = class {
+  /**
+   * Initialize orchestrator with a tool registry.
+   * Injection pattern helps with testability and AI readiness score.
+   */
+  constructor(registry = import_core7.ToolRegistry) {
+    this.registry = registry;
   }
-  return sanitized;
-}
-function sanitizeToolConfig(config) {
-  return sanitizeConfigRecursive(config);
-}
-async function analyzeUnified(options) {
-  await (0, import_core7.initializeParsers)();
-  const startTime = Date.now();
-  const requestedTools = options.tools ?? [
-    "patterns",
-    "context",
-    "consistency"
-  ];
-  const result = {
-    summary: {
-      totalIssues: 0,
-      criticalIssues: 0,
-      // Added as per instruction
-      majorIssues: 0,
-      // Added as per instruction
-      totalFiles: 0,
-      toolsRun: [],
-      executionTime: 0,
-      config: options,
-      toolConfigs: {}
+  /**
+   * Deeply sanitizes a configuration object.
+   */
+  sanitizeConfig(obj) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
+    const sanitized = {};
+    const infraToStrip = [
+      "rootDir",
+      "onProgress",
+      "progressCallback",
+      "streamResults",
+      "batchSize",
+      "useSmartDefaults"
+    ];
+    for (const [key, value] of Object.entries(obj)) {
+      if (infraToStrip.includes(key)) continue;
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        sanitized[key] = this.sanitizeConfig(value);
+      } else {
+        sanitized[key] = value;
+      }
     }
-  };
-  for (const toolName of requestedTools) {
-    let provider = import_core7.ToolRegistry.find(toolName);
-    if (!provider) {
-      const packageName = TOOL_PACKAGE_MAP[toolName] ?? (toolName.startsWith("@aiready/") ? toolName : `@aiready/${toolName}`);
-      try {
-        await import(packageName);
-        provider = import_core7.ToolRegistry.find(toolName);
-        if (provider) {
-          console.log(
-            `\u2705 Successfully loaded tool provider: ${toolName} from ${packageName}`
-          );
-        } else {
+    return sanitized;
+  }
+  /**
+   * Performs the unified analysis.
+   */
+  async analyze(options) {
+    await (0, import_core7.initializeParsers)();
+    const startTime = Date.now();
+    const requestedTools = options.tools ?? [
+      "patterns",
+      "context",
+      "consistency"
+    ];
+    const result = {
+      summary: {
+        totalIssues: 0,
+        criticalIssues: 0,
+        majorIssues: 0,
+        totalFiles: 0,
+        toolsRun: [],
+        executionTime: 0,
+        config: options,
+        toolConfigs: {}
+      }
+    };
+    for (const toolName of requestedTools) {
+      let provider = this.registry.find(toolName);
+      if (!provider) {
+        const packageName = TOOL_PACKAGE_MAP[toolName] ?? (toolName.startsWith("@aiready/") ? toolName : `@aiready/${toolName}`);
+        try {
+          await import(packageName);
+          provider = this.registry.find(toolName);
+        } catch (err) {
           console.log(
-            `\u26A0\uFE0F Loaded ${packageName} but provider ${toolName} still not found in registry.`
+            `\u274C Failed to dynamically load tool ${toolName} (${packageName}):`,
+            err.message
           );
         }
-      } catch (err) {
-        console.log(
-          `\u274C Failed to dynamically load tool ${toolName} (${packageName}):`,
-          err.message
+      }
+      if (!provider) {
+        console.warn(
+          `\u26A0\uFE0F  Warning: Tool provider for '${toolName}' not found. Skipping.`
         );
+        continue;
       }
-    }
-    if (!provider) {
-      console.warn(
-        `\u26A0\uFE0F  Warning: Tool provider for '${toolName}' not found. Skipping.`
-      );
-      continue;
-    }
-    try {
-      const sanitizedOptions = { ...options };
-      delete sanitizedOptions.onProgress;
-      delete sanitizedOptions.progressCallback;
-      const toolOptions = {
-        rootDir: options.rootDir
-        // Always include rootDir
-      };
-      [...import_core7.GLOBAL_INFRA_OPTIONS, ...import_core7.COMMON_FINE_TUNING_OPTIONS].forEach(
-        (key) => {
-          if (key in options && key !== "toolConfigs" && key !== "tools") {
-            toolOptions[key] = options[key];
+      try {
+        const toolOptions = {
+          rootDir: options.rootDir
+        };
+        [...import_core7.GLOBAL_INFRA_OPTIONS, ...import_core7.COMMON_FINE_TUNING_OPTIONS].forEach(
+          (key) => {
+            if (key in options && key !== "toolConfigs" && key !== "tools") {
+              toolOptions[key] = options[key];
+            }
           }
+        );
+        if (options.toolConfigs?.[provider.id]) {
+          Object.assign(toolOptions, options.toolConfigs[provider.id]);
+        } else if (options.tools && !Array.isArray(options.tools) && typeof options.tools === "object" && options.tools[provider.id]) {
+          Object.assign(toolOptions, options.tools[provider.id]);
+        }
+        toolOptions.onProgress = (processed, total, msg) => {
+          if (options.progressCallback) {
+            options.progressCallback({
+              tool: provider.id,
+              processed,
+              total,
+              message: msg
+            });
+          }
+        };
+        const output = await provider.analyze(toolOptions);
+        if (output.metadata) {
+          output.metadata.config = this.sanitizeConfig(toolOptions);
         }
-      );
-      if (options.toolConfigs?.[provider.id]) {
-        Object.assign(toolOptions, options.toolConfigs[provider.id]);
-      } else if (options.tools && !Array.isArray(options.tools) && typeof options.tools === "object" && options.tools[provider.id]) {
-        Object.assign(toolOptions, options.tools[provider.id]);
-      } else if (options[provider.id]) {
-        Object.assign(toolOptions, options[provider.id]);
-      }
-      toolOptions.onProgress = (processed, total, message) => {
         if (options.progressCallback) {
-          options.progressCallback({
-            tool: provider.id,
-            processed,
-            total,
-            message
-          });
+          options.progressCallback({ tool: provider.id, data: output });
         }
-      };
-      const output = await provider.analyze(toolOptions);
-      if (output.metadata) {
-        output.metadata.config = sanitizeToolConfig(toolOptions);
-      }
-      if (options.progressCallback) {
-        options.progressCallback({ tool: provider.id, data: output });
-      }
-      result[provider.id] = output;
-      result.summary.toolsRun.push(provider.id);
-      if (output.summary?.config) {
-        result.summary.toolConfigs[provider.id] = sanitizeToolConfig(
-          output.summary.config
-        );
-      } else if (output.metadata?.config) {
-        result.summary.toolConfigs[provider.id] = sanitizeToolConfig(
-          output.metadata.config
+        result[provider.id] = output;
+        result.summary.toolsRun.push(provider.id);
+        const toolConfig = output.summary?.config ?? output.metadata?.config ?? toolOptions;
+        result.summary.toolConfigs[provider.id] = this.sanitizeConfig(toolConfig);
+        const toolFiles = output.summary?.totalFiles ?? output.summary?.filesAnalyzed ?? 0;
+        if (toolFiles > result.summary.totalFiles) {
+          result.summary.totalFiles = toolFiles;
+        }
+        const issueCount = output.results.reduce(
+          (sum, file) => sum + (file.issues?.length ?? 0),
+          0
         );
-      } else {
-        result.summary.toolConfigs[provider.id] = sanitizeToolConfig(toolOptions);
-      }
-      const toolFiles = output.summary?.totalFiles ?? output.summary?.filesAnalyzed ?? 0;
-      if (toolFiles > result.summary.totalFiles) {
-        result.summary.totalFiles = toolFiles;
+        result.summary.totalIssues += issueCount;
+      } catch (err) {
+        console.error(`\u274C Error running tool '${provider.id}':`, err);
       }
-      const issueCount = output.results.reduce(
-        (sum, file) => sum + (file.issues?.length ?? 0),
-        0
-      );
-      result.summary.totalIssues += issueCount;
-    } catch (err) {
-      console.error(`\u274C Error running tool '${provider.id}':`, err);
     }
+    result.summary.config = this.sanitizeConfig({
+      scan: {
+        tools: requestedTools,
+        include: options.include,
+        exclude: options.exclude
+      },
+      tools: result.summary.toolConfigs
+    });
+    result.summary.executionTime = Date.now() - startTime;
+    this.applyLegacyKeys(result);
+    return result;
   }
-  result.summary.config = sanitizeConfigRecursive({
-    scan: {
-      tools: requestedTools,
-      include: options.include,
-      exclude: options.exclude
-    },
-    // Use 'tools' for tool-specific configurations to match AIReadyConfig
-    tools: result.summary.toolConfigs
-  });
-  result.summary.executionTime = Date.now() - startTime;
-  const keyMappings = {
-    "pattern-detect": ["patternDetect", "patterns"],
-    "context-analyzer": ["contextAnalyzer", "context"],
-    "naming-consistency": ["namingConsistency", "consistency"],
-    "ai-signal-clarity": ["aiSignalClarity"],
-    "agent-grounding": ["agentGrounding"],
-    "testability-index": ["testabilityIndex", "testability"],
-    "doc-drift": ["docDrift"],
-    "dependency-health": ["dependencyHealth", "deps"],
-    "change-amplification": ["changeAmplification"]
-  };
-  for (const [kebabKey, aliases] of Object.entries(keyMappings)) {
-    if (result[kebabKey]) {
-      for (const alias of aliases) {
-        result[alias] = result[kebabKey];
+  applyLegacyKeys(result) {
+    const keyMappings = {
+      "pattern-detect": ["patternDetect", "patterns"],
+      "context-analyzer": ["contextAnalyzer", "context"],
+      "naming-consistency": ["namingConsistency", "consistency"],
+      "ai-signal-clarity": ["aiSignalClarity"],
+      "agent-grounding": ["agentGrounding"],
+      "testability-index": ["testabilityIndex", "testability"],
+      "doc-drift": ["docDrift"],
+      "dependency-health": ["dependencyHealth", "deps"],
+      "change-amplification": ["changeAmplification"]
+    };
+    for (const [kebabKey, aliases] of Object.entries(keyMappings)) {
+      if (result[kebabKey]) {
+        for (const alias of aliases) {
+          result[alias] = result[kebabKey];
+        }
       }
     }
   }
-  return result;
+};
+async function analyzeUnified(options) {
+  const orchestrator = new UnifiedOrchestrator(import_core7.ToolRegistry);
+  return orchestrator.analyze(options);
 }
-async function scoreUnified(results, options) {
-  const toolScores = /* @__PURE__ */ new Map();
-  for (const toolId of results.summary.toolsRun) {
-    const provider = import_core7.ToolRegistry.get(toolId);
-    if (!provider) continue;
-    const output = results[toolId];
-    if (!output) continue;
-    try {
-      const toolScore = provider.score(output, options);
-      if (!toolScore.tokenBudget) {
-        if (toolId === import_core7.ToolName.PatternDetect && output.duplicates) {
-          const wastedTokens = output.duplicates.reduce(
-            (sum, d) => sum + (d.tokenCost ?? 0),
-            0
-          );
-          toolScore.tokenBudget = (0, import_core7.calculateTokenBudget)({
-            totalContextTokens: wastedTokens * 2,
-            wastedTokens: {
-              duplication: wastedTokens,
-              fragmentation: 0,
-              chattiness: 0
-            }
-          });
-        } else if (toolId === import_core7.ToolName.ContextAnalyzer && output.summary) {
-          toolScore.tokenBudget = (0, import_core7.calculateTokenBudget)({
-            totalContextTokens: output.summary.totalTokens,
-            wastedTokens: {
-              duplication: 0,
-              fragmentation: output.summary.totalPotentialSavings ?? 0,
-              chattiness: 0
-            }
-          });
+
+// src/scoring-orchestrator.ts
+var import_core8 = require("@aiready/core");
+var ScoringOrchestrator = class {
+  /**
+   * Initialize scoring orchestrator with a tool registry.
+   * Injection pattern helps with testability and AI readiness score.
+   */
+  constructor(registry = import_core8.ToolRegistry) {
+    this.registry = registry;
+  }
+  /**
+   * Calculates scores for all analyzed tools.
+   */
+  async score(results, options) {
+    const toolScores = /* @__PURE__ */ new Map();
+    for (const toolId of results.summary.toolsRun) {
+      const provider = this.registry.get(toolId);
+      if (!provider) continue;
+      const output = results[toolId];
+      if (!output) continue;
+      try {
+        const toolScore = provider.score(output, options);
+        if (!toolScore.tokenBudget) {
+          if (toolId === import_core8.ToolName.PatternDetect && output.duplicates) {
+            const wastedTokens = output.duplicates.reduce(
+              (sum, d) => sum + (d.tokenCost ?? 0),
+              0
+            );
+            toolScore.tokenBudget = (0, import_core8.calculateTokenBudget)({
+              totalContextTokens: wastedTokens * 2,
+              wastedTokens: {
+                duplication: wastedTokens,
+                fragmentation: 0,
+                chattiness: 0
+              }
+            });
+          } else if (toolId === import_core8.ToolName.ContextAnalyzer && output.summary) {
+            toolScore.tokenBudget = (0, import_core8.calculateTokenBudget)({
+              totalContextTokens: output.summary.totalTokens,
+              wastedTokens: {
+                duplication: 0,
+                fragmentation: output.summary.totalPotentialSavings ?? 0,
+                chattiness: 0
+              }
+            });
+          }
         }
+        toolScores.set(toolId, toolScore);
+      } catch (err) {
+        console.error(`\u274C Error scoring tool '${toolId}':`, err);
+      }
+    }
+    if (toolScores.size === 0) {
+      return this.emptyScoringResult();
+    }
+    return (0, import_core8.calculateOverallScore)(toolScores, options, void 0);
+  }
+  /**
+   * Generate human-readable summary of unified results.
+   */
+  generateSummary(result) {
+    const { summary } = result;
+    let output = `\u{1F680} AIReady Analysis Complete
+
+`;
+    output += `\u{1F4CA} Summary:
+`;
+    output += `   Tools run: ${summary.toolsRun.join(", ")}
+`;
+    output += `   Total issues found: ${summary.totalIssues}
+`;
+    output += `   Execution time: ${(summary.executionTime / 1e3).toFixed(2)}s
+
+`;
+    for (const provider of this.registry.getAll()) {
+      const toolResult = result[provider.id];
+      if (toolResult) {
+        const issueCount = toolResult.results.reduce(
+          (sum, r) => sum + (r.issues?.length ?? 0),
+          0
+        );
+        output += `\u2022 ${provider.id}: ${issueCount} issues
+`;
       }
-      toolScores.set(toolId, toolScore);
-    } catch (err) {
-      console.error(`\u274C Error scoring tool '${toolId}':`, err);
     }
+    return output;
   }
-  if (toolScores.size === 0) {
+  emptyScoringResult() {
     return {
       overall: 0,
       rating: "Critical",
@@ -781,7 +878,10 @@ async function scoreUnified(results, options) {
       }
     };
   }
-  return (0, import_core7.calculateOverallScore)(toolScores, options, void 0);
+};
+async function scoreUnified(results, options) {
+  const orchestrator = new ScoringOrchestrator(import_core8.ToolRegistry);
+  return orchestrator.score(results, options);
 }
 
 // src/commands/scan-orchestrator.ts
@@ -870,7 +970,7 @@ async function handleBusinessImpactMetrics(results, scoringResult, modelId) {
     0
   );
   if (totalContext > 0) {
-    const unifiedBudget = (0, import_core8.calculateTokenBudget)({
+    const unifiedBudget = (0, import_core9.calculateTokenBudget)({
       totalContextTokens: totalContext,
       wastedTokens: {
         duplication: totalWastedDuplication,
@@ -911,7 +1011,7 @@ async function scanAction(directory, options) {
   console.log(import_chalk6.default.blue("\u{1F680} Starting AIReady unified analysis...\n"));
   const startTime = Date.now();
   const resolvedDir = (0, import_path4.resolve)(process.cwd(), directory ?? ".");
-  const repoMetadata = (0, import_core9.getRepoMetadata)(resolvedDir);
+  const repoMetadata = (0, import_core10.getRepoMetadata)(resolvedDir);
   try {
     const finalOptions = await resolveScanConfig(resolvedDir, options);
     const { results, scoringResult } = await runUnifiedScan(
@@ -942,13 +1042,13 @@ async function scanAction(directory, options) {
       repository: repoMetadata
     };
     const outputFormat = options.output ?? finalOptions.output?.format ?? "console";
-    const outputPath = (0, import_core9.resolveOutputPath)(
+    const outputPath = (0, import_core10.resolveOutputPath)(
       options.outputFile ?? finalOptions.output?.file,
       `aiready-report-${(0, import_core2.getReportTimestamp)()}.json`,
       resolvedDir
     );
     if (outputFormat === "json") {
-      (0, import_core9.handleJSONOutput)(
+      (0, import_core10.handleJSONOutput)(
         outputData,
         outputPath,
         `\u2705 Report saved to ${outputPath}`
@@ -968,15 +1068,21 @@ async function scanAction(directory, options) {
       });
     }
     await warnIfGraphCapExceeded(outputData, resolvedDir);
-    await handleGatekeeper(outputData, scoringResult, options, results);
+    await handleGatekeeper(
+      outputData,
+      scoringResult,
+      options,
+      finalOptions,
+      results
+    );
   } catch (error) {
-    (0, import_core9.handleCLIError)(error, "Analysis");
+    (0, import_core10.handleCLIError)(error, "Analysis");
   }
 }
-async function handleGatekeeper(outputData, scoringResult, options, results) {
+async function handleGatekeeper(outputData, scoringResult, options, finalOptions, results) {
   if (!scoringResult) return;
-  const threshold = options.threshold ? parseInt(options.threshold) : void 0;
-  const failOnLevel = options.failOn ?? "critical";
+  const threshold = options.threshold ? parseInt(options.threshold) : finalOptions.threshold;
+  const failOnLevel = options.failOn ?? finalOptions.failOn ?? "critical";
   const isCI = options.ci ?? process.env.CI === "true";
   let shouldFail = false;
   let failReason = "";
@@ -988,7 +1094,7 @@ async function handleGatekeeper(outputData, scoringResult, options, results) {
 \u{1F4DD} Emitting GitHub Action annotations for ${report.results.length} issues...`
       )
     );
-    (0, import_core9.emitIssuesAsAnnotations)(report.results);
+    (0, import_core10.emitIssuesAsAnnotations)(report.results);
   }
   if (threshold && scoringResult.overall < threshold) {
     shouldFail = true;
@@ -1037,7 +1143,7 @@ ${import_chalk6.default.bold("CI/CD Integration:")}
 var import_fs5 = require("fs");
 var import_path5 = require("path");
 var import_chalk7 = __toESM(require("chalk"));
-var import_core10 = require("@aiready/core");
+var import_core11 = require("@aiready/core");
 async function initAction(options) {
   const fileExt = options.format === "js" ? "js" : "json";
   const fileName = fileExt === "js" ? "aiready.config.js" : "aiready.json";
@@ -1068,15 +1174,15 @@ async function initAction(options) {
         "**/*.spec.ts"
       ],
       tools: [
-        import_core10.ToolName.PatternDetect,
-        import_core10.ToolName.ContextAnalyzer,
-        import_core10.ToolName.NamingConsistency,
-        import_core10.ToolName.AiSignalClarity,
-        import_core10.ToolName.AgentGrounding,
-        import_core10.ToolName.TestabilityIndex,
-        import_core10.ToolName.DocDrift,
-        import_core10.ToolName.DependencyHealth,
-        import_core10.ToolName.ChangeAmplification
+        import_core11.ToolName.PatternDetect,
+        import_core11.ToolName.ContextAnalyzer,
+        import_core11.ToolName.NamingConsistency,
+        import_core11.ToolName.AiSignalClarity,
+        import_core11.ToolName.AgentGrounding,
+        import_core11.ToolName.TestabilityIndex,
+        import_core11.ToolName.DocDrift,
+        import_core11.ToolName.DependencyHealth,
+        import_core11.ToolName.ChangeAmplification
       ]
     },
     // Output preferences
@@ -1091,7 +1197,7 @@ async function initAction(options) {
     },
     // Tool-specific configurations
     tools: {
-      [import_core10.ToolName.PatternDetect]: {
+      [import_core11.ToolName.PatternDetect]: {
         // Core detection thresholds
         minSimilarity: 0.4,
         // Jaccard similarity threshold (0-1)
@@ -1121,7 +1227,7 @@ async function initAction(options) {
           // Add any additional advanced options here
         } : {}
       },
-      [import_core10.ToolName.ContextAnalyzer]: {
+      [import_core11.ToolName.ContextAnalyzer]: {
         // Smart defaults are generated dynamically based on repository size
         // These are fallback values for when smart defaults can't be calculated
         maxContextBudget: 25e3,
@@ -1138,7 +1244,7 @@ async function initAction(options) {
         includeNodeModules: false
         // Whether to include node_modules in analysis
       },
-      [import_core10.ToolName.NamingConsistency]: {
+      [import_core11.ToolName.NamingConsistency]: {
         // Core checks
         checkNaming: true,
         // Check naming conventions and quality
@@ -1185,7 +1291,7 @@ async function initAction(options) {
         ],
         ...options.full ? { disableChecks: [] } : {}
       },
-      [import_core10.ToolName.AiSignalClarity]: {
+      [import_core11.ToolName.AiSignalClarity]: {
         // All signal clarity checks enabled by default
         checkMagicLiterals: true,
         // Detect magic numbers and strings
@@ -1204,7 +1310,7 @@ async function initAction(options) {
         checkLargeFiles: true
         // Detect files that are too large
       },
-      [import_core10.ToolName.AgentGrounding]: {
+      [import_core11.ToolName.AgentGrounding]: {
         // Structure clarity
         maxRecommendedDepth: 4,
         // Max directory depth before flagging as "too deep"
@@ -1215,7 +1321,7 @@ async function initAction(options) {
         additionalVagueNames: ["stuff", "misc", "temp", "test"]
         // Custom vague file names
       },
-      [import_core10.ToolName.TestabilityIndex]: {
+      [import_core11.ToolName.TestabilityIndex]: {
         // Coverage thresholds
         minCoverageRatio: 0.3,
         // Minimum acceptable test/source ratio
@@ -1225,19 +1331,19 @@ async function initAction(options) {
         maxDepth: 10
         // Maximum scan depth
       },
-      [import_core10.ToolName.DocDrift]: {
+      [import_core11.ToolName.DocDrift]: {
         // Drift detection
         maxCommits: 50,
         // Maximum commit distance to check for drift
         staleMonths: 3
         // Consider comments older than this as outdated
       },
-      [import_core10.ToolName.DependencyHealth]: {
+      [import_core11.ToolName.DependencyHealth]: {
         // Training cutoff for AI knowledge assessment
         trainingCutoffYear: 2023
         // Year cutoff for AI training data
       },
-      [import_core10.ToolName.ChangeAmplification]: {
+      [import_core11.ToolName.ChangeAmplification]: {
         // Change amplification primarily relies on global scan settings
         // No additional tool-specific configuration required
       }
@@ -1281,134 +1387,157 @@ module.exports = ${JSON.stringify(defaultConfig, null, 2)};
 }
 
 // src/commands/patterns.ts
+var import_chalk9 = __toESM(require("chalk"));
+var import_core13 = require("@aiready/core");
+
+// src/utils/terminal-renderers.ts
 var import_chalk8 = __toESM(require("chalk"));
-var import_core11 = require("@aiready/core");
-async function patternsAction(directory, options) {
-  console.log(import_chalk8.default.blue("\u{1F50D} Analyzing patterns...\n"));
-  const startTime = Date.now();
-  try {
-    const useSmartDefaults = !options.fullScan;
-    const defaults = {
-      useSmartDefaults,
-      include: void 0,
-      exclude: void 0,
-      output: {
-        format: "console",
-        file: void 0
-      }
-    };
-    if (!useSmartDefaults) {
-      defaults.minSimilarity = 0.4;
-      defaults.minLines = 5;
-    }
-    const cliOptions = {
-      minSimilarity: options.similarity ? parseFloat(options.similarity) : void 0,
-      minLines: options.minLines ? parseInt(options.minLines) : void 0,
-      useSmartDefaults,
-      include: options.include?.split(","),
-      exclude: options.exclude?.split(",")
-    };
-    if (options.maxCandidates) {
-      cliOptions.maxCandidatesPerBlock = parseInt(options.maxCandidates);
-    }
-    if (options.minSharedTokens) {
-      cliOptions.minSharedTokens = parseInt(options.minSharedTokens);
-    }
-    const { resolvedDir, finalOptions } = await (0, import_core11.prepareActionConfig)(
-      directory,
-      defaults,
-      cliOptions
+var import_core12 = require("@aiready/core");
+var SAFETY_ICONS = {
+  safe: "\u2705",
+  "moderate-risk": "\u26A0\uFE0F ",
+  "high-risk": "\u{1F534}",
+  "blind-risk": "\u{1F480}"
+};
+var SAFETY_COLORS = {
+  safe: import_chalk8.default.green,
+  "moderate-risk": import_chalk8.default.yellow,
+  "high-risk": import_chalk8.default.red,
+  "blind-risk": import_chalk8.default.bgRed.white
+};
+function renderToolHeader(label, emoji, score, rating) {
+  console.log(
+    `  ${emoji} ${label}:         ${import_chalk8.default.bold(score + "/100")} (${rating})`
+  );
+}
+function renderSafetyRating(safety) {
+  const icon = SAFETY_ICONS[safety] ?? "\u2753";
+  const color = SAFETY_COLORS[safety] ?? import_chalk8.default.white;
+  console.log(
+    `     AI Change Safety:  ${color(`${icon} ${safety.toUpperCase()}`)}`
+  );
+}
+function renderIssueSummaryBlock(summary) {
+  const total = (summary.criticalIssues || 0) + (summary.majorIssues || 0) + (summary.minorIssues || 0);
+  if (total === 0) {
+    console.log(import_chalk8.default.green("\u2705 No significant issues found!\n"));
+    return;
+  }
+  console.log(import_chalk8.default.bold("\u26A0\uFE0F  Issues Found:\n"));
+  if (summary.criticalIssues > 0)
+    console.log(
+      import_chalk8.default.red(`   \u{1F534} Critical: ${import_chalk8.default.bold(summary.criticalIssues)}`)
     );
-    const { analyzePatterns, generateSummary, calculatePatternScore } = await import("@aiready/pattern-detect");
-    const { results, duplicates } = await analyzePatterns(
-      finalOptions
+  if (summary.majorIssues > 0)
+    console.log(
+      import_chalk8.default.yellow(`   \u{1F7E1} Major: ${import_chalk8.default.bold(summary.majorIssues)}`)
     );
-    const elapsedTime = (0, import_core11.getElapsedTime)(startTime);
-    const summary = generateSummary(results);
-    let patternScore;
-    if (options.score) {
-      patternScore = calculatePatternScore(duplicates, results.length);
-    }
-    const { format: outputFormat, file: userOutputFile } = (0, import_core11.resolveOutputFormat)(
-      options,
-      finalOptions
+  if (summary.minorIssues > 0)
+    console.log(import_chalk8.default.blue(`   \u{1F535} Minor: ${import_chalk8.default.bold(summary.minorIssues)}`));
+  if (summary.totalPotentialSavings) {
+    console.log(
+      import_chalk8.default.green(
+        `
+   \u{1F4A1} Potential savings: ${import_chalk8.default.bold(summary.totalPotentialSavings.toLocaleString())} tokens
+`
+      )
     );
-    if (outputFormat === "json") {
-      const outputData = (0, import_core11.formatStandardReport)({
-        results,
-        summary,
-        elapsedTime,
-        score: patternScore
-      });
-      (0, import_core11.handleStandardJSONOutput)({
-        outputData,
-        outputFile: userOutputFile,
-        resolvedDir
-      });
-    } else {
-      (0, import_core11.printTerminalHeader)("PATTERN ANALYSIS SUMMARY");
+  }
+}
+function renderSubSection(title) {
+  console.log("\n" + (0, import_core12.getTerminalDivider)());
+  console.log(import_chalk8.default.bold.white(`  ${title.toUpperCase()}`));
+  console.log((0, import_core12.getTerminalDivider)() + "\n");
+}
+function renderToolScoreFooter(score) {
+  if (score) {
+    console.log(`
+\u{1F4CA} AI Readiness Score (${score.toolName || "Tool"})
+`);
+    console.log((0, import_core12.formatToolScore)(score));
+    console.log();
+  }
+}
+
+// src/commands/patterns.ts
+async function patternsAction(directory, options) {
+  return await executeToolAction(directory, options, {
+    toolName: "pattern-detect",
+    label: "Pattern analysis",
+    emoji: "\u{1F50D}",
+    defaults: {
+      useSmartDefaults: !options.fullScan,
+      include: void 0,
+      exclude: void 0,
+      output: { format: "console", file: void 0 },
+      minSimilarity: options.fullScan ? 0.4 : void 0,
+      minLines: options.fullScan ? 5 : void 0
+    },
+    getCliOptions: (opts) => ({
+      minSimilarity: opts.similarity ? parseFloat(opts.similarity) : void 0,
+      minLines: opts.minLines ? parseInt(opts.minLines) : void 0,
+      maxCandidatesPerBlock: opts.maxCandidates ? parseInt(opts.maxCandidates) : void 0,
+      minSharedTokens: opts.minSharedTokens ? parseInt(opts.minSharedTokens) : void 0
+    }),
+    importTool: async () => {
+      const { analyzePatterns, generateSummary, calculatePatternScore } = await import("@aiready/pattern-detect");
+      return {
+        analyze: analyzePatterns,
+        generateSummary,
+        calculateScore: calculatePatternScore
+      };
+    },
+    renderConsole: ({ results, summary, elapsedTime, score }) => {
+      const duplicates = results.duplicates || [];
+      (0, import_core13.printTerminalHeader)("PATTERN ANALYSIS SUMMARY");
       console.log(
-        import_chalk8.default.white(`\u{1F4C1} Files analyzed: ${import_chalk8.default.bold(results.length)}`)
+        import_chalk9.default.white(`\u{1F4C1} Files analyzed: ${import_chalk9.default.bold(results.length)}`)
       );
       console.log(
-        import_chalk8.default.yellow(
-          `\u26A0  Duplicate patterns found: ${import_chalk8.default.bold(summary.totalPatterns)}`
+        import_chalk9.default.yellow(
+          `\u26A0  Duplicate patterns found: ${import_chalk9.default.bold(summary.totalPatterns)}`
         )
       );
       console.log(
-        import_chalk8.default.red(
-          `\u{1F4B0} Token cost (wasted): ${import_chalk8.default.bold(summary.totalTokenCost.toLocaleString())}`
+        import_chalk9.default.red(
+          `\u{1F4B0} Token cost (wasted): ${import_chalk9.default.bold(summary.totalTokenCost.toLocaleString())}`
         )
       );
       console.log(
-        import_chalk8.default.gray(`\u23F1  Analysis time: ${import_chalk8.default.bold(elapsedTime + "s")}`)
+        import_chalk9.default.gray(`\u23F1  Analysis time: ${import_chalk9.default.bold(elapsedTime + "s")}`)
       );
       const sortedTypes = Object.entries(summary.patternsByType || {}).filter(([, count]) => count > 0).sort(([, a], [, b]) => b - a);
       if (sortedTypes.length > 0) {
-        console.log("\n" + (0, import_core11.getTerminalDivider)());
-        console.log(import_chalk8.default.bold.white("  PATTERNS BY TYPE"));
-        console.log((0, import_core11.getTerminalDivider)() + "\n");
+        renderSubSection("Patterns By Type");
         sortedTypes.forEach(([type, count]) => {
-          console.log(`  ${import_chalk8.default.white(type.padEnd(15))} ${import_chalk8.default.bold(count)}`);
+          console.log(`  ${import_chalk9.default.white(type.padEnd(15))} ${import_chalk9.default.bold(count)}`);
         });
       }
       if (summary.totalPatterns > 0 && duplicates.length > 0) {
-        console.log("\n" + (0, import_core11.getTerminalDivider)());
-        console.log(import_chalk8.default.bold.white("  TOP DUPLICATE PATTERNS"));
-        console.log((0, import_core11.getTerminalDivider)() + "\n");
-        const topDuplicates = [...duplicates].sort((a, b) => b.similarity - a.similarity).slice(0, 10);
-        topDuplicates.forEach((dup) => {
-          const severity = dup.similarity > 0.95 ? "CRITICAL" : dup.similarity > 0.9 ? "HIGH" : "MEDIUM";
-          const severityIcon = dup.similarity > 0.95 ? "\u{1F534}" : dup.similarity > 0.9 ? "\u{1F7E1}" : "\u{1F535}";
-          const file1Name = dup.file1.split("/").pop() || dup.file1;
-          const file2Name = dup.file2.split("/").pop() || dup.file2;
+        renderSubSection("Top Duplicate Patterns");
+        [...duplicates].sort((a, b) => b.similarity - a.similarity).slice(0, 10).forEach((dup) => {
+          const isHigh = dup.similarity > 0.9;
+          const icon = dup.similarity > 0.95 ? "\u{1F534}" : isHigh ? "\u{1F7E1}" : "\u{1F535}";
+          const label = dup.similarity > 0.95 ? "CRITICAL" : isHigh ? "HIGH" : "MEDIUM";
           console.log(
-            `${severityIcon} ${severity}: ${import_chalk8.default.bold(file1Name)} \u2194 ${import_chalk8.default.bold(file2Name)}`
+            `${icon} ${label}: ${import_chalk9.default.bold(dup.file1.split("/").pop())} \u2194 ${import_chalk9.default.bold(dup.file2.split("/").pop())}`
           );
           console.log(
-            `   Similarity: ${import_chalk8.default.bold(Math.round(dup.similarity * 100) + "%")} | Wasted: ${import_chalk8.default.bold(dup.tokenCost.toLocaleString())} tokens each`
+            `   Similarity: ${import_chalk9.default.bold(Math.round(dup.similarity * 100) + "%")} | Wasted: ${import_chalk9.default.bold(dup.tokenCost.toLocaleString())} tokens each`
           );
           console.log(
-            `   Lines: ${import_chalk8.default.cyan(dup.line1 + "-" + dup.endLine1)} \u2194 ${import_chalk8.default.cyan(dup.line2 + "-" + dup.endLine2)}
+            `   Lines: ${import_chalk9.default.cyan(dup.line1 + "-" + dup.endLine1)} \u2194 ${import_chalk9.default.cyan(dup.line2 + "-" + dup.endLine2)}
 `
           );
         });
       } else {
         console.log(
-          import_chalk8.default.green("\n\u2728 Great! No duplicate patterns detected.\n")
+          import_chalk9.default.green("\n\u2728 Great! No duplicate patterns detected.\n")
         );
       }
-      if (patternScore) {
-        console.log((0, import_core11.getTerminalDivider)());
-        console.log(import_chalk8.default.bold.white("  AI READINESS SCORE (Patterns)"));
-        console.log((0, import_core11.getTerminalDivider)() + "\n");
-        console.log((0, import_core11.formatToolScore)(patternScore));
-        console.log();
-      }
+      renderToolScoreFooter(score);
     }
-  } catch (error) {
-    (0, import_core11.handleCLIError)(error, "Pattern analysis");
-  }
+  });
 }
 var PATTERNS_HELP_TEXT = `
 EXAMPLES:
@@ -1418,283 +1547,146 @@ EXAMPLES:
 `;
 
 // src/commands/context.ts
-var import_chalk9 = __toESM(require("chalk"));
-var import_core12 = require("@aiready/core");
+var import_chalk10 = __toESM(require("chalk"));
+var import_core14 = require("@aiready/core");
 async function contextAction(directory, options) {
-  console.log(import_chalk9.default.blue("\u{1F9E0} Analyzing context costs...\n"));
-  const startTime = Date.now();
-  try {
-    const defaults = {
+  return await executeToolAction(directory, options, {
+    toolName: "context-analyzer",
+    label: "Context analysis",
+    emoji: "\u{1F9E0}",
+    defaults: {
       maxDepth: 5,
       maxContextBudget: 1e4,
       include: void 0,
       exclude: void 0,
-      output: {
-        format: "console",
-        file: void 0
-      }
-    };
-    const { resolvedDir, finalOptions: baseOptions } = await (0, import_core12.prepareActionConfig)(directory, defaults, {
-      maxDepth: options.maxDepth ? parseInt(options.maxDepth) : void 0,
-      maxContextBudget: options.maxContext ? parseInt(options.maxContext) : void 0,
-      include: options.include?.split(","),
-      exclude: options.exclude?.split(",")
-    });
-    let finalOptions = { ...baseOptions };
-    const { getSmartDefaults } = await import("@aiready/context-analyzer");
-    const contextSmartDefaults = await getSmartDefaults(
-      resolvedDir,
-      baseOptions
-    );
-    finalOptions = { ...contextSmartDefaults, ...finalOptions };
-    console.log("\u{1F4CB} Configuration:");
-    console.log(`   Max depth: ${finalOptions.maxDepth}`);
-    console.log(`   Max context budget: ${finalOptions.maxContextBudget}`);
-    console.log(
-      `   Min cohesion: ${(finalOptions.minCohesion * 100).toFixed(1)}%`
-    );
-    console.log(
-      `   Max fragmentation: ${(finalOptions.maxFragmentation * 100).toFixed(1)}%`
-    );
-    console.log(`   Analysis focus: ${finalOptions.focus}`);
-    console.log("");
-    const { analyzeContext, generateSummary, calculateContextScore } = await import("@aiready/context-analyzer");
-    const results = await analyzeContext(finalOptions);
-    const elapsedTime = (0, import_core12.getElapsedTime)(startTime);
-    const summary = generateSummary(results);
-    let contextScore;
-    if (options.score) {
-      contextScore = calculateContextScore(summary);
-    }
-    const { format: outputFormat, file: userOutputFile } = (0, import_core12.resolveOutputFormat)(
-      options,
-      finalOptions
-    );
-    if (outputFormat === "json") {
-      const outputData = (0, import_core12.formatStandardReport)({
-        results,
-        summary,
-        elapsedTime,
-        score: contextScore
-      });
-      (0, import_core12.handleStandardJSONOutput)({
-        outputData,
-        outputFile: userOutputFile,
-        resolvedDir
-      });
-    } else {
-      const terminalWidth = process.stdout.columns ?? 80;
-      const dividerWidth = Math.min(60, terminalWidth - 2);
-      const divider = "\u2501".repeat(dividerWidth);
-      console.log(import_chalk9.default.cyan(divider));
-      console.log(import_chalk9.default.bold.white("  CONTEXT ANALYSIS SUMMARY"));
-      console.log(import_chalk9.default.cyan(divider) + "\n");
+      output: { format: "console", file: void 0 }
+    },
+    getCliOptions: (opts) => ({
+      maxDepth: opts.maxDepth ? parseInt(opts.maxDepth) : void 0,
+      maxContextBudget: opts.maxContext ? parseInt(opts.maxContext) : void 0
+    }),
+    preAnalyze: async (resolvedDir, baseOptions) => {
+      const { getSmartDefaults } = await import("@aiready/context-analyzer");
+      const smartDefaults = await getSmartDefaults(resolvedDir, baseOptions);
+      return { ...smartDefaults, ...baseOptions };
+    },
+    importTool: async () => {
+      const { analyzeContext, generateSummary, calculateContextScore } = await import("@aiready/context-analyzer");
+      return {
+        analyze: analyzeContext,
+        generateSummary,
+        calculateScore: calculateContextScore
+      };
+    },
+    renderConsole: ({ summary, elapsedTime, score }) => {
+      (0, import_core14.printTerminalHeader)("CONTEXT ANALYSIS SUMMARY");
       console.log(
-        import_chalk9.default.white(`\u{1F4C1} Files analyzed: ${import_chalk9.default.bold(summary.totalFiles)}`)
+        import_chalk10.default.white(`\u{1F4C1} Files analyzed: ${import_chalk10.default.bold(summary.totalFiles)}`)
       );
       console.log(
-        import_chalk9.default.white(
-          `\u{1F4CA} Total tokens: ${import_chalk9.default.bold(summary.totalTokens.toLocaleString())}`
+        import_chalk10.default.white(
+          `\u{1F4CA} Total tokens: ${import_chalk10.default.bold(summary.totalTokens.toLocaleString())}`
         )
       );
       console.log(
-        import_chalk9.default.yellow(
-          `\u{1F4B0} Avg context budget: ${import_chalk9.default.bold(summary.avgContextBudget.toFixed(0))} tokens/file`
+        import_chalk10.default.yellow(
+          `\u{1F4B0} Avg context budget: ${import_chalk10.default.bold(summary.avgContextBudget.toFixed(0))} tokens/file`
         )
       );
       console.log(
-        import_chalk9.default.white(`\u23F1  Analysis time: ${import_chalk9.default.bold(elapsedTime + "s")}
+        import_chalk10.default.white(`\u23F1  Analysis time: ${import_chalk10.default.bold(elapsedTime + "s")}
 `)
       );
-      const totalIssues = summary.criticalIssues + summary.majorIssues + summary.minorIssues;
-      if (totalIssues > 0) {
-        console.log(import_chalk9.default.bold("\u26A0\uFE0F  Issues Found:\n"));
-        if (summary.criticalIssues > 0) {
-          console.log(
-            import_chalk9.default.red(`   \u{1F534} Critical: ${import_chalk9.default.bold(summary.criticalIssues)}`)
-          );
-        }
-        if (summary.majorIssues > 0) {
-          console.log(
-            import_chalk9.default.yellow(`   \u{1F7E1} Major: ${import_chalk9.default.bold(summary.majorIssues)}`)
-          );
-        }
-        if (summary.minorIssues > 0) {
-          console.log(
-            import_chalk9.default.blue(`   \u{1F535} Minor: ${import_chalk9.default.bold(summary.minorIssues)}`)
-          );
-        }
-        console.log(
-          import_chalk9.default.green(
-            `
-   \u{1F4A1} Potential savings: ${import_chalk9.default.bold(summary.totalPotentialSavings.toLocaleString())} tokens
-`
-          )
-        );
-      } else {
-        console.log(import_chalk9.default.green("\u2705 No significant issues found!\n"));
-      }
-      if (summary.deepFiles.length > 0) {
-        console.log(import_chalk9.default.bold("\u{1F4CF} Deep Import Chains:\n"));
-        console.log(
-          import_chalk9.default.gray(`   Average depth: ${summary.avgImportDepth.toFixed(1)}`)
-        );
-        console.log(
-          import_chalk9.default.gray(`   Maximum depth: ${summary.maxImportDepth}
-`)
-        );
+      renderIssueSummaryBlock(summary);
+      if (summary.deepFiles && summary.deepFiles.length > 0) {
+        renderSubSection("Deep Import Chains");
         summary.deepFiles.slice(0, 10).forEach((item) => {
           const fileName = item.file.split("/").slice(-2).join("/");
           console.log(
-            `   ${import_chalk9.default.cyan("\u2192")} ${import_chalk9.default.white(fileName)} ${import_chalk9.default.dim(`(depth: ${item.depth})`)}`
+            `   ${import_chalk10.default.cyan("\u2192")} ${import_chalk10.default.white(fileName)} ${import_chalk10.default.dim(`(depth: ${item.depth})`)}`
           );
         });
-        console.log();
       }
-      if (summary.fragmentedModules.length > 0) {
-        console.log(import_chalk9.default.bold("\u{1F9E9} Fragmented Modules:\n"));
-        console.log(
-          import_chalk9.default.gray(
-            `   Average fragmentation: ${(summary.avgFragmentation * 100).toFixed(0)}%
-`
-          )
-        );
+      if (summary.fragmentedModules && summary.fragmentedModules.length > 0) {
+        renderSubSection("Fragmented Modules");
         summary.fragmentedModules.slice(0, 10).forEach((module2) => {
           console.log(
-            `   ${import_chalk9.default.yellow("\u25CF")} ${import_chalk9.default.white(module2.domain)} - ${import_chalk9.default.dim(`${module2.files.length} files, ${(module2.fragmentationScore * 100).toFixed(0)}% scattered`)}`
+            `   ${import_chalk10.default.yellow("\u25CF")} ${import_chalk10.default.white(module2.domain)} - ${import_chalk10.default.dim(`${module2.files.length} files, ${(module2.fragmentationScore * 100).toFixed(0)}% scattered`)}`
           );
           console.log(
-            import_chalk9.default.dim(
+            import_chalk10.default.dim(
               `     Token cost: ${module2.totalTokens.toLocaleString()}, Cohesion: ${(module2.avgCohesion * 100).toFixed(0)}%`
             )
           );
         });
-        console.log();
-      }
-      if (summary.lowCohesionFiles.length > 0) {
-        console.log(import_chalk9.default.bold("\u{1F500} Low Cohesion Files:\n"));
-        console.log(
-          import_chalk9.default.gray(
-            `   Average cohesion: ${(summary.avgCohesion * 100).toFixed(0)}%
-`
-          )
-        );
-        summary.lowCohesionFiles.slice(0, 10).forEach((item) => {
-          const fileName = item.file.split("/").slice(-2).join("/");
-          const scorePercent = (item.score * 100).toFixed(0);
-          const color = item.score < 0.4 ? import_chalk9.default.red : import_chalk9.default.yellow;
-          console.log(
-            `   ${color("\u25CB")} ${import_chalk9.default.white(fileName)} ${import_chalk9.default.dim(`(${scorePercent}% cohesion)`)}`
-          );
-        });
-        console.log();
-      }
-      if (summary.topExpensiveFiles.length > 0) {
-        console.log(import_chalk9.default.bold("\u{1F4B8} Most Expensive Files (Context Budget):\n"));
-        summary.topExpensiveFiles.slice(0, 10).forEach((item) => {
-          const fileName = item.file.split("/").slice(-2).join("/");
-          const severityColor = item.severity === "critical" ? import_chalk9.default.red : item.severity === "major" ? import_chalk9.default.yellow : import_chalk9.default.blue;
-          console.log(
-            `   ${severityColor("\u25CF")} ${import_chalk9.default.white(fileName)} ${import_chalk9.default.dim(`(${item.contextBudget.toLocaleString()} tokens)`)}`
-          );
-        });
-        console.log();
-      }
-      if (contextScore) {
-        console.log(import_chalk9.default.cyan(divider));
-        console.log(import_chalk9.default.bold.white("  AI READINESS SCORE (Context)"));
-        console.log(import_chalk9.default.cyan(divider) + "\n");
-        console.log((0, import_core12.formatToolScore)(contextScore));
-        console.log();
       }
+      renderToolScoreFooter(score);
     }
-  } catch (error) {
-    (0, import_core12.handleCLIError)(error, "Context analysis");
-  }
+  });
 }
 
 // src/commands/consistency.ts
-var import_chalk10 = __toESM(require("chalk"));
+var import_chalk11 = __toESM(require("chalk"));
 var import_fs6 = require("fs");
-var import_core13 = require("@aiready/core");
+var import_core15 = require("@aiready/core");
 async function consistencyAction(directory, options) {
-  console.log(import_chalk10.default.blue("\u{1F50D} Analyzing consistency...\n"));
-  const startTime = Date.now();
-  try {
-    const defaults = {
+  return await executeToolAction(directory, options, {
+    toolName: "naming-consistency",
+    label: "Consistency analysis",
+    emoji: "\u{1F50D}",
+    defaults: {
       checkNaming: true,
       checkPatterns: true,
       minSeverity: "info",
       include: void 0,
       exclude: void 0,
-      output: {
-        format: "console",
-        file: void 0
-      }
-    };
-    const { resolvedDir, finalOptions } = await (0, import_core13.prepareActionConfig)(
-      directory,
-      defaults,
-      {
-        checkNaming: options.naming !== false,
-        checkPatterns: options.patterns !== false,
-        minSeverity: options.minSeverity,
-        include: options.include?.split(","),
-        exclude: options.exclude?.split(",")
+      output: { format: "console", file: void 0 }
+    },
+    getCliOptions: (opts) => ({
+      checkNaming: opts.naming !== false,
+      checkPatterns: opts.patterns !== false,
+      minSeverity: opts.minSeverity
+    }),
+    importTool: async () => {
+      const { analyzeConsistency, calculateConsistencyScore } = await import("@aiready/consistency");
+      return {
+        analyze: analyzeConsistency,
+        generateSummary: (report) => report.summary,
+        calculateScore: (summary, _resultsCount) => {
+          return calculateConsistencyScore(
+            summary.results?.flatMap((r) => r.issues) ?? [],
+            summary.summary.filesAnalyzed
+          );
+        }
+      };
+    },
+    renderConsole: ({ results, summary, elapsedTime, score, finalOptions }) => {
+      const report = results;
+      const { format: outputFormat, file: userOutputFile } = (0, import_core15.resolveOutputFormat)(options, finalOptions);
+      if (outputFormat === "markdown") {
+        const markdown = generateMarkdownReport(report, elapsedTime);
+        const outputPath = (0, import_core15.resolveOutputPath)(
+          userOutputFile,
+          `aiready-report-${(0, import_core2.getReportTimestamp)()}.md`,
+          directory
+        );
+        (0, import_fs6.writeFileSync)(outputPath, markdown);
+        console.log(import_chalk11.default.green(`\u2705 Report saved to ${outputPath}`));
+        return;
       }
-    );
-    const { analyzeConsistency, calculateConsistencyScore } = await import("@aiready/consistency");
-    const report = await analyzeConsistency(finalOptions);
-    const elapsedTime = (0, import_core13.getElapsedTime)(startTime);
-    let consistencyScore;
-    if (options.score) {
-      const issues = report.results?.flatMap((r) => r.issues) ?? [];
-      consistencyScore = calculateConsistencyScore(
-        issues,
-        report.summary.filesAnalyzed
-      );
-    }
-    const { format: outputFormat, file: userOutputFile } = (0, import_core13.resolveOutputFormat)(
-      options,
-      finalOptions
-    );
-    if (outputFormat === "json") {
-      const outputData = (0, import_core13.formatStandardReport)({
-        report,
-        summary: report.summary,
-        elapsedTime,
-        score: consistencyScore
-      });
-      (0, import_core13.handleStandardJSONOutput)({
-        outputData,
-        outputFile: userOutputFile,
-        resolvedDir
-      });
-    } else if (outputFormat === "markdown") {
-      const markdown = generateMarkdownReport(report, elapsedTime);
-      const outputPath = (0, import_core13.resolveOutputPath)(
-        userOutputFile,
-        `aiready-report-${(0, import_core2.getReportTimestamp)()}.md`,
-        resolvedDir
-      );
-      (0, import_fs6.writeFileSync)(outputPath, markdown);
-      console.log(import_chalk10.default.green(`\u2705 Report saved to ${outputPath}`));
-    } else {
-      console.log(import_chalk10.default.bold("\n\u{1F4CA} Summary\n"));
-      console.log(
-        `Files Analyzed: ${import_chalk10.default.cyan(report.summary.filesAnalyzed)}`
-      );
-      console.log(`Total Issues: ${import_chalk10.default.yellow(report.summary.totalIssues)}`);
-      console.log(`  Naming: ${import_chalk10.default.yellow(report.summary.namingIssues)}`);
-      console.log(`  Patterns: ${import_chalk10.default.yellow(report.summary.patternIssues)}`);
+      console.log(import_chalk11.default.bold("\n\u{1F4CA} Summary\n"));
+      console.log(`Files Analyzed: ${import_chalk11.default.cyan(summary.filesAnalyzed)}`);
+      console.log(`Total Issues: ${import_chalk11.default.yellow(summary.totalIssues)}`);
+      console.log(`  Naming: ${import_chalk11.default.yellow(summary.namingIssues)}`);
+      console.log(`  Patterns: ${import_chalk11.default.yellow(summary.patternIssues)}`);
       console.log(
-        `  Architecture: ${import_chalk10.default.yellow(report.summary.architectureIssues ?? 0)}`
+        `  Architecture: ${import_chalk11.default.yellow(summary.architectureIssues ?? 0)}`
       );
-      console.log(`Analysis Time: ${import_chalk10.default.gray(elapsedTime + "s")}
+      console.log(`Analysis Time: ${import_chalk11.default.gray(elapsedTime + "s")}
 `);
-      if (report.summary.totalIssues === 0) {
+      if (summary.totalIssues === 0) {
         console.log(
-          import_chalk10.default.green(
+          import_chalk11.default.green(
             "\u2728 No consistency issues found! Your codebase is well-maintained.\n"
           )
         );
@@ -1706,100 +1698,88 @@ async function consistencyAction(directory, options) {
           (r) => r.issues.some((i) => i.category === "patterns")
         );
         if (namingResults.length > 0) {
-          console.log(import_chalk10.default.bold("\u{1F3F7}\uFE0F  Naming Issues\n"));
+          console.log(import_chalk11.default.bold("\u{1F3F7}\uFE0F  Naming Issues\n"));
           let shown = 0;
           for (const namingFileResult of namingResults) {
             if (shown >= 5) break;
             for (const issue of namingFileResult.issues) {
               if (shown >= 5) break;
-              const severityColor = issue.severity === "critical" ? import_chalk10.default.red : issue.severity === "major" ? import_chalk10.default.yellow : issue.severity === "minor" ? import_chalk10.default.blue : import_chalk10.default.gray;
+              const severityColor = issue.severity === "critical" ? import_chalk11.default.red : issue.severity === "major" ? import_chalk11.default.yellow : issue.severity === "minor" ? import_chalk11.default.blue : import_chalk11.default.gray;
               console.log(
-                `${severityColor(issue.severity.toUpperCase())} ${import_chalk10.default.dim(`${issue.location.file}:${issue.location.line}`)}`
+                `${severityColor(issue.severity.toUpperCase())} ${import_chalk11.default.dim(`${issue.location.file}:${issue.location.line}`)}`
               );
               console.log(`  ${issue.message}`);
               if (issue.suggestion) {
                 console.log(
-                  `  ${import_chalk10.default.dim("\u2192")} ${import_chalk10.default.italic(issue.suggestion)}`
+                  `  ${import_chalk11.default.dim("\u2192")} ${import_chalk11.default.italic(issue.suggestion)}`
                 );
               }
               console.log();
               shown++;
             }
           }
-          const remaining = namingResults.reduce((sum, r) => sum + r.issues.length, 0) - shown;
-          if (remaining > 0) {
-            console.log(import_chalk10.default.dim(`  ... and ${remaining} more issues
-`));
-          }
         }
         if (patternResults.length > 0) {
-          console.log(import_chalk10.default.bold("\u{1F504} Pattern Issues\n"));
+          console.log(import_chalk11.default.bold("\u{1F504} Pattern Issues\n"));
           let shown = 0;
           for (const patternFileResult of patternResults) {
             if (shown >= 5) break;
             for (const issue of patternFileResult.issues) {
               if (shown >= 5) break;
-              const severityColor = issue.severity === "critical" ? import_chalk10.default.red : issue.severity === "major" ? import_chalk10.default.yellow : issue.severity === "minor" ? import_chalk10.default.blue : import_chalk10.default.gray;
+              const severityColor = issue.severity === "critical" ? import_chalk11.default.red : issue.severity === "major" ? import_chalk11.default.yellow : issue.severity === "minor" ? import_chalk11.default.blue : import_chalk11.default.gray;
               console.log(
-                `${severityColor(issue.severity.toUpperCase())} ${import_chalk10.default.dim(`${issue.location.file}:${issue.location.line}`)}`
+                `${severityColor(issue.severity.toUpperCase())} ${import_chalk11.default.dim(`${issue.location.file}:${issue.location.line}`)}`
               );
               console.log(`  ${issue.message}`);
               if (issue.suggestion) {
                 console.log(
-                  `  ${import_chalk10.default.dim("\u2192")} ${import_chalk10.default.italic(issue.suggestion)}`
+                  `  ${import_chalk11.default.dim("\u2192")} ${import_chalk11.default.italic(issue.suggestion)}`
                 );
               }
               console.log();
               shown++;
             }
           }
-          const remaining = patternResults.reduce((sum, r) => sum + r.issues.length, 0) - shown;
-          if (remaining > 0) {
-            console.log(import_chalk10.default.dim(`  ... and ${remaining} more issues
-`));
-          }
         }
-        if (report.recommendations.length > 0) {
-          console.log(import_chalk10.default.bold("\u{1F4A1} Recommendations\n"));
+        if (report.recommendations?.length > 0) {
+          console.log(import_chalk11.default.bold("\u{1F4A1} Recommendations\n"));
           report.recommendations.forEach((rec, i) => {
             console.log(`${i + 1}. ${rec}`);
           });
           console.log();
         }
       }
-      if (consistencyScore) {
-        console.log(import_chalk10.default.bold("\n\u{1F4CA} AI Readiness Score (Consistency)\n"));
-        console.log((0, import_core13.formatToolScore)(consistencyScore));
+      if (score) {
+        console.log(import_chalk11.default.bold("\n\u{1F4CA} AI Readiness Score (Consistency)\n"));
+        console.log((0, import_core15.formatToolScore)(score));
         console.log();
       }
     }
-  } catch (error) {
-    (0, import_core13.handleCLIError)(error, "Consistency analysis");
-  }
+  });
 }
 
 // src/commands/visualize.ts
-var import_chalk11 = __toESM(require("chalk"));
+var import_chalk12 = __toESM(require("chalk"));
 var import_fs7 = require("fs");
 var import_path6 = require("path");
 var import_child_process = require("child_process");
-var import_core14 = require("@aiready/core");
-var import_core15 = require("@aiready/core");
+var import_core16 = require("@aiready/core");
+var import_core17 = require("@aiready/core");
 async function visualizeAction(directory, options) {
   try {
     const dirPath = (0, import_path6.resolve)(process.cwd(), directory ?? ".");
     let reportPath = options.report ? (0, import_path6.resolve)(dirPath, options.report) : null;
     if (!reportPath || !(0, import_fs7.existsSync)(reportPath)) {
-      const latestScan = (0, import_core15.findLatestReport)(dirPath);
+      const latestScan = (0, import_core17.findLatestReport)(dirPath);
       if (latestScan) {
         reportPath = latestScan;
         console.log(
-          import_chalk11.default.dim(`Found latest report: ${latestScan.split("/").pop()}`)
+          import_chalk12.default.dim(`Found latest report: ${latestScan.split("/").pop()}`)
         );
       } else {
-        console.error(import_chalk11.default.red("\u274C No AI readiness report found"));
+        console.error(import_chalk12.default.red("\u274C No AI readiness report found"));
         console.log(
-          import_chalk11.default.dim(
+          import_chalk12.default.dim(
             `
 Generate a report with:
   aiready scan --output json
@@ -1929,29 +1909,29 @@ Or specify a custom report:
           return;
         } else {
           console.log(
-            import_chalk11.default.yellow(
+            import_chalk12.default.yellow(
               "\u26A0\uFE0F  Dev server not available (requires local @aiready/visualizer with web assets)."
             )
           );
           console.log(
-            import_chalk11.default.cyan("   Falling back to static HTML generation...\n")
+            import_chalk12.default.cyan("   Falling back to static HTML generation...\n")
           );
           useDevMode = false;
         }
       } catch (err) {
         console.error("Failed to start dev server:", err);
         console.log(
-          import_chalk11.default.cyan("   Falling back to static HTML generation...\n")
+          import_chalk12.default.cyan("   Falling back to static HTML generation...\n")
         );
         useDevMode = false;
       }
     }
     console.log("Generating HTML...");
-    const html = (0, import_core15.generateHTML)(graph);
+    const html = (0, import_core17.generateHTML)(graph);
     const defaultOutput = "visualization.html";
     const outPath = (0, import_path6.resolve)(dirPath, options.output ?? defaultOutput);
     (0, import_fs7.writeFileSync)(outPath, html, "utf8");
-    console.log(import_chalk11.default.green(`\u2705 Visualization written to: ${outPath}`));
+    console.log(import_chalk12.default.green(`\u2705 Visualization written to: ${outPath}`));
     if (options.open || options.serve) {
       const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
       if (options.serve) {
@@ -1981,7 +1961,7 @@ Or specify a custom report:
           server.listen(port, () => {
             const addr = `http://localhost:${port}/`;
             console.log(
-              import_chalk11.default.cyan(`\u{1F310} Local visualization server running at ${addr}`)
+              import_chalk12.default.cyan(`\u{1F310} Local visualization server running at ${addr}`)
             );
             (0, import_child_process.spawn)(opener, [`"${addr}"`], { shell: true });
           });
@@ -1997,7 +1977,7 @@ Or specify a custom report:
       }
     }
   } catch (err) {
-    (0, import_core14.handleCLIError)(err, "Visualization");
+    (0, import_core16.handleCLIError)(err, "Visualization");
   }
 }
 var VISUALIZE_HELP_TEXT = `
@@ -2028,72 +2008,63 @@ NOTES:
 `;
 
 // src/commands/shared/standard-tool-actions.ts
-var import_chalk12 = __toESM(require("chalk"));
+var import_chalk13 = __toESM(require("chalk"));
 
 // src/commands/agent-grounding.ts
-var import_chalk13 = __toESM(require("chalk"));
-var import_core16 = require("@aiready/core");
+var import_chalk14 = __toESM(require("chalk"));
 
 // src/commands/testability.ts
-var import_chalk14 = __toESM(require("chalk"));
-var import_core17 = require("@aiready/core");
+var import_chalk15 = __toESM(require("chalk"));
 async function testabilityAction(directory, options) {
-  const { analyzeTestability, calculateTestabilityScore } = await import("@aiready/testability");
-  const config = await (0, import_core17.loadConfig)(directory);
-  const merged = (0, import_core17.mergeConfigWithDefaults)(config, {
-    minCoverageRatio: 0.3
-  });
-  const report = await analyzeTestability({
-    rootDir: directory,
-    minCoverageRatio: options.minCoverageRatio ?? merged.minCoverageRatio,
-    include: options.include,
-    exclude: options.exclude
+  return await executeToolAction(directory, options, {
+    toolName: "testability-index",
+    label: "Testability analysis",
+    emoji: "\u{1F9EA}",
+    defaults: {
+      minCoverageRatio: 0.3,
+      include: void 0,
+      exclude: void 0,
+      output: { format: "console", file: void 0 }
+    },
+    getCliOptions: (opts) => ({
+      minCoverageRatio: opts.minCoverage ? parseFloat(opts.minCoverage) : void 0
+    }),
+    importTool: async () => {
+      const tool = await import("@aiready/testability");
+      return {
+        analyze: tool.analyzeTestability,
+        generateSummary: (report) => report.summary,
+        calculateScore: tool.calculateTestabilityScore
+      };
+    },
+    renderConsole: ({ results, summary, score }) => {
+      renderToolHeader("Testability", "\u{1F9EA}", score?.score || 0, summary.rating);
+      renderSafetyRating(summary.aiChangeSafetyRating);
+      const rawData = results.rawData || results;
+      console.log(
+        import_chalk15.default.dim(
+          `     Coverage: ${Math.round(summary.coverageRatio * 100)}%  (${rawData.testFiles} test / ${rawData.sourceFiles} source files)`
+        )
+      );
+      if (summary.aiChangeSafetyRating === "blind-risk") {
+        console.log(
+          import_chalk15.default.red.bold(
+            "\n     \u26A0\uFE0F  NO TESTS \u2014 AI changes to this codebase are completely unverifiable!\n"
+          )
+        );
+      }
+      if (score) {
+        renderToolScoreFooter(score);
+      }
+    }
   });
-  const scoring = calculateTestabilityScore(report);
-  if (options.output === "json") {
-    return scoring;
-  }
-  const safetyIcons = {
-    safe: "\u2705",
-    "moderate-risk": "\u26A0\uFE0F ",
-    "high-risk": "\u{1F534}",
-    "blind-risk": "\u{1F480}"
-  };
-  const safetyColors = {
-    safe: import_chalk14.default.green,
-    "moderate-risk": import_chalk14.default.yellow,
-    "high-risk": import_chalk14.default.red,
-    "blind-risk": import_chalk14.default.bgRed.white
-  };
-  const safety = report.summary.aiChangeSafetyRating;
-  const icon = safetyIcons[safety] ?? "\u2753";
-  const color = safetyColors[safety] ?? import_chalk14.default.white;
-  console.log(
-    `  \u{1F9EA} Testability:         ${import_chalk14.default.bold(scoring.score + "/100")} (${report.summary.rating})`
-  );
-  console.log(
-    `     AI Change Safety:  ${color(`${icon} ${safety.toUpperCase()}`)}`
-  );
-  console.log(
-    import_chalk14.default.dim(
-      `     Coverage: ${Math.round(report.summary.coverageRatio * 100)}%  (${report.rawData.testFiles} test / ${report.rawData.sourceFiles} source files)`
-    )
-  );
-  if (safety === "blind-risk") {
-    console.log(
-      import_chalk14.default.red.bold(
-        "\n     \u26A0\uFE0F  NO TESTS \u2014 AI changes to this codebase are completely unverifiable!\n"
-      )
-    );
-  }
-  return scoring;
 }
 
 // src/commands/change-amplification.ts
 var import_cli = require("@aiready/change-amplification/dist/cli.js");
 
 // src/commands/bug.ts
-var import_chalk15 = __toESM(require("chalk"));
+var import_chalk16 = __toESM(require("chalk"));
 var import_child_process2 = require("child_process");
 async function bugAction(message, options) {
   const repoUrl = "https://github.com/caopengau/aiready-cli";
@@ -2111,35 +2082,35 @@ Generated via AIReady CLI 'bug' command.
 Type: ${type}
     `.trim();
     if (options.submit) {
-      console.log(import_chalk15.default.blue("\u{1F680} Submitting issue via GitHub CLI...\n"));
+      console.log(import_chalk16.default.blue("\u{1F680} Submitting issue via GitHub CLI...\n"));
       try {
         (0, import_child_process2.execSync)("gh auth status", { stdio: "ignore" });
         const command = `gh issue create --repo ${repoSlug} --title ${JSON.stringify(title)} --body ${JSON.stringify(body)} --label ${label}`;
         const output = (0, import_child_process2.execSync)(command, { encoding: "utf8" }).trim();
-        console.log(import_chalk15.default.green("\u2705 Issue Created Successfully!"));
-        console.log(import_chalk15.default.cyan(output));
+        console.log(import_chalk16.default.green("\u2705 Issue Created Successfully!"));
+        console.log(import_chalk16.default.cyan(output));
         return;
       } catch {
-        console.error(import_chalk15.default.red("\n\u274C Failed to submit via gh CLI."));
+        console.error(import_chalk16.default.red("\n\u274C Failed to submit via gh CLI."));
         console.log(
-          import_chalk15.default.yellow(
+          import_chalk16.default.yellow(
             '   Make sure gh is installed and run "gh auth login".\n'
           )
         );
-        console.log(import_chalk15.default.dim("   Falling back to URL generation..."));
+        console.log(import_chalk16.default.dim("   Falling back to URL generation..."));
       }
     }
     const template = type === "bug" ? "bug_report.md" : type === "feature" ? "feature_request.md" : "new_metric_idea.md";
     const fullUrl = `${repoUrl}/issues/new?title=${encodeURIComponent(title)}&body=${encodeURIComponent(body)}&labels=${label}&template=${template}`;
-    console.log(import_chalk15.default.green("\u{1F680} Issue Draft Prepared!\n"));
-    console.log(import_chalk15.default.bold("Title:  ") + title);
-    console.log(import_chalk15.default.bold("Type:   ") + type);
-    console.log(import_chalk15.default.bold("\nClick the link below to submit this issue:"));
-    console.log(import_chalk15.default.cyan(fullUrl));
-    console.log(import_chalk15.default.bold("\n\u{1F916} [FOR AI AGENTS]:"));
-    console.log(import_chalk15.default.dim("   You have successfully prepared a report."));
+    console.log(import_chalk16.default.green("\u{1F680} Issue Draft Prepared!\n"));
+    console.log(import_chalk16.default.bold("Title:  ") + title);
+    console.log(import_chalk16.default.bold("Type:   ") + type);
+    console.log(import_chalk16.default.bold("\nClick the link below to submit this issue:"));
+    console.log(import_chalk16.default.cyan(fullUrl));
+    console.log(import_chalk16.default.bold("\n\u{1F916} [FOR AI AGENTS]:"));
+    console.log(import_chalk16.default.dim("   You have successfully prepared a report."));
     console.log(
-      import_chalk15.default.dim(
+      import_chalk16.default.dim(
         "   Please present the URL above to the user so they can finalize the submission."
       )
     );
@@ -2148,14 +2119,14 @@ Type: ${type}
   const bugUrl = `${repoUrl}/issues/new?template=bug_report.md`;
   const featureUrl = `${repoUrl}/issues/new?template=feature_request.md`;
   const metricUrl = `${repoUrl}/issues/new?template=new_metric_idea.md`;
-  console.log(import_chalk15.default.blue("\u{1F4AC} Feedback & Bug Reports\n"));
-  console.log(`  Report a Bug:        ${import_chalk15.default.cyan(bugUrl)}`);
-  console.log(`  Request a Feature:   ${import_chalk15.default.cyan(featureUrl)}`);
-  console.log(`  Suggest a Metric:    ${import_chalk15.default.cyan(metricUrl)}`);
-  console.log(import_chalk15.default.bold("\n\u{1F916} [FOR AI AGENTS]:"));
-  console.log(import_chalk15.default.dim("   To prepare a specific report, run:"));
+  console.log(import_chalk16.default.blue("\u{1F4AC} Feedback & Bug Reports\n"));
+  console.log(`  Report a Bug:        ${import_chalk16.default.cyan(bugUrl)}`);
+  console.log(`  Request a Feature:   ${import_chalk16.default.cyan(featureUrl)}`);
+  console.log(`  Suggest a Metric:    ${import_chalk16.default.cyan(metricUrl)}`);
+  console.log(import_chalk16.default.bold("\n\u{1F916} [FOR AI AGENTS]:"));
+  console.log(import_chalk16.default.dim("   To prepare a specific report, run:"));
   console.log(
-    import_chalk15.default.cyan(
+    import_chalk16.default.cyan(
       '   aiready bug "your description here" --type bug|feature|metric'
     )
   );