@vibecheckai/cli 3.2.2 → 3.2.4

package/bin/runners/lib/replay/index.js

@@ -1,263 +1,263 @@
-/**
- * Replay Module
- * 
- * Provides a unified API for recording and replaying user interactions
- * with the ability to verify behavior and detect regressions.
- */
-
-const path = require('path');
-const fs = require('fs').promises;
-const debug = require('debug')('vibecheck:replay');
-
-// Core components
-const CapsuleManager = require('./capsule-manager');
-const ReplayRecorder = require('./recorder');
-const ReplayPlayer = require('./player');
-
-/**
- * Main Replay API
- */
-class ReplayEngine {
-  constructor(options = {}) {
-    this.options = {
-      basePath: process.cwd(),
-      ...options
-    };
-    
-    this.manager = new CapsuleManager(this.options.basePath);
-    this.recorder = null;
-    this.player = null;
-  }
-
-  /**
-   * Initialize the replay system
-   */
-  async init() {
-    await this.manager.init();
-    debug('Replay engine initialized');
-    return this;
-  }
-
-  /**
-   * Start a new recording session
-   */
-  startRecording(options = {}) {
-    if (this.recorder) {
-      throw new Error('Recording already in progress');
-    }
-    
-    this.recorder = new ReplayRecorder({
-      ...options,
-      basePath: this.options.basePath
-    });
-    
-    this.recorder.start();
-    debug('Started new recording session');
-    
-    return this.recorder;
-  }
-
-  /**
-   * Stop the current recording and save as a capsule
-   */
-  async stopRecording(saveOptions = {}) {
-    if (!this.recorder) {
-      throw new Error('No active recording to stop');
-    }
-    
-    const result = this.recorder.stop();
-    const { id, path: capsulePath } = await this.recorder.save(this.options.basePath);
-    
-    debug(`Recording saved as capsule: ${id} (${capsulePath})`);
-    
-    this.recorder = null;
-    
-    return {
-      id,
-      path: capsulePath,
-      metadata: result.metadata
-    };
-  }
-
-  /**
-   * List available replay capsules
-   */
-  async listCapsules() {
-    return this.manager.listCapsules();
-  }
-
-  /**
-   * Get a replay capsule by ID or path
-   */
-  async getCapsule(idOrPath) {
-    return this.manager.loadCapsule(idOrPath);
-  }
-
-  /**
-   * Delete a replay capsule
-   */
-  async deleteCapsule(idOrPath) {
-    return this.manager.deleteCapsule(idOrPath);
-  }
-
-  /**
-   * Export a capsule to a portable format
-   */
-  async exportCapsule(idOrPath, outputPath) {
-    return this.manager.exportCapsule(idOrPath, outputPath);
-  }
-
-  /**
-   * Import a capsule from a file
-   */
-  async importCapsule(filePath) {
-    return this.manager.importCapsule(filePath);
-  }
-
-  /**
-   * Create a new replay player for a capsule
-   */
-  createPlayer(options = {}) {
-    if (this.player) {
-      throw new Error('A player is already active');
-    }
-    
-    this.player = new ReplayPlayer({
-      ...this.options,
-      ...options
-    });
-    
-    return this.player;
-  }
-
-  /**
-   * Play a replay capsule
-   */
-  async playCapsule(capsule, options = {}) {
-    const player = this.createPlayer(options);
-    await player.loadCapsule(capsule);
-    
-    if (options.browser) {
-      await player.setupPlaywright(options.browser);
-    }
-    
-    return player.play();
-  }
-
-  /**
-   * Create a Playwright recorder
-   */
-  createPlaywrightRecorder(page, options = {}) {
-    return ReplayRecorder.fromPlaywright(page, {
-      ...this.options,
-      ...options
-    });
-  }
-
-  /**
-   * Clean up resources
-   */
-  async cleanup() {
-    if (this.player) {
-      await this.player.close().catch(console.error);
-      this.player = null;
-    }
-    
-    if (this.recorder) {
-      this.recorder.stop();
-      this.recorder = null;
-    }
-  }
-}
-
-// Export everything
-module.exports = {
-  // Main API
-  ReplayEngine,
-  
-  // Core components
-  CapsuleManager,
-  ReplayRecorder,
-  ReplayPlayer,
-  
-  // Factory function for quick setup
-  createReplayEngine: async (options = {}) => {
-    const engine = new ReplayEngine(options);
-    await engine.init();
-    return engine;
-  },
-  
-  // Utility functions
-  utils: {
-    /**
-     * Generate a human-readable report from replay results
-     */
-    generateReport: (results) => {
-      const { metadata, stats } = results;
-      const { name, description, duration, steps } = metadata;
-      const { passed, failed, skipped } = stats;
-      
-      return {
-        title: `Replay Report: ${name}`,
-        summary: {
-          description,
-          duration: `${(duration / 1000).toFixed(2)}s`,
-          totalSteps: steps,
-          passed,
-          failed,
-          skipped,
-          success: failed === 0
-        },
-        timestamp: new Date().toISOString(),
-        details: results.steps ? results.steps.map(step => ({
-          id: step.id,
-          type: step.type,
-          status: step.error ? 'failed' : 'passed',
-          duration: step.duration ? `${step.duration.toFixed(2)}ms` : 'N/A',
-          error: step.error ? step.error.message : null
-        })) : []
-      };
-    },
-    
-    /**
-     * Compare two replay results to detect regressions
-     */
-    compareResults: (baseline, current) => {
-      const regressions = [];
-      
-      // Check step counts
-      if (baseline.stats.totalSteps !== current.stats.totalSteps) {
-        regressions.push({
-          type: 'step_count_mismatch',
-          message: `Different number of steps: ${baseline.stats.totalSteps} vs ${current.stats.totalSteps}`
-        });
-      }
-      
-      // Check for new failures
-      if (current.stats.failed > baseline.stats.failed) {
-        regressions.push({
-          type: 'new_failures',
-          message: `New failures: ${current.stats.failed - baseline.stats.failed} more than baseline`
-        });
-      }
-      
-      // Check for performance regressions (if timing data is available)
-      if (baseline.metadata.duration && current.metadata.duration) {
-        const threshold = baseline.metadata.duration * 1.5; // 50% slower
-        if (current.metadata.duration > threshold) {
-          regressions.push({
-            type: 'performance_regression',
-            message: `Performance regression: ${(current.metadata.duration / 1000).toFixed(2)}s vs baseline ${(baseline.metadata.duration / 1000).toFixed(2)}s`
-          });
-        }
-      }
-      
-      return {
-        hasRegressions: regressions.length > 0,
-        regressions,
-        baseline: baseline.stats,
-        current: current.stats
-      };
-    }
-  }
-};
+/**
+ * Replay Module
+ * 
+ * Provides a unified API for recording and replaying user interactions
+ * with the ability to verify behavior and detect regressions.
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const debug = require('debug')('vibecheck:replay');
+
+// Core components
+const CapsuleManager = require('./capsule-manager');
+const ReplayRecorder = require('./recorder');
+const ReplayPlayer = require('./player');
+
+/**
+ * Main Replay API
+ */
+class ReplayEngine {
+  constructor(options = {}) {
+    this.options = {
+      basePath: process.cwd(),
+      ...options
+    };
+    
+    this.manager = new CapsuleManager(this.options.basePath);
+    this.recorder = null;
+    this.player = null;
+  }
+
+  /**
+   * Initialize the replay system
+   */
+  async init() {
+    await this.manager.init();
+    debug('Replay engine initialized');
+    return this;
+  }
+
+  /**
+   * Start a new recording session
+   */
+  startRecording(options = {}) {
+    if (this.recorder) {
+      throw new Error('Recording already in progress');
+    }
+    
+    this.recorder = new ReplayRecorder({
+      ...options,
+      basePath: this.options.basePath
+    });
+    
+    this.recorder.start();
+    debug('Started new recording session');
+    
+    return this.recorder;
+  }
+
+  /**
+   * Stop the current recording and save as a capsule
+   */
+  async stopRecording(saveOptions = {}) {
+    if (!this.recorder) {
+      throw new Error('No active recording to stop');
+    }
+    
+    const result = this.recorder.stop();
+    const { id, path: capsulePath } = await this.recorder.save(this.options.basePath);
+    
+    debug(`Recording saved as capsule: ${id} (${capsulePath})`);
+    
+    this.recorder = null;
+    
+    return {
+      id,
+      path: capsulePath,
+      metadata: result.metadata
+    };
+  }
+
+  /**
+   * List available replay capsules
+   */
+  async listCapsules() {
+    return this.manager.listCapsules();
+  }
+
+  /**
+   * Get a replay capsule by ID or path
+   */
+  async getCapsule(idOrPath) {
+    return this.manager.loadCapsule(idOrPath);
+  }
+
+  /**
+   * Delete a replay capsule
+   */
+  async deleteCapsule(idOrPath) {
+    return this.manager.deleteCapsule(idOrPath);
+  }
+
+  /**
+   * Export a capsule to a portable format
+   */
+  async exportCapsule(idOrPath, outputPath) {
+    return this.manager.exportCapsule(idOrPath, outputPath);
+  }
+
+  /**
+   * Import a capsule from a file
+   */
+  async importCapsule(filePath) {
+    return this.manager.importCapsule(filePath);
+  }
+
+  /**
+   * Create a new replay player for a capsule
+   */
+  createPlayer(options = {}) {
+    if (this.player) {
+      throw new Error('A player is already active');
+    }
+    
+    this.player = new ReplayPlayer({
+      ...this.options,
+      ...options
+    });
+    
+    return this.player;
+  }
+
+  /**
+   * Play a replay capsule
+   */
+  async playCapsule(capsule, options = {}) {
+    const player = this.createPlayer(options);
+    await player.loadCapsule(capsule);
+    
+    if (options.browser) {
+      await player.setupPlaywright(options.browser);
+    }
+    
+    return player.play();
+  }
+
+  /**
+   * Create a Playwright recorder
+   */
+  createPlaywrightRecorder(page, options = {}) {
+    return ReplayRecorder.fromPlaywright(page, {
+      ...this.options,
+      ...options
+    });
+  }
+
+  /**
+   * Clean up resources
+   */
+  async cleanup() {
+    if (this.player) {
+      await this.player.close().catch(console.error);
+      this.player = null;
+    }
+    
+    if (this.recorder) {
+      this.recorder.stop();
+      this.recorder = null;
+    }
+  }
+}
+
+// Export everything
+module.exports = {
+  // Main API
+  ReplayEngine,
+  
+  // Core components
+  CapsuleManager,
+  ReplayRecorder,
+  ReplayPlayer,
+  
+  // Factory function for quick setup
+  createReplayEngine: async (options = {}) => {
+    const engine = new ReplayEngine(options);
+    await engine.init();
+    return engine;
+  },
+  
+  // Utility functions
+  utils: {
+    /**
+     * Generate a human-readable report from replay results
+     */
+    generateReport: (results) => {
+      const { metadata, stats } = results;
+      const { name, description, duration, steps } = metadata;
+      const { passed, failed, skipped } = stats;
+      
+      return {
+        title: `Replay Report: ${name}`,
+        summary: {
+          description,
+          duration: `${(duration / 1000).toFixed(2)}s`,
+          totalSteps: steps,
+          passed,
+          failed,
+          skipped,
+          success: failed === 0
+        },
+        timestamp: new Date().toISOString(),
+        details: results.steps ? results.steps.map(step => ({
+          id: step.id,
+          type: step.type,
+          status: step.error ? 'failed' : 'passed',
+          duration: step.duration ? `${step.duration.toFixed(2)}ms` : 'N/A',
+          error: step.error ? step.error.message : null
+        })) : []
+      };
+    },
+    
+    /**
+     * Compare two replay results to detect regressions
+     */
+    compareResults: (baseline, current) => {
+      const regressions = [];
+      
+      // Check step counts
+      if (baseline.stats.totalSteps !== current.stats.totalSteps) {
+        regressions.push({
+          type: 'step_count_mismatch',
+          message: `Different number of steps: ${baseline.stats.totalSteps} vs ${current.stats.totalSteps}`
+        });
+      }
+      
+      // Check for new failures
+      if (current.stats.failed > baseline.stats.failed) {
+        regressions.push({
+          type: 'new_failures',
+          message: `New failures: ${current.stats.failed - baseline.stats.failed} more than baseline`
+        });
+      }
+      
+      // Check for performance regressions (if timing data is available)
+      if (baseline.metadata.duration && current.metadata.duration) {
+        const threshold = baseline.metadata.duration * 1.5; // 50% slower
+        if (current.metadata.duration > threshold) {
+          regressions.push({
+            type: 'performance_regression',
+            message: `Performance regression: ${(current.metadata.duration / 1000).toFixed(2)}s vs baseline ${(baseline.metadata.duration / 1000).toFixed(2)}s`
+          });
+        }
+      }
+      
+      return {
+        hasRegressions: regressions.length > 0,
+        regressions,
+        baseline: baseline.stats,
+        current: current.stats
+      };
+    }
+  }
+};