@aiready/consistency 0.8.30 → 0.8.32

package/src/analyzers/naming.ts

@@ -14,11 +14,18 @@ export async function analyzeNaming(files: string[]): Promise<NamingIssue[]> {
   const issues: NamingIssue[] = [];
 
   // Load and merge configuration
-  const { customAbbreviations, customShortWords, disabledChecks } = await loadNamingConfig(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);
   }
 
@@ -26,8 +33,8 @@ export async function analyzeNaming(files: string[]): Promise<NamingIssue[]> {
 }
 
 function analyzeFileNaming(
-  file: string, 
-  content: string, 
+  file: string,
+  content: string,
   customAbbreviations: Set<string>,
   customShortWords: Set<string>,
   disabledChecks: Set<string>
@@ -41,7 +48,10 @@ function analyzeFileNaming(
   const lines = content.split('\n');
 
   // Merge custom sets with defaults
-  const allAbbreviations = new Set([...ACCEPTABLE_ABBREVIATIONS, ...customAbbreviations]);
+  const allAbbreviations = new Set([
+    ...ACCEPTABLE_ABBREVIATIONS,
+    ...customAbbreviations,
+  ]);
   const allShortWords = new Set([...COMMON_SHORT_WORDS, ...customShortWords]);
 
   /**
@@ -56,10 +66,13 @@ function analyzeFileNaming(
   /**
    * Helper: Check if a variable is short-lived (used only within 3-5 lines)
    */
-  const isShortLivedVariable = (varName: string, declarationIndex: number): boolean => {
+  const isShortLivedVariable = (
+    varName: string,
+    declarationIndex: number
+  ): boolean => {
     const searchRange = 5; // Check 5 lines after declaration
     const endIndex = Math.min(lines.length, declarationIndex + searchRange + 1);
-    
+
     let usageCount = 0;
     for (let i = declarationIndex; i < endIndex; i++) {
       // Match variable name as whole word
@@ -69,7 +82,7 @@ function analyzeFileNaming(
         usageCount += matches.length;
       }
     }
-    
+
     // If variable is only used 2-3 times within 5 lines, it's short-lived
     // (1 = declaration, 1-2 = actual usage)
     return usageCount >= 2 && usageCount <= 3;
@@ -82,54 +95,70 @@ function analyzeFileNaming(
 
     // Check for single letter variables (except i, j, k, l in loops/common contexts)
     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();
-        
+
         // Coverage metrics context (s/b/f/l are standard for statements/branches/functions/lines)
-        const isCoverageContext = /coverage|summary|metrics|pct|percent/i.test(line) || 
+        const isCoverageContext =
+          /coverage|summary|metrics|pct|percent/i.test(line) ||
           /\.(?:statements|branches|functions|lines)\.pct/i.test(line);
         if (isCoverageContext && ['s', 'b', 'f', 'l'].includes(letter)) {
           continue;
         }
-        
+
         // Enhanced loop/iterator context detection
-        const isInLoopContext = 
-          line.includes('for') || 
+        const isInLoopContext =
+          line.includes('for') ||
           /\.(map|filter|forEach|reduce|find|some|every)\s*\(/.test(line) ||
           line.includes('=>') || // Arrow function
           /\w+\s*=>\s*/.test(line); // Callback pattern
-        
+
         // Check for i18n/translation context
-        const isI18nContext = 
+        const isI18nContext =
           line.includes('useTranslation') ||
           line.includes('i18n.t') ||
           /\bt\s*\(['"]/.test(line); // t('key') pattern
-        
+
         // Check for arrow function parameter (improved detection with context window)
-        const isArrowFunctionParam = 
+        const isArrowFunctionParam =
           /\(\s*[a-z]\s*(?:,\s*[a-z]\s*)*\)\s*=>/.test(line) || // (s) => or (a, b) =>
           /[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); // .map(\n  s =>
-        
+          (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)); // .map(\n  s =>
+
         // Check if variable is short-lived (comparison/temporary contexts)
         const isShortLived = isShortLivedVariable(letter, index);
-        
-        if (!isInLoopContext && !isI18nContext && !isArrowFunctionParam && !isShortLived && !['x', 'y', 'z', 'i', 'j', 'k', 'l', 'n', 'm'].includes(letter)) {
+
+        if (
+          !isInLoopContext &&
+          !isI18nContext &&
+          !isArrowFunctionParam &&
+          !isShortLived &&
+          !['x', 'y', 'z', 'i', 'j', 'k', 'l', 'n', 'm'].includes(letter)
+        ) {
           // Skip in test files unless it's really unclear
-          if (isTestFile && ['a', 'b', 'c', 'd', 'e', 'f', 's'].includes(letter)) {
+          if (
+            isTestFile &&
+            ['a', 'b', 'c', 'd', 'e', 'f', 's'].includes(letter)
+          ) {
             continue;
           }
-          
+
           issues.push({
             file,
             line: lineNumber,
             type: 'poor-naming',
             identifier: match[1],
             severity: 'minor',
-            suggestion: `Use descriptive variable name instead of single letter '${match[1]}'`
+            suggestion: `Use descriptive variable name instead of single letter '${match[1]}'`,
           });
         }
       }
@@ -137,63 +166,78 @@ function analyzeFileNaming(
 
     // Check for overly abbreviated variables
     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();
-        
+
         // Skip if it's a common short English word (full word, not abbreviation)
         if (allShortWords.has(abbrev)) {
           continue;
         }
-        
+
         // Skip acceptable abbreviations (including custom ones)
         if (allAbbreviations.has(abbrev)) {
           continue;
         }
-        
+
         // Check for arrow function parameter context (with multi-line detection)
-        const isArrowFunctionParam = 
+        const isArrowFunctionParam =
           /\(\s*[a-z]\s*(?:,\s*[a-z]\s*)*\)\s*=>/.test(line) || // (s) => or (a, b) =>
           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)); // .map(\n  s =>
-        
+          (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)); // .map(\n  s =>
+
         if (isArrowFunctionParam) {
           continue;
         }
-        
+
         // For very short names (1-2 letters), check for date/time context
         if (abbrev.length <= 2) {
-          const isDateTimeContext = /date|time|day|hour|minute|second|timestamp/i.test(line);
+          const isDateTimeContext =
+            /date|time|day|hour|minute|second|timestamp/i.test(line);
           if (isDateTimeContext && ['d', 't', 'dt'].includes(abbrev)) {
             continue;
           }
-          
+
           // Check for user/auth context
           const isUserContext = /user|auth|account/i.test(line);
           if (isUserContext && abbrev === 'u') {
             continue;
           }
         }
-        
+
         issues.push({
           file,
           line: lineNumber,
           type: 'abbreviation',
           identifier: match[1],
           severity: 'info',
-          suggestion: `Consider using full word instead of abbreviation '${match[1]}'`
+          suggestion: `Consider using full word instead of abbreviation '${match[1]}'`,
         });
       }
     }
 
     // Check for snake_case vs camelCase mixing in TypeScript/JavaScript
-    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*=/);
-      
+    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*=/
+      );
+      // Variable present for future checks; reference to avoid lint warnings
+      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,
@@ -201,14 +245,16 @@ function analyzeFileNaming(
           type: 'convention-mix',
           identifier: snakeCaseVars[1],
           severity: 'minor',
-          suggestion: `Use camelCase '${snakeCaseToCamelCase(snakeCaseVars[1])}' instead of snake_case in TypeScript/JavaScript`
+          suggestion: `Use camelCase '${snakeCaseToCamelCase(snakeCaseVars[1])}' instead of snake_case in TypeScript/JavaScript`,
         });
       }
     }
 
     // Check for unclear boolean names (should start with is/has/should/can)
     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)) {
@@ -218,7 +264,7 @@ function analyzeFileNaming(
             type: 'unclear',
             identifier: name,
             severity: 'info',
-            suggestion: `Boolean variable '${name}' should start with is/has/should/can for clarity`
+            suggestion: `Boolean variable '${name}' should start with is/has/should/can for clarity`,
           });
         }
       }
