@vibecheckai/cli 3.4.0 → 3.5.1

package/bin/runners/lib/agent-firewall/interceptor/cursor.js

@@ -1,35 +0,0 @@
-/**
- * Cursor IDE Interceptor
- * 
- * Cursor-specific integration for agent firewall.
- * Hooks into Cursor's file write events.
- */
-
-"use strict";
-
-const { interceptFileWrite } = require("./base");
-
-/**
- * Intercept file write in Cursor
- * This would be called by Cursor's extension/plugin system
- */
-async function interceptCursorWrite({
-  projectRoot,
-  filePath,
-  content,
-  oldContent,
-  agentId = "cursor"
-}) {
-  return await interceptFileWrite({
-    projectRoot,
-    agentId,
-    intent: "Cursor AI edit",
-    filePath,
-    content,
-    oldContent
-  });
-}
-
-module.exports = {
-  interceptCursorWrite
-};

package/bin/runners/lib/agent-firewall/interceptor/vscode.js

@@ -1,35 +0,0 @@
-/**
- * VS Code LSP Interceptor
- * 
- * VS Code LSP integration for agent firewall.
- * Generic LSP hook for file writes.
- */
-
-"use strict";
-
-const { interceptFileWrite } = require("./base");
-
-/**
- * Intercept file write via LSP
- * This would be called by VS Code's LSP server
- */
-async function interceptVSCodeWrite({
-  projectRoot,
-  filePath,
-  content,
-  oldContent,
-  agentId = "vscode"
-}) {
-  return await interceptFileWrite({
-    projectRoot,
-    agentId,
-    intent: "VS Code AI edit",
-    filePath,
-    content,
-    oldContent
-  });
-}
-
-module.exports = {
-  interceptVSCodeWrite
-};

package/bin/runners/lib/agent-firewall/interceptor/windsurf.js

@@ -1,34 +0,0 @@
-/**
- * Windsurf IDE Interceptor
- * 
- * Windsurf-specific integration for agent firewall.
- */
-
-"use strict";
-
-const { interceptFileWrite } = require("./base");
-
-/**
- * Intercept file write in Windsurf
- * This would be called by Windsurf's extension/plugin system
- */
-async function interceptWindsurfWrite({
-  projectRoot,
-  filePath,
-  content,
-  oldContent,
-  agentId = "windsurf"
-}) {
-  return await interceptFileWrite({
-    projectRoot,
-    agentId,
-    intent: "Windsurf AI edit",
-    filePath,
-    content,
-    oldContent
-  });
-}
-
-module.exports = {
-  interceptWindsurfWrite
-};

package/bin/runners/lib/agent-firewall/lawbook/distributor.js

