@aiready/cli 0.7.18 → 0.7.20

package/dist/cli.js

@@ -68,6 +68,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(
@@ -77,6 +80,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;
@@ -86,14 +92,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);
     }
@@ -103,34 +111,6 @@ async function analyzeUnified(options) {
   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
-`;
-  }
-  if (result.consistency) {
-    output += `\u{1F3F7}\uFE0F Consistency Analysis: ${result.consistency.summary.totalIssues} issues
-`;
-  }
-  return output;
-}
 
 // src/cli.ts
 var import_chalk = __toESM(require("chalk"));
@@ -163,103 +143,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(import_chalk.default.cyan("\n=== AIReady Run Preview ==="));
+    console.log(import_chalk.default.white("Tools to run:"), (finalOptions.tools || ["patterns", "context", "consistency"]).join(", "));
+    console.log(import_chalk.default.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(import_chalk.default.white("\nGeneral settings:"));
+    if (finalOptions.rootDir) console.log(`  rootDir: ${import_chalk.default.bold(String(finalOptions.rootDir))}`);
+    if (finalOptions.include) console.log(`  include: ${import_chalk.default.bold(truncate(finalOptions.include, 6))}`);
+    if (finalOptions.exclude) console.log(`  exclude: ${import_chalk.default.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(import_chalk.default.white("\nPattern-detect settings:"));
+      console.log(`  minSimilarity: ${import_chalk.default.bold(pd.minSimilarity ?? "default")}`);
+      console.log(`  minLines: ${import_chalk.default.bold(pd.minLines ?? "default")}`);
+      if (pd.approx !== void 0) console.log(`  approx: ${import_chalk.default.bold(String(pd.approx))}`);
+      if (pd.minSharedTokens !== void 0) console.log(`  minSharedTokens: ${import_chalk.default.bold(String(pd.minSharedTokens))}`);
+      if (pd.maxCandidatesPerBlock !== void 0) console.log(`  maxCandidatesPerBlock: ${import_chalk.default.bold(String(pd.maxCandidatesPerBlock))}`);
+      if (pd.batchSize !== void 0) console.log(`  batchSize: ${import_chalk.default.bold(String(pd.batchSize))}`);
+      if (pd.streamResults !== void 0) console.log(`  streamResults: ${import_chalk.default.bold(String(pd.streamResults))}`);
+      if (pd.severity !== void 0) console.log(`  severity: ${import_chalk.default.bold(String(pd.severity))}`);
+      if (pd.includeTests !== void 0) console.log(`  includeTests: ${import_chalk.default.bold(String(pd.includeTests))}`);
     }
-    const results = await analyzeUnified(finalOptions);
+    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(import_chalk.default.white("\nContext-analyzer settings:"));
+      console.log(`  maxDepth: ${import_chalk.default.bold(ca.maxDepth ?? "default")}`);
+      console.log(`  maxContextBudget: ${import_chalk.default.bold(ca.maxContextBudget ?? "default")}`);
+      if (ca.minCohesion !== void 0) console.log(`  minCohesion: ${import_chalk.default.bold(String(ca.minCohesion))}`);
+      if (ca.maxFragmentation !== void 0) console.log(`  maxFragmentation: ${import_chalk.default.bold(String(ca.maxFragmentation))}`);
+      if (ca.includeNodeModules !== void 0) console.log(`  includeNodeModules: ${import_chalk.default.bold(String(ca.includeNodeModules))}`);
+    }
+    if (finalOptions.consistency) {
+      const c = finalOptions.consistency;
+      console.log(import_chalk.default.white("\nConsistency settings:"));
+      console.log(`  checkNaming: ${import_chalk.default.bold(String(c.checkNaming ?? true))}`);
+      console.log(`  checkPatterns: ${import_chalk.default.bold(String(c.checkPatterns ?? true))}`);
+      console.log(`  checkArchitecture: ${import_chalk.default.bold(String(c.checkArchitecture ?? false))}`);
+      if (c.minSeverity) console.log(`  minSeverity: ${import_chalk.default.bold(c.minSeverity)}`);
+      if (c.acceptedAbbreviations) console.log(`  acceptedAbbreviations: ${import_chalk.default.bold(truncate(c.acceptedAbbreviations, 8))}`);
+      if (c.shortWords) console.log(`  shortWords: ${import_chalk.default.bold(truncate(c.shortWords, 8))}`);
+    }
+    console.log(import_chalk.default.white("\nStarting analysis..."));
+    const progressCallback = (event) => {
+      console.log(import_chalk.default.cyan(`
+--- ${event.tool.toUpperCase()} RESULTS ---`));
+      try {
+        if (event.tool === "patterns") {
+          const pr = event.data;
+          console.log(`  Duplicate patterns: ${import_chalk.default.bold(String(pr.duplicates?.length || 0))}`);
+          console.log(`  Files with pattern issues: ${import_chalk.default.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 ${import_chalk.default.bold(String(pr.duplicates?.length || 0))} duplicates into ${import_chalk.default.bold(String(pr.groups.length))} file pairs`);
+          }
+          if (pr.clusters && pr.clusters.length >= 0) {
+            console.log(`  \u2705 Created ${import_chalk.default.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: ${import_chalk.default.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: ${import_chalk.default.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(import_chalk.default.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(import_chalk.default.cyan("\n=== AIReady Run Summary ==="));
+    console.log(import_chalk.default.white("Tools run:"), (finalOptions.tools || ["patterns", "context", "consistency"]).join(", "));
+    console.log(import_chalk.default.cyan("\nResults summary:"));
+    console.log(`  Total issues (all tools): ${import_chalk.default.bold(String(results.summary.totalIssues || 0))}`);
+    if (results.duplicates) console.log(`  Duplicate patterns found: ${import_chalk.default.bold(String(results.duplicates.length || 0))}`);
+    if (results.patterns) console.log(`  Pattern files with issues: ${import_chalk.default.bold(String(results.patterns.length || 0))}`);
+    if (results.context) console.log(`  Context issues: ${import_chalk.default.bold(String(results.context.length || 0))}`);
+    if (results.consistency) console.log(`  Consistency issues: ${import_chalk.default.bold(String(results.consistency.summary.totalIssues || 0))}`);
+    console.log(import_chalk.default.cyan("===========================\n"));
     const elapsedTime = (0, import_core.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 ? (0, import_core.parseWeightString)(options.weights) : void 0;
-      scoringResult = (0, import_core.calculateOverallScore)(toolScores, finalOptions, cliWeights);
-      if (options.threshold) {
-        const threshold = parseFloat(options.threshold);
-        if (scoringResult.overall < threshold) {
-          console.error(import_chalk.default.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 = (0, import_core.resolveOutputPath)(
-        userOutputFile,
-        `aiready-scan-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.json`,
-        directory
-      );
-      (0, import_core.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(import_chalk.default.cyan("\n" + divider));
-        console.log(import_chalk.default.bold.white("  AI READINESS SCORE"));
-        console.log(import_chalk.default.cyan(divider) + "\n");
-        const { emoji, color } = (0, import_core.getRatingDisplay)(scoringResult.rating);
-        const scoreColor = color === "green" ? import_chalk.default.green : color === "blue" ? import_chalk.default.blue : color === "yellow" ? import_chalk.default.yellow : import_chalk.default.red;
-        console.log(`  ${emoji} Overall Score: ${scoreColor.bold(scoringResult.overall + "/100")} (${import_chalk.default.bold(scoringResult.rating)})`);
-        console.log(`  ${import_chalk.default.dim("Timestamp:")} ${new Date(scoringResult.timestamp).toLocaleString()}
-`);
-        if (scoringResult.breakdown.length > 0) {
-          console.log(import_chalk.default.bold("  Component Scores:\n"));
+      const cliWeights = (0, import_core.parseWeightString)(options.weights);
+      if (toolScores.size > 0) {
+        scoringResult = (0, import_core.calculateOverallScore)(toolScores, finalOptions, cliWeights.size ? cliWeights : void 0);
+        console.log(import_chalk.default.bold("\n\u{1F4CA} AI Readiness Overall Score"));
+        console.log(`  ${(0, import_core.formatScore)(scoringResult)}`);
+        if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
+          console.log(import_chalk.default.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} ${import_chalk.default.white(tool.toolName.padEnd(20))} ${scoreColor(tool.score + "/100")} ${import_chalk.default.dim(`(weight: ${weight})`)}`);
+            const rating = (0, import_core.getRating)(tool.score);
+            const rd = (0, import_core.getRatingDisplay)(rating);
+            console.log(`  - ${tool.toolName}: ${tool.score}/100 (${rating}) ${rd.emoji}`);
           });
           console.log();
+          if (finalOptions.scoring?.showBreakdown) {
+            console.log(import_chalk.default.bold("Detailed tool breakdown:"));
+            scoringResult.breakdown.forEach((tool) => {
+              console.log((0, import_core.formatToolScore)(tool));
+            });
+            console.log();
+          }
         }
-        console.log(import_chalk.default.dim(`  Weighted Formula: ${scoringResult.calculation.formula}`));
-        console.log(import_chalk.default.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(import_chalk.default.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(`     ${import_chalk.default.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 = (0, import_core.resolveOutputPath)(userOutputFile, defaultFilename, directory);
+          const outputData = { ...results, scoring: scoringResult };
+          (0, import_core.handleJSONOutput)(outputData, outputPath, `\u2705 Summary saved to ${outputPath}`);
         }
       }
     }