@neuroverseos/governance 0.1.0 → 0.1.2

package/dist/init-Z66T6TDI.js

@@ -0,0 +1,142 @@
+// src/cli/init.ts
+function generateTemplate(name) {
+  const worldId = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  return `---
+world_id: ${worldId}
+name: ${name}
+version: 1.0.0
+runtime_mode: SIMULATION
+default_profile: baseline
+alternative_profile: alternative
+---
+
+# Thesis
+
+Replace this with your world's structural claim \u2014 the testable hypothesis that simulation can confirm or refute.
+
+# Invariants
+
+- \`invariant_one\` \u2014 Replace with a structural truth that must always hold (structural, immutable)
+- \`invariant_two\` \u2014 Replace with another non-negotiable constraint (structural, immutable)
+
+# State
+
+## example_variable
+- type: number
+- min: 0
+- max: 100
+- step: 5
+- default: 50
+- label: Example Variable
+- description: Replace with what this variable represents
+
+## example_enum
+- type: enum
+- options: option_a, option_b, option_c
+- default: option_a
+- label: Example Enum
+- description: Replace with what this choice represents
+
+# Assumptions
+
+## baseline
+- name: Baseline Scenario
+- description: The default conditions under which the model operates
+- example_param: default_value
+
+## alternative
+- name: Alternative Scenario
+- description: What changes under different conditions
+- example_param: changed_value
+
+# Rules
+
+## rule-001: Example Rule (structural)
+Replace with a description of what this rule detects and why it matters.
+
+When example_variable < 20 [state]
+Then effective_margin *= 0.30
+Collapse: effective_margin < 0.03
+
+> trigger: Replace with what triggers this rule
+> rule: Replace with the causal mechanism
+> shift: Replace with what changes structurally
+> effect: Replace with the quantitative impact
+
+## rule-002: Example Advantage (advantage)
+Replace with a description of a positive reinforcement rule.
+
+When example_variable > 80 [state]
+Then effective_margin *= 1.15
+
+> trigger: Replace with what triggers this advantage
+> rule: Replace with why this helps
+> shift: Replace with the structural improvement
+> effect: Replace with the quantitative benefit
+
+# Gates
+
+- THRIVING: effective_margin >= 40
+- STABLE: effective_margin >= 20
+- COMPRESSED: effective_margin >= 10
+- CRITICAL: effective_margin > 3
+- MODEL_COLLAPSES: effective_margin <= 3
+
+# Outcomes
+
+## effective_margin
+- type: number
+- range: 0-100
+- display: percentage
+- label: Effective Margin
+- primary: true
+`;
+}
+function parseArgs(argv) {
+  let name = "My World";
+  let outputPath = "./world.nv-world.md";
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--name" && i + 1 < argv.length) {
+      name = argv[++i];
+    } else if (arg === "--output" && i + 1 < argv.length) {
+      outputPath = argv[++i];
+    }
+  }
+  return { name, outputPath };
+}
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs(argv);
+    const { writeFile } = await import("fs/promises");
+    const { existsSync } = await import("fs");
+    if (existsSync(args.outputPath)) {
+      process.stderr.write(`File already exists: ${args.outputPath}
+`);
+      process.stderr.write("Use a different --output path or remove the existing file.\n");
+      process.exit(1);
+      return;
+    }
+    const template = generateTemplate(args.name);
+    await writeFile(args.outputPath, template, "utf-8");
+    const result = {
+      created: args.outputPath,
+      worldName: args.name,
+      nextSteps: [
+        `Edit ${args.outputPath} \u2014 replace placeholder content with your governance spec`,
+        `neuroverse bootstrap --input ${args.outputPath} --output ./world/ --validate`,
+        "neuroverse validate --world ./world/",
+        `echo '{"intent":"test action"}' | neuroverse guard --world ./world/`
+      ]
+    };
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`Init failed: ${e}
+`);
+    process.exit(3);
+  }
+}
+export {
+  main
+};

package/dist/simulate-ETHHINZ4.js

