@vibecheckai/cli 3.1.5 → 3.1.6

package/bin/runners/runInit.js

@@ -182,6 +182,8 @@ const ICONS = {
   update: '✏️',
   skip: '⏭️',
   detect: '🔍',
+  repair: '🔧',
+  tool: '🛠️',
   
   // Objects
   file: '📄',
@@ -295,6 +297,556 @@ function printSection(title, icon = '◆') {
   printDivider();
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// FRAMEWORK-SPECIFIC CONFIGURATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function getFrameworkConfig(detection) {
+  if (!detection || !detection.frameworks) {
+    return {
+      framework: "node",
+      checks: ["routes", "env", "auth", "security"],
+      ignorePaths: [],
+      extra: {},
+    };
+  }
+
+  // Find the primary detected framework
+  const detectedFrameworks = Object.entries(detection.frameworks)
+    .filter(([key, fw]) => fw.detected)
+    .map(([key, fw]) => ({ key, ...fw }));
+
+  if (detectedFrameworks.length === 0) {
+    return {
+      framework: "node",
+      checks: ["routes", "env", "auth", "security"],
+      ignorePaths: [],
+      extra: {},
+    };
+  }
+
+  // Use the first detected framework (usually the most specific)
+  const primary = detectedFrameworks[0];
+  const frameworkKey = primary.key;
+
+  // Framework-specific configurations
+  const frameworkConfigs = {
+    nextjs: {
+      framework: "nextjs",
+      checks: ["routes", "auth", "api", "security", "ssr"],
+      ignorePaths: [".next/", "out/", ".vercel/"],
+      extra: {},
+    },
+    remix: {
+      framework: "remix",
+      checks: ["routes", "auth", "api", "security", "loaders"],
+      ignorePaths: [".remix/", "build/"],
+      extra: {},
+    },
+    nuxt: {
+      framework: "nuxt",
+      checks: ["routes", "auth", "api", "security"],
+      ignorePaths: [".nuxt/", ".output/"],
+      extra: {},
+    },
+    sveltekit: {
+      framework: "sveltekit",
+      checks: ["routes", "auth", "api", "security"],
+      ignorePaths: [".svelte-kit/", "build/"],
+      extra: {},
+    },
+    react: {
+      framework: "react",
+      checks: ["components", "api", "security"],
+      ignorePaths: ["build/", "dist/"],
+      extra: {},
+    },
+    vue: {
+      framework: "vue",
+      checks: ["components", "api", "security"],
+      ignorePaths: ["dist/"],
+      extra: {},
+    },
+    fastify: {
+      framework: "fastify",
+      checks: ["routes", "auth", "api", "security"],
+      ignorePaths: [],
+      extra: {
+        fastify: {
+          plugins: detection.frameworks?.fastify?.plugins || [],
+        },
+      },
+    },
+    express: {
+      framework: "express",
+      checks: ["routes", "auth", "api", "security"],
+      ignorePaths: [],
+      extra: {},
+    },
+    nestjs: {
+      framework: "nestjs",
+      checks: ["routes", "auth", "api", "security", "modules"],
+      ignorePaths: ["dist/"],
+      extra: {},
+    },
+  };
+
+  // Get framework-specific config or use detected checks
+  const config = frameworkConfigs[frameworkKey] || {
+    framework: frameworkKey,
+    checks: primary.checks || ["routes", "env", "auth", "security"],
+    ignorePaths: [],
+    extra: {},
+  };
+
+  // Merge detected checks if available
+  if (primary.checks && primary.checks.length > 0) {
+    config.checks = [...new Set([...config.checks, ...primary.checks])];
+  }
+
+  return config;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// INIT STATE TRACKING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function saveInitState(targetDir, state) {
+  try {
+    const statePath = path.join(targetDir, ".vibecheck", ".init-state.json");
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+  } catch (e) {
+    // Non-critical - state tracking is optional
+    if (process.env.VIBECHECK_DEBUG) {
+      console.error(`Failed to save init state: ${e.message}`);
+    }
+  }
+}
+
+function loadInitState(targetDir) {
+  try {
+    const statePath = path.join(targetDir, ".vibecheck", ".init-state.json");
+    if (fs.existsSync(statePath)) {
+      return JSON.parse(fs.readFileSync(statePath, "utf-8"));
+    }
+  } catch (e) {
+    // Non-critical
+  }
+  return null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// POST-INIT VALIDATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function verifyInitSetup(targetDir, opts) {
+  const issues = [];
+  const vibecheckDir = path.join(targetDir, ".vibecheck");
+  
+  // Check directory structure
+  const requiredDirs = [
+    vibecheckDir,
+    path.join(vibecheckDir, "results"),
+    path.join(vibecheckDir, "contracts"),
+  ];
+  
+  for (const dir of requiredDirs) {
+    if (!fs.existsSync(dir)) {
+      issues.push(`Missing directory: ${path.relative(targetDir, dir)}`);
+    }
+  }
+  
+  // Check config.json
+  const configPath = path.join(vibecheckDir, "config.json");
+  if (!fs.existsSync(configPath)) {
+    issues.push("Missing: .vibecheck/config.json");
+  } else {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      if (!config.version || !config.checks) {
+        issues.push("Invalid config.json structure");
+      }
+    } catch (e) {
+      issues.push(`Invalid config.json: ${e.message}`);
+    }
+  }
+  
+  // Check truthpack
+  const truthpackPath = path.join(vibecheckDir, "truthpack.json");
+  if (!fs.existsSync(truthpackPath)) {
+    issues.push("Missing: .vibecheck/truthpack.json (run 'vibecheck ctx build')");
+  } else {
+    try {
+      const truthpack = JSON.parse(fs.readFileSync(truthpackPath, "utf-8"));
+      if (!truthpack.version || !truthpack.generatedAt) {
+        issues.push("Invalid truthpack.json structure");
+      }
+    } catch (e) {
+      issues.push(`Invalid truthpack.json: ${e.message}`);
+    }
+  }
+  
+  // Check contracts
+  const contractsDir = path.join(vibecheckDir, "contracts");
+  const requiredContracts = ["routes.contract.json", "env.contract.json"];
+  for (const contract of requiredContracts) {
+    const contractPath = path.join(contractsDir, contract);
+    if (!fs.existsSync(contractPath)) {
+      issues.push(`Missing contract: ${contract}`);
+    }
+  }
+  
+  if (issues.length === 0 && !opts.json) {
+    console.log();
+    console.log(`  ${colors.success}${ICONS.check}${c.reset} ${c.bold}Setup Verification:${c.reset} All checks passed`);
+  }
+  
+  return {
+    success: issues.length === 0,
+    issues,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FRAMEWORK-SPECIFIC RECOMMENDATIONS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printFrameworkRecommendations(detection, opts) {
+  const frameworks = Object.keys(detection.frameworks || {}).filter(k => detection.frameworks[k].detected);
+  if (frameworks.length === 0) return;
+  
+  const primaryFramework = frameworks[0];
+  const framework = detection.frameworks[primaryFramework];
+  
+  const recommendations = [];
+  
+  // Next.js specific
+  if (primaryFramework === 'nextjs') {
+    recommendations.push({
+      icon: ICONS.framework,
+      title: "Next.js Route Verification",
+      command: "vibecheck scan --routes",
+      description: "Verify all Next.js routes are properly configured",
+    });
+    if (!opts.connect) {
+      recommendations.push({
+        icon: ICONS.ci,
+        title: "Add Vercel Integration",
+        command: "vibecheck init --connect",
+        description: "Enable GitHub Actions for automatic PR checks",
+      });
+    }
+  }
+  
+  // Fastify specific
+  if (primaryFramework === 'fastify') {
+    recommendations.push({
+      icon: ICONS.framework,
+      title: "Fastify Route Extraction",
+      command: "vibecheck scan --routes",
+      description: "Extract and verify all Fastify routes",
+    });
+  }
+  
+  // Express specific
+  if (primaryFramework === 'express') {
+    recommendations.push({
+      icon: ICONS.framework,
+      title: "Express Route Analysis",
+      command: "vibecheck scan --routes",
+      description: "Analyze Express route definitions",
+    });
+  }
+  
+  // Auth providers
+  const authProviders = Object.keys(detection.auth || {}).filter(k => detection.auth[k].detected);
+  if (authProviders.length > 0) {
+    recommendations.push({
+      icon: ICONS.auth,
+      title: "Auth Coverage Check",
+      command: "vibecheck scan --auth",
+      description: "Verify authentication coverage across routes",
+    });
+  }
+  
+  // Payment providers
+  const paymentProviders = Object.keys(detection.payments || {}).filter(k => detection.payments[k].detected);
+  if (paymentProviders.length > 0) {
+    recommendations.push({
+      icon: ICONS.payment,
+      title: "Payment Flow Verification",
+      command: "vibecheck scan --billing",
+      description: "Verify payment webhook handlers and idempotency",
+    });
+  }
+  
+  if (recommendations.length > 0) {
+    console.log();
+    printSection('RECOMMENDATIONS', ICONS.sparkle);
+    console.log();
+    for (const rec of recommendations) {
+      console.log(`  ${rec.icon} ${c.bold}${rec.title}${c.reset}`);
+      console.log(`     ${c.dim}${rec.description}${c.reset}`);
+      console.log(`     ${c.cyan}${rec.command}${c.reset}`);
+      console.log();
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// REPAIR MODE - Fix partial init state
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runRepairMode(targetDir, projectName, opts) {
+  printSection('REPAIR MODE', ICONS.repair);
+  console.log();
+  console.log(`  ${colors.info}${ICONS.info}${c.reset} Scanning for partial initialization state...`);
+  console.log();
+  
+  // Load previous init state if available
+  const previousState = loadInitState(targetDir);
+  if (previousState && !opts.json) {
+    console.log(`  ${c.dim}Previous init: ${previousState.timestamp} (${previousState.mode} mode)${c.reset}`);
+    if (previousState.errors && previousState.errors.length > 0) {
+      console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${previousState.errors.length} error(s) from previous attempt`);
+    }
+    console.log();
+  }
+
+  const vibecheckDir = path.join(targetDir, ".vibecheck");
+  const issues = [];
+  const fixes = [];
+
+  // Check for missing directories
+  const requiredDirs = [
+    vibecheckDir,
+    path.join(vibecheckDir, "results"),
+    path.join(vibecheckDir, "reports"),
+    path.join(vibecheckDir, "contracts"),
+    path.join(vibecheckDir, "missions"),
+    path.join(vibecheckDir, "checkpoints"),
+    path.join(vibecheckDir, "runs"),
+  ];
+
+  for (const dir of requiredDirs) {
+    if (!fs.existsSync(dir)) {
+      issues.push(`Missing directory: ${path.relative(targetDir, dir)}`);
+      if (!opts.dryRun) {
+        fs.mkdirSync(dir, { recursive: true });
+        fixes.push(`Created: ${path.relative(targetDir, dir)}`);
+      } else {
+        fixes.push(`Would create: ${path.relative(targetDir, dir)}`);
+      }
+    }
+  }
+
+  // Check for missing config.json
+  const configPath = path.join(vibecheckDir, "config.json");
+  if (!fs.existsSync(configPath)) {
+    issues.push("Missing: .vibecheck/config.json");
+    if (!opts.dryRun) {
+      try {
+        const { detectAll } = require("./lib/enterprise-detect");
+        const detection = detectAll(targetDir);
+        const frameworkConfig = getFrameworkConfig(detection);
+        const config = {
+          version: "2.0.0",
+          project: projectName,
+          createdAt: new Date().toISOString(),
+          framework: frameworkConfig.framework || "node",
+          checks: frameworkConfig.checks || ["routes", "env", "auth", "security"],
+          output: ".vibecheck",
+          policy: {
+            allowlist: { domains: [], packages: [] },
+            ignore: {
+              paths: [
+                "node_modules",
+                "__tests__",
+                "*.test.*",
+                "*.spec.*",
+                ...(frameworkConfig.ignorePaths || []),
+              ],
+            },
+          },
+          thresholds: {
+            minScore: 70,
+            maxBlockers: 0,
+            maxWarnings: 10,
+          },
+          ...(frameworkConfig.extra || {}),
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        fixes.push("Created: .vibecheck/config.json");
+      } catch (e) {
+        issues.push(`Failed to create config.json: ${e.message}`);
+      }
+    } else {
+      fixes.push("Would create: .vibecheck/config.json");
+    }
+  }
+
+  // Check for missing truthpack
+  const truthpackPath = path.join(vibecheckDir, "truthpack.json");
+  if (!fs.existsSync(truthpackPath)) {
+    issues.push("Missing: .vibecheck/truthpack.json");
+    if (!opts.dryRun) {
+      startSpinner('Generating truthpack...', colors.accent);
+      try {
+        const { runCtx } = require("./runCtx");
+        await runCtx(["build", "--path", targetDir, "--quiet"]);
+        stopSpinner('Truthpack generated', true);
+        fixes.push("Generated: .vibecheck/truthpack.json");
+      } catch (e) {
+        stopSpinner('Truthpack generation failed', false);
+        issues.push(`Failed to generate truthpack: ${e.message}`);
+      }
+    } else {
+      fixes.push("Would generate: .vibecheck/truthpack.json");
+    }
+  }
+
+  // Check for missing contracts
+  const contractsDir = path.join(vibecheckDir, "contracts");
+  const routeContractPath = path.join(contractsDir, "routes.contract.json");
+  const envContractPath = path.join(contractsDir, "env.contract.json");
+
+  if (!fs.existsSync(routeContractPath)) {
+    issues.push("Missing: .vibecheck/contracts/routes.contract.json");
+    if (!opts.dryRun) {
+      const routeContract = {
+        version: "1.0.0",
+        generatedAt: new Date().toISOString(),
+        routes: [],
+        description: "Route contract - populated by scan",
+      };
+      fs.writeFileSync(routeContractPath, JSON.stringify(routeContract, null, 2));
+      fixes.push("Created: .vibecheck/contracts/routes.contract.json");
+    } else {
+      fixes.push("Would create: .vibecheck/contracts/routes.contract.json");
+    }
+  }
+
+  if (!fs.existsSync(envContractPath)) {
+    issues.push("Missing: .vibecheck/contracts/env.contract.json");
+    if (!opts.dryRun) {
+      const envContract = {
+        version: "1.0.0",
+        generatedAt: new Date().toISOString(),
+        required: [],
+        optional: [],
+        description: "Environment contract - populated by scan",
+      };
+      fs.writeFileSync(envContractPath, JSON.stringify(envContract, null, 2));
+      fixes.push("Created: .vibecheck/contracts/env.contract.json");
+    } else {
+      fixes.push("Would create: .vibecheck/contracts/env.contract.json");
+    }
+  }
+
+  // Use previous state to prioritize fixes
+  if (previousState && previousState.errors && previousState.errors.length > 0) {
+    const previousErrors = previousState.errors.map(e => e.step);
+    // Prioritize fixing errors from previous attempt
+    const prioritizedIssues = [];
+    const otherIssues = [];
+    
+    for (const issue of issues) {
+      const isPreviousError = previousErrors.some(step => issue.toLowerCase().includes(step));
+      if (isPreviousError) {
+        prioritizedIssues.push(issue);
+      } else {
+        otherIssues.push(issue);
+      }
+    }
+    
+    issues.length = 0;
+    issues.push(...prioritizedIssues, ...otherIssues);
+  }
+  
+  // Summary
+  console.log();
+  if (issues.length === 0) {
+    console.log(`  ${colors.success}${ICONS.check}${c.reset} No issues found - initialization is complete`);
+    // Clear previous state on successful repair
+    if (!opts.dryRun) {
+      const statePath = path.join(targetDir, ".vibecheck", ".init-state.json");
+      if (fs.existsSync(statePath)) {
+        fs.unlinkSync(statePath);
+      }
+    }
+    return 0;
+  }
+
+  console.log(`  ${colors.warning}${ICONS.warning}${c.reset} Found ${issues.length} issue(s)`);
+  if (previousState && previousState.errors && previousState.errors.length > 0) {
+    console.log(`  ${c.dim}(${previousState.errors.length} from previous attempt)${c.reset}`);
+  }
+  console.log();
+  for (const issue of issues) {
+    console.log(`    ${c.dim}•${c.reset} ${issue}`);
+  }
+
+  if (fixes.length > 0) {
+    console.log();
+    console.log(`  ${colors.success}${ICONS.check}${c.reset} Applied ${fixes.length} fix(es)`);
+    for (const fix of fixes) {
+      console.log(`    ${c.dim}•${c.reset} ${fix}`);
+    }
+  }
+
+  console.log();
+  return issues.length > 0 ? (opts.dryRun ? 0 : 1) : 0;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ENHANCED DETECTION DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printEnhancedDetection(detection, verbose = false) {
+  const frameworks = Object.keys(detection.frameworks || {}).filter(k => detection.frameworks[k].detected);
+  const databases = Object.keys(detection.databases || {}).filter(k => detection.databases[k].detected);
+  const authProviders = Object.keys(detection.auth || {}).filter(k => detection.auth[k].detected);
+  const paymentProviders = Object.keys(detection.payments || {}).filter(k => detection.payments[k].detected);
+  
+  if (frameworks.length > 0) {
+    console.log(`  ${colors.info}${ICONS.info}${c.reset} ${c.bold}Detected Stack:${c.reset}`);
+    console.log(`     ${ICONS.framework} Frameworks: ${frameworks.map(f => detection.frameworks[f].name).join(', ')}`);
+    
+    if (databases.length > 0) {
+      console.log(`     ${ICONS.database} Databases: ${databases.map(d => detection.databases[d].name).join(', ')}`);
+    }
+    if (authProviders.length > 0) {
+      console.log(`     ${ICONS.auth} Auth: ${authProviders.map(a => detection.auth[a].name).join(', ')}`);
+    }
+    if (paymentProviders.length > 0) {
+      console.log(`     ${ICONS.payment} Payments: ${paymentProviders.map(p => detection.payments[p].name).join(', ')}`);
+    }
+    
+    if (verbose) {
+      console.log();
+      console.log(`  ${c.dim}Detection Details:${c.reset}`);
+      if (detection.packageManager) {
+        console.log(`     Package Manager: ${detection.packageManager}`);
+      }
+      if (detection.nodeVersion) {
+        console.log(`     Node Version: ${detection.nodeVersion}`);
+      }
+      const checks = detection.checks || [];
+      if (checks.length > 0) {
+        console.log(`     Recommended Checks: ${checks.join(', ')}`);
+      }
+      const invariants = detection.invariants || [];
+      if (invariants.length > 0) {
+        console.log(`     Invariants: ${invariants.join(', ')}`);
+      }
+    }
+    console.log();
+  } else {
+    console.log(`  ${colors.warning}${ICONS.warning}${c.reset} No framework detected - using default Node.js configuration`);
+    console.log();
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // DETECTION DISPLAY
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -314,7 +866,14 @@ function printDetectionResults(detection) {
   ];
   
   for (const cat of categories) {
-    const items = detection[cat.key] || [];
+    const itemsObj = detection[cat.key] || {};
+    // Handle both object and array formats
+    const items = Array.isArray(itemsObj) 
+      ? itemsObj 
+      : Object.entries(itemsObj)
+          .filter(([key, value]) => value && (value.detected || value === true))
+          .map(([key, value]) => typeof value === 'object' ? value.name || key : key);
+    
     if (items.length === 0) continue;
     
     const itemList = items.slice(0, 4).join(', ');
@@ -343,6 +902,10 @@ function printSetupStep(step, status, detail = null) {
   let icon, color;
   
   switch (status) {
+    case 'dry-run':
+      icon = ICONS.info;
+      color = colors.warning;
+      break;
     case 'creating':
       icon = ICONS.create;
       color = colors.accent;
@@ -550,6 +1113,11 @@ function printHelp() {
   ${c.bold}Basic Options:${c.reset}
     ${colors.accent}--path, -p <dir>${c.reset}     Project path ${c.dim}(default: current directory)${c.reset}
     ${colors.accent}--quick, -q${c.reset}          Skip wizard, use defaults
+    ${colors.accent}--wizard, -i${c.reset}         Interactive setup wizard
+    ${colors.accent}--dry-run${c.reset}            Preview changes without applying
+    ${colors.accent}--repair${c.reset}             Fix partial init state
+    ${colors.accent}--verify${c.reset}            Verify setup after init
+    ${colors.accent}--verbose, -v${c.reset}       Show detailed output
     ${colors.accent}--git-hooks${c.reset}          Install git pre-push hook
     ${colors.accent}--json${c.reset}               Output results as JSON
     ${colors.accent}--help, -h${c.reset}           Show this help
@@ -614,9 +1182,16 @@ function parseArgs(args) {
     help: false,
     quick: false,
     json: false,
+    verbose: false,
     // Mode flags (--local is default, --connect requires STARTER)
     local: false,
     connect: false,
+    // Enhancement flags
+    wizard: false,
+    interactive: false,
+    dryRun: false,
+    repair: false,
+    verify: false,
     // Enterprise options
     enterprise: false,
     ci: false,
@@ -636,6 +1211,16 @@ function parseArgs(args) {
     if (a === "--help" || a === "-h") out.help = true;
     if (a === "--quick" || a === "-q") out.quick = true;
     if (a === "--json") out.json = true;
+    if (a === "--verbose" || a === "-v") out.verbose = true;
+    if (a === "--verify") out.verify = true;
+    
+    // Enhancement flags
+    if (a === "--wizard" || a === "--interactive" || a === "-i") {
+      out.wizard = true;
+      out.interactive = true;
+    }
+    if (a === "--dry-run" || a === "--dryrun") out.dryRun = true;
+    if (a === "--repair") out.repair = true;
     
     // Mode flags
     if (a === "--local" || a === "-l") out.local = true;
@@ -699,9 +1284,41 @@ async function runLocalSetup(targetDir, projectName, opts, filesCreated) {
   printSection('LOCAL SETUP', ICONS.setup);
   console.log();
   
+  const totalSteps = 7; // Approximate number of major steps
+  let currentStep = 0;
+  
+  function logStep(stepName) {
+    currentStep++;
+    if (opts.verbose && !opts.json) {
+      console.log(`  ${c.dim}[${currentStep}/${totalSteps}]${c.reset} ${stepName}`);
+    }
+  }
+  
+  // Detect framework for framework-specific templates
+  let detection = null;
+  if (!opts.dryRun) {
+    try {
+      const { detectAll } = require("./lib/enterprise-detect");
+      detection = detectAll(targetDir);
+      if (!opts.json) {
+        printEnhancedDetection(detection, opts.verbose);
+      }
+    } catch (e) {
+      if (!opts.json) {
+        console.log(`  ${colors.warning}${ICONS.warning}${c.reset} Detection failed: ${e.message}`);
+        if (opts.verbose) {
+          console.log(`  ${c.dim}Stack: ${e.stack}${c.reset}`);
+        }
+        console.log(`  ${c.dim}Using default configuration${c.reset}`);
+        console.log();
+      }
+    }
+  }
+  
   const vibecheckDir = path.join(targetDir, ".vibecheck");
   
   // 1. Create .vibecheck/ directory structure
+  logStep('Creating directory structure');
   const dirs = [
     vibecheckDir,
     path.join(vibecheckDir, "results"),
@@ -714,50 +1331,82 @@ async function runLocalSetup(targetDir, projectName, opts, filesCreated) {
   
   for (const dir of dirs) {
     if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+      if (opts.dryRun) {
+        printSetupStep(path.relative(targetDir, dir), 'dry-run', 'would create');
+      } else {
+        fs.mkdirSync(dir, { recursive: true });
+      }
     }
   }
-  printSetupStep('.vibecheck/', 'success', 'directory structure created');
-  filesCreated.push('.vibecheck/');
+  if (!opts.dryRun) {
+    printSetupStep('.vibecheck/', 'success', 'directory structure created');
+    filesCreated.push('.vibecheck/');
+  }
   
-  // 2. Create config.json
+  // 2. Create config.json with framework-specific settings
+  logStep('Creating configuration');
   const configPath = path.join(vibecheckDir, "config.json");
-  if (!fs.existsSync(configPath)) {
+  if (!fs.existsSync(configPath) || opts.dryRun) {
+    const frameworkConfig = getFrameworkConfig(detection);
     const config = {
       version: "2.0.0",
       project: projectName,
       createdAt: new Date().toISOString(),
-      checks: ["routes", "env", "auth", "security"],
+      framework: frameworkConfig.framework || "node",
+      checks: frameworkConfig.checks || ["routes", "env", "auth", "security"],
       output: ".vibecheck",
       policy: {
         allowlist: { domains: [], packages: [] },
-        ignore: { paths: ["node_modules", "__tests__", "*.test.*", "*.spec.*"] },
+        ignore: { 
+          paths: [
+            "node_modules", 
+            "__tests__", 
+            "*.test.*", 
+            "*.spec.*",
+            ...(frameworkConfig.ignorePaths || [])
+          ] 
+        },
       },
       thresholds: {
         minScore: 70,
         maxBlockers: 0,
         maxWarnings: 10,
       },
+      ...(frameworkConfig.extra || {}),
     };
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-    printSetupStep('config.json', 'success', 'configuration created');
-    filesCreated.push('.vibecheck/config.json');
+    
+    if (opts.dryRun) {
+      printSetupStep('config.json', 'dry-run', `would create (framework: ${config.framework})`);
+      console.log(`  ${c.dim}Config preview:${c.reset}`);
+      console.log(JSON.stringify(config, null, 2));
+    } else {
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      printSetupStep('config.json', 'success', `configuration created (framework: ${config.framework})`);
+      filesCreated.push('.vibecheck/config.json');
+    }
   } else {
     printSetupStep('config.json', 'exists', 'already exists');
   }
   
   // 3. Generate truthpack
-  startSpinner('Building truthpack...', colors.accent);
-  try {
-    const { runCtx } = require("./runCtx");
-    await runCtx(["build", "--path", targetDir, "--quiet"]);
-    stopSpinner('Truthpack generated', true);
-    filesCreated.push('.vibecheck/truthpack.json');
-  } catch (e) {
-    stopSpinner('Truthpack generation failed (will retry on scan)', false);
+  logStep('Generating truthpack');
+  if (!opts.dryRun) {
+    startSpinner('Building truthpack...', colors.accent);
+    try {
+      const { runCtx } = require("./runCtx");
+      await runCtx(["build", "--path", targetDir, "--quiet"]);
+      stopSpinner('Truthpack generated', true);
+      filesCreated.push('.vibecheck/truthpack.json');
+    } catch (e) {
+      stopSpinner('Truthpack generation failed', false);
+      throw new Error(`Truthpack generation failed: ${e.message}. Run 'vibecheck ctx build' manually or 'vibecheck init --repair' to retry.`);
+    }
+  } else {
+    printSetupStep('truthpack.json', 'dry-run', 'would generate via vibecheck ctx build');
   }
   
   // 4. Generate contracts
+  logStep('Creating contracts');
   const contractsDir = path.join(vibecheckDir, "contracts");
   
   // Routes contract
@@ -769,9 +1418,13 @@ async function runLocalSetup(targetDir, projectName, opts, filesCreated) {
       routes: [],
       description: "Route contract - populated by scan",
     };
-    fs.writeFileSync(routeContractPath, JSON.stringify(routeContract, null, 2));
-    printSetupStep('routes.contract.json', 'success', 'route contract created');
-    filesCreated.push('.vibecheck/contracts/routes.contract.json');
+    if (opts.dryRun) {
+      printSetupStep('routes.contract.json', 'dry-run', 'would create');
+    } else {
+      fs.writeFileSync(routeContractPath, JSON.stringify(routeContract, null, 2));
+      printSetupStep('routes.contract.json', 'success', 'route contract created');
+      filesCreated.push('.vibecheck/contracts/routes.contract.json');
+    }
   }
   
   // Env contract
@@ -784,35 +1437,55 @@ async function runLocalSetup(targetDir, projectName, opts, filesCreated) {
       optional: [],
       description: "Environment contract - populated by scan",
     };
-    fs.writeFileSync(envContractPath, JSON.stringify(envContract, null, 2));
-    printSetupStep('env.contract.json', 'success', 'env contract created');
-    filesCreated.push('.vibecheck/contracts/env.contract.json');
+    if (opts.dryRun) {
+      printSetupStep('env.contract.json', 'dry-run', 'would create');
+    } else {
+      fs.writeFileSync(envContractPath, JSON.stringify(envContract, null, 2));
+      printSetupStep('env.contract.json', 'success', 'env contract created');
+      filesCreated.push('.vibecheck/contracts/env.contract.json');
+    }
   }
   
   // 5. Generate IDE rules (MDC for Cursor, rules for others)
-  startSpinner('Generating IDE rules...', colors.accent);
-  try {
-    const { runContext } = require("./runContext");
-    await runContext(["--path", targetDir, "--quiet"]);
-    stopSpinner('IDE rules generated', true);
-    filesCreated.push('.cursor/rules/', '.windsurf/', '.github/copilot-instructions.md');
-  } catch (e) {
-    stopSpinner('IDE rules skipped (run vibecheck context later)', false);
+  logStep('Generating IDE rules');
+  if (!opts.dryRun) {
+    startSpinner('Generating IDE rules...', colors.accent);
+    try {
+      const { runContext } = require("./runContext");
+      await runContext(["--path", targetDir, "--quiet"]);
+      stopSpinner('IDE rules generated', true);
+      filesCreated.push('.cursor/rules/', '.windsurf/', '.github/copilot-instructions.md');
+    } catch (e) {
+      stopSpinner('IDE rules generation failed', false);
+      if (!opts.json) {
+        console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${e.message}`);
+        console.log(`  ${c.dim}Run 'vibecheck context' manually to generate IDE rules${c.reset}`);
+      }
+      // Don't throw - IDE rules are optional
+    }
+  } else {
+    printSetupStep('IDE rules', 'dry-run', 'would generate via vibecheck context');
   }
   
   // 6. Create .vibecheckrc at project root
+  logStep('Creating root config');
   const rcPath = path.join(targetDir, ".vibecheckrc.json");
   if (!fs.existsSync(rcPath)) {
     const rc = {
       extends: ".vibecheck/config.json",
       tier: "free",
     };
-    fs.writeFileSync(rcPath, JSON.stringify(rc, null, 2));
-    printSetupStep('.vibecheckrc.json', 'success', 'root config created');
-    filesCreated.push('.vibecheckrc.json');
+    if (opts.dryRun) {
+      printSetupStep('.vibecheckrc.json', 'dry-run', 'would create');
+    } else {
+      fs.writeFileSync(rcPath, JSON.stringify(rc, null, 2));
+      printSetupStep('.vibecheckrc.json', 'success', 'root config created');
+      filesCreated.push('.vibecheckrc.json');
+    }
   }
   
   // 7. Update .gitignore
+  logStep('Updating .gitignore');
   const gitignorePath = path.join(targetDir, ".gitignore");
   if (fs.existsSync(gitignorePath)) {
     let gitignore = fs.readFileSync(gitignorePath, "utf-8");
@@ -822,9 +1495,13 @@ async function runLocalSetup(targetDir, projectName, opts, filesCreated) {
     if (!gitignore.includes(".vibecheck/checkpoints/")) additions.push(".vibecheck/checkpoints/");
     
     if (additions.length > 0) {
-      gitignore += `\n# vibecheck (generated outputs)\n${additions.join("\n")}\n`;
-      fs.writeFileSync(gitignorePath, gitignore);
-      printSetupStep('.gitignore', 'success', 'updated with vibecheck paths');
+      if (opts.dryRun) {
+        printSetupStep('.gitignore', 'dry-run', `would add: ${additions.join(', ')}`);
+      } else {
+        gitignore += `\n# vibecheck (generated outputs)\n${additions.join("\n")}\n`;
+        fs.writeFileSync(gitignorePath, gitignore);
+        printSetupStep('.gitignore', 'success', 'updated with vibecheck paths');
+      }
     }
   }
   
@@ -937,18 +1614,22 @@ async function runInit(args) {
 
   const targetDir = path.resolve(opts.path);
   const projectName = path.basename(targetDir);
+  let bannerPrinted = false;
 
   // Enterprise mode - comprehensive setup
   const useEnterprise = opts.enterprise || opts.ci || opts.compliance || 
                         opts.team || opts.mcp || opts.detect;
   
   if (EnterpriseInit && useEnterprise && !opts.local && !opts.connect) {
-    printBanner();
-    printEnterpriseHeader(opts);
-    
-    console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
-    console.log(`  ${c.dim}Path:${c.reset}     ${targetDir}`);
-    console.log();
+    if (!opts.json) {
+      printBanner();
+      bannerPrinted = true;
+      printEnterpriseHeader(opts);
+      
+      console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+      console.log(`  ${c.dim}Path:${c.reset}     ${targetDir}`);
+      console.log();
+    }
     
     const enterprise = new EnterpriseInit(targetDir, opts);
     return await enterprise.run();
@@ -956,10 +1637,12 @@ async function runInit(args) {
 
   // Detect-only mode (quick detection report)
   if (opts.detect) {
-    printBanner();
-    
-    console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
-    console.log(`  ${c.dim}Path:${c.reset}     ${targetDir}`);
+    if (!opts.json) {
+      printBanner();
+      bannerPrinted = true;
+      console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+      console.log(`  ${c.dim}Path:${c.reset}     ${targetDir}`);
+    }
     
     startSpinner('Detecting project configuration...', colors.accent);
     
@@ -967,9 +1650,11 @@ async function runInit(args) {
       const { detectAll } = require("./lib/enterprise-detect");
       const detection = detectAll(targetDir);
       stopSpinner('Detection complete', true);
-      printDetectionResults(detection);
-      console.log();
-      console.log(`  ${c.dim}Full JSON output:${c.reset}`);
+      if (!opts.json) {
+        printDetectionResults(detection);
+        console.log();
+        console.log(`  ${c.dim}Full JSON output:${c.reset}`);
+      }
       console.log(JSON.stringify(detection, null, 2));
     } catch (e) {
       stopSpinner('Detection failed', false);
@@ -982,8 +1667,32 @@ async function runInit(args) {
   // NEW: --local and --connect modes
   // ═══════════════════════════════════════════════════════════════════════════
   
-  if (!opts.json) {
+  // Interactive wizard mode
+  if (opts.wizard && InitWizard) {
+    if (!opts.json && !bannerPrinted) {
+      printBanner();
+    }
+    const wizard = new InitWizard(targetDir, opts);
+    return await wizard.run();
+  }
+  
+  // Repair mode - fix partial state
+  if (opts.repair) {
+    if (!opts.json && !bannerPrinted) {
+      printBanner();
+      bannerPrinted = true;
+      console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+      console.log(`  ${c.dim}Path:${c.reset}     ${targetDir}`);
+      console.log(`  ${c.dim}Mode:${c.reset}     ${colors.accent}Repair${c.reset}`);
+      console.log();
+    }
+    return await runRepairMode(targetDir, projectName, opts);
+  }
+  
+  // Print banner only once (not already printed in enterprise/detect modes)
+  if (!opts.json && !bannerPrinted) {
     printBanner();
+    bannerPrinted = true;
     
     const mode = opts.connect ? 'Local + Connect' : 'Local';
     const tierBadge = opts.connect ? `${c.cyan}[STARTER]${c.reset}` : `${c.green}[FREE]${c.reset}`;
@@ -991,6 +1700,9 @@ async function runInit(args) {
     console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
     console.log(`  ${c.dim}Path:${c.reset}     ${targetDir}`);
     console.log(`  ${c.dim}Mode:${c.reset}     ${colors.accent}${mode}${c.reset} ${tierBadge}`);
+    if (opts.dryRun) {
+      console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${c.bold}DRY-RUN MODE${c.reset} - No files will be created`);
+    }
   }
   
   let filesCreated = [];
@@ -1001,6 +1713,7 @@ async function runInit(args) {
     mode: opts.connect ? 'connect' : 'local',
     filesCreated: [],
     errors: [],
+    dryRun: opts.dryRun,
   };
   
   // Always run local setup first
@@ -1008,9 +1721,16 @@ async function runInit(args) {
     try {
       filesCreated = await runLocalSetup(targetDir, projectName, opts, filesCreated);
     } catch (e) {
-      result.errors.push({ step: 'local', error: e.message });
+      result.errors.push({ step: 'local', error: e.message, stack: e.stack });
       if (!opts.json) {
         console.log(`  ${colors.error}${ICONS.cross}${c.reset} Local setup error: ${e.message}`);
+        if (opts.verbose) {
+          console.log(`  ${c.dim}Stack: ${e.stack}${c.reset}`);
+        }
+        console.log(`  ${colors.info}${ICONS.info}${c.reset} Run ${c.cyan}vibecheck init --repair${c.reset} to fix partial state`);
+      }
+      if (!opts.dryRun) {
+        return 1; // Exit on error unless dry-run
       }
     }
   }
@@ -1020,9 +1740,15 @@ async function runInit(args) {
     try {
       filesCreated = await runConnectSetup(targetDir, projectName, opts, filesCreated);
     } catch (e) {
-      result.errors.push({ step: 'connect', error: e.message });
+      result.errors.push({ step: 'connect', error: e.message, stack: e.stack });
       if (!opts.json) {
         console.log(`  ${colors.error}${ICONS.cross}${c.reset} Connect setup error: ${e.message}`);
+        if (opts.verbose) {
+          console.log(`  ${c.dim}Stack: ${e.stack}${c.reset}`);
+        }
+      }
+      if (!opts.dryRun) {
+        return 1;
       }
     }
   }
@@ -1063,6 +1789,31 @@ fi
   const mode = opts.connect ? 'Local + Connect' : 'Local Setup';
   printSuccessCard(projectName, mode, filesCreated.length);
   
+  // Generate dependency graph
+  if (!opts.dryRun) {
+    if (!opts.json) {
+      startSpinner('Generating dependency graph...', colors.accent);
+    }
+    try {
+      const { buildDependencyGraph, generateHtmlVisualization } = require("./context/dependency-graph");
+      const depGraph = buildDependencyGraph(targetDir);
+      const htmlViz = generateHtmlVisualization(depGraph, { maxNodes: 200 });
+      const graphPath = path.join(targetDir, ".vibecheck", "dependency-graph.html");
+      fs.writeFileSync(graphPath, htmlViz);
+      filesCreated.push('.vibecheck/dependency-graph.html');
+      if (!opts.json) {
+        stopSpinner('Dependency graph generated', true);
+      }
+    } catch (e) {
+      if (!opts.json) {
+        stopSpinner('Dependency graph skipped', false);
+        console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${e.message}`);
+      }
+    }
+  } else {
+    printSetupStep('dependency-graph.html', 'dry-run', 'would generate');
+  }
+  
   // Init summary
   printSection('INIT SUMMARY', ICONS.check);
   console.log();
@@ -1070,11 +1821,52 @@ fi
   console.log(`  ${colors.success}${ICONS.check}${c.reset} Truthpack generated`);
   console.log(`  ${colors.success}${ICONS.check}${c.reset} Contracts initialized`);
   console.log(`  ${colors.success}${ICONS.check}${c.reset} IDE rules generated`);
+  console.log(`  ${colors.success}${ICONS.check}${c.reset} Dependency graph generated`);
   if (opts.connect) {
     console.log(`  ${colors.success}${ICONS.check}${c.reset} GitHub Actions workflows installed`);
   }
   console.log();
   
+  // Show dependency graph location
+  const graphPath = path.join(targetDir, ".vibecheck", "dependency-graph.html");
+  if (fs.existsSync(graphPath)) {
+    console.log(`  ${colors.info}${ICONS.info}${c.reset} ${c.bold}Dependency Graph:${c.reset}`);
+    console.log(`     ${c.cyan}file://${graphPath.replace(/\\/g, '/')}${c.reset}`);
+    console.log();
+  }
+  
+  // Save init state for repair mode
+  if (!opts.dryRun) {
+    saveInitState(targetDir, {
+      timestamp: new Date().toISOString(),
+      mode: opts.connect ? 'connect' : 'local',
+      filesCreated,
+      errors: result.errors,
+      detection: detection ? {
+        frameworks: Object.keys(detection.frameworks || {}).filter(k => detection.frameworks[k].detected),
+        checks: detection.checks || [],
+      } : null,
+    });
+  }
+  
+  // Post-init validation
+  if (opts.verify && !opts.dryRun) {
+    const validationResult = await verifyInitSetup(targetDir, opts);
+    if (!validationResult.success && !opts.json) {
+      console.log();
+      console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${c.bold}Validation Issues Found:${c.reset}`);
+      for (const issue of validationResult.issues) {
+        console.log(`     ${c.dim}•${c.reset} ${issue}`);
+      }
+      console.log();
+    }
+  }
+  
+  // Framework-specific recommendations
+  if (detection && !opts.json && !opts.dryRun) {
+    printFrameworkRecommendations(detection, opts);
+  }
+  
   // Next steps
   printNextSteps({ hasCI: opts.connect, mode: opts.connect ? 'connect' : 'local' });