@neuroverseos/governance 0.1.5 → 0.2.1

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
+};

package/dist/{chunk-EIUHJXBB.js → chunk-GR6DGCZ2.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-FYS2CBUW.js";
 import {
   validateWorld
-} from "./chunk-O5OMJMIE.js";
+} from "./chunk-7P3S7MAY.js";
 
 // src/engine/improve-engine.ts
 function improveWorld(world) {

package/dist/{chunk-EQXFOKH2.js → chunk-IVPKFJX3.js}

@@ -1,9 +1,14 @@
 import {
   evaluateGuard
-} from "./chunk-B4NF3OLW.js";
+} from "./chunk-PQBJBVSW.js";
 import {
   loadWorld
-} from "./chunk-M3TZFGHO.js";
+} from "./chunk-JZPQGIKR.js";
+import {
+  advancePlan,
+  evaluatePlan,
+  getPlanProgress
+} from "./chunk-P74Y66ZV.js";
 
 // src/adapters/langchain.ts
 var GovernanceBlockedError = class extends Error {
@@ -31,12 +36,15 @@ var NeuroVerseCallbackHandler = class {
   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
+      level: options.level,
+      plan: this.activePlan
     };
     this.mapToolCall = options.mapToolCall ?? defaultMapToolCall;
   }
@@ -55,6 +63,7 @@ var NeuroVerseCallbackHandler = class {
       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") {
@@ -67,6 +76,18 @@ var NeuroVerseCallbackHandler = class {
         throw new GovernanceBlockedError(verdict, event);
       }
     }
