@neuroverseos/governance 0.1.6 → 0.2.1

package/dist/cli/plan.d.cts

@@ -0,0 +1,20 @@
+/**
+ * neuroverse plan — Plan Enforcement CLI
+ *
+ * Subcommands:
+ *   compile   Parse plan markdown into plan.json
+ *   check     Check an action against a plan (stdin → stdout)
+ *   status    Show plan progress
+ *   advance   Mark a step as completed
+ *   derive    Generate a full world from a plan
+ *
+ * Usage:
+ *   neuroverse plan compile <plan.md> [--output plan.json]
+ *   echo '{"intent":"..."}' | neuroverse plan check --plan plan.json [--world ./world/]
+ *   neuroverse plan status --plan plan.json
+ *   neuroverse plan advance <step_id> --plan plan.json
+ *   neuroverse plan derive <plan.md> [--output ./world/]
+ */
+declare function main(args: string[]): Promise<void>;
+
+export { main };

package/dist/cli/plan.d.ts

@@ -0,0 +1,20 @@
+/**
+ * neuroverse plan — Plan Enforcement CLI
+ *
+ * Subcommands:
+ *   compile   Parse plan markdown into plan.json
+ *   check     Check an action against a plan (stdin → stdout)
+ *   status    Show plan progress
+ *   advance   Mark a step as completed
+ *   derive    Generate a full world from a plan
+ *
+ * Usage:
+ *   neuroverse plan compile <plan.md> [--output plan.json]
+ *   echo '{"intent":"..."}' | neuroverse plan check --plan plan.json [--world ./world/]
+ *   neuroverse plan status --plan plan.json
+ *   neuroverse plan advance <step_id> --plan plan.json
+ *   neuroverse plan derive <plan.md> [--output ./world/]
+ */
+declare function main(args: string[]): Promise<void>;
+
+export { main };

package/dist/cli/plan.js

