@aiready/consistency 0.6.12 → 0.6.13

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/consistency@0.6.12 build /Users/pengcao/projects/aiready/packages/consistency
+> @aiready/consistency@0.6.13 build /Users/pengcao/projects/aiready/packages/consistency
 > 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 47.29 KB
-CJS dist/cli.js   46.80 KB
-CJS ⚡️ Build success in 215ms
 ESM dist/cli.mjs            8.76 KB
+ESM dist/index.mjs          12.69 KB
 ESM dist/chunk-7PHHJOGC.mjs 36.87 KB
-ESM dist/index.mjs          9.40 KB
-ESM ⚡️ Build success in 215ms
+ESM ⚡️ Build success in 167ms
+CJS dist/index.js 50.65 KB
+CJS dist/cli.js   46.80 KB
+CJS ⚡️ Build success in 167ms
 DTS Build start
-DTS ⚡️ Build success in 1940ms
+DTS ⚡️ Build success in 2088ms
 DTS dist/cli.d.ts    20.00 B
-DTS dist/index.d.ts  2.99 KB
+DTS dist/index.d.ts  3.38 KB
 DTS dist/cli.d.mts   20.00 B
-DTS dist/index.d.mts 2.99 KB
+DTS dist/index.d.mts 3.38 KB

package/.turbo/turbo-test.log

@@ -1,51 +1,61 @@
 
 
-> @aiready/consistency@0.6.12 test /Users/pengcao/projects/aiready/packages/consistency
+> @aiready/consistency@0.6.13 test /Users/pengcao/projects/aiready/packages/consistency
 > vitest run
 
 
  RUN  v2.1.9 /Users/pengcao/projects/aiready/packages/consistency
 
