vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/polish/resilience.js

@@ -0,0 +1,92 @@
+/**
+ * Resilience Polish Engine
+ *
+ * Checks: Circuit breakers, retry logic, timeouts, graceful shutdown, bulkhead.
+ */
+
+const path = require("path");
+const { pathExists, findFile, readFileSafe } = require("./utils");
+
+module.exports = async function resilienceEngine(projectPath) {
+  const issues = [];
+  const packageJson = await readFileSafe(path.join(projectPath, "package.json"));
+  const srcPath = path.join(projectPath, "src");
+  const hasSrc = await pathExists(srcPath);
+  const searchPath = hasSrc ? srcPath : projectPath;
+
+  // Circuit breaker
+  if (!(packageJson && /opossum|cockatiel|resilience4j|circuit.*breaker/i.test(packageJson))) {
+    issues.push({
+      id: "missing-circuit-breaker",
+      category: "Resilience",
+      severity: "medium",
+      title: "Missing Circuit Breaker",
+      description: "No circuit breaker library found. External service failures can cascade.",
+      suggestion: "Add opossum or cockatiel for circuit breaker patterns on external calls.",
+      autoFixable: false,
+      aiPrompt: "Implement circuit breaker pattern using opossum for external API calls. Configure thresholds, fallback responses, and health checks.",
+    });
+  }
+
+  // Retry logic
+  const hasRetryLib = packageJson && /axios-retry|got|ky|p-retry|async-retry/i.test(packageJson);
+  const hasRetryInCode = await findFile(searchPath, /retry|exponential.*backoff|maxRetries/i);
+  if (!hasRetryLib && !hasRetryInCode) {
+    issues.push({
+      id: "missing-retry-logic",
+      category: "Resilience",
+      severity: "high",
+      title: "Missing Retry Logic",
+      description: "No retry mechanism found. Transient failures will cause immediate errors.",
+      suggestion: "Add retry logic with exponential backoff for external API calls.",
+      autoFixable: false,
+      aiPrompt: "Add retry logic with exponential backoff using axios-retry or p-retry. Configure max retries, backoff multiplier, and jitter.",
+    });
+  }
+
+  // Timeouts
+  const hasTimeoutConfig = await findFile(searchPath, /timeout|AbortController|AbortSignal/i);
+  if (!hasTimeoutConfig && hasSrc) {
+    issues.push({
+      id: "missing-timeouts",
+      category: "Resilience",
+      severity: "high",
+      title: "Missing Request Timeouts",
+      description: "No timeout configuration found. Slow external services can hang your app.",
+      suggestion: "Add timeouts to all external HTTP calls and database queries.",
+      autoFixable: false,
+      aiPrompt: "Add timeout handling to all external API calls and database queries. Use AbortController for fetch, configure connection/query timeouts for DB.",
+    });
+  }
+
+  // Graceful shutdown
+  const hasGracefulShutdown = await findFile(searchPath, /graceful.*shutdown|SIGTERM|SIGINT|beforeExit/i);
+  if (!hasGracefulShutdown) {
+    issues.push({
+      id: "missing-graceful-shutdown",
+      category: "Resilience",
+      severity: "high",
+      title: "Missing Graceful Shutdown",
+      description: "No graceful shutdown handling found. In-flight requests may be dropped.",
+      suggestion: "Add SIGTERM/SIGINT handlers to drain connections before shutdown.",
+      autoFixable: true,
+      aiPrompt: "Implement graceful shutdown. Handle SIGTERM/SIGINT, stop accepting new connections, drain existing ones, close DB pools, exit cleanly.",
+    });
+  }
+
+  // Bulkhead / concurrency limiting
+  if (!(packageJson && /bottleneck|p-limit|p-queue|semaphore/i.test(packageJson))) {
+    issues.push({
+      id: "missing-bulkhead",
+      category: "Resilience",
+      severity: "low",
+      title: "Missing Bulkhead/Rate Limiting for Internal Operations",
+      description: "No internal concurrency limiting found. Resource exhaustion possible.",
+      suggestion: "Add bottleneck or p-limit to limit concurrent operations.",
+      autoFixable: false,
+      aiPrompt: "Add concurrency limiting using bottleneck or p-limit for resource-intensive operations (file uploads, heavy computations, external API calls).",
+    });
+  }
+
+  return issues;
+};

