@aiready/cli 0.9.43 → 0.9.46

package/src/cli.ts

@@ -16,6 +16,8 @@ import {
   visualizeHelpText,
   visualiseHelpText,
   changeAmplificationAction,
+  uploadAction,
+  uploadHelpText,
 } from './commands';
 
 const getDirname = () => {
@@ -111,6 +113,9 @@ program
     'Fail on issues: critical, major, any',
     'critical'
   )
+  .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);
@@ -274,4 +279,17 @@ program
     await changeAmplificationAction(directory, options);
   });
 
+// Upload command - Upload report JSON to platform
+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();

package/src/commands/index.ts

@@ -15,3 +15,4 @@ export { aiSignalClarityAction } from './ai-signal-clarity';
 export { agentGroundingAction } from './agent-grounding';
 export { testabilityAction } from './testability';
 export { changeAmplificationAction } from './change-amplification';
+export { uploadAction, uploadHelpText } from './upload';

package/src/commands/scan.ts

@@ -15,17 +15,22 @@ import {
   calculateOverallScore,
   formatScore,
   formatToolScore,
+  calculateTokenBudget,
+  estimateCostFromBudget,
+  getModelPreset,
   getRating,
   getRatingDisplay,
   parseWeightString,
+  getRepoMetadata,
   type ToolScoringOutput,
 } from '@aiready/core';
-import { analyzeUnified } from '../index';
+import { analyzeUnified, scoreUnified, type ScoringResult } from '../index';
 import {
   getReportTimestamp,
   warnIfGraphCapExceeded,
   truncateArray,
 } from '../utils/helpers';
