vibecheck-ai 2.0.1 → 5.0.0

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

@@ -0,0 +1,304 @@
+/**
+ * Lawbook Module
+ * 
+ * Org-Wide Invariant Libraries
+ * Formalize and enforce tribal rules across an organization.
+ * 
+ * Codename: Lawbook
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { lawbookLogger: log, getErrorMessage } = require("../logger.js");
+
+const {
+  INVARIANT_TYPES,
+  INVARIANT_SEVERITY,
+  LAWBOOK_FILE_SCHEMA,
+  validateInvariant,
+  parseLawbook,
+  serializeLawbook,
+  createDefaultLawbook,
+  createInvariantTemplate,
+} = require("./schema.js");
+
+const {
+  InvariantEvaluator,
+  createEvaluator,
+} = require("./evaluator.js");
+
+const {
+  LawbookDistributor,
+  createDistributor,
+  MERGE_STRATEGIES,
+} = require("./distributor.js");
+
+const {
+  LawbookRegistry,
+  createRegistry,
+  INDUSTRY_TEMPLATES,
+} = require("./registry.js");
+
+// Default lawbook path
+const DEFAULT_LAWBOOK_PATH = ".vibecheck/invariants.yaml";
+const LEGACY_LAWBOOK_PATH = ".vibecheck/lawbook.yaml";
+
+/**
+ * Lawbook singleton for managing invariants
+ */
+class Lawbook {
+  constructor() {
+    this.evaluator = null;
+    this.projectRoot = null;
+    this.lawbookPath = null;
+    this.loaded = false;
+  }
+  
+  /**
+   * Initialize the lawbook for a project
+   * @param {string} projectRoot - Project root directory
+   * @returns {Lawbook} This instance
+   */
+  init(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.evaluator = createEvaluator({ projectRoot });
+    
+    // Try to load existing lawbook
+    this.load();
+    
+    return this;
+  }
+  
+  /**
+   * Load lawbook from disk
+   * @param {string} customPath - Optional custom path
+   * @returns {boolean} Success
+   */
+  load(customPath = null) {
+    const paths = customPath 
+      ? [customPath]
+      : [
+          path.join(this.projectRoot, DEFAULT_LAWBOOK_PATH),
+          path.join(this.projectRoot, LEGACY_LAWBOOK_PATH),
+        ];
+    
+    for (const lawbookPath of paths) {
+      if (fs.existsSync(lawbookPath)) {
+        try {
+          const content = fs.readFileSync(lawbookPath, "utf-8");
+          const lawbook = parseLawbook(content);
+          
+          this.evaluator.clear();
+          this.evaluator.loadLawbook(lawbook);
+          this.lawbookPath = lawbookPath;
+          this.loaded = true;
+          
+          return true;
+        } catch (error) {
+          log.warn(`Failed to load lawbook from ${lawbookPath}: ${getErrorMessage(error)}`);
+        }
+      }
+    }
+    
+    this.loaded = false;
+    return false;
+  }
+  
+  /**
+   * Save current invariants to disk
+   * @param {string} customPath - Optional custom path
+   * @returns {boolean} Success
+   */
+  save(customPath = null) {
+    const savePath = customPath || this.lawbookPath || path.join(this.projectRoot, DEFAULT_LAWBOOK_PATH);
+    
+    try {
+      const dir = path.dirname(savePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      const lawbook = {
+        version: "1.0.0",
+        name: "project-invariants",
+        invariants: this.evaluator.getInvariants(),
+      };
+      
+      const content = serializeLawbook(lawbook);
+      fs.writeFileSync(savePath, content);
+      
+      this.lawbookPath = savePath;
+      return true;
+    } catch (error) {
+      log.error(`Failed to save lawbook: ${getErrorMessage(error)}`);
+      return false;
+    }
+  }
+  
+  /**
+   * Evaluate a proposal against all invariants
+   * @param {Object} proposal - Change proposal
+   * @returns {Object} Evaluation result
+   */
+  evaluate(proposal) {
+    if (!this.evaluator) {
+      return {
+        passed: true,
+        violations: [],
+        summary: { total: 0, block: 0, error: 0, warning: 0, info: 0 },
+        message: "No lawbook loaded",
+      };
+    }
+    
+    return this.evaluator.evaluate(proposal);
+  }
+  
+  /**
+   * Add an invariant
+   * @param {Object} invariant - Invariant to add
+   * @returns {boolean} Success
+   */
+  addInvariant(invariant) {
+    if (!this.evaluator) {
+      throw new Error("Lawbook not initialized");
+    }
+    
+    this.evaluator.addInvariant(invariant);
+    return true;
+  }
+  
+  /**
+   * Remove an invariant by ID
+   * @param {string} id - Invariant ID
+   * @returns {boolean} Success
+   */
+  removeInvariant(id) {
+    if (!this.evaluator) return false;
+    return this.evaluator.removeInvariant(id);
+  }
+  
+  /**
+   * Get an invariant by ID
+   * @param {string} id - Invariant ID
+   * @returns {Object|null} Invariant or null
+   */
+  getInvariant(id) {
+    if (!this.evaluator) return null;
+    return this.evaluator.getInvariant(id);
+  }
+  
+  /**
+   * Get all invariants
+   * @returns {Object[]} All invariants
+   */
+  getInvariants() {
+    if (!this.evaluator) return [];
+    return this.evaluator.getInvariants();
+  }
+  
+  /**
+   * Create a new invariant from template
+   * @param {string} id - Invariant ID
+   * @param {string} rule - Rule type
+   * @returns {Object} New invariant template
+   */
+  createTemplate(id, rule) {
+    return createInvariantTemplate(id, rule);
+  }
+  
+  /**
+   * Initialize with default lawbook if none exists
+   * @param {string} name - Lawbook name
+   * @returns {boolean} Created
+   */
+  initDefault(name = "project-invariants") {
+    const defaultPath = path.join(this.projectRoot, DEFAULT_LAWBOOK_PATH);
+    
+    if (fs.existsSync(defaultPath)) {
+      return false;
+    }
+    
+    const lawbook = createDefaultLawbook(name);
+    
+    try {
+      const dir = path.dirname(defaultPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      const content = serializeLawbook(lawbook);
+      fs.writeFileSync(defaultPath, content);
+      
+      this.evaluator.loadLawbook(lawbook);
+      this.lawbookPath = defaultPath;
+      this.loaded = true;
+      
+      return true;
+    } catch (error) {
+      log.error(`Failed to create default lawbook: ${getErrorMessage(error)}`);
+      return false;
+    }
+  }
+  
+  /**
+   * Check if lawbook is loaded
+   * @returns {boolean} Is loaded
+   */
+  isLoaded() {
+    return this.loaded;
+  }
+  
+  /**
+   * Get lawbook statistics
+   * @returns {Object} Statistics
+   */
+  getStatistics() {
+    const invariants = this.getInvariants();
+    
+    const byRule = {};
+    const bySeverity = {};
+    
+    for (const inv of invariants) {
+      byRule[inv.rule] = (byRule[inv.rule] || 0) + 1;
+      bySeverity[inv.severity || "error"] = (bySeverity[inv.severity || "error"] || 0) + 1;
+    }
+    
+    return {
+      total: invariants.length,
+      loaded: this.loaded,
+      path: this.lawbookPath,
+      byRule,
+      bySeverity,
+    };
+  }
+}
+
+// Singleton instance
+const lawbook = new Lawbook();
+
+module.exports = {
+  lawbook,
+  Lawbook,
+  // Schema exports
+  INVARIANT_TYPES,
+  INVARIANT_SEVERITY,
+  LAWBOOK_FILE_SCHEMA,
+  validateInvariant,
+  parseLawbook,
+  serializeLawbook,
+  createDefaultLawbook,
+  createInvariantTemplate,
+  // Evaluator exports
+  InvariantEvaluator,
+  createEvaluator,
+  // Distributor exports
+  LawbookDistributor,
+  createDistributor,
+  MERGE_STRATEGIES,
+  // Registry exports
+  LawbookRegistry,
+  createRegistry,
+  INDUSTRY_TEMPLATES,
+};