@aiready/cli 0.7.16 → 0.7.18

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/cli@0.7.16 build /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.7.18 build /Users/pengcao/projects/aiready/packages/cli
 > tsup src/index.ts src/cli.ts --format cjs,esm --dts
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -9,16 +9,16 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-CJS dist/index.js 4.55 KB
-CJS dist/cli.js   28.47 KB
+CJS dist/cli.js   35.44 KB
+CJS dist/index.js 4.60 KB
 CJS ⚡️ Build success in 13ms
-ESM dist/cli.mjs            22.00 KB
 ESM dist/index.mjs          138.00 B
-ESM dist/chunk-AGAMURT4.mjs 3.42 KB
+ESM dist/cli.mjs            28.57 KB
+ESM dist/chunk-P3XAXCTK.mjs 3.46 KB
 ESM ⚡️ Build success in 13ms
 DTS Build start
-DTS ⚡️ Build success in 451ms
+DTS ⚡️ Build success in 501ms
 DTS dist/cli.d.ts    20.00 B
-DTS dist/index.d.ts  991.00 B
+DTS dist/index.d.ts  1.06 KB
 DTS dist/cli.d.mts   20.00 B
-DTS dist/index.d.mts 991.00 B
+DTS dist/index.d.mts 1.06 KB

package/.turbo/turbo-test.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/cli@0.7.16 test /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.7.18 test /Users/pengcao/projects/aiready/packages/cli
 > vitest run
 
 [?25l
@@ -11,14 +11,14 @@
 
  Test Files 0 passed (1)
       Tests 0 passed (0)
-   Start at 18:01:42
+   Start at 23:10:25
    Duration 0ms
 [?2026l[?2026h
  ❯ src/__tests__/cli.test.ts 0/3
 
  Test Files 0 passed (1)
       Tests 0 passed (3)
-   Start at 18:01:42
+   Start at 23:10:25
    Duration 201ms
 [?2026l ✓ src/__tests__/cli.test.ts (3 tests) 2ms
    ✓ CLI Unified Analysis (3)
@@ -28,7 +28,7 @@
 
  Test Files  1 passed (1)
       Tests  3 passed (3)
-   Start at  18:01:42
-   Duration  278ms (transform 50ms, setup 0ms, import 205ms, tests 2ms, environment 0ms)
+   Start at  23:10:25
+   Duration  283ms (transform 53ms, setup 0ms, import 211ms, tests 2ms, environment 0ms)
 
 [?25h

package/dist/chunk-P3XAXCTK.mjs

@@ -0,0 +1,110 @@
+// 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);
+    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);
+    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 report = await analyzeConsistency({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude,
+      checkNaming: true,
+      checkPatterns: true,
+      minSeverity: "info"
+    });
+    if (report.results) {
+      report.results = sortBySeverity(report.results);
+    }
+    result.consistency = report;
+    result.summary.totalIssues += report.summary.totalIssues;
+  }
+  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;
+}
+
+export {
+  analyzeUnified,
+  generateUnifiedSummary
+};

package/dist/cli.js

@@ -69,6 +69,7 @@ async function analyzeUnified(options) {
   if (tools.includes("patterns")) {
     const patternResult = await (0, import_pattern_detect.analyzePatterns)(options);
     result.patterns = sortBySeverity(patternResult.results);
+    result.duplicates = patternResult.duplicates;
     result.summary.totalIssues += patternResult.results.reduce(
       (sum, file) => sum + file.issues.length,
       0
@@ -140,7 +141,7 @@ var import_fs2 = require("fs");
 var packageJson = JSON.parse((0, import_fs2.readFileSync)((0, import_path.join)(__dirname, "../package.json"), "utf8"));
 var program = new import_commander.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)").action(async (directory, options) => {
+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) => {
   console.log(import_chalk.default.blue("\u{1F680} Starting AIReady unified analysis...\n"));
   const startTime = Date.now();
   try {
@@ -166,6 +167,47 @@ program.command("scan").description("Run unified analysis on a codebase").argume
     }
     const results = await analyzeUnified(finalOptions);
     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")) {
+        const { calculatePatternScore } = await import("@aiready/pattern-detect");
+        const duplicates = results.duplicates || [];
+        const score = calculatePatternScore(duplicates, results.patterns.length);
+        toolScores.set("pattern-detect", score);
+      }
+      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.consistency && baseOptions.tools.includes("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);
+        }
+      }
+    }
     const outputFormat = options.output || finalOptions.output?.format || "console";
     const userOutputFile = options.outputFile || finalOptions.output?.file;
     if (outputFormat === "json") {
@@ -174,7 +216,8 @@ program.command("scan").description("Run unified analysis on a codebase").argume
         summary: {
           ...results.summary,
           executionTime: parseFloat(elapsedTime)
-        }
+        },
+        ...scoringResult && { scoring: scoringResult }
       };
       const outputPath = (0, import_core.resolveOutputPath)(
         userOutputFile,
@@ -184,12 +227,47 @@ program.command("scan").description("Run unified analysis on a codebase").argume
       (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"));
+          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})`)}`);
+          });
+          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`)}
+`);
+          });
+        }
+      }
     }
   } catch (error) {
     (0, import_core.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)").action(async (directory, options) => {
+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) => {
   console.log(import_chalk.default.blue("\u{1F50D} Analyzing patterns...\n"));
   const startTime = Date.now();
   try {
@@ -221,16 +299,21 @@ program.command("patterns").description("Run pattern detection analysis").argume
       cliOptions.minSharedTokens = parseInt(options.minSharedTokens);
     }
     const finalOptions = await (0, import_core.loadMergedConfig)(directory, defaults, cliOptions);
-    const { analyzePatterns: analyzePatterns2, generateSummary } = await import("@aiready/pattern-detect");
+    const { analyzePatterns: analyzePatterns2, generateSummary, calculatePatternScore } = await import("@aiready/pattern-detect");
     const { results, duplicates } = await analyzePatterns2(finalOptions);
     const elapsedTime = (0, import_core.getElapsedTime)(startTime);
     const summary = generateSummary(results);
+    let patternScore;
+    if (options.score) {
+      patternScore = calculatePatternScore(duplicates, results.length);
+    }
     const outputFormat = options.output || finalOptions.output?.format || "console";
     const userOutputFile = options.outputFile || finalOptions.output?.file;
     if (outputFormat === "json") {
       const outputData = {
         results,
-        summary: { ...summary, executionTime: parseFloat(elapsedTime) }
+        summary: { ...summary, executionTime: parseFloat(elapsedTime) },
+        ...patternScore && { scoring: patternScore }
       };
       const outputPath = (0, import_core.resolveOutputPath)(
         userOutputFile,
@@ -276,12 +359,19 @@ program.command("patterns").description("Run pattern detection analysis").argume
       } else {
         console.log(import_chalk.default.green("\n\u2728 Great! No duplicate patterns detected.\n"));
       }
+      if (patternScore) {
+        console.log(import_chalk.default.cyan(divider));
+        console.log(import_chalk.default.bold.white("  AI READINESS SCORE (Patterns)"));
+        console.log(import_chalk.default.cyan(divider) + "\n");
+        console.log((0, import_core.formatToolScore)(patternScore));
+        console.log();
+      }
     }
   } catch (error) {
     (0, import_core.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)").action(async (directory, options) => {
+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) => {
   console.log(import_chalk.default.blue("\u{1F9E0} Analyzing context costs...\n"));
   const startTime = Date.now();
   try {
@@ -312,16 +402,21 @@ program.command("context").description("Run context window cost analysis").argum
     console.log(`   Max fragmentation: ${(finalOptions.maxFragmentation * 100).toFixed(1)}%`);
     console.log(`   Analysis focus: ${finalOptions.focus}`);
     console.log("");
-    const { analyzeContext: analyzeContext2, generateSummary } = await import("@aiready/context-analyzer");
+    const { analyzeContext: analyzeContext2, generateSummary, calculateContextScore } = await import("@aiready/context-analyzer");
     const results = await analyzeContext2(finalOptions);
     const elapsedTime = (0, import_core.getElapsedTime)(startTime);
     const summary = generateSummary(results);
+    let contextScore;
+    if (options.score) {
+      contextScore = calculateContextScore(summary);
+    }
     const outputFormat = options.output || finalOptions.output?.format || "console";
     const userOutputFile = options.outputFile || finalOptions.output?.file;
     if (outputFormat === "json") {
       const outputData = {
         results,
-        summary: { ...summary, executionTime: parseFloat(elapsedTime) }
+        summary: { ...summary, executionTime: parseFloat(elapsedTime) },
+        ...contextScore && { scoring: contextScore }
       };
       const outputPath = (0, import_core.resolveOutputPath)(
         userOutputFile,
@@ -401,12 +496,19 @@ program.command("context").description("Run context window cost analysis").argum
         });
         console.log();
       }
+      if (contextScore) {
+        console.log(import_chalk.default.cyan(divider));
+        console.log(import_chalk.default.bold.white("  AI READINESS SCORE (Context)"));
+        console.log(import_chalk.default.cyan(divider) + "\n");
+        console.log((0, import_core.formatToolScore)(contextScore));
+        console.log();
+      }
     }
   } catch (error) {
     (0, import_core.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)").action(async (directory, options) => {
+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) => {
   console.log(import_chalk.default.blue("\u{1F50D} Analyzing consistency...\n"));
   const startTime = Date.now();
   try {
@@ -428,9 +530,14 @@ program.command("consistency").description("Check naming, patterns, and architec
       include: options.include?.split(","),
       exclude: options.exclude?.split(",")
     });
-    const { analyzeConsistency: analyzeConsistency2 } = await import("@aiready/consistency");
+    const { analyzeConsistency: analyzeConsistency2, calculateConsistencyScore } = await import("@aiready/consistency");
     const report = await analyzeConsistency2(finalOptions);
     const elapsedTime = (0, import_core.getElapsedTime)(startTime);
+    let consistencyScore;
+    if (options.score) {
+      const issues = report.results?.flatMap((r) => r.issues) || [];
+      consistencyScore = calculateConsistencyScore(issues, report.summary.filesAnalyzed);
+    }
     const outputFormat = options.output || finalOptions.output?.format || "console";
     const userOutputFile = options.outputFile || finalOptions.output?.file;
     if (outputFormat === "json") {
@@ -439,7 +546,8 @@ program.command("consistency").description("Check naming, patterns, and architec
         summary: {
           ...report.summary,
           executionTime: parseFloat(elapsedTime)
-        }
+        },
+        ...consistencyScore && { scoring: consistencyScore }
       };
       const outputPath = (0, import_core.resolveOutputPath)(
         userOutputFile,
@@ -528,6 +636,11 @@ program.command("consistency").description("Check naming, patterns, and architec
           console.log();
         }
       }
+      if (consistencyScore) {
+        console.log(import_chalk.default.bold("\n\u{1F4CA} AI Readiness Score (Consistency)\n"));
+        console.log((0, import_core.formatToolScore)(consistencyScore));
+        console.log();
+      }
     }
   } catch (error) {
     (0, import_core.handleCLIError)(error, "Consistency analysis");

package/dist/cli.mjs

@@ -2,19 +2,29 @@
 import {
   analyzeUnified,
   generateUnifiedSummary
-} from "./chunk-AGAMURT4.mjs";
+} from "./chunk-P3XAXCTK.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
 import chalk from "chalk";
 import { writeFileSync } from "fs";
 import { join } from "path";
