@vibecheckai/cli 3.2.3 → 3.2.4

package/bin/runners/lib/engines/code-quality-engine.js

@@ -0,0 +1,255 @@
+/**
+ * Code Quality Detection Engine
+ * Detects code smells, complexity issues, maintainability problems
+ */
+
+const { getAST } = require("./ast-cache");
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const { shouldExcludeFile } = require("./file-filter");
+
+/**
+ * Calculate cyclomatic complexity of a function
+ */
+function calculateComplexity(node) {
+  let complexity = 1; // Base complexity
+  
+  traverse(node, {
+    IfStatement: () => complexity++,
+    SwitchCase: () => complexity++,
+    ForStatement: () => complexity++,
+    ForInStatement: () => complexity++,
+    ForOfStatement: () => complexity++,
+    WhileStatement: () => complexity++,
+    DoWhileStatement: () => complexity++,
+    CatchClause: () => complexity++,
+    ConditionalExpression: () => complexity++,
+    LogicalExpression: (path) => {
+      if (path.node.operator === "&&" || path.node.operator === "||") {
+        complexity++;
+      }
+    },
+  });
+  
+  return complexity;
+}
+
+/**
+ * Analyze a file for code quality issues
+ */
+function analyzeCodeQuality(code, filePath) {
+  const findings = [];
+  
+  // Skip excluded files
+  if (shouldExcludeFile(filePath)) return findings;
+  
+  const ast = getAST(code, filePath);
+  if (!ast) return findings;
+
+  const lines = code.split("\n");
+
+  // Function complexity
+  traverse(ast, {
+    FunctionDeclaration(path) {
+      const node = path.node;
+      const complexity = calculateComplexity(node);
+      
+      if (complexity > 15) {
+        const line = node.loc.start.line;
+        findings.push({
+          type: "high_complexity",
+          severity: "WARN",
+          category: "CodeQuality",
+          file: filePath,
+          line,
+          column: node.loc.start.column,
+          title: `High cyclomatic complexity: ${complexity}`,
+          message: `Function "${node.id?.name || "anonymous"}" has complexity ${complexity} - consider refactoring`,
+          codeSnippet: lines[line - 1]?.trim(),
+          confidence: "high",
+        });
+      }
+    },
+    ArrowFunctionExpression(path) {
+      const node = path.node;
+      const complexity = calculateComplexity(node);
+      
+      if (complexity > 15) {
+        const line = node.loc.start.line;
+        findings.push({
+          type: "high_complexity",
+          severity: "WARN",
+          category: "CodeQuality",
+          file: filePath,
+          line,
+          column: node.loc.start.column,
+          title: `High cyclomatic complexity: ${complexity}`,
+          message: `Arrow function has complexity ${complexity} - consider refactoring`,
+          codeSnippet: lines[line - 1]?.trim(),
+          confidence: "high",
+        });
+      }
+    },
+  });
+
+  // Long functions
+  traverse(ast, {
+    FunctionDeclaration(path) {
+      const node = path.node;
+      const startLine = node.loc.start.line;
+      const endLine = node.loc.end.line;
+      const length = endLine - startLine;
+      
+      if (length > 100) {
+        findings.push({
+          type: "long_function",
+          severity: "WARN",
+          category: "CodeQuality",
+          file: filePath,
+          line: startLine,
+          column: node.loc.start.column,
+          title: `Long function: ${length} lines`,
+          message: `Function "${node.id?.name || "anonymous"}" is ${length} lines - consider breaking into smaller functions`,
+          codeSnippet: lines[startLine - 1]?.trim(),
+          confidence: "med",
+        });
+      }
+    },
+  });
+
+  // Deeply nested code
+  let nestingDepth = 0;
+  let maxNesting = 0;
+  let maxNestingLine = 0;
+  
+  traverse(ast, {
+    enter(path) {
+      if (t.isIfStatement(path.node) || 
+          t.isForStatement(path.node) || 
+          t.isWhileStatement(path.node) ||
+          t.isSwitchStatement(path.node) ||
+          t.isTryStatement(path.node)) {
+        nestingDepth++;
+        if (nestingDepth > maxNesting) {
+          maxNesting = nestingDepth;
+          maxNestingLine = path.node.loc.start.line;
+        }
+      }
+    },
+    exit(path) {
+      if (t.isIfStatement(path.node) || 
+          t.isForStatement(path.node) || 
+          t.isWhileStatement(path.node) ||
+          t.isSwitchStatement(path.node) ||
+          t.isTryStatement(path.node)) {
+        nestingDepth--;
+      }
+    },
+  });
+
+  if (maxNesting > 5) {
+    findings.push({
+      type: "deep_nesting",
+      severity: "WARN",
+      category: "CodeQuality",
+      file: filePath,
+      line: maxNestingLine,
+      column: 0,
+      title: `Deep nesting: ${maxNesting} levels`,
+      message: `Code has ${maxNesting} levels of nesting - consider refactoring with early returns or extraction`,
+      codeSnippet: lines[maxNestingLine - 1]?.trim(),
+      confidence: "med",
+    });
+  }
+
+  // Duplicate code detection (simple string-based)
+  const functionBodies = new Map();
+  traverse(ast, {
+    FunctionDeclaration(path) {
+      const node = path.node;
+      if (node.body) {
+        const bodyCode = code.substring(node.body.start, node.body.end);
+        const normalized = bodyCode.replace(/\s+/g, " ").trim();
+        
+        if (normalized.length > 50) { // Only check substantial functions
+          if (functionBodies.has(normalized)) {
+            const original = functionBodies.get(normalized);
+            findings.push({
+              type: "duplicate_code",
+              severity: "WARN",
+              category: "CodeQuality",
+              file: filePath,
+              line: node.loc.start.line,
+              column: node.loc.start.column,
+              title: "Potential duplicate code",
+              message: `Function "${node.id?.name || "anonymous"}" appears similar to function at line ${original}`,
+              codeSnippet: lines[node.loc.start.line - 1]?.trim(),
+              confidence: "low",
+            });
+          } else {
+            functionBodies.set(normalized, node.loc.start.line);
+          }
+        }
+      }
+    },
+  });
+
+  // Magic numbers
+  traverse(ast, {
+    NumericLiteral(path) {
+      const node = path.node;
+      const value = node.value;
+      
+      // Skip common constants (0, 1, -1, 100, 1000)
+      if ([0, 1, -1, 100, 1000].includes(value)) return;
+      
+      // Check if it's not in a common context (array index, etc.)
+      const parent = path.parent;
+      if (!t.isArrayExpression(parent) && 
+          !t.isMemberExpression(parent) &&
+          !t.isBinaryExpression(parent)) {
+        const line = node.loc.start.line;
+        findings.push({
+          type: "magic_number",
+          severity: "WARN",
+          category: "CodeQuality",
+          file: filePath,
+          line,
+          column: node.loc.start.column,
+          title: `Magic number: ${value}`,
+          message: `Consider extracting ${value} as a named constant`,
+          codeSnippet: lines[line - 1]?.trim(),
+          confidence: "low",
+        });
+      }
+    },
+  });
+
+  // Long parameter lists
+  traverse(ast, {
+    FunctionDeclaration(path) {
+      const node = path.node;
+      if (node.params && node.params.length > 5) {
+        const line = node.loc.start.line;
+        findings.push({
+          type: "long_parameter_list",
+          severity: "WARN",
+          category: "CodeQuality",
+          file: filePath,
+          line,
+          column: node.loc.start.column,
+          title: `Long parameter list: ${node.params.length} parameters`,
+          message: `Function "${node.id?.name || "anonymous"}" has ${node.params.length} parameters - consider using an options object`,
+          codeSnippet: lines[line - 1]?.trim(),
+          confidence: "med",
+        });
+      }
+    },
+  });
+
+  return findings;
+}
+
+module.exports = {
+  analyzeCodeQuality,
+};

