@neuroverseos/governance 0.1.0 → 0.1.2

package/dist/cli/neuroverse.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/neuroverse.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/neuroverse.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+// src/cli/neuroverse.ts
+var USAGE = `
+neuroverse \u2014 Turn ideas into worlds.
+
+Commands:
+  build          Build a world from markdown (derive + compile in one step)
+  explain        Human-readable summary of a compiled world
+  simulate       Step-by-step state evolution
+  improve        Actionable suggestions for strengthening a world
+  init           Scaffold a new .nv-world.md template
+  validate       Static analysis on world files
+  guard          Runtime governance evaluation (stdin \u2192 stdout)
+  trace          Runtime action audit log
+  impact         Counterfactual governance impact report
+  world          World management (status, diff, snapshot, rollback)
+  derive         AI-assisted synthesis of .nv-world.md from markdown
+  bootstrap      Compile .nv-world.md \u2192 world JSON files
+  configure-ai   Configure AI provider credentials
+
+Usage:
+  neuroverse build <input.md> [--output <dir>]
+  neuroverse explain <world-path-or-id> [--json]
+  neuroverse simulate <world-path-or-id> [--steps N] [--set key=value] [--profile name]
+  neuroverse improve <world-path-or-id> [--json]
+  neuroverse init [--name "World Name"] [--output path]
+  neuroverse validate --world <dir> [--format full|summary|findings]
+  neuroverse guard --world <dir> [--trace] [--level basic|standard|strict]
+  neuroverse trace [--log <path>] [--summary] [--filter BLOCK] [--last 20]
+  neuroverse impact [--log <path>] [--json]
+  neuroverse world status <path>
+  neuroverse world diff <path1> <path2>
+  neuroverse world snapshot <path>
+  neuroverse world rollback <path>
+  neuroverse derive --input <path> [--output <path>] [--dry-run]
+  neuroverse bootstrap --input <.md> --output <dir> [--validate]
+  neuroverse configure-ai --provider <name> --model <name> --api-key <key>
+
+Examples:
+  neuroverse build horror-notes.md
+  neuroverse explain inherited_silence
+  neuroverse simulate inherited_silence --steps 5
+  neuroverse improve inherited_silence
+  neuroverse build ./docs/ --output ./my-world/
+  neuroverse init --name "Customer Service Governance"
+  neuroverse validate --world ./world/ --format summary
+  echo '{"intent":"delete user data"}' | neuroverse guard --world ./world/ --trace
+`.trim();
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const subArgs = args.slice(1);
+  switch (command) {
+    case "build": {
+      const { main: buildMain } = await import("../build-73KAVHEY.js");
+      return buildMain(subArgs);
+    }
+    case "explain": {
+      const { main: explainMain } = await import("../explain-3B3VB6TL.js");
+      return explainMain(subArgs);
+    }
+    case "simulate": {
+      const { main: simulateMain } = await import("../simulate-ETHHINZ4.js");
+      return simulateMain(subArgs);
+    }
+    case "improve": {
+      const { main: improveMain } = await import("../improve-YG6I6ERG.js");
+      return improveMain(subArgs);
+    }
+    case "init": {
+      const { main: initMain } = await import("../init-Z66T6TDI.js");
+      return initMain(subArgs);
+    }
+    case "bootstrap": {
+      const { main: bootstrapMain } = await import("../bootstrap-H4HHKQ5G.js");
+      return bootstrapMain(subArgs);
+    }
+    case "validate": {
+      const { main: validateMain } = await import("../validate-UVE6GKQU.js");
+      return validateMain(subArgs);
+    }
+    case "guard": {
+      const { main: guardMain } = await import("../guard-67Y66P3I.js");
+      return guardMain(subArgs);
+    }
+    case "trace": {
+      const { main: traceMain } = await import("../trace-3YODSSIP.js");
+      return traceMain(subArgs);
+    }
+    case "impact": {
+      const { main: impactMain } = await import("../impact-CHERK3O6.js");
+      return impactMain(subArgs);
+    }
+    case "world": {
+      const { main: worldMain } = await import("../world-WLNHL5XC.js");
+      return worldMain(subArgs);
+    }
+    case "derive": {
+      const { main: deriveMain } = await import("../derive-6NAEWLM5.js");
+      return deriveMain(subArgs);
+    }
+    case "configure-ai": {
+      const { main: configureAiMain } = await import("../configure-ai-46JVG56I.js");
+      return configureAiMain(subArgs);
+    }
+    case "--help":
+    case "-h":
+    case "help":
+    case void 0: {
+      process.stdout.write(USAGE + "\n");
+      process.exit(0);
+      break;
+    }
+    default: {
+      process.stderr.write(`Unknown command: "${command}"
+
+`);
+      process.stdout.write(USAGE + "\n");
+      process.exit(1);
+    }
+  }
+}
+main().catch((e) => {
+  process.stderr.write(`Fatal: ${e}
+`);
+  process.exit(3);
+});

