@aiready/consistency 0.20.19 → 0.20.21

package/dist/index.mjs

@@ -1,8 +1,9 @@
 import {
   analyzeConsistency,
   analyzeNamingAST,
-  analyzePatterns
-} from "./chunk-6H3JHDP7.mjs";
+  analyzePatterns,
+  calculateConsistencyScore
+} from "./chunk-CLWNLHDB.mjs";
 
 // src/index.ts
 import { ToolRegistry } from "@aiready/core";
@@ -10,108 +11,10 @@ import { ToolRegistry } from "@aiready/core";
 // src/provider.ts
 import {
   createProvider,
-  ToolName as ToolName2
+  ToolName
 } from "@aiready/core";
-
-// src/scoring.ts
-import { calculateProductivityImpact, ToolName } from "@aiready/core";
-function calculateConsistencyScore(issues, totalFilesAnalyzed, costConfig) {
-  void costConfig;
-  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"
-    });
-  }
-  const productivityImpact = calculateProductivityImpact(issues);
-  return {
-    toolName: ToolName.NamingConsistency,
-    score,
-    rawMetrics: {
-      totalIssues,
-      criticalIssues,
-      majorIssues,
-      minorIssues,
-      issuesPerFile: Math.round(issuesPerFile * 100) / 100,
-      avgWeightedIssuesPerFile: Math.round(avgWeightedIssuesPerFile * 100) / 100,
-      // Business value metrics
-      estimatedDeveloperHours: productivityImpact.totalHours
-    },
-    factors,
-    recommendations
-  };
-}
-
-// src/provider.ts
 var ConsistencyProvider = createProvider({
-  id: ToolName2.NamingConsistency,
+  id: ToolName.NamingConsistency,
   alias: ["consistency", "naming", "standards"],
   version: "0.16.5",
   defaultWeight: 14,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/consistency",
-  "version": "0.20.19",
+  "version": "0.20.21",
   "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": "^14.0.0",
-    "@aiready/core": "0.23.20"
+    "@aiready/core": "0.23.22"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/__tests__/scoring.test.ts

@@ -52,12 +52,12 @@ describe('Consistency Scoring', () => {
       // 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
-      );
+      expect(
+        result.factors.some((f: any) => f.name === 'Critical Issues')
+      ).toBe(true);
+      expect(
+        result.recommendations.some((r: any) => r.priority === 'high')
+      ).toBe(true);
     });
 
     it('should apply weighted severity penalties', () => {
@@ -109,10 +109,10 @@ describe('Consistency Scoring', () => {
 
       expect(result.recommendations.length).toBeGreaterThan(0);
       expect(
-        result.recommendations.some((r) => r.action.includes('critical'))
+        result.recommendations.some((r: any) => r.action.includes('critical'))
       ).toBe(true);
       expect(
-        result.recommendations.some((r) => r.action.includes('naming'))
+        result.recommendations.some((r: any) => r.action.includes('naming'))
       ).toBe(true);
     });
 
@@ -136,7 +136,7 @@ describe('Consistency Scoring', () => {
       const result = calculateConsistencyScore(issues, 10);
 
       expect(
-        result.recommendations.some((r) => r.action.includes('linter'))
+        result.recommendations.some((r: any) => r.action.includes('linter'))
       ).toBe(true);
     });
 

package/src/analyzer.ts

@@ -13,6 +13,7 @@ import type {
 import { analyzeNamingAST } from './analyzers/naming-ast';
 import { analyzeNamingGeneralized } from './analyzers/naming-generalized';
 import { analyzePatterns } from './analyzers/patterns';
+import { calculateConsistencyScore as calculateConsistencyScoreFromScoring } from './scoring';
 
 /**
  * Main consistency analyzer that orchestrates all analysis types.
@@ -90,11 +91,15 @@ export async function analyzeConsistency(
 
   // Build final results
   for (const [fileName, issues] of fileIssuesMap.entries()) {
+    const scoreResult = calculateConsistencyScoreFromScoring(
+      issues,
+      filePaths.length
+    );
     results.push({
       fileName,
       issues: issues.map((i) => transformToIssue(i)),
       metrics: {
-        consistencyScore: calculateConsistencyScore(issues),
+        consistencyScore: scoreResult.score / 100,
       },
     });
   }
@@ -234,28 +239,3 @@ function transformToIssue(i: any): Issue {
     suggestion: i.suggestion,
   };
 }
-
-function calculateConsistencyScore(issues: ConsistencyIssue[]): number {
-  let totalWeight = 0;
-  for (const issue of issues) {
-    const val = getSeverityLevel(issue.severity);
-    switch (val) {
-      case 4:
-        totalWeight += 10;
-        break;
-      case 3:
-        totalWeight += 5;
-        break;
-      case 2:
-        totalWeight += 2;
-        break;
-      case 1:
-        totalWeight += 1;
-        break;
-      default:
-        totalWeight += 1;
-    }
-  }
-  // Score from 0-1, where 1 is perfect
-  return Math.max(0, 1 - totalWeight / 100);
-}

package/src/analyzers/naming-ast.ts

@@ -79,12 +79,10 @@ function analyzeIdentifiers(
             );
           } else if (param.type === 'ObjectPattern') {
             // Handle destructured parameters: { id, name }
-            extractDestructuredIdentifiers(
-              param,
-              true,
-              scopeTracker,
-              isArrowParameter
-            );
+            extractDestructuredIdentifiers(param, scopeTracker, {
+              isParameter: true,
+              isArrowParameter,
+            });
           }
         });
       }
@@ -299,10 +297,14 @@ class ScopeTracker {
  */
 function extractDestructuredIdentifiers(
   node: TSESTree.ObjectPattern | TSESTree.ArrayPattern,
-  isParameter: boolean,
   scopeTracker: ScopeTracker,
-  isArrowParameter: boolean = false
+  options: {
+    isParameter?: boolean;
+    isArrowParameter?: boolean;
+  } = {}
 ) {
+  const { isParameter = false, isArrowParameter = false } = options;
+
   if (node.type === 'ObjectPattern') {
     node.properties.forEach((prop) => {
       if (prop.type === 'Property' && prop.value.type === 'Identifier') {

package/src/analyzers/naming-generalized.ts

@@ -58,7 +58,7 @@ export async function analyzeNamingGeneralized(
   const issues: NamingIssue[] = [];
 
   for (const file of files) {
-    const parser = getParser(file);
+    const parser = await getParser(file);
     if (!parser) continue;
 
     try {