@openspecui/core 3.5.2 → 3.6.1

package/dist/openspec-projection-DWqBxedv.mjs

@@ -0,0 +1,223 @@
+import { c as getMarkdownHeadingFacts, l as trimMarkdownSlice, n as createMarkdownReadingDocument, o as getMarkdownFactSpan, s as getMarkdownHeadingEnd } from "./markdown-reading-CrchEfoW.mjs";
+import { r as builtinOpenSpecReadingPlugin } from "./openspec-annotations-BMy9nWUe.mjs";
+
+//#region src/openspec-projection.ts
+const OPEN_SPEC_SPEC_PROJECTION_ID = "openspec.projection.spec.v2";
+const OPEN_SPEC_READING_SECTIONS_PROJECTION_ID = "openspec.projection.reading-sections.v2";
+function createOpenSpecReadingPlugin(options) {
+	return {
+		...builtinOpenSpecReadingPlugin,
+		id: "openspec.builtin-reading-with-projections.v2",
+		projectionRules: [createOpenSpecReadingSectionsProjectionRule(), createOpenSpecSpecProjectionRule(options)]
+	};
+}
+function parseOpenSpecMarkdownToSpec(specId, content) {
+	return projectOpenSpecMarkdown(content, { specId }).projections[OPEN_SPEC_SPEC_PROJECTION_ID];
+}
+function projectOpenSpecMarkdown(sourceMarkdown, options, plugins = [createOpenSpecReadingPlugin(options)]) {
+	return toProjectedOpenSpecDocument(createMarkdownReadingDocument(sourceMarkdown, plugins));
+}
+function projectAnnotatedOpenSpecToSpec(specId, document) {
+	return projectOpenSpecContextToSpec(createDetachedProjectionContext(document), { specId });
+}
+function getOpenSpecReadingSections(document) {
+	const context = createDetachedProjectionContext(document);
+	return {
+		sections: collectSpecSections(context),
+		requirements: collectRequirementBlocks(context)
+	};
+}
+function getOpenSpecProjectionAnnotation(annotations, factId, kind) {
+	return annotations.find((annotation) => annotation.targetFactId === factId && annotation.kind === kind);
+}
+function createOpenSpecReadingSectionsProjectionRule() {
+	return {
+		id: OPEN_SPEC_READING_SECTIONS_PROJECTION_ID,
+		project(context) {
+			return {
+				sections: collectSpecSections(toOpenSpecProjectionContext(context)),
+				requirements: collectRequirementBlocks(toOpenSpecProjectionContext(context))
+			};
+		}
+	};
+}
+function createOpenSpecSpecProjectionRule(options) {
+	return {
+		id: OPEN_SPEC_SPEC_PROJECTION_ID,
+		project(context) {
+			return projectOpenSpecContextToSpec(toOpenSpecProjectionContext(context), options);
+		}
+	};
+}
+function projectOpenSpecContextToSpec(context, options) {
+	const name = context.annotations.find((annotation) => annotation.kind === "document-title")?.metadata?.title || options.specId;
+	const overviewSection = collectSpecSections(context).find((section) => section.kind === "overview");
+	const overview = overviewSection ? trimMarkdownSlice(context.sourceMarkdown, getContentStartAfterHeading(context, overviewSection.factId, overviewSection.start), overviewSection.end) : "";
+	const requirements = collectRequirementBlocks(context).map((requirement) => projectRequirement(context, requirement));
+	return {
+		id: options.specId,
+		name: name || options.specId,
+		overview: overview.trim(),
+		requirements,
+		metadata: {
+			version: "1.0.0",
+			format: "openspec"
+		}
+	};
+}
+function createRequirementText(title, bodyMarkdown, scenarioText) {
+	return [
+		title,
+		bodyMarkdown,
+		scenarioText
+	].filter((part) => part.trim()).join("\n\n");
+}
+function collectSpecSections(context) {
+	const headings = getMarkdownHeadingFacts(context);
+	return headings.reduce((sections, fact, index) => {
+		if (fact.depth !== 2) return sections;
+		const span = getFactSpan(fact);
+		if (!span) return sections;
+		sections.push({
+			id: fact.id,
+			title: fact.text,
+			kind: getSectionKind(context.annotations, fact.id),
+			factId: fact.id,
+			start: span.start,
+			end: getMarkdownHeadingEnd(headings, index, context.sourceMarkdown.length)
+		});
+		return sections;
+	}, []);
+}
+function collectRequirementBlocks(context) {
+	const headings = getMarkdownHeadingFacts(context);
+	let reqIndex = 0;
+	return headings.reduce((requirements, fact, index) => {
+		const annotation = getOpenSpecProjectionAnnotation(context.annotations, fact.id, "requirement");
+		if (!annotation) return requirements;
+		const span = getFactSpan(fact);
+		if (!span) return requirements;
+		reqIndex++;
+		const end = getMarkdownHeadingEnd(headings, index, context.sourceMarkdown.length);
+		const title = annotation.metadata?.title?.trim() || fact.text;
+		requirements.push({
+			id: `req-${reqIndex}`,
+			title,
+			factId: fact.id,
+			start: span.start,
+			end,
+			scenarios: collectScenarioBlocks(context, headings, fact, end)
+		});
+		return requirements;
+	}, []);
+}
+function collectScenarioBlocks(context, headings, requirementFact, requirementEnd) {
+	const requirementSpan = getFactSpan(requirementFact);
+	if (!requirementSpan) return [];
+	return headings.reduce((scenarios, fact, index) => {
+		const annotation = getOpenSpecProjectionAnnotation(context.annotations, fact.id, "scenario");
+		if (!annotation) return scenarios;
+		const span = getFactSpan(fact);
+		if (!span || span.start <= requirementSpan.start || span.start >= requirementEnd) return scenarios;
+		scenarios.push({
+			title: annotation.metadata?.title?.trim() || fact.text,
+			factId: fact.id,
+			start: span.start,
+			end: Math.min(getScenarioEnd(context, headings, index, requirementEnd), requirementEnd)
+		});
+		return scenarios;
+	}, []);
+}
+function getScenarioEnd(context, headings, scenarioIndex, requirementEnd) {
+	for (let i = scenarioIndex + 1; i < headings.length; i++) {
+		const next = headings[i];
+		const nextSpan = getFactSpan(next);
+		if (!nextSpan || nextSpan.start >= requirementEnd) return requirementEnd;
+		if ((next.depth ?? 6) <= 3 || getOpenSpecProjectionAnnotation(context.annotations, next.id, "scenario")) return nextSpan.start;
+	}
+	return requirementEnd;
+}
+function getContentStartAfterHeading(context, factId, fallback) {
+	const fact = context.factById.get(factId);
+	return fact ? getFactSpan(fact)?.end ?? fallback : fallback;
+}
+function projectScenario(context, scenario) {
+	const bodyMarkdown = trimMarkdownSlice(context.sourceMarkdown, getContentStartAfterHeading(context, scenario.factId, scenario.start), scenario.end);
+	const rawText = [scenario.title, bodyMarkdown].filter((part) => part.trim()).join("\n");
+	return {
+		title: scenario.title,
+		bodyMarkdown,
+		rawText,
+		steps: getScenarioStepsFromAnnotations(context, scenario)
+	};
+}
+function getScenarioStepsFromAnnotations(context, scenario) {
+	return context.annotations.reduce((steps, annotation) => {
+		if (annotation.kind !== "scenario-step") return steps;
+		const fact = context.factById.get(annotation.targetFactId);
+		const span = fact ? getFactSpan(fact) : void 0;
+		if (!span || span.start <= scenario.start || span.start >= scenario.end) return steps;
+		const keyword = annotation.metadata?.keyword;
+		const contentMarkdown = annotation.metadata?.contentMarkdown;
+		const rawText = annotation.metadata?.rawMarkdown;
+		if (!isScenarioStepKeyword(keyword) || !contentMarkdown || !rawText) return steps;
+		steps.push({
+			keyword,
+			contentMarkdown,
+			rawText
+		});
+		return steps;
+	}, []);
+}
+function isScenarioStepKeyword(value) {
+	return value === "GIVEN" || value === "WHEN" || value === "THEN" || value === "AND" || value === "BUT";
+}
+function projectRequirement(context, requirement) {
+	const bodyEnd = requirement.scenarios.map((scenario) => scenario.start).sort((left, right) => left - right)[0] ?? requirement.end;
+	const bodyMarkdown = trimMarkdownSlice(context.sourceMarkdown, getContentStartAfterHeading(context, requirement.factId, requirement.start), bodyEnd);
+	const scenarios = requirement.scenarios.map((scenario) => projectScenario(context, scenario));
+	const scenarioText = scenarios.map((scenario) => scenario.rawText).join("\n\n");
+	return {
+		id: requirement.id,
+		title: requirement.title,
+		bodyMarkdown,
+		text: createRequirementText(requirement.title, bodyMarkdown, scenarioText),
+		scenarios
+	};
+}
+function getFactSpan(fact) {
+	return getMarkdownFactSpan(fact);
+}
+function getSectionKind(annotations, factId) {
+	if (getOpenSpecProjectionAnnotation(annotations, factId, "purpose-section")) return "overview";
+	if (getOpenSpecProjectionAnnotation(annotations, factId, "requirements-section")) return "requirements";
+	return "other";
+}
+function createDetachedProjectionContext(document) {
+	return {
+		sourceMarkdown: document.sourceMarkdown,
+		facts: document.facts,
+		factById: new Map(document.facts.map((fact) => [fact.id, fact])),
+		annotations: document.annotations.filter(isOpenSpecAnnotation)
+	};
+}
+function toOpenSpecProjectionContext(context) {
+	return {
+		sourceMarkdown: context.sourceMarkdown,
+		facts: context.facts,
+		factById: context.factById,
+		annotations: context.annotations.filter(isOpenSpecAnnotation)
+	};
+}
+function toProjectedOpenSpecDocument(document) {
+	return {
+		...document,
+		annotations: document.annotations.filter(isOpenSpecAnnotation)
+	};
+}
+function isOpenSpecAnnotation(annotation) {
+	return annotation.kind === "document-title" || annotation.kind === "purpose-section" || annotation.kind === "requirements-section" || annotation.kind === "requirement" || annotation.kind === "scenario" || annotation.kind === "scenario-step" || annotation.kind === "keyword";
+}
+
+//#endregion
+export { getOpenSpecReadingSections as a, projectOpenSpecMarkdown as c, getOpenSpecProjectionAnnotation as i, OPEN_SPEC_SPEC_PROJECTION_ID as n, parseOpenSpecMarkdownToSpec as o, createOpenSpecReadingPlugin as r, projectAnnotatedOpenSpecToSpec as s, OPEN_SPEC_READING_SECTIONS_PROJECTION_ID as t };