@neuroverseos/governance 0.5.0 → 0.6.0

package/dist/migrate-NH5PVMX4.js

@@ -0,0 +1,221 @@
+import "./chunk-QWGCMQQD.js";
+
+// src/cli/migrate.ts
+import { readFileSync, writeFileSync, cpSync, existsSync } from "fs";
+import { join } from "path";
+var USAGE = `
+neuroverse migrate \u2014 World schema version migration
+
+Usage:
+  neuroverse migrate --world <dir> [options]
+
+Options:
+  --world <dir>       World directory to migrate (required)
+  --dry-run           Show what would change without modifying files
+  --backup            Copy original world to <dir>.backup before migrating
+  --target <version>  Target schema version (default: latest)
+  --json              Output migration plan as JSON
+
+Examples:
+  neuroverse migrate --world ./world/ --dry-run
+  neuroverse migrate --world ./world/ --backup
+  neuroverse migrate --world ./world/ --target 1.1.0
+`.trim();
+var MIGRATIONS = [
+  {
+    from: "1.0.0",
+    to: "1.1.0",
+    description: "Add enforcement_level to world.json, normalize metadata fields",
+    apply: (worldPath) => {
+      const changes = [];
+      const worldJsonPath = join(worldPath, "world.json");
+      if (existsSync(worldJsonPath)) {
+        const world = JSON.parse(readFileSync(worldJsonPath, "utf-8"));
+        if (!world.enforcement_level) {
+          world.enforcement_level = "standard";
+          writeFileSync(worldJsonPath, JSON.stringify(world, null, 2) + "\n", "utf-8");
+          changes.push({
+            file: "world.json",
+            action: "modified",
+            description: 'Added enforcement_level: "standard"'
+          });
+        }
+      }
+      const metaPath = join(worldPath, "metadata.json");
+      if (existsSync(metaPath)) {
+        const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+        let modified = false;
+        if (meta.configurator_version && !meta.authoring_method) {
+          meta.authoring_method = meta.configurator_version;
+          delete meta.configurator_version;
+          modified = true;
+        }
+        if (!meta.schema_version) {
+          meta.schema_version = "1.1.0";
+          modified = true;
+        } else {
+          meta.schema_version = "1.1.0";
+          modified = true;
+        }
+        if (modified) {
+          writeFileSync(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+          changes.push({
+            file: "metadata.json",
+            action: "modified",
+            description: "Normalized metadata fields, updated schema_version to 1.1.0"
+          });
+        }
+      }
+      return changes;
+    }
+  }
+];
+var LATEST_VERSION = MIGRATIONS.length > 0 ? MIGRATIONS[MIGRATIONS.length - 1].to : "1.0.0";
+function detectVersion(worldPath) {
+  const metaPath = join(worldPath, "metadata.json");
+  if (existsSync(metaPath)) {
+    try {
+      const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+      if (meta.schema_version) return meta.schema_version;
+    } catch {
+    }
+  }
+  return "1.0.0";
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) < (pb[i] ?? 0)) return -1;
+    if ((pa[i] ?? 0) > (pb[i] ?? 0)) return 1;
+  }
+  return 0;
+}
+function findMigrationPath(from, to) {
+  const path = [];
+  let current = from;
+  while (compareVersions(current, to) < 0) {
+    const next = MIGRATIONS.find((m) => m.from === current);
+    if (!next) break;
+    path.push(next);
+    current = next.to;
+  }
+  return path;
+}
+function parseArgs(argv) {
+  let worldPath = "";
+  let dryRun = false;
+  let backup = false;
+  let target = LATEST_VERSION;
+  let json = false;
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--world" && argv[i + 1]) {
+      worldPath = argv[++i];
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--backup") {
+      backup = true;
+    } else if (arg === "--target" && argv[i + 1]) {
+      target = argv[++i];
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    }
+  }
+  return { worldPath, dryRun, backup, target, json, help };
+}
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    process.stdout.write(USAGE + "\n");
+    return;
+  }
+  if (!args.worldPath) {
+    process.stderr.write("Error: --world <dir> is required.\n");
+    process.exit(1);
+  }
+  const currentVersion = detectVersion(args.worldPath);
+  const targetVersion = args.target;
+  if (compareVersions(currentVersion, targetVersion) >= 0) {
+    const plan2 = {
+      currentVersion,
+      targetVersion,
+      migrations: [],
+      changes: []
+    };
+    if (args.json) {
+      process.stdout.write(JSON.stringify(plan2, null, 2) + "\n");
+    } else {
+      process.stdout.write(`World is already at version ${currentVersion} (target: ${targetVersion})
+`);
+      process.stdout.write("No migrations needed.\n");
+    }
+    return;
+  }
+  const migrationPath = findMigrationPath(currentVersion, targetVersion);
+  if (migrationPath.length === 0) {
+    process.stderr.write(`No migration path from ${currentVersion} to ${targetVersion}
+`);
+    process.exit(1);
+    return;
+  }
+  if (args.dryRun) {
+    const plan2 = {
+      currentVersion,
+      targetVersion,
+      migrations: migrationPath.map((m) => ({ from: m.from, to: m.to, description: m.description })),
+      changes: []
+    };
+    if (args.json) {
+      process.stdout.write(JSON.stringify(plan2, null, 2) + "\n");
+    } else {
+      process.stdout.write(`Migration plan: ${currentVersion} \u2192 ${targetVersion}
+`);
+      process.stdout.write(`Steps: ${migrationPath.length}
+
+`);
+      for (const m of migrationPath) {
+        process.stdout.write(`  ${m.from} \u2192 ${m.to}: ${m.description}
+`);
+      }
+      process.stdout.write("\nRun without --dry-run to apply.\n");
+    }
+    return;
+  }
+  if (args.backup) {
+    const backupPath = args.worldPath + ".backup";
+    cpSync(args.worldPath, backupPath, { recursive: true });
+    process.stdout.write(`Backup created: ${backupPath}
+`);
+  }
+  const allChanges = [];
+  for (const migration of migrationPath) {
+    process.stdout.write(`Applying: ${migration.from} \u2192 ${migration.to} (${migration.description})
+`);
+    const changes = migration.apply(args.worldPath);
+    allChanges.push(...changes);
+    for (const change of changes) {
+      process.stdout.write(`  ${change.action}: ${change.file} \u2014 ${change.description}
+`);
+    }
+  }
+  const plan = {
+    currentVersion,
+    targetVersion,
+    migrations: migrationPath.map((m) => ({ from: m.from, to: m.to, description: m.description })),
+    changes: allChanges
+  };
+  if (args.json) {
+    process.stdout.write(JSON.stringify(plan, null, 2) + "\n");
+  }
+  process.stdout.write(`
+Migration complete: ${currentVersion} \u2192 ${targetVersion} (${allChanges.length} changes)
+`);
+}
+export {
+  LATEST_VERSION,
+  main
+};

