@aiready/cli 0.9.43 → 0.9.46

package/dist/cli.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   __require,
-  analyzeUnified
-} from "./chunk-LLJMKNBI.mjs";
+  analyzeUnified,
+  scoreUnified
+} from "./chunk-6FOVC2OE.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -11,21 +12,23 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/scan.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import { writeFileSync, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolvePath2 } from "path";
+import { resolve as resolvePath3 } from "path";
 import {
   loadMergedConfig,
   handleJSONOutput,
-  handleCLIError,
+  handleCLIError as handleCLIError2,
   getElapsedTime,
   resolveOutputPath,
-  calculateOverallScore,
   formatScore,
   formatToolScore,
+  calculateTokenBudget,
+  estimateCostFromBudget,
+  getModelPreset,
   getRating,
   getRatingDisplay,
-  parseWeightString
+  getRepoMetadata
 } from "@aiready/core";
 
 // src/utils/helpers.ts
@@ -152,11 +155,113 @@ function truncateArray(arr, cap = 8) {
   return shown.join(", ") + (more > 0 ? `, ... (+${more} more)` : "");
 }
 
+// src/commands/upload.ts
+import fs from "fs";
+import { resolve as resolvePath2 } from "path";
+import chalk2 from "chalk";
+import { handleCLIError } from "@aiready/core";
+async function uploadAction(file, options) {
+  const startTime = Date.now();
+  const filePath = resolvePath2(process.cwd(), file);
+  const serverUrl = options.server || process.env.AIREADY_SERVER || "https://dev.platform.getaiready.dev";
+  const apiKey = options.apiKey || process.env.AIREADY_API_KEY;
+  if (!apiKey) {
+    console.error(chalk2.red("\u274C API Key is required for upload."));
+    console.log(
+      chalk2.dim(
+        "   Set AIREADY_API_KEY environment variable or use --api-key flag."
+      )
+    );
+    console.log(
+      chalk2.dim("   Get an API key from https://getaiready.dev/dashboard")
+    );
+    process.exit(1);
+  }
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk2.red(`\u274C File not found: ${filePath}`));
+    process.exit(1);
+  }
+  try {
+    console.log(chalk2.blue(`\u{1F680} Uploading report to ${serverUrl}...`));
+    console.log(chalk2.dim(`   Reading report from ${filePath}...`));
+    const reportContent = fs.readFileSync(filePath, "utf-8");
+    const reportData = JSON.parse(reportContent);
+    console.log(chalk2.dim(`   Successfully parsed report JSON.`));
+    const repoId = options.repoId || reportData.repository?.repoId;
+    const res = await fetch(`${serverUrl}/api/analysis/upload`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        data: reportData,
+        repoId
+        // Might be null, server will handle mapping
+      })
+    });
+    const contentType = res.headers.get("content-type");
+    let result = {};
+    if (contentType?.includes("application/json")) {
+      result = await res.json();
+    } else {
+      const text = await res.text();
+      result = { error: text || res.statusText };
+    }
+    if (!res.ok) {
+      console.error(
+        chalk2.red(`\u274C Upload failed: ${result.error || res.statusText}`)
+      );
+      if (contentType?.includes("text/html")) {
+        console.log(
+          chalk2.yellow(
+            "   Note: Received an HTML response. This often indicates a redirect (e.g., to a login page) or a server error."
+          )
+        );
+        if (result.error?.includes("Redirecting")) {
+          console.log(
+            chalk2.dim(
+              "   Detected redirect. Check if the API endpoint requires authentication or has changed."
+            )
+          );
+        }
+      }
+      if (res.status === 401) {
+        console.log(
+          chalk2.dim("   Hint: Your API key may be invalid or expired.")
+        );
+      }
+      process.exit(1);
+    }
+    const duration = ((Date.now() - startTime) / 1e3).toFixed(2);
+    console.log(chalk2.green(`
+\u2705 Upload successful! (${duration}s)`));
+    console.log(chalk2.cyan(`   View results: ${serverUrl}/dashboard`));
+    if (result.analysis) {
+      console.log(chalk2.dim(`   Analysis ID: ${result.analysis.id}`));
+      console.log(chalk2.dim(`   Score: ${result.analysis.aiScore}/100`));
+    }
+  } catch (error) {
+    handleCLIError(error, "Upload");
+  }
+}
+var uploadHelpText = `
+EXAMPLES:
+  $ aiready upload report.json --api-key ar_...
+  $ aiready upload .aiready/latest.json
+  $ AIREADY_API_KEY=ar_... aiready upload report.json
+
+ENVIRONMENT VARIABLES:
+  AIREADY_API_KEY    Your platform API key
+  AIREADY_SERVER     Custom platform URL (default: https://dev.platform.getaiready.dev)
+`;
+
 // src/commands/scan.ts
 async function scanAction(directory, options) {
-  console.log(chalk2.blue("\u{1F680} Starting AIReady unified analysis...\n"));
+  console.log(chalk3.blue("\u{1F680} Starting AIReady unified analysis...\n"));
   const startTime = Date.now();
-  const resolvedDir = resolvePath2(process.cwd(), directory || ".");
+  const resolvedDir = resolvePath3(process.cwd(), directory || ".");
+  const repoMetadata = getRepoMetadata(resolvedDir);
   try {
     const defaults = {
       tools: [
@@ -199,7 +304,7 @@ async function scanAction(directory, options) {
           break;
         default:
           console.log(
-            chalk2.yellow(
+            chalk3.yellow(
               `
 \u26A0\uFE0F  Unknown profile '${options.profile}'. Using specified tools or defaults.`
             )
@@ -231,22 +336,22 @@ async function scanAction(directory, options) {
         ...baseOptions
       };
     }
-    console.log(chalk2.cyan("\n=== AIReady Run Preview ==="));
+    console.log(chalk3.cyan("\n=== AIReady Run Preview ==="));
     console.log(
-      chalk2.white("Tools to run:"),
+      chalk3.white("Tools to run:"),
       (finalOptions.tools || ["patterns", "context", "consistency"]).join(", ")
     );
-    console.log(chalk2.white("Will use settings from config and defaults."));
-    console.log(chalk2.white("\nGeneral settings:"));
+    console.log(chalk3.white("Will use settings from config and defaults."));
+    console.log(chalk3.white("\nGeneral settings:"));
     if (finalOptions.rootDir)
-      console.log(`  rootDir: ${chalk2.bold(String(finalOptions.rootDir))}`);
+      console.log(`  rootDir: ${chalk3.bold(String(finalOptions.rootDir))}`);
     if (finalOptions.include)
       console.log(
-        `  include: ${chalk2.bold(truncateArray(finalOptions.include, 6))}`
+        `  include: ${chalk3.bold(truncateArray(finalOptions.include, 6))}`
       );
     if (finalOptions.exclude)
       console.log(
-        `  exclude: ${chalk2.bold(truncateArray(finalOptions.exclude, 6))}`
+        `  exclude: ${chalk3.bold(truncateArray(finalOptions.exclude, 6))}`
       );
     if (finalOptions["pattern-detect"] || finalOptions.minSimilarity) {
       const patternDetectConfig = finalOptions["pattern-detect"] || {
@@ -260,40 +365,40 @@ async function scanAction(directory, options) {
         severity: finalOptions.severity,
         includeTests: finalOptions.includeTests
       };
-      console.log(chalk2.white("\nPattern-detect settings:"));
+      console.log(chalk3.white("\nPattern-detect settings:"));
       console.log(
-        `  minSimilarity: ${chalk2.bold(patternDetectConfig.minSimilarity ?? "default")}`
+        `  minSimilarity: ${chalk3.bold(patternDetectConfig.minSimilarity ?? "default")}`
       );
       console.log(
-        `  minLines: ${chalk2.bold(patternDetectConfig.minLines ?? "default")}`
+        `  minLines: ${chalk3.bold(patternDetectConfig.minLines ?? "default")}`
       );
       if (patternDetectConfig.approx !== void 0)
         console.log(
-          `  approx: ${chalk2.bold(String(patternDetectConfig.approx))}`
+          `  approx: ${chalk3.bold(String(patternDetectConfig.approx))}`
         );
       if (patternDetectConfig.minSharedTokens !== void 0)
         console.log(
-          `  minSharedTokens: ${chalk2.bold(String(patternDetectConfig.minSharedTokens))}`
+          `  minSharedTokens: ${chalk3.bold(String(patternDetectConfig.minSharedTokens))}`
         );
       if (patternDetectConfig.maxCandidatesPerBlock !== void 0)
         console.log(
-          `  maxCandidatesPerBlock: ${chalk2.bold(String(patternDetectConfig.maxCandidatesPerBlock))}`
+          `  maxCandidatesPerBlock: ${chalk3.bold(String(patternDetectConfig.maxCandidatesPerBlock))}`
         );
       if (patternDetectConfig.batchSize !== void 0)
         console.log(
-          `  batchSize: ${chalk2.bold(String(patternDetectConfig.batchSize))}`
+          `  batchSize: ${chalk3.bold(String(patternDetectConfig.batchSize))}`
         );
       if (patternDetectConfig.streamResults !== void 0)
         console.log(
-          `  streamResults: ${chalk2.bold(String(patternDetectConfig.streamResults))}`
+          `  streamResults: ${chalk3.bold(String(patternDetectConfig.streamResults))}`
         );
       if (patternDetectConfig.severity !== void 0)
         console.log(
-          `  severity: ${chalk2.bold(String(patternDetectConfig.severity))}`
+          `  severity: ${chalk3.bold(String(patternDetectConfig.severity))}`
         );
       if (patternDetectConfig.includeTests !== void 0)
         console.log(
-          `  includeTests: ${chalk2.bold(String(patternDetectConfig.includeTests))}`
+          `  includeTests: ${chalk3.bold(String(patternDetectConfig.includeTests))}`
         );
     }
     if (finalOptions["context-analyzer"] || finalOptions.maxDepth) {
@@ -304,57 +409,57 @@ async function scanAction(directory, options) {
         maxFragmentation: finalOptions.maxFragmentation,
         includeNodeModules: finalOptions.includeNodeModules
       };
-      console.log(chalk2.white("\nContext-analyzer settings:"));
-      console.log(`  maxDepth: ${chalk2.bold(ca.maxDepth ?? "default")}`);
+      console.log(chalk3.white("\nContext-analyzer settings:"));
+      console.log(`  maxDepth: ${chalk3.bold(ca.maxDepth ?? "default")}`);
       console.log(
-        `  maxContextBudget: ${chalk2.bold(ca.maxContextBudget ?? "default")}`
+        `  maxContextBudget: ${chalk3.bold(ca.maxContextBudget ?? "default")}`
       );
       if (ca.minCohesion !== void 0)
-        console.log(`  minCohesion: ${chalk2.bold(String(ca.minCohesion))}`);
+        console.log(`  minCohesion: ${chalk3.bold(String(ca.minCohesion))}`);
       if (ca.maxFragmentation !== void 0)
         console.log(
-          `  maxFragmentation: ${chalk2.bold(String(ca.maxFragmentation))}`
+          `  maxFragmentation: ${chalk3.bold(String(ca.maxFragmentation))}`
         );
       if (ca.includeNodeModules !== void 0)
         console.log(
-          `  includeNodeModules: ${chalk2.bold(String(ca.includeNodeModules))}`
+          `  includeNodeModules: ${chalk3.bold(String(ca.includeNodeModules))}`
         );
     }
     if (finalOptions.consistency) {
       const c = finalOptions.consistency;
-      console.log(chalk2.white("\nConsistency settings:"));
+      console.log(chalk3.white("\nConsistency settings:"));
       console.log(
-        `  checkNaming: ${chalk2.bold(String(c.checkNaming ?? true))}`
+        `  checkNaming: ${chalk3.bold(String(c.checkNaming ?? true))}`
       );
       console.log(
-        `  checkPatterns: ${chalk2.bold(String(c.checkPatterns ?? true))}`
+        `  checkPatterns: ${chalk3.bold(String(c.checkPatterns ?? true))}`
       );
       console.log(
-        `  checkArchitecture: ${chalk2.bold(String(c.checkArchitecture ?? false))}`
+        `  checkArchitecture: ${chalk3.bold(String(c.checkArchitecture ?? false))}`
       );
       if (c.minSeverity)
-        console.log(`  minSeverity: ${chalk2.bold(c.minSeverity)}`);
+        console.log(`  minSeverity: ${chalk3.bold(c.minSeverity)}`);
       if (c.acceptedAbbreviations)
         console.log(
-          `  acceptedAbbreviations: ${chalk2.bold(truncateArray(c.acceptedAbbreviations, 8))}`
+          `  acceptedAbbreviations: ${chalk3.bold(truncateArray(c.acceptedAbbreviations, 8))}`
         );
       if (c.shortWords)
         console.log(
-          `  shortWords: ${chalk2.bold(truncateArray(c.shortWords, 8))}`
+          `  shortWords: ${chalk3.bold(truncateArray(c.shortWords, 8))}`
         );
     }
-    console.log(chalk2.white("\nStarting analysis..."));
+    console.log(chalk3.white("\nStarting analysis..."));
     const progressCallback = (event) => {
-      console.log(chalk2.cyan(`
+      console.log(chalk3.cyan(`
 --- ${event.tool.toUpperCase()} RESULTS ---`));
       try {
         if (event.tool === "patterns") {
           const pr = event.data;
           console.log(
-            `  Duplicate patterns: ${chalk2.bold(String(pr.duplicates?.length || 0))}`
+            `  Duplicate patterns: ${chalk3.bold(String(pr.duplicates?.length || 0))}`
           );
           console.log(
-            `  Files with pattern issues: ${chalk2.bold(String(pr.results?.length || 0))}`
+            `  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) => {
@@ -376,12 +481,12 @@ async function scanAction(directory, options) {
           }
           if (pr.groups && pr.groups.length >= 0) {
             console.log(
-              `  \u2705 Grouped ${chalk2.bold(String(pr.duplicates?.length || 0))} duplicates into ${chalk2.bold(String(pr.groups.length))} file pairs`
+              `  \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 ${chalk2.bold(String(pr.clusters.length))} refactor clusters`
+              `  \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(", ");
@@ -393,7 +498,7 @@ async function scanAction(directory, options) {
         } else if (event.tool === "context") {
           const cr = event.data;
           console.log(
-            `  Context issues found: ${chalk2.bold(String(cr.length || 0))}`
+            `  Context issues found: ${chalk3.bold(String(cr.length || 0))}`
           );
           cr.slice(0, 5).forEach((c, i) => {
             const msg = c.message ? ` - ${c.message}` : "";
@@ -404,7 +509,7 @@ async function scanAction(directory, options) {
         } else if (event.tool === "consistency") {
           const rep = event.data;
           console.log(
-            `  Consistency totalIssues: ${chalk2.bold(String(rep.summary?.totalIssues || 0))}`
+            `  Consistency totalIssues: ${chalk3.bold(String(rep.summary?.totalIssues || 0))}`
           );
           if (rep.results && rep.results.length > 0) {
             const fileMap = /* @__PURE__ */ new Map();
@@ -439,7 +544,7 @@ async function scanAction(directory, options) {
             const remaining = files.length - topFiles.length;
             if (remaining > 0) {
               console.log(
-                chalk2.dim(
+                chalk3.dim(
                   `   ... and ${remaining} more files with issues (use --output json for full details)`
                 )
               );
@@ -448,37 +553,37 @@ async function scanAction(directory, options) {
         } else if (event.tool === "doc-drift") {
           const dr = event.data;
           console.log(
-            `  Issues found: ${chalk2.bold(String(dr.issues?.length || 0))}`
+            `  Issues found: ${chalk3.bold(String(dr.issues?.length || 0))}`
           );
           if (dr.rawData) {
             console.log(
-              `  Signature Mismatches: ${chalk2.bold(dr.rawData.outdatedComments || 0)}`
+              `  Signature Mismatches: ${chalk3.bold(dr.rawData.outdatedComments || 0)}`
             );
             console.log(
-              `  Undocumented Complexity: ${chalk2.bold(dr.rawData.undocumentedComplexity || 0)}`
+              `  Undocumented Complexity: ${chalk3.bold(dr.rawData.undocumentedComplexity || 0)}`
             );
           }
         } else if (event.tool === "deps-health") {
           const dr = event.data;
           console.log(
-            `  Packages Analyzed: ${chalk2.bold(String(dr.summary?.packagesAnalyzed || 0))}`
+            `  Packages Analyzed: ${chalk3.bold(String(dr.summary?.packagesAnalyzed || 0))}`
           );
           if (dr.rawData) {
             console.log(
-              `  Deprecated Packages: ${chalk2.bold(dr.rawData.deprecatedPackages || 0)}`
+              `  Deprecated Packages: ${chalk3.bold(dr.rawData.deprecatedPackages || 0)}`
             );
             console.log(
-              `  AI Cutoff Skew Score: ${chalk2.bold(dr.rawData.trainingCutoffSkew?.toFixed(1) || 0)}`
+              `  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: ${chalk2.bold(String(dr.issues?.length || 0))}`
+            `  Coupling issues: ${chalk3.bold(String(dr.issues?.length || 0))}`
           );
           if (dr.summary) {
             console.log(
-              `  Complexity Score: ${chalk2.bold(dr.summary.score || 0)}/100`
+              `  Complexity Score: ${chalk3.bold(dr.summary.score || 0)}/100`
             );
           }
         }
@@ -499,227 +604,169 @@ async function scanAction(directory, options) {
       },
       suppressToolConfig: true
     });
-    console.log(chalk2.cyan("\n=== AIReady Run Summary ==="));
+    console.log(chalk3.cyan("\n=== AIReady Run Summary ==="));
     console.log(
-      chalk2.white("Tools run:"),
+      chalk3.white("Tools run:"),
       (finalOptions.tools || ["patterns", "context", "consistency"]).join(", ")
     );
-    console.log(chalk2.cyan("\nResults summary:"));
+    console.log(chalk3.cyan("\nResults summary:"));
     console.log(
-      `  Total issues (all tools): ${chalk2.bold(String(results.summary.totalIssues || 0))}`
+      `  Total issues (all tools): ${chalk3.bold(String(results.summary.totalIssues || 0))}`
     );
     if (results.duplicates)
       console.log(
-        `  Duplicate patterns found: ${chalk2.bold(String(results.duplicates.length || 0))}`
+        `  Duplicate patterns found: ${chalk3.bold(String(results.duplicates.length || 0))}`
       );
     if (results.patterns)
       console.log(
-        `  Pattern files with issues: ${chalk2.bold(String(results.patterns.length || 0))}`
+        `  Pattern files with issues: ${chalk3.bold(String(results.patterns.length || 0))}`
       );
     if (results.context)
       console.log(
-        `  Context issues: ${chalk2.bold(String(results.context.length || 0))}`
+        `  Context issues: ${chalk3.bold(String(results.context.length || 0))}`
       );
     console.log(
-      `  Consistency issues: ${chalk2.bold(String(results.consistency?.summary?.totalIssues || 0))}`
+      `  Consistency issues: ${chalk3.bold(String(results.consistency?.summary?.totalIssues || 0))}`
     );
     if (results.changeAmplification)
       console.log(
-        `  Change amplification: ${chalk2.bold(String(results.changeAmplification.summary?.score || 0))}/100`
+        `  Change amplification: ${chalk3.bold(String(results.changeAmplification.summary?.score || 0))}/100`
       );
-    console.log(chalk2.cyan("===========================\n"));
+    console.log(chalk3.cyan("===========================\n"));
     const elapsedTime = getElapsedTime(startTime);
     void elapsedTime;
     let scoringResult;
     if (options.score || finalOptions.scoring?.showBreakdown) {
-      const toolScores = /* @__PURE__ */ new Map();
-      if (results.duplicates) {
-        const { calculatePatternScore } = await import("@aiready/pattern-detect");
-        try {
-          const patternScore = calculatePatternScore(
-            results.duplicates,
-            results.patterns?.length || 0
-          );
-          toolScores.set("pattern-detect", patternScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.context) {
-        const { generateSummary: genContextSummary, calculateContextScore } = await import("@aiready/context-analyzer");
+      scoringResult = await scoreUnified(results, finalOptions);
+      console.log(chalk3.bold("\n\u{1F4CA} AI Readiness Overall Score"));
+      console.log(`  ${formatScore(scoringResult)}`);
+      if (options.compareTo) {
         try {
-          const ctxSummary = genContextSummary(results.context);
-          const contextScore = calculateContextScore(ctxSummary);
-          toolScores.set("context-analyzer", contextScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.consistency) {
-        const { calculateConsistencyScore } = await import("@aiready/consistency");
-        try {
-          const issues = results.consistency.results?.flatMap((r) => r.issues) || [];
-          const totalFiles = results.consistency.summary?.filesAnalyzed || 0;
-          const consistencyScore = calculateConsistencyScore(
-            issues,
-            totalFiles
-          );
-          toolScores.set("consistency", consistencyScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.aiSignalClarity) {
-        const { calculateAiSignalClarityScore } = await import("@aiready/ai-signal-clarity");
-        try {
-          const hrScore = calculateAiSignalClarityScore(
-            results.aiSignalClarity
+          const prevReportStr = readFileSync2(
+            resolvePath3(process.cwd(), options.compareTo),
+            "utf8"
           );
-          toolScores.set("ai-signal-clarity", hrScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.grounding) {
-        const { calculateGroundingScore } = await import("@aiready/agent-grounding");
-        try {
-          const agScore = calculateGroundingScore(results.grounding);
-          toolScores.set("agent-grounding", agScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.testability) {
-        const { calculateTestabilityScore } = await import("@aiready/testability");
-        try {
-          const tbScore = calculateTestabilityScore(results.testability);
-          toolScores.set("testability", tbScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.docDrift) {
-        toolScores.set("doc-drift", {
-          toolName: "doc-drift",
-          score: results.docDrift.summary.score,
-          rawMetrics: results.docDrift.rawData,
-          factors: [],
-          recommendations: (results.docDrift.recommendations || []).map(
-            (action) => ({
-              action,
-              estimatedImpact: 5,
-              priority: "medium"
-            })
-          )
-        });
-      }
-      if (results.deps) {
-        toolScores.set("dependency-health", {
-          toolName: "dependency-health",
-          score: results.deps.summary.score,
-          rawMetrics: results.deps.rawData,
-          factors: [],
-          recommendations: (results.deps.recommendations || []).map(
-            (action) => ({
-              action,
-              estimatedImpact: 5,
-              priority: "medium"
-            })
-          )
-        });
-      }
-      if (results.changeAmplification) {
-        toolScores.set("change-amplification", {
-          toolName: "change-amplification",
-          score: results.changeAmplification.summary.score,
-          rawMetrics: results.changeAmplification.rawData,
-          factors: [],
-          recommendations: (results.changeAmplification.recommendations || []).map((action) => ({
-            action,
-            estimatedImpact: 5,
-            priority: "medium"
-          }))
-        });
-      }
-      const cliWeights = parseWeightString(options.weights);
-      if (toolScores.size > 0) {
-        scoringResult = calculateOverallScore(
-          toolScores,
-          finalOptions,
-          cliWeights.size ? cliWeights : void 0
-        );
-        console.log(chalk2.bold("\n\u{1F4CA} AI Readiness Overall Score"));
-        console.log(`  ${formatScore(scoringResult)}`);
-        if (options.compareTo) {
-          try {
-            const prevReportStr = readFileSync2(
-              resolvePath2(process.cwd(), options.compareTo),
-              "utf8"
-            );
-            const prevReport = JSON.parse(prevReportStr);
-            const prevScore = prevReport.scoring?.score || prevReport.scoring?.overallScore;
-            if (typeof prevScore === "number") {
-              const diff = scoringResult.overall - prevScore;
-              const diffStr = diff > 0 ? `+${diff}` : String(diff);
-              console.log();
-              if (diff > 0) {
-                console.log(
-                  chalk2.green(
-                    `  \u{1F4C8} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
-                  )
-                );
-              } else if (diff < 0) {
-                console.log(
-                  chalk2.red(
-                    `  \u{1F4C9} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
-                  )
-                );
-              } else {
-                console.log(
-                  chalk2.blue(
-                    `  \u2796 Trend: No change compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
-                  )
-                );
-              }
-              scoringResult.trend = {
-                previousScore: prevScore,
-                difference: diff
-              };
+          const prevReport = JSON.parse(prevReportStr);
+          const prevScore = prevReport.scoring?.score || prevReport.scoring?.overallScore;
+          if (typeof prevScore === "number") {
+            const diff = scoringResult.overall - prevScore;
+            const diffStr = diff > 0 ? `+${diff}` : String(diff);
+            console.log();
+            if (diff > 0) {
+              console.log(
+                chalk3.green(
+                  `  \u{1F4C8} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
+                )
+              );
+            } else if (diff < 0) {
+              console.log(
+                chalk3.red(
+                  `  \u{1F4C9} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
+                )
+              );
             } else {
               console.log(
-                chalk2.yellow(
-                  `
-  \u26A0\uFE0F  Previous report at ${options.compareTo} does not contain an overall score.`
+                chalk3.blue(
+                  `  \u2796 Trend: No change compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
                 )
               );
             }
-          } catch (e) {
-            void e;
+            scoringResult.trend = {
+              previousScore: prevScore,
+              difference: diff
+            };
+          } else {
             console.log(
-              chalk2.yellow(
+              chalk3.yellow(
                 `
-  \u26A0\uFE0F  Could not read or parse previous report at ${options.compareTo}.`
+  \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}.`
+            )
+          );
         }
-        if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
-          console.log(chalk2.bold("\nTool breakdown:"));
+      }
+      const totalWastedDuplication = (scoringResult.breakdown || []).reduce(
+        (sum, s) => sum + (s.tokenBudget?.wastedTokens.bySource.duplication || 0),
+        0
+      );
+      const totalWastedFragmentation = (scoringResult.breakdown || []).reduce(
+        (sum, s) => sum + (s.tokenBudget?.wastedTokens.bySource.fragmentation || 0),
+        0
+      );
+      const totalContext = Math.max(
+        ...(scoringResult.breakdown || []).map(
+          (s) => s.tokenBudget?.totalContextTokens || 0
+        )
+      );
+      if (totalContext > 0) {
+        const unifiedBudget = calculateTokenBudget({
+          totalContextTokens: totalContext,
+          wastedTokens: {
+            duplication: totalWastedDuplication,
+            fragmentation: totalWastedFragmentation,
+            chattiness: 0
+          }
+        });
+        const targetModel = options.model || "claude-4.6";
+        const modelPreset = getModelPreset(targetModel);
+        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(
+          `  Wasted Tokens: ${chalk3.red(unifiedBudget.wastedTokens.total.toLocaleString())} (${(unifiedBudget.wastedTokens.total / unifiedBudget.totalContextTokens * 100).toFixed(1)}%)`
+        );
+        console.log(`  Waste Breakdown:`);
+        console.log(
+          `    \u2022 Duplication:   ${unifiedBudget.wastedTokens.bySource.duplication.toLocaleString()} tokens`
+        );
+        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]}]`
+        );
+        scoringResult.tokenBudget = unifiedBudget;
+        scoringResult.costEstimate = {
+          model: modelPreset.name,
+          ...costEstimate
+        };
+      }
+      if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
+        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();
+        if (finalOptions.scoring?.showBreakdown) {
+          console.log(chalk3.bold("Detailed tool 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(formatToolScore(tool));
           });
           console.log();
-          if (finalOptions.scoring?.showBreakdown) {
-            console.log(chalk2.bold("Detailed tool breakdown:"));
-            scoringResult.breakdown.forEach((tool) => {
-              console.log(formatToolScore(tool));
-            });
-            console.log();
-          }
         }
       }
     }
@@ -733,12 +780,23 @@ async function scanAction(directory, options) {
         defaultFilename,
         resolvedDir
       );
-      const outputData = { ...results, scoring: scoringResult };
+      const outputData = {
+        ...results,
+        scoring: 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();
@@ -748,10 +806,21 @@ async function scanAction(directory, options) {
         defaultFilename,
         resolvedDir
       );
-      const outputData = { ...results, scoring: scoringResult };
+      const outputData = {
+        ...results,
+        scoring: scoringResult,
+        repository: repoMetadata
+      };
       try {
         writeFileSync(outputPath, JSON.stringify(outputData, null, 2));
-        console.log(chalk2.dim(`\u2705 Report auto-persisted to ${outputPath}`));
+        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;
@@ -833,37 +902,37 @@ async function scanAction(directory, options) {
         }
       }
       if (shouldFail) {
-        console.log(chalk2.red("\n\u{1F6AB} PR BLOCKED: AI Readiness Check Failed"));
-        console.log(chalk2.red(`   Reason: ${failReason}`));
-        console.log(chalk2.dim("\n   Remediation steps:"));
+        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(
-          chalk2.dim("   1. Run `aiready scan` locally to see detailed issues")
+          chalk3.dim("   1. Run `aiready scan` locally to see detailed issues")
         );
-        console.log(chalk2.dim("   2. Fix the critical issues before merging"));
+        console.log(chalk3.dim("   2. Fix the critical issues before merging"));
         console.log(
-          chalk2.dim(
+          chalk3.dim(
             "   3. Consider upgrading to Team plan for historical tracking: https://getaiready.dev/pricing"
           )
         );
         process.exit(1);
       } else {
-        console.log(chalk2.green("\n\u2705 PR PASSED: AI Readiness Check"));
+        console.log(chalk3.green("\n\u2705 PR PASSED: AI Readiness Check"));
         if (threshold) {
           console.log(
-            chalk2.green(
+            chalk3.green(
               `   Score: ${scoringResult.overall}/100 (threshold: ${threshold})`
             )
           );
         }
         console.log(
-          chalk2.dim(
+          chalk3.dim(
             "\n   \u{1F4A1} Track historical trends: https://getaiready.dev \u2014 Team plan $99/mo"
           )
         );
       }
     }
   } catch (error) {
-    handleCLIError(error, "Analysis");
+    handleCLIError2(error, "Analysis");
   }
 }
 var scanHelpText = `
@@ -877,6 +946,8 @@ EXAMPLES:
   $ 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
@@ -896,20 +967,20 @@ CI/CD INTEGRATION (Gatekeeper Mode):
 `;
 
 // src/commands/patterns.ts
-import chalk3 from "chalk";
-import { resolve as resolvePath3 } from "path";
+import chalk4 from "chalk";
+import { resolve as resolvePath4 } from "path";
 import {
   loadMergedConfig as loadMergedConfig2,
   handleJSONOutput as handleJSONOutput2,
-  handleCLIError as handleCLIError2,
+  handleCLIError as handleCLIError3,
   getElapsedTime as getElapsedTime2,
   resolveOutputPath as resolveOutputPath2,
   formatToolScore as formatToolScore2
 } from "@aiready/core";
 async function patternsAction(directory, options) {
-  console.log(chalk3.blue("\u{1F50D} Analyzing patterns...\n"));
+  console.log(chalk4.blue("\u{1F50D} Analyzing patterns...\n"));
   const startTime = Date.now();
-  const resolvedDir = resolvePath3(process.cwd(), directory || ".");
+  const resolvedDir = resolvePath4(process.cwd(), directory || ".");
   try {
     const useSmartDefaults = !options.fullScan;
     const defaults = {
@@ -973,38 +1044,38 @@ async function patternsAction(directory, options) {
       const terminalWidth = process.stdout.columns || 80;
       const dividerWidth = Math.min(60, terminalWidth - 2);
       const divider = "\u2501".repeat(dividerWidth);
-      console.log(chalk3.cyan(divider));
-      console.log(chalk3.bold.white("  PATTERN ANALYSIS SUMMARY"));
-      console.log(chalk3.cyan(divider) + "\n");
+      console.log(chalk4.cyan(divider));
+      console.log(chalk4.bold.white("  PATTERN ANALYSIS SUMMARY"));
+      console.log(chalk4.cyan(divider) + "\n");
       console.log(
-        chalk3.white(`\u{1F4C1} Files analyzed: ${chalk3.bold(results.length)}`)
+        chalk4.white(`\u{1F4C1} Files analyzed: ${chalk4.bold(results.length)}`)
       );
       console.log(
-        chalk3.yellow(
-          `\u26A0  Duplicate patterns found: ${chalk3.bold(summary.totalPatterns)}`
+        chalk4.yellow(
+          `\u26A0  Duplicate patterns found: ${chalk4.bold(summary.totalPatterns)}`
         )
       );
       console.log(
-        chalk3.red(
-          `\u{1F4B0} Token cost (wasted): ${chalk3.bold(summary.totalTokenCost.toLocaleString())}`
+        chalk4.red(
+          `\u{1F4B0} Token cost (wasted): ${chalk4.bold(summary.totalTokenCost.toLocaleString())}`
         )
       );
       console.log(
-        chalk3.gray(`\u23F1  Analysis time: ${chalk3.bold(elapsedTime + "s")}`)
+        chalk4.gray(`\u23F1  Analysis time: ${chalk4.bold(elapsedTime + "s")}`)
       );
       const sortedTypes = Object.entries(summary.patternsByType || {}).filter(([, count]) => count > 0).sort(([, a], [, b]) => b - a);
       if (sortedTypes.length > 0) {
-        console.log(chalk3.cyan("\n" + divider));
-        console.log(chalk3.bold.white("  PATTERNS BY TYPE"));
-        console.log(chalk3.cyan(divider) + "\n");
+        console.log(chalk4.cyan("\n" + divider));
+        console.log(chalk4.bold.white("  PATTERNS BY TYPE"));
+        console.log(chalk4.cyan(divider) + "\n");
         sortedTypes.forEach(([type, count]) => {
-          console.log(`  ${chalk3.white(type.padEnd(15))} ${chalk3.bold(count)}`);
+          console.log(`  ${chalk4.white(type.padEnd(15))} ${chalk4.bold(count)}`);
         });
       }
       if (summary.totalPatterns > 0 && duplicates.length > 0) {
-        console.log(chalk3.cyan("\n" + divider));
-        console.log(chalk3.bold.white("  TOP DUPLICATE PATTERNS"));
-        console.log(chalk3.cyan(divider) + "\n");
+        console.log(chalk4.cyan("\n" + divider));
+        console.log(chalk4.bold.white("  TOP DUPLICATE PATTERNS"));
+        console.log(chalk4.cyan(divider) + "\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";
@@ -1012,31 +1083,31 @@ async function patternsAction(directory, options) {
           const file1Name = dup.file1.split("/").pop() || dup.file1;
           const file2Name = dup.file2.split("/").pop() || dup.file2;
           console.log(
-            `${severityIcon} ${severity}: ${chalk3.bold(file1Name)} \u2194 ${chalk3.bold(file2Name)}`
+            `${severityIcon} ${severity}: ${chalk4.bold(file1Name)} \u2194 ${chalk4.bold(file2Name)}`
           );
           console.log(
-            `   Similarity: ${chalk3.bold(Math.round(dup.similarity * 100) + "%")} | Wasted: ${chalk3.bold(dup.tokenCost.toLocaleString())} tokens each`
+            `   Similarity: ${chalk4.bold(Math.round(dup.similarity * 100) + "%")} | Wasted: ${chalk4.bold(dup.tokenCost.toLocaleString())} tokens each`
           );
           console.log(
-            `   Lines: ${chalk3.cyan(dup.line1 + "-" + dup.endLine1)} \u2194 ${chalk3.cyan(dup.line2 + "-" + dup.endLine2)}
+            `   Lines: ${chalk4.cyan(dup.line1 + "-" + dup.endLine1)} \u2194 ${chalk4.cyan(dup.line2 + "-" + dup.endLine2)}
 `
           );
         });
       } else {
         console.log(
-          chalk3.green("\n\u2728 Great! No duplicate patterns detected.\n")
+          chalk4.green("\n\u2728 Great! No duplicate patterns detected.\n")
         );
       }
       if (patternScore) {
-        console.log(chalk3.cyan(divider));
-        console.log(chalk3.bold.white("  AI READINESS SCORE (Patterns)"));
-        console.log(chalk3.cyan(divider) + "\n");
+        console.log(chalk4.cyan(divider));
+        console.log(chalk4.bold.white("  AI READINESS SCORE (Patterns)"));
+        console.log(chalk4.cyan(divider) + "\n");
         console.log(formatToolScore2(patternScore));
         console.log();
       }
     }
   } catch (error) {
-    handleCLIError2(error, "Pattern analysis");
+    handleCLIError3(error, "Pattern analysis");
   }
 }
 var patternsHelpText = `
@@ -1047,20 +1118,20 @@ EXAMPLES:
 `;
 
 // src/commands/context.ts
-import chalk4 from "chalk";
-import { resolve as resolvePath4 } from "path";
+import chalk5 from "chalk";
+import { resolve as resolvePath5 } from "path";
 import {
   loadMergedConfig as loadMergedConfig3,
   handleJSONOutput as handleJSONOutput3,
-  handleCLIError as handleCLIError3,
+  handleCLIError as handleCLIError4,
   getElapsedTime as getElapsedTime3,
   resolveOutputPath as resolveOutputPath3,
   formatToolScore as formatToolScore3
 } from "@aiready/core";
 async function contextAction(directory, options) {
-  console.log(chalk4.blue("\u{1F9E0} Analyzing context costs...\n"));
+  console.log(chalk5.blue("\u{1F9E0} Analyzing context costs...\n"));
   const startTime = Date.now();
-  const resolvedDir = resolvePath4(process.cwd(), directory || ".");
+  const resolvedDir = resolvePath5(process.cwd(), directory || ".");
   try {
     const defaults = {
       maxDepth: 5,
@@ -1126,85 +1197,85 @@ async function contextAction(directory, options) {
       const terminalWidth = process.stdout.columns || 80;
       const dividerWidth = Math.min(60, terminalWidth - 2);
       const divider = "\u2501".repeat(dividerWidth);
-      console.log(chalk4.cyan(divider));
-      console.log(chalk4.bold.white("  CONTEXT ANALYSIS SUMMARY"));
-      console.log(chalk4.cyan(divider) + "\n");
+      console.log(chalk5.cyan(divider));
+      console.log(chalk5.bold.white("  CONTEXT ANALYSIS SUMMARY"));
+      console.log(chalk5.cyan(divider) + "\n");
       console.log(
-        chalk4.white(`\u{1F4C1} Files analyzed: ${chalk4.bold(summary.totalFiles)}`)
+        chalk5.white(`\u{1F4C1} Files analyzed: ${chalk5.bold(summary.totalFiles)}`)
       );
       console.log(
-        chalk4.white(
-          `\u{1F4CA} Total tokens: ${chalk4.bold(summary.totalTokens.toLocaleString())}`
+        chalk5.white(
+          `\u{1F4CA} Total tokens: ${chalk5.bold(summary.totalTokens.toLocaleString())}`
         )
       );
       console.log(
-        chalk4.yellow(
-          `\u{1F4B0} Avg context budget: ${chalk4.bold(summary.avgContextBudget.toFixed(0))} tokens/file`
+        chalk5.yellow(
+          `\u{1F4B0} Avg context budget: ${chalk5.bold(summary.avgContextBudget.toFixed(0))} tokens/file`
         )
       );
       console.log(
-        chalk4.white(`\u23F1  Analysis time: ${chalk4.bold(elapsedTime + "s")}
+        chalk5.white(`\u23F1  Analysis time: ${chalk5.bold(elapsedTime + "s")}
 `)
       );
       const totalIssues = summary.criticalIssues + summary.majorIssues + summary.minorIssues;
       if (totalIssues > 0) {
-        console.log(chalk4.bold("\u26A0\uFE0F  Issues Found:\n"));
+        console.log(chalk5.bold("\u26A0\uFE0F  Issues Found:\n"));
         if (summary.criticalIssues > 0) {
           console.log(
-            chalk4.red(`   \u{1F534} Critical: ${chalk4.bold(summary.criticalIssues)}`)
+            chalk5.red(`   \u{1F534} Critical: ${chalk5.bold(summary.criticalIssues)}`)
           );
         }
         if (summary.majorIssues > 0) {
           console.log(
-            chalk4.yellow(`   \u{1F7E1} Major: ${chalk4.bold(summary.majorIssues)}`)
+            chalk5.yellow(`   \u{1F7E1} Major: ${chalk5.bold(summary.majorIssues)}`)
           );
         }
         if (summary.minorIssues > 0) {
           console.log(
-            chalk4.blue(`   \u{1F535} Minor: ${chalk4.bold(summary.minorIssues)}`)
+            chalk5.blue(`   \u{1F535} Minor: ${chalk5.bold(summary.minorIssues)}`)
           );
         }
         console.log(
-          chalk4.green(
+          chalk5.green(
             `
-   \u{1F4A1} Potential savings: ${chalk4.bold(summary.totalPotentialSavings.toLocaleString())} tokens
+   \u{1F4A1} Potential savings: ${chalk5.bold(summary.totalPotentialSavings.toLocaleString())} tokens
 `
           )
         );
       } else {
-        console.log(chalk4.green("\u2705 No significant issues found!\n"));
+        console.log(chalk5.green("\u2705 No significant issues found!\n"));
       }
       if (summary.deepFiles.length > 0) {
-        console.log(chalk4.bold("\u{1F4CF} Deep Import Chains:\n"));
+        console.log(chalk5.bold("\u{1F4CF} Deep Import Chains:\n"));
         console.log(
-          chalk4.gray(`   Average depth: ${summary.avgImportDepth.toFixed(1)}`)
+          chalk5.gray(`   Average depth: ${summary.avgImportDepth.toFixed(1)}`)
         );
         console.log(
-          chalk4.gray(`   Maximum depth: ${summary.maxImportDepth}
+          chalk5.gray(`   Maximum depth: ${summary.maxImportDepth}
 `)
         );
         summary.deepFiles.slice(0, 10).forEach((item) => {
           const fileName = item.file.split("/").slice(-2).join("/");
           console.log(
-            `   ${chalk4.cyan("\u2192")} ${chalk4.white(fileName)} ${chalk4.dim(`(depth: ${item.depth})`)}`
+            `   ${chalk5.cyan("\u2192")} ${chalk5.white(fileName)} ${chalk5.dim(`(depth: ${item.depth})`)}`
           );
         });
         console.log();
       }
       if (summary.fragmentedModules.length > 0) {
-        console.log(chalk4.bold("\u{1F9E9} Fragmented Modules:\n"));
+        console.log(chalk5.bold("\u{1F9E9} Fragmented Modules:\n"));
         console.log(
-          chalk4.gray(
+          chalk5.gray(
             `   Average fragmentation: ${(summary.avgFragmentation * 100).toFixed(0)}%
 `
           )
         );
         summary.fragmentedModules.slice(0, 10).forEach((module) => {
           console.log(
-            `   ${chalk4.yellow("\u25CF")} ${chalk4.white(module.domain)} - ${chalk4.dim(`${module.files.length} files, ${(module.fragmentationScore * 100).toFixed(0)}% scattered`)}`
+            `   ${chalk5.yellow("\u25CF")} ${chalk5.white(module.domain)} - ${chalk5.dim(`${module.files.length} files, ${(module.fragmentationScore * 100).toFixed(0)}% scattered`)}`
           );
           console.log(
-            chalk4.dim(
+            chalk5.dim(
               `     Token cost: ${module.totalTokens.toLocaleString()}, Cohesion: ${(module.avgCohesion * 100).toFixed(0)}%`
             )
           );
@@ -1212,9 +1283,9 @@ async function contextAction(directory, options) {
         console.log();
       }
       if (summary.lowCohesionFiles.length > 0) {
-        console.log(chalk4.bold("\u{1F500} Low Cohesion Files:\n"));
+        console.log(chalk5.bold("\u{1F500} Low Cohesion Files:\n"));
         console.log(
-          chalk4.gray(
+          chalk5.gray(
             `   Average cohesion: ${(summary.avgCohesion * 100).toFixed(0)}%
 `
           )
@@ -1222,53 +1293,53 @@ async function contextAction(directory, options) {
         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 ? chalk4.red : chalk4.yellow;
+          const color = item.score < 0.4 ? chalk5.red : chalk5.yellow;
           console.log(
-            `   ${color("\u25CB")} ${chalk4.white(fileName)} ${chalk4.dim(`(${scorePercent}% cohesion)`)}`
+            `   ${color("\u25CB")} ${chalk5.white(fileName)} ${chalk5.dim(`(${scorePercent}% cohesion)`)}`
           );
         });
         console.log();
       }
       if (summary.topExpensiveFiles.length > 0) {
-        console.log(chalk4.bold("\u{1F4B8} Most Expensive Files (Context Budget):\n"));
+        console.log(chalk5.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" ? chalk4.red : item.severity === "major" ? chalk4.yellow : chalk4.blue;
+          const severityColor = item.severity === "critical" ? chalk5.red : item.severity === "major" ? chalk5.yellow : chalk5.blue;
           console.log(
-            `   ${severityColor("\u25CF")} ${chalk4.white(fileName)} ${chalk4.dim(`(${item.contextBudget.toLocaleString()} tokens)`)}`
+            `   ${severityColor("\u25CF")} ${chalk5.white(fileName)} ${chalk5.dim(`(${item.contextBudget.toLocaleString()} tokens)`)}`
           );
         });
         console.log();
       }
       if (contextScore) {
-        console.log(chalk4.cyan(divider));
-        console.log(chalk4.bold.white("  AI READINESS SCORE (Context)"));
-        console.log(chalk4.cyan(divider) + "\n");
+        console.log(chalk5.cyan(divider));
+        console.log(chalk5.bold.white("  AI READINESS SCORE (Context)"));
+        console.log(chalk5.cyan(divider) + "\n");
         console.log(formatToolScore3(contextScore));
         console.log();
       }
     }
   } catch (error) {
-    handleCLIError3(error, "Context analysis");
+    handleCLIError4(error, "Context analysis");
   }
 }
 
 // src/commands/consistency.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import { writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolvePath5 } from "path";
+import { resolve as resolvePath6 } from "path";
 import {
   loadMergedConfig as loadMergedConfig4,
   handleJSONOutput as handleJSONOutput4,
-  handleCLIError as handleCLIError4,
+  handleCLIError as handleCLIError5,
   getElapsedTime as getElapsedTime4,
   resolveOutputPath as resolveOutputPath4,
   formatToolScore as formatToolScore4
 } from "@aiready/core";
 async function consistencyAction(directory, options) {
-  console.log(chalk5.blue("\u{1F50D} Analyzing consistency...\n"));
+  console.log(chalk6.blue("\u{1F50D} Analyzing consistency...\n"));
   const startTime = Date.now();
-  const resolvedDir = resolvePath5(process.cwd(), directory || ".");
+  const resolvedDir = resolvePath6(process.cwd(), directory || ".");
   try {
     const defaults = {
       checkNaming: true,
@@ -1328,23 +1399,23 @@ async function consistencyAction(directory, options) {
         resolvedDir
       );
       writeFileSync2(outputPath, markdown);
-      console.log(chalk5.green(`\u2705 Report saved to ${outputPath}`));
+      console.log(chalk6.green(`\u2705 Report saved to ${outputPath}`));
     } else {
-      console.log(chalk5.bold("\n\u{1F4CA} Summary\n"));
+      console.log(chalk6.bold("\n\u{1F4CA} Summary\n"));
       console.log(
-        `Files Analyzed: ${chalk5.cyan(report.summary.filesAnalyzed)}`
+        `Files Analyzed: ${chalk6.cyan(report.summary.filesAnalyzed)}`
       );
-      console.log(`Total Issues: ${chalk5.yellow(report.summary.totalIssues)}`);
-      console.log(`  Naming: ${chalk5.yellow(report.summary.namingIssues)}`);
-      console.log(`  Patterns: ${chalk5.yellow(report.summary.patternIssues)}`);
+      console.log(`Total Issues: ${chalk6.yellow(report.summary.totalIssues)}`);
+      console.log(`  Naming: ${chalk6.yellow(report.summary.namingIssues)}`);
+      console.log(`  Patterns: ${chalk6.yellow(report.summary.patternIssues)}`);
       console.log(
-        `  Architecture: ${chalk5.yellow(report.summary.architectureIssues || 0)}`
+        `  Architecture: ${chalk6.yellow(report.summary.architectureIssues || 0)}`
       );
-      console.log(`Analysis Time: ${chalk5.gray(elapsedTime + "s")}
+      console.log(`Analysis Time: ${chalk6.gray(elapsedTime + "s")}
 `);
       if (report.summary.totalIssues === 0) {
         console.log(
-          chalk5.green(
+          chalk6.green(
             "\u2728 No consistency issues found! Your codebase is well-maintained.\n"
           )
         );
@@ -1356,20 +1427,20 @@ async function consistencyAction(directory, options) {
           (r) => r.issues.some((i) => i.category === "patterns")
         );
         if (namingResults.length > 0) {
-          console.log(chalk5.bold("\u{1F3F7}\uFE0F  Naming Issues\n"));
+          console.log(chalk6.bold("\u{1F3F7}\uFE0F  Naming Issues\n"));
           let shown = 0;
           for (const result of namingResults) {
             if (shown >= 5) break;
             for (const issue of result.issues) {
               if (shown >= 5) break;
-              const severityColor = issue.severity === "critical" ? chalk5.red : issue.severity === "major" ? chalk5.yellow : issue.severity === "minor" ? chalk5.blue : chalk5.gray;
+              const severityColor = issue.severity === "critical" ? chalk6.red : issue.severity === "major" ? chalk6.yellow : issue.severity === "minor" ? chalk6.blue : chalk6.gray;
               console.log(
-                `${severityColor(issue.severity.toUpperCase())} ${chalk5.dim(`${issue.location.file}:${issue.location.line}`)}`
+                `${severityColor(issue.severity.toUpperCase())} ${chalk6.dim(`${issue.location.file}:${issue.location.line}`)}`
               );
               console.log(`  ${issue.message}`);
               if (issue.suggestion) {
                 console.log(
-                  `  ${chalk5.dim("\u2192")} ${chalk5.italic(issue.suggestion)}`
+                  `  ${chalk6.dim("\u2192")} ${chalk6.italic(issue.suggestion)}`
                 );
               }
               console.log();
@@ -1378,25 +1449,25 @@ async function consistencyAction(directory, options) {
           }
           const remaining = namingResults.reduce((sum, r) => sum + r.issues.length, 0) - shown;
           if (remaining > 0) {
-            console.log(chalk5.dim(`  ... and ${remaining} more issues
+            console.log(chalk6.dim(`  ... and ${remaining} more issues
 `));
           }
         }
         if (patternResults.length > 0) {
-          console.log(chalk5.bold("\u{1F504} Pattern Issues\n"));
+          console.log(chalk6.bold("\u{1F504} Pattern Issues\n"));
           let shown = 0;
           for (const result of patternResults) {
             if (shown >= 5) break;
             for (const issue of result.issues) {
               if (shown >= 5) break;
-              const severityColor = issue.severity === "critical" ? chalk5.red : issue.severity === "major" ? chalk5.yellow : issue.severity === "minor" ? chalk5.blue : chalk5.gray;
+              const severityColor = issue.severity === "critical" ? chalk6.red : issue.severity === "major" ? chalk6.yellow : issue.severity === "minor" ? chalk6.blue : chalk6.gray;
               console.log(
-                `${severityColor(issue.severity.toUpperCase())} ${chalk5.dim(`${issue.location.file}:${issue.location.line}`)}`
+                `${severityColor(issue.severity.toUpperCase())} ${chalk6.dim(`${issue.location.file}:${issue.location.line}`)}`
               );
               console.log(`  ${issue.message}`);
               if (issue.suggestion) {
                 console.log(
-                  `  ${chalk5.dim("\u2192")} ${chalk5.italic(issue.suggestion)}`
+                  `  ${chalk6.dim("\u2192")} ${chalk6.italic(issue.suggestion)}`
                 );
               }
               console.log();
@@ -1405,12 +1476,12 @@ async function consistencyAction(directory, options) {
           }
           const remaining = patternResults.reduce((sum, r) => sum + r.issues.length, 0) - shown;
           if (remaining > 0) {
-            console.log(chalk5.dim(`  ... and ${remaining} more issues
+            console.log(chalk6.dim(`  ... and ${remaining} more issues
 `));
           }
         }
         if (report.recommendations.length > 0) {
-          console.log(chalk5.bold("\u{1F4A1} Recommendations\n"));
+          console.log(chalk6.bold("\u{1F4A1} Recommendations\n"));
           report.recommendations.forEach((rec, i) => {
             console.log(`${i + 1}. ${rec}`);
           });
@@ -1418,38 +1489,38 @@ async function consistencyAction(directory, options) {
         }
       }
       if (consistencyScore) {
-        console.log(chalk5.bold("\n\u{1F4CA} AI Readiness Score (Consistency)\n"));
+        console.log(chalk6.bold("\n\u{1F4CA} AI Readiness Score (Consistency)\n"));
         console.log(formatToolScore4(consistencyScore));
         console.log();
       }
     }
   } catch (error) {
-    handleCLIError4(error, "Consistency analysis");
+    handleCLIError5(error, "Consistency analysis");
   }
 }
 
 // src/commands/visualize.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, existsSync as existsSync2, copyFileSync } from "fs";
-import { resolve as resolvePath6 } from "path";
+import { resolve as resolvePath7 } from "path";
 import { spawn } from "child_process";
-import { handleCLIError as handleCLIError5 } from "@aiready/core";
+import { handleCLIError as handleCLIError6 } from "@aiready/core";
 import { generateHTML } from "@aiready/core";
 async function visualizeAction(directory, options) {
   try {
-    const dirPath = resolvePath6(process.cwd(), directory || ".");
-    let reportPath = options.report ? resolvePath6(dirPath, options.report) : null;
+    const dirPath = resolvePath7(process.cwd(), directory || ".");
+    let reportPath = options.report ? resolvePath7(dirPath, options.report) : null;
     if (!reportPath || !existsSync2(reportPath)) {
       const latestScan = findLatestScanReport(dirPath);
       if (latestScan) {
         reportPath = latestScan;
         console.log(
-          chalk6.dim(`Found latest report: ${latestScan.split("/").pop()}`)
+          chalk7.dim(`Found latest report: ${latestScan.split("/").pop()}`)
         );
       } else {
-        console.error(chalk6.red("\u274C No AI readiness report found"));
+        console.error(chalk7.red("\u274C No AI readiness report found"));
         console.log(
-          chalk6.dim(
+          chalk7.dim(
             `
 Generate a report with:
   aiready scan --output json
@@ -1463,7 +1534,7 @@ Or specify a custom report:
     }
     const raw = readFileSync3(reportPath, "utf8");
     const report = JSON.parse(raw);
-    const configPath = resolvePath6(dirPath, "aiready.json");
+    const configPath = resolvePath7(dirPath, "aiready.json");
     let graphConfig = { maxNodes: 400, maxEdges: 600 };
     if (existsSync2(configPath)) {
       try {
@@ -1487,7 +1558,7 @@ Or specify a custom report:
     let devServerStarted = false;
     if (useDevMode) {
       try {
-        const monorepoWebDir = resolvePath6(dirPath, "packages/visualizer");
+        const monorepoWebDir = resolvePath7(dirPath, "packages/visualizer");
         let webDir = "";
         let visualizerAvailable = false;
         if (existsSync2(monorepoWebDir)) {
@@ -1495,8 +1566,8 @@ Or specify a custom report:
           visualizerAvailable = true;
         } else {
           const nodemodulesLocations = [
-            resolvePath6(dirPath, "node_modules", "@aiready", "visualizer"),
-            resolvePath6(
+            resolvePath7(dirPath, "node_modules", "@aiready", "visualizer"),
+            resolvePath7(
               process.cwd(),
               "node_modules",
               "@aiready",
@@ -1506,14 +1577,14 @@ Or specify a custom report:
           let currentDir = dirPath;
           while (currentDir !== "/" && currentDir !== ".") {
             nodemodulesLocations.push(
-              resolvePath6(currentDir, "node_modules", "@aiready", "visualizer")
+              resolvePath7(currentDir, "node_modules", "@aiready", "visualizer")
             );
-            const parent = resolvePath6(currentDir, "..");
+            const parent = resolvePath7(currentDir, "..");
             if (parent === currentDir) break;
             currentDir = parent;
           }
           for (const location of nodemodulesLocations) {
-            if (existsSync2(location) && existsSync2(resolvePath6(location, "package.json"))) {
+            if (existsSync2(location) && existsSync2(resolvePath7(location, "package.json"))) {
               webDir = location;
               visualizerAvailable = true;
               break;
@@ -1522,20 +1593,20 @@ Or specify a custom report:
           if (!visualizerAvailable) {
             try {
               const vizPkgPath = __require.resolve("@aiready/visualizer/package.json");
-              webDir = resolvePath6(vizPkgPath, "..");
+              webDir = resolvePath7(vizPkgPath, "..");
               visualizerAvailable = true;
             } catch (err) {
               void err;
             }
           }
         }
-        const webViteConfigExists = webDir && existsSync2(resolvePath6(webDir, "web", "vite.config.ts"));
+        const webViteConfigExists = webDir && existsSync2(resolvePath7(webDir, "web", "vite.config.ts"));
         if (visualizerAvailable && webViteConfigExists) {
           const spawnCwd = webDir;
           const { watch } = await import("fs");
           const copyReportToViz = () => {
             try {
-              const destPath = resolvePath6(spawnCwd, "web", "report-data.json");
+              const destPath = resolvePath7(spawnCwd, "web", "report-data.json");
               copyFileSync(reportPath, destPath);
               console.log(`\u{1F4CB} Report synced to ${destPath}`);
             } catch (e) {
@@ -1579,19 +1650,19 @@ Or specify a custom report:
           return;
         } else {
           console.log(
-            chalk6.yellow(
+            chalk7.yellow(
               "\u26A0\uFE0F  Dev server not available (requires local @aiready/visualizer with web assets)."
             )
           );
           console.log(
-            chalk6.cyan("   Falling back to static HTML generation...\n")
+            chalk7.cyan("   Falling back to static HTML generation...\n")
           );
           useDevMode = false;
         }
       } catch (err) {
         console.error("Failed to start dev server:", err);
         console.log(
-          chalk6.cyan("   Falling back to static HTML generation...\n")
+          chalk7.cyan("   Falling back to static HTML generation...\n")
         );
         useDevMode = false;
       }
@@ -1599,9 +1670,9 @@ Or specify a custom report:
     console.log("Generating HTML...");
     const html = generateHTML(graph);
     const defaultOutput = "visualization.html";
-    const outPath = resolvePath6(dirPath, options.output || defaultOutput);
+    const outPath = resolvePath7(dirPath, options.output || defaultOutput);
     writeFileSync3(outPath, html, "utf8");
-    console.log(chalk6.green(`\u2705 Visualization written to: ${outPath}`));
+    console.log(chalk7.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) {
@@ -1631,7 +1702,7 @@ Or specify a custom report:
           server.listen(port, () => {
             const addr = `http://localhost:${port}/`;
             console.log(
-              chalk6.cyan(`\u{1F310} Local visualization server running at ${addr}`)
+              chalk7.cyan(`\u{1F310} Local visualization server running at ${addr}`)
             );
             spawn(opener, [`"${addr}"`], { shell: true });
           });
@@ -1647,7 +1718,7 @@ Or specify a custom report:
       }
     }
   } catch (err) {
-    handleCLIError5(err, "Visualization");
+    handleCLIError6(err, "Visualization");
   }
 }
 var visualizeHelpText = `
@@ -1678,15 +1749,15 @@ NOTES:
 `;
 
 // src/commands/ai-signal-clarity.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import { loadConfig, mergeConfigWithDefaults } from "@aiready/core";
 
 // src/commands/agent-grounding.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 import { loadConfig as loadConfig2, mergeConfigWithDefaults as mergeConfigWithDefaults2 } from "@aiready/core";
 
 // src/commands/testability.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import { loadConfig as loadConfig3, mergeConfigWithDefaults as mergeConfigWithDefaults3 } from "@aiready/core";
 
 // src/commands/change-amplification.ts
@@ -1761,7 +1832,7 @@ program.command("scan").description(
   "--fail-on <level>",
   "Fail on issues: critical, major, any",
   "critical"
-).addHelpText("after", scanHelpText).action(async (directory, options) => {
+).option("--api-key <key>", "Platform API key for automatic upload").option("--upload", "Automatically upload results to the platform").option("--server <url>", "Custom platform URL").addHelpText("after", scanHelpText).action(async (directory, options) => {
   await scanAction(directory, options);
 });
 program.command("patterns").description("Detect duplicate code patterns that confuse AI models").argument("[directory]", "Directory to analyze", ".").option("-s, --similarity <number>", "Minimum similarity score (0-1)", "0.40").option("-l, --min-lines <number>", "Minimum lines to consider", "5").option(
@@ -1842,4 +1913,7 @@ program.command("visualize").description("Generate interactive visualization fro
 program.command("change-amplification").description("Analyze graph metrics for change amplification").argument("[directory]", "Directory to analyze", ".").option("--include <patterns>", "File patterns to include (comma-separated)").option("--exclude <patterns>", "File patterns to exclude (comma-separated)").option("-o, --output <format>", "Output format: console, json", "console").option("--output-file <path>", "Output file path (for json)").action(async (directory, options) => {
   await changeAmplificationAction(directory, options);
 });
+program.command("upload").description("Upload an AIReady report JSON to the platform").argument("<file>", "Report JSON file to upload").option("--api-key <key>", "Platform API key").option("--repo-id <id>", "Platform repository ID (optional)").option("--server <url>", "Custom platform URL").addHelpText("after", uploadHelpText).action(async (file, options) => {
+  await uploadAction(file, options);
+});
 program.parse();