-[?25l · src/__tests__/analyzer.test.ts (18)
-[?25l · src/__tests__/analyzer.test.ts (18)
- · src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ❯ analyzeConsistency (2)
-     ⠙ should analyze naming issues
-     · should detect minimum severity filtering
-   · analyzeNaming (8)
-   · analyzePatterns (3)
-   · consistency scoring (2)
-   · recommendations (3)
- · src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l · src/__tests__/scoring.test.ts (8)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ✓ src/__tests__/language-filter.test.ts (3)
+[?25l[?25l ✓ src/__tests__/scoring.test.ts (8)
+ · src/__tests__/analyzer.test.ts (18)
+ ✓ src/__tests__/language-filter.test.ts (3)
+[?25l[?25l[?25l[?25l[?25l[?25l[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
-     ⠹ should analyze naming issues
-     · should detect minimum severity filtering
+     ✓ should analyze naming issues
+     ⠙ should detect minimum severity filtering
    · analyzeNaming (8)
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
- · src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+ ✓ src/__tests__/language-filter.test.ts (3)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
-     ⠸ should analyze naming issues
-     · should detect minimum severity filtering
+     ✓ should analyze naming issues
+     ⠹ should detect minimum severity filtering
    · analyzeNaming (8)
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
- · src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ❯ analyzeConsistency (2)
+ ✓ src/__tests__/language-filter.test.ts (3)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ✓ src/__tests__/analyzer.test.ts (18)
+ ✓ src/__tests__/language-filter.test.ts (3)
+ ✓ src/__tests__/analyzer.test.ts (18)
+ ✓ src/__tests__/language-filter.test.ts (3)
+ ✓ src/__tests__/scoring.test.ts (8)
+
+ Test Files  3 passed (3)
+      Tests  29 passed (29)
+   Start at  16:05:50
+   Duration  2.20s (transform 335ms, setup 0ms, collect 2.05s, tests 167ms, environment 0ms, prepare 750ms)
+
+[?25h[?25h
+
      ⠼ should analyze naming issues
      · should detect minimum severity filtering
    · analyzeNaming (8)
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
- · src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+ ✓ src/__tests__/language-filter.test.ts (3)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ⠴ should analyze naming issues
      · should detect minimum severity filtering
@@ -53,8 +63,9 @@
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
- · src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+ ✓ src/__tests__/language-filter.test.ts (3)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ⠦ should analyze naming issues
      · should detect minimum severity filtering
@@ -62,8 +73,9 @@
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
- · src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+ ✓ src/__tests__/language-filter.test.ts (3)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ⠧ should analyze naming issues
      · should detect minimum severity filtering
@@ -72,7 +84,8 @@
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ⠇ should analyze naming issues
      · should detect minimum severity filtering
@@ -81,7 +94,8 @@
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ⠏ should analyze naming issues
      · should detect minimum severity filtering
@@ -90,7 +104,8 @@
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ⠋ should analyze naming issues
      · should detect minimum severity filtering
@@ -99,7 +114,8 @@
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ⠙ should analyze naming issues
      · should detect minimum severity filtering
@@ -108,7 +124,8 @@
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ⠹ should analyze naming issues
      · should detect minimum severity filtering
@@ -117,183 +134,88 @@
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
-     ⠸ should analyze naming issues
-     · should detect minimum severity filtering
-   · analyzeNaming (8)
-   · analyzePatterns (3)
-   · consistency scoring (2)
-   · recommendations (3)
-   ❯ analyzeConsistency (2)
-     ⠼ should analyze naming issues
-     · should detect minimum severity filtering
-   · analyzeNaming (8)
-   · analyzePatterns (3)
-   · consistency scoring (2)
-   · recommendations (3)
- ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ❯ analyzeConsistency (2)
-     ⠴ should analyze naming issues
-     · should detect minimum severity filtering
-   · analyzeNaming (8)
-   · analyzePatterns (3)
-   · consistency scoring (2)
-   · recommendations (3)
- ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ❯ analyzeConsistency (2)
-     ⠦ should analyze naming issues
-     · should detect minimum severity filtering
-   · analyzeNaming (8)
-   · analyzePatterns (3)
-   · consistency scoring (2)
-   · recommendations (3)
- ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ❯ analyzeConsistency (2)
-     ⠧ should analyze naming issues
-     · should detect minimum severity filtering
-   · analyzeNaming (8)
-   · analyzePatterns (3)
-   · consistency scoring (2)
-   · recommendations (3)
- ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ❯ analyzeConsistency (2)
-     ✓ should analyze naming issues 312ms
+     ✓ should analyze naming issues
      ⠙ should detect minimum severity filtering
    · analyzeNaming (8)
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
-     ✓ should analyze naming issues 312ms
+     ✓ should analyze naming issues
      ⠹ should detect minimum severity filtering
    · analyzeNaming (8)
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
-     ✓ should analyze naming issues 312ms
+     ✓ should analyze naming issues
      ⠸ should detect minimum severity filtering
    · analyzeNaming (8)
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ❯ analyzeConsistency (2)
-     ✓ should analyze naming issues 312ms
-     ⠼ should detect minimum severity filtering
-   · analyzeNaming (8)
-   · analyzePatterns (3)
-   · consistency scoring (2)
-   · recommendations (3)
- ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ❯ analyzeConsistency (2)
-     ✓ should analyze naming issues 312ms
-     ⠴ should detect minimum severity filtering
-   · analyzeNaming (8)
-   · analyzePatterns (3)
-   · consistency scoring (2)
-   · recommendations (3)
- ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ❯ analyzeConsistency (2)
-     ✓ should analyze naming issues 312ms
-     ⠦ should detect minimum severity filtering
-   · analyzeNaming (8)
-   · analyzePatterns (3)
-   · consistency scoring (2)
-   · recommendations (3)
- ✓ src/__tests__/language-filter.test.ts (3)
- ✓ src/__tests__/analyzer.test.ts (18) 415ms
- ✓ src/__tests__/language-filter.test.ts (3)
-
- Test Files  2 passed (2)
-      Tests  21 passed (21)
-   Start at  18:01:20
-   Duration  2.38s (transform 742ms, setup 0ms, collect 2.26s, tests 425ms, environment 0ms, prepare 531ms)
-
-[?25h[?25h
-ms
-   ✓ analyzeNaming (8)
-   ✓ analyzePatterns (3)
-   ✓ consistency scoring (2)
-   ❯ recommendations (3)
-     ⠙ should generate relevant recommendations
-     · should suggest standardizing error handling
-     · should suggest using async/await consistently
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ✓ src/__tests__/analyzer.test.ts (18)
  ✓ src/__tests__/language-filter.test.ts (3)
- ✓ src/__tests__/analyzer.test.ts (18) 451ms
+ ✓ src/__tests__/analyzer.test.ts (18)
  ✓ src/__tests__/language-filter.test.ts (3)
+ ✓ src/__tests__/scoring.test.ts (8)
 
- Test Files  2 passed (2)
-      Tests  21 passed (21)
-   Start at  18:01:19
-   Duration  2.72s (transform 1.07s, setup 0ms, collect 3.76s, tests 456ms, environment 0ms, prepare 214ms)
+ Test Files  3 passed (3)
+      Tests  29 passed (29)
+   Start at  16:05:50
+   Duration  2.46s (transform 373ms, setup 0ms, collect 2.05s, tests 286ms, environment 0ms, prepare 1.01s)
 
 [?25h[?25h
-st.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ✓ should analyze naming issues
-     ⠹ should detect minimum severity filtering
-   · analyzeNaming (8)
-   · analyzePatterns (3)
-   · consistency scoring (2)
-   · recommendations (3)
- ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ❯ analyzeConsistency (2)
-     ✓ should analyze naming issues
-     ⠸ should detect minimum severity filtering
+     ⠙ should detect minimum severity filtering
    · analyzeNaming (8)
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ✓ should analyze naming issues
-     ⠼ should detect minimum severity filtering
+     ⠹ should detect minimum severity filtering
    · analyzeNaming (8)
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ❯ src/__tests__/analyzer.test.ts (18)
    ❯ analyzeConsistency (2)
      ✓ should analyze naming issues
-     ⠴ should detect minimum severity filtering
+     ⠸ should detect minimum severity filtering
    · analyzeNaming (8)
    · analyzePatterns (3)
    · consistency scoring (2)
    · recommendations (3)
  ✓ src/__tests__/language-filter.test.ts (3)
-[?25l ❯ src/__tests__/analyzer.test.ts (18)
-   ✓ analyzeConsistency (2) 553ms
-   ✓ analyzeNaming (8)
-   ✓ analyzePatterns (3)
-   ✓ consistency scoring (2)
-   ❯ recommendations (3)
-     ⠙ should generate relevant recommendations
-     · should suggest standardizing error handling
-     · should suggest using async/await consistently
+[?25l ✓ src/__tests__/scoring.test.ts (8)
+ ✓ src/__tests__/analyzer.test.ts (18) 370ms
  ✓ src/__tests__/language-filter.test.ts (3)
- ✓ src/__tests__/analyzer.test.ts (18) 596ms
+ ✓ src/__tests__/analyzer.test.ts (18) 370ms
  ✓ src/__tests__/language-filter.test.ts (3)
+ ✓ src/__tests__/scoring.test.ts (8)
 
- Test Files  2 passed (2)
-      Tests  21 passed (21)
-   Start at  18:01:19
-   Duration  2.68s (transform 1.41s, setup 0ms, collect 2.94s, tests 724ms, environment 0ms, prepare 693ms)
+ Test Files  3 passed (3)
+      Tests  29 passed (29)
+   Start at  16:05:50
+   Duration  2.65s (transform 1.05s, setup 0ms, collect 3.33s, tests 464ms, environment 0ms, prepare 765ms)
 
 [?25h[?25h

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { ScanOptions, AnalysisResult, Issue } from '@aiready/core';
+import { ScanOptions, AnalysisResult, Issue, ToolScoringOutput } from '@aiready/core';
 
 interface ConsistencyOptions extends ScanOptions {
     /** Check naming conventions and quality */
@@ -86,4 +86,14 @@ declare function detectNamingConventions(files: string[], allIssues: Array<{
  */
 declare function analyzePatterns(files: string[]): Promise<PatternIssue[]>;
 
-export { type ArchitectureIssue, type ConsistencyIssue, type ConsistencyOptions, type ConsistencyReport, type NamingIssue, type PatternIssue, analyzeConsistency, analyzeNaming, analyzeNamingAST, analyzePatterns, detectNamingConventions };
+/**
+ * Calculate AI Readiness Score for code consistency (0-100)
+ *
+ * Based on:
+ * - Issue density (issues per file)
+ * - Weighted severity (critical: 10pts, major: 3pts, minor: 0.5pts)
+ * - Pattern consistency across codebase
+ */
+declare function calculateConsistencyScore(issues: ConsistencyIssue[], totalFilesAnalyzed: number): ToolScoringOutput;
+
+export { type ArchitectureIssue, type ConsistencyIssue, type ConsistencyOptions, type ConsistencyReport, type NamingIssue, type PatternIssue, analyzeConsistency, analyzeNaming, analyzeNamingAST, analyzePatterns, calculateConsistencyScore, detectNamingConventions };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ScanOptions, AnalysisResult, Issue } from '@aiready/core';
+import { ScanOptions, AnalysisResult, Issue, ToolScoringOutput } from '@aiready/core';
 
 interface ConsistencyOptions extends ScanOptions {
     /** Check naming conventions and quality */
@@ -86,4 +86,14 @@ declare function detectNamingConventions(files: string[], allIssues: Array<{
  */
 declare function analyzePatterns(files: string[]): Promise<PatternIssue[]>;
 
-export { type ArchitectureIssue, type ConsistencyIssue, type ConsistencyOptions, type ConsistencyReport, type NamingIssue, type PatternIssue, analyzeConsistency, analyzeNaming, analyzeNamingAST, analyzePatterns, detectNamingConventions };
+/**
+ * Calculate AI Readiness Score for code consistency (0-100)
+ *
+ * Based on:
+ * - Issue density (issues per file)
+ * - Weighted severity (critical: 10pts, major: 3pts, minor: 0.5pts)
+ * - Pattern consistency across codebase
+ */
+declare function calculateConsistencyScore(issues: ConsistencyIssue[], totalFilesAnalyzed: number): ToolScoringOutput;
+
+export { type ArchitectureIssue, type ConsistencyIssue, type ConsistencyOptions, type ConsistencyReport, type NamingIssue, type PatternIssue, analyzeConsistency, analyzeNaming, analyzeNamingAST, analyzePatterns, calculateConsistencyScore, detectNamingConventions };

package/dist/index.js

@@ -24,6 +24,7 @@ __export(index_exports, {
   analyzeNaming: () => analyzeNaming,
   analyzeNamingAST: () => analyzeNamingAST,
   analyzePatterns: () => analyzePatterns,
+  calculateConsistencyScore: () => calculateConsistencyScore2,
   detectNamingConventions: () => detectNamingConventions
 });
 module.exports = __toCommonJS(index_exports);
@@ -1573,11 +1574,103 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
   });
   return issues;
 }
+
+// src/scoring.ts
+function calculateConsistencyScore2(issues, totalFilesAnalyzed) {
+  const criticalIssues = issues.filter((i) => i.severity === "critical").length;
+  const majorIssues = issues.filter((i) => i.severity === "major").length;
+  const minorIssues = issues.filter((i) => i.severity === "minor").length;
+  const totalIssues = issues.length;
+  const issuesPerFile = totalFilesAnalyzed > 0 ? totalIssues / totalFilesAnalyzed : 0;
+  const densityPenalty = Math.min(50, issuesPerFile * 15);
+  const weightedCount = criticalIssues * 10 + majorIssues * 3 + minorIssues * 0.5;
+  const avgWeightedIssuesPerFile = totalFilesAnalyzed > 0 ? weightedCount / totalFilesAnalyzed : 0;
+  const severityPenalty = Math.min(50, avgWeightedIssuesPerFile * 2);
+  const rawScore = 100 - densityPenalty - severityPenalty;
+  const score = Math.max(0, Math.min(100, Math.round(rawScore)));
+  const factors = [
+    {
+      name: "Issue Density",
+      impact: -Math.round(densityPenalty),
+      description: `${issuesPerFile.toFixed(2)} issues per file ${issuesPerFile < 1 ? "(excellent)" : issuesPerFile < 3 ? "(acceptable)" : "(high)"}`
+    }
+  ];
+  if (criticalIssues > 0) {
+    const criticalImpact = Math.min(30, criticalIssues * 10);
+    factors.push({
+      name: "Critical Issues",
+      impact: -criticalImpact,
+      description: `${criticalIssues} critical consistency issue${criticalIssues > 1 ? "s" : ""} (high AI confusion risk)`
+    });
+  }
+  if (majorIssues > 0) {
+    const majorImpact = Math.min(20, Math.round(majorIssues * 3));
+    factors.push({
+      name: "Major Issues",
+      impact: -majorImpact,
+      description: `${majorIssues} major issue${majorIssues > 1 ? "s" : ""} (moderate AI confusion risk)`
+    });
+  }
+  if (minorIssues > 0 && minorIssues >= totalFilesAnalyzed) {
+    const minorImpact = -Math.round(minorIssues * 0.5);
+    factors.push({
+      name: "Minor Issues",
+      impact: minorImpact,
+      description: `${minorIssues} minor issue${minorIssues > 1 ? "s" : ""} (slight AI confusion risk)`
+    });
+  }
+  const recommendations = [];
+  if (criticalIssues > 0) {
+    const estimatedImpact = Math.min(30, criticalIssues * 10);
+    recommendations.push({
+      action: "Fix critical naming/pattern inconsistencies (highest AI confusion risk)",
+      estimatedImpact,
+      priority: "high"
+    });
+  }
+  if (majorIssues > 5) {
+    const estimatedImpact = Math.min(15, Math.round(majorIssues / 2));
+    recommendations.push({
+      action: "Standardize naming conventions across codebase",
+      estimatedImpact,
+      priority: "medium"
+    });
+  }
+  if (issuesPerFile > 3) {
+    recommendations.push({
+      action: "Establish and enforce coding style guide to reduce inconsistencies",
+      estimatedImpact: 12,
+      priority: "medium"
+    });
+  }
+  if (totalIssues > 20 && minorIssues / totalIssues > 0.7) {
+    recommendations.push({
+      action: "Enable linter/formatter to automatically fix minor style issues",
+      estimatedImpact: 8,
+      priority: "low"
+    });
+  }
+  return {
+    toolName: "consistency",
+    score,
+    rawMetrics: {
+      totalIssues,
+      criticalIssues,
+      majorIssues,
+      minorIssues,
+      issuesPerFile: Math.round(issuesPerFile * 100) / 100,
+      avgWeightedIssuesPerFile: Math.round(avgWeightedIssuesPerFile * 100) / 100
+    },
+    factors,
+    recommendations
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   analyzeConsistency,
   analyzeNaming,
   analyzeNamingAST,
   analyzePatterns,
+  calculateConsistencyScore,
   detectNamingConventions
 });

package/dist/index.mjs

@@ -186,10 +186,102 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
   });
   return issues;
 }
+
+// src/scoring.ts
+function calculateConsistencyScore(issues, totalFilesAnalyzed) {
+  const criticalIssues = issues.filter((i) => i.severity === "critical").length;
+  const majorIssues = issues.filter((i) => i.severity === "major").length;
+  const minorIssues = issues.filter((i) => i.severity === "minor").length;
+  const totalIssues = issues.length;
+  const issuesPerFile = totalFilesAnalyzed > 0 ? totalIssues / totalFilesAnalyzed : 0;
+  const densityPenalty = Math.min(50, issuesPerFile * 15);
+  const weightedCount = criticalIssues * 10 + majorIssues * 3 + minorIssues * 0.5;
+  const avgWeightedIssuesPerFile = totalFilesAnalyzed > 0 ? weightedCount / totalFilesAnalyzed : 0;
+  const severityPenalty = Math.min(50, avgWeightedIssuesPerFile * 2);
+  const rawScore = 100 - densityPenalty - severityPenalty;
+  const score = Math.max(0, Math.min(100, Math.round(rawScore)));
+  const factors = [
+    {
+      name: "Issue Density",
+      impact: -Math.round(densityPenalty),
+      description: `${issuesPerFile.toFixed(2)} issues per file ${issuesPerFile < 1 ? "(excellent)" : issuesPerFile < 3 ? "(acceptable)" : "(high)"}`
+    }
+  ];
+  if (criticalIssues > 0) {
+    const criticalImpact = Math.min(30, criticalIssues * 10);
+    factors.push({
+      name: "Critical Issues",
+      impact: -criticalImpact,
+      description: `${criticalIssues} critical consistency issue${criticalIssues > 1 ? "s" : ""} (high AI confusion risk)`
+    });
+  }
+  if (majorIssues > 0) {
+    const majorImpact = Math.min(20, Math.round(majorIssues * 3));
+    factors.push({
+      name: "Major Issues",
+      impact: -majorImpact,
+      description: `${majorIssues} major issue${majorIssues > 1 ? "s" : ""} (moderate AI confusion risk)`
+    });
+  }
+  if (minorIssues > 0 && minorIssues >= totalFilesAnalyzed) {
+    const minorImpact = -Math.round(minorIssues * 0.5);
+    factors.push({
+      name: "Minor Issues",
+      impact: minorImpact,
+      description: `${minorIssues} minor issue${minorIssues > 1 ? "s" : ""} (slight AI confusion risk)`
+    });
+  }
+  const recommendations = [];
+  if (criticalIssues > 0) {
+    const estimatedImpact = Math.min(30, criticalIssues * 10);
+    recommendations.push({
+      action: "Fix critical naming/pattern inconsistencies (highest AI confusion risk)",
+      estimatedImpact,
+      priority: "high"
+    });
+  }
+  if (majorIssues > 5) {
+    const estimatedImpact = Math.min(15, Math.round(majorIssues / 2));
+    recommendations.push({
+      action: "Standardize naming conventions across codebase",
+      estimatedImpact,
+      priority: "medium"
+    });
+  }
+  if (issuesPerFile > 3) {
+    recommendations.push({
+      action: "Establish and enforce coding style guide to reduce inconsistencies",
+      estimatedImpact: 12,
+      priority: "medium"
+    });
+  }
+  if (totalIssues > 20 && minorIssues / totalIssues > 0.7) {
+    recommendations.push({
+      action: "Enable linter/formatter to automatically fix minor style issues",
+      estimatedImpact: 8,
+      priority: "low"
+    });
+  }
+  return {
+    toolName: "consistency",
+    score,
+    rawMetrics: {
+      totalIssues,
+      criticalIssues,
+      majorIssues,
+      minorIssues,
+      issuesPerFile: Math.round(issuesPerFile * 100) / 100,
+      avgWeightedIssuesPerFile: Math.round(avgWeightedIssuesPerFile * 100) / 100
+    },
+    factors,
+    recommendations
+  };
+}
 export {
   analyzeConsistency,
   analyzeNaming,
   analyzeNamingAST,
   analyzePatterns,
+  calculateConsistencyScore,
   detectNamingConventions
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/consistency",
-  "version": "0.6.12",
+  "version": "0.6.13",
   "description": "Detects consistency issues in naming, patterns, and architecture that confuse AI models",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -43,7 +43,7 @@
     "@typescript-eslint/typescript-estree": "^8.53.0",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
-    "@aiready/core": "0.7.9"
+    "@aiready/core": "0.7.10"
   },
   "devDependencies": {
     "@types/node": "^22.10.5",

package/src/__tests__/scoring.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect } from 'vitest';
+import { calculateConsistencyScore } from '../scoring';
+import type { ConsistencyIssue } from '../types';
+
+describe('Consistency Scoring', () => {
+  describe('calculateConsistencyScore', () => {
+    it('should return perfect score for no issues', () => {
+      const result = calculateConsistencyScore([], 100);
+
+      expect(result.score).toBe(100);
+      expect(result.toolName).toBe('consistency');
+      expect(result.rawMetrics.totalIssues).toBe(0);
+      expect(result.recommendations).toHaveLength(0);
+    });
+
+    it('should penalize high issue density', () => {
+      const issues: ConsistencyIssue[] = Array(50).fill({
+        severity: 'minor',
+        category: 'naming',
+        message: 'Test issue',
+        location: { file: 'test.ts', line: 1 },
+      } as ConsistencyIssue);
+
+      // 50 issues / 10 files = 5 issues per file
+      // densityPenalty = min(50, 5 * 15) = 50
+      const result = calculateConsistencyScore(issues, 10);
+
+      expect(result.score).toBeLessThan(60);
+      expect(result.rawMetrics.issuesPerFile).toBe(5);
+    });
+
+    it('should heavily penalize critical issues', () => {
+      const issues: ConsistencyIssue[] = [
+        {
+          severity: 'critical',
+          category: 'naming',
+          message: 'Critical naming issue',
+          location: { file: 'test.ts', line: 1 },
+        } as ConsistencyIssue,
+        {
+          severity: 'critical',
+          category: 'naming',
+          message: 'Another critical issue',
+          location: { file: 'test.ts', line: 10 },
+        } as ConsistencyIssue,
+      ];
+
+      const result = calculateConsistencyScore(issues, 10);
+
+      // 2 issues / 10 files = 0.2 issues/file → densityPenalty = 3
+      // weightedCount = 2*10 = 20, avgWeighted = 2.0 → severityPenalty = 4
+      // score = 100 - 3 - 4 = 93
+      expect(result.score).toBe(93);
+      expect(result.rawMetrics.criticalIssues).toBe(2);
+      expect(result.factors.some(f => f.name === 'Critical Issues')).toBe(true);
+      expect(result.recommendations.some(r => r.priority === 'high')).toBe(true);
+    });
+
+    it('should apply weighted severity penalties', () => {
+      const issues: ConsistencyIssue[] = [
+        ...Array(5).fill({ severity: 'critical' } as ConsistencyIssue),
+        ...Array(10).fill({ severity: 'major' } as ConsistencyIssue),
+        ...Array(20).fill({ severity: 'minor' } as ConsistencyIssue),
+      ];
+
+      const result = calculateConsistencyScore(
+        issues.map((i, idx) => ({
+          ...i,
+          category: 'naming',
+          message: 'test',
+          location: { file: 'test.ts', line: idx },
+        })) as ConsistencyIssue[],
+        50
+      );
+
+      expect(result.rawMetrics.criticalIssues).toBe(5);
+      expect(result.rawMetrics.majorIssues).toBe(10);
+      expect(result.rawMetrics.minorIssues).toBe(20);
+      // 35 issues / 50 files = 0.7 issues/file → densityPenalty = 10.5
+      // weightedCount = 50+30+10 = 90, avgWeighted = 1.8 → severityPenalty = 3.6
+      // score = 100 - 10.5 - 3.6 = 85.9 → 86
+      expect(result.score).toBe(86);
+    });
+
+    it('should generate appropriate recommendations', () => {
+      const issues: ConsistencyIssue[] = [
+        ...Array(3).fill({ severity: 'critical', category: 'naming' } as ConsistencyIssue),
+        ...Array(10).fill({ severity: 'major', category: 'patterns' } as ConsistencyIssue),
+      ];
+
+      const result = calculateConsistencyScore(
+        issues.map((i, idx) => ({
+          ...i,
+          message: 'test',
+          location: { file: 'test.ts', line: idx },
+        })) as ConsistencyIssue[],
+        5
+      );
+
+      expect(result.recommendations.length).toBeGreaterThan(0);
+      expect(result.recommendations.some(r => r.action.includes('critical'))).toBe(true);
+      expect(result.recommendations.some(r => r.action.includes('naming'))).toBe(true);
+    });
+
+    it('should handle edge case of zero files', () => {
+      const issues: ConsistencyIssue[] = [];
+
+      const result = calculateConsistencyScore(issues, 0);
+
+      expect(result.score).toBe(100);
+      expect(result.rawMetrics.issuesPerFile).toBe(0);
+    });
+
+    it('should recommend linter for many minor issues', () => {
+      const issues: ConsistencyIssue[] = Array(30).fill({
+        severity: 'minor',
+        category: 'naming',
+        message: 'Minor style issue',
+        location: { file: 'test.ts', line: 1 },
+      } as ConsistencyIssue);
+
+      const result = calculateConsistencyScore(issues, 10);
+
+      expect(result.recommendations.some(r => r.action.includes('linter'))).toBe(true);
+    });
+
+    it('should combine all penalty types', () => {
+      const issues: ConsistencyIssue[] = [
+        ...Array(10).fill({ severity: 'critical', category: 'naming' } as ConsistencyIssue),
+        ...Array(20).fill({ severity: 'major', category: 'patterns' } as ConsistencyIssue),
+        ...Array(40).fill({ severity: 'minor', category: 'naming' } as ConsistencyIssue),
+      ];
+
+      const result = calculateConsistencyScore(
+        issues.map((i, idx) => ({
+          ...i,
+          message: 'test',
+          location: { file: 'test.ts', line: idx },
+        })) as ConsistencyIssue[],
+        10
+      );
+
+      // 70 issues / 10 files = 7 issues/file
+      // High density + critical issues + weighted severity
+      expect(result.score).toBeLessThan(30);
+      expect(result.factors.length).toBeGreaterThan(2);
+      expect(result.recommendations.length).toBeGreaterThan(0);
+    });
+  });
+});

package/src/index.ts

@@ -3,6 +3,7 @@ export { analyzeNamingAST } from './analyzers/naming-ast';
 export { analyzeNaming } from './analyzers/naming'; // Legacy regex version
 export { detectNamingConventions } from './analyzers/naming-constants';
 export { analyzePatterns } from './analyzers/patterns';
+export { calculateConsistencyScore } from './scoring';
 export type {
   ConsistencyOptions,
   ConsistencyReport,

package/src/scoring.ts

@@ -0,0 +1,128 @@
+import type { ToolScoringOutput } from '@aiready/core';
+import type { ConsistencyIssue } from './types';
+
+/**
+ * Calculate AI Readiness Score for code consistency (0-100)
+ * 
+ * Based on:
+ * - Issue density (issues per file)
+ * - Weighted severity (critical: 10pts, major: 3pts, minor: 0.5pts)
+ * - Pattern consistency across codebase
+ */
+export function calculateConsistencyScore(
+  issues: ConsistencyIssue[],
+  totalFilesAnalyzed: number
+): ToolScoringOutput {
+  const criticalIssues = issues.filter(i => i.severity === 'critical').length;
+  const majorIssues = issues.filter(i => i.severity === 'major').length;
+  const minorIssues = issues.filter(i => i.severity === 'minor').length;
+  const totalIssues = issues.length;
+  
+  // Issue density penalty (0-50 points)
+  // Ideal: 0 issues/file = 0 penalty
+  // Acceptable: <1 issue/file = 10 penalty
+  // High: 1-3 issues/file = 10-40 penalty
+  // Critical: >3 issues/file = 40-50 penalty
+  const issuesPerFile = totalFilesAnalyzed > 0 ? totalIssues / totalFilesAnalyzed : 0;
+  const densityPenalty = Math.min(50, issuesPerFile * 15);
+  
+  // Weighted severity penalty (0-50 points)
+  // Each critical: 10 points
+  // Each major: 3 points
+  // Each minor: 0.5 points
+  const weightedCount = (criticalIssues * 10) + (majorIssues * 3) + (minorIssues * 0.5);
+  const avgWeightedIssuesPerFile = totalFilesAnalyzed > 0 ? weightedCount / totalFilesAnalyzed : 0;
+  const severityPenalty = Math.min(50, avgWeightedIssuesPerFile * 2);
+  
+  // Calculate final score
+  const rawScore = 100 - densityPenalty - severityPenalty;
+  const score = Math.max(0, Math.min(100, Math.round(rawScore)));
+  
+  // Build factors array
+  const factors: ToolScoringOutput['factors'] = [
+    {
+      name: 'Issue Density',
+      impact: -Math.round(densityPenalty),
+      description: `${issuesPerFile.toFixed(2)} issues per file ${issuesPerFile < 1 ? '(excellent)' : issuesPerFile < 3 ? '(acceptable)' : '(high)'}`,
+    },
+  ];
+  
+  if (criticalIssues > 0) {
+    const criticalImpact = Math.min(30, criticalIssues * 10);
+    factors.push({
+      name: 'Critical Issues',
+      impact: -criticalImpact,
+      description: `${criticalIssues} critical consistency issue${criticalIssues > 1 ? 's' : ''} (high AI confusion risk)`,
+    });
+  }
+  
+  if (majorIssues > 0) {
+    const majorImpact = Math.min(20, Math.round(majorIssues * 3));
+    factors.push({
+      name: 'Major Issues',
+      impact: -majorImpact,
+      description: `${majorIssues} major issue${majorIssues > 1 ? 's' : ''} (moderate AI confusion risk)`,
+    });
+  }
+  
+  if (minorIssues > 0 && minorIssues >= totalFilesAnalyzed) {
+    const minorImpact = -Math.round(minorIssues * 0.5);
+    factors.push({
+      name: 'Minor Issues',
+      impact: minorImpact,
+      description: `${minorIssues} minor issue${minorIssues > 1 ? 's' : ''} (slight AI confusion risk)`,
+    });
+  }
+  
+  // Generate recommendations
+  const recommendations: ToolScoringOutput['recommendations'] = [];
+  
+  if (criticalIssues > 0) {
+    const estimatedImpact = Math.min(30, criticalIssues * 10);
+    recommendations.push({
+      action: 'Fix critical naming/pattern inconsistencies (highest AI confusion risk)',
+      estimatedImpact,
+      priority: 'high',
+    });
+  }
+  
+  if (majorIssues > 5) {
+    const estimatedImpact = Math.min(15, Math.round(majorIssues / 2));
+    recommendations.push({
+      action: 'Standardize naming conventions across codebase',
+      estimatedImpact,
+      priority: 'medium',
+    });
+  }
+  
+  if (issuesPerFile > 3) {
+    recommendations.push({
+      action: 'Establish and enforce coding style guide to reduce inconsistencies',
+      estimatedImpact: 12,
+      priority: 'medium',
+    });
+  }
+  
+  if (totalIssues > 20 && minorIssues / totalIssues > 0.7) {
+    recommendations.push({
+      action: 'Enable linter/formatter to automatically fix minor style issues',
+      estimatedImpact: 8,
+      priority: 'low',
+    });
+  }
+  
+  return {
+    toolName: 'consistency',
+    score,
+    rawMetrics: {
+      totalIssues,
+      criticalIssues,
+      majorIssues,
+      minorIssues,
+      issuesPerFile: Math.round(issuesPerFile * 100) / 100,
+      avgWeightedIssuesPerFile: Math.round(avgWeightedIssuesPerFile * 100) / 100,
+    },
+    factors,
+    recommendations,
+  };
+}