@neuroverseos/governance 0.3.4 → 0.4.1

package/dist/engine/bootstrap-parser.cjs

@@ -0,0 +1,560 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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/engine/bootstrap-parser.ts
+var bootstrap_parser_exports = {};
+__export(bootstrap_parser_exports, {
+  parseWorldMarkdown: () => parseWorldMarkdown
+});
+module.exports = __toCommonJS(bootstrap_parser_exports);
+function splitSections(markdown) {
+  const lines = markdown.split("\n");
+  let frontmatter = "";
+  let bodyStart = 0;
+  if (lines[0]?.trim() === "---") {
+    const endIdx = lines.indexOf("---", 1);
+    if (endIdx > 0) {
+      frontmatter = lines.slice(1, endIdx).join("\n");
+      bodyStart = endIdx + 1;
+    }
+  }
+  const sections = [];
+  let currentSection = null;
+  const contentLines = [];
+  for (let i = bodyStart; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("# ")) {
+      if (currentSection) {
+        currentSection.content = contentLines.join("\n").trim();
+        sections.push(currentSection);
+        contentLines.length = 0;
+      }
+      currentSection = {
+        name: line.replace(/^#\s+/, "").trim(),
+        content: "",
+        startLine: i + 1
+        // 1-based
+      };
+    } else if (currentSection) {
+      contentLines.push(line);
+    }
+  }
+  if (currentSection) {
+    currentSection.content = contentLines.join("\n").trim();
+    sections.push(currentSection);
+  }
+  return { frontmatter, sections };
+}
+function parseFrontmatter(yaml, issues) {
+  const result = {};
+  for (const line of yaml.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const value = trimmed.slice(colonIdx + 1).trim();
+    result[key] = value;
+  }
+  if (!result.world_id) {
+    issues.push({ line: 1, section: "frontmatter", message: "Missing world_id in frontmatter", severity: "error" });
+  }
+  if (!result.name) {
+    issues.push({ line: 1, section: "frontmatter", message: "Missing name in frontmatter", severity: "error" });
+  }
+  return {
+    world_id: result.world_id ?? "",
+    name: result.name ?? "",
+    version: result.version,
+    runtime_mode: result.runtime_mode,
+    default_profile: result.default_profile,
+    alternative_profile: result.alternative_profile
+  };
+}
+function parseThesis(content, startLine, issues) {
+  const thesis = content.trim();
+  if (!thesis) {
+    issues.push({ line: startLine, section: "Thesis", message: "Thesis section is empty", severity: "error" });
+  }
+  return thesis;
+}
+function parseInvariants(content, startLine, issues) {
+  const invariants = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith("- ")) continue;
+    const lineNum = startLine + i + 1;
+    const match = line.match(
+      /^-\s+`([^`]+)`\s*[—–-]\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/
+    );
+    if (match) {
+      const id = match[1];
+      const label = match[2].trim();
+      const parens = match[3] ?? "structural, immutable";
+      const enforcement = parens.includes("prompt") ? "prompt" : parens.includes("operational") ? "operational" : "structural";
+      const mutable = parens.includes("mutable") && !parens.includes("immutable");
+      invariants.push({ id, label, enforcement, mutable, line: lineNum });
+    } else {
+      const fallback = line.match(/^-\s+\*\*([^*]+)\*\*\s*[—–-]\s*(.+)/);
+      if (fallback) {
+        const id = fallback[1].toLowerCase().replace(/\s+/g, "_");
+        const label = fallback[2].trim();
+        invariants.push({ id, label, enforcement: "structural", mutable: false, line: lineNum });
+      } else {
+        issues.push({ line: lineNum, section: "Invariants", message: `Could not parse invariant: "${line}"`, severity: "warning" });
+      }
+    }
+  }
+  if (invariants.length === 0) {
+    issues.push({ line: startLine, section: "Invariants", message: "No invariants found", severity: "error" });
+  }
+  return invariants;
+}
+function parseStateVariables(content, startLine, issues) {
+  const variables = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const lineNum = sub.startLine;
+    const type = props.type;
+    if (!type) {
+      issues.push({ line: lineNum, section: "State", message: `Variable "${sub.name}" missing type`, severity: "error" });
+      continue;
+    }
+    let defaultVal = props.default ?? "";
+    if (type === "number") {
+      defaultVal = parseFloat(String(defaultVal)) || 0;
+    } else if (type === "boolean") {
+      defaultVal = String(defaultVal).toLowerCase() === "true";
+    }
+    const variable = {
+      id: sub.name,
+      type,
+      default: defaultVal,
+      label: props.label ?? sub.name,
+      description: props.description ?? "",
+      line: lineNum
+    };
+    if (type === "number") {
+      if (props.min !== void 0) variable.min = parseFloat(props.min);
+      if (props.max !== void 0) variable.max = parseFloat(props.max);
+      if (props.step !== void 0) variable.step = parseFloat(props.step);
+    }
+    if (type === "enum" && props.options) {
+      variable.options = props.options.split(",").map((s) => s.trim());
+    }
+    variables.push(variable);
+  }
+  return variables;
+}
+function parseAssumptions(content, startLine, issues) {
+  const profiles = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const name = props.name ?? sub.name;
+    const description = props.description ?? "";
+    const parameters = {};
+    for (const [key, val] of Object.entries(props)) {
+      if (key === "name" || key === "description") continue;
+      if (val === "true") parameters[key] = true;
+      else if (val === "false") parameters[key] = false;
+      else if (!isNaN(Number(val)) && val.trim() !== "") parameters[key] = Number(val);
+      else parameters[key] = val;
+    }
+    profiles.push({
+      id: sub.name,
+      name,
+      description,
+      parameters,
+      line: sub.startLine
+    });
+  }
+  return profiles;
+}
+function parseRules(content, startLine, issues) {
+  const rules = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (let ruleIdx = 0; ruleIdx < subSections.length; ruleIdx++) {
+    const sub = subSections[ruleIdx];
+    const lineNum = sub.startLine;
+    const headingMatch = sub.name.match(/^([^:]+):\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/);
+    const id = headingMatch ? headingMatch[1].trim() : `rule-${String(ruleIdx + 1).padStart(3, "0")}`;
+    const label = headingMatch ? headingMatch[2].trim() : sub.name;
+    const severity = headingMatch?.[3]?.trim() ?? "degradation";
+    const lines = sub.content.split("\n");
+    let description = "";
+    const triggers = [];
+    const effects = [];
+    let collapseCheck;
+    const causalParts = {};
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("When ")) {
+        const triggerStr = line.slice(5);
+        const parts = triggerStr.split(/\s+AND\s+/i);
+        for (const part of parts) {
+          const trigger = parseTriggerExpression(part.trim());
+          if (trigger) triggers.push(trigger);
+          else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse trigger: "${part}"`, severity: "warning" });
+        }
+      } else if (line.startsWith("Then ")) {
+        const effectStr = line.slice(5);
+        const parts = effectStr.split(",");
+        for (const part of parts) {
+          const effect = parseEffectExpression(part.trim());
+          if (effect) effects.push(effect);
+          else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse effect: "${part}"`, severity: "warning" });
+        }
+      } else if (line.startsWith("Collapse:")) {
+        const collapseStr = line.slice(9).trim();
+        const collapse = parseCollapseExpression(collapseStr);
+        if (collapse) collapseCheck = collapse;
+        else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse collapse: "${collapseStr}"`, severity: "warning" });
+      } else if (line.startsWith("> ")) {
+        const causalMatch = line.match(/^>\s*(trigger|rule|shift|effect):\s*(.+)/i);
+        if (causalMatch) {
+          causalParts[causalMatch[1].toLowerCase()] = causalMatch[2].trim();
+        }
+      } else if (line && !line.startsWith("-") && !line.startsWith("#")) {
+        if (!description) description = line;
+        else description += " " + line;
+      }
+    }
+    if (triggers.length === 0) {
+      issues.push({ line: lineNum, section: "Rules", message: `Rule "${id}" has no triggers (missing "When" line)`, severity: "warning" });
+    }
+    if (effects.length === 0) {
+      issues.push({ line: lineNum, section: "Rules", message: `Rule "${id}" has no effects (missing "Then" line)`, severity: "warning" });
+    }
+    const causal_translation = Object.keys(causalParts).length > 0 ? {
+      trigger_text: causalParts.trigger ?? "",
+      rule_text: causalParts.rule ?? "",
+      shift_text: causalParts.shift ?? "",
+      effect_text: causalParts.effect ?? ""
+    } : void 0;
+    rules.push({
+      id,
+      label,
+      severity,
+      description: description || void 0,
+      order: ruleIdx + 1,
+      triggers,
+      effects,
+      collapse_check: collapseCheck,
+      causal_translation,
+      line: lineNum
+    });
+  }
+  return rules;
+}
+function parseTriggerExpression(expr) {
+  const match = expr.match(
+    /^(\w+)\s*(==|!=|>=|<=|>|<|in)\s*(.+?)\s*\[(state|assumption)\]\s*$/
+  );
+  if (!match) return null;
+  const field = match[1];
+  const operator = match[2];
+  let value = match[3].trim();
+  const source = match[4];
+  value = parseValueLiteral(value);
+  return { field, operator, value, source };
+}
+function parseEffectExpression(expr) {
+  const compound = expr.match(/^(\w+)\s*(\*=|\+=|-=)\s*(.+)$/);
+  if (compound) {
+    const target = compound[1];
+    const op = compound[2];
+    const value = parseValueLiteral(compound[3].trim());
+    const operationMap = {
+      "*=": "multiply",
+      "+=": "add",
+      "-=": "subtract"
+    };
+    return { target, operation: operationMap[op], value };
+  }
+  const assignment = expr.match(/^(\w+)\s*=\s*(.+)$/);
+  if (assignment) {
+    const target = assignment[1];
+    const value = parseValueLiteral(assignment[2].trim());
+    const operation = typeof value === "boolean" ? "set_boolean" : "set";
+    return { target, operation, value };
+  }
+  return null;
+}
+function parseCollapseExpression(expr) {
+  const cleaned = expr.replace(/\s*→.*$/, "").trim();
+  const match = cleaned.match(/^(\w+)\s*(==|!=|>=|<=|>|<)\s*([\d.]+)$/);
+  if (!match) return null;
+  return {
+    field: match[1],
+    operator: match[2],
+    value: parseFloat(match[3])
+  };
+}
+function parseGates(content, startLine, issues) {
+  const gates = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith("- ")) continue;
+    const lineNum = startLine + i + 1;
+    const match = line.match(/^-\s+(\w+):\s*(\w+)\s*(==|!=|>=|<=|>|<)\s*([\d.]+)/);
+    if (match) {
+      gates.push({
+        status: match[1],
+        field: match[2],
+        operator: match[3],
+        value: parseFloat(match[4]),
+        line: lineNum
+      });
+    } else {
+      issues.push({ line: lineNum, section: "Gates", message: `Could not parse gate: "${line}"`, severity: "warning" });
+    }
+  }
+  if (gates.length === 0) {
+    issues.push({ line: startLine, section: "Gates", message: "No gates found", severity: "error" });
+  }
+  return gates;
+}
+function parseOutcomes(content, startLine, issues) {
+  const outcomes = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const outcome = {
+      id: sub.name,
+      type: props.type ?? "number",
+      label: props.label ?? sub.name,
+      line: sub.startLine
+    };
+    if (props.range) {
+      const rangeParts = props.range.split("-").map(Number);
+      if (rangeParts.length === 2 && !isNaN(rangeParts[0]) && !isNaN(rangeParts[1])) {
+        outcome.range = [rangeParts[0], rangeParts[1]];
+      }
+    }
+    if (props.display) outcome.display = props.display;
+    if (props.primary) outcome.primary = props.primary === "true";
+    if (props.assignment) outcome.assignment = props.assignment;
+    outcomes.push(outcome);
+  }
+  return outcomes;
+}
+function splitH2Sections(content, baseStartLine) {
+  const lines = content.split("\n");
+  const sections = [];
+  let current = null;
+  const contentLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      if (current) {
+        current.content = contentLines.join("\n").trim();
+        sections.push(current);
+        contentLines.length = 0;
+      }
+      current = {
+        name: line.replace(/^##\s+/, "").trim(),
+        content: "",
+        startLine: baseStartLine + i + 1
+      };
+    } else if (current) {
+      contentLines.push(line);
+    }
+  }
+  if (current) {
+    current.content = contentLines.join("\n").trim();
+    sections.push(current);
+  }
+  return sections;
+}
+function parseKeyValueBullets(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^-\s+(\w[\w\s]*?):\s*(.+)$/);
+    if (match) {
+      result[match[1].trim().toLowerCase().replace(/\s+/g, "_")] = match[2].trim();
+    }
+  }
+  return result;
+}
+function parseValueLiteral(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  const num = Number(raw);
+  if (!isNaN(num) && raw.trim() !== "") return num;
+  return raw;
+}
+function parseLenses(content, startLine, issues) {
+  const lenses = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const lineNum = sub.startLine;
+    const directives = [];
+    const lines = sub.content.split("\n");
+    let directiveIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith(">")) {
+        const blockContent = line.slice(1).trim();
+        const colonIdx = blockContent.indexOf(":");
+        if (colonIdx > 0) {
+          const scope = blockContent.slice(0, colonIdx).trim();
+          let instruction = blockContent.slice(colonIdx + 1).trim();
+          for (let j = i + 1; j < lines.length; j++) {
+            const nextLine = lines[j].trim();
+            if (nextLine.startsWith(">")) {
+              const nextContent = nextLine.slice(1).trim();
+              const nextColon = nextContent.indexOf(":");
+              if (nextColon > 0 && !nextContent.slice(0, nextColon).includes(" ")) {
+                break;
+              }
+              instruction += " " + nextContent;
+              i = j;
+            } else {
+              break;
+            }
+          }
+          directives.push({
+            id: `${sub.name}_directive_${directiveIndex++}`,
+            scope,
+            instruction,
+            line: startLine + i
+          });
+        }
+      }
+    }
+    const tags = (props.tags ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    const defaultForRoles = (props.default_for_roles ?? props.roles ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    lenses.push({
+      id: sub.name,
+      name: props.name ?? sub.name,
+      tagline: props.tagline ?? "",
+      description: props.description ?? "",
+      tags,
+      formality: props.formality ?? "neutral",
+      verbosity: props.verbosity ?? "balanced",
+      emotion: props.emotion ?? "neutral",
+      confidence: props.confidence ?? "balanced",
+      defaultForRoles,
+      directives,
+      priority: props.priority ? parseInt(props.priority, 10) : 50,
+      stackable: props.stackable === "false" ? false : true,
+      line: lineNum
+    });
+  }
+  return lenses;
+}
+function parseWorldMarkdown(markdown) {
+  const issues = [];
+  const { frontmatter: fmRaw, sections } = splitSections(markdown);
+  const frontmatter = parseFrontmatter(fmRaw, issues);
+  const findSection = (name) => sections.find((s) => s.name.toLowerCase() === name.toLowerCase());
+  const thesisSection = findSection("Thesis");
+  const thesis = thesisSection ? parseThesis(thesisSection.content, thesisSection.startLine, issues) : "";
+  if (!thesisSection) {
+    issues.push({ line: 0, section: "Thesis", message: "Missing # Thesis section", severity: "error" });
+  }
+  const invariantsSection = findSection("Invariants");
+  const invariants = invariantsSection ? parseInvariants(invariantsSection.content, invariantsSection.startLine, issues) : [];
+  if (!invariantsSection) {
+    issues.push({ line: 0, section: "Invariants", message: "Missing # Invariants section", severity: "error" });
+  }
+  const stateSection = findSection("State");
+  const stateVariables = stateSection ? parseStateVariables(stateSection.content, stateSection.startLine, issues) : [];
+  if (!stateSection) {
+    issues.push({ line: 0, section: "State", message: "Missing # State section", severity: "warning" });
+  }
+  const assumptionsSection = findSection("Assumptions");
+  const assumptions = assumptionsSection ? parseAssumptions(assumptionsSection.content, assumptionsSection.startLine, issues) : [];
+  if (!assumptionsSection) {
+    issues.push({ line: 0, section: "Assumptions", message: "Missing # Assumptions section", severity: "warning" });
+  }
+  const rulesSection = findSection("Rules");
+  const rules = rulesSection ? parseRules(rulesSection.content, rulesSection.startLine, issues) : [];
+  if (!rulesSection) {
+    issues.push({ line: 0, section: "Rules", message: "Missing # Rules section", severity: "warning" });
+  }
+  const gatesSection = findSection("Gates");
+  const gates = gatesSection ? parseGates(gatesSection.content, gatesSection.startLine, issues) : [];
+  if (!gatesSection) {
+    issues.push({ line: 0, section: "Gates", message: "Missing # Gates section", severity: "warning" });
+  }
+  const outcomesSection = findSection("Outcomes");
+  const outcomes = outcomesSection ? parseOutcomes(outcomesSection.content, outcomesSection.startLine, issues) : [];
+  const lensesSection = findSection("Lenses");
+  const lenses = lensesSection ? parseLenses(lensesSection.content, lensesSection.startLine, issues) : [];
+  let lensPolicy;
+  let lensLockPin;
+  if (lensesSection) {
+    const topContent = lensesSection.content.split(/^##\s/m)[0];
+    const topProps = parseKeyValueBullets(topContent);
+    if (topProps.policy === "locked" || topProps.policy === "role_default" || topProps.policy === "user_choice") {
+      lensPolicy = topProps.policy;
+    }
+    if (topProps.lock_pin) {
+      lensLockPin = topProps.lock_pin;
+    }
+  }
+  const parsedSections = sections.map((s) => s.name);
+  const knownSections = /* @__PURE__ */ new Set(["thesis", "invariants", "state", "assumptions", "rules", "gates", "outcomes", "lenses"]);
+  for (const section of sections) {
+    if (!knownSections.has(section.name.toLowerCase())) {
+      issues.push({
+        line: section.startLine,
+        section: section.name,
+        message: `Unrecognized section "${section.name}" \u2014 will be ignored`,
+        severity: "info"
+      });
+    }
+  }
+  const hasErrors = issues.some((i) => i.severity === "error");
+  if (!frontmatter.world_id || !thesis) {
+    if (hasErrors) {
+      return { world: null, issues };
+    }
+  }
+  return {
+    world: {
+      frontmatter,
+      thesis,
+      invariants,
+      stateVariables,
+      assumptions,
+      rules,
+      gates,
+      outcomes,
+      lenses,
+      lensPolicy,
+      lensLockPin
+    },
+    issues
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseWorldMarkdown
+});

package/dist/engine/bootstrap-parser.d.cts

@@ -0,0 +1,96 @@
+import { P as ParsedWorld, a as ParseIssue } from '../bootstrap-contract-DcV6t-8M.cjs';
+
+/**
+ * Bootstrap Parser — .nv-world.md → ParsedWorld
+ *
+ * Deterministic markdown parser for the NeuroVerse world authoring format.
+ * No LLM calls. No heuristics. Pattern matching on structured markdown.
+ *
+ * ## Markdown Format (.nv-world.md)
+ *
+ * ```markdown
+ * ---
+ * world_id: my-world
+ * name: My World
+ * version: 1.0.0
+ * default_profile: baseline
+ * alternative_profile: alternative
+ * ---
+ *
+ * # Thesis
+ * The structural claim this world tests...
+ *
+ * # Invariants
+ * - `invariant_id` — Label text (structural, immutable)
+ * - `another_id` — Another label (structural, immutable)
+ *
+ * # State
+ * ## variable_name
+ * - type: number
+ * - min: 0
+ * - max: 100
+ * - step: 5
+ * - default: 50
+ * - label: Human Label
+ * - description: What this variable represents
+ *
+ * ## another_variable
+ * - type: enum
+ * - options: option_a, option_b, option_c
+ * - default: option_a
+ * - label: Another Variable
+ * - description: Description here
+ *
+ * # Assumptions
+ * ## baseline
+ * - name: Baseline Scenario
+ * - description: The default conditions
+ * - param_key: param_value
+ *
+ * ## alternative
+ * - name: Alternative Scenario
+ * - description: What changes
+ * - param_key: different_value
+ *
+ * # Rules
+ * ## rule-001: Rule Label (structural)
+ * Description of what this rule does.
+ *
+ * When field == "value" [state] AND other_field > 50 [assumption]
+ * Then target *= 0.30, other_target = false
+ * Collapse: field < 0.03
+ *
+ * > trigger: Trigger text here
+ * > rule: Rule text here
+ * > shift: Shift text here
+ * > effect: Effect text here
+ *
+ * # Gates
+ * - THRIVING: effective_margin >= 40
+ * - STABLE: effective_margin >= 20
+ * - COMPRESSED: effective_margin >= 10
+ * - CRITICAL: effective_margin > 3
+ * - MODEL_COLLAPSES: effective_margin <= 3
+ *
+ * # Outcomes
+ * ## outcome_id
+ * - type: number
+ * - range: 0-100
+ * - display: percentage
+ * - label: Outcome Label
+ * - primary: true
+ * ```
+ */
+
+/**
+ * Parse a .nv-world.md string into a ParsedWorld.
+ *
+ * Returns the parsed world and a list of issues.
+ * Callers should check issues for severity === 'error' before proceeding.
+ */
+declare function parseWorldMarkdown(markdown: string): {
+    world: ParsedWorld | null;
+    issues: ParseIssue[];
+};
+
+export { parseWorldMarkdown };