@hoplogic/spec 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1120 @@
+'use strict';
+
+// src/grammar.ts
+var ZH_GRAMMAR = {
+  sectionNames: {
+    overview: "\u4EFB\u52A1\u6982\u8FF0",
+    input_def: "\u8F93\u5165\u5B9A\u4E49",
+    constraints: "\u786C\u6027\u7EA6\u675F",
+    execution: "\u6267\u884C\u6D41\u7A0B",
+    output_format: "\u8F93\u51FA\u683C\u5F0F",
+    input_example: "\u8F93\u5165\u65E5\u5FD7\u793A\u4F8B"
+  },
+  attrMap: {
+    "\u7C7B\u578B": "step_type",
+    "\u4EFB\u52A1": "task",
+    "\u8F93\u5165": "inputs",
+    "\u8F93\u51FA": "outputs",
+    "\u8F93\u51FA\u683C\u5F0F": "return_format",
+    "\u6838\u9A8C": "verifier",
+    "\u8BF4\u660E": "description",
+    "\u903B\u8F91": "description",
+    "\u6761\u4EF6": "condition",
+    "\u904D\u5386\u96C6\u5408": "collection",
+    "\u5143\u7D20\u53D8\u91CF": "element_var",
+    "\u6700\u5927\u8F6E\u6B21": "max_iterations",
+    "\u52A8\u4F5C": "action",
+    "\u76EE\u6807\u5FAA\u73AF": "target_loop",
+    "\u9000\u51FA\u6807\u8BC6": "exit_id",
+    "\u8C03\u7528\u76EE\u6807": "call_target",
+    "\u5DE5\u5177\u57DF": "tool_domain",
+    "Hoplet\u8DEF\u5F84": "hoplet_path",
+    "MCP\u670D\u52A1": "mcp_service",
+    "RAG\u77E5\u8BC6\u5E93": "rag_collection",
+    "\u5C55\u5F00\u6A21\u5F0F": "expand_mode",
+    "\u6700\u5927\u6B65\u6570": "max_steps",
+    "\u6700\u5927\u8F6E\u6570": "max_rounds",
+    "\u5141\u8BB8\u7C7B\u578B": "allowed_types",
+    "\u56FA\u5316\u8DEF\u5F84": "solidified_spec",
+    "\u6700\u5927\u6DF1\u5EA6": "max_depth"
+  },
+  stepPrefix: "\u6B65\u9AA4",
+  loopLabel: "loop",
+  branchLabel: "branch"
+};
+var EN_GRAMMAR = {
+  sectionNames: {
+    overview: "Overview",
+    input_def: "Input Definition",
+    constraints: "Constraints",
+    execution: "Execution Flow",
+    output_format: "Output Format",
+    input_example: "Input Example"
+  },
+  attrMap: {
+    "Type": "step_type",
+    "Task": "task",
+    "Input": "inputs",
+    "Output": "outputs",
+    "Output Format": "return_format",
+    "Verify": "verifier",
+    "Description": "description",
+    "Logic": "description",
+    "Condition": "condition",
+    "Collection": "collection",
+    "Element Variable": "element_var",
+    "Max Iterations": "max_iterations",
+    "Action": "action",
+    "Target Loop": "target_loop",
+    "Exit ID": "exit_id",
+    "Call Target": "call_target",
+    "Tool Domain": "tool_domain",
+    "Hoplet Path": "hoplet_path",
+    "MCP Service": "mcp_service",
+    "RAG Collection": "rag_collection",
+    "Expand Mode": "expand_mode",
+    "Max Steps": "max_steps",
+    "Max Rounds": "max_rounds",
+    "Allowed Types": "allowed_types",
+    "Solidified Spec": "solidified_spec",
+    "Max Depth": "max_depth"
+  },
+  stepPrefix: "Step",
+  loopLabel: "loop",
+  branchLabel: "branch"
+};
+function detectGrammar(markdown) {
+  if (markdown.includes("## \u6267\u884C\u6D41\u7A0B") || markdown.includes("#### \u6B65\u9AA4")) {
+    return ZH_GRAMMAR;
+  }
+  if (markdown.includes("## Execution Flow") || markdown.includes("#### Step")) {
+    return EN_GRAMMAR;
+  }
+  return ZH_GRAMMAR;
+}
+
+// src/spec-parser.ts
+var ATTR_RE = /^(?<indent>\s*)-\s+(?<key>[^：:]+)[：:]\s*(?<value>.+)$/;
+var SECTION_RE = /^##\s+(.+)$/;
+function makeStepHeaderRe(grammar) {
+  const prefix = escapeRegex(grammar.stepPrefix);
+  return new RegExp(
+    `^(?<indent>\\s*)####\\s+${prefix}\\s*(?<id>[\\d.]+)(?:[\uFF1A:]\\s*(?<name>[^\uFF08(\\s]+))?`
+  );
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractSections(markdown) {
+  const sections = {};
+  const lines = markdown.split("\n");
+  let currentTitle = "";
+  let currentLines = [];
+  for (const line of lines) {
+    const m = SECTION_RE.exec(line);
+    if (m) {
+      if (currentTitle) {
+        sections[currentTitle] = currentLines.join("\n").trim();
+      }
+      currentTitle = m[1].trim();
+      currentLines = [];
+    } else {
+      currentLines.push(line);
+    }
+  }
+  if (currentTitle) {
+    sections[currentTitle] = currentLines.join("\n").trim();
+  }
+  return sections;
+}
+function extractExecutionSection(markdown, grammar) {
+  const executionTitle = grammar.sectionNames["execution"] ?? "\u6267\u884C\u6D41\u7A0B";
+  const lines = markdown.split("\n");
+  const result = [];
+  let inSection = false;
+  for (const line of lines) {
+    const m = SECTION_RE.exec(line);
+    if (m) {
+      const title = m[1].trim();
+      if (title === executionTitle) {
+        inSection = true;
+        continue;
+      } else if (inSection) {
+        break;
+      }
+    }
+    if (inSection) {
+      result.push(line);
+    }
+  }
+  return result;
+}
+function splitIntoStepBlocks(lines, stepHeaderRe) {
+  const blocks = [];
+  let currentBlock = null;
+  for (const line of lines) {
+    const m = stepHeaderRe.exec(line);
+    if (m) {
+      if (currentBlock) blocks.push(currentBlock);
+      const indentStr = m.groups?.["indent"] ?? "";
+      currentBlock = {
+        indent: indentStr.length,
+        header: line,
+        body: []
+      };
+    } else if (currentBlock) {
+      currentBlock.body.push(line);
+    }
+  }
+  if (currentBlock) blocks.push(currentBlock);
+  return blocks;
+}
+function parseStepAttrs(bodyLines, attrMap) {
+  const attrs = {};
+  for (const line of bodyLines) {
+    const m = ATTR_RE.exec(line);
+    if (!m) continue;
+    const key = m.groups?.["key"]?.trim() ?? "";
+    const value = m.groups?.["value"]?.trim() ?? "";
+    const mappedKey = attrMap[key];
+    if (mappedKey) {
+      attrs[mappedKey] = value;
+    }
+  }
+  return attrs;
+}
+var EMPTY_MARKERS = /* @__PURE__ */ new Set(["(\u65E0)", "(none)", "\u65E0", "none", "\uFF08\u65E0\uFF09"]);
+function parseInputs(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed || EMPTY_MARKERS.has(trimmed)) return [];
+  return trimmed.split(/[,，]/).map((s) => s.trim()).filter(Boolean);
+}
+function parseOutputs(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return [];
+  return trimmed.split(/[,，]/).map((s) => s.trim()).filter(Boolean);
+}
+function mapVerifyStrategy(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "\u9006\u5411" || trimmed.toLowerCase() === "reverse") return "reverse";
+  if (trimmed === "\u6B63\u5411\u4EA4\u53C9" || trimmed.toLowerCase() === "forward_cross") return "forward_cross";
+  return "none";
+}
+function createStepInfo(partial) {
+  return {
+    step_id: partial.step_id,
+    step_name: partial.step_name ?? "",
+    step_type: partial.step_type ?? "code",
+    description: partial.description ?? "",
+    task: partial.task ?? "",
+    inputs: partial.inputs ?? {},
+    outputs: partial.outputs ?? {},
+    return_format: partial.return_format ?? "",
+    verify_strategy: partial.verify_strategy ?? "none",
+    children: partial.children ?? [],
+    loop_mode: partial.loop_mode,
+    collection: partial.collection,
+    element_var: partial.element_var,
+    condition: partial.condition,
+    max_iterations: partial.max_iterations,
+    branch_condition: partial.branch_condition,
+    call_target: partial.call_target,
+    call_path: partial.call_path,
+    flow_action: partial.flow_action,
+    exit_id: partial.exit_id,
+    expand_mode: partial.expand_mode,
+    max_steps: partial.max_steps
+  };
+}
+function buildStepFromAttrs(stepId, stepName, attrs) {
+  const stepType = attrs["step_type"] ?? "code";
+  const step = createStepInfo({
+    step_id: stepId,
+    step_name: stepName || `step${stepId.replace(/\./g, "_")}`,
+    step_type: stepType
+  });
+  if (attrs["task"]) step.task = attrs["task"];
+  if (attrs["description"]) step.description = attrs["description"];
+  if (attrs["return_format"]) step.return_format = attrs["return_format"];
+  if (attrs["inputs"]) {
+    const names = parseInputs(attrs["inputs"]);
+    step.inputs = Object.fromEntries(names.map((n) => [n, n]));
+  }
+  if (attrs["outputs"]) {
+    const names = parseOutputs(attrs["outputs"]);
+    step.outputs = Object.fromEntries(names.map((n) => [n, n]));
+  }
+  if (attrs["verifier"]) {
+    step.verify_strategy = mapVerifyStrategy(attrs["verifier"]);
+  }
+  if (stepType === "loop") {
+    if (attrs["collection"]) {
+      step.loop_mode = "for-each";
+      step.collection = attrs["collection"];
+      step.element_var = attrs["element_var"] ?? "";
+    } else if (attrs["condition"]) {
+      step.loop_mode = "while";
+      step.condition = attrs["condition"];
+    }
+    if (attrs["max_iterations"]) {
+      const n = parseInt(attrs["max_iterations"], 10);
+      if (!isNaN(n)) step.max_iterations = n;
+    }
+  }
+  if (stepType === "branch" && attrs["condition"]) {
+    step.branch_condition = attrs["condition"];
+  }
+  if (stepType === "flow") {
+    step.flow_action = attrs["action"] ?? "exit";
+    if (attrs["exit_id"]) step.exit_id = attrs["exit_id"];
+  }
+  if (stepType === "call") {
+    step.call_target = attrs["call_target"] ?? "";
+    step.call_path = attrs["hoplet_path"] ?? attrs["tool_domain"] ?? attrs["mcp_service"] ?? attrs["rag_collection"] ?? "";
+  }
+  if (stepType === "subtask") {
+    step.expand_mode = attrs["expand_mode"] ?? "static";
+    if (attrs["max_steps"]) {
+      const n = parseInt(attrs["max_steps"], 10);
+      if (!isNaN(n)) step.max_steps = n;
+    }
+  }
+  return step;
+}
+function buildTree(blocks, stepHeaderRe, grammar) {
+  const steps = [];
+  let i = 0;
+  while (i < blocks.length) {
+    const block = blocks[i];
+    const { indent, header, body } = block;
+    const m = stepHeaderRe.exec(header);
+    if (!m) {
+      i++;
+      continue;
+    }
+    const stepId = m.groups?.["id"] ?? "";
+    const stepName = m.groups?.["name"] ?? "";
+    const attrs = parseStepAttrs(body, grammar.attrMap);
+    const parenMatch = header.match(/[（(]\s*(\w+)\s*[)）]/);
+    if (parenMatch && !attrs["step_type"]) {
+      attrs["step_type"] = parenMatch[1];
+    }
+    const step = buildStepFromAttrs(stepId, stepName, attrs);
+    const childBlocks = [];
+    let j = i + 1;
+    while (j < blocks.length && blocks[j].indent > indent) {
+      childBlocks.push(blocks[j]);
+      j++;
+    }
+    if (childBlocks.length > 0) {
+      step.children = buildTree(childBlocks, stepHeaderRe, grammar);
+    }
+    steps.push(step);
+    i = j;
+  }
+  return steps;
+}
+function parseSpec(markdown, grammar) {
+  const g = grammar ?? detectGrammar(markdown);
+  const stepHeaderRe = makeStepHeaderRe(g);
+  const execLines = extractExecutionSection(markdown, g);
+  const blocks = splitIntoStepBlocks(execLines, stepHeaderRe);
+  return buildTree(blocks, stepHeaderRe, g);
+}
+function parseFullSpec(markdown, grammar) {
+  const g = grammar ?? detectGrammar(markdown);
+  const sections = extractSections(markdown);
+  const steps = parseSpec(markdown, g);
+  const titleMatch = markdown.match(/^#\s+(.+)$/m);
+  const title = titleMatch ? titleMatch[1].trim() : "";
+  const overviewKey = g.sectionNames["overview"] ?? "\u4EFB\u52A1\u6982\u8FF0";
+  const description = sections[overviewKey] ?? "";
+  const inputKey = g.sectionNames["input_def"] ?? "\u8F93\u5165\u5B9A\u4E49";
+  const outputKey = g.sectionNames["output_format"] ?? "\u8F93\u51FA\u683C\u5F0F";
+  return {
+    sections,
+    steps,
+    title,
+    description,
+    input_format: sections[inputKey] ?? "",
+    output_format: sections[outputKey] ?? ""
+  };
+}
+
+// src/spec-validator.ts
+var VALID_TYPES = /* @__PURE__ */ new Set(["LLM", "call", "loop", "branch", "code", "flow", "subtask"]);
+var VALID_EXPAND_MODES = /* @__PURE__ */ new Set(["static", "dynamic", "think", "seq_think"]);
+var SNAKE_CASE_RE = /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/;
+var INPUT_VAR_RE = /^\s*-\s*`(\w+)`/;
+function checkStructure(steps, sections, grammar) {
+  const errors = [];
+  const requiredLogical = ["overview", "input_def", "constraints", "execution", "output_format", "input_example"];
+  const missing = [];
+  for (const logical of requiredLogical) {
+    const displayName = grammar.sectionNames[logical];
+    if (displayName && !(displayName in sections)) {
+      missing.push(displayName);
+    }
+  }
+  if (missing.length > 0) {
+    errors.push({
+      check: "structure",
+      step_id: "",
+      message: `Missing required sections: ${missing.join(", ")}`,
+      level: "error"
+    });
+  }
+  if (steps.length === 0) {
+    errors.push({
+      check: "structure",
+      step_id: "",
+      message: "Execution flow is empty (no steps)",
+      level: "error"
+    });
+    return errors;
+  }
+  const lastStep = steps[steps.length - 1];
+  if (lastStep.step_type !== "flow" || lastStep.flow_action !== "exit") {
+    errors.push({
+      check: "structure",
+      step_id: lastStep.step_id,
+      message: `Last top-level step must be flow(action=exit), got ${lastStep.step_type}${lastStep.flow_action ? `:${lastStep.flow_action}` : ""}`,
+      level: "error"
+    });
+  }
+  return errors;
+}
+function checkTypes(steps, mode) {
+  const errors = [];
+  checkTypesRecursive(steps, false, mode, errors);
+  return errors;
+}
+function checkTypesRecursive(steps, inLoop, mode, errors) {
+  for (const step of steps) {
+    if (!VALID_TYPES.has(step.step_type)) {
+      errors.push({
+        check: "type",
+        step_id: step.step_id,
+        message: `Invalid step_type "${step.step_type}". Valid: ${[...VALID_TYPES].join(", ")}`,
+        level: "error"
+      });
+      continue;
+    }
+    if (step.step_type === "flow" && (step.flow_action === "continue" || step.flow_action === "break")) {
+      if (!inLoop) {
+        errors.push({
+          check: "type",
+          step_id: step.step_id,
+          message: `flow:${step.flow_action} can only appear inside a loop`,
+          level: "error"
+        });
+      }
+    }
+    if ((step.step_type === "loop" || step.step_type === "branch") && step.children.length === 0) {
+      errors.push({
+        check: "type",
+        step_id: step.step_id,
+        message: `${step.step_type} step must have children`,
+        level: "error"
+      });
+    }
+    if (step.step_type === "subtask") {
+      checkSubtask(step, errors);
+    }
+    if (mode === "jit" && step.step_type === "loop" && step.loop_mode === "while") {
+      if (!step.max_iterations || step.max_iterations <= 0) {
+        errors.push({
+          check: "type",
+          step_id: step.step_id,
+          message: "JIT mode: while loop must have max_iterations > 0",
+          level: "error"
+        });
+      }
+    }
+    const childInLoop = inLoop || step.step_type === "loop";
+    if (step.children.length > 0) {
+      checkTypesRecursive(step.children, childInLoop, mode, errors);
+    }
+  }
+}
+function checkSubtask(step, errors) {
+  const mode = step.expand_mode ?? "static";
+  if (!VALID_EXPAND_MODES.has(mode)) {
+    errors.push({
+      check: "type",
+      step_id: step.step_id,
+      message: `Invalid expand_mode "${mode}". Valid: ${[...VALID_EXPAND_MODES].join(", ")}`,
+      level: "error"
+    });
+    return;
+  }
+  if (mode === "static") {
+    if (step.children.length === 0) {
+      errors.push({
+        check: "type",
+        step_id: step.step_id,
+        message: "subtask(static) must have children",
+        level: "error"
+      });
+    }
+  } else {
+    if (step.children.length > 0) {
+      errors.push({
+        check: "type",
+        step_id: step.step_id,
+        message: `subtask(${mode}) must NOT have children (generated at runtime)`,
+        level: "error"
+      });
+    }
+    if (!step.task) {
+      errors.push({
+        check: "type",
+        step_id: step.step_id,
+        message: `subtask(${mode}) must have task description`,
+        level: "error"
+      });
+    }
+    if (Object.keys(step.outputs).length === 0) {
+      errors.push({
+        check: "type",
+        step_id: step.step_id,
+        message: `subtask(${mode}) must declare outputs`,
+        level: "error"
+      });
+    }
+    if (step.max_steps !== void 0 && step.max_steps <= 0) {
+      errors.push({
+        check: "type",
+        step_id: step.step_id,
+        message: `subtask(${mode}) max_steps must be > 0`,
+        level: "error"
+      });
+    }
+  }
+}
+function checkTree(steps) {
+  const errors = [];
+  checkTreeRecursive(steps, [], errors);
+  return errors;
+}
+function checkTreeRecursive(steps, ancestorLoops, errors) {
+  for (const step of steps) {
+    if (step.step_type === "flow" && (step.flow_action === "continue" || step.flow_action === "break")) {
+      if (step.exit_id && !ancestorLoops.includes(step.exit_id)) {
+        errors.push({
+          check: "tree",
+          step_id: step.step_id,
+          message: `flow:${step.flow_action} target "${step.exit_id}" not found in ancestor loops: [${ancestorLoops.join(", ")}]`,
+          level: "error"
+        });
+      }
+    }
+    if (step.step_type === "branch") {
+      if (!step.branch_condition) {
+        errors.push({
+          check: "tree",
+          step_id: step.step_id,
+          message: "branch step must have a condition",
+          level: "error"
+        });
+      }
+    }
+    if (step.step_type === "loop") {
+      const hasCollection = !!step.collection;
+      const hasCondition = !!step.condition;
+      if (!hasCollection && !hasCondition) {
+        errors.push({
+          check: "tree",
+          step_id: step.step_id,
+          message: "loop must have either collection (for-each) or condition (while)",
+          level: "error"
+        });
+      }
+    }
+    const newLoops = step.step_type === "loop" ? [...ancestorLoops, step.step_name] : ancestorLoops;
+    if (step.children.length > 0) {
+      checkTreeRecursive(step.children, newLoops, errors);
+    }
+  }
+}
+function checkDataflow(steps, sections, grammar) {
+  const errors = [];
+  const inputKey = grammar.sectionNames["input_def"] ?? "\u8F93\u5165\u5B9A\u4E49";
+  const inputSection = sections[inputKey] ?? "";
+  const available = /* @__PURE__ */ new Set();
+  for (const line of inputSection.split("\n")) {
+    const m = INPUT_VAR_RE.exec(line);
+    if (m?.[1]) available.add(m[1]);
+  }
+  checkDataflowRecursive(steps, available, errors);
+  return errors;
+}
+function checkDataflowRecursive(steps, available, errors) {
+  for (const step of steps) {
+    for (const input of Object.keys(step.inputs)) {
+      if (!available.has(input)) {
+        errors.push({
+          check: "dataflow",
+          step_id: step.step_id,
+          message: `Input variable "${input}" not produced by prior steps`,
+          level: "error"
+        });
+      }
+    }
+    if (step.step_type === "loop" && step.loop_mode === "for-each" && step.collection) {
+      if (!available.has(step.collection)) {
+        errors.push({
+          check: "dataflow",
+          step_id: step.step_id,
+          message: `Loop collection "${step.collection}" not produced by prior steps`,
+          level: "error"
+        });
+      }
+      const childAvailable = new Set(available);
+      if (step.element_var) childAvailable.add(step.element_var);
+      checkDataflowRecursive(step.children, childAvailable, errors);
+    } else if (step.children.length > 0) {
+      const childAvailable = new Set(available);
+      checkDataflowRecursive(step.children, childAvailable, errors);
+      for (const child of step.children) {
+        for (const out of Object.keys(child.outputs)) {
+          available.add(out);
+        }
+      }
+    }
+    for (const out of Object.keys(step.outputs)) {
+      available.add(out);
+    }
+  }
+}
+function checkVerifierCoverage(steps) {
+  const errors = [];
+  checkVerifierRecursive(steps, errors);
+  return errors;
+}
+function checkVerifierRecursive(steps, errors) {
+  for (const step of steps) {
+    if (step.step_type === "LLM" && step.verify_strategy === "none") {
+      errors.push({
+        check: "verifier",
+        step_id: step.step_id,
+        message: `LLM step "${step.step_name}" has no explicit verify strategy (default: reverse)`,
+        level: "warning"
+      });
+    }
+    if (step.children.length > 0) {
+      checkVerifierRecursive(step.children, errors);
+    }
+  }
+}
+function checkNaming(steps, mode) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  checkNamingRecursive(steps, mode, seen, errors);
+  return errors;
+}
+function checkNamingRecursive(steps, mode, seen, errors) {
+  for (const step of steps) {
+    const name = step.step_name;
+    if (!name) continue;
+    if (seen.has(name)) {
+      errors.push({
+        check: "naming",
+        step_id: step.step_id,
+        message: `Duplicate step_name "${name}"`,
+        level: "error"
+      });
+    }
+    seen.add(name);
+    if (mode === "aot" && !SNAKE_CASE_RE.test(name)) {
+      errors.push({
+        check: "naming",
+        step_id: step.step_id,
+        message: `step_name "${name}" must be snake_case (AOT mode)`,
+        level: "error"
+      });
+    }
+    if (step.children.length > 0) {
+      checkNamingRecursive(step.children, mode, seen, errors);
+    }
+  }
+}
+function validateSpec(steps, mode = "jit", sections, grammar) {
+  const g = grammar ?? ZH_GRAMMAR;
+  const s = sections ?? {};
+  return [
+    ...checkStructure(steps, s, g),
+    ...checkTypes(steps, mode),
+    ...checkTree(steps),
+    ...checkDataflow(steps, s, g),
+    ...checkVerifierCoverage(steps),
+    ...checkNaming(steps, mode)
+  ];
+}
+
+// src/plan-spec.ts
+var VALID_STEP_TYPES = /* @__PURE__ */ new Set(["reason", "act", "check", "decide", "subtask"]);
+var CONTAINER_TYPES = /* @__PURE__ */ new Set(["decide", "subtask"]);
+var MARKER_TO_STATUS = {
+  "[x]": "done",
+  "[>]": "active",
+  "[!]": "blocked",
+  "[-]": "skipped"
+};
+var STATUS_TO_MARKER = {
+  done: "[x]",
+  active: "[>]",
+  blocked: "[!]",
+  skipped: "[-]",
+  pending: ""
+};
+var STEP_RE = /^(?<indent>\s*)(?<id>[\d.]+)\.\s*(?:(?<marker>\[[ x>!\-]\])\s*)?(?:(?<name>[a-z_]\w*)\s+)?(?:\[(?<type>\w+)\])\s*(?<desc>[^→|]*?)(?:\s*(?:→|->)\s*(?<outputs>[^|]*?))?(?:\s*\|\s*(?<result>.*))?$/;
+var TITLE_RE = /^#\s+Plan:\s*(.+)$/;
+var GOAL_RE = /^Goal:\s*(.+)$/;
+var STATUS_RE = /^Status:\s*(DONE|ABORTED)(?:\s+(.*))?$/;
+var CONSTRAINT_RE = /^-\s+(.+)$/;
+var DETAIL_RE = /^(\s*)>\s?(.*)$/;
+function parsePlan(markdown) {
+  const lines = markdown.split("\n");
+  let title = "";
+  let goal = "";
+  const constraints = [];
+  let status;
+  let abortReason;
+  let phase = "header";
+  const rawSteps = [];
+  let currentStepIdx = -1;
+  for (const line of lines) {
+    const statusMatch = STATUS_RE.exec(line);
+    if (statusMatch) {
+      status = statusMatch[1];
+      abortReason = statusMatch[2]?.trim() || void 0;
+      continue;
+    }
+    const titleMatch = TITLE_RE.exec(line);
+    if (titleMatch) {
+      title = titleMatch[1].trim();
+      continue;
+    }
+    const goalMatch = GOAL_RE.exec(line);
+    if (goalMatch) {
+      goal = goalMatch[1].trim();
+      continue;
+    }
+    if (line.startsWith("Constraints:")) {
+      phase = "constraints";
+      continue;
+    }
+    if (line.startsWith("## Steps")) {
+      phase = "steps";
+      continue;
+    }
+    if (phase === "constraints") {
+      const cm = CONSTRAINT_RE.exec(line);
+      if (cm) {
+        constraints.push(cm[1].trim());
+      } else if (line.trim() === "" || line.startsWith("#")) ;
+      continue;
+    }
+    if (phase === "steps") {
+      const sm = STEP_RE.exec(line);
+      if (sm) {
+        const marker = sm.groups?.["marker"] ?? "";
+        const stepStatus = MARKER_TO_STATUS[marker] ?? "pending";
+        rawSteps.push({
+          indent: (sm.groups?.["indent"] ?? "").length,
+          id: sm.groups?.["id"] ?? "",
+          status: stepStatus,
+          name: sm.groups?.["name"] ?? "",
+          type: sm.groups?.["type"] ?? "act",
+          description: (sm.groups?.["desc"] ?? "").trim(),
+          outputs: (sm.groups?.["outputs"] ?? "").trim(),
+          result: (sm.groups?.["result"] ?? "").trim(),
+          detail: []
+        });
+        currentStepIdx = rawSteps.length - 1;
+        continue;
+      }
+      const dm = DETAIL_RE.exec(line);
+      if (dm && currentStepIdx >= 0) {
+        rawSteps[currentStepIdx].detail.push(dm[2] ?? "");
+        continue;
+      }
+    }
+  }
+  const steps = buildPlanTree(rawSteps);
+  return {
+    title,
+    goal,
+    constraints,
+    steps,
+    status,
+    abort_reason: abortReason
+  };
+}
+function buildPlanTree(rawSteps) {
+  const result = [];
+  let i = 0;
+  while (i < rawSteps.length) {
+    const raw = rawSteps[i];
+    const indent = raw.indent;
+    const step = {
+      step_id: raw.id,
+      step_type: raw.type,
+      description: raw.description,
+      status: raw.status,
+      result: raw.result || void 0,
+      outputs: raw.outputs || void 0,
+      inputs: void 0,
+      detail: raw.detail.length > 0 ? raw.detail.join("\n") : void 0,
+      children: []
+    };
+    if (step.detail) {
+      const inputMatch = step.detail.match(/←\s*(.+)/);
+      if (inputMatch) {
+        step.inputs = inputMatch[1].trim();
+      }
+    }
+    const childRaws = [];
+    let j = i + 1;
+    while (j < rawSteps.length && rawSteps[j].indent > indent) {
+      childRaws.push(rawSteps[j]);
+      j++;
+    }
+    if (childRaws.length > 0) {
+      step.children = buildPlanTree(childRaws);
+    }
+    if (raw.name) {
+      step.step_name = raw.name;
+    }
+    result.push(step);
+    i = j;
+  }
+  return result;
+}
+function serializePlan(plan) {
+  const lines = [];
+  if (plan.status) {
+    lines.push(`Status: ${plan.status}${plan.abort_reason ? ` ${plan.abort_reason}` : ""}`);
+  }
+  lines.push(`# Plan: ${plan.title}`);
+  lines.push(`Goal: ${plan.goal}`);
+  if (plan.constraints.length > 0) {
+    lines.push("Constraints:");
+    for (const c of plan.constraints) {
+      lines.push(`- ${c}`);
+    }
+  }
+  lines.push("## Steps");
+  serializeSteps(plan.steps, 0, lines);
+  return lines.join("\n") + "\n";
+}
+function serializeSteps(steps, depth, lines) {
+  const indent = "  ".repeat(depth);
+  for (const step of steps) {
+    const marker = STATUS_TO_MARKER[step.status];
+    const markerStr = marker ? `${marker} ` : "";
+    const outputStr = step.outputs ? ` \u2192 ${step.outputs}` : "";
+    const resultStr = step.result ? ` | ${step.result}` : "";
+    lines.push(`${indent}${step.step_id}. ${markerStr}[${step.step_type}] ${step.description}${outputStr}${resultStr}`);
+    if (step.detail) {
+      for (const dl of step.detail.split("\n")) {
+        lines.push(`${indent}  > ${dl}`);
+      }
+    }
+    if (step.children.length > 0) {
+      serializeSteps(step.children, depth + 1, lines);
+    }
+  }
+}
+function validatePlan(plan) {
+  const errors = [];
+  if (!plan.title) {
+    errors.push({ step_id: "", message: "Plan must have a title", level: "error" });
+  }
+  if (!plan.goal) {
+    errors.push({ step_id: "", message: "Plan must have a goal", level: "error" });
+  }
+  if (plan.steps.length === 0) {
+    errors.push({ step_id: "", message: "Plan must have at least one step", level: "error" });
+  }
+  validateSteps(plan.steps, errors);
+  return errors;
+}
+function validateSteps(steps, errors) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (ids.has(step.step_id)) {
+      errors.push({
+        step_id: step.step_id,
+        message: `Duplicate step_id "${step.step_id}"`,
+        level: "error"
+      });
+    }
+    ids.add(step.step_id);
+    if (!VALID_STEP_TYPES.has(step.step_type)) {
+      errors.push({
+        step_id: step.step_id,
+        message: `Invalid step_type "${step.step_type}"`,
+        level: "error"
+      });
+    }
+    if (CONTAINER_TYPES.has(step.step_type) && step.children.length === 0) {
+      errors.push({
+        step_id: step.step_id,
+        message: `${step.step_type} step should have children`,
+        level: "warning"
+      });
+    }
+    if (!CONTAINER_TYPES.has(step.step_type) && step.children.length > 0) {
+      errors.push({
+        step_id: step.step_id,
+        message: `${step.step_type} step should not have children`,
+        level: "warning"
+      });
+    }
+    if (step.children.length > 0) {
+      validateSteps(step.children, errors);
+    }
+  }
+}
+function findStep(plan, stepId) {
+  return findStepInList(plan.steps, stepId);
+}
+function findStepInList(steps, stepId) {
+  for (const step of steps) {
+    if (step.step_id === stepId) return step;
+    if (step.children.length > 0) {
+      const found = findStepInList(step.children, stepId);
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+function countSteps(plan) {
+  return countStepList(plan.steps);
+}
+function countStepList(steps) {
+  let count = 0;
+  for (const step of steps) {
+    count++;
+    if (step.children.length > 0) {
+      count += countStepList(step.children);
+    }
+  }
+  return count;
+}
+function countByStatus(plan) {
+  const counts = {
+    pending: 0,
+    active: 0,
+    done: 0,
+    blocked: 0,
+    skipped: 0
+  };
+  countStatusRecursive(plan.steps, counts);
+  return counts;
+}
+function countStatusRecursive(steps, counts) {
+  for (const step of steps) {
+    counts[step.status]++;
+    if (step.children.length > 0) {
+      countStatusRecursive(step.children, counts);
+    }
+  }
+}
+
+// src/format-repair.ts
+var KNOWN_KEYS = /* @__PURE__ */ new Set([
+  "fact",
+  "logic",
+  "explanation",
+  "severity",
+  "type",
+  "location",
+  "evidence",
+  "verdict",
+  "cause",
+  "result",
+  "description",
+  "reason"
+]);
+function registerKnownKeys(...keys) {
+  for (const k of keys) {
+    KNOWN_KEYS.add(k);
+  }
+}
+function parseResult(raw) {
+  if (typeof raw === "object" && raw !== null) {
+    if (Array.isArray(raw)) return raw;
+    return raw;
+  }
+  if (typeof raw !== "string") return {};
+  const s = raw.trim();
+  if (!s) return {};
+  const fenceMatch = s.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+  if (fenceMatch) {
+    try {
+      const parsed = JSON.parse(fenceMatch[1]);
+      if (typeof parsed === "object" && parsed !== null) return parsed;
+    } catch {
+    }
+  }
+  try {
+    const parsed = JSON.parse(s);
+    if (typeof parsed === "object" && parsed !== null) return parsed;
+  } catch {
+  }
+  return {};
+}
+function coerceToDict(item) {
+  if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+    return item;
+  }
+  if (typeof item !== "string") return void 0;
+  const s = item.trim();
+  if (!s.startsWith("{")) return void 0;
+  try {
+    const parsed = JSON.parse(s);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return parsePseudoJson(s);
+}
+function parsePseudoJson(s) {
+  const inner = s.slice(1, -1).trim();
+  if (!inner) return {};
+  const keyPatterns = [...KNOWN_KEYS].map((k) => escapeRegex2(k)).join("|");
+  const splitPattern = new RegExp(`[,\uFF0C]\\s*(?=(${keyPatterns})\\s*:)`);
+  const parts = inner.split(splitPattern).filter((p) => p !== void 0);
+  const result = {};
+  let foundAny = false;
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx < 0) continue;
+    const key = trimmed.slice(0, colonIdx).trim().replace(/^["']|["']$/g, "");
+    if (!key) continue;
+    let value = trimmed.slice(colonIdx + 1).trim();
+    value = value.replace(/[,，]\s*$/, "").replace(/^["']|["']$/g, "");
+    result[key] = value;
+    foundAny = true;
+  }
+  return foundAny ? result : void 0;
+}
+function escapeRegex2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function coerceToList(item) {
+  if (Array.isArray(item)) return item;
+  if (typeof item !== "string") return void 0;
+  const s = item.trim();
+  if (!s.startsWith("[")) return void 0;
+  try {
+    const parsed = JSON.parse(s);
+    if (Array.isArray(parsed)) return parsed;
+  } catch {
+  }
+  const inner = s.slice(1, -1).trim();
+  if (!inner) return [];
+  const blocks = inner.match(/\{(?:[^{}]*|\{[^{}]*\})*\}/g);
+  if (!blocks || blocks.length === 0) return void 0;
+  const result = [];
+  for (const block of blocks) {
+    const dict = coerceToDict(block);
+    result.push(dict ?? block);
+  }
+  return result;
+}
+function repairValue(val) {
+  if (typeof val === "string") {
+    const s = val.trim();
+    if (s.startsWith("{")) {
+      try {
+        const parsed = JSON.parse(s);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          return repairValue(parsed);
+        }
+      } catch {
+      }
+      const dict = coerceToDict(s);
+      if (dict) return dict;
+      return val;
+    }
+    if (s.startsWith("[")) {
+      try {
+        const parsed = JSON.parse(s);
+        if (Array.isArray(parsed)) return parsed.map((item) => repairValue(item));
+      } catch {
+      }
+      const list = coerceToList(s);
+      if (list) return list.map((item) => repairValue(item));
+      return val;
+    }
+    return val;
+  }
+  if (Array.isArray(val)) {
+    return val.map((item) => repairValue(item));
+  }
+  if (typeof val === "object" && val !== null) {
+    const result = {};
+    for (const [k, v] of Object.entries(val)) {
+      result[k] = repairValue(v);
+    }
+    return result;
+  }
+  return val;
+}
+function detectSerializationResidue(data, path = "") {
+  const issues = [];
+  if (typeof data === "object" && data !== null) {
+    if (Array.isArray(data)) {
+      for (let i = 0; i < data.length; i++) {
+        const itemPath = `${path}[${i}]`;
+        const item = data[i];
+        if (typeof item === "string") {
+          const s = item.trim();
+          if (s.startsWith("{")) issues.push(itemPath);
+          else if (s.startsWith("[")) issues.push(itemPath);
+        } else if (typeof item === "object" && item !== null) {
+          issues.push(...detectSerializationResidue(item, itemPath));
+        }
+      }
+    } else {
+      for (const [k, v] of Object.entries(data)) {
+        const fieldPath = path ? `${path}.${k}` : k;
+        if (typeof v === "string") {
+          const s = v.trim();
+          if (s.startsWith("{")) issues.push(fieldPath);
+          else if (s.startsWith("[")) issues.push(fieldPath);
+        } else if (typeof v === "object" && v !== null) {
+          issues.push(...detectSerializationResidue(v, fieldPath));
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+exports.EN_GRAMMAR = EN_GRAMMAR;
+exports.ZH_GRAMMAR = ZH_GRAMMAR;
+exports.coerceToDict = coerceToDict;
+exports.countByStatus = countByStatus;
+exports.countSteps = countSteps;
+exports.detectGrammar = detectGrammar;
+exports.detectSerializationResidue = detectSerializationResidue;
+exports.findStep = findStep;
+exports.parseFullSpec = parseFullSpec;
+exports.parsePlan = parsePlan;
+exports.parseResult = parseResult;
+exports.parseSpec = parseSpec;
+exports.registerKnownKeys = registerKnownKeys;
+exports.repairValue = repairValue;
+exports.serializePlan = serializePlan;
+exports.validatePlan = validatePlan;
+exports.validateSpec = validateSpec;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map