@vibecheckai/cli 3.1.4 → 3.1.6

package/bin/registry.js

@@ -86,7 +86,7 @@ const COMMANDS = {
     description: "Verdict engine - SHIP / WARN / BLOCK", 
     tier: "free", 
     category: "proof", 
-    aliases: ["verdict"], 
+    aliases: ["verdict", "go"], 
     caps: "static-only on FREE", 
     runner: () => require("./runners/runShip").runShip 
   },

package/bin/runners/ENHANCEMENT_GUIDE.md

@@ -0,0 +1,121 @@
+# Command Enhancement Guide
+
+This guide shows how to apply the enhancements from `vibecheck.js` to all command runners.
+
+## 1. Add Global Flags Support
+
+### Import the utilities:
+```javascript
+const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
+```
+
+### Update parseArgs function:
+```javascript
+function parseArgs(args) {
+  // Parse global flags first
+  const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
+  
+  const opts = {
+    // ... existing options
+    path: globalFlags.path || process.cwd(),
+    json: globalFlags.json || false,
+    verbose: globalFlags.verbose || false,
+    help: globalFlags.help || false,
+    noBanner: globalFlags.noBanner || false,
+    ci: globalFlags.ci || false,
+    quiet: globalFlags.quiet || false,
+  };
+  
+  // Parse command-specific args from cleanArgs
+  for (let i = 0; i < cleanArgs.length; i++) {
+    const a = cleanArgs[i];
+    // ... command-specific parsing
+  }
+  
+  return opts;
+}
+```
+
+## 2. Update Banner Printing
+
+### Update printHelp:
+```javascript
+function printHelp(showBanner = true) {
+  if (showBanner && shouldShowBanner({})) {
+    console.log(BANNER);
+  }
+  // ... rest of help
+}
+```
+
+### Update banner printing in main function:
+```javascript
+async function runCommand(args) {
+  const opts = parseArgs(args);
+  
+  if (opts.help) {
+    printHelp(shouldShowBanner(opts));
+    return 0;
+  }
+  
+  // Print banner (respects --no-banner, VIBECHECK_NO_BANNER, --ci, --quiet, --json)
+  if (shouldShowBanner(opts)) {
+    printBanner();
+  }
+  
+  // ... rest of command
+}
+```
+
+## 3. Add Aliases to Help Text
+
+Update help text to show aliases:
+```javascript
+function printHelp(showBanner = true) {
+  // ...
+  console.log(`
+  ${ansi.bold}Usage:${ansi.reset} vibecheck command ${ansi.dim}(alias1, alias2)${ansi.reset} [options]
+  
+  ${ansi.bold}Aliases:${ansi.reset} ${ansi.dim}alias1, alias2${ansi.reset}
+  `);
+}
+```
+
+## 4. Lazy Loading (Optional)
+
+For commands that load heavy modules, use lazy loading:
+```javascript
+const { lazy } = require("./lib/global-flags");
+
+const getHeavyModule = lazy("heavy-module", () => require("./lib/heavy-module"));
+
+// Use later:
+const heavyModule = getHeavyModule();
+```
+
+## Commands Updated
+
+✅ `runScan.js` - Full support for --no-banner, global flags, aliases in help
+✅ `runShip.js` - Full support for --no-banner, global flags, aliases in help  
+✅ `runReport.js` - Full support for --no-banner, global flags
+✅ `runInit.js` - Already enhanced with all features
+
+## Commands Pending
+
+- `runStatus.js` - No banner, but should support global flags
+- `runFix.js` - Needs banner support
+- `runProve.js` - Needs banner support
+- `runContext.js` - Needs banner support
+- `runCtx.js` - Needs banner support
+- All other commands - Apply same pattern
+
+## Testing Checklist
+
+For each command:
+- [ ] `command --no-banner` suppresses banner
+- [ ] `VIBECHECK_NO_BANNER=true command` suppresses banner
+- [ ] `command --ci` suppresses banner
+- [ ] `command --quiet` suppresses banner
+- [ ] `command --json` suppresses banner
+- [ ] `command --help` shows aliases (if any)
+- [ ] Global flags (--path, --output, --verbose) work correctly

package/bin/runners/lib/global-flags.js

