@vibecheckai/cli 3.2.5 → 3.3.0

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

@@ -0,0 +1,490 @@
+/**
+ * Time Machine State Reconstructor
+ * 
+ * Rebuilds file and reality state at any timestamp.
+ * Shows what the AI thought vs what was actually true.
+ * 
+ * Codename: Time Machine
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+/**
+ * @typedef {Object} FileState
+ * @property {string} path - File path
+ * @property {boolean} existed - Did file exist at timestamp
+ * @property {string} [content] - File content if available
+ * @property {string} [hash] - Content hash
+ * @property {Object} [metadata] - Additional metadata
+ */
+
+/**
+ * @typedef {Object} ReconstructedState
+ * @property {Date} timestamp - Point in time
+ * @property {FileState[]} files - File states
+ * @property {Object} routes - Route registry
+ * @property {Object} envVars - Environment variables
+ * @property {Object} services - Service definitions
+ * @property {string} snapshotId - Snapshot ID used
+ */
+
+/**
+ * @typedef {Object} BeliefVsRealityComparison
+ * @property {Object} agentBelief - What agent assumed
+ * @property {Object} actualReality - What was true
+ * @property {Object[]} discrepancies - Differences found
+ * @property {number} accuracyScore - How accurate was the agent
+ */
+
+/**
+ * State Reconstructor class
+ */
+class StateReconstructor {
+  constructor(options = {}) {
+    this.projectRoot = options.projectRoot || process.cwd();
+    this.snapshotsDir = path.join(this.projectRoot, ".vibecheck", "snapshots");
+    this.packetsDir = path.join(this.projectRoot, ".vibecheck", "packets");
+    this.guardrailDir = path.join(this.projectRoot, ".guardrail");
+    this.snapshotCache = new Map();
+  }
+  
+  /**
+   * Reconstruct state at a specific timestamp
+   * @param {Date} timestamp - Target timestamp
+   * @param {Object} options - Options
+   * @returns {ReconstructedState} Reconstructed state
+   */
+  async reconstructState(timestamp, options = {}) {
+    const {
+      files = null, // Specific files to reconstruct
+      includeContent = false,
+      useSnapshots = true,
+    } = options;
+    
+    // Find the nearest snapshot before the timestamp
+    const nearestSnapshot = await this.findNearestSnapshot(timestamp);
+    
+    // Load the snapshot or build from packets
+    let baseState;
+    
+    if (nearestSnapshot && useSnapshots) {
+      baseState = await this.loadSnapshot(nearestSnapshot);
+    } else {
+      baseState = await this.buildStateFromPackets(timestamp);
+    }
+    
+    // Apply any changes between snapshot and target time
+    if (nearestSnapshot) {
+      baseState = await this.applyChanges(baseState, nearestSnapshot.timestamp, timestamp);
+    }
+    
+    // Filter to specific files if requested
+    if (files && files.length > 0) {
+      baseState.files = baseState.files.filter(f => 
+        files.some(reqFile => f.path.includes(reqFile) || reqFile.includes(f.path))
+      );
+    }
+    
+    // Optionally load content
+    if (includeContent) {
+      await this.loadFileContents(baseState, timestamp);
+    }
+    
+    return {
+      timestamp,
+      snapshotId: nearestSnapshot?.id || `reconstructed_${timestamp.getTime()}`,
+      ...baseState,
+    };
+  }
+  
+  /**
+   * Find the nearest snapshot before a timestamp
+   * @param {Date} timestamp - Target timestamp
+   * @returns {Object|null} Nearest snapshot or null
+   */
+  async findNearestSnapshot(timestamp) {
+    if (!fs.existsSync(this.snapshotsDir)) {
+      return null;
+    }
+    
+    const targetTime = timestamp.getTime();
+    let nearestSnapshot = null;
+    let nearestDiff = Infinity;
+    
+    const files = fs.readdirSync(this.snapshotsDir)
+      .filter(f => f.endsWith(".json"))
+      .sort();
+    
+    for (const file of files) {
+      try {
+        const snapshotPath = path.join(this.snapshotsDir, file);
+        const content = fs.readFileSync(snapshotPath, "utf-8");
+        const snapshot = JSON.parse(content);
+        
+        const snapshotTime = new Date(snapshot.timestamp).getTime();
+        
+        // Only consider snapshots before or at the target time
+        if (snapshotTime <= targetTime) {
+          const diff = targetTime - snapshotTime;
+          if (diff < nearestDiff) {
+            nearestDiff = diff;
+            nearestSnapshot = {
+              id: file.replace(".json", ""),
+              path: snapshotPath,
+              timestamp: new Date(snapshot.timestamp),
+              data: snapshot,
+            };
+          }
+        }
+      } catch {
+        // Skip invalid snapshots
+      }
+    }
+    
+    return nearestSnapshot;
+  }
+  
+  /**
+   * Load a snapshot
+   * @param {Object} snapshotInfo - Snapshot info
+   * @returns {Object} Loaded state
+   */
+  async loadSnapshot(snapshotInfo) {
+    if (this.snapshotCache.has(snapshotInfo.id)) {
+      return JSON.parse(JSON.stringify(this.snapshotCache.get(snapshotInfo.id)));
+    }
+    
+    const state = {
+      files: snapshotInfo.data.files || [],
+      routes: snapshotInfo.data.routes || {},
+      envVars: snapshotInfo.data.envVars || {},
+      services: snapshotInfo.data.services || {},
+    };
+    
+    this.snapshotCache.set(snapshotInfo.id, state);
+    
+    return JSON.parse(JSON.stringify(state));
+  }
+  
+  /**
+   * Build state from change packets
+   * @param {Date} timestamp - Target timestamp
+   * @returns {Object} Built state
+   */
+  async buildStateFromPackets(timestamp) {
+    const state = {
+      files: [],
+      routes: {},
+      envVars: {},
+      services: {},
+    };
+    
+    // Try to load from guardrail context
+    const contextPath = path.join(this.guardrailDir, "context-snapshot.json");
+    
+    if (fs.existsSync(contextPath)) {
+      try {
+        const context = JSON.parse(fs.readFileSync(contextPath, "utf-8"));
+        
+        // Extract file information
+        if (context.files) {
+          state.files = Object.entries(context.files).map(([filePath, info]) => ({
+            path: filePath,
+            existed: true,
+            hash: info.hash,
+            metadata: info,
+          }));
+        }
+        
+        // Extract routes
+        if (context.routes) {
+          state.routes = context.routes;
+        }
+        
+        // Extract env vars
+        if (context.envVars) {
+          state.envVars = context.envVars;
+        }
+      } catch {
+        // Ignore errors
+      }
+    }
+    
+    // Apply changes from packets up to timestamp
+    if (fs.existsSync(this.packetsDir)) {
+      const packets = fs.readdirSync(this.packetsDir)
+        .filter(f => f.endsWith(".json"))
+        .sort();
+      
+      for (const packetFile of packets) {
+        try {
+          const packet = JSON.parse(
+            fs.readFileSync(path.join(this.packetsDir, packetFile), "utf-8")
+          );
+          
+          const packetTime = new Date(packet.timestamp || packet.createdAt);
+          if (packetTime > timestamp) break;
+          
+          // Apply packet changes to state
+          this.applyPacketToState(state, packet);
+        } catch {
+          // Skip invalid packets
+        }
+      }
+    }
+    
+    return state;
+  }
+  
+  /**
+   * Apply a packet's changes to state
+   * @param {Object} state - State to modify
+   * @param {Object} packet - Packet to apply
+   */
+  applyPacketToState(state, packet) {
+    for (const op of packet.operations || []) {
+      const filePath = op.path || op.file;
+      if (!filePath) continue;
+      
+      const existingIndex = state.files.findIndex(f => f.path === filePath);
+      
+      switch (op.type) {
+        case "create":
+          if (existingIndex === -1) {
+            state.files.push({
+              path: filePath,
+              existed: true,
+              hash: op.content ? this.hashContent(op.content) : null,
+            });
+          } else {
+            state.files[existingIndex].existed = true;
+            if (op.content) {
+              state.files[existingIndex].hash = this.hashContent(op.content);
+            }
+          }
+          break;
+          
+        case "delete":
+          if (existingIndex !== -1) {
+            state.files[existingIndex].existed = false;
+          }
+          break;
+          
+        case "modify":
+          if (existingIndex !== -1 && op.content) {
+            state.files[existingIndex].hash = this.hashContent(op.content);
+          }
+          break;
+      }
+    }
+  }
+  
+  /**
+   * Apply changes between two timestamps
+   * @param {Object} state - Base state
+   * @param {Date} fromTime - Start time
+   * @param {Date} toTime - End time
+   * @returns {Object} Updated state
+   */
+  async applyChanges(state, fromTime, toTime) {
+    if (!fs.existsSync(this.packetsDir)) {
+      return state;
+    }
+    
+    const packets = fs.readdirSync(this.packetsDir)
+      .filter(f => f.endsWith(".json"))
+      .sort();
+    
+    for (const packetFile of packets) {
+      try {
+        const packet = JSON.parse(
+          fs.readFileSync(path.join(this.packetsDir, packetFile), "utf-8")
+        );
+        
+        const packetTime = new Date(packet.timestamp || packet.createdAt);
+        
+        if (packetTime <= fromTime) continue;
+        if (packetTime > toTime) break;
+        
+        this.applyPacketToState(state, packet);
+      } catch {
+        // Skip invalid packets
+      }
+    }
+    
+    return state;
+  }
+  
+  /**
+   * Load file contents for a state
+   * @param {Object} state - State to load content for
+   * @param {Date} timestamp - Target timestamp
+   */
+  async loadFileContents(state, timestamp) {
+    // For now, we can only load current content
+    // Historical content would require git integration
+    for (const file of state.files) {
+      if (file.existed) {
+        const fullPath = path.resolve(this.projectRoot, file.path);
+        
+        if (fs.existsSync(fullPath)) {
+          try {
+            file.content = fs.readFileSync(fullPath, "utf-8");
+            file.currentHash = this.hashContent(file.content);
+          } catch {
+            // Skip unreadable files
+          }
+        }
+      }
+    }
+  }
+  
+  /**
+   * Compare agent belief vs actual reality
+   * @param {Object} agentBelief - What agent assumed
+   * @param {ReconstructedState} actualState - Reconstructed reality
+   * @returns {BeliefVsRealityComparison} Comparison result
+   */
+  compareBeliefVsReality(agentBelief, actualState) {
+    const discrepancies = [];
+    let correctAssumptions = 0;
+    let totalAssumptions = 0;
+    
+    for (const assumption of agentBelief.assumptions || []) {
+      totalAssumptions++;
+      
+      const check = this.checkAssumption(assumption, actualState);
+      
+      if (!check.valid) {
+        discrepancies.push({
+          assumption: assumption.type,
+          target: assumption.target,
+          expected: assumption.expectedValue,
+          actual: check.actualValue,
+          message: check.message,
+        });
+      } else {
+        correctAssumptions++;
+      }
+    }
+    
+    const accuracyScore = totalAssumptions > 0
+      ? Math.round((correctAssumptions / totalAssumptions) * 100)
+      : 100;
+    
+    return {
+      agentBelief,
+      actualReality: {
+        fileCount: actualState.files.filter(f => f.existed).length,
+        routeCount: Object.keys(actualState.routes).length,
+        envVarCount: Object.keys(actualState.envVars).length,
+      },
+      discrepancies,
+      accuracyScore,
+      totalAssumptions,
+      correctAssumptions,
+    };
+  }
+  
+  /**
+   * Check if an assumption matches reality
+   * @param {Object} assumption - Assumption to check
+   * @param {ReconstructedState} state - Reality state
+   * @returns {Object} Check result
+   */
+  checkAssumption(assumption, state) {
+    switch (assumption.type) {
+      case "file_exists": {
+        const file = state.files.find(f => f.path === assumption.target);
+        const exists = file?.existed ?? false;
+        const expected = assumption.expectedValue !== false;
+        return {
+          valid: exists === expected,
+          actualValue: exists,
+          message: exists === expected ? "Match" : `File ${expected ? "does not exist" : "exists unexpectedly"}`,
+        };
+      }
+      
+      case "route_exists": {
+        const routeExists = !!state.routes[assumption.target];
+        const expected = assumption.expectedValue !== false;
+        return {
+          valid: routeExists === expected,
+          actualValue: routeExists,
+          message: routeExists === expected ? "Match" : `Route ${expected ? "does not exist" : "exists unexpectedly"}`,
+        };
+      }
+      
+      case "env_exists": {
+        const envExists = !!state.envVars[assumption.target];
+        const expected = assumption.expectedValue !== false;
+        return {
+          valid: envExists === expected,
+          actualValue: envExists,
+          message: envExists === expected ? "Match" : `Env var ${expected ? "does not exist" : "exists unexpectedly"}`,
+        };
+      }
+      
+      default:
+        return {
+          valid: true,
+          actualValue: "unknown",
+          message: "Cannot verify assumption type",
+        };
+    }
+  }
+  
+  /**
+   * Create a snapshot of current state
+   * @param {string} snapshotId - Optional snapshot ID
+   * @returns {string} Snapshot ID
+   */
+  async createSnapshot(snapshotId = null) {
+    const id = snapshotId || `snapshot_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    
+    // Build current state
+    const state = await this.buildStateFromPackets(new Date());
+    
+    const snapshot = {
+      id,
+      timestamp: new Date().toISOString(),
+      ...state,
+    };
+    
+    // Save snapshot
+    if (!fs.existsSync(this.snapshotsDir)) {
+      fs.mkdirSync(this.snapshotsDir, { recursive: true });
+    }
+    
+    fs.writeFileSync(
+      path.join(this.snapshotsDir, `${id}.json`),
+      JSON.stringify(snapshot, null, 2)
+    );
+    
+    return id;
+  }
+  
+  /**
+   * Hash content for comparison
+   * @param {string} content - Content to hash
+   * @returns {string} Hash
+   */
+  hashContent(content) {
+    return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  }
+}
+
+/**
+ * Create a state reconstructor instance
+ * @param {Object} options - Options
+ * @returns {StateReconstructor} State reconstructor
+ */
+function createStateReconstructor(options = {}) {
+  return new StateReconstructor(options);
+}
+
+module.exports = { StateReconstructor, createStateReconstructor };