package/dist/configure-ai-46JVG56I.js

@@ -0,0 +1,129 @@
+import {
+  CONFIGURE_AI_EXIT_CODES,
+  createProvider,
+  getConfigPath,
+  loadConfig,
+  redactConfig,
+  saveConfig
+} from "./chunk-T4X42QXC.js";
+
+// src/cli/configure-ai.ts
+function parseArgs(argv) {
+  let provider;
+  let model;
+  let apiKey;
+  let endpoint;
+  let show = false;
+  let test = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--provider" && i + 1 < argv.length) {
+      provider = argv[++i];
+    } else if (arg === "--model" && i + 1 < argv.length) {
+      model = argv[++i];
+    } else if (arg === "--api-key" && i + 1 < argv.length) {
+      apiKey = argv[++i];
+    } else if (arg === "--endpoint" && i + 1 < argv.length) {
+      endpoint = argv[++i];
+    } else if (arg === "--show") {
+      show = true;
+    } else if (arg === "--test") {
+      test = true;
+    }
+  }
+  return { provider, model, apiKey, endpoint, show, test };
+}
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs(argv);
+    if (args.show) {
+      const config2 = await loadConfig();
+      if (!config2) {
+        process.stdout.write(JSON.stringify({
+          configured: false,
+          configPath: getConfigPath()
+        }, null, 2) + "\n");
+      } else {
+        process.stdout.write(JSON.stringify({
+          configured: true,
+          configPath: getConfigPath(),
+          ...redactConfig(config2)
+        }, null, 2) + "\n");
+      }
+      process.exit(CONFIGURE_AI_EXIT_CODES.SUCCESS);
+      return;
+    }
+    if (args.test) {
+      const config2 = await loadConfig();
+      if (!config2) {
+        process.stderr.write(JSON.stringify({
+          error: "No configuration found. Run: neuroverse configure-ai --provider ... --model ... --api-key ..."
+        }, null, 2) + "\n");
+        process.exit(CONFIGURE_AI_EXIT_CODES.VALIDATION_FAIL);
+        return;
+      }
+      try {
+        const provider = createProvider(config2);
+        await provider.complete("You are a test. Respond with only: OK", "Test connection.");
+        process.stdout.write(JSON.stringify({
+          success: true,
+          message: "Connection test passed",
+          ...redactConfig(config2)
+        }, null, 2) + "\n");
+        process.exit(CONFIGURE_AI_EXIT_CODES.SUCCESS);
+      } catch (e) {
+        process.stderr.write(JSON.stringify({
+          success: false,
+          error: `Connection test failed: ${e instanceof Error ? e.message : String(e)}`
+        }, null, 2) + "\n");
+        process.exit(CONFIGURE_AI_EXIT_CODES.VALIDATION_FAIL);
+      }
+      return;
+    }
+    if (!args.provider && !args.model && !args.apiKey && !args.endpoint) {
+      process.stderr.write(JSON.stringify({
+        error: "Provide at least one of: --provider, --model, --api-key, --endpoint",
+        usage: "neuroverse configure-ai --provider openai --model gpt-4.1-mini --api-key sk-..."
+      }, null, 2) + "\n");
+      process.exit(CONFIGURE_AI_EXIT_CODES.VALIDATION_FAIL);
+      return;
+    }
+    const existing = await loadConfig();
+    const config = {
+      provider: args.provider ?? existing?.provider ?? "openai",
+      model: args.model ?? existing?.model ?? "",
+      apiKey: args.apiKey ?? existing?.apiKey ?? "",
+      endpoint: args.endpoint ?? existing?.endpoint ?? null
+    };
+    if (!config.model) {
+      process.stderr.write(JSON.stringify({
+        error: "Model is required. Use --model <name>"
+      }, null, 2) + "\n");
+      process.exit(CONFIGURE_AI_EXIT_CODES.VALIDATION_FAIL);
+      return;
+    }
+    if (!config.apiKey) {
+      process.stderr.write(JSON.stringify({
+        error: "API key is required. Use --api-key <key>"
+      }, null, 2) + "\n");
+      process.exit(CONFIGURE_AI_EXIT_CODES.VALIDATION_FAIL);
+      return;
+    }
+    await saveConfig(config);
+    process.stdout.write(JSON.stringify({
+      success: true,
+      configPath: getConfigPath(),
+      ...redactConfig(config)
+    }, null, 2) + "\n");
+    process.exit(CONFIGURE_AI_EXIT_CODES.SUCCESS);
+  } catch (e) {
+    process.stderr.write(JSON.stringify({
+      error: "Configuration failed",
+      detail: e instanceof Error ? e.message : String(e)
+    }, null, 2) + "\n");
+    process.exit(CONFIGURE_AI_EXIT_CODES.ERROR);
+  }
+}
+export {
+  main
+};