+import { uploadAction } from './upload';
 
 interface ScanOptions {
   tools?: string;
@@ -41,6 +46,10 @@ interface ScanOptions {
   threshold?: string;
   ci?: boolean;
   failOn?: string;
+  model?: string;
+  apiKey?: string;
+  upload?: boolean;
+  server?: string;
 }
 
 export async function scanAction(directory: string, options: ScanOptions) {
@@ -50,6 +59,9 @@ export async function scanAction(directory: string, options: ScanOptions) {
   // Resolve directory to absolute path to ensure .aiready/ is created in the right location
   const resolvedDir = resolvePath(process.cwd(), directory || '.');
 
+  // Extract repo metadata for linkage
+  const repoMetadata = getRepoMetadata(resolvedDir);
+
   try {
     // Define defaults
     const defaults = {
@@ -476,237 +488,162 @@ export async function scanAction(directory: string, options: ScanOptions) {
     void elapsedTime;
 
     // Calculate score if requested: assemble per-tool scoring outputs
-    let scoringResult: ReturnType<typeof calculateOverallScore> | undefined;
+    let scoringResult: ScoringResult | undefined;
     if (options.score || finalOptions.scoring?.showBreakdown) {
-      const toolScores: Map<string, ToolScoringOutput> = new Map();
+      scoringResult = await scoreUnified(results, finalOptions);
 
-      // Patterns score
-      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;
-        }
-      }
+      console.log(chalk.bold('\n📊 AI Readiness Overall Score'));
+      console.log(`  ${formatScore(scoringResult)}`);
 
-      // Context score
-      if (results.context) {
-        const { generateSummary: genContextSummary, calculateContextScore } =
-          await import('@aiready/context-analyzer');
-        try {
-          const ctxSummary = genContextSummary(results.context);
-          const contextScore = calculateContextScore(ctxSummary);
-          toolScores.set('context-analyzer', contextScore);
-        } catch (err) {
-          void err;
-        }
-      }
+      // Parse CLI weight overrides (if any)
+      // Note: weights are already handled inside scoreUnified via finalOptions and calculateOverallScore
 
-      // Consistency score
-      if (results.consistency) {
-        const { calculateConsistencyScore } =
-          await import('@aiready/consistency');
+      // Check if we need to compare to a previous report
+      if (options.compareTo) {
         try {
-          const issues =
-            results.consistency.results?.flatMap((r: any) => r.issues) || [];
-          const totalFiles = results.consistency.summary?.filesAnalyzed || 0;
-          const consistencyScore = calculateConsistencyScore(
-            issues,
-            totalFiles
+          const prevReportStr = readFileSync(
+            resolvePath(process.cwd(), options.compareTo),
+            'utf8'
           );
-          toolScores.set('consistency', consistencyScore);
-        } catch (err) {
-          void err;
-        }
-      }
+          const prevReport = JSON.parse(prevReportStr);
+          const prevScore =
+            prevReport.scoring?.score || prevReport.scoring?.overallScore;
 
-      // AI signal clarity score
-      if (results.aiSignalClarity) {
-        const { calculateAiSignalClarityScore } =
-          await import('@aiready/ai-signal-clarity');
-        try {
-          const hrScore = calculateAiSignalClarityScore(
-            results.aiSignalClarity
-          );
-          toolScores.set('ai-signal-clarity', hrScore);
-        } catch (err) {
-          void err;
-        }
-      }
+          if (typeof prevScore === 'number') {
+            const diff = scoringResult.overall - prevScore;
+            const diffStr = diff > 0 ? `+${diff}` : String(diff);
+            console.log();
+            if (diff > 0) {
+              console.log(
+                chalk.green(
+                  `  📈 Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} → ${scoringResult.overall})`
+                )
+              );
+            } else if (diff < 0) {
+              console.log(
+                chalk.red(
+                  `  📉 Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} → ${scoringResult.overall})`
+                )
+              );
+              // Trend gating: if we regressed and CI is on or threshold is present, we could lower the threshold effectively,
+              // but for now, we just highlight the regression.
+            } else {
+              console.log(
+                chalk.blue(
+                  `  ➖ Trend: No change compared to ${options.compareTo} (${prevScore} → ${scoringResult.overall})`
+                )
+              );
+            }
 
-      // Agent grounding score
-      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;
+            // Add trend info to scoringResult for programmatic use
+            (scoringResult as any).trend = {
+              previousScore: prevScore,
+              difference: diff,
+            };
+          } else {
+            console.log(
+              chalk.yellow(
+                `\n  ⚠️  Previous report at ${options.compareTo} does not contain an overall score.`
+              )
+            );
+          }
+        } catch (e) {
+          void e;
+          console.log(
+            chalk.yellow(
+              `\n  ⚠️  Could not read or parse previous report at ${options.compareTo}.`
+            )
+          );
         }
       }
 
-      // Testability score
-      if (results.testability) {
-        const { calculateTestabilityScore } =
-          await import('@aiready/testability');
-        try {
-          const tbScore = calculateTestabilityScore(results.testability);
-          toolScores.set('testability', tbScore);
-        } catch (err) {
-          void err;
-        }
-      }
+      // Unified Token Budget Analysis
+      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
+        )
+      );
 
-      // Documentation Drift score
-      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: string) => ({
-              action,
-              estimatedImpact: 5,
-              priority: 'medium',
-            })
-          ),
+      if (totalContext > 0) {
+        const unifiedBudget = calculateTokenBudget({
+          totalContextTokens: totalContext,
+          wastedTokens: {
+            duplication: totalWastedDuplication,
+            fragmentation: totalWastedFragmentation,
+            chattiness: 0,
+          },
         });
-      }
 
-      // Dependency Health score
-      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: string) => ({
-              action,
-              estimatedImpact: 5,
-              priority: 'medium',
-            })
-          ),
-        });
-      }
+        const targetModel = options.model || 'claude-4.6';
+        const modelPreset = getModelPreset(targetModel);
+        const costEstimate = estimateCostFromBudget(unifiedBudget, modelPreset);
 
-      // Change Amplification score
-      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: string) => ({
-            action,
-            estimatedImpact: 5,
-            priority: 'medium',
-          })),
-        });
-      }
+        const barWidth = 20;
+        const filled = Math.round(unifiedBudget.efficiencyRatio * barWidth);
+        const bar =
+          chalk.green('█'.repeat(filled)) +
+          chalk.dim('░'.repeat(barWidth - filled));
 
