@aiready/cli 0.9.38 → 0.9.40

package/dist/chunk-PDOONNSK.mjs

@@ -0,0 +1,228 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { analyzePatterns } from "@aiready/pattern-detect";
+import { analyzeContext } from "@aiready/context-analyzer";
+import { analyzeConsistency } from "@aiready/consistency";
+var severityOrder = {
+  critical: 4,
+  major: 3,
+  minor: 2,
+  info: 1
+};
+function sortBySeverity(results) {
+  return results.map((file) => {
+    const sortedIssues = [...file.issues].sort((a, b) => {
+      const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
+      if (severityDiff !== 0) return severityDiff;
+      return (a.location?.line || 0) - (b.location?.line || 0);
+    });
+    return { ...file, issues: sortedIssues };
+  }).sort((a, b) => {
+    const aMaxSeverity = Math.max(...a.issues.map((i) => severityOrder[i.severity] || 0), 0);
+    const bMaxSeverity = Math.max(...b.issues.map((i) => severityOrder[i.severity] || 0), 0);
+    if (aMaxSeverity !== bMaxSeverity) {
+      return bMaxSeverity - aMaxSeverity;
+    }
+    if (a.issues.length !== b.issues.length) {
+      return b.issues.length - a.issues.length;
+    }
+    return a.fileName.localeCompare(b.fileName);
+  });
+}
+async function analyzeUnified(options) {
+  const startTime = Date.now();
+  const tools = options.tools || ["patterns", "context", "consistency"];
+  const result = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: tools,
+      executionTime: 0
+    }
+  };
+  if (tools.includes("patterns")) {
+    const patternResult = await 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(
+      (sum, file) => sum + file.issues.length,
+      0
+    );
+  }
+  if (tools.includes("context")) {
+    const contextResults = await 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;
+      if (a.tokenCost !== b.tokenCost) return b.tokenCost - a.tokenCost;
+      return b.fragmentationScore - a.fragmentationScore;
+    });
+    result.summary.totalIssues += result.context?.length || 0;
+  }
+  if (tools.includes("consistency")) {
+    const consistencyOptions = {
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude,
+      ...options.consistency || {}
+    };
+    const report = await analyzeConsistency(consistencyOptions);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "consistency", data: report });
+    }
+    if (report.results) {
+      report.results = sortBySeverity(report.results);
+    }
+    result.consistency = report;
+    result.summary.totalIssues += report.summary.totalIssues;
+  }
+  if (tools.includes("doc-drift")) {
+    const { analyzeDocDrift } = await import("@aiready/doc-drift");
+    const report = await analyzeDocDrift({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "doc-drift", data: report });
+    }
+    result.docDrift = report;
+    result.summary.totalIssues += report.issues?.length || 0;
+  }
+  if (tools.includes("deps-health")) {
+    const { analyzeDeps } = await import("@aiready/deps");
+    const report = await analyzeDeps({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "deps-health", data: report });
+    }
+    result.deps = report;
+    result.summary.totalIssues += report.issues?.length || 0;
+  }
+  if (tools.includes("aiSignalClarity")) {
+    const { analyzeAiSignalClarity } = await import("@aiready/ai-signal-clarity");
+    const report = await analyzeAiSignalClarity({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "aiSignalClarity", data: report });
+    }
+    result.aiSignalClarity = report;
+    result.summary.totalIssues += report.results?.reduce((sum, r) => sum + (r.issues?.length || 0), 0) || 0;
+  }
+  if (tools.includes("grounding")) {
+    const { analyzeAgentGrounding } = await import("@aiready/agent-grounding");
+    const report = await analyzeAgentGrounding({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "grounding", data: report });
+    }
+    result.grounding = report;
+    result.summary.totalIssues += report.issues?.length || 0;
+  }
+  if (tools.includes("testability")) {
+    const { analyzeTestability } = await import("@aiready/testability");
+    const report = await analyzeTestability({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "testability", data: report });
+    }
+    result.testability = report;
+    result.summary.totalIssues += report.issues?.length || 0;
+  }
+  if (tools.includes("changeAmplification")) {
+    const { analyzeChangeAmplification } = await import("@aiready/change-amplification");
+    const report = await analyzeChangeAmplification({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "changeAmplification", data: report });
+    }
+    result.changeAmplification = report;
+    result.summary.totalIssues += report.summary?.totalIssues || 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) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
+`;
+  }
+  if (result.consistency) {
+    output += `\u{1F3F7}\uFE0F Consistency Analysis: ${result.consistency.summary.totalIssues} issues
+`;
+  }
+  if (result.docDrift) {
+    output += `\u{1F4DD} Doc Drift Analysis: ${result.docDrift.issues?.length || 0} issues
+`;
+  }
+  if (result.deps) {
+    output += `\u{1F4E6} Dependency Health: ${result.deps.issues?.length || 0} issues
+`;
+  }
+  if (result.aiSignalClarity) {
+    output += `\u{1F9E0} AI Signal Clarity: ${result.aiSignalClarity.summary?.totalSignals || 0} signals
+`;
+  }
+  if (result.grounding) {
+    output += `\u{1F9ED} Agent Grounding: ${result.grounding.issues?.length || 0} issues
+`;
+  }
+  if (result.testability) {
+    output += `\u{1F9EA} Testability Index: ${result.testability.issues?.length || 0} issues
+`;
+  }
+  if (result.changeAmplification) {
+    output += `\u{1F4A5} Change Amplification: ${result.changeAmplification.summary?.totalIssues || 0} cascading risks
+`;
+  }
+  return output;
+}
+
+export {
+  __require,
+  analyzeUnified,
+  generateUnifiedSummary
+};

package/dist/cli.js

@@ -143,17 +143,17 @@ async function analyzeUnified(options) {
     result.deps = report;
     result.summary.totalIssues += report.issues?.length || 0;
   }
-  if (tools.includes("hallucination")) {
-    const { analyzeHallucinationRisk } = await import("@aiready/hallucination-risk");
-    const report = await analyzeHallucinationRisk({
+  if (tools.includes("aiSignalClarity")) {
+    const { analyzeAiSignalClarity } = await import("@aiready/ai-signal-clarity");
+    const report = await analyzeAiSignalClarity({
       rootDir: options.rootDir,
       include: options.include,
       exclude: options.exclude
     });
     if (options.progressCallback) {
-      options.progressCallback({ tool: "hallucination", data: report });
+      options.progressCallback({ tool: "aiSignalClarity", data: report });
     }
-    result.hallucination = report;
+    result.aiSignalClarity = report;
     result.summary.totalIssues += report.results?.reduce((sum, r) => sum + (r.issues?.length || 0), 0) || 0;
   }
   if (tools.includes("grounding")) {
@@ -182,6 +182,19 @@ async function analyzeUnified(options) {
     result.testability = report;
     result.summary.totalIssues += report.issues?.length || 0;
   }
+  if (tools.includes("changeAmplification")) {
+    const { analyzeChangeAmplification } = await import("@aiready/change-amplification");
+    const report = await analyzeChangeAmplification({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "changeAmplification", data: report });
+    }
+    result.changeAmplification = report;
+    result.summary.totalIssues += report.summary?.totalIssues || 0;
+  }
   result.summary.executionTime = Date.now() - startTime;
   return result;
 }
@@ -298,19 +311,23 @@ async function scanAction(directory, options) {
   const resolvedDir = (0, import_path2.resolve)(process.cwd(), directory || ".");
   try {
     const defaults = {
-      tools: ["patterns", "context", "consistency", "hallucination", "grounding", "testability", "doc-drift", "deps-health"],
+      tools: ["patterns", "context", "consistency", "aiSignalClarity", "grounding", "testability", "doc-drift", "deps-health", "changeAmplification"],
       include: void 0,
       exclude: void 0,
       output: {
-        format: "json",
+        format: "console",
         file: void 0
       }
     };
-    let profileTools = options.tools ? options.tools.split(",").map((t) => t.trim()) : void 0;
+    let profileTools = options.tools ? options.tools.split(",").map((t) => {
+      const tool = t.trim();
+      if (tool === "hallucination" || tool === "hallucination-risk") return "aiSignalClarity";
+      return tool;
+    }) : void 0;
     if (options.profile) {
       switch (options.profile.toLowerCase()) {
         case "agentic":
-          profileTools = ["hallucination", "grounding", "testability"];
+          profileTools = ["aiSignalClarity", "grounding", "testability"];
           break;
         case "cost":
           profileTools = ["patterns", "context"];
@@ -326,11 +343,14 @@ async function scanAction(directory, options) {
 \u26A0\uFE0F  Unknown profile '${options.profile}'. Using specified tools or defaults.`));
       }
     }
