@aiready/cli 0.10.4 → 0.12.0

package/dist/cli.mjs

@@ -3,7 +3,7 @@ import {
   __require,
   analyzeUnified,
   scoreUnified
-} from "./chunk-R3O7QPKD.mjs";
+} from "./chunk-N56YAZVN.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -19,18 +19,15 @@ import {
   loadMergedConfig,
   handleJSONOutput,
   handleCLIError as handleCLIError2,
-  getElapsedTime,
   resolveOutputPath,
   formatScore,
-  formatToolScore,
   calculateTokenBudget,
   estimateCostFromBudget,
   getModelPreset,
   getRating,
-  getRatingDisplay,
   getRepoMetadata,
   Severity,
-  IssueType
+  ToolName
 } from "@aiready/core";
 
 // src/utils/helpers.ts
@@ -150,12 +147,6 @@ function generateMarkdownReport(report, elapsedTime) {
   }
   return markdown;
 }
-function truncateArray(arr, cap = 8) {
-  if (!Array.isArray(arr)) return "";
-  const shown = arr.slice(0, cap).map((v) => String(v));
-  const more = arr.length - shown.length;
-  return shown.join(", ") + (more > 0 ? `, ... (+${more} more)` : "");
-}
 
 // src/commands/upload.ts
 import fs from "fs";
