@neuroverseos/governance 0.3.1 → 0.3.3

package/dist/chunk-5TPFNWRU.js

@@ -0,0 +1,215 @@
+import {
+  validateWorld
+} from "./chunk-7P3S7MAY.js";
+
+// src/engine/add-engine.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "").slice(0, 60);
+}
+async function addGuard(worldDir, input) {
+  const { readFile, writeFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const guardsPath = join(worldDir, "guards.json");
+  let config;
+  try {
+    const raw = await readFile(guardsPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    config = { guards: [], intent_vocabulary: {} };
+  }
+  const id = input.id ?? `guard_${slugify(input.label)}`;
+  if (config.guards.some((g) => g.id === id)) {
+    throw new Error(`Guard with id "${id}" already exists. Use a different label or provide --id.`);
+  }
+  const guard = {
+    id,
+    label: input.label,
+    description: input.description ?? input.label,
+    category: input.category ?? "operational",
+    enforcement: input.enforcement,
+    immutable: false,
+    intent_patterns: input.intentPatterns,
+    ...input.appliesTo && { appliesTo: input.appliesTo },
+    ...input.invariantRef && { invariant_ref: input.invariantRef },
+    ...input.enforcement === "modify" && input.reason && { modify_to: input.reason }
+  };
+  config.guards.push(guard);
+  await writeFile(guardsPath, JSON.stringify(config, null, 2) + "\n");
+  const { loadWorldFromDirectory } = await import("./world-loader-Y6HMQH2D.js");
+  const world = await loadWorldFromDirectory(worldDir);
+  const report = validateWorld(world);
+  return {
+    type: "guard",
+    id,
+    file: guardsPath,
+    valid: report.summary.isHealthy,
+    findings: report.findings,
+    construct: guard
+  };
+}
+async function addRule(worldDir, input) {
+  const { readFile, writeFile, mkdir } = await import("fs/promises");
+  const { join } = await import("path");
+  const { readdirSync } = await import("fs");
+  const rulesDir = join(worldDir, "rules");
+  await mkdir(rulesDir, { recursive: true });
+  let nextNum = 1;
+  try {
+    const existing = readdirSync(rulesDir).filter((f) => f.match(/^rule-\d+\.json$/)).sort();
+    if (existing.length > 0) {
+      const lastFile = existing[existing.length - 1];
+      const match = lastFile.match(/rule-(\d+)\.json/);
+      if (match) nextNum = parseInt(match[1], 10) + 1;
+    }
+  } catch {
+  }
+  const ruleNum = String(nextNum).padStart(3, "0");
+  const id = input.id ?? `rule_${slugify(input.label)}`;
+  const rule = {
+    id,
+    severity: input.severity,
+    label: input.label,
+    description: input.description ?? input.label,
+    order: nextNum,
+    triggers: input.triggers,
+    ...input.effects && { effects: input.effects },
+    ...input.collapseCheck && { collapse_check: input.collapseCheck },
+    causal_translation: input.causalTranslation ?? {
+      trigger_text: `Triggers when: ${input.triggers.map((t) => `${t.field} ${t.operator} ${t.value}`).join(" AND ")}`,
+      rule_text: input.label,
+      shift_text: input.description ?? input.label,
+      effect_text: input.effects ? input.effects.map((e) => `${e.target} ${e.operation} ${e.value}`).join(", ") : "No direct effects"
+    }
+  };
+  const rulePath = join(rulesDir, `rule-${ruleNum}.json`);
+  await writeFile(rulePath, JSON.stringify(rule, null, 2) + "\n");
+  const { loadWorldFromDirectory } = await import("./world-loader-Y6HMQH2D.js");
+  const world = await loadWorldFromDirectory(worldDir);
+  const report = validateWorld(world);
+  return {
+    type: "rule",
+    id,
+    file: rulePath,
+    valid: report.summary.isHealthy,
+    findings: report.findings,
+    construct: rule
+  };
+}
+async function addInvariant(worldDir, input) {
+  const { readFile, writeFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const invariantsPath = join(worldDir, "invariants.json");
+  let config;
+  try {
+    const raw = await readFile(invariantsPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    config = { invariants: [] };
+  }
+  const id = input.id ?? slugify(input.label);
+  if (config.invariants.some((inv) => inv.id === id)) {
+    throw new Error(`Invariant with id "${id}" already exists.`);
+  }
+  const invariant = {
+    id,
+    label: input.label,
+    enforcement: input.enforcement ?? "structural",
+    mutable: false
+  };
+  config.invariants.push(invariant);
+  await writeFile(invariantsPath, JSON.stringify(config, null, 2) + "\n");
+  const { loadWorldFromDirectory } = await import("./world-loader-Y6HMQH2D.js");
+  const world = await loadWorldFromDirectory(worldDir);
+  const report = validateWorld(world);
+  return {
+    type: "invariant",
+    id,
+    file: invariantsPath,
+    valid: report.summary.isHealthy,
+    findings: report.findings,
+    construct: invariant
+  };
+}
+function classifyIntent(text) {
+  const lower = text.toLowerCase().trim();
+  const guardPatterns = [
+    /^block\b/,
+    /^prevent\b/,
+    /^deny\b/,
+    /^reject\b/,
+    /^disallow\b/,
+    /^forbid\b/,
+    /^stop\b/,
+    /^pause\b/,
+    /^warn\s+(when|if|on|before)\b/,
+    /^require\s+approval\b/,
+    /^flag\b/,
+    /^restrict\b/
+  ];
+  const invariantPatterns = [
+    /must\s+(always|never)\b/,
+    /must\s+not\b/,
+    /shall\s+(always|never)\b/,
+    /can\s*not\s+(ever|drop|exceed|go)\b/,
+    /cannot\s+(ever|drop|exceed|go)\b/,
+    /\bmust\s+remain\b/,
+    /\balways\s+be\b/,
+    /\bnever\s+(exceed|drop|go|fall|be)\b/,
+    /\bfloor\b.*\bmust\b/,
+    /\bcap\b.*\bmust\b/,
+    /\bhard\s+limit\b/,
+    /\bguarantee\b/
+  ];
+  const rulePatterns = [
+    /^if\b.*\bthen\b/,
+    /^when\b.*\b(reduce|increase|multiply|set|add|subtract)\b/,
+    /\b(reduce|increase|multiply|degrade|boost)\b.*\bby\b/,
+    /\b(viability|margin|score|trust|budget)\b.*\b(drop|rise|change|shift)/,
+    /\beffect\b/,
+    /\btrigger\b.*\bwhen\b/,
+    /\bcollapse\b.*\bif\b/
+  ];
+  const guardScore = guardPatterns.filter((p) => p.test(lower)).length;
+  const invariantScore = invariantPatterns.filter((p) => p.test(lower)).length;
+  const ruleScore = rulePatterns.filter((p) => p.test(lower)).length;
+  const max = Math.max(guardScore, invariantScore, ruleScore);
+  if (max === 0) return "ambiguous";
+  const scores = [guardScore, invariantScore, ruleScore];
+  const winners = scores.filter((s) => s === max);
+  if (winners.length > 1) return "ambiguous";
+  if (guardScore === max) return "guard";
+  if (invariantScore === max) return "invariant";
+  return "rule";
+}
+function parseGuardDescription(text) {
+  const lower = text.toLowerCase().trim();
+  let enforcement = "block";
+  if (/^pause\b|require\s+approval/i.test(lower)) enforcement = "pause";
+  else if (/^warn\b|^flag\b/i.test(lower)) enforcement = "warn";
+  else if (/^block\b|^prevent\b|^deny\b|^reject\b|^forbid\b|^disallow\b|^stop\b/i.test(lower)) enforcement = "block";
+  const stripped = text.replace(/^(block|prevent|deny|reject|forbid|disallow|stop|pause|warn|flag|restrict)\s+(if\s+|when\s+|on\s+|before\s+)?/i, "").trim();
+  const words = stripped.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  const patterns = [];
+  if (words.length > 0) {
+    patterns.push(`*${words.join("*")}*`);
+    if (words.length > 1) {
+      for (const word of words) {
+        patterns.push(`*${word}*`);
+      }
+    }
+  }
+  return {
+    label: text,
+    enforcement,
+    intentPatterns: patterns.length > 0 ? patterns : ["*"],
+    description: text
+  };
+}
+
+export {
+  addGuard,
+  addRule,
+  addInvariant,
+  classifyIntent,
+  parseGuardDescription
+};

package/dist/chunk-5U2MQO5P.js

@@ -0,0 +1,57 @@
+import {
+  advancePlan,
+  evaluatePlan,
+  getPlanProgress
+} from "./chunk-QLPTHTVB.js";
+
+// src/adapters/shared.ts
+var GovernanceBlockedError = class extends Error {
+  verdict;
+  constructor(verdict, message) {
+    super(message ?? `[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
+    this.name = "GovernanceBlockedError";
+    this.verdict = verdict;
+  }
+};
+function trackPlanProgress(event, state, callbacks) {
+  if (!state.activePlan) return;
+  const planVerdict = evaluatePlan(event, state.activePlan);
+  if (planVerdict.matchedStep) {
+    const advResult = advancePlan(state.activePlan, planVerdict.matchedStep);
+    if (advResult.success && advResult.plan) {
+      state.activePlan = advResult.plan;
+      state.engineOptions.plan = state.activePlan;
+    }
+    const progress = getPlanProgress(state.activePlan);
+    callbacks.onPlanProgress?.(progress);
+    if (progress.completed === progress.total) {
+      callbacks.onPlanComplete?.();
+    }
+  }
+}
+function extractScope(args) {
+  if (typeof args.path === "string") return args.path;
+  if (typeof args.file_path === "string") return args.file_path;
+  if (typeof args.filename === "string") return args.filename;
+  if (typeof args.url === "string") return args.url;
+  if (typeof args.command === "string") return args.command;
+  return void 0;
+}
+function buildEngineOptions(options, plan) {
+  return {
+    trace: options.trace ?? false,
+    level: options.level,
+    plan: plan ?? options.plan
+  };
+}
+function defaultBlockMessage(verdict) {
+  return `Action blocked by governance policy: ${verdict.reason ?? "rule violation"}. Rule: ${verdict.ruleId ?? "unknown"}.`;
+}
+
+export {
+  GovernanceBlockedError,
+  trackPlanProgress,
+  extractScope,
+  buildEngineOptions,
+  defaultBlockMessage
+};

package/dist/chunk-6CZSKEY5.js

@@ -0,0 +1,164 @@
+// src/engine/plan-parser.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().replace(/\s+/g, "_");
+}
+function extractBracketAnnotation(line, key) {
+  const regex = new RegExp(`\\[${key}:\\s*([^\\]]+)\\]`, "i");
+  const match = line.match(regex);
+  if (!match) return null;
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function extractParenAnnotation(line, key) {
+  const regex = new RegExp(`\\(${key}:\\s*([^)]+)\\)`, "i");
+  const match = line.match(regex);
+  if (!match) return null;
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function stripAnnotations(line) {
+  return line.replace(/\[(?:tools|tag|verify|type):\s*[^\]]+\]/gi, "").replace(/\((?:after):\s*[^)]+\)/gi, "").trim();
+}
+function parseFrontmatter(content) {
+  const frontmatter = {};
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+  if (!fmMatch) {
+    return { frontmatter, body: content };
+  }
+  const fmBody = fmMatch[1];
+  for (const line of fmBody.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body: content.slice(fmMatch[0].length) };
+}
+function parseSections(body) {
+  const steps = [];
+  const constraints = [];
+  let currentSection = "none";
+  for (const line of body.split("\n")) {
+    const trimmed = line.trim();
+    if (/^#+\s*Steps/i.test(trimmed)) {
+      currentSection = "steps";
+      continue;
+    }
+    if (/^#+\s*Constraints/i.test(trimmed)) {
+      currentSection = "constraints";
+      continue;
+    }
+    if (/^#+\s/.test(trimmed) && currentSection !== "none") {
+      currentSection = "none";
+      continue;
+    }
+    if (trimmed.startsWith("- ")) {
+      const item = trimmed.slice(2).trim();
+      if (currentSection === "steps") {
+        steps.push(item);
+      } else if (currentSection === "constraints") {
+        constraints.push(item);
+      }
+    }
+  }
+  return { steps, constraints };
+}
+function parseStep(raw) {
+  const label = stripAnnotations(raw);
+  const id = slugify(label);
+  const tools = extractBracketAnnotation(raw, "tools");
+  const tags = extractBracketAnnotation(raw, "tag");
+  const verifyArr = extractBracketAnnotation(raw, "verify");
+  const requires = extractParenAnnotation(raw, "after");
+  return {
+    id,
+    label,
+    tools: tools ?? void 0,
+    tags: tags ?? void 0,
+    verify: verifyArr?.[0] ?? void 0,
+    requires: requires ?? void 0,
+    status: "pending"
+  };
+}
+function parseConstraint(raw, index) {
+  const typeAnnotation = extractBracketAnnotation(raw, "type");
+  const description = stripAnnotations(raw);
+  const id = `constraint_${index}`;
+  let type = "custom";
+  let enforcement = "block";
+  let limit;
+  let unit;
+  if (typeAnnotation?.[0] === "approval") {
+    type = "approval";
+    enforcement = "pause";
+  } else if (/budget|\$|spending|cost/i.test(description)) {
+    type = "budget";
+    const amountMatch = description.match(/\$?([\d,]+)/);
+    if (amountMatch) {
+      limit = parseInt(amountMatch[1].replace(/,/g, ""), 10);
+      unit = "USD";
+    }
+  } else if (/time|hour|minute|day|deadline/i.test(description)) {
+    type = "time";
+  } else if (/scope|access|database|production/i.test(description)) {
+    type = "scope";
+  }
+  const trigger = description.toLowerCase();
+  return {
+    id,
+    type,
+    description,
+    enforcement,
+    limit,
+    unit,
+    trigger
+  };
+}
+function parsePlanMarkdown(markdown) {
+  const errors = [];
+  const { frontmatter, body } = parseFrontmatter(markdown.trim());
+  const { steps: stepLines, constraints: constraintLines } = parseSections(body);
+  if (!frontmatter.plan_id) {
+    errors.push("Missing required field: plan_id");
+  }
+  if (stepLines.length === 0) {
+    errors.push("Plan must have at least one step");
+  }
+  if (errors.length > 0) {
+    return { success: false, errors };
+  }
+  const steps = stepLines.map((line) => parseStep(line));
+  const constraints = constraintLines.map((line, i) => parseConstraint(line, i));
+  let expires_at;
+  if (frontmatter.expires) {
+    expires_at = new Date(frontmatter.expires).toISOString();
+  }
+  const completionRaw = frontmatter.completion?.toLowerCase();
+  const completion = completionRaw === "verified" ? "verified" : "trust";
+  const plan = {
+    plan_id: frontmatter.plan_id,
+    objective: frontmatter.objective ?? "",
+    sequential: frontmatter.sequential === "true",
+    completion,
+    steps,
+    constraints,
+    world_id: frontmatter.world ?? void 0,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    expires_at
+  };
+  return { success: true, plan, errors: [] };
+}
+
+// src/contracts/plan-contract.ts
+var PLAN_EXIT_CODES = {
+  ON_PLAN: 0,
+  OFF_PLAN: 1,
+  CONSTRAINT_VIOLATED: 2,
+  ERROR: 3,
+  PLAN_COMPLETE: 4
+};
+
+export {
+  parsePlanMarkdown,
+  PLAN_EXIT_CODES
+};