@openspecui/core 6.2.1 → 7.0.0

package/dist/active-root-config-L5QaMb3A.mjs

@@ -0,0 +1,333 @@
+import { isMap, isNode, isScalar, isSeq, parseDocument } from "yaml";
+import { z } from "zod";
+
+//#region src/active-root-config-contract.ts
+/**
+* Orthogonal intents (updated 2026-08-02 Asia/Shanghai):
+* 1. Define OpenSpec 1.7 Active Root official-field and diagnostic contracts.
+* 2. Define exact owner/file/revision mutation admission and typed recovery results.
+*
+* Original request (2026-08-01): structured fields align with official OpenSpec while raw YAML accepts team extensions.
+* Derived checkpoint (2026-08-02): stale Active Root saves return the latest physical source instead of overwriting it.
+*/
+/** OpenSpec 1.7 hard limit for project context encoded as UTF-8. */
+const MAX_ACTIVE_ROOT_CONTEXT_BYTES = 50 * 1024;
+const NonEmptyStringSchema = z.string().min(1);
+const NonEmptyStringListSchema = z.array(NonEmptyStringSchema);
+const ActiveRootRulesSchema = z.record(NonEmptyStringSchema, NonEmptyStringListSchema);
+const ActiveRootOperationSchema = z.object({ guidance: NonEmptyStringListSchema }).strict();
+const ActiveRootOperationsSchema = z.object({
+	apply: ActiveRootOperationSchema.optional(),
+	archive: ActiveRootOperationSchema.optional()
+}).strict();
+function withinContextByteLimit(value) {
+	return new TextEncoder().encode(value).byteLength <= MAX_ACTIVE_ROOT_CONTEXT_BYTES;
+}
+const ActiveRootContextSchema = z.string().refine(withinContextByteLimit, `Context must not exceed ${MAX_ACTIVE_ROOT_CONTEXT_BYTES} UTF-8 bytes.`);
+/** Runtime schema for the resilient official-field projection. */
+const ActiveRootOfficialConfigSchema = z.object({
+	schema: NonEmptyStringSchema.nullable(),
+	context: ActiveRootContextSchema.nullable(),
+	rules: ActiveRootRulesSchema.nullable(),
+	operations: ActiveRootOperationsSchema.nullable()
+}).strict();
+/** Runtime schema for one complete Structured-mode update. */
+const ActiveRootStructuredUpdateSchema = z.object({
+	schema: NonEmptyStringSchema,
+	context: ActiveRootContextSchema.nullable(),
+	rules: ActiveRootRulesSchema.nullable(),
+	operations: z.object({
+		apply: ActiveRootOperationSchema.nullable(),
+		archive: ActiveRootOperationSchema.nullable()
+	}).strict().nullable()
+}).strict();
+/** Opaque digest proving the exact Active Root owner, file, presence, and source bytes read by an editor. */
+const ActiveRootRevisionSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+const ActiveRootMutationLocatorShape = {
+	ownerPath: z.string().min(1),
+	filePath: z.string().min(1),
+	revision: ActiveRootRevisionSchema
+};
+/** Runtime schema for Structured or Raw mutation admission at one exact physical revision. */
+const ActiveRootMutationSchema = z.discriminatedUnion("mode", [z.object({
+	...ActiveRootMutationLocatorShape,
+	mode: z.literal("structured"),
+	update: ActiveRootStructuredUpdateSchema
+}).strict(), z.object({
+	...ActiveRootMutationLocatorShape,
+	mode: z.literal("raw"),
+	content: z.string()
+}).strict()]);
+
+//#endregion
+//#region src/active-root-config-yaml.ts
+/**
+* Orthogonal intents (updated 2026-08-02 Asia/Shanghai):
+* 1. Inspect OpenSpec 1.7 official fields resiliently while ignoring team-key ownership.
+* 2. Validate Raw YAML syntax without imposing the official key set.
+* 3. Patch only Structured-owned YAML nodes while retaining representable presentation and extensions.
+*
+* Original request (2026-08-01): preserve complete raw YAML because teams may define their own configuration keys.
+* Derived checkpoint (2026-08-02): Structured mode owns schema, context, rules, and apply/archive guidance only.
+*/
+const EMPTY_OFFICIAL_CONFIG = {
+	schema: null,
+	context: null,
+	rules: null,
+	operations: null
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function contextByteLength(value) {
+	return new TextEncoder().encode(value).byteLength;
+}
+function yamlErrors(content) {
+	const document = parseDocument(content);
+	if (document.errors.length === 0) return [];
+	return [{
+		code: "config-unparseable",
+		severity: "error",
+		path: "$",
+		message: document.errors.map((error) => error.message).join("\n")
+	}];
+}
+function inspectRules(value, diagnostics) {
+	if (value === void 0) return null;
+	if (!isRecord(value)) {
+		diagnostics.push({
+			code: "rules-invalid",
+			severity: "error",
+			path: "rules",
+			message: "The rules field must be a mapping of artifact ids to string arrays."
+		});
+		return null;
+	}
+	const rules = {};
+	for (const [artifactId, candidate] of Object.entries(value)) {
+		if (!Array.isArray(candidate) || candidate.some((entry) => typeof entry !== "string")) {
+			diagnostics.push({
+				code: "rules-entry-invalid",
+				severity: "error",
+				path: `rules.${artifactId}`,
+				message: `Rules for '${artifactId}' must be an array of strings.`
+			});
+			continue;
+		}
+		const entries = candidate.filter((entry) => entry.length > 0);
+		if (entries.length < candidate.length) diagnostics.push({
+			code: "rules-entry-empty",
+			severity: "warning",
+			path: `rules.${artifactId}`,
+			message: `Empty rules for '${artifactId}' are ignored by OpenSpec.`
+		});
+		if (entries.length > 0) rules[artifactId] = entries;
+	}
+	return Object.keys(rules).length > 0 ? rules : null;
+}
+function inspectOperations(value, diagnostics) {
+	if (value === void 0) return null;
+	if (!isRecord(value)) {
+		diagnostics.push({
+			code: "operations-invalid",
+			severity: "error",
+			path: "operations",
+			message: "The operations field must be a mapping."
+		});
+		return null;
+	}
+	const operations = {};
+	for (const operationId of ["apply", "archive"]) {
+		const candidate = value[operationId];
+		if (candidate === void 0) continue;
+		if (!isRecord(candidate)) {
+			diagnostics.push({
+				code: "operation-invalid",
+				severity: "error",
+				path: `operations.${operationId}`,
+				message: `Operation '${operationId}' must be a mapping.`
+			});
+			continue;
+		}
+		if (candidate.guidance === void 0) continue;
+		if (!Array.isArray(candidate.guidance) || candidate.guidance.some((entry) => typeof entry !== "string")) {
+			diagnostics.push({
+				code: "operation-guidance-invalid",
+				severity: "error",
+				path: `operations.${operationId}.guidance`,
+				message: `Guidance for '${operationId}' must be an array of strings.`
+			});
+			continue;
+		}
+		const guidance = candidate.guidance.filter((entry) => entry.length > 0);
+		if (guidance.length < candidate.guidance.length) diagnostics.push({
+			code: "operation-guidance-empty",
+			severity: "warning",
+			path: `operations.${operationId}.guidance`,
+			message: `Empty '${operationId}' guidance entries are ignored by OpenSpec.`
+		});
+		if (guidance.length > 0) operations[operationId] = { guidance };
+	}
+	return Object.keys(operations).length > 0 ? operations : null;
+}
+/** Inspect official OpenSpec 1.7 Active Root fields independently and retain recoverable diagnostics. */
+function inspectActiveRootOfficialConfig(content) {
+	if (content === null || content.trim().length === 0) return {
+		official: { ...EMPTY_OFFICIAL_CONFIG },
+		diagnostics: [{
+			code: "schema-missing",
+			severity: "error",
+			path: "schema",
+			message: "The active OpenSpec config does not declare a schema."
+		}]
+	};
+	const document = parseDocument(content);
+	if (document.errors.length > 0) return {
+		official: { ...EMPTY_OFFICIAL_CONFIG },
+		diagnostics: yamlErrors(content)
+	};
+	const raw = document.toJS();
+	if (!isRecord(raw)) return {
+		official: { ...EMPTY_OFFICIAL_CONFIG },
+		diagnostics: [{
+			code: "config-not-mapping",
+			severity: "error",
+			path: "$",
+			message: "OpenSpec config must be a YAML mapping for Structured mode."
+		}]
+	};
+	const diagnostics = [];
+	let schema = null;
+	if (raw.schema === void 0) diagnostics.push({
+		code: "schema-missing",
+		severity: "error",
+		path: "schema",
+		message: "The active OpenSpec config does not declare a schema."
+	});
+	else if (typeof raw.schema !== "string" || raw.schema.length === 0) diagnostics.push({
+		code: "schema-invalid",
+		severity: "error",
+		path: "schema",
+		message: "The schema field must be a non-empty string."
+	});
+	else schema = raw.schema;
+	let context = null;
+	if (raw.context !== void 0) if (typeof raw.context !== "string") diagnostics.push({
+		code: "context-invalid",
+		severity: "error",
+		path: "context",
+		message: "The context field must be a string."
+	});
+	else if (contextByteLength(raw.context) > MAX_ACTIVE_ROOT_CONTEXT_BYTES) diagnostics.push({
+		code: "context-too-large",
+		severity: "error",
+		path: "context",
+		message: `The context field exceeds ${MAX_ACTIVE_ROOT_CONTEXT_BYTES} UTF-8 bytes.`
+	});
+	else context = raw.context;
+	return {
+		official: {
+			schema,
+			context,
+			rules: inspectRules(raw.rules, diagnostics),
+			operations: inspectOperations(raw.operations, diagnostics)
+		},
+		diagnostics
+	};
+}
+/** Validate Raw-mode YAML syntax while allowing any syntactically valid document shape and custom keys. */
+function validateActiveRootRawYaml(content) {
+	const diagnostics = yamlErrors(content);
+	return {
+		valid: diagnostics.length === 0,
+		diagnostics
+	};
+}
+function editableDocument(content) {
+	const document = parseDocument(content ?? "");
+	if (document.errors.length > 0) throw new Error(`Active Root cannot be edited in Structured mode: ${document.errors.map((error) => error.message).join("\n")}`);
+	if (document.contents !== null && !isMap(document.contents)) throw new Error("Active Root cannot be edited in Structured mode: config is not a YAML mapping.");
+	return document;
+}
+function copyPresentation(source, target) {
+	if (!isNode(source) || !isNode(target)) return;
+	target.comment = source.comment;
+	target.commentBefore = source.commentBefore;
+	target.spaceBefore = source.spaceBefore;
+	if (isScalar(source) && isScalar(target) && typeof target.value === "string") target.type = source.type;
+	if (isMap(source) && isMap(target) || isSeq(source) && isSeq(target)) target.flow = source.flow;
+	if (isSeq(source) && isSeq(target)) for (let index = 0; index < Math.min(source.items.length, target.items.length); index += 1) copyPresentation(source.items[index], target.items[index]);
+}
+function replaceNode(document, path, value) {
+	const previous = document.getIn(path, true);
+	const replacement = document.createNode(value);
+	copyPresentation(previous, replacement);
+	document.setIn(path, replacement);
+}
+function ensureMap(document, path) {
+	const current = document.getIn(path, true);
+	if (isMap(current)) return current;
+	replaceNode(document, path, {});
+	const replacement = document.getIn(path, true);
+	if (!isMap(replacement)) throw new Error(`Unable to create YAML mapping at ${path.join(".")}.`);
+	return replacement;
+}
+function mappingStringKeys(mapping) {
+	const keys = [];
+	for (const pair of mapping.items) if (isScalar(pair.key) && typeof pair.key.value === "string") keys.push(pair.key.value);
+	return keys;
+}
+function patchRules(document, rules) {
+	if (rules === null) {
+		document.delete("rules");
+		return;
+	}
+	const mapping = ensureMap(document, ["rules"]);
+	for (const artifactId of mappingStringKeys(mapping)) if (!Object.hasOwn(rules, artifactId)) mapping.delete(artifactId);
+	for (const [artifactId, entries] of Object.entries(rules)) replaceNode(document, ["rules", artifactId], entries);
+}
+function removeOperationGuidance(document, operationId) {
+	const operations = document.getIn(["operations"], true);
+	if (!isMap(operations)) return;
+	const operation = document.getIn(["operations", operationId], true);
+	if (isMap(operation)) {
+		operation.delete("guidance");
+		if (operation.items.length === 0) operations.delete(operationId);
+	} else if (operation !== void 0) operations.delete(operationId);
+	if (operations.items.length === 0) document.delete("operations");
+}
+function patchOperations(document, operations) {
+	if (operations === null) {
+		removeOperationGuidance(document, "apply");
+		removeOperationGuidance(document, "archive");
+		return;
+	}
+	ensureMap(document, ["operations"]);
+	for (const operationId of ["apply", "archive"]) {
+		const operation = operations[operationId];
+		if (operation === null) {
+			removeOperationGuidance(document, operationId);
+			continue;
+		}
+		ensureMap(document, ["operations", operationId]);
+		replaceNode(document, [
+			"operations",
+			operationId,
+			"guidance"
+		], operation.guidance);
+	}
+}
+/** Patch only Structured-owned official nodes and retain all representable unowned YAML evidence. */
+function patchActiveRootOfficialFields(content, update) {
+	const validated = ActiveRootStructuredUpdateSchema.parse(update);
+	const document = editableDocument(content);
+	replaceNode(document, ["schema"], validated.schema);
+	if (validated.context === null) document.delete("context");
+	else replaceNode(document, ["context"], validated.context);
+	patchRules(document, validated.rules);
+	patchOperations(document, validated.operations);
+	return document.toString({ lineWidth: 0 });
+}
+
+//#endregion
+export { ActiveRootOfficialConfigSchema as a, MAX_ACTIVE_ROOT_CONTEXT_BYTES as c, ActiveRootMutationSchema as i, patchActiveRootOfficialFields as n, ActiveRootRevisionSchema as o, validateActiveRootRawYaml as r, ActiveRootStructuredUpdateSchema as s, inspectActiveRootOfficialConfig as t };

package/dist/active-root-config.d.mts

@@ -0,0 +1,6 @@
+import "./document-translation-BNbM3fEj.mjs";
+import "./sounds-qIKfPgxj.mjs";
+import "./notifications-ClhEHZU3.mjs";
+import "./index-CF5niw80.mjs";
+import { _ as ActiveRootStructuredUpdateSchema, a as ActiveRootConfigDiagnostic, c as ActiveRootMutation, d as ActiveRootOfficialConfig, f as ActiveRootOfficialConfigSchema, g as ActiveRootStructuredUpdate, h as ActiveRootRevisionSchema, i as ActiveRootConfig, l as ActiveRootMutationResult, m as ActiveRootRevision, n as patchActiveRootOfficialFields, o as ActiveRootConfigFile, p as ActiveRootRawValidation, r as validateActiveRootRawYaml, s as ActiveRootConfigInspection, t as inspectActiveRootOfficialConfig, u as ActiveRootMutationSchema, v as MAX_ACTIVE_ROOT_CONTEXT_BYTES } from "./active-root-config-BXb2HeOF.mjs";
+export { ActiveRootConfig, ActiveRootConfigDiagnostic, ActiveRootConfigFile, ActiveRootConfigInspection, ActiveRootMutation, ActiveRootMutationResult, ActiveRootMutationSchema, ActiveRootOfficialConfig, ActiveRootOfficialConfigSchema, ActiveRootRawValidation, ActiveRootRevision, ActiveRootRevisionSchema, ActiveRootStructuredUpdate, ActiveRootStructuredUpdateSchema, MAX_ACTIVE_ROOT_CONTEXT_BYTES, inspectActiveRootOfficialConfig, patchActiveRootOfficialFields, validateActiveRootRawYaml };

package/dist/active-root-config.mjs

@@ -0,0 +1,3 @@
+import { a as ActiveRootOfficialConfigSchema, c as MAX_ACTIVE_ROOT_CONTEXT_BYTES, i as ActiveRootMutationSchema, n as patchActiveRootOfficialFields, o as ActiveRootRevisionSchema, r as validateActiveRootRawYaml, s as ActiveRootStructuredUpdateSchema, t as inspectActiveRootOfficialConfig } from "./active-root-config-L5QaMb3A.mjs";
+
+export { ActiveRootMutationSchema, ActiveRootOfficialConfigSchema, ActiveRootRevisionSchema, ActiveRootStructuredUpdateSchema, MAX_ACTIVE_ROOT_CONTEXT_BYTES, inspectActiveRootOfficialConfig, patchActiveRootOfficialFields, validateActiveRootRawYaml };

package/dist/{cli-projection-Cus0QYkY.d.mts → cli-projection-CBwRFPMi.d.mts}

@@ -1,4 +1,4 @@
-import { n as CliJsonValue, t as CliCommandResult } from "./command-result-BkUqqa0m.mjs";
+import { G as CliJsonValue, W as CliCommandResult } from "./index-CF5niw80.mjs";
 import { z } from "zod";
 
 //#region src/cli-projection.d.ts

package/dist/{cli-projection-BHfqvlpA.mjs → cli-projection-CKRwTvwf.mjs}

@@ -1,4 +1,4 @@
-import { n as CliDiagnosticSchema } from "./common-BpgNUOOT.mjs";
+import { n as CliDiagnosticSchema } from "./common-BRL_34xt.mjs";
 import { z } from "zod";
 
 //#region src/cli-projection.ts

package/dist/cli-projection.d.mts

@@ -1,6 +1,6 @@
-import "./command-result-BkUqqa0m.mjs";
-import "./document-translation-J_NddeDy.mjs";
-import "./sounds-CsPiQKxX.mjs";
-import "./notifications-COeXWb2h.mjs";
-import { _ as toCliProjectionCommandEvidence, a as CliProjectionFailure, c as CliProjectionInvalidationCauseSchema, d as CliProjectionState, f as CliProjectionStateName, g as createCliProjectionStateSchema, h as cliProjectionStates, i as CliProjectionCommandEvidenceSchema, l as CliProjectionNotice, m as cliProjectionInvalidationCauses, n as CliProjectionCommandError, o as CliProjectionFailureSchema, p as CliProjectionStateNameSchema, r as CliProjectionCommandEvidence, s as CliProjectionInvalidationCause, t as CliJsonValueSchema, u as CliProjectionNoticeSchema, v as toCliProjectionFailure, y as toCliProjectionNotice } from "./cli-projection-Cus0QYkY.mjs";
+import "./document-translation-BNbM3fEj.mjs";
+import "./sounds-qIKfPgxj.mjs";
+import "./notifications-ClhEHZU3.mjs";
+import "./index-CF5niw80.mjs";
+import { _ as toCliProjectionCommandEvidence, a as CliProjectionFailure, c as CliProjectionInvalidationCauseSchema, d as CliProjectionState, f as CliProjectionStateName, g as createCliProjectionStateSchema, h as cliProjectionStates, i as CliProjectionCommandEvidenceSchema, l as CliProjectionNotice, m as cliProjectionInvalidationCauses, n as CliProjectionCommandError, o as CliProjectionFailureSchema, p as CliProjectionStateNameSchema, r as CliProjectionCommandEvidence, s as CliProjectionInvalidationCause, t as CliJsonValueSchema, u as CliProjectionNoticeSchema, v as toCliProjectionFailure, y as toCliProjectionNotice } from "./cli-projection-CBwRFPMi.mjs";
 export { CliJsonValueSchema, CliProjectionCommandError, CliProjectionCommandEvidence, CliProjectionCommandEvidenceSchema, CliProjectionFailure, CliProjectionFailureSchema, CliProjectionInvalidationCause, CliProjectionInvalidationCauseSchema, CliProjectionNotice, CliProjectionNoticeSchema, CliProjectionState, CliProjectionStateName, CliProjectionStateNameSchema, cliProjectionInvalidationCauses, cliProjectionStates, createCliProjectionStateSchema, toCliProjectionCommandEvidence, toCliProjectionFailure, toCliProjectionNotice };

package/dist/cli-projection.mjs

@@ -1,4 +1,4 @@
-import "./common-BpgNUOOT.mjs";
-import { a as CliProjectionInvalidationCauseSchema, c as cliProjectionInvalidationCauses, d as toCliProjectionCommandEvidence, f as toCliProjectionFailure, i as CliProjectionFailureSchema, l as cliProjectionStates, n as CliProjectionCommandError, o as CliProjectionNoticeSchema, p as toCliProjectionNotice, r as CliProjectionCommandEvidenceSchema, s as CliProjectionStateNameSchema, t as CliJsonValueSchema, u as createCliProjectionStateSchema } from "./cli-projection-BHfqvlpA.mjs";
+import "./common-BRL_34xt.mjs";
+import { a as CliProjectionInvalidationCauseSchema, c as cliProjectionInvalidationCauses, d as toCliProjectionCommandEvidence, f as toCliProjectionFailure, i as CliProjectionFailureSchema, l as cliProjectionStates, n as CliProjectionCommandError, o as CliProjectionNoticeSchema, p as toCliProjectionNotice, r as CliProjectionCommandEvidenceSchema, s as CliProjectionStateNameSchema, t as CliJsonValueSchema, u as createCliProjectionStateSchema } from "./cli-projection-CKRwTvwf.mjs";
 
 export { CliJsonValueSchema, CliProjectionCommandError, CliProjectionCommandEvidenceSchema, CliProjectionFailureSchema, CliProjectionInvalidationCauseSchema, CliProjectionNoticeSchema, CliProjectionStateNameSchema, cliProjectionInvalidationCauses, cliProjectionStates, createCliProjectionStateSchema, toCliProjectionCommandEvidence, toCliProjectionFailure, toCliProjectionNotice };

package/dist/{common-BpgNUOOT.mjs → common-BRL_34xt.mjs}

@@ -2,7 +2,7 @@ import { z } from "zod";
 
 //#region src/cli-contracts/common.ts
 /**
-* Orthogonal intents (created 2026-07-15 Asia/Shanghai):
+* Orthogonal intents (updated 2026-08-01 Asia/Shanghai):
 * 1. Model OpenSpec CLI diagnostics without reinterpreting their meaning.
 * 2. Preserve root selection provenance exactly as emitted by the CLI.
 * 3. Preserve direct Reference indexes and their upstream health evidence.
@@ -26,6 +26,7 @@ const CliRootSourceSchema = z.enum([
 	"store",
 	"declared",
 	"nearest",
+	"global_default",
 	"implicit"
 ]);
 /** CLI-selected planning root with upstream selection provenance. */