@vibecheckai/cli 3.3.0 → 3.5.0

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

@@ -0,0 +1,444 @@
+/**
+ * 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,
+};