@neuroverseos/governance 0.3.1 → 0.3.3

package/dist/chunk-A5W4GNQO.js

@@ -0,0 +1,130 @@
+// src/runtime/model-adapter.ts
+var DEFAULT_SYSTEM_PROMPT = `You are an AI assistant operating under NeuroVerse governance.
+All your tool calls are evaluated against governance rules before execution.
+If an action is blocked, you will be told why. Adjust your approach accordingly.
+Do not attempt to bypass governance rules.`;
+var ModelAdapter = class {
+  config;
+  messages;
+  tools;
+  constructor(config, tools = []) {
+    this.config = config;
+    this.tools = tools;
+    this.messages = [];
+    const systemPrompt = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.messages.push({ role: "system", content: systemPrompt });
+  }
+  /**
+   * Send a user message and get the model's response.
+   */
+  async chat(userMessage) {
+    this.messages.push({ role: "user", content: userMessage });
+    return this.complete();
+  }
+  /**
+   * Send a tool result back to the model and get the next response.
+   */
+  async sendToolResult(toolCallId, result) {
+    this.messages.push({
+      role: "tool",
+      content: result,
+      tool_call_id: toolCallId
+    });
+    return this.complete();
+  }
+  /**
+   * Send a governance block message as a tool result.
+   */
+  async sendBlockedResult(toolCallId, reason) {
+    return this.sendToolResult(
+      toolCallId,
+      `[GOVERNANCE BLOCKED] ${reason}. Please adjust your approach.`
+    );
+  }
+  /**
+   * Call the model API and parse the response.
+   */
+  async complete() {
+    const url = `${this.config.baseUrl}/chat/completions`;
+    const body = {
+      model: this.config.model,
+      messages: this.messages,
+      max_tokens: this.config.maxTokens ?? 4096
+    };
+    if (this.tools.length > 0) {
+      body.tools = this.tools;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.config.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Model API error ${response.status}: ${text}`);
+    }
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice) {
+      throw new Error("Model returned no choices");
+    }
+    const message = choice.message;
+    this.messages.push(message);
+    return {
+      content: message.content ?? null,
+      toolCalls: message.tool_calls ?? [],
+      finishReason: choice.finish_reason ?? "stop"
+    };
+  }
+  /** Get current message count (for context tracking). */
+  get messageCount() {
+    return this.messages.length;
+  }
+};
+var PROVIDERS = {
+  openai: {
+    baseUrl: "https://api.openai.com/v1",
+    defaultModel: "gpt-4o",
+    envVar: "OPENAI_API_KEY"
+  },
+  anthropic: {
+    baseUrl: "https://api.anthropic.com/v1",
+    defaultModel: "claude-sonnet-4-20250514",
+    envVar: "ANTHROPIC_API_KEY"
+  },
+  ollama: {
+    baseUrl: "http://localhost:11434/v1",
+    defaultModel: "llama3",
+    envVar: ""
+  }
+};
+function resolveProvider(provider, overrides) {
+  const preset = PROVIDERS[provider];
+  if (!preset) {
+    throw new Error(
+      `Unknown provider: "${provider}". Available: ${Object.keys(PROVIDERS).join(", ")}`
+    );
+  }
+  const apiKey = overrides?.apiKey ?? (preset.envVar ? process.env[preset.envVar] : "") ?? "";
+  if (!apiKey && preset.envVar) {
+    throw new Error(
+      `Missing API key. Set ${preset.envVar} or pass --api-key.`
+    );
+  }
+  return {
+    baseUrl: overrides?.baseUrl ?? preset.baseUrl,
+    apiKey,
+    model: overrides?.model ?? preset.defaultModel,
+    systemPrompt: overrides?.systemPrompt,
+    maxTokens: overrides?.maxTokens
+  };
+}
+
+export {
+  ModelAdapter,
+  PROVIDERS,
+  resolveProvider
+};

package/dist/chunk-A7GKPPU7.js

@@ -0,0 +1,226 @@
+import {
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
+
+// src/engine/audit-logger.ts
+var FileAuditLogger = class {
+  logPath;
+  buffer = [];
+  flushTimer = null;
+  flushIntervalMs;
+  constructor(logPath, options) {
+    this.logPath = logPath;
+    this.flushIntervalMs = options?.flushIntervalMs ?? 1e3;
+  }
+  log(event) {
+    this.buffer.push(JSON.stringify(event));
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        void this.flush();
+      }, this.flushIntervalMs);
+    }
+  }
+  async flush() {
+    if (this.buffer.length === 0) return;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    const lines = this.buffer.splice(0).join("\n") + "\n";
+    try {
+      const { appendFile, mkdir } = await import("fs/promises");
+      const { dirname } = await import("path");
+      await mkdir(dirname(this.logPath), { recursive: true });
+      await appendFile(this.logPath, lines, "utf-8");
+    } catch {
+    }
+  }
+};
+var ConsoleAuditLogger = class {
+  log(event) {
+    const iconMap = {
+      "ALLOW": "\u25CF",
+      "BLOCK": "\u25CB",
+      "PAUSE": "\u25D1",
+      "MODIFY": "\u25D0",
+      "PENALIZE": "\u25CC",
+      "REWARD": "\u25C9",
+      "NEUTRAL": "\u25EF"
+    };
+    const icon = iconMap[event.decision] ?? "\xB7";
+    const ts = event.timestamp.split("T")[1]?.replace("Z", "") ?? event.timestamp;
+    let line = `[${ts}] ${icon} ${event.decision.padEnd(10)} ${event.actor ?? "\u2014"} \u2192 ${event.intent}`;
+    if (event.reason) line += ` (${event.reason})`;
+    if (event.consequence) line += ` [consequence: ${event.consequence.description}]`;
+    if (event.reward) line += ` [reward: ${event.reward.description}]`;
+    process.stderr.write(line + "\n");
+  }
+};
+var CompositeAuditLogger = class {
+  loggers;
+  constructor(...loggers) {
+    this.loggers = loggers;
+  }
+  log(event) {
+    for (const logger of this.loggers) {
+      try {
+        logger.log(event);
+      } catch {
+      }
+    }
+  }
+  async flush() {
+    await Promise.all(
+      this.loggers.map((l) => l.flush?.()).filter(Boolean)
+    );
+  }
+};
+function verdictToAuditEvent(event, verdict) {
+  const auditEvent = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    worldId: verdict.evidence.worldId,
+    worldName: verdict.evidence.worldName,
+    worldVersion: verdict.evidence.worldVersion,
+    intent: event.intent,
+    tool: event.tool,
+    scope: event.scope,
+    actor: event.roleId,
+    direction: event.direction,
+    decision: verdict.status,
+    reason: verdict.reason,
+    ruleId: verdict.ruleId,
+    warning: verdict.warning,
+    guardsMatched: verdict.evidence.guardsMatched,
+    rulesMatched: verdict.evidence.rulesMatched,
+    invariantsSatisfied: verdict.evidence.invariantsSatisfied,
+    invariantsTotal: verdict.evidence.invariantsTotal,
+    enforcementLevel: verdict.evidence.enforcementLevel,
+    durationMs: verdict.trace?.durationMs,
+    args: event.args
+  };
+  if (verdict.consequence) {
+    auditEvent.consequence = verdict.consequence;
+  }
+  if (verdict.reward) {
+    auditEvent.reward = verdict.reward;
+  }
+  if (verdict.intentRecord) {
+    auditEvent.originalIntent = verdict.intentRecord.originalIntent;
+    auditEvent.finalAction = verdict.intentRecord.finalAction;
+  }
+  return auditEvent;
+}
+function createGovernanceEngine(world, options = {}) {
+  const { auditLogger, auditArgs, ...engineOptions } = options;
+  return {
+    /**
+     * Evaluate a governance event and log the result.
+     */
+    evaluate(event) {
+      const verdict = evaluateGuard(event, world, engineOptions);
+      if (auditLogger) {
+        const auditEvent = verdictToAuditEvent(event, verdict);
+        if (!auditArgs) {
+          delete auditEvent.args;
+        }
+        auditLogger.log(auditEvent);
+      }
+      return verdict;
+    },
+    /** Flush the audit logger. */
+    async flush() {
+      await auditLogger?.flush?.();
+    },
+    /** The underlying world definition. */
+    world
+  };
+}
+async function readAuditLog(logPath, filter) {
+  const { readFile } = await import("fs/promises");
+  let content;
+  try {
+    content = await readFile(logPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (!filter || filter(event)) {
+        events.push(event);
+      }
+    } catch {
+    }
+  }
+  return events;
+}
+function summarizeAuditEvents(events) {
+  const allowed = events.filter((e) => e.decision === "ALLOW").length;
+  const blocked = events.filter((e) => e.decision === "BLOCK").length;
+  const paused = events.filter((e) => e.decision === "PAUSE").length;
+  const modified = events.filter((e) => e.decision === "MODIFY").length;
+  const penalized = events.filter((e) => e.decision === "PENALIZE").length;
+  const rewarded = events.filter((e) => e.decision === "REWARD").length;
+  const neutral = events.filter((e) => e.decision === "NEUTRAL").length;
+  const actorSet = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (e.actor) actorSet.add(e.actor);
+  }
+  const intentMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const entry = intentMap.get(e.intent) ?? { count: 0, blocked: 0, paused: 0, penalized: 0, rewarded: 0 };
+    entry.count++;
+    if (e.decision === "BLOCK") entry.blocked++;
+    if (e.decision === "PAUSE") entry.paused++;
+    if (e.decision === "PENALIZE") entry.penalized++;
+    if (e.decision === "REWARD") entry.rewarded++;
+    intentMap.set(e.intent, entry);
+  }
+  const topIntents = [...intentMap.entries()].map(([intent, data]) => ({ intent, ...data })).sort((a, b) => b.count - a.count);
+  const ruleMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.ruleId) {
+      ruleMap.set(e.ruleId, (ruleMap.get(e.ruleId) ?? 0) + 1);
+    }
+    for (const g of e.guardsMatched) {
+      ruleMap.set(g, (ruleMap.get(g) ?? 0) + 1);
+    }
+  }
+  const topRules = [...ruleMap.entries()].map(([ruleId, count]) => ({ ruleId, count })).sort((a, b) => b.count - a.count);
+  const redirected = blocked + paused + modified + penalized;
+  const total = events.length;
+  return {
+    totalActions: total,
+    allowed,
+    blocked,
+    paused,
+    modified,
+    penalized,
+    rewarded,
+    neutral,
+    actors: [...actorSet],
+    topIntents,
+    topRules,
+    firstEvent: events[0]?.timestamp ?? "",
+    lastEvent: events[events.length - 1]?.timestamp ?? "",
+    behavioralEconomy: {
+      totalPenalties: penalized,
+      totalRewards: rewarded,
+      netPressure: rewarded - penalized,
+      redirectionRate: total > 0 ? redirected / total : 0
+    }
+  };
+}
+
+export {
+  FileAuditLogger,
+  ConsoleAuditLogger,
+  CompositeAuditLogger,
+  verdictToAuditEvent,
+  createGovernanceEngine,
+  readAuditLog,
+  summarizeAuditEvents
+};

package/dist/chunk-AKW5YVCE.js

@@ -0,0 +1,96 @@
+// src/loader/world-resolver.ts
+import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync } from "fs";
+import { join, resolve, isAbsolute } from "path";
+var WORLDS_DIR = ".neuroverse/worlds";
+var ACTIVE_WORLD_FILE = ".neuroverse/active_world";
+function listWorlds(cwd = process.cwd()) {
+  const worldsDir = join(cwd, WORLDS_DIR);
+  if (!existsSync(worldsDir)) return [];
+  const activeName = getActiveWorldName(cwd);
+  const entries = readdirSync(worldsDir);
+  return entries.filter((name) => {
+    const worldJson = join(worldsDir, name, "world.json");
+    return existsSync(worldJson);
+  }).map((name) => ({
+    name,
+    path: join(worldsDir, name),
+    active: name === activeName
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function getActiveWorldName(cwd = process.cwd()) {
+  const filePath = join(cwd, ACTIVE_WORLD_FILE);
+  try {
+    return readFileSync(filePath, "utf-8").trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function setActiveWorld(name, cwd = process.cwd()) {
+  const worldsDir = join(cwd, WORLDS_DIR);
+  const worldPath = join(worldsDir, name, "world.json");
+  if (!existsSync(worldPath)) {
+    const available = listWorlds(cwd);
+    const names = available.map((w) => w.name).join(", ");
+    throw new Error(
+      `World "${name}" not found in ${WORLDS_DIR}/
+` + (names ? `Available: ${names}` : "No worlds found. Run `neuroverse build` first.")
+    );
+  }
+  const dir = join(cwd, ".neuroverse");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(join(cwd, ACTIVE_WORLD_FILE), name + "\n", "utf-8");
+}
+function resolveWorldPath(explicit, cwd = process.cwd()) {
+  if (explicit) {
+    return resolveNameOrPath(explicit, cwd);
+  }
+  const envWorld = process.env.NEUROVERSE_WORLD;
+  if (envWorld) {
+    return resolveNameOrPath(envWorld, cwd);
+  }
+  const activeName = getActiveWorldName(cwd);
+  if (activeName) {
+    return resolveNameOrPath(activeName, cwd);
+  }
+  const worlds = listWorlds(cwd);
+  if (worlds.length === 1) {
+    return resolve(worlds[0].path);
+  }
+  return void 0;
+}
+function describeActiveWorld(explicit, cwd = process.cwd()) {
+  if (explicit) {
+    return { name: explicit, source: "--world flag" };
+  }
+  const envWorld = process.env.NEUROVERSE_WORLD;
+  if (envWorld) {
+    return { name: envWorld, source: "NEUROVERSE_WORLD env var" };
+  }
+  const activeName = getActiveWorldName(cwd);
+  if (activeName) {
+    return { name: activeName, source: ".neuroverse/active_world" };
+  }
+  const worlds = listWorlds(cwd);
+  if (worlds.length === 1) {
+    return { name: worlds[0].name, source: "auto-detected (only world)" };
+  }
+  return void 0;
+}
+function resolveNameOrPath(ref, cwd) {
+  if (ref.includes("/") || ref.includes("\\") || ref.startsWith(".") || isAbsolute(ref)) {
+    return resolve(cwd, ref);
+  }
+  const namedPath = join(cwd, WORLDS_DIR, ref);
+  if (existsSync(join(namedPath, "world.json"))) {
+    return resolve(namedPath);
+  }
+  return resolve(cwd, ref);
+}
+
+export {
+  listWorlds,
+  getActiveWorldName,
+  setActiveWorld,
+  resolveWorldPath,
+  describeActiveWorld
+};