@neuroverseos/governance 0.3.0 → 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-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
-};

package/dist/chunk-BUWWN2NX.js

@@ -1,192 +0,0 @@
-// src/engine/explain-engine.ts
-function detectTensions(rules) {
-  const increases = /* @__PURE__ */ new Map();
-  const decreases = /* @__PURE__ */ new Map();
-  for (const rule of rules) {
-    const allEffects = collectAllEffects(rule);
-    for (const effect of allEffects) {
-      const target = effect.target;
-      const isIncrease = effect.operation === "add" || effect.operation === "multiply" && typeof effect.value === "number" && effect.value > 1;
-      const isDecrease = effect.operation === "subtract" || effect.operation === "multiply" && typeof effect.value === "number" && effect.value < 1;
-      if (isIncrease) {
-        if (!increases.has(target)) increases.set(target, []);
-        increases.get(target).push(rule.label);
-      }
-      if (isDecrease) {
-        if (!decreases.has(target)) decreases.set(target, []);
-        decreases.get(target).push(rule.label);
-      }
-    }
-  }
-  const tensions = [];
-  for (const [variable, incRules] of increases) {
-    const decRules = decreases.get(variable);
-    if (decRules && decRules.length > 0) {
-      tensions.push({
-        variable,
-        increasedBy: incRules,
-        decreasedBy: decRules
-      });
-    }
-  }
-  return tensions;
-}
-function collectAllEffects(rule) {
-  const effects = [...rule.effects ?? []];
-  for (const ce of rule.effects_conditional ?? []) {
-    effects.push(...ce.effects);
-  }
-  return effects;
-}
-function explainWorld(world) {
-  const dynamics = [...world.rules].sort((a, b) => a.order - b.order).map((rule) => {
-    const allEffects = collectAllEffects(rule);
-    return {
-      ruleId: rule.id,
-      label: rule.label,
-      severity: rule.severity,
-      triggerDescription: rule.causal_translation?.trigger_text ?? describeTriggers(rule),
-      effectDescription: rule.causal_translation?.effect_text ?? describeEffects(allEffects),
-      targets: [...new Set(allEffects.map((e) => e.target))]
-    };
-  });
-  const stateVariables = Object.entries(world.stateSchema.variables ?? {}).map(
-    ([name, v]) => ({
-      name,
-      label: v.label || name,
-      type: v.type,
-      defaultValue: v.default,
-      range: v.type === "number" && v.min !== void 0 && v.max !== void 0 ? `${v.min}\u2013${v.max}` : v.type === "enum" && v.options ? v.options.join(", ") : void 0
-    })
-  );
-  const invariants = world.invariants.map((inv) => ({
-    id: inv.id,
-    label: inv.label,
-    enforcement: inv.enforcement
-  }));
-  const gates = (world.gates.viability_classification ?? []).map((g) => ({
-    status: g.status,
-    field: g.field,
-    threshold: `${g.operator} ${g.value}`
-  }));
-  const tensions = detectTensions(world.rules);
-  const outcomes = (world.outcomes.computed_outcomes ?? []).map((o) => ({
-    id: o.id,
-    label: o.label,
-    type: o.type,
-    primary: o.primary ?? false
-  }));
-  const stats = {
-    invariants: world.invariants.length,
-    stateVariables: Object.keys(world.stateSchema.variables ?? {}).length,
-    rules: world.rules.length,
-    gates: (world.gates.viability_classification ?? []).length,
-    outcomes: (world.outcomes.computed_outcomes ?? []).length,
-    assumptions: Object.keys(world.assumptions.profiles ?? {}).length
-  };
-  return {
-    worldName: world.world.name,
-    worldId: world.world.world_id,
-    thesis: world.world.thesis,
-    dynamics,
-    stateVariables,
-    invariants,
-    gates,
-    tensions,
-    outcomes,
-    stats
-  };
-}
-function describeTriggers(rule) {
-  if (!rule.triggers || rule.triggers.length === 0) return "Always active";
-  return rule.triggers.map((t) => `${t.field} ${t.operator} ${t.value}`).join(" AND ");
-}
-function describeEffects(effects) {
-  if (effects.length === 0) return "No direct effects";
-  return effects.map((e) => {
-    switch (e.operation) {
-      case "multiply":
-        return `${e.target} scaled by ${e.value}`;
-      case "add":
-        return `${e.target} increased by ${e.value}`;
-      case "subtract":
-        return `${e.target} decreased by ${e.value}`;
-      case "set":
-        return `${e.target} set to ${e.value}`;
-      case "set_boolean":
-        return `${e.target} set to ${e.value}`;
-      default:
-        return `${e.target} ${e.operation} ${e.value}`;
-    }
-  }).join("; ");
-}
-function renderExplainText(output) {
-  const lines = [];
-  lines.push(`WORLD: ${output.worldName}`);
-  lines.push(`ID: ${output.worldId}`);
-  lines.push("");
-  if (output.thesis) {
-    lines.push("THESIS");
-    lines.push(`  ${output.thesis}`);
-    lines.push("");
-  }
-  lines.push("STRUCTURE");
-  lines.push(`  ${output.stats.invariants} invariants, ${output.stats.stateVariables} state variables, ${output.stats.rules} rules`);
-  lines.push(`  ${output.stats.gates} viability gates, ${output.stats.outcomes} outcomes, ${output.stats.assumptions} assumption profiles`);
-  lines.push("");
-  if (output.dynamics.length > 0) {
-    lines.push("KEY DYNAMICS");
-    for (const d of output.dynamics) {
-      const severity = d.severity === "structural" ? "[structural]" : d.severity === "advantage" ? "[advantage]" : "[degradation]";
-      lines.push(`  ${d.label} ${severity}`);
-      lines.push(`    When: ${d.triggerDescription}`);
-      lines.push(`    Then: ${d.effectDescription}`);
-    }
-    lines.push("");
-  }
-  if (output.tensions.length > 0) {
-    lines.push("DRAMATIC TENSIONS");
-    for (const t of output.tensions) {
-      lines.push(`  ${t.variable}:`);
-      lines.push(`    Increased by: ${t.increasedBy.join(", ")}`);
-      lines.push(`    Decreased by: ${t.decreasedBy.join(", ")}`);
-    }
-    lines.push("");
-  }
-  if (output.stateVariables.length > 0) {
-    lines.push("STATE VARIABLES");
-    for (const v of output.stateVariables) {
-      const range = v.range ? ` (${v.range})` : "";
-      lines.push(`  ${v.label}: ${v.type}, default ${v.defaultValue}${range}`);
-    }
-    lines.push("");
-  }
-  if (output.invariants.length > 0) {
-    lines.push("INVARIANTS (cannot change)");
-    for (const inv of output.invariants) {
-      lines.push(`  ${inv.label} [${inv.enforcement}]`);
-    }
-    lines.push("");
-  }
-  if (output.gates.length > 0) {
-    lines.push("VIABILITY GATES");
-    for (const g of output.gates) {
-      lines.push(`  ${g.status}: ${g.field} ${g.threshold}`);
-    }
-    lines.push("");
-  }
-  if (output.outcomes.length > 0) {
-    lines.push("OUTCOMES");
-    for (const o of output.outcomes) {
-      const primary = o.primary ? " [primary]" : "";
-      lines.push(`  ${o.label} (${o.type})${primary}`);
-    }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-
-export {
-  explainWorld,
-  renderExplainText
-};

package/dist/chunk-COT5XS4V.js

@@ -1,109 +0,0 @@
-import {
-  evaluateGuard
-} from "./chunk-4JRYGIO7.js";
-import {
-  advancePlan,
-  evaluatePlan,
-  getPlanProgress
-} from "./chunk-4QXB6PEO.js";
-import {
-  loadWorld
-} from "./chunk-JZPQGIKR.js";
-
-// src/adapters/langchain.ts
-var GovernanceBlockedError = class extends Error {
-  verdict;
-  event;
-  constructor(verdict, event) {
-    super(`[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
-    this.name = "GovernanceBlockedError";
-    this.verdict = verdict;
-    this.event = event;
-  }
-};
-function defaultMapToolCall(toolName, toolInput) {
-  return {
-    intent: toolName,
-    tool: toolName,
-    scope: typeof toolInput.path === "string" ? toolInput.path : typeof toolInput.url === "string" ? toolInput.url : void 0,
-    args: toolInput,
-    direction: "input"
-  };
-}
-var NeuroVerseCallbackHandler = class {
-  name = "NeuroVerseGovernance";
-  world;
-  options;
-  engineOptions;
-  mapToolCall;
-  activePlan;
-  constructor(world, options = {}) {
-    this.world = world;
-    this.options = options;
-    this.activePlan = options.plan;
-    this.engineOptions = {
-      trace: options.trace ?? false,
-      level: options.level,
-      plan: this.activePlan
-    };
-    this.mapToolCall = options.mapToolCall ?? defaultMapToolCall;
-  }
-  /**
-   * Called before a tool is executed.
-   * Evaluates the tool call against the governance world.
-   *
-   * @throws GovernanceBlockedError if the action is BLOCKED
-   * @throws GovernanceBlockedError if the action is PAUSED and onPause returns false
-   */
-  async handleToolStart(tool, input) {
-    let parsedInput;
-    try {
-      parsedInput = typeof input === "string" ? JSON.parse(input) : input;
-    } catch {
-      parsedInput = { raw: input };
-    }
-    const event = this.mapToolCall(tool.name, parsedInput);
-    this.engineOptions.plan = this.activePlan;
-    const verdict = evaluateGuard(event, this.world, this.engineOptions);
-    this.options.onEvaluate?.(verdict, event);
-    if (verdict.status === "BLOCK") {
-      this.options.onBlock?.(verdict, event);
-      throw new GovernanceBlockedError(verdict, event);
-    }
-    if (verdict.status === "PAUSE") {
-      const approved = await this.options.onPause?.(verdict, event);
-      if (!approved) {
-        throw new GovernanceBlockedError(verdict, event);
-      }
-    }
-    if (verdict.status === "ALLOW" && this.activePlan) {
-      const planVerdict = evaluatePlan(event, this.activePlan);
-      if (planVerdict.matchedStep) {
-        const advResult = advancePlan(this.activePlan, planVerdict.matchedStep);
-        if (advResult.success && advResult.plan) {
-          this.activePlan = advResult.plan;
-          this.engineOptions.plan = this.activePlan;
-        }
-        const progress = getPlanProgress(this.activePlan);
-        this.options.onPlanProgress?.(progress);
-        if (progress.completed === progress.total) {
-          this.options.onPlanComplete?.();
-        }
-      }
-    }
-  }
-};
-async function createNeuroVerseCallbackHandler(worldPath, options) {
-  const world = await loadWorld(worldPath);
-  return new NeuroVerseCallbackHandler(world, options);
-}
-function createNeuroVerseCallbackHandlerFromWorld(world, options) {
-  return new NeuroVerseCallbackHandler(world, options);
-}
-
-export {
-  GovernanceBlockedError,
-  NeuroVerseCallbackHandler,
-  createNeuroVerseCallbackHandler,
-  createNeuroVerseCallbackHandlerFromWorld
-};

package/dist/chunk-ER62HNGF.js

@@ -1,139 +0,0 @@
-import {
-  evaluateGuard
-} from "./chunk-4JRYGIO7.js";
-import {
-  advancePlan,
-  evaluatePlan,
-  getPlanProgress
-} from "./chunk-4QXB6PEO.js";
-import {
-  loadWorld
-} from "./chunk-JZPQGIKR.js";
-
-// src/adapters/openai.ts
-var GovernanceBlockedError = class extends Error {
-  verdict;
-  toolCallId;
-  constructor(verdict, toolCallId) {
-    super(`[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
-    this.name = "GovernanceBlockedError";
-    this.verdict = verdict;
-    this.toolCallId = toolCallId;
-  }
-};
-function defaultMapFunctionCall(name, args) {
-  return {
-    intent: name,
-    tool: name,
-    scope: typeof args.path === "string" ? args.path : typeof args.url === "string" ? args.url : void 0,
-    args,
-    direction: "input"
-  };
-}
-function defaultBlockMessage(verdict) {
-  return `Action blocked by governance policy: ${verdict.reason ?? "rule violation"}. Rule: ${verdict.ruleId ?? "unknown"}.`;
-}
-var GovernedToolExecutor = class {
-  world;
-  options;
-  engineOptions;
-  mapFn;
-  blockMsg;
-  activePlan;
-  constructor(world, options = {}) {
-    this.world = world;
-    this.options = options;
-    this.activePlan = options.plan;
-    this.engineOptions = {
-      trace: options.trace ?? false,
-      level: options.level,
-      plan: this.activePlan
-    };
-    this.mapFn = options.mapFunctionCall ?? defaultMapFunctionCall;
-    this.blockMsg = options.blockMessage ?? defaultBlockMessage;
-  }
-  /**
-   * Evaluate a single tool call against governance rules.
-   * Returns the verdict without executing the tool.
-   */
-  evaluate(toolCall) {
-    let args;
-    try {
-      args = JSON.parse(toolCall.function.arguments);
-    } catch {
-      args = { raw: toolCall.function.arguments };
-    }
-    const event = this.mapFn(toolCall.function.name, args);
-    this.engineOptions.plan = this.activePlan;
-    const verdict = evaluateGuard(event, this.world, this.engineOptions);
-    this.options.onEvaluate?.(verdict, event);
-    if (verdict.status === "ALLOW" && this.activePlan) {
-      const planVerdict = evaluatePlan(event, this.activePlan);
-      if (planVerdict.matchedStep) {
-        const advResult = advancePlan(this.activePlan, planVerdict.matchedStep);
-        if (advResult.success && advResult.plan) {
-          this.activePlan = advResult.plan;
-          this.engineOptions.plan = this.activePlan;
-        }
-        const progress = getPlanProgress(this.activePlan);
-        this.options.onPlanProgress?.(progress);
-        if (progress.completed === progress.total) {
-          this.options.onPlanComplete?.();
-        }
-      }
-    }
-    return verdict;
-  }
-  /**
-   * Execute a tool call with governance enforcement.
-   *
-   * If ALLOW: runs the tool and returns the result.
-   * If BLOCK: returns a blocked message (no execution).
-   * If PAUSE: throws — caller must handle approval flow.
-   *
-   * @param toolCall - The OpenAI tool call to evaluate
-   * @param runner - The actual tool execution function
-   * @returns A tool result message ready for the OpenAI API
-   */
-  async execute(toolCall, runner) {
-    const verdict = this.evaluate(toolCall);
-    if (verdict.status === "BLOCK") {
-      return {
-        tool_call_id: toolCall.id,
-        role: "tool",
-        content: this.blockMsg(verdict),
-        _verdict: verdict
-      };
-    }
-    if (verdict.status === "PAUSE") {
-      throw new GovernanceBlockedError(verdict, toolCall.id);
-    }
-    let args;
-    try {
-      args = JSON.parse(toolCall.function.arguments);
-    } catch {
-      args = { raw: toolCall.function.arguments };
-    }
-    const content = await runner(toolCall.function.name, args);
-    return {
-      tool_call_id: toolCall.id,
-      role: "tool",
-      content,
-      _verdict: verdict
-    };
-  }
-};
-async function createGovernedToolExecutor(worldPath, options) {
-  const world = await loadWorld(worldPath);
-  return new GovernedToolExecutor(world, options);
-}
-function createGovernedToolExecutorFromWorld(world, options) {
-  return new GovernedToolExecutor(world, options);
-}
-
-export {
-  GovernanceBlockedError,
-  GovernedToolExecutor,
-  createGovernedToolExecutor,
-  createGovernedToolExecutorFromWorld
-};