-    const baseOptions = await (0, import_core.loadMergedConfig)(resolvedDir, defaults, {
-      tools: profileTools,
+    const cliOverrides = {
       include: options.include?.split(","),
       exclude: options.exclude?.split(",")
-    });
+    };
+    if (profileTools) {
+      cliOverrides.tools = profileTools;
+    }
+    const baseOptions = await (0, import_core.loadMergedConfig)(resolvedDir, defaults, cliOverrides);
     let finalOptions = { ...baseOptions };
     if (baseOptions.tools.includes("patterns")) {
       const { getSmartDefaults } = await import("@aiready/pattern-detect");
@@ -473,6 +493,12 @@ async function scanAction(directory, options) {
             console.log(`  Deprecated Packages: ${import_chalk2.default.bold(dr.rawData.deprecatedPackages || 0)}`);
             console.log(`  AI Cutoff Skew Score: ${import_chalk2.default.bold(dr.rawData.trainingCutoffSkew?.toFixed(1) || 0)}`);
           }
+        } else if (event.tool === "change-amplification" || event.tool === "changeAmplification") {
+          const dr = event.data;
+          console.log(`  Coupling issues: ${import_chalk2.default.bold(String(dr.issues?.length || 0))}`);
+          if (dr.summary) {
+            console.log(`  Complexity Score: ${import_chalk2.default.bold(dr.summary.score || 0)}/100`);
+          }
         }
       } catch (err) {
       }