-import { loadMergedConfig, handleJSONOutput, handleCLIError, getElapsedTime, resolveOutputPath } from "@aiready/core";
+import {
+  loadMergedConfig,
+  handleJSONOutput,
+  handleCLIError,
+  getElapsedTime,
+  resolveOutputPath,
+  calculateOverallScore,
+  formatToolScore,
+  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)").action(async (directory, options) => {
+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) => {
   console.log(chalk.blue("\u{1F680} Starting AIReady unified analysis...\n"));
   const startTime = Date.now();
   try {
@@ -40,6 +50,47 @@ program.command("scan").description("Run unified analysis on a codebase").argume
     }
     const results = await analyzeUnified(finalOptions);
     const elapsedTime = getElapsedTime(startTime);
+    let scoringResult;
+    if (options.score || finalOptions.scoring?.showBreakdown) {
+      const toolScores = /* @__PURE__ */ new Map();
+      if (results.patterns && baseOptions.tools.includes("patterns")) {
+        const { calculatePatternScore } = await import("@aiready/pattern-detect");
+        const duplicates = results.duplicates || [];
+        const score = calculatePatternScore(duplicates, results.patterns.length);
+        toolScores.set("pattern-detect", score);
+      }
+      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.consistency && baseOptions.tools.includes("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);
+        }
+      }
+    }
     const outputFormat = options.output || finalOptions.output?.format || "console";
     const userOutputFile = options.outputFile || finalOptions.output?.file;
     if (outputFormat === "json") {
@@ -48,7 +99,8 @@ program.command("scan").description("Run unified analysis on a codebase").argume
         summary: {
           ...results.summary,
           executionTime: parseFloat(elapsedTime)
-        }
+        },
+        ...scoringResult && { scoring: scoringResult }
       };
       const outputPath = resolveOutputPath(
         userOutputFile,
@@ -58,12 +110,47 @@ program.command("scan").description("Run unified analysis on a codebase").argume
       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"));
+          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})`)}`);
+          });
+          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`)}
+`);
+          });
+        }
+      }
     }
   } catch (error) {
     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)").action(async (directory, options) => {
