@neuroverseos/governance 0.5.1 → 0.6.0

package/dist/cli/worldmodel.js

@@ -0,0 +1,742 @@
+import {
+  compileWorldModel,
+  emitContextsConfig,
+  emitLensSuggestions,
+  emitOverlapMap,
+  emitSignalSchema,
+  emitWorldMarkdown
+} from "../chunk-EQR7BGFN.js";
+import {
+  parseWorldModel
+} from "../chunk-UGTNKTHS.js";
+import "../chunk-QWGCMQQD.js";
+
+// src/cli/worldmodel.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { resolve, basename, dirname, join } from "path";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var CYAN = "\x1B[36m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var MAGENTA = "\x1B[35m";
+var RESET = "\x1B[0m";
+var USAGE = `
+neuroverse worldmodel \u2014 Behavioral world model toolkit
+
+  ${BOLD}This file defines how a system behaves, how that behavior
+  is interpreted, and how it evolves over time.${RESET}
+
+Commands:
+  init           Scaffold a new .worldmodel.md template
+  validate       Check structure and completeness
+  explain        Human-readable model summary
+  build          Compile to .nv-world.md + signals + overlaps + contexts + lenses
+  emit-world     Emit compiled .nv-world.md to stdout
+  emit-signals   Emit signal schema JSON to stdout
+  emit-lenses    Emit lens suggestions JSON to stdout
+  emit-contexts  Emit contextual modifiers JSON to stdout
+  emit-overlaps  Emit overlap map JSON to stdout
+
+Usage:
+  neuroverse worldmodel init [--name "Name"] [--output path]
+  neuroverse worldmodel validate <source.worldmodel.md> [--json]
+  neuroverse worldmodel explain <source.worldmodel.md> [--json]
+  neuroverse worldmodel build <source.worldmodel.md> [--output <dir>]
+  neuroverse worldmodel emit-world <source.worldmodel.md>
+  neuroverse worldmodel emit-signals <source.worldmodel.md> [--json]
+  neuroverse worldmodel emit-lenses <source.worldmodel.md> [--json]
+  neuroverse worldmodel emit-contexts <source.worldmodel.md> [--json]
+  neuroverse worldmodel emit-overlaps <source.worldmodel.md> [--json]
+
+Examples:
+  neuroverse worldmodel init --name "Auki Vanguard"
+  neuroverse worldmodel build ./auki-vanguard.worldmodel.md --output ./world/
+  neuroverse worldmodel explain ./auki-vanguard.worldmodel.md
+`.trim();
+function parseArgs(argv) {
+  const args = {
+    inputPath: "",
+    output: "",
+    name: "",
+    json: false,
+    help: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      args.json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      args.help = true;
+    } else if (arg === "--output" && i + 1 < argv.length) {
+      args.output = argv[++i];
+    } else if (arg === "--name" && i + 1 < argv.length) {
+      args.name = argv[++i];
+    } else if (!arg.startsWith("--") && !args.inputPath) {
+      args.inputPath = arg;
+    }
+  }
+  return args;
+}
+function formatIssue(issue) {
+  const color = issue.severity === "error" ? RED : issue.severity === "warning" ? YELLOW : DIM;
+  const icon = issue.severity === "error" ? "x" : issue.severity === "warning" ? "!" : "i";
+  const lineRef = issue.line > 0 ? `:${issue.line}` : "";
+  return `  ${color}${icon}${RESET} [${issue.section}${lineRef}] ${issue.message}`;
+}
+async function readSourceFile(inputPath) {
+  const fullPath = resolve(inputPath);
+  if (!existsSync(fullPath)) {
+    process.stderr.write(`File not found: ${fullPath}
+`);
+    process.exit(3);
+  }
+  return readFile(fullPath, "utf-8");
+}
+async function loadAndParse(inputPath) {
+  const content = await readSourceFile(inputPath);
+  const result = parseWorldModel(content);
+  if (!result.model) {
+    process.stderr.write(`${RED}Failed to parse ${inputPath}${RESET}
+`);
+    for (const issue of result.issues) {
+      process.stderr.write(formatIssue(issue) + "\n");
+    }
+    process.exit(1);
+  }
+  return { model: result.model, issues: result.issues };
+}
+async function cmdInit(argv) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    process.stdout.write(
+      'neuroverse worldmodel init \u2014 Scaffold a new .worldmodel.md template\n\nOptions:\n  --name <name>    Model name (default: "My Behavioral Model")\n  --output <path>  Output path (default: ./model.worldmodel.md)\n'
+    );
+    return;
+  }
+  const modelName = args.name || "My Behavioral Model";
+  const outputPath = resolve(
+    args.output || `./${toFileName(modelName)}.worldmodel.md`
+  );
+  if (existsSync(outputPath)) {
+    process.stderr.write(`File already exists: ${outputPath}
+`);
+    process.stderr.write("Use --output to specify a different path.\n");
+    process.exit(1);
+  }
+  const template = generateScaffold(modelName);
+  const dir = dirname(outputPath);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  await writeFile(outputPath, template, "utf-8");
+  process.stderr.write(`${GREEN}Created${RESET} ${outputPath}
+`);
+  process.stderr.write(
+    `${DIM}Edit the template, then run: neuroverse worldmodel validate ${basename(outputPath)}${RESET}
+`
+  );
+}
+function toFileName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function generateScaffold(modelName) {
+  return `---
+name: ${modelName}
+version: 1.0.0
+---
+
+# Core Model Geometry
+<!--
+This section defines the STRUCTURE of your behavioral system.
+
+You are defining:
+- what the system is trying to achieve (mission)
+- the major domains it operates within (2-4 recommended)
+- the skills inside each domain
+- the values that govern those skills
+- what emerges when domains interact
+- what identity forms when everything is aligned
+
+Think of this as the "physics" of your system.
+-->
+
+## Mission
+<!-- What is this system trying to achieve? This is not a slogan \u2014 it is the core aim. -->
+
+Replace with your mission statement.
+
+## Domains
+<!--
+Define 2-4 domains. Each domain is a mode of operating.
+Each domain MUST include:
+- Skills (what it can do)
+- Values (how it must behave while doing it)
+
+Domains are NOT personality traits \u2014 they are capability environments.
+-->
+
+### Domain One
+
+#### Skills
+- Replace with a capability
+- Replace with another capability
+
+#### Values
+- Replace with a constraint
+- Replace with another constraint
+
+### Domain Two
+
+#### Skills
+- Replace with a capability
+- Replace with another capability
+
+#### Values
+- Replace with a constraint
+- Replace with another constraint
+
+## Overlap Effects
+<!--
+Define what emerges when TWO domains interact well.
+
+Format:
+- Domain A + Domain B = Emergent State
+
+These are NOT enforced rules.
+These are INTERPRETIVE STATES used downstream.
+
+They answer:
+"What does it feel like / look like when these are working together?"
+-->
+
+- Domain One + Domain Two = Replace With Emergent State
+
+## Center Identity
+<!--
+What does the system become when all domains are aligned?
+This is the CORE IDENTITY of the system.
+-->
+
+Replace with center identity name
+
+# Contextual Modifiers
+<!--
+This section defines how BEHAVIOR IS INTERPRETED differently depending on context.
+
+These do NOT define truth.
+They define how meaning changes depending on:
+- who is acting
+- where behavior occurs
+- what phase the system is in
+
+This is what makes the model multidimensional.
+-->
+
+## Authority Layers
+<!-- Who is acting? -->
+- founder
+- maintainer
+- contributor
+- agent
+
+## Spatial Contexts
+<!-- Where is behavior happening? -->
+- planning
+- execution
+- deployment
+- governance
+
+## Interpretation Rules
+<!--
+How does context change meaning?
+
+Examples:
+- ambiguity from a founder carries more risk than ambiguity from a contributor
+- weak ownership in deployment is more serious than in planning
+-->
+
+- Replace with an interpretation rule
+
+# Evolution Layer
+<!--
+This section defines:
+- what GOOD behavior looks like
+- what DRIFT looks like
+- what can be OBSERVED
+- how decisions should be made
+- how the model EVOLVES
+
+This is the EXECUTABLE layer.
+-->
+
+## Aligned Behaviors
+<!-- What does success look like in action? -->
+- Replace with an aligned behavior
+
+## Drift Behaviors
+<!-- What does misalignment look like? -->
+- Replace with a drift behavior
+
+## Signals
+<!--
+What can be measured or observed?
+
+Use simple snake_case identifiers:
+- clarity
+- ownership
+- follow_through
+-->
+
+- clarity
+- ownership
+
+## Decision Priorities
+<!--
+What wins when tradeoffs appear?
+
+Format:
+- preferred > secondary
+-->
+
+- quality > speed
+
+## Evolution Conditions
+<!--
+When should the model adapt?
+
+Examples:
+- repeated successful behavior outside assumptions should trigger review
+- persistent drift across scopes should trigger evolution proposal
+-->
+
+- Replace with an evolution condition
+`;
+}
+async function cmdValidate(argv) {
+  const args = parseArgs(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel validate <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const content = await readSourceFile(args.inputPath);
+  const result = parseWorldModel(content);
+  const errors = result.issues.filter((i) => i.severity === "error");
+  const warnings = result.issues.filter((i) => i.severity === "warning");
+  const infos = result.issues.filter((i) => i.severity === "info");
+  if (args.json) {
+    const summary = result.model ? {
+      valid: errors.length === 0,
+      domains: result.model.geometry.domains.length,
+      overlaps: result.model.geometry.overlapEffects.length,
+      signals: result.model.evolution.signals.length,
+      aligned_behaviors: result.model.evolution.alignedBehaviors.length,
+      drift_behaviors: result.model.evolution.driftBehaviors.length,
+      priorities: result.model.evolution.decisionPriorities.length,
+      errors: errors.length,
+      warnings: warnings.length
+    } : { valid: false, errors: errors.length, warnings: warnings.length };
+    process.stdout.write(
+      JSON.stringify({ summary, issues: result.issues }, null, 2) + "\n"
+    );
+    process.exit(errors.length > 0 ? 1 : 0);
+    return;
+  }
+  if (errors.length === 0) {
+    process.stderr.write(
+      `${GREEN}Valid${RESET} ${args.inputPath}
+`
+    );
+  } else {
+    process.stderr.write(
+      `${RED}Invalid${RESET} ${args.inputPath}
+`
+    );
+  }
+  if (result.model) {
+    const m = result.model;
+    process.stderr.write(
+      `${DIM}  Domains: ${m.geometry.domains.length}  Overlaps: ${m.geometry.overlapEffects.length}  Signals: ${m.evolution.signals.length}${RESET}
+`
+    );
+  }
+  if (result.issues.length > 0) {
+    process.stderr.write("\n");
+    for (const issue of result.issues) {
+      process.stderr.write(formatIssue(issue) + "\n");
+    }
+  }
+  process.exit(errors.length > 0 ? 1 : 0);
+}
+async function cmdExplain(argv) {
+  const args = parseArgs(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel explain <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  if (args.json) {
+    const output = buildExplainData(model);
+    process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+    return;
+  }
+  const out = process.stdout;
+  out.write(`
+${BOLD}MODEL:${RESET} ${model.frontmatter.name} (v${model.frontmatter.version})
+
+`);
+  out.write(`${CYAN}${BOLD}CORE MODEL GEOMETRY${RESET}
+`);
+  out.write(`  ${BOLD}Mission:${RESET} ${model.geometry.mission}
+`);
+  const domainNames = model.geometry.domains.map((d) => d.name).join(", ");
+  out.write(
+    `  ${BOLD}Domains (${model.geometry.domains.length}):${RESET} ${domainNames}
+`
+  );
+  for (const domain of model.geometry.domains) {
+    out.write(`
+  ${MAGENTA}${domain.name}${RESET}
+`);
+    if (domain.skills.length > 0) {
+      out.write(`    ${DIM}Skills:${RESET} ${domain.skills.join(", ")}
+`);
+    }
+    if (domain.values.length > 0) {
+      out.write(`    ${DIM}Values:${RESET} ${domain.values.join(", ")}
+`);
+    }
+  }
+  if (model.geometry.overlapEffects.length > 0) {
+    out.write(`
+  ${BOLD}Overlaps (${model.geometry.overlapEffects.length}):${RESET}
+`);
+    for (const o of model.geometry.overlapEffects) {
+      out.write(`    ${o.domainA} + ${o.domainB} = ${GREEN}${o.effect}${RESET}
+`);
+    }
+  }
+  if (model.geometry.centerIdentity) {
+    out.write(
+      `
+  ${BOLD}Center Identity:${RESET} ${GREEN}${model.geometry.centerIdentity}${RESET}
+`
+    );
+  }
+  out.write(`
+${CYAN}${BOLD}CONTEXTUAL MODIFIERS${RESET}
+`);
+  if (model.modifiers.authorityLayers.length > 0) {
+    out.write(
+      `  ${BOLD}Authority:${RESET} ${model.modifiers.authorityLayers.join(", ")}
+`
+    );
+  }
+  if (model.modifiers.spatialContexts.length > 0) {
+    out.write(
+      `  ${BOLD}Spatial:${RESET} ${model.modifiers.spatialContexts.join(", ")}
+`
+    );
+  }
+  if (model.modifiers.interpretationRules.length > 0) {
+    out.write(
+      `  ${BOLD}Interpretation Rules:${RESET} ${model.modifiers.interpretationRules.length} defined
+`
+    );
+    for (const rule of model.modifiers.interpretationRules) {
+      out.write(`    ${DIM}- ${rule}${RESET}
+`);
+    }
+  }
+  out.write(`
+${CYAN}${BOLD}EVOLUTION LAYER${RESET}
+`);
+  out.write(
+    `  Aligned behaviors: ${model.evolution.alignedBehaviors.length} defined
+`
+  );
+  out.write(
+    `  Drift behaviors:   ${model.evolution.driftBehaviors.length} defined
+`
+  );
+  out.write(
+    `  Signals:           ${model.evolution.signals.length} tracked
+`
+  );
+  out.write(
+    `  Decision priorities: ${model.evolution.decisionPriorities.length} defined
+`
+  );
+  out.write(
+    `  Evolution conditions: ${model.evolution.evolutionConditions.length} defined
+`
+  );
+  out.write(`
+${DIM}---${RESET}
+`);
+  const overlapEffects = model.geometry.overlapEffects.map((o) => o.effect).join(", ");
+  out.write(
+    `
+This model operates across ${model.geometry.domains.length} domains governed by embedded values.
+`
+  );
+  if (overlapEffects) {
+    out.write(
+      `It produces ${GREEN}${overlapEffects}${RESET} when domains interact well.
+`
+    );
+  }
+  if (model.evolution.driftBehaviors.length > 0) {
+    const driftSample = model.evolution.driftBehaviors.slice(0, 3).join("; ");
+    out.write(`Drift shows as: ${YELLOW}${driftSample}${RESET}.
+`);
+  }
+  if (model.geometry.centerIdentity) {
+    out.write(
+      `When aligned, the system becomes: ${GREEN}${BOLD}${model.geometry.centerIdentity}${RESET}.
+`
+    );
+  }
+  out.write("\n");
+}
+function buildExplainData(model) {
+  return {
+    name: model.frontmatter.name,
+    version: model.frontmatter.version,
+    model_id: model.frontmatter.model_id,
+    geometry: {
+      mission: model.geometry.mission,
+      domains: model.geometry.domains.map((d) => ({
+        name: d.name,
+        skills: d.skills,
+        values: d.values
+      })),
+      overlaps: model.geometry.overlapEffects.map((o) => ({
+        domainA: o.domainA,
+        domainB: o.domainB,
+        effect: o.effect
+      })),
+      centerIdentity: model.geometry.centerIdentity
+    },
+    modifiers: {
+      authority: model.modifiers.authorityLayers,
+      spatial: model.modifiers.spatialContexts,
+      interpretationRules: model.modifiers.interpretationRules.length
+    },
+    evolution: {
+      alignedBehaviors: model.evolution.alignedBehaviors.length,
+      driftBehaviors: model.evolution.driftBehaviors.length,
+      signals: model.evolution.signals,
+      priorities: model.evolution.decisionPriorities.length,
+      evolutionConditions: model.evolution.evolutionConditions.length
+    }
+  };
+}
+async function cmdBuild(argv) {
+  const args = parseArgs(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel build <source.worldmodel.md> [--output <dir>] [--json]\n"
+    );
+    return;
+  }
+  const { model, issues } = await loadAndParse(args.inputPath);
+  const errors = issues.filter((i) => i.severity === "error");
+  if (errors.length > 0) {
+    process.stderr.write(`${RED}Cannot build \u2014 validation errors:${RESET}
+`);
+    for (const issue of errors) {
+      process.stderr.write(formatIssue(issue) + "\n");
+    }
+    process.exit(1);
+  }
+  const warnings = issues.filter((i) => i.severity === "warning");
+  if (warnings.length > 0) {
+    process.stderr.write(`${YELLOW}Warnings:${RESET}
+`);
+    for (const issue of warnings) {
+      process.stderr.write(formatIssue(issue) + "\n");
+    }
+    process.stderr.write("\n");
+  }
+  const output = compileWorldModel(model);
+  const outputDir = resolve(
+    args.output || `.neuroverse/worldmodels/${model.frontmatter.model_id}/`
+  );
+  if (!existsSync(outputDir)) {
+    await mkdir(outputDir, { recursive: true });
+  }
+  const worldPath = join(outputDir, `${model.frontmatter.model_id}.nv-world.md`);
+  const signalsPath = join(outputDir, "signals.json");
+  const overlapsPath = join(outputDir, "overlaps.json");
+  const contextsPath = join(outputDir, "contexts.json");
+  const lensesPath = join(outputDir, "lenses.json");
+  await Promise.all([
+    writeFile(worldPath, output.worldMarkdown, "utf-8"),
+    writeFile(signalsPath, JSON.stringify(output.signalSchema, null, 2) + "\n", "utf-8"),
+    writeFile(overlapsPath, JSON.stringify(output.overlapMap, null, 2) + "\n", "utf-8"),
+    writeFile(contextsPath, JSON.stringify(output.contextsConfig, null, 2) + "\n", "utf-8"),
+    writeFile(lensesPath, JSON.stringify(output.lensSuggestions, null, 2) + "\n", "utf-8")
+  ]);
+  if (args.json) {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          success: true,
+          outputDir,
+          files: {
+            world: worldPath,
+            signals: signalsPath,
+            overlaps: overlapsPath,
+            contexts: contextsPath,
+            lenses: lensesPath
+          }
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  } else {
+    process.stderr.write(`${GREEN}Built${RESET} ${model.frontmatter.name}
+
+`);
+    process.stderr.write(`  ${BOLD}Output:${RESET} ${outputDir}/
+`);
+    process.stderr.write(`    ${basename(worldPath)}${DIM}  \u2014 executable world${RESET}
+`);
+    process.stderr.write(`    signals.json${DIM}     \u2014 signal schema${RESET}
+`);
+    process.stderr.write(`    overlaps.json${DIM}    \u2014 overlap map${RESET}
+`);
+    process.stderr.write(`    contexts.json${DIM}    \u2014 contextual modifiers${RESET}
+`);
+    process.stderr.write(`    lenses.json${DIM}      \u2014 lens suggestions${RESET}
+
+`);
+    const ruleCount = model.evolution.driftBehaviors.length + model.evolution.alignedBehaviors.length + model.evolution.decisionPriorities.length;
+    const invariantCount = model.geometry.domains.reduce(
+      (sum, d) => sum + d.values.length,
+      0
+    );
+    process.stderr.write(
+      `  ${DIM}${invariantCount} invariants, ${model.evolution.signals.length + 1} state vars, ${ruleCount} rules, 5 gates, ${model.geometry.overlapEffects.length} lenses${RESET}
+`
+    );
+    process.stderr.write(
+      `
+  ${DIM}Next: neuroverse bootstrap --input ${worldPath} --output ${outputDir}${RESET}
+`
+    );
+  }
+}
+async function cmdEmitWorld(argv) {
+  const args = parseArgs(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write("neuroverse worldmodel emit-world <source.worldmodel.md>\n");
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  const markdown = emitWorldMarkdown(model);
+  if (args.output) {
+    const dir = dirname(resolve(args.output));
+    if (!existsSync(dir)) await mkdir(dir, { recursive: true });
+    await writeFile(resolve(args.output), markdown, "utf-8");
+    process.stderr.write(`${GREEN}Written${RESET} ${args.output}
+`);
+  } else {
+    process.stdout.write(markdown);
+  }
+}
+async function cmdEmitSignals(argv) {
+  const args = parseArgs(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel emit-signals <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  const schema = emitSignalSchema(model);
+  process.stdout.write(JSON.stringify(schema, null, 2) + "\n");
+}
+async function cmdEmitLenses(argv) {
+  const args = parseArgs(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel emit-lenses <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  const lenses = emitLensSuggestions(model);
+  process.stdout.write(JSON.stringify(lenses, null, 2) + "\n");
+}
+async function cmdEmitContexts(argv) {
+  const args = parseArgs(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel emit-contexts <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  const contexts = emitContextsConfig(model);
+  process.stdout.write(JSON.stringify(contexts, null, 2) + "\n");
+}
+async function cmdEmitOverlaps(argv) {
+  const args = parseArgs(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel emit-overlaps <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  const overlaps = emitOverlapMap(model);
+  process.stdout.write(JSON.stringify(overlaps, null, 2) + "\n");
+}
+async function main(argv = process.argv.slice(2)) {
+  const subcommand = argv[0] ?? "";
+  const subArgs = argv.slice(1);
+  switch (subcommand) {
+    case "init":
+      return cmdInit(subArgs);
+    case "validate":
+      return cmdValidate(subArgs);
+    case "explain":
+      return cmdExplain(subArgs);
+    case "build":
+      return cmdBuild(subArgs);
+    case "emit-world":
+      return cmdEmitWorld(subArgs);
+    case "emit-signals":
+      return cmdEmitSignals(subArgs);
+    case "emit-lenses":
+      return cmdEmitLenses(subArgs);
+    case "emit-contexts":
+      return cmdEmitContexts(subArgs);
+    case "emit-overlaps":
+      return cmdEmitOverlaps(subArgs);
+    case "--help":
+    case "-h":
+    case "help":
+    case "":
+      process.stdout.write(USAGE + "\n");
+      break;
+    default:
+      process.stderr.write(`Unknown worldmodel command: "${subcommand}"
+
+`);
+      process.stdout.write(USAGE + "\n");
+      process.exit(1);
+  }
+}
+export {
+  main
+};