@aiready/cli 0.7.19 → 0.7.21

package/src/cli.ts

@@ -14,6 +14,7 @@ import {
   calculateOverallScore,
   formatScore,
   formatToolScore,
+  getRating,
   getRatingDisplay,
   parseWeightString,
   type AIReadyConfig,
@@ -27,22 +28,64 @@ const program = new Command();
 
 program
   .name('aiready')
-  .description('AIReady - Unified AI-readiness analysis tools')
+  .description('AIReady - Assess and improve AI-readiness of codebases')
   .version(packageJson.version)
-  .addHelpText('after', '\nCONFIGURATION:\n  Supports config files: aiready.json, aiready.config.json, .aiready.json, .aireadyrc.json, aiready.config.js, .aireadyrc.js\n  CLI options override config file settings');
+  .addHelpText('after', `
+AI READINESS SCORING:
+  Get a 0-100 score indicating how AI-ready your codebase is.
+  Use --score flag with any analysis command for detailed breakdown.
+
+EXAMPLES:
+  $ aiready scan                          # Quick analysis of current directory
+  $ aiready scan --score                  # Get AI Readiness Score (0-100)
+  $ aiready scan --tools patterns         # Run only pattern detection
+  $ aiready patterns --similarity 0.6     # Custom similarity threshold
+  $ aiready scan --output json --output-file results.json
+
+GETTING STARTED:
+  1. Run 'aiready scan' to analyze your codebase
+  2. Use 'aiready scan --score' for AI readiness assessment
+  3. Create aiready.json for persistent configuration
+  4. Set up CI/CD with '--threshold' for quality gates
+
+CONFIGURATION:
+  Config files (searched upward): aiready.json, .aiready.json, aiready.config.*
+  CLI options override config file settings
+
+  Example aiready.json:
+  {
+    "scan": { "exclude": ["**/dist/**", "**/node_modules/**"] },
+    "tools": {
+      "pattern-detect": { "minSimilarity": 0.5 },
+      "context-analyzer": { "maxContextBudget": 15000 }
+    },
+    "output": { "format": "json", "directory": ".aiready" }
+  }
+
+VERSION: ${packageJson.version}
+DOCUMENTATION: https://aiready.dev/docs/cli
+GITHUB: https://github.com/caopengau/aiready-cli
+LANDING: https://github.com/caopengau/aiready-landing`);
 
 program
   .command('scan')
-  .description('Run unified analysis on a codebase')
+  .description('Run comprehensive AI-readiness analysis (patterns + context + consistency)')
   .argument('[directory]', 'Directory to analyze', '.')
   .option('-t, --tools <tools>', 'Tools to run (comma-separated: patterns,context,consistency)', 'patterns,context,consistency')
   .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)')
-  .option('--score', 'Calculate and display AI Readiness Score (0-100)')
-  .option('--weights <weights>', 'Override tool weights for scoring (e.g., "patterns:50,context:30,consistency:20")')
-  .option('--threshold <score>', 'Minimum passing score for CI/CD (exits with code 1 if below)')
+  .option('--score', 'Calculate and display AI Readiness Score (0-100) with breakdown')
+  .option('--weights <weights>', 'Custom scoring weights (patterns:40,context:35,consistency:25)')
+  .option('--threshold <score>', 'Fail CI/CD if score below threshold (0-100)')
+  .addHelpText('after', `
+EXAMPLES:
+  $ aiready scan                                    # Analyze all tools
+  $ aiready scan --tools patterns,context           # Skip consistency
+  $ aiready scan --score --threshold 75             # CI/CD with threshold
+  $ aiready scan --output json --output-file report.json
+`)
   .action(async (directory, options) => {
     console.log(chalk.blue('🚀 Starting AIReady unified analysis...\n'));
 
@@ -67,142 +110,270 @@ program
         exclude: options.exclude?.split(','),
       }) as any;
 