+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) => {
   console.log(chalk.blue("\u{1F50D} Analyzing patterns...\n"));
   const startTime = Date.now();
   try {
@@ -95,16 +182,21 @@ program.command("patterns").description("Run pattern detection analysis").argume
       cliOptions.minSharedTokens = parseInt(options.minSharedTokens);
     }
     const finalOptions = await loadMergedConfig(directory, defaults, cliOptions);
-    const { analyzePatterns, generateSummary } = await import("@aiready/pattern-detect");
+    const { analyzePatterns, generateSummary, calculatePatternScore } = await import("@aiready/pattern-detect");
     const { results, duplicates } = await analyzePatterns(finalOptions);
     const elapsedTime = getElapsedTime(startTime);
     const summary = generateSummary(results);
+    let patternScore;
+    if (options.score) {
+      patternScore = calculatePatternScore(duplicates, results.length);
+    }
     const outputFormat = options.output || finalOptions.output?.format || "console";
     const userOutputFile = options.outputFile || finalOptions.output?.file;
     if (outputFormat === "json") {
       const outputData = {
         results,
-        summary: { ...summary, executionTime: parseFloat(elapsedTime) }
+        summary: { ...summary, executionTime: parseFloat(elapsedTime) },
+        ...patternScore && { scoring: patternScore }
       };
       const outputPath = resolveOutputPath(
         userOutputFile,
@@ -150,12 +242,19 @@ program.command("patterns").description("Run pattern detection analysis").argume
       } else {
         console.log(chalk.green("\n\u2728 Great! No duplicate patterns detected.\n"));
       }
+      if (patternScore) {
+        console.log(chalk.cyan(divider));
+        console.log(chalk.bold.white("  AI READINESS SCORE (Patterns)"));
+        console.log(chalk.cyan(divider) + "\n");
+        console.log(formatToolScore(patternScore));
+        console.log();
+      }
     }
   } catch (error) {
     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)").action(async (directory, options) => {
