opsx-gherkin 1.0.0

package/dist/converter-CFtzcfoM.mjs

@@ -0,0 +1,977 @@
+import { a as validateOpenSpec, i as parseAndValidateMdg, l as isFsError, n as openSpecDiagnostics, r as parseAndValidateFeature, s as ConversionError, t as gherkinDiagnostics } from "./official-99qBUZpr.mjs";
+import { link, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+//#region src/model.ts
+/** Rename Rules are structural wrappers; their FROM and TO names carry the identity. */
+function normalizedModel(model) {
+	return {
+		...model,
+		rules: model.rules.map((rule) => ({
+			...rule,
+			name: rule.operation === "RENAMED" ? "Rename requirement" : rule.name
+		}))
+	};
+}
+function assertPreserved(source, destination) {
+	if (!isDeepStrictEqual(normalizedModel(source), normalizedModel(destination))) throw new ConversionError("Conversion would change the normalized document model", ["The destination was not emitted. Check supported structure, ordering, and literal values."]);
+}
+//#endregion
+//#region src/constants.ts
+const OPERATION_TAGS = /* @__PURE__ */ new Map([
+	["@openspec-added", "ADDED"],
+	["@openspec-modified", "MODIFIED"],
+	["@openspec-removed", "REMOVED"],
+	["@openspec-renamed", "RENAMED"]
+]);
+const RESERVED_PREFIXES = ["@openspec-", "@mdg-"];
+const SYNTHETIC_TAG = "@mdg-feature-scenarios";
+const DELTA_TAG = "@openspec-delta";
+//#endregion
+//#region src/syntax.ts
+function pushDescriptionAndSteps(output, node, mdg = false) {
+	if (node.description) output.push(node.description, "");
+	for (const step of node.steps) {
+		const keyword = mdg ? titleCase(step.keyword) : `**${step.keyword}**`;
+		output.push(`${mdg ? "*" : "-"} ${keyword} ${step.text}`);
+		if (step.table) pushTable(output, step.table, false, !mdg);
+		if (step.docString) {
+			output.push("", `  \`\`\`${step.docString.mediaType || ""}`);
+			for (const line of step.docString.content.split("\n")) output.push(`  ${line}`);
+			output.push("  ```");
+		}
+	}
+	output.push("");
+}
+function pushTable(output, rows, blankAfter = true, separator = true) {
+	if (!rows?.length) return;
+	output.push(`  | ${rows[0].map(escapeCell).join(" | ")} |`);
+	if (separator) output.push(`  | ${rows[0].map(() => "---").join(" | ")} |`);
+	for (const row of rows.slice(1)) output.push(`  | ${row.map(escapeCell).join(" | ")} |`);
+	if (blankAfter) output.push("");
+}
+function parseTable(lines) {
+	const rows = lines.filter((line) => /^\s{2,}\|/.test(line)).map(parseTableRow);
+	if (rows.length >= 2 && rows[1].every((cell) => /^:?-+:?$/.test(cell))) rows.splice(1, 1);
+	if (!rows.length) throw new ConversionError("Empty table");
+	const width = rows[0].length;
+	if (rows.some((row) => row.length !== width)) throw new ConversionError("Inconsistent table column count");
+	return rows;
+}
+function parseTableRow(line) {
+	const content = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+	const cells = [];
+	let cell = "";
+	let escaped = false;
+	for (const char of content) if (escaped) {
+		cell += char === "n" ? "\n" : char;
+		escaped = false;
+	} else if (char === "\\") escaped = true;
+	else if (char === "|") {
+		cells.push(cell.trim());
+		cell = "";
+	} else cell += char;
+	cells.push(cell.trim());
+	return cells;
+}
+function normalizeLines(text) {
+	return text.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n").split("\n");
+}
+function fenceMask(lines) {
+	const mask = [];
+	let fence = null;
+	for (let index = 0; index < lines.length; index += 1) {
+		const match = lines[index].match(/^\s*(`{3,}|~{3,})/);
+		mask[index] = Boolean(fence);
+		if (match && !fence) {
+			fence = match[1][0];
+			mask[index] = true;
+		} else if (match && fence === match[1][0]) {
+			mask[index] = true;
+			fence = null;
+		}
+	}
+	return mask;
+}
+function findHeading(lines, mask, level) {
+	for (let index = 0; index < lines.length; index += 1) {
+		const match = !mask[index] && lines[index].match(new RegExp(`^#{${level}}\\s+(.+?)\\s*$`));
+		if (match) return {
+			index,
+			title: match[1].trim()
+		};
+	}
+	return null;
+}
+function headingsInRange(lines, mask, level, start, end) {
+	const result = [];
+	for (let index = start; index < end; index += 1) {
+		const match = !mask[index] && lines[index].match(new RegExp(`^#{${level}}\\s+(.+?)\\s*$`));
+		if (match) result.push({
+			index,
+			title: match[1].trim()
+		});
+	}
+	return result;
+}
+function findSection(lines, mask, title) {
+	const section = findSectionOptional(lines, mask, title);
+	if (!section) throw new ConversionError(`Missing OpenSpec section: ## ${title}`);
+	return section;
+}
+function findSectionOptional(lines, mask, title) {
+	for (let index = 0; index < lines.length; index += 1) if (!mask[index] && new RegExp(`^##\\s+${escapeRegex(title)}\\s*$`, "i").test(lines[index])) {
+		let end = lines.length;
+		for (let next = index + 1; next < lines.length; next += 1) if (!mask[next] && /^##\s+/.test(lines[next])) {
+			end = next;
+			break;
+		}
+		return {
+			start: index,
+			end
+		};
+	}
+	return null;
+}
+function sectionContent(lines, mask, title) {
+	const section = findSectionOptional(lines, mask, title);
+	return section ? trimBlank(lines.slice(section.start + 1, section.end)).join("\n") : null;
+}
+function precedingTags(lines, headingIndex) {
+	let index = headingIndex - 1;
+	while (index >= 0 && !lines[index].trim()) index -= 1;
+	const blocks = [];
+	while (index >= 0 && isTagLine(lines[index])) {
+		blocks.unshift(...extractTags(lines[index]));
+		index -= 1;
+		while (index >= 0 && !lines[index].trim()) index -= 1;
+	}
+	return blocks;
+}
+function tagBlockStart(lines, headingIndex) {
+	let index = headingIndex - 1;
+	while (index >= 0 && !lines[index].trim()) index -= 1;
+	while (index >= 0 && isTagLine(lines[index])) {
+		index -= 1;
+		while (index >= 0 && !lines[index].trim()) index -= 1;
+	}
+	return index + 1;
+}
+function tagStartLine(lines, node) {
+	return tagBlockStart(lines, nodeLine(node) - 1) + 1;
+}
+function isTagLine(line) {
+	return [...line.matchAll(/`(@[^`]+)`/g)].length > 0 && line.replace(/`(@[^`]+)`/g, "").trim() === "";
+}
+function extractTags(line) {
+	return [...line.matchAll(/`(@[^`]+)`/g)].map((match) => match[1]);
+}
+function proseBetween(lines, startLine, endLine) {
+	const slice = lines.slice(Math.max(0, startLine - 1), Math.max(0, endLine - 1));
+	while (slice.length && (!slice[slice.length - 1].trim() || isTagLine(slice[slice.length - 1]))) slice.pop();
+	return trimBlank(slice).join("\n");
+}
+function nextSiblingLine(line, siblings, fallback) {
+	return siblings.map(nodeLine).filter((candidate) => candidate > line).sort((a, b) => a - b)[0] || fallback;
+}
+function nodeLine(child) {
+	if ("location" in child) return child.location.line;
+	const value = child.background ?? child.scenario ?? child.rule ?? child.examples;
+	if (!value) throw new ConversionError("Missing Gherkin node location");
+	return value.location.line;
+}
+function trimBlank(lines) {
+	const copy = [...lines];
+	while (copy.length && !copy[0].trim()) copy.shift();
+	while (copy.length && !copy[copy.length - 1].trim()) copy.pop();
+	return copy;
+}
+function pushTags(output, tags) {
+	if (tags?.length) output.push(tags.map((tag) => `\`${tag}\``).join(" "));
+}
+function resolveOpenSpecName(text, options) {
+	const lines = normalizeLines(text);
+	const h1 = findHeading(lines, fenceMask(lines), 1);
+	if (h1) return h1.title.replace(/^Feature:\s*/i, "").trim();
+	if (options.name) return options.name;
+	if (options.sourcePath) {
+		const parent = basename(dirname(options.sourcePath));
+		if (parent && parent !== ".") return parent;
+	}
+	throw new ConversionError("OpenSpec text without an H1 title requires --name");
+}
+function slugify(value) {
+	return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "spec";
+}
+function titleCase(keyword) {
+	return keyword[0] + keyword.slice(1).toLowerCase();
+}
+function escapeCell(value) {
+	return String(value).replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\n/g, "\\n");
+}
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/parsers/mdg.ts
+function parseMdgModel(text, document) {
+	const feature = document.feature;
+	if (!feature) throw new ConversionError("Gherkin document has no Feature");
+	const lines = normalizeLines(text);
+	const featureChildren = [...feature.children].sort((a, b) => nodeLine(a) - nodeLine(b));
+	const firstFeatureChild = featureChildren[0] ? tagStartLine(lines, featureChildren[0]) : lines.length + 1;
+	const description = proseBetween(lines, feature.location.line + 1, firstFeatureChild);
+	const featureTags = feature.tags.map((tag) => tag.name);
+	const isDelta = featureTags.includes(DELTA_TAG);
+	const model = {
+		kind: isDelta ? "delta" : "main",
+		name: feature.name.trim(),
+		description,
+		tags: featureTags.filter((tag) => tag !== DELTA_TAG),
+		background: null,
+		featureScenarios: [],
+		rules: []
+	};
+	for (let index = 0; index < featureChildren.length; index += 1) {
+		const child = featureChildren[index];
+		const boundary = featureChildren[index + 1] ? tagStartLine(lines, featureChildren[index + 1]) : lines.length + 1;
+		if (child.background) model.background = mapMdgBackground(child.background, lines, featureChildren);
+		if (child.scenario) model.featureScenarios.push(mapMdgScenario(child.scenario, lines));
+		if (child.rule) model.rules.push(mapMdgRule(child.rule, lines, isDelta, boundary));
+	}
+	return model;
+}
+function mapMdgRule(rule, lines, isDelta, boundary) {
+	const children = [...rule.children].sort((a, b) => nodeLine(a) - nodeLine(b));
+	const firstChild = children[0] ? tagStartLine(lines, children[0]) : lines.length + 1;
+	const tags = rule.tags.map((tag) => tag.name);
+	const operationTags = tags.filter((tag) => OPERATION_TAGS.has(tag));
+	let operation;
+	if (isDelta) {
+		if (operationTags.length !== 1) throw new ConversionError(`Delta Rule "${rule.name}" must have exactly one @openspec operation tag`);
+		operation = OPERATION_TAGS.get(operationTags[0]);
+	} else if (operationTags.length) throw new ConversionError(`Main-spec Rule "${rule.name}" cannot use OpenSpec delta operation tags`);
+	const description = proseBetween(lines, rule.location.line + 1, children.length ? firstChild : boundary);
+	const mapped = {
+		name: rule.name.trim(),
+		description,
+		tags: tags.filter((tag) => !OPERATION_TAGS.has(tag)),
+		operation,
+		rename: null,
+		background: null,
+		scenarios: []
+	};
+	for (const child of children) {
+		if (child.background) mapped.background = mapMdgBackground(child.background, lines, children);
+		if (child.scenario) mapped.scenarios.push(mapMdgScenario(child.scenario, lines));
+	}
+	if (operation === "RENAMED") {
+		const from = description.match(/^FROM:\s*`### Requirement:\s*(.+?)`\s*$/im)?.[1];
+		const to = description.match(/^TO:\s*`### Requirement:\s*(.+?)`\s*$/im)?.[1];
+		if (!from || !to) throw new ConversionError(`RENAMED Rule "${rule.name}" requires FROM and TO lines`);
+		if (description.replace(/^FROM:.*$/gim, "").replace(/^TO:.*$/gim, "").trim() || mapped.background || mapped.scenarios.length) throw new ConversionError("RENAMED Rule contains unsupported content");
+		mapped.rename = {
+			from: from.trim(),
+			to: to.trim()
+		};
+		mapped.description = "";
+	}
+	return mapped;
+}
+function mapMdgBackground(background, lines, siblings) {
+	const firstStep = background.steps[0]?.location.line || nextSiblingLine(background.location.line, siblings, lines.length + 1);
+	return {
+		name: background.name.trim(),
+		description: proseBetween(lines, background.location.line + 1, firstStep),
+		steps: background.steps.map(mapMdgStep)
+	};
+}
+function mapMdgScenario(scenario, lines) {
+	const firstContent = Math.min(scenario.steps[0]?.location.line || Infinity, scenario.examples[0] ? tagStartLine(lines, { examples: scenario.examples[0] }) : Infinity);
+	return {
+		kind: /outline/i.test(scenario.keyword) ? "outline" : "scenario",
+		name: scenario.name.trim(),
+		description: proseBetween(lines, scenario.location.line + 1, Number.isFinite(firstContent) ? firstContent : lines.length + 1),
+		tags: scenario.tags.map((tag) => tag.name),
+		steps: scenario.steps.map(mapMdgStep),
+		examples: scenario.examples.map((examples) => mapMdgExamples(examples, lines))
+	};
+}
+function mapMdgExamples(examples, lines) {
+	const tableLine = examples.tableHeader?.location.line || lines.length + 1;
+	const rows = [];
+	if (examples.tableHeader) rows.push(examples.tableHeader.cells.map((cell) => cell.value));
+	rows.push(...examples.tableBody.map((row) => row.cells.map((cell) => cell.value)));
+	return {
+		name: examples.name.trim(),
+		description: proseBetween(lines, examples.location.line + 1, tableLine),
+		tags: examples.tags.map((tag) => tag.name),
+		rows
+	};
+}
+function mapMdgStep(step) {
+	return {
+		keyword: step.keyword.trim().toUpperCase(),
+		text: step.text,
+		table: step.dataTable ? step.dataTable.rows.map((row) => row.cells.map((cell) => cell.value)) : null,
+		docString: step.docString ? {
+			mediaType: step.docString.mediaType || "",
+			content: step.docString.content
+		} : null
+	};
+}
+//#endregion
+//#region src/parsers/feature.ts
+function description(value) {
+	const prefix = " ".repeat((value.location.column ?? 1) + 1);
+	return trimBlank(value.description.split("\n").map((line) => line.startsWith(prefix) ? line.slice(prefix.length) : line)).join("\n");
+}
+function background(value) {
+	return {
+		name: value.name.trim(),
+		description: description(value),
+		steps: value.steps.map(mapMdgStep)
+	};
+}
+function scenario(value) {
+	return {
+		...background(value),
+		kind: /outline/i.test(value.keyword) ? "outline" : "scenario",
+		tags: value.tags.map((tag) => tag.name),
+		examples: value.examples.map((group) => ({
+			name: group.name.trim(),
+			description: description(group),
+			tags: group.tags.map((tag) => tag.name),
+			rows: [...group.tableHeader ? [group.tableHeader.cells.map((cell) => cell.value)] : [], ...group.tableBody.map((row) => row.cells.map((cell) => cell.value))]
+		}))
+	};
+}
+function parseFeatureModel(document) {
+	const feature = document.feature;
+	if (!feature) throw new ConversionError("Gherkin document has no Feature");
+	const tags = feature.tags.map((tag) => tag.name);
+	const model = {
+		name: feature.name.trim(),
+		description: description(feature),
+		kind: tags.includes("@openspec-delta") ? "delta" : "main",
+		tags: tags.filter((tag) => tag !== DELTA_TAG),
+		background: null,
+		featureScenarios: [],
+		rules: []
+	};
+	for (const child of feature.children) {
+		if (child.background) model.background = background(child.background);
+		if (child.scenario) model.featureScenarios.push(scenario(child.scenario));
+		if (child.rule) {
+			const value = child.rule;
+			const tags = value.tags.map((tag) => tag.name);
+			const operationTag = tags.find((tag) => OPERATION_TAGS.has(tag));
+			const rule = {
+				name: value.name.trim(),
+				description: description(value),
+				tags: tags.filter((tag) => !OPERATION_TAGS.has(tag)),
+				operation: operationTag ? OPERATION_TAGS.get(operationTag) : void 0,
+				rename: null,
+				background: null,
+				scenarios: []
+			};
+			for (const item of value.children) {
+				if (item.background) rule.background = background(item.background);
+				if (item.scenario) rule.scenarios.push(scenario(item.scenario));
+			}
+			if (rule.operation === "RENAMED") {
+				const from = rule.description.match(/^FROM:\s*### Requirement:\s*(.+)$/m)?.[1];
+				const to = rule.description.match(/^TO:\s*### Requirement:\s*(.+)$/m)?.[1];
+				if (!from || !to) throw new ConversionError("RENAMED Rule requires FROM and TO");
+				rule.rename = {
+					from: from.trim(),
+					to: to.trim()
+				};
+				rule.description = "";
+			}
+			model.rules.push(rule);
+		}
+	}
+	return model;
+}
+//#endregion
+//#region src/parsers/openspec.ts
+function detectOpenSpecKind(text) {
+	const lines = text.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n").split("\n");
+	const mask = fenceMask(lines);
+	const main = lines.some((line, index) => !mask[index] && /^##\s+Requirements\s*$/i.test(line));
+	const delta = lines.some((line, index) => !mask[index] && /^##\s+(ADDED|MODIFIED|REMOVED|RENAMED) Requirements\s*$/i.test(line));
+	if (main && delta) throw new ConversionError("OpenSpec input mixes main and delta requirement sections");
+	if (!main && !delta) throw new ConversionError("OpenSpec input has no Requirements or delta sections");
+	return delta ? "delta" : "main";
+}
+function parseOpenSpecModel(text, { kind, name }) {
+	const lines = normalizeLines(text);
+	const mask = fenceMask(lines);
+	const h1 = findHeading(lines, mask, 1);
+	const title = h1 ? h1.title : name;
+	const tags = h1 ? precedingTags(lines, h1.index) : [];
+	const model = {
+		kind,
+		name: title,
+		description: sectionContent(lines, mask, "Purpose")?.trim() || "",
+		tags: tags.filter((tag) => tag !== DELTA_TAG),
+		background: null,
+		featureScenarios: [],
+		rules: []
+	};
+	if (kind === "main") parseMainOpenSpec(lines, mask, model);
+	else parseDeltaOpenSpec(lines, mask, model);
+	return model;
+}
+function parseMainOpenSpec(lines, mask, model) {
+	const section = findSection(lines, mask, "Requirements");
+	const requirements = headingsInRange(lines, mask, 3, section.start + 1, section.end).filter((heading) => /^Requirement:\s*/i.test(heading.title));
+	const firstRequirementStart = requirements[0] ? tagBlockStart(lines, requirements[0].index) : section.end;
+	const preamble = trimBlank(lines.slice(section.start + 1, firstRequirementStart));
+	if (preamble.length) model.background = parseOpenSpecBackground(preamble, "feature");
+	for (let index = 0; index < requirements.length; index += 1) {
+		const heading = requirements[index];
+		const rule = parseOpenSpecRequirement(lines, mask, heading, index + 1 < requirements.length ? tagBlockStart(lines, requirements[index + 1].index) : section.end);
+		if (rule.tags.includes("@mdg-feature-scenarios")) {
+			rule.tags = rule.tags.filter((tag) => tag !== SYNTHETIC_TAG);
+			if (rule.background && !model.background) model.background = rule.background;
+			model.featureScenarios.push(...rule.scenarios);
+		} else model.rules.push(rule);
+	}
+}
+function parseDeltaOpenSpec(lines, mask, model) {
+	model.tags = model.tags.filter((tag) => tag !== DELTA_TAG);
+	const operations = headingsInRange(lines, mask, 2, 0, lines.length).flatMap((heading) => {
+		const match = heading.title.match(/^(ADDED|MODIFIED|REMOVED|RENAMED) Requirements$/i);
+		return match ? [match[1].toUpperCase()] : [];
+	});
+	if (new Set(operations).size !== operations.length) throw new ConversionError("Repeated delta operation section is unsupported");
+	for (const operation of operations) {
+		const section = findSectionOptional(lines, mask, `${operation} Requirements`);
+		if (!section) continue;
+		if (operation === "RENAMED") {
+			for (let index = section.start + 1; index < section.end; index += 1) {
+				const from = lines[index].match(/^\s*-?\s*FROM:\s*`?### Requirement:\s*(.+?)`?\s*$/i);
+				if (!from) continue;
+				let toIndex = index + 1;
+				while (toIndex < section.end && !lines[toIndex].trim()) toIndex += 1;
+				const to = lines[toIndex]?.match(/^\s*-?\s*TO:\s*`?### Requirement:\s*(.+?)`?\s*$/i);
+				if (!to) throw new ConversionError(`RENAMED entry for "${from[1].trim()}" has no TO line`);
+				model.rules.push({
+					name: "Rename requirement",
+					description: "",
+					tags: precedingTags(lines, index),
+					operation,
+					rename: {
+						from: from[1].trim(),
+						to: to[1].trim()
+					},
+					background: null,
+					scenarios: []
+				});
+				index = toIndex;
+			}
+			continue;
+		}
+		const headings = headingsInRange(lines, mask, 3, section.start + 1, section.end).filter((heading) => /^Requirement:\s*/i.test(heading.title));
+		for (let index = 0; index < headings.length; index += 1) {
+			const heading = headings[index];
+			const rule = parseOpenSpecRequirement(lines, mask, heading, index + 1 < headings.length ? tagBlockStart(lines, headings[index + 1].index) : section.end);
+			rule.operation = operation;
+			model.rules.push(rule);
+		}
+	}
+}
+function parseOpenSpecRequirement(lines, mask, heading, end) {
+	const childHeadings = headingsInRange(lines, mask, 4, heading.index + 1, end).filter((item) => /^(Scenario(?: Outline)?|Background):/i.test(item.title));
+	const firstChild = childHeadings[0] ? tagBlockStart(lines, childHeadings[0].index) : end;
+	const headerBody = trimBlank(lines.slice(heading.index + 1, firstChild));
+	let background = null;
+	let descriptionLines = headerBody;
+	const marker = headerBody.findIndex((line) => /^\*\*Background:/i.test(line));
+	if (marker >= 0) {
+		descriptionLines = trimBlank(headerBody.slice(0, marker));
+		background = parseOpenSpecBackground(headerBody.slice(marker), "rule");
+	}
+	const rule = {
+		name: heading.title.replace(/^Requirement:\s*/i, "").trim(),
+		description: descriptionLines.join("\n").trim(),
+		tags: precedingTags(lines, heading.index),
+		operation: void 0,
+		rename: null,
+		background,
+		scenarios: []
+	};
+	for (let index = 0; index < childHeadings.length; index += 1) {
+		const child = childHeadings[index];
+		const childEnd = index + 1 < childHeadings.length ? tagBlockStart(lines, childHeadings[index + 1].index) : end;
+		if (/^Background:/i.test(child.title)) rule.background = parseOpenSpecScenario(lines, mask, child, childEnd, true);
+		else rule.scenarios.push(parseOpenSpecScenario(lines, mask, child, childEnd, false));
+	}
+	return rule;
+}
+function parseOpenSpecBackground(lines, scope) {
+	const marker = lines[0]?.match(/^\*\*Background:(.*?)\*\*\s*$/i);
+	if (!marker) throw new ConversionError(`Unsupported ${scope} Requirements preamble; expected **Background:**`);
+	const parsed = parseOpenSpecBody(lines.slice(1));
+	return {
+		name: marker[1].trim(),
+		description: parsed.description,
+		steps: parsed.steps
+	};
+}
+function parseOpenSpecScenario(lines, mask, heading, end, background) {
+	const examplesHeadings = headingsInRange(lines, mask, 5, heading.index + 1, end).filter((item) => /^Examples:/i.test(item.title));
+	const bodyEnd = examplesHeadings[0] ? tagBlockStart(lines, examplesHeadings[0].index) : end;
+	const body = parseOpenSpecBody(lines.slice(heading.index + 1, bodyEnd));
+	if (background) return {
+		name: heading.title.replace(/^Background:\s*/i, "").trim(),
+		description: body.description,
+		steps: body.steps
+	};
+	const scenario = {
+		kind: /^Scenario Outline:/i.test(heading.title) ? "outline" : "scenario",
+		name: heading.title.replace(/^Scenario(?: Outline)?:\s*/i, "").trim(),
+		description: body.description,
+		tags: precedingTags(lines, heading.index),
+		steps: body.steps,
+		examples: []
+	};
+	for (let index = 0; index < examplesHeadings.length; index += 1) {
+		const example = examplesHeadings[index];
+		const exampleEnd = index + 1 < examplesHeadings.length ? tagBlockStart(lines, examplesHeadings[index + 1].index) : end;
+		const exampleLines = trimBlank(lines.slice(example.index + 1, exampleEnd));
+		const tableIndex = exampleLines.findIndex((line) => /^\s{2,}\|/.test(line));
+		if (tableIndex < 0) throw new ConversionError(`Examples "${example.title}" has no table`);
+		scenario.examples.push({
+			name: example.title.replace(/^Examples:\s*/i, "").trim(),
+			description: trimBlank(exampleLines.slice(0, tableIndex)).join("\n"),
+			tags: precedingTags(lines, example.index),
+			rows: parseTable(exampleLines.slice(tableIndex))
+		});
+	}
+	return scenario;
+}
+function parseOpenSpecBody(rawLines) {
+	const lines = trimBlank(rawLines);
+	const firstStep = lines.findIndex((line) => /^\s*[-*+]\s+\*\*(GIVEN|WHEN|THEN|AND|BUT)\*\*/i.test(line));
+	const description = firstStep < 0 ? lines.join("\n").trim() : trimBlank(lines.slice(0, firstStep)).join("\n");
+	const steps = [];
+	if (firstStep < 0) return {
+		description,
+		steps
+	};
+	let index = firstStep;
+	while (index < lines.length) {
+		if (!lines[index].trim()) {
+			index += 1;
+			continue;
+		}
+		const match = lines[index].match(/^\s*[-*+]\s+\*\*(GIVEN|WHEN|THEN|AND|BUT)\*\*\s+(.+)$/i);
+		if (!match) throw new ConversionError(`Unsupported OpenSpec scenario line: ${lines[index]}`);
+		const step = {
+			keyword: match[1].toUpperCase(),
+			text: match[2],
+			table: null,
+			docString: null
+		};
+		index += 1;
+		while (index < lines.length && !lines[index].trim()) index += 1;
+		if (index < lines.length && /^\s*```/.test(lines[index])) {
+			const opener = /^(\s*)```(.*)$/.exec(lines[index]);
+			if (!opener) throw new ConversionError("Invalid DocString opener");
+			const indent = opener[1].length;
+			const content = [];
+			index += 1;
+			while (index < lines.length && !/^\s*```\s*$/.test(lines[index])) {
+				content.push(lines[index].slice(Math.min(indent, lines[index].length)));
+				index += 1;
+			}
+			if (index >= lines.length) throw new ConversionError("Unclosed OpenSpec DocString");
+			index += 1;
+			step.docString = {
+				mediaType: opener[2].trim(),
+				content: content.join("\n")
+			};
+		} else if (index < lines.length && /^\s{2,}\|/.test(lines[index])) {
+			const tableLines = [];
+			while (index < lines.length && /^\s{2,}\|/.test(lines[index])) tableLines.push(lines[index++]);
+			step.table = parseTable(tableLines);
+		}
+		steps.push(step);
+	}
+	return {
+		description,
+		steps
+	};
+}
+//#endregion
+//#region src/renderers/feature.ts
+function serializeFeature(model) {
+	const output = [];
+	pushFeatureTags(output, model.kind === "delta" ? [...model.tags, DELTA_TAG] : model.tags, 0);
+	output.push(`Feature: ${model.name}`);
+	pushFeatureDescription(output, model.description, 2);
+	if (model.background) serializeFeatureBackground(output, model.background, 2);
+	for (const scenario of model.featureScenarios) serializeFeatureScenario(output, scenario, 2);
+	for (const rule of model.rules) serializeFeatureRule(output, rule);
+	return `${trimBlank(output).join("\n")}\n`;
+}
+function serializeFeatureRule(output, rule) {
+	const operationTag = rule.operation ? [...OPERATION_TAGS].find(([, operation]) => operation === rule.operation)?.[0] : null;
+	output.push("");
+	pushFeatureTags(output, [...rule.tags, ...operationTag ? [operationTag] : []], 2);
+	output.push(`  Rule: ${rule.operation === "RENAMED" ? "Rename requirement" : rule.name}`);
+	if (rule.operation === "RENAMED") {
+		pushFeatureDescription(output, `FROM: ### Requirement: ${rule.rename?.from}\nTO: ### Requirement: ${rule.rename?.to}`, 4);
+		return;
+	}
+	pushFeatureDescription(output, rule.description, 4);
+	if (rule.background) serializeFeatureBackground(output, rule.background, 4);
+	for (const scenario of rule.scenarios) serializeFeatureScenario(output, scenario, 4);
+}
+function serializeFeatureBackground(output, background, indent) {
+	output.push("", `${" ".repeat(indent)}Background:${background.name ? ` ${background.name}` : ""}`);
+	pushFeatureDescription(output, background.description, indent + 2);
+	pushFeatureSteps(output, background.steps, indent + 2);
+}
+function serializeFeatureScenario(output, scenario, indent) {
+	output.push("");
+	pushFeatureTags(output, scenario.tags, indent);
+	output.push(`${" ".repeat(indent)}${scenario.kind === "outline" ? "Scenario Outline" : "Scenario"}: ${scenario.name}`);
+	pushFeatureDescription(output, scenario.description, indent + 2);
+	pushFeatureSteps(output, scenario.steps, indent + 2);
+	for (const examples of scenario.examples) {
+		output.push("");
+		pushFeatureTags(output, examples.tags, indent + 2);
+		output.push(`${" ".repeat(indent + 2)}Examples: ${examples.name}`);
+		pushFeatureDescription(output, examples.description, indent + 4);
+		pushFeatureTable(output, examples.rows, indent + 4);
+	}
+}
+function pushFeatureSteps(output, steps, indent) {
+	const prefix = " ".repeat(indent);
+	for (const step of steps) {
+		output.push(`${prefix}${titleCase(step.keyword)} ${step.text}`);
+		if (step.table) pushFeatureTable(output, step.table, indent + 2);
+		if (step.docString) {
+			const fence = step.docString.content.split("\n").some((line) => line.trim() === "\"\"\"") ? "```" : "\"\"\"";
+			output.push(`${" ".repeat(indent + 2)}${fence}${step.docString.mediaType || ""}`);
+			for (const line of step.docString.content.split("\n")) output.push(`${" ".repeat(indent + 2)}${line}`);
+			output.push(`${" ".repeat(indent + 2)}${fence}`);
+		}
+	}
+}
+function pushFeatureTable(output, rows, indent) {
+	if (!rows?.length) return;
+	const prefix = " ".repeat(indent);
+	for (const row of rows) output.push(`${prefix}| ${row.map(escapeCell).join(" | ")} |`);
+}
+function pushFeatureDescription(output, description, indent) {
+	if (!description) return;
+	const prefix = " ".repeat(indent);
+	output.push("");
+	for (const line of description.split("\n")) output.push(line ? `${prefix}${line}` : "");
+}
+function pushFeatureTags(output, tags, indent) {
+	if (tags?.length) output.push(`${" ".repeat(indent)}${tags.join(" ")}`);
+}
+//#endregion
+//#region src/renderers/mdg.ts
+function serializeMdg(model) {
+	const output = [];
+	pushTags(output, model.kind === "delta" ? [...model.tags, DELTA_TAG] : model.tags);
+	output.push(`# Feature: ${model.name}`, "");
+	if (model.description) output.push(model.description, "");
+	if (model.background) serializeMdgBackground(output, model.background, 2);
+	for (const scenario of model.featureScenarios) serializeMdgScenario(output, scenario, 3);
+	for (const rule of model.rules) serializeMdgRule(output, rule);
+	return `${trimBlank(output).join("\n")}\n`;
+}
+function serializeMdgRule(output, rule) {
+	const operationTag = rule.operation ? [...OPERATION_TAGS].find(([, operation]) => operation === rule.operation)?.[0] : null;
+	pushTags(output, [...rule.tags, ...operationTag ? [operationTag] : []]);
+	output.push(`## Rule: ${rule.operation === "RENAMED" ? "Rename requirement" : rule.name}`, "");
+	if (rule.operation === "RENAMED") {
+		output.push(`FROM: \`### Requirement: ${rule.rename?.from}\``, `TO: \`### Requirement: ${rule.rename?.to}\``, "");
+		return;
+	}
+	if (rule.description) output.push(rule.description, "");
+	if (rule.background) serializeMdgBackground(output, rule.background, 3);
+	for (const scenario of rule.scenarios) serializeMdgScenario(output, scenario, 3);
+}
+function serializeMdgBackground(output, background, level) {
+	output.push(`${"#".repeat(level)} Background:${background.name ? ` ${background.name}` : ""}`, "");
+	pushDescriptionAndSteps(output, background, true);
+}
+function serializeMdgScenario(output, scenario, level) {
+	pushTags(output, scenario.tags);
+	output.push(`${"#".repeat(level)} ${scenario.kind === "outline" ? "Scenario Outline" : "Scenario"}: ${scenario.name}`, "");
+	pushDescriptionAndSteps(output, scenario, true);
+	for (const examples of scenario.examples) {
+		pushTags(output, examples.tags);
+		output.push(`${"#".repeat(level + 1)} Examples: ${examples.name}`, "");
+		if (examples.description) output.push(examples.description, "");
+		pushTable(output, examples.rows, true, false);
+	}
+}
+//#endregion
+//#region src/renderers/openspec.ts
+function serializeOpenSpec(model) {
+	const output = [];
+	pushTags(output, model.tags);
+	if (model.kind === "delta") pushTags(output, [DELTA_TAG]);
+	output.push(`# ${model.name}`, "");
+	if (model.description) output.push("## Purpose", "", model.description, "");
+	if (model.kind === "delta") serializeOpenSpecDelta(output, model);
+	else serializeOpenSpecMain(output, model);
+	return `${trimBlank(output).join("\n")}\n`;
+}
+function serializeOpenSpecMain(output, model) {
+	output.push("## Requirements", "");
+	if (model.background) {
+		output.push(`**Background:${model.background.name ? ` ${model.background.name}` : ""}**`, "");
+		pushDescriptionAndSteps(output, model.background);
+	}
+	if (model.featureScenarios.length) {
+		pushTags(output, [SYNTHETIC_TAG]);
+		output.push("### Requirement: Feature-level scenarios", "", "The system SHALL exhibit the feature-level behavior defined by the following scenarios.", "");
+		for (const scenario of model.featureScenarios) serializeOpenSpecScenario(output, scenario);
+	}
+	for (const rule of model.rules) serializeOpenSpecRule(output, rule);
+}
+function serializeOpenSpecDelta(output, model) {
+	for (const operation of new Set(model.rules.map((rule) => rule.operation))) {
+		const rules = model.rules.filter((rule) => rule.operation === operation);
+		if (!rules.length) continue;
+		output.push(`## ${operation} Requirements`, "");
+		if (operation === "RENAMED") for (const rule of rules) {
+			pushTags(output, rule.tags);
+			output.push(`- FROM: \`### Requirement: ${rule.rename?.from}\``, `- TO: \`### Requirement: ${rule.rename?.to}\``, "");
+		}
+		else if (operation === "REMOVED") for (const rule of rules) {
+			pushTags(output, rule.tags);
+			output.push(`### Requirement: ${rule.name}`, "");
+		}
+		else for (const rule of rules) serializeOpenSpecRule(output, rule);
+	}
+}
+function serializeOpenSpecRule(output, rule) {
+	pushTags(output, rule.tags);
+	output.push(`### Requirement: ${rule.name}`, "", rule.description, "");
+	if (rule.background) {
+		output.push(`#### Background: ${rule.background.name}`.trimEnd(), "");
+		pushDescriptionAndSteps(output, rule.background);
+	}
+	for (const scenario of rule.scenarios) serializeOpenSpecScenario(output, scenario);
+}
+function serializeOpenSpecScenario(output, scenario) {
+	pushTags(output, scenario.tags);
+	output.push(`#### ${scenario.kind === "outline" ? "Scenario Outline" : "Scenario"}: ${scenario.name}`, "");
+	pushDescriptionAndSteps(output, scenario);
+	for (const examples of scenario.examples) {
+		pushTags(output, examples.tags);
+		output.push(`##### Examples: ${examples.name}`, "");
+		if (examples.description) output.push(examples.description, "");
+		pushTable(output, examples.rows);
+	}
+}
+//#endregion
+//#region src/validation/profile.ts
+function validateProfile(model, sourceKind) {
+	if (!model.name) throw new ConversionError("Feature/spec name is required");
+	if (!model.description && model.kind === "main") throw new ConversionError("Feature Purpose/description is required");
+	const allTags = [
+		...model.tags,
+		...model.rules.flatMap((rule) => [...rule.tags, ...rule.scenarios.flatMap((scenario) => [...scenario.tags, ...scenario.examples.flatMap((examples) => examples.tags)])]),
+		...model.featureScenarios.flatMap((scenario) => scenario.tags)
+	];
+	for (const tag of allTags) if (RESERVED_PREFIXES.some((prefix) => tag.startsWith(prefix))) throw new ConversionError(`Reserved tag is not allowed as user metadata: ${tag}`);
+	if (model.kind === "main") {
+		if (!model.rules.length && !model.featureScenarios.length) throw new ConversionError("Feature has no behavior to convert");
+		for (const rule of model.rules) {
+			if (!/\b(?:SHALL|MUST)\b/.test(rule.description)) throw new ConversionError(`Rule/Requirement "${rule.name}" must contain SHALL or MUST`);
+			if (!rule.scenarios.length && !rule.background) throw new ConversionError(`Rule/Requirement "${rule.name}" has no scenarios or Background`);
+		}
+	} else {
+		if (model.background || model.featureScenarios.length) throw new ConversionError("Delta Features cannot contain feature-level Background or scenarios");
+		for (const rule of model.rules) {
+			if ((rule.operation === "ADDED" || rule.operation === "MODIFIED") && !/\b(?:SHALL|MUST)\b/.test(rule.description)) throw new ConversionError(`${rule.operation} Rule "${rule.name}" must contain SHALL or MUST`);
+			if ((rule.operation === "ADDED" || rule.operation === "MODIFIED") && !rule.scenarios.length && !rule.background) throw new ConversionError(`${rule.operation} Rule "${rule.name}" requires behavior`);
+			if (rule.operation === "REMOVED" && (rule.description || rule.scenarios.length || rule.background)) throw new ConversionError(`REMOVED Rule "${rule.name}" must contain only its name`);
+			if (rule.operation === "RENAMED" && !rule.rename) throw new ConversionError("RENAMED Rule requires FROM and TO");
+		}
+	}
+	for (const scenario of [...model.featureScenarios, ...model.rules.flatMap((rule) => rule.scenarios)]) {
+		if (!scenario.steps.length) throw new ConversionError(`Scenario "${scenario.name}" has no steps`);
+		if (scenario.kind === "outline" && !scenario.examples.length) throw new ConversionError(`Scenario Outline "${scenario.name}" has no Examples`);
+		if (scenario.kind === "scenario" && scenario.examples.length) throw new ConversionError(`Scenario "${scenario.name}" cannot contain Examples`);
+	}
+	if (sourceKind === "openspec" && model.kind === "delta" && !model.rules.length) throw new ConversionError("Delta has no operations");
+}
+//#endregion
+//#region src/convert.ts
+async function mdgToOpsx(text, options = {}) {
+	const source = parseAndValidateMdg(text, options.sourcePath);
+	if (!source.valid || !source.document) throw new ConversionError("Invalid Markdown with Gherkin input", gherkinDiagnostics(source));
+	const model = parseMdgModel(text, source.document);
+	validateProfile(model, "mdg");
+	const output = serializeOpenSpec(model);
+	const name = options.name || slugify(model.name);
+	const report = await validateOpenSpec(output, {
+		kind: model.kind,
+		name,
+		projectRoot: options.projectRoot
+	});
+	if (!report.valid) throw new ConversionError("Generated OpenSpec failed official validation", openSpecDiagnostics(report));
+	assertPreserved(model, parseOpenSpecModel(output, {
+		kind: model.kind,
+		name
+	}));
+	return output;
+}
+async function openSpecModel(text, options) {
+	const kind = detectOpenSpecKind(text);
+	const name = resolveOpenSpecName(text, options);
+	const report = await validateOpenSpec(text, {
+		kind,
+		name,
+		projectRoot: options.projectRoot
+	});
+	if (!report.valid) throw new ConversionError("Invalid OpenSpec input", openSpecDiagnostics(report));
+	const model = parseOpenSpecModel(text, {
+		kind,
+		name
+	});
+	validateProfile(model, "openspec");
+	return model;
+}
+async function opsxToMdg(text, options = {}) {
+	const model = await openSpecModel(text, options);
+	const output = serializeMdg(model);
+	const target = parseAndValidateMdg(output);
+	if (!target.valid || !target.document) throw new ConversionError("Generated Markdown with Gherkin failed official validation", gherkinDiagnostics(target));
+	assertPreserved(model, parseMdgModel(output, target.document));
+	return output;
+}
+async function opsxToFeature(text, options = {}) {
+	const model = await openSpecModel(text, options);
+	const output = serializeFeature(model);
+	const target = parseAndValidateFeature(output);
+	if (!target.valid || !target.document) throw new ConversionError("Generated Gherkin feature failed official validation", gherkinDiagnostics(target));
+	assertPreserved(model, parseFeatureModel(target.document));
+	return output;
+}
+//#endregion
+//#region src/cli/converter.ts
+async function runConverterCli(direction, argv = process.argv.slice(2)) {
+	try {
+		const options = parseArgs(argv, direction);
+		if (options.help) {
+			process.stdout.write(usage(direction));
+			return 0;
+		}
+		const input = await readInput(options);
+		const convert = {
+			"mdg-to-opsx": mdgToOpsx,
+			"opsx-to-mdg": opsxToMdg,
+			"opsx-to-feature": opsxToFeature
+		}[direction];
+		const output = await convert(input.text, {
+			sourcePath: input.path,
+			name: options.name,
+			projectRoot: options.projectRoot ? resolve(options.projectRoot) : void 0
+		});
+		if (options.output) await writeAtomic(resolve(options.output), output, options.force);
+		else process.stdout.write(output);
+		return 0;
+	} catch (error) {
+		if (error instanceof ConversionError) {
+			process.stderr.write(`${error.message}\n`);
+			for (const diagnostic of error.diagnostics) process.stderr.write(`- ${diagnostic}\n`);
+			return 1;
+		}
+		process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+}
+function parseArgs(argv, direction) {
+	const options = {
+		force: false,
+		help: false
+	};
+	for (let index = 0; index < argv.length; index += 1) {
+		const argument = argv[index];
+		if (argument === "--help" || argument === "-h") options.help = true;
+		else if (argument === "--force") options.force = true;
+		else if (argument === "--text") options.text = requiredValue(argv, ++index, argument);
+		else if (argument === "--output" || argument === "-o") options.output = requiredValue(argv, ++index, argument);
+		else if (argument === "--name") options.name = requiredValue(argv, ++index, argument);
+		else if (argument === "--project-root") options.projectRoot = requiredValue(argv, ++index, argument);
+		else if (argument.startsWith("-")) throw new Error(`Unknown option: ${argument}\n${usage(direction)}`);
+		else if (!options.input) options.input = argument;
+		else throw new Error(`Only one input path is allowed\n${usage(direction)}`);
+	}
+	if (options.input && options.text !== void 0) throw new Error(`Use either an input path or --text, not both\n${usage(direction)}`);
+	if (options.force && !options.output) throw new Error("--force requires --output");
+	return options;
+}
+async function readInput(options) {
+	if (options.text !== void 0) return {
+		text: options.text,
+		path: void 0
+	};
+	if (options.input) {
+		const path = resolve(options.input);
+		return {
+			text: await readFile(path, "utf8"),
+			path
+		};
+	}
+	if (process.stdin.isTTY) throw new Error("No input: pass a path, --text, or pipe text on stdin");
+	return {
+		text: await readStream(process.stdin),
+		path: void 0
+	};
+}
+async function readStream(stream) {
+	stream.setEncoding("utf8");
+	let result = "";
+	for await (const chunk of stream) result += chunk;
+	return result;
+}
+async function writeAtomic(path, content, force) {
+	await mkdir(dirname(path), { recursive: true });
+	const temporary = resolve(dirname(path), `.${basename(path)}.${process.pid}.${Date.now()}.tmp`);
+	await writeFile(temporary, content, {
+		encoding: "utf8",
+		flag: "wx"
+	});
+	try {
+		if (force) await rename(temporary, path);
+		else {
+			try {
+				await link(temporary, path);
+			} catch (error) {
+				if (isFsError(error, "EEXIST")) throw new Error(`Output already exists: ${path} (use --force to replace it)`);
+				throw error;
+			}
+			await unlink(temporary);
+		}
+	} catch (error) {
+		await unlink(temporary).catch(() => {});
+		throw error;
+	}
+}
+function requiredValue(argv, index, option) {
+	if (index >= argv.length) throw new Error(`Missing value for ${option}`);
+	return argv[index];
+}
+function usage(direction) {
+	return `Usage: ${direction} [input] [--text content] [-o output] [--force] [--name name] [--project-root path]\n`;
+}
+//#endregion
+export { runConverterCli as t };
+
+//# sourceMappingURL=converter-CFtzcfoM.mjs.map