@@ -485,7 +511,8 @@ async function scanAction(directory, options) {
     if (results.duplicates) console.log(`  Duplicate patterns found: ${import_chalk2.default.bold(String(results.duplicates.length || 0))}`);
     if (results.patterns) console.log(`  Pattern files with issues: ${import_chalk2.default.bold(String(results.patterns.length || 0))}`);
     if (results.context) console.log(`  Context issues: ${import_chalk2.default.bold(String(results.context.length || 0))}`);
-    if (results.consistency) console.log(`  Consistency issues: ${import_chalk2.default.bold(String(results.consistency.summary.totalIssues || 0))}`);
+    console.log(`  Consistency issues: ${import_chalk2.default.bold(String(results.consistency?.summary?.totalIssues || 0))}`);
+    if (results.changeAmplification) console.log(`  Change amplification: ${import_chalk2.default.bold(String(results.changeAmplification.summary?.score || 0))}/100`);
     console.log(import_chalk2.default.cyan("===========================\n"));
     const elapsedTime = (0, import_core.getElapsedTime)(startTime);
     let scoringResult;
@@ -518,11 +545,11 @@ async function scanAction(directory, options) {
         } catch (err) {
         }
       }
-      if (results.hallucination) {
-        const { calculateHallucinationScore } = await import("@aiready/hallucination-risk");
+      if (results.aiSignalClarity) {
+        const { calculateAiSignalClarityScore } = await import("@aiready/ai-signal-clarity");
         try {
-          const hrScore = calculateHallucinationScore(results.hallucination);
-          toolScores.set("hallucination-risk", hrScore);
+          const hrScore = calculateAiSignalClarityScore(results.aiSignalClarity);
+          toolScores.set("ai-signal-clarity", hrScore);
         } catch (err) {
         }
       }
@@ -548,7 +575,7 @@ async function scanAction(directory, options) {
           score: results.docDrift.summary.score,
           rawMetrics: results.docDrift.rawData,
           factors: [],
-          recommendations: results.docDrift.recommendations.map((action) => ({ action, estimatedImpact: 5, priority: "medium" }))
+          recommendations: (results.docDrift.recommendations || []).map((action) => ({ action, estimatedImpact: 5, priority: "medium" }))
         });
       }
       if (results.deps) {
@@ -557,7 +584,16 @@ async function scanAction(directory, options) {
           score: results.deps.summary.score,
           rawMetrics: results.deps.rawData,
           factors: [],
-          recommendations: results.deps.recommendations.map((action) => ({ action, estimatedImpact: 5, priority: "medium" }))
+          recommendations: (results.deps.recommendations || []).map((action) => ({ action, estimatedImpact: 5, priority: "medium" }))
+        });
+      }
+      if (results.changeAmplification) {
+        toolScores.set("change-amplification", {
+          toolName: "change-amplification",
+          score: results.changeAmplification.summary.score,
+          rawMetrics: results.changeAmplification.rawData,
+          factors: [],
+          recommendations: (results.changeAmplification.recommendations || []).map((action) => ({ action, estimatedImpact: 5, priority: "medium" }))
         });
       }
       const cliWeights = (0, import_core.parseWeightString)(options.weights);