+
       // Apply smart defaults for pattern detection if patterns tool is enabled
       let finalOptions = { ...baseOptions };
       if (baseOptions.tools.includes('patterns')) {
         const { getSmartDefaults } = await import('@aiready/pattern-detect');
         const patternSmartDefaults = await getSmartDefaults(directory, baseOptions);
-        finalOptions = { ...patternSmartDefaults, ...finalOptions };
+        // Merge deeply to preserve nested config
+        finalOptions = { ...patternSmartDefaults, ...finalOptions, ...baseOptions };
+      }
+
+      // Print pre-run summary with expanded settings (truncate long arrays)
+      console.log(chalk.cyan('\n=== AIReady Run Preview ==='));
+      console.log(chalk.white('Tools to run:'), (finalOptions.tools || ['patterns', 'context', 'consistency']).join(', '));
+      console.log(chalk.white('Will use settings from config and defaults.'));
+
+      const truncate = (arr: any[] | undefined, cap = 8) => {
+        if (!Array.isArray(arr)) return '';
+        const shown = arr.slice(0, cap).map((v) => String(v));
+        const more = arr.length - shown.length;
+        return shown.join(', ') + (more > 0 ? `, ... (+${more} more)` : '');
+      };
+
+      // Common top-level settings
+      console.log(chalk.white('\nGeneral settings:'));
+      if (finalOptions.rootDir) console.log(`  rootDir: ${chalk.bold(String(finalOptions.rootDir))}`);
+      if (finalOptions.include) console.log(`  include: ${chalk.bold(truncate(finalOptions.include, 6))}`);
+      if (finalOptions.exclude) console.log(`  exclude: ${chalk.bold(truncate(finalOptions.exclude, 6))}`);
+
+      if (finalOptions['pattern-detect'] || finalOptions.minSimilarity) {
+        const pd = finalOptions['pattern-detect'] || {
+          minSimilarity: finalOptions.minSimilarity,
+          minLines: finalOptions.minLines,
+          approx: finalOptions.approx,
+          minSharedTokens: finalOptions.minSharedTokens,
+          maxCandidatesPerBlock: finalOptions.maxCandidatesPerBlock,
+          batchSize: finalOptions.batchSize,
+          streamResults: finalOptions.streamResults,
+          severity: (finalOptions as any).severity,
+          includeTests: (finalOptions as any).includeTests,
+        };
+        console.log(chalk.white('\nPattern-detect settings:'));
+        console.log(`  minSimilarity: ${chalk.bold(pd.minSimilarity ?? 'default')}`);
+        console.log(`  minLines: ${chalk.bold(pd.minLines ?? 'default')}`);
+        if (pd.approx !== undefined) console.log(`  approx: ${chalk.bold(String(pd.approx))}`);
+        if (pd.minSharedTokens !== undefined) console.log(`  minSharedTokens: ${chalk.bold(String(pd.minSharedTokens))}`);
+        if (pd.maxCandidatesPerBlock !== undefined) console.log(`  maxCandidatesPerBlock: ${chalk.bold(String(pd.maxCandidatesPerBlock))}`);
+        if (pd.batchSize !== undefined) console.log(`  batchSize: ${chalk.bold(String(pd.batchSize))}`);
+        if (pd.streamResults !== undefined) console.log(`  streamResults: ${chalk.bold(String(pd.streamResults))}`);
+        if (pd.severity !== undefined) console.log(`  severity: ${chalk.bold(String(pd.severity))}`);
+        if (pd.includeTests !== undefined) console.log(`  includeTests: ${chalk.bold(String(pd.includeTests))}`);
+      }
+
+      if (finalOptions['context-analyzer'] || finalOptions.maxDepth) {
+        const ca = finalOptions['context-analyzer'] || {
+          maxDepth: finalOptions.maxDepth,
+          maxContextBudget: finalOptions.maxContextBudget,
+          minCohesion: (finalOptions as any).minCohesion,
+          maxFragmentation: (finalOptions as any).maxFragmentation,
+          includeNodeModules: (finalOptions as any).includeNodeModules,
+        };
+        console.log(chalk.white('\nContext-analyzer settings:'));
+        console.log(`  maxDepth: ${chalk.bold(ca.maxDepth ?? 'default')}`);
+        console.log(`  maxContextBudget: ${chalk.bold(ca.maxContextBudget ?? 'default')}`);
+        if (ca.minCohesion !== undefined) console.log(`  minCohesion: ${chalk.bold(String(ca.minCohesion))}`);
+        if (ca.maxFragmentation !== undefined) console.log(`  maxFragmentation: ${chalk.bold(String(ca.maxFragmentation))}`);
+        if (ca.includeNodeModules !== undefined) console.log(`  includeNodeModules: ${chalk.bold(String(ca.includeNodeModules))}`);
+      }
+
+      if (finalOptions.consistency) {
+        const c = finalOptions.consistency;
+        console.log(chalk.white('\nConsistency settings:'));
+        console.log(`  checkNaming: ${chalk.bold(String(c.checkNaming ?? true))}`);
+        console.log(`  checkPatterns: ${chalk.bold(String(c.checkPatterns ?? true))}`);
+        console.log(`  checkArchitecture: ${chalk.bold(String(c.checkArchitecture ?? false))}`);
+        if (c.minSeverity) console.log(`  minSeverity: ${chalk.bold(c.minSeverity)}`);
+        if (c.acceptedAbbreviations) console.log(`  acceptedAbbreviations: ${chalk.bold(truncate(c.acceptedAbbreviations, 8))}`);
+        if (c.shortWords) console.log(`  shortWords: ${chalk.bold(truncate(c.shortWords, 8))}`);
       }
 
