@vibecheckai/cli 3.7.0 → 3.9.0

package/bin/runners/runForge.js

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+/**
+ * 🔥 FORGE - AI Brain Generator Runner
+ * 
+ * Generates the smallest set of rules that produce the biggest accuracy lift.
+ * "Minimal but lethal" - 5-10 rules max by default, expandable tiers.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+// Import CLI utilities for professional styling
+const {
+  colors: c,
+  printBanner,
+  printCommandHeader,
+  printSectionHeader,
+  printTable,
+  highlight,
+  highlightPath,
+  highlightCode,
+  printSuccess,
+  printError,
+  printWarning,
+  formatNumber,
+  gradientText,
+} = require("./cli-utils");
+
+// Default configuration
+const DEFAULT_CONFIG = {
+  maxRules: 10,
+  tier: "standard",
+  platforms: ["cursor", "windsurf"],
+  incremental: true,
+  generateContract: true,
+  generateTruthpack: true,
+  verbose: false,
+};
+
+// Rule tier configurations
+const TIER_CONFIGS = {
+  minimal: {
+    maxRules: 5,
+    features: ["architecture", "avoid", "types", "components", "testing"],
+  },
+  standard: {
+    maxRules: 10,
+    features: ["architecture", "avoid", "types", "components", "testing", "state", "data-flow", "environment", "hooks", "api-patterns"],
+  },
+  extended: {
+    maxRules: 20,
+    features: ["architecture", "avoid", "types", "components", "testing", "state", "data-flow", "environment", "hooks", "api-patterns", "security", "performance", "accessibility", "i18n", "error-handling", "logging", "caching", "database", "authentication", "authorization"],
+  },
+  comprehensive: {
+    maxRules: 50,
+    features: ["*"],
+  },
+};
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+  const opts = {
+    ...DEFAULT_CONFIG,
+    help: false,
+    path: ".",
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") opts.help = true;
+    if (arg === "--path" || arg === "-p") opts.path = args[++i];
+    if (arg.startsWith("--path=")) opts.path = arg.split("=")[1];
+    if (arg === "--tier" || arg === "-t") opts.tier = args[++i];
+    if (arg.startsWith("--tier=")) opts.tier = arg.split("=")[1];
+    if (arg === "--max-rules") opts.maxRules = parseInt(args[++i]);
+    if (arg.startsWith("--max-rules=")) opts.maxRules = parseInt(arg.split("=")[1]);
+    if (arg === "--no-incremental") opts.incremental = false;
+    if (arg === "--no-contract") opts.generateContract = false;
+    if (arg === "--no-truthpack") opts.generateTruthpack = false;
+    if (arg === "--verbose" || arg === "-v") opts.verbose = true;
+    if (arg === "--cursor-only") opts.platforms = ["cursor"];
+    if (arg === "--windsurf-only") opts.platforms = ["windsurf"];
+    if (arg === "minimal") opts.tier = "minimal";
+    if (arg === "standard") opts.tier = "standard";
+    if (arg === "extended") opts.tier = "extended";
+    if (arg === "comprehensive") opts.tier = "comprehensive";
+  }
+
+  return opts;
+}
+
+/**
+ * Print help message
+ */
+function printHelp() {
+  console.log();
+  printBanner();
+  printCommandHeader("FORGE", "AI Brain Generator v1.0");
+  
+  console.log(`${gradientText("Minimal but lethal", [c.red, c.yellow, c.green])} - Generate the smallest set of rules that produce the biggest accuracy lift.\n`);
+  
+  console.log(`${c.yellow}USAGE${c.reset}`);
+  console.log(`  ${c.cyan}vibecheck forge${c.reset} ${c.dim}[options] [tier]${c.reset}`);
+  console.log();
+  
+  console.log(`${c.yellow}TIERS${c.reset}`);
+  const tiers = [
+    ["minimal", "5 rules max", "Core essentials only"],
+    ["standard", "10 rules max", "Balanced coverage (default)"],
+    ["extended", "20 rules max", "Comprehensive coverage"],
+    ["comprehensive", "50 rules max", "Everything included"],
+  ];
+  printTable(["Tier", "Rules", "Description"], tiers);
+  console.log();
+  
+  console.log(`${c.yellow}OPTIONS${c.reset}`);
+  const options = [
+    ["--path, -p <dir>", "Project directory (default: current)"],
+    ["--tier, -t <tier>", "Rule tier (minimal|standard|extended|comprehensive)"],
+    ["--max-rules <n>", "Override max rules for tier"],
+    ["--no-incremental", "Regenerate all rules (don't diff)"],
+    ["--no-contract", "Skip AI contract generation"],
+    ["--no-truthpack", "Skip truthpack generation"],
+    ["--cursor-only", "Generate only Cursor rules"],
+    ["--windsurf-only", "Generate only Windsurf rules"],
+    ["--verbose, -v", "Show detailed output"],
+    ["--help, -h", "Show this help"],
+  ];
+  printTable(["Option", "Description"], options);
+  console.log();
+  
+  console.log(`${c.yellow}OUTPUTS${c.reset}`);
+  const outputs = [
+    [".cursorrules", "Main Cursor rules file"],
+    [".cursor/rules/*.mdc", "MDC specification files"],
+    [".cursor/skills/", "Auto-generated skills"],
+    [".cursor/agents/", "Subagent definitions"],
+    [".cursor/hooks/", "Automation hooks"],
+    [".windsurf/rules/", "Windsurf rules"],
+    [".vibecheck/ai-contract.json", "AI Contract (JSON)"],
+    [".vibecheck/AI_CONTRACT.md", "Human-readable contract"],
+    [".vibecheck/truth/truthpack.json", "Truthpack"],
+    [".vibecheck/forge-manifest.json", "Manifest for incremental"],
+  ];
+  printTable(["File", "Description"], outputs);
+  console.log();
+  
+  console.log(`${c.yellow}EXAMPLES${c.reset}`);
+  console.log(`  ${c.cyan}vibecheck forge${c.reset}                    ${c.dim}# Standard tier, incremental${c.reset}`);
+  console.log(`  ${c.cyan}vibecheck forge minimal${c.reset}            ${c.dim}# Minimal tier (5 rules)${c.reset}`);
+  console.log(`  ${c.cyan}vibecheck forge --max-rules=7${c.reset}      ${c.dim}# Custom rule count${c.reset}`);
+  console.log(`  ${c.cyan}vibecheck forge --no-incremental${c.reset}   ${c.dim}# Force full regeneration${c.reset}`);
+  console.log();
+}
+
+/**
+ * Main forge runner
+ */
+async function runForge(args) {
+  const opts = parseArgs(args);
+
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+
+  const startTime = Date.now();
+  const projectPath = path.resolve(opts.path);
+
+  // Display header
+  console.log();
+  printBanner();
+  printCommandHeader("FORGE", "AI Brain Generator v1.0");
+  
+  console.log(`${c.dim}Project:${c.reset} ${highlightPath(projectPath)}`);
+  console.log(`${c.dim}Tier:${c.reset} ${highlight(opts.tier)} (max ${opts.maxRules} rules)`);
+  console.log(`${c.dim}Mode:${c.reset} ${opts.incremental ? "Incremental" : "Full regeneration"}`);
+  console.log();
+
+  try {
+    // Try to import TypeScript forge module
+    let forgeModule;
+    try {
+      forgeModule = require("../../packages/cli/src/forge");
+    } catch {
+      // Fall back to JavaScript implementation
+      forgeModule = null;
+    }
+
+    if (forgeModule) {
+      // Use TypeScript implementation
+      const result = await forgeModule.forge(projectPath, opts);
+      
+      printForgeResults(result, opts, startTime);
+      return 0;
+    }
+
+    // Fallback: use existing context generator with forge wrapper
+    console.log(`${c.yellow}⚡ Using context generator with Forge enhancements...${c.reset}\n`);
+    
+    const { runContext } = require("../../packages/cli/src/context");
+    const contextArgs = ["--path", projectPath, "--enhanced"];
+    
+    if (opts.verbose) contextArgs.push("--verbose");
+    
+    const result = await runContext(contextArgs);
+    
+    // Generate additional forge-specific outputs
+    if (opts.generateContract) {
+      generateSimpleContract(projectPath);
+    }
+    
+    if (opts.generateTruthpack) {
+      generateSimpleTruthpack(projectPath);
+    }
+    
+    const timeMs = Date.now() - startTime;
+    console.log(`\n${c.green}✓ Forge complete in ${timeMs}ms${c.reset}`);
+    
+    return result;
+  } catch (error) {
+    printError(`Forge failed: ${error.message}`);
+    if (opts.verbose) {
+      console.error(error.stack);
+    }
+    return 1;
+  }
+}
+
+/**
+ * Print forge results
+ */
+function printForgeResults(result, opts, startTime) {
+  const timeMs = Date.now() - startTime;
+  
+  printSectionHeader("FORGE COMPLETE");
+  
+  console.log(`${c.green}🔥 Generated ${result.stats.rulesGenerated} rules in ${timeMs}ms${c.reset}\n`);
+  
+  // Stats
+  const statsTable = [
+    ["Rules Generated", formatNumber(result.stats.rulesGenerated)],
+    ["Files Written", formatNumber(result.stats.filesWritten)],
+    ["Rules Skipped", formatNumber(result.stats.rulesSkipped)],
+    ["Rules Pruned", formatNumber(result.stats.rulesPruned)],
+    ["Incremental", result.stats.incremental ? "Yes" : "No"],
+    ["Time", `${timeMs}ms`],
+  ];
+  printTable(["Metric", "Value"], statsTable);
+  console.log();
+  
+  // Contract summary
+  if (result.contract) {
+    console.log(`${c.cyan}📜 AI Contract${c.reset}`);
+    console.log(`  ${c.dim}Allowed actions:${c.reset} ${result.contract.allowed.length}`);
+    console.log(`  ${c.dim}Forbidden actions:${c.reset} ${result.contract.forbidden.length}`);
+    console.log(`  ${c.dim}Critical safety rules:${c.reset} ${result.contract.safetyRules.critical.length}`);
+    console.log();
+  }
+  
+  // Truthpack summary
+  if (result.truthpack) {
+    console.log(`${c.cyan}📦 Truthpack${c.reset}`);
+    console.log(`  ${c.dim}Sections:${c.reset} ${Object.keys(result.truthpack.sections).length}`);
+    console.log(`  ${c.dim}Confidence:${c.reset} ${(result.truthpack.confidence * 100).toFixed(1)}%`);
+    console.log(`  ${c.dim}Issues:${c.reset} ${result.truthpack.validationIssues.length}`);
+    console.log();
+  }
+  
+  // Files list
+  console.log(`${c.cyan}Generated Files:${c.reset}`);
+  result.files.slice(0, 15).forEach((file, idx) => {
+    console.log(`  ${c.dim}${idx + 1}.${c.reset} ${highlightPath(file)}`);
+  });
+  if (result.files.length > 15) {
+    console.log(`  ${c.dim}... and ${result.files.length - 15} more${c.reset}`);
+  }
+  console.log();
+  
+  // Summary banner
+  console.log(`${c.bgGreen}${c.black}  🔥 FORGE v1.0 - Minimal but lethal  ${c.reset}\n`);
+}
+
+/**
+ * Generate a simple AI contract
+ */
+function generateSimpleContract(projectPath) {
+  const contract = {
+    version: "1.0.0",
+    generatedAt: new Date().toISOString(),
+    projectId: path.basename(projectPath),
+    allowed: [
+      "Create new files in appropriate directories",
+      "Modify existing source code files",
+      "Add or update dependencies",
+      "Create and run tests",
+    ],
+    forbidden: [
+      "Commit secrets or credentials to code",
+      "Disable security checks",
+      "Use `any` type in TypeScript",
+      "Skip error handling",
+    ],
+    requiresConfirmation: [
+      "Delete any file",
+      "Modify database schema",
+      "Change authentication logic",
+    ],
+    fileBoundaries: {
+      mayCreate: ["src/**/*", "tests/**/*"],
+      mayNotModify: [".env", "*.lock", "node_modules/**"],
+      restrictedPatterns: ["**/auth/**", "**/config/**"],
+    },
+    codeStandards: {
+      mustFollow: ["Use TypeScript", "Follow existing patterns"],
+      mustAvoid: ["any type", "console.log in production"],
+      preferredPatterns: ["Functional components", "Custom hooks"],
+    },
+    safetyRules: {
+      critical: ["Never commit secrets", "Always validate input"],
+      high: ["Handle errors explicitly", "Use HTTPS"],
+      standard: ["Keep dependencies updated", "Write tests"],
+    },
+  };
+  
+  const vibecheckDir = path.join(projectPath, ".vibecheck");
+  if (!fs.existsSync(vibecheckDir)) {
+    fs.mkdirSync(vibecheckDir, { recursive: true });
+  }
+  
+  fs.writeFileSync(
+    path.join(vibecheckDir, "ai-contract.json"),
+    JSON.stringify(contract, null, 2)
+  );
+  
+  // Write human-readable version
+  const contractMd = `# AI Contract
+
+> This document defines what AI agents may and may not do in this repository.
+> Generated by Forge v1.0
+
+## Permissions
+
+### Allowed Actions
+${contract.allowed.map(a => `- ✅ ${a}`).join("\n")}
+
+### Forbidden Actions
+${contract.forbidden.map(f => `- ❌ ${f}`).join("\n")}
+
+### Requires Confirmation
+${contract.requiresConfirmation.map(r => `- ⚠️ ${r}`).join("\n")}
+
+## Safety Rules
+
+### Critical (Never Violate)
+${contract.safetyRules.critical.map(r => `- 🔴 ${r}`).join("\n")}
+
+### High Priority
+${contract.safetyRules.high.map(r => `- 🟠 ${r}`).join("\n")}
+
+---
+*Generated at: ${contract.generatedAt}*
+`;
+  
+  fs.writeFileSync(path.join(vibecheckDir, "AI_CONTRACT.md"), contractMd);
+}
+
+/**
+ * Generate a simple truthpack
+ */
+function generateSimpleTruthpack(projectPath) {
+  const truthpack = {
+    version: "2.0.0",
+    generatedAt: new Date().toISOString(),
+    projectPath: projectPath,
+    contentHash: crypto.createHash("sha256").update(projectPath).digest("hex").slice(0, 16),
+    sections: {
+      routes: { server: [], clientRefs: [], serverOnly: [], clientOnly: [], methodMismatches: [] },
+      env: { declared: [], used: [], unused: [], missing: [], sensitive: [] },
+      components: { components: [], maxDepth: 0, orphans: [] },
+      graph: { modules: {}, cycles: [], entryPoints: [], shared: [] },
+    },
+    confidence: 0.75,
+    validationIssues: [],
+  };
+  
+  const truthDir = path.join(projectPath, ".vibecheck", "truth");
+  if (!fs.existsSync(truthDir)) {
+    fs.mkdirSync(truthDir, { recursive: true });
+  }
+  
+  fs.writeFileSync(
+    path.join(truthDir, "truthpack.json"),
+    JSON.stringify(truthpack, null, 2)
+  );
+}
+
+module.exports = { runForge };
+
+// Run if called directly
+if (require.main === module) {
+  runForge(process.argv.slice(2))
+    .then(code => process.exit(code))
+    .catch(err => {
+      console.error(err);
+      process.exit(1);
+    });
+}