vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/cli-output.js

@@ -0,0 +1,400 @@
+/**
+ * CLI Output Utilities - Enterprise Grade
+ * * Standardizes run lifecycle, artifact management, telemetry,
+ * * and JSON output for the Vibecheck suite.
+ * * Features:
+ * - 🛡️ Atomic file writes (no corruption on crash)
+ * - 🔄 Automatic "latest" symlinking for easy debugging
+ * - 🕵️ Deep CI/Git context extraction
+ * - 🛑 Beautiful Crash Reporting (matches UI style)
+ * - 🧹 Automatic Log Rotation
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const os = require("os");
+const childProcess = require("child_process");
+const chalk = require("chalk"); // Added for premium error reporting
+
+// Re-export exit codes for backward compatibility
+const { EXIT, verdictToExitCode } = require("./exit-codes");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONFIGURATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const CONFIG = {
+  DIR_NAME: ".vibecheck",
+  MAX_RETAINED_RUNS: 50, // Keep last 50 runs, delete older
+  WIDTH: 76,
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// RUN ID GENERATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Generate a unique, time-sortable run ID
+ * Format: YYYY-MM-DD-HHmm-UUID
+ */
+function generateRunId() {
+  const date = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 16);
+  const uuid = crypto.randomUUID().slice(0, 8);
+  return `${date}-${uuid}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONTEXT GATHERING (Telemetry)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function getSystemContext() {
+  return {
+    platform: os.platform(),
+    arch: os.arch(),
+    node: process.version,
+    cpus: os.cpus().length,
+    memory: Math.round(os.totalmem() / 1024 / 1024 / 1024) + 'GB',
+    cwd: process.cwd(),
+  };
+}
+
+function getGitContext() {
+  try {
+    const commit = childProcess.execSync('git rev-parse --short HEAD', { stdio: 'pipe' }).toString().trim();
+    const branch = childProcess.execSync('git rev-parse --abbrev-ref HEAD', { stdio: 'pipe' }).toString().trim();
+    const isDirty = childProcess.execSync('git status --porcelain', { stdio: 'pipe' }).toString().trim().length > 0;
+    return { commit, branch, isDirty };
+  } catch (e) {
+    return null; // Not a git repo
+  }
+}
+
+function getCiContext() {
+  if (process.env.GITHUB_ACTIONS) return { provider: 'GitHub Actions', runId: process.env.GITHUB_RUN_ID };
+  if (process.env.GITLAB_CI) return { provider: 'GitLab CI', jobId: process.env.CI_JOB_ID };
+  if (process.env.JENKINS_URL) return { provider: 'Jenkins', buildUrl: process.env.BUILD_URL };
+  if (process.env.CI) return { provider: 'Generic CI' };
+  return { provider: null };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FILESYSTEM OPS (Atomic & Safe)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Atomic write to prevent file corruption if process dies mid-write
+ */
+function safeWriteJson(filePath, data) {
+  const tempPath = `${filePath}.tmp.${crypto.randomUUID().slice(0, 6)}`;
+  try {
+    fs.writeFileSync(tempPath, JSON.stringify(data, null, 2));
+    fs.renameSync(tempPath, filePath); // Atomic operation
+  } catch (err) {
+    try { fs.unlinkSync(tempPath); } catch (e) {} // Cleanup
+    throw err;
+  }
+}
+
+function updateSymlink(target, linkPath) {
+  try {
+    if (fs.existsSync(linkPath)) fs.unlinkSync(linkPath);
+    // 'junction' type is required for Windows to not require Admin
+    fs.symlinkSync(target, linkPath, 'junction'); 
+  } catch (e) {
+    // Ignore symlink errors (often permissions)
+  }
+}
+
+/**
+ * Cleanup old runs to save disk space (Log Rotation)
+ */
+function rotateLogs(runsDir) {
+  try {
+    if (!fs.existsSync(runsDir)) return;
+    
+    const runs = fs.readdirSync(runsDir)
+      .map(name => ({ name, path: path.join(runsDir, name) }))
+      .filter(item => fs.statSync(item.path).isDirectory() && item.name !== 'latest')
+      .sort((a, b) => b.name.localeCompare(a.name)); // Newest first
+
+    if (runs.length > CONFIG.MAX_RETAINED_RUNS) {
+      const toDelete = runs.slice(CONFIG.MAX_RETAINED_RUNS);
+      toDelete.forEach(run => fs.rmSync(run.path, { recursive: true, force: true }));
+    }
+  } catch (e) {
+    // Non-blocking cleanup failure
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// OUTPUT DIRECTORY MANAGEMENT
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function getRunPaths(runId, projectPath = process.cwd()) {
+  const baseDir = path.join(projectPath, CONFIG.DIR_NAME);
+  const runDir = path.join(baseDir, "runs", runId);
+  const latestLink = path.join(baseDir, "runs", "latest");
+  const artifactsDir = path.join(runDir, "artifacts");
+  
+  // Ensure directories exist
+  fs.mkdirSync(artifactsDir, { recursive: true });
+  
+  // Update 'latest' symlink for easy debugging
+  updateSymlink(runDir, latestLink);
+  
+  // Trigger cleanup async (don't block the CLI)
+  setTimeout(() => rotateLogs(path.join(baseDir, "runs")), 100).unref();
+
+  return {
+    runDir,
+    artifactsDir,
+    manifestPath: path.join(runDir, "manifest.json"),
+    commandPath: path.join(runDir, "command.json"),
+    crashPath: path.join(runDir, "crash.json"),
+  };
+}
+
+function saveArtifact(runId, name, data, type = "json") {
+  const { artifactsDir } = getRunPaths(runId);
+  const artifactPath = path.join(artifactsDir, `${name}.${type}`);
+  
+  if (type === "json") {
+    safeWriteJson(artifactPath, data);
+  } else {
+    fs.writeFileSync(artifactPath, data);
+  }
+  
+  return artifactPath;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// JSON OUTPUT SCHEMA
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function createJsonOutput(options) {
+  const {
+    runId,
+    command,
+    startTime,
+    exitCode,
+    verdict,
+    result = {},
+    tier = "free",
+    version = "1.0.0",
+    projectPath = process.cwd(),
+    artifacts = [],
+  } = options;
+  
+  return {
+    meta: {
+      schemaVersion: "2.0.0",
+      generatedAt: new Date().toISOString(),
+      tool: { name: "vibecheck", version, tier },
+      system: getSystemContext(),
+      git: getGitContext(),
+      ci: getCiContext(),
+    },
+    run: {
+      id: runId,
+      command,
+      durationMs: startTime ? Date.now() - new Date(startTime).getTime() : 0,
+      exitCode,
+      verdict,
+    },
+    // The actual data payload
+    data: result,
+    // Links to files created
+    artifacts: artifacts.map(art => ({
+      type: art.type,
+      name: path.basename(art.path),
+      path: path.relative(projectPath, art.path), // Relative for portability
+      description: art.description,
+    })),
+  };
+}
+
+function writeJsonOutput(output, outputPath) {
+  const jsonString = JSON.stringify(output, null, 2);
+  
+  if (outputPath) {
+    // If output is a file, write to it
+    safeWriteJson(outputPath, output);
+    return outputPath;
+  } else {
+    // If stdout, we must ensure we don't break pipe consumers
+    process.stdout.write(jsonString + '\n');
+    return null;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// VERDICT MAPPING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function exitCodeToVerdict(exitCode) {
+  const map = {
+    0: "SHIP",
+    1: "WARN",
+    2: "BLOCK",
+    3: "FEATURE_DENIED",
+    4: "INVALID_INPUT",
+    5: "INTERNAL_ERROR"
+  };
+  return map[exitCode] || "UNKNOWN";
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// COMMAND WRAPPER (The Safety Net)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Wrap a command runner with world-class output handling,
+ * telemetry, and crash protection.
+ */
+async function withStandardOutput(commandFn, options = {}) {
+  const {
+    command,
+    startTime = new Date().toISOString(),
+    runId = generateRunId(),
+    json = false,
+    output = null,
+    tier = "free",
+    version = "1.0.0",
+  } = options;
+  
+  const paths = getRunPaths(runId);
+  const artifacts = [];
+  
+  // Artifact helper injected into the command
+  const artifactSaver = (name, data, type = 'json') => {
+    try {
+      const artifactPath = saveArtifact(runId, name, data, type);
+      artifacts.push({ type, path: artifactPath, description: name });
+      return artifactPath;
+    } catch (e) {
+      console.error(chalk.yellow(`⚠️ Warning: Failed to save artifact ${name}: ${e.message}`));
+      return null;
+    }
+  };
+
+  try {
+    // Execute Command
+    const result = await commandFn({
+      runId,
+      paths,
+      saveArtifact: artifactSaver,
+    });
+    
+    // Normalize Result
+    const exitCode = typeof result === "number" ? result : (result.exitCode ?? 0);
+    const verdict = result.verdict || exitCodeToVerdict(exitCode);
+    const resultData = typeof result === "object" ? result : {};
+
+    const outputObj = createJsonOutput({
+      runId, command, startTime, exitCode, verdict,
+      result: resultData, tier, version, artifacts
+    });
+
+    // 1. Always save to internal history
+    safeWriteJson(paths.commandPath, outputObj);
+
+    // 2. If JSON requested by user, print/write it
+    if (json) {
+      writeJsonOutput(outputObj, output);
+    }
+
+    return exitCode;
+
+  } catch (error) {
+    // 🛑 CRITICAL ERROR HANDLING
+    const exitCode = error.exitCode || 5;
+    const verdict = "INTERNAL_ERROR";
+    
+    const errorData = {
+      message: error.message,
+      stack: error.stack,
+      code: error.code || 'UNKNOWN',
+    };
+
+    const outputObj = createJsonOutput({
+      runId, command, startTime, exitCode, verdict,
+      result: { error: errorData }, tier, version, artifacts
+    });
+
+    // Save crash report to disk
+    safeWriteJson(paths.crashPath, outputObj);
+    safeWriteJson(paths.commandPath, outputObj);
+
+    if (json) {
+      writeJsonOutput(outputObj, output);
+    } else {
+      // VISUAL CRASH REPORT
+      console.error('');
+      console.error(chalk.bgRed.white.bold(` 🛑 SYSTEM ALERT: INTERNAL CRASH `));
+      console.error(chalk.red('─'.repeat(CONFIG.WIDTH)));
+      console.error(`${chalk.bold('Error:')}   ${error.message}`);
+      console.error(`${chalk.bold('Run ID:')}  ${runId}`);
+      console.error(`${chalk.bold('Log:')}     ${chalk.cyan(paths.crashPath)}`);
+      console.error(chalk.red('─'.repeat(CONFIG.WIDTH)));
+      console.error('');
+    }
+
+    throw error; // Re-throw so the process actually exits with error
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STANDARD FLAGS PARSER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseStandardFlags(args) {
+  const flags = {
+    json: false,
+    ci: !!process.env.CI, // Auto-detect CI
+    path: process.cwd(),
+    output: null,
+    verbose: false,
+    strict: false,
+    help: false,
+    version: false,
+    debug: false,
+  };
+  
+  const parsed = [];
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    if (arg === '--json' || arg === '-j') flags.json = true;
+    else if (arg === '--ci') flags.ci = true;
+    else if (arg === '--verbose' || arg === '-v') flags.verbose = true;
+    else if (arg === '--strict') flags.strict = true;
+    else if (arg === '--help' || arg === '-h') flags.help = true;
+    else if (arg === '--version' || arg === '-V') flags.version = true;
+    else if (arg === '--debug' || arg === '-d') flags.debug = true;
+    else if (arg.startsWith('--path=')) flags.path = arg.split('=')[1];
+    else if (arg === '-p' && args[i+1]) { flags.path = args[++i]; }
+    else if (arg.startsWith('--output=')) flags.output = arg.split('=')[1];
+    else if (arg === '-o' && args[i+1]) { flags.output = args[++i]; }
+    else parsed.push(arg);
+  }
+  
+  return { flags, parsed };
+}
+
+module.exports = {
+  generateRunId,
+  getRunPaths,
+  saveArtifact,
+  createJsonOutput,
+  writeJsonOutput,
+  exitCodeToVerdict, // Local function
+  // Re-exported from exit-codes.js
+  verdictToExitCode,
+  EXIT,
+  withStandardOutput,
+  parseStandardFlags,
+};