@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/engines/async-patterns-engine.js

@@ -1,444 +0,0 @@
-/**
- * Async Patterns Engine
- * Detects:
- * - Unhandled promise rejections
- * - Missing await keywords
- * - Promise anti-patterns
- * - Race conditions
- * - Sequential await when parallel is better
- * - Floating promises
- * - async/await misuse
- */
-
-const { getAST } = require("./ast-cache");
-const traverse = require("@babel/traverse").default;
-const t = require("@babel/types");
-const { shouldExcludeFile, isTestContext, hasIgnoreDirective } = require("./file-filter");
-
-function snippetForLine(lines, line) {
-  return lines[line - 1] ? lines[line - 1].trim() : "";
-}
-
-/**
- * Check if a node is a promise-returning call
- */
-function isPromiseReturning(node) {
-  if (!t.isCallExpression(node)) return false;
-  
-  const callee = node.callee;
-  
-  // Promise constructor
-  if (t.isNewExpression(node) && t.isIdentifier(node.callee, { name: "Promise" })) {
-    return true;
-  }
-  
-  // Promise.resolve, Promise.reject, Promise.all, etc.
-  if (t.isMemberExpression(callee) && t.isIdentifier(callee.object, { name: "Promise" })) {
-    return true;
-  }
-  
-  // Common async methods
-  if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
-    const methodName = callee.property.name;
-    const asyncMethods = ["fetch", "then", "catch", "finally", "json", "text", "blob"];
-    if (asyncMethods.includes(methodName)) return true;
-  }
-  
-  // fetch()
-  if (t.isIdentifier(callee, { name: "fetch" })) return true;
-  
-  // axios(), axios.get(), etc.
-  if (t.isIdentifier(callee, { name: "axios" })) return true;
-  if (t.isMemberExpression(callee) && t.isIdentifier(callee.object, { name: "axios" })) {
-    return true;
-  }
-  
-  return false;
-}
-
-/**
- * Check if expression is awaited or has .then/.catch
- */
-function isHandled(path) {
-  const parent = path.parentPath;
-  
-  // Awaited
-  if (parent.isAwaitExpression()) return true;
-  
-  // Has .then or .catch
-  if (parent.isMemberExpression() && t.isIdentifier(parent.node.property)) {
-    const prop = parent.node.property.name;
-    if (prop === "then" || prop === "catch" || prop === "finally") return true;
-  }
-  
-  // Returned
-  if (parent.isReturnStatement()) return true;
-  
-  // Assigned to variable (might be handled later)
-  if (parent.isVariableDeclarator()) return true;
-  
-  // Passed as argument (callback)
-  if (parent.isCallExpression()) return true;
-  
-  // Part of Promise.all, Promise.race, etc.
-  if (parent.isArrayExpression()) {
-    const grandparent = parent.parentPath;
-    if (grandparent.isCallExpression()) {
-      const callee = grandparent.node.callee;
-      if (t.isMemberExpression(callee) && t.isIdentifier(callee.object, { name: "Promise" })) {
-        return true;
-      }
-    }
-  }
-  
-  return false;
-}
-
-/**
- * Check if inside an async function
- */
-function isInAsyncFunction(path) {
-  const fnParent = path.getFunctionParent();
-  return fnParent && fnParent.node.async;
-}
-
-/**
- * Analyze async patterns
- */
-function analyzeAsyncPatterns(code, filePath) {
-  const findings = [];
-  
-  if (shouldExcludeFile(filePath)) return findings;
-  if (isTestContext(code, filePath)) return findings;
-  if (hasIgnoreDirective(code, "async-patterns")) return findings;
-  
-  const ast = getAST(code, filePath);
-  if (!ast) return findings;
-  
-  const lines = code.split("\n");
-  
-  // Track sequential awaits that could be parallel
-  const sequentialAwaits = new Map(); // fnPath -> [{ line, varName }]
-  
-  traverse(ast, {
-    // Check for floating promises (unhandled)
-    CallExpression(path) {
-      const node = path.node;
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      if (isPromiseReturning(node) && !isHandled(path)) {
-        // Check if it's an expression statement (standalone call)
-        if (path.parentPath.isExpressionStatement()) {
-          findings.push({
-            type: "floating_promise",
-            severity: "WARN",
-            category: "AsyncPatterns",
-            file: filePath,
-            line: loc.line,
-            column: loc.column,
-            title: "Floating promise (unhandled)",
-            message: "Promise returned but not awaited or handled. Errors may be silently swallowed.",
-            codeSnippet: snippetForLine(lines, loc.line),
-            confidence: "high",
-            fixHint: "Add 'await' or '.catch()' to handle potential errors",
-          });
-        }
-      }
-    },
-    
-    // Check for await in non-async function
-    AwaitExpression(path) {
-      const node = path.node;
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      if (!isInAsyncFunction(path)) {
-        // This would be a syntax error, but might slip through in some cases
-        findings.push({
-          type: "await_outside_async",
-          severity: "BLOCK",
-          category: "AsyncPatterns",
-          file: filePath,
-          line: loc.line,
-          column: loc.column,
-          title: "await outside async function",
-          message: "await can only be used inside async functions.",
-          codeSnippet: snippetForLine(lines, loc.line),
-          confidence: "high",
-          fixHint: "Make the containing function async",
-        });
-      }
-      
-      // Track for sequential await detection
-      const fnParent = path.getFunctionParent();
-      if (fnParent) {
-        if (!sequentialAwaits.has(fnParent)) {
-          sequentialAwaits.set(fnParent, []);
-        }
-        
-        // Check if it's a variable declaration
-        const parent = path.parentPath;
-        if (parent.isVariableDeclarator() && t.isIdentifier(parent.node.id)) {
-          sequentialAwaits.get(fnParent).push({
-            line: loc.line,
-            varName: parent.node.id.name,
-            argument: path.node.argument,
-          });
-        }
-      }
-    },
-    
-    // Check for Promise constructor anti-patterns
-    NewExpression(path) {
-      const node = path.node;
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      if (t.isIdentifier(node.callee, { name: "Promise" })) {
-        const executor = node.arguments[0];
-        
-        if (t.isArrowFunctionExpression(executor) || t.isFunctionExpression(executor)) {
-          // Check for async executor (anti-pattern)
-          if (executor.async) {
-            findings.push({
-              type: "async_promise_executor",
-              severity: "WARN",
-              category: "AsyncPatterns",
-              file: filePath,
-              line: loc.line,
-              column: loc.column,
-              title: "Async function as Promise executor",
-              message: "Using async function as Promise executor can lead to unhandled rejections.",
-              codeSnippet: snippetForLine(lines, loc.line),
-              confidence: "high",
-              fixHint: "Remove async from executor or restructure to avoid Promise constructor",
-            });
-          }
-          
-          // Check for return statement in executor (doesn't work as expected)
-          let hasReturn = false;
-          traverse(executor.body, {
-            ReturnStatement(innerPath) {
-              // Ignore nested functions
-              if (innerPath.getFunctionParent() === path) return;
-              hasReturn = true;
-            },
-            noScope: true,
-          }, path.scope);
-          
-          if (hasReturn) {
-            findings.push({
-              type: "promise_executor_return",
-              severity: "INFO",
-              category: "AsyncPatterns",
-              file: filePath,
-              line: loc.line,
-              column: loc.column,
-              title: "Return in Promise executor",
-              message: "Return value in Promise executor is ignored. Use resolve() instead.",
-              codeSnippet: snippetForLine(lines, loc.line),
-              confidence: "med",
-              fixHint: "Use resolve(value) instead of return value",
-            });
-          }
-        }
-      }
-    },
-    
-    // Check for .then() in async function (prefer await)
-    MemberExpression(path) {
-      const node = path.node;
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      if (t.isIdentifier(node.property, { name: "then" }) && isInAsyncFunction(path)) {
-        // Check if it's being called
-        if (path.parentPath.isCallExpression() && path.parentPath.node.callee === node) {
-          findings.push({
-            type: "then_in_async",
-            severity: "INFO",
-            category: "AsyncPatterns",
-            file: filePath,
-            line: loc.line,
-            column: loc.column,
-            title: ".then() in async function",
-            message: "Consider using await instead of .then() in async functions for cleaner code.",
-            codeSnippet: snippetForLine(lines, loc.line),
-            confidence: "low",
-            fixHint: "const result = await promise; instead of promise.then(result => ...)",
-          });
-        }
-      }
-    },
-    
-    // Check for Promise.all with await in loop (should be batched)
-    ForStatement(path) {
-      checkAwaitInLoop(path, findings, filePath, lines);
-    },
-    ForInStatement(path) {
-      checkAwaitInLoop(path, findings, filePath, lines);
-    },
-    ForOfStatement(path) {
-      checkAwaitInLoop(path, findings, filePath, lines);
-    },
-    WhileStatement(path) {
-      checkAwaitInLoop(path, findings, filePath, lines);
-    },
-    
-    // Check for missing error handling
-    TryStatement(path) {
-      const node = path.node;
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      // Check if try block has await but catch is empty
-      let hasAwait = false;
-      path.traverse({
-        AwaitExpression() {
-          hasAwait = true;
-        },
-      });
-      
-      if (hasAwait && node.handler) {
-        const catchBody = node.handler.body;
-        if (t.isBlockStatement(catchBody) && catchBody.body.length === 0) {
-          findings.push({
-            type: "empty_async_catch",
-            severity: "WARN",
-            category: "AsyncPatterns",
-            file: filePath,
-            line: node.handler.loc?.start.line || loc.line,
-            column: 0,
-            title: "Empty catch block for async operation",
-            message: "Async operation errors are being silently swallowed.",
-            codeSnippet: snippetForLine(lines, node.handler.loc?.start.line || loc.line),
-            confidence: "high",
-            fixHint: "Log or re-throw the error in the catch block",
-          });
-        }
-      }
-    },
-  });
-  
-  // Analyze sequential awaits
-  for (const [fnPath, awaits] of sequentialAwaits) {
-    if (awaits.length < 2) continue;
-    
-    // Check for independent awaits that could be parallel
-    // This is a heuristic - we look for awaits that don't depend on each other
-    const independentGroups = findIndependentAwaits(awaits, code);
-    
-    for (const group of independentGroups) {
-      if (group.length >= 2) {
-        const firstLine = group[0].line;
-        const varNames = group.map(a => a.varName).join(", ");
-        
-        findings.push({
-          type: "sequential_await",
-          severity: "INFO",
-          category: "AsyncPatterns",
-          file: filePath,
-          line: firstLine,
-          column: 0,
-          title: `Sequential awaits could be parallel`,
-          message: `Variables [${varNames}] are awaited sequentially but appear independent. Consider Promise.all().`,
-          codeSnippet: snippetForLine(lines, firstLine),
-          confidence: "low",
-          fixHint: `const [${varNames}] = await Promise.all([...])`,
-        });
-      }
-    }
-  }
-  
-  return findings;
-}
-
-/**
- * Check for await in loop
- */
-function checkAwaitInLoop(path, findings, filePath, lines) {
-  const node = path.node;
-  const loc = node.loc?.start;
-  if (!loc) return;
-  
-  let awaitCount = 0;
-  let firstAwaitLine = null;
-  
-  path.traverse({
-    AwaitExpression(innerPath) {
-      // Skip nested functions
-      const fnParent = innerPath.getFunctionParent();
-      if (fnParent !== path.getFunctionParent()) return;
-      
-      awaitCount++;
-      if (!firstAwaitLine) {
-        firstAwaitLine = innerPath.node.loc?.start.line;
-      }
-    },
-  });
-  
-  if (awaitCount > 0) {
-    findings.push({
-      type: "await_in_loop",
-      severity: "INFO",
-      category: "AsyncPatterns",
-      file: filePath,
-      line: firstAwaitLine || loc.line,
-      column: 0,
-      title: "await inside loop",
-      message: `Found ${awaitCount} await(s) in loop. Consider Promise.all() for parallel execution if operations are independent.`,
-      codeSnippet: snippetForLine(lines, firstAwaitLine || loc.line),
-      confidence: "low",
-      fixHint: "const results = await Promise.all(items.map(async item => ...))",
-    });
-  }
-}
-
-/**
- * Find groups of independent awaits
- * This is a simple heuristic - checks if variables reference each other
- */
-function findIndependentAwaits(awaits, code) {
-  const groups = [];
-  const used = new Set();
-  
-  for (let i = 0; i < awaits.length; i++) {
-    if (used.has(i)) continue;
-    
-    const group = [awaits[i]];
-    used.add(i);
-    
-    for (let j = i + 1; j < awaits.length; j++) {
-      if (used.has(j)) continue;
-      
-      // Check if awaits[j] depends on any previous result
-      const prevVars = group.map(a => a.varName);
-      const awaitCode = code.substring(
-        awaits[j].argument?.start || 0,
-        awaits[j].argument?.end || 0
-      );
-      
-      // Simple check: does the await reference previous variables?
-      const dependsOnPrev = prevVars.some(v => 
-        new RegExp(`\\b${v}\\b`).test(awaitCode)
-      );
-      
-      if (!dependsOnPrev) {
-        group.push(awaits[j]);
-        used.add(j);
-      }
-    }
-    
-    groups.push(group);
-  }
-  
-  return groups.filter(g => g.length >= 2);
-}
-
-module.exports = {
-  analyzeAsyncPatterns,
-  isPromiseReturning,
-  isHandled,
-  isInAsyncFunction,
-};