+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) => {
   console.log(chalk.blue("\u{1F9E0} Analyzing context costs...\n"));
   const startTime = Date.now();
   try {
@@ -186,16 +285,21 @@ program.command("context").description("Run context window cost analysis").argum
     console.log(`   Max fragmentation: ${(finalOptions.maxFragmentation * 100).toFixed(1)}%`);
     console.log(`   Analysis focus: ${finalOptions.focus}`);
     console.log("");
-    const { analyzeContext, generateSummary } = await import("@aiready/context-analyzer");
+    const { analyzeContext, generateSummary, calculateContextScore } = await import("@aiready/context-analyzer");
     const results = await analyzeContext(finalOptions);
     const elapsedTime = getElapsedTime(startTime);
     const summary = generateSummary(results);
+    let contextScore;
+    if (options.score) {
+      contextScore = calculateContextScore(summary);
+    }
     const outputFormat = options.output || finalOptions.output?.format || "console";
     const userOutputFile = options.outputFile || finalOptions.output?.file;
     if (outputFormat === "json") {
       const outputData = {
         results,
-        summary: { ...summary, executionTime: parseFloat(elapsedTime) }
+        summary: { ...summary, executionTime: parseFloat(elapsedTime) },
+        ...contextScore && { scoring: contextScore }
       };
       const outputPath = resolveOutputPath(
         userOutputFile,
@@ -275,12 +379,19 @@ program.command("context").description("Run context window cost analysis").argum
         });
         console.log();
       }
+      if (contextScore) {
+        console.log(chalk.cyan(divider));
+        console.log(chalk.bold.white("  AI READINESS SCORE (Context)"));
+        console.log(chalk.cyan(divider) + "\n");
+        console.log(formatToolScore(contextScore));
+        console.log();
+      }
     }
   } catch (error) {
     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)").action(async (directory, options) => {
