@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/engine/types.js

@@ -0,0 +1,124 @@
+// bin/runners/lib/engine/types.js
+// JSDoc type definitions for the engine
+
+/**
+ * @typedef {Object} FileRecord
+ * @property {string} abs - Absolute path
+ * @property {string} rel - Relative path from repo root (forward slashes)
+ * @property {number} size - File size in bytes
+ * @property {number} mtime - Last modified time (ms since epoch)
+ * @property {string} hash - Content hash (sha256)
+ * @property {string} [ext] - File extension (e.g., ".ts", ".js")
+ */
+
+/**
+ * @typedef {Object} RepoSignals
+ * @property {boolean} hasPackageJson
+ * @property {boolean} hasRequirementsTxt
+ * @property {boolean} hasPyprojectToml
+ * @property {boolean} hasGoMod
+ * @property {boolean} hasGemfile
+ * @property {boolean} hasNextApp - has app/ directory
+ * @property {boolean} hasNextPages - has pages/ directory
+ * @property {boolean} hasOpenAPI
+ * @property {boolean} hasGraphQL
+ * @property {Set<string>} detectedFrameworks
+ */
+
+/**
+ * @typedef {Object} RepoIndexResult
+ * @property {FileRecord[]} files - All indexed files
+ * @property {RepoSignals} signals - Detected signals
+ * @property {Map<string, string>} contentCache - abs -> content
+ * @property {Map<string, Set<string>>} tokenIndex - token -> Set<abs>
+ * @property {Object} stats
+ * @property {number} stats.totalFiles
+ * @property {number} stats.totalSize
+ * @property {number} stats.indexTimeMs
+ */
+
+/**
+ * @typedef {Object} Evidence
+ * @property {string} id - Unique evidence ID (ev_xxxx)
+ * @property {string} file - Relative file path
+ * @property {string} lines - Line range (e.g., "10-15")
+ * @property {string} snippetHash - SHA256 of snippet
+ * @property {string} reason - Why this is evidence
+ */
+
+/**
+ * @typedef {Object} RouteFact
+ * @property {string} method - HTTP method (GET, POST, *, etc.)
+ * @property {string} path - Canonicalized route path
+ * @property {string} handler - Relative file path
+ * @property {string} framework - Source framework
+ * @property {"high"|"med"|"low"} confidence
+ * @property {Evidence[]} evidence
+ * @property {string[]} [hooks] - Fastify hooks if present
+ */
+
+/**
+ * @typedef {Object} ClientRefFact
+ * @property {string} method - HTTP method or "*"
+ * @property {string} path - Canonicalized path
+ * @property {string} source - Relative file path
+ * @property {"high"|"med"|"low"} confidence
+ * @property {string} kind - fetch, axios_member, axios_config, useSWR, useQuery
+ * @property {Evidence[]} evidence
+ */
+
+/**
+ * @typedef {Object} EnvFact
+ * @property {string} name - Environment variable name
+ * @property {string[]} files - Files where it's referenced
+ * @property {boolean} hasDefault - Whether a default value exists
+ * @property {string} [defaultValue] - Default value if any
+ */
+
+/**
+ * @typedef {Object} Gap
+ * @property {string} kind - Gap type (e.g., "fastify_plugin_unresolved")
+ * @property {string} [file] - Related file
+ * @property {string} [spec] - Module specifier
+ * @property {string} [name] - Identifier name
+ * @property {string} [note] - Additional notes
+ * @property {string} [error] - Error message if from catch
+ */
+
+/**
+ * @typedef {Object} AdapterResult
+ * @property {RouteFact[]} routes
+ * @property {ClientRefFact[]} clientRefs
+ * @property {Gap[]} gaps
+ * @property {Object} stats
+ * @property {number} stats.filesScanned
+ * @property {number} stats.parseErrors
+ * @property {number} [quality] - 0-1 extraction quality score
+ */
+
+/**
+ * @typedef {Object} Finding
+ * @property {string} id - Stable finding ID
+ * @property {string} title
+ * @property {string} description
+ * @property {"info"|"warn"|"block"} severity
+ * @property {"high"|"med"|"low"} confidence
+ * @property {Evidence[]} evidence
+ * @property {Gap[]} [gaps]
+ * @property {string} [suggestedFix]
+ * @property {string} [category]
+ */
+
+/**
+ * @typedef {Object} ScanResult
+ * @property {Finding[]} findings
+ * @property {Object} truthpack
+ * @property {Object} stats
+ * @property {number} stats.scanTimeMs
+ * @property {number} stats.filesIndexed
+ * @property {number} stats.routesFound
+ * @property {number} stats.clientRefsFound
+ * @property {number} stats.gapsFound
+ */
+
+module.exports = {};