package/bin/runners/lib/polish/security.js

@@ -0,0 +1,78 @@
+/**
+ * Security Polish Engine
+ *
+ * Checks: .env management, gitignore, security headers, CORS.
+ */
+
+const path = require("path");
+const { pathExists, readFileSafe } = require("./utils");
+
+module.exports = async function securityEngine(projectPath) {
+  const issues = [];
+
+  // .env.example
+  const hasEnvExample =
+    (await pathExists(path.join(projectPath, ".env.example"))) ||
+    (await pathExists(path.join(projectPath, ".env.sample")));
+  if (!hasEnvExample) {
+    issues.push({
+      id: "missing-env-example",
+      category: "Security",
+      severity: "medium",
+      title: "Missing .env.example",
+      description: "No .env.example file found. Team members won't know what env vars are needed.",
+      suggestion: "Create .env.example with all required environment variables (without values).",
+      autoFixable: true,
+    });
+  }
+
+  // .env in .gitignore
+  const gitignore = await readFileSafe(path.join(projectPath, ".gitignore"));
+  if (gitignore && !gitignore.includes(".env")) {
+    issues.push({
+      id: "env-not-gitignored",
+      category: "Security",
+      severity: "critical",
+      title: ".env Not in .gitignore",
+      description: "Environment files may be committed to git, exposing secrets.",
+      suggestion: "Add .env* to .gitignore immediately.",
+      autoFixable: true,
+    });
+  }
+
+  // Security headers
+  const packageJson = await readFileSafe(path.join(projectPath, "package.json"));
+  const hasHelmet = packageJson && /helmet|next-secure-headers/i.test(packageJson);
+  if (!hasHelmet) {
+    issues.push({
+      id: "missing-security-headers",
+      category: "Security",
+      severity: "high",
+      title: "Missing Security Headers",
+      description: "No security headers library found (helmet, etc.).",
+      suggestion: "Add helmet or security headers middleware for CSP, HSTS, etc.",
+      autoFixable: false,
+    });
+  }
+
+  // CORS
+  const hasCors = packageJson && /cors|@fastify\/cors/i.test(packageJson);
+  const nextConfig =
+    (await readFileSafe(path.join(projectPath, "next.config.js"))) ||
+    (await readFileSafe(path.join(projectPath, "next.config.mjs")));
+  const hasNextCors = nextConfig && /headers|Access-Control/i.test(nextConfig);
+
+  if (!hasCors && !hasNextCors) {
+    issues.push({
+      id: "missing-cors",
+      category: "Security",
+      severity: "medium",
+      title: "No CORS Configuration",
+      description: "No CORS configuration found. May have issues with cross-origin requests.",
+      suggestion: "Add CORS configuration to control which origins can access your API.",
+      autoFixable: false,
+    });
+  }
+
+  return issues;
+};

package/bin/runners/lib/polish/seo.js

@@ -0,0 +1,71 @@
+/**
+ * SEO Polish Engine
+ *
+ * Checks: robots.txt, sitemap, meta tags, Open Graph.
+ */
+
+const path = require("path");
+const { pathExists, findFile } = require("./utils");
+
+module.exports = async function seoEngine(projectPath) {
+  const issues = [];
+
+  const hasRobots = await pathExists(path.join(projectPath, "public", "robots.txt"));
+  if (!hasRobots) {
+    issues.push({
+      id: "missing-robots",
+      category: "SEO",
+      severity: "medium",
+      title: "Missing robots.txt",
+      description: "No robots.txt file found. Search engines may not crawl correctly.",
+      suggestion: "Add robots.txt to public folder to guide search engine crawlers.",
+      autoFixable: true,
+    });
+  }
+
+  const hasSitemap =
+    (await pathExists(path.join(projectPath, "public", "sitemap.xml"))) ||
+    (await findFile(projectPath, /sitemap/i));
+  if (!hasSitemap) {
+    issues.push({
+      id: "missing-sitemap",
+      category: "SEO",
+      severity: "medium",
+      title: "Missing Sitemap",
+      description: "No sitemap found. Search engines may miss some pages.",
+      suggestion: "Generate sitemap.xml for better search engine indexing.",
+      autoFixable: false,
+    });
+  }
+
+  const hasMetaTags = await findFile(projectPath, /MetaTags|Seo|Head|metadata/i);
+  if (!hasMetaTags) {
+    issues.push({
+      id: "missing-meta-setup",
+      category: "SEO",
+      severity: "high",
+      title: "Missing Meta Tag Setup",
+      description: "No meta tag component found. Pages may lack proper SEO metadata.",
+      suggestion: "Add a SEO/MetaTags component for consistent meta descriptions.",
+      autoFixable: true,
+    });
+  }
+
+  const hasOgImage =
+    (await pathExists(path.join(projectPath, "public", "og-image.png"))) ||
+    (await pathExists(path.join(projectPath, "public", "og.png"))) ||
+    (await findFile(path.join(projectPath, "public"), /og[-_]?image/i));
+  if (!hasOgImage) {
+    issues.push({
+      id: "missing-og-image",
+      category: "SEO",
+      severity: "low",
+      title: "Missing Open Graph Image",
+      description: "No OG image found. Social media shares will look plain.",
+      suggestion: "Add og-image.png to public folder for social media previews.",
+      autoFixable: false,
+    });
+  }
+
+  return issues;
+};

package/bin/runners/lib/polish/styles.js

@@ -0,0 +1,62 @@
+/**
+ * Terminal styling constants for polish command output.
+ */
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  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 icons = {
+  critical: '🔴',
+  high: '🟠',
+  medium: '🟡',
+  low: '🔵',
+  check: '✓',
+  cross: '✗',
+  arrow: '→',
+  star: '★',
+  sparkle: '✨',
+  wrench: '🔧',
+  rocket: '🚀',
+  shield: '🛡️',
+  lightning: '⚡',
+  eye: '👁️',
+  search: '🔍',
+  book: '📖',
+  gear: '⚙️',
+  server: '🖥️',
+  lock: '🔒',
+};
+
+const categoryIcons = {
+  Frontend: icons.sparkle,
+  Backend: icons.server,
+  Security: icons.lock,
+  Performance: icons.lightning,
+  Accessibility: icons.eye,
+  SEO: icons.search,
+  Configuration: icons.gear,
+  Documentation: icons.book,
+  Infrastructure: icons.rocket,
+  Observability: '📊',
+  Resilience: '🛡️',
+  Internationalization: '🌍',
+  Privacy: '🔐',
+};
+
+module.exports = { c, icons, categoryIcons };

package/bin/runners/lib/polish/utils.js

@@ -0,0 +1,104 @@
+/**
+ * Shared filesystem utilities for polish engines.
+ *
+ * Every engine needs these. Centralizing here avoids duplication
+ * and keeps engine files focused on detection logic.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+async function pathExists(filePath) {
+  try {
+    await fs.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function findFile(dir, pattern, maxDepth = 5, currentDepth = 0) {
+  if (currentDepth >= maxDepth) return null;
+
+  try {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (
+        entry.name.startsWith(".") ||
+        entry.name === "node_modules" ||
+        entry.name === "dist" ||
+        entry.name === "build"
+      ) {
+        continue;
+      }
+
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        const found = await findFile(fullPath, pattern, maxDepth, currentDepth + 1);
+        if (found) return found;
+      } else if (pattern.test(entry.name)) {
+        return fullPath;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function findAllFiles(dir, pattern, maxDepth = 5, currentDepth = 0) {
+  if (currentDepth >= maxDepth) return [];
+  const results = [];
+
+  try {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (
+        entry.name.startsWith(".") ||
+        entry.name === "node_modules" ||
+        entry.name === "dist" ||
+        entry.name === "build"
+      ) {
+        continue;
+      }
+
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        const found = await findAllFiles(fullPath, pattern, maxDepth, currentDepth + 1);
+        results.push(...found);
+      } else if (pattern.test(entry.name)) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+    // Ignore permission / read errors
+  }
+
+  return results;
+}
+
+async function readFileSafe(filePath) {
+  try {
+    return await fs.promises.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+async function fileContains(filePath, pattern) {
+  const content = await readFileSafe(filePath);
+  if (!content) return false;
+  return pattern.test(content);
+}
+
+module.exports = {
+  pathExists,
+  findFile,
+  findAllFiles,
+  readFileSafe,
+  fileContains,
+};

package/bin/runners/lib/preflight.js

@@ -0,0 +1,142 @@
+/**
+ * Preflight checks - Run before any vibecheck command
+ *
+ * Validates:
+ * - Node version
+ * - Required dependencies
+ * - Project structure
+ * - Configuration
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const MIN_NODE_VERSION = 18;
+
+function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split(".")[0], 10);
+  if (major < MIN_NODE_VERSION) {
+    return {
+      ok: false,
+      message: `Node.js ${MIN_NODE_VERSION}+ required (you have ${version})`
+    };
+  }
+  return { ok: true };
+}
+
+function checkPlaywright() {
+  try {
+    require.resolve("playwright");
+    return { ok: true };
+  } catch {
+    return {
+      ok: false,
+      optional: true,
+      message: "Playwright not installed. Reality mode requires: npm i -D playwright"
+    };
+  }
+}
+
+function checkFastGlob() {
+  try {
+    require.resolve("fast-glob");
+    return { ok: true };
+  } catch {
+    return {
+      ok: false,
+      message: "fast-glob not installed. Run: npm install"
+    };
+  }
+}
+
+function checkProjectRoot(root) {
+  const pkgPath = path.join(root, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    return {
+      ok: false,
+      message: "No package.json found. Are you in a project directory?"
+    };
+  }
+  return { ok: true };
+}
+
+function checkGit(root) {
+  const gitPath = path.join(root, ".git");
+  if (!fs.existsSync(gitPath)) {
+    return {
+      ok: false,
+      optional: true,
+      message: "Not a git repository. Some features may not work."
+    };
+  }
+  return { ok: true };
+}
+
+function checkWritable(root) {
+  const vibecheckDir = path.join(root, ".vibecheck");
+  try {
+    fs.mkdirSync(vibecheckDir, { recursive: true });
+    const testFile = path.join(vibecheckDir, ".write_test");
+    fs.writeFileSync(testFile, "test");
+    fs.unlinkSync(testFile);
+    return { ok: true };
+  } catch {
+    return {
+      ok: false,
+      message: "Cannot write to .vibecheck directory. Check permissions."
+    };
+  }
+}
+
+function runPreflight(root, { silent = false, strict = false } = {}) {
+  const checks = [
+    { name: "Node.js", check: checkNodeVersion },
+    { name: "Project", check: () => checkProjectRoot(root) },
+    { name: "Writable", check: () => checkWritable(root) },
+    { name: "Git", check: () => checkGit(root) },
+    { name: "fast-glob", check: checkFastGlob },
+    { name: "Playwright", check: checkPlaywright },
+  ];
+
+  const results = [];
+  let hasError = false;
+
+  for (const { name, check } of checks) {
+    const result = check();
+    results.push({ name, ...result });
+    
+    if (!result.ok && !result.optional) {
+      hasError = true;
+    }
+  }
+
+  if (!silent && hasError) {
+    console.error("\n⚠️ Preflight checks failed:\n");
+    for (const r of results) {
+      if (!r.ok && !r.optional) {
+        console.error(`  ✗ ${r.name}: ${r.message}`);
+      }
+    }
+    console.error("");
+  }
+
+  if (!silent && !hasError) {
+    // Show optional warnings
+    const optionalWarnings = results.filter(r => !r.ok && r.optional);
+    if (optionalWarnings.length && process.env.VIBECHECK_VERBOSE) {
+      for (const r of optionalWarnings) {
+        console.warn(`  ⚠ ${r.name}: ${r.message}`);
+      }
+    }
+  }
+
+  return {
+    ok: !hasError,
+    results
+  };
+}
+
+module.exports = { runPreflight, checkNodeVersion, checkPlaywright };

package/bin/runners/lib/prerequisites.js

@@ -0,0 +1,149 @@
+/**
+ * Prerequisite Auto-Running
+ * 
+ * Automatically runs prerequisites (like scan) if they're missing
+ * to improve UX - users don't need to know the correct command order.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Check if scan results exist
+ */
+function hasScanResults(projectPath) {
+  const latestPath = path.join(projectPath, ".vibecheck", "results", "latest.json");
+  return fs.existsSync(latestPath);
+}
+
+/**
+ * Check if ship results exist
+ */
+function hasShipResults(projectPath) {
+  const shipPath = path.join(projectPath, ".vibecheck", "last_ship.json");
+  return fs.existsSync(shipPath);
+}
+
+/**
+ * Check if truthpack exists
+ */
+function hasTruthpack(projectPath) {
+  const truthpackPath = path.join(projectPath, ".vibecheck", "truthpack.json");
+  return fs.existsSync(truthpackPath);
+}
+
+/**
+ * Auto-run scan if results are missing
+ */
+async function ensureScanResults(projectPath, opts = {}) {
+  if (hasScanResults(projectPath)) {
+    return { ran: false, reason: "Scan results already exist" };
+  }
+
+  // Don't auto-run in CI or if explicitly disabled
+  if (opts.ci || opts.noAutoRun || process.env.CI) {
+    return { ran: false, reason: "Auto-run disabled (CI mode or --no-auto-run)" };
+  }
+
+  try {
+    const { runScan } = require("../runScan");
+    
+    if (!opts.quiet && !opts.json) {
+      console.log(`\n  ${opts.colors?.info || ''}${opts.icons?.info || 'ℹ'}${opts.ansi?.reset || ''} No scan results found. Running scan first...\n`);
+    }
+
+    const scanArgs = ["--path", projectPath, "--offline", "--quiet"];
+    if (opts.json) scanArgs.push("--json");
+    
+    const exitCode = await runScan(scanArgs);
+    
+    if (hasScanResults(projectPath)) {
+      return { ran: true, exitCode, success: true };
+    } else {
+      return { ran: true, exitCode, success: false, reason: "Scan completed but no results file created" };
+    }
+  } catch (error) {
+    return { ran: true, success: false, error: error.message };
+  }
+}
+
+/**
+ * Auto-run ship if results are missing (for commands that need ship results)
+ */
+async function ensureShipResults(projectPath, opts = {}) {
+  if (hasShipResults(projectPath)) {
+    return { ran: false, reason: "Ship results already exist" };
+  }
+
+  // Don't auto-run in CI or if explicitly disabled
+  if (opts.ci || opts.noAutoRun || process.env.CI) {
+    return { ran: false, reason: "Auto-run disabled (CI mode or --no-auto-run)" };
+  }
+
+  try {
+    const { runShip } = require("../runShip");
+    
+    if (!opts.quiet && !opts.json) {
+      console.log(`\n  ${opts.colors?.info || ''}${opts.icons?.info || 'ℹ'}${opts.ansi?.reset || ''} No ship results found. Running ship first...\n`);
+    }
+
+    const shipArgs = ["--path", projectPath, "--no-banner", "--offline"];
+    if (opts.quiet) shipArgs.push("--quiet");
+    if (opts.json) shipArgs.push("--json");
+    
+    const exitCode = await runShip(shipArgs);
+    
+    if (hasShipResults(projectPath)) {
+      return { ran: true, exitCode, success: true };
+    } else {
+      return { ran: true, exitCode, success: false, reason: "Ship completed but no results file created" };
+    }
+  } catch (error) {
+    return { ran: true, success: false, error: error.message };
+  }
+}
+
+/**
+ * Auto-run context if truthpack is missing
+ */
+async function ensureTruthpack(projectPath, opts = {}) {
+  if (hasTruthpack(projectPath)) {
+    return { ran: false, reason: "Truthpack already exists" };
+  }
+
+  // Don't auto-run in CI or if explicitly disabled
+  if (opts.ci || opts.noAutoRun || process.env.CI) {
+    return { ran: false, reason: "Auto-run disabled (CI mode or --no-auto-run)" };
+  }
+
+  try {
+    const { runContext } = require("../runContext");
+    
+    if (!opts.quiet && !opts.json) {
+      console.log(`\n  ${opts.colors?.info || ''}${opts.icons?.info || 'ℹ'}${opts.ansi?.reset || ''} No truthpack found. Generating context first...\n`);
+    }
+
+    const contextArgs = ["--path", projectPath];
+    if (opts.quiet) contextArgs.push("--quiet");
+    if (opts.json) contextArgs.push("--json");
+    
+    const exitCode = await runContext(contextArgs);
+    
+    if (hasTruthpack(projectPath)) {
+      return { ran: true, exitCode, success: true };
+    } else {
+      return { ran: true, exitCode, success: false, reason: "Context completed but no truthpack created" };
+    }
+  } catch (error) {
+    return { ran: true, success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  hasScanResults,
+  hasShipResults,
+  hasTruthpack,
+  ensureScanResults,
+  ensureShipResults,
+  ensureTruthpack,
+};