@@ -0,0 +1,346 @@
+import {
+  PLAN_EXIT_CODES,
+  parsePlanMarkdown
+} from "../chunk-37JG24WH.js";
+import {
+  advancePlan,
+  evaluatePlan,
+  getPlanProgress
+} from "../chunk-P74Y66ZV.js";
+import "../chunk-YZFATT7X.js";
+
+// src/cli/plan.ts
+import { readFileSync, writeFileSync } from "fs";
+function parseArg(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : void 0;
+}
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", reject);
+  });
+}
+async function compileCommand(args) {
+  const inputPath = args.find((a) => !a.startsWith("--"));
+  if (!inputPath) {
+    process.stderr.write("Usage: neuroverse plan compile <plan.md> [--output plan.json]\n");
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const outputPath = parseArg(args, "--output") ?? inputPath.replace(/\.md$/, ".json");
+  let markdown;
+  try {
+    markdown = readFileSync(inputPath, "utf-8");
+  } catch (err) {
+    process.stderr.write(`Error reading ${inputPath}: ${err}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const result = parsePlanMarkdown(markdown);
+  if (!result.success || !result.plan) {
+    process.stderr.write(`Parse errors:
+`);
+    for (const error of result.errors) {
+      process.stderr.write(`  - ${error}
+`);
+    }
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  writeFileSync(outputPath, JSON.stringify(result.plan, null, 2) + "\n");
+  const plan = result.plan;
+  process.stdout.write(`Plan compiled: ${plan.plan_id}
+`);
+  process.stdout.write(`  Objective: ${plan.objective}
+`);
+  process.stdout.write(`  Steps: ${plan.steps.length}
+`);
+  process.stdout.write(`  Constraints: ${plan.constraints.length}
+`);
+  process.stdout.write(`  Sequential: ${plan.sequential}
+`);
+  if (plan.world_id) process.stdout.write(`  World: ${plan.world_id}
+`);
+  if (plan.expires_at) process.stdout.write(`  Expires: ${plan.expires_at}
+`);
+  process.stdout.write(`  Output: ${outputPath}
+`);
+}
+async function checkCommand(args) {
+  const planPath = parseArg(args, "--plan");
+  if (!planPath) {
+    process.stderr.write(`Usage: echo '{"intent":"..."}' | neuroverse plan check --plan plan.json
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  let plan;
+  try {
+    plan = JSON.parse(readFileSync(planPath, "utf-8"));
+  } catch (err) {
+    process.stderr.write(`Error reading plan: ${err}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const stdinData = await readStdin();
+  let event;
+  try {
+    event = JSON.parse(stdinData);
+  } catch {
+    process.stderr.write('Error: stdin must be valid JSON with an "intent" field.\n');
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  if (!event.intent) {
+    process.stderr.write('Error: event must have an "intent" field.\n');
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const worldPath = parseArg(args, "--world");
+  if (worldPath) {
+    const { loadWorld } = await import("../world-loader-HMPTOEA2.js");
+    const { evaluateGuard } = await import("../guard-engine-D7X4CVAE.js");
+    const world = await loadWorld(worldPath);
+    const verdict2 = evaluateGuard(event, world, { plan });
+    process.stdout.write(JSON.stringify(verdict2, null, 2) + "\n");
+    const exitCode2 = verdict2.status === "ALLOW" ? 0 : verdict2.status === "BLOCK" ? 1 : 2;
+    process.exit(exitCode2);
+    return;
+  }
+  const verdict = evaluatePlan(event, plan);
+  process.stdout.write(JSON.stringify(verdict, null, 2) + "\n");
+  const exitCode = PLAN_EXIT_CODES[verdict.status] ?? PLAN_EXIT_CODES.ERROR;
+  process.exit(exitCode);
+}
+async function statusCommand(args) {
+  const planPath = parseArg(args, "--plan");
+  if (!planPath) {
+    process.stderr.write("Usage: neuroverse plan status --plan plan.json\n");
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  let plan;
+  try {
+    plan = JSON.parse(readFileSync(planPath, "utf-8"));
+  } catch (err) {
+    process.stderr.write(`Error reading plan: ${err}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const progress = getPlanProgress(plan);
+  process.stdout.write(`Plan: ${plan.plan_id}
+`);
+  process.stdout.write(`Objective: ${plan.objective}
+`);
+  process.stdout.write(`Progress: ${progress.completed}/${progress.total} (${progress.percentage}%)
+`);
+  process.stdout.write(`
+Steps:
+`);
+  for (const step of plan.steps) {
+    const status = step.status === "completed" ? "[x]" : step.status === "active" ? "[>]" : step.status === "skipped" ? "[-]" : "[ ]";
+    let line = `  ${status} ${step.label}`;
+    if (step.tags?.length) line += ` [tag: ${step.tags.join(", ")}]`;
+    if (step.verify) line += ` [verify: ${step.verify}]`;
+    if (step.requires?.length) line += ` (after: ${step.requires.join(", ")})`;
+    process.stdout.write(line + "\n");
+  }
+  if (plan.constraints.length > 0) {
+    process.stdout.write(`
+Constraints:
+`);
+    for (const c of plan.constraints) {
+      process.stdout.write(`  - ${c.description} [${c.type}/${c.enforcement}]
+`);
+    }
+  }
+}
+async function advanceCommand(args) {
+  const stepId = args.find((a) => !a.startsWith("--"));
+  const planPath = parseArg(args, "--plan");
+  if (!stepId || !planPath) {
+    process.stderr.write("Usage: neuroverse plan advance <step_id> --plan plan.json\n");
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  let plan;
+  try {
+    plan = JSON.parse(readFileSync(planPath, "utf-8"));
+  } catch (err) {
+    process.stderr.write(`Error reading plan: ${err}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const step = plan.steps.find((s) => s.id === stepId);
+  if (!step) {
+    process.stderr.write(`Error: step "${stepId}" not found in plan.
+`);
+    process.stderr.write(`Available steps: ${plan.steps.map((s) => s.id).join(", ")}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  if (step.status === "completed") {
+    process.stdout.write(`Step "${stepId}" is already completed.
+`);
+    return;
+  }
+  const updated = advancePlan(plan, stepId);
+  writeFileSync(planPath, JSON.stringify(updated, null, 2) + "\n");
+  const progress = getPlanProgress(updated);
+  process.stdout.write(`Step completed: ${step.label}
+`);
+  process.stdout.write(`Progress: ${progress.completed}/${progress.total} (${progress.percentage}%)
+`);
+  if (progress.completed === progress.total) {
+    process.stdout.write(`
+Plan complete!
+`);
+  }
+}
+async function deriveCommand(args) {
+  const inputPath = args.find((a) => !a.startsWith("--"));
+  if (!inputPath) {
+    process.stderr.write("Usage: neuroverse plan derive <plan.md> [--output ./world/]\n");
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const outputDir = parseArg(args, "--output") ?? "./derived-world/";
+  let markdown;
+  try {
+    markdown = readFileSync(inputPath, "utf-8");
+  } catch (err) {
+    process.stderr.write(`Error reading ${inputPath}: ${err}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const result = parsePlanMarkdown(markdown);
+  if (!result.success || !result.plan) {
+    process.stderr.write(`Parse errors:
+`);
+    for (const error of result.errors) {
+      process.stderr.write(`  - ${error}
+`);
+    }
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const plan = result.plan;
+  const { mkdirSync } = await import("fs");
+  mkdirSync(outputDir, { recursive: true });
+  const worldJson = {
+    world_id: `plan_${plan.plan_id}`,
+    name: `Derived: ${plan.objective}`,
+    thesis: plan.objective,
+    version: "1.0.0",
+    runtime_mode: "COMPLIANCE",
+    default_assumption_profile: "default",
+    default_alternative_profile: "default",
+    modules: ["governance"],
+    players: { thinking_space: true, experience_space: false, action_space: true }
+  };
+  const invariants = plan.constraints.map((c, i) => ({
+    id: `inv_${c.id}`,
+    label: c.description,
+    type: "structural",
+    enforcement: c.enforcement === "block" ? "hard" : "soft"
+  }));
+  const guards = {
+    intent_vocabulary: {},
+    guards: plan.steps.map((step) => {
+      const patternKey = `plan_step_${step.id}`;
+      return {
+        id: `guard_${step.id}`,
+        label: `Plan step: ${step.label}`,
+        description: `Governs execution of plan step: ${step.label}`,
+        category: "operational",
+        enforcement: "warn",
+        intent_patterns: [patternKey],
+        appliesTo: step.tools ?? [],
+        default_enabled: true,
+        immutable: false
+      };
+    })
+  };
+  for (const step of plan.steps) {
+    const keywords = step.label.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+    const pattern = keywords.map((k) => `(?=.*${k})`).join("") + ".*";
+    guards.intent_vocabulary[`plan_step_${step.id}`] = {
+      pattern,
+      description: step.label
+    };
+  }
+  writeFileSync(`${outputDir}/world.json`, JSON.stringify(worldJson, null, 2) + "\n");
+  writeFileSync(`${outputDir}/invariants.json`, JSON.stringify(invariants, null, 2) + "\n");
+  writeFileSync(`${outputDir}/guards.json`, JSON.stringify(guards, null, 2) + "\n");
+  process.stdout.write(`World derived from plan: ${plan.plan_id}
+`);
+  process.stdout.write(`  Output: ${outputDir}
+`);
+  process.stdout.write(`  Files: world.json, invariants.json, guards.json
+`);
+  process.stdout.write(`  Guards: ${plan.steps.length} (one per step)
+`);
+  process.stdout.write(`  Invariants: ${plan.constraints.length} (one per constraint)
+`);
+}
+var PLAN_USAGE = `
+neuroverse plan \u2014 Plan enforcement for AI agents.
+
+Subcommands:
+  compile   Parse plan markdown into plan.json
+  check     Check an action against a plan (stdin \u2192 stdout)
+  status    Show plan progress
+  advance   Mark a step as completed
+  derive    Generate a full world from a plan
+
+Usage:
+  neuroverse plan compile <plan.md> [--output plan.json]
+  echo '{"intent":"..."}' | neuroverse plan check --plan plan.json [--world ./world/]
+  neuroverse plan status --plan plan.json
+  neuroverse plan advance <step_id> --plan plan.json
+  neuroverse plan derive <plan.md> [--output ./world/]
+`.trim();
+async function main(args) {
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+  switch (subcommand) {
+    case "compile":
+      return compileCommand(subArgs);
+    case "check":
+      return checkCommand(subArgs);
+    case "status":
+      return statusCommand(subArgs);
+    case "advance":
+      return advanceCommand(subArgs);
+    case "derive":
+      return deriveCommand(subArgs);
+    case "--help":
+    case "-h":
+    case "help":
+    case void 0:
+      process.stdout.write(PLAN_USAGE + "\n");
+      process.exit(0);
+      break;
+    default:
+      process.stderr.write(`Unknown plan subcommand: "${subcommand}"
+
+`);
+      process.stdout.write(PLAN_USAGE + "\n");
+      process.exit(1);
+  }
+}
+export {
+  main
+};