package/bin/runners/lib/engines/accessibility-engine.js

@@ -1,115 +1,12 @@
 /**
  * Accessibility Analysis Engine
  * Detects accessibility issues in React/JSX code
- * Enhanced with smarter detection:
- * - Distinguishes decorative vs informative images (empty alt="" is valid)
- * - Checks for visible text content in buttons/links
- * - Detects Next.js Image component and accessible patterns
- * - Supports aria-hidden for decorative elements
  */
 
 const { getAST } = require("./ast-cache");
 const traverse = require("@babel/traverse").default;
 const t = require("@babel/types");
 
-/**
- * Get attribute value from JSX element
- */
-function getAttributeValue(attributes, name) {
-  const attr = attributes.find(a => 
-    t.isJSXAttribute(a) && a.name && a.name.name === name
-  );
-  if (!attr) return undefined;
-  
-  if (t.isStringLiteral(attr.value)) {
-    return attr.value.value;
-  }
-  if (t.isJSXExpressionContainer(attr.value)) {
-    const expr = attr.value.expression;
-    if (t.isStringLiteral(expr)) return expr.value;
-    if (t.isTemplateLiteral(expr) && expr.quasis.length === 1) {
-      return expr.quasis[0].value.raw;
-    }
-  }
-  return null; // Has attribute but value is dynamic
-}
-
-/**
- * Check if element has visible text content
- */
-function hasVisibleTextContent(element) {
-  if (!element.children) return false;
-  
-  for (const child of element.children) {
-    // Text node
-    if (t.isJSXText(child) && child.value.trim()) {
-      return true;
-    }
-    // Expression that might be text
-    if (t.isJSXExpressionContainer(child)) {
-      const expr = child.expression;
-      if (t.isStringLiteral(expr) && expr.value.trim()) return true;
-      if (t.isTemplateLiteral(expr)) return true;
-      if (t.isIdentifier(expr)) return true; // Variable might be text
-    }
-    // Nested element - recursively check
-    if (t.isJSXElement(child)) {
-      if (hasVisibleTextContent(child)) return true;
-    }
-  }
-  return false;
-}
-
-/**
- * Check if image is decorative (intentionally hidden from screen readers)
- */
-function isDecorativeImage(attributes) {
-  // Check for aria-hidden="true"
-  const ariaHidden = getAttributeValue(attributes, "aria-hidden");
-  if (ariaHidden === "true") return true;
-  
-  // Check for role="presentation" or role="none"
-  const role = getAttributeValue(attributes, "role");
-  if (role === "presentation" || role === "none") return true;
-  
-  // Empty alt="" is valid for decorative images
-  const alt = getAttributeValue(attributes, "alt");
-  if (alt === "") return true;
-  
-  return false;
-}
-
-/**
- * Check if element is likely a decorative icon
- */
-function isLikelyIcon(attributes, tagName) {
-  // Common icon patterns
-  const className = getAttributeValue(attributes, "className") || "";
-  const iconPatterns = [
-    /icon/i,
-    /fa-/i,        // FontAwesome
-    /bi-/i,        // Bootstrap Icons
-    /lucide/i,     // Lucide icons
-    /heroicon/i,   // Heroicons
-    /material/i,   // Material icons
-    /mdi-/i,       // Material Design Icons
-  ];
-  
-  if (iconPatterns.some(p => p.test(className))) return true;
-  
-  // SVG icons
-  if (tagName === "svg") {
-    const width = getAttributeValue(attributes, "width");
-    const height = getAttributeValue(attributes, "height");
-    // Small dimensions often indicate icons
-    if ((width && parseInt(width) <= 32) || (height && parseInt(height) <= 32)) {
-      return true;
-    }
-  }
-  
-  return false;
-}
-
 /**
  * Analyze accessibility issues
  */
