@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/engines/mock-data-engine.js

@@ -1,19 +1,12 @@
 /**
  * Mock Data Detection Engine
  * Uses AST analysis to detect mock/test data patterns in production code
- * Enhanced with context-aware detection to reduce false positives
  */
 
 const { getAST, parseCode } = require("./ast-cache");
 const traverse = require("@babel/traverse").default;
 const t = require("@babel/types");
 const { shouldExcludeFile } = require("./file-filter");
-const { 
-  detectFalsePositive, 
-  quickFalsePositiveCheck,
-  isTailwindPlaceholderModifier,
-  isLegitimateUILabel,
-} = require("./context-detection");
 
 /**
  * Check if a string literal looks like mock/test data
@@ -113,25 +106,6 @@ function isSuspiciousSetTimeout(node) {
   return false;
 }
 
-/**
- * Check if a finding should be skipped due to context
- */
-function shouldSkipFinding(line, lineIndex, lines, patternType) {
-  // Quick pre-filter for common false positives
-  if (quickFalsePositiveCheck(line)) {
-    return true;
-  }
-  
-  // Detailed context analysis
-  const result = detectFalsePositive(line, line, {
-    lineIndex,
-    allLines: lines,
-    patternType,
-  });
-  
-  return result.isFalsePositive;
-}
-
 /**
  * Analyze a file for mock data patterns
  */
