@aiready/consistency 0.8.31 → 0.8.34

package/dist/index.mjs

@@ -7,7 +7,7 @@ import {
   detectNamingConventions,
   loadNamingConfig,
   snakeCaseToCamelCase
-} from "./chunk-YEHXYHGY.mjs";
+} from "./chunk-J5IFYDVU.mjs";
 
 // src/analyzers/naming.ts
 import { readFileContent } from "@aiready/core";
@@ -16,7 +16,13 @@ async function analyzeNaming(files) {
   const { customAbbreviations, customShortWords, disabledChecks } = await loadNamingConfig(files);
   for (const file of files) {
     const content = await readFileContent(file);
-    const fileIssues = analyzeFileNaming(file, content, customAbbreviations, customShortWords, disabledChecks);
+    const fileIssues = analyzeFileNaming(
+      file,
+      content,
+      customAbbreviations,
+      customShortWords,
+      disabledChecks
+    );
     issues.push(...fileIssues);
   }
   return issues;
@@ -25,7 +31,10 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
   const issues = [];
   const isTestFile = file.match(/\.(test|spec)\.(ts|tsx|js|jsx)$/);
   const lines = content.split("\n");
-  const allAbbreviations = /* @__PURE__ */ new Set([...ACCEPTABLE_ABBREVIATIONS, ...customAbbreviations]);
+  const allAbbreviations = /* @__PURE__ */ new Set([
+    ...ACCEPTABLE_ABBREVIATIONS,
+    ...customAbbreviations
+  ]);
   const allShortWords = /* @__PURE__ */ new Set([...COMMON_SHORT_WORDS, ...customShortWords]);
   const getContextWindow = (index, windowSize = 3) => {
     const start = Math.max(0, index - windowSize);
@@ -49,7 +58,9 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
     const lineNumber = index + 1;
     const contextWindow = getContextWindow(index);
     if (!disabledChecks.has("single-letter")) {
-      const singleLetterMatches = line.matchAll(/\b(?:const|let|var)\s+([a-hm-z])\s*=/gi);
+      const singleLetterMatches = line.matchAll(
+        /\b(?:const|let|var)\s+([a-hm-z])\s*=/gi
+      );
       for (const match of singleLetterMatches) {
         const letter = match[1].toLowerCase();
         const isCoverageContext = /coverage|summary|metrics|pct|percent/i.test(line) || /\.(?:statements|branches|functions|lines)\.pct/i.test(line);
@@ -63,7 +74,9 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
         /[a-z]\s*=>/.test(line) || // s => on same line
         // Multi-line arrow function detection: look for pattern in context window
         new RegExp(`\\b${letter}\\s*\\)\\s*$`).test(line) && /=>/.test(contextWindow) || // (s)\n =>
-        new RegExp(`\\.(?:map|filter|forEach|reduce|find|some|every)\\s*\\(\\s*$`).test(lines[index - 1] || "") && /=>/.test(contextWindow);
+        new RegExp(
+          `\\.(?:map|filter|forEach|reduce|find|some|every)\\s*\\(\\s*$`
+        ).test(lines[index - 1] || "") && /=>/.test(contextWindow);
         const isShortLived = isShortLivedVariable(letter, index);
         if (!isInLoopContext && !isI18nContext && !isArrowFunctionParam && !isShortLived && !["x", "y", "z", "i", "j", "k", "l", "n", "m"].includes(letter)) {
           if (isTestFile && ["a", "b", "c", "d", "e", "f", "s"].includes(letter)) {
@@ -81,7 +94,9 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
       }
     }
     if (!disabledChecks.has("abbreviation")) {
-      const abbreviationMatches = line.matchAll(/\b(?:const|let|var)\s+([a-z]{1,3})(?=[A-Z]|_|\s*=)/g);
+      const abbreviationMatches = line.matchAll(
+        /\b(?:const|let|var)\s+([a-z]{1,3})(?=[A-Z]|_|\s*=)/g
+      );
       for (const match of abbreviationMatches) {
         const abbrev = match[1].toLowerCase();
         if (allShortWords.has(abbrev)) {
@@ -94,7 +109,9 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
         new RegExp(`\\b${abbrev}\\s*=>`).test(line) || // s => on same line
         // Multi-line arrow function: check context window
         new RegExp(`\\b${abbrev}\\s*\\)\\s*$`).test(line) && /=>/.test(contextWindow) || // (s)\n =>
-        new RegExp(`\\.(?:map|filter|forEach|reduce|find|some|every)\\s*\\(\\s*$`).test(lines[index - 1] || "") && new RegExp(`^\\s*${abbrev}\\s*=>`).test(line);
+        new RegExp(
+          `\\.(?:map|filter|forEach|reduce|find|some|every)\\s*\\(\\s*$`
+        ).test(lines[index - 1] || "") && new RegExp(`^\\s*${abbrev}\\s*=>`).test(line);
         if (isArrowFunctionParam) {
           continue;
         }
@@ -119,8 +136,13 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
       }
     }
     if (!disabledChecks.has("convention-mix") && file.match(/\.(ts|tsx|js|jsx)$/)) {
-      const camelCaseVars = line.match(/\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*)\s*=/);
-      const snakeCaseVars = line.match(/\b(?:const|let|var)\s+([a-z][a-z0-9]*_[a-z0-9_]*)\s*=/);
+      const camelCaseVars = line.match(
+        /\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*)\s*=/
+      );
+      void camelCaseVars;
+      const snakeCaseVars = line.match(
+        /\b(?:const|let|var)\s+([a-z][a-z0-9]*_[a-z0-9_]*)\s*=/
+      );
       if (snakeCaseVars) {
         issues.push({
           file,
@@ -133,7 +155,9 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
       }
     }
     if (!disabledChecks.has("unclear")) {
-      const booleanMatches = line.matchAll(/\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*)\s*:\s*boolean/gi);
+      const booleanMatches = line.matchAll(
+        /\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*)\s*:\s*boolean/gi
+      );
       for (const match of booleanMatches) {
         const name = match[1];
         if (!name.match(/^(is|has|should|can|will|did)/i)) {
@@ -152,25 +176,59 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
       const functionMatches = line.matchAll(/function\s+([a-z][a-zA-Z0-9]*)/g);
       for (const match of functionMatches) {
         const name = match[1];
-        const isKeyword = ["for", "if", "else", "while", "do", "switch", "case", "break", "continue", "return", "throw", "try", "catch", "finally", "with", "yield", "await"].includes(name);
+        const isKeyword = [
+          "for",
+          "if",
+          "else",
+          "while",
+          "do",
+          "switch",
+          "case",
+          "break",
+          "continue",
+          "return",
+          "throw",
+          "try",
+          "catch",
+          "finally",
+          "with",
+          "yield",
+          "await"
+        ].includes(name);
         if (isKeyword) {
           continue;
         }
-        const isEntryPoint = ["main", "init", "setup", "bootstrap"].includes(name);
+        const isEntryPoint = ["main", "init", "setup", "bootstrap"].includes(
+          name
+        );
         if (isEntryPoint) {
           continue;
         }
-        const isFactoryPattern = name.match(/(Factory|Builder|Creator|Generator|Provider|Adapter|Mock)$/);
+        const isFactoryPattern = name.match(
+          /(Factory|Builder|Creator|Generator|Provider|Adapter|Mock)$/
+        );
         const isEventHandler = name.match(/^on[A-Z]/);
         const isDescriptiveLong = name.length > 15;
         const isReactHook = name.match(/^use[A-Z]/);
-        const isDescriptivePattern = name.match(/^(default|total|count|sum|avg|max|min|initial|current|previous|next)\w+/) || name.match(/\w+(Count|Total|Sum|Average|List|Map|Set|Config|Settings|Options|Props|Data|Info|Details|State|Status|Response|Result)$/);
+        const isDescriptivePattern = name.match(
+          /^(default|total|count|sum|avg|max|min|initial|current|previous|next)\w+/
+        ) || name.match(
+          /\w+(Count|Total|Sum|Average|List|Map|Set|Config|Settings|Options|Props|Data|Info|Details|State|Status|Response|Result)$/
+        );
         const isHelperPattern = name.match(/^(to|from|with|without|for|as|into)\w+/) || // toMetadata, withLogger, forPath
         name.match(/^\w+(To|From|With|Without|For|As|Into)\w*$/);
-        const isUtilityName = ["cn", "proxy", "sitemap", "robots", "gtag"].includes(name);
+        const isUtilityName = [
+          "cn",
+          "proxy",
+          "sitemap",
+          "robots",
+          "gtag"
+        ].includes(name);
         const capitalCount = (name.match(/[A-Z]/g) || []).length;
         const isCompoundWord = capitalCount >= 3;
-        const hasActionVerb = name.match(/^(get|set|is|has|can|should|create|update|delete|fetch|load|save|process|handle|validate|check|find|search|filter|map|reduce|make|do|run|start|stop|build|parse|format|render|calculate|compute|generate|transform|convert|normalize|sanitize|encode|decode|compress|extract|merge|split|join|sort|compare|test|verify|ensure|apply|execute|invoke|call|emit|dispatch|trigger|listen|subscribe|unsubscribe|add|remove|clear|reset|toggle|enable|disable|open|close|connect|disconnect|send|receive|read|write|import|export|register|unregister|mount|unmount|track|store|persist|upsert|derive|classify|combine|discover|activate|require|assert|expect|mask|escape|sign|put|list|complete|page|safe|mock|pick|pluralize|text)/);
+        const hasActionVerb = name.match(
+          /^(get|set|is|has|can|should|create|update|delete|fetch|load|save|process|handle|validate|check|find|search|filter|map|reduce|make|do|run|start|stop|build|parse|format|render|calculate|compute|generate|transform|convert|normalize|sanitize|encode|decode|compress|extract|merge|split|join|sort|compare|test|verify|ensure|apply|execute|invoke|call|emit|dispatch|trigger|listen|subscribe|unsubscribe|add|remove|clear|reset|toggle|enable|disable|open|close|connect|disconnect|send|receive|read|write|import|export|register|unregister|mount|unmount|track|store|persist|upsert|derive|classify|combine|discover|activate|require|assert|expect|mask|escape|sign|put|list|complete|page|safe|mock|pick|pluralize|text)/
+        );
         if (!hasActionVerb && !isFactoryPattern && !isEventHandler && !isDescriptiveLong && !isDescriptivePattern && !isCompoundWord && !isHelperPattern && !isUtilityName && !isReactHook) {
           issues.push({
             file,
@@ -188,10 +246,9 @@ function analyzeFileNaming(file, content, customAbbreviations, customShortWords,
 }
 
 // src/scoring.ts
-import {
-  calculateProductivityImpact
-} from "@aiready/core";
+import { calculateProductivityImpact } 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/consistency",
-  "version": "0.8.31",
+  "version": "0.8.34",
   "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.9.32"
+    "@aiready/core": "0.9.35"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/__tests__/analyzer.test.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect } from 'vitest';
 import { analyzeConsistency } from '../analyzer';
-import { analyzeNaming } from '../analyzers/naming';
 import { analyzePatterns } from '../analyzers/patterns';
 
 describe('analyzeConsistency', () => {
@@ -39,6 +38,8 @@ const x = 10;
 const y = 20;
 const result = x + y;
 `;
+    void testCode;
+    void 0;
     // In a real test, we'd create temp files or mock file reading
     // For now, this is a placeholder structure
     expect(true).toBe(true);
@@ -47,12 +48,45 @@ const result = x + y;
   it('should NOT flag acceptable abbreviations', () => {
     // These should all be acceptable and NOT flagged
     const acceptableAbbreviations = [
-      'env', 'req', 'res', 'ctx', 'err', 'api', 'url', 'id',
-      'max', 'min', 'now', 'utm', 'has', 'is', 'can',
-      'db', 'fs', 'os', 'ui', 'tmp', 'src', 'dst',
+      'env',
+      'req',
+      'res',
+      'ctx',
+      'err',
+      'api',
+      'url',
+      'id',
+      'max',
+      'min',
+      'now',
+      'utm',
+      'has',
+      'is',
+      'can',
+      'db',
+      'fs',
+      'os',
+      'ui',
+      'tmp',
+      'src',
+      'dst',
       // New additions from Phase 1
-      'img', 'txt', 'doc', 'md', 'ts', 'js', 'ddb', 's3',
-      'fcp', 'lcp', 'fps', 'po', 'dto', 'e2e', 'a11y', 'i18n'
+      'img',
+      'txt',
+      'doc',
+      'md',
+      'ts',
+      'js',
+      'ddb',
+      's3',
+      'fcp',
+      'lcp',
+      'fps',
+      'po',
+      'dto',
+      'e2e',
+      'a11y',
+      'i18n',
     ];
     // These abbreviations should not trigger warnings
     expect(acceptableAbbreviations.length).toBeGreaterThan(0);
@@ -61,8 +95,24 @@ const result = x + y;
   it('should NOT flag common short English words', () => {
     // Full words, not abbreviations - should be accepted
     const commonWords = [
-      'day', 'key', 'net', 'to', 'go', 'for', 'not', 'new', 'old',
-      'top', 'end', 'run', 'try', 'use', 'get', 'set', 'add', 'put'
+      'day',
+      'key',
+      'net',
+      'to',
+      'go',
+      'for',
+      'not',
+      'new',
+      'old',
+      'top',
+      'end',
+      'run',
+      'try',
+      'use',
+      'get',
+      'set',
+      'add',
+      'put',
     ];
     // These are full words and should not be flagged as abbreviations
     expect(commonWords.length).toBeGreaterThan(0);
@@ -73,6 +123,7 @@ const result = x + y;
 const user_name = 'John';
 const user_id = 123;
 `;
+    void testCode;
     // Test would check for convention-mix issues
     expect(true).toBe(true);
   });
@@ -82,6 +133,7 @@ const user_id = 123;
 const enabled: boolean = true;
 const active: boolean = false;
 `;
+    void testCode;
     // Should suggest prefixes like isEnabled, isActive
     expect(true).toBe(true);
   });
@@ -92,6 +144,7 @@ const id = '123';
 const url = 'https://example.com';
 const api = new ApiClient();
 `;
+    void testCode;
     // Should not flag these as issues
     expect(true).toBe(true);
   });
@@ -108,6 +161,7 @@ items.filter(
     item.valid
 )
 `;
+    void multiLineArrowCode;
     // 's' and 'item' should not be flagged as poor naming
     expect(true).toBe(true);
   });
@@ -119,6 +173,7 @@ const a = obj1;
 const b = obj2;
 return compare(a, b);
 `;
+    void shortLivedCode;
     // 'a' and 'b' should not be flagged as they're short-lived
     expect(true).toBe(true);
   });

package/src/__tests__/language-filter.test.ts

@@ -13,10 +13,10 @@ describe('Language File Filtering', () => {
       '/path/to/file.tsx',
       '/path/to/file.js',
       '/path/to/file.jsx',
-      '/path/to/file.py',     // Should be filtered out
-      '/path/to/file.java',   // Should be filtered out
-      '/path/to/file.rb',     // Should be filtered out
-      '/path/to/file.go',     // Should be filtered out
+      '/path/to/file.py', // Should be filtered out
+      '/path/to/file.java', // Should be filtered out
+      '/path/to/file.rb', // Should be filtered out
+      '/path/to/file.go', // Should be filtered out
     ];
 
     // This test verifies that the function doesn't crash on non-JS/TS files
@@ -26,10 +26,7 @@ describe('Language File Filtering', () => {
   });
 
   it('should filter out Python files before parsing', async () => {
-    const files = [
-      '/path/to/script.py',
-      '/path/to/another.py',
-    ];
+    const files = ['/path/to/script.py', '/path/to/another.py'];
 
     // Should not attempt to parse Python files
     const result = await analyzeNamingAST(files);
@@ -42,7 +39,7 @@ describe('Language File Filtering', () => {
       'test.jsx',
       'test.ts',
       'test.tsx',
-      'TEST.JS',  // Test case-insensitive
+      'TEST.JS', // Test case-insensitive
       'TEST.TS',
     ];
 

package/src/__tests__/scoring.test.ts

@@ -52,8 +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) => f.name === 'Critical Issues')).toBe(
+        true
+      );
+      expect(result.recommendations.some((r) => r.priority === 'high')).toBe(
+        true
+      );
     });
 
     it('should apply weighted severity penalties', () => {
@@ -84,8 +88,14 @@ describe('Consistency Scoring', () => {
 
     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),
+        ...Array(3).fill({
+          severity: 'critical',
+          category: 'naming',
+        } as ConsistencyIssue),
+        ...Array(10).fill({
+          severity: 'major',
+          category: 'patterns',
+        } as ConsistencyIssue),
       ];
 
       const result = calculateConsistencyScore(
@@ -98,8 +108,12 @@ describe('Consistency Scoring', () => {
       );
 
       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);
+      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', () => {
@@ -121,14 +135,25 @@ describe('Consistency Scoring', () => {
 
       const result = calculateConsistencyScore(issues, 10);
 
-      expect(result.recommendations.some(r => r.action.includes('linter'))).toBe(true);
+      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),
+        ...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(

package/src/analyzer.ts

@@ -1,6 +1,10 @@
 import { scanFiles } from '@aiready/core';
 import type { AnalysisResult, Issue } from '@aiready/core';
-import type { ConsistencyOptions, ConsistencyReport, ConsistencyIssue } from './types';
+import type {
+  ConsistencyOptions,
+  ConsistencyReport,
+  ConsistencyIssue,
+} from './types';
 import { analyzeNamingAST } from './analyzers/naming-ast';
 import { analyzePythonNaming } from './analyzers/naming-python';
 import { analyzePatterns } from './analyzers/patterns';
@@ -20,21 +24,26 @@ export async function analyzeConsistency(
     ...scanOptions
   } = options;
 
+  // Mark intentionally-unused option to avoid lint warnings
+  void checkArchitecture;
+
   // Scan files
   const filePaths = await scanFiles(scanOptions);
 
   // Separate files by language
-  const tsJsFiles = filePaths.filter(f => /\.(ts|tsx|js|jsx)$/i.test(f));
-  const pythonFiles = filePaths.filter(f => /\.py$/i.test(f));
+  const tsJsFiles = filePaths.filter((f) => /\.(ts|tsx|js|jsx)$/i.test(f));
+  const pythonFiles = filePaths.filter((f) => /\.py$/i.test(f));
 
   // Collect issues by category - now handles multiple languages
   let namingIssues: any[] = [];
   if (checkNaming) {
-    const tsJsNamingIssues = tsJsFiles.length > 0 ? await analyzeNamingAST(tsJsFiles) : [];
-    const pythonNamingIssues = pythonFiles.length > 0 ? await analyzePythonNaming(pythonFiles) : [];
+    const tsJsNamingIssues =
+      tsJsFiles.length > 0 ? await analyzeNamingAST(tsJsFiles) : [];
+    const pythonNamingIssues =
+      pythonFiles.length > 0 ? await analyzePythonNaming(pythonFiles) : [];
     namingIssues = [...tsJsNamingIssues, ...pythonNamingIssues];
   }
-  
+
   const patternIssues = checkPatterns ? await analyzePatterns(filePaths) : [];
 
   // Convert to AnalysisResult format
@@ -48,16 +57,19 @@ export async function analyzeConsistency(
     }
 
     const consistencyIssue: ConsistencyIssue = {
-      type: issue.type === 'convention-mix' ? 'naming-inconsistency' : 'naming-quality',
+      type:
+        issue.type === 'convention-mix'
+          ? 'naming-inconsistency'
+          : 'naming-quality',
       category: 'naming',
       severity: issue.severity,
       message: `${issue.type}: ${issue.identifier}`,
       location: {
         file: issue.file,
         line: issue.line,
-        column: issue.column
+        column: issue.column,
       },
-      suggestion: issue.suggestion
+      suggestion: issue.suggestion,
     };
 
     if (!fileIssuesMap.has(issue.file)) {
@@ -79,10 +91,10 @@ export async function analyzeConsistency(
       message: issue.description,
       location: {
         file: issue.files[0] || 'multiple files',
-        line: 1
+        line: 1,
       },
       examples: issue.examples,
-      suggestion: `Standardize ${issue.type} patterns across ${issue.files.length} files`
+      suggestion: `Standardize ${issue.type} patterns across ${issue.files.length} files`,
     };
 
     // Add to first file in the pattern
@@ -101,28 +113,32 @@ export async function analyzeConsistency(
       fileName,
       issues: issues as Issue[],
       metrics: {
-        consistencyScore: calculateConsistencyScore(issues)
-      }
+        consistencyScore: calculateConsistencyScore(issues),
+      },
     });
   }
 
   // Sort results by severity first, then by issue count per file
   results.sort((fileResultA, fileResultB) => {
     const severityOrder = { critical: 0, major: 1, minor: 2, info: 3 };
-    
+
     // Get highest severity in each file
     const maxSeverityA = Math.min(
-      ...fileResultA.issues.map(i => severityOrder[(i as ConsistencyIssue).severity])
+      ...fileResultA.issues.map(
+        (i) => severityOrder[(i as ConsistencyIssue).severity]
+      )
     );
     const maxSeverityB = Math.min(
-      ...fileResultB.issues.map(i => severityOrder[(i as ConsistencyIssue).severity])
+      ...fileResultB.issues.map(
+        (i) => severityOrder[(i as ConsistencyIssue).severity]
+      )
     );
-    
+
     // Sort by severity first
     if (maxSeverityA !== maxSeverityB) {
       return maxSeverityA - maxSeverityB;
     }
-    
+
     // Then by issue count (descending)
     return fileResultB.issues.length - fileResultA.issues.length;
   });
@@ -131,8 +147,12 @@ export async function analyzeConsistency(
   const recommendations = generateRecommendations(namingIssues, patternIssues);
 
   // Compute filtered counts (respecting minSeverity) to report accurate summary
-  const namingCountFiltered = namingIssues.filter(i => shouldIncludeSeverity(i.severity, minSeverity)).length;
-  const patternCountFiltered = patternIssues.filter(i => shouldIncludeSeverity(i.severity, minSeverity)).length;
+  const namingCountFiltered = namingIssues.filter((i) =>
+    shouldIncludeSeverity(i.severity, minSeverity)
+  ).length;
+  const patternCountFiltered = patternIssues.filter((i) =>
+    shouldIncludeSeverity(i.severity, minSeverity)
+  ).length;
 
   // Detect naming conventions (TODO: re-implement for AST version)
   // const conventionAnalysis = detectNamingConventions(filePaths, namingIssues);
@@ -143,10 +163,10 @@ export async function analyzeConsistency(
       namingIssues: namingCountFiltered,
       patternIssues: patternCountFiltered,
       architectureIssues: 0,
-      filesAnalyzed: filePaths.length
+      filesAnalyzed: filePaths.length,
     },
     results,
-    recommendations
+    recommendations,
   };
 }
 
@@ -161,7 +181,10 @@ function shouldIncludeSeverity(
 function calculateConsistencyScore(issues: ConsistencyIssue[]): number {
   // Higher score = more consistent (fewer issues)
   const weights = { critical: 10, major: 5, minor: 2, info: 1 };
-  const totalWeight = issues.reduce((sum, issue) => sum + weights[issue.severity], 0);
+  const totalWeight = issues.reduce(
+    (sum, issue) => sum + weights[issue.severity],
+    0
+  );
   // Score from 0-1, where 1 is perfect
   return Math.max(0, 1 - totalWeight / 100);
 }
@@ -173,14 +196,18 @@ function generateRecommendations(
   const recommendations: string[] = [];
 
   if (namingIssues.length > 0) {
-    const conventionMixCount = namingIssues.filter(i => i.type === 'convention-mix').length;
+    const conventionMixCount = namingIssues.filter(
+      (i) => i.type === 'convention-mix'
+    ).length;
     if (conventionMixCount > 0) {
       recommendations.push(
         `Standardize naming conventions: Found ${conventionMixCount} snake_case variables in TypeScript/JavaScript (use camelCase)`
       );
     }
 
-    const poorNamingCount = namingIssues.filter(i => i.type === 'poor-naming').length;
+    const poorNamingCount = namingIssues.filter(
+      (i) => i.type === 'poor-naming'
+    ).length;
     if (poorNamingCount > 0) {
       recommendations.push(
         `Improve variable naming: Found ${poorNamingCount} single-letter or unclear variable names`
@@ -189,21 +216,23 @@ function generateRecommendations(
   }
 
   if (patternIssues.length > 0) {
-    const errorHandlingIssues = patternIssues.filter(i => i.type === 'error-handling');
+    const errorHandlingIssues = patternIssues.filter(
+      (i) => i.type === 'error-handling'
+    );
     if (errorHandlingIssues.length > 0) {
       recommendations.push(
         'Standardize error handling strategy across the codebase (prefer try-catch with typed errors)'
       );
     }
 
-    const asyncIssues = patternIssues.filter(i => i.type === 'async-style');
+    const asyncIssues = patternIssues.filter((i) => i.type === 'async-style');
     if (asyncIssues.length > 0) {
       recommendations.push(
         'Use async/await consistently instead of mixing with promise chains or callbacks'
       );
     }
 
-    const importIssues = patternIssues.filter(i => i.type === 'import-style');
+    const importIssues = patternIssues.filter((i) => i.type === 'import-style');
     if (importIssues.length > 0) {
       recommendations.push(
         'Use ES modules consistently across the project (avoid mixing with CommonJS)'
@@ -212,7 +241,9 @@ function generateRecommendations(
   }
 
   if (recommendations.length === 0) {
-    recommendations.push('No major consistency issues found! Your codebase follows good practices.');
+    recommendations.push(
+      'No major consistency issues found! Your codebase follows good practices.'
+    );
   }
 
   return recommendations;