@aiready/consistency 0.16.2 → 0.16.3

package/src/analyzers/patterns.ts

@@ -1,251 +1,74 @@
-import { readFileContent } from '@aiready/core';
+import { readFileSync } from 'fs';
+import { Severity } from '@aiready/core';
 import type { PatternIssue } from '../types';
 
 /**
- * Analyzes code pattern consistency
+ * Detect inconsistent code patterns across files
  */
-export async function analyzePatterns(
-  files: string[]
-): Promise<PatternIssue[]> {
+export async function analyzePatterns(filePaths: string[]): Promise<PatternIssue[]> {
   const issues: PatternIssue[] = [];
-
-  // Analyze error handling patterns
-  const errorHandlingIssues = await analyzeErrorHandling(files);
-  issues.push(...errorHandlingIssues);
-
-  // Analyze async/await patterns
-  const asyncIssues = await analyzeAsyncPatterns(files);
-  issues.push(...asyncIssues);
-
-  // Analyze import styles
-  const importIssues = await analyzeImportStyles(files);
-  issues.push(...importIssues);
-
-  return issues;
-}
-
-async function analyzeErrorHandling(files: string[]): Promise<PatternIssue[]> {
-  const patterns = {
-    tryCatch: [] as string[],
-    throwsError: [] as string[],
-    returnsNull: [] as string[],
-    returnsError: [] as string[],
+  const contents = new Map<string, string>();
+
+  // 1. Error handling style
+  const tryCatchPattern = /try\s*\{/g;
+  const catchPattern = /catch\s*\(\s*(\w+)\s*\)/g;
+  
+  const styleStats = {
+    tryCatch: 0,
+    thenCatch: 0,
+    asyncAwait: 0,
+    commonJs: 0,
+    esm: 0,
   };
 
-  for (const file of files) {
-    const content = await readFileContent(file);
-
-    if (content.includes('try {') || content.includes('} catch')) {
-      patterns.tryCatch.push(file);
-    }
-    if (content.match(/throw new \w*Error/)) {
-      patterns.throwsError.push(file);
-    }
-    if (content.match(/return null/)) {
-      patterns.returnsNull.push(file);
-    }
-    if (content.match(/return \{ error:/)) {
-      patterns.returnsError.push(file);
+  for (const filePath of filePaths) {
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      contents.set(filePath, content);
+
+      if (content.match(tryCatchPattern)) styleStats.tryCatch++;
+      if (content.match(/\.catch\s*\(/)) styleStats.thenCatch++;
+      if (content.match(/\bawait\b/)) styleStats.asyncAwait++;
+      
+      if (content.match(/\brequire\s*\(/)) styleStats.commonJs++;
+      if (content.match(/\bimport\b.*\bfrom\b/)) styleStats.esm++;
+    } catch (err) {
+      void err;
     }
   }
 
-  const issues: PatternIssue[] = [];
+  const totalFiles = filePaths.length;
 
-  // Check for mixed error handling strategies
-  const strategiesUsed = Object.values(patterns).filter(
-    (p) => p.length > 0
-  ).length;
-  if (strategiesUsed > 2) {
+  // Report inconsistencies if there's a significant mix
+  if (styleStats.tryCatch > 0 && styleStats.thenCatch > 0) {
+    const dominant = styleStats.tryCatch >= styleStats.thenCatch ? 'try-catch' : '.catch()';
+    const minority = dominant === 'try-catch' ? '.catch()' : 'try-catch';
+    
     issues.push({
-      files: [
-        ...new Set([
-          ...patterns.tryCatch,
-          ...patterns.throwsError,
-          ...patterns.returnsNull,
-          ...patterns.returnsError,
-        ]),
-      ],
+      files: filePaths.filter(f => {
+        const c = contents.get(f) || '';
+        return minority === 'try-catch' ? c.match(tryCatchPattern) : c.match(/\.catch\s*\(/);
+      }),
       type: 'error-handling',
-      description: 'Inconsistent error handling strategies across codebase',
-      examples: [
-        patterns.tryCatch.length > 0
-          ? `Try-catch used in ${patterns.tryCatch.length} files`
-          : '',
-        patterns.throwsError.length > 0
-          ? `Throws errors in ${patterns.throwsError.length} files`
-          : '',
-        patterns.returnsNull.length > 0
-          ? `Returns null in ${patterns.returnsNull.length} files`
-          : '',
-        patterns.returnsError.length > 0
-          ? `Returns error objects in ${patterns.returnsError.length} files`
-          : '',
-      ].filter((e) => e),
-      severity: 'major',
-    });
-  }
-
-  return issues;
-}
-
-async function analyzeAsyncPatterns(files: string[]): Promise<PatternIssue[]> {
-  const patterns = {
-    asyncAwait: [] as string[],
-    promises: [] as string[],
-    callbacks: [] as string[],
-  };
-
-  for (const file of files) {
-    const content = await readFileContent(file);
-
-    if (content.match(/async\s+(function|\(|[a-zA-Z])/)) {
-      patterns.asyncAwait.push(file);
-    }
-    if (content.match(/\.then\(/) || content.match(/\.catch\(/)) {
-      patterns.promises.push(file);
-    }
-    if (content.match(/callback\s*\(/) || content.match(/\(\s*err\s*,/)) {
-      patterns.callbacks.push(file);
-    }
-  }
-
-  const issues: PatternIssue[] = [];
-
-  // Modern codebases should prefer async/await
-  if (patterns.callbacks.length > 0 && patterns.asyncAwait.length > 0) {
-    issues.push({
-      files: [...patterns.callbacks, ...patterns.asyncAwait],
-      type: 'async-style',
-      description: 'Mixed async patterns: callbacks and async/await',
-      examples: [
-        `Callbacks found in: ${patterns.callbacks.slice(0, 3).join(', ')}`,
-        `Async/await used in: ${patterns.asyncAwait.slice(0, 3).join(', ')}`,
-      ],
-      severity: 'minor',
-    });
-  }
-
-  // Mixing .then() chains with async/await
-  if (
-    patterns.promises.length > patterns.asyncAwait.length * 0.3 &&
-    patterns.asyncAwait.length > 0
-  ) {
-    issues.push({
-      files: patterns.promises,
-      type: 'async-style',
-      description:
-        'Consider using async/await instead of promise chains for consistency',
-      examples: patterns.promises.slice(0, 5),
-      severity: 'info',
+      description: `Mixed error handling styles: codebase primarily uses ${dominant}, but found ${minority} in some files.`,
+      examples: [dominant, minority],
+      severity: Severity.Minor,
     });
   }
 
-  return issues;
-}
-
-async function analyzeImportStyles(files: string[]): Promise<PatternIssue[]> {
-  const patterns = {
-    esModules: [] as string[],
-    commonJS: [] as string[],
-    mixed: [] as string[],
-  };
-
-  for (const file of files) {
-    const content = await readFileContent(file);
-    const hasESM = content.match(/^import\s+/m);
-
-    // Check for actual CommonJS require() calls, excluding:
-    // - String literals: "require('...') or 'require('...')
-    // - Regex patterns: /require\(/
-    // - Comments: // require( or /* require( */
-    const hasCJS = hasActualRequireCalls(content);
-
-    if (hasESM && hasCJS) {
-      patterns.mixed.push(file);
-    } else if (hasESM) {
-      patterns.esModules.push(file);
-    } else if (hasCJS) {
-      patterns.commonJS.push(file);
-    }
-  }
-
-  const issues: PatternIssue[] = [];
-
-  // Check for mixed import styles in same file
-  if (patterns.mixed.length > 0) {
+  if (styleStats.commonJs > 0 && styleStats.esm > 0) {
+    const minority = styleStats.esm >= styleStats.commonJs ? 'CommonJS (require)' : 'ESM (import)';
     issues.push({
-      files: patterns.mixed,
+      files: filePaths.filter(f => {
+        const c = contents.get(f) || '';
+        return minority === 'CommonJS (require)' ? c.match(/\brequire\s*\(/) : c.match(/\bimport\b/);
+      }),
       type: 'import-style',
-      description: 'Mixed ES modules and CommonJS imports in same files',
-      examples: patterns.mixed.slice(0, 5),
-      severity: 'major',
+      description: `Mixed module systems: found both ESM and CommonJS.`,
+      examples: ['import X from "y"', 'const X = require("y")'],
+      severity: Severity.Major,
     });
   }
 
-  // Check for inconsistent styles across project
-  if (patterns.esModules.length > 0 && patterns.commonJS.length > 0) {
-    const ratio =
-      patterns.commonJS.length /
-      (patterns.esModules.length + patterns.commonJS.length);
-    if (ratio > 0.2 && ratio < 0.8) {
-      issues.push({
-        files: [...patterns.esModules, ...patterns.commonJS],
-        type: 'import-style',
-        description: 'Inconsistent import styles across project',
-        examples: [
-          `ES modules: ${patterns.esModules.length} files`,
-          `CommonJS: ${patterns.commonJS.length} files`,
-        ],
-        severity: 'minor',
-      });
-    }
-  }
-
   return issues;
 }
-
-/**
- * Detects actual require() calls, excluding false positives
- * Filters out require() in:
- * - String literals (single/double/template quotes)
- * - Regex patterns
- * - Single-line comments (//)
- * - Multi-line comments
- */
-function hasActualRequireCalls(content: string): boolean {
-  // Simple heuristic: remove obvious false positives
-  // 1. Remove single-line comments
-  let cleaned = content.replace(/\/\/.*$/gm, '');
-
-  // 2. Remove multi-line comments (non-greedy)
-  cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, '');
-
-  // 3. Remove string literals - use simpler regex to avoid backtracking
-  // Match strings but don't try to be perfect, just remove obvious ones
-  cleaned = cleaned.replace(/"[^"\n]*"/g, '""');
-  cleaned = cleaned.replace(/'[^'\n]*'/g, "''");
-  cleaned = cleaned.replace(/`[^`]*`/g, '``');
-
-  // 4. Simple regex detection: if we see /require in the line, likely a regex pattern
-  // Remove lines that look like regex patterns with require
-  cleaned = cleaned.replace(/\/[^/\n]*require[^/\n]*\/[gimsuvy]*/g, '');
-
-  // Now check for require( in the cleaned content
-  return /require\s*\(/.test(cleaned);
-}
-
-/**
- * Analyzes API design consistency
- */
-export async function analyzeAPIDesign(
-  files: string[]
-): Promise<PatternIssue[]> {
-  // This would analyze:
-  // - Function parameter order consistency
-  // - Return type patterns
-  // - Options object vs individual parameters
-  // For now, return empty array
-  // Parameter currently unused; reference to avoid lint warnings
-  void files;
-  return [];
-}

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { ScanOptions, AnalysisResult, Issue } from '@aiready/core';
+import type { ScanOptions, AnalysisResult, Issue, Severity, IssueType } from '@aiready/core';
 
 export interface ConsistencyOptions extends ScanOptions {
   /** Check naming conventions and quality */
@@ -8,15 +8,15 @@ export interface ConsistencyOptions extends ScanOptions {
   /** Check architectural consistency */
   checkArchitecture?: boolean;
   /** Minimum severity to report */
-  minSeverity?: 'info' | 'minor' | 'major' | 'critical';
+  minSeverity?: Severity;
 }
 
 export interface ConsistencyIssue extends Issue {
   type:
-    | 'naming-inconsistency'
-    | 'naming-quality'
-    | 'pattern-inconsistency'
-    | 'architecture-inconsistency';
+    | IssueType.NamingInconsistency
+    | IssueType.NamingQuality
+    | IssueType.PatternInconsistency
+    | IssueType.ArchitectureInconsistency;
   category: 'naming' | 'patterns' | 'architecture';
   /** Examples of the inconsistency found */
   examples?: string[];
@@ -28,10 +28,10 @@ export interface NamingIssue {
   file: string;
   line: number;
   column?: number;
-  type: 'poor-naming' | 'convention-mix' | 'abbreviation' | 'unclear';
+  type: string;
   identifier: string;
   suggestion?: string;
-  severity: 'critical' | 'major' | 'minor' | 'info';
+  severity: Severity;
   category?: 'naming';
 }
 
@@ -40,14 +40,14 @@ export interface PatternIssue {
   type: 'error-handling' | 'async-style' | 'import-style' | 'api-design';
   description: string;
   examples: string[];
-  severity: 'critical' | 'major' | 'minor' | 'info';
+  severity: Severity;
 }
 
 export interface ArchitectureIssue {
   type: 'file-organization' | 'module-structure' | 'export-style';
   description: string;
   affectedPaths: string[];
-  severity: 'critical' | 'major' | 'minor' | 'info';
+  severity: Severity;
 }
 
 export interface ConsistencyReport {

package/src/utils/context-detector.ts

@@ -1,5 +1,6 @@
 import { TSESTree } from '@typescript-eslint/typescript-estree';
 import { traverseAST } from './ast-parser';
+import { Severity } from '@aiready/core';
 
 export type FileType = 'test' | 'production' | 'config' | 'types';
 export type CodeLayer = 'api' | 'business' | 'data' | 'utility' | 'unknown';
@@ -227,38 +228,50 @@ export function buildCodeContext(
  * Get context-adjusted severity based on code context
  */
 export function adjustSeverity(
-  baseSeverity: 'info' | 'minor' | 'major' | 'critical',
+  baseSeverity: Severity | string,
   context: CodeContext,
   issueType: string
-): 'info' | 'minor' | 'major' | 'critical' {
+): Severity {
+  const getEnum = (s: any): Severity => {
+    if (s === Severity.Critical || s === 'critical') return Severity.Critical;
+    if (s === Severity.Major || s === 'major') return Severity.Major;
+    if (s === Severity.Minor || s === 'minor') return Severity.Minor;
+    return Severity.Info;
+  };
+
+  let currentSev = getEnum(baseSeverity);
+
   // Test files: Be more lenient
   if (context.isTestFile) {
-    if (baseSeverity === 'minor') return 'info';
-    if (baseSeverity === 'major') return 'minor';
+    if (currentSev === Severity.Minor) currentSev = Severity.Info;
+    if (currentSev === Severity.Major) currentSev = Severity.Minor;
   }
 
   // Type definition files: Be more lenient (often use short generic names)
   if (context.isTypeDefinition) {
-    if (baseSeverity === 'minor') return 'info';
+    if (currentSev === Severity.Minor) currentSev = Severity.Info;
   }
 
   // API layer: Be stricter (public interface)
   if (context.codeLayer === 'api') {
-    if (baseSeverity === 'info' && issueType === 'unclear') return 'minor';
-    if (baseSeverity === 'minor' && issueType === 'unclear') return 'major';
+    if (currentSev === Severity.Info && issueType === 'unclear')
+      currentSev = Severity.Minor;
+    if (currentSev === Severity.Minor && issueType === 'unclear')
+      currentSev = Severity.Major;
   }
 
   // High complexity: Be stricter (need clearer names)
   if (context.complexity > 10) {
-    if (baseSeverity === 'info') return 'minor';
+    if (currentSev === Severity.Info) currentSev = Severity.Minor;
   }
 
   // Utility/helper layer: Allow shorter names
   if (context.codeLayer === 'utility') {
-    if (baseSeverity === 'minor' && issueType === 'abbreviation') return 'info';
+    if (currentSev === Severity.Minor && issueType === 'abbreviation')
+      currentSev = Severity.Info;
   }
 
-  return baseSeverity;
+  return currentSev;
 }
 
 /**