@@ -127,40 +24,12 @@ function analyzeAccessibility(code, filePath) {
     JSXElement(path) {
       const node = path.node;
       const openingElement = node.openingElement;
+      const tagName = openingElement.name.name;
       
-      // Handle both simple names and member expressions (e.g., Image, Next.Image)
-      let tagName = null;
-      if (t.isJSXIdentifier(openingElement.name)) {
-        tagName = openingElement.name.name;
-      } else if (t.isJSXMemberExpression(openingElement.name)) {
-        tagName = openingElement.name.property.name;
-      }
-      
-      if (!tagName) return;
-      
-      const attributes = openingElement.attributes || [];
-      
-      // Missing alt text on images (including Next.js Image component)
-      if (tagName === "img" || tagName === "Image") {
-        // Skip decorative images
-        if (isDecorativeImage(attributes)) {
-          return;
-        }
-        
-        // Skip if likely an icon with aria-hidden parent
-        if (isLikelyIcon(attributes, tagName)) {
-          // Check if parent has aria-hidden
-          const parent = path.findParent(p => t.isJSXElement(p.node));
-          if (parent) {
-            const parentAttrs = parent.node.openingElement.attributes || [];
-            if (getAttributeValue(parentAttrs, "aria-hidden") === "true") {
-              return;
-            }
-          }
-        }
-        
-        const hasAlt = attributes.some(attr => 
-          t.isJSXAttribute(attr) && attr.name && attr.name.name === "alt"
+      // Missing alt text on images
+      if (tagName === "img") {
+        const hasAlt = openingElement.attributes.some(attr => 
+          t.isJSXAttribute(attr) && attr.name.name === "alt"
         );
         
         if (!hasAlt) {
@@ -173,70 +42,32 @@ function analyzeAccessibility(code, filePath) {
             line,
             column: openingElement.loc.start.column,
             title: "Image missing alt text",
-            message: "Images must have alt text. Use alt=\"\" for decorative images.",
+            message: "Images must have alt text for screen readers",
             codeSnippet: lines[line - 1]?.trim(),
             confidence: "high",
-            fixHint: "Add alt=\"description\" for informative images or alt=\"\" for decorative ones",
           });
         }
       }
       
       // Interactive elements without accessible labels
-      const interactiveElements = ["button", "a", "input", "select", "textarea", "Button", "Link"];
+      const interactiveElements = ["button", "a", "input", "select", "textarea"];
       if (interactiveElements.includes(tagName)) {
-        const hasAriaLabel = attributes.some(attr => 
-          t.isJSXAttribute(attr) && attr.name &&
+        const hasLabel = openingElement.attributes.some(attr => 
+          t.isJSXAttribute(attr) && 
           (attr.name.name === "aria-label" || 
            attr.name.name === "aria-labelledby" ||
            attr.name.name === "title")
         );
         
-        // Check for visible text content (most common way to label buttons/links)
-        const hasTextContent = hasVisibleTextContent(node);
-        
         // Check for associated label element
         const hasAssociatedLabel = path.findParent(p => {
           if (t.isJSXElement(p.node)) {
-            const parentName = t.isJSXIdentifier(p.node.openingElement.name)
-              ? p.node.openingElement.name.name
-              : null;
-            return parentName === "label";
-          }
-          return false;
-        });
-        
-        // Check for sr-only children (screen reader only text)
-        const hasSrOnlyText = node.children && node.children.some(child => {
-          if (t.isJSXElement(child)) {
-            const childAttrs = child.openingElement.attributes || [];
-            const className = getAttributeValue(childAttrs, "className") || "";
-            return /sr-only|visually-hidden|screen-reader/i.test(className);
+            return p.node.openingElement.name.name === "label";
           }
           return false;
         });
         
-        // Skip for links and buttons that have visible text or are in link/button components
-        if (tagName === "a" || tagName === "Link" || tagName === "button" || tagName === "Button") {
-          if (hasTextContent || hasAriaLabel || hasSrOnlyText) {
-            // Has accessible name, skip
-          } else {
-            const line = openingElement.loc.start.line;
-            findings.push({
-              type: "missing_accessible_label",
-              severity: "WARN",
-              category: "Accessibility",
-              file: filePath,
-              line,
-              column: openingElement.loc.start.column,
-              title: `${tagName} element missing accessible name`,
-              message: `Add visible text, aria-label, or sr-only text for screen readers`,
-              codeSnippet: lines[line - 1]?.trim(),
-              confidence: "med",
-              fixHint: "Add visible text content or aria-label for accessibility",
-            });
-          }
-        } else if (!hasAriaLabel && !hasAssociatedLabel) {
-          // Form inputs need labels
+        if (!hasLabel && !hasAssociatedLabel && tagName !== "a") {
           const line = openingElement.loc.start.line;
           findings.push({
             type: "missing_accessible_label",
@@ -249,7 +80,6 @@ function analyzeAccessibility(code, filePath) {
             message: `Add aria-label, aria-labelledby, or wrap in <label>`,
             codeSnippet: lines[line - 1]?.trim(),
             confidence: "med",
-            fixHint: "Add aria-label or associate with a <label> element using htmlFor",
           });
         }
       }
@@ -292,27 +122,16 @@ function analyzeAccessibility(code, filePath) {
       
       // Missing keyboard handlers on interactive elements
       if (tagName === "div" || tagName === "span") {
-        const hasOnClick = attributes.some(attr => 
-          t.isJSXAttribute(attr) && attr.name &&
-          attr.name.name === "onClick"
-        );
-        
-        const hasKeyHandler = attributes.some(attr => 
-          t.isJSXAttribute(attr) && attr.name &&
-          (attr.name.name === "onKeyDown" || 
-           attr.name.name === "onKeyUp" || 
-           attr.name.name === "onKeyPress")
+        const hasOnClick = openingElement.attributes.some(attr => 
+          t.isJSXAttribute(attr) && 
+          (attr.name.name === "onClick" || attr.name.name === "onKeyDown")
         );
         
-        const role = getAttributeValue(attributes, "role");
-        const hasInteractiveRole = role && ["button", "link", "tab", "menuitem", "option"].includes(role);
-        
-        const hasTabIndex = attributes.some(attr =>
-          t.isJSXAttribute(attr) && attr.name && attr.name.name === "tabIndex"
+        const hasRole = openingElement.attributes.some(attr => 
+          t.isJSXAttribute(attr) && attr.name.name === "role"
         );
         
-        // Only flag if has onClick but missing both keyboard handler and proper role
-        if (hasOnClick && !hasKeyHandler && !hasInteractiveRole) {
+        if (hasOnClick && !hasRole) {
           const line = openingElement.loc.start.line;
           findings.push({
             type: "missing_keyboard_handler",
@@ -322,28 +141,9 @@ function analyzeAccessibility(code, filePath) {
             line,
             column: openingElement.loc.start.column,
             title: "Interactive element missing keyboard support",
-            message: "Elements with onClick should have role=\"button\" (or similar), tabIndex, and onKeyDown",
-            codeSnippet: lines[line - 1]?.trim(),
-            confidence: "med",
-            fixHint: "Add role=\"button\" tabIndex={0} onKeyDown={(e) => e.key === 'Enter' && handleClick()}",
-          });
-        }
-        
-        // Also warn if has role but no tabIndex (not focusable)
-        if (hasInteractiveRole && !hasTabIndex) {
-          const line = openingElement.loc.start.line;
-          findings.push({
-            type: "missing_tabindex",
-            severity: "WARN",
-            category: "Accessibility",
-            file: filePath,
-            line,
-            column: openingElement.loc.start.column,
-            title: "Interactive element not focusable",
-            message: `Element with role="${role}" should have tabIndex={0} to be keyboard focusable`,
+            message: "Elements with onClick should have onKeyDown and proper role",
             codeSnippet: lines[line - 1]?.trim(),
             confidence: "med",
-            fixHint: "Add tabIndex={0} to make the element keyboard focusable",
           });
         }
       }