@aigne/aos 0.2.0-beta

package/dist/scaffold/workspace-dsl.cjs

@@ -0,0 +1,339 @@
+const require_dsl_shared = require('../dsl-shared.cjs');
+const require_dsl_error = require('./dsl-error.cjs');
+
+//#region src/scaffold/workspace-dsl.ts
+const STRING = "\"((?:[^\"\\\\]|\\\\.)*)\"";
+function pathHasTraversal(path) {
+	let decoded = path;
+	try {
+		decoded = decodeURIComponent(path);
+	} catch {}
+	const re = /(^|\/)\.\.($|\/)/;
+	return re.test(path) || re.test(decoded);
+}
+/**
+* Project a parsed workspace definition onto the formalized convention
+* manifest — flattening sections to their folder roots and lifting the agent
+* and default content path.
+*/
+function workspaceManifestFromDefinition(definition) {
+	const roots = [];
+	for (const section of definition.sections ?? []) for (const root of section.roots ?? []) roots.push({
+		id: root.id,
+		title: root.title,
+		path: root.path,
+		...root.editable !== void 0 ? { editable: root.editable } : {}
+	});
+	return {
+		roots,
+		...definition.defaultPath ? { defaultPath: definition.defaultPath } : {},
+		...definition.agent?.module ? { agent: {
+			module: definition.agent.module,
+			...definition.agent.title ? { title: definition.agent.title } : {},
+			...definition.agent.placeholder ? { placeholder: definition.agent.placeholder } : {}
+		} } : {}
+	};
+}
+/**
+* Schema-validate a workspace convention manifest (strict: declare ⇒ execute,
+* never silently degrade to an empty workspace). Throws a
+* {@link ScaffoldDslCompileError} on any violation:
+* - no folder roots at all,
+* - a root `from` / `default` path that is relative or contains `..` traversal.
+*/
+function validateWorkspaceManifest(manifest) {
+	if (!manifest.roots || manifest.roots.length === 0) throw parseError(1, "Workspace manifest must declare at least one root");
+	for (const root of manifest.roots) {
+		if (!root.path.startsWith("/")) throw parseError(1, `Workspace root "${root.id}" path must be absolute: ${root.path}`);
+		if (pathHasTraversal(root.path)) throw parseError(1, `Workspace root "${root.id}" path must not contain traversal (..): ${root.path}`);
+	}
+	if (manifest.defaultPath !== void 0) {
+		if (!manifest.defaultPath.startsWith("/")) throw parseError(1, `Workspace default path must be absolute: ${manifest.defaultPath}`);
+		if (pathHasTraversal(manifest.defaultPath)) throw parseError(1, `Workspace default path must not contain traversal (..): ${manifest.defaultPath}`);
+	}
+}
+function compileWorkspaceDsl(source) {
+	const declaration = require_dsl_shared.parseDeclaration(source, {
+		kind: "workspace",
+		allowQuotedId: true,
+		allowHeadValues: true,
+		expected: "Expected workspace \"Title\" {",
+		fieldKeywords: [
+			"description",
+			"default",
+			"detail",
+			"agent",
+			"rail",
+			"group",
+			"root"
+		],
+		fieldInlineContinuationKeywords: { root: ["description"] },
+		nestedFieldKeywords: ["group"],
+		error: parseSharedError
+	});
+	const variant = parseVariant(declaration.headValues ?? []);
+	const workspace = {
+		title: declaration.id,
+		...variant ? { variant } : {},
+		rail: [],
+		sections: []
+	};
+	let railOrder = 1;
+	const sections = [];
+	for (const field of declaration.fields) {
+		if (field.name.value === "description") {
+			workspace.description = parseSingleStringField(field, "Expected description \"<text>\"");
+			continue;
+		}
+		if (field.name.value === "default") {
+			workspace.defaultPath = parseSingleStringField(field, "Expected default \"<path>\"");
+			continue;
+		}
+		if (field.name.value === "detail") {
+			workspace.detail = parseDetailField(field);
+			continue;
+		}
+		if (field.name.value === "agent") {
+			workspace.agent = parseAgentField(field);
+			continue;
+		}
+		if (field.name.value === "rail") {
+			workspace.rail ??= [];
+			workspace.rail.push(parseRailField(field, railOrder++));
+			continue;
+		}
+		if (field.name.value === "group") {
+			sections.push(parseGroupField(field, sections.length + 1));
+			continue;
+		}
+		if (field.name.value === "root") {
+			const section = ensureDefaultSection(sections);
+			section.roots ??= [];
+			section.roots.push(parseRootField(field, section.roots.length + 1));
+			continue;
+		}
+		throw parseError(field.name.line, `Unsupported workspace DSL line: ${field.name.value}`, field.name.column);
+	}
+	workspace.sections = sections;
+	if (workspace.rail?.length === 0) delete workspace.rail;
+	if (workspace.sections.length === 0) throw parseError(1, "Workspace DSL must define at least one root");
+	return workspace;
+}
+function formatWorkspaceDsl(source) {
+	const workspace = compileWorkspaceDsl(source);
+	const lines = [`workspace ${quote(workspace.title ?? "Workspace")}${workspace.variant ? ` variant ${workspace.variant}` : ""} {`];
+	if (workspace.description) lines.push(`  description ${quote(workspace.description)}`);
+	if (workspace.defaultPath) lines.push(`  default ${quote(workspace.defaultPath)}`);
+	if (workspace.detail?.renderer) lines.push(`  detail ${workspace.detail.renderer}${workspace.detail.pattern ? ` pattern ${workspace.detail.pattern}` : ""}`);
+	if (workspace.agent?.module) lines.push(`  agent ${workspace.agent.module}${workspace.agent.title ? ` ${quote(workspace.agent.title)}` : ""}${workspace.agent.placeholder ? ` placeholder ${quote(workspace.agent.placeholder)}` : ""}`);
+	for (const item of workspace.rail ?? []) lines.push(`  rail ${quote(item.title)}${item.icon ? ` icon ${item.icon}` : ""}${item.href ? ` href ${quote(item.href)}` : ""}${item.active ? " active" : ""}`);
+	const sections = workspace.sections ?? [];
+	if (sections.length > 0) lines.push("");
+	sections.forEach((section, index) => {
+		if (index > 0) lines.push("");
+		const sectionId = section.id && section.id !== slugify(section.title) ? `${section.id} ` : "";
+		lines.push(`  group ${sectionId}${quote(section.title)} {`);
+		if (section.description) lines.push(`    description ${quote(section.description)}`);
+		for (const root of section.roots ?? []) {
+			const options = [
+				root.maxDepth !== void 0 ? `depth ${root.maxDepth}` : void 0,
+				root.itemStyle && root.itemStyle !== "compact" ? `style ${root.itemStyle}` : void 0,
+				...formatRootFilterOptions(root),
+				root.description ? `description ${quote(root.description)}` : void 0,
+				root.editable === true ? "editable" : root.editable === false ? "readonly" : void 0
+			].filter(Boolean).join(" ");
+			const rootId = root.id && root.id !== slugify(root.title) ? `${root.id} ` : "";
+			lines.push(`    root ${rootId}${quote(root.title)} from ${quote(root.path)}${options ? ` ${options}` : ""}`);
+		}
+		lines.push("  }");
+	});
+	lines.push("}");
+	return `${lines.join("\n")}\n`;
+}
+function ensureDefaultSection(sections) {
+	let section = sections[0];
+	if (!section) {
+		section = {
+			id: "workspace",
+			title: "Workspace",
+			order: 1,
+			roots: []
+		};
+		sections.push(section);
+	}
+	return section;
+}
+function parseVariant(tokens) {
+	if (tokens.length === 0) return void 0;
+	if (tokens.length === 2 && tokens[0]?.type === "word" && tokens[0].value === "variant") {
+		const variant = tokens[1];
+		if (variant?.type === "word") return variant.value;
+	}
+	const token = tokens[0];
+	throw parseError(token?.line ?? 1, "Expected workspace \"Title\" [variant name] {", token?.column);
+}
+function parseDetailField(field) {
+	const renderer = field.values[0];
+	if (renderer?.type !== "word" || renderer.value !== "surface" && renderer.value !== "auto-surface") throw parseError(renderer?.line ?? field.name.line, "Expected detail surface|auto-surface");
+	const patternKeyword = field.values[1];
+	const pattern = field.values[2];
+	if (!patternKeyword) return { renderer: renderer.value };
+	if (patternKeyword.type === "word" && patternKeyword.value === "pattern" && pattern?.type === "word") return {
+		renderer: renderer.value,
+		pattern: pattern.value
+	};
+	throw parseError(patternKeyword.line, "Expected detail surface|auto-surface [pattern name]");
+}
+function parseAgentField(field) {
+	const module = field.values[0];
+	if (module?.type !== "word") throw parseError(module?.line ?? field.name.line, "Expected agent <module> [\"Title\"]");
+	let index = 1;
+	let title;
+	if (field.values[index]?.type === "string") {
+		title = require_dsl_shared.parseDslStringToken(field.values[index], parseSharedError);
+		index += 1;
+	}
+	let placeholder;
+	const placeholderKeyword = field.values[index];
+	if (placeholderKeyword) {
+		const value = field.values[index + 1];
+		if (placeholderKeyword.type !== "word" || placeholderKeyword.value !== "placeholder" || value?.type !== "string") throw parseError(placeholderKeyword.line, "Expected agent <module> [\"Title\"] [placeholder \"...\"]");
+		placeholder = require_dsl_shared.parseDslStringToken(value, parseSharedError);
+		index += 2;
+	}
+	if (field.values.length !== index) {
+		const token = field.values[index];
+		throw parseError(token.line, "Expected agent <module> [\"Title\"] [placeholder \"...\"]", token.column);
+	}
+	return {
+		module: module.value,
+		...title ? { title } : {},
+		...placeholder ? { placeholder } : {}
+	};
+}
+function parseRailField(field, order) {
+	const titleToken = field.values[0];
+	if (titleToken?.type !== "string") throw parseError(titleToken?.line ?? field.name.line, "Expected rail \"Title\"");
+	const title = require_dsl_shared.parseDslStringToken(titleToken, parseSharedError);
+	const rest = joinDslValues(field.values.slice(1));
+	const icon = rest.match(/\bicon\s+([A-Za-z0-9_-]+)/);
+	const href = rest.match(/* @__PURE__ */ new RegExp(`\\bhref\\s+${STRING}`));
+	return {
+		id: slugify(title),
+		title,
+		...icon?.[1] ? { icon: icon[1] } : {},
+		...href?.[1] ? { href: unescapeString(href[1]) } : {},
+		...rest.match(/\bactive\b/) ? { active: true } : {},
+		order
+	};
+}
+function parseGroupField(field, order) {
+	const parsed = parseOptionalIdTitleField(field, "Expected group [id] \"Title\" {");
+	const section = {
+		id: parsed.id ?? slugify(parsed.title),
+		title: parsed.title,
+		order,
+		roots: []
+	};
+	let rootOrder = 1;
+	for (const child of field.children ?? []) {
+		if (child.name.value === "description") {
+			section.description = parseSingleStringField(child, "Expected description \"<text>\"");
+			continue;
+		}
+		if (child.name.value === "root") {
+			section.roots?.push(parseRootField(child, rootOrder++));
+			continue;
+		}
+		throw parseError(child.name.line, `Unsupported workspace group DSL line: ${child.name.value}`, child.name.column);
+	}
+	return section;
+}
+function parseRootField(field, order) {
+	const parsed = parseOptionalIdTitleField(field, "Expected root [id] \"Title\" from \"<path>\"");
+	const from = field.values[parsed.nextIndex];
+	const path = field.values[parsed.nextIndex + 1];
+	if (from?.type !== "word" || from.value !== "from" || path?.type !== "string") throw parseError(from?.line ?? field.name.line, "Expected root [id] \"Title\" from \"<path>\"");
+	const rest = joinDslValues(field.values.slice(parsed.nextIndex + 2));
+	const depth = rest.match(/\bdepth\s+(\d+)/);
+	const style = rest.match(/\bstyle\s+([A-Za-z0-9_-]+)/);
+	const descriptionValue = rest.match(/* @__PURE__ */ new RegExp(`\\bdescription\\s+${STRING}`));
+	const excludes = parseStringListOption(rest, "exclude");
+	const filter = excludes.length > 0 ? { exclude: excludes } : rest.match(/\bfilter\s+none\b/) ? void 0 : { exclude: [".aup"] };
+	const editable = rest.match(/\beditable\b/) ? true : rest.match(/\breadonly\b/) ? false : void 0;
+	return {
+		id: parsed.id ?? slugify(parsed.title),
+		title: parsed.title,
+		path: require_dsl_shared.parseDslStringToken(path, parseSharedError),
+		...descriptionValue?.[1] ? { description: unescapeString(descriptionValue[1]) } : {},
+		order,
+		maxDepth: depth ? Number(depth[1]) : 1,
+		layout: "grouped",
+		itemStyle: style?.[1] ?? "compact",
+		...filter ? { filter } : {},
+		sort: { field: "id" },
+		...editable !== void 0 ? { editable } : {}
+	};
+}
+function parseOptionalIdTitleField(field, message) {
+	const first = field.values[0];
+	const second = field.values[1];
+	if (first?.type === "string") return {
+		title: require_dsl_shared.parseDslStringToken(first, parseSharedError),
+		nextIndex: 1
+	};
+	if (first?.type === "word" && second?.type === "string") return {
+		id: first.value,
+		title: require_dsl_shared.parseDslStringToken(second, parseSharedError),
+		nextIndex: 2
+	};
+	throw parseError(first?.line ?? field.name.line, message, first?.column ?? field.name.column);
+}
+function parseSingleStringField(field, message) {
+	const value = field.values[0];
+	if (field.values.length !== 1 || value?.type !== "string") throw parseError(value?.line ?? field.name.line, message, value?.column ?? field.name.column);
+	return require_dsl_shared.parseDslStringToken(value, parseSharedError);
+}
+function joinDslValues(tokens) {
+	return tokens.map((token) => token.value).join(" ");
+}
+function parseSharedError(message, line, column = 1) {
+	return parseError(line, message, column);
+}
+function unescapeString(value) {
+	return value.replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+}
+function quote(value) {
+	return JSON.stringify(value);
+}
+function parseStringListOption(rest, option) {
+	const optionMatch = rest.match(/* @__PURE__ */ new RegExp(`\\b${option}\\b`));
+	if (!optionMatch || optionMatch.index === void 0) return [];
+	const tail = rest.slice(optionMatch.index + option.length).trimStart();
+	const nextKeywordIndex = tail.search(/\s+(?:description|depth|style|editable|readonly|filter)\b/);
+	const valueSource = nextKeywordIndex >= 0 ? tail.slice(0, nextKeywordIndex) : tail;
+	const values = [];
+	for (const match of valueSource.matchAll(new RegExp(STRING, "g"))) values.push(unescapeString(match[1] ?? ""));
+	return values;
+}
+function formatRootFilterOptions(root) {
+	if (!root.filter) return ["filter none"];
+	if (typeof root.filter === "string") return [];
+	const exclude = root.filter.exclude;
+	if (!Array.isArray(exclude)) return [];
+	const values = exclude.filter((value) => typeof value === "string");
+	if (values.length === 1 && values[0] === ".aup") return [];
+	return [`exclude ${values.map((value) => quote(value)).join(" ")}`];
+}
+function slugify(value) {
+	return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "workspace";
+}
+function parseError(line, message, column = 1) {
+	return require_dsl_error.scaffoldDslParseError("workspace", line, message, column);
+}
+
+//#endregion
+exports.compileWorkspaceDsl = compileWorkspaceDsl;
+exports.formatWorkspaceDsl = formatWorkspaceDsl;
+exports.validateWorkspaceManifest = validateWorkspaceManifest;
+exports.workspaceManifestFromDefinition = workspaceManifestFromDefinition;