@@ -621,6 +657,17 @@ async function scanAction(directory, options) {
       const outputData = { ...results, scoring: scoringResult };
       (0, import_core.handleJSONOutput)(outputData, outputPath, `\u2705 Report saved to ${outputPath}`);
       warnIfGraphCapExceeded(outputData, resolvedDir);
+    } else {
+      const timestamp = getReportTimestamp();
+      const defaultFilename = `aiready-report-${timestamp}.json`;
+      const outputPath = (0, import_core.resolveOutputPath)(userOutputFile, defaultFilename, resolvedDir);
+      const outputData = { ...results, scoring: scoringResult };
+      try {
+        (0, import_fs2.writeFileSync)(outputPath, JSON.stringify(outputData, null, 2));
+        console.log(import_chalk2.default.dim(`\u2705 Report auto-persisted to ${outputPath}`));
+        warnIfGraphCapExceeded(outputData, resolvedDir);
+      } catch (err) {
+      }
     }
     const isCI = options.ci || process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
     if (isCI && scoringResult) {
@@ -724,7 +771,7 @@ EXAMPLES:
   $ aiready scan --output json --output-file report.json
 
 PROFILES:
-  agentic:      hallucination, grounding, testability
+  agentic:      aiSignalClarity, grounding, testability
   cost:         patterns, context
   security:     consistency, testability
   onboarding:   context, consistency, grounding
@@ -1357,7 +1404,7 @@ NOTES:
   - Same options as 'visualize'. Use --serve to host the static HTML, or --dev for live reload.
 `;
 
-// src/commands/hallucination-risk.ts
+// src/commands/ai-signal-clarity.ts
 var import_chalk7 = __toESM(require("chalk"));
 var import_core7 = require("@aiready/core");
 
@@ -1369,6 +1416,9 @@ var import_core8 = require("@aiready/core");
 var import_chalk9 = __toESM(require("chalk"));
 var import_core9 = require("@aiready/core");
 
+// src/commands/change-amplification.ts
+var import_cli = require("@aiready/change-amplification/dist/cli.js");
+
 // src/cli.ts
 var import_meta = {};
 var getDirname = () => {
@@ -1383,11 +1433,11 @@ AI READINESS SCORING:
   Use --score flag with any analysis command for detailed breakdown.
 
 EXAMPLES:
-  $ aiready scan                          # Quick analysis of current directory
+  $ aiready scan                          # Comprehensive 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
+  $ npx @aiready/cli scan                 # Industry standard way to run standard scan
+  $ aiready scan --output json            # Output raw JSON for piping
 
 GETTING STARTED:
   1. Run 'aiready scan' to analyze your codebase
@@ -1413,7 +1463,7 @@ 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,hallucination,grounding,testability)").option("--profile <type>", "Scan profile to use (agentic, cost, security, onboarding)").option("--compare-to <path>", "Compare results against a previous AIReady report JSON").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", "json").option("--output-file <path>", "Output file path (for json)").option("--no-score", "Disable calculating AI Readiness Score (enabled by default)").option("--weights <weights>", "Custom scoring weights").option("--threshold <score>", "Fail CI/CD if score below threshold (0-100)").option("--ci", "CI mode: GitHub Actions annotations, no colors, fail on threshold").option("--fail-on <level>", "Fail on issues: critical, major, any", "critical").addHelpText("after", scanHelpText).action(async (directory, options) => {
+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,doc-drift,deps-health,aiSignalClarity,grounding,testability,changeAmplification)").option("--profile <type>", "Scan profile to use (agentic, cost, security, onboarding)").option("--compare-to <path>", "Compare results against a previous AIReady report JSON").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("--no-score", "Disable calculating AI Readiness Score (enabled by default)").option("--weights <weights>", "Custom scoring weights").option("--threshold <score>", "Fail CI/CD if score below threshold (0-100)").option("--ci", "CI mode: GitHub Actions annotations, no colors, fail on threshold").option("--fail-on <level>", "Fail on issues: critical, major, any", "critical").addHelpText("after", scanHelpText).action(async (directory, options) => {
   await scanAction(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", patternsHelpText).action(async (directory, options) => {
@@ -1431,4 +1481,7 @@ program.command("visualise").description("Alias for visualize (British spelling)
 program.command("visualize").description("Generate interactive visualization from an AIReady report").argument("[directory]", "Directory to analyze", ".").option("--report <path>", "Report path (auto-detects latest .aiready/aiready-report-*.json if not provided)").option("-o, --output <path>", "Output HTML path (relative to directory)", "packages/visualizer/visualization.html").option("--open", "Open generated HTML in default browser").option("--serve [port]", "Start a local static server to serve the visualization (optional port number)", false).option("--dev", "Start Vite dev server (live reload) for interactive development", false).addHelpText("after", visualizeHelpText).action(async (directory, options) => {
   await visualizeAction(directory, options);
 });
+program.command("change-amplification").description("Analyze graph metrics for change amplification").argument("[directory]", "Directory to analyze", ".").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)").action(async (directory, options) => {
+  await (0, import_cli.changeAmplificationAction)(directory, options);
+});
 program.parse();