-      const results = await analyzeUnified(finalOptions);
+      console.log(chalk.white('\nStarting analysis...'));
+
+      // Progress callback to surface per-tool output as each tool finishes
+      const progressCallback = (event: { tool: string; data: any }) => {
+        console.log(chalk.cyan(`\n--- ${event.tool.toUpperCase()} RESULTS ---`));
+        try {
+          if (event.tool === 'patterns') {
+            const pr = event.data as any;
+            console.log(`  Duplicate patterns: ${chalk.bold(String(pr.duplicates?.length || 0))}`);
+            console.log(`  Files with pattern issues: ${chalk.bold(String(pr.results?.length || 0))}`);
+            // show top duplicate summaries
+            if (pr.duplicates && pr.duplicates.length > 0) {
+              pr.duplicates.slice(0, 5).forEach((d: any, i: number) => {
+                console.log(`   ${i + 1}. ${d.file1.split('/').pop()} ↔ ${d.file2.split('/').pop()} (sim=${(d.similarity * 100).toFixed(1)}%)`);
+              });
+            }
+
+            // show top files with pattern issues (sorted by issue count desc)
+            if (pr.results && pr.results.length > 0) {
+              console.log(`  Top files with pattern issues:`);
+              const sortedByIssues = [...pr.results].sort((a: any, b: any) => (b.issues?.length || 0) - (a.issues?.length || 0));
+              sortedByIssues.slice(0, 5).forEach((r: any, i: number) => {
+                console.log(`   ${i + 1}. ${r.fileName.split('/').pop()} - ${r.issues.length} issue(s)`);
+              });
+            }
+
+            // Grouping and clusters summary (if available) — show after detailed findings
+            if (pr.groups && pr.groups.length >= 0) {
+              console.log(`  ✅ Grouped ${chalk.bold(String(pr.duplicates?.length || 0))} duplicates into ${chalk.bold(String(pr.groups.length))} file pairs`);
+            }
+            if (pr.clusters && pr.clusters.length >= 0) {
+              console.log(`  ✅ Created ${chalk.bold(String(pr.clusters.length))} refactor clusters`);
+              // show brief cluster summaries
+              pr.clusters.slice(0, 3).forEach((cl: any, idx: number) => {
+                const files = (cl.files || []).map((f: any) => f.path.split('/').pop()).join(', ');
+                console.log(`   ${idx + 1}. ${files} (${cl.tokenCost || 'n/a'} tokens)`);
+              });
+            }
+          } else if (event.tool === 'context') {
+            const cr = event.data as any[];
+            console.log(`  Context issues found: ${chalk.bold(String(cr.length || 0))}`);
+            cr.slice(0, 5).forEach((c: any, i: number) => {
+              const msg = c.message ? ` - ${c.message}` : '';
+              console.log(`   ${i + 1}. ${c.file} (${c.severity || 'n/a'})${msg}`);
+            });
+          } else if (event.tool === 'consistency') {
+            const rep = event.data as any;
+            console.log(`  Consistency totalIssues: ${chalk.bold(String(rep.summary?.totalIssues || 0))}`);
+
+            if (rep.results && rep.results.length > 0) {
+              // Group issues by file
+              const fileMap = new Map<string, any[]>();
+              rep.results.forEach((r: any) => {
+                (r.issues || []).forEach((issue: any) => {
+                  const file = issue.location?.file || r.file || 'unknown';
+                  if (!fileMap.has(file)) fileMap.set(file, []);
+                  fileMap.get(file)!.push(issue);
+                });
+              });
+
+              // Sort files by number of issues desc
+              const files = Array.from(fileMap.entries()).sort((a, b) => b[1].length - a[1].length);
+              const topFiles = files.slice(0, 10);
+
+              topFiles.forEach(([file, issues], idx) => {
+                // Count severities
+                const counts = issues.reduce((acc: any, it: any) => {
+                  const s = (it.severity || 'info').toLowerCase();
+                  acc[s] = (acc[s] || 0) + 1;
+                  return acc;
+                }, {} as Record<string, number>);
+
+                const sample = issues.find((it: any) => it.severity === 'critical' || it.severity === 'major') || issues[0];
+                const sampleMsg = sample ? ` — ${sample.message}` : '';
+
+                console.log(`   ${idx + 1}. ${file} — ${issues.length} issue(s) (critical:${counts.critical||0} major:${counts.major||0} minor:${counts.minor||0} info:${counts.info||0})${sampleMsg}`);
+              });
+
+              const remaining = files.length - topFiles.length;
+              if (remaining > 0) {
+                console.log(chalk.dim(`   ... and ${remaining} more files with issues (use --output json for full details)`));
+              }
+            }
+          }
+        } catch (err) {
+          // don't crash the run for progress printing errors
+        }
+      };
+
+      const results = await analyzeUnified({ ...finalOptions, progressCallback, suppressToolConfig: true });
+
+      // Summarize tools and results to console
+      console.log(chalk.cyan('\n=== AIReady Run Summary ==='));
+      console.log(chalk.white('Tools run:'), (finalOptions.tools || ['patterns', 'context', 'consistency']).join(', '));
+
+      // Results summary
+      console.log(chalk.cyan('\nResults summary:'));
+      console.log(`  Total issues (all tools): ${chalk.bold(String(results.summary.totalIssues || 0))}`);
+      if (results.duplicates) console.log(`  Duplicate patterns found: ${chalk.bold(String(results.duplicates.length || 0))}`);
+      if (results.patterns) console.log(`  Pattern files with issues: ${chalk.bold(String(results.patterns.length || 0))}`);
+      if (results.context) console.log(`  Context issues: ${chalk.bold(String(results.context.length || 0))}`);
+      if (results.consistency) console.log(`  Consistency issues: ${chalk.bold(String(results.consistency.summary.totalIssues || 0))}`);
+      console.log(chalk.cyan('===========================\n'));
 
       const elapsedTime = getElapsedTime(startTime);
 
