@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/engines/cross-file-analysis-engine.js

@@ -1,11 +1,6 @@
 /**
  * Cross-File Analysis Engine
  * Analyzes relationships between files: unused exports, circular dependencies, import consistency
- * Enhanced with monorepo support:
- * - tsconfig.json path alias resolution
- * - package.json exports field support
- * - Workspace package detection
- * - Better barrel export handling
  */
 
 const fs = require("fs");
@@ -14,162 +9,6 @@ const { getAST } = require("./ast-cache");
 const traverse = require("@babel/traverse").default;
 const t = require("@babel/types");
 
-/**
- * Load and cache tsconfig.json paths
- */
-let cachedPathAliases = null;
-let cachedPathsRoot = null;
-
-function loadPathAliases(repoRoot) {
-  if (cachedPathAliases && cachedPathsRoot === repoRoot) {
-    return cachedPathAliases;
-  }
-  
-  cachedPathsRoot = repoRoot;
-  cachedPathAliases = new Map();
-  
-  // Try to load tsconfig.json
-  const tsconfigPaths = [
-    path.join(repoRoot, "tsconfig.json"),
-    path.join(repoRoot, "tsconfig.base.json"),
-    path.join(repoRoot, "jsconfig.json"),
-  ];
-  
-  for (const tsconfigPath of tsconfigPaths) {
-    if (fs.existsSync(tsconfigPath)) {
-      try {
-        // Remove comments from JSON (tsconfig allows them)
-        const content = fs.readFileSync(tsconfigPath, "utf8")
-          .replace(/\/\*[\s\S]*?\*\//g, "")
-          .replace(/\/\/.*$/gm, "");
-        const tsconfig = JSON.parse(content);
-        const compilerOptions = tsconfig.compilerOptions || {};
-        const baseUrl = compilerOptions.baseUrl || ".";
-        const paths = compilerOptions.paths || {};
-        
-        for (const [alias, targets] of Object.entries(paths)) {
-          // Convert alias pattern to regex
-          const aliasPattern = alias.replace(/\*/g, "(.*)");
-          const aliasRegex = new RegExp(`^${aliasPattern}$`);
-          
-          cachedPathAliases.set(aliasRegex, {
-            alias,
-            targets: targets.map(t => path.join(repoRoot, baseUrl, t)),
-          });
-        }
-        break; // Use first found config
-      } catch (e) {
-        // Ignore parse errors
-      }
-    }
-  }
-  
-  return cachedPathAliases;
-}
-
-/**
- * Resolve path alias to actual path
- */
-function resolvePathAlias(importPath, repoRoot) {
-  const pathAliases = loadPathAliases(repoRoot);
-  
-  for (const [aliasRegex, { alias, targets }] of pathAliases.entries()) {
-    const match = importPath.match(aliasRegex);
-    if (match) {
-      const captured = match[1] || "";
-      
-      for (const target of targets) {
-        const resolved = target.replace(/\*/g, captured);
-        
-        // Try common extensions
-        const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
-        for (const ext of extensions) {
-          const candidate = resolved + ext;
-          if (fs.existsSync(candidate)) {
-            return candidate;
-          }
-        }
-      }
-    }
-  }
-  
-  return null;
-}
-
-/**
- * Detect workspace packages in monorepo
- */
-let cachedWorkspaces = null;
-
-function detectWorkspaces(repoRoot) {
-  if (cachedWorkspaces) return cachedWorkspaces;
-  
-  cachedWorkspaces = new Map();
-  const packageJsonPath = path.join(repoRoot, "package.json");
-  
-  if (!fs.existsSync(packageJsonPath)) return cachedWorkspaces;
-  
-  try {
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-    const workspaces = packageJson.workspaces || [];
-    
-    // Handle both array and object format
-    const workspacePatterns = Array.isArray(workspaces) 
-      ? workspaces 
-      : workspaces.packages || [];
-    
-    for (const pattern of workspacePatterns) {
-      // Simple glob matching (handles common patterns like "packages/*")
-      const baseDir = pattern.replace(/\*.*$/, "");
-      const fullBaseDir = path.join(repoRoot, baseDir);
-      
-      if (fs.existsSync(fullBaseDir)) {
-        const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.isDirectory()) {
-            const pkgJsonPath = path.join(fullBaseDir, entry.name, "package.json");
-            if (fs.existsSync(pkgJsonPath)) {
-              try {
-                const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
-                cachedWorkspaces.set(pkgJson.name, {
-                  name: pkgJson.name,
-                  path: path.join(baseDir, entry.name),
-                  exports: pkgJson.exports || {},
-                });
-              } catch (e) {
-                // Ignore parse errors
-              }
-            }
-          }
-        }
-      }
-    }
-  } catch (e) {
-    // Ignore errors
-  }
-  
-  return cachedWorkspaces;
-}
-
-/**
- * Check if import is a workspace package
- */
-function isWorkspaceImport(importPath, repoRoot) {
-  const workspaces = detectWorkspaces(repoRoot);
-  return workspaces.has(importPath) || 
-         Array.from(workspaces.keys()).some(ws => importPath.startsWith(ws + "/"));
-}
-
-/**
- * Check if file is a barrel/index file (re-exports)
- */
-function isBarrelFile(fileRel) {
-  return fileRel.endsWith("/index.ts") || 
-         fileRel.endsWith("/index.tsx") || 
-         fileRel.endsWith("/index.js") ||
-         fileRel.endsWith("/index.jsx");
-}
-
 /**
  * Build export map for all files
  */