package/dist/scaffold/workspace-dsl.d.cts

@@ -0,0 +1,49 @@
+import { ScaffoldWorkspaceDefinition } from "./types.cjs";
+
+//#region src/scaffold/workspace-dsl.d.ts
+/**
+ * Formalized `afs-workspace` convention contract (task 0.1).
+ *
+ * The `workspace.dsl` shell language parses into a {@link ScaffoldWorkspaceDefinition}
+ * (rail/variant/sections/etc — the full shell). The *convention schema* is the
+ * narrower contract the generalized wiring depends on: the folder roots (each a
+ * select→content source), the agent, and the default content path. Extracting
+ * it into a flat, validated manifest keeps the convention decoupled from the
+ * particular DSL surface and gives one place to reject bad manifests.
+ */
+interface WorkspaceManifestRoot {
+  id: string;
+  title: string;
+  /** Absolute AFS path to the folder this root projects. */
+  path: string;
+  editable?: boolean;
+}
+interface WorkspaceManifestAgent {
+  module: string;
+  title?: string;
+  placeholder?: string;
+}
+interface WorkspaceManifest {
+  roots: WorkspaceManifestRoot[];
+  defaultPath?: string;
+  agent?: WorkspaceManifestAgent;
+}
+/**
+ * Project a parsed workspace definition onto the formalized convention
+ * manifest — flattening sections to their folder roots and lifting the agent
+ * and default content path.
+ */
+declare function workspaceManifestFromDefinition(definition: ScaffoldWorkspaceDefinition): WorkspaceManifest;
+/**
+ * Schema-validate a workspace convention manifest (strict: declare ⇒ execute,
+ * never silently degrade to an empty workspace). Throws a
+ * {@link ScaffoldDslCompileError} on any violation:
+ * - no folder roots at all,
+ * - a root `from` / `default` path that is relative or contains `..` traversal.
+ */
+declare function validateWorkspaceManifest(manifest: WorkspaceManifest): void;
+declare function compileWorkspaceDsl(source: string): ScaffoldWorkspaceDefinition;
+declare function formatWorkspaceDsl(source: string): string;
+//#endregion
+export { WorkspaceManifest, WorkspaceManifestAgent, WorkspaceManifestRoot, compileWorkspaceDsl, formatWorkspaceDsl, validateWorkspaceManifest, workspaceManifestFromDefinition };
+//# sourceMappingURL=workspace-dsl.d.cts.map

