@vibecheckai/cli 3.3.0 → 3.5.0

package/bin/runners/lib/engines/import-order-engine.js

@@ -0,0 +1,429 @@
+/**
+ * Import Order Engine
+ * Detects:
+ * - Inconsistent import ordering
+ * - Mixed import styles (require vs import)
+ * - Circular import potential
+ * - Unused imports (basic detection)
+ * - Side-effect imports
+ * - Type-only imports that should use 'import type'
+ */
+
+const { getAST } = require("./ast-cache");
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const { shouldExcludeFile, isTestContext, hasIgnoreDirective } = require("./file-filter");
+
+/**
+ * Import categories for ordering
+ */
+const IMPORT_CATEGORIES = {
+  BUILTIN: 1,      // node:fs, fs, path, etc.
+  EXTERNAL: 2,     // react, lodash, @org/pkg
+  INTERNAL: 3,     // @/, ~/, #/
+  PARENT: 4,       // ../
+  SIBLING: 5,      // ./
+  INDEX: 6,        // ./index, .
+  STYLE: 7,        // .css, .scss, .less
+  TYPE: 8,         // import type
+};
+
+/**
+ * Node.js built-in modules
+ */
+const BUILTIN_MODULES = new Set([
+  "assert", "buffer", "child_process", "cluster", "console", "constants",
+  "crypto", "dgram", "dns", "domain", "events", "fs", "http", "https",
+  "module", "net", "os", "path", "punycode", "querystring", "readline",
+  "repl", "stream", "string_decoder", "sys", "timers", "tls", "tty",
+  "url", "util", "vm", "zlib", "process",
+]);
+
+/**
+ * Determine import category
+ */
+function getImportCategory(source, isTypeOnly = false) {
+  if (isTypeOnly) return IMPORT_CATEGORIES.TYPE;
+  
+  // Style imports
+  if (/\.(css|scss|sass|less|styl)$/.test(source)) {
+    return IMPORT_CATEGORIES.STYLE;
+  }
+  
+  // Node built-in
+  if (source.startsWith("node:") || BUILTIN_MODULES.has(source)) {
+    return IMPORT_CATEGORIES.BUILTIN;
+  }
+  
+  // Internal aliases
+  if (source.startsWith("@/") || source.startsWith("~/") || source.startsWith("#/")) {
+    return IMPORT_CATEGORIES.INTERNAL;
+  }
+  
+  // Relative imports
+  if (source.startsWith("../")) {
+    return IMPORT_CATEGORIES.PARENT;
+  }
+  
+  if (source === "." || source === "./index" || source.startsWith("./index.")) {
+    return IMPORT_CATEGORIES.INDEX;
+  }
+  
+  if (source.startsWith("./")) {
+    return IMPORT_CATEGORIES.SIBLING;
+  }
+  
+  // External packages
+  return IMPORT_CATEGORIES.EXTERNAL;
+}
+
+/**
+ * Get category name for display
+ */
+function getCategoryName(category) {
+  const names = {
+    [IMPORT_CATEGORIES.BUILTIN]: "built-in",
+    [IMPORT_CATEGORIES.EXTERNAL]: "external",
+    [IMPORT_CATEGORIES.INTERNAL]: "internal alias",
+    [IMPORT_CATEGORIES.PARENT]: "parent",
+    [IMPORT_CATEGORIES.SIBLING]: "sibling",
+    [IMPORT_CATEGORIES.INDEX]: "index",
+    [IMPORT_CATEGORIES.STYLE]: "style",
+    [IMPORT_CATEGORIES.TYPE]: "type",
+  };
+  return names[category] || "unknown";
+}
+
+function snippetForLine(lines, line) {
+  return lines[line - 1] ? lines[line - 1].trim() : "";
+}
+
+/**
+ * Analyze import order and patterns
+ */
+function analyzeImportOrder(code, filePath) {
+  const findings = [];
+  
+  if (shouldExcludeFile(filePath)) return findings;
+  if (isTestContext(code, filePath)) return findings;
+  if (hasIgnoreDirective(code, "import-order")) return findings;
+  
+  const ast = getAST(code, filePath);
+  if (!ast) return findings;
+  
+  const lines = code.split("\n");
+  
+  // Collect all imports
+  const imports = [];
+  const requires = [];
+  const importedIdentifiers = new Set();
+  const usedIdentifiers = new Set();
+  let lastImportLine = 0;
+  let hasCodeBetweenImports = false;
+  
+  traverse(ast, {
+    ImportDeclaration(path) {
+      const node = path.node;
+      const loc = node.loc?.start;
+      if (!loc) return;
+      
+      const source = node.source.value;
+      const isTypeOnly = node.importKind === "type";
+      const category = getImportCategory(source, isTypeOnly);
+      
+      // Track imported identifiers
+      for (const specifier of node.specifiers) {
+        if (t.isImportSpecifier(specifier) || t.isImportDefaultSpecifier(specifier)) {
+          importedIdentifiers.add(specifier.local.name);
+        } else if (t.isImportNamespaceSpecifier(specifier)) {
+          importedIdentifiers.add(specifier.local.name);
+        }
+      }
+      
+      // Check for code between imports
+      if (lastImportLine > 0 && loc.line > lastImportLine + 1) {
+        // Check if there's actual code between (not just blank lines or comments)
+        const linesBetween = lines.slice(lastImportLine, loc.line - 1);
+        const hasCode = linesBetween.some(l => {
+          const trimmed = l.trim();
+          return trimmed && !trimmed.startsWith("//") && !trimmed.startsWith("/*");
+        });
+        if (hasCode) {
+          hasCodeBetweenImports = true;
+        }
+      }
+      lastImportLine = loc.line;
+      
+      imports.push({
+        source,
+        category,
+        line: loc.line,
+        isTypeOnly,
+        isSideEffect: node.specifiers.length === 0,
+        node,
+      });
+    },
+    
+    // Track require() calls
+    CallExpression(path) {
+      const node = path.node;
+      
+      if (t.isIdentifier(node.callee, { name: "require" }) &&
+          node.arguments.length > 0 &&
+          t.isStringLiteral(node.arguments[0])) {
+        
+        const loc = node.loc?.start;
+        if (!loc) return;
+        
+        requires.push({
+          source: node.arguments[0].value,
+          line: loc.line,
+        });
+      }
+    },
+    
+    // Track used identifiers
+    Identifier(path) {
+      // Skip if it's a declaration
+      if (path.isBindingIdentifier()) return;
+      
+      // Skip property names
+      if (path.parentPath.isMemberExpression() && 
+          path.key === "property" && 
+          !path.parentPath.node.computed) {
+        return;
+      }
+      
+      // Skip import specifiers
+      if (path.parentPath.isImportSpecifier() || 
+          path.parentPath.isImportDefaultSpecifier() ||
+          path.parentPath.isImportNamespaceSpecifier()) {
+        return;
+      }
+      
+      usedIdentifiers.add(path.node.name);
+    },
+    
+    // Track JSX usage
+    JSXIdentifier(path) {
+      if (path.parentPath.isJSXOpeningElement() || path.parentPath.isJSXClosingElement()) {
+        usedIdentifiers.add(path.node.name);
+      }
+    },
+  });
+  
+  // Check import order
+  let lastCategory = 0;
+  let lastSource = "";
+  let orderViolations = [];
+  
+  for (let i = 0; i < imports.length; i++) {
+    const imp = imports[i];
+    
+    // Check category order
+    if (imp.category < lastCategory) {
+      orderViolations.push({
+        line: imp.line,
+        source: imp.source,
+        expectedBefore: getCategoryName(lastCategory),
+        actualCategory: getCategoryName(imp.category),
+      });
+    } else if (imp.category === lastCategory) {
+      // Within same category, check alphabetical order (optional)
+      // Skip this for now as it's too strict
+    }
+    
+    lastCategory = imp.category;
+    lastSource = imp.source;
+  }
+  
+  // Report order violations (grouped)
+  if (orderViolations.length > 0) {
+    const firstViolation = orderViolations[0];
+    findings.push({
+      type: "import_order",
+      severity: "INFO",
+      category: "ImportOrder",
+      file: filePath,
+      line: firstViolation.line,
+      column: 0,
+      title: `Import order inconsistent (${orderViolations.length} issues)`,
+      message: `'${firstViolation.source}' (${firstViolation.actualCategory}) should come before ${firstViolation.expectedBefore} imports.`,
+      codeSnippet: snippetForLine(lines, firstViolation.line),
+      confidence: "low",
+      fixHint: "Order imports: built-in → external → internal → parent → sibling → index → styles",
+    });
+  }
+  
+  // Check for mixed import/require
+  if (imports.length > 0 && requires.length > 0) {
+    const firstRequire = requires[0];
+    findings.push({
+      type: "mixed_imports",
+      severity: "INFO",
+      category: "ImportOrder",
+      file: filePath,
+      line: firstRequire.line,
+      column: 0,
+      title: "Mixed import and require statements",
+      message: `File uses both ESM imports (${imports.length}) and CommonJS require (${requires.length}). Consider using consistent module syntax.`,
+      codeSnippet: snippetForLine(lines, firstRequire.line),
+      confidence: "low",
+      fixHint: "Convert to ESM: import x from 'y' instead of const x = require('y')",
+    });
+  }
+  
+  // Check for code between imports
+  if (hasCodeBetweenImports) {
+    findings.push({
+      type: "code_between_imports",
+      severity: "INFO",
+      category: "ImportOrder",
+      file: filePath,
+      line: 1,
+      column: 0,
+      title: "Code between import statements",
+      message: "There is code between import statements. Keep all imports at the top of the file.",
+      codeSnippet: "",
+      confidence: "med",
+      fixHint: "Move all imports to the top of the file, before any other code",
+    });
+  }
+  
+  // Check for side-effect imports (warn if not intentional)
+  const sideEffectImports = imports.filter(i => i.isSideEffect);
+  for (const imp of sideEffectImports) {
+    // Skip known side-effect imports
+    if (/\.(css|scss|sass|less)$/.test(imp.source)) continue;
+    if (imp.source.includes("polyfill")) continue;
+    if (imp.source.includes("register")) continue;
+    
+    findings.push({
+      type: "side_effect_import",
+      severity: "INFO",
+      category: "ImportOrder",
+      file: filePath,
+      line: imp.line,
+      column: 0,
+      title: `Side-effect import: ${imp.source}`,
+      message: "Import doesn't import any values. If intentional, add a comment.",
+      codeSnippet: snippetForLine(lines, imp.line),
+      confidence: "low",
+      fixHint: "Add // side-effect import comment or import specific values",
+    });
+  }
+  
+  // Check for potentially unused imports
+  const unusedImports = [];
+  for (const identifier of importedIdentifiers) {
+    if (!usedIdentifiers.has(identifier)) {
+      // Skip common false positives
+      if (identifier === "React") continue; // JSX transform
+      if (identifier.startsWith("_")) continue; // Intentionally unused
+      
+      unusedImports.push(identifier);
+    }
+  }
+  
+  if (unusedImports.length > 0) {
+    // Find the line for the first unused import
+    let unusedLine = 1;
+    for (const imp of imports) {
+      for (const spec of imp.node.specifiers) {
+        if (unusedImports.includes(spec.local.name)) {
+          unusedLine = imp.line;
+          break;
+        }
+      }
+    }
+    
+    findings.push({
+      type: "unused_import",
+      severity: "INFO",
+      category: "ImportOrder",
+      file: filePath,
+      line: unusedLine,
+      column: 0,
+      title: `Potentially unused imports (${unusedImports.length})`,
+      message: `Imports may be unused: ${unusedImports.slice(0, 5).join(", ")}${unusedImports.length > 5 ? "..." : ""}`,
+      codeSnippet: snippetForLine(lines, unusedLine),
+      confidence: "low",
+      fixHint: "Remove unused imports or prefix with underscore if intentional",
+    });
+  }
+  
+  // Check for imports that should use 'import type'
+  traverse(ast, {
+    ImportDeclaration(path) {
+      const node = path.node;
+      if (node.importKind === "type") return; // Already type import
+      
+      const loc = node.loc?.start;
+      if (!loc) return;
+      
+      // Check if all specifiers are only used as types
+      let allTypeOnly = true;
+      
+      for (const specifier of node.specifiers) {
+        if (!t.isImportSpecifier(specifier)) {
+          allTypeOnly = false;
+          break;
+        }
+        
+        const name = specifier.local.name;
+        
+        // Check if used as value anywhere
+        let usedAsValue = false;
+        traverse(ast, {
+          Identifier(innerPath) {
+            if (innerPath.node.name !== name) return;
+            if (innerPath.parentPath.isImportSpecifier()) return;
+            
+            // Check if in type annotation
+            if (innerPath.findParent(p => 
+              p.isTSTypeAnnotation() || 
+              p.isTSTypeReference() ||
+              p.isTSInterfaceDeclaration() ||
+              p.isTSTypeAliasDeclaration()
+            )) {
+              return; // Type usage, OK
+            }
+            
+            usedAsValue = true;
+          },
+        }, path.scope, path);
+        
+        if (usedAsValue) {
+          allTypeOnly = false;
+          break;
+        }
+      }
+      
+      if (allTypeOnly && node.specifiers.length > 0) {
+        findings.push({
+          type: "should_be_type_import",
+          severity: "INFO",
+          category: "ImportOrder",
+          file: filePath,
+          line: loc.line,
+          column: 0,
+          title: "Import could use 'import type'",
+          message: "All imports from this module are only used as types.",
+          codeSnippet: snippetForLine(lines, loc.line),
+          confidence: "low",
+          fixHint: "Change to: import type { ... } from '...'",
+        });
+      }
+    },
+  });
+  
+  return findings;
+}
+
+module.exports = {
+  analyzeImportOrder,
+  getImportCategory,
+  getCategoryName,
+  IMPORT_CATEGORIES,
+  BUILTIN_MODULES,
+};

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

@@ -1,12 +1,19 @@
 /**
  * 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
@@ -106,6 +113,25 @@ 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
  */
@@ -125,10 +151,16 @@ 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",
@@ -138,14 +170,13 @@ 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: lines[line - 1]?.trim(),
+          codeSnippet: lineContent.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",
@@ -155,7 +186,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: lines[line - 1]?.trim(),
+          codeSnippet: lineContent.trim(),
           confidence: "med",
         });
       }
@@ -165,9 +196,15 @@ 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",
@@ -177,13 +214,12 @@ 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: lines[line - 1]?.trim(),
+          codeSnippet: lineContent.trim(),
           confidence: "med",
         });
       }
       
       if (t.isStringLiteral(value) && isMockString(value.value)) {
-        const line = getLineNumber(path.node, code);
         findings.push({
           type: "mock_property_value",
           severity: "WARN",
@@ -193,7 +229,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: lines[line - 1]?.trim(),
+          codeSnippet: lineContent.trim(),
           confidence: "med",
         });
       }
@@ -236,10 +272,17 @@ 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",
@@ -249,7 +292,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: lines[line - 1]?.trim(),
+            codeSnippet: lineContent.trim(),
             confidence: "med",
           });
           break;