@vibecheckai/cli 3.5.0 → 3.5.1

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

@@ -1,293 +0,0 @@
-/**
- * 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 };
-  },
-};