@@ -1,465 +0,0 @@
-/**
- * Lawbook Distributor
- * 
- * Syncs org-level policies to projects via API.
- * Manages version control and conflict resolution.
- * 
- * Codename: Lawbook
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const crypto = require("crypto");
-
-const { parseLawbook, serializeLawbook, validateInvariant } = require("./schema.js");
-const { lawbookLogger: log, getErrorMessage } = require("../logger.js");
-
-/**
- * @typedef {Object} SyncResult
- * @property {boolean} success - Sync successful
- * @property {number} added - Invariants added
- * @property {number} updated - Invariants updated
- * @property {number} removed - Invariants removed
- * @property {string[]} conflicts - Conflict descriptions
- * @property {string} version - Synced version
- */
-
-/**
- * Merge strategies for conflict resolution
- */
-const MERGE_STRATEGIES = {
-  ORG_WINS: "org_wins",       // Org policies override local
-  LOCAL_WINS: "local_wins",   // Local policies override org
-  STRICT: "strict",           // Fail on conflicts
-  MERGE: "merge",             // Merge with local taking precedence on conflicts
-};
-
-/**
- * Lawbook Distributor class
- */
-class LawbookDistributor {
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.apiEndpoint = options.apiEndpoint || process.env.VIBECHECK_API_URL || "https://api.vibecheck.ai";
-    this.apiKey = options.apiKey || process.env.VIBECHECK_API_KEY;
-    this.cacheDir = path.join(this.projectRoot, ".vibecheck", "lawbook-cache");
-    this.syncHistoryPath = path.join(this.projectRoot, ".vibecheck", "lawbook-sync.json");
-  }
-  
-  /**
-   * Fetch org lawbook from API
-   * @param {string} orgId - Organization ID
-   * @param {string} libraryId - Library ID (optional)
-   * @returns {Object} Fetched lawbook
-   */
-  async fetchOrgLawbook(orgId, libraryId = "default") {
-    try {
-      const url = `${this.apiEndpoint}/v1/orgs/${orgId}/lawbooks/${libraryId}`;
-      
-      const response = await fetch(url, {
-        headers: {
-          "Authorization": `Bearer ${this.apiKey}`,
-          "Content-Type": "application/json",
-        },
-      });
-      
-      if (!response.ok) {
-        throw new Error(`Failed to fetch lawbook: ${response.status}`);
-      }
-      
-      const data = await response.json();
-      
-      // Cache the result
-      this.cacheLawbook(orgId, libraryId, data);
-      
-      return data;
-    } catch (error) {
-      // Try to use cached version
-      const cached = this.getCachedLawbook(orgId, libraryId);
-      if (cached) {
-        log.warn(`Using cached lawbook: ${getErrorMessage(error)}`);
-        return cached;
-      }
-      throw error;
-    }
-  }
-  
-  /**
-   * Sync org lawbook to local project
-   * @param {string} orgId - Organization ID
-   * @param {Object} options - Sync options
-   * @returns {SyncResult} Sync result
-   */
-  async sync(orgId, options = {}) {
-    const {
-      libraryId = "default",
-      strategy = MERGE_STRATEGIES.MERGE,
-      dryRun = false,
-    } = options;
-    
-    const result = {
-      success: false,
-      added: 0,
-      updated: 0,
-      removed: 0,
-      conflicts: [],
-      version: null,
-    };
-    
-    try {
-      // Fetch org lawbook
-      const orgLawbook = await this.fetchOrgLawbook(orgId, libraryId);
-      result.version = orgLawbook.version;
-      
-      // Load local lawbook
-      const localPath = path.join(this.projectRoot, ".vibecheck", "invariants.yaml");
-      let localLawbook = null;
-      
-      if (fs.existsSync(localPath)) {
-        const content = fs.readFileSync(localPath, "utf-8");
-        localLawbook = parseLawbook(content);
-      }
-      
-      // Merge lawbooks
-      const merged = this.mergeLawbooks(orgLawbook, localLawbook, strategy, result);
-      
-      // Apply changes if not dry run
-      if (!dryRun && result.conflicts.length === 0) {
-        const dir = path.dirname(localPath);
-        if (!fs.existsSync(dir)) {
-          fs.mkdirSync(dir, { recursive: true });
-        }
-        
-        const content = serializeLawbook(merged);
-        fs.writeFileSync(localPath, content);
-        
-        // Record sync
-        this.recordSync(orgId, libraryId, result.version);
-        
-        result.success = true;
-      } else if (dryRun) {
-        result.success = true;
-      }
-      
-      return result;
-    } catch (error) {
-      result.success = false;
-      result.conflicts.push(`Sync error: ${error.message}`);
-      return result;
-    }
-  }
-  
-  /**
-   * Merge org and local lawbooks
-   * @param {Object} orgLawbook - Org lawbook
-   * @param {Object} localLawbook - Local lawbook
-   * @param {string} strategy - Merge strategy
-   * @param {Object} result - Result object to update
-   * @returns {Object} Merged lawbook
-   */
-  mergeLawbooks(orgLawbook, localLawbook, strategy, result) {
-    const merged = {
-      version: orgLawbook.version,
-      name: localLawbook?.name || orgLawbook.name,
-      description: localLawbook?.description || orgLawbook.description,
-      extends: orgLawbook.name,
-      invariants: [],
-    };
-    
-    // Index invariants by ID
-    const orgInvariants = new Map();
-    const localInvariants = new Map();
-    
-    for (const inv of orgLawbook.invariants || []) {
-      inv._source = "org";
-      orgInvariants.set(inv.id, inv);
-    }
-    
-    for (const inv of localLawbook?.invariants || []) {
-      inv._source = "local";
-      localInvariants.set(inv.id, inv);
-    }
-    
-    // Process org invariants
-    for (const [id, orgInv] of orgInvariants) {
-      const localInv = localInvariants.get(id);
-      
-      if (!localInv) {
-        // New from org
-        merged.invariants.push({ ...orgInv, _source: undefined });
-        result.added++;
-      } else {
-        // Exists in both - check for conflicts
-        const conflict = this.detectConflict(orgInv, localInv);
-        
-        if (conflict) {
-          switch (strategy) {
-            case MERGE_STRATEGIES.ORG_WINS:
-              merged.invariants.push({ ...orgInv, _source: undefined });
-              result.updated++;
-              break;
-              
-            case MERGE_STRATEGIES.LOCAL_WINS:
-              merged.invariants.push({ ...localInv, _source: undefined });
-              break;
-              
-            case MERGE_STRATEGIES.STRICT:
-              result.conflicts.push(`Conflict on '${id}': ${conflict}`);
-              break;
-              
-            case MERGE_STRATEGIES.MERGE:
-            default:
-              // Merge with local taking precedence
-              const mergedInv = { ...orgInv, ...localInv, _source: undefined };
-              merged.invariants.push(mergedInv);
-              result.updated++;
-              break;
-          }
-        } else {
-          // No conflict - use org version (might have updates)
-          merged.invariants.push({ ...orgInv, _source: undefined });
-        }
-        
-        localInvariants.delete(id);
-      }
-    }
-    
-    // Add remaining local-only invariants
-    for (const [, localInv] of localInvariants) {
-      merged.invariants.push({ ...localInv, _source: undefined });
-    }
-    
-    return merged;
-  }
-  
-  /**
-   * Detect conflict between org and local invariant
-   * @param {Object} orgInv - Org invariant
-   * @param {Object} localInv - Local invariant
-   * @returns {string|null} Conflict description or null
-   */
-  detectConflict(orgInv, localInv) {
-    // Check for rule type conflict
-    if (orgInv.rule !== localInv.rule) {
-      return `Rule type mismatch: org='${orgInv.rule}', local='${localInv.rule}'`;
-    }
-    
-    // Check for severity conflict
-    if (orgInv.severity !== localInv.severity) {
-      return `Severity mismatch: org='${orgInv.severity}', local='${localInv.severity}'`;
-    }
-    
-    // Check for scope conflict
-    if (orgInv.scope !== localInv.scope) {
-      return `Scope mismatch: org='${orgInv.scope}', local='${localInv.scope}'`;
-    }
-    
-    return null;
-  }
-  
-  /**
-   * Cache a lawbook locally
-   * @param {string} orgId - Org ID
-   * @param {string} libraryId - Library ID
-   * @param {Object} lawbook - Lawbook to cache
-   */
-  cacheLawbook(orgId, libraryId, lawbook) {
-    try {
-      if (!fs.existsSync(this.cacheDir)) {
-        fs.mkdirSync(this.cacheDir, { recursive: true });
-      }
-      
-      const cachePath = path.join(this.cacheDir, `${orgId}-${libraryId}.json`);
-      fs.writeFileSync(cachePath, JSON.stringify({
-        lawbook,
-        cachedAt: new Date().toISOString(),
-      }, null, 2));
-    } catch (error) {
-      log.warn(`Failed to cache lawbook: ${getErrorMessage(error)}`);
-    }
-  }
-  
-  /**
-   * Get cached lawbook
-   * @param {string} orgId - Org ID
-   * @param {string} libraryId - Library ID
-   * @returns {Object|null} Cached lawbook or null
-   */
-  getCachedLawbook(orgId, libraryId) {
-    try {
-      const cachePath = path.join(this.cacheDir, `${orgId}-${libraryId}.json`);
-      
-      if (fs.existsSync(cachePath)) {
-        const content = fs.readFileSync(cachePath, "utf-8");
-        const cached = JSON.parse(content);
-        
-        // Check cache age (24 hours max)
-        const cacheAge = Date.now() - new Date(cached.cachedAt).getTime();
-        if (cacheAge < 24 * 60 * 60 * 1000) {
-          return cached.lawbook;
-        }
-      }
-    } catch (error) {
-      log.warn(`Failed to read cached lawbook: ${getErrorMessage(error)}`);
-    }
-    return null;
-  }
-  
-  /**
-   * Record a sync event
-   * @param {string} orgId - Org ID
-   * @param {string} libraryId - Library ID
-   * @param {string} version - Synced version
-   */
-  recordSync(orgId, libraryId, version) {
-    try {
-      let history = [];
-      
-      if (fs.existsSync(this.syncHistoryPath)) {
-        const content = fs.readFileSync(this.syncHistoryPath, "utf-8");
-        history = JSON.parse(content);
-      }
-      
-      history.push({
-        orgId,
-        libraryId,
-        version,
-        syncedAt: new Date().toISOString(),
-      });
-      
-      // Keep last 50 entries
-      if (history.length > 50) {
-        history = history.slice(-50);
-      }
-      
-      const dir = path.dirname(this.syncHistoryPath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      
-      fs.writeFileSync(this.syncHistoryPath, JSON.stringify(history, null, 2));
-    } catch (error) {
-      log.warn(`Failed to record sync: ${getErrorMessage(error)}`);
-    }
-  }
-  
-  /**
-   * Get sync history
-   * @returns {Object[]} Sync history
-   */
-  getSyncHistory() {
-    try {
-      if (fs.existsSync(this.syncHistoryPath)) {
-        const content = fs.readFileSync(this.syncHistoryPath, "utf-8");
-        return JSON.parse(content);
-      }
-    } catch (error) {
-      log.warn(`Failed to read sync history: ${getErrorMessage(error)}`);
-    }
-    return [];
-  }
-  
-  /**
-   * Check if sync is needed
-   * @param {string} orgId - Org ID
-   * @param {string} libraryId - Library ID
-   * @returns {Object} Sync status
-   */
-  async checkSyncStatus(orgId, libraryId = "default") {
-    const history = this.getSyncHistory();
-    const lastSync = history.filter(h => h.orgId === orgId && h.libraryId === libraryId).pop();
-    
-    // Fetch current version from API
-    try {
-      const url = `${this.apiEndpoint}/v1/orgs/${orgId}/lawbooks/${libraryId}/version`;
-      const response = await fetch(url, {
-        headers: {
-          "Authorization": `Bearer ${this.apiKey}`,
-        },
-      });
-      
-      if (response.ok) {
-        const data = await response.json();
-        
-        return {
-          needsSync: !lastSync || lastSync.version !== data.version,
-          currentVersion: data.version,
-          lastSyncVersion: lastSync?.version || null,
-          lastSyncTime: lastSync?.syncedAt || null,
-        };
-      }
-    } catch (error) {
-      // Ignore - will use cached data
-    }
-    
-    return {
-      needsSync: !lastSync,
-      currentVersion: null,
-      lastSyncVersion: lastSync?.version || null,
-      lastSyncTime: lastSync?.syncedAt || null,
-    };
-  }
-  
-  /**
-   * Publish local invariants to org (requires admin)
-   * @param {string} orgId - Org ID
-   * @param {Object[]} invariants - Invariants to publish
-   * @returns {Object} Publish result
-   */
-  async publishToOrg(orgId, invariants, options = {}) {
-    const {
-      libraryId = "default",
-      message = "Published from local project",
-    } = options;
-    
-    try {
-      // Validate all invariants first
-      for (const inv of invariants) {
-        const validation = validateInvariant(inv);
-        if (!validation.valid) {
-          throw new Error(`Invalid invariant '${inv.id}': ${validation.errors.map(e => e.message).join(", ")}`);
-        }
-      }
-      
-      const url = `${this.apiEndpoint}/v1/orgs/${orgId}/lawbooks/${libraryId}/publish`;
-      
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${this.apiKey}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          invariants,
-          message,
-          publishedAt: new Date().toISOString(),
-        }),
-      });
-      
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({}));
-        throw new Error(error.message || `Publish failed: ${response.status}`);
-      }
-      
-      return await response.json();
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message,
-      };
-    }
-  }
-}
-
-/**
- * Create a distributor instance
- * @param {Object} options - Options
- * @returns {LawbookDistributor} Distributor instance
- */
-function createDistributor(options = {}) {
-  return new LawbookDistributor(options);
-}
-
-module.exports = { LawbookDistributor, createDistributor, MERGE_STRATEGIES };