@aiready/cli 0.7.19 → 0.7.21

package/dist/cli.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 import {
-  analyzeUnified,
-  generateUnifiedSummary
-} from "./chunk-P3XAXCTK.mjs";
+  analyzeUnified
+} from "./chunk-3SG2GLFJ.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -16,15 +15,58 @@ import {
   getElapsedTime,
   resolveOutputPath,
   calculateOverallScore,
+  formatScore,
   formatToolScore,
+  getRating,
   getRatingDisplay,
   parseWeightString
 } from "@aiready/core";
 import { readFileSync } from "fs";
 var packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf8"));
 var program = new Command();
-program.name("aiready").description("AIReady - Unified AI-readiness analysis tools").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");
-program.command("scan").description("Run unified analysis on a codebase").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)").action(async (directory, options) => {
+program.name("aiready").description("AIReady - Assess and improve AI-readiness of codebases").version(packageJson.version).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 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) 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("\u{1F680} Starting AIReady unified analysis...\n"));
   const startTime = Date.now();
   try {
@@ -46,103 +88,210 @@ program.command("scan").description("Run unified analysis on a codebase").argume
     if (baseOptions.tools.includes("patterns")) {
       const { getSmartDefaults } = await import("@aiready/pattern-detect");
       const patternSmartDefaults = await getSmartDefaults(directory, baseOptions);
-      finalOptions = { ...patternSmartDefaults, ...finalOptions };
+      finalOptions = { ...patternSmartDefaults, ...finalOptions, ...baseOptions };
+    }
+    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, 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)` : "");
+    };
+    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.severity,
+        includeTests: finalOptions.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 !== void 0) console.log(`  approx: ${chalk.bold(String(pd.approx))}`);
+      if (pd.minSharedTokens !== void 0) console.log(`  minSharedTokens: ${chalk.bold(String(pd.minSharedTokens))}`);
+      if (pd.maxCandidatesPerBlock !== void 0) console.log(`  maxCandidatesPerBlock: ${chalk.bold(String(pd.maxCandidatesPerBlock))}`);
+      if (pd.batchSize !== void 0) console.log(`  batchSize: ${chalk.bold(String(pd.batchSize))}`);
+      if (pd.streamResults !== void 0) console.log(`  streamResults: ${chalk.bold(String(pd.streamResults))}`);
+      if (pd.severity !== void 0) console.log(`  severity: ${chalk.bold(String(pd.severity))}`);
+      if (pd.includeTests !== void 0) 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.minCohesion,
+        maxFragmentation: finalOptions.maxFragmentation,
+        includeNodeModules: finalOptions.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 !== void 0) console.log(`  minCohesion: ${chalk.bold(String(ca.minCohesion))}`);
+      if (ca.maxFragmentation !== void 0) console.log(`  maxFragmentation: ${chalk.bold(String(ca.maxFragmentation))}`);
+      if (ca.includeNodeModules !== void 0) 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..."));
+    const progressCallback = (event) => {
+      console.log(chalk.cyan(`
+--- ${event.tool.toUpperCase()} RESULTS ---`));
+      try {
+        if (event.tool === "patterns") {
+          const pr = event.data;
+          console.log(`  Duplicate patterns: ${chalk.bold(String(pr.duplicates?.length || 0))}`);
+          console.log(`  Files with pattern issues: ${chalk.bold(String(pr.results?.length || 0))}`);
+          if (pr.duplicates && pr.duplicates.length > 0) {
+            pr.duplicates.slice(0, 5).forEach((d, i) => {
+              console.log(`   ${i + 1}. ${d.file1.split("/").pop()} \u2194 ${d.file2.split("/").pop()} (sim=${(d.similarity * 100).toFixed(1)}%)`);
+            });
+          }
+          if (pr.results && pr.results.length > 0) {
+            console.log(`  Top files with pattern issues:`);
+            const sortedByIssues = [...pr.results].sort((a, b) => (b.issues?.length || 0) - (a.issues?.length || 0));
+            sortedByIssues.slice(0, 5).forEach((r, i) => {
+              console.log(`   ${i + 1}. ${r.fileName.split("/").pop()} - ${r.issues.length} issue(s)`);
+            });
+          }
+          if (pr.groups && pr.groups.length >= 0) {
+            console.log(`  \u2705 Grouped ${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(`  \u2705 Created ${chalk.bold(String(pr.clusters.length))} refactor clusters`);
+            pr.clusters.slice(0, 3).forEach((cl, idx) => {
+              const files = (cl.files || []).map((f) => f.path.split("/").pop()).join(", ");
+              console.log(`   ${idx + 1}. ${files} (${cl.tokenCost || "n/a"} tokens)`);
+            });
+          }
+        } else if (event.tool === "context") {
+          const cr = event.data;
+          console.log(`  Context issues found: ${chalk.bold(String(cr.length || 0))}`);
+          cr.slice(0, 5).forEach((c, i) => {
+            const msg = c.message ? ` - ${c.message}` : "";
+            console.log(`   ${i + 1}. ${c.file} (${c.severity || "n/a"})${msg}`);
+          });
+        } else if (event.tool === "consistency") {
+          const rep = event.data;
+          console.log(`  Consistency totalIssues: ${chalk.bold(String(rep.summary?.totalIssues || 0))}`);
+          if (rep.results && rep.results.length > 0) {
+            const fileMap = /* @__PURE__ */ new Map();
+            rep.results.forEach((r) => {
+              (r.issues || []).forEach((issue) => {
+                const file = issue.location?.file || r.file || "unknown";
+                if (!fileMap.has(file)) fileMap.set(file, []);
+                fileMap.get(file).push(issue);
+              });
+            });
+            const files = Array.from(fileMap.entries()).sort((a, b) => b[1].length - a[1].length);
+            const topFiles = files.slice(0, 10);
+            topFiles.forEach(([file, issues], idx) => {
+              const counts = issues.reduce((acc, it) => {
+                const s = (it.severity || "info").toLowerCase();
+                acc[s] = (acc[s] || 0) + 1;
+                return acc;
+              }, {});
+              const sample = issues.find((it) => it.severity === "critical" || it.severity === "major") || issues[0];
+              const sampleMsg = sample ? ` \u2014 ${sample.message}` : "";
+              console.log(`   ${idx + 1}. ${file} \u2014 ${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) {
+      }
+    };
+    const results = await analyzeUnified({ ...finalOptions, progressCallback, suppressToolConfig: true });
+    console.log(chalk.cyan("\n=== AIReady Run Summary ==="));
+    console.log(chalk.white("Tools run:"), (finalOptions.tools || ["patterns", "context", "consistency"]).join(", "));
+    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);
     let scoringResult;
     if (options.score || finalOptions.scoring?.showBreakdown) {
       const toolScores = /* @__PURE__ */ new Map();
-      if (results.patterns && baseOptions.tools.includes("patterns")) {
+      if (results.duplicates) {
         const { calculatePatternScore } = await import("@aiready/pattern-detect");
-        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) {
+        }
       }
-      if (results.context && baseOptions.tools.includes("context")) {
-        const { calculateContextScore } = await import("@aiready/context-analyzer");
-        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);
-        toolScores.set("context-analyzer", 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) {
+        }
       }
-      if (results.consistency && baseOptions.tools.includes("consistency")) {
+      if (results.consistency) {
         const { calculateConsistencyScore } = await import("@aiready/consistency");
-        const issues = results.consistency.results?.flatMap((r) => r.issues) || [];
-        const score = calculateConsistencyScore(issues, results.consistency.summary.filesAnalyzed);
-        toolScores.set("consistency", score);
-      }
-      const cliWeights = options.weights ? parseWeightString(options.weights) : void 0;
-      scoringResult = calculateOverallScore(toolScores, finalOptions, cliWeights);
-      if (options.threshold) {
-        const threshold = parseFloat(options.threshold);
-        if (scoringResult.overall < threshold) {
-          console.error(chalk.red(`
-\u274C Score ${scoringResult.overall} is below threshold ${threshold}
-`));
-          process.exit(1);
+        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) {
         }
       }
-    }
-    const outputFormat = options.output || finalOptions.output?.format || "console";
-    const userOutputFile = options.outputFile || finalOptions.output?.file;
-    if (outputFormat === "json") {
-      const outputData = {
-        ...results,
-        summary: {
-          ...results.summary,
-          executionTime: parseFloat(elapsedTime)
-        },
-        ...scoringResult && { scoring: scoringResult }
-      };
-      const outputPath = resolveOutputPath(
-        userOutputFile,
-        `aiready-scan-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.json`,
-        directory
-      );
-      handleJSONOutput(outputData, outputPath, `\u2705 Results saved to ${outputPath}`);
-    } else {
-      console.log(generateUnifiedSummary(results));
-      if (scoringResult) {
-        const terminalWidth = process.stdout.columns || 80;
-        const dividerWidth = Math.min(60, terminalWidth - 2);
-        const divider = "\u2501".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()}
-`);
-        if (scoringResult.breakdown.length > 0) {
-          console.log(chalk.bold("  Component Scores:\n"));
+      const cliWeights = parseWeightString(options.weights);
+      if (toolScores.size > 0) {
+        scoringResult = calculateOverallScore(toolScores, finalOptions, cliWeights.size ? cliWeights : void 0);
+        console.log(chalk.bold("\n\u{1F4CA} AI Readiness Overall Score"));
+        console.log(`  ${formatScore(scoringResult)}`);
+        if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
+          console.log(chalk.bold("\nTool breakdown:"));
           scoringResult.breakdown.forEach((tool) => {
-            const toolEmoji = tool.toolName === "pattern-detect" ? "\u{1F50D}" : tool.toolName === "context-analyzer" ? "\u{1F9E0}" : "\u{1F3F7}\uFE0F";
-            const weight = scoringResult.calculation.weights[tool.toolName];
-            console.log(`  ${toolEmoji} ${chalk.white(tool.toolName.padEnd(20))} ${scoreColor(tool.score + "/100")} ${chalk.dim(`(weight: ${weight})`)}`);
+            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();
+          }
         }
-        console.log(chalk.dim(`  Weighted Formula: ${scoringResult.calculation.formula}`));
-        console.log(chalk.dim(`  Normalized Score: ${scoringResult.calculation.normalized}
-`));
-        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" ? "\u{1F534}" : rec.priority === "medium" ? "\u{1F7E1}" : "\u{1F535}";
-            console.log(`  ${i + 1}. ${priorityIcon} ${rec.action}`);
-            console.log(`     ${chalk.dim(`Impact: +${rec.estimatedImpact} points`)}
-`);
-          });
+        const outputFormat = options.output || finalOptions.output?.format || "console";
+        const userOutputFile = options.outputFile || finalOptions.output?.file;
+        if (outputFormat === "json") {
+          const dateStr = (/* @__PURE__ */ 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, `\u2705 Summary saved to ${outputPath}`);
         }
       }
     }
@@ -150,7 +299,12 @@ program.command("scan").description("Run unified analysis on a codebase").argume
     handleCLIError(error, "Analysis");
   }
 });