@@ -0,0 +1,107 @@
+import {
+  renderSimulateText,
+  simulateWorld
+} from "./chunk-FYS2CBUW.js";
+import {
+  loadWorld
+} from "./chunk-M3TZFGHO.js";
+
+// src/cli/simulate.ts
+function parseArgs(argv) {
+  let worldPath = "";
+  let steps = 1;
+  let json = false;
+  let profile;
+  const stateOverrides = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      json = true;
+    } else if (arg === "--steps" && i + 1 < argv.length) {
+      steps = parseInt(argv[++i], 10);
+      if (isNaN(steps) || steps < 1) steps = 1;
+      if (steps > 50) steps = 50;
+    } else if (arg === "--profile" && i + 1 < argv.length) {
+      profile = argv[++i];
+    } else if (arg === "--set" && i + 1 < argv.length) {
+      const pair = argv[++i];
+      const eqIdx = pair.indexOf("=");
+      if (eqIdx > 0) {
+        const key = pair.slice(0, eqIdx);
+        const rawValue = pair.slice(eqIdx + 1);
+        stateOverrides[key] = parseValue(rawValue);
+      }
+    } else if (!arg.startsWith("--") && !worldPath) {
+      worldPath = arg;
+    }
+  }
+  if (!worldPath) {
+    throw new Error("Usage: neuroverse simulate <world-path-or-id> [--steps N] [--set key=value]");
+  }
+  return { worldPath, steps, stateOverrides, profile, json };
+}
+function parseValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const num = Number(raw);
+  if (!isNaN(num) && raw.trim() !== "") return num;
+  return raw;
+}
+async function resolveWorldPath(input) {
+  const { stat } = await import("fs/promises");
+  try {
+    const info = await stat(input);
+    if (info.isDirectory()) return input;
+  } catch {
+  }
+  const neuroversePath = `.neuroverse/worlds/${input}`;
+  try {
+    const info = await stat(neuroversePath);
+    if (info.isDirectory()) return neuroversePath;
+  } catch {
+  }
+  throw new Error(
+    `World not found: "${input}"
+Tried:
+  ${input}
+  ${neuroversePath}
+
+Build a world first: neuroverse build <input.md>`
+  );
+}
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs(argv);
+    const resolvedPath = await resolveWorldPath(args.worldPath);
+    const world = await loadWorld(resolvedPath);
+    const result = simulateWorld(world, {
+      steps: args.steps,
+      stateOverrides: Object.keys(args.stateOverrides).length > 0 ? args.stateOverrides : void 0,
+      profile: args.profile
+    });
+    if (args.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    } else {
+      process.stderr.write("\n");
+      process.stderr.write(renderSimulateText(result) + "\n");
+    }
+    if (!args.json) {
+      process.stderr.write("\nNext steps:\n");
+      process.stderr.write(`  Improve    neuroverse improve ${args.worldPath}
+`);
+      if (args.steps === 1) {
+        process.stderr.write(`  Deeper     neuroverse simulate ${args.worldPath} --steps 5
+`);
+      }
+      process.stderr.write("\n");
+    }
+    process.exit(result.collapsed ? 2 : 0);
+  } catch (e) {
+    process.stderr.write(`${e instanceof Error ? e.message : String(e)}
+`);
+    process.exit(1);
+  }
+}
+export {
+  main
+};

package/dist/trace-3YODSSIP.js

