@vibecheckai/cli 3.2.6 → 3.3.0

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

@@ -0,0 +1,267 @@
+/**
+ * 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

@@ -0,0 +1,436 @@
+/**
+ * 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 };