padrone 1.1.0 → 1.2.0

package/dist/codegen/index.mjs

@@ -0,0 +1,1348 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+//#region src/codegen/code-builder.ts
+var CodeBuilderImpl = class CodeBuilderImpl {
+	imports = /* @__PURE__ */ new Map();
+	lines = [];
+	indent;
+	constructor(indent = 0) {
+		this.indent = indent;
+	}
+	import(specifier, source) {
+		const specs = Array.isArray(specifier) ? specifier : [specifier];
+		const existing = this.imports.get(source);
+		if (existing) {
+			for (const s of specs) existing.specifiers.add(s);
+			existing.typeOnly = false;
+		} else this.imports.set(source, {
+			specifiers: new Set(specs),
+			typeOnly: false
+		});
+		return this;
+	}
+	importDefault(name, source) {
+		const existing = this.imports.get(source);
+		if (existing) {
+			existing.defaultSpecifier = name;
+			existing.typeOnly = false;
+		} else this.imports.set(source, {
+			specifiers: /* @__PURE__ */ new Set(),
+			defaultSpecifier: name,
+			typeOnly: false
+		});
+		return this;
+	}
+	importType(specifier, source) {
+		const specs = Array.isArray(specifier) ? specifier : [specifier];
+		const existing = this.imports.get(source);
+		if (existing) for (const s of specs) existing.specifiers.add(s);
+		else this.imports.set(source, {
+			specifiers: new Set(specs),
+			typeOnly: true
+		});
+		return this;
+	}
+	line(code) {
+		this.lines.push({
+			type: "line",
+			content: code ?? ""
+		});
+		return this;
+	}
+	block(openOrBuilder, builderOrClose, closeOrBuilder) {
+		let open;
+		let close;
+		let builder;
+		if (typeof openOrBuilder === "function") builder = openOrBuilder;
+		else if (typeof builderOrClose === "function") {
+			open = openOrBuilder;
+			builder = builderOrClose;
+			close = typeof closeOrBuilder === "string" ? closeOrBuilder : void 0;
+		} else if (typeof closeOrBuilder === "function") {
+			open = openOrBuilder;
+			close = typeof builderOrClose === "string" ? builderOrClose : void 0;
+			builder = closeOrBuilder;
+		} else throw new Error("Invalid block() arguments");
+		this.lines.push({
+			type: "block-open",
+			content: open ?? ""
+		});
+		const inner = new CodeBuilderImpl(this.indent + 1);
+		builder(inner);
+		for (const [source, entry] of inner.imports) {
+			const existing = this.imports.get(source);
+			if (existing) {
+				for (const s of entry.specifiers) existing.specifiers.add(s);
+				if (entry.defaultSpecifier) existing.defaultSpecifier = entry.defaultSpecifier;
+				if (!entry.typeOnly) existing.typeOnly = false;
+			} else this.imports.set(source, {
+				specifiers: new Set(entry.specifiers),
+				defaultSpecifier: entry.defaultSpecifier,
+				typeOnly: entry.typeOnly
+			});
+		}
+		for (const line of inner.lines) this.lines.push(line);
+		this.lines.push({
+			type: "block-close",
+			content: close ?? ""
+		});
+		return this;
+	}
+	comment(text) {
+		this.lines.push({
+			type: "line",
+			content: `// ${text}`
+		});
+		return this;
+	}
+	docComment(text) {
+		const lines = text.split("\n");
+		if (lines.length === 1) this.lines.push({
+			type: "line",
+			content: `/** ${text} */`
+		});
+		else {
+			this.lines.push({
+				type: "line",
+				content: "/**"
+			});
+			for (const line of lines) this.lines.push({
+				type: "line",
+				content: ` * ${line}`
+			});
+			this.lines.push({
+				type: "line",
+				content: " */"
+			});
+		}
+		return this;
+	}
+	todoComment(text) {
+		this.lines.push({
+			type: "line",
+			content: `// TODO: ${text}`
+		});
+		return this;
+	}
+	raw(code) {
+		this.lines.push({
+			type: "raw",
+			content: code
+		});
+		return this;
+	}
+	build() {
+		const parts = [];
+		if (this.imports.size > 0) {
+			const typeImports = [];
+			const valueImports = [];
+			for (const [source, entry] of this.imports) {
+				const specs = [...entry.specifiers].sort();
+				const namedPart = specs.length > 0 ? specs.length === 1 && !specs[0].includes(" ") ? `{ ${specs[0]} }` : `{ ${specs.join(", ")} }` : null;
+				const specStr = entry.defaultSpecifier ? namedPart ? `${entry.defaultSpecifier}, ${namedPart}` : entry.defaultSpecifier : namedPart;
+				const line = entry.typeOnly ? `import type ${specStr} from '${source}'` : `import ${specStr} from '${source}'`;
+				if (entry.typeOnly) typeImports.push(line);
+				else valueImports.push(line);
+			}
+			parts.push([...valueImports, ...typeImports].join("\n"));
+			parts.push("");
+		}
+		let currentIndent = this.indent;
+		for (const line of this.lines) if (line.type === "raw") parts.push(line.content);
+		else if (line.type === "block-open") {
+			if (line.content) {
+				const indent = "  ".repeat(currentIndent);
+				parts.push(`${indent}${line.content}`);
+			}
+			currentIndent++;
+		} else if (line.type === "block-close") {
+			currentIndent--;
+			if (line.content) {
+				const indent = "  ".repeat(currentIndent);
+				parts.push(`${indent}${line.content}`);
+			}
+		} else if (line.content === "") parts.push("");
+		else {
+			const indent = "  ".repeat(currentIndent);
+			parts.push(`${indent}${line.content}`);
+		}
+		return {
+			text: parts.join("\n"),
+			imports: new Map([...this.imports].map(([source, entry]) => [source, {
+				specifiers: new Set(entry.specifiers),
+				typeOnly: entry.typeOnly
+			}]))
+		};
+	}
+};
+/**
+* Create a new CodeBuilder for constructing TypeScript source files.
+*/
+function createCodeBuilder() {
+	return new CodeBuilderImpl();
+}
+//#endregion
+//#region src/codegen/parsers/fish.ts
+/**
+* Parse fish shell completion scripts into CommandMeta.
+*
+* Fish completions use the `complete` builtin:
+*   complete -c <command> -s <short> -l <long> -d <description> -a <arguments> -r -f
+*/
+function parseFishCompletions(text) {
+	const lines = text.split("\n");
+	const result = {
+		name: "",
+		arguments: [],
+		subcommands: []
+	};
+	const subcommandMap = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		if (!trimmed.match(/^complete\s+/)) continue;
+		const parts = parseCompleteLine(trimmed);
+		if (!parts) continue;
+		if (!result.name && parts.command) result.name = parts.command;
+		const subcommandCondition = parts.condition?.match(/__fish_seen_subcommand_from\s+(\S+)/);
+		if (subcommandCondition) {
+			const subName = subcommandCondition[1];
+			let sub = subcommandMap.get(subName);
+			if (!sub) {
+				sub = {
+					name: subName,
+					arguments: []
+				};
+				subcommandMap.set(subName, sub);
+			}
+			if (parts.longFlag || parts.shortFlag) {
+				const field = completionToField(parts);
+				if (field) sub.arguments.push(field);
+			}
+			continue;
+		}
+		if (parts.arguments && !parts.longFlag && !parts.shortFlag) {
+			const names = parts.arguments.split(/\s+/);
+			for (const name of names) {
+				if (!name || name.startsWith("(")) continue;
+				if (!subcommandMap.has(name)) subcommandMap.set(name, {
+					name,
+					description: parts.description,
+					arguments: []
+				});
+				else if (parts.description) subcommandMap.get(name).description = parts.description;
+			}
+			continue;
+		}
+		if (parts.longFlag || parts.shortFlag) {
+			const field = completionToField(parts);
+			if (field) result.arguments.push(field);
+		}
+	}
+	for (const sub of subcommandMap.values()) {
+		if (sub.arguments.length === 0) delete sub.arguments;
+		result.subcommands.push(sub);
+	}
+	if (result.arguments.length === 0) delete result.arguments;
+	if (result.subcommands.length === 0) delete result.subcommands;
+	return result;
+}
+function parseCompleteLine(line) {
+	const parts = {};
+	const cmdMatch = line.match(/-c\s+(\S+)/);
+	if (cmdMatch) parts.command = cmdMatch[1];
+	const shortMatch = line.match(/-s\s+(\S+)/);
+	if (shortMatch) parts.shortFlag = shortMatch[1];
+	const longMatch = line.match(/-l\s+(\S+)/);
+	if (longMatch) parts.longFlag = longMatch[1];
+	const descMatch = line.match(/-d\s+['"]([^'"]+)['"]/) || line.match(/-d\s+(\S+)/);
+	if (descMatch) parts.description = descMatch[1];
+	const argsMatch = line.match(/-a\s+['"]([^'"]+)['"]/) || line.match(/-a\s+(\S+)/);
+	if (argsMatch) parts.arguments = argsMatch[1];
+	const condMatch = line.match(/-n\s+['"]([^'"]+)['"]/) || line.match(/-n\s+(\S+)/);
+	if (condMatch) parts.condition = condMatch[1];
+	parts.requiresArg = /-r\b/.test(line);
+	parts.noFiles = /-f\b/.test(line);
+	return parts;
+}
+function completionToField(parts) {
+	const name = parts.longFlag ? parts.longFlag.replace(/-([a-z])/g, (_, c) => c.toUpperCase()) : parts.shortFlag || "";
+	if (!name) return null;
+	let type = parts.requiresArg ? "string" : "boolean";
+	let enumValues;
+	if (parts.arguments) {
+		const values = parts.arguments.split(/\s+/).filter((v) => !v.startsWith("("));
+		if (values.length > 0 && values.length <= 20) {
+			enumValues = values;
+			type = "enum";
+		}
+	}
+	const aliases = parts.shortFlag && parts.longFlag ? [`-${parts.shortFlag}`] : void 0;
+	return {
+		name,
+		type,
+		description: parts.description,
+		aliases,
+		enumValues
+	};
+}
+//#endregion
+//#region src/codegen/parsers/help.ts
+/**
+* Parse --help text output into CommandMeta.
+* Handles common styles: GNU coreutils, Go cobra, Python argparse, Node commander/yargs, gh CLI.
+*/
+function parseHelpOutput(text, options) {
+	const lines = text.split("\n");
+	const result = {
+		name: options?.name || "",
+		arguments: [],
+		positionals: [],
+		subcommands: []
+	};
+	let section = "none";
+	const usageMatch = text.match(/^[Uu](?:SAGE|sage):?\s*(\S+)/m) || text.match(/^USAGE\n\s+(\S+)/m);
+	if (usageMatch && !result.name) result.name = usageMatch[1];
+	const descriptionLines = [];
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) {
+			if (descriptionLines.length > 0) break;
+			continue;
+		}
+		if (isSectionHeader(trimmed)) break;
+		if (descriptionLines.length === 0 || descriptionLines.length > 0) descriptionLines.push(trimmed);
+	}
+	if (descriptionLines.length > 0) result.description = descriptionLines.join(" ");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const sectionType = detectSection(trimmed);
+		if (sectionType) {
+			section = sectionType;
+			continue;
+		}
+		switch (section) {
+			case "commands": {
+				const cmd = parseCommandLine(line);
+				if (cmd) result.subcommands.push(cmd);
+				break;
+			}
+			case "options": {
+				const field = parseOptionLine(line);
+				if (field) result.arguments.push(field);
+				break;
+			}
+			case "arguments":
+			case "positional": {
+				const field = parsePositionalLine(line);
+				if (field) result.positionals.push(field);
+				break;
+			}
+			case "aliases":
+				if (trimmed.match(/^\S+(?:\s+\S+)*$/)) {
+					const parts = trimmed.split(/\s+/);
+					if (parts.length >= 2) {
+						const alias = parts[parts.length - 1];
+						if (!result.aliases) result.aliases = [];
+						result.aliases.push(alias);
+					}
+				}
+				break;
+		}
+	}
+	if (result.arguments.length === 0) delete result.arguments;
+	if (result.positionals.length === 0) delete result.positionals;
+	if (result.subcommands.length === 0) delete result.subcommands;
+	if (result.aliases?.length === 0) delete result.aliases;
+	return result;
+}
+function isSectionHeader(line) {
+	return /^[A-Z][A-Za-z\s]*:?\s*$/i.test(line) || /^[A-Z][A-Z\s]+$/i.test(line);
+}
+function detectSection(line) {
+	const lower = line.toLowerCase().replace(/:$/, "").trim();
+	if (/^(?:available\s+)?(?:commands|subcommands)$/.test(lower)) return "commands";
+	if (/^(?:\w+\s+)*commands$/.test(lower) && !/alias/.test(lower)) return "commands";
+	if (/^(?:global\s+|inherited\s+)?(?:options|flags)$/.test(lower)) return "options";
+	if (/^(?:positional\s+)?(?:arguments|args|positionals)$/.test(lower)) return "positional";
+	if (/^alias(?:es)?(?:\s+commands)?$/.test(lower)) return "aliases";
+	if (lower === "usage") return "usage";
+	if (/^(?:help\s+topics|examples?|learn\s+more|json\s+fields|see\s+also|notes?)$/.test(lower)) return "skip";
+	return null;
+}
+function parseCommandLine(line) {
+	const colonMatch = line.match(/^\s{2,}([\w][\w-]*):?\s{2,}(.+)$/);
+	if (colonMatch) return {
+		name: colonMatch[1].replace(/:$/, ""),
+		description: colonMatch[2].trim()
+	};
+	const nameOnly = line.match(/^\s{2,}([\w][\w-]*):?\s*$/);
+	if (nameOnly) return { name: nameOnly[1].replace(/:$/, "") };
+	return null;
+}
+function parseOptionLine(line) {
+	const cobraMatch = line.match(/^\s{2,}(?:(-\w),\s+)?(-{1,2}[\w-]+)(?:\s+([^\s<>]+))?\s{2,}(.+)$/);
+	if (cobraMatch) {
+		const shortFlag = cobraMatch[1];
+		const longFlag = cobraMatch[2];
+		const typeHint = cobraMatch[3];
+		const description = cobraMatch[4]?.trim();
+		const name = normalizeOptionName(longFlag);
+		const aliases = shortFlag ? [normalizeAlias(shortFlag)] : void 0;
+		const { type, ambiguous } = resolveType(typeHint);
+		const { defaultValue, resolvedType } = extractDefault(description, type, ambiguous);
+		const { enumValues, resolvedType: finalType } = extractEnum(description, resolvedType);
+		return reconcileField({
+			name,
+			type: finalType,
+			description,
+			required: type === "boolean" ? void 0 : true,
+			aliases,
+			default: defaultValue,
+			enumValues,
+			ambiguous: ambiguous || void 0
+		});
+	}
+	const gnuMatch = line.match(/^\s{2,}(?:(-\w),?\s+)?(-{1,2}[\w-]+)(?:\s*[=\s]\s*(?:<([^>]+)>|\[([^\]]+)\]|(\w+)))?\s{2,}(.+)$/);
+	if (gnuMatch) {
+		const shortFlag = gnuMatch[1];
+		const longFlag = gnuMatch[2];
+		const valueName = gnuMatch[3] || gnuMatch[4] || gnuMatch[5];
+		const description = gnuMatch[6]?.trim();
+		const name = normalizeOptionName(longFlag);
+		const aliases = shortFlag ? [normalizeAlias(shortFlag)] : void 0;
+		const { type, ambiguous } = resolveType(valueName);
+		const { defaultValue, resolvedType } = extractDefault(description, type, ambiguous);
+		const { enumValues, resolvedType: finalType } = extractEnum(description, resolvedType);
+		const required = !gnuMatch[4];
+		return reconcileField({
+			name,
+			type: finalType,
+			description,
+			required: finalType === "boolean" ? void 0 : required,
+			aliases,
+			default: defaultValue,
+			enumValues,
+			ambiguous: ambiguous || void 0
+		});
+	}
+	const simple = line.match(/^\s{2,}(-{1,2}[\w-]+)\s{2,}(.+)$/);
+	if (simple) return {
+		name: normalizeOptionName(simple[1]),
+		type: "boolean",
+		description: simple[2].trim()
+	};
+	return null;
+}
+/**
+* Resolve a type hint string to a FieldMeta type.
+*/
+function resolveType(hint) {
+	if (!hint) return {
+		type: "boolean",
+		ambiguous: false
+	};
+	const lower = hint.toLowerCase();
+	if (/^(num|number|int|integer|port|count|float|duration)$/.test(lower)) return {
+		type: "number",
+		ambiguous: false
+	};
+	if (/^(str|string|text|name|path|file|dir|url|host|query|expression|template)$/.test(lower)) return {
+		type: "string",
+		ambiguous: false
+	};
+	if (/^(bool|boolean)$/.test(lower)) return {
+		type: "boolean",
+		ambiguous: false
+	};
+	if (/^(strings|fields)$/.test(lower)) return {
+		type: "array",
+		ambiguous: false
+	};
+	return {
+		type: "string",
+		ambiguous: true
+	};
+}
+/**
+* Extract default value from description text.
+*/
+function extractDefault(description, type, ambiguous) {
+	let resolvedType = type;
+	let defaultValue;
+	const defaultMatch = description?.match(/\(default[:\s]+([^)]+)\)/i) || description?.match(/\[default[:\s]+([^\]]+)\]/i);
+	if (defaultMatch) {
+		const raw = defaultMatch[1].trim();
+		if (raw === "true" || raw === "false") {
+			defaultValue = raw === "true";
+			resolvedType = "boolean";
+		} else if (/^\d+$/.test(raw)) {
+			defaultValue = parseInt(raw, 10);
+			if (resolvedType === "string" && !ambiguous) resolvedType = "number";
+		} else if (/^\d+\.\d+$/.test(raw)) {
+			defaultValue = parseFloat(raw);
+			if (resolvedType === "string" && !ambiguous) resolvedType = "number";
+		} else defaultValue = raw.replace(/^["']|["']$/g, "");
+	}
+	return {
+		defaultValue,
+		resolvedType
+	};
+}
+/**
+* Extract enum values from description text.
+*/
+function extractEnum(description, type) {
+	const choiceMatch = description?.match(/\((?:one of|choices?)[:\s]+([^)]+)\)/i);
+	if (choiceMatch) return {
+		enumValues: choiceMatch[1].split(/[,|]/).map((v) => v.trim().replace(/^["']|["']$/g, "")),
+		resolvedType: "enum"
+	};
+	const inlineMatch = description?.match(/\{(\w+(?:\|[\w-]+)+)\}/);
+	if (inlineMatch) return {
+		enumValues: inlineMatch[1].split("|"),
+		resolvedType: "enum"
+	};
+	return {
+		enumValues: void 0,
+		resolvedType: type
+	};
+}
+/**
+* Fix up a parsed field for edge cases:
+* - Enum default not in the listed values → add it
+* - Default value type doesn't match declared type → reset to type default + mark ambiguous
+*/
+function reconcileField(field) {
+	if (field.type === "enum" && field.enumValues && field.default !== void 0) {
+		const defStr = String(field.default);
+		if (!field.enumValues.includes(defStr)) field.enumValues = [...field.enumValues, defStr];
+	}
+	if (field.default !== void 0) {
+		if (field.type === "boolean" && typeof field.default !== "boolean") {
+			field.default = false;
+			field.ambiguous = true;
+		} else if (field.type === "number" && typeof field.default !== "number") {
+			field.default = 0;
+			field.ambiguous = true;
+		}
+	}
+	return field;
+}
+function parsePositionalLine(line) {
+	const match = line.match(/^\s{2,}<?(\w[\w-]*)>?\s{2,}(.+)$/);
+	if (!match) return null;
+	return {
+		name: match[1],
+		type: "string",
+		description: match[2].trim(),
+		positional: true,
+		ambiguous: true
+	};
+}
+/**
+* Strip leading dashes from a flag name, preserving kebab-case.
+*/
+function normalizeOptionName(flag) {
+	return flag.replace(/^-+/, "");
+}
+/**
+* Strip leading dash from a short alias flag (e.g. '-v' → 'v').
+*/
+function normalizeAlias(alias) {
+	return alias.replace(/^-/, "");
+}
+//#endregion
+//#region src/codegen/parsers/merge.ts
+/**
+* Deep-merge multiple CommandMeta from different sources.
+* Deduplicates fields, resolves conflicts, and combines subcommands.
+*
+* Later sources take precedence for descriptions and types,
+* unless the earlier source was more specific (non-ambiguous).
+*/
+function mergeCommandMeta(...sources) {
+	if (sources.length === 0) return { name: "" };
+	if (sources.length === 1) return sources[0];
+	const result = { name: "" };
+	for (const source of sources) {
+		if (source.name && !result.name) result.name = source.name;
+		if (source.description) result.description = source.description;
+		if (source.aliases) result.aliases = [...new Set([...result.aliases || [], ...source.aliases])];
+		if (source.examples) result.examples = [...new Set([...result.examples || [], ...source.examples])];
+		if (source.deprecated !== void 0) result.deprecated = source.deprecated;
+		if (source.arguments) result.arguments = mergeFields(result.arguments || [], source.arguments);
+		if (source.positionals) result.positionals = mergeFields(result.positionals || [], source.positionals);
+		if (source.subcommands) result.subcommands = mergeSubcommands(result.subcommands || [], source.subcommands);
+	}
+	if (result.aliases?.length === 0) delete result.aliases;
+	if (result.examples?.length === 0) delete result.examples;
+	if (result.arguments?.length === 0) delete result.arguments;
+	if (result.positionals?.length === 0) delete result.positionals;
+	if (result.subcommands?.length === 0) delete result.subcommands;
+	return result;
+}
+/**
+* Merge two arrays of FieldMeta by name.
+* Later fields take precedence unless earlier was non-ambiguous.
+*/
+function mergeFields(existing, incoming) {
+	const map = /* @__PURE__ */ new Map();
+	for (const field of existing) map.set(field.name, { ...field });
+	for (const field of incoming) {
+		const prev = map.get(field.name);
+		if (!prev) {
+			map.set(field.name, { ...field });
+			continue;
+		}
+		const merged = { ...prev };
+		if (field.type !== "unknown") {
+			if (prev.ambiguous || !field.ambiguous) {
+				merged.type = field.type;
+				merged.ambiguous = field.ambiguous;
+			}
+		}
+		if (field.description) merged.description = field.description;
+		if (field.default !== void 0) merged.default = field.default;
+		if (field.required !== void 0) merged.required = field.required;
+		if (field.aliases) merged.aliases = [...new Set([...prev.aliases || [], ...field.aliases])];
+		if (field.enumValues) merged.enumValues = [...new Set([...prev.enumValues || [], ...field.enumValues])];
+		if (field.items) merged.items = field.items;
+		map.set(field.name, merged);
+	}
+	return [...map.values()];
+}
+/**
+* Merge two arrays of CommandMeta by name, recursively.
+*/
+function mergeSubcommands(existing, incoming) {
+	const map = /* @__PURE__ */ new Map();
+	for (const cmd of existing) map.set(cmd.name, cmd);
+	for (const cmd of incoming) {
+		const prev = map.get(cmd.name);
+		if (!prev) map.set(cmd.name, cmd);
+		else map.set(cmd.name, mergeCommandMeta(prev, cmd));
+	}
+	return [...map.values()];
+}
+//#endregion
+//#region src/codegen/parsers/zsh.ts
+/**
+* Parse zsh completion function definitions into CommandMeta.
+*
+* Zsh completions typically use _arguments or compadd:
+*   _arguments \
+*     '-v[verbose mode]' \
+*     '--output=[output file]:filename:_files' \
+*     '1:command:(start stop restart)'
+*/
+function parseZshCompletions(text) {
+	const result = {
+		name: "",
+		arguments: [],
+		positionals: [],
+		subcommands: []
+	};
+	const compdefMatch = text.match(/#compdef\s+(\S+)/);
+	if (compdefMatch) result.name = compdefMatch[1];
+	else {
+		const funcMatch = text.match(/^_(\w+)\s*\(\)/m);
+		if (funcMatch) result.name = funcMatch[1];
+	}
+	const argumentsBlocks = findArgumentsBlocks(text);
+	for (const block of argumentsBlocks) {
+		const specs = parseArgumentSpecs(block);
+		for (const spec of specs) if (spec.positional) result.positionals.push(spec);
+		else result.arguments.push(spec);
+	}
+	const subcommands = findSubcommands(text);
+	result.subcommands.push(...subcommands);
+	if (result.arguments.length === 0) delete result.arguments;
+	if (result.positionals.length === 0) delete result.positionals;
+	if (result.subcommands.length === 0) delete result.subcommands;
+	return result;
+}
+/**
+* Extract _arguments blocks from zsh completion text.
+* Handles backslash continuation lines.
+*/
+function findArgumentsBlocks(text) {
+	const blocks = [];
+	const lines = text.replace(/\\\n\s*/g, " ").split("\n");
+	for (const line of lines) {
+		const match = line.match(/_arguments\s+(.+)/);
+		if (match) blocks.push(match[1]);
+	}
+	return blocks;
+}
+/**
+* Parse individual argument specs from an _arguments line.
+*/
+function parseArgumentSpecs(block) {
+	const results = [];
+	const specs = extractQuotedStrings(block);
+	for (const spec of specs) {
+		const field = parseZshSpec(spec);
+		if (field) results.push(field);
+	}
+	return results;
+}
+/**
+* Extract single-quoted strings from an _arguments block.
+*/
+function extractQuotedStrings(text) {
+	const strings = [];
+	const regex = /'([^']+)'/g;
+	let match;
+	while ((match = regex.exec(text)) !== null) strings.push(match[1]);
+	return strings;
+}
+/**
+* Parse a single zsh argument spec.
+*
+* Formats:
+*   '-v[verbose mode]'                              → boolean flag
+*   '--output=[output file]:filename:_files'         → string with value
+*   '(-v --verbose)'{-v,--verbose}'[verbose mode]'   → flag with aliases
+*   '*--flag[repeatable]'                            → array
+*   '1:command:(start stop restart)'                 → positional enum
+*   ':filename:_files'                               → positional
+*/
+function parseZshSpec(spec) {
+	const positionalMatch = spec.match(/^(\d+)?:([^:]*):(.*)$/);
+	if (positionalMatch) {
+		const description = positionalMatch[2] || void 0;
+		const enumMatch = positionalMatch[3]?.match(/^\(([^)]+)\)$/);
+		if (enumMatch) {
+			const values = enumMatch[1].split(/\s+/);
+			return {
+				name: description?.toLowerCase().replace(/\s+/g, "_") || `arg${positionalMatch[1] || "0"}`,
+				type: "enum",
+				enumValues: values,
+				description,
+				positional: true
+			};
+		}
+		return {
+			name: description?.toLowerCase().replace(/\s+/g, "_") || `arg${positionalMatch[1] || "0"}`,
+			type: "string",
+			description,
+			positional: true,
+			ambiguous: true
+		};
+	}
+	const repeatable = spec.startsWith("*");
+	const flagMatch = (repeatable ? spec.slice(1) : spec).match(/^(-{1,2}[\w-]+)(?:=?)(?:\[([^\]]*)\])?(?::([^:]*):?(.*))?$/);
+	if (!flagMatch) return null;
+	const rawName = flagMatch[1];
+	const description = flagMatch[2] || void 0;
+	const valueName = flagMatch[3] || void 0;
+	const name = rawName.replace(/^-+/, "").replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+	let type = rawName.includes("=") || !!valueName ? "string" : "boolean";
+	if (repeatable) type = "array";
+	let enumValues;
+	if (flagMatch[4]) {
+		const enumMatch = flagMatch[4].match(/^\(([^)]+)\)$/);
+		if (enumMatch) {
+			enumValues = enumMatch[1].split(/\s+/);
+			type = "enum";
+		}
+	}
+	return {
+		name,
+		type,
+		description,
+		enumValues
+	};
+}
+/**
+* Find subcommand definitions from _describe calls or case statements.
+*/
+function findSubcommands(text) {
+	const subcommands = [];
+	const seen = /* @__PURE__ */ new Set();
+	const describeRegex = /\(([^)]+)\)/g;
+	const joined = text.replace(/\\\n\s*/g, " ");
+	let match;
+	while ((match = describeRegex.exec(joined)) !== null) {
+		const content = match[1];
+		const entries = content.match(/'([^']+)'/g) || content.match(/"([^"]+)"/g);
+		if (!entries) continue;
+		for (const entry of entries) {
+			const parts = entry.replace(/^['"]|['"]$/g, "").split(":");
+			if (parts.length >= 2 && /^[\w-]+$/.test(parts[0])) {
+				const name = parts[0];
+				if (seen.has(name)) continue;
+				seen.add(name);
+				subcommands.push({
+					name,
+					description: parts.slice(1).join(":")
+				});
+			}
+		}
+	}
+	return subcommands;
+}
+//#endregion
+//#region src/codegen/discovery.ts
+/**
+* Discover CLI structure by running --help recursively and optionally
+* parsing shell completion scripts.
+*/
+async function discoverCli(options) {
+	const { command, sources = ["help"], depth, delay = 50, log, timeout = 1e4 } = options;
+	const warnings = [];
+	let invocations = 0;
+	const results = [];
+	if (sources.includes("help")) {
+		log?.info(`Discovering ${command} via --help...`);
+		const helpResult = await crawlHelp(command, [], {
+			depth,
+			delay,
+			timeout,
+			log,
+			onInvocation: () => {
+				invocations++;
+			},
+			onWarning: (msg) => {
+				warnings.push(msg);
+			}
+		});
+		results.push(helpResult);
+	}
+	if (sources.includes("fish")) {
+		log?.info(`Parsing fish completions for ${command}...`);
+		const fishText = await getCompletionScript(command, "fish", timeout);
+		if (fishText) results.push(parseFishCompletions(fishText));
+		else warnings.push("Could not obtain fish completion script");
+	}
+	if (sources.includes("zsh")) {
+		log?.info(`Parsing zsh completions for ${command}...`);
+		const zshText = await getCompletionScript(command, "zsh", timeout);
+		if (zshText) results.push(parseZshCompletions(zshText));
+		else warnings.push("Could not obtain zsh completion script");
+	}
+	const merged = results.length > 0 ? mergeCommandMeta(...results) : { name: command };
+	if (!merged.name) merged.name = command;
+	return {
+		command: merged,
+		invocations,
+		warnings
+	};
+}
+/**
+* Breadth-first crawl of --help output.
+*/
+async function crawlHelp(command, prefixArgs, options) {
+	const fullCmd = [command, ...prefixArgs].join(" ");
+	options.onInvocation();
+	const helpText = await runHelp(command, prefixArgs, options.timeout);
+	if (!helpText) {
+		options.onWarning(`No help output from: ${fullCmd} --help`);
+		return { name: prefixArgs[prefixArgs.length - 1] || command };
+	}
+	const parsed = parseHelpOutput(helpText, { name: prefixArgs[prefixArgs.length - 1] || command });
+	options.log?.info(`  ${fullCmd}: ${parsed.subcommands?.length || 0} subcommands, ${parsed.arguments?.length || 0} options`);
+	const currentDepth = prefixArgs.length;
+	if (parsed.subcommands && parsed.subcommands.length > 0 && (options.depth === void 0 || currentDepth < options.depth)) {
+		const resolvedSubs = [];
+		for (const sub of parsed.subcommands) {
+			if (options.delay > 0) await sleep(options.delay);
+			const resolved = await crawlHelp(command, [...prefixArgs, sub.name], options);
+			if (!resolved.description && sub.description) resolved.description = sub.description;
+			resolvedSubs.push(resolved);
+		}
+		parsed.subcommands = resolvedSubs;
+	}
+	return parsed;
+}
+/**
+* Run `<cmd> --help` or `<cmd> help` and return combined stdout+stderr.
+*/
+async function runHelp(command, args, timeout) {
+	let result = await runCommand(command, [...args, "--help"], timeout);
+	if (result) return result;
+	if (args.length > 0) {
+		result = await runCommand(command, ["help", ...args], timeout);
+		if (result) return result;
+	}
+	return null;
+}
+/**
+* Run a command and return its combined output, or null on failure.
+*/
+async function runCommand(command, args, timeout) {
+	try {
+		const proc = Bun.spawn([command, ...args], {
+			stdout: "pipe",
+			stderr: "pipe",
+			stdin: "ignore"
+		});
+		const timer = setTimeout(() => proc.kill(), timeout);
+		const [_exitCode, stdoutBuf, stderrBuf] = await Promise.all([
+			proc.exited,
+			new Response(proc.stdout).arrayBuffer(),
+			new Response(proc.stderr).arrayBuffer()
+		]);
+		clearTimeout(timer);
+		const stdout = new TextDecoder().decode(stdoutBuf).trim();
+		const stderr = new TextDecoder().decode(stderrBuf).trim();
+		const combined = stdout || stderr;
+		if (!combined) return null;
+		if (combined.length < 10) return null;
+		return combined;
+	} catch {
+		return null;
+	}
+}
+/**
+* Try to get a shell completion script for a command.
+* Checks both `<cmd> completion <shell>` and well-known file paths.
+*/
+async function getCompletionScript(command, shell, timeout) {
+	let result = await runCommand(command, ["completion", shell], timeout);
+	if (result) return result;
+	result = await runCommand(command, ["completions", shell], timeout);
+	if (result) return result;
+	const paths = shell === "fish" ? [`/usr/share/fish/vendor_completions.d/${command}.fish`, `/usr/local/share/fish/vendor_completions.d/${command}.fish`] : [`/usr/share/zsh/site-functions/_${command}`, `/usr/local/share/zsh/site-functions/_${command}`];
+	for (const path of paths) try {
+		const file = Bun.file(path);
+		if (await file.exists()) return await file.text();
+	} catch {}
+	return null;
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//#endregion
+//#region src/codegen/file-emitter.ts
+var FileEmitterImpl = class {
+	files = [];
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	addFile(path, content) {
+		const text = typeof content === "string" ? content : content.text;
+		const fullContent = this.options.header ? `${this.options.header}\n\n${text}` : text;
+		this.files.push({
+			path,
+			content: fullContent
+		});
+	}
+	async emit() {
+		const result = {
+			written: [],
+			skipped: [],
+			errors: []
+		};
+		const outDir = resolve(this.options.outDir);
+		for (const file of this.files) {
+			const fullPath = join(outDir, file.path);
+			try {
+				if (existsSync(fullPath) && !this.options.overwrite) {
+					result.skipped.push(file.path);
+					continue;
+				}
+				if (this.options.dryRun) {
+					result.written.push(file.path);
+					continue;
+				}
+				mkdirSync(dirname(fullPath), { recursive: true });
+				writeFileSync(fullPath, file.content, "utf-8");
+				result.written.push(file.path);
+			} catch (err) {
+				result.errors.push({
+					file: file.path,
+					error: err instanceof Error ? err : new Error(String(err))
+				});
+			}
+		}
+		return result;
+	}
+};
+/**
+* Create a FileEmitter for writing multiple generated files to disk.
+*/
+function createFileEmitter(options) {
+	return new FileEmitterImpl(options);
+}
+//#endregion
+//#region src/codegen/generators/barrel-file.ts
+/**
+* Generate an index.ts barrel file that re-exports all given files.
+*/
+function generateBarrelFile(files, ctx) {
+	const code = ctx.createCodeBuilder();
+	for (const file of files) {
+		const importPath = file.startsWith("./") ? file : `./${file}`;
+		code.line(`export * from '${importPath}'`);
+	}
+	return code;
+}
+//#endregion
+//#region src/codegen/schema-to-code.ts
+/**
+* Convert a JSON Schema property to Zod code.
+*/
+function jsonSchemaPropertyToZod(prop, required, ambiguous) {
+	let code;
+	const type = prop.type;
+	const enumValues = prop.enum;
+	if (enumValues && enumValues.length > 0) code = `z.enum([${enumValues.map((v) => JSON.stringify(v)).join(", ")}])`;
+	else if (type === "string") code = "z.string()";
+	else if (type === "number" || type === "integer") code = "z.number()";
+	else if (type === "boolean") code = "z.boolean()";
+	else if (type === "array") {
+		const items = prop.items;
+		code = `${items ? jsonSchemaPropertyToZod(items, true) : "z.unknown()"}.array()`;
+	} else code = "z.unknown()";
+	if (prop.default !== void 0) code += `.default(${JSON.stringify(prop.default)})`;
+	else if (!required) code += ".optional()";
+	if (prop.description) code += `.describe(${JSON.stringify(prop.description)})`;
+	if (ambiguous) code += " /* TODO: verify type */";
+	return code;
+}
+/**
+* Generate Zod source code from a Standard Schema instance by introspecting
+* its `~standard.jsonSchema` interface.
+*/
+function schemaToCode(schema) {
+	try {
+		return jsonSchemaToCode(schema["~standard"].jsonSchema.input({ target: "draft-2020-12" }));
+	} catch {
+		return {
+			code: "z.unknown()",
+			imports: ["z"]
+		};
+	}
+}
+function jsonSchemaToCode(jsonSchema) {
+	if (jsonSchema.type === "object" && jsonSchema.properties) {
+		const properties = jsonSchema.properties;
+		const required = new Set(jsonSchema.required || []);
+		return {
+			code: `z.object({\n${Object.entries(properties).map(([key, prop]) => {
+				return `  ${key}: ${jsonSchemaPropertyToZod(prop, required.has(key))},`;
+			}).join("\n")}\n})`,
+			imports: ["z"]
+		};
+	}
+	return {
+		code: jsonSchemaPropertyToZod(jsonSchema, true),
+		imports: ["z"]
+	};
+}
+/**
+* Build a real Zod schema from FieldMeta objects.
+* Returns the schema as Zod source code, since we can't dynamically import Zod here
+* (codegen has no runtime dependency on padrone's main entry point).
+*/
+function fieldMetaToCode(fields) {
+	return {
+		code: `z.object({\n${fields.map((field) => {
+			let code;
+			switch (field.type) {
+				case "string":
+					code = "z.string()";
+					break;
+				case "number":
+					code = "z.number()";
+					break;
+				case "boolean":
+					code = "z.boolean()";
+					break;
+				case "array":
+					code = `${(field.items || "string") === "number" ? "z.number()" : "z.string()"}.array()`;
+					break;
+				case "enum":
+					if (field.enumValues && field.enumValues.length > 0) code = `z.enum([${field.enumValues.map((v) => JSON.stringify(v)).join(", ")}])`;
+					else code = "z.string()";
+					break;
+				default:
+					code = "z.unknown()";
+					break;
+			}
+			if (field.default !== void 0) code += `.default(${JSON.stringify(field.default)})`;
+			else if (!field.required) code += ".optional()";
+			if (field.description) code += `.describe(${JSON.stringify(field.description)})`;
+			if (field.ambiguous) code += " /* TODO: verify type */";
+			return `  ${needsQuoting(field.name) ? JSON.stringify(field.name) : field.name}: ${code},`;
+		}).join("\n")}\n})`,
+		imports: ["z"]
+	};
+}
+const JS_RESERVED$1 = new Set([
+	"break",
+	"case",
+	"catch",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"export",
+	"extends",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield",
+	"class",
+	"const",
+	"enum",
+	"let",
+	"static",
+	"implements",
+	"interface",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"await",
+	"async"
+]);
+/** Returns true if the name needs quoting to be a valid JS object key. */
+function needsQuoting(name) {
+	if (JS_RESERVED$1.has(name)) return true;
+	return !/^[a-zA-Z_$][\w$]*$/.test(name);
+}
+//#endregion
+//#region src/codegen/generators/command-file.ts
+const JS_RESERVED = new Set([
+	"break",
+	"case",
+	"catch",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"export",
+	"extends",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield",
+	"class",
+	"const",
+	"enum",
+	"let",
+	"static",
+	"implements",
+	"interface",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"await",
+	"async"
+]);
+/** Convert a command name to a safe JS identifier (camelCase, reserved-word-safe). */
+function toSafeIdentifier(name) {
+	const camel = name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+	if (/^\d/.test(camel)) return `_${camel}`;
+	if (JS_RESERVED.has(camel)) return `_${camel}`;
+	return camel;
+}
+/** Build the exported function name for a command (e.g. 'repo' → 'repoCommand'). */
+function toCommandFunctionName(name) {
+	return `${toSafeIdentifier(name)}Command`;
+}
+/**
+* Generate a single Padrone command file from a CommandMeta.
+* Produces a named function that chains .configure(), .arguments(), and .wrap() or .action().
+*/
+function generateCommandFile(command, ctx, options) {
+	const code = ctx.createCodeBuilder();
+	const hasArgs = command.arguments && command.arguments.length > 0 || command.positionals && command.positionals.length > 0;
+	if (hasArgs) code.import("z", "zod/v4");
+	code.importType("AnyPadroneBuilder", "padrone");
+	if (options?.subcommands) for (const sub of options.subcommands) code.import([sub.varName], sub.importPath);
+	code.line();
+	if (command.deprecated) {
+		const msg = typeof command.deprecated === "string" ? command.deprecated : "This command is deprecated";
+		code.comment(`@deprecated ${msg}`);
+	}
+	const fnName = toCommandFunctionName(command.name);
+	code.line(`export function ${fnName}<T extends AnyPadroneBuilder>(cmd: T) {`);
+	code.line(`  return cmd`);
+	const configParts = [];
+	if (command.description) configParts.push(`description: ${JSON.stringify(command.description)}`);
+	if (command.deprecated) configParts.push(`deprecated: ${typeof command.deprecated === "string" ? JSON.stringify(command.deprecated) : "true"}`);
+	if (configParts.length > 0) code.line(`    .configure({ ${configParts.join(", ")} })`);
+	if (hasArgs) {
+		const allFields = [...command.arguments || [], ...command.positionals || []];
+		const schemaCode = fieldMetaToCode(allFields);
+		const positionalNames = (command.positionals || []).map((p) => p.type === "array" ? `'...${p.name}'` : `'${p.name}'`);
+		const fieldsMap = buildFieldsMap(allFields);
+		if (positionalNames.length > 0 || fieldsMap) {
+			code.line(`    .arguments(${schemaCode.code}, {`);
+			if (positionalNames.length > 0) code.line(`      positional: [${positionalNames.join(", ")}],`);
+			if (fieldsMap) code.line(`      fields: ${fieldsMap},`);
+			code.line(`    })`);
+		} else code.line(`    .arguments(${schemaCode.code})`);
+	}
+	if (options?.subcommands) for (const sub of options.subcommands) {
+		const nameArg = sub.aliases && sub.aliases.length > 0 ? `[${JSON.stringify(sub.name)}, ${sub.aliases.map((a) => JSON.stringify(a)).join(", ")}]` : JSON.stringify(sub.name);
+		code.line(`    .command(${nameArg}, ${sub.varName})`);
+	}
+	if (options?.wrap) {
+		const wrapParts = [];
+		wrapParts.push(`command: ${JSON.stringify(options.wrap.command)}`);
+		if (options.wrap.args && options.wrap.args.length > 0) wrapParts.push(`args: [${options.wrap.args.map((a) => JSON.stringify(a)).join(", ")}]`);
+		code.line(`    .wrap({ ${wrapParts.join(", ")} })`);
+	} else code.line(`    .action((args) => { /* TODO */ })`);
+	code.line(`}`);
+	return code;
+}
+function buildFieldsMap(fields) {
+	const entries = [];
+	for (const field of fields) if (field.aliases && field.aliases.length > 0) {
+		const alias = field.aliases.length === 1 ? JSON.stringify(field.aliases[0]) : `[${field.aliases.map((a) => JSON.stringify(a)).join(", ")}]`;
+		const key = /^[a-zA-Z_$][\w$]*$/.test(field.name) ? field.name : JSON.stringify(field.name);
+		entries.push(`${key}: { alias: ${alias} }`);
+	}
+	if (entries.length === 0) return null;
+	return `{ ${entries.join(", ")} }`;
+}
+//#endregion
+//#region src/codegen/generators/command-tree.ts
+/**
+* Walk a CommandMeta tree and emit one file per command plus a root program file.
+* Maps nested subcommands to a directory structure.
+*/
+function generateCommandTree(root, ctx, options) {
+	const rootImports = [];
+	function walkCommands(cmd, dirPath, parentArgs) {
+		if (cmd === root) {
+			for (const sub of cmd.subcommands || []) walkCommands(sub, "commands", []);
+			return;
+		}
+		const filePath = `${dirPath}/${cmd.name}.ts`;
+		const childRefs = [];
+		if (cmd.subcommands && cmd.subcommands.length > 0) for (const sub of cmd.subcommands) {
+			walkCommands(sub, `${dirPath}/${cmd.name}`, [...parentArgs, cmd.name]);
+			childRefs.push({
+				name: sub.name,
+				varName: toCommandFunctionName(sub.name),
+				importPath: `./${cmd.name}/${sub.name}.ts`,
+				aliases: sub.aliases
+			});
+		}
+		const fileOptions = {};
+		if (options?.wrap) fileOptions.wrap = {
+			command: options.wrap.command,
+			args: [...parentArgs, cmd.name]
+		};
+		if (childRefs.length > 0) fileOptions.subcommands = childRefs;
+		const code = generateCommandFile(cmd, ctx, Object.keys(fileOptions).length > 0 ? fileOptions : void 0);
+		ctx.emitter.addFile(filePath, code.build());
+		rootImports.push({
+			name: cmd.name,
+			varName: toCommandFunctionName(cmd.name),
+			path: `./${filePath.replace(/\.ts$/, ".ts")}`,
+			aliases: cmd.aliases
+		});
+	}
+	walkCommands(root, "", []);
+	const program = ctx.createCodeBuilder();
+	const rootHasArgs = root.arguments && root.arguments.length > 0 || root.positionals && root.positionals.length > 0;
+	if (rootHasArgs) program.import("z", "zod/v4");
+	program.import(["createPadrone"], "padrone");
+	const directChildren = rootImports.filter((imp) => imp.path.split("/").length <= 3);
+	for (const imp of directChildren) program.import([imp.varName], imp.path);
+	program.line();
+	program.line(`const program = createPadrone(${JSON.stringify(root.name)})`);
+	const configParts = [];
+	if (root.description) configParts.push(`description: ${JSON.stringify(root.description)}`);
+	if (configParts.length > 0) program.line(`  .configure({ ${configParts.join(", ")} })`);
+	if (rootHasArgs) {
+		const schemaCode = fieldMetaToCode([...root.arguments || [], ...root.positionals || []]);
+		program.line(`  .arguments(${schemaCode.code})`);
+	}
+	for (const imp of directChildren) {
+		const nameArg = imp.aliases && imp.aliases.length > 0 ? `[${JSON.stringify(imp.name)}, ${imp.aliases.map((a) => JSON.stringify(a)).join(", ")}]` : JSON.stringify(imp.name);
+		program.line(`  .command(${nameArg}, ${imp.varName})`);
+	}
+	if (directChildren.length === 0 && options?.wrap) program.line(`  .wrap({ command: ${JSON.stringify(options.wrap.command)} })`);
+	program.line();
+	program.line(`export default program`);
+	ctx.emitter.addFile("program.ts", program.build());
+	const index = ctx.createCodeBuilder();
+	index.line(`export { default } from './program.ts'`);
+	ctx.emitter.addFile("index.ts", index.build());
+}
+//#endregion
+//#region src/codegen/template.ts
+/**
+* Compile a template string into a reusable render function.
+*/
+function template(text) {
+	return (data, partials) => {
+		return render(text, data, partials);
+	};
+}
+function render(text, data, partials) {
+	let result = text;
+	result = result.replace(/\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_match, key, body) => {
+		const value = data[key];
+		if (value === void 0 || value === null || value === false) return "";
+		if (Array.isArray(value)) return value.map((item) => {
+			if (typeof item === "object" && item !== null) return render(body, item, partials);
+			return body.replace(/\{\{\.\}\}/g, String(item));
+		}).join("");
+		if (typeof value === "object") return render(body, value, partials);
+		return render(body, data, partials);
+	});
+	if (partials) result = result.replace(/\{\{>(\w+)\}\}/g, (_match, name) => {
+		const partialText = partials[name];
+		if (!partialText) return "";
+		return render(partialText, data, partials);
+	});
+	result = result.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+		const value = data[key];
+		if (value === void 0 || value === null) return "";
+		return String(value);
+	});
+	return result;
+}
+//#endregion
+export { createCodeBuilder, createFileEmitter, discoverCli, fieldMetaToCode, generateBarrelFile, generateCommandFile, generateCommandTree, mergeCommandMeta, parseFishCompletions, parseHelpOutput, parseZshCompletions, schemaToCode, template };
+
+//# sourceMappingURL=index.mjs.map