@neuroverseos/governance 0.3.1 → 0.3.4

package/dist/demo-G43RLCPK.js

@@ -0,0 +1,469 @@
+#!/usr/bin/env node
+import {
+  govern,
+  handleCreateCapsule,
+  handleHealthCheck,
+  handleListPresets,
+  handleReasonRequest,
+  writeTempWorld
+} from "./chunk-U6U7EJZL.js";
+import {
+  adaptationFromVerdict,
+  detectBehavioralPatterns,
+  generateAdaptationNarrative
+} from "./chunk-CNSO6XW5.js";
+import {
+  resolveWorldPath
+} from "./chunk-AKW5YVCE.js";
+import "./chunk-W7LLXRGY.js";
+import "./chunk-QLPTHTVB.js";
+import {
+  DEFAULT_BUNDLED_WORLD,
+  loadBundledWorld,
+  loadWorld
+} from "./chunk-CTZHONLA.js";
+import {
+  __require
+} from "./chunk-QWGCMQQD.js";
+
+// src/cli/demo.ts
+import { createServer } from "http";
+import { spawn } from "child_process";
+import { join, extname } from "path";
+import { tmpdir } from "os";
+import { existsSync, readFileSync } from "fs";
+import { fileURLToPath } from "url";
+async function main(args) {
+  let port = 3456;
+  let worldName;
+  let noBrowser = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--port" && args[i + 1]) {
+      port = parseInt(args[i + 1], 10);
+      i++;
+    } else if (args[i] === "--world" && args[i + 1]) {
+      worldName = args[i + 1];
+      i++;
+    } else if (args[i] === "--no-browser") {
+      noBrowser = true;
+    } else if (args[i] === "--help" || args[i] === "-h") {
+      process.stdout.write(`
+neuroverse demo \u2014 Interactive governance demo
+
+Usage:
+  neuroverse demo [options]
+
+Options:
+  --world <name>   Load a specific world (e.g., social-media, trading-agent)
+  --port <number>  Server port (default: 3456)
+  --no-browser     Don't open browser automatically
+
+The demo server wraps the real guard engine.
+Same evaluateGuard() as \`neuroverse guard\`. ONE engine. ONE path.
+`);
+      return;
+    }
+  }
+  const TEMP_WORLD_DIR = join(tmpdir(), "neuroverse-demo");
+  let activePolicy = "";
+  let policyUpdatedAt = null;
+  let activeWorld = null;
+  let activeSimulation = null;
+  if (worldName) {
+    try {
+      const worldPath = await resolveWorldPath(worldName);
+      if (worldPath) {
+        activeWorld = await loadWorld(worldPath);
+        process.stderr.write(`  Loaded world: ${worldName} (${worldPath})
+`);
+      }
+    } catch {
+      process.stderr.write(`  Warning: Could not load world "${worldName}"
+`);
+    }
+  }
+  if (!activeWorld) {
+    activeWorld = await loadBundledWorld(DEFAULT_BUNDLED_WORLD);
+    process.stderr.write(`  Using default world: ${DEFAULT_BUNDLED_WORLD}
+`);
+  }
+  async function syncPolicyToWorld() {
+    if (!activePolicy) {
+      activeWorld = null;
+      return;
+    }
+    const lines = activePolicy.split("\n").filter((l) => l.trim().length > 0);
+    await writeTempWorld(TEMP_WORLD_DIR, lines);
+    activeWorld = await loadWorld(TEMP_WORLD_DIR);
+  }
+  const sseClients = /* @__PURE__ */ new Set();
+  let eventCounter = 0;
+  const evaluationHistory = [];
+  function resolveVizDir() {
+    const candidates = [
+      join(process.cwd(), "dist", "viz"),
+      join(process.cwd(), "node_modules", "@neuroverseos", "governance", "dist", "viz")
+    ];
+    try {
+      const thisDir = typeof __dirname !== "undefined" ? __dirname : join(fileURLToPath(import.meta.url), "..");
+      candidates.push(join(thisDir, "..", "viz"));
+    } catch {
+    }
+    for (const dir of candidates) {
+      if (existsSync(join(dir, "index.html"))) return dir;
+    }
+    return null;
+  }
+  const MIME_TYPES = {
+    ".html": "text/html",
+    ".js": "application/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2"
+  };
+  function serveStaticFile(res, filePath) {
+    if (!existsSync(filePath)) return false;
+    const ext = extname(filePath);
+    const mime = MIME_TYPES[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "Content-Type": mime });
+    res.end(readFileSync(filePath));
+    return true;
+  }
+  const vizDir = resolveVizDir();
+  function broadcastEvent(event) {
+    const id = ++eventCounter;
+    const data = JSON.stringify({ id, timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...event });
+    const message = `id: ${id}
+data: ${data}
+
+`;
+    for (const client of sseClients) {
+      try {
+        client.write(message);
+      } catch {
+        sseClients.delete(client);
+      }
+    }
+  }
+  function setCors(res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  }
+  function readBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+      req.on("error", reject);
+    });
+  }
+  function normalizeAction(body) {
+    if (body.action && typeof body.action === "object" && body.action.agentId) {
+      return body.action;
+    }
+    if (body.actor || body.action && typeof body.action === "string") {
+      const agentId = body.actor ?? "unknown";
+      const actionType = typeof body.action === "string" ? body.action : "unknown";
+      const payload = body.payload ?? {};
+      return {
+        agentId,
+        type: actionType,
+        description: payload.description ?? `${agentId}: ${actionType}`,
+        magnitude: payload.confidence ?? 0.5,
+        context: { ...payload, world: body.world, source: "connector" }
+      };
+    }
+    return { error: "Invalid request format." };
+  }
+  const server = createServer(async (req, res) => {
+    setCors(res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = req.url ?? "/";
+    try {
+      if (url === "/api/v1/events" && req.method === "GET") {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "Access-Control-Allow-Origin": "*"
+        });
+        res.write(`data: ${JSON.stringify({ type: "connected", activePolicy: activePolicy.length > 0, eventCount: eventCounter })}
+
+`);
+        sseClients.add(res);
+        req.on("close", () => {
+          sseClients.delete(res);
+        });
+        const keepAlive = setInterval(() => {
+          try {
+            res.write(": keepalive\n\n");
+          } catch {
+            clearInterval(keepAlive);
+          }
+        }, 15e3);
+        req.on("close", () => clearInterval(keepAlive));
+        return;
+      }
+      res.setHeader("Content-Type", "application/json");
+      if (url === "/api/v1/policy" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const text = body.policyText ?? body.policy ?? body.text;
+        if (!text || typeof text !== "string") {
+          res.writeHead(400);
+          res.end(JSON.stringify({ error: "policyText is required" }));
+          return;
+        }
+        activePolicy = text;
+        policyUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await syncPolicyToWorld();
+        broadcastEvent({ type: "policy_updated", policyText: activePolicy, updatedAt: policyUpdatedAt });
+        res.writeHead(200);
+        res.end(JSON.stringify({ status: "ok", policyText: activePolicy, updatedAt: policyUpdatedAt }));
+        return;
+      }
+      if (url === "/api/v1/policy" && req.method === "GET") {
+        res.writeHead(200);
+        res.end(JSON.stringify({ policyText: activePolicy, active: activePolicy.length > 0, updatedAt: policyUpdatedAt }));
+        return;
+      }
+      if ((url === "/api/v1/evaluate" || url === "/api/evaluate") && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const action = normalizeAction(body);
+        if ("error" in action) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ error: action.error }));
+          return;
+        }
+        if (!activeWorld) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ error: "No governance rules set. POST /api/v1/policy first." }));
+          return;
+        }
+        const verdict = govern(action, activeWorld);
+        evaluationHistory.push({ action, verdict });
+        broadcastEvent({
+          type: "evaluation",
+          action,
+          verdict: { status: verdict.status, reason: verdict.reason, ruleId: verdict.ruleId, consequence: verdict.consequence, reward: verdict.reward }
+        });
+        res.writeHead(200);
+        res.end(JSON.stringify(verdict));
+        return;
+      }
+      if (url === "/api/v1/simulate" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const agents = body.agents ?? 50;
+        const steps = body.steps ?? 20;
+        const policyText = body.policyText ?? activePolicy;
+        if (policyText && policyText !== activePolicy) {
+          activePolicy = policyText;
+          policyUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          await syncPolicyToWorld();
+          broadcastEvent({ type: "policy_updated", policyText: activePolicy, updatedAt: policyUpdatedAt });
+        }
+        if (!activeWorld) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ error: "No governance rules set." }));
+          return;
+        }
+        if (activeSimulation) {
+          try {
+            activeSimulation.kill();
+          } catch {
+          }
+          activeSimulation = null;
+        }
+        const scriptCandidates = [
+          join(process.cwd(), "examples", "social-media-sim", "simulation.py"),
+          join(process.cwd(), "demo", "simulations", "social_simulation.py")
+        ];
+        const scriptPath = scriptCandidates.find((p) => existsSync(p));
+        if (!scriptPath) {
+          res.writeHead(500);
+          res.end(JSON.stringify({ error: "Simulation script not found" }));
+          return;
+        }
+        const simArgs = [scriptPath, "--agents", String(agents), "--steps", String(steps)];
+        if (body.llmApiKey) {
+          simArgs.push("--llm-api-key", body.llmApiKey);
+          if (body.llmBaseUrl) simArgs.push("--llm-base-url", body.llmBaseUrl);
+          if (body.llmModel) simArgs.push("--llm-model", body.llmModel);
+        }
+        broadcastEvent({ type: "simulation_start", agents, steps, mode: body.llmApiKey ? "llm" : "rule-based" });
+        const proc = spawn("python3", simArgs, { cwd: process.cwd(), env: { ...process.env } });
+        activeSimulation = proc;
+        let buffer = "";
+        proc.stdout.on("data", (chunk) => {
+          buffer += chunk.toString();
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              broadcastEvent({ type: "simulation_event", ...JSON.parse(line) });
+            } catch {
+            }
+          }
+        });
+        proc.stderr.on("data", (chunk) => {
+          const msg = chunk.toString().trim();
+          if (msg) process.stderr.write(`[SIM] ${msg}
+`);
+        });
+        proc.on("close", (code) => {
+          activeSimulation = null;
+          broadcastEvent({ type: "simulation_complete", exitCode: code });
+        });
+        res.writeHead(200);
+        res.end(JSON.stringify({ status: "started", agents, steps }));
+        return;
+      }
+      if (url === "/api/v1/simulate/stop" && req.method === "POST") {
+        if (activeSimulation) {
+          activeSimulation.kill();
+          activeSimulation = null;
+          broadcastEvent({ type: "simulation_stopped" });
+          res.writeHead(200);
+          res.end(JSON.stringify({ status: "stopped" }));
+        } else {
+          res.writeHead(200);
+          res.end(JSON.stringify({ status: "no_simulation_running" }));
+        }
+        return;
+      }
+      if (url === "/api/v1/simulate/source" && req.method === "GET") {
+        const candidates = [
+          { sim: "examples/social-media-sim/simulation.py", bridge: "examples/social-media-sim/bridge.py" },
+          { sim: "demo/simulations/social_simulation.py", bridge: "demo/simulations/neuroverse_bridge.py" }
+        ];
+        const files = [];
+        for (const c of candidates) {
+          const simPath = join(process.cwd(), c.sim);
+          if (existsSync(simPath)) {
+            files.push({ name: "simulation.py", path: c.sim, content: readFileSync(simPath, "utf-8"), language: "python" });
+            const bridgePath = join(process.cwd(), c.bridge);
+            if (existsSync(bridgePath)) {
+              files.push({ name: "bridge.py", path: c.bridge, content: readFileSync(bridgePath, "utf-8"), language: "python" });
+            }
+            break;
+          }
+        }
+        res.writeHead(200);
+        res.end(JSON.stringify({ files }));
+        return;
+      }
+      if (url === "/api/v1/reason" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const result = await handleReasonRequest(body);
+        res.writeHead("error" in result && result.status === "error" ? 400 : 200);
+        res.end(JSON.stringify(result));
+        return;
+      }
+      if (url === "/api/v1/reason/capsule" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        res.writeHead(200);
+        res.end(JSON.stringify(handleCreateCapsule(body)));
+        return;
+      }
+      if (url === "/api/v1/reason/health" && req.method === "GET") {
+        res.writeHead(200);
+        res.end(JSON.stringify(handleHealthCheck()));
+        return;
+      }
+      if (url === "/api/v1/reason/presets" && req.method === "GET") {
+        res.writeHead(200);
+        res.end(JSON.stringify(await handleListPresets(join(process.cwd(), "policies"))));
+        return;
+      }
+      if (url === "/api/v1/behavioral" && req.method === "GET") {
+        const adaptations = evaluationHistory.map(({ action, verdict }) => {
+          const executed = verdict.status === "BLOCK" ? "idle" : action.type;
+          return adaptationFromVerdict(action.agentId, action.type, executed, verdict);
+        });
+        const patterns = detectBehavioralPatterns(adaptations, new Set(evaluationHistory.map((e) => e.action.agentId)).size);
+        const narrative = generateAdaptationNarrative(patterns);
+        res.writeHead(200);
+        res.end(JSON.stringify({ patterns, narrative, adaptations: adaptations.length, agents: new Set(evaluationHistory.map((e) => e.action.agentId)).size }));
+        return;
+      }
+      if (req.method === "GET" && vizDir) {
+        const reqPath = url === "/" || url === "/index.html" ? "/index.html" : url;
+        const filePath = join(vizDir, reqPath);
+        if (filePath.startsWith(vizDir) && serveStaticFile(res, filePath)) return;
+      }
+      if (req.method === "GET" && (url === "/" || url === "/index.html")) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`<html><body style="background:#0a0a0a;color:#e2e8f0;font-family:monospace;padding:40px">
+          <h2>NeuroVerse Demo Server</h2>
+          <p>API is running. Build the viz to see the Governance Observation Deck:</p>
+          <pre style="color:#8b5cf6">npm run build:viz</pre>
+          <p style="color:#64748b">Then refresh this page.</p>
+          <p style="margin-top:20px">API endpoints:</p>
+          <pre style="color:#64748b">POST /api/v1/policy    \u2014 Set rules
+POST /api/v1/evaluate  \u2014 Guard evaluation
+GET  /api/v1/events    \u2014 SSE governance feed
+GET  /api/v1/behavioral \u2014 Behavioral analysis
+POST /api/v1/simulate  \u2014 Launch simulation</pre>
+        </body></html>`);
+        return;
+      }
+      res.writeHead(404);
+      res.end(JSON.stringify({ error: "Not found" }));
+    } catch (err) {
+      console.error("Server error:", err);
+      res.writeHead(500);
+      res.end(JSON.stringify({ error: "Internal server error" }));
+    }
+  });
+  server.listen(port, () => {
+    process.stderr.write(`
+  NeuroVerse Demo Server
+`);
+    process.stderr.write(`  http://localhost:${port}
+`);
+    process.stderr.write(`
+  Engine: evaluateGuard() \u2014 same as \`neuroverse guard\`
+`);
+    process.stderr.write(`  Temp world: ${TEMP_WORLD_DIR}
+`);
+    if (worldName) {
+      process.stderr.write(`  World: ${worldName}
+`);
+    }
+    process.stderr.write(`
+  POST /api/v1/policy     \u2192 Set rules (writes temp world)
+`);
+    process.stderr.write(`  POST /api/v1/evaluate   \u2192 Guard evaluation (real engine)
+`);
+    process.stderr.write(`  GET  /api/v1/events     \u2192 SSE governance feed
+`);
+    process.stderr.write(`  POST /api/v1/simulate   \u2192 Launch social simulation
+`);
+    process.stderr.write(`
+  ONE engine. ONE path. CLI is the bible.
+
+`);
+    if (!noBrowser) {
+      const url = `http://localhost:${port}`;
+      try {
+        const { exec } = __require("child_process");
+        const cmd = process.platform === "darwin" ? `open ${url}` : process.platform === "win32" ? `start ${url}` : `xdg-open ${url}`;
+        exec(cmd);
+      } catch {
+      }
+    }
+  });
+  await new Promise(() => {
+  });
+}
+export {
+  main
+};

package/dist/derive-LMDUTXDD.js

@@ -0,0 +1,154 @@
+import {
+  DeriveInputError,
+  DeriveProviderError,
+  deriveWorld
+} from "./chunk-YEKMVDWK.js";
+import {
+  DERIVE_EXIT_CODES
+} from "./chunk-FMSTRBBS.js";
+import "./chunk-OT6PXH54.js";
+import "./chunk-INWQHLPS.js";
+import "./chunk-7P3S7MAY.js";
+import "./chunk-EMQDLDAF.js";
+import "./chunk-PVTQQS3Y.js";
+import "./chunk-QWGCMQQD.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-CQRZVOXK.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
+};