-      // Calculate score if requested
+      // Calculate score if requested: assemble per-tool scoring outputs
       let scoringResult: ReturnType<typeof calculateOverallScore> | undefined;
       if (options.score || finalOptions.scoring?.showBreakdown) {
         const toolScores: Map<string, ToolScoringOutput> = new Map();
-        
-        // Collect scores from each tool that was run
-        if (results.patterns && baseOptions.tools.includes('patterns')) {
+
+        // Patterns score
+        if (results.duplicates) {
           const { calculatePatternScore } = await import('@aiready/pattern-detect');
-          // Use the actual duplicates array which has tokenCost field
-          const duplicates = results.duplicates || [];
-          const score = calculatePatternScore(duplicates, results.patterns.length);
-          toolScores.set('pattern-detect', score);
+          try {
+            const patternScore = calculatePatternScore(results.duplicates, results.patterns?.length || 0);
+            toolScores.set('pattern-detect', patternScore);
+          } catch (err) {
+            // ignore scoring failures for a single tool
+          }
         }
-        
-        if (results.context && baseOptions.tools.includes('context')) {
-          const { calculateContextScore } = await import('@aiready/context-analyzer');
-          // Calculate summary from context results
-          const summary = {
-            avgContextBudget: results.context.reduce((sum, r) => sum + r.contextBudget, 0) / results.context.length,
-            maxContextBudget: Math.max(...results.context.map(r => r.contextBudget)),
-            avgImportDepth: results.context.reduce((sum, r) => sum + r.importDepth, 0) / results.context.length,
-            maxImportDepth: Math.max(...results.context.map(r => r.importDepth)),
-            avgFragmentation: results.context.reduce((sum, r) => sum + r.fragmentationScore, 0) / results.context.length,
-            criticalIssues: results.context.filter(r => r.severity === 'critical').length,
-            majorIssues: results.context.filter(r => r.severity === 'major').length,
-          };
-          const score = calculateContextScore(summary as any);
-          toolScores.set('context-analyzer', score);
+
+        // 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) {
+            // ignore
+          }
         }
-        
-        if (results.consistency && baseOptions.tools.includes('consistency')) {
+
+        // Consistency score
+        if (results.consistency) {
           const { calculateConsistencyScore } = await import('@aiready/consistency');
-          const issues = results.consistency.results?.flatMap((r: any) => r.issues) || [];
-          const score = calculateConsistencyScore(issues, results.consistency.summary.filesAnalyzed);
-          toolScores.set('consistency', score);
-        }
-        
-        // Parse weight overrides from CLI
-        const cliWeights = options.weights ? parseWeightString(options.weights) : undefined;
-        
-        // Calculate overall score
-        scoringResult = calculateOverallScore(toolScores, finalOptions as AIReadyConfig, cliWeights);
-        
-        // Check threshold
-        if (options.threshold) {
-          const threshold = parseFloat(options.threshold);
-          if (scoringResult.overall < threshold) {
-            console.error(chalk.red(`\n❌ Score ${scoringResult.overall} is below threshold ${threshold}\n`));
-            process.exit(1);
+          try {
+            const issues = results.consistency.results?.flatMap((r: any) => r.issues) || [];
+            const totalFiles = results.consistency.summary?.filesAnalyzed || 0;
+            const consistencyScore = calculateConsistencyScore(issues, totalFiles);
+            toolScores.set('consistency', consistencyScore);
+          } catch (err) {
+            // ignore
           }
         }
-      }
 
-      const outputFormat = options.output || finalOptions.output?.format || 'console';
-      const userOutputFile = options.outputFile || finalOptions.output?.file;
+        // Parse CLI weight overrides (if any)
+        const cliWeights = parseWeightString((options as any).weights);
 
-      if (outputFormat === 'json') {
-        const outputData = {
-          ...results,
-          summary: {
-            ...results.summary,
-            executionTime: parseFloat(elapsedTime),
-          },
-          ...(scoringResult && { scoring: scoringResult }),
-        };
+        // Only calculate overall score if we have at least one tool score
+        if (toolScores.size > 0) {
+          scoringResult = calculateOverallScore(toolScores, finalOptions, cliWeights.size ? cliWeights : undefined);
 
-        const outputPath = resolveOutputPath(
-          userOutputFile,
-          `aiready-scan-${new Date().toISOString().split('T')[0]}.json`,
-          directory
-        );
-        
-        handleJSONOutput(outputData, outputPath, `✅ Results saved to ${outputPath}`);
-      } else {
-        // Console output
-        console.log(generateUnifiedSummary(results));
-        
-        // Display score if calculated
-        if (scoringResult) {
-          const terminalWidth = process.stdout.columns || 80;
-          const dividerWidth = Math.min(60, terminalWidth - 2);
-          const divider = '━'.repeat(dividerWidth);
-          
-          console.log(chalk.cyan('\n' + divider));
-          console.log(chalk.bold.white('  AI READINESS SCORE'));
-          console.log(chalk.cyan(divider) + '\n');
-          
-          const { emoji, color } = getRatingDisplay(scoringResult.rating);
-          const scoreColor = color === 'green' ? chalk.green : 
-                            color === 'blue' ? chalk.blue : 
-                            color === 'yellow' ? chalk.yellow : chalk.red;
-          
-          console.log(`  ${emoji} Overall Score: ${scoreColor.bold(scoringResult.overall + '/100')} (${chalk.bold(scoringResult.rating)})`);          console.log(`  ${chalk.dim('Timestamp:')} ${new Date(scoringResult.timestamp).toLocaleString()}\n`);
-          
-          // Show breakdown by tool
-          if (scoringResult.breakdown.length > 0) {
-            console.log(chalk.bold('  Component Scores:\n'));
-            scoringResult.breakdown.forEach(tool => {
-              const toolEmoji = tool.toolName === 'pattern-detect' ? '🔍' :
-                              tool.toolName === 'context-analyzer' ? '🧠' : '🏷️';
-              const weight = scoringResult.calculation.weights[tool.toolName];
-              console.log(`  ${toolEmoji} ${chalk.white(tool.toolName.padEnd(20))} ${scoreColor(tool.score + '/100')} ${chalk.dim(`(weight: ${weight})`)}`);
+          console.log(chalk.bold('\n📊 AI Readiness Overall Score'));
+          console.log(`  ${formatScore(scoringResult)}`);
+
+          // 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();
+
+            if (finalOptions.scoring?.showBreakdown) {
+              console.log(chalk.bold('Detailed tool breakdown:'));
+              scoringResult.breakdown.forEach((tool) => {
+                console.log(formatToolScore(tool));
+              });
+              console.log();
+            }
           }
-          
-          // Show calculation
-          console.log(chalk.dim(`  Weighted Formula: ${scoringResult.calculation.formula}`));
-          console.log(chalk.dim(`  Normalized Score: ${scoringResult.calculation.normalized}\n`));
-          
-          // Show top recommendations across all tools
-          const allRecommendations = scoringResult.breakdown
-            .flatMap(tool => tool.recommendations || [])
-            .sort((a, b) => b.estimatedImpact - a.estimatedImpact)
-            .slice(0, 5);
-          
-          if (allRecommendations.length > 0) {
-            console.log(chalk.bold('  Top Recommendations:\n'));
-            allRecommendations.forEach((rec, i) => {
-              const priorityIcon = rec.priority === 'high' ? '🔴' : 
-                                 rec.priority === 'medium' ? '🟡' : '🔵';
-              console.log(`  ${i + 1}. ${priorityIcon} ${rec.action}`);
-              console.log(`     ${chalk.dim(`Impact: +${rec.estimatedImpact} points`)}\n`);
-            });
+
+          // Persist JSON summary by default when output is json or when config directory present
+          const outputFormat = options.output || finalOptions.output?.format || 'console';
+          const userOutputFile = options.outputFile || finalOptions.output?.file;
+          if (outputFormat === 'json') {
+            const dateStr = new Date().toISOString().split('T')[0];
+            const defaultFilename = `aiready-scan-${dateStr}.json`;
+            const outputPath = resolveOutputPath(userOutputFile, defaultFilename, directory);
+            const outputData = { ...results, scoring: scoringResult };
+            handleJSONOutput(outputData, outputPath, `✅ Summary saved to ${outputPath}`);
           }
         }
       }
@@ -214,7 +385,7 @@ program
 // Individual tool commands for convenience
 program
   .command('patterns')
-  .description('Run pattern detection analysis')
+  .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')
@@ -226,6 +397,12 @@ program
   .option('-o, --output <format>', 'Output format: console, json', 'console')
   .option('--output-file <path>', 'Output file path (for json)')
   .option('--score', 'Calculate and display AI Readiness Score for patterns (0-100)')
+  .addHelpText('after', `
+EXAMPLES:
+  $ aiready patterns                                 # Default analysis
+  $ aiready patterns --similarity 0.6               # Stricter matching
+  $ aiready patterns --min-lines 10                 # Larger patterns only
+`)
   .action(async (directory, options) => {
     console.log(chalk.blue('🔍 Analyzing patterns...\n'));
 
@@ -370,7 +547,7 @@ program
 
 program
   .command('context')
-  .description('Run context window cost analysis')
+  .description('Analyze context window costs and dependency fragmentation')
   .argument('[directory]', 'Directory to analyze', '.')
   .option('--max-depth <number>', 'Maximum acceptable import depth', '5')
   .option('--max-context <number>', 'Maximum acceptable context budget (tokens)', '10000')
@@ -546,7 +723,7 @@ program
 
   program
     .command('consistency')
-    .description('Check naming, patterns, and architecture consistency')
+    .description('Check naming conventions and architectural consistency')
     .argument('[directory]', 'Directory to analyze', '.')
     .option('--naming', 'Check naming conventions (default: true)')
     .option('--no-naming', 'Skip naming analysis')

package/src/index.ts

@@ -6,6 +6,8 @@ import type { ContextAnalysisResult } from '@aiready/context-analyzer';
 import type { PatternDetectOptions, DuplicatePattern } from '@aiready/pattern-detect';
 import type { ConsistencyReport } from '@aiready/consistency';
 
+import type { ConsistencyOptions } from '@aiready/consistency';
+
 export interface UnifiedAnalysisOptions extends ScanOptions {
   tools?: ('patterns' | 'context' | 'consistency')[];
   minSimilarity?: number;
@@ -13,6 +15,8 @@ export interface UnifiedAnalysisOptions extends ScanOptions {
   maxCandidatesPerBlock?: number;
   minSharedTokens?: number;
   useSmartDefaults?: boolean;
+  consistency?: Partial<ConsistencyOptions>;
+  progressCallback?: (event: { tool: string; data: any }) => void;
 }
 
 export interface UnifiedAnalysisResult {
@@ -68,6 +72,7 @@ export async function analyzeUnified(
 ): Promise<UnifiedAnalysisResult> {
   const startTime = Date.now();
   const tools = options.tools || ['patterns', 'context', 'consistency'];
+  // Tools requested and effective options are used from `options`
   const result: UnifiedAnalysisResult = {
     summary: {
       totalIssues: 0,
@@ -79,6 +84,10 @@ export async function analyzeUnified(
   // Run pattern detection
   if (tools.includes('patterns')) {
     const patternResult = await analyzePatterns(options);
+    // Emit progress for patterns
+    if (options.progressCallback) {
+      options.progressCallback({ tool: 'patterns', data: patternResult });
+    }
     // Sort results by severity
     result.patterns = sortBySeverity(patternResult.results);
     // Store duplicates for scoring
@@ -93,6 +102,9 @@ export async function analyzeUnified(
   // Run context analysis
   if (tools.includes('context')) {
     const contextResults = await analyzeContext(options);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: 'context', data: contextResults });
+    }
     // Sort context results by severity (most severe first)
     result.context = contextResults.sort((a, b) => {
       const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
@@ -107,14 +119,17 @@ export async function analyzeUnified(
 
   // Run consistency analysis
   if (tools.includes('consistency')) {
-    const report = await analyzeConsistency({
+    // Use config fields if present, fallback to defaults
+    const consistencyOptions = {
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
-      checkNaming: true,
-      checkPatterns: true,
-      minSeverity: 'info',
-    });
+      ...(options.consistency || {}),
+    };
+    const report = await analyzeConsistency(consistencyOptions);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: 'consistency', data: report });
+    }
     // Sort consistency results by severity
     if (report.results) {
       report.results = sortBySeverity(report.results);
@@ -135,11 +150,11 @@ export function generateUnifiedSummary(result: UnifiedAnalysisResult): string {
   output += `   Total issues found: ${summary.totalIssues}\n`;
   output += `   Execution time: ${(summary.executionTime / 1000).toFixed(2)}s\n\n`;
 
-  if (result.patterns?.length) {
+  if (result.patterns) {
     output += `🔍 Pattern Analysis: ${result.patterns.length} issues\n`;
   }
 
-  if (result.context?.length) {
+  if (result.context) {
     output += `🧠 Context Analysis: ${result.context.length} issues\n`;
   }
 

package/dist/chunk-KZKXZKES.mjs

@@ -1,54 +0,0 @@
-// src/index.ts
-import { analyzePatterns } from "@aiready/pattern-detect";
-import { analyzeContext } from "@aiready/context-analyzer";
-async function analyzeUnified(options) {
-  const startTime = Date.now();
-  const tools = options.tools || ["patterns", "context"];
-  const result = {
-    summary: {
-      totalIssues: 0,
-      toolsRun: tools,
-      executionTime: 0
-    }
-  };
-  if (tools.includes("patterns")) {
-    const patternResult = await analyzePatterns(options);
-    result.patterns = patternResult.results;
-    result.summary.totalIssues += patternResult.results.length;
-  }
-  if (tools.includes("context")) {
-    result.context = await analyzeContext(options);
-    result.summary.totalIssues += result.context?.length || 0;
-  }
-  result.summary.executionTime = Date.now() - startTime;
-  return result;
-}
-function generateUnifiedSummary(result) {
-  const { summary } = result;
-  let output = `\u{1F680} AIReady Analysis Complete
-
-`;
-  output += `\u{1F4CA} Summary:
-`;
-  output += `   Tools run: ${summary.toolsRun.join(", ")}
-`;
-  output += `   Total issues found: ${summary.totalIssues}
-`;
-  output += `   Execution time: ${(summary.executionTime / 1e3).toFixed(2)}s
-
-`;
-  if (result.patterns?.length) {
-    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
-`;
-  }
-  if (result.context?.length) {
-    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
-`;
-  }
-  return output;
-}
-
-export {
-  analyzeUnified,
-  generateUnifiedSummary
-};