@@ -0,0 +1,164 @@
+import {
+  readAuditLog,
+  summarizeAuditEvents
+} from "./chunk-FYPYZFV5.js";
+import "./chunk-B4NF3OLW.js";
+
+// src/cli/trace.ts
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--summary") {
+      args.summary = true;
+    } else if (arg === "--json") {
+      args.json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      args.help = true;
+    } else if (arg === "--log" && argv[i + 1]) {
+      args.log = argv[++i];
+    } else if (arg === "--filter" && argv[i + 1]) {
+      args.filter = argv[++i].toUpperCase();
+    } else if (arg === "--actor" && argv[i + 1]) {
+      args.actor = argv[++i];
+    } else if (arg === "--intent" && argv[i + 1]) {
+      args.intent = argv[++i];
+    } else if (arg === "--last" && argv[i + 1]) {
+      args.last = argv[++i];
+    }
+  }
+  return args;
+}
+var USAGE = `
+neuroverse trace \u2014 Runtime action audit log
+
+Usage:
+  neuroverse trace [options]
+
+Options:
+  --log <path>         Path to audit log (default: .neuroverse/audit.ndjson)
+  --summary            Show aggregate summary
+  --filter <decision>  Filter: ALLOW, BLOCK, or PAUSE
+  --actor <id>         Filter by actor/role ID
+  --intent <pattern>   Filter by intent (substring)
+  --last <n>           Show last N events
+  --json               Raw JSON output
+`.trim();
+function formatEvent(event) {
+  const ts = event.timestamp.split("T")[1]?.replace("Z", "").slice(0, 8) ?? event.timestamp;
+  const icon = event.decision === "ALLOW" ? "  \u2713" : event.decision === "BLOCK" ? "  \u2717" : "  \u23F8";
+  const parts = [];
+  parts.push(`  [${ts}] ${event.actor ?? "unknown"}`);
+  parts.push(`    Action: ${event.intent}${event.tool ? ` (tool: ${event.tool})` : ""}`);
+  parts.push(`    Result:${icon} ${event.decision}`);
+  if (event.guardsMatched.length > 0) {
+    parts.push(`    Guards: ${event.guardsMatched.join(", ")}`);
+  }
+  if (event.rulesMatched.length > 0) {
+    parts.push(`    Rules:  ${event.rulesMatched.join(", ")}`);
+  }
+  if (event.reason) {
+    parts.push(`    Reason: ${event.reason}`);
+  }
+  if (event.warning) {
+    parts.push(`    Warning: ${event.warning}`);
+  }
+  return parts.join("\n");
+}
+function formatSummary(events) {
+  const summary = summarizeAuditEvents(events);
+  const lines = [];
+  lines.push("GOVERNANCE SUMMARY");
+  lines.push("\u2500".repeat(40));
+  lines.push("");
+  lines.push(`  Total actions:  ${summary.totalActions}`);
+  lines.push(`  Allowed:        ${summary.allowed}`);
+  lines.push(`  Blocked:        ${summary.blocked}`);
+  lines.push(`  Paused:         ${summary.paused}`);
+  if (summary.actors.length > 0) {
+    lines.push("");
+    lines.push(`  Actors: ${summary.actors.join(", ")}`);
+  }
+  if (summary.firstEvent) {
+    lines.push("");
+    lines.push(`  First event: ${summary.firstEvent}`);
+    lines.push(`  Last event:  ${summary.lastEvent}`);
+  }
+  if (summary.topIntents.length > 0) {
+    lines.push("");
+    lines.push("  Top actions:");
+    for (const entry of summary.topIntents.slice(0, 10)) {
+      const extra = [];
+      if (entry.blocked > 0) extra.push(`${entry.blocked} blocked`);
+      if (entry.paused > 0) extra.push(`${entry.paused} paused`);
+      const suffix = extra.length > 0 ? ` (${extra.join(", ")})` : "";
+      lines.push(`    ${entry.intent.padEnd(30)} ${String(entry.count).padStart(5)}${suffix}`);
+    }
+  }
+  if (summary.topRules.length > 0) {
+    lines.push("");
+    lines.push("  Top triggered rules/guards:");
+    for (const entry of summary.topRules.slice(0, 10)) {
+      lines.push(`    ${entry.ruleId.padEnd(30)} ${String(entry.count).padStart(5)}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    process.stdout.write(USAGE + "\n");
+    process.exit(0);
+  }
+  const logPath = args.log ?? ".neuroverse/audit.ndjson";
+  const filterFn = (event) => {
+    if (args.filter && event.decision !== args.filter) return false;
+    if (args.actor && event.actor !== args.actor) return false;
+    if (args.intent && !event.intent.includes(args.intent)) return false;
+    return true;
+  };
+  let events = await readAuditLog(logPath, filterFn);
+  if (events.length === 0) {
+    process.stderr.write(`No audit events found in ${logPath}
+`);
+    process.stderr.write("Run governance evaluations with audit logging enabled to generate events.\n");
+    process.exit(0);
+  }
+  if (args.last) {
+    const n = parseInt(args.last, 10);
+    if (n > 0 && n < events.length) {
+      events = events.slice(-n);
+    }
+  }
+  if (args.summary) {
+    if (args.json) {
+      process.stdout.write(JSON.stringify(summarizeAuditEvents(events), null, 2) + "\n");
+    } else {
+      process.stdout.write(formatSummary(events) + "\n");
+    }
+    process.exit(0);
+  }
+  if (args.json) {
+    process.stdout.write(JSON.stringify(events, null, 2) + "\n");
+    process.exit(0);
+  }
+  process.stdout.write("ACTION TRACE\n");
+  process.stdout.write("\u2500".repeat(40) + "\n");
+  for (const event of events) {
+    process.stdout.write("\n" + formatEvent(event) + "\n");
+  }
+  process.stdout.write("\n");
+  process.stdout.write(`Total: ${events.length} events`);
+  const blocked = events.filter((e) => e.decision === "BLOCK").length;
+  const paused = events.filter((e) => e.decision === "PAUSE").length;
+  if (blocked > 0 || paused > 0) {
+    const parts = [];
+    if (blocked > 0) parts.push(`${blocked} blocked`);
+    if (paused > 0) parts.push(`${paused} paused`);
+    process.stdout.write(` (${parts.join(", ")})`);
+  }
+  process.stdout.write("\n");
+}
+export {
+  main
+};

package/dist/validate-UVE6GKQU.js

@@ -0,0 +1,72 @@
+import {
+  VALIDATE_EXIT_CODES
+} from "./chunk-I3RRAYK2.js";
+import {
+  loadWorld
+} from "./chunk-M3TZFGHO.js";
+import {
+  validateWorld
+} from "./chunk-O5OMJMIE.js";
+
+// src/cli/validate.ts
+function parseArgs(argv) {
+  let worldPath = "";
+  let format = "full";
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--world" && i + 1 < argv.length) {
+      worldPath = argv[++i];
+    } else if (arg === "--format" && i + 1 < argv.length) {
+      const val = argv[++i];
+      if (val === "full" || val === "summary" || val === "findings") {
+        format = val;
+      } else {
+        throw new Error(`Invalid format: "${val}". Must be full, summary, or findings.`);
+      }
+    }
+  }
+  if (!worldPath) {
+    throw new Error("--world <path> is required");
+  }
+  return { worldPath, format };
+}
+function formatOutput(report, format) {
+  if (format === "summary") {
+    return JSON.stringify({
+      worldName: report.worldName,
+      worldVersion: report.worldVersion,
+      summary: report.summary
+    }, null, 2);
+  }
+  if (format === "findings") {
+    return JSON.stringify({
+      worldName: report.worldName,
+      findings: report.findings
+    }, null, 2);
+  }
+  return JSON.stringify(report, null, 2);
+}
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs(argv);
+    const world = await loadWorld(args.worldPath);
+    const report = validateWorld(world);
+    process.stdout.write(formatOutput(report, args.format) + "\n");
+    let exitCode;
+    if (report.summary.errors > 0) {
+      exitCode = VALIDATE_EXIT_CODES.FAIL;
+    } else if (report.summary.warnings > 0) {
+      exitCode = VALIDATE_EXIT_CODES.WARN;
+    } else {
+      exitCode = VALIDATE_EXIT_CODES.PASS;
+    }
+    process.exit(exitCode);
+  } catch (e) {
+    const errorResult = { error: "Validation failed", detail: String(e) };
+    process.stderr.write(JSON.stringify(errorResult, null, 2) + "\n");
+    process.exit(VALIDATE_EXIT_CODES.ERROR);
+  }
+}
+export {
+  main
+};

package/dist/validate-engine-657D75OG.js

@@ -0,0 +1,6 @@
+import {
+  validateWorld
+} from "./chunk-O5OMJMIE.js";
+export {
+  validateWorld
+};