@neuroverseos/governance 0.2.3 → 0.3.1

package/dist/chunk-A5W4GNQO.js

@@ -1,130 +0,0 @@
-// 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-AF2VX4AL.js

@@ -1,363 +0,0 @@
-import {
-  applyConsequence,
-  applyReward,
-  createAgentState,
-  tickAgentStates
-} from "./chunk-D2UCV5AK.js";
-import {
-  evaluateGuard
-} from "./chunk-IZSO75NZ.js";
-import {
-  advancePlan,
-  evaluatePlan,
-  getPlanProgress
-} from "./chunk-QLPTHTVB.js";
-import {
-  loadWorld
-} from "./chunk-JZPQGIKR.js";
-
-// src/runtime/session.ts
-async function defaultToolExecutor(name, args) {
-  return `Tool "${name}" executed successfully with args: ${JSON.stringify(args)}`;
-}
-var SessionManager = class {
-  config;
-  state;
-  engineOptions;
-  executor;
-  constructor(config) {
-    this.config = config;
-    this.executor = config.toolExecutor ?? defaultToolExecutor;
-    this.engineOptions = {
-      trace: config.trace ?? false,
-      level: config.level,
-      plan: config.plan
-    };
-    this.state = {
-      active: false,
-      world: config.world,
-      plan: config.plan,
-      progress: config.plan ? getPlanProgress(config.plan) : void 0,
-      actionsEvaluated: 0,
-      actionsAllowed: 0,
-      actionsBlocked: 0,
-      actionsPaused: 0,
-      actionsModified: 0,
-      actionsPenalized: 0,
-      actionsRewarded: 0,
-      agentStates: /* @__PURE__ */ new Map()
-    };
-  }
-  /**
-   * Initialize the session — load world from disk if needed.
-   */
-  async start() {
-    if (this.config.worldPath && !this.config.world) {
-      this.state.world = await loadWorld(this.config.worldPath);
-    }
-    if (!this.state.world) {
-      throw new Error("No world provided. Use --world or pass a world definition.");
-    }
-    this.state.active = true;
-    return this.getState();
-  }
-  /**
-   * Evaluate a single event against governance.
-   * Returns the verdict without executing anything.
-   */
-  evaluate(event) {
-    this.engineOptions.plan = this.state.plan;
-    this.engineOptions.agentStates = this.state.agentStates;
-    const verdict = evaluateGuard(event, this.state.world, this.engineOptions);
-    this.state.actionsEvaluated++;
-    if (verdict.status === "ALLOW") this.state.actionsAllowed++;
-    if (verdict.status === "BLOCK") this.state.actionsBlocked++;
-    if (verdict.status === "PAUSE") this.state.actionsPaused++;
-    if (verdict.status === "MODIFY") this.state.actionsModified++;
-    if (verdict.status === "PENALIZE") this.state.actionsPenalized++;
-    if (verdict.status === "REWARD") this.state.actionsRewarded++;
-    if (event.roleId) {
-      let agentState = this.state.agentStates.get(event.roleId) ?? createAgentState(event.roleId);
-      if (verdict.status === "PENALIZE" && verdict.consequence) {
-        agentState = applyConsequence(agentState, verdict.consequence, verdict.ruleId ?? "unknown");
-      }
-      if (verdict.status === "REWARD" && verdict.reward) {
-        agentState = applyReward(agentState, verdict.reward, verdict.ruleId ?? "unknown");
-      }
-      this.state.agentStates.set(event.roleId, agentState);
-    }
-    this.config.onVerdict?.(verdict, event);
-    return verdict;
-  }
-  /**
-   * Advance all agent states by one round.
-   * Call this at the end of each simulation round to decrement cooldowns.
-   */
-  tickRound() {
-    this.state.agentStates = tickAgentStates(this.state.agentStates);
-  }
-  /**
-   * Get the behavior state for a specific agent.
-   */
-  getAgentState(agentId) {
-    return this.state.agentStates.get(agentId);
-  }
-  /**
-   * Evaluate and execute a tool call.
-   * Returns the execution result or block reason.
-   */
-  async executeToolCall(toolCall) {
-    let args;
-    try {
-      args = JSON.parse(toolCall.function.arguments);
-    } catch {
-      args = { raw: toolCall.function.arguments };
-    }
-    const event = {
-      intent: toolCall.function.name,
-      tool: toolCall.function.name,
-      args,
-      direction: "input"
-    };
-    const verdict = this.evaluate(event);
-    if (verdict.status === "BLOCK" || verdict.status === "PENALIZE") {
-      return { allowed: false, verdict };
-    }
-    if (verdict.status === "PAUSE") {
-      return { allowed: false, verdict };
-    }
-    const result = await this.executor(toolCall.function.name, args);
-    this.config.onToolResult?.(toolCall.function.name, result);
-    if (this.state.plan) {
-      const planVerdict = evaluatePlan(event, this.state.plan);
-      if (planVerdict.matchedStep) {
-        const advResult = advancePlan(this.state.plan, planVerdict.matchedStep);
-        if (advResult.success && advResult.plan) {
-          this.state.plan = advResult.plan;
-          this.engineOptions.plan = this.state.plan;
-        }
-        this.state.progress = getPlanProgress(this.state.plan);
-        this.config.onPlanProgress?.(this.state.progress);
-        if (this.state.progress.completed === this.state.progress.total) {
-          this.config.onPlanComplete?.();
-        }
-      }
-    }
-    return { allowed: true, verdict, result };
-  }
-  /**
-   * Process a model response — evaluate and execute all tool calls.
-   * Returns results for each tool call.
-   */
-  async processModelResponse(response, model) {
-    if (response.toolCalls.length === 0) {
-      return response;
-    }
-    for (const toolCall of response.toolCalls) {
-      const { allowed, verdict, result } = await this.executeToolCall(toolCall);
-      if (allowed && result) {
-        const nextResponse = await model.sendToolResult(toolCall.id, result);
-        if (nextResponse.toolCalls.length > 0) {
-          return this.processModelResponse(nextResponse, model);
-        }
-        return nextResponse;
-      } else {
-        const reason = verdict.reason ?? "Action blocked by governance.";
-        const nextResponse = await model.sendBlockedResult(toolCall.id, reason);
-        if (nextResponse.toolCalls.length > 0) {
-          return this.processModelResponse(nextResponse, model);
-        }
-        return nextResponse;
-      }
-    }
-    return response;
-  }
-  /** Get current session state. */
-  getState() {
-    return { ...this.state };
-  }
-  /** Stop the session. */
-  stop() {
-    this.state.active = false;
-    return this.getState();
-  }
-};
-async function runPipeMode(config) {
-  const session = new SessionManager(config);
-  await session.start();
-  const state = session.getState();
-  process.stderr.write(`[neuroverse] Pipe mode active
-`);
-  process.stderr.write(`[neuroverse] World: ${state.world.world.name}
-`);
-  if (state.plan) {
-    process.stderr.write(`[neuroverse] Plan: ${state.plan.plan_id} (${state.plan.objective})
-`);
-  }
-  return new Promise((resolve, reject) => {
-    let buffer = "";
-    process.stdin.setEncoding("utf-8");
-    process.stdin.on("data", (chunk) => {
-      buffer += chunk;
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        try {
-          const event = JSON.parse(trimmed);
-          if (!event.intent) {
-            process.stderr.write(`[neuroverse] Warning: event missing "intent" field
-`);
-            continue;
-          }
-          const verdict = session.evaluate(event);
-          process.stdout.write(JSON.stringify(verdict) + "\n");
-        } catch (err) {
-          process.stderr.write(`[neuroverse] Error parsing line: ${err}
-`);
-        }
-      }
-    });
-    process.stdin.on("end", () => {
-      if (buffer.trim()) {
-        try {
-          const event = JSON.parse(buffer.trim());
-          if (event.intent) {
-            const verdict = session.evaluate(event);
-            process.stdout.write(JSON.stringify(verdict) + "\n");
-          }
-        } catch {
-        }
-      }
-      const finalState = session.stop();
-      process.stderr.write(
-        `[neuroverse] Session complete: ${finalState.actionsEvaluated} evaluated, ${finalState.actionsAllowed} allowed, ${finalState.actionsBlocked} blocked, ${finalState.actionsPaused} paused
-`
-      );
-      resolve();
-    });
-    process.stdin.on("error", reject);
-  });
-}
-async function runInteractiveMode(config, model) {
-  const session = new SessionManager(config);
-  await session.start();
-  const state = session.getState();
-  process.stdout.write("\n");
-  process.stdout.write(`  World: ${state.world.world.name}
-`);
-  if (state.plan) {
-    process.stdout.write(`  Plan: ${state.plan.plan_id}
-`);
-    process.stdout.write(`  Goal: ${state.plan.objective}
-`);
-    process.stdout.write(`  Steps: ${state.progress?.total ?? 0}
-`);
-  }
-  process.stdout.write(`  Type "exit" to end session.
-`);
-  process.stdout.write("\n");
-  const readline = await import("readline");
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: "> "
-  });
-  const printProgress = () => {
-    const s = session.getState();
-    if (s.progress) {
-      process.stdout.write(
-        `  [plan: ${s.progress.completed}/${s.progress.total} (${s.progress.percentage}%)]
-`
-      );
-    }
-  };
-  rl.prompt();
-  rl.on("line", async (input) => {
-    const trimmed = input.trim();
-    if (!trimmed) {
-      rl.prompt();
-      return;
-    }
-    if (trimmed === "exit" || trimmed === "quit") {
-      const finalState = session.stop();
-      process.stdout.write("\n");
-      process.stdout.write(`  Session complete.
-`);
-      process.stdout.write(`  Actions: ${finalState.actionsEvaluated} evaluated`);
-      process.stdout.write(`, ${finalState.actionsAllowed} allowed`);
-      process.stdout.write(`, ${finalState.actionsBlocked} blocked
-`);
-      if (finalState.progress) {
-        process.stdout.write(
-          `  Plan: ${finalState.progress.completed}/${finalState.progress.total} steps completed
-`
-        );
-      }
-      process.stdout.write("\n");
-      rl.close();
-      return;
-    }
-    if (trimmed === "status") {
-      const s = session.getState();
-      process.stdout.write(`
-  World: ${s.world.world.name}
-`);
-      process.stdout.write(`  Actions: ${s.actionsEvaluated} evaluated
-`);
-      process.stdout.write(`  Allowed: ${s.actionsAllowed} | Blocked: ${s.actionsBlocked} | Modified: ${s.actionsModified} | Paused: ${s.actionsPaused}
-`);
-      process.stdout.write(`  Penalized: ${s.actionsPenalized} | Rewarded: ${s.actionsRewarded}
-`);
-      if (s.progress && s.plan) {
-        process.stdout.write(`  Plan: ${s.plan.plan_id} \u2014 ${s.progress.completed}/${s.progress.total} (${s.progress.percentage}%)
-`);
-        for (const step of s.plan.steps) {
-          const icon = step.status === "completed" ? "[x]" : "[ ]";
-          process.stdout.write(`    ${icon} ${step.label}
-`);
-        }
-      }
-      process.stdout.write("\n");
-      rl.prompt();
-      return;
-    }
-    try {
-      const response = await model.chat(trimmed);
-      if (response.toolCalls.length > 0) {
-        const finalResponse = await session.processModelResponse(response, model);
-        if (finalResponse.content) {
-          process.stdout.write(`
-${finalResponse.content}
-
-`);
-        }
-        printProgress();
-      } else if (response.content) {
-        process.stdout.write(`
-${response.content}
-
-`);
-      }
-    } catch (err) {
-      process.stderr.write(`
-  Error: ${err}
-
-`);
-    }
-    rl.prompt();
-  });
-  rl.on("close", () => {
-    session.stop();
-  });
-  return new Promise((resolve) => {
-    rl.on("close", resolve);
-  });
-}
-
-export {
-  SessionManager,
-  runPipeMode,
-  runInteractiveMode
-};

package/dist/chunk-AKW5YVCE.js

@@ -1,96 +0,0 @@
-// 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
-};