+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) => {
   console.log(chalk.blue("\u{1F50D} Analyzing consistency...\n"));
   const startTime = Date.now();
   try {
@@ -302,9 +413,14 @@ program.command("consistency").description("Check naming, patterns, and architec
       include: options.include?.split(","),
       exclude: options.exclude?.split(",")
     });
-    const { analyzeConsistency } = await import("@aiready/consistency");
+    const { analyzeConsistency, calculateConsistencyScore } = await import("@aiready/consistency");
     const report = await analyzeConsistency(finalOptions);
     const elapsedTime = getElapsedTime(startTime);
+    let consistencyScore;
+    if (options.score) {
+      const issues = report.results?.flatMap((r) => r.issues) || [];
+      consistencyScore = calculateConsistencyScore(issues, report.summary.filesAnalyzed);
+    }
     const outputFormat = options.output || finalOptions.output?.format || "console";
     const userOutputFile = options.outputFile || finalOptions.output?.file;
     if (outputFormat === "json") {
@@ -313,7 +429,8 @@ program.command("consistency").description("Check naming, patterns, and architec
         summary: {
           ...report.summary,
           executionTime: parseFloat(elapsedTime)
-        }
+        },
+        ...consistencyScore && { scoring: consistencyScore }
       };
       const outputPath = resolveOutputPath(
         userOutputFile,
@@ -402,6 +519,11 @@ program.command("consistency").description("Check naming, patterns, and architec
           console.log();
         }
       }
+      if (consistencyScore) {
+        console.log(chalk.bold("\n\u{1F4CA} AI Readiness Score (Consistency)\n"));
+        console.log(formatToolScore(consistencyScore));
+        console.log();
+      }
     }
   } catch (error) {
     handleCLIError(error, "Consistency analysis");

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 import { ScanOptions, AnalysisResult } from '@aiready/core';
 import { ContextAnalysisResult } from '@aiready/context-analyzer';
+import { DuplicatePattern } from '@aiready/pattern-detect';
 import { ConsistencyReport } from '@aiready/consistency';
 
 interface UnifiedAnalysisOptions extends ScanOptions {
@@ -12,6 +13,7 @@ interface UnifiedAnalysisOptions extends ScanOptions {
 }
 interface UnifiedAnalysisResult {
     patterns?: AnalysisResult[];
+    duplicates?: DuplicatePattern[];
     context?: ContextAnalysisResult[];
     consistency?: ConsistencyReport;
     summary: {

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { ScanOptions, AnalysisResult } from '@aiready/core';
 import { ContextAnalysisResult } from '@aiready/context-analyzer';
+import { DuplicatePattern } from '@aiready/pattern-detect';
 import { ConsistencyReport } from '@aiready/consistency';
 
 interface UnifiedAnalysisOptions extends ScanOptions {
@@ -12,6 +13,7 @@ interface UnifiedAnalysisOptions extends ScanOptions {
 }
 interface UnifiedAnalysisResult {
     patterns?: AnalysisResult[];
+    duplicates?: DuplicatePattern[];
     context?: ContextAnalysisResult[];
     consistency?: ConsistencyReport;
     summary: {

package/dist/index.js

@@ -66,6 +66,7 @@ async function analyzeUnified(options) {
   if (tools.includes("patterns")) {
     const patternResult = await (0, import_pattern_detect.analyzePatterns)(options);
     result.patterns = sortBySeverity(patternResult.results);
+    result.duplicates = patternResult.duplicates;
     result.summary.totalIssues += patternResult.results.reduce(
       (sum, file) => sum + file.issues.length,
       0

package/dist/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/cli",
-  "version": "0.7.16",
+  "version": "0.7.18",
   "description": "Unified CLI for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -9,16 +9,16 @@
     "aiready": "./dist/cli.js"
   },
   "dependencies": {
-    "commander": "^12.1.0",
+    "commander": "^14.0.0",
     "chalk": "^5.3.0",
-    "@aiready/core": "0.7.9",
-    "@aiready/context-analyzer": "0.7.12",
-    "@aiready/pattern-detect": "0.9.17",
-    "@aiready/consistency": "0.6.12"
+    "@aiready/context-analyzer": "0.7.16",
+    "@aiready/consistency": "0.6.14",
+    "@aiready/core": "0.7.11",
+    "@aiready/pattern-detect": "0.9.20"
   },
   "devDependencies": {
     "tsup": "^8.3.5",
-    "@types/node": "^20.0.0"
+    "@types/node": "^24.0.0"
   },
   "keywords": [
     "aiready",

package/src/cli.ts

@@ -5,7 +5,20 @@ import { analyzeUnified, generateUnifiedSummary } from './index';
 import chalk from 'chalk';
 import { writeFileSync } from 'fs';
 import { join } from 'path';
-import { loadMergedConfig, handleJSONOutput, handleCLIError, getElapsedTime, resolveOutputPath } from '@aiready/core';
+import { 
+  loadMergedConfig, 
+  handleJSONOutput, 
+  handleCLIError, 
+  getElapsedTime, 
+  resolveOutputPath,
+  calculateOverallScore,
+  formatScore,
+  formatToolScore,
+  getRatingDisplay,
+  parseWeightString,
+  type AIReadyConfig,
+  type ToolScoringOutput,
+} from '@aiready/core';
 import { readFileSync } from 'fs';
 
 const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
@@ -27,6 +40,9 @@ program
   .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) => {
     console.log(chalk.blue('🚀 Starting AIReady unified analysis...\n'));
 
@@ -63,6 +79,59 @@ program
 
       const elapsedTime = getElapsedTime(startTime);
 
+      // Calculate score if requested
+      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')) {
+          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);
+        }
+        
+        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);
+        }
+        
+        if (results.consistency && baseOptions.tools.includes('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);
+          }
+        }
+      }
+
       const outputFormat = options.output || finalOptions.output?.format || 'console';
       const userOutputFile = options.outputFile || finalOptions.output?.file;
 
@@ -73,6 +142,7 @@ program
             ...results.summary,
             executionTime: parseFloat(elapsedTime),
           },
+          ...(scoringResult && { scoring: scoringResult }),
         };
 
         const outputPath = resolveOutputPath(
@@ -85,6 +155,56 @@ program
       } 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();
+          }
+          
+          // 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`);
+            });
+          }
+        }
       }
     } catch (error) {
       handleCLIError(error, 'Analysis');
@@ -105,6 +225,7 @@ program
   .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) => {
     console.log(chalk.blue('🔍 Analyzing patterns...\n'));
 
@@ -150,12 +271,18 @@ program
 
       const finalOptions = await loadMergedConfig(directory, defaults, cliOptions);
 
-      const { analyzePatterns, generateSummary } = await import('@aiready/pattern-detect');
+      const { analyzePatterns, generateSummary, calculatePatternScore } = await import('@aiready/pattern-detect');
 
       const { results, duplicates } = await analyzePatterns(finalOptions);
 
       const elapsedTime = getElapsedTime(startTime);
       const summary = generateSummary(results);
+      
+      // Calculate score if requested
+      let patternScore: ToolScoringOutput | undefined;
+      if (options.score) {
+        patternScore = calculatePatternScore(duplicates, results.length);
+      }
 
       const outputFormat = options.output || finalOptions.output?.format || 'console';
       const userOutputFile = options.outputFile || finalOptions.output?.file;
@@ -164,6 +291,7 @@ program
         const outputData = {
           results,
           summary: { ...summary, executionTime: parseFloat(elapsedTime) },
+          ...(patternScore && { scoring: patternScore }),
         };
 
         const outputPath = resolveOutputPath(
@@ -225,6 +353,15 @@ program
         } else {
           console.log(chalk.green('\n✨ Great! No duplicate patterns detected.\n'));
         }
+        
+        // Display score if calculated
+        if (patternScore) {
+          console.log(chalk.cyan(divider));
+          console.log(chalk.bold.white('  AI READINESS SCORE (Patterns)'));
+          console.log(chalk.cyan(divider) + '\n');
+          console.log(formatToolScore(patternScore));
+          console.log();
+        }
       }
     } catch (error) {
       handleCLIError(error, 'Pattern analysis');
@@ -241,6 +378,7 @@ program
   .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('🧠 Analyzing context costs...\n'));
 