@@ -259,43 +98,8 @@ function buildExportMap(files, repoRoot) {
 
 /**
  * Resolve import path to actual file path
- * Enhanced with path alias and monorepo support
  */
 function resolveImportPath(importPath, fromFile, repoRoot) {
-  // Skip external packages (node_modules)
-  if (!importPath.startsWith(".") && !importPath.startsWith("/") && !importPath.startsWith("@/")) {
-    // Check if it's a workspace import
-    if (isWorkspaceImport(importPath, repoRoot)) {
-      // Resolve workspace import
-      const workspaces = detectWorkspaces(repoRoot);
-      const wsName = Array.from(workspaces.keys()).find(ws => 
-        importPath === ws || importPath.startsWith(ws + "/")
-      );
-      
-      if (wsName) {
-        const ws = workspaces.get(wsName);
-        const subPath = importPath.slice(wsName.length + 1) || "index";
-        const wsFullPath = path.join(repoRoot, ws.path, "src", subPath);
-        
-        const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx"];
-        for (const ext of extensions) {
-          const candidate = wsFullPath + ext;
-          if (fs.existsSync(candidate)) {
-            return path.relative(repoRoot, candidate).replace(/\\/g, "/");
-          }
-        }
-      }
-    }
-    
-    // Try path alias resolution
-    const aliasResolved = resolvePathAlias(importPath, repoRoot);
-    if (aliasResolved) {
-      return path.relative(repoRoot, aliasResolved).replace(/\\/g, "/");
-    }
-    
-    return null; // External package
-  }
-  
   const dir = path.dirname(path.join(repoRoot, fromFile));
   let resolved = path.resolve(dir, importPath);
   
@@ -353,41 +157,17 @@ function analyzeCrossFile(files, repoRoot) {
     
     for (const exp of exports) {
       if (!used.has(exp) && exp !== "default") {
-        // Skip known patterns that legitimately have unused exports
-        const shouldSkip = 
-          // Test/spec files
-          fileRel.includes(".test.") || 
-          fileRel.includes(".spec.") ||
-          fileRel.includes("__tests__") ||
-          // Config files
-          fileRel.includes("config") ||
-          fileRel.includes(".config.") ||
-          // Type definitions
-          fileRel.endsWith(".d.ts") ||
-          // Barrel/index files (re-exports are intentionally not all used)
-          isBarrelFile(fileRel) ||
-          // Entry points
-          fileRel.includes("/pages/") ||
-          fileRel.includes("/app/") ||
-          fileRel.endsWith("/index.ts") ||
-          // API routes (exported handlers are used by framework)
-          fileRel.includes("/api/") ||
-          // Stories
-          fileRel.includes(".stories.") ||
-          // Migrations
-          fileRel.includes("/migrations/");
-        
-        if (!shouldSkip) {
+        // Check if it's a test file or config file (likely to have unused exports)
+        if (!fileRel.includes(".test.") && !fileRel.includes(".spec.") && !fileRel.includes("config")) {
           findings.push({
             type: "unused_export",
-            severity: "INFO", // Downgraded from WARN - often intentional
+            severity: "WARN",
             category: "CodeQuality",
             file: fileRel,
-            line: 0,
-            title: `Potentially unused export: ${exp}`,
-            message: `Export "${exp}" from ${fileRel} is not imported by other analyzed files`,
-            confidence: "low", // Low confidence - might be used externally
-            fixHint: "Verify if this export is used externally or remove if truly unused",
+            line: 0, // Would need to track line numbers
+            title: `Unused export: ${exp}`,
+            message: `Export "${exp}" from ${fileRel} is never imported`,
+            confidence: "med",
           });
         }
       }
@@ -431,42 +211,20 @@ function analyzeCrossFile(files, repoRoot) {
     return null;
   }
   
-  const reportedCycles = new Set();
-  
   for (const fileRel of exportMap.keys()) {
     if (!visited.has(fileRel)) {
       const cycle = detectCycle(fileRel);
       if (cycle && cycle.length > 2) {
-        // Create a normalized cycle key to avoid duplicate reports
-        const cycleKey = [...cycle].sort().join("|");
-        
-        if (!reportedCycles.has(cycleKey)) {
-          reportedCycles.add(cycleKey);
-          
-          // Determine severity based on cycle type
-          // Type-only imports often don't cause runtime issues
-          let severity = "WARN";
-          let confidence = "high";
-          
-          // Check if any files in the cycle are barrel files (common and often harmless)
-          const hasBarrel = cycle.some(f => isBarrelFile(f));
-          if (hasBarrel) {
-            severity = "INFO";
-            confidence = "med";
-          }
-          
-          findings.push({
-            type: "circular_dependency",
-            severity,
-            category: "CodeQuality",
-            file: cycle[0],
-            line: 0,
-            title: `Circular dependency detected (${cycle.length - 1} files)`,
-            message: `Circular dependency: ${cycle.join(" → ")}`,
-            confidence,
-            fixHint: "Break the cycle by extracting shared code to a separate module, or use dynamic imports",
-          });
-        }
+        findings.push({
+          type: "circular_dependency",
+          severity: "WARN",
+          category: "CodeQuality",
+          file: cycle[0],
+          line: 0,
+          title: `Circular dependency detected`,
+          message: `Circular dependency: ${cycle.join(" → ")}`,
+          confidence: "high",
+        });
       }
     }
   }
@@ -488,46 +246,23 @@ function analyzeCrossFile(files, repoRoot) {
   
   for (const [targetFile, styles] of importStyles.entries()) {
     if (styles.size > 1) {
-      // Filter out path alias variations that resolve to the same file
-      const uniqueStyles = new Set(
-        Array.from(styles).filter(s => !s.startsWith("@/") || styles.size === 1)
-      );
-      
-      if (uniqueStyles.size > 1) {
-        findings.push({
-          type: "inconsistent_imports",
-          severity: "INFO", // Downgraded - often just style preference
-          category: "CodeQuality",
-          file: targetFile,
-          line: 0,
-          title: `Inconsistent import paths`,
-          message: `Module imported with ${uniqueStyles.size} different paths: ${Array.from(uniqueStyles).join(", ")}`,
-          confidence: "low",
-          fixHint: "Standardize import paths using path aliases (e.g., @/) for consistency",
-        });
-      }
+      findings.push({
+        type: "inconsistent_imports",
+        severity: "WARN",
+        category: "CodeQuality",
+        file: targetFile,
+        line: 0,
+        title: `Inconsistent import paths`,
+        message: `Module imported with ${styles.size} different paths: ${Array.from(styles).join(", ")}`,
+        confidence: "low",
+      });
     }
   }
   
   return findings;
 }
 
-/**
- * Clear all caches (useful for testing)
- */
-function clearCaches() {
-  cachedPathAliases = null;
-  cachedPathsRoot = null;
-  cachedWorkspaces = null;
-}
-
 module.exports = {
   analyzeCrossFile,
   buildExportMap,
-  resolveImportPath,
-  loadPathAliases,
-  detectWorkspaces,
-  isWorkspaceImport,
-  isBarrelFile,
-  clearCaches,
 };

package/bin/runners/lib/engines/empty-catch-engine.js

@@ -1,95 +1,12 @@
 /**
  * Empty Catch Block Detection Engine
  * Uses AST analysis to detect empty or effectively empty catch blocks
- * Enhanced with:
- * - Intentional suppression comment detection
- * - Structured logging detection (winston, pino, bunyan)
- * - Error reporting service detection (Sentry, Bugsnag, Rollbar)
- * - Recovery/cleanup pattern detection
  */
 
 const { getAST, parseCode } = require("./ast-cache");
 const traverse = require("@babel/traverse").default;
 const t = require("@babel/types");
 
-/**
- * Comments that indicate intentional error suppression
- */
-const INTENTIONAL_SUPPRESSION_PATTERNS = [
-  /intentionally?\s*(?:ignored?|suppress(?:ed)?|silent|swallow(?:ed)?)/i,
-  /error\s*(?:is\s*)?(?:expected|ok|fine|acceptable)/i,
-  /safe\s*to\s*ignore/i,
-  /this\s*(?:error|exception)\s*(?:can|is)\s*(?:safely\s*)?(?:be\s*)?ignored/i,
-  /ignore\s*(?:this\s*)?(?:error|exception)/i,
-  /suppress(?:ed)?\s*(?:error|exception)/i,
-  /best\s*effort/i,
-  /fallback/i,
-  /graceful(?:ly)?/i,
-  /optional/i,
-  /non-critical/i,
-  /not\s*(?:a\s*)?(?:critical|fatal)/i,
-];
-
-/**
- * Structured logging calls (not console)
- */
-const STRUCTURED_LOGGER_PATTERNS = [
-  // Logger method calls
-  /^logger\./i,
-  /^log\./i,
-  /^winston\./i,
-  /^pino\./i,
-  /^bunyan\./i,
-  /^console\.(error|warn)/i,
-  // Error tracking services
-  /Sentry\.capture/i,
-  /Bugsnag\.notify/i,
-  /Rollbar\.error/i,
-  /trackError/i,
-  /reportError/i,
-  /captureException/i,
-  /logError/i,
-];
-
-/**
- * Check if code contains intentional suppression comment
- */
-function hasIntentionalSuppressionComment(code, startLine, endLine, lines) {
-  // Check comments in and around the catch block
-  for (let i = Math.max(0, startLine - 2); i <= Math.min(lines.length - 1, endLine + 1); i++) {
-    const line = lines[i];
-    // Check for intentional suppression patterns in comments
-    if (INTENTIONAL_SUPPRESSION_PATTERNS.some(pattern => pattern.test(line))) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/**
- * Check if expression is a structured logging call
- */
-function isStructuredLoggingCall(expression, code) {
-  if (!t.isCallExpression(expression)) return false;
-  
-  const callee = expression.callee;
-  let calleeStr = "";
-  
-  // Build the callee string
-  if (t.isMemberExpression(callee)) {
-    if (t.isIdentifier(callee.object)) {
-      calleeStr = callee.object.name + ".";
-    }
-    if (t.isIdentifier(callee.property)) {
-      calleeStr += callee.property.name;
-    }
-  } else if (t.isIdentifier(callee)) {
-    calleeStr = callee.name;
-  }
-  
-  return STRUCTURED_LOGGER_PATTERNS.some(pattern => pattern.test(calleeStr));
-}
-
 /**
  * Check if a catch block is effectively empty
  */
@@ -166,86 +83,59 @@ function analyzeEmptyCatch(code, filePath) {
       
       if (!body) return;
       
-      const startLine = catchNode.loc.start.line;
-      const endLine = catchNode.loc.end.line;
-      
-      // Check for intentional suppression comments first
-      if (hasIntentionalSuppressionComment(code, startLine - 1, endLine - 1, lines)) {
-        // Has intentional suppression comment - skip or low severity
-        return;
-      }
-      
       // Check if completely empty
       if (isEmptyCatchBlock(body)) {
+        const line = catchNode.loc.start.line;
         findings.push({
           type: "empty_catch",
           severity: "WARN",
           category: "EmptyCatch",
           file: filePath,
-          line: startLine,
+          line,
           column: catchNode.loc.start.column,
           title: "Empty catch block",
           message: "Catch block contains no error handling code",
-          codeSnippet: lines[startLine - 1]?.trim(),
+          codeSnippet: lines[line - 1]?.trim(),
           confidence: "high",
-          fixHint: "Add error handling, logging, or a comment explaining why the error is intentionally ignored",
         });
         return;
       }
       
-      // Check if only has comments - but allow console.error/warn, structured logging, return/throw
+      // Check if only has comments - but allow console.error/warn and return/throw
       const statements = body.body || [];
       const hasRealHandling = statements.some(stmt => {
-        // Allow return statements (with or without value)
+        // Allow return statements
         if (t.isReturnStatement(stmt)) return true;
-        
-        // Allow throw statements (re-throwing or wrapping)
+        // Allow throw statements
         if (t.isThrowStatement(stmt)) return true;
-        
-        // Allow structured logging and error reporting
+        // Allow console.error/warn (logging is acceptable error handling)
         if (t.isExpressionStatement(stmt) && t.isCallExpression(stmt.expression)) {
-          if (isStructuredLoggingCall(stmt.expression, code)) {
-            return true;
+          const callee = stmt.expression.callee;
+          if (t.isMemberExpression(callee) && 
+              t.isIdentifier(callee.object, { name: "console" }) &&
+              t.isIdentifier(callee.property)) {
+            if (["error", "warn"].includes(callee.property.name)) {
+              return true; // This is acceptable error handling
+            }
           }
         }
-        
-        // Allow await expressions (might be async error handling)
-        if (t.isExpressionStatement(stmt) && t.isAwaitExpression(stmt.expression)) {
-          return true;
-        }
-        
-        // Allow variable assignments (might be setting error state)
-        if (t.isExpressionStatement(stmt) && t.isAssignmentExpression(stmt.expression)) {
-          return true;
-        }
-        
-        // Allow variable declarations (const error = ...)
-        if (t.isVariableDeclaration(stmt)) {
-          return true;
-        }
-        
-        // Allow if statements (conditional error handling)
-        if (t.isIfStatement(stmt)) {
-          return true;
-        }
-        
         return false;
       });
       
       // Only flag if it truly has no handling
       if (!hasRealHandling && onlyHasComments(body, code)) {
+        const line = catchNode.loc.start.line;
         findings.push({
           type: "comment_only_catch",
           severity: "WARN",
           category: "EmptyCatch",
           file: filePath,
-          line: startLine,
+          line,
           column: catchNode.loc.start.column,
           title: "Catch block with only comments",
           message: "Catch block contains only comments, no actual error handling",
-          codeSnippet: lines[startLine - 1]?.trim(),
+          codeSnippet: lines[line - 1]?.trim(),
           confidence: "med",
-          fixHint: "Add proper error handling or use a recognized suppression comment pattern",
         });
       }
     },