@@ -151,16 +125,10 @@ function analyzeMockData(code, filePath) {
     VariableDeclarator(path) {
       const id = path.node.id;
       const init = path.node.init;
-      const line = getLineNumber(path.node, code);
-      const lineContent = lines[line - 1] || "";
-      
-      // Skip if this line is a false positive (CSS class, UI label, etc.)
-      if (shouldSkipFinding(lineContent, line - 1, lines, "mock")) {
-        return;
-      }
       
       // Check variable name
       if (t.isIdentifier(id) && isMockVariableName(id.name)) {
+        const line = getLineNumber(path.node, code);
         findings.push({
           type: "mock_variable",
           severity: "WARN",
@@ -170,13 +138,14 @@ function analyzeMockData(code, filePath) {
           column: path.node.loc.start.column,
           title: `Mock data variable: ${id.name}`,
           message: `Variable name suggests mock/test data: ${id.name}`,
-          codeSnippet: lineContent.trim(),
+          codeSnippet: lines[line - 1]?.trim(),
           confidence: "high",
         });
       }
       
       // Check initializer value
       if (init && t.isStringLiteral(init) && isMockString(init.value)) {
+        const line = getLineNumber(path.node, code);
         findings.push({
           type: "mock_string_literal",
           severity: "WARN",
@@ -186,7 +155,7 @@ function analyzeMockData(code, filePath) {
           column: path.node.loc.start.column,
           title: "Mock/test string literal detected",
           message: `String value appears to be mock data: "${init.value.substring(0, 50)}"`,
-          codeSnippet: lineContent.trim(),
+          codeSnippet: lines[line - 1]?.trim(),
           confidence: "med",
         });
       }
@@ -196,15 +165,9 @@ function analyzeMockData(code, filePath) {
     ObjectProperty(path) {
       const key = path.node.key;
       const value = path.node.value;
-      const line = getLineNumber(path.node, code);
-      const lineContent = lines[line - 1] || "";
-      
-      // Skip if this line is a false positive (CSS class, UI label, etc.)
-      if (shouldSkipFinding(lineContent, line - 1, lines, "mock")) {
-        return;
-      }
       
       if (t.isIdentifier(key) && isMockVariableName(key.name)) {
+        const line = getLineNumber(path.node, code);
         findings.push({
           type: "mock_object_property",
           severity: "WARN",
@@ -214,12 +177,13 @@ function analyzeMockData(code, filePath) {
           column: path.node.loc.start.column,
           title: `Mock data property: ${key.name}`,
           message: `Object property name suggests mock data: ${key.name}`,
-          codeSnippet: lineContent.trim(),
+          codeSnippet: lines[line - 1]?.trim(),
           confidence: "med",
         });
       }
       
       if (t.isStringLiteral(value) && isMockString(value.value)) {
+        const line = getLineNumber(path.node, code);
         findings.push({
           type: "mock_property_value",
           severity: "WARN",
@@ -229,7 +193,7 @@ function analyzeMockData(code, filePath) {
           column: path.node.loc.start.column,
           title: "Mock string in object property",
           message: `Property value appears to be mock data: "${value.value.substring(0, 50)}"`,
-          codeSnippet: lineContent.trim(),
+          codeSnippet: lines[line - 1]?.trim(),
           confidence: "med",
         });
       }
@@ -272,17 +236,10 @@ function analyzeMockData(code, filePath) {
 
     // Check template literals
     TemplateLiteral(path) {
-      const line = getLineNumber(path.node, code);
-      const lineContent = lines[line - 1] || "";
-      
-      // Skip if this line is a false positive (CSS class, UI label, etc.)
-      if (shouldSkipFinding(lineContent, line - 1, lines, "mock")) {
-        return;
-      }
-      
       const quasis = path.node.quasis;
       for (const quasi of quasis) {
         if (quasi.value && isMockString(quasi.value.raw)) {
+          const line = getLineNumber(path.node, code);
           findings.push({
             type: "mock_template_literal",
             severity: "WARN",
@@ -292,7 +249,7 @@ function analyzeMockData(code, filePath) {
             column: path.node.loc.start.column,
             title: "Mock data in template literal",
             message: `Template literal contains mock/test data pattern`,
-            codeSnippet: lineContent.trim(),
+            codeSnippet: lines[line - 1]?.trim(),
             confidence: "med",
           });
           break;

package/bin/runners/lib/engines/performance-issues-engine.js

@@ -1,10 +1,6 @@
 /**
  * Performance Issues Detection Engine
  * Detects memory leaks, inefficient loops, large bundle sizes, and performance anti-patterns
- * Enhanced with framework-aware detection:
- * - React Server Components (different rules apply)
- * - Next.js App Router patterns
- * - Client-only hooks in server components
  */
 
 const { getAST } = require("./ast-cache");
@@ -12,32 +8,6 @@ const traverse = require("@babel/traverse").default;
 const t = require("@babel/types");
 const { shouldExcludeFile } = require("./file-filter");
 
-/**
- * Check if file is a React Server Component
- */
-function isServerComponent(code, filePath) {
-  const normalizedPath = filePath.replace(/\\/g, "/");
-  
-  // Check if it's in app directory (Next.js App Router)
-  if (!normalizedPath.includes("/app/")) {
-    return false;
-  }
-  
-  // Check for "use client" directive - if present, it's NOT a server component
-  if (/['"]use client['"]/.test(code)) {
-    return false;
-  }
-  
-  return true;
-}
-
-/**
- * Check if file is a client component
- */
-function isClientComponent(code) {
-  return /['"]use client['"]/.test(code);
-}
-
 /**
  * Analyze a file for performance issues
  */
@@ -51,77 +21,48 @@ function analyzePerformanceIssues(code, filePath) {
   if (!ast) return findings;
 
   const lines = code.split("\n");
-  
-  // Determine component type
-  const isRSC = isServerComponent(code, filePath);
-  const isCC = isClientComponent(code);
 
   // Memory leaks: Event listeners not removed
-  // Skip for Server Components (no DOM access)
-  if (!isRSC) {
-    traverse(ast, {
-      CallExpression(path) {
-        const node = path.node;
+  traverse(ast, {
+    CallExpression(path) {
+      const node = path.node;
+      
+      // Check for addEventListener without corresponding removeEventListener
+      if (t.isMemberExpression(node.callee)) {
+        const prop = node.callee.property;
         
-        // Check for addEventListener without corresponding removeEventListener
-        if (t.isMemberExpression(node.callee)) {
-          const prop = node.callee.property;
+        if (t.isIdentifier(prop) && prop.name === "addEventListener") {
+          // Check if there's a corresponding removeEventListener in the same scope
+          const scope = path.scope;
+          const hasRemoveListener = scope.getAllBindings().some((binding, name) => {
+            return name.includes("removeEventListener") || name.includes("removeListener");
+          });
           
-          if (t.isIdentifier(prop) && prop.name === "addEventListener") {
-            // Check if there's a corresponding removeEventListener in the same scope
-            const scope = path.scope;
-            let hasRemoveListener = false;
-            try {
-              const bindings = scope.getAllBindings();
-              for (const name in bindings) {
-                if (name.includes("removeEventListener") || name.includes("removeListener")) {
-                  hasRemoveListener = true;
-                  break;
-                }
-              }
-            } catch (e) {
-              // Scope traversal can fail, assume safe
-              hasRemoveListener = true;
-            }
-            
-            // Also check if it's in a useEffect cleanup (React)
-            const parent = path.findParent(p => 
-              t.isCallExpression(p.node) && 
-              t.isIdentifier(p.node.callee, { name: "useEffect" })
-            );
-            
-            // Check if there's a cleanup function returning removeEventListener
-            if (parent) {
-              const useEffectArg = parent.node.arguments[0];
-              if (t.isArrowFunctionExpression(useEffectArg) || t.isFunctionExpression(useEffectArg)) {
-                const funcCode = code.substring(useEffectArg.start, useEffectArg.end);
-                if (/return.*removeEventListener|removeEventListener.*return/s.test(funcCode)) {
-                  hasRemoveListener = true;
-                }
-              }
-            }
-            
-            if (!hasRemoveListener && !parent) {
-              const line = node.loc.start.line;
-              findings.push({
-                type: "memory_leak",
-                severity: "WARN",
-                category: "Performance",
-                file: filePath,
-                line,
-                column: node.loc.start.column,
-                title: "Potential memory leak: Event listener not removed",
-                message: "addEventListener called without corresponding removeEventListener. Use useEffect cleanup.",
-                codeSnippet: lines[line - 1]?.trim(),
-                confidence: "med",
-                fixHint: "Add cleanup in useEffect: useEffect(() => { el.addEventListener(...); return () => el.removeEventListener(...); }, [])",
-              });
-            }
+          // Also check if it's in a useEffect cleanup (React)
+          const parent = path.findParent(p => 
+            t.isCallExpression(p.node) && 
+            t.isIdentifier(p.node.callee, { name: "useEffect" })
+          );
+          
+          if (!hasRemoveListener && !parent) {
+            const line = node.loc.start.line;
+            findings.push({
+              type: "memory_leak",
+              severity: "WARN",
+              category: "Performance",
+              file: filePath,
+              line,
+              column: node.loc.start.column,
+              title: "Potential memory leak: Event listener not removed",
+              message: "addEventListener called without corresponding removeEventListener",
+              codeSnippet: lines[line - 1]?.trim(),
+              confidence: "med",
+            });
           }
         }
-      },
-    });
-  }
+      }
+    },
+  });
 
   // Inefficient loops: nested loops with O(n²) complexity
   // Only flag if depth >= 4 (3 levels is often acceptable)
@@ -310,93 +251,12 @@ function analyzePerformanceIssues(code, filePath) {
             message: `Importing entire ${source} library - use tree-shaking or import specific functions`,
             codeSnippet: lines[line - 1]?.trim(),
             confidence: "med",
-            fixHint: `Import specific functions: import { specificFn } from '${source}/specificFn'`,
           });
         }
       }
     },
   });
 
-  // React Server Components: Detect client-only hooks used in server components
-  if (isRSC) {
-    const clientOnlyHooks = [
-      "useState",
-      "useEffect",
-      "useLayoutEffect",
-      "useRef",
-      "useCallback",
-      "useMemo",
-      "useReducer",
-      "useContext",
-      "useImperativeHandle",
-      "useDebugValue",
-    ];
-    
-    traverse(ast, {
-      CallExpression(path) {
-        const node = path.node;
-        
-        if (t.isIdentifier(node.callee)) {
-          const hookName = node.callee.name;
-          
-          if (clientOnlyHooks.includes(hookName)) {
-            const line = node.loc.start.line;
-            findings.push({
-              type: "client_hook_in_server_component",
-              severity: "BLOCK",
-              category: "Performance",
-              file: filePath,
-              line,
-              column: node.loc.start.column,
-              title: `Client-only hook '${hookName}' used in Server Component`,
-              message: `${hookName} cannot be used in Server Components. Add 'use client' directive or move to a client component.`,
-              codeSnippet: lines[line - 1]?.trim(),
-              confidence: "high",
-              fixHint: "Add 'use client' at the top of the file, or extract this logic to a client component",
-            });
-          }
-        }
-      },
-    });
-  }
-  
-  // Detect async/await in client components that should be server components
-  if (isCC) {
-    // Check for database queries in client components
-    const serverOnlyPatterns = [
-      /prisma\./,
-      /db\./,
-      /\.findUnique\(/,
-      /\.findMany\(/,
-      /\.create\(/,
-      /\.update\(/,
-      /\.delete\(/,
-      /fs\./,
-      /readFile/,
-      /writeFile/,
-    ];
-    
-    if (serverOnlyPatterns.some(p => p.test(code))) {
-      const normalizedPath = filePath.replace(/\\/g, "/");
-      // Only warn if in app directory where RSC is available
-      if (normalizedPath.includes("/app/")) {
-        findings.push({
-          type: "server_code_in_client_component",
-          severity: "WARN",
-          category: "Performance",
-          file: filePath,
-          line: 1,
-          column: 0,
-          title: "Server-only code in Client Component",
-          message: "Database/filesystem operations should be in Server Components for better performance",
-          codeSnippet: "'use client'",
-          confidence: "med",
-          fixHint: "Remove 'use client' and move client interactivity to child components",
-        });
-      }
-    }
-  }
-
   return findings;
 }