package/dist/scaffold/workspace-dsl.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-dsl.d.cts","names":[],"sources":["../../src/scaffold/workspace-dsl.ts"],"mappings":";;;;;AA0BA;;;;;;;;UAAiB,qBAAA;EACf,EAAA;EACA,KAAA;EAMqC;EAJrC,IAAA;EACA,QAAA;AAAA;AAAA,UAGe,sBAAA;EACf,MAAA;EACA,KAAA;EACA,WAAA;AAAA;AAAA,UAGe,iBAAA;EACf,KAAA,EAAO,qBAAA;EACP,WAAA;EACA,KAAA,GAAQ,sBAAA;AAAA;;;;;;iBAqBM,+BAAA,CACd,UAAA,EAAY,2BAAA,GACX,iBAAA;;;;;;;;iBAkCa,yBAAA,CAA0B,QAAA,EAAU,iBAAA;AAAA,iBA4BpC,mBAAA,CAAoB,MAAA,WAAiB,2BAAA;AAAA,iBAsErC,kBAAA,CAAmB,MAAA"}

package/dist/scaffold/workspace-dsl.d.mts

@@ -0,0 +1,49 @@
+import { ScaffoldWorkspaceDefinition } from "./types.mjs";
+
+//#region src/scaffold/workspace-dsl.d.ts
+/**
+ * Formalized `afs-workspace` convention contract (task 0.1).
+ *
+ * The `workspace.dsl` shell language parses into a {@link ScaffoldWorkspaceDefinition}
+ * (rail/variant/sections/etc — the full shell). The *convention schema* is the
+ * narrower contract the generalized wiring depends on: the folder roots (each a
+ * select→content source), the agent, and the default content path. Extracting
+ * it into a flat, validated manifest keeps the convention decoupled from the
+ * particular DSL surface and gives one place to reject bad manifests.
+ */
+interface WorkspaceManifestRoot {
+  id: string;
+  title: string;
+  /** Absolute AFS path to the folder this root projects. */
+  path: string;
+  editable?: boolean;
+}
+interface WorkspaceManifestAgent {
+  module: string;
+  title?: string;
+  placeholder?: string;
+}
+interface WorkspaceManifest {
+  roots: WorkspaceManifestRoot[];
+  defaultPath?: string;
+  agent?: WorkspaceManifestAgent;
+}
+/**
+ * Project a parsed workspace definition onto the formalized convention
+ * manifest — flattening sections to their folder roots and lifting the agent
+ * and default content path.
+ */
+declare function workspaceManifestFromDefinition(definition: ScaffoldWorkspaceDefinition): WorkspaceManifest;
+/**
+ * Schema-validate a workspace convention manifest (strict: declare ⇒ execute,
+ * never silently degrade to an empty workspace). Throws a
+ * {@link ScaffoldDslCompileError} on any violation:
+ * - no folder roots at all,
+ * - a root `from` / `default` path that is relative or contains `..` traversal.
+ */
+declare function validateWorkspaceManifest(manifest: WorkspaceManifest): void;
+declare function compileWorkspaceDsl(source: string): ScaffoldWorkspaceDefinition;
+declare function formatWorkspaceDsl(source: string): string;
+//#endregion
+export { WorkspaceManifest, WorkspaceManifestAgent, WorkspaceManifestRoot, compileWorkspaceDsl, formatWorkspaceDsl, validateWorkspaceManifest, workspaceManifestFromDefinition };
+//# sourceMappingURL=workspace-dsl.d.mts.map

package/dist/scaffold/workspace-dsl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-dsl.d.mts","names":[],"sources":["../../src/scaffold/workspace-dsl.ts"],"mappings":";;;;;AA0BA;;;;;;;;UAAiB,qBAAA;EACf,EAAA;EACA,KAAA;EAMqC;EAJrC,IAAA;EACA,QAAA;AAAA;AAAA,UAGe,sBAAA;EACf,MAAA;EACA,KAAA;EACA,WAAA;AAAA;AAAA,UAGe,iBAAA;EACf,KAAA,EAAO,qBAAA;EACP,WAAA;EACA,KAAA,GAAQ,sBAAA;AAAA;;;;;;iBAqBM,+BAAA,CACd,UAAA,EAAY,2BAAA,GACX,iBAAA;;;;;;;;iBAkCa,yBAAA,CAA0B,QAAA,EAAU,iBAAA;AAAA,iBA4BpC,mBAAA,CAAoB,MAAA,WAAiB,2BAAA;AAAA,iBAsErC,kBAAA,CAAmB,MAAA"}