@@ -229,19 +275,39 @@ function analyzeFileNaming(
       const functionMatches = line.matchAll(/function\s+([a-z][a-zA-Z0-9]*)/g);
       for (const match of functionMatches) {
         const name = match[1];
-        
+
         // Skip JavaScript/TypeScript keywords that shouldn't be function names
-        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;
         }
-        
+
         // Skip common entry point names
-        const isEntryPoint = ['main', 'init', 'setup', 'bootstrap'].includes(name);
+        const isEntryPoint = ['main', 'init', 'setup', 'bootstrap'].includes(
+          name
+        );
         if (isEntryPoint) {
           continue;
         }
-        
+
         // Functions should typically start with verbs, but allow:
         // 1. Factory/builder patterns (ends with Factory, Builder, etc.)
         // 2. Descriptive compound names that explain what they return
@@ -251,37 +317,63 @@ function analyzeFileNaming(
         // 6. Compound words with 3+ capitals
         // 7. Helper/utility functions (common patterns)
         // 8. React hooks (useX pattern)
-        
-        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; // Reduced from 20 to 15
         const isReactHook = name.match(/^use[A-Z]/); // React hooks
-        
+
         // Check for descriptive patterns
-        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)$/
+          );
+
         // Helper/utility function patterns
-        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*$/); // metadataTo, pathFrom
-        
+        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*$/); // metadataTo, pathFrom
+
         // Common utility names that are descriptive