-program.command("patterns").description("Run pattern detection analysis").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("--max-candidates <number>", "Maximum candidates per block (performance tuning)").option("--min-shared-tokens <number>", "Minimum shared tokens for candidates (performance tuning)").option("--full-scan", "Disable smart defaults for comprehensive analysis (slower)").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 for patterns (0-100)").action(async (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("--max-candidates <number>", "Maximum candidates per block (performance tuning)").option("--min-shared-tokens <number>", "Minimum shared tokens for candidates (performance tuning)").option("--full-scan", "Disable smart defaults for comprehensive analysis (slower)").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 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("\u{1F50D} Analyzing patterns...\n"));
   const startTime = Date.now();
   try {
@@ -254,7 +408,7 @@ program.command("patterns").description("Run pattern detection analysis").argume
     handleCLIError(error, "Pattern analysis");
   }
 });
-program.command("context").description("Run context window cost analysis").argument("[directory]", "Directory to analyze", ".").option("--max-depth <number>", "Maximum acceptable import depth", "5").option("--max-context <number>", "Maximum acceptable context budget (tokens)", "10000").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 for context (0-100)").action(async (directory, options) => {
+program.command("context").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").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 for context (0-100)").action(async (directory, options) => {
   console.log(chalk.blue("\u{1F9E0} Analyzing context costs...\n"));
   const startTime = Date.now();
   try {
@@ -391,7 +545,7 @@ program.command("context").description("Run context window cost analysis").argum
     handleCLIError(error, "Context analysis");
   }
 });