+    if (verdict.status === "ALLOW" && this.activePlan) {
+      const planVerdict = evaluatePlan(event, this.activePlan);
+      if (planVerdict.matchedStep) {
+        this.activePlan = advancePlan(this.activePlan, planVerdict.matchedStep);
+        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) {

package/dist/{chunk-D7BGWV2J.js → chunk-NF5POFCI.js}

@@ -1,14 +1,16 @@
 import {
-  createProvider,
+  createProvider
+} from "./chunk-Q6O7ZLO2.js";
+import {
   loadConfig
-} from "./chunk-T4X42QXC.js";
+} from "./chunk-OT6PXH54.js";
 import {
   emitWorldDefinition,
   parseWorldMarkdown
 } from "./chunk-XPDMYECO.js";
 import {
   validateWorld
-} from "./chunk-O5OMJMIE.js";
+} from "./chunk-7P3S7MAY.js";
 
 // src/engine/derive-normalizer.ts
 function findSections(lines) {

package/dist/chunk-OT6PXH54.js

@@ -0,0 +1,61 @@
+// src/providers/config-manager.ts
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+function getConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return join(xdg, "neuroverse");
+  return join(homedir(), ".neuroverse");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+async function loadConfig() {
+  try {
+    const raw = await readFile(getConfigPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.provider || !parsed.model || !parsed.apiKey) {
+      return null;
+    }
+    return {
+      provider: parsed.provider,
+      model: parsed.model,
+      apiKey: parsed.apiKey,
+      endpoint: parsed.endpoint ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(config) {
+  const dir = getConfigDir();
+  await mkdir(dir, { recursive: true });
+  const configPath = getConfigPath();
+  const content = JSON.stringify(
+    {
+      provider: config.provider,
+      model: config.model,
+      apiKey: config.apiKey,
+      endpoint: config.endpoint
+    },
+    null,
+    2
+  );
+  await writeFile(configPath, content, { mode: 384 });
+  await chmod(configPath, 384);
+}
+function redactConfig(config) {
+  return {
+    provider: config.provider,
+    model: config.model,
+    apiKey: config.apiKey ? `${config.apiKey.slice(0, 4)}...${config.apiKey.slice(-4)}` : "(not set)",
+    endpoint: config.endpoint
+  };
+}
+
+export {
+  getConfigPath,
+  loadConfig,
+  saveConfig,
+  redactConfig
+};

package/dist/chunk-P74Y66ZV.js

@@ -0,0 +1,205 @@
+// src/engine/plan-engine.ts
+function keywordMatch(eventText, step) {
+  const stepText = [
+    step.label,
+    step.description ?? "",
+    ...step.tags ?? []
+  ].join(" ").toLowerCase();
+  const keywords = stepText.split(/\s+/).filter((w) => w.length > 3);
+  if (keywords.length === 0) return false;
+  const matched = keywords.filter((kw) => eventText.includes(kw));
+  return matched.length >= Math.ceil(keywords.length * 0.5);
+}
+function tokenSimilarity(a, b) {
+  const tokensA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  const tokensB = new Set(b.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  if (tokensA.size === 0 || tokensB.size === 0) return 0;
+  let intersection = 0;
+  for (const t of tokensA) {
+    if (tokensB.has(t)) intersection++;
+  }
+  const union = (/* @__PURE__ */ new Set([...tokensA, ...tokensB])).size;
+  return union > 0 ? intersection / union : 0;
+}
+function findMatchingStep(eventText, event, steps) {
+  const pendingOrActive = steps.filter((s) => s.status === "pending" || s.status === "active");
+  if (pendingOrActive.length === 0) {
+    return { matched: null, closest: null, closestScore: 0 };
+  }
+  for (const step of pendingOrActive) {
+    if (keywordMatch(eventText, step)) {
+      if (step.tools && event.tool && !step.tools.includes(event.tool)) {
+        continue;
+      }
+      return { matched: step, closest: step, closestScore: 1 };
+    }
+  }
+  const intentText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ");
+  let bestStep = null;
+  let bestScore = 0;
+  for (const step of pendingOrActive) {
+    const stepText = [step.label, step.description ?? "", ...step.tags ?? []].join(" ");
+    const score = tokenSimilarity(intentText, stepText);
+    if (score > bestScore) {
+      bestScore = score;
+      bestStep = step;
+    }
+  }
+  const SIMILARITY_THRESHOLD = 0.35;
+  if (bestScore >= SIMILARITY_THRESHOLD && bestStep) {
+    if (bestStep.tools && event.tool && !bestStep.tools.includes(event.tool)) {
+      return { matched: null, closest: bestStep, closestScore: bestScore };
+    }
+    return { matched: bestStep, closest: bestStep, closestScore: bestScore };
+  }
+  return { matched: null, closest: bestStep, closestScore: bestScore };
+}
+function isSequenceValid(step, plan) {
+  if (!plan.sequential) return true;
+  if (!step.requires || step.requires.length === 0) return true;
+  return step.requires.every((reqId) => {
+    const reqStep = plan.steps.find((s) => s.id === reqId);
+    return reqStep?.status === "completed";
+  });
+}
+function checkConstraints(event, eventText, constraints) {
+  const checks = [];
+  for (const constraint of constraints) {
+    if (constraint.type === "approval") {
+      if (constraint.trigger && eventText.includes(constraint.trigger.substring(0, 10).toLowerCase())) {
+        checks.push({ constraintId: constraint.id, passed: false, reason: constraint.description });
+        return { violated: constraint, checks };
+      }
+      const keywords = constraint.description.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+      const relevant = keywords.some((kw) => eventText.includes(kw));
+      if (relevant) {
+        checks.push({ constraintId: constraint.id, passed: false, reason: constraint.description });
+        return { violated: constraint, checks };
+      }
+      checks.push({ constraintId: constraint.id, passed: true });
+      continue;
+    }
+    if (constraint.type === "scope" && constraint.trigger) {
+      const keywords = constraint.trigger.split(/\s+/).filter((w) => w.length > 3);
+      const violated = keywords.length > 0 && keywords.every((kw) => eventText.includes(kw));
+      checks.push({
+        constraintId: constraint.id,
+        passed: !violated,
+        reason: violated ? constraint.description : void 0
+      });
+      if (violated) {
+        return { violated: constraint, checks };
+      }
+      continue;
+    }
+    checks.push({ constraintId: constraint.id, passed: true });
+  }
+  return { violated: null, checks };
+}
+function getPlanProgress(plan) {
+  const completed = plan.steps.filter((s) => s.status === "completed").length;
+  const total = plan.steps.length;
+  return {
+    completed,
+    total,
+    percentage: total > 0 ? Math.round(completed / total * 100) : 0
+  };
+}
+function advancePlan(plan, stepId) {
+  return {
+    ...plan,
+    steps: plan.steps.map(
+      (s) => s.id === stepId ? { ...s, status: "completed" } : s
+    )
+  };
+}
+function evaluatePlan(event, plan) {
+  const progress = getPlanProgress(plan);
+  if (plan.expires_at) {
+    const expiresAt = new Date(plan.expires_at).getTime();
+    if (Date.now() > expiresAt) {
+      return {
+        allowed: true,
+        status: "PLAN_COMPLETE",
+        reason: "Plan has expired.",
+        progress
+      };
+    }
+  }
+  if (progress.completed === progress.total) {
+    return {
+      allowed: true,
+      status: "PLAN_COMPLETE",
+      reason: "All plan steps are completed.",
+      progress
+    };
+  }
+  const eventText = [
+    event.intent,
+    event.tool ?? "",
+    event.scope ?? ""
+  ].join(" ").toLowerCase();
+  const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
+  if (!matched) {
+    return {
+      allowed: false,
+      status: "OFF_PLAN",
+      reason: "Action does not match any plan step.",
+      closestStep: closest?.label,
+      similarityScore: closestScore,
+      progress
+    };
+  }
+  if (!isSequenceValid(matched, plan)) {
+    const pendingDeps = (matched.requires ?? []).filter((reqId) => plan.steps.find((s) => s.id === reqId)?.status !== "completed").join(", ");
+    return {
+      allowed: false,
+      status: "OFF_PLAN",
+      reason: `Step "${matched.label}" requires completion of: ${pendingDeps}`,
+      matchedStep: matched.id,
+      progress
+    };
+  }
+  const { violated } = checkConstraints(event, eventText, plan.constraints);
+  if (violated) {
+    return {
+      allowed: false,
+      status: "CONSTRAINT_VIOLATED",
+      reason: violated.description,
+      matchedStep: matched.id,
+      progress
+    };
+  }
+  return {
+    allowed: true,
+    status: "ON_PLAN",
+    reason: `Matches step: ${matched.label}`,
+    matchedStep: matched.id,
+    progress
+  };
+}
+function buildPlanCheck(event, plan, verdict) {
+  const eventText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ").toLowerCase();
+  const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
+  const { checks: constraintChecks } = checkConstraints(event, eventText, plan.constraints);
+  const progress = getPlanProgress(plan);
+  return {
+    planId: plan.plan_id,
+    matched: !!matched,
+    matchedStepId: matched?.id,
+    matchedStepLabel: matched?.label,
+    closestStepId: !matched ? closest?.id : void 0,
+    closestStepLabel: !matched ? closest?.label : void 0,
+    similarityScore: !matched ? closestScore : void 0,
+    sequenceValid: matched ? isSequenceValid(matched, plan) : void 0,
+    constraintsChecked: constraintChecks,
+    progress: { completed: progress.completed, total: progress.total }
+  };
+}
+
+export {
+  getPlanProgress,
+  advancePlan,
+  evaluatePlan,
+  buildPlanCheck
+};