-      // Parse CLI weight overrides (if any)
-      const cliWeights = parseWeightString((options as any).weights);
-
-      // Only calculate overall score if we have at least one tool score
-      if (toolScores.size > 0) {
-        scoringResult = calculateOverallScore(
-          toolScores,
-          finalOptions,
-          cliWeights.size ? cliWeights : undefined
+        console.log(chalk.bold('\n📊 AI Token Budget Analysis (v0.13)'));
+        console.log(
+          `  Efficiency: [${bar}] ${(unifiedBudget.efficiencyRatio * 100).toFixed(0)}%`
+        );
+        console.log(
+          `  Total Context: ${chalk.bold(unifiedBudget.totalContextTokens.toLocaleString())} tokens`
+        );
+        console.log(
+          `  Wasted Tokens: ${chalk.red(unifiedBudget.wastedTokens.total.toLocaleString())} (${((unifiedBudget.wastedTokens.total / unifiedBudget.totalContextTokens) * 100).toFixed(1)}%)`
+        );
+        console.log(`  Waste Breakdown:`);
+        console.log(
+          `    • Duplication:   ${unifiedBudget.wastedTokens.bySource.duplication.toLocaleString()} tokens`
+        );
+        console.log(
+          `    • Fragmentation: ${unifiedBudget.wastedTokens.bySource.fragmentation.toLocaleString()} tokens`
+        );
+        console.log(
+          `  Potential Savings: ${chalk.green(unifiedBudget.potentialRetrievableTokens.toLocaleString())} tokens retrievable`
+        );
+        console.log(
+          `\n  Est. Monthly Cost (${modelPreset.name}): ${chalk.bold('$' + costEstimate.total)} [range: $${costEstimate.range[0]}-$${costEstimate.range[1]}]`
         );
 
-        console.log(chalk.bold('\n📊 AI Readiness Overall Score'));
-        console.log(`  ${formatScore(scoringResult)}`);
+        // Attach unified budget to report for JSON persistence
+        (scoringResult as any).tokenBudget = unifiedBudget;
+        (scoringResult as any).costEstimate = {
+          model: modelPreset.name,
+          ...costEstimate,
+        };
+      }
 
-        // Check if we need to compare to a previous report
-        if (options.compareTo) {
-          try {
-            const prevReportStr = readFileSync(
-              resolvePath(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(
-                  chalk.green(
-                    `  📈 Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} → ${scoringResult.overall})`
-                  )
-                );
-              } else if (diff < 0) {
-                console.log(
-                  chalk.red(
-                    `  📉 Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} → ${scoringResult.overall})`
-                  )
-                );
-                // Trend gating: if we regressed and CI is on or threshold is present, we could lower the threshold effectively,
-                // but for now, we just highlight the regression.
-              } else {
-                console.log(
-                  chalk.blue(
-                    `  ➖ Trend: No change compared to ${options.compareTo} (${prevScore} → ${scoringResult.overall})`
-                  )
-                );
-              }
-
-              // Add trend info to scoringResult for programmatic use
-              (scoringResult as any).trend = {
-                previousScore: prevScore,
-                difference: diff,
-              };
-            } else {
-              console.log(
-                chalk.yellow(
-                  `\n  ⚠️  Previous report at ${options.compareTo} does not contain an overall score.`
-                )
-              );
-            }
-          } catch (e) {
-            void e;
-            console.log(
-              chalk.yellow(
-                `\n  ⚠️  Could not read or parse previous report at ${options.compareTo}.`
-              )
-            );
-          }
-        }
+      // Show concise breakdown; detailed breakdown only if config requests it
+      if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
+        console.log(chalk.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();
 
-        // Show concise breakdown; detailed breakdown only if config requests it
-        if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
-          console.log(chalk.bold('\nTool breakdown:'));
+        if (finalOptions.scoring?.showBreakdown) {
+          console.log(chalk.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(chalk.bold('Detailed tool breakdown:'));
-            scoringResult.breakdown.forEach((tool) => {
-              console.log(formatToolScore(tool));
-            });
-            console.log();
-          }
         }
       }
     }
@@ -723,13 +660,26 @@ export async function scanAction(directory: string, options: ScanOptions) {
         defaultFilename,
         resolvedDir
       );