@@ -269,14 +260,14 @@ async function scanAction(directory, options) {
   try {
     const defaults = {
       tools: [
-        "patterns",
-        "context",
-        "consistency",
+        "pattern-detect",
+        "context-analyzer",
+        "naming-consistency",
         "ai-signal-clarity",
         "agent-grounding",
-        "testability",
+        "testability-index",
         "doc-drift",
-        "deps-health",
+        "dependency-health",
         "change-amplification"
       ],
       include: void 0,
@@ -286,35 +277,37 @@ async function scanAction(directory, options) {
         file: void 0
       }
     };
-    let profileTools = options.tools ? options.tools.split(",").map((t) => {
-      const tool = t.trim();
-      if (tool === "hallucination" || tool === "hallucination-risk")
-        return "aiSignalClarity";
-      return tool;
-    }) : void 0;
+    let profileTools = options.tools ? options.tools.split(",").map((t) => t.trim()) : void 0;
     if (options.profile) {
       switch (options.profile.toLowerCase()) {
         case "agentic":
           profileTools = [
-            "ai-signal-clarity",
-            "agent-grounding",
-            "testability"
+            ToolName.AiSignalClarity,
+            ToolName.AgentGrounding,
+            ToolName.TestabilityIndex
           ];
           break;
         case "cost":
-          profileTools = ["patterns", "context"];
+          profileTools = [ToolName.PatternDetect, ToolName.ContextAnalyzer];
           break;
         case "security":
-          profileTools = ["consistency", "testability"];
+          profileTools = [
+            ToolName.NamingConsistency,
+            ToolName.TestabilityIndex
+          ];
           break;
         case "onboarding":
-          profileTools = ["context", "consistency", "agent-grounding"];
+          profileTools = [
+            ToolName.ContextAnalyzer,
+            ToolName.NamingConsistency,
+            ToolName.AgentGrounding
+          ];
           break;
         default:
           console.log(
             chalk3.yellow(
               `
-\u26A0\uFE0F  Unknown profile '${options.profile}'. Using specified tools or defaults.`
+\u26A0\uFE0F  Unknown profile '${options.profile}'. Using defaults.`
             )
           );
       }
@@ -323,16 +316,14 @@ async function scanAction(directory, options) {
       include: options.include?.split(","),
       exclude: options.exclude?.split(",")
     };
-    if (profileTools) {
-      cliOverrides.tools = profileTools;
-    }
+    if (profileTools) cliOverrides.tools = profileTools;
     const baseOptions = await loadMergedConfig(
       resolvedDir,
       defaults,
       cliOverrides
     );
     let finalOptions = { ...baseOptions };
-    if (baseOptions.tools.includes("patterns")) {
+    if (baseOptions.tools.includes(ToolName.PatternDetect) || baseOptions.tools.includes("patterns")) {
       const { getSmartDefaults } = await import("@aiready/pattern-detect");
       const patternSmartDefaults = await getSmartDefaults(
         resolvedDir,
@@ -347,256 +338,21 @@ async function scanAction(directory, options) {
     console.log(chalk3.cyan("\n=== AIReady Run Preview ==="));
     console.log(
       chalk3.white("Tools to run:"),
-      (finalOptions.tools || ["patterns", "context", "consistency"]).join(", ")
+      (finalOptions.tools || []).join(", ")
     );
-    console.log(chalk3.white("Will use settings from config and defaults."));
-    console.log(chalk3.white("\nGeneral settings:"));
-    if (finalOptions.rootDir)
-      console.log(`  rootDir: ${chalk3.bold(String(finalOptions.rootDir))}`);
-    if (finalOptions.include)
-      console.log(
-        `  include: ${chalk3.bold(truncateArray(finalOptions.include, 6))}`
-      );
-    if (finalOptions.exclude)
-      console.log(
-        `  exclude: ${chalk3.bold(truncateArray(finalOptions.exclude, 6))}`
-      );
-    if (finalOptions["pattern-detect"] || finalOptions.minSimilarity) {
-      const patternDetectConfig = finalOptions["pattern-detect"] || {
-        minSimilarity: finalOptions.minSimilarity,
-        minLines: finalOptions.minLines,
-        approx: finalOptions.approx,
-        minSharedTokens: finalOptions.minSharedTokens,
-        maxCandidatesPerBlock: finalOptions.maxCandidatesPerBlock,
-        batchSize: finalOptions.batchSize,
-        streamResults: finalOptions.streamResults,
-        severity: finalOptions.severity,
-        includeTests: finalOptions.includeTests
-      };
-      console.log(chalk3.white("\nPattern-detect settings:"));
-      console.log(
-        `  minSimilarity: ${chalk3.bold(patternDetectConfig.minSimilarity ?? "default")}`
-      );
-      console.log(
-        `  minLines: ${chalk3.bold(patternDetectConfig.minLines ?? "default")}`
-      );
-      if (patternDetectConfig.approx !== void 0)
-        console.log(
-          `  approx: ${chalk3.bold(String(patternDetectConfig.approx))}`
-        );
-      if (patternDetectConfig.minSharedTokens !== void 0)
-        console.log(
-          `  minSharedTokens: ${chalk3.bold(String(patternDetectConfig.minSharedTokens))}`
-        );
-      if (patternDetectConfig.maxCandidatesPerBlock !== void 0)
-        console.log(
-          `  maxCandidatesPerBlock: ${chalk3.bold(String(patternDetectConfig.maxCandidatesPerBlock))}`
-        );
-      if (patternDetectConfig.batchSize !== void 0)
-        console.log(
-          `  batchSize: ${chalk3.bold(String(patternDetectConfig.batchSize))}`
-        );
-      if (patternDetectConfig.streamResults !== void 0)
-        console.log(
-          `  streamResults: ${chalk3.bold(String(patternDetectConfig.streamResults))}`
-        );
-      if (patternDetectConfig.severity !== void 0)
-        console.log(
-          `  severity: ${chalk3.bold(String(patternDetectConfig.severity))}`
-        );
-      if (patternDetectConfig.includeTests !== void 0)
-        console.log(
-          `  includeTests: ${chalk3.bold(String(patternDetectConfig.includeTests))}`
-        );
-    }
-    if (finalOptions["context-analyzer"] || finalOptions.maxDepth) {
-      const ca = finalOptions["context-analyzer"] || {
-        maxDepth: finalOptions.maxDepth,
-        maxContextBudget: finalOptions.maxContextBudget,
-        minCohesion: finalOptions.minCohesion,
-        maxFragmentation: finalOptions.maxFragmentation,
-        includeNodeModules: finalOptions.includeNodeModules
-      };
-      console.log(chalk3.white("\nContext-analyzer settings:"));
-      console.log(`  maxDepth: ${chalk3.bold(ca.maxDepth ?? "default")}`);
-      console.log(
-        `  maxContextBudget: ${chalk3.bold(ca.maxContextBudget ?? "default")}`
-      );
-      if (ca.minCohesion !== void 0)
-        console.log(`  minCohesion: ${chalk3.bold(String(ca.minCohesion))}`);
-      if (ca.maxFragmentation !== void 0)
-        console.log(
-          `  maxFragmentation: ${chalk3.bold(String(ca.maxFragmentation))}`
-        );
-      if (ca.includeNodeModules !== void 0)
-        console.log(
-          `  includeNodeModules: ${chalk3.bold(String(ca.includeNodeModules))}`
-        );
-    }
-    if (finalOptions.consistency) {
-      const c = finalOptions.consistency;
-      console.log(chalk3.white("\nConsistency settings:"));
-      console.log(
-        `  checkNaming: ${chalk3.bold(String(c.checkNaming ?? true))}`
-      );
-      console.log(
-        `  checkPatterns: ${chalk3.bold(String(c.checkPatterns ?? true))}`
-      );
-      console.log(
-        `  checkArchitecture: ${chalk3.bold(String(c.checkArchitecture ?? false))}`
-      );
-      if (c.minSeverity)
-        console.log(`  minSeverity: ${chalk3.bold(c.minSeverity)}`);
-      if (c.acceptedAbbreviations)
-        console.log(
-          `  acceptedAbbreviations: ${chalk3.bold(truncateArray(c.acceptedAbbreviations, 8))}`
-        );
-      if (c.shortWords)
-        console.log(
-          `  shortWords: ${chalk3.bold(truncateArray(c.shortWords, 8))}`
-        );
-    }
-    console.log(chalk3.white("\nStarting analysis..."));
     const progressCallback = (event) => {
       console.log(chalk3.cyan(`
 --- ${event.tool.toUpperCase()} RESULTS ---`));
-      try {
-        if (event.tool === "patterns") {
-          const pr = event.data;
+      const res = event.data;
+      if (res.summary) {
+        if (res.summary.totalIssues !== void 0)
+          console.log(`  Issues found: ${chalk3.bold(res.summary.totalIssues)}`);
+        if (res.summary.score !== void 0)
+          console.log(`  Tool Score: ${chalk3.bold(res.summary.score)}/100`);
+        if (res.summary.totalFiles !== void 0)
           console.log(
-            `  Duplicate patterns: ${chalk3.bold(String(pr.duplicates?.length || 0))}`
+            `  Files analyzed: ${chalk3.bold(res.summary.totalFiles)}`
           );
-          console.log(
-            `  Files with pattern issues: ${chalk3.bold(String(pr.results?.length || 0))}`
-          );
-          if (pr.duplicates && pr.duplicates.length > 0) {
-            pr.duplicates.slice(0, 5).forEach((d, i) => {
-              console.log(
-                `   ${i + 1}. ${d.file1.split("/").pop()} \u2194 ${d.file2.split("/").pop()} (sim=${(d.similarity * 100).toFixed(1)}%)`
-              );
-            });
-          }
-          if (pr.results && pr.results.length > 0) {
-            console.log(`  Top files with pattern issues:`);
-            const sortedByIssues = [...pr.results].sort(
-              (a, b) => (b.issues?.length || 0) - (a.issues?.length || 0)
-            );
-            sortedByIssues.slice(0, 5).forEach((r, i) => {
-              console.log(
-                `   ${i + 1}. ${r.fileName.split("/").pop()} - ${r.issues.length} issue(s)`
-              );
-            });
-          }
-          if (pr.groups && pr.groups.length >= 0) {
-            console.log(
-              `  \u2705 Grouped ${chalk3.bold(String(pr.duplicates?.length || 0))} duplicates into ${chalk3.bold(String(pr.groups.length))} file pairs`
-            );
-          }
-          if (pr.clusters && pr.clusters.length >= 0) {
-            console.log(
-              `  \u2705 Created ${chalk3.bold(String(pr.clusters.length))} refactor clusters`
-            );
-            pr.clusters.slice(0, 3).forEach((cl, idx) => {
-              const files = (cl.files || []).map((f) => f.path.split("/").pop()).join(", ");
-              console.log(
-                `   ${idx + 1}. ${files} (${cl.tokenCost || "n/a"} tokens)`
-              );
-            });
-          }
-        } else if (event.tool === "context") {
-          const cr = event.data;
-          console.log(
-            `  Context issues found: ${chalk3.bold(String(cr.length || 0))}`
-          );
-          cr.slice(0, 5).forEach((c, i) => {
-            const msg = c.message ? ` - ${c.message}` : "";
-            console.log(
-              `   ${i + 1}. ${c.file} (${c.severity || "n/a"})${msg}`
-            );
-          });
-        } else if (event.tool === "consistency") {
-          const rep = event.data;
-          console.log(
-            `  Consistency totalIssues: ${chalk3.bold(String(rep.summary?.totalIssues || 0))}`
-          );
-          if (rep.results && rep.results.length > 0) {
-            const fileMap = /* @__PURE__ */ new Map();
-            rep.results.forEach((r) => {
-              (r.issues || []).forEach((issue) => {
-                const file = issue.location?.file || r.file || "unknown";
-                if (!fileMap.has(file)) fileMap.set(file, []);
-                fileMap.get(file).push(issue);
-              });
-            });
-            const files = Array.from(fileMap.entries()).sort(
-              (a, b) => b[1].length - a[1].length
-            );
-            const topFiles = files.slice(0, 10);
-            topFiles.forEach(([file, issues], idx) => {
-              const counts = issues.reduce(
-                (acc, it) => {
-                  const s = (it.severity || Severity.Info).toLowerCase();
-                  acc[s] = (acc[s] || 0) + 1;
-                  return acc;
-                },
-                {}
-              );
-              const sample = issues.find(
-                (it) => it.severity === Severity.Critical || it.severity === Severity.Major
-              ) || issues[0];
-              const sampleMsg = sample ? ` \u2014 ${sample.message}` : "";
-              console.log(
-                `   ${idx + 1}. ${file} \u2014 ${issues.length} issue(s) (critical:${counts[Severity.Critical] || 0} major:${counts[Severity.Major] || 0} minor:${counts[Severity.Minor] || 0} info:${counts[Severity.Info] || 0})${sampleMsg}`
-              );
-            });
-            const remaining = files.length - topFiles.length;
-            if (remaining > 0) {
-              console.log(
-                chalk3.dim(
-                  `   ... and ${remaining} more files with issues (use --output json for full details)`
-                )
-              );
-            }
-          }
-        } else if (event.tool === "doc-drift") {
-          const dr = event.data;
-          console.log(
-            `  Issues found: ${chalk3.bold(String(dr.issues?.length || 0))}`
-          );
-          if (dr.rawData) {
-            console.log(
-              `  Signature Mismatches: ${chalk3.bold(dr.rawData.outdatedComments || 0)}`
-            );
-            console.log(
-              `  Undocumented Complexity: ${chalk3.bold(dr.rawData.undocumentedComplexity || 0)}`
-            );
-          }
-        } else if (event.tool === "deps-health") {
-          const dr = event.data;
-          console.log(
-            `  Packages Analyzed: ${chalk3.bold(String(dr.summary?.packagesAnalyzed || 0))}`
-          );
-          if (dr.rawData) {
-            console.log(
-              `  Deprecated Packages: ${chalk3.bold(dr.rawData.deprecatedPackages || 0)}`
-            );
-            console.log(
-              `  AI Cutoff Skew Score: ${chalk3.bold(dr.rawData.trainingCutoffSkew?.toFixed(1) || 0)}`
-            );
-          }
-        } else if (event.tool === "change-amplification" || event.tool === "changeAmplification") {
-          const dr = event.data;
-          console.log(
-            `  Coupling issues: ${chalk3.bold(String(dr.issues?.length || 0))}`
-          );
-          if (dr.summary) {
-            console.log(
-              `  Complexity Score: ${chalk3.bold(dr.summary.score || 0)}/100`
-            );
-          }
-        }
-      } catch (err) {
-        void err;
       }
     };
     const results = await analyzeUnified({
@@ -606,44 +362,14 @@ async function scanAction(directory, options) {
         process.stdout.write(
           `\r\x1B[K   [${processed}/${total}] ${message}...`
         );
-        if (processed === total) {
-          process.stdout.write("\n");
-        }
+        if (processed === total) process.stdout.write("\n");
       },
       suppressToolConfig: true
     });
     console.log(chalk3.cyan("\n=== AIReady Run Summary ==="));
-    console.log(
-      chalk3.white("Tools run:"),
-      (finalOptions.tools || ["patterns", "context", "consistency"]).join(", ")
-    );
-    console.log(chalk3.cyan("\nResults summary:"));
     console.log(
       `  Total issues (all tools): ${chalk3.bold(String(results.summary.totalIssues || 0))}`
     );
-    if (results.patternDetect) {
-      console.log(
-        `  Duplicate patterns found: ${chalk3.bold(String(results.patternDetect.duplicates?.length || 0))}`
-      );
-      console.log(
-        `  Pattern files with issues: ${chalk3.bold(String(results.patternDetect.results.length || 0))}`
-      );
-    }
-    if (results.contextAnalyzer)
-      console.log(
-        `  Context issues: ${chalk3.bold(String(results.contextAnalyzer.results.length || 0))}`
-      );
-    if (results.consistency)
-      console.log(
-        `  Consistency issues: ${chalk3.bold(String(results.consistency.summary?.totalIssues || 0))}`
-      );
-    if (results.changeAmplification)
-      console.log(
-        `  Change amplification: ${chalk3.bold(String(results.changeAmplification.summary?.score || 0))}/100`
-      );
-    console.log(chalk3.cyan("===========================\n"));
-    const elapsedTime = getElapsedTime(startTime);
-    void elapsedTime;
     let scoringResult;
     if (options.score || finalOptions.scoring?.showBreakdown) {
       scoringResult = await scoreUnified(results, finalOptions);
@@ -651,55 +377,34 @@ async function scanAction(directory, options) {
       console.log(`  ${formatScore(scoringResult)}`);
       if (options.compareTo) {
         try {
-          const prevReportStr = readFileSync2(
-            resolvePath3(process.cwd(), options.compareTo),
-            "utf8"
+          const prevReport = JSON.parse(
+            readFileSync2(resolvePath3(process.cwd(), options.compareTo), "utf8")
           );
-          const prevReport = JSON.parse(prevReportStr);
-          const prevScore = prevReport.scoring?.score || prevReport.scoring?.overallScore;
+          const prevScore = prevReport.scoring?.overall || prevReport.scoring?.score;
           if (typeof prevScore === "number") {
             const diff = scoringResult.overall - prevScore;
             const diffStr = diff > 0 ? `+${diff}` : String(diff);
-            console.log();
-            if (diff > 0) {
+            if (diff > 0)
               console.log(
                 chalk3.green(
                   `  \u{1F4C8} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
                 )
               );
-            } else if (diff < 0) {
+            else if (diff < 0)
               console.log(
                 chalk3.red(
                   `  \u{1F4C9} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
                 )
               );
-            } else {
+            else
               console.log(
                 chalk3.blue(
-                  `  \u2796 Trend: No change compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
+                  `  \u2796 Trend: No change (${prevScore} \u2192 ${scoringResult.overall})`
                 )
               );
-            }
-            scoringResult.trend = {
-              previousScore: prevScore,
-              difference: diff
-            };
-          } else {
-            console.log(
-              chalk3.yellow(
-                `
-  \u26A0\uFE0F  Previous report at ${options.compareTo} does not contain an overall score.`
-              )
-            );
           }
         } catch (e) {
           void e;
-          console.log(
-            chalk3.yellow(
-              `
-  \u26A0\uFE0F  Could not read or parse previous report at ${options.compareTo}.`
-            )
-          );
         }
       }
       const totalWastedDuplication = (scoringResult.breakdown || []).reduce(
@@ -713,7 +418,8 @@ async function scanAction(directory, options) {
       const totalContext = Math.max(
         ...(scoringResult.breakdown || []).map(
           (s) => s.tokenBudget?.totalContextTokens || 0
-        )
+        ),
+        0
       );
       if (totalContext > 0) {
         const unifiedBudget = calculateTokenBudget({
@@ -724,35 +430,17 @@ async function scanAction(directory, options) {
             chattiness: 0
           }
         });
-        const targetModel = options.model || "claude-4.6";
-        const modelPreset = getModelPreset(targetModel);
+        const modelPreset = getModelPreset(options.model || "claude-4.6");
         const costEstimate = estimateCostFromBudget(unifiedBudget, modelPreset);
-        const barWidth = 20;
-        const filled = Math.round(unifiedBudget.efficiencyRatio * barWidth);
-        const bar = chalk3.green("\u2588".repeat(filled)) + chalk3.dim("\u2591".repeat(barWidth - filled));
-        console.log(chalk3.bold("\n\u{1F4CA} AI Token Budget Analysis (v0.13)"));
-        console.log(
-          `  Efficiency: [${bar}] ${(unifiedBudget.efficiencyRatio * 100).toFixed(0)}%`
-        );
-        console.log(
-          `  Total Context: ${chalk3.bold(unifiedBudget.totalContextTokens.toLocaleString())} tokens`
-        );
+        console.log(chalk3.bold("\n\u{1F4CA} AI Token Budget Analysis"));
         console.log(
-          `  Wasted Tokens: ${chalk3.red(unifiedBudget.wastedTokens.total.toLocaleString())} (${(unifiedBudget.wastedTokens.total / unifiedBudget.totalContextTokens * 100).toFixed(1)}%)`
+          `  Efficiency: ${(unifiedBudget.efficiencyRatio * 100).toFixed(0)}%`
         );
-        console.log(`  Waste Breakdown:`);
         console.log(
-          `    \u2022 Duplication:   ${unifiedBudget.wastedTokens.bySource.duplication.toLocaleString()} tokens`
+          `  Wasted Tokens: ${chalk3.red(unifiedBudget.wastedTokens.total.toLocaleString())}`
         );
         console.log(
-          `    \u2022 Fragmentation: ${unifiedBudget.wastedTokens.bySource.fragmentation.toLocaleString()} tokens`
-        );
-        console.log(
-          `  Potential Savings: ${chalk3.green(unifiedBudget.potentialRetrievableTokens.toLocaleString())} tokens retrievable`
-        );
-        console.log(
-          `
-  Est. Monthly Cost (${modelPreset.name}): ${chalk3.bold("$" + costEstimate.total)} [range: $${costEstimate.range[0]}-$${costEstimate.range[1]}]`
+          `  Est. Monthly Cost (${modelPreset.name}): ${chalk3.bold("$" + costEstimate.total)}`
         );
         scoringResult.tokenBudget = unifiedBudget;
         scoringResult.costEstimate = {
@@ -760,85 +448,31 @@ async function scanAction(directory, options) {
           ...costEstimate
         };
       }
-      if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
+      if (scoringResult.breakdown) {
         console.log(chalk3.bold("\nTool breakdown:"));
         scoringResult.breakdown.forEach((tool) => {
           const rating = getRating(tool.score);
-          const rd = getRatingDisplay(rating);
-          console.log(
-            `  - ${tool.toolName}: ${tool.score}/100 (${rating}) ${rd.emoji}`
-          );
+          console.log(`  - ${tool.toolName}: ${tool.score}/100 (${rating})`);
         });
-        console.log();
-        if (finalOptions.scoring?.showBreakdown) {
-          console.log(chalk3.bold("Detailed tool breakdown:"));
-          scoringResult.breakdown.forEach((tool) => {
-            console.log(formatToolScore(tool));
-          });
-          console.log();
-        }
       }
     }
     const mapToUnifiedReport = (res, scoring) => {
       const allResults = [];
-      let totalFilesSet = /* @__PURE__ */ new Set();
+      const totalFilesSet = /* @__PURE__ */ new Set();
       let criticalCount = 0;
       let majorCount = 0;
-      const collect = (spokeRes, defaultType = IssueType.AiSignalClarity) => {
+      res.summary.toolsRun.forEach((toolId) => {
+        const spokeRes = res[toolId];
         if (!spokeRes || !spokeRes.results) return;
         spokeRes.results.forEach((r) => {
-          const fileName = r.fileName || r.file || "unknown";
-          totalFilesSet.add(fileName);
-          const normalizedResult = {
-            fileName,
-            issues: [],
-            metrics: r.metrics || { tokenCost: r.tokenCost || 0 }
-          };
-          if (r.issues && Array.isArray(r.issues)) {
-            r.issues.forEach((i) => {
-              const normalizedIssue = typeof i === "string" ? {
-                type: defaultType,
-                severity: r.severity || Severity.Info,
-                message: i,
-                location: { file: fileName, line: 1 }
-              } : {
-                type: i.type || defaultType,
-                severity: i.severity || r.severity || Severity.Info,
-                message: i.message || String(i),
-                location: i.location || { file: fileName, line: 1 },
-                suggestion: i.suggestion
-              };
-              if (normalizedIssue.severity === Severity.Critical || normalizedIssue.severity === "critical")
-                criticalCount++;
-              if (normalizedIssue.severity === Severity.Major || normalizedIssue.severity === "major")
-                majorCount++;
-              normalizedResult.issues.push(normalizedIssue);
-            });
-          } else if (r.severity) {
-            const normalizedIssue = {
-              type: defaultType,
-              severity: r.severity,
-              message: r.message || "General issue",
-              location: { file: fileName, line: 1 }
-            };
-            if (normalizedIssue.severity === Severity.Critical || normalizedIssue.severity === "critical")
-              criticalCount++;
-            if (normalizedIssue.severity === Severity.Major || normalizedIssue.severity === "major")
-              majorCount++;
-            normalizedResult.issues.push(normalizedIssue);
-          }
-          allResults.push(normalizedResult);
+          totalFilesSet.add(r.fileName);
+          allResults.push(r);
+          r.issues?.forEach((i) => {
+            if (i.severity === Severity.Critical) criticalCount++;
+            if (i.severity === Severity.Major) majorCount++;
+          });
         });
-      };
-      collect(res.patternDetect, IssueType.DuplicatePattern);
-      collect(res.contextAnalyzer, IssueType.ContextFragmentation);
-      collect(res.consistency, IssueType.NamingInconsistency);
-      collect(res.docDrift, IssueType.DocDrift);
-      collect(res.dependencyHealth, IssueType.DependencyHealth);
-      collect(res.aiSignalClarity, IssueType.AiSignalClarity);
-      collect(res.agentGrounding, IssueType.AgentNavigationFailure);
-      collect(res.testability, IssueType.LowTestability);
-      collect(res.changeAmplification, IssueType.ChangeAmplification);
+      });
       return {
         ...res,
         results: allResults,
@@ -851,199 +485,70 @@ async function scanAction(directory, options) {
         scoring
       };
     };
+    const outputData = {
+      ...mapToUnifiedReport(results, scoringResult),
+      repository: repoMetadata
+    };
     const outputFormat = options.output || finalOptions.output?.format || "console";
-    const userOutputFile = options.outputFile || finalOptions.output?.file;
+    const outputPath = resolveOutputPath(
+      options.outputFile || finalOptions.output?.file,
+      `aiready-report-${getReportTimestamp()}.json`,
+      resolvedDir
+    );
     if (outputFormat === "json") {
-      const timestamp = getReportTimestamp();
-      const defaultFilename = `aiready-report-${timestamp}.json`;
-      const outputPath = resolveOutputPath(
-        userOutputFile,
-        defaultFilename,
-        resolvedDir
-      );
-      const outputData = {
-        ...mapToUnifiedReport(results, scoringResult),
-        repository: repoMetadata
-      };
       handleJSONOutput(
         outputData,
         outputPath,
         `\u2705 Report saved to ${outputPath}`
       );
-      if (options.upload) {
-        console.log(chalk3.blue("\n\u{1F4E4} Automatic upload triggered..."));
-        await uploadAction(outputPath, {
-          apiKey: options.apiKey,
-          server: options.server
-        });
-      }
-      await warnIfGraphCapExceeded(outputData, resolvedDir);
     } else {
-      const timestamp = getReportTimestamp();
-      const defaultFilename = `aiready-report-${timestamp}.json`;
-      const outputPath = resolveOutputPath(
-        userOutputFile,
-        defaultFilename,
-        resolvedDir
-      );
-      const outputData = {
-        ...mapToUnifiedReport(results, scoringResult),
-        repository: repoMetadata
-      };
       try {
         writeFileSync(outputPath, JSON.stringify(outputData, null, 2));
         console.log(chalk3.dim(`\u2705 Report auto-persisted to ${outputPath}`));
-        if (options.upload) {
-          console.log(chalk3.blue("\n\u{1F4E4} Automatic upload triggered..."));
-          await uploadAction(outputPath, {
-            apiKey: options.apiKey,
-            server: options.server
-          });
-        }
-        await warnIfGraphCapExceeded(outputData, resolvedDir);
       } catch (err) {
         void err;
       }
     }
-    const isCI = options.ci || process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
+    if (options.upload) {
+      await uploadAction(outputPath, {
+        apiKey: options.apiKey,
+        server: options.server
+      });
+    }
+    await warnIfGraphCapExceeded(outputData, resolvedDir);
+    const isCI = options.ci || process.env.CI === "true";
     if (isCI && scoringResult) {
       const threshold = options.threshold ? parseInt(options.threshold) : void 0;
       const failOnLevel = options.failOn || "critical";
-      if (process.env.GITHUB_ACTIONS === "true") {
-        console.log(`
-::group::AI Readiness Score`);
-        console.log(`score=${scoringResult.overall}`);
-        if (scoringResult.breakdown) {
-          scoringResult.breakdown.forEach((tool) => {
-            console.log(`${tool.toolName}=${tool.score}`);
-          });
-        }
-        console.log("::endgroup::");
-        if (threshold && scoringResult.overall < threshold) {
-          console.log(
-            `::error::AI Readiness Score ${scoringResult.overall} is below threshold ${threshold}`
-          );
-        } else if (threshold) {
-          console.log(
-            `::notice::AI Readiness Score: ${scoringResult.overall}/100 (threshold: ${threshold})`
-          );
-        }
-        if (results.patternDetect) {
-          const criticalPatterns = results.patternDetect.results.flatMap(
-            (p) => p.issues.filter((i) => i.severity === Severity.Critical)
-          );
-          criticalPatterns.slice(0, 10).forEach((issue) => {
-            console.log(
-              `::warning file=${issue.location?.file || "unknown"},line=${issue.location?.line || 1}::${issue.message}`
-            );
-          });
-        }
-      }
       let shouldFail = false;
       let failReason = "";
       if (threshold && scoringResult.overall < threshold) {
         shouldFail = true;
-        failReason = `AI Readiness Score ${scoringResult.overall} is below threshold ${threshold}`;
+        failReason = `Score ${scoringResult.overall} < threshold ${threshold}`;
       }
+      const report = mapToUnifiedReport(results, scoringResult);
       if (failOnLevel !== "none") {
-        const severityLevels = { critical: 4, major: 3, minor: 2, any: 1 };
-        const minSeverity = severityLevels[failOnLevel] || 4;
-        let criticalCount = 0;
-        let majorCount = 0;
-        if (results.patternDetect) {
-          results.patternDetect.results.forEach((p) => {
-            p.issues.forEach((i) => {
-              if (i.severity === Severity.Critical) criticalCount++;
-              if (i.severity === Severity.Major) majorCount++;
-            });
-          });
-        }
-        if (results.contextAnalyzer) {
-          results.contextAnalyzer.results.forEach((c) => {
-            if (c.severity === Severity.Critical) criticalCount++;
-            if (c.severity === Severity.Major) majorCount++;
-          });
-        }
-        if (results.consistency) {
-          results.consistency.results.forEach((r) => {
-            r.issues?.forEach((i) => {
-              if (i.severity === Severity.Critical) criticalCount++;
-              if (i.severity === Severity.Major) majorCount++;
-            });
-          });
-        }
-        if (minSeverity >= 4 && criticalCount > 0) {
+        if (failOnLevel === "critical" && report.summary.criticalIssues > 0) {
           shouldFail = true;
-          failReason = `Found ${criticalCount} critical issues`;
-        } else if (minSeverity >= 3 && criticalCount + majorCount > 0) {
+          failReason = `Found ${report.summary.criticalIssues} critical issues`;
+        } else if (failOnLevel === "major" && report.summary.criticalIssues + report.summary.majorIssues > 0) {
           shouldFail = true;
-          failReason = `Found ${criticalCount} critical and ${majorCount} major issues`;
+          failReason = `Found ${report.summary.criticalIssues} critical and ${report.summary.majorIssues} major issues`;
         }
       }
       if (shouldFail) {
-        console.log(chalk3.red("\n\u{1F6AB} PR BLOCKED: AI Readiness Check Failed"));
-        console.log(chalk3.red(`   Reason: ${failReason}`));
-        console.log(chalk3.dim("\n   Remediation steps:"));
-        console.log(
-          chalk3.dim("   1. Run `aiready scan` locally to see detailed issues")
-        );
-        console.log(chalk3.dim("   2. Fix the critical issues before merging"));
-        console.log(
-          chalk3.dim(
-            "   3. Consider upgrading to Team plan for historical tracking: https://getaiready.dev/pricing"
-          )
-        );
+        console.log(chalk3.red(`
+\u{1F6AB} PR BLOCKED: ${failReason}`));
         process.exit(1);
       } else {
-        console.log(chalk3.green("\n\u2705 PR PASSED: AI Readiness Check"));
-        if (threshold) {
-          console.log(
-            chalk3.green(
-              `   Score: ${scoringResult.overall}/100 (threshold: ${threshold})`
-            )
-          );
-        }
-        console.log(
-          chalk3.dim(
-            "\n   \u{1F4A1} Track historical trends: https://getaiready.dev \u2014 Team plan $99/mo"
-          )
-        );
+        console.log(chalk3.green("\n\u2705 PR PASSED"));
       }
     }
   } catch (error) {
     handleCLIError2(error, "Analysis");
   }
 }
-var scanHelpText = `
-EXAMPLES:
-  $ aiready scan                                    # Analyze all tools
-  $ aiready scan --tools patterns,context           # Skip consistency
-  $ aiready scan --profile agentic                  # Optimize for AI agent execution
-  $ aiready scan --profile security                 # Optimize for secure coding (testability)
-  $ aiready scan --compare-to prev-report.json      # Compare trends against previous run
-  $ aiready scan --score --threshold 75             # CI/CD with threshold
-  $ aiready scan --ci --threshold 70                # GitHub Actions gatekeeper
-  $ aiready scan --ci --fail-on major               # Fail on major+ issues
-  $ aiready scan --output json --output-file report.json
-  $ aiready scan --upload --api-key ar_...             # Automatic platform upload
-  $ aiready scan --upload --server custom-url.com      # Upload to custom platform
-
-PROFILES:
-  agentic:      aiSignalClarity, grounding, testability
-  cost:         patterns, context
-  security:     consistency, testability
-  onboarding:   context, consistency, grounding
-
-CI/CD INTEGRATION (Gatekeeper Mode):
-  Use --ci for GitHub Actions integration:
-  - Outputs GitHub Actions annotations for PR checks
-  - Fails with exit code 1 if threshold not met
-  - Shows clear "blocked" message with remediation steps
-
-  Example GitHub Actions workflow:
-    - name: AI Readiness Check
-      run: aiready scan --ci --threshold 70
-`;
+var scanHelpText = `...`;
 
 // src/commands/patterns.ts
 import chalk4 from "chalk";