package/dist/derive-6NAEWLM5.js

@@ -0,0 +1,150 @@
+import {
+  DeriveInputError,
+  DeriveProviderError,
+  deriveWorld
+} from "./chunk-D7BGWV2J.js";
+import {
+  DERIVE_EXIT_CODES
+} from "./chunk-T4X42QXC.js";
+import "./chunk-XPDMYECO.js";
+import "./chunk-O5OMJMIE.js";
+
+// src/cli/derive.ts
+function parseArgs(argv) {
+  let inputPath = "";
+  let outputPath = "./derived.nv-world.md";
+  let validate = true;
+  let dryRun = false;
+  let bootstrapDir;
+  let provider;
+  let model;
+  let endpoint;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--input" && i + 1 < argv.length) {
+      inputPath = argv[++i];
+    } else if (arg === "--output" && i + 1 < argv.length) {
+      outputPath = argv[++i];
+    } else if (arg === "--validate") {
+      validate = true;
+    } else if (arg === "--no-validate") {
+      validate = false;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--bootstrap" && i + 1 < argv.length) {
+      bootstrapDir = argv[++i];
+    } else if (arg === "--provider" && i + 1 < argv.length) {
+      provider = argv[++i];
+    } else if (arg === "--model" && i + 1 < argv.length) {
+      model = argv[++i];
+    } else if (arg === "--endpoint" && i + 1 < argv.length) {
+      endpoint = argv[++i];
+    }
+  }
+  if (!inputPath) throw new DeriveInputError("--input <path> is required");
+  return { inputPath, outputPath, validate, dryRun, bootstrapDir, provider, model, endpoint };
+}
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs(argv);
+    const { result, exitCode, dryRunOutput } = await deriveWorld({
+      inputPath: args.inputPath,
+      outputPath: args.outputPath,
+      validate: args.validate,
+      dryRun: args.dryRun,
+      providerOverride: args.provider || args.model || args.endpoint ? {
+        provider: args.provider,
+        model: args.model,
+        endpoint: args.endpoint
+      } : void 0
+    });
+    if (dryRunOutput) {
+      process.stdout.write(JSON.stringify({
+        dryRun: true,
+        systemPrompt: dryRunOutput.systemPrompt,
+        userPrompt: dryRunOutput.userPrompt,
+        durationMs: result.durationMs
+      }, null, 2) + "\n");
+      process.exit(DERIVE_EXIT_CODES.SUCCESS);
+      return;
+    }
+    process.stderr.write(`
+Derived world written to: ${result.outputPath}
+`);
+    process.stderr.write(`Derivation Gate: ${result.gate}
+`);
+    if (result.normalization) {
+      const n = result.normalization;
+      const details = [];
+      if (n.invariantIds > 0) details.push(`${n.invariantIds} invariant ID(s) wrapped`);
+      if (n.gateThresholds > 0) details.push(`${n.gateThresholds} gate threshold(s) converted`);
+      if (n.triggerTags > 0) details.push(`${n.triggerTags} trigger(s) tagged with [state]`);
+      process.stderr.write(`
+Normalization: ${n.fixCount} fix(es) applied
+`);
+      for (const d of details) process.stderr.write(`  - ${d}
+`);
+    }
+    if (result.findings.length > 0) {
+      process.stderr.write(`
+`);
+      const errs = result.findings.filter((f) => f.severity === "error");
+      const warns = result.findings.filter((f) => f.severity === "warning");
+      if (errs.length > 0) {
+        process.stderr.write(`Errors (${errs.length}):
+`);
+        for (const f of errs) {
+          process.stderr.write(`  ERROR [${f.section}]: ${f.message}
+`);
+        }
+      }
+      if (warns.length > 0) {
+        process.stderr.write(`Warnings (${warns.length}):
+`);
+        for (const f of warns) {
+          process.stderr.write(`  WARN  [${f.section}]: ${f.message}
+`);
+        }
+      }
+      process.stderr.write(`
+`);
+    }
+    if (result.gate === "SUSPECT" || result.gate === "DERIVATION_REJECTED") {
+      process.stderr.write(`The file has been written. Open ${result.outputPath} to review and fix.
+`);
+    }
+    if (args.bootstrapDir && exitCode === 0) {
+      process.stderr.write(`
+Bootstrapping to ${args.bootstrapDir}...
+`);
+      const { main: bootstrapMain } = await import("./bootstrap-H4HHKQ5G.js");
+      await bootstrapMain([
+        "--input",
+        result.outputPath,
+        "--output",
+        args.bootstrapDir,
+        ...args.validate ? ["--validate"] : []
+      ]);
+      return;
+    }
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    process.exit(exitCode);
+  } catch (e) {
+    if (e instanceof DeriveInputError) {
+      process.stderr.write(JSON.stringify({ error: e.message }, null, 2) + "\n");
+      process.exit(DERIVE_EXIT_CODES.INPUT_ERROR);
+    } else if (e instanceof DeriveProviderError) {
+      process.stderr.write(JSON.stringify({ error: e.message }, null, 2) + "\n");
+      process.exit(DERIVE_EXIT_CODES.PROVIDER_ERROR);
+    } else {
+      process.stderr.write(JSON.stringify({
+        error: "Derive failed",
+        detail: e instanceof Error ? e.message : String(e)
+      }, null, 2) + "\n");
+      process.exit(DERIVE_EXIT_CODES.PROVIDER_ERROR);
+    }
+  }
+}
+export {
+  main
+};