-      const outputData = { ...results, scoring: scoringResult };
+      const outputData = {
+        ...results,
+        scoring: scoringResult,
+        repository: repoMetadata,
+      };
       handleJSONOutput(
         outputData,
         outputPath,
         `✅ Report saved to ${outputPath}`
       );
 
+      // Automatic Upload
+      if (options.upload) {
+        console.log(chalk.blue('\n📤 Automatic upload triggered...'));
+        await uploadAction(outputPath, {
+          apiKey: options.apiKey,
+          server: options.server,
+        });
+      }
+
       // Warn if graph caps may be exceeded
       await warnIfGraphCapExceeded(outputData, resolvedDir);
     } else {
@@ -741,11 +691,24 @@ export async function scanAction(directory: string, options: ScanOptions) {
         defaultFilename,
         resolvedDir
       );
-      const outputData = { ...results, scoring: scoringResult };
+      const outputData = {
+        ...results,
+        scoring: scoringResult,
+        repository: repoMetadata,
+      };
 
       try {
         writeFileSync(outputPath, JSON.stringify(outputData, null, 2));
         console.log(chalk.dim(`✅ Report auto-persisted to ${outputPath}`));
+
+        // Automatic Upload (from auto-persistent report)
+        if (options.upload) {
+          console.log(chalk.blue('\n📤 Automatic upload triggered...'));
+          await uploadAction(outputPath, {
+            apiKey: options.apiKey,
+            server: options.server,
+          });
+        }
         // Warn if graph caps may be exceeded
         await warnIfGraphCapExceeded(outputData, resolvedDir);
       } catch (err) {
@@ -897,6 +860,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

package/src/commands/upload.ts

@@ -0,0 +1,125 @@
+import fs from 'fs';
+import { resolve as resolvePath } from 'path';
+import chalk from 'chalk';
+import { handleCLIError } from '@aiready/core';
+
+interface UploadOptions {
+  apiKey?: string;
+  repoId?: string;
+  server?: string;
+}
+
+export async function uploadAction(file: string, options: UploadOptions) {
+  const startTime = Date.now();
+  const filePath = resolvePath(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(chalk.red('❌ API Key is required for upload.'));
+    console.log(
+      chalk.dim(
+        '   Set AIREADY_API_KEY environment variable or use --api-key flag.'
+      )
+    );
+    console.log(
+      chalk.dim('   Get an API key from https://getaiready.dev/dashboard')
+    );
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`❌ File not found: ${filePath}`));
+    process.exit(1);
+  }
+
+  try {
+    console.log(chalk.blue(`🚀 Uploading report to ${serverUrl}...`));
+
+    // Read the report file
+    console.log(chalk.dim(`   Reading report from ${filePath}...`));
+    const reportContent = fs.readFileSync(filePath, 'utf-8');
+    const reportData = JSON.parse(reportContent);
+    console.log(chalk.dim(`   Successfully parsed report JSON.`));
+
+    // Prepare upload payload
+    // Note: repoId is optional if the metadata contains it, but for now we'll require it or infer from metadata
+    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: any = {};
+
+    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(
+        chalk.red(`❌ Upload failed: ${result.error || res.statusText}`)
+      );
+
+      // Special case for redirects or HTML error pages
+      if (contentType?.includes('text/html')) {
+        console.log(
+          chalk.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(
+            chalk.dim(
+              '   Detected redirect. Check if the API endpoint requires authentication or has changed.'
+            )
+          );
+        }
+      }
+
+      if (res.status === 401) {
+        console.log(
+          chalk.dim('   Hint: Your API key may be invalid or expired.')
+        );
+      }
+      process.exit(1);
+    }
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    console.log(chalk.green(`\n✅ Upload successful! (${duration}s)`));
+    console.log(chalk.cyan(`   View results: ${serverUrl}/dashboard`));
+
+    if (result.analysis) {
+      console.log(chalk.dim(`   Analysis ID: ${result.analysis.id}`));
+      console.log(chalk.dim(`   Score: ${result.analysis.aiScore}/100`));
+    }
+  } catch (error) {
+    handleCLIError(error, 'Upload');
+  }
+}
+
+export const 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)
+`;