@@ -0,0 +1,213 @@
+/**
+ * Global Flags Parser & Utilities
+ * Shared utilities for all commands to handle global flags consistently
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// LAZY LOADING - Defer requires until needed
+// ═══════════════════════════════════════════════════════════════════════════════
+const lazyModules = {};
+
+function lazy(name, loader) {
+  return () => {
+    if (!lazyModules[name]) {
+      lazyModules[name] = loader();
+    }
+    return lazyModules[name];
+  };
+}
+
+const getOs = lazy("os", () => require("os"));
+const getPath = lazy("path", () => require("path"));
+const getFs = lazy("fs", () => require("fs"));
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// GLOBAL FLAGS PARSER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Parse global flags from command arguments
+ * Extracts global flags and returns clean args for command-specific parsing
+ */
+function parseGlobalFlags(rawArgs) {
+  const flags = {
+    help: false,
+    version: false,
+    json: false,
+    ci: false,
+    quiet: false,
+    verbose: false,
+    debug: false,
+    strict: false,
+    noBanner: false,
+    path: process.cwd(),
+    output: null,
+  };
+
+  const cleanArgs = [];
+  let i = 0;
+
+  while (i < rawArgs.length) {
+    const arg = rawArgs[i];
+
+    switch (arg) {
+      case "--help":
+      case "-h":
+        flags.help = true;
+        break;
+      case "--version":
+      case "-v":
+        flags.version = true;
+        break;
+      case "--json":
+        flags.json = true;
+        break;
+      case "--ci":
+        flags.ci = true;
+        flags.noBanner = true; // CI mode automatically suppresses banner
+        break;
+      case "--quiet":
+      case "-q":
+        flags.quiet = true;
+        flags.noBanner = true; // Quiet mode also suppresses banner
+        break;
+      case "--verbose":
+        flags.verbose = true;
+        break;
+      case "--debug":
+        flags.debug = true;
+        break;
+      case "--strict":
+        flags.strict = true;
+        break;
+      case "--no-banner":
+        flags.noBanner = true;
+        break;
+      case "--path":
+      case "-p":
+        flags.path = rawArgs[++i] || process.cwd();
+        break;
+      case "--output":
+      case "-o":
+        flags.output = rawArgs[++i] || null;
+        break;
+      default:
+        if (arg.startsWith("--path=")) {
+          flags.path = arg.split("=")[1];
+        } else if (arg.startsWith("--output=")) {
+          flags.output = arg.split("=")[1];
+        } else {
+          cleanArgs.push(arg);
+        }
+    }
+    i++;
+  }
+
+  return { flags, cleanArgs };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// BANNER CHECKING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Check if banner should be shown
+ * Respects --no-banner flag, VIBECHECK_NO_BANNER env var, and VIBECHECK_QUIET
+ */
+function shouldShowBanner(flags = {}) {
+  // Check environment variables first
+  if (process.env.VIBECHECK_NO_BANNER === "true") return false;
+  if (process.env.VIBECHECK_QUIET === "true") return false;
+  
+  // Check flags
+  if (flags.noBanner === true) return false;
+  if (flags.ci === true) return false;
+  if (flags.quiet === true) return false;
+  if (flags.json === true) return false; // JSON output shouldn't have banners
+  
+  return true;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CI DETECTION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Check if running in CI environment
+ */
+function isCI() {
+  return !!(
+    process.env.CI ||
+    process.env.CONTINUOUS_INTEGRATION ||
+    process.env.BUILD_NUMBER ||
+    process.env.TRAVIS ||
+    process.env.CIRCLECI ||
+    process.env.JENKINS_URL ||
+    process.env.GITLAB_CI ||
+    process.env.GITHUB_ACTIONS ||
+    process.env.BUILDKITE ||
+    process.env.TEAMCITY_VERSION ||
+    process.env.TF_BUILD
+  );
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONFIG LOADING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Load config with environment variable support
+ */
+function loadConfig(flags = {}) {
+  const path = getPath();
+  const fs = getFs();
+  
+  const config = {
+    debug: false,
+    verbose: false,
+    quiet: false,
+    color: true,
+    analytics: true,
+    updateCheck: true,
+    timeout: 30000,
+    maxRetries: 3,
+    noBanner: false,
+  };
+
+  // Load project config if exists
+  const projectConfigPath = path.join(process.cwd(), ".vibecheckrc.json");
+  if (fs.existsSync(projectConfigPath)) {
+    try {
+      Object.assign(config, JSON.parse(fs.readFileSync(projectConfigPath, "utf-8")));
+    } catch {
+      // Ignore invalid config
+    }
+  }
+
+  // Environment overrides
+  if (process.env.VIBECHECK_DEBUG === "true") config.debug = true;
+  if (process.env.VIBECHECK_VERBOSE === "true") config.verbose = true;
+  if (process.env.VIBECHECK_QUIET === "true") config.quiet = true;
+  if (process.env.VIBECHECK_NO_BANNER === "true") config.noBanner = true;
+  if (process.env.NO_COLOR || process.env.VIBECHECK_NO_COLOR) config.color = false;
+
+  // Flag overrides (highest priority)
+  if (flags.debug) config.debug = true;
+  if (flags.verbose) config.verbose = true;
+  if (flags.quiet) config.quiet = true;
+  if (flags.noBanner) config.noBanner = true;
+  if (flags.ci) config.noBanner = true;
+
+  return config;
+}
+
+module.exports = {
+  parseGlobalFlags,
+  shouldShowBanner,
+  isCI,
+  loadConfig,
+  lazy,
+  getOs,
+  getPath,
+  getFs,
+};