vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/agent-firewall/session/collector.js

@@ -0,0 +1,451 @@
+/**
+ * Session Collector - Logs Changes During Vibe Sessions
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * SEAMLESS INTENT - SESSION CHANGE COLLECTOR
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * When no intent is declared (OBSERVE mode), this collector:
+ * - Logs all AI-generated changes
+ * - Tracks files modified, created, deleted
+ * - Stores changes for later review/approval
+ * - Enables post-hoc intent creation
+ * 
+ * Flow:
+ * 1. AI makes changes → collector.record(event)
+ * 2. Session ends → vibecheck approve
+ * 3. User approves → intent created retroactively
+ * 
+ * @module session/collector
+ * @version 1.0.0
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONSTANTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const SESSION_DIR = ".vibecheck/session";
+const PENDING_FILE = "pending-changes.json";
+const SESSION_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours - session timeout
+
+/**
+ * Change event types
+ */
+const CHANGE_TYPE = {
+  FILE_CREATE: "file_create",
+  FILE_MODIFY: "file_modify",
+  FILE_DELETE: "file_delete",
+  ROUTE_ADD: "route_add",
+  ENV_ADD: "env_add",
+  UNKNOWN: "unknown",
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SESSION COLLECTOR
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Session collector for tracking AI changes
+ */
+class SessionCollector {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.sessionDir = path.join(projectRoot, SESSION_DIR);
+    this.pendingFile = path.join(this.sessionDir, PENDING_FILE);
+    this._session = null;
+  }
+  
+  /**
+   * Ensure session directory exists
+   */
+  _ensureDir() {
+    if (!fs.existsSync(this.sessionDir)) {
+      fs.mkdirSync(this.sessionDir, { recursive: true });
+    }
+  }
+  
+  /**
+   * Load or create session
+   * @returns {Object} Session data
+   */
+  _loadSession() {
+    if (this._session) return this._session;
+    
+    this._ensureDir();
+    
+    if (fs.existsSync(this.pendingFile)) {
+      try {
+        const data = JSON.parse(fs.readFileSync(this.pendingFile, "utf-8"));
+        
+        // Check if session is still valid (not expired)
+        const startedAt = new Date(data.started_at).getTime();
+        if (Date.now() - startedAt > SESSION_TTL_MS) {
+          // Session expired, archive and create new
+          this._archiveSession(data);
+          this._session = this._createNewSession();
+        } else {
+          this._session = data;
+        }
+      } catch {
+        this._session = this._createNewSession();
+      }
+    } else {
+      this._session = this._createNewSession();
+    }
+    
+    return this._session;
+  }
+  
+  /**
+   * Create new session
+   * @returns {Object} New session
+   */
+  _createNewSession() {
+    return {
+      id: `session-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`,
+      started_at: new Date().toISOString(),
+      changes: [],
+      files_touched: [],
+      domains: [],
+      stats: {
+        total_changes: 0,
+        files_created: 0,
+        files_modified: 0,
+        files_deleted: 0,
+        routes_added: 0,
+        env_vars_added: 0,
+      },
+    };
+  }
+  
+  /**
+   * Save session to disk
+   */
+  _saveSession() {
+    this._ensureDir();
+    fs.writeFileSync(this.pendingFile, JSON.stringify(this._session, null, 2));
+  }
+  
+  /**
+   * Archive old session
+   * @param {Object} session - Session to archive
+   */
+  _archiveSession(session) {
+    const archiveDir = path.join(this.sessionDir, "archive");
+    if (!fs.existsSync(archiveDir)) {
+      fs.mkdirSync(archiveDir, { recursive: true });
+    }
+    
+    const archiveFile = path.join(
+      archiveDir,
+      `session-${session.id}-${Date.now()}.json`
+    );
+    
+    session.archived_at = new Date().toISOString();
+    session.archived_reason = "expired";
+    
+    fs.writeFileSync(archiveFile, JSON.stringify(session, null, 2));
+  }
+  
+  /**
+   * Record a change event
+   * @param {Object} event - Change event
+   * @returns {Object} Recorded change
+   */
+  record(event) {
+    const session = this._loadSession();
+    
+    const change = {
+      id: `change-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`,
+      timestamp: new Date().toISOString(),
+      type: event.type || CHANGE_TYPE.UNKNOWN,
+      path: event.path || event.location,
+      agent_id: event.agent_id || event.agentId || "unknown",
+      domain: event.domain || this._detectDomain(event.path || event.location),
+      diff_summary: event.diff_summary || null,
+      lines_added: event.lines_added || 0,
+      lines_removed: event.lines_removed || 0,
+    };
+    
+    // Add to changes
+    session.changes.push(change);
+    session.stats.total_changes++;
+    
+    // Track file
+    if (change.path && !session.files_touched.includes(change.path)) {
+      session.files_touched.push(change.path);
+    }
+    
+    // Track domain
+    if (change.domain && !session.domains.includes(change.domain)) {
+      session.domains.push(change.domain);
+    }
+    
+    // Update stats
+    switch (change.type) {
+      case CHANGE_TYPE.FILE_CREATE:
+        session.stats.files_created++;
+        break;
+      case CHANGE_TYPE.FILE_MODIFY:
+        session.stats.files_modified++;
+        break;
+      case CHANGE_TYPE.FILE_DELETE:
+        session.stats.files_deleted++;
+        break;
+      case CHANGE_TYPE.ROUTE_ADD:
+        session.stats.routes_added++;
+        break;
+      case CHANGE_TYPE.ENV_ADD:
+        session.stats.env_vars_added++;
+        break;
+    }
+    
+    this._saveSession();
+    
+    return change;
+  }
+  
+  /**
+   * Get pending changes
+   * @returns {Object} Session with pending changes
+   */
+  getPending() {
+    return this._loadSession();
+  }
+  
+  /**
+   * Check if there are pending changes
+   * @returns {boolean} True if pending changes exist
+   */
+  hasPending() {
+    const session = this._loadSession();
+    return session.changes.length > 0;
+  }
+  
+  /**
+   * Get summary of changes
+   * @returns {Object} Summary
+   */
+  getSummary() {
+    const session = this._loadSession();
+    
+    return {
+      session_id: session.id,
+      started_at: session.started_at,
+      duration_minutes: Math.round((Date.now() - new Date(session.started_at).getTime()) / 60000),
+      total_changes: session.stats.total_changes,
+      files_touched: session.files_touched.length,
+      domains: session.domains,
+      stats: session.stats,
+    };
+  }
+  
+  /**
+   * Generate auto-intent summary from changes
+   * @returns {string} Generated summary
+   */
+  generateIntentSummary() {
+    const session = this._loadSession();
+    
+    if (session.changes.length === 0) {
+      return "No changes";
+    }
+    
+    const domains = session.domains;
+    const files = session.files_touched;
+    const stats = session.stats;
+    
+    // Build summary
+    let summary = "";
+    
+    if (stats.files_created > 0 && stats.files_modified === 0) {
+      summary = "Created ";
+    } else if (stats.files_modified > 0 && stats.files_created === 0) {
+      summary = "Modified ";
+    } else {
+      summary = "Changed ";
+    }
+    
+    if (domains.length === 1) {
+      summary += `${domains[0]} `;
+    } else if (domains.length > 1) {
+      summary += `${domains.slice(0, 2).join(", ")} `;
+    }
+    
+    if (files.length === 1) {
+      summary += `(${path.basename(files[0])})`;
+    } else {
+      summary += `(${files.length} files)`;
+    }
+    
+    return summary;
+  }
+  
+  /**
+   * Approve all pending changes and create intent
+   * @param {string} [intentSummary] - Optional custom summary
+   * @returns {Object} Approval result with created intent
+   */
+  approve(intentSummary = null) {
+    const session = this._loadSession();
+    
+    if (session.changes.length === 0) {
+      return { success: false, error: "No pending changes to approve" };
+    }
+    
+    // Generate intent
+    const summary = intentSummary || this.generateIntentSummary();
+    
+    // Build allowed_changes from session
+    const allowed_changes = session.files_touched.map(file => ({
+      type: "file_modify",
+      target: file,
+    }));
+    
+    // Create intent
+    try {
+      const { createIntent, IntentStore } = require("../intent");
+      
+      const intent = createIntent({
+        summary,
+        constraints: [],
+        allowed_changes,
+        scope: session.domains.length > 0 ? { domains: session.domains } : undefined,
+      });
+      
+      const store = new IntentStore(this.projectRoot);
+      const storeResult = store.store(intent);
+      
+      if (!storeResult.success) {
+        return { success: false, error: storeResult.error };
+      }
+      
+      // Archive session as approved
+      session.approved_at = new Date().toISOString();
+      session.intent_hash = intent.hash;
+      this._archiveApproved(session);
+      
+      // Clear pending
+      this.clear();
+      
+      return {
+        success: true,
+        intent,
+        session_id: session.id,
+        changes_approved: session.changes.length,
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+  
+  /**
+   * Archive approved session
+   * @param {Object} session - Approved session
+   */
+  _archiveApproved(session) {
+    const archiveDir = path.join(this.sessionDir, "approved");
+    if (!fs.existsSync(archiveDir)) {
+      fs.mkdirSync(archiveDir, { recursive: true });
+    }
+    
+    const archiveFile = path.join(
+      archiveDir,
+      `approved-${session.id}.json`
+    );
+    
+    fs.writeFileSync(archiveFile, JSON.stringify(session, null, 2));
+  }
+  
+  /**
+   * Reject/clear pending changes
+   */
+  reject() {
+    const session = this._loadSession();
+    
+    if (session.changes.length > 0) {
+      session.rejected_at = new Date().toISOString();
+      this._archiveSession(session);
+    }
+    
+    this.clear();
+  }
+  
+  /**
+   * Clear pending changes (start fresh)
+   */
+  clear() {
+    this._session = this._createNewSession();
+    this._saveSession();
+  }
+  
+  /**
+   * Detect domain from file path
+   * @param {string} filePath - File path
+   * @returns {string} Domain
+   */
+  _detectDomain(filePath) {
+    if (!filePath) return "general";
+    
+    const lower = filePath.toLowerCase();
+    
+    if (lower.includes("auth") || lower.includes("login") || lower.includes("session")) {
+      return "auth";
+    }
+    if (lower.includes("payment") || lower.includes("stripe") || lower.includes("billing")) {
+      return "payments";
+    }
+    if (lower.includes("route") || lower.includes("api") || lower.includes("endpoint")) {
+      return "routes";
+    }
+    if (lower.includes("component") || lower.includes("page") || lower.includes("ui")) {
+      return "ui";
+    }
+    if (lower.includes("database") || lower.includes("prisma") || lower.includes("migration")) {
+      return "database";
+    }
+    if (lower.includes("config") || lower.includes("env") || lower.includes("setting")) {
+      return "config";
+    }
+    if (lower.includes("test") || lower.includes("spec")) {
+      return "tests";
+    }
+    
+    return "general";
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// GLOBAL COLLECTOR (for convenience)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+let _globalCollector = null;
+
+/**
+ * Get global collector instance
+ * @param {string} projectRoot - Project root
+ * @returns {SessionCollector} Collector instance
+ */
+function getCollector(projectRoot) {
+  if (!_globalCollector || _globalCollector.projectRoot !== projectRoot) {
+    _globalCollector = new SessionCollector(projectRoot);
+  }
+  return _globalCollector;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  SessionCollector,
+  getCollector,
+  CHANGE_TYPE,
+  SESSION_TTL_MS,
+};

package/bin/runners/lib/agent-firewall/session/index.js

@@ -0,0 +1,26 @@
+/**
+ * Session Module - Entry Point
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * SEAMLESS INTENT - SESSION TRACKING
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * @module session
+ * @version 1.0.0
+ */
+
+"use strict";
+
+const {
+  SessionCollector,
+  getCollector,
+  CHANGE_TYPE,
+  SESSION_TTL_MS,
+} = require("./collector");
+
+module.exports = {
+  SessionCollector,
+  getCollector,
+  CHANGE_TYPE,
+  SESSION_TTL_MS,
+};