@vibecheckai/cli 3.0.4 → 3.0.7

package/bin/runners/runAIAgent.js

@@ -1,2 +1,229 @@
-async function runAIAgent(args) { console.log("AI Agent not yet implemented"); return 0; }
+/**
+ * vibecheck ai-test - AI Agent for autonomous app testing
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+};
+
+function parseArgs(args) {
+  const opts = {
+    help: false,
+    url: null,
+    maxSteps: 20,
+    headed: false,
+    verbose: false,
+    json: false,
+    scenario: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--help":
+      case "-h":
+        opts.help = true;
+        break;
+      case "--url":
+      case "-u":
+        opts.url = args[++i];
+        break;
+      case "--max-steps":
+        opts.maxSteps = parseInt(args[++i]);
+        break;
+      case "--headed":
+        opts.headed = true;
+        break;
+      case "--verbose":
+      case "-v":
+        opts.verbose = true;
+        break;
+      case "--json":
+        opts.json = true;
+        break;
+      case "--scenario":
+      case "-s":
+        opts.scenario = args[++i];
+        break;
+    }
+  }
+
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${c.bold}vibecheck ai-test${c.reset} - AI Agent for autonomous app testing
+
+${c.bold}USAGE${c.reset}
+  vibecheck ai-test --url <url> [options]
+
+${c.bold}OPTIONS${c.reset}
+  --help, -h          Show this help
+  --url, -u <url>     Target URL (required)
+  --max-steps <n>     Maximum exploration steps (default: 20)
+  --headed            Run browser in headed mode
+  --verbose, -v       Show detailed output
+  --json              Output results as JSON
+  --scenario, -s <s>  Test scenario (login, checkout, signup)
+
+${c.bold}SCENARIOS${c.reset}
+  login     Test login flow
+  checkout  Test checkout/payment flow
+  signup    Test user registration
+  explore   General exploration (default)
+
+${c.bold}EXAMPLES${c.reset}
+  vibecheck ai-test --url http://localhost:3000
+  vibecheck ai-test --url http://localhost:3000 --scenario login
+  vibecheck ai-test --url http://localhost:3000 --headed --verbose
+`);
+}
+
+async function runAIAgent(args) {
+  const opts = parseArgs(args);
+
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+
+  if (!opts.url) {
+    console.log(`${c.red}✗${c.reset} --url is required\n`);
+    console.log(`${c.dim}Example: vibecheck ai-test --url http://localhost:3000${c.reset}\n`);
+    return 1;
+  }
+
+  console.log(`
+${c.bold}${c.magenta}🤖 AI AGENT TEST${c.reset}
+${c.dim}─────────────────────────────────────────${c.reset}
+  Target:    ${c.cyan}${opts.url}${c.reset}
+  Scenario:  ${opts.scenario || "explore"}
+  Max steps: ${opts.maxSteps}
+`);
+
+  // Check for Playwright
+  let playwright;
+  try {
+    playwright = require("playwright");
+  } catch (e) {
+    console.log(`${c.yellow}⚠${c.reset} Playwright not installed`);
+    console.log(`${c.dim}  Run: npm install -D playwright${c.reset}\n`);
+    return 1;
+  }
+
+  const findings = [];
+  const visited = new Set();
+  const actions = [];
+
+  try {
+    const browser = await playwright.chromium.launch({ headless: !opts.headed });
+    const context = await browser.newContext();
+    const page = await context.newPage();
+
+    // Track console errors
+    page.on("console", (msg) => {
+      if (msg.type() === "error") {
+        findings.push({
+          type: "console_error",
+          message: msg.text(),
+          url: page.url(),
+        });
+      }
+    });
+
+    // Track network errors
+    page.on("requestfailed", (request) => {
+      findings.push({
+        type: "network_error",
+        url: request.url(),
+        failure: request.failure()?.errorText,
+      });
+    });
+
+    console.log(`${c.cyan}▸${c.reset} Navigating to ${opts.url}...`);
+    await page.goto(opts.url, { waitUntil: "networkidle" });
+    visited.add(opts.url);
+    actions.push({ type: "navigate", url: opts.url });
+
+    // Simple exploration loop
+    for (let step = 0; step < opts.maxSteps; step++) {
+      if (opts.verbose) {
+        console.log(`${c.dim}  Step ${step + 1}/${opts.maxSteps}${c.reset}`);
+      }
+
+      // Find clickable elements
+      const buttons = await page.$$("button:visible, a:visible, [role='button']:visible");
+      
+      if (buttons.length === 0) break;
+
+      // Click a random button
+      const randomBtn = buttons[Math.floor(Math.random() * buttons.length)];
+      try {
+        const text = await randomBtn.textContent();
+        await randomBtn.click({ timeout: 3000 });
+        actions.push({ type: "click", text: text?.trim().slice(0, 50) });
+        
+        if (opts.verbose) {
+          console.log(`${c.green}✓${c.reset} Clicked: ${text?.trim().slice(0, 30)}`);
+        }
+        
+        await page.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => {});
+        
+        const currentUrl = page.url();
+        if (!visited.has(currentUrl)) {
+          visited.add(currentUrl);
+          if (opts.verbose) {
+            console.log(`${c.cyan}→${c.reset} New page: ${currentUrl}`);
+          }
+        }
+      } catch (e) {
+        // Element may have disappeared
+      }
+    }
+
+    await browser.close();
+
+    // Report
+    console.log(`
+${c.bold}─────────────────────────────────────────${c.reset}
+${c.bold}RESULTS${c.reset}
+  Pages visited: ${visited.size}
+  Actions taken: ${actions.length}
+  Issues found:  ${findings.length}
+`);
+
+    if (findings.length > 0) {
+      console.log(`${c.bold}Issues:${c.reset}`);
+      for (const f of findings.slice(0, 10)) {
+        console.log(`  ${c.red}✗${c.reset} [${f.type}] ${f.message || f.url}`);
+      }
+      if (findings.length > 10) {
+        console.log(`  ${c.dim}... and ${findings.length - 10} more${c.reset}`);
+      }
+      console.log();
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify({ visited: [...visited], actions, findings }, null, 2));
+    }
+
+    return findings.length > 0 ? 1 : 0;
+
+  } catch (error) {
+    console.error(`${c.red}✗${c.reset} AI Agent failed: ${error.message}`);
+    return 1;
+  }
+}
+
 module.exports = { runAIAgent };

package/bin/runners/runBadge.js

@@ -1,2 +1,182 @@
-async function runBadge(args) { console.log("Badge generator not yet implemented"); return 0; }
+/**
+ * vibecheck badge - Generate ship badges for your project
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+};
+
+function parseArgs(args) {
+  const opts = {
+    help: false,
+    output: null,
+    format: "markdown",
+    verdict: null,
+    score: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--help":
+      case "-h":
+        opts.help = true;
+        break;
+      case "--output":
+      case "-o":
+        opts.output = args[++i];
+        break;
+      case "--format":
+      case "-f":
+        opts.format = args[++i];
+        break;
+      case "--verdict":
+        opts.verdict = args[++i];
+        break;
+      case "--score":
+        opts.score = parseInt(args[++i]);
+        break;
+    }
+  }
+
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${c.bold}vibecheck badge${c.reset} - Generate ship badges for your project
+
+${c.bold}USAGE${c.reset}
+  vibecheck badge [options]
+
+${c.bold}OPTIONS${c.reset}
+  --help, -h          Show this help
+  --output, -o <file> Output file (default: stdout)
+  --format, -f <fmt>  Format: markdown, html, svg (default: markdown)
+  --verdict <v>       Override verdict: SHIP, WARN, BLOCK
+  --score <n>         Override score (0-100)
+
+${c.bold}EXAMPLES${c.reset}
+  vibecheck badge                    # Generate from last scan
+  vibecheck badge -o README.md       # Append to README
+  vibecheck badge --format svg       # SVG badge
+  vibecheck badge --verdict SHIP     # Force SHIP badge
+`);
+}
+
+function getVerdictColor(verdict) {
+  switch (verdict) {
+    case "SHIP": return "brightgreen";
+    case "WARN": return "yellow";
+    case "BLOCK": return "red";
+    default: return "lightgrey";
+  }
+}
+
+function generateMarkdownBadge(verdict, score) {
+  const color = getVerdictColor(verdict);
+  const label = "vibecheck";
+  const message = verdict === "SHIP" ? `${verdict}%20✓` : verdict;
+  return `[![vibecheck](https://img.shields.io/badge/${label}-${message}-${color})](https://vibecheckai.dev)`;
+}
+
+function generateHtmlBadge(verdict, score) {
+  const color = verdict === "SHIP" ? "#4CAF50" : verdict === "WARN" ? "#FFC107" : "#F44336";
+  return `<a href="https://vibecheckai.dev"><img src="https://img.shields.io/badge/vibecheck-${verdict}-${color.replace("#", "")}" alt="vibecheck ${verdict}"></a>`;
+}
+
+function generateSvgBadge(verdict, score) {
+  const color = verdict === "SHIP" ? "#4CAF50" : verdict === "WARN" ? "#FFC107" : "#F44336";
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="100" height="20">
+  <linearGradient id="b" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <mask id="a"><rect width="100" height="20" rx="3" fill="#fff"/></mask>
+  <g mask="url(#a)">
+    <rect width="60" height="20" fill="#555"/>
+    <rect x="60" width="40" height="20" fill="${color}"/>
+    <rect width="100" height="20" fill="url(#b)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
+    <text x="30" y="15" fill="#010101" fill-opacity=".3">vibecheck</text>
+    <text x="30" y="14">vibecheck</text>
+    <text x="80" y="15" fill="#010101" fill-opacity=".3">${verdict}</text>
+    <text x="80" y="14">${verdict}</text>
+  </g>
+</svg>`;
+}
+
+async function runBadge(args) {
+  const opts = parseArgs(args);
+
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+
+  // Try to load last scan result
+  let verdict = opts.verdict || "SHIP";
+  let score = opts.score || 100;
+
+  const lastScanPath = path.join(process.cwd(), ".vibecheck", "last_scan.json");
+  if (!opts.verdict && fs.existsSync(lastScanPath)) {
+    try {
+      const lastScan = JSON.parse(fs.readFileSync(lastScanPath, "utf8"));
+      verdict = lastScan.verdict || "SHIP";
+      score = lastScan.score || 100;
+    } catch (e) {
+      // Use defaults
+    }
+  }
+
+  // Generate badge
+  let badge;
+  switch (opts.format) {
+    case "html":
+      badge = generateHtmlBadge(verdict, score);
+      break;
+    case "svg":
+      badge = generateSvgBadge(verdict, score);
+      break;
+    default:
+      badge = generateMarkdownBadge(verdict, score);
+  }
+
+  // Output
+  if (opts.output) {
+    const outputPath = path.resolve(opts.output);
+    if (fs.existsSync(outputPath)) {
+      const content = fs.readFileSync(outputPath, "utf8");
+      // Replace existing badge or append
+      if (content.includes("vibecheck")) {
+        const updated = content.replace(/\[!\[vibecheck\].*?\]\(https:\/\/vibecheckai\.dev\)/g, badge);
+        fs.writeFileSync(outputPath, updated);
+        console.log(`${c.green}✓${c.reset} Updated badge in ${outputPath}`);
+      } else {
+        fs.writeFileSync(outputPath, content + "\n\n" + badge + "\n");
+        console.log(`${c.green}✓${c.reset} Added badge to ${outputPath}`);
+      }
+    } else {
+      fs.writeFileSync(outputPath, badge + "\n");
+      console.log(`${c.green}✓${c.reset} Created ${outputPath} with badge`);
+    }
+  } else {
+    console.log(`\n${c.bold}Generated Badge:${c.reset}\n`);
+    console.log(badge);
+    console.log(`\n${c.dim}Copy and paste into your README.md${c.reset}\n`);
+  }
+
+  return 0;
+}
+
 module.exports = { runBadge };

package/bin/runners/runCtx.js

@@ -131,9 +131,14 @@ async function runCtx(args) {
   const nextRoutes = (truthpack.routes?.server || []).filter(r => 
     r.handler?.includes("app/api") || r.handler?.includes("pages/api")
   ).length;
-  const fastifyRoutes = (truthpack.routes?.server || []).filter(r => 
+  const otherRoutes = (truthpack.routes?.server || []).filter(r => 
     !r.handler?.includes("app/api") && !r.handler?.includes("pages/api")
   ).length;
+  
+  // Detect framework from routes evidence or truthpack meta
+  const detectedFramework = truthpack.meta?.framework || 
+    (truthpack.routes?.server || []).find(r => r.evidence?.[0]?.reason)?.evidence?.[0]?.reason?.split(' ')[0] ||
+    'Express';
   const clientRefs = truthpack.routes?.clientRefs?.length || 0;
   const gaps = truthpack.routes?.gaps?.length || 0;
 
@@ -153,7 +158,7 @@ async function runCtx(args) {
   console.log('');
   console.log(`${c.cyan}┌─ Routes ──────────────────────────────────────────────────────────────┐${c.reset}`);
   console.log(`${c.cyan}│${c.reset}  ${c.bold}▲ Next.js:${c.reset}  ${nextRoutes} routes`);
-  console.log(`${c.cyan}│${c.reset}  ${c.bold}⚡ Fastify:${c.reset} ${fastifyRoutes} routes`);
+  console.log(`${c.cyan}│${c.reset}  ${c.bold}⚡ ${detectedFramework}:${c.reset} ${otherRoutes} routes`);
   console.log(`${c.cyan}│${c.reset}  ${c.dim}Client refs:${c.reset} ${clientRefs}  ${gaps > 0 ? `${c.yellow}⚠ ${gaps} gaps${c.reset}` : `${c.green}✓ no gaps${c.reset}`}`);
   console.log(`${c.cyan}└───────────────────────────────────────────────────────────────────────┘${c.reset}`);