@neuroverseos/governance 0.3.0 → 0.3.3

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-TLIV4OOU.js → derive-FJZVIPUZ.js}

@@ -2,14 +2,15 @@ import {
   DeriveInputError,
   DeriveProviderError,
   deriveWorld
-} from "./chunk-NF5POFCI.js";
+} from "./chunk-6S5CFQXY.js";
 import {
   DERIVE_EXIT_CODES
 } from "./chunk-Q6O7ZLO2.js";
 import "./chunk-OT6PXH54.js";
-import "./chunk-XPDMYECO.js";
 import "./chunk-7P3S7MAY.js";
-import "./chunk-YZFATT7X.js";
+import "./chunk-EMQDLDAF.js";
+import "./chunk-PVTQQS3Y.js";
+import "./chunk-QWGCMQQD.js";
 
 // src/cli/derive.ts
 function parseArgs(argv) {
@@ -119,7 +120,7 @@ Normalization: ${n.fixCount} fix(es) applied
       process.stderr.write(`
 Bootstrapping to ${args.bootstrapDir}...
 `);
-      const { main: bootstrapMain } = await import("./bootstrap-GXVDZNF7.js");
+      const { main: bootstrapMain } = await import("./bootstrap-CQRZVOXK.js");
       await bootstrapMain([
         "--input",
         result.outputPath,

package/dist/{doctor-XPDLEYXN.js → doctor-6BC6X2VO.js}

@@ -3,16 +3,18 @@ import {
 } from "./chunk-OT6PXH54.js";
 import {
   __glob
-} from "./chunk-YZFATT7X.js";
+} from "./chunk-QWGCMQQD.js";
 
 // import("../adapters/**/*") in src/cli/doctor.ts
 var globImport_adapters = __glob({
   "../adapters/autoresearch.ts": () => import("./adapters/autoresearch.js"),
+  "../adapters/deep-agents.ts": () => import("./adapters/deep-agents.js"),
   "../adapters/express.ts": () => import("./adapters/express.js"),
   "../adapters/index.ts": () => import("./adapters/index.js"),
   "../adapters/langchain.ts": () => import("./adapters/langchain.js"),
   "../adapters/openai.ts": () => import("./adapters/openai.js"),
-  "../adapters/openclaw.ts": () => import("./adapters/openclaw.js")
+  "../adapters/openclaw.ts": () => import("./adapters/openclaw.js"),
+  "../adapters/shared.ts": () => import("./shared-7RLUHNMU.js")
 });
 
 // src/cli/doctor.ts
@@ -101,7 +103,7 @@ async function main(argv) {
     });
   }
   try {
-    const { evaluateGuard } = await import("./guard-engine-JLTUARGU.js");
+    const { evaluateGuard } = await import("./guard-engine-PNR6MHCM.js");
     checks.push({
       label: "Guard engine",
       status: typeof evaluateGuard === "function" ? "pass" : "fail",
@@ -111,7 +113,7 @@ async function main(argv) {
     checks.push({ label: "Guard engine", status: "fail", value: "failed to load" });
   }
   try {
-    const { validateWorld } = await import("./validate-engine-UIABSIHD.js");
+    const { validateWorld } = await import("./validate-engine-7ZXFVGF2.js");
     checks.push({
       label: "Validation engine",
       status: typeof validateWorld === "function" ? "pass" : "fail",