@@ -282,12 +420,18 @@ program
       console.log(`   Analysis focus: ${finalOptions.focus}`);
       console.log('');
 
-      const { analyzeContext, generateSummary } = await import('@aiready/context-analyzer');
+      const { analyzeContext, generateSummary, calculateContextScore } = await import('@aiready/context-analyzer');
 
       const results = await analyzeContext(finalOptions);
 
       const elapsedTime = getElapsedTime(startTime);
       const summary = generateSummary(results);
+      
+      // Calculate score if requested
+      let contextScore: ToolScoringOutput | undefined;
+      if (options.score) {
+        contextScore = calculateContextScore(summary as any);
+      }
 
       const outputFormat = options.output || finalOptions.output?.format || 'console';
       const userOutputFile = options.outputFile || finalOptions.output?.file;
@@ -296,6 +440,7 @@ program
         const outputData = {
           results,
           summary: { ...summary, executionTime: parseFloat(elapsedTime) },
+          ...(contextScore && { scoring: contextScore }),
         };
 
         const outputPath = resolveOutputPath(
@@ -384,6 +529,15 @@ program
           });
           console.log();
         }
+        
+        // Display score if calculated
+        if (contextScore) {
+          console.log(chalk.cyan(divider));
+          console.log(chalk.bold.white('  AI READINESS SCORE (Context)'));
+          console.log(chalk.cyan(divider) + '\n');
+          console.log(formatToolScore(contextScore));
+          console.log();
+        }
       }
     } catch (error) {
       handleCLIError(error, 'Context analysis');
@@ -403,6 +557,7 @@ program
     .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('🔍 Analyzing consistency...\n'));
 
