@neuroverseos/governance 0.3.1 → 0.3.3

package/dist/bootstrap-CQRZVOXK.js

@@ -0,0 +1,116 @@
+import {
+  BOOTSTRAP_EXIT_CODES
+} from "./chunk-4NGDRRQH.js";
+import {
+  parseWorldMarkdown
+} from "./chunk-EMQDLDAF.js";
+import {
+  emitWorldDefinition
+} from "./chunk-PVTQQS3Y.js";
+import "./chunk-QWGCMQQD.js";
+
+// src/cli/bootstrap.ts
+function parseArgs(argv) {
+  let inputPath = "";
+  let outputPath = "";
+  let validate = false;
+  let format = "full";
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--input" && i + 1 < argv.length) {
+      inputPath = argv[++i];
+    } else if (arg === "--output" && i + 1 < argv.length) {
+      outputPath = argv[++i];
+    } else if (arg === "--validate") {
+      validate = true;
+    } else if (arg === "--format" && i + 1 < argv.length) {
+      const val = argv[++i];
+      if (val === "full" || val === "summary") format = val;
+    }
+  }
+  if (!inputPath) throw new Error("--input <path> is required");
+  if (!outputPath) throw new Error("--output <path> is required");
+  return { inputPath, outputPath, validate, format };
+}
+async function writeWorldFiles(outputDir, world) {
+  const { writeFile, mkdir } = await import("fs/promises");
+  const { join } = await import("path");
+  await mkdir(outputDir, { recursive: true });
+  await writeFile(join(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
+  await writeFile(join(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
+  await writeFile(join(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
+  await writeFile(join(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
+  const rulesDir = join(outputDir, "rules");
+  await mkdir(rulesDir, { recursive: true });
+  const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
+  for (let i = 0; i < sortedRules.length; i++) {
+    const ruleNum = String(i + 1).padStart(3, "0");
+    await writeFile(join(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+  }
+  await writeFile(join(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
+  await writeFile(join(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
+  await writeFile(join(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
+}
+async function main(argv = process.argv.slice(2)) {
+  const startTime = performance.now();
+  try {
+    const args = parseArgs(argv);
+    const { readFile } = await import("fs/promises");
+    let markdown;
+    try {
+      markdown = await readFile(args.inputPath, "utf-8");
+    } catch {
+      const errorResult = { error: `Cannot read file: ${args.inputPath}` };
+      process.stderr.write(JSON.stringify(errorResult, null, 2) + "\n");
+      process.exit(BOOTSTRAP_EXIT_CODES.ERROR);
+      return;
+    }
+    const parseResult = parseWorldMarkdown(markdown);
+    const parseErrors = parseResult.issues.filter((i) => i.severity === "error");
+    if (parseErrors.length > 0 || !parseResult.world) {
+      const result2 = {
+        success: false,
+        sourcePath: args.inputPath,
+        issues: parseResult.issues,
+        parsedSections: [],
+        durationMs: performance.now() - startTime
+      };
+      process.stdout.write(JSON.stringify(result2, null, 2) + "\n");
+      process.exit(BOOTSTRAP_EXIT_CODES.FAIL);
+      return;
+    }
+    const emitResult = emitWorldDefinition(parseResult.world);
+    const allIssues = [...parseResult.issues, ...emitResult.issues];
+    await writeWorldFiles(args.outputPath, emitResult.world);
+    let validateReport;
+    if (args.validate) {
+      const { validateWorld } = await import("./validate-engine-7ZXFVGF2.js");
+      validateReport = validateWorld(emitResult.world);
+    }
+    const result = {
+      success: true,
+      sourcePath: args.inputPath,
+      issues: allIssues,
+      parsedSections: Object.keys(parseResult.world).filter((k) => {
+        const val = parseResult.world[k];
+        if (Array.isArray(val)) return val.length > 0;
+        if (typeof val === "string") return val.length > 0;
+        return !!val;
+      }),
+      durationMs: performance.now() - startTime
+    };
+    if (validateReport) {
+      result.validateReport = args.format === "summary" ? { summary: validateReport.summary } : validateReport;
+    }
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    const hasErrors = allIssues.some((i) => i.severity === "error");
+    process.exit(hasErrors ? BOOTSTRAP_EXIT_CODES.FAIL : BOOTSTRAP_EXIT_CODES.SUCCESS);
+  } catch (e) {
+    const errorResult = { error: "Bootstrap failed", detail: String(e) };
+    process.stderr.write(JSON.stringify(errorResult, null, 2) + "\n");
+    process.exit(BOOTSTRAP_EXIT_CODES.ERROR);
+  }
+}
+export {
+  main
+};

package/dist/bootstrap-emitter-Q7UIJZ2O.js

@@ -0,0 +1,7 @@
+import {
+  emitWorldDefinition
+} from "./chunk-PVTQQS3Y.js";
+import "./chunk-QWGCMQQD.js";
+export {
+  emitWorldDefinition
+};

package/dist/bootstrap-parser-EEF36XDU.js

@@ -0,0 +1,7 @@
+import {
+  parseWorldMarkdown
+} from "./chunk-EMQDLDAF.js";
+import "./chunk-QWGCMQQD.js";
+export {
+  parseWorldMarkdown
+};