@vibecheckai/cli 3.0.4 → 3.0.7

package/bin/runners/lib/reality/toast-detector.js

@@ -0,0 +1,393 @@
+/**
+ * Toast/Notification Detector v2
+ * 
+ * Detects toasts via DOM observation with library-specific selectors.
+ * Emits signals: toast_success, toast_error, toast_info, toast_unknown
+ */
+
+"use strict";
+
+// =============================================================================
+// LIBRARY-SPECIFIC SELECTORS
+// =============================================================================
+
+const TOAST_LIBRARIES = {
+  sonner: {
+    name: "sonner",
+    container: "[data-sonner-toaster]",
+    toast: "[data-sonner-toast]",
+    typeAttr: "data-type",
+  },
+  reactHotToast: {
+    name: "react-hot-toast",
+    container: "#_rht_toaster, .react-hot-toast",
+    toast: "[aria-live]",
+  },
+  reactToastify: {
+    name: "react-toastify",
+    container: ".Toastify__toast-container",
+    toast: ".Toastify__toast",
+    successClass: "Toastify__toast--success",
+    errorClass: "Toastify__toast--error",
+    infoClass: "Toastify__toast--info",
+    warningClass: "Toastify__toast--warning",
+  },
+  radix: {
+    name: "radix",
+    container: "[data-radix-toast-viewport]",
+    toast: "[data-radix-toast-root]",
+    stateAttr: "data-state",
+  },
+  mantine: {
+    name: "mantine",
+    container: ".mantine-Notifications-root",
+    toast: ".mantine-Notification-root",
+  },
+  chakra: {
+    name: "chakra",
+    container: "[id^='chakra-toast-manager']",
+    toast: "[id^='chakra-toast']",
+  },
+  mui: {
+    name: "mui",
+    container: ".MuiSnackbar-root",
+    toast: ".MuiSnackbarContent-root, .MuiAlert-root",
+    successClass: "MuiAlert-standardSuccess",
+    errorClass: "MuiAlert-standardError",
+    infoClass: "MuiAlert-standardInfo",
+    warningClass: "MuiAlert-standardWarning",
+  },
+  notistack: {
+    name: "notistack",
+    container: ".SnackbarContainer-root",
+    toast: "#notistack-snackbar",
+  },
+  antd: {
+    name: "antd",
+    container: ".ant-message, .ant-notification",
+    toast: ".ant-message-notice, .ant-notification-notice",
+    successClass: "ant-message-success, ant-notification-notice-success",
+    errorClass: "ant-message-error, ant-notification-notice-error",
+  },
+  bootstrap: {
+    name: "bootstrap",
+    container: ".toast-container",
+    toast: ".toast[aria-live]",
+  },
+};
+
+// Universal heuristic selectors
+const UNIVERSAL_SELECTORS = {
+  ariaLive: '[aria-live="polite"], [aria-live="assertive"]',
+  roleAlert: '[role="alert"]',
+  roleStatus: '[role="status"]',
+  ariaAtomic: '[aria-atomic="true"]',
+};
+
+// Class tokens that indicate toast
+const TOAST_CLASS_TOKENS = [
+  "toast", "snackbar", "notification", "noti", "sonner",
+  "Toastify", "chakra-toast", "mantine-Notification",
+  "MuiSnackbar", "ant-message", "ant-notification", "notistack"
+];
+
+// Success/error classification tokens
+const SUCCESS_TOKENS = ["success", "check", "done", "saved", "complete", "✓", "✅"];
+const ERROR_TOKENS = ["error", "fail", "warning", "alert", "danger", "❌", "⚠"];
+const INFO_TOKENS = ["info", "notice", "ℹ"];
+
+// =============================================================================
+// TOAST DETECTOR SCRIPT (runs in browser context)
+// =============================================================================
+
+const TOAST_DETECTOR_SCRIPT = `
+(function setupToastDetector(options = {}) {
+  const {
+    maxLifetimeMs = 15000,
+    captureScreenshots = true,
+  } = options;
+
+  const TOAST_CLASS_TOKENS = ${JSON.stringify(TOAST_CLASS_TOKENS)};
+  const SUCCESS_TOKENS = ${JSON.stringify(SUCCESS_TOKENS)};
+  const ERROR_TOKENS = ${JSON.stringify(ERROR_TOKENS)};
+  const INFO_TOKENS = ${JSON.stringify(INFO_TOKENS)};
+
+  const signals = [];
+  const seenToasts = new Set();
+
+  function normalizeText(text) {
+    return (text || '').trim().replace(/\\s+/g, ' ').slice(0, 200);
+  }
+
+  function classifyToast(el) {
+    const classes = el.className?.toLowerCase() || '';
+    const text = normalizeText(el.textContent);
+    const dataType = el.getAttribute('data-type')?.toLowerCase();
+    
+    // Check data-type first (most reliable)
+    if (dataType) {
+      if (SUCCESS_TOKENS.some(t => dataType.includes(t))) return 'toast_success';
+      if (ERROR_TOKENS.some(t => dataType.includes(t))) return 'toast_error';
+      if (INFO_TOKENS.some(t => dataType.includes(t))) return 'toast_info';
+    }
+
+    // Check classes
+    if (SUCCESS_TOKENS.some(t => classes.includes(t))) return 'toast_success';
+    if (ERROR_TOKENS.some(t => classes.includes(t))) return 'toast_error';
+    if (INFO_TOKENS.some(t => classes.includes(t))) return 'toast_info';
+
+    // Check text content
+    const textLower = text.toLowerCase();
+    if (SUCCESS_TOKENS.some(t => textLower.includes(t))) return 'toast_success';
+    if (ERROR_TOKENS.some(t => textLower.startsWith(t))) return 'toast_error';
+
+    // Check for icon aria-labels
+    const icons = el.querySelectorAll('[aria-label]');
+    for (const icon of icons) {
+      const label = icon.getAttribute('aria-label')?.toLowerCase();
+      if (label && SUCCESS_TOKENS.some(t => label.includes(t))) return 'toast_success';
+      if (label && ERROR_TOKENS.some(t => label.includes(t))) return 'toast_error';
+    }
+
+    return 'toast_unknown';
+  }
+
+  function detectLibrary(el) {
+    // Check specific library markers
+    if (el.closest('[data-sonner-toaster]')) return 'sonner';
+    if (el.closest('.Toastify__toast-container')) return 'react-toastify';
+    if (el.closest('[data-radix-toast-viewport]')) return 'radix';
+    if (el.closest('.mantine-Notifications-root')) return 'mantine';
+    if (el.closest('[id^="chakra-toast"]')) return 'chakra';
+    if (el.closest('.MuiSnackbar-root')) return 'mui';
+    if (el.closest('.SnackbarContainer-root')) return 'notistack';
+    if (el.closest('.ant-message, .ant-notification')) return 'antd';
+    return 'unknown';
+  }
+
+  function isToastCandidate(el) {
+    // Skip hidden elements
+    const style = window.getComputedStyle(el);
+    if (style.display === 'none' || style.visibility === 'hidden') return false;
+    if (style.opacity === '0') return false;
+
+    // Check ARIA roles
+    const role = el.getAttribute('role');
+    if (role === 'alert' || role === 'status') return true;
+    if (el.getAttribute('aria-live')) return true;
+    if (el.getAttribute('aria-atomic') === 'true') return true;
+
+    // Check class tokens
+    const classes = el.className?.toLowerCase() || '';
+    if (TOAST_CLASS_TOKENS.some(t => classes.includes(t.toLowerCase()))) return true;
+
+    // Check positioning (fixed/sticky near edges)
+    if (style.position === 'fixed' || style.position === 'sticky') {
+      const rect = el.getBoundingClientRect();
+      const isNearEdge = rect.top < 100 || rect.bottom > window.innerHeight - 100;
+      if (isNearEdge && el.textContent?.trim().length > 0) return true;
+    }
+
+    return false;
+  }
+
+  function generateToastId(el) {
+    const text = normalizeText(el.textContent).slice(0, 50);
+    const rect = el.getBoundingClientRect();
+    return text + ':' + Math.round(rect.top) + ':' + Math.round(rect.left);
+  }
+
+  function processToast(el) {
+    const toastId = generateToastId(el);
+    if (seenToasts.has(toastId)) return;
+    seenToasts.add(toastId);
+
+    const signal = {
+      kind: classifyToast(el),
+      atMs: performance.now(),
+      libraryHint: detectLibrary(el),
+      message: normalizeText(el.textContent),
+      selectorHint: el.id ? '#' + el.id : (el.className ? '.' + el.className.split(' ')[0] : el.tagName.toLowerCase()),
+    };
+
+    signals.push(signal);
+
+    // Dispatch custom event for external listeners
+    window.dispatchEvent(new CustomEvent('vibecheck:toast', { detail: signal }));
+  }
+
+  // Mutation observer to catch toasts
+  const observer = new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      // Check added nodes
+      for (const node of mutation.addedNodes) {
+        if (node.nodeType !== 1) continue;
+        
+        // Check if this node is a toast
+        if (isToastCandidate(node)) {
+          processToast(node);
+        }
+
+        // Check descendants
+        if (node.querySelectorAll) {
+          const candidates = node.querySelectorAll('[role="alert"], [role="status"], [aria-live]');
+          candidates.forEach(el => {
+            if (isToastCandidate(el)) processToast(el);
+          });
+        }
+      }
+
+      // Check attribute changes (e.g., data-state="open")
+      if (mutation.type === 'attributes' && mutation.attributeName === 'data-state') {
+        const el = mutation.target;
+        if (el.getAttribute('data-state') === 'open' && isToastCandidate(el)) {
+          processToast(el);
+        }
+      }
+    }
+  });
+
+  observer.observe(document.body, {
+    childList: true,
+    subtree: true,
+    attributes: true,
+    attributeFilter: ['data-state', 'class', 'aria-live'],
+  });
+
+  // Also scan existing toasts
+  const existingToasts = document.querySelectorAll('[role="alert"], [role="status"], [aria-live]');
+  existingToasts.forEach(el => {
+    if (isToastCandidate(el)) processToast(el);
+  });
+
+  // Return API
+  return {
+    getSignals: () => [...signals],
+    clearSignals: () => { signals.length = 0; seenToasts.clear(); },
+    stop: () => observer.disconnect(),
+  };
+})
+`;
+
+// =============================================================================
+// SERVER-SIDE HELPERS
+// =============================================================================
+
+/**
+ * Classify toast kind from signal data
+ */
+function classifyToastSignal(signal) {
+  if (!signal) return "toast_unknown";
+
+  const text = (signal.message || "").toLowerCase();
+  const classes = (signal.classes || "").toLowerCase();
+
+  // Success patterns
+  if (SUCCESS_TOKENS.some(t => text.includes(t) || classes.includes(t))) {
+    return "toast_success";
+  }
+
+  // Error patterns
+  if (ERROR_TOKENS.some(t => text.includes(t) || classes.includes(t))) {
+    return "toast_error";
+  }
+
+  // Info patterns
+  if (INFO_TOKENS.some(t => text.includes(t) || classes.includes(t))) {
+    return "toast_info";
+  }
+
+  return "toast_unknown";
+}
+
+/**
+ * Create toast signal payload
+ */
+function createToastSignal(options = {}) {
+  const {
+    kind = "toast_unknown",
+    atMs = Date.now(),
+    libraryHint = "unknown",
+    message = "",
+    selectorHint = "",
+    screenshot = null,
+  } = options;
+
+  return {
+    kind,
+    atMs,
+    libraryHint,
+    message: message.slice(0, 200),
+    selectorHint,
+    screenshot,
+  };
+}
+
+/**
+ * Check if a toast is a false positive (persistent banner, etc.)
+ */
+function isToastFalsePositive(signal, options = {}) {
+  const { maxLifetimeMs = 15000 } = options;
+
+  // If it's been visible too long, likely a persistent banner
+  if (signal.visibleDuration && signal.visibleDuration > maxLifetimeMs) {
+    return true;
+  }
+
+  // Common false positive patterns
+  const falsePositivePatterns = [
+    /cookie.*consent/i,
+    /accept.*cookies/i,
+    /privacy.*policy/i,
+    /subscribe.*newsletter/i,
+    /sign.*up/i,
+  ];
+
+  const text = signal.message || "";
+  if (falsePositivePatterns.some(p => p.test(text))) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get library-specific selectors for a known library
+ */
+function getLibrarySelectors(libraryName) {
+  return TOAST_LIBRARIES[libraryName] || null;
+}
+
+/**
+ * Build combined selector for all toast libraries
+ */
+function buildToastSelector() {
+  const selectors = [];
+
+  // Add library-specific selectors
+  for (const lib of Object.values(TOAST_LIBRARIES)) {
+    if (lib.toast) selectors.push(lib.toast);
+  }
+
+  // Add universal selectors
+  selectors.push(UNIVERSAL_SELECTORS.roleAlert);
+  selectors.push(UNIVERSAL_SELECTORS.roleStatus);
+  selectors.push(UNIVERSAL_SELECTORS.ariaLive);
+
+  return selectors.join(", ");
+}
+
+module.exports = {
+  TOAST_DETECTOR_SCRIPT,
+  TOAST_LIBRARIES,
+  UNIVERSAL_SELECTORS,
+  TOAST_CLASS_TOKENS,
+  SUCCESS_TOKENS,
+  ERROR_TOKENS,
+  INFO_TOKENS,
+  classifyToastSignal,
+  createToastSignal,
+  isToastFalsePositive,
+  getLibrarySelectors,
+  buildToastSelector,
+};

package/bin/runners/lib/report-html.js

@@ -1,3 +1,8 @@
+/**
+ * @deprecated Use html-report.js instead. This module is kept for backward compatibility.
+ * Import from report.js for the unified API.
+ */
+
 /**
  * World-Class HTML Report Templates
  * 

package/bin/runners/lib/report-templates.js

@@ -1,3 +1,8 @@
+/**
+ * @deprecated Use html-report.js instead. This module is kept for backward compatibility.
+ * Import from report.js for the unified API.
+ */
+
 /**
  * Enhanced Report Templates
  * 

package/bin/runners/lib/report.js

@@ -0,0 +1,135 @@
+/**
+ * Unified Report Module
+ * 
+ * This is the SINGLE entry point for all report generation.
+ * Internal modules:
+ * - report-engine.js  → data assembly + export formats
+ * - html-report.js    → HTML generation (primary)
+ * - report-html.js    → Alternative HTML styles (deprecated)
+ * - report-templates.js → Template components (internal)
+ */
+
+const path = require("path");
+const fs = require("fs");
+
+// Primary modules
+const { generateHTMLReport, writeHTMLReport } = require("./html-report");
+const { buildReportData, exportToSARIF, exportToCSV, exportToMarkdown, exportToJSON } = require("./report-engine");
+
+/**
+ * Generate a report from ship results
+ * @param {Object} options
+ * @param {string} options.repoRoot - Repository root path
+ * @param {Object} options.shipReport - Ship report data (optional, loads from disk if not provided)
+ * @param {string} options.format - Output format: html (default), json, sarif, csv, markdown
+ * @param {string} options.outputPath - Custom output path (optional)
+ * @returns {Object} { path, format, data }
+ */
+async function generateReport(options = {}) {
+  const {
+    repoRoot = process.cwd(),
+    shipReport = null,
+    format = "html",
+    outputPath = null,
+  } = options;
+
+  // Load ship report if not provided
+  let report = shipReport;
+  if (!report) {
+    const shipPath = path.join(repoRoot, ".vibecheck", "ship", "last_ship.json");
+    if (fs.existsSync(shipPath)) {
+      report = JSON.parse(fs.readFileSync(shipPath, "utf-8"));
+    } else {
+      throw new Error("No ship report found. Run 'vibecheck ship' first.");
+    }
+  }
+
+  // Build report data
+  const reportData = buildReportData(report);
+
+  // Generate output based on format
+  let outputFile;
+  let outputData;
+
+  switch (format.toLowerCase()) {
+    case "html":
+      outputData = generateHTMLReport(reportData);
+      outputFile = outputPath || path.join(repoRoot, ".vibecheck", "reports", "report.html");
+      break;
+    case "json":
+      outputData = exportToJSON(reportData);
+      outputFile = outputPath || path.join(repoRoot, ".vibecheck", "reports", "report.json");
+      break;
+    case "sarif":
+      outputData = exportToSARIF(reportData);
+      outputFile = outputPath || path.join(repoRoot, ".vibecheck", "reports", "report.sarif");
+      break;
+    case "csv":
+      outputData = exportToCSV(reportData);
+      outputFile = outputPath || path.join(repoRoot, ".vibecheck", "reports", "report.csv");
+      break;
+    case "markdown":
+    case "md":
+      outputData = exportToMarkdown(reportData);
+      outputFile = outputPath || path.join(repoRoot, ".vibecheck", "reports", "report.md");
+      break;
+    default:
+      throw new Error(`Unknown format: ${format}. Use: html, json, sarif, csv, markdown`);
+  }
+
+  // Ensure output directory exists
+  const outputDir = path.dirname(outputFile);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Write output
+  fs.writeFileSync(outputFile, outputData, "utf-8");
+
+  return {
+    path: outputFile,
+    format,
+    data: reportData,
+  };
+}
+
+/**
+ * Open the latest report in browser
+ */
+async function openReport(repoRoot = process.cwd()) {
+  const reportPath = path.join(repoRoot, ".vibecheck", "ship", "last_ship.html");
+  const altPath = path.join(repoRoot, ".vibecheck", "reports", "report.html");
+  
+  const filePath = fs.existsSync(reportPath) ? reportPath : 
+                   fs.existsSync(altPath) ? altPath : null;
+
+  if (!filePath) {
+    throw new Error("No report found. Run 'vibecheck ship' or 'vibecheck report' first.");
+  }
+
+  // Cross-platform open
+  const { exec } = require("child_process");
+  const cmd = process.platform === "win32" ? `start "" "${filePath}"` :
+              process.platform === "darwin" ? `open "${filePath}"` :
+              `xdg-open "${filePath}"`;
+
+  return new Promise((resolve, reject) => {
+    exec(cmd, (err) => {
+      if (err) reject(err);
+      else resolve(filePath);
+    });
+  });
+}
+
+module.exports = {
+  generateReport,
+  openReport,
+  // Re-export for backward compatibility
+  generateHTMLReport,
+  writeHTMLReport,
+  buildReportData,
+  exportToSARIF,
+  exportToCSV,
+  exportToMarkdown,
+  exportToJSON,
+};

package/bin/runners/lib/route-truth.js

@@ -8,9 +8,9 @@
  * Then implements validate_claim(route_exists) on top of it.
  */
 
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
 
 // ============================================================================
 // CANONICALIZATION
@@ -19,7 +19,7 @@ import crypto from 'crypto';
 /**
  * Canonicalize a path to standard format.
  */
-export function canonicalizePath(p) {
+function canonicalizePath(p) {
   let s = p.trim();
   if (!s.startsWith('/')) s = '/' + s;
   s = s.replace(/\/+/g, '/');
@@ -33,7 +33,7 @@ export function canonicalizePath(p) {
   return s;
 }
 
-export function canonicalizeMethod(m) {
+function canonicalizeMethod(m) {
   const u = m.toUpperCase();
   if (u === 'ALL' || u === 'ANY') return '*';
   return u;
@@ -141,7 +141,7 @@ function extractAppRouterMethods(code) {
   return methods;
 }
 
-export async function resolveNextRoutes(repoRoot) {
+async function resolveNextRoutes(repoRoot) {
   const routes = [];
   
   // App Router: app/api/**/route.ts|js
@@ -227,7 +227,7 @@ export async function resolveNextRoutes(repoRoot) {
 // FASTIFY RESOLVER (Simplified - regex based)
 // ============================================================================
 
-export async function resolveFastifyRoutes(repoRoot) {
+async function resolveFastifyRoutes(repoRoot) {
   const routes = [];
   const gaps = [];
   
@@ -321,7 +321,7 @@ export async function resolveFastifyRoutes(repoRoot) {
 // ROUTE INDEX
 // ============================================================================
 
-export class RouteIndex {
+class RouteIndex {
   constructor() {
     this.routes = [];
     this.byMethod = new Map();
@@ -424,7 +424,7 @@ export class RouteIndex {
 // VALIDATE CLAIM
 // ============================================================================
 
-export async function validateRouteExists(claim, repoRoot, routeIndex) {
+async function validateRouteExists(claim, repoRoot, routeIndex) {
   const index = routeIndex || new RouteIndex();
   if (!routeIndex) await index.build(repoRoot);
   
@@ -467,7 +467,7 @@ export async function validateRouteExists(claim, repoRoot, routeIndex) {
   };
 }
 
-export default {
+module.exports = {
   canonicalizePath,
   canonicalizeMethod,
   resolveNextRoutes,