@vibecheckai/cli 3.3.0 → 3.5.0

package/bin/runners/lib/authority/index.js

@@ -0,0 +1,293 @@
+/**
+ * Authority System - The AI That Says No
+ * 
+ * Allows designated approvers (human or automated) to sign off on changes.
+ * 
+ * Built-in Authorities:
+ * - security: Security review (checks for vulnerabilities)
+ * - architecture: Architecture review (patterns, structure)
+ * - compliance: Compliance check (SOC2, GDPR, HIPAA, etc.)
+ * - quality: Code quality review
+ * - human: Requires human approval (creates GitHub issue/Slack message)
+ * 
+ * @example
+ * const { listAuthorities, requestApproval } = require('./authority');
+ * 
+ * // List available authorities
+ * const authorities = await listAuthorities();
+ * 
+ * // Request approval from security authority
+ * const result = await requestApproval('security', {
+ *   files: [{ path: 'src/auth.ts', content: '...' }],
+ *   diff: '+ const password = "secret123";',
+ * });
+ * 
+ * console.log(result.verdict); // 'APPROVED' or 'REJECTED'
+ */
+
+"use strict";
+
+const { SecurityAuthority } = require("./authorities/security");
+const { ArchitectureAuthority } = require("./authorities/architecture");
+const { ComplianceAuthority } = require("./authorities/compliance");
+const { QualityAuthority } = require("./authorities/quality");
+const { HumanAuthority } = require("./authorities/human");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// AUTHORITY REGISTRY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const AUTHORITIES = {
+  security: SecurityAuthority,
+  architecture: ArchitectureAuthority,
+  compliance: ComplianceAuthority,
+  quality: QualityAuthority,
+  human: HumanAuthority,
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PUBLIC API
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * List all available approval authorities
+ * 
+ * @returns {Promise<Array<{name: string, description: string, automated: boolean, tier: string}>>}
+ */
+async function listAuthorities() {
+  return Object.entries(AUTHORITIES).map(([name, Authority]) => ({
+    name,
+    description: Authority.description,
+    automated: Authority.automated,
+    tier: Authority.tier,
+  }));
+}
+
+/**
+ * Get a specific authority by name
+ * 
+ * @param {string} authorityName - Name of the authority
+ * @returns {Object|null} Authority class or null if not found
+ */
+function getAuthority(authorityName) {
+  return AUTHORITIES[authorityName] || null;
+}
+
+/**
+ * Check if an authority exists
+ * 
+ * @param {string} authorityName - Name of the authority
+ * @returns {boolean}
+ */
+function hasAuthority(authorityName) {
+  return authorityName in AUTHORITIES;
+}
+
+/**
+ * Request approval from a specific authority
+ * 
+ * @param {string} authorityName - Name of the authority to request approval from
+ * @param {Object} payload - The payload to review
+ * @param {Array<{path: string, content: string}>} payload.files - Files to review
+ * @param {string} payload.diff - Git diff of changes
+ * @param {Object} payload.context - Additional context (branch, commit, etc.)
+ * @param {Object} options - Additional options for the authority
+ * @returns {Promise<{
+ *   authority: string,
+ *   verdict: 'APPROVED' | 'REJECTED' | 'PENDING',
+ *   reason: string,
+ *   findings: Array<Object>,
+ *   timestamp: string,
+ *   signature: string,
+ *   metadata?: Object
+ * }>}
+ */
+async function requestApproval(authorityName, payload, options = {}) {
+  const Authority = AUTHORITIES[authorityName];
+  
+  if (!Authority) {
+    throw new Error(`Unknown authority: ${authorityName}`);
+  }
+
+  const authority = new Authority(options);
+  const result = await authority.review(payload);
+
+  // Determine verdict from result
+  let verdict;
+  if (result.status === "pending") {
+    verdict = "PENDING";
+  } else {
+    verdict = result.approved ? "APPROVED" : "REJECTED";
+  }
+
+  return {
+    authority: authorityName,
+    verdict,
+    reason: result.reason,
+    findings: result.findings || [],
+    timestamp: new Date().toISOString(),
+    signature: result.signature,
+    metadata: result.metadata,
+    // Include additional fields from specific authorities
+    ...(result.qualityScore !== undefined && { qualityScore: result.qualityScore }),
+    ...(result.metrics && { metrics: result.metrics }),
+    ...(result.approvalRequest && { approvalRequest: result.approvalRequest }),
+    ...(result.notifications && { notifications: result.notifications }),
+    ...(result.existingApproval && { existingApproval: result.existingApproval }),
+  };
+}
+
+/**
+ * Run multiple authorities in parallel
+ * 
+ * @param {string[]} authorityNames - Names of authorities to run
+ * @param {Object} payload - The payload to review
+ * @param {Object} options - Options passed to each authority
+ * @returns {Promise<Array<Object>>} Results from all authorities
+ */
+async function requestMultipleApprovals(authorityNames, payload, options = {}) {
+  const results = await Promise.all(
+    authorityNames.map(name => 
+      requestApproval(name, payload, options[name] || {})
+        .catch(error => ({
+          authority: name,
+          verdict: "ERROR",
+          reason: error.message,
+          findings: [],
+          timestamp: new Date().toISOString(),
+          signature: null,
+          error: true,
+        }))
+    )
+  );
+
+  return results;
+}
+
+/**
+ * Get aggregated verdict from multiple authority results
+ * 
+ * @param {Array<Object>} results - Results from requestMultipleApprovals
+ * @returns {{
+ *   verdict: 'APPROVED' | 'REJECTED' | 'PENDING',
+ *   summary: Object,
+ *   blockers: Array<string>
+ * }}
+ */
+function getAggregatedVerdict(results) {
+  const summary = {
+    total: results.length,
+    approved: 0,
+    rejected: 0,
+    pending: 0,
+    error: 0,
+  };
+
+  const blockers = [];
+
+  for (const result of results) {
+    switch (result.verdict) {
+      case "APPROVED":
+        summary.approved++;
+        break;
+      case "REJECTED":
+        summary.rejected++;
+        blockers.push(`${result.authority}: ${result.reason}`);
+        break;
+      case "PENDING":
+        summary.pending++;
+        blockers.push(`${result.authority}: Awaiting approval`);
+        break;
+      case "ERROR":
+        summary.error++;
+        blockers.push(`${result.authority}: Error - ${result.reason}`);
+        break;
+    }
+  }
+
+  let verdict;
+  if (summary.rejected > 0 || summary.error > 0) {
+    verdict = "REJECTED";
+  } else if (summary.pending > 0) {
+    verdict = "PENDING";
+  } else {
+    verdict = "APPROVED";
+  }
+
+  return {
+    verdict,
+    summary,
+    blockers,
+  };
+}
+
+/**
+ * Register a custom authority
+ * 
+ * @param {string} name - Name for the authority
+ * @param {Function} AuthorityClass - Authority class with static description, automated, tier properties
+ */
+function registerAuthority(name, AuthorityClass) {
+  if (AUTHORITIES[name]) {
+    throw new Error(`Authority "${name}" is already registered`);
+  }
+  
+  if (!AuthorityClass.description) {
+    throw new Error("Authority class must have a static 'description' property");
+  }
+  
+  if (typeof AuthorityClass.prototype.review !== "function") {
+    throw new Error("Authority class must have a 'review' method");
+  }
+
+  AUTHORITIES[name] = AuthorityClass;
+}
+
+/**
+ * Unregister a custom authority (built-in authorities cannot be removed)
+ * 
+ * @param {string} name - Name of the authority to remove
+ */
+function unregisterAuthority(name) {
+  const builtInAuthorities = ["security", "architecture", "compliance", "quality", "human"];
+  
+  if (builtInAuthorities.includes(name)) {
+    throw new Error(`Cannot unregister built-in authority: ${name}`);
+  }
+  
+  if (!AUTHORITIES[name]) {
+    throw new Error(`Authority "${name}" is not registered`);
+  }
+  
+  delete AUTHORITIES[name];
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  // Core API
+  listAuthorities,
+  requestApproval,
+  requestMultipleApprovals,
+  getAggregatedVerdict,
+  
+  // Authority management
+  getAuthority,
+  hasAuthority,
+  registerAuthority,
+  unregisterAuthority,
+  
+  // Authority classes (for extension/testing)
+  SecurityAuthority,
+  ArchitectureAuthority,
+  ComplianceAuthority,
+  QualityAuthority,
+  HumanAuthority,
+  
+  // Registry (read-only access)
+  get AUTHORITIES() {
+    return { ...AUTHORITIES };
+  },
+};