@neuroverseos/governance 0.3.1 → 0.3.4

package/dist/index.js

@@ -0,0 +1,479 @@
+import {
+  actionToGuardEvent,
+  createGovernor,
+  govern,
+  handleCreateCapsule,
+  handleHealthCheck,
+  handleListPresets,
+  handleReasonRequest,
+  writeTempWorld
+} from "./chunk-U6U7EJZL.js";
+import {
+  generateImpactReport,
+  generateImpactReportFromFile,
+  renderImpactReport
+} from "./chunk-TG6SEF24.js";
+import {
+  adaptationFromVerdict,
+  classifyAdaptation,
+  detectBehavioralPatterns,
+  generateAdaptationNarrative
+} from "./chunk-CNSO6XW5.js";
+import {
+  CompositeAuditLogger,
+  ConsoleAuditLogger,
+  FileAuditLogger,
+  createGovernanceEngine,
+  readAuditLog,
+  summarizeAuditEvents,
+  verdictToAuditEvent
+} from "./chunk-A7GKPPU7.js";
+import {
+  improveWorld,
+  renderImproveText
+} from "./chunk-F66BVUYB.js";
+import {
+  BOOTSTRAP_EXIT_CODES
+} from "./chunk-4NGDRRQH.js";
+import {
+  VALIDATE_EXIT_CODES
+} from "./chunk-I3RRAYK2.js";
+import {
+  GUARD_EXIT_CODES,
+  classifyIntentWithAI,
+  evaluateGuardWithAI,
+  extractContentFields
+} from "./chunk-VXHSMA3I.js";
+import {
+  ModelAdapter,
+  PROVIDERS,
+  resolveProvider
+} from "./chunk-A5W4GNQO.js";
+import {
+  McpGovernanceServer
+} from "./chunk-B6OXJLJ5.js";
+import {
+  addGuard,
+  addInvariant,
+  addRule,
+  classifyIntent,
+  parseGuardDescription
+} from "./chunk-5TPFNWRU.js";
+import {
+  deriveWorld,
+  extractWorldMarkdown,
+  normalizeWorldMarkdown
+} from "./chunk-YEKMVDWK.js";
+import {
+  CONFIGURE_AI_EXIT_CODES,
+  DERIVE_EXIT_CODES
+} from "./chunk-FMSTRBBS.js";
+import "./chunk-OT6PXH54.js";
+import "./chunk-INWQHLPS.js";
+import {
+  validateWorld
+} from "./chunk-7P3S7MAY.js";
+import {
+  explainWorld,
+  renderExplainText
+} from "./chunk-ZJTDUCC2.js";
+import {
+  renderSimulateText,
+  simulateWorld
+} from "./chunk-ZWI3NIXK.js";
+import {
+  PLAN_EXIT_CODES,
+  parsePlanMarkdown
+} from "./chunk-6CZSKEY5.js";
+import {
+  describeActiveWorld,
+  getActiveWorldName,
+  listWorlds,
+  resolveWorldPath,
+  setActiveWorld
+} from "./chunk-AKW5YVCE.js";
+import {
+  parseWorldMarkdown
+} from "./chunk-EMQDLDAF.js";
+import {
+  emitWorldDefinition
+} from "./chunk-PVTQQS3Y.js";
+import {
+  SessionManager,
+  runInteractiveMode,
+  runPipeMode
+} from "./chunk-IS4WUH6Y.js";
+import {
+  applyConsequence,
+  applyReward,
+  createAgentState,
+  generateDecisionFlow,
+  renderDecisionFlow,
+  tickAgentStates
+} from "./chunk-D2UCV5AK.js";
+import {
+  evaluateGuard,
+  eventToAllowlistKey
+} from "./chunk-W7LLXRGY.js";
+import {
+  advancePlan,
+  buildPlanCheck,
+  evaluatePlan,
+  getPlanProgress
+} from "./chunk-QLPTHTVB.js";
+import {
+  loadWorld,
+  loadWorldFromDirectory
+} from "./chunk-CTZHONLA.js";
+import "./chunk-QWGCMQQD.js";
+
+// src/engine/verdict-formatter.ts
+var ANSI = {
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  reset: "\x1B[0m"
+};
+function c(text, ...codes) {
+  return codes.join("") + text + ANSI.reset;
+}
+function formatVerdict(verdict, options = {}) {
+  const {
+    showRuleId = true,
+    showEvidence = false,
+    showWarning = true,
+    color = false,
+    compact = false
+  } = options;
+  if (compact) {
+    return formatCompact(verdict, { showRuleId, showWarning, color });
+  }
+  return formatFull(verdict, { showRuleId, showEvidence, showWarning, color });
+}
+function formatCompact(verdict, opts) {
+  const status = formatStatus(verdict.status, opts.color);
+  const parts = [status];
+  if (opts.showRuleId && verdict.ruleId) {
+    parts.push(verdict.ruleId);
+  }
+  if (verdict.reason) {
+    parts.push(verdict.reason);
+  }
+  if (opts.showWarning && verdict.warning) {
+    parts.push(`warning: ${verdict.warning}`);
+  }
+  return parts.join(" \u2014 ");
+}
+function formatFull(verdict, opts) {
+  const lines = [];
+  lines.push(formatStatus(verdict.status, opts.color));
+  if (opts.showRuleId && verdict.ruleId) {
+    lines.push(`  Rule: ${verdict.ruleId}`);
+  }
+  if (verdict.reason) {
+    lines.push(`  Reason: ${verdict.reason}`);
+  }
+  if (verdict.consequence) {
+    const label = opts.color ? c("Consequence:", ANSI.red) : "Consequence:";
+    lines.push(`  ${label} ${verdict.consequence.description}`);
+    if (verdict.consequence.rounds) {
+      lines.push(`  Freeze: ${verdict.consequence.rounds} round(s)`);
+    }
+    if (verdict.consequence.magnitude) {
+      lines.push(`  Magnitude: ${(verdict.consequence.magnitude * 100).toFixed(0)}%`);
+    }
+  }
+  if (verdict.reward) {
+    const label = opts.color ? c("Reward:", ANSI.blue) : "Reward:";
+    lines.push(`  ${label} ${verdict.reward.description}`);
+    if (verdict.reward.rounds) {
+      lines.push(`  Duration: ${verdict.reward.rounds} round(s)`);
+    }
+    if (verdict.reward.magnitude) {
+      lines.push(`  Boost: ${(verdict.reward.magnitude * 100).toFixed(0)}%`);
+    }
+  }
+  if (verdict.intentRecord) {
+    const ir = verdict.intentRecord;
+    const label = opts.color ? c("Intent Flow:", ANSI.cyan) : "Intent Flow:";
+    lines.push(`  ${label} ${ir.originalIntent} \u2192 ${ir.finalAction}`);
+  }
+  if (opts.showWarning && verdict.warning) {
+    const label = opts.color ? c("Warning:", ANSI.yellow) : "Warning:";
+    lines.push(`  ${label} ${verdict.warning}`);
+  }
+  if (opts.showEvidence) {
+    const ev = verdict.evidence;
+    lines.push(`  World: ${ev.worldName} v${ev.worldVersion}`);
+    lines.push(`  Invariants: ${ev.invariantsSatisfied}/${ev.invariantsTotal} covered`);
+    if (ev.guardsMatched.length > 0) {
+      lines.push(`  Guards matched: ${ev.guardsMatched.join(", ")}`);
+    }
+    if (ev.rulesMatched.length > 0) {
+      lines.push(`  Rules matched: ${ev.rulesMatched.join(", ")}`);
+    }
+    lines.push(`  Enforcement: ${ev.enforcementLevel}`);
+  }
+  return lines.join("\n");
+}
+function formatStatus(status, color) {
+  switch (status) {
+    case "ALLOW":
+      return color ? c("ALLOWED", ANSI.green, ANSI.bold) : "ALLOWED";
+    case "BLOCK":
+      return color ? c("BLOCKED", ANSI.red, ANSI.bold) : "BLOCKED";
+    case "PAUSE":
+      return color ? c("PAUSED", ANSI.yellow, ANSI.bold) : "PAUSED";
+    case "MODIFY":
+      return color ? c("MODIFIED", ANSI.yellow, ANSI.bold) : "MODIFIED";
+    case "PENALIZE":
+      return color ? c("PENALIZED", ANSI.red, ANSI.bold) : "PENALIZED";
+    case "REWARD":
+      return color ? c("REWARDED", ANSI.blue, ANSI.bold) : "REWARDED";
+    case "NEUTRAL":
+      return color ? c("NEUTRAL", ANSI.gray, ANSI.bold) : "NEUTRAL";
+    default:
+      return status;
+  }
+}
+function formatVerdictOneLine(verdict) {
+  const parts = [verdict.status];
+  if (verdict.ruleId) {
+    parts[0] += `: ${verdict.ruleId}`;
+  }
+  if (verdict.reason) {
+    parts.push(verdict.reason);
+  }
+  return parts.join(" \u2014 ");
+}
+
+// src/engine/condition-engine.ts
+function getFieldValue(event, field) {
+  if (field.startsWith("args.")) {
+    const key = field.slice(5);
+    return event.args?.[key];
+  }
+  return event[field];
+}
+function toString(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+function evaluateCondition(condition, event) {
+  const fieldValue = getFieldValue(event, condition.field);
+  if (fieldValue === void 0 && condition.operator !== "!=") {
+    return { matched: false, evidence: null };
+  }
+  switch (condition.operator) {
+    case "==":
+      return evaluateEquals(fieldValue, condition.value);
+    case "!=":
+      return evaluateNotEquals(fieldValue, condition.value);
+    case ">":
+      return evaluateComparison(fieldValue, condition.value, (a, b) => a > b);
+    case "<":
+      return evaluateComparison(fieldValue, condition.value, (a, b) => a < b);
+    case ">=":
+      return evaluateComparison(fieldValue, condition.value, (a, b) => a >= b);
+    case "<=":
+      return evaluateComparison(fieldValue, condition.value, (a, b) => a <= b);
+    case "in":
+      return evaluateIn(fieldValue, condition.value);
+    case "contains":
+      return evaluateContains(fieldValue, condition.value);
+    case "contains_any":
+      return evaluateContainsAny(fieldValue, condition.value);
+    case "matches_pattern":
+      return evaluateMatchesPattern(fieldValue, condition.value);
+    case "starts_with":
+      return evaluateStartsWith(fieldValue, condition.value);
+    case "ends_with":
+      return evaluateEndsWith(fieldValue, condition.value);
+    default:
+      return { matched: false, evidence: null };
+  }
+}
+function evaluateEquals(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue);
+  const condStr = toString(conditionValue);
+  const matched = fieldStr === condStr;
+  return {
+    matched,
+    evidence: matched ? `${fieldStr} == ${condStr}` : null
+  };
+}
+function evaluateNotEquals(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue);
+  const condStr = toString(conditionValue);
+  const matched = fieldStr !== condStr;
+  return {
+    matched,
+    evidence: matched ? `${fieldStr} != ${condStr}` : null
+  };
+}
+function evaluateComparison(fieldValue, conditionValue, comparator) {
+  const a = Number(fieldValue);
+  const b = Number(conditionValue);
+  if (isNaN(a) || isNaN(b)) return { matched: false, evidence: null };
+  const matched = comparator(a, b);
+  return {
+    matched,
+    evidence: matched ? `${a} compared to ${b}` : null
+  };
+}
+function evaluateIn(fieldValue, conditionValue) {
+  if (!Array.isArray(conditionValue)) return { matched: false, evidence: null };
+  const fieldStr = toString(fieldValue);
+  const matched = conditionValue.some((v) => toString(v) === fieldStr);
+  return {
+    matched,
+    evidence: matched ? `"${fieldStr}" found in [${conditionValue.join(", ")}]` : null
+  };
+}
+function evaluateContains(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue).toLowerCase();
+  const searchStr = toString(conditionValue).toLowerCase();
+  const matched = fieldStr.includes(searchStr);
+  return {
+    matched,
+    evidence: matched ? `"${searchStr}" found in field` : null
+  };
+}
+function evaluateContainsAny(fieldValue, conditionValue) {
+  if (!Array.isArray(conditionValue)) return { matched: false, evidence: null };
+  const fieldStr = toString(fieldValue).toLowerCase();
+  for (const pattern of conditionValue) {
+    const patternLower = toString(pattern).toLowerCase();
+    if (fieldStr.includes(patternLower)) {
+      return {
+        matched: true,
+        evidence: `"${patternLower}" found in field`
+      };
+    }
+  }
+  return { matched: false, evidence: null };
+}
+function evaluateMatchesPattern(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue);
+  const patterns = Array.isArray(conditionValue) ? conditionValue : [toString(conditionValue)];
+  for (const pattern of patterns) {
+    try {
+      const regex = new RegExp(toString(pattern), "i");
+      if (regex.test(fieldStr)) {
+        return {
+          matched: true,
+          evidence: `matched pattern /${pattern}/`
+        };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { matched: false, evidence: null };
+}
+function evaluateStartsWith(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue).toLowerCase();
+  const prefix = toString(conditionValue).toLowerCase();
+  const matched = fieldStr.startsWith(prefix);
+  return {
+    matched,
+    evidence: matched ? `field starts with "${prefix}"` : null
+  };
+}
+function evaluateEndsWith(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue).toLowerCase();
+  const suffix = toString(conditionValue).toLowerCase();
+  const matched = fieldStr.endsWith(suffix);
+  return {
+    matched,
+    evidence: matched ? `field ends with "${suffix}"` : null
+  };
+}
+export {
+  BOOTSTRAP_EXIT_CODES,
+  CONFIGURE_AI_EXIT_CODES,
+  CompositeAuditLogger,
+  ConsoleAuditLogger,
+  DERIVE_EXIT_CODES,
+  FileAuditLogger,
+  GUARD_EXIT_CODES,
+  McpGovernanceServer,
+  ModelAdapter,
+  PLAN_EXIT_CODES,
+  PROVIDERS,
+  SessionManager,
+  VALIDATE_EXIT_CODES,
+  actionToGuardEvent,
+  adaptationFromVerdict,
+  addGuard,
+  addInvariant,
+  addRule,
+  advancePlan,
+  applyConsequence,
+  applyReward,
+  buildPlanCheck,
+  classifyAdaptation,
+  classifyIntent,
+  classifyIntentWithAI,
+  createAgentState,
+  createGovernanceEngine,
+  createGovernor,
+  deriveWorld,
+  describeActiveWorld,
+  detectBehavioralPatterns,
+  emitWorldDefinition,
+  evaluateCondition,
+  evaluateGuard,
+  evaluateGuardWithAI,
+  evaluatePlan,
+  eventToAllowlistKey,
+  explainWorld,
+  extractContentFields,
+  extractWorldMarkdown,
+  formatVerdict,
+  formatVerdictOneLine,
+  generateAdaptationNarrative,
+  generateDecisionFlow,
+  generateImpactReport,
+  generateImpactReportFromFile,
+  getActiveWorldName,
+  getPlanProgress,
+  govern,
+  handleCreateCapsule,
+  handleHealthCheck,
+  handleListPresets,
+  handleReasonRequest,
+  improveWorld,
+  listWorlds,
+  loadWorld,
+  loadWorldFromDirectory,
+  normalizeWorldMarkdown,
+  parseGuardDescription,
+  parsePlanMarkdown,
+  parseWorldMarkdown,
+  readAuditLog,
+  renderDecisionFlow,
+  renderExplainText,
+  renderImpactReport,
+  renderImproveText,
+  renderSimulateText,
+  resolveProvider,
+  resolveWorldPath,
+  runInteractiveMode,
+  runPipeMode,
+  setActiveWorld,
+  simulateWorld,
+  summarizeAuditEvents,
+  tickAgentStates,
+  validateWorld,
+  verdictToAuditEvent,
+  writeTempWorld
+};