@vibecheckai/cli 3.5.1 → 3.5.3

package/bin/runners/runContext.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Type declarations for runContext.js
+ */
+export function runContext(args: string[]): Promise<number>;

package/bin/runners/runContext.js

@@ -1,22 +1,39 @@
 /**
  * runContext.js - AI Rules Generator
  * 
- * Generates .cursorrules, .windsurf/rules, and other AI context files.
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * World-Class AI Context Generation
+ * ═══════════════════════════════════════════════════════════════════════════════
  */
 
 const path = require("path");
+const fs = require("fs");
 const { runContext: contextRunner } = require("./context");
-const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
+const { parseGlobalFlags, shouldShowBanner, shouldSuppressOutput, isJsonMode } = require("./lib/global-flags");
+const { EXIT } = require("./lib/exit-codes");
+const {
+  ansi,
+  sym,
+  renderMinimalHeader,
+  renderSectionHeader,
+  renderSuccess,
+  renderError,
+  renderBullet,
+  renderFooter,
+  Spinner,
+  getTierFromKey,
+} = require("./lib/unified-cli-output");
 
 async function runContext(args) {
-  // Parse global flags first
   const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
-  
+  const quiet = shouldSuppressOutput(globalFlags);
+  const json = isJsonMode(globalFlags);
   const root = globalFlags.path || process.cwd();
+  const startTime = Date.now();
   
   // Parse command-specific args
   const opts = {
-    ...globalFlags, // Merge global flags (includes help, json, noBanner, etc.)
+    ...globalFlags,
     output: null,
     format: "all"
   };
@@ -29,34 +46,129 @@ async function runContext(args) {
   }
   
   if (opts.help) {
-    const banner = shouldShowBanner(opts) ? `
-  ${require('./lib/global-flags').BANNER || ''}
-` : '';
-    console.log(`${banner}
-vibecheck context - Generate AI rules files
-
-USAGE
-  vibecheck context              Generate all AI rules files
-  vibecheck context --format X   Generate specific format (cursor, windsurf, all)
-
-OPTIONS
-  -o, --output <dir>    Output directory (default: project root)
-  -f, --format <fmt>    Format: cursor, windsurf, all (default: all)
-  -h, --help            Show this help
+    console.log(`
+  ${ansi.bold}USAGE${ansi.reset}
+    ${ansi.cyan}vibecheck context${ansi.reset} [options]
+
+  ${ansi.dim}Aliases: rules, ai-rules, mdc${ansi.reset}
+
+  Generate project-aware AI coding rules for your IDE. These rules help
+  AI assistants understand your codebase conventions, preventing common
+  mistakes and enforcing patterns.
+
+  ${ansi.bold}FORMATS${ansi.reset}
+    ${ansi.cyan}cursor${ansi.reset}      .cursorrules file for Cursor IDE
+    ${ansi.cyan}mdc${ansi.reset}         MDC format (.cursor/rules/*.mdc)
+    ${ansi.cyan}windsurf${ansi.reset}    Windsurf rules directory
+    ${ansi.cyan}copilot${ansi.reset}     GitHub Copilot instructions
+    ${ansi.cyan}all${ansi.reset}         Generate all formats (default)
+
+  ${ansi.bold}OPTIONS${ansi.reset}
+    ${ansi.cyan}-f, --format <fmt>${ansi.reset}   Format to generate (default: all)
+    ${ansi.cyan}-o, --output <dir>${ansi.reset}   Output directory (default: project root)
+    ${ansi.cyan}--json${ansi.reset}               Output result as JSON
+    ${ansi.cyan}--quiet, -q${ansi.reset}          Suppress non-essential output
+    ${ansi.cyan}--help, -h${ansi.reset}           Show this help
+
+  ${ansi.bold}EXAMPLES${ansi.reset}
+    ${ansi.dim}# Generate all rule files${ansi.reset}
+    vibecheck context
+
+    ${ansi.dim}# Generate only Cursor rules${ansi.reset}
+    vibecheck context --format cursor
+
+    ${ansi.dim}# Custom output directory${ansi.reset}
+    vibecheck context --output ./ai-rules
+
+  ${ansi.bold}OUTPUT FILES${ansi.reset}
+    .cursorrules              Cursor IDE rules
+    .cursor/rules/*.mdc       MDC format rules
+    .windsurf/rules/*.md      Windsurf rules
+    .github/copilot-instructions.md
+
+  ${ansi.dim}────────────────────────────────────────────────────────────────────${ansi.reset}
+  ${ansi.dim}Documentation: https://docs.vibecheckai.dev/cli/context${ansi.reset}
 `);
-    return 0;
+    return EXIT.SUCCESS;
+  }
+  
+  // Validate project path exists
+  if (!fs.existsSync(root)) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: `Project path does not exist: ${root}` }));
+    } else {
+      renderError(`Project path does not exist: ${root}`);
+      console.log(`  ${ansi.dim}Verify the path and try again.${ansi.reset}`);
+    }
+    return EXIT.NOT_FOUND;
+  }
+  
+  // Validate format option
+  const validFormats = ["all", "cursor", "mdc", "windsurf", "copilot"];
+  if (!validFormats.includes(opts.format)) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: `Unknown format: ${opts.format}`, validFormats }));
+    } else {
+      renderError(`Unknown format: ${opts.format}`);
+      console.log(`  ${ansi.dim}Valid formats: ${validFormats.join(", ")}${ansi.reset}`);
+    }
+    return EXIT.USER_ERROR;
   }
   
   try {
-    await contextRunner({
+    if (!quiet && !json) {
+      renderMinimalHeader("context", "starter");
+      renderSectionHeader("Generating AI Rules", sym.gear);
+    }
+    
+    const spinner = !quiet && !json ? new Spinner(`Analyzing project and generating ${opts.format} rules`).start() : null;
+    
+    const result = await contextRunner({
       repoRoot: root,
       output: opts.output,
       format: opts.format
     });
-    return 0;
+    
+    const duration = Date.now() - startTime;
+    
+    if (json) {
+      console.log(JSON.stringify({ 
+        success: true, 
+        format: opts.format,
+        files: result?.files || [],
+        path: root,
+        duration,
+      }));
+    } else if (!quiet) {
+      spinner?.succeed("AI rules generated successfully");
+      
+      // Show generated files
+      if (result?.files && result.files.length > 0) {
+        console.log();
+        console.log(`  ${ansi.bold}Generated files:${ansi.reset}`);
+        result.files.forEach(f => {
+          renderBullet(`${ansi.cyan}${f}${ansi.reset}`, 4);
+        });
+      }
+      
+      renderFooter({
+        nextSteps: [
+          { cmd: "vibecheck scan", desc: "analyze code quality" },
+          { cmd: "vibecheck guard", desc: "validate AI outputs" },
+        ],
+        docsUrl: "https://docs.vibecheckai.dev/cli/context",
+      });
+    }
+    
+    return EXIT.SUCCESS;
   } catch (error) {
-    console.error("Error generating context:", error.message);
-    return 1;
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: error.message }));
+    } else {
+      renderError(`Failed to generate context: ${error.message}`);
+      console.log(`  ${ansi.dim}Run "vibecheck doctor" to check your setup.${ansi.reset}`);
+    }
+    return EXIT.INTERNAL_ERROR;
   }
 }
 

package/bin/runners/runDoctor.js

@@ -18,7 +18,10 @@ const {
   verdictToExitCode,
   saveArtifact 
 } = require("./lib/cli-output");
-const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
+const { parseGlobalFlags, shouldShowBanner, shouldSuppressOutput, isJsonMode } = require("./lib/global-flags");
+const { EXIT } = require("./lib/exit-codes");
+const { formatWorkflowUpsell } = require("./lib/upsell");
+const { getApiKey } = require("./lib/auth");
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // ADVANCED TERMINAL - ANSI CODES & UTILITIES
@@ -298,86 +301,110 @@ async function runDoctor(args, context = {}) {
   const startTime = context.startTime || new Date().toISOString();
   
   const opts = parseArgs(args);
+  const quiet = shouldSuppressOutput(opts);
+  const json = isJsonMode(opts);
   const executionStart = Date.now();
   
   if (opts.help) {
     printHelp(shouldShowBanner(opts));
-    return 0;
+    return EXIT.SUCCESS;
   }
 
   const projectPath = path.resolve(opts.path || process.cwd());
-  const projectName = path.basename(projectPath);
   
-  // Print banner conditionally
-  if (shouldShowBanner(opts)) {
-    printBanner();
-    console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
-    console.log(`  ${c.dim}Path:${c.reset}     ${projectPath}`);
-    console.log();
+  // Validate project path exists
+  if (!fs.existsSync(projectPath)) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: `Project path does not exist: ${projectPath}` }));
+    } else {
+      console.error(`  ❌ Project path does not exist: ${projectPath}`);
+    }
+    return EXIT.NOT_FOUND;
   }
+  const projectName = path.basename(projectPath);
   
-  // Use new DoctorService if available
-  if (DoctorService.name === 'DoctorService') {
-    const doctor = new DoctorService(projectPath, {
-      json: opts.json,
-      fix: opts.fix,
-      fixDryRun: opts.dryRun,
-      quiet: opts.quiet,
-      verbose: opts.verbose,
-      categories: opts.categories,
-      skipNetwork: opts.skipNetwork,
-      saveReport: opts.saveReport,
-      failOnWarn: opts.failOnWarn,
-      runId,
-    });
-    
-    const results = await doctor.run();
+  try {
+    // Print banner conditionally
+    if (shouldShowBanner(opts) && !quiet) {
+      printBanner();
+      console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+      console.log(`  ${c.dim}Path:${c.reset}     ${projectPath}`);
+      console.log();
+    }
     
-    // Apply CLI output conventions
-    if (opts.json) {
-      const output = createJsonOutput({
+    // Use new DoctorService if available
+    if (DoctorService.name === 'DoctorService') {
+      const doctor = new DoctorService(projectPath, {
+        json: opts.json,
+        fix: opts.fix,
+        fixDryRun: opts.dryRun,
+        quiet: opts.quiet || quiet,
+        verbose: opts.verbose,
+        categories: opts.categories,
+        skipNetwork: opts.skipNetwork,
+        saveReport: opts.saveReport,
+        failOnWarn: opts.failOnWarn,
         runId,
-        command: "doctor",
-        startTime,
-        exitCode: results.exitCode || 0,
-        verdict: exitCodeToVerdict(results.exitCode || 0),
-        result: {
-          health: results.health || "unknown",
-          checks: results.checks || [],
-          fixes: results.fixes || [],
-          summary: {
-            total: results.totalChecks || 0,
-            passed: results.passedChecks || 0,
-            warnings: results.warnings || 0,
-            errors: results.errors || 0,
-          }
-        },
-        tier: "free",
-        version: require("../../package.json").version,
-        artifacts: results.reportPath ? [{
-          type: "report",
-          path: results.reportPath,
-          description: "Doctor report"
-        }] : []
       });
       
-      writeJsonOutput(output, opts.output);
+      const results = await doctor.run();
+      
+      // Apply CLI output conventions
+      if (opts.json || json) {
+        const output = createJsonOutput({
+          runId,
+          command: "doctor",
+          startTime,
+          exitCode: results.exitCode || EXIT.SUCCESS,
+          verdict: exitCodeToVerdict(results.exitCode || EXIT.SUCCESS),
+          result: {
+            health: results.health || "unknown",
+            checks: results.checks || [],
+            fixes: results.fixes || [],
+            summary: {
+              total: results.totalChecks || 0,
+              passed: results.passedChecks || 0,
+              warnings: results.warnings || 0,
+              errors: results.errors || 0,
+            }
+          },
+          tier: "free",
+          version: require("../../package.json").version,
+          artifacts: results.reportPath ? [{
+            type: "report",
+            path: results.reportPath,
+            description: "Doctor report"
+          }] : []
+        });
+        
+        writeJsonOutput(output, opts.output);
+      }
+      
+      // Save artifacts
+      if (results.checks) {
+        saveArtifact(runId, "checks", results.checks);
+      }
+      if (results.fixes) {
+        saveArtifact(runId, "fixes", results.fixes);
+      }
+      
+      // Map results to proper exit codes
+      if (results.errors > 0) return EXIT.BLOCKING;
+      if (results.warnings > 0) return EXIT.WARNINGS;
+      return EXIT.SUCCESS;
     }
     
-    // Save artifacts
-    if (results.checks) {
-      saveArtifact(runId, "checks", results.checks);
-    }
-    if (results.fixes) {
-      saveArtifact(runId, "fixes", results.fixes);
+    // Legacy fallback
+    const doctor = new DoctorService(projectPath, opts);
+    return await doctor.diagnose();
+  } catch (error) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: error.message }));
+    } else {
+      console.error(`  ❌ Doctor check failed: ${error.message}`);
     }
-    
-    return results.exitCode || 0;
+    return EXIT.INTERNAL_ERROR;
   }
-  
-  // Legacy fallback
-  const doctor = new DoctorService(projectPath, opts);
-  return await doctor.diagnose();
 }
 
 function parseArgs(args) {
@@ -573,12 +600,33 @@ function runDoctorLegacy() {
   }
 
   console.log("");
+  
+  // Get tier for upsell
+  const { key } = getApiKey();
+  const currentTier = key ? "starter" : "free";
+  
   if (hasIssues) {
-    console.log("  ❌ Issues found. Fix them and run doctor again.\n");
-    return 2;
+    console.log("  ❌ Issues found. Fix them and run doctor again.");
+    console.log();
+    console.log(`  ${c.dim}Need help?${c.reset} ${colors.accent}vibecheck fix${c.reset} ${c.dim}can auto-repair many issues${c.reset}`);
+    if (currentTier === "free") {
+      console.log(`  ${c.dim}Requires STARTER plan • vibecheckai.dev${c.reset}`);
+    }
+    console.log();
+    return EXIT.BLOCKING;
   } else {
-    console.log("  ✅ Environment healthy!\n");
-    return 0;
+    console.log("  ✅ Environment healthy!");
+    console.log();
+    
+    // Workflow upsell
+    const workflow = formatWorkflowUpsell("doctor", currentTier);
+    if (workflow) {
+      console.log(`  ${workflow}`);
+    } else {
+      console.log(`  ${c.dim}Ready to scan?${c.reset} ${colors.accent}vibecheck scan${c.reset} ${c.dim}finds AI mistakes before they ship${c.reset}`);
+    }
+    console.log();
+    return EXIT.SUCCESS;
   }
 }