@vibecheckai/cli 3.4.0 → 3.5.1

package/bin/runners/lib/agent-firewall/time-machine/index.js

@@ -1,267 +0,0 @@
-/**
- * Time Machine Module
- * 
- * Forensic Replay for AI Actions
- * Enables deep analysis and replay of what AI agents did.
- * 
- * Codename: Time Machine
- */
-
-"use strict";
-
-const { ReplayEngine, createReplayEngine } = require("./replay-engine.js");
-const { TimelineBuilder, createTimelineBuilder, EVENT_TYPES } = require("./timeline-builder.js");
-const { StateReconstructor, createStateReconstructor } = require("./state-reconstructor.js");
-const { IncidentCorrelator, createIncidentCorrelator, RELATIONSHIP_TYPES } = require("./incident-correlator.js");
-
-/**
- * Time Machine singleton for unified access
- */
-class TimeMachine {
-  constructor() {
-    this.replayEngine = null;
-    this.timelineBuilder = null;
-    this.stateReconstructor = null;
-    this.incidentCorrelator = null;
-    this.projectRoot = null;
-    this.initialized = false;
-  }
-  
-  /**
-   * Initialize the Time Machine for a project
-   * @param {string} projectRoot - Project root directory
-   * @returns {TimeMachine} This instance
-   */
-  init(projectRoot) {
-    if (this.initialized && this.projectRoot === projectRoot) {
-      return this;
-    }
-    
-    this.projectRoot = projectRoot;
-    this.replayEngine = createReplayEngine({ projectRoot });
-    this.timelineBuilder = createTimelineBuilder({ projectRoot });
-    this.stateReconstructor = createStateReconstructor({ projectRoot });
-    this.incidentCorrelator = createIncidentCorrelator({ projectRoot });
-    this.initialized = true;
-    
-    return this;
-  }
-  
-  /**
-   * Start a replay session
-   * @param {Object} options - Replay options
-   * @returns {Object} Replay session
-   */
-  async startReplay(options = {}) {
-    this.ensureInitialized();
-    return this.replayEngine.startReplay(options);
-  }
-  
-  /**
-   * Get current snapshot in a replay session
-   * @param {string} sessionId - Session ID
-   * @returns {Object|null} Current snapshot
-   */
-  getCurrentSnapshot(sessionId) {
-    this.ensureInitialized();
-    return this.replayEngine.getCurrentSnapshot(sessionId);
-  }
-  
-  /**
-   * Move to next snapshot
-   * @param {string} sessionId - Session ID
-   * @returns {Object|null} Next snapshot
-   */
-  nextSnapshot(sessionId) {
-    this.ensureInitialized();
-    return this.replayEngine.nextSnapshot(sessionId);
-  }
-  
-  /**
-   * Move to previous snapshot
-   * @param {string} sessionId - Session ID
-   * @returns {Object|null} Previous snapshot
-   */
-  previousSnapshot(sessionId) {
-    this.ensureInitialized();
-    return this.replayEngine.previousSnapshot(sessionId);
-  }
-  
-  /**
-   * Get replay session status
-   * @param {string} sessionId - Session ID
-   * @returns {Object|null} Session status
-   */
-  getSessionStatus(sessionId) {
-    this.ensureInitialized();
-    return this.replayEngine.getSessionStatus(sessionId);
-  }
-  
-  /**
-   * End a replay session
-   * @param {string} sessionId - Session ID
-   */
-  endReplay(sessionId) {
-    this.ensureInitialized();
-    this.replayEngine.endReplay(sessionId);
-  }
-  
-  /**
-   * Build a forensic timeline
-   * @param {Object} options - Timeline options
-   * @returns {Object} Forensic timeline
-   */
-  async buildTimeline(options = {}) {
-    this.ensureInitialized();
-    return this.timelineBuilder.buildTimeline(options);
-  }
-  
-  /**
-   * Generate a timeline report
-   * @param {Object} timeline - Timeline to report on
-   * @returns {Object} Report
-   */
-  generateReport(timeline) {
-    this.ensureInitialized();
-    return this.timelineBuilder.generateReport(timeline);
-  }
-  
-  /**
-   * Compare agent belief vs reality for a snapshot
-   * @param {Object} snapshot - Snapshot to analyze
-   * @returns {Object} Comparison result
-   */
-  compareBeliefVsReality(snapshot) {
-    this.ensureInitialized();
-    return this.replayEngine.compareBeliefVsReality(snapshot);
-  }
-  
-  /**
-   * Quick replay for an incident
-   * @param {string} incidentId - Incident ID
-   * @param {Object} options - Additional options
-   * @returns {Object} Replay result with timeline
-   */
-  async replayIncident(incidentId, options = {}) {
-    this.ensureInitialized();
-    
-    // Build timeline for the incident
-    const timeline = await this.buildTimeline({
-      ...options,
-      includeIncidents: true,
-    });
-    
-    // Find the incident
-    const incidentEvent = timeline.events.find(
-      e => e.id === incidentId || e.details?.incidentId === incidentId
-    );
-    
-    if (!incidentEvent) {
-      return {
-        success: false,
-        error: "Incident not found",
-      };
-    }
-    
-    // Start replay from before the incident
-    const incidentTime = new Date(incidentEvent.timestamp);
-    const lookbackMs = options.lookbackMs || 24 * 60 * 60 * 1000; // 24 hours default
-    
-    const session = await this.startReplay({
-      startTime: new Date(incidentTime.getTime() - lookbackMs),
-      endTime: incidentTime,
-      ...options,
-    });
-    
-    return {
-      success: true,
-      session,
-      timeline,
-      incident: incidentEvent,
-      rootCause: timeline.rootCause,
-      causalChain: timeline.causalChain,
-    };
-  }
-  
-  /**
-   * Reconstruct state at a specific timestamp
-   * @param {Date} timestamp - Target timestamp
-   * @param {Object} options - Options
-   * @returns {Object} Reconstructed state
-   */
-  async reconstructState(timestamp, options = {}) {
-    this.ensureInitialized();
-    return this.stateReconstructor.reconstructState(timestamp, options);
-  }
-  
-  /**
-   * Record a new incident
-   * @param {Object} incidentData - Incident data
-   * @returns {Object} Created incident
-   */
-  recordIncident(incidentData) {
-    this.ensureInitialized();
-    return this.incidentCorrelator.recordIncident(incidentData);
-  }
-  
-  /**
-   * Correlate an incident with firewall events
-   * @param {string} incidentId - Incident ID
-   * @param {Object} options - Options
-   * @returns {Object} Incident report
-   */
-  async correlateIncident(incidentId, options = {}) {
-    this.ensureInitialized();
-    return this.incidentCorrelator.correlateIncident(incidentId, options);
-  }
-  
-  /**
-   * Get all recorded incidents
-   * @returns {Object[]} All incidents
-   */
-  getAllIncidents() {
-    this.ensureInitialized();
-    return this.incidentCorrelator.getAllIncidents();
-  }
-  
-  /**
-   * Create a snapshot of current state
-   * @param {string} snapshotId - Optional snapshot ID
-   * @returns {string} Snapshot ID
-   */
-  async createSnapshot(snapshotId = null) {
-    this.ensureInitialized();
-    return this.stateReconstructor.createSnapshot(snapshotId);
-  }
-  
-  /**
-   * Ensure Time Machine is initialized
-   */
-  ensureInitialized() {
-    if (!this.initialized) {
-      throw new Error("Time Machine not initialized. Call timeMachine.init(projectRoot) first.");
-    }
-  }
-}
-
-// Singleton instance
-const timeMachine = new TimeMachine();
-
-module.exports = {
-  timeMachine,
-  TimeMachine,
-  // Replay Engine
-  ReplayEngine,
-  createReplayEngine,
-  // Timeline Builder
-  TimelineBuilder,
-  createTimelineBuilder,
-  EVENT_TYPES,
-  // State Reconstructor
-  StateReconstructor,
-  createStateReconstructor,
-  // Incident Correlator
-  IncidentCorrelator,
-  createIncidentCorrelator,
-  RELATIONSHIP_TYPES,
-};