@@ -431,11 +586,18 @@ program
           exclude: options.exclude?.split(','),
         });
 
-        const { analyzeConsistency } = await import('@aiready/consistency');
+        const { analyzeConsistency, calculateConsistencyScore } = await import('@aiready/consistency');
 
         const report = await analyzeConsistency(finalOptions);
 
         const elapsedTime = getElapsedTime(startTime);
+        
+        // Calculate score if requested
+        let consistencyScore: ToolScoringOutput | undefined;
+        if (options.score) {
+          const issues = report.results?.flatMap((r: any) => r.issues) || [];
+          consistencyScore = calculateConsistencyScore(issues, report.summary.filesAnalyzed);
+        }
 
         const outputFormat = options.output || finalOptions.output?.format || 'console';
         const userOutputFile = options.outputFile || finalOptions.output?.file;
@@ -447,6 +609,7 @@ program
               ...report.summary,
               executionTime: parseFloat(elapsedTime),
             },
+            ...(consistencyScore && { scoring: consistencyScore }),
           };
 
           const outputPath = resolveOutputPath(
@@ -545,6 +708,13 @@ program
               console.log();
             }
           }
+          
+          // Display score if calculated
+          if (consistencyScore) {
+            console.log(chalk.bold('\n📊 AI Readiness Score (Consistency)\n'));
+            console.log(formatToolScore(consistencyScore));
+            console.log();
+          }
         }
       } catch (error) {
         handleCLIError(error, 'Consistency analysis');

package/src/index.ts

@@ -3,7 +3,7 @@ import { analyzeContext } from '@aiready/context-analyzer';
 import { analyzeConsistency } from '@aiready/consistency';
 import type { AnalysisResult, ScanOptions } from '@aiready/core';
 import type { ContextAnalysisResult } from '@aiready/context-analyzer';
-import type { PatternDetectOptions } from '@aiready/pattern-detect';
+import type { PatternDetectOptions, DuplicatePattern } from '@aiready/pattern-detect';
 import type { ConsistencyReport } from '@aiready/consistency';
 
 export interface UnifiedAnalysisOptions extends ScanOptions {
@@ -17,6 +17,7 @@ export interface UnifiedAnalysisOptions extends ScanOptions {
 
 export interface UnifiedAnalysisResult {
   patterns?: AnalysisResult[];
+  duplicates?: DuplicatePattern[]; // Store actual duplicates for scoring
   context?: ContextAnalysisResult[];
   consistency?: ConsistencyReport;
   summary: {
@@ -80,6 +81,8 @@ export async function analyzeUnified(
     const patternResult = await analyzePatterns(options);
     // Sort results by severity
     result.patterns = sortBySeverity(patternResult.results);
+    // Store duplicates for scoring
+    result.duplicates = patternResult.duplicates;
     // Count actual issues, not file count
     result.summary.totalIssues += patternResult.results.reduce(
       (sum, file) => sum + file.issues.length,