@vibecheckai/cli 2.8.2 → 3.0.0

package/bin/runners/runContextCompiler.js

@@ -0,0 +1,385 @@
+#!/usr/bin/env node
+/**
+ * Context Compiler v1
+ * 
+ * Generates task-targeted context slices from the Truth Pack.
+ * Big context = noise. Small context = missing facts.
+ * This compiles exactly what you need for the task.
+ * 
+ * Usage:
+ *   compileContext({ task: 'Fix dead login button', focus: { files: [...], routes: [...] } })
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import yaml from 'js-yaml';
+
+/**
+ * Load the truth pack from disk
+ */
+async function loadTruthpack(projectPath) {
+  const truthpackPath = path.join(projectPath, '.vibecheck', 'truth', 'truthpack.json');
+  try {
+    const content = await fs.readFile(truthpackPath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load invariants from disk
+ */
+async function loadInvariants(projectPath) {
+  const invariantsPath = path.join(projectPath, '.vibecheck', 'invariants.yml');
+  try {
+    const content = await fs.readFile(invariantsPath, 'utf8');
+    return yaml.load(content);
+  } catch {
+    return { invariants: [] };
+  }
+}
+
+/**
+ * Compile context for a specific task
+ * 
+ * @param {Object} request - Context compilation request
+ * @param {string} request.task - What you're trying to do
+ * @param {Object} request.focus - Optional focus areas
+ * @param {string[]} request.focus.files - Specific files to include
+ * @param {string[]} request.focus.routes - Specific routes to include
+ * @param {string[]} request.constraints - Constraints to apply
+ * @param {number} request.maxTokensHint - Max tokens hint
+ * @param {string} projectPath - Project root path
+ * @returns {Object} Compiled context slice
+ */
+export async function compileContext(request, projectPath = process.cwd()) {
+  const contextId = `ctxslice_${crypto.randomBytes(4).toString('hex')}`;
+  const { task, focus = {}, constraints = [], maxTokensHint = 4000 } = request;
+  
+  const truthpack = await loadTruthpack(projectPath);
+  if (!truthpack) {
+    return {
+      contextId,
+      error: 'No truth pack found. Run `vibecheck ctx` first.',
+      summary: null,
+      truthSlice: null,
+      evidence: [],
+      invariants: [],
+    };
+  }
+  
+  const invariantsData = await loadInvariants(projectPath);
+  
+  // Analyze task to determine relevant domains
+  const analysis = analyzeTask(task);
+  
+  // Filter truth pack to relevant content
+  const truthSlice = buildTruthSlice(truthpack, analysis, focus);
+  
+  // Gather evidence for the slice
+  const evidence = gatherEvidence(truthSlice);
+  
+  // Select applicable invariants
+  const applicableInvariants = selectInvariants(invariantsData, analysis);
+  
+  // Generate summary
+  const summary = generateSummary(task, truthSlice, analysis);
+  
+  // Apply constraints
+  const appliedConstraints = applyConstraints(truthSlice, constraints);
+  
+  // Estimate token count
+  const tokenEstimate = estimateTokens(truthSlice, evidence);
+  
+  return {
+    contextId,
+    summary,
+    task,
+    analysis: {
+      domains: analysis.domains,
+      keywords: analysis.keywords,
+      action: analysis.action,
+    },
+    truthSlice,
+    evidence: evidence.slice(0, 50), // Limit evidence
+    invariants: applicableInvariants.map(i => i.id),
+    constraints: appliedConstraints,
+    tokenEstimate,
+    warnings: generateWarnings(analysis, tokenEstimate, maxTokensHint),
+  };
+}
+
+/**
+ * Analyze task to determine domains, keywords, and action
+ */
+function analyzeTask(task) {
+  const taskLower = task.toLowerCase();
+  
+  // Detect domains
+  const domains = [];
+  if (/auth|login|logout|session|password|jwt|token/i.test(task)) domains.push('auth');
+  if (/billing|payment|stripe|subscription|checkout|tier|pro|enterprise/i.test(task)) domains.push('billing');
+  if (/route|endpoint|api|handler|fetch|axios/i.test(task)) domains.push('api');
+  if (/component|button|form|ui|page|modal|dialog/i.test(task)) domains.push('ui');
+  if (/database|prisma|model|schema|query|db/i.test(task)) domains.push('data');
+  if (/test|spec|jest|vitest/i.test(task)) domains.push('testing');
+  if (/security|xss|csrf|injection|sanitize/i.test(task)) domains.push('security');
+  if (/env|environment|config|secret/i.test(task)) domains.push('env');
+  
+  if (domains.length === 0) domains.push('general');
+  
+  // Detect action type
+  let action = 'unknown';
+  if (/fix|bug|broken|error|issue|problem|dead/i.test(task)) action = 'fix';
+  else if (/add|create|implement|build|new/i.test(task)) action = 'create';
+  else if (/update|change|modify|refactor/i.test(task)) action = 'update';
+  else if (/delete|remove|drop/i.test(task)) action = 'delete';
+  else if (/wire|connect|integrate|link/i.test(task)) action = 'integrate';
+  else if (/verify|check|validate|test/i.test(task)) action = 'verify';
+  
+  // Extract keywords
+  const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'have', 'has', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'must', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'this', 'that', 'these', 'those', 'i', 'me', 'my', 'we', 'our', 'you', 'your', 'it', 'its', 'they', 'them', 'their', 'what', 'which', 'who', 'and', 'but', 'if', 'or', 'because', 'fix', 'add', 'update', 'create', 'make', 'build']);
+  
+  const keywords = task
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .split(/\s+/)
+    .filter(word => word.length > 2 && !stopWords.has(word));
+  
+  return { domains, action, keywords };
+}
+
+/**
+ * Build a filtered truth slice based on analysis and focus
+ */
+function buildTruthSlice(truthpack, analysis, focus) {
+  const slice = {
+    routes: { server: [], clientRefs: [] },
+    env: { vars: [] },
+    auth: null,
+    billing: null,
+  };
+  
+  // Filter routes
+  if (focus.routes && focus.routes.length > 0) {
+    slice.routes.server = truthpack.routes.server.filter(r => 
+      focus.routes.some(fr => r.path.includes(fr) || fr.includes(r.path))
+    );
+    slice.routes.clientRefs = truthpack.routes.clientRefs.filter(r =>
+      focus.routes.some(fr => r.path.includes(fr) || fr.includes(r.path))
+    );
+  } else if (analysis.keywords.length > 0) {
+    slice.routes.server = truthpack.routes.server.filter(r =>
+      analysis.keywords.some(k => r.path.includes(k) || r.handler.includes(k))
+    );
+    slice.routes.clientRefs = truthpack.routes.clientRefs.filter(r =>
+      analysis.keywords.some(k => r.path.includes(k) || r.source.includes(k))
+    );
+  }
+  
+  // Include routes from focused files
+  if (focus.files && focus.files.length > 0) {
+    const fileRoutes = truthpack.routes.server.filter(r =>
+      focus.files.some(f => r.handler.includes(f))
+    );
+    const fileClientRefs = truthpack.routes.clientRefs.filter(r =>
+      focus.files.some(f => r.source.includes(f))
+    );
+    
+    slice.routes.server.push(...fileRoutes.filter(r => !slice.routes.server.includes(r)));
+    slice.routes.clientRefs.push(...fileClientRefs.filter(r => !slice.routes.clientRefs.includes(r)));
+  }
+  
+  // Filter env vars based on keywords
+  if (analysis.keywords.length > 0) {
+    slice.env.vars = truthpack.env.vars.filter(v =>
+      analysis.keywords.some(k => v.name.toLowerCase().includes(k))
+    );
+  }
+  
+  // Include auth if relevant
+  if (analysis.domains.includes('auth')) {
+    slice.auth = truthpack.auth;
+  }
+  
+  // Include billing if relevant
+  if (analysis.domains.includes('billing')) {
+    slice.billing = truthpack.billing;
+  }
+  
+  return slice;
+}
+
+/**
+ * Gather evidence from the truth slice
+ */
+function gatherEvidence(truthSlice) {
+  const evidence = [];
+  
+  for (const route of truthSlice.routes.server) {
+    if (route.evidence) evidence.push(...route.evidence);
+  }
+  
+  for (const ref of truthSlice.routes.clientRefs) {
+    if (ref.evidence) evidence.push(...ref.evidence);
+  }
+  
+  for (const v of truthSlice.env.vars) {
+    if (v.references) evidence.push(...v.references);
+  }
+  
+  if (truthSlice.auth?.model?.signals) {
+    for (const s of truthSlice.auth.model.signals) {
+      if (s.evidence) evidence.push(...s.evidence);
+    }
+  }
+  
+  return evidence;
+}
+
+/**
+ * Select applicable invariants based on task analysis
+ */
+function selectInvariants(invariantsData, analysis) {
+  const invariants = invariantsData.invariants || [];
+  
+  const domainToApplies = {
+    auth: ['server', 'middleware', 'api'],
+    billing: ['server', 'ui'],
+    api: ['api', 'server'],
+    ui: ['ui'],
+    security: ['all', 'server'],
+  };
+  
+  const relevantApplies = new Set();
+  for (const domain of analysis.domains) {
+    const applies = domainToApplies[domain] || [];
+    applies.forEach(a => relevantApplies.add(a));
+  }
+  
+  // Always include security-related invariants for fix/integrate actions
+  if (analysis.action === 'fix' || analysis.action === 'integrate') {
+    relevantApplies.add('server');
+    relevantApplies.add('middleware');
+  }
+  
+  return invariants.filter(inv => {
+    if (!inv.appliesTo) return true;
+    return inv.appliesTo.some(a => relevantApplies.has(a) || a === 'all');
+  });
+}
+
+/**
+ * Generate a summary of the context
+ */
+function generateSummary(task, truthSlice, analysis) {
+  const parts = [];
+  
+  parts.push(`Task: ${task}`);
+  parts.push(`Domains: ${analysis.domains.join(', ')}`);
+  parts.push(`Action: ${analysis.action}`);
+  
+  if (truthSlice.routes.server.length > 0) {
+    parts.push(`Server routes: ${truthSlice.routes.server.length}`);
+  }
+  
+  if (truthSlice.routes.clientRefs.length > 0) {
+    parts.push(`Client refs: ${truthSlice.routes.clientRefs.length}`);
+  }
+  
+  // Check for mismatches (gaps)
+  const serverPaths = new Set(truthSlice.routes.server.map(r => r.path));
+  const clientPaths = truthSlice.routes.clientRefs.map(r => r.path);
+  const mismatches = clientPaths.filter(p => !serverPaths.has(p));
+  
+  if (mismatches.length > 0) {
+    parts.push(`⚠️ Route mismatches: ${mismatches.join(', ')}`);
+  }
+  
+  return parts.join(' | ');
+}
+
+/**
+ * Apply constraints to the truth slice
+ */
+function applyConstraints(truthSlice, constraints) {
+  const applied = [];
+  
+  for (const constraint of constraints) {
+    switch (constraint) {
+      case 'do_not_invent_routes':
+        applied.push({
+          id: 'do_not_invent_routes',
+          description: 'Only use routes that exist in the truth pack',
+          enforced: true,
+        });
+        break;
+        
+      case 'no_new_env_vars_without_proof':
+        applied.push({
+          id: 'no_new_env_vars_without_proof',
+          description: 'Do not add env vars that are not declared in .env.example',
+          enforced: true,
+        });
+        break;
+        
+      case 'require_auth_verification':
+        applied.push({
+          id: 'require_auth_verification',
+          description: 'Verify auth is enforced on protected routes',
+          enforced: true,
+        });
+        break;
+    }
+  }
+  
+  return applied;
+}
+
+/**
+ * Estimate token count for the context
+ */
+function estimateTokens(truthSlice, evidence) {
+  let tokens = 0;
+  
+  // Routes: ~50 tokens each
+  tokens += truthSlice.routes.server.length * 50;
+  tokens += truthSlice.routes.clientRefs.length * 30;
+  
+  // Env vars: ~20 tokens each
+  tokens += truthSlice.env.vars.length * 20;
+  
+  // Auth/billing: ~200 tokens each if present
+  if (truthSlice.auth) tokens += 200;
+  if (truthSlice.billing) tokens += 200;
+  
+  // Evidence: ~100 tokens each
+  tokens += evidence.length * 100;
+  
+  return tokens;
+}
+
+/**
+ * Generate warnings based on context
+ */
+function generateWarnings(analysis, tokenEstimate, maxTokensHint) {
+  const warnings = [];
+  
+  if (analysis.domains.includes('auth') || analysis.domains.includes('billing')) {
+    warnings.push('High-stakes domain detected - verify all claims before making changes');
+  }
+  
+  if (tokenEstimate > maxTokensHint) {
+    warnings.push(`Context exceeds ${maxTokensHint} token hint (est: ${tokenEstimate}). Consider narrowing focus.`);
+  }
+  
+  if (analysis.action === 'fix' && analysis.domains.includes('auth')) {
+    warnings.push('Auth fix - ensure changes do not weaken security');
+  }
+  
+  return warnings;
+}
+
+export default { compileContext };

package/bin/runners/runCtx.js

@@ -0,0 +1,187 @@
+// bin/runners/runCtx.js
+const path = require("path");
+const fs = require("fs");
+const { buildTruthpack, writeTruthpack, detectFastifyEntry } = require("./lib/truth");
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+};
+
+function parseArgs(args) {
+  const opts = {
+    path: process.cwd(),
+    fastifyEntry: null,
+    json: false,
+    snapshot: false,
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json' || arg === '-j') opts.json = true;
+    else if (arg === '--snapshot' || arg === '-s') opts.snapshot = true;
+    else if (arg === '--fastify-entry') opts.fastifyEntry = args[++i];
+    else if (arg === '--path' || arg === '-p') opts.path = args[++i];
+    else if (arg === '--help' || arg === '-h') opts.help = true;
+  }
+
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${c.cyan}${c.bold}📦 vibecheck ctx${c.reset} — Truth Pack Generator
+
+${c.dim}Build a comprehensive truth pack of your codebase for AI agents.${c.reset}
+
+${c.bold}USAGE${c.reset}
+  vibecheck ctx                Generate truth pack
+  vibecheck ctx --snapshot     Save timestamped snapshot
+  vibecheck ctx --json         Output as JSON
+
+${c.bold}OPTIONS${c.reset}
+  --json, -j          Output raw JSON
+  --snapshot, -s      Save to snapshots/ with timestamp
+  --fastify-entry     Fastify entry file (e.g. src/server.ts)
+  --path, -p          Project path (default: current directory)
+  --help, -h          Show this help
+
+${c.bold}TRUTH PACK CONTENTS${c.reset}
+  • ${c.cyan}routes${c.reset}      Server routes + client refs + gaps
+  • ${c.cyan}env${c.reset}         Used vars + declared vars + sources
+  • ${c.cyan}auth${c.reset}        Middleware + patterns + signals
+  • ${c.cyan}billing${c.reset}     Stripe usage + webhooks + gates
+  • ${c.cyan}enforcement${c.reset} Paid surface checks
+
+${c.bold}OUTPUT${c.reset}
+  .vibecheck/truth/truthpack.json   Main truth pack
+  .vibecheck/truth/truthpack.md     Human-readable summary
+
+${c.bold}EXAMPLES${c.reset}
+  vibecheck ctx                          # Generate truth pack
+  vibecheck ctx --snapshot               # Save snapshot
+  vibecheck ctx --json > truthpack.json  # Export as JSON
+`);
+}
+
+async function runCtx(args) {
+  const opts = typeof args === 'object' && !Array.isArray(args) 
+    ? args  // Legacy object format
+    : parseArgs(args || []);
+
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+
+  const root = opts.repoRoot || opts.path || process.cwd();
+  const entry = opts.fastifyEntry || detectFastifyEntry(root);
+
+  // Print header
+  if (!opts.json && !opts.print) {
+    console.log('');
+    console.log(`${c.cyan}╔══════════════════════════════════════════════════════════════════════╗${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}                                                                      ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}   ${c.bold}📦 TRUTH PACK GENERATOR${c.reset}                                          ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}   ${c.dim}Building ground truth for AI agents${c.reset}                              ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}                                                                      ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}╚══════════════════════════════════════════════════════════════════════╝${c.reset}`);
+    console.log('');
+  }
+
+  // Build truthpack with progress
+  if (!opts.json && !opts.print) {
+    process.stdout.write(`${c.dim}○${c.reset} Building truth pack...`);
+  }
+
+  const truthpack = await buildTruthpack({ repoRoot: root, fastifyEntry: entry });
+  writeTruthpack(root, truthpack);
+
+  if (!opts.json && !opts.print) {
+    process.stdout.write(`\r${c.green}✓${c.reset} Truth pack built        \n`);
+  }
+
+  // Handle snapshot
+  if (opts.snapshot) {
+    const snapshotsDir = path.join(root, ".vibecheck", "truth", "snapshots");
+    fs.mkdirSync(snapshotsDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const snapshotPath = path.join(snapshotsDir, `truthpack-${timestamp}.json`);
+    fs.writeFileSync(snapshotPath, JSON.stringify(truthpack, null, 2));
+    if (!opts.json) {
+      console.log(`${c.green}✓${c.reset} Snapshot saved: ${c.dim}${path.relative(root, snapshotPath)}${c.reset}`);
+    }
+  }
+
+  // JSON output
+  if (opts.json || opts.print) {
+    console.log(JSON.stringify(truthpack, null, 2));
+    return 0;
+  }
+
+  // Beautiful summary
+  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 => 
+    !r.handler?.includes("app/api") && !r.handler?.includes("pages/api")
+  ).length;
+  const clientRefs = truthpack.routes?.clientRefs?.length || 0;
+  const gaps = truthpack.routes?.gaps?.length || 0;
+
+  const envUsed = truthpack.env?.vars?.length || 0;
+  const envDeclared = truthpack.env?.declared?.length || 0;
+  const envSources = (truthpack.env?.declaredSources || []).join(", ") || "none";
+
+  const nextMiddleware = truthpack.auth?.nextMiddleware?.length || 0;
+  const fastifySignals = truthpack.auth?.fastify?.signalTypes?.length || 0;
+
+  const hasStripe = truthpack.billing?.hasStripe;
+  const webhooks = truthpack.billing?.summary?.webhookHandlersFound || 0;
+
+  const enforced = truthpack.enforcement?.enforcedCount || 0;
+  const checked = truthpack.enforcement?.checkedCount || 0;
+
+  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.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}`);
+
+  console.log(`${c.magenta}┌─ Environment ─────────────────────────────────────────────────────────┐${c.reset}`);
+  console.log(`${c.magenta}│${c.reset}  ${c.bold}Used:${c.reset}     ${envUsed} env vars`);
+  console.log(`${c.magenta}│${c.reset}  ${c.bold}Declared:${c.reset} ${envDeclared} (${envSources})`);
+  console.log(`${c.magenta}└───────────────────────────────────────────────────────────────────────┘${c.reset}`);
+
+  console.log(`${c.blue}┌─ Auth ─────────────────────────────────────────────────────────────────┐${c.reset}`);
+  console.log(`${c.blue}│${c.reset}  ${c.bold}Next middleware:${c.reset} ${nextMiddleware}`);
+  console.log(`${c.blue}│${c.reset}  ${c.bold}Fastify signals:${c.reset} ${fastifySignals}`);
+  console.log(`${c.blue}└───────────────────────────────────────────────────────────────────────┘${c.reset}`);
+
+  console.log(`${c.yellow}┌─ Billing ──────────────────────────────────────────────────────────────┐${c.reset}`);
+  console.log(`${c.yellow}│${c.reset}  ${c.bold}Stripe:${c.reset}   ${hasStripe ? `${c.green}✓ detected${c.reset}` : `${c.dim}not detected${c.reset}`}`);
+  console.log(`${c.yellow}│${c.reset}  ${c.bold}Webhooks:${c.reset} ${webhooks} handlers`);
+  console.log(`${c.yellow}│${c.reset}  ${c.bold}Enforced:${c.reset} ${enforced}/${checked} paid routes`);
+  console.log(`${c.yellow}└───────────────────────────────────────────────────────────────────────┘${c.reset}`);
+
+  console.log('');
+  console.log(`${c.green}${c.bold}✓ Truth pack saved${c.reset}`);
+  console.log(`  ${c.dim}→${c.reset} ${path.join(root, ".vibecheck", "truth", "truthpack.json")}`);
+  if (entry) {
+    console.log(`  ${c.dim}Fastify entry:${c.reset} ${entry}`);
+  }
+  console.log('');
+
+  return 0;
+}
+
+module.exports = { runCtx };