@vibecheckai/cli 2.8.2 → 3.0.0

package/bin/runners/runWatch.js

@@ -0,0 +1,230 @@
+/**
+ * vibecheck watch - Continuous Dev Mode
+ *
+ * Watches for file changes and re-runs ship automatically.
+ * Shows a persistent status line with current verdict.
+ * Perfect for development workflow.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { shipCore } = require("./runShip");
+
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  blue: "\x1b[34m",
+  clear: "\x1b[2J\x1b[H",
+};
+
+const IGNORE_PATTERNS = [
+  /node_modules/,
+  /\.next/,
+  /\.vibecheck/,
+  /dist/,
+  /build/,
+  /\.git/,
+  /\.DS_Store/,
+  /\.log$/,
+  /\.map$/,
+];
+
+function shouldIgnore(filePath) {
+  return IGNORE_PATTERNS.some(p => p.test(filePath));
+}
+
+function debounce(fn, ms) {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => fn(...args), ms);
+  };
+}
+
+function formatTime() {
+  const d = new Date();
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+}
+
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function printStatus({ verdict, findings, duration, lastFile, runCount }) {
+  const verdictColor = verdict === "SHIP" ? c.green : verdict === "WARN" ? c.yellow : c.red;
+  const blocks = findings.filter(f => f.severity === "BLOCK").length;
+  const warns = findings.filter(f => f.severity === "WARN").length;
+
+  console.log(`
+${c.cyan}${c.bold}╔════════════════════════════════════════════════════════════╗
+║  👁️  vibecheck watch                                         ║
+╚════════════════════════════════════════════════════════════╝${c.reset}
+
+  ${c.dim}Time:${c.reset}     ${formatTime()}
+  ${c.dim}Runs:${c.reset}     ${runCount}
+  ${c.dim}Duration:${c.reset} ${formatDuration(duration)}
+  ${c.dim}Changed:${c.reset}  ${lastFile || "(initial)"}
+
+${c.bold}  VERDICT:  ${verdictColor}${verdict}${c.reset}
+  
+  ${c.dim}Findings:${c.reset} ${blocks} BLOCK, ${warns} WARN
+
+${verdict === "SHIP" ? `  ${c.green}✓ Ready to ship${c.reset}` : `  ${c.yellow}⚠ Run "vibecheck fix" to resolve${c.reset}`}
+
+${c.dim}  Watching for changes... (Ctrl+C to stop)${c.reset}
+`);
+}
+
+function printTopFindings(findings, max = 5) {
+  const top = findings
+    .filter(f => f.severity === "BLOCK" || f.severity === "WARN")
+    .slice(0, max);
+
+  if (!top.length) return;
+
+  console.log(`${c.dim}  Top findings:${c.reset}`);
+  for (const f of top) {
+    const icon = f.severity === "BLOCK" ? c.red + "●" : c.yellow + "●";
+    console.log(`    ${icon}${c.reset} ${f.title}`);
+  }
+  console.log("");
+}
+
+async function runShipQuiet(root, fastifyEntry) {
+  const start = Date.now();
+  try {
+    const result = await shipCore({ repoRoot: root, fastifyEntry, noWrite: false });
+    return {
+      verdict: result.verdict,
+      findings: result.report?.findings || [],
+      duration: Date.now() - start,
+      error: null
+    };
+  } catch (err) {
+    return {
+      verdict: "ERROR",
+      findings: [],
+      duration: Date.now() - start,
+      error: err.message
+    };
+  }
+}
+
+function watchDirectory(dir, callback) {
+  const watchers = new Map();
+
+  function addWatcher(p) {
+    if (watchers.has(p)) return;
+    try {
+      const watcher = fs.watch(p, { recursive: false }, (event, filename) => {
+        if (!filename || shouldIgnore(filename)) return;
+        callback(path.join(p, filename), event);
+      });
+      watchers.set(p, watcher);
+    } catch {}
+  }
+
+  function scanDir(p) {
+    try {
+      addWatcher(p);
+      const entries = fs.readdirSync(p, { withFileTypes: true });
+      for (const entry of entries) {
+        if (shouldIgnore(entry.name)) continue;
+        const full = path.join(p, entry.name);
+        if (entry.isDirectory()) {
+          scanDir(full);
+        }
+      }
+    } catch {}
+  }
+
+  scanDir(dir);
+
+  return {
+    close: () => {
+      for (const w of watchers.values()) {
+        try { w.close(); } catch {}
+      }
+      watchers.clear();
+    }
+  };
+}
+
+async function runWatch({
+  repoRoot,
+  fastifyEntry,
+  debounceMs = 500,
+  clearScreen = true
+} = {}) {
+  const root = repoRoot || process.cwd();
+  let runCount = 0;
+  let lastFile = null;
+
+  console.log(`${c.cyan}Starting vibecheck watch...${c.reset}\n`);
+
+  async function runAndDisplay() {
+    runCount++;
+    
+    if (clearScreen) {
+      process.stdout.write(c.clear);
+    }
+
+    const result = await runShipQuiet(root, fastifyEntry);
+
+    if (result.error) {
+      console.log(`${c.red}Error: ${result.error}${c.reset}`);
+      return;
+    }
+
+    printStatus({
+      verdict: result.verdict,
+      findings: result.findings,
+      duration: result.duration,
+      lastFile,
+      runCount
+    });
+
+    printTopFindings(result.findings);
+  }
+
+  // Initial run
+  await runAndDisplay();
+
+  // Watch for changes
+  const debouncedRun = debounce(async (filePath) => {
+    lastFile = path.relative(root, filePath);
+    await runAndDisplay();
+  }, debounceMs);
+
+  const watcher = watchDirectory(root, (filePath) => {
+    // Only watch source files
+    if (!/\.(ts|tsx|js|jsx|json|env|md|yml|yaml)$/.test(filePath)) return;
+    if (shouldIgnore(filePath)) return;
+    debouncedRun(filePath);
+  });
+
+  // Handle cleanup
+  process.on("SIGINT", () => {
+    console.log(`\n${c.dim}Watch stopped.${c.reset}`);
+    watcher.close();
+    process.exit(0);
+  });
+
+  process.on("SIGTERM", () => {
+    watcher.close();
+    process.exit(0);
+  });
+
+  // Keep process alive
+  await new Promise(() => {});
+}
+
+module.exports = { runWatch };

package/bin/runners/utils.js

@@ -0,0 +1,360 @@
+const fs = require("fs");
+const path = require("path");
+
+const VERSION = "2.0.0";
+
+// ANSI color codes for terminal output
+const colors = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+  bgRed: "\x1b[41m",
+  bgGreen: "\x1b[42m",
+  bgYellow: "\x1b[43m",
+  bgBlue: "\x1b[44m",
+};
+
+const c = colors;
+
+function ensureOutputDir(outputDir) {
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+}
+
+function detectProjectFeatures(projectPath) {
+  const features = {
+    isMonorepo: false,
+    frameworks: [],
+    orm: null,
+    ci: !!process.env.CI,
+  };
+
+  try {
+    // Monorepo
+    if (
+      fs.existsSync(path.join(projectPath, "turbo.json")) ||
+      fs.existsSync(path.join(projectPath, "pnpm-workspace.yaml")) ||
+      fs.existsSync(path.join(projectPath, "lerna.json"))
+    ) {
+      features.isMonorepo = true;
+    }
+
+    // Frameworks
+    const pkgPath = path.join(projectPath, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      // Full-stack frameworks
+      if (allDeps.next) features.frameworks.push("nextjs");
+      if (allDeps.nuxt || allDeps["@nuxt/core"]) features.frameworks.push("nuxt");
+      if (allDeps["@remix-run/node"] || allDeps["@remix-run/react"]) features.frameworks.push("remix");
+      
+      // Frontend frameworks
+      if (allDeps.react || allDeps["react-dom"]) features.frameworks.push("react");
+      if (allDeps.vue) features.frameworks.push("vue");
+      if (allDeps.svelte || allDeps["svelte-kit"]) features.frameworks.push("svelte");
+      if (allDeps["@angular/core"]) features.frameworks.push("angular");
+      
+      // Build tools
+      if (allDeps.vite || allDeps["@vitejs/plugin-react"] || allDeps["@vitejs/plugin-vue"]) {
+        features.frameworks.push("vite");
+      }
+      if (allDeps.webpack) features.frameworks.push("webpack");
+      if (allDeps.turbopack) features.frameworks.push("turbopack");
+      
+      // Backend frameworks
+      if (allDeps.fastify) features.frameworks.push("fastify");
+      if (allDeps.express) features.frameworks.push("express");
+      if (allDeps["@nestjs/core"]) features.frameworks.push("nestjs");
+      if (allDeps.koa) features.frameworks.push("koa");
+    }
+
+    // Config files
+    if (
+      fs.existsSync(path.join(projectPath, "next.config.js")) ||
+      fs.existsSync(path.join(projectPath, "next.config.mjs"))
+    ) {
+      if (!features.frameworks.includes("nextjs"))
+        features.frameworks.push("nextjs");
+    }
+    
+    // Vite config files
+    if (
+      fs.existsSync(path.join(projectPath, "vite.config.ts")) ||
+      fs.existsSync(path.join(projectPath, "vite.config.js")) ||
+      fs.existsSync(path.join(projectPath, "vite.config.mjs"))
+    ) {
+      if (!features.frameworks.includes("vite"))
+        features.frameworks.push("vite");
+    }
+
+    // ORM
+    if (
+      fs.existsSync(path.join(projectPath, "prisma")) ||
+      fs.existsSync(path.join(projectPath, "schema.prisma"))
+    ) {
+      features.orm = "prisma";
+    }
+    if (fs.existsSync(path.join(projectPath, "drizzle.config.ts"))) {
+      features.orm = "drizzle";
+    }
+  } catch (err) {
+    // ignore detection errors
+  }
+
+  return features;
+}
+
+function writeArtifacts(outputDir, results) {
+  ensureOutputDir(outputDir);
+
+  const timestamp = new Date().toISOString();
+
+  // Always write summary.json (machine-readable)
+  const summary = {
+    version: VERSION,
+    timestamp,
+    score: results.score || 0,
+    grade: results.grade || "F",
+    canShip: results.canShip || false,
+    checks: results.checks || {},
+    counts: results.counts || {},
+  };
+  fs.writeFileSync(
+    path.join(outputDir, "summary.json"),
+    JSON.stringify(summary, null, 2),
+  );
+
+  // Write summary.md (human-readable)
+  const md = generateMarkdownSummary(results);
+  fs.writeFileSync(path.join(outputDir, "summary.md"), md);
+
+  // Write report.html (shareable)
+  const html = generateHtmlReport(results);
+  fs.writeFileSync(path.join(outputDir, "report.html"), html);
+
+  // Write per-module artifacts
+  const artifactsDir = path.join(outputDir, "artifacts");
+  ensureOutputDir(artifactsDir);
+
+  if (results.integrity) {
+    fs.writeFileSync(
+      path.join(artifactsDir, "integrity.json"),
+      JSON.stringify(results.integrity, null, 2),
+    );
+  }
+  if (results.hygiene) {
+    fs.writeFileSync(
+      path.join(artifactsDir, "hygiene.json"),
+      JSON.stringify(results.hygiene, null, 2),
+    );
+  }
+  if (results.security) {
+    fs.writeFileSync(
+      path.join(artifactsDir, "security.json"),
+      JSON.stringify(results.security, null, 2),
+    );
+  }
+
+  return summary;
+}
+
+function generateMarkdownSummary(results) {
+  const lines = [];
+  lines.push("# 🛡️ vibecheck Scan Summary\n");
+  lines.push(`**Generated:** ${new Date().toISOString()}`);
+  lines.push(`**Score:** ${results.score}/100 (Grade: ${results.grade})`);
+  lines.push(`**Verdict:** ${results.canShip ? "✅ SHIP" : "🚫 NO-SHIP"}\n`);
+
+  if (results.deductions?.length > 0) {
+    lines.push("## Score Breakdown\n");
+    lines.push("| Category | Points | Reason |");
+    lines.push("|----------|--------|--------|");
+    for (const d of results.deductions) {
+      lines.push(`| ${d.category} | ${d.points} | ${d.reason} |`);
+    }
+    lines.push("");
+  }
+
+  if (results.blockers?.length > 0) {
+    lines.push("## 🚨 Blockers\n");
+    for (const b of results.blockers.slice(0, 10)) {
+      lines.push(`- **${b.type}**: ${b.detail} (\`${b.file}\`)`);
+    }
+    lines.push("");
+  }
+
+  lines.push("---\n_Generated by Vibecheck_");
+  return lines.join("\n");
+}
+
+function generateHtmlReport(results) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>vibecheck Report</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; max-width: 800px; margin: 0 auto; padding: 2rem; }
+    .score { font-size: 3rem; font-weight: bold; text-align: center; padding: 2rem; border-radius: 1rem; }
+    .ship { background: #d4edda; color: #155724; }
+    .no-ship { background: #f8d7da; color: #721c24; }
+    table { width: 100%; border-collapse: collapse; margin: 1rem 0; }
+    th, td { padding: 0.5rem; text-align: left; border-bottom: 1px solid #ddd; }
+    .blocker { background: #fff3cd; padding: 0.5rem; margin: 0.25rem 0; border-radius: 0.25rem; }
+  </style>
+</head>
+<body>
+  <h1>🛡️ vibecheck Report</h1>
+  <div class="score ${results.canShip ? "ship" : "no-ship"}">
+    ${results.score}/100 (${results.grade})<br>
+    <small>${results.canShip ? "✅ CLEAR TO SHIP" : "🚫 NOT READY"}</small>
+  </div>
+  <p><strong>Generated:</strong> ${new Date().toISOString()}</p>
+  ${
+    results.blockers?.length > 0
+      ? `
+  <h2>🚨 Blockers</h2>
+  ${results.blockers
+    .slice(0, 10)
+    .map(
+      (b) =>
+        `<div class="blocker"><strong>${b.type}</strong>: ${b.detail} (<code>${b.file}</code>)</div>`,
+    )
+    .join("")}
+  `
+      : ""
+  }
+  <hr>
+  <p><em>Generated by vibecheck v${VERSION}</em></p>
+</body>
+</html>`;
+}
+
+function printResults(results, format) {
+  if (format === "json" || (Array.isArray(format) && format.includes("json"))) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+
+  // Get score color
+  const getScoreColor = (score) => {
+    if (score >= 80) return c.green;
+    if (score >= 50) return c.yellow;
+    return c.red;
+  };
+
+  const scoreColor = getScoreColor(results.score);
+  const gradeEmoji =
+    results.score >= 80 ? "🟢" : results.score >= 50 ? "🟡" : "🔴";
+
+  // Text format - pretty print with colors
+  console.log("");
+  console.log(`  ${c.bold}${c.cyan}🛡️  vibecheck SCAN RESULTS${c.reset}`);
+  console.log("");
+
+  // Score box with color
+  const boxColor = results.canShip ? c.green : c.red;
+  console.log(
+    `  ${boxColor}╔════════════════════════════════════════════════╗${c.reset}`,
+  );
+  console.log(
+    `  ${boxColor}║${c.reset}                                                ${boxColor}║${c.reset}`,
+  );
+  console.log(
+    `  ${boxColor}║${c.reset}   ${gradeEmoji}  ${c.bold}INTEGRITY SCORE:${c.reset} ${scoreColor}${c.bold}${String(results.score).padStart(3)}${c.reset} / 100            ${boxColor}║${c.reset}`,
+  );
+  console.log(
+    `  ${boxColor}║${c.reset}      ${c.bold}GRADE:${c.reset} ${scoreColor}${c.bold}${results.grade}${c.reset}                                 ${boxColor}║${c.reset}`,
+  );
+  console.log(
+    `  ${boxColor}║${c.reset}                                                ${boxColor}║${c.reset}`,
+  );
+  if (results.canShip) {
+    console.log(
+      `  ${boxColor}║${c.reset}      ${c.bgGreen}${c.bold} ✅ CLEAR TO SHIP ${c.reset}                       ${boxColor}║${c.reset}`,
+    );
+  } else {
+    console.log(
+      `  ${boxColor}║${c.reset}      ${c.bgRed}${c.bold} 🚫 NOT READY TO SHIP ${c.reset}                   ${boxColor}║${c.reset}`,
+    );
+  }
+  console.log(
+    `  ${boxColor}║${c.reset}                                                ${boxColor}║${c.reset}`,
+  );
+  console.log(
+    `  ${boxColor}╚════════════════════════════════════════════════╝${c.reset}`,
+  );
+  console.log("");
+
+  // Category breakdown with visual bars
+  console.log(`  ${c.bold}📊 CATEGORY BREAKDOWN${c.reset}\n`);
+  const categories = [
+    { key: "api", icon: "🔗", name: "API Wiring" },
+    { key: "auth", icon: "🔐", name: "Auth Coverage" },
+    { key: "secrets", icon: "🔑", name: "Secrets" },
+    { key: "routes", icon: "🗺️ ", name: "Route Integrity" },
+    { key: "mock", icon: "🧪", name: "Mock Blocker" },
+    { key: "iac", icon: "☁️ ", name: "IaC Security" },
+    { key: "pii", icon: "🕵️ ", name: "PII Privacy" },
+    { key: "hallucinations", icon: "🤖", name: "AI Vibechecks" },
+  ];
+
+  for (const cat of categories) {
+    if (results.counts?.[cat.key] !== undefined) {
+      const count = results.counts?.[cat.key] || 0;
+      const isPass = count === 0;
+      const status = isPass ? `${c.green}✓${c.reset}` : `${c.red}✗${c.reset}`;
+      const countStr = isPass
+        ? `${c.green}${c.bold}0 issues${c.reset}`
+        : `${c.red}${c.bold}${count} issue${count !== 1 ? "s" : ""}${c.reset}`;
+      console.log(
+        `  ${status} ${cat.icon} ${c.dim}${cat.name.padEnd(16)}${c.reset} ${countStr}`,
+      );
+    }
+  }
+  console.log("");
+
+  // Blockers with severity colors
+  if (results.blockers?.length > 0) {
+    console.log(`  ${c.bold}${c.red}🚨 TOP BLOCKERS${c.reset}\n`);
+    for (const b of results.blockers.slice(0, 5)) {
+      const priorityColor = b.priority === "P0" ? c.red : c.yellow;
+      console.log(
+        `  ${priorityColor}${c.bold}${b.priority}${c.reset} ${b.icon} ${c.bold}${b.type.padEnd(10)}${c.reset} ${c.dim}${b.detail}${c.reset}`,
+      );
+      console.log(`       ${c.cyan}${b.file}${c.reset}`);
+    }
+    console.log("");
+  }
+
+  // Footer
+  console.log(
+    `  ${c.dim}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}`,
+  );
+  console.log(
+    `  ${c.dim}📄 Full report:${c.reset} ${c.cyan}${results.outputDir}/report.html${c.reset}`,
+  );
+  console.log(
+    `  ${c.dim}🔧 Fix issues:${c.reset}  ${c.cyan}vibecheck fix${c.reset}`,
+  );
+  console.log("");
+}
+
+module.exports = {
+  ensureOutputDir,
+  writeArtifacts,
+  generateMarkdownSummary,
+  generateHtmlReport,
+  printResults,
+  detectProjectFeatures,
+  VERSION,
+};