Bump version to 1.0.20 and rebuild

Author: CodeDeficient

karpeslop-bin.js

@@ -61,7 +61,7 @@ class AISlopDetector {
     description: 'Placeholder comments where AI failed to implement'
   }, {
     id: 'assumption_comment',
-    pattern: /\b(assuming|assumes?|presumably|apparently|it seems|seems like|probably|hopefully)\b.{0,50}\b(that|this|the|it)\b/gi,
+    pattern: /\b(assuming|assumes?|presumably|apparently|it seems|seems like)\b.{0,50}\b(that|this|the|it)\b/gi,
     message: "AI making unverified assumptions — dangerous in production",
     severity: 'high',
     description: 'Comments indicating unverified assumptions'
@@ -131,8 +131,8 @@ class AISlopDetector {
     description: 'Detects unsafe as any assertions'
   }, {
     id: 'unsafe_double_type_assertion',
-    pattern: /as\s+unknown\s+as\s+\w+/g,
-    message: "Found unsafe 'as unknown as Type' type assertion. Use proper type guards or validation.",
+    pattern: /as\s+\w+\s+as\s+\w+/g,
+    message: "Found unsafe double type assertion. Consider using 'as unknown as Type' for safe conversions.",
     severity: 'high',
     description: 'Detects unsafe double type assertions'
   }, {
@@ -162,13 +162,9 @@ class AISlopDetector {
     message: "Found TODO/FIXME/HACK comment indicating incomplete implementation.",
     severity: 'medium',
     description: 'Detects incomplete implementation markers'
-  }, {
-    id: 'complex_nested_conditionals',
-    pattern: /(?:if\s*\(|for\s*\(|while\s*\()/g,
-    message: "Found potentially complex nested control structures. Consider refactoring for readability.",
-    severity: 'medium',
-    description: 'Detects potential complex conditionals'
-  }, {
+  },
+  // Note: complex_nested_conditionals is handled separately below with improved logic
+  {
     id: 'unsafe_member_access',
     pattern: /\.\s*any\s*\[/g,
     message: "Found potentially unsafe member access on 'any' type.",
@@ -235,7 +231,9 @@ class AISlopDetector {
         // Generated library files
         'scripts/ai-slop-detector.ts',
         // Exclude the detector script itself to avoid false positives
-        'ai-slop-detector.ts' // Also exclude when in root directory
+        'ai-slop-detector.ts',
+        // Also exclude when in root directory
+        'improved-ai-slop-detector.ts' // Exclude the improved detector script to avoid false positives
         ]
       });
 
@@ -364,6 +362,11 @@ class AISlopDetector {
           continue;
         }
 
+        // Skip the complex_nested_conditionals pattern since we handle it separately
+        if (pattern.id === 'complex_nested_conditionals') {
+          continue;
+        }
+
         // Create a new RegExp object for each check to reset lastIndex
         const regex = new RegExp(pattern.pattern.source, pattern.pattern.flags);
         let match;
@@ -378,6 +381,37 @@ class AISlopDetector {
             continue;
           }
 
+          // Skip legitimate JSON parsing patterns
+          if (pattern.id === 'any_type_usage' && (line.includes('JSON.parse(') || line.includes('.json') || line.includes('response.json'))) {
+            continue;
+          }
+
+          // Skip legitimate API response handling where 'any' is often unavoidable
+          if (pattern.id === 'any_type_usage' && (line.includes('ApiResponse') || line.includes('apiResponse') || line.includes('res.json') || line.includes('fetch') || line.includes('axios'))) {
+            continue;
+          }
+
+          // Skip legitimate uses of 'any' for dynamic data processing
+          if (pattern.id === 'any_type_usage' && (line.includes('data: any') || line.includes('(data: any)') || line.includes('result: any') || line.includes('response: any'))) {
+            // Check if it's in a function that processes dynamic data
+            if (line.includes('parse') || line.includes('process') || line.includes('transform')) {
+              continue;
+            }
+          }
+
+          // Special handling for function_param_any_type pattern
+          if (pattern.id === 'function_param_any_type') {
+            // Skip legitimate uses in data processing functions
+            if (line.includes('(data: any)') && (line.includes('parse') || line.includes('process') || line.includes('transform'))) {
+              continue;
+            }
+
+            // Skip legitimate uses in generic functions dealing with external data
+            if (line.includes('ApiResponse') || line.includes('apiResponse') || line.includes('JSON.parse') || line.includes('response: any')) {
+              continue;
+            }
+          }
+
           // Special handling for missing error handling - look for properly handled fetch calls
           if (pattern.id === 'missing_error_handling') {
             // Check if this fetch call is part of a properly handled async function
@@ -389,10 +423,55 @@ class AISlopDetector {
 
           // Special handling for unsafe_double_type_assertion - skip legitimate UI library patterns
           if (pattern.id === 'unsafe_double_type_assertion') {
-            // Check the full line context to identify legitimate UI library patterns
+            // Check the full line context to identify potentially legitimate patterns
+            const fullLine = line.trim();
+            // Skip patterns that are actually safe (as unknown as Type) since we changed the regex
+            // but double-check to be extra sure
+            if (fullLine.includes('as unknown as')) {
+              continue; // This is actually safe - skip it
+            }
+          }
+
+          // Special handling for production_console_log - skip legitimate error handling and debugging patterns
+          if (pattern.id === 'production_console_log') {
             const fullLine = line.trim();
-            if (fullLine.includes('as unknown as React.ElementType') || fullLine.includes('as unknown as TooltipFormatter') || fullLine.includes('as unknown as import(') || fullLine.includes('as unknown as import ')) {
-              continue; // Skip legitimate UI library patterns
+
+            // Skip console.error logs inside catch blocks (legitimate error handling)
+            if (fullLine.includes('console.error(') && this.isInTryCatchBlock(lines, i)) {
+              continue;
+            }
+
+            // Skip general debugging logs that might be intentional in development
+            if (fullLine.includes('console.log(') && (fullLine.includes('Debug') || fullLine.includes('debug') || fullLine.includes('debug:'))) {
+              continue;
+            }
+
+            // Skip console logs that contain the word 'error' in a non-error context (like error handling)
+            if ((fullLine.includes('console.log(') || fullLine.includes('console.info(')) && (fullLine.includes('error') || fullLine.includes('Error'))) {
+              continue;
+            }
+          }
+
+          // Special handling for hedging_uncertainty_comment - skip legitimate test patterns
+          if (pattern.id === 'hedging_uncertainty_comment' || pattern.id === 'assumption_comment') {
+            // Skip these patterns in test files where they might be legitimate test descriptions
+            if (filePath.includes('test') || filePath.includes('spec') || filePath.includes('__tests__')) {
+              continue;
+            }
+
+            // Skip common English phrases that are not code-related
+            const fullLine = line.trim().toLowerCase();
+            if (fullLine.includes('should work') && (fullLine.includes('//') || fullLine.includes('/*') || fullLine.includes('*/'))) {
+              // This is likely a comment in a test file
+              continue;
+            }
+          }
+
+          // Special handling for unsafe_type_assertion - skip legitimate test patterns
+          if (pattern.id === 'unsafe_type_assertion') {
+            // Skip these in test files where they might be legitimate for testing
+            if (filePath.includes('test') || filePath.includes('spec') || filePath.includes('__tests__')) {
+              continue;
             }
           }
 
@@ -414,9 +493,114 @@ class AISlopDetector {
           });
         }
       }
+
+      // Now handle complex nested conditionals separately with improved logic
+      this.analyzeComplexNestedConditionals(filePath, lines, i, lineNumber, line);
     }
   }
 
+  /**
+   * Analyze complex nested conditionals using a more sophisticated approach
+   * This tracks nesting depth rather than just finding control structure keywords
+   */
+  analyzeComplexNestedConditionals(filePath, lines, lineIndex, lineNumber, line) {
+    // Count opening braces in this line to determine if we're entering nested blocks
+    const ifMatches = line.match(/\bif\s*\(/g);
+    const forMatches = line.match(/\bfor\s*\(/g);
+    const whileMatches = line.match(/\bwhile\s*\(/g);
+
+    // Only flag if there are potentially nested control structures in a single line
+    // or if the line has multiple indicators of complexity
+    if (ifMatches && ifMatches.length > 1 || forMatches && forMatches.length > 1 || whileMatches && whileMatches.length > 1 || ifMatches && (forMatches || whileMatches) || forMatches && whileMatches) {
+      this.issues.push({
+        type: 'complex_nested_conditionals',
+        file: filePath,
+        line: lineNumber,
+        column: 1,
+        code: line.trim(),
+        message: "Found potentially complex nested control structures in a single line. Consider refactoring for readability.",
+        severity: 'medium'
+      });
+    }
+
+    // Also look for deeply nested if statements across multiple lines
+    // Count indentation to detect nesting
+    const indentation = line.search(/\S/); // Get leading whitespace length
+    if (indentation >= 16 && (line.includes('if (') || line.includes('for (') || line.includes('while ('))) {
+      // This might indicate a highly nested structure
+      // But first, verify it's not a simple case like formatting
+      const trimmedLine = line.trim();
+      if (!trimmedLine.startsWith('//') && !trimmedLine.includes('=>')) {
+        // Skip comments and arrow functions
+        this.issues.push({
+          type: 'complex_nested_conditionals',
+          file: filePath,
+          line: lineNumber,
+          column: indentation + 1,
+          code: line.trim(),
+          message: "Highly indented control structure suggests deep nesting. Consider refactoring for readability.",
+          severity: 'medium'
+        });
+      }
+    }
+  }
+
+  /**
+   * Check if a particular line is within a try-catch block
+   * Used to determine if console.error is legitimate error handling
+   */
+  isInTryCatchBlock(lines, lineIndex) {
+    // Look backwards from the given line to find try/catch blocks
+    let tryBlockDepth = 0;
+    let catchBlockStartLine = -1;
+
+    // Track opening and closing braces to understand block scope
+    for (let i = lineIndex; i >= 0; i--) {
+      const line = lines[i];
+
+      // Check for catch blocks (which are often where error logging happens)
+      if (line.includes('catch (')) {
+        catchBlockStartLine = i;
+        // Find the opening brace of the catch block
+        if (line.includes('{')) {
+          return true;
+        } else {
+          // If the catch is on its own line, the next line with { is the start
+          for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+            if (lines[j].includes('{')) {
+              return true;
+            }
+          }
+        }
+      }
+
+      // Check for try blocks
+      if (line.includes('try {') || line.includes('try') && line.includes('{')) {
+        if (catchBlockStartLine > i) {
+          return true; // We found a try block that encompasses the current line
+        }
+      }
+
+      // More sophisticated brace tracking to identify block depth
+      const openBraces = (line.match(/{/g) || []).length;
+      const closeBraces = (line.match(/}/g) || []).length;
+      if (openBraces > closeBraces) {
+        tryBlockDepth++;
+      } else if (closeBraces > openBraces) {
+        tryBlockDepth = Math.max(0, tryBlockDepth - closeBraces + openBraces);
+      }
+
+      // If we're at top level (depth 0) and haven't found a try/catch, we're outside
+      if (tryBlockDepth === 0) {
+        // Check if there was a catch block before we exited
+        if (catchBlockStartLine > i) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   /**
    * Generate a detailed report of findings
    */

package.json

@@ -1,6 +1,6 @@
 {
   "name": "karpeslop",
-  "version": "1.0.19",
+  "version": "1.0.20",
   "description": "The linter Andrej Karpathy wishes existed. Detects the three axes of AI slop with extreme prejudice.",
   "type": "module",
   "bin": {