-        const isUtilityName = ['cn', 'proxy', 'sitemap', 'robots', 'gtag'].includes(name);
-        
+        const isUtilityName = [
+          'cn',
+          'proxy',
+          'sitemap',
+          'robots',
+          'gtag',
+        ].includes(name);
+
         // Count capital letters for compound detection
         const capitalCount = (name.match(/[A-Z]/g) || []).length;
         const isCompoundWord = capitalCount >= 3; // daysSinceLastCommit has 4 capitals
-        
-        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) {
+
+        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,
             line: lineNumber,
             type: 'unclear',
             identifier: name,
             severity: 'info',
-            suggestion: `Function '${name}' should start with an action verb (get, set, create, etc.)`
+            suggestion: `Function '${name}' should start with an action verb (get, set, create, etc.)`,
           });
         }
       }

package/src/analyzers/patterns.ts

@@ -4,7 +4,9 @@ import type { PatternIssue } from '../types';
 /**
  * Analyzes code pattern consistency
  */
-export async function analyzePatterns(files: string[]): Promise<PatternIssue[]> {
+export async function analyzePatterns(
+  files: string[]
+): Promise<PatternIssue[]> {
   const issues: PatternIssue[] = [];
 
   // Analyze error handling patterns
@@ -27,12 +29,12 @@ async function analyzeErrorHandling(files: string[]): Promise<PatternIssue[]> {
     tryCatch: [] as string[],
     throwsError: [] as string[],
     returnsNull: [] as string[],
-    returnsError: [] as string[]
+    returnsError: [] as string[],
   };
 
   for (const file of files) {
     const content = await readFileContent(file);
-    
+
     if (content.includes('try {') || content.includes('} catch')) {
       patterns.tryCatch.push(file);
     }
@@ -50,24 +52,36 @@ async function analyzeErrorHandling(files: string[]): Promise<PatternIssue[]> {
   const issues: PatternIssue[] = [];
 
   // Check for mixed error handling strategies
-  const strategiesUsed = Object.values(patterns).filter(p => p.length > 0).length;
+  const strategiesUsed = Object.values(patterns).filter(
+    (p) => p.length > 0
+  ).length;
   if (strategiesUsed > 2) {
     issues.push({
-      files: [...new Set([
-        ...patterns.tryCatch,
-        ...patterns.throwsError,
-        ...patterns.returnsNull,
-        ...patterns.returnsError
-      ])],
+      files: [
+        ...new Set([
+          ...patterns.tryCatch,
+          ...patterns.throwsError,
+          ...patterns.returnsNull,
+          ...patterns.returnsError,
+        ]),
+      ],
       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'
+        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',
     });
   }
 
@@ -78,12 +92,12 @@ async function analyzeAsyncPatterns(files: string[]): Promise<PatternIssue[]> {
   const patterns = {
     asyncAwait: [] as string[],
     promises: [] as string[],
-    callbacks: [] 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);
     }
@@ -105,20 +119,24 @@ async function analyzeAsyncPatterns(files: string[]): Promise<PatternIssue[]> {
       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(', ')}`
+        `Async/await used in: ${patterns.asyncAwait.slice(0, 3).join(', ')}`,
       ],
-      severity: 'minor'
+      severity: 'minor',
     });
   }
 
   // Mixing .then() chains with async/await
-  if (patterns.promises.length > patterns.asyncAwait.length * 0.3 && patterns.asyncAwait.length > 0) {
+  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',
+      description:
+        'Consider using async/await instead of promise chains for consistency',
       examples: patterns.promises.slice(0, 5),
-      severity: 'info'
+      severity: 'info',
     });
   }
 
@@ -129,19 +147,19 @@ async function analyzeImportStyles(files: string[]): Promise<PatternIssue[]> {
   const patterns = {
     esModules: [] as string[],
     commonJS: [] as string[],
-    mixed: [] 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) {
@@ -160,13 +178,15 @@ async function analyzeImportStyles(files: string[]): Promise<PatternIssue[]> {
       type: 'import-style',
       description: 'Mixed ES modules and CommonJS imports in same files',
       examples: patterns.mixed.slice(0, 5),
-      severity: 'major'
+      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);
+    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],
@@ -174,9 +194,9 @@ async function analyzeImportStyles(files: string[]): Promise<PatternIssue[]> {
         description: 'Inconsistent import styles across project',
         examples: [
           `ES modules: ${patterns.esModules.length} files`,
-          `CommonJS: ${patterns.commonJS.length} files`
+          `CommonJS: ${patterns.commonJS.length} files`,
         ],
-        severity: 'minor'
+        severity: 'minor',
       });
     }
   }
@@ -196,20 +216,20 @@ 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);
 }
@@ -217,11 +237,15 @@ function hasActualRequireCalls(content: string): boolean {
 /**
  * Analyzes API design consistency
  */
-export async function analyzeAPIDesign(files: string[]): Promise<PatternIssue[]> {
+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 [];
 }