vibecheck-ai 2.0.2 → 5.0.0

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

@@ -0,0 +1,231 @@
+/**
+ * Enterprise Reality Output - V5 "Mission Control" Format
+ * Features:
+ * - Dynamic "REALITY" ASCII Art
+ * - Runtime Verification Status
+ * - Browser Test Results
+ * - Pixel-perfect 80-char alignment
+ */
+
+const path = require('path');
+
+// ANSI Color Helpers
+const ESC = '\x1b';
+const chalk = {
+  reset: `${ESC}[0m`,
+  bold: `${ESC}[1m`,
+  dim: `${ESC}[2m`,
+  red: `${ESC}[31m`,
+  green: `${ESC}[32m`,
+  yellow: `${ESC}[33m`,
+  cyan: `${ESC}[36m`,
+  magenta: `${ESC}[35m`,
+  white: `${ESC}[37m`,
+  gray: `${ESC}[90m`,
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONFIGURATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const WIDTH = 80;
+
+const BOX = {
+  topLeft: '╔', topRight: '╗', bottomLeft: '╚', bottomRight: '╝',
+  horizontal: '═', vertical: '║',
+  teeRight: '╠', teeLeft: '╣', teeTop: '╤', teeBottom: '╧',
+  cross: '╪',
+  lightH: '─', lightV: '│',
+  lightTeeLeft: '├', lightTeeRight: '┤', lightCross: '┼'
+};
+
+// EXTERNAL HEADER
+const LOGO_VIBECHECK = `
+  ██╗   ██╗██╗██████╗ ███████╗ ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗
+  ██║   ██║██║██╔══██╗██╔════╝██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝
+  ██║   ██║██║██████╔╝█████╗  ██║     ███████║█████╗  ██║     █████╔╝
+  ╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██║     ██╔══██║██╔══╝  ██║     ██╔═██╗
+   ╚████╔╝ ██║██████╔╝███████╗╚██████╗██║  ██║███████╗╚██████╗██║  ██╗
+    ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝
+`;
+
+// HERO: REALITY (Green/Blue)
+const LOGO_REALITY = `
+    ██████╗ ███████╗ █████╗ ██╗     ██╗████████╗██╗   ██╗
+    ██╔══██╗██╔════╝██╔══██╗██║     ██║╚══██╔══╝╚██╗ ██╔╝
+    ██████╔╝█████╗  ███████║██║     ██║   ██║    ╚████╔╝ 
+    ██╔══██╗██╔══╝  ██╔══██║██║     ██║   ██║     ╚██╔╝  
+    ██║  ██║███████╗██║  ██║███████╗██║   ██║      ██║   
+    ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚══════╝╚═╝   ╚═╝      ╚═╝   
+`;
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITIES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function padCenter(str, width) {
+  const visibleLen = stripAnsi(str).length;
+  const padding = Math.max(0, width - visibleLen);
+  const left = Math.floor(padding / 2);
+  const right = padding - left;
+  return ' '.repeat(left) + str + ' '.repeat(right);
+}
+
+function padRight(str, len) {
+  const visibleLen = stripAnsi(str).length;
+  const truncated = visibleLen > len ? str.substring(0, len - 3) + '...' : str;
+  return truncated + ' '.repeat(Math.max(0, len - visibleLen));
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN FORMATTER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function formatRealityOutput(result, options = {}) {
+  const {
+    verdict = null,
+    tests = [],
+    passed = 0,
+    failed = 0,
+    warnings = 0,
+    coverage = 0,
+    duration = 0,
+    url = null,
+    success = false,
+    error = null,
+  } = result;
+
+  const isSuccess = success || (verdict === 'SHIP' && failed === 0);
+  const themeColor = isSuccess ? chalk.green : error ? chalk.red : chalk.yellow;
+  const statusText = isSuccess ? 'VERIFICATION PASSED' : error ? 'VERIFICATION FAILED' : 'VERIFICATION IN PROGRESS';
+  
+  const lines = [];
+
+  // 1. Render External Header
+  lines.push(chalk.cyan + LOGO_VIBECHECK.trim() + chalk.reset);
+  lines.push('');
+
+  // 2. Render Box Top
+  lines.push(`${chalk.gray}${BOX.topLeft}${BOX.horizontal.repeat(WIDTH - 2)}${BOX.topRight}${chalk.reset}`);
+  lines.push(`${chalk.gray}${BOX.vertical}${' '.repeat(WIDTH - 2)}${BOX.vertical}${chalk.reset}`);
+
+  // 3. Render Hero Logo (REALITY)
+  LOGO_REALITY.trim().split('\n').filter(l => l.trim().length > 0).forEach(l => {
+    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${themeColor}${padCenter(l.trim(), WIDTH - 2)}${chalk.reset}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+  });
+  lines.push(`${chalk.gray}${BOX.vertical}${' '.repeat(WIDTH - 2)}${BOX.vertical}${chalk.reset}`);
+
+  // 4. Info Row
+  const version = options.version || 'v3.5.5';
+  const infoText = `${chalk.bold}${version} REALITY${chalk.reset}  ::  STATUS: ${themeColor}${statusText}${chalk.reset}`;
+  const metaText = `Tests: ${tests.length} | Passed: ${passed}`;
+  const infoLine = `  ${infoText}${' '.repeat(Math.max(1, WIDTH - 6 - stripAnsi(infoText).length - stripAnsi(metaText).length))}${chalk.dim}${metaText}${chalk.reset}`;
+  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${infoLine}  ${chalk.gray}${BOX.vertical}${chalk.reset}`);
+  
+  const urlLine = url ? `  URL: ${padRight(url, 50)}` : `  Project: ${padRight(path.basename(options.projectPath || process.cwd()), 50)}`;
+  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${urlLine}${' '.repeat(WIDTH - 2 - stripAnsi(urlLine).length)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+
+  // 5. Split Pane
+  lines.push(`${chalk.gray}${BOX.teeRight}${BOX.horizontal.repeat(44)}${BOX.teeTop}${BOX.horizontal.repeat(WIDTH - 47)}${BOX.teeLeft}${chalk.reset}`);
+  
+  function printSplitRow(left, right) {
+    const leftContent = padRight(left || '', 42); 
+    const rightContent = padRight(right || '', WIDTH - 48); 
+    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset} ${leftContent} ${chalk.gray}${BOX.lightV}${chalk.reset} ${rightContent} ${chalk.gray}${BOX.vertical}${chalk.reset}`);
+  }
+
+  // Row 1: Headers
+  printSplitRow(`${chalk.bold}RUNTIME TESTS${chalk.reset}`, `${chalk.bold}VERIFICATION RESULTS${chalk.reset}`);
+  
+  // Row 2: Divider
+  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset} ${BOX.lightH.repeat(42)} ${chalk.gray}${BOX.lightCross}${chalk.reset} ${BOX.lightH.repeat(WIDTH - 48)} ${chalk.gray}${BOX.vertical}${chalk.reset}`);
+
+  // Prepare Left Column
+  const totalTests = tests.length || (passed + failed);
+  const passRate = totalTests > 0 ? Math.round((passed / totalTests) * 100) : 0;
+  const leftCol = [
+    '',
+    ` VERDICT         [${verdict === 'SHIP' ? chalk.green + 'SHIP' : verdict === 'BLOCK' ? chalk.red + 'BLOCK' : chalk.yellow + 'WARN'}${chalk.reset}]`,
+    ` Status:         ${verdict || 'N/A'}`,
+    '',
+    `${chalk.gray}${BOX.lightH.repeat(42)}${chalk.reset}`,
+    `${chalk.bold} TEST RESULTS${chalk.reset}`,
+    '',
+    ` Total:          ${chalk.cyan}${totalTests}${chalk.reset}`,
+    ` Passed:         ${chalk.green}${passed}${chalk.reset}`,
+    ` Failed:         ${chalk.red}${failed}${chalk.reset}`,
+    ` Warnings:        ${chalk.yellow}${warnings}${chalk.reset}`,
+    ` Pass Rate:      ${chalk.cyan}${passRate}%${chalk.reset}`,
+  ];
+
+  // Prepare Right Column
+  const rightCol = [];
+  rightCol.push('');
+  
+  rightCol.push(` COVERAGE       [${coverage}%]`);
+  rightCol.push(` Routes:         ${chalk.cyan}${coverage}%${chalk.reset}`);
+  rightCol.push('');
+  
+  if (isSuccess) {
+    rightCol.push(`${chalk.green} [✓] VERIFIED${chalk.reset}`);
+    rightCol.push(` All runtime tests`);
+    rightCol.push(` passed.`);
+  } else if (error) {
+    rightCol.push(`${chalk.red} [!] FAILED${chalk.reset}`);
+    rightCol.push(` Verification error.`);
+    rightCol.push('');
+    let msg = error.message || 'Unknown error';
+    if (msg.length > 25) msg = msg.substring(0, 25) + '...';
+    rightCol.push(` ${chalk.red}${msg}${chalk.reset}`);
+  } else {
+    rightCol.push(`${chalk.yellow} [○] IN PROGRESS${chalk.reset}`);
+    rightCol.push(` Running browser`);
+    rightCol.push(` tests...`);
+  }
+  
+  if (tests.length > 0) {
+    rightCol.push('');
+    rightCol.push(`${chalk.bold} TEST SUMMARY${chalk.reset}`);
+    tests.slice(0, 3).forEach((test, i) => {
+      const status = test.passed ? chalk.green + '✓' : chalk.red + '✖';
+      const name = (test.name || test.route || 'Test').substring(0, 20);
+      rightCol.push(` ${status}${chalk.reset} ${name}`);
+    });
+    if (tests.length > 3) {
+      rightCol.push(` ${chalk.dim}... ${tests.length - 3} more${chalk.reset}`);
+    }
+  }
+
+  // Merge Columns
+  const maxRows = Math.max(leftCol.length, rightCol.length);
+  for (let i = 0; i < maxRows; i++) {
+    printSplitRow(leftCol[i] || '', rightCol[i] || '');
+  }
+
+  // 6. Action Footer
+  lines.push(`${chalk.gray}${BOX.teeRight}${BOX.horizontal.repeat(WIDTH - 2)}${BOX.teeLeft}${chalk.reset}`);
+  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset} ${chalk.bold}RUNTIME CONTROL${chalk.reset}${' '.repeat(WIDTH - 17)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset} ${BOX.lightH.repeat(WIDTH - 4)} ${chalk.gray}${BOX.vertical}${chalk.reset}`);
+
+  if (isSuccess) {
+    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset} ${chalk.green}[✓] RUNTIME VERIFIED. READY FOR PRODUCTION.${chalk.reset}${' '.repeat(WIDTH - 45)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+    lines.push(`${chalk.gray}${BOX.vertical}${' '.repeat(WIDTH - 2)}${BOX.vertical}${chalk.reset}`);
+    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset} > ${chalk.cyan}vibecheck ship${chalk.reset}             [DEPLOY]    Proceed with deployment           ${chalk.gray}${BOX.vertical}${chalk.reset}`);
+  } else {
+    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset} ${chalk.red}[!] VERIFICATION FAILED. REVIEW REQUIRED.${chalk.reset}${' '.repeat(WIDTH - 42)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+    lines.push(`${chalk.gray}${BOX.vertical}${' '.repeat(WIDTH - 2)}${BOX.vertical}${chalk.reset}`);
+    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset} > ${chalk.cyan}vibecheck reality --retry${chalk.reset}   [RETRY]     Re-run verification              ${chalk.gray}${BOX.vertical}${chalk.reset}`);
+    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset} > ${chalk.cyan}vibecheck fix --apply${chalk.reset}      [FIX]       Apply fixes before retry           ${chalk.gray}${BOX.vertical}${chalk.reset}`);
+  }
+
+  // 7. Box Bottom
+  lines.push(`${chalk.gray}${BOX.bottomLeft}${BOX.horizontal.repeat(WIDTH - 2)}${BOX.bottomRight}${chalk.reset}`);
+
+  return lines.join('\n');
+}
+
+module.exports = { formatRealityOutput };

package/bin/runners/lib/receipts.js

@@ -0,0 +1,179 @@
+/**
+ * Receipts and Manifests Generation
+ * 
+ * Creates manifest.json and receipt.json for paid command runs.
+ * Required for audit trail and billing verification.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { logUsage } = require("./usage");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// RECEIPT GENERATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function getRunDir(runId) {
+  const runDir = path.join(process.cwd(), ".vibecheck", "runs", runId);
+  const receiptsDir = path.join(process.cwd(), ".vibecheck", "receipts");
+  
+  // Ensure directories exist
+  if (!fs.existsSync(runDir)) fs.mkdirSync(runDir, { recursive: true });
+  if (!fs.existsSync(receiptsDir)) fs.mkdirSync(receiptsDir, { recursive: true });
+  
+  return { runDir, receiptsDir };
+}
+
+/**
+ * Get git commit hash if available
+ */
+function getGitInfo() {
+  try {
+    const gitDir = path.join(process.cwd(), ".git");
+    if (!fs.existsSync(gitDir)) return null;
+    
+    const headFile = path.join(gitDir, "HEAD");
+    if (!fs.existsSync(headFile)) return null;
+    
+    const headRef = fs.readFileSync(headFile, "utf8").trim();
+    const refMatch = headRef.match(/^ref: (.+)$/);
+    
+    if (refMatch) {
+      const refFile = path.join(gitDir, refMatch[1]);
+      if (fs.existsSync(refFile)) {
+        return fs.readFileSync(refFile, "utf8").trim();
+      }
+    } else {
+      // Detached HEAD
+      return headRef;
+    }
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Calculate hash of manifest for receipt integrity
+ */
+function calculateManifestHash(manifest) {
+  const manifestString = JSON.stringify(manifest, Object.keys(manifest).sort());
+  return crypto.createHash("sha256").update(manifestString).digest("hex");
+}
+
+/**
+ * Create manifest and receipt for a command run
+ */
+async function createManifestAndReceipt(options) {
+  const { runId, command, args, tier, exitCode, startTime, endTime, projectPath } = options;
+  const { runDir, receiptsDir } = getRunDir(runId);
+  
+  // Create manifest
+  const manifest = {
+    runId,
+    command,
+    args,
+    timestamp: startTime,
+    duration: endTime ? new Date(endTime).getTime() - new Date(startTime).getTime() : null,
+    project: {
+      path: projectPath,
+      git: getGitInfo(),
+      branch: process.env.GIT_BRANCH || null,
+    },
+    environment: {
+      nodeVersion: process.version,
+      platform: process.platform,
+      arch: process.arch,
+    },
+    execution: {
+      exitCode,
+      endTime,
+    },
+    outputs: [], // To be filled by runners if needed
+  };
+  
+  // Save manifest
+  const manifestPath = path.join(runDir, "manifest.json");
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  
+  // Create receipt
+  const manifestHash = calculateManifestHash(manifest);
+  const receipt = {
+    runId,
+    command,
+    tier,
+    timestamp: new Date().toISOString(),
+    manifestHash,
+    verification: {
+      algorithm: "SHA-256",
+      signature: "TODO: Implement server-side signing",
+    },
+    billing: {
+      tier,
+      charged: false, // TODO: Check with backend
+      usage: {
+        // Units will be populated by individual runners
+      },
+    },
+  };
+  
+  // Save receipt
+  const receiptPath = path.join(receiptsDir, `${runId}.json`);
+  fs.writeFileSync(receiptPath, JSON.stringify(receipt, null, 2));
+  
+  // Log usage (if units are provided)
+  if (options.units) {
+    logUsage({
+      runId,
+      command,
+      tier,
+      units: options.units,
+      timestamp: startTime,
+      projectPath,
+    });
+  }
+  
+  return { manifest, receipt, manifestPath, receiptPath };
+}
+
+/**
+ * Verify a receipt against its manifest
+ */
+function verifyReceipt(receiptPath) {
+  try {
+    const receipt = JSON.parse(fs.readFileSync(receiptPath, "utf8"));
+    const manifestPath = path.join(
+      process.cwd(), 
+      ".vibecheck", 
+      "runs", 
+      receipt.runId, 
+      "manifest.json"
+    );
+    
+    if (!fs.existsSync(manifestPath)) {
+      return { valid: false, error: "Manifest not found" };
+    }
+    
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    const calculatedHash = calculateManifestHash(manifest);
+    
+    if (calculatedHash !== receipt.manifestHash) {
+      return { valid: false, error: "Manifest hash mismatch" };
+    }
+    
+    return { valid: true, receipt, manifest };
+  } catch (error) {
+    return { valid: false, error: error.message };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+module.exports = {
+  createManifestAndReceipt,
+  verifyReceipt,
+  calculateManifestHash,
+};

package/bin/runners/lib/redact.js

@@ -0,0 +1,29 @@
+// bin/runners/lib/redact.js
+function redactString(s) {
+  if (typeof s !== "string") return s;
+
+  return s
+    .replace(/(api[_-]?key|secret|token|password)\s*[:=]\s*["']?([^"'\s]{6,})["']?/gi, "$1: [REDACTED]")
+    .replace(/(bearer)\s+([a-z0-9_\-\.=]{12,})/gi, "$1 [REDACTED]")
+    .replace(/sk-[a-z0-9]{16,}/gi, "[REDACTED]")
+    .replace(/[a-z0-9+\/=]{80,}/gi, "[REDACTED_BLOB]");
+}
+
+function redactObject(obj) {
+  if (obj == null) return obj;
+  if (typeof obj === "string") return redactString(obj);
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(redactObject);
+
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (/api[_-]?key|secret|token|password|private/i.test(k)) {
+      out[k] = "[REDACTED]";
+      continue;
+    }
+    out[k] = redactObject(v);
+  }
+  return out;
+}
+
+module.exports = { redactObject };

package/bin/runners/lib/replay/capsule-manager.js

@@ -0,0 +1,154 @@
+/**
+ * Replay Capsule Manager
+ * Handles saving, loading, and managing replay capsules
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+const crypto = require('crypto');
+
+class CapsuleManager {
+  constructor(basePath) {
+    this.basePath = path.join(basePath, '.vibecheck', 'replays');
+  }
+
+  async init() {
+    await fs.mkdir(this.basePath, { recursive: true });
+  }
+
+  async saveCapsule(capsule) {
+    const id = capsule.id || uuidv4();
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const capsuleDir = path.join(this.basePath, `${timestamp}_${id}`);
+    
+    await fs.mkdir(capsuleDir, { recursive: true });
+    
+    // Save metadata
+    const metadata = {
+      id,
+      createdAt: new Date().toISOString(),
+      name: capsule.name || `Replay ${timestamp}`,
+      description: capsule.description || '',
+      tags: capsule.tags || [],
+      steps: capsule.steps ? capsule.steps.length : 0,
+      duration: capsule.duration || 0,
+      status: 'captured',
+      ...capsule.metadata
+    };
+
+    // Save steps
+    const steps = capsule.steps || [];
+    
+    // Generate deterministic hash for the capsule
+    const hash = crypto
+      .createHash('sha256')
+      .update(JSON.stringify({ metadata, steps }))
+      .digest('hex');
+      
+    metadata.hash = hash;
+
+    await Promise.all([
+      fs.writeFile(
+        path.join(capsuleDir, 'metadata.json'),
+        JSON.stringify(metadata, null, 2),
+        'utf8'
+      ),
+      fs.writeFile(
+        path.join(capsuleDir, 'steps.json'),
+        JSON.stringify(steps, null, 2),
+        'utf8'
+      )
+    ]);
+
+    return { id, path: capsuleDir, metadata };
+  }
+
+  async loadCapsule(capsuleId) {
+    const capsules = await this.listCapsules();
+    const capsule = capsules.find(c => c.id === capsuleId || c.metadata.id === capsuleId);
+    
+    if (!capsule) {
+      throw new Error(`Capsule ${capsuleId} not found`);
+    }
+
+    const [metadata, steps] = await Promise.all([
+      fs.readFile(path.join(capsule.path, 'metadata.json'), 'utf8')
+        .then(JSON.parse),
+      fs.readFile(path.join(capsule.path, 'steps.json'), 'utf8')
+        .then(JSON.parse)
+    ]);
+
+    return { metadata, steps };
+  }
+
+  async listCapsules() {
+    try {
+      const dirs = await fs.readdir(this.basePath, { withFileTypes: true });
+      const capsules = [];
+
+      for (const dir of dirs) {
+        if (!dir.isDirectory()) continue;
+        
+        try {
+          const metadataPath = path.join(this.basePath, dir.name, 'metadata.json');
+          const metadata = JSON.parse(await fs.readFile(metadataPath, 'utf8'));
+          
+          capsules.push({
+            id: metadata.id,
+            name: metadata.name,
+            path: path.join(this.basePath, dir.name),
+            metadata,
+            timestamp: new Date(metadata.createdAt).getTime()
+          });
+        } catch (err) {
+          console.error(`Error loading capsule ${dir.name}:`, err.message);
+        }
+      }
+
+      // Sort by timestamp, newest first
+      return capsules.sort((a, b) => b.timestamp - a.timestamp);
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        return [];
+      }
+      throw err;
+    }
+  }
+
+  async deleteCapsule(capsuleId) {
+    const capsules = await this.listCapsules();
+    const capsule = capsules.find(c => c.id === capsuleId || c.metadata.id === capsuleId);
+    
+    if (!capsule) {
+      throw new Error(`Capsule ${capsuleId} not found`);
+    }
+
+    await fs.rm(capsule.path, { recursive: true, force: true });
+    return true;
+  }
+
+  async exportCapsule(capsuleId, outputPath) {
+    const { metadata, steps } = await this.loadCapsule(capsuleId);
+    const exportData = { metadata, steps };
+    
+    await fs.writeFile(
+      outputPath,
+      JSON.stringify(exportData, null, 2),
+      'utf8'
+    );
+    
+    return outputPath;
+  }
+
+  async importCapsule(filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf8'));
+    return this.saveCapsule({
+      ...data.metadata,
+      steps: data.steps,
+      imported: true
+    });
+  }
+}
+
+module.exports = CapsuleManager;