@vibecheckai/cli 3.4.0 → 3.5.0

package/bin/runners/lib/engines/context-detection.js

@@ -0,0 +1,264 @@
+/**
+ * Context-Aware Detection Utilities
+ * 
+ * Provides smarter detection logic to reduce false positives in vibecheck scans.
+ * Handles cases like:
+ * - Tailwind CSS modifiers (placeholder:text-white/40)
+ * - UI button labels (Mock/Live toggles)
+ * - Valid example data (Todo App in project lists)
+ */
+
+/**
+ * Patterns that indicate Tailwind CSS class context
+ * These are styling directives, not placeholder content
+ */
+const TAILWIND_MODIFIER_PATTERNS = [
+  // Tailwind placeholder: modifier (styles placeholder text in inputs)
+  /\bplaceholder:/,
+  // Other Tailwind state modifiers that might contain keywords
+  /\b(?:hover|focus|active|disabled|checked|invalid|required|empty|default):/,
+  // Tailwind arbitrary value syntax
+  /\[placeholder[:\]]/,
+];
+
+/**
+ * Patterns that indicate className or CSS context
+ */
+const CSS_CLASS_PATTERNS = [
+  // className="..." or className={...}
+  /className\s*[=:]\s*[{"`']/,
+  // class="..." (HTML)
+  /\bclass\s*=\s*["']/,
+  // Tailwind @apply directive
+  /@apply\s+/,
+  // CSS-in-JS style objects
+  /\bstyle\s*[=:]\s*\{/,
+  // clsx, classnames, cn utilities
+  /\b(?:clsx|classnames|cn)\s*\(/,
+  // twMerge, tailwind-merge
+  /\b(?:twMerge|tailwind-merge)\s*\(/,
+];
+
+/**
+ * Patterns for UI labels/buttons that legitimately use "mock", "todo", etc.
+ */
+const LEGITIMATE_UI_LABEL_PATTERNS = [
+  // Button onClick handlers with mode labels
+  /onClick\s*=.*['"](?:mock|live|demo|test)["']/i,
+  // Mode change handlers
+  /onModeChange\s*\?\.\s*\(['"](?:mock|live|demo)["']\)/i,
+  // Radio button or toggle values
+  /value\s*[=:]\s*['"](?:mock|live|demo|test)["']/i,
+  // UI state labels
+  /mode\s*===?\s*['"](?:mock|live|demo|test)["']/i,
+  // Tab or button labels in arrays/maps
+  /\[\s*['"](?:mock|live)["']\s*,/i,
+  // Option/select values
+  /option\s*value\s*=\s*['"](?:mock|live|demo)["']/i,
+  // Button children with mode text
+  />\s*(?:Mock|Live|Demo|Test)\s*</i,
+];
+
+/**
+ * Patterns for legitimate example/template data
+ */
+const LEGITIMATE_EXAMPLE_DATA_PATTERNS = [
+  // Array of project/template names (common in UI)
+  /\[\s*['"](?:Todo\s*App|Landing\s*Page|Dashboard|Blog|Portfolio|E-?commerce)["']/i,
+  // Project name selectors or dropdowns
+  /projectName|templateName|appName|recentProjects/i,
+  // Example/sample data arrays in UI components
+  /examples?\s*[=:]\s*\[/i,
+  /templates?\s*[=:]\s*\[/i,
+  /presets?\s*[=:]\s*\[/i,
+  // Map over example items
+  /\.map\(\s*\(\s*(?:name|item|template)\s*\)/i,
+];
+
+/**
+ * Check if a line contains Tailwind CSS placeholder modifier
+ */
+function isTailwindPlaceholderModifier(line) {
+  return TAILWIND_MODIFIER_PATTERNS.some(pattern => pattern.test(line));
+}
+
+/**
+ * Check if the context is a CSS class definition
+ */
+function isCSSClassContext(line, surroundingLines) {
+  // Check the current line
+  if (CSS_CLASS_PATTERNS.some(pattern => pattern.test(line))) {
+    return true;
+  }
+  
+  // Check surrounding lines for context
+  if (surroundingLines && surroundingLines.length > 0) {
+    const contextBlock = surroundingLines.join('\n');
+    return CSS_CLASS_PATTERNS.some(pattern => pattern.test(contextBlock));
+  }
+  
+  return false;
+}
+
+/**
+ * Check if "mock" or similar words are used as legitimate UI labels
+ */
+function isLegitimateUILabel(line, surroundingLines) {
+  const fullContext = surroundingLines 
+    ? [...surroundingLines, line].join('\n')
+    : line;
+  
+  return LEGITIMATE_UI_LABEL_PATTERNS.some(pattern => pattern.test(fullContext));
+}
+
+/**
+ * Check if the content is legitimate example/template data
+ */
+function isLegitimateExampleData(line, surroundingLines) {
+  const fullContext = surroundingLines 
+    ? [...surroundingLines, line].join('\n')
+    : line;
+  
+  return LEGITIMATE_EXAMPLE_DATA_PATTERNS.some(pattern => pattern.test(fullContext));
+}
+
+/**
+ * Check if the match is in a JSX prop context (not user-visible content)
+ */
+function isJSXPropContext(line, matchedPattern) {
+  // Check if the pattern is part of a JSX prop name (not value)
+  const propNamePatterns = [
+    // Prop names that legitimately contain keywords
+    /\b(?:placeholder|mock|test)(?:Id|Key|Ref|Name|Type|Mode|Data)\s*[=:]/i,
+    // Data attributes
+    /data-(?:placeholder|mock|test)\s*=/i,
+    // Aria labels (visible content, but intentional)
+    /aria-(?:label|description)\s*=\s*["'][^"']*(?:placeholder|mock|test)/i,
+  ];
+  
+  return propNamePatterns.some(pattern => pattern.test(line));
+}
+
+/**
+ * Main context detection function
+ * Analyzes a line and its context to determine if a match is a false positive
+ */
+function detectFalsePositive(line, matchedPattern, options = {}) {
+  const { lineIndex, allLines, filePath, patternType } = options;
+  
+  // Get surrounding lines for context (2 before, 2 after)
+  let surroundingLines = [];
+  if (allLines && lineIndex !== undefined) {
+    const start = Math.max(0, lineIndex - 2);
+    const end = Math.min(allLines.length, lineIndex + 3);
+    surroundingLines = allLines.slice(start, end);
+  }
+  
+  // Check for Tailwind CSS placeholder modifier
+  const lowerPattern = (matchedPattern || '').toLowerCase();
+  if (lowerPattern.includes('placeholder') || patternType === 'placeholder') {
+    if (isTailwindPlaceholderModifier(line)) {
+      return {
+        isFalsePositive: true,
+        reason: 'Tailwind CSS placeholder: modifier (styles input placeholder text)',
+        confidence: 0.95,
+      };
+    }
+  }
+  
+  // Check for CSS class context
+  if (isCSSClassContext(line, surroundingLines)) {
+    return {
+      isFalsePositive: true,
+      reason: 'CSS class/className context (styling, not content)',
+      confidence: 0.9,
+    };
+  }
+  
+  // Check for legitimate UI labels (Mock/Live toggles, etc.)
+  if (lowerPattern.includes('mock') || patternType === 'mock') {
+    if (isLegitimateUILabel(line, surroundingLines)) {
+      return {
+        isFalsePositive: true,
+        reason: 'Legitimate UI label (mode toggle, button text)',
+        confidence: 0.85,
+      };
+    }
+  }
+  
+  // Check for legitimate example data ("Todo App", etc.)
+  if (lowerPattern.includes('todo') || patternType === 'todo') {
+    if (isLegitimateExampleData(line, surroundingLines)) {
+      return {
+        isFalsePositive: true,
+        reason: 'Legitimate example/template data in UI',
+        confidence: 0.8,
+      };
+    }
+  }
+  
+  // Check for JSX props that are not content
+  if (isJSXPropContext(line, matchedPattern)) {
+    return {
+      isFalsePositive: true,
+      reason: 'JSX prop context (attribute, not visible content)',
+      confidence: 0.75,
+    };
+  }
+  
+  // Not a false positive
+  return {
+    isFalsePositive: false,
+    confidence: 0.5,
+  };
+}
+
+/**
+ * Quick check if a line is likely a false positive
+ * Use this for fast pre-filtering before detailed analysis
+ */
+function quickFalsePositiveCheck(line) {
+  // Fast check for common false positive patterns
+  const quickPatterns = [
+    /className.*placeholder:/,
+    /class=.*placeholder:/,
+    /placeholder:text-/,
+    /placeholder:opacity-/,
+    /placeholder:italic/,
+    /onModeChange.*['"]mock["']/i,
+    /onClick.*['"]mock["']/i,
+    /value=['"](?:mock|live)["']/i,
+    /\[['"]Todo App["']/i,
+    /\[['"]Mock["'],\s*['"]Live["']\]/i,
+    />\s*Mock\s*</i,
+    />\s*Live\s*</i,
+  ];
+  
+  return quickPatterns.some(pattern => pattern.test(line));
+}
+
+/**
+ * Filter findings to remove false positives
+ */
+function filterFalsePositives(findings, allLines, options = {}) {
+  return findings.filter(finding => {
+    const lineContent = finding.content || finding.codeSnippet || allLines[finding.line - 1] || '';
+    const result = detectFalsePositive(lineContent, lineContent, {
+      lineIndex: finding.line - 1,
+      allLines,
+      ...options,
+    });
+    return !result.isFalsePositive;
+  });
+}
+
+module.exports = {
+  isTailwindPlaceholderModifier,
+  isCSSClassContext,
+  isLegitimateUILabel,
+  isLegitimateExampleData,
+  isJSXPropContext,
+  detectFalsePositive,
+  quickFalsePositiveCheck,
+  filterFalsePositives,
+};

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

@@ -1,6 +1,11 @@
 /**
  * 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");
@@ -9,6 +14,162 @@ 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
  */
@@ -98,8 +259,43 @@ 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);
   
@@ -157,17 +353,41 @@ function analyzeCrossFile(files, repoRoot) {
     
     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")) {
+        // 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) {
           findings.push({
             type: "unused_export",
-            severity: "WARN",
+            severity: "INFO", // Downgraded from WARN - often intentional
             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",
+            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",
           });
         }
       }
@@ -211,20 +431,42 @@ 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) {
-        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",
-        });
+        // 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",
+          });
+        }
       }
     }
   }
@@ -246,23 +488,46 @@ function analyzeCrossFile(files, repoRoot) {
   
   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",
-      });
+      // 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",
+        });
+      }
     }
   }
   
   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,
 };