package/bin/runners/lib/engines/console-logs-engine.js

@@ -0,0 +1,115 @@
+/**
+ * Console Log Detection Engine
+ * Uses AST analysis to detect console.* calls in production code
+ */
+
+const { getAST, parseCode } = require("./ast-cache");
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const { shouldExcludeFile, isTestContext: isTestContextCheck } = require("./file-filter");
+
+/**
+ * Check if a call expression is a console.* call
+ */
+function isConsoleCall(node) {
+  if (!t.isCallExpression(node)) return false;
+  
+  const callee = node.callee;
+  
+  // console.log(), console.warn(), etc.
+  if (t.isMemberExpression(callee)) {
+    const object = callee.object;
+    const property = callee.property;
+    
+    if (t.isIdentifier(object) && object.name === "console") {
+      if (t.isIdentifier(property)) {
+        const methods = ["log", "warn", "debug", "info", "trace", "error", "dir", "table"];
+        return methods.includes(property.name);
+      }
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Analyze a file for console.* calls
+ */
+function analyzeConsoleLogs(code, filePath) {
+  const findings = [];
+  
+  // Skip excluded files
+  if (shouldExcludeFile(filePath)) return findings;
+  
+  // Skip test contexts
+  if (isTestContextCheck(code, filePath)) return findings;
+  
+  const ast = getAST(code, filePath);
+  if (!ast) return findings;
+
+  const lines = code.split("\n");
+  const MAX_FINDINGS = 15;
+  let consoleCount = 0;
+
+  traverse(ast, {
+    CallExpression(path) {
+      if (isConsoleCall(path.node)) {
+        // Check if it's commented out
+        const leadingComments = path.node.leadingComments || [];
+        const isCommented = leadingComments.some(c => 
+          c.type === "CommentLine" || c.type === "CommentBlock"
+        );
+        
+        if (isCommented) return;
+        
+        consoleCount++;
+        
+        if (findings.length < MAX_FINDINGS) {
+          const line = path.node.loc.start.line;
+          const snippet = lines[line - 1]?.trim() || "";
+          
+          // Get method name
+          let method = "log";
+          if (t.isMemberExpression(path.node.callee) && 
+              t.isIdentifier(path.node.callee.property)) {
+            method = path.node.callee.property.name;
+          }
+          
+          findings.push({
+            type: `console_${method}`,
+            severity: "WARN",
+            category: "ConsoleLog",
+            file: filePath,
+            line,
+            column: path.node.loc.start.column,
+            title: `console.${method}() in production code`,
+            message: `console.${method}() call found at line ${line}`,
+            codeSnippet: snippet.substring(0, 60),
+            confidence: "high",
+          });
+        }
+      }
+    },
+  });
+
+  // Add summary if there are many
+  if (consoleCount > MAX_FINDINGS) {
+    findings.push({
+      type: "summary",
+      severity: "WARN",
+      category: "ConsoleLog",
+      file: filePath,
+      line: 0,
+      title: `${consoleCount} console.* statements found (${consoleCount - MAX_FINDINGS} more not shown)`,
+      message: `Found ${consoleCount} console statements in this file`,
+      confidence: "high",
+    });
+  }
+
+  return findings;
+}
+
+module.exports = {
+  analyzeConsoleLogs,
+  parseCode,
+};

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

@@ -0,0 +1,268 @@
+/**
+ * Cross-File Analysis Engine
+ * Analyzes relationships between files: unused exports, circular dependencies, import consistency
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { getAST } = require("./ast-cache");
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+
+/**
+ * Build export map for all files
+ */
+function buildExportMap(files, repoRoot) {
+  const exportMap = new Map(); // filePath -> Set<exportNames>
+  const importMap = new Map(); // filePath -> Map<importedFrom, Set<importedNames>>
+  
+  for (const fileAbs of files) {
+    try {
+      const code = fs.readFileSync(fileAbs, "utf8");
+      const fileRel = path.relative(repoRoot, fileAbs).replace(/\\/g, "/");
+      const ast = getAST(code, fileRel);
+      if (!ast) continue;
+      
+      const exports = new Set();
+      const imports = new Map();
+      
+      traverse(ast, {
+        // Collect exports
+        ExportNamedDeclaration(path) {
+          if (path.node.declaration) {
+            if (t.isFunctionDeclaration(path.node.declaration)) {
+              exports.add(path.node.declaration.id?.name);
+            } else if (t.isVariableDeclaration(path.node.declaration)) {
+              path.node.declaration.declarations.forEach(decl => {
+                if (t.isIdentifier(decl.id)) {
+                  exports.add(decl.id.name);
+                }
+              });
+            } else if (t.isClassDeclaration(path.node.declaration)) {
+              exports.add(path.node.declaration.id?.name);
+            }
+          }
+          if (path.node.specifiers) {
+            path.node.specifiers.forEach(spec => {
+              if (t.isExportSpecifier(spec)) {
+                exports.add(spec.exported.name);
+              }
+            });
+          }
+        },
+        ExportDefaultDeclaration(path) {
+          if (t.isIdentifier(path.node.declaration)) {
+            exports.add("default");
+          } else if (t.isFunctionDeclaration(path.node.declaration)) {
+            exports.add("default");
+          } else if (t.isClassDeclaration(path.node.declaration)) {
+            exports.add("default");
+          }
+        },
+        
+        // Collect imports
+        ImportDeclaration(path) {
+          const source = path.node.source.value;
+          if (!source.startsWith(".") && !source.startsWith("/")) {
+            // External import, skip
+            return;
+          }
+          
+          const importedNames = new Set();
+          path.node.specifiers.forEach(spec => {
+            if (t.isImportSpecifier(spec)) {
+              importedNames.add(spec.imported.name);
+            } else if (t.isImportDefaultSpecifier(spec)) {
+              importedNames.add("default");
+            } else if (t.isImportNamespaceSpecifier(spec)) {
+              importedNames.add("*");
+            }
+          });
+          
+          if (importedNames.size > 0) {
+            imports.set(source, importedNames);
+          }
+        },
+      });
+      
+      exportMap.set(fileRel, exports);
+      importMap.set(fileRel, imports);
+    } catch (err) {
+      // Skip files that can't be analyzed
+      continue;
+    }
+  }
+  
+  return { exportMap, importMap };
+}
+
+/**
+ * Resolve import path to actual file path
+ */
+function resolveImportPath(importPath, fromFile, repoRoot) {
+  const dir = path.dirname(path.join(repoRoot, fromFile));
+  let resolved = path.resolve(dir, importPath);
+  
+  // Try common extensions
+  const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+  for (const ext of extensions) {
+    const candidate = resolved + ext;
+    if (fs.existsSync(candidate)) {
+      return path.relative(repoRoot, candidate).replace(/\\/g, "/");
+    }
+  }
+  
+  // Try without extension
+  if (fs.existsSync(resolved)) {
+    return path.relative(repoRoot, resolved).replace(/\\/g, "/");
+  }
+  
+  return null;
+}
+
+/**
+ * Analyze cross-file issues
+ */
+function analyzeCrossFile(files, repoRoot) {
+  const findings = [];
+  const { exportMap, importMap } = buildExportMap(files, repoRoot);
+  
+  // 1. Find unused exports
+  const usedExports = new Map(); // filePath -> Set<usedExportNames>
+  
+  for (const [fileRel, imports] of importMap.entries()) {
+    for (const [importPath, importedNames] of imports.entries()) {
+      const targetFile = resolveImportPath(importPath, fileRel, repoRoot);
+      if (!targetFile || !exportMap.has(targetFile)) continue;
+      
+      const exports = exportMap.get(targetFile);
+      if (!usedExports.has(targetFile)) {
+        usedExports.set(targetFile, new Set());
+      }
+      
+      importedNames.forEach(name => {
+        if (name === "*") {
+          // Namespace import - mark all exports as used
+          exports.forEach(exp => usedExports.get(targetFile).add(exp));
+        } else {
+          usedExports.get(targetFile).add(name);
+        }
+      });
+    }
+  }
+  
+  // Find unused exports
+  for (const [fileRel, exports] of exportMap.entries()) {
+    const used = usedExports.get(fileRel) || new Set();
+    
+    for (const exp of exports) {
+      if (!used.has(exp) && exp !== "default") {
+        // 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: "WARN",
+            category: "CodeQuality",
+            file: fileRel,
+            line: 0, // Would need to track line numbers
+            title: `Unused export: ${exp}`,
+            message: `Export "${exp}" from ${fileRel} is never imported`,
+            confidence: "med",
+          });
+        }
+      }
+    }
+  }
+  
+  // 2. Detect circular dependencies
+  const visited = new Set();
+  const recursionStack = new Set();
+  
+  function detectCycle(fileRel, path = []) {
+    if (recursionStack.has(fileRel)) {
+      // Found cycle!
+      const cycleStart = path.indexOf(fileRel);
+      const cycle = path.slice(cycleStart).concat(fileRel);
+      return cycle;
+    }
+    
+    if (visited.has(fileRel)) {
+      return null;
+    }
+    
+    visited.add(fileRel);
+    recursionStack.add(fileRel);
+    
+    const imports = importMap.get(fileRel);
+    if (imports) {
+      for (const [importPath] of imports.entries()) {
+        const targetFile = resolveImportPath(importPath, fileRel, repoRoot);
+        if (targetFile && exportMap.has(targetFile)) {
+          const cycle = detectCycle(targetFile, path.concat(fileRel));
+          if (cycle) {
+            recursionStack.delete(fileRel);
+            return cycle;
+          }
+        }
+      }
+    }
+    
+    recursionStack.delete(fileRel);
+    return null;
+  }
+  
+  for (const fileRel of exportMap.keys()) {
+    if (!visited.has(fileRel)) {
+      const cycle = detectCycle(fileRel);
+      if (cycle && cycle.length > 2) {
+        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",
+        });
+      }
+    }
+  }
+  
+  // 3. Check for inconsistent imports (same module imported differently)
+  const importStyles = new Map(); // modulePath -> Set<importStyles>
+  
+  for (const [fileRel, imports] of importMap.entries()) {
+    for (const [importPath] of imports.entries()) {
+      const targetFile = resolveImportPath(importPath, fileRel, repoRoot);
+      if (!targetFile) continue;
+      
+      if (!importStyles.has(targetFile)) {
+        importStyles.set(targetFile, new Set());
+      }
+      importStyles.get(targetFile).add(importPath);
+    }
+  }
+  
+  for (const [targetFile, styles] of importStyles.entries()) {
+    if (styles.size > 1) {
+      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;
+}
+
+module.exports = {
+  analyzeCrossFile,
+  buildExportMap,
+};