package/dist/explain-3B3VB6TL.js

@@ -0,0 +1,69 @@
+import {
+  explainWorld,
+  renderExplainText
+} from "./chunk-BUWWN2NX.js";
+import {
+  loadWorld
+} from "./chunk-M3TZFGHO.js";
+
+// src/cli/explain.ts
+function parseArgs(argv) {
+  let worldPath = "";
+  let json = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      json = true;
+    } else if (!arg.startsWith("--") && !worldPath) {
+      worldPath = arg;
+    }
+  }
+  if (!worldPath) {
+    throw new Error("Usage: neuroverse explain <world-path-or-id>");
+  }
+  return { worldPath, json };
+}
+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 explanation = explainWorld(world);
+    if (args.json) {
+      process.stdout.write(JSON.stringify(explanation, null, 2) + "\n");
+    } else {
+      process.stderr.write("\n");
+      process.stderr.write(renderExplainText(explanation));
+    }
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`${e instanceof Error ? e.message : String(e)}
+`);
+    process.exit(1);
+  }
+}
+export {
+  main
+};

package/dist/guard-67Y66P3I.js

@@ -0,0 +1,82 @@
+import {
+  GUARD_EXIT_CODES
+} from "./chunk-MWDQ4MJB.js";
+import {
+  evaluateGuard
+} from "./chunk-B4NF3OLW.js";
+import {
+  loadWorld
+} from "./chunk-M3TZFGHO.js";
+
+// src/cli/guard.ts
+function parseArgs(argv) {
+  let worldPath = "";
+  let trace = false;
+  let level;
+  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 === "--trace") {
+      trace = true;
+    } else if (arg === "--level" && i + 1 < argv.length) {
+      const val = argv[++i];
+      if (val === "basic" || val === "standard" || val === "strict") {
+        level = val;
+      } else {
+        throw new Error(`Invalid level: "${val}". Must be basic, standard, or strict.`);
+      }
+    }
+  }
+  if (!worldPath) {
+    throw new Error("--world <path> is required");
+  }
+  return { worldPath, trace, level };
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs(argv);
+    const input = await readStdin();
+    if (!input.trim()) {
+      const errorResult = {
+        error: "No input on stdin. Pipe a JSON GuardEvent.",
+        usage: `echo '{"intent":"..."}'  | neuroverse guard --world <path>`
+      };
+      process.stdout.write(JSON.stringify(errorResult, null, 2) + "\n");
+      process.exit(GUARD_EXIT_CODES.ERROR);
+    }
+    let event;
+    try {
+      event = JSON.parse(input);
+    } catch (e) {
+      const errorResult = { error: "Invalid JSON on stdin", detail: String(e) };
+      process.stdout.write(JSON.stringify(errorResult, null, 2) + "\n");
+      process.exit(GUARD_EXIT_CODES.ERROR);
+    }
+    if (!event.intent) {
+      const errorResult = { error: 'GuardEvent must have an "intent" field' };
+      process.stdout.write(JSON.stringify(errorResult, null, 2) + "\n");
+      process.exit(GUARD_EXIT_CODES.ERROR);
+    }
+    const world = await loadWorld(args.worldPath);
+    const options = { trace: args.trace, level: args.level };
+    const verdict = evaluateGuard(event, world, options);
+    process.stdout.write(JSON.stringify(verdict, null, 2) + "\n");
+    const exitCode = GUARD_EXIT_CODES[verdict.status];
+    process.exit(exitCode);
+  } catch (e) {
+    const errorResult = { error: "Guard evaluation failed", detail: String(e) };
+    process.stderr.write(JSON.stringify(errorResult, null, 2) + "\n");
+    process.exit(GUARD_EXIT_CODES.ERROR);
+  }
+}
+export {
+  main
+};