package/dist/{playground-4BK2XQ47.js → playground-3TTBN7XD.js}

@@ -1,15 +1,15 @@
 import {
   validateWorld
 } from "./chunk-7P3S7MAY.js";
-import {
-  evaluateGuard
-} from "./chunk-ZAF6JH23.js";
-import "./chunk-QLPTHTVB.js";
 import {
   DEFAULT_BUNDLED_WORLD,
   loadBundledWorld,
   loadWorld
-} from "./chunk-BXLTEUS4.js";
+} from "./chunk-I4RTIMLX.js";
+import {
+  evaluateGuard
+} from "./chunk-ZAF6JH23.js";
+import "./chunk-QLPTHTVB.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/playground.ts

package/dist/{redteam-BRZALBPP.js → redteam-W644UMWN.js}

@@ -1,10 +1,10 @@
+import {
+  loadWorld
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";
 import "./chunk-QLPTHTVB.js";
-import {
-  loadWorld
-} from "./chunk-BXLTEUS4.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/redteam.ts

package/dist/{session-SGRUT2UH.js → session-FMAROEIE.js}

@@ -2,11 +2,11 @@ import {
   SessionManager,
   runInteractiveMode,
   runPipeMode
-} from "./chunk-UTH7OXTM.js";
+} from "./chunk-OTZU76DH.js";
 import "./chunk-D2UCV5AK.js";
+import "./chunk-I4RTIMLX.js";
 import "./chunk-ZAF6JH23.js";
 import "./chunk-QLPTHTVB.js";
-import "./chunk-BXLTEUS4.js";
 import "./chunk-QWGCMQQD.js";
 export {
   SessionManager,

package/dist/{shared-CwGpPheR.d.ts → shared-DAzdfWtU.d.ts}

@@ -1,4 +1,4 @@
-import { a as GuardVerdict, P as PlanDefinition, c as PlanProgress, b as GuardEngineOptions, G as GuardEvent } from './guard-contract-CLBbTGK_.js';
+import { G as GuardVerdict, P as PlanDefinition, c as PlanProgress, b as GuardEngineOptions, a as GuardEvent } from './guard-contract-q6HJAq3Q.js';
 
 /**
  * Shared Adapter Utilities

package/dist/{shared-BGzmYP5g.d.cts → shared-PpalGKxc.d.cts}

@@ -1,4 +1,4 @@
-import { a as GuardVerdict, P as PlanDefinition, c as PlanProgress, b as GuardEngineOptions, G as GuardEvent } from './guard-contract-CLBbTGK_.cjs';
+import { G as GuardVerdict, P as PlanDefinition, c as PlanProgress, b as GuardEngineOptions, a as GuardEvent } from './guard-contract-ddiIPlOg.cjs';
 
 /**
  * Shared Adapter Utilities

package/dist/sign-RRELHKWM.js

@@ -0,0 +1,11 @@
+import {
+  buildManifest,
+  canonicalManifest,
+  main
+} from "./chunk-H3REGQRI.js";
+import "./chunk-QWGCMQQD.js";
+export {
+  buildManifest,
+  canonicalManifest,
+  main
+};

package/dist/{simulate-FGXKIH7V.js → simulate-VT437EEL.js}

@@ -5,10 +5,10 @@ import {
 import {
   renderSimulateText,
   simulateWorld
-} from "./chunk-7QIAF377.js";
+} from "./chunk-CYDMUJVZ.js";
 import {
   loadWorld
-} from "./chunk-BXLTEUS4.js";
+} from "./chunk-I4RTIMLX.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/simulate.ts

package/dist/{test-PT44BSYG.js → test-XDB2DH3L.js}

@@ -1,10 +1,10 @@
+import {
+  loadWorld
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";
 import "./chunk-QLPTHTVB.js";
-import {
-  loadWorld
-} from "./chunk-BXLTEUS4.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/test.ts

package/dist/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);