-program.command("consistency").description("Check naming, patterns, and architecture consistency").argument("[directory]", "Directory to analyze", ".").option("--naming", "Check naming conventions (default: true)").option("--no-naming", "Skip naming analysis").option("--patterns", "Check code patterns (default: true)").option("--no-patterns", "Skip pattern analysis").option("--min-severity <level>", "Minimum severity: info|minor|major|critical", "info").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, markdown", "console").option("--output-file <path>", "Output file path (for json/markdown)").option("--score", "Calculate and display AI Readiness Score for consistency (0-100)").action(async (directory, options) => {
+program.command("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").option("--patterns", "Check code patterns (default: true)").option("--no-patterns", "Skip pattern analysis").option("--min-severity <level>", "Minimum severity: info|minor|major|critical", "info").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, markdown", "console").option("--output-file <path>", "Output file path (for json/markdown)").option("--score", "Calculate and display AI Readiness Score for consistency (0-100)").action(async (directory, options) => {
   console.log(chalk.blue("\u{1F50D} Analyzing consistency...\n"));
   const startTime = Date.now();
   try {

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import { ScanOptions, AnalysisResult } from '@aiready/core';
 import { ContextAnalysisResult } from '@aiready/context-analyzer';
 import { DuplicatePattern } from '@aiready/pattern-detect';
-import { ConsistencyReport } from '@aiready/consistency';
+import { ConsistencyOptions, ConsistencyReport } from '@aiready/consistency';
 
 interface UnifiedAnalysisOptions extends ScanOptions {
     tools?: ('patterns' | 'context' | 'consistency')[];
@@ -10,6 +10,11 @@ interface UnifiedAnalysisOptions extends ScanOptions {
     maxCandidatesPerBlock?: number;
     minSharedTokens?: number;
     useSmartDefaults?: boolean;
+    consistency?: Partial<ConsistencyOptions>;
+    progressCallback?: (event: {
+        tool: string;
+        data: any;
+    }) => void;
 }
 interface UnifiedAnalysisResult {
     patterns?: AnalysisResult[];

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { ScanOptions, AnalysisResult } from '@aiready/core';
 import { ContextAnalysisResult } from '@aiready/context-analyzer';
 import { DuplicatePattern } from '@aiready/pattern-detect';
-import { ConsistencyReport } from '@aiready/consistency';
+import { ConsistencyOptions, ConsistencyReport } from '@aiready/consistency';
 
 interface UnifiedAnalysisOptions extends ScanOptions {
     tools?: ('patterns' | 'context' | 'consistency')[];
@@ -10,6 +10,11 @@ interface UnifiedAnalysisOptions extends ScanOptions {
     maxCandidatesPerBlock?: number;
     minSharedTokens?: number;
     useSmartDefaults?: boolean;
+    consistency?: Partial<ConsistencyOptions>;
+    progressCallback?: (event: {
+        tool: string;
+        data: any;
+    }) => void;
 }
 interface UnifiedAnalysisResult {
     patterns?: AnalysisResult[];

package/dist/index.js

@@ -65,6 +65,9 @@ async function analyzeUnified(options) {
   };
   if (tools.includes("patterns")) {
     const patternResult = await (0, import_pattern_detect.analyzePatterns)(options);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "patterns", data: patternResult });
+    }
     result.patterns = sortBySeverity(patternResult.results);
     result.duplicates = patternResult.duplicates;
     result.summary.totalIssues += patternResult.results.reduce(
@@ -74,6 +77,9 @@ async function analyzeUnified(options) {
   }
   if (tools.includes("context")) {
     const contextResults = await (0, import_context_analyzer.analyzeContext)(options);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "context", data: contextResults });
+    }
     result.context = contextResults.sort((a, b) => {
       const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
       if (severityDiff !== 0) return severityDiff;
@@ -83,14 +89,16 @@ async function analyzeUnified(options) {
     result.summary.totalIssues += result.context?.length || 0;
   }
   if (tools.includes("consistency")) {
-    const report = await (0, import_consistency.analyzeConsistency)({
+    const consistencyOptions = {
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude,
-      checkNaming: true,
-      checkPatterns: true,
-      minSeverity: "info"
-    });
+      ...options.consistency || {}
+    };
+    const report = await (0, import_consistency.analyzeConsistency)(consistencyOptions);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "consistency", data: report });
+    }
     if (report.results) {
       report.results = sortBySeverity(report.results);
     }
@@ -114,11 +122,11 @@ function generateUnifiedSummary(result) {
   output += `   Execution time: ${(summary.executionTime / 1e3).toFixed(2)}s
 
 `;
-  if (result.patterns?.length) {
+  if (result.patterns) {
     output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
 `;
   }
-  if (result.context?.length) {
+  if (result.context) {
     output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
 `;
   }

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {
   analyzeUnified,
   generateUnifiedSummary
-} from "./chunk-P3XAXCTK.mjs";
+} from "./chunk-3SG2GLFJ.mjs";
 export {
   analyzeUnified,
   generateUnifiedSummary

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/cli",
-  "version": "0.7.19",
+  "version": "0.7.21",
   "description": "Unified CLI for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -11,10 +11,10 @@
   "dependencies": {
     "commander": "^14.0.0",
     "chalk": "^5.3.0",
-    "@aiready/pattern-detect": "0.9.21",
-    "@aiready/core": "0.7.12",
-    "@aiready/context-analyzer": "0.7.17",
-    "@aiready/consistency": "0.6.15"
+    "@aiready/pattern-detect": "0.9.23",
+    "@aiready/core": "0.7.14",
+    "@aiready/context-analyzer": "0.7.19",
+    "@aiready/consistency": "0.6.17"
   },
   "devDependencies": {
     "tsup": "^8.3.5",