@vibecheckai/cli 3.0.10 → 3.1.0

package/bin/runners/lib/usage.js

@@ -0,0 +1,153 @@
+/**
+ * Usage Logger - Track metered units per command
+ * 
+ * Records usage for monetization and billing.
+ * All paid commands must log their usage.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// USAGE LOGGING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function getUsageLogPath() {
+  const home = os.homedir();
+  const vibecheckDir = path.join(home, ".vibecheck");
+  const usageDir = path.join(vibecheckDir, "usage");
+  
+  // Ensure directories exist
+  if (!fs.existsSync(vibecheckDir)) fs.mkdirSync(vibecheckDir, { recursive: true });
+  if (!fs.existsSync(usageDir)) fs.mkdirSync(usageDir, { recursive: true });
+  
+  return path.join(usageDir, "usage.jsonl");
+}
+
+/**
+ * Log usage for a command run
+ * @param {Object} usage - Usage data
+ * @param {string} usage.runId - Unique run identifier
+ * @param {string} usage.command - Command name
+ * @param {string} usage.tier - User tier (free/pro/complete)
+ * @param {Object} usage.units - Units consumed
+ * @param {number} usage.units.pages - Pages crawled (reality)
+ * @param {number} usage.units.clicks - UI interactions (reality)
+ * @param {number} usage.units.endpoints - API endpoints tested (permissions)
+ * @param {number} usage.units.roles - Roles tested (permissions)
+ * @param {number} usage.units.files - Files modified (fix)
+ * @param {number} usage.units.hunks - Hunks applied (fix)
+ * @param {number} usage.units.exports - Reports generated
+ * @param {string} usage.timestamp - ISO timestamp
+ * @param {string} usage.projectPath - Project directory
+ */
+function logUsage(usage) {
+  const logPath = getUsageLogPath();
+  const entry = {
+    ...usage,
+    timestamp: usage.timestamp || new Date().toISOString(),
+    hostname: os.hostname(),
+    platform: process.platform,
+    nodeVersion: process.version,
+  };
+  
+  // Append to log file (JSONL format - one JSON per line)
+  const line = JSON.stringify(entry) + "\n";
+  fs.appendFileSync(logPath, line);
+  
+  // Also store in run-specific directory for receipts
+  if (usage.runId) {
+    const runDir = path.join(process.cwd(), ".vibecheck", "runs", usage.runId);
+    if (fs.existsSync(runDir)) {
+      fs.writeFileSync(path.join(runDir, "usage.json"), JSON.stringify(entry, null, 2));
+    }
+  }
+  
+  return entry;
+}
+
+/**
+ * Get usage statistics for a time period
+ * @param {Object} options - Query options
+ * @param {string} options.since - ISO date to start from
+ * @param {string} options.until - ISO date to end at
+ * @param {string} options.command - Filter by command
+ * @param {string} options.tier - Filter by tier
+ * @returns {Array} Array of usage entries
+ */
+function getUsage(options = {}) {
+  const logPath = getUsageLogPath();
+  
+  if (!fs.existsSync(logPath)) return [];
+  
+  const lines = fs.readFileSync(logPath, "utf8").split("\n").filter(Boolean);
+  const entries = lines.map(line => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+  
+  // Apply filters
+  let filtered = entries;
+  
+  if (options.since) {
+    filtered = filtered.filter(e => e.timestamp >= options.since);
+  }
+  
+  if (options.until) {
+    filtered = filtered.filter(e => e.timestamp <= options.until);
+  }
+  
+  if (options.command) {
+    filtered = filtered.filter(e => e.command === options.command);
+  }
+  
+  if (options.tier) {
+    filtered = filtered.filter(e => e.tier === options.tier);
+  }
+  
+  return filtered;
+}
+
+/**
+ * Get aggregate usage by unit type
+ * @param {Object} options - Query options (same as getUsage)
+ * @returns {Object} Aggregated totals
+ */
+function getUsageTotals(options = {}) {
+  const entries = getUsage(options);
+  const totals = {
+    runs: entries.length,
+    pages: 0,
+    clicks: 0,
+    endpoints: 0,
+    roles: 0,
+    files: 0,
+    hunks: 0,
+    exports: 0,
+  };
+  
+  for (const entry of entries) {
+    if (entry.units) {
+      totals.pages += entry.units.pages || 0;
+      totals.clicks += entry.units.clicks || 0;
+      totals.endpoints += entry.units.endpoints || 0;
+      totals.roles += entry.units.roles || 0;
+      totals.files += entry.units.files || 0;
+      totals.hunks += entry.units.hunks || 0;
+      totals.exports += entry.units.exports || 0;
+    }
+  }
+  
+  return totals;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+module.exports = {
+  logUsage,
+  getUsage,
+  getUsageTotals,
+};

package/bin/runners/runBadge.js

@@ -12,6 +12,9 @@
 const fs = require("fs");
 const path = require("path");
 
+const upsell = require("./lib/upsell");
+const entitlements = require("./lib/entitlements-v2");
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // ADVANCED TERMINAL - ANSI CODES & UTILITIES
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -726,7 +729,7 @@ function printHelp() {
 // MAIN BADGE FUNCTION
 // ═══════════════════════════════════════════════════════════════════════════════
 
-async function runBadge(args) {
+async function runBadge(args, context = {}) {
   const opts = parseArgs(args);
 
   if (opts.help) {
@@ -740,10 +743,15 @@ async function runBadge(args) {
     return 0;
   }
 
+  // Get current tier for policy enforcement
+  const authInfo = context.authInfo || {};
+  const tier = authInfo.access?.tier || await entitlements.getTier({ apiKey: authInfo.key });
+
   // Load last scan result
   let verdict = opts.verdict || 'SHIP';
   let score = opts.score || 100;
   let stats = { blockers: 0, warnings: 0 };
+  let findings = [];
 
   const lastScanPath = path.join(process.cwd(), '.vibecheck', 'last_scan.json');
   const lastShipPath = path.join(process.cwd(), '.vibecheck', 'last_ship.json');
@@ -755,11 +763,12 @@ async function runBadge(args) {
     if (fs.existsSync(reportPath)) {
       try {
         const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
-        verdict = report.verdict || 'SHIP';
+        verdict = report.verdict || report.meta?.verdict || 'SHIP';
+        findings = report.findings || [];
         score = report.score ?? report.vibeScore ?? 100;
         stats = {
-          blockers: report.counts?.BLOCK || report.findings?.filter(f => f.severity === 'BLOCK').length || 0,
-          warnings: report.counts?.WARN || report.findings?.filter(f => f.severity === 'WARN').length || 0,
+          blockers: report.counts?.BLOCK || findings.filter(f => f.severity === 'BLOCK').length || 0,
+          warnings: report.counts?.WARN || findings.filter(f => f.severity === 'WARN').length || 0,
         };
       } catch (e) {
         // Use defaults
@@ -767,6 +776,24 @@ async function runBadge(args) {
     }
   }
 
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // BADGE POLICY ENFORCEMENT - SHIP ONLY
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // Badge is only generated when:
+  // 1. User has STARTER+ tier (enforced at CLI level)
+  // 2. Last verdict = SHIP
+  // 
+  // If verdict != SHIP, show withheld message with top issues
+  if (verdict !== 'SHIP' && !opts.verdict) {
+    console.log(BANNER_FULL);
+    
+    // Show badge withheld message with top issues
+    console.log(upsell.formatBadgeWithheld(verdict, findings, tier));
+    
+    // Do NOT write badge file
+    return verdict === 'BLOCK' ? 2 : 1;
+  }
+
   const projectName = path.basename(process.cwd());
 
   // Print banner

package/bin/runners/runDoctor.js

@@ -10,6 +10,14 @@
 
 const fs = require("fs");
 const path = require("path");
+const { 
+  generateRunId, 
+  createJsonOutput, 
+  writeJsonOutput, 
+  exitCodeToVerdict,
+  verdictToExitCode,
+  saveArtifact 
+} = require("./lib/cli-output");
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // ADVANCED TERMINAL - ANSI CODES & UTILITIES
@@ -283,9 +291,13 @@ try {
 // MAIN DOCTOR FUNCTION
 // ═══════════════════════════════════════════════════════════════════════════════
 
-async function runDoctor(args) {
+async function runDoctor(args, context = {}) {
+  // Extract runId from context or generate new one
+  const runId = context.runId || generateRunId();
+  const startTime = context.startTime || new Date().toISOString();
+  
   const opts = parseArgs(args);
-  const startTime = Date.now();
+  const executionStart = Date.now();
   
   if (opts.help) {
     printHelp();
@@ -315,8 +327,51 @@ async function runDoctor(args) {
       skipNetwork: opts.skipNetwork,
       saveReport: opts.saveReport,
       failOnWarn: opts.failOnWarn,
+      runId,
     });
-    return await doctor.run();
+    
+    const results = await doctor.run();
+    
+    // Apply CLI output conventions
+    if (opts.json) {
+      const output = createJsonOutput({
+        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);
+    }
+    
+    // Save artifacts
+    if (results.checks) {
+      saveArtifact(runId, "checks", results.checks);
+    }
+    if (results.fixes) {
+      saveArtifact(runId, "fixes", results.fixes);
+    }
+    
+    return results.exitCode || 0;
   }
   
   // Legacy fallback
@@ -333,6 +388,9 @@ function parseArgs(args) {
     dryRun: false,
     quiet: false,
     verbose: false,
+    strict: false,
+    ci: false,
+    output: null,
     categories: null,
     skipNetwork: false,
     saveReport: true,
@@ -381,6 +439,17 @@ function parseArgs(args) {
       case '--fail-on-warn':
         opts.failOnWarn = true;
         break;
+      case '--strict':
+        opts.strict = true;
+        break;
+      case '--ci':
+        opts.ci = true;
+        opts.quiet = true;
+        break;
+      case '--output':
+      case '-o':
+        opts.output = args[++i];
+        break;
       default:
         if (!arg.startsWith('-')) {
           opts.path = path.resolve(arg);

package/bin/runners/runFix.js

@@ -35,6 +35,7 @@ const { buildSharePack } = require('./lib/share-pack');
 
 // Entitlements enforcement
 const entitlements = require('./lib/entitlements-v2');
+const upsell = require('./lib/upsell');
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // ADVANCED TERMINAL - ANSI CODES & UTILITIES
@@ -549,6 +550,18 @@ async function runFix(args) {
     console.log(`  ${colors.mission}${ICONS.robot}${c.reset} ${c.bold}vibecheck fix --autopilot --apply${c.reset}`);
     console.log(`     ${c.dim}Loop until SHIP or stuck${c.reset}`);
     console.log();
+    
+    // Earned upsell: Show if --apply is locked for their tier
+    const applyAccess = await entitlements.checkCommand("fix.apply_patches", { projectPath: root });
+    if (!applyAccess.allowed) {
+      console.log(upsell.formatEarnedUpsell({
+        cmd: "fix",
+        withheldArtifact: "apply",
+        upgradeTier: applyAccess.requiredTier || "complete",
+        why: "Apply patches automatically",
+      }));
+    }
+    
     return 0;
   }
 

package/bin/runners/runGraph.js

@@ -31,6 +31,9 @@ const {
   mergeRuntimeResults
 } = require("./lib/graph");
 
+// Entitlements enforcement
+const entitlements = require("./lib/entitlements-v2");
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // ADVANCED TERMINAL - ANSI CODES & UTILITIES
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -174,6 +177,17 @@ async function runGraph(args) {
     return 0;
   }
 
+  // TIER ENFORCEMENT: COMPLETE only
+  const access = await entitlements.enforce("graph", {
+    projectPath: opts.path || process.cwd(),
+    silent: false,
+  });
+  
+  if (!access.allowed) {
+    console.log(`\n${c.yellow}Tip:${c.reset} The graph command requires COMPLETE tier for advanced proof graph visualization.`);
+    return entitlements.EXIT_FEATURE_NOT_ALLOWED;
+  }
+
   const root = path.resolve(opts.path || process.cwd());
   const projectName = path.basename(root);
   const outDir = path.join(root, ".vibecheck", "graph");