package/bin/runners/lib/agent-firewall/time-machine/replay-engine.js

@@ -1,436 +0,0 @@
-/**
- * Time Machine Replay Engine
- * 
- * Reconstructs codebase state at any point in time.
- * Enables forensic analysis of AI agent actions.
- * 
- * Codename: Time Machine
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const { timeMachineLogger: log, getErrorMessage } = require("../logger.js");
-
-/**
- * @typedef {Object} ReplaySnapshot
- * @property {string} snapshotId - Unique snapshot ID
- * @property {Date} timestamp - Point in time
- * @property {Object} realityState - What the repo actually was
- * @property {Object} agentBelief - What the agent assumed
- * @property {Object} proposal - The change proposal
- * @property {Object} verdict - The verdict issued
- * @property {Object} [overrideContext] - Override info if applicable
- */
-
-/**
- * @typedef {Object} ReplaySession
- * @property {string} sessionId - Replay session ID
- * @property {Date} startTime - When replay started
- * @property {Date} targetTime - Point being replayed
- * @property {ReplaySnapshot[]} snapshots - Snapshots in this session
- * @property {number} currentIndex - Current position in replay
- */
-
-/**
- * Replay Engine class
- */
-class ReplayEngine {
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.packetsDir = path.join(this.projectRoot, ".vibecheck", "packets");
-    this.auditDir = path.join(this.projectRoot, ".vibecheck", "audit");
-    this.snapshotsDir = path.join(this.projectRoot, ".vibecheck", "snapshots");
-    this.sessions = new Map();
-    this.packetCache = new Map();
-  }
-  
-  /**
-   * Start a replay session for a specific time range
-   * @param {Object} options - Replay options
-   * @returns {ReplaySession} Replay session
-   */
-  async startReplay(options = {}) {
-    const {
-      startTime,
-      endTime = new Date(),
-      agentId = null,
-      file = null,
-      incidentId = null,
-    } = options;
-    
-    const sessionId = `replay_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    
-    // Load relevant packets
-    const packets = await this.loadPackets({
-      startTime,
-      endTime,
-      agentId,
-      file,
-    });
-    
-    // Build snapshots from packets
-    const snapshots = await this.buildSnapshots(packets);
-    
-    const session = {
-      sessionId,
-      startTime: new Date(),
-      targetTime: startTime,
-      options,
-      snapshots,
-      currentIndex: 0,
-      totalSnapshots: snapshots.length,
-    };
-    
-    this.sessions.set(sessionId, session);
-    
-    return session;
-  }
-  
-  /**
-   * Load change packets for a time range
-   * @param {Object} filters - Filter options
-   * @returns {Object[]} Change packets
-   */
-  async loadPackets(filters = {}) {
-    const packets = [];
-    
-    if (!fs.existsSync(this.packetsDir)) {
-      return packets;
-    }
-    
-    const files = fs.readdirSync(this.packetsDir)
-      .filter(f => f.endsWith(".json"))
-      .sort();
-    
-    for (const file of files) {
-      try {
-        const content = fs.readFileSync(path.join(this.packetsDir, file), "utf-8");
-        const packet = JSON.parse(content);
-        
-        // Apply time filter
-        const packetTime = new Date(packet.timestamp || packet.createdAt);
-        
-        if (filters.startTime && packetTime < new Date(filters.startTime)) {
-          continue;
-        }
-        
-        if (filters.endTime && packetTime > new Date(filters.endTime)) {
-          continue;
-        }
-        
-        // Apply agent filter
-        if (filters.agentId && packet.agentId !== filters.agentId) {
-          continue;
-        }
-        
-        // Apply file filter
-        if (filters.file) {
-          const affectedFiles = this.extractAffectedFiles(packet);
-          if (!affectedFiles.some(f => f.includes(filters.file))) {
-            continue;
-          }
-        }
-        
-        packets.push(packet);
-      } catch (error) {
-        log.warn(`Failed to load packet ${file}: ${getErrorMessage(error)}`);
-      }
-    }
-    
-    // Sort by timestamp
-    packets.sort((a, b) => {
-      const timeA = new Date(a.timestamp || a.createdAt).getTime();
-      const timeB = new Date(b.timestamp || b.createdAt).getTime();
-      return timeA - timeB;
-    });
-    
-    return packets;
-  }
-  
-  /**
-   * Extract affected files from a packet
-   * @param {Object} packet - Change packet
-   * @returns {string[]} Affected file paths
-   */
-  extractAffectedFiles(packet) {
-    const files = [];
-    
-    if (packet.file) files.push(packet.file);
-    if (packet.filePath) files.push(packet.filePath);
-    
-    for (const op of packet.operations || []) {
-      if (op.path) files.push(op.path);
-      if (op.file) files.push(op.file);
-      if (op.filePath) files.push(op.filePath);
-    }
-    
-    return files;
-  }
-  
-  /**
-   * Build replay snapshots from packets
-   * @param {Object[]} packets - Change packets
-   * @returns {ReplaySnapshot[]} Replay snapshots
-   */
-  async buildSnapshots(packets) {
-    const snapshots = [];
-    
-    for (const packet of packets) {
-      const snapshot = {
-        snapshotId: packet.id || `snap_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-        timestamp: new Date(packet.timestamp || packet.createdAt),
-        realityState: await this.extractRealityState(packet),
-        agentBelief: this.extractAgentBelief(packet),
-        proposal: this.extractProposal(packet),
-        verdict: this.extractVerdict(packet),
-        overrideContext: this.extractOverrideContext(packet),
-        metadata: {
-          agentId: packet.agentId,
-          sessionId: packet.sessionId,
-          file: packet.file || this.extractAffectedFiles(packet)[0],
-        },
-      };
-      
-      snapshots.push(snapshot);
-    }
-    
-    return snapshots;
-  }
-  
-  /**
-   * Extract reality state from a packet
-   * @param {Object} packet - Change packet
-   * @returns {Object} Reality state
-   */
-  async extractRealityState(packet) {
-    // Try to load from proof artifact
-    if (packet.proof?.realitySnapshot) {
-      return packet.proof.realitySnapshot;
-    }
-    
-    // Build from packet data
-    return {
-      files: this.extractAffectedFiles(packet).map(f => ({
-        path: f,
-        exists: true, // Would need historical data to verify
-      })),
-      timestamp: packet.timestamp || packet.createdAt,
-    };
-  }
-  
-  /**
-   * Extract what the agent believed/assumed
-   * @param {Object} packet - Change packet
-   * @returns {Object} Agent belief state
-   */
-  extractAgentBelief(packet) {
-    const assumptions = packet.assumptions || packet.proposal?.assumptions || [];
-    
-    return {
-      assumptions: assumptions.map(a => ({
-        type: a.type,
-        target: a.target || a.path,
-        expectedValue: a.expectedValue || a.value,
-        wasValid: a.valid !== undefined ? a.valid : null,
-      })),
-      confidence: packet.confidence || packet.proposal?.confidence,
-      intent: packet.intent || packet.proposal?.intent,
-    };
-  }
-  
-  /**
-   * Extract the proposal from a packet
-   * @param {Object} packet - Change packet
-   * @returns {Object} Proposal
-   */
-  extractProposal(packet) {
-    return {
-      proposalId: packet.proposalId || packet.id,
-      intent: packet.intent || packet.proposal?.intent,
-      operations: packet.operations || packet.proposal?.operations || [],
-      summary: packet.summary || packet.proposal?.summary,
-    };
-  }
-  
-  /**
-   * Extract the verdict from a packet
-   * @param {Object} packet - Change packet
-   * @returns {Object} Verdict
-   */
-  extractVerdict(packet) {
-    return {
-      decision: packet.verdict?.decision || packet.proof?.decision || packet.decision,
-      confidence: packet.verdict?.confidence || packet.proof?.confidence,
-      rulesTriggered: packet.verdict?.rulesTriggered || packet.proof?.rulesTriggered || [],
-      riskScore: packet.riskScore || packet.proof?.riskScore,
-      riskLevel: packet.riskLevel || packet.proof?.riskLevel,
-    };
-  }
-  
-  /**
-   * Extract override context if any
-   * @param {Object} packet - Change packet
-   * @returns {Object|null} Override context
-   */
-  extractOverrideContext(packet) {
-    if (!packet.proof?.overrideUsed && !packet.override?.used) {
-      return null;
-    }
-    
-    return {
-      used: true,
-      by: packet.proof?.overrideBy || packet.override?.by,
-      reason: packet.proof?.overrideReason || packet.override?.reason,
-      timestamp: packet.proof?.overrideTimestamp || packet.override?.timestamp,
-    };
-  }
-  
-  /**
-   * Get the current snapshot in a replay session
-   * @param {string} sessionId - Session ID
-   * @returns {ReplaySnapshot|null} Current snapshot
-   */
-  getCurrentSnapshot(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return null;
-    
-    return session.snapshots[session.currentIndex] || null;
-  }
-  
-  /**
-   * Move to the next snapshot
-   * @param {string} sessionId - Session ID
-   * @returns {ReplaySnapshot|null} Next snapshot or null if at end
-   */
-  nextSnapshot(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return null;
-    
-    if (session.currentIndex < session.snapshots.length - 1) {
-      session.currentIndex++;
-      return session.snapshots[session.currentIndex];
-    }
-    
-    return null;
-  }
-  
-  /**
-   * Move to the previous snapshot
-   * @param {string} sessionId - Session ID
-   * @returns {ReplaySnapshot|null} Previous snapshot or null if at start
-   */
-  previousSnapshot(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return null;
-    
-    if (session.currentIndex > 0) {
-      session.currentIndex--;
-      return session.snapshots[session.currentIndex];
-    }
-    
-    return null;
-  }
-  
-  /**
-   * Jump to a specific snapshot index
-   * @param {string} sessionId - Session ID
-   * @param {number} index - Index to jump to
-   * @returns {ReplaySnapshot|null} Snapshot at index
-   */
-  jumpToSnapshot(sessionId, index) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return null;
-    
-    if (index >= 0 && index < session.snapshots.length) {
-      session.currentIndex = index;
-      return session.snapshots[index];
-    }
-    
-    return null;
-  }
-  
-  /**
-   * Get session status
-   * @param {string} sessionId - Session ID
-   * @returns {Object|null} Session status
-   */
-  getSessionStatus(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return null;
-    
-    return {
-      sessionId: session.sessionId,
-      totalSnapshots: session.totalSnapshots,
-      currentIndex: session.currentIndex,
-      currentSnapshot: session.snapshots[session.currentIndex],
-      isAtStart: session.currentIndex === 0,
-      isAtEnd: session.currentIndex === session.snapshots.length - 1,
-      progress: session.totalSnapshots > 0 
-        ? Math.round((session.currentIndex / (session.totalSnapshots - 1)) * 100)
-        : 100,
-    };
-  }
-  
-  /**
-   * End a replay session
-   * @param {string} sessionId - Session ID
-   */
-  endReplay(sessionId) {
-    this.sessions.delete(sessionId);
-  }
-  
-  /**
-   * Get all active replay sessions
-   * @returns {Object[]} Active sessions
-   */
-  getActiveSessions() {
-    return Array.from(this.sessions.values()).map(s => ({
-      sessionId: s.sessionId,
-      startTime: s.startTime,
-      targetTime: s.targetTime,
-      totalSnapshots: s.totalSnapshots,
-      currentIndex: s.currentIndex,
-    }));
-  }
-  
-  /**
-   * Compare what agent believed vs what was true
-   * @param {ReplaySnapshot} snapshot - Snapshot to analyze
-   * @returns {Object} Comparison result
-   */
-  compareBeliefVsReality(snapshot) {
-    const discrepancies = [];
-    
-    for (const assumption of snapshot.agentBelief.assumptions || []) {
-      if (assumption.wasValid === false) {
-        discrepancies.push({
-          type: assumption.type,
-          target: assumption.target,
-          expected: assumption.expectedValue,
-          actual: "Did not match reality",
-          severity: "error",
-        });
-      }
-    }
-    
-    return {
-      hadDiscrepancies: discrepancies.length > 0,
-      discrepancies,
-      confidence: snapshot.agentBelief.confidence,
-      verdictIssued: snapshot.verdict.decision,
-    };
-  }
-}
-
-/**
- * Create a replay engine instance
- * @param {Object} options - Options
- * @returns {ReplayEngine} Replay engine
- */
-function createReplayEngine(options = {}) {
-  return new ReplayEngine(options);
-}
-
-module.exports = { ReplayEngine, createReplayEngine };