vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/runTruth.d.ts

@@ -0,0 +1,5 @@
+export interface TruthOptions {
+  projectRoot?: string;
+  verbose?: boolean;
+}
+export function runTruth(options?: TruthOptions): Promise<void>;

package/bin/runners/runTruth.js

@@ -0,0 +1,101 @@
+/**
+ * Truth Command Handler
+ * 
+ * Enhanced truth command to generate truthpack files.
+ * Generates: routes.json, env.json, auth.json, contracts.json, ui.graph.json
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { buildTruthpackV2 } = require("./lib/extractors/truthpack-v2");
+
+/**
+ * Run truth command
+ * @param {object} options - Command options
+ * @param {string} options.scope - Scope: 'routes', 'env', 'auth', 'contracts', 'all'
+ * @param {string} options.projectRoot - Project root directory
+ */
+async function runTruth(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const scope = options.scope || "all";
+  
+  const truthpackDir = path.join(projectRoot, ".vibecheck", "truthpack");
+  
+  // Ensure directory exists
+  if (!fs.existsSync(truthpackDir)) {
+    fs.mkdirSync(truthpackDir, { recursive: true });
+  }
+  
+  try {
+    // Build truthpack
+    const truthpack = await buildTruthpackV2({
+      repoRoot: projectRoot
+    });
+    
+    // Write truthpack files based on scope
+    if (scope === "all" || scope === "routes") {
+      const routesFile = path.join(truthpackDir, "routes.json");
+      // Extract routes from truthpack structure: truthpack.truthpack.routes.server
+      const serverRoutes = truthpack.truthpack?.routes?.server || [];
+      const gaps = truthpack.truthpack?.routes?.gaps || [];
+      const stack = truthpack.truthpack?.project || {};
+      
+      fs.writeFileSync(routesFile, JSON.stringify({
+        routes: serverRoutes.map(r => ({
+          path: r.path,
+          method: r.method,
+          handler: r.handler || r.source
+        })),
+        gaps: gaps,
+        stack: {
+          framework: stack.frameworks?.[0] || "unknown",
+          language: "typescript"
+        }
+      }, null, 2));
+    }
+    
+    if (scope === "all" || scope === "env") {
+      const envFile = path.join(truthpackDir, "env.json");
+      fs.writeFileSync(envFile, JSON.stringify(truthpack.env || {}, null, 2));
+    }
+    
+    if (scope === "all" || scope === "auth") {
+      const authFile = path.join(truthpackDir, "auth.json");
+      fs.writeFileSync(authFile, JSON.stringify(truthpack.auth || {}, null, 2));
+    }
+    
+    if (scope === "all" || scope === "contracts") {
+      const contractsFile = path.join(truthpackDir, "contracts.json");
+      fs.writeFileSync(contractsFile, JSON.stringify(truthpack.contracts || {}, null, 2));
+    }
+    
+    // UI graph (if Reality enabled)
+    if (scope === "all" && truthpack.uiGraph) {
+      const uiGraphFile = path.join(truthpackDir, "ui.graph.json");
+      fs.writeFileSync(uiGraphFile, JSON.stringify(truthpack.uiGraph, null, 2));
+    }
+    
+    return {
+      success: true,
+      message: `Truthpack generated successfully (scope: ${scope})`,
+      files: {
+        routes: scope === "all" || scope === "routes" ? "routes.json" : null,
+        env: scope === "all" || scope === "env" ? "env.json" : null,
+        auth: scope === "all" || scope === "auth" ? "auth.json" : null,
+        contracts: scope === "all" || scope === "contracts" ? "contracts.json" : null,
+        uiGraph: scope === "all" && truthpack.uiGraph ? "ui.graph.json" : null
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+module.exports = {
+  runTruth
+};

package/bin/runners/runValidate.js

@@ -0,0 +1,179 @@
+/**
+ * vibecheck validate - Validate AI-generated code for hallucinations
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { buildTruthpackSmart } = require("./lib/truth");
+const { routeMatches } = require("./lib/claims");
+const { EXIT } = require("./lib/exit-codes");
+const { formatSoftUpsell, formatWorkflowUpsell, PRICING_URL } = require("./lib/upsell");
+const { getApiKey } = require("./lib/auth");
+
+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,
+    file: null,
+    json: false,
+    verbose: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--help":
+      case "-h":
+        opts.help = true;
+        break;
+      case "--json":
+        opts.json = true;
+        break;
+      case "--verbose":
+      case "-v":
+        opts.verbose = true;
+        break;
+      default:
+        if (!arg.startsWith("-")) {
+          opts.file = arg;
+        }
+    }
+  }
+
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${c.bold}vibecheck validate${c.reset} - Validate AI-generated code for hallucinations
+
+${c.bold}USAGE${c.reset}
+  vibecheck validate [file] [options]
+
+${c.bold}OPTIONS${c.reset}
+  --help, -h     Show this help
+  --json         Output as JSON
+  --verbose, -v  Show detailed output
+
+${c.bold}WHAT IT CHECKS${c.reset}
+  - API routes referenced but not defined
+  - Env vars used but not declared
+  - Imports that don't exist
+  - Function calls to undefined functions
+
+${c.bold}EXAMPLES${c.reset}
+  vibecheck validate                     # Validate all files
+  vibecheck validate src/api/route.ts    # Validate specific file
+  vibecheck validate --json              # JSON output
+`);
+}
+
+async function runValidate(args) {
+  const opts = parseArgs(args);
+
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+
+  const projectPath = process.cwd();
+  
+  console.log(`\n${c.bold}🔍 Validating code for hallucinations...${c.reset}\n`);
+
+  try {
+    // Build truthpack for validation
+    const truthpack = await buildTruthpackSmart({ repoRoot: projectPath });
+    
+    const issues = [];
+    
+    // Check for missing routes
+    const clientRefs = truthpack.routes?.clientRefs || [];
+    const serverRoutes = truthpack.routes?.server || [];
+    
+    for (const ref of clientRefs) {
+      const method = ref.method || "*";
+      const p = ref.path;
+      const exists = serverRoutes.some(r => routeMatches(r, method, p) || routeMatches(r, "*", p));
+      
+      if (!exists) {
+        issues.push({
+          type: "missing_route",
+          severity: "error",
+          message: `Route ${method} ${p} is referenced but not defined`,
+          file: ref.evidence?.[0]?.file || "unknown",
+          line: ref.evidence?.[0]?.lines?.split("-")[0] || 1,
+        });
+      }
+    }
+    
+    // Check for undeclared env vars (excluding system vars)
+    const envVars = truthpack.env?.vars || [];
+    const declared = new Set(truthpack.env?.declared || []);
+    const systemVars = new Set([
+      'HOME', 'USER', 'PATH', 'NODE_ENV', 'CI', 'DEBUG', 'PORT',
+      'APPDATA', 'USERPROFILE', 'COMPUTERNAME', 'HOSTNAME',
+    ]);
+    
+    for (const v of envVars) {
+      if (!declared.has(v.name) && !systemVars.has(v.name) && v.name.startsWith("VIBECHECK_")) {
+        issues.push({
+          type: "undeclared_env",
+          severity: "warning",
+          message: `Env var ${v.name} is used but not declared in .env.example`,
+          file: v.references?.[0]?.file || "unknown",
+          line: v.references?.[0]?.lines?.split("-")[0] || 1,
+        });
+      }
+    }
+    
+    // Output results
+    const { key } = getApiKey();
+    const currentTier = key ? "starter" : "free";
+    
+    if (opts.json) {
+      console.log(JSON.stringify({ issues, valid: issues.length === 0 }, null, 2));
+    } else {
+      if (issues.length === 0) {
+        console.log(`${c.green}✓${c.reset} No hallucinations detected!\n`);
+        console.log(`  ${c.dim}All routes and env vars are properly defined.${c.reset}\n`);
+        
+        // Workflow upsell
+        const workflow = formatWorkflowUpsell("validate", currentTier);
+        if (workflow) console.log(`  ${workflow}\n`);
+      } else {
+        console.log(`${c.yellow}⚠${c.reset} Found ${issues.length} potential issues:\n`);
+        
+        for (const issue of issues) {
+          const icon = issue.severity === "error" ? `${c.red}✗${c.reset}` : `${c.yellow}⚠${c.reset}`;
+          console.log(`  ${icon} ${issue.message}`);
+          console.log(`    ${c.dim}${issue.file}:${issue.line}${c.reset}`);
+        }
+        console.log();
+        
+        // Upsell for auto-fix
+        if (currentTier === "free") {
+          console.log(`  ${c.dim}─────────────────────────────────────────────────────────────${c.reset}`);
+          console.log(`  ${c.cyan}★ STARTER${c.reset}${c.dim}: auto-fix hallucinations with vibecheck fix${c.reset}`);
+          console.log(`  ${c.dim}  Upgrade → ${PRICING_URL}${c.reset}\n`);
+        }
+      }
+    }
+    
+    return issues.some(i => i.severity === "error") ? EXIT.BLOCKING : EXIT.SUCCESS;
+    
+  } catch (error) {
+    console.error(`${c.red}✗${c.reset} Validation failed: ${error.message}`);
+    return EXIT.INTERNAL_ERROR;
+  }
+}
+
+module.exports = { runValidate };