@aiready/consistency 0.20.2 → 0.20.3

package/src/analyzer.ts

@@ -2,7 +2,7 @@ import {
   scanFiles,
   Severity,
   IssueType,
-  GLOBAL_SCAN_OPTIONS,
+  getSeverityLevel,
 } from '@aiready/core';
 import type { AnalysisResult, Issue } from '@aiready/core';
 import type {
@@ -58,149 +58,70 @@ export async function analyzeConsistency(
 
   // Process naming issues
   for (const issue of namingIssues) {
-    if (!shouldIncludeSeverity(issue.severity, minSeverity)) {
-      continue;
-    }
-
-    const consistencyIssue: ConsistencyIssue = {
-      type:
-        issue.type === 'convention-mix'
-          ? IssueType.NamingInconsistency
-          : IssueType.NamingQuality,
-      category: 'naming',
-      severity: getSeverityEnum(issue.severity),
-      message: `${issue.type}: ${issue.identifier}`,
-      location: {
-        file: issue.file,
-        line: issue.line,
-        column: issue.column,
-      },
-      suggestion: issue.suggestion,
-    };
-
-    if (!fileIssuesMap.has(issue.file)) {
-      fileIssuesMap.set(issue.file, []);
-    }
-    fileIssuesMap.get(issue.file)!.push(consistencyIssue);
+    if (!shouldIncludeSeverity(issue.severity, minSeverity)) continue;
+
+    const fileName =
+      (issue as any).fileName ||
+      (issue as any).file ||
+      (issue as any).filePath ||
+      'unknown';
+    if (!fileIssuesMap.has(fileName)) fileIssuesMap.set(fileName, []);
+    fileIssuesMap.get(fileName)!.push(issue as unknown as ConsistencyIssue);
   }
 
   // Process pattern issues
   for (const issue of patternIssues) {
-    if (!shouldIncludeSeverity(issue.severity, minSeverity)) {
-      continue;
-    }
-
-    const consistencyIssue: ConsistencyIssue = {
-      type: IssueType.PatternInconsistency,
-      category: 'patterns',
-      severity: getSeverityEnum(issue.severity),
-      message: issue.description,
-      location: {
-        file: issue.files[0] || 'multiple files',
-        line: 1,
-      },
-      examples: issue.examples,
-      suggestion: `Standardize ${issue.type} patterns across ${issue.files.length} files`,
-    };
-
-    // Add to first file in the pattern
-    const firstFile = issue.files[0];
-    if (firstFile && !fileIssuesMap.has(firstFile)) {
-      fileIssuesMap.set(firstFile, []);
-    }
-    if (firstFile) {
-      fileIssuesMap.get(firstFile)!.push(consistencyIssue);
-    }
+    if (!shouldIncludeSeverity(issue.severity, minSeverity)) continue;
+
+    const fileName =
+      (issue as any).fileName ||
+      (issue as any).file ||
+      (issue as any).filePath ||
+      (Array.isArray((issue as any).files)
+        ? (issue as any).files[0]
+        : 'unknown');
+    if (!fileIssuesMap.has(fileName)) fileIssuesMap.set(fileName, []);
+    fileIssuesMap.get(fileName)!.push(issue as unknown as ConsistencyIssue);
   }
 
-  // Convert to AnalysisResult format
-  for (const [fileName, issues] of fileIssuesMap) {
+  // Build final results
+  for (const [fileName, issues] of fileIssuesMap.entries()) {
     results.push({
       fileName,
-      issues: issues as Issue[],
+      issues: issues.map((i) => transformToIssue(i)),
       metrics: {
         consistencyScore: calculateConsistencyScore(issues),
       },
     });
   }
 
-  // Sort results by severity first, then by issue count per file
-  results.sort((fileResultA, fileResultB) => {
-    // Get highest severity in each file
-    const maxSeverityA = Math.min(
-      ...fileResultA.issues.map((i) => {
-        const val = getSeverityLevel((i as ConsistencyIssue).severity);
-        // Map 4->0, 3->1, 2->2, 1->3
-        return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
-      })
-    );
-    const maxSeverityB = Math.min(
-      ...fileResultB.issues.map((i) => {
-        const val = getSeverityLevel((i as ConsistencyIssue).severity);
-        return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
-      })
-    );
-
-    // Sort by severity first
-    if (maxSeverityA !== maxSeverityB) {
-      return maxSeverityA - maxSeverityB;
-    }
-
-    // Then by issue count (descending)
-    return fileResultB.issues.length - fileResultA.issues.length;
-  });
-
-  // Generate recommendations
-  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;
+  // Generate high-level recommendations
+  const recommendations: string[] = [];
+  if (namingIssues.length > 0) {
+    recommendations.push('Standardize naming conventions across the codebase');
+  }
+  if (patternIssues.length > 0) {
+    recommendations.push('Consolidate repetitive implementation patterns');
+  }
+  if (results.some((r) => (r.metrics?.consistencyScore ?? 1) < 0.8)) {
+    recommendations.push('Improve cross-module consistency to reduce AI confusion');
+  }
 
   return {
+    results,
     summary: {
-      totalIssues: namingCountFiltered + patternCountFiltered,
-      namingIssues: namingCountFiltered,
-      patternIssues: patternCountFiltered,
-      architectureIssues: 0,
       filesAnalyzed: filePaths.length,
-      config: Object.fromEntries(
-        Object.entries(options).filter(
-          ([key]) => !GLOBAL_SCAN_OPTIONS.includes(key) || key === 'rootDir'
-        )
-      ),
+      totalIssues: results.reduce((acc, r) => acc + r.issues.length, 0),
+      namingIssues: namingIssues.length,
+      patternIssues: patternIssues.length,
+      architectureIssues: 0,
     },
-    results,
     recommendations,
-  };
-}
-
-function getSeverityLevel(s: any): number {
-  if (s === Severity.Critical || s === 'critical') return 4;
-  if (s === Severity.Major || s === 'major') return 3;
-  if (s === Severity.Minor || s === 'minor') return 2;
-  if (s === Severity.Info || s === 'info') return 1;
-  return 0;
-}
-
-function getSeverityEnum(s: any): Severity {
-  const val = getSeverityLevel(s);
-  switch (val) {
-    case 4:
-      return Severity.Critical;
-    case 3:
-      return Severity.Major;
-    case 2:
-      return Severity.Minor;
-    case 1:
-      return Severity.Info;
-    default:
-      return Severity.Info;
-  }
+    metadata: {
+      toolName: 'naming-consistency',
+      timestamp: new Date().toISOString(),
+    },
+  } as unknown as ConsistencyReport;
 }
 
 function shouldIncludeSeverity(
@@ -210,6 +131,91 @@ function shouldIncludeSeverity(
   return getSeverityLevel(severity) >= getSeverityLevel(minSeverity);
 }
 
+/**
+ * Map string type to IssueType enum value
+ */
+function getIssueType(type: string | undefined): IssueType {
+  if (!type) return IssueType.NamingInconsistency;
+
+  // Map string values to enum
+  const typeMap: Record<string, IssueType> = {
+    'naming-inconsistency': IssueType.NamingInconsistency,
+    'naming-quality': IssueType.NamingQuality,
+    'pattern-inconsistency': IssueType.PatternInconsistency,
+    'architecture-inconsistency': IssueType.ArchitectureInconsistency,
+    'error-handling': IssueType.PatternInconsistency,
+    'async-style': IssueType.PatternInconsistency,
+    'import-style': IssueType.PatternInconsistency,
+    'api-design': IssueType.PatternInconsistency,
+  };
+
+  return typeMap[type] || IssueType.NamingInconsistency;
+}
+
+/**
+ * Transform NamingIssue or PatternIssue to the required Issue format
+ */
+function transformToIssue(i: any): Issue {
+  // If already has message and location, return as is
+  if (i.message && i.location) {
+    return {
+      type: getIssueType(i.type),
+      severity: i.severity as Severity,
+      message: i.message,
+      location: i.location,
+      suggestion: i.suggestion,
+    };
+  }
+
+  // Handle NamingIssue format (has file, line, column, identifier, suggestion)
+  if (i.identifier || i.type) {
+    const line = i.line || 1;
+    const column = i.column || 1;
+    return {
+      type: getIssueType(i.type),
+      severity: i.severity as Severity,
+      message: i.suggestion
+        ? `Naming issue: ${i.suggestion}`
+        : `Naming issue for '${i.identifier || 'unknown'}'`,
+      location: {
+        file: i.file || i.fileName || '',
+        line,
+        column,
+        endLine: line,
+        endColumn: column + (i.identifier?.length || 10),
+      },
+      suggestion: i.suggestion,
+    };
+  }
+
+  // Handle PatternIssue format (has description, files)
+  if (i.description || i.files) {
+    const fileName = Array.isArray(i.files) ? i.files[0] : i.file || '';
+    return {
+      type: getIssueType(i.type),
+      severity: i.severity as Severity,
+      message: i.description || 'Pattern inconsistency found',
+      location: {
+        file: fileName,
+        line: 1,
+        column: 1,
+        endLine: 1,
+        endColumn: 10,
+      },
+      suggestion: i.examples?.[0],
+    };
+  }
+
+  // Fallback
+  return {
+    type: getIssueType(i.type),
+    severity: i.severity as Severity,
+    message: i.message || 'Unknown issue',
+    location: i.location || { file: '', line: 1, column: 1 },
+    suggestion: i.suggestion,
+  };
+}
+
 function calculateConsistencyScore(issues: ConsistencyIssue[]): number {
   let totalWeight = 0;
   for (const issue of issues) {
@@ -234,63 +240,3 @@ function calculateConsistencyScore(issues: ConsistencyIssue[]): number {
   // Score from 0-1, where 1 is perfect
   return Math.max(0, 1 - totalWeight / 100);
 }
-
-function generateRecommendations(
-  namingIssues: any[],
-  patternIssues: any[]
-): string[] {
-  const recommendations: string[] = [];
-
-  if (namingIssues.length > 0) {
-    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;
-    if (poorNamingCount > 0) {
-      recommendations.push(
-        `Improve variable naming: Found ${poorNamingCount} single-letter or unclear variable names`
-      );
-    }
-  }
-
-  if (patternIssues.length > 0) {
-    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');
-    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');
-    if (importIssues.length > 0) {
-      recommendations.push(
-        'Use ES modules consistently across the project (avoid mixing with CommonJS)'
-      );
-    }
-  }
-
-  if (recommendations.length === 0) {
-    recommendations.push(
-      'No major consistency issues found! Your codebase follows good practices.'
-    );
-  }
-
-  return recommendations;
-}

package/src/analyzers/naming-ast.ts

@@ -4,9 +4,7 @@ import type { NamingIssue } from '../types';
 import {
   parseFile,
   traverseAST,
-  getFunctionName,
   getLineNumber,
-  isCoverageContext,
   isLoopStatement,
 } from '../utils/ast-parser';
 import {
@@ -154,7 +152,7 @@ function checkVariableNaming(
   issues: NamingIssue[],
   context: any
 ) {
-  const { name, node, line, options } = varInfo;
+  const { name, line, options } = varInfo;
 
   // Skip very common small names if they are in acceptable context
   if (isAcceptableInContext(name, context, options)) {
@@ -253,6 +251,13 @@ class ScopeTracker {
   }
 }
 
+/**
+ * Extracts identifiers from destructured patterns (object or array destructuring)
+ * and registers them in the scope tracker.
+ * @param node - The AST node representing the destructured pattern
+ * @param isParameter - When true, indicates the destructured variable is a function parameter; when false, it's a local variable
+ * @param scopeTracker - The scope tracker to register variables with
+ */
 function extractDestructuredIdentifiers(
   node: TSESTree.ObjectPattern | TSESTree.ArrayPattern,
   isParameter: boolean,

package/src/analyzers/naming-generalized.ts

@@ -5,7 +5,7 @@
  * naming conventions across all supported languages.
  */
 
-import { getParser, Severity, IssueType } from '@aiready/core';
+import { getParser, Severity } from '@aiready/core';
 import type { NamingIssue } from '../types';
 import { readFileSync } from 'fs';
 
@@ -31,7 +31,6 @@ export async function analyzeNamingGeneralized(
       // 1. Check Exports
       for (const exp of result.exports) {
         let pattern: RegExp | undefined;
-        const typeName = exp.type;
 
         if (exp.type === 'class') {
           pattern = conventions.classPattern;
@@ -49,7 +48,7 @@ export async function analyzeNamingGeneralized(
 
         if (pattern && !pattern.test(exp.name)) {
           issues.push({
-            type: 'poor-naming',
+            type: 'naming-inconsistency',
             identifier: exp.name,
             file,
             line: exp.loc?.start.line || 1,
@@ -72,7 +71,7 @@ export async function analyzeNamingGeneralized(
           ) {
             // This is often a 'convention-mix' issue (e.g. importing snake_case into camelCase project)
             issues.push({
-              type: 'convention-mix',
+              type: 'naming-inconsistency',
               identifier: spec,
               file,
               line: imp.loc?.start.line || 1,

package/src/analyzers/naming.ts

@@ -5,6 +5,8 @@ import type { NamingIssue } from '../types';
 /**
  * Legacy regex-based naming analyzer
  * (Used as fallback or for languages without AST support)
+ * @param filePaths - Array of file paths to analyze
+ * @returns Array of naming issues found
  */
 export async function analyzeNaming(
   filePaths: string[]

package/src/analyzers/patterns.ts

@@ -13,7 +13,6 @@ export async function analyzePatterns(
 
   // 1. Error handling style
   const tryCatchPattern = /try\s*\{/g;
-  const catchPattern = /catch\s*\(\s*(\w+)\s*\)/g;
 
   const styleStats = {
     tryCatch: 0,
@@ -39,8 +38,6 @@ export async function analyzePatterns(
     }
   }
 
-  const totalFiles = filePaths.length;
-
   // Report inconsistencies if there's a significant mix
   if (styleStats.tryCatch > 0 && styleStats.thenCatch > 0) {
     const dominant =
@@ -54,7 +51,7 @@ export async function analyzePatterns(
           ? c.match(tryCatchPattern)
           : c.match(/\.catch\s*\(/);
       }),
-      type: 'error-handling',
+      type: 'pattern-inconsistency',
       description: `Mixed error handling styles: codebase primarily uses ${dominant}, but found ${minority} in some files.`,
       examples: [dominant, minority],
       severity: Severity.Minor,
@@ -73,7 +70,7 @@ export async function analyzePatterns(
           ? c.match(/\brequire\s*\(/)
           : c.match(/\bimport\b/);
       }),
-      type: 'import-style',
+      type: 'pattern-inconsistency',
       description: `Mixed module systems: found both ESM and CommonJS.`,
       examples: ['import X from "y"', 'const X = require("y")'],
       severity: Severity.Major,

package/src/types.ts

@@ -43,7 +43,12 @@ export interface NamingIssue {
 
 export interface PatternIssue {
   files: string[];
-  type: 'error-handling' | 'async-style' | 'import-style' | 'api-design';
+  type:
+    | 'error-handling'
+    | 'async-style'
+    | 'import-style'
+    | 'api-design'
+    | 'pattern-inconsistency';
   description: string;
   examples: string[];
   severity: Severity;