@aiready/cli 0.9.41 → 0.9.45

package/dist/index.js

@@ -126,7 +126,8 @@ async function analyzeUnified(options) {
     const report = await analyzeDocDrift({
       rootDir: options.rootDir,
       include: options.include,
-      exclude: options.exclude
+      exclude: options.exclude,
+      onProgress: options.onProgress
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: "doc-drift", data: report });
@@ -139,7 +140,8 @@ async function analyzeUnified(options) {
     const report = await analyzeDeps({
       rootDir: options.rootDir,
       include: options.include,
-      exclude: options.exclude
+      exclude: options.exclude,
+      onProgress: options.onProgress
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: "deps-health", data: report });
@@ -152,7 +154,8 @@ async function analyzeUnified(options) {
     const report = await analyzeAiSignalClarity({
       rootDir: options.rootDir,
       include: options.include,
-      exclude: options.exclude
+      exclude: options.exclude,
+      onProgress: options.onProgress
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: "aiSignalClarity", data: report });
@@ -168,7 +171,8 @@ async function analyzeUnified(options) {
     const report = await analyzeAgentGrounding({
       rootDir: options.rootDir,
       include: options.include,
-      exclude: options.exclude
+      exclude: options.exclude,
+      onProgress: options.onProgress
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: "grounding", data: report });
@@ -181,7 +185,8 @@ async function analyzeUnified(options) {
     const report = await analyzeTestability({
       rootDir: options.rootDir,
       include: options.include,
-      exclude: options.exclude
+      exclude: options.exclude,
+      onProgress: options.onProgress
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: "testability", data: report });
@@ -194,7 +199,8 @@ async function analyzeUnified(options) {
     const report = await analyzeChangeAmplification({
       rootDir: options.rootDir,
       include: options.include,
-      exclude: options.exclude
+      exclude: options.exclude,
+      onProgress: options.onProgress
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: "changeAmplification", data: report });

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {
   analyzeUnified,
   generateUnifiedSummary
-} from "./chunk-HLBKROD3.mjs";
+} from "./chunk-LLJMKNBI.mjs";
 export {
   analyzeUnified,
   generateUnifiedSummary

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/cli",
-  "version": "0.9.41",
+  "version": "0.9.45",
   "description": "Unified CLI for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -11,17 +11,17 @@
   "dependencies": {
     "chalk": "^5.3.0",
     "commander": "^14.0.0",
-    "@aiready/agent-grounding": "0.1.6",
-    "@aiready/context-analyzer": "0.9.36",
-    "@aiready/core": "0.9.33",
-    "@aiready/consistency": "0.8.32",
-    "@aiready/deps": "0.1.6",
-    "@aiready/doc-drift": "0.1.6",
-    "@aiready/change-amplification": "0.1.6",
-    "@aiready/ai-signal-clarity": "0.1.6",
-    "@aiready/pattern-detect": "0.11.32",
-    "@aiready/visualizer": "0.1.38",
-    "@aiready/testability": "0.1.6"
+    "@aiready/core": "0.9.37",
+    "@aiready/deps": "0.1.10",
+    "@aiready/doc-drift": "0.1.10",
+    "@aiready/agent-grounding": "0.1.10",
+    "@aiready/ai-signal-clarity": "0.1.10",
+    "@aiready/visualizer": "0.1.42",
+    "@aiready/consistency": "0.8.36",
+    "@aiready/context-analyzer": "0.9.40",
+    "@aiready/testability": "0.1.10",
+    "@aiready/pattern-detect": "0.11.36",
+    "@aiready/change-amplification": "0.1.10"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

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/ai-signal-clarity.ts

@@ -10,7 +10,7 @@ export async function aiSignalClarityAction(
   directory: string,
   options: any
 ): Promise<ToolScoringOutput | undefined> {
-  const { analyzeAiSignalClarity, calculateHallucinationScore } =
+  const { analyzeAiSignalClarity, calculateAiSignalClarityScore } =
     await import('@aiready/ai-signal-clarity');
 
   const config = await loadConfig(directory);
@@ -25,7 +25,7 @@ export async function aiSignalClarityAction(
     exclude: options.exclude,
   });
 
-  const scoring = calculateHallucinationScore(report);
+  const scoring = calculateAiSignalClarityScore(report);
 
   if (options.output === 'json') {
     return scoring;

package/src/commands/consistency.ts

@@ -38,7 +38,7 @@ export async function consistencyAction(
 
   try {
     // Define defaults
-    const defaults = {
+    const defaults: any = {
       checkNaming: true,
       checkPatterns: true,
       minSeverity: 'info' as const,

package/src/commands/context.ts

@@ -36,7 +36,7 @@ export async function contextAction(
 
   try {
     // Define defaults
-    const defaults = {
+    const defaults: any = {
       maxDepth: 5,
       maxContextBudget: 10000,
       include: undefined,

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,9 +15,13 @@ import {
   calculateOverallScore,
   formatScore,
   formatToolScore,
+  calculateTokenBudget,
+  estimateCostFromBudget,
+  getModelPreset,
   getRating,
   getRatingDisplay,
   parseWeightString,
+  getRepoMetadata,
   type ToolScoringOutput,
 } from '@aiready/core';
 import { analyzeUnified } from '../index';
@@ -26,6 +30,7 @@ import {
   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 = {
@@ -74,11 +86,11 @@ export async function scanAction(directory: string, options: ScanOptions) {
 
     let profileTools = options.tools
       ? options.tools.split(',').map((t: string) => {
-          const tool = t.trim();
-          if (tool === 'hallucination' || tool === 'hallucination-risk')
-            return 'aiSignalClarity';
-          return tool;
-        })
+        const tool = t.trim();
+        if (tool === 'hallucination' || tool === 'hallucination-risk')
+          return 'aiSignalClarity';
+        return tool;
+      })
       : undefined;
     if (options.profile) {
       switch (options.profile.toLowerCase()) {
@@ -424,9 +436,21 @@ export async function scanAction(directory: string, options: ScanOptions) {
     const results = await analyzeUnified({
       ...finalOptions,
       progressCallback,
+      onProgress: (processed: number, total: number, message: string) => {
+        // Clear line and print progress
+        process.stdout.write(
+          `\r\x1b[K   [${processed}/${total}] ${message}...`
+        );
+        if (processed === total) {
+          process.stdout.write('\n'); // Move to next line when done
+        }
+      },
       suppressToolConfig: true,
     });
 
+    // Determine if we need to print a trailing newline because the last tool didn't finish normally or had 0 files
+    // But progressCallback already outputs `\n--- TOOL RESULTS ---` so it's fine.
+
     // Summarize tools and results to console
     console.log(chalk.cyan('\n=== AIReady Run Summary ==='));
     console.log(
@@ -477,6 +501,18 @@ export async function scanAction(directory: string, options: ScanOptions) {
             results.duplicates,
             results.patterns?.length || 0
           );
+
+          // Calculate token budget for patterns (waste = duplication)
+          const wastedTokens = results.duplicates.reduce((sum: number, d: any) => sum + (d.tokenCost || 0), 0);
+          patternScore.tokenBudget = calculateTokenBudget({
+            totalContextTokens: wastedTokens * 2, // Estimated context
+            wastedTokens: {
+              duplication: wastedTokens,
+              fragmentation: 0,
+              chattiness: 0
+            }
+          });
+
           toolScores.set('pattern-detect', patternScore);
         } catch (err) {
           void err;
@@ -490,6 +526,17 @@ export async function scanAction(directory: string, options: ScanOptions) {
         try {
           const ctxSummary = genContextSummary(results.context);
           const contextScore = calculateContextScore(ctxSummary);
+
+          // Calculate token budget for context (waste = fragmentation + depth overhead)
+          contextScore.tokenBudget = calculateTokenBudget({
+            totalContextTokens: ctxSummary.totalTokens,
+            wastedTokens: {
+              duplication: 0,
+              fragmentation: ctxSummary.totalPotentialSavings || 0,
+              chattiness: 0
+            }
+          });
+
           toolScores.set('context-analyzer', contextScore);
         } catch (err) {
           void err;
@@ -676,6 +723,49 @@ export async function scanAction(directory: string, options: ScanOptions) {
           }
         }
 
+        // Unified Token Budget Analysis
+        const totalWastedDuplication = Array.from(toolScores.values())
+          .reduce((sum, s) => sum + (s.tokenBudget?.wastedTokens.bySource.duplication || 0), 0);
+        const totalWastedFragmentation = Array.from(toolScores.values())
+          .reduce((sum, s) => sum + (s.tokenBudget?.wastedTokens.bySource.fragmentation || 0), 0);
+        const totalContext = Math.max(...Array.from(toolScores.values()).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 = chalk.green('█'.repeat(filled)) + chalk.dim('░'.repeat(barWidth - filled));
+
+          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]}]`);
+
+          // Attach unified budget to report for JSON persistence
+          (scoringResult as any).tokenBudget = unifiedBudget;
+          (scoringResult as any).costEstimate = {
+            model: modelPreset.name,
+            ...costEstimate
+          };
+        }
+
         // Show concise breakdown; detailed breakdown only if config requests it
         if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
           console.log(chalk.bold('\nTool breakdown:'));
@@ -711,13 +801,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 {
@@ -729,11 +832,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) {
@@ -885,6 +1001,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,87 @@
+import fs from 'fs';
+import path, { 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
+    const reportData = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+
+    // 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 result = (await res.json()) as any;
+
+    if (!res.ok) {
+      console.error(chalk.red(`❌ Upload failed: ${result.error || res.statusText}`));
+      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)
+`;

package/src/index.ts

@@ -169,6 +169,7 @@ export async function analyzeUnified(
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'doc-drift', data: report });
@@ -184,6 +185,7 @@ export async function analyzeUnified(
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'deps-health', data: report });
@@ -200,6 +202,7 @@ export async function analyzeUnified(
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'aiSignalClarity', data: report });
@@ -219,6 +222,7 @@ export async function analyzeUnified(
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'grounding', data: report });
@@ -234,6 +238,7 @@ export async function analyzeUnified(
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'testability', data: report });
@@ -250,6 +255,7 @@ export async function analyzeUnified(
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
+      onProgress: options.onProgress,
     });
     if (options.progressCallback) {
       options.progressCallback({ tool: 'changeAmplification', data: report });