create-agentic-monorepo 0.1.0

package/dist/main.mjs

@@ -0,0 +1,885 @@
+#!/usr/bin/env node
+import { a as toOverrides, d as validateConfig, l as presets, o as CreatorError, r as parseCliArgs, s as catalog, t as hasSelection, u as resolveOptions } from "./args-D-klo3P0.mjs";
+import { lstat, mkdir, open, readFile, readdir, realpath, rmdir, unlink } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
+import { createHash } from "node:crypto";
+import { parse, stringify } from "yaml";
+import spawn from "cross-spawn";
+import pc from "picocolors";
+//#region ../../../libs/platform/node/scaffolding/dist/index.mjs
+/** Read and strictly validate a creator configuration file. */
+async function readConfig(filePath) {
+	const absolutePath = resolve(process.cwd(), filePath);
+	let source;
+	try {
+		source = await readFile(absolutePath, "utf8");
+	} catch (cause) {
+		throw new CreatorError("INVALID_CONFIG", `Unable to read configuration file ${absolutePath}`, { cause });
+	}
+	let value;
+	try {
+		value = JSON.parse(source);
+	} catch (cause) {
+		throw new CreatorError("INVALID_CONFIG", `Configuration file ${absolutePath} is not valid JSON`, { cause });
+	}
+	try {
+		return validateConfig(value);
+	} catch (cause) {
+		if (cause instanceof CreatorError) throw cause;
+		throw new CreatorError("INVALID_CONFIG", `Configuration file ${absolutePath} is invalid`, { cause });
+	}
+}
+function conflict(message, cause) {
+	return new CreatorError("DESTINATION_CONFLICT", message, cause === void 0 ? void 0 : { cause });
+}
+/** Resolve a destination through its existing parent and enforce an empty target. */
+async function inspectDestination(directory) {
+	const requested = resolve(process.cwd(), directory);
+	let current;
+	try {
+		current = await lstat(requested);
+	} catch (cause) {
+		if (cause.code !== "ENOENT") throw conflict(`Unable to inspect destination ${requested}`, cause);
+		const parent = dirname(requested);
+		let canonicalParent;
+		try {
+			canonicalParent = await realpath(parent);
+		} catch (parentCause) {
+			throw conflict(`Destination parent does not exist: ${parent}`, parentCause);
+		}
+		let parentStat;
+		try {
+			parentStat = await lstat(canonicalParent);
+		} catch (parentCause) {
+			throw conflict(`Unable to inspect destination parent ${canonicalParent}`, parentCause);
+		}
+		if (!parentStat.isDirectory()) throw conflict(`Destination parent is not a directory: ${canonicalParent}`);
+		return {
+			path: join(canonicalParent, requested.slice(parent.length + 1)),
+			existed: false,
+			identity: null
+		};
+	}
+	if (current.isSymbolicLink()) throw conflict(`Destination must not be a symbolic link: ${requested}`);
+	if (!current.isDirectory()) throw conflict(`Destination is not a directory: ${requested}`);
+	let entries;
+	try {
+		entries = await readdir(requested);
+	} catch (cause) {
+		throw conflict(`Unable to inspect destination ${requested}`, cause);
+	}
+	if (entries.length > 0) throw conflict(`Destination is not empty: ${requested}`);
+	return {
+		path: requested,
+		existed: true,
+		identity: {
+			dev: current.dev,
+			ino: current.ino
+		}
+	};
+}
+/** Canonical JSON used for template digest calculation. */
+function canonicalTemplateValue(snapshot) {
+	const files = [...snapshot.files].map((file) => ({
+		path: file.path,
+		mode: file.mode,
+		text: file.text
+	})).sort((left, right) => left.path.localeCompare(right.path));
+	const variantLockfiles = Object.fromEntries(Object.entries(snapshot.variantLockfiles ?? {}).sort(([left], [right]) => left.localeCompare(right)));
+	return JSON.stringify({
+		files,
+		variantLockfiles
+	});
+}
+function calculateTemplateDigest(snapshot) {
+	return `sha256:${createHash("sha256").update(canonicalTemplateValue(snapshot), "utf8").digest("hex")}`;
+}
+function validateTemplatePath(value) {
+	if (value.length === 0 || value.includes("\\") || value.includes("\0")) return false;
+	if (isAbsolute(value) || win32.isAbsolute(value) || win32.parse(value).root.length > 0) return false;
+	const normalized = posix.normalize(value);
+	return normalized === value && normalized !== "." && !normalized.split("/").includes("..") && !value.startsWith("/");
+}
+function invalid$1(message, cause) {
+	return new CreatorError("INVALID_TEMPLATE", message, cause === void 0 ? void 0 : { cause });
+}
+function parseSnapshot(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalid$1("Template asset must contain a JSON object");
+	const record = value;
+	if (record.formatVersion !== 1) throw invalid$1("Unsupported template format version");
+	if (typeof record.creatorVersion !== "string" || record.creatorVersion.length === 0) throw invalid$1("Template creatorVersion must be a non-empty string");
+	if (typeof record.digest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(record.digest)) throw invalid$1("Template digest must be a sha256 digest");
+	if (!Array.isArray(record.files) || record.files.length === 0) throw invalid$1("Template files must be a non-empty array");
+	const files = [];
+	const paths = /* @__PURE__ */ new Set();
+	const caseFoldedPaths = /* @__PURE__ */ new Set();
+	for (const item of record.files) {
+		if (typeof item !== "object" || item === null || Array.isArray(item)) throw invalid$1("Template file entries must be objects");
+		const file = item;
+		if (typeof file.path !== "string" || file.mode !== 420 && file.mode !== 493 || typeof file.text !== "string" || !validateTemplatePath(file.path)) throw invalid$1("Template contains an invalid file entry");
+		const key = file.path.toLocaleLowerCase("en-US");
+		if (paths.has(file.path) || caseFoldedPaths.has(key)) throw invalid$1(`Template contains duplicate file path ${file.path}`);
+		paths.add(file.path);
+		caseFoldedPaths.add(key);
+		files.push({
+			path: file.path,
+			mode: file.mode,
+			text: file.text
+		});
+	}
+	let variantLockfiles;
+	if (record.variantLockfiles !== void 0) {
+		if (typeof record.variantLockfiles !== "object" || record.variantLockfiles === null || Array.isArray(record.variantLockfiles)) throw invalid$1("Template variantLockfiles must be an object");
+		const variants = {};
+		for (const [key, text] of Object.entries(record.variantLockfiles)) {
+			if (key.length === 0 || typeof text !== "string") throw invalid$1("Template variantLockfiles contains an invalid entry");
+			variants[key] = text;
+		}
+		variantLockfiles = variants;
+	}
+	const snapshot = {
+		formatVersion: 1,
+		creatorVersion: record.creatorVersion,
+		digest: record.digest,
+		files,
+		...variantLockfiles === void 0 ? {} : { variantLockfiles }
+	};
+	if (calculateTemplateDigest(snapshot) !== snapshot.digest) throw invalid$1("Template digest does not match its contents");
+	return snapshot;
+}
+/** Read, validate, and verify an immutable bundled template asset. */
+async function loadTemplate(templateUrl) {
+	let text;
+	try {
+		text = await readFile(templateUrl, "utf8");
+	} catch (cause) {
+		throw invalid$1(`Unable to read template asset ${templateUrl.href}`, cause);
+	}
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch (cause) {
+		throw invalid$1("Template asset is not valid JSON", cause);
+	}
+	return parseSnapshot(value);
+}
+const APP_PATHS = {
+	web: "apps/web/example-app",
+	cli: "apps/cli/example-app",
+	mac: "apps/mac/example-app"
+};
+const IMPORTER_PATHS = {
+	web: "apps/web/example-app",
+	cli: "apps/cli/example-app"
+};
+function invalid(message, cause) {
+	return new CreatorError("INVALID_TEMPLATE", message, cause === void 0 ? void 0 : { cause });
+}
+function descriptors() {
+	const source = catalog;
+	if (Array.isArray(source)) return source;
+	if (typeof source === "object" && source !== null) return Object.values(source);
+	throw invalid("Scaffolding catalog is not an object or array");
+}
+function normalizeSource(text) {
+	return text.replace(/\r\n?/g, "\n");
+}
+function parseJson(text, path) {
+	try {
+		const value = JSON.parse(text);
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("expected an object");
+		return value;
+	} catch (cause) {
+		throw invalid(`Template member ${path} is not a JSON object`, cause);
+	}
+}
+function selectedSourcePaths(options) {
+	const selected = new Set(options.components);
+	const paths = [];
+	for (const descriptor of descriptors()) {
+		if (!selected.has(descriptor.id) || descriptor.status !== "available") continue;
+		for (const sourcePath of descriptor.sourcePaths) paths.push(sourcePath);
+	}
+	return paths;
+}
+function pathMatches(path, sourcePath) {
+	return path === sourcePath || path.startsWith(`${sourcePath}/`);
+}
+function renderPackage(text, options) {
+	const packageJson = parseJson(text, "package.json");
+	packageJson.name = options.name;
+	packageJson.private = true;
+	const roots = options.components.filter((component) => component === "web" || component === "cli" || component === "mac" || component === "search-domain" || component === "mac-filesystem").map((component) => APP_PATHS[component] ?? (component === "search-domain" ? "libs/domains/search" : "libs/platform/mac/filesystem"));
+	const lintRoots = roots.length === 0 ? ["tools"] : [...roots, "tools"];
+	packageJson.scripts = {
+		...typeof packageJson.scripts === "object" && packageJson.scripts !== null ? packageJson.scripts : {},
+		lint: `oxlint ${lintRoots.join(" ")} && node tools/check-boundaries.mjs`
+	};
+	return `${JSON.stringify(packageJson, null, 2)}\n`;
+}
+function selectedImporters(options) {
+	const result = /* @__PURE__ */ new Set(["."]);
+	for (const app of options.apps) {
+		const importer = IMPORTER_PATHS[app];
+		if (importer !== void 0) result.add(importer);
+	}
+	if (options.apps.some((app) => app === "web" || app === "cli")) result.add("libs/domains/search");
+	return result;
+}
+function renderLockfile(text, options, variant) {
+	const source = variant ?? text;
+	let document;
+	try {
+		document = parse(source);
+	} catch (cause) {
+		throw invalid("Template lockfile is not valid YAML", cause);
+	}
+	if (typeof document !== "object" || document === null || Array.isArray(document)) throw invalid("Template lockfile must be a YAML object");
+	const lockfile = document;
+	if (lockfile.lockfileVersion !== "9.0" && lockfile.lockfileVersion !== 9) throw invalid("Template lockfile must use lockfileVersion 9.0");
+	if (typeof lockfile.importers !== "object" || lockfile.importers === null || Array.isArray(lockfile.importers)) throw invalid("Template lockfile has no importer map");
+	const importers = lockfile.importers;
+	const keep = selectedImporters(options);
+	for (const key of Object.keys(importers)) if (!keep.has(key)) delete importers[key];
+	for (const key of keep) if (importers[key] === void 0) throw invalid(`Template lockfile is missing selected importer ${key}`);
+	return normalizeSource(stringify(lockfile));
+}
+function renderNx(text) {
+	if (typeof parseJson(text, "nx.json").analytics !== "boolean") throw invalid("Template member nx.json[\"analytics\"] must be a boolean");
+	const match = text.match(/("analytics"\s*:\s*)(true|false)/);
+	if (match === null || match.index === void 0) throw invalid("Template nx.json is missing the \"analytics\" key");
+	const rendered = `${text.slice(0, match.index)}${match[1]}false${text.slice(match.index + match[0].length)}`;
+	return rendered.endsWith("\n") ? rendered : `${rendered}\n`;
+}
+function renderConfig(options, template) {
+	return `{
+  "schemaVersion": 1,
+  "name": ${JSON.stringify(options.name)},
+  "apps": [${options.apps.map((app) => JSON.stringify(app)).join(", ")}],
+  "rust": ${JSON.stringify(options.rust)},
+  "templateVersion": ${JSON.stringify(template.creatorVersion)},
+  "templateDigest": ${JSON.stringify(template.digest)}
+}
+`;
+}
+function renderReadme(options, template) {
+	const selected = options.apps.length === 0 ? "an empty workspace" : options.apps.map((app) => `${app} starter`).join(", ");
+	const appLines = options.apps.length === 0 ? "- No application is included yet. Add a domain and app following docs/architecture.md." : options.apps.map((app) => `- ${APP_PATHS[app]} (${app})`).join("\n");
+	const buildLines = options.apps.length === 0 ? "pnpm nx run-many -t typecheck build test lint" : options.apps.map((app) => `pnpm nx run ${app}-example-app:build`).join("\n");
+	const developCommands = {
+		web: "pnpm nx run web-example-app:dev",
+		cli: "pnpm nx run cli-example-app:start -- demo",
+		mac: "pnpm nx run mac-example-app:run"
+	};
+	const developSection = options.apps.length === 0 ? "" : `## Develop\n\n\`\`\`sh\n${options.apps.map((app) => developCommands[app]).join("\n")}\n\`\`\`\n\nIf you change a library, rebuild it before the running development server picks it up.\n\n`;
+	return `# ${options.name}\n\nThis repository contains ${selected}, generated from Agentic Monorepo (template ${template.creatorVersion}). Examples are intentionally small and should be replaced with your product's real domains.\n\n## Included projects\n\n${appLines}\n${options.rust ? "- libs/rust/search-index (independent Rust library)\n" : ""}\n${developSection}## Checks\n\n\`\`\`sh\n${buildLines}\npnpm nx run-many -t typecheck build test lint\npnpm format:check\n\`\`\`\n\nReplay this selection with npx create-agentic-monorepo ${options.name} --config ./agentic.config.json. The generated examples use the shared search domain where applicable; Rust is independent and is not wired into an application.\n`;
+}
+function renderWorkflow(options) {
+	const steps = [
+		{
+			id: "checkout",
+			uses: "actions/checkout@v4"
+		},
+		{
+			id: "setup-pnpm",
+			uses: "pnpm/action-setup@v4"
+		},
+		{
+			id: "setup-node",
+			uses: "actions/setup-node@v4",
+			with: {
+				"node-version": 22,
+				cache: "pnpm"
+			}
+		}
+	];
+	if (options.apps.includes("mac")) steps.push({
+		id: "setup-swiftlint",
+		run: "brew install swiftlint"
+	});
+	if (options.rust) steps.push({
+		id: "setup-rust",
+		run: "rustup toolchain install 1.97.1 --profile minimal --component clippy --component rustfmt"
+	});
+	steps.push({
+		id: "install-dependencies",
+		run: "pnpm install --frozen-lockfile"
+	}, {
+		id: "verify-workspace",
+		run: "pnpm nx run-many -t typecheck build test lint"
+	}, {
+		id: "check-format",
+		run: "pnpm format:check"
+	});
+	return `${stringify({
+		name: "ci",
+		on: {
+			push: { branches: ["main"] },
+			pull_request: {}
+		},
+		jobs: { verify: {
+			"runs-on": options.apps.includes("mac") ? "macos-latest" : "ubuntu-latest",
+			steps
+		} }
+	})}`;
+}
+/** Render a complete selected repository before any destination mutation. */
+function renderRepository(template, options) {
+	const sourcePaths = selectedSourcePaths(options);
+	const selectedFiles = template.files.filter((file) => sourcePaths.some((sourcePath) => pathMatches(file.path, sourcePath)));
+	if (!selectedFiles.some((file) => file.path === "package.json")) throw invalid("Selected template does not include package.json");
+	const files = /* @__PURE__ */ new Map();
+	for (const file of selectedFiles) {
+		if (!validateTemplatePath(file.path)) throw invalid(`Invalid selected template path ${file.path}`);
+		files.set(file.path, {
+			path: file.path,
+			mode: file.mode,
+			text: normalizeSource(file.text)
+		});
+	}
+	const lockKey = `${options.apps.join("+") || "none"};rust=${options.rust ? "1" : "0"}`;
+	const variant = template.variantLockfiles?.[lockKey];
+	for (const file of files.values()) if (file.path === "package.json") files.set(file.path, {
+		...file,
+		text: renderPackage(file.text, options)
+	});
+	else if (file.path === "pnpm-lock.yaml") files.set(file.path, {
+		...file,
+		text: renderLockfile(file.text, options, variant)
+	});
+	else if (file.path === "nx.json") files.set(file.path, {
+		...file,
+		text: renderNx(file.text)
+	});
+	else if (file.path === ".github/workflows/ci.yml") files.set(file.path, {
+		...file,
+		text: renderWorkflow(options)
+	});
+	files.set("agentic.config.json", {
+		path: "agentic.config.json",
+		mode: 420,
+		text: renderConfig(options, template)
+	});
+	files.set("README.md", {
+		path: "README.md",
+		mode: 420,
+		text: renderReadme(options, template)
+	});
+	const rendered = [...files.values()].sort((left, right) => left.path.localeCompare(right.path));
+	const seen = /* @__PURE__ */ new Set();
+	for (const file of rendered) {
+		if (seen.has(file.path)) throw invalid(`Duplicate rendered path ${file.path}`);
+		seen.add(file.path);
+	}
+	return rendered;
+}
+function error(code, message, cause) {
+	return new CreatorError(code, message, cause === void 0 ? void 0 : { cause });
+}
+function digest(text) {
+	return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function checkAborted(signal) {
+	if (signal.aborted) throw error("CANCELLED", "Repository creation was cancelled");
+}
+function contained(destination, candidate) {
+	const root = resolve(destination);
+	const target = resolve(candidate);
+	return target !== root && target.startsWith(`${root}${sep}`);
+}
+async function rollback(files, directories, destination, destinationOwned) {
+	for (const file of [...files].reverse()) try {
+		const current = await lstat(file.path);
+		if (current.isSymbolicLink() || current.dev !== file.dev || current.ino !== file.ino) continue;
+		const text = await (await open(file.path, "r")).readFile({ encoding: "utf8" });
+		if (file.digest.length === 0 || digest(text) === file.digest) await unlink(file.path);
+	} catch {}
+	for (const directory of [...directories].reverse()) try {
+		const current = await lstat(directory.path);
+		if (current.isDirectory() && current.dev === directory.dev && current.ino === directory.ino) await rmdir(directory.path);
+	} catch {}
+	if (destinationOwned) try {
+		if ((await lstat(destination.path)).isDirectory() && (await readdir(destination.path)).length === 0) await rmdir(destination.path);
+	} catch {}
+}
+async function reserveDestination(destination) {
+	if (!destination.existed) try {
+		await mkdir(destination.path, {
+			mode: 493,
+			recursive: false
+		});
+		return true;
+	} catch (cause) {
+		if (cause.code === "EEXIST") throw error("DESTINATION_CONFLICT", `Destination appeared while creating it: ${destination.path}`, cause);
+		throw error("WRITE_FAILED", `Unable to reserve destination ${destination.path}`, cause);
+	}
+	let current;
+	try {
+		current = await lstat(destination.path);
+	} catch (cause) {
+		throw error("DESTINATION_CONFLICT", `Destination changed before creation: ${destination.path}`, cause);
+	}
+	if (!current.isDirectory() || current.isSymbolicLink()) throw error("DESTINATION_CONFLICT", `Destination changed before creation: ${destination.path}`);
+	if (destination.identity === null || current.dev !== destination.identity.dev || current.ino !== destination.identity.ino) throw error("DESTINATION_CONFLICT", `Destination changed before creation: ${destination.path}`);
+	try {
+		if ((await readdir(destination.path)).length !== 0) throw error("DESTINATION_CONFLICT", `Destination is no longer empty: ${destination.path}`);
+	} catch (cause) {
+		if (cause instanceof CreatorError) throw cause;
+		throw error("DESTINATION_CONFLICT", `Unable to recheck destination ${destination.path}`, cause);
+	}
+	return false;
+}
+async function ensureParentDirectories(destination, filePath, owned) {
+	const parent = dirname(filePath);
+	if (parent === destination) return;
+	const relativeParent = relative(destination, parent);
+	if (!relativeParent || relativeParent.startsWith("..") || relativeParent.includes(`..${sep}`)) throw error("INVALID_TEMPLATE", `Template file escapes destination: ${filePath}`);
+	let current = destination;
+	for (const segment of relativeParent.split(sep)) {
+		current = resolve(current, segment);
+		let stat;
+		try {
+			stat = await lstat(current);
+		} catch (cause) {
+			if (cause.code !== "ENOENT") throw error("WRITE_FAILED", `Unable to inspect directory ${current}`, cause);
+			try {
+				await mkdir(current, {
+					mode: 493,
+					recursive: false
+				});
+			} catch (mkdirCause) {
+				throw error("WRITE_FAILED", `Unable to create directory ${current}`, mkdirCause);
+			}
+			stat = await lstat(current);
+			owned.push({
+				path: current,
+				dev: stat.dev,
+				ino: stat.ino
+			});
+			continue;
+		}
+		if (!stat.isDirectory() || stat.isSymbolicLink()) throw error("DESTINATION_CONFLICT", `Template parent is not a safe directory: ${current}`);
+		if (!owned.some((entry) => entry.path === current)) throw error("DESTINATION_CONFLICT", `Unexpected existing template directory: ${current}`);
+	}
+}
+async function writeFileExclusive(file, destination, created, signal) {
+	checkAborted(signal);
+	const filePath = resolve(destination, file.path);
+	if (!contained(destination, filePath)) throw error("INVALID_TEMPLATE", `Template file escapes destination: ${file.path}`);
+	let handle;
+	try {
+		handle = await open(filePath, "wx", file.mode);
+		const opened = await handle.stat();
+		created.push({
+			path: filePath,
+			dev: opened.dev,
+			ino: opened.ino,
+			digest: ""
+		});
+		await handle.writeFile(file.text, "utf8");
+		await handle.chmod(file.mode);
+		await handle.close();
+		const index = created.length - 1;
+		const createdFile = created[index];
+		if (createdFile !== void 0) created[index] = {
+			...createdFile,
+			digest: digest(file.text)
+		};
+	} catch (cause) {
+		try {
+			await handle?.close();
+		} catch {}
+		if (cause.code === "EEXIST") throw error("DESTINATION_CONFLICT", `Template file already exists: ${file.path}`, cause);
+		throw error("WRITE_FAILED", `Unable to create ${file.path}`, cause);
+	}
+	const stat = await lstat(filePath);
+	if (!stat.isFile() || stat.isSymbolicLink()) throw error("WRITE_FAILED", `Created path is not a regular file: ${file.path}`);
+	checkAborted(signal);
+}
+/** Render and write a repository using exclusive files and ownership-aware rollback. */
+async function createRepository(template, options, destination, signal) {
+	checkAborted(signal);
+	const rendered = renderRepository(template, options);
+	const destinationOwned = await reserveDestination(destination);
+	const files = [];
+	const directories = [];
+	try {
+		for (const file of rendered) {
+			checkAborted(signal);
+			const filePath = resolve(destination.path, file.path);
+			if (!contained(destination.path, filePath)) throw error("INVALID_TEMPLATE", `Template file escapes destination: ${file.path}`);
+			await ensureParentDirectories(destination.path, filePath, directories);
+			await writeFileExclusive(file, destination.path, files, signal);
+		}
+		checkAborted(signal);
+	} catch (cause) {
+		await rollback(files, directories, destination, destinationOwned);
+		if (cause instanceof CreatorError) throw cause;
+		throw error("WRITE_FAILED", `Unable to create repository in ${destination.path}`, cause);
+	}
+}
+function setupError(message, cause) {
+	return new CreatorError("SETUP_FAILED", message, cause === void 0 ? void 0 : { cause });
+}
+function cancellation() {
+	return new CreatorError("CANCELLED", "Setup was cancelled");
+}
+function terminate(child) {
+	const pid = child.pid;
+	if (pid === void 0 || pid === null) return;
+	if (process.platform === "win32") {
+		spawn("taskkill.exe", [
+			"/PID",
+			String(pid),
+			"/T",
+			"/F"
+		], {
+			stdio: "ignore",
+			shell: false
+		}).unref();
+		return;
+	}
+	try {
+		process.kill(-pid, "SIGTERM");
+	} catch {
+		try {
+			child.kill("SIGTERM");
+		} catch {}
+	}
+	setTimeout(() => {
+		try {
+			process.kill(-pid, "SIGKILL");
+		} catch {}
+	}, 5e3).unref();
+}
+function runProcess(executable, args, directory, signal, onOutput) {
+	return new Promise((resolve, reject) => {
+		let child;
+		try {
+			child = spawn(executable, [...args], {
+				cwd: directory,
+				shell: false,
+				detached: process.platform !== "win32",
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+		} catch (cause) {
+			reject(setupError(`Unable to start ${executable}`, cause));
+			return;
+		}
+		let stdout = "";
+		let aborted = signal.aborted;
+		const onAbort = () => {
+			aborted = true;
+			terminate(child);
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		child.stdout?.on("data", (chunk) => {
+			const text = String(chunk);
+			stdout += text;
+			onOutput(text);
+		});
+		child.stderr?.on("data", (chunk) => onOutput(String(chunk)));
+		child.once("error", (cause) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(aborted ? cancellation() : setupError(`Unable to run ${executable}`, cause));
+		});
+		child.once("close", (code) => {
+			signal.removeEventListener("abort", onAbort);
+			if (aborted) reject(cancellation());
+			else resolve({
+				code,
+				stdout
+			});
+		});
+		if (aborted) onAbort();
+	});
+}
+function packageManagerVersion(value) {
+	if (typeof value !== "string" || !value.startsWith("pnpm@") || value.slice(5).length === 0) throw setupError("Generated package.json must pin packageManager to pnpm@<version>");
+	return value.slice(5);
+}
+/** Run only explicitly requested setup operations, sequentially and without a shell. */
+async function runSetup(directory, options, signal, onOutput) {
+	const result = {
+		install: "skipped",
+		git: "skipped"
+	};
+	if (options.install) {
+		let packageJson;
+		try {
+			packageJson = JSON.parse(await readFile(join(directory, "package.json"), "utf8"));
+		} catch (cause) {
+			throw setupError("Unable to read generated package.json for setup", cause);
+		}
+		const expected = packageManagerVersion(packageJson.packageManager);
+		const version = await runProcess("pnpm", ["--version"], directory, signal, onOutput);
+		if (version.code !== 0 || version.stdout.trim() !== expected) throw setupError(`Expected pnpm ${expected}, but found ${version.stdout.trim() || "an unavailable version"}`);
+		const install = await runProcess("pnpm", ["install", "--frozen-lockfile"], directory, signal, onOutput);
+		if (install.code !== 0) throw setupError(`pnpm install failed with exit code ${install.code ?? 1}`);
+		result.install = "completed";
+	}
+	if (options.git) {
+		const git = await runProcess("git", ["init", "--initial-branch=main"], directory, signal, onOutput);
+		if (git.code !== 0) throw setupError(`git init failed with exit code ${git.code ?? 1}`);
+		result.git = "completed";
+	}
+	return result;
+}
+//#endregion
+//#region src/output.ts
+function writeJson(value) {
+	process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+function stripAnsi(value) {
+	return value.replace(/[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g, "");
+}
+function cleanDiagnostic(value) {
+	return stripAnsi(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "").trim();
+}
+function printHelp(stream = process.stdout) {
+	stream.write(`create-agentic-monorepo [destination]\n\nCreate a repository from the Agentic Monorepo starter.\n\nOptions:\n  --name <name>             Root package/repository name\n  --preset <id>             web, cli, mac, web-cli, full, or workspace\n  --apps <csv>              web, cli, mac, or none\n  --rust / --no-rust       Include the independent Rust library\n  --install / --no-install Install dependencies with pinned pnpm\n  --git / --no-git         Initialize local Git\n  --config <path>           Read a strict JSON configuration\n  --yes, -y                Do not prompt (defaults to web)\n  --dry-run                Print the plan without writing or running commands\n  --json                   Emit one machine-readable result on stdout\n  --plain                  Use accessible line-oriented prompts\n  --list                   List supported and Coming soon capabilities\n  --help, -h               Show this help\n  --version, -v            Show the creator version\n`);
+}
+function printList(presets, capabilities, json) {
+	if (json) {
+		writeJson({
+			schemaVersion: 1,
+			status: "catalog",
+			presets,
+			capabilities
+		});
+		return;
+	}
+	const lines = ["Supported starters", ""];
+	for (const preset of presets) lines.push(`  ${preset.label} — ${preset.hint}`);
+	lines.push("", "Capabilities");
+	for (const capability of capabilities) {
+		const badge = capability.status === "available" ? "Available" : "Coming soon";
+		const requirements = capability.requirements.length > 0 ? ` (${capability.requirements.join(", ")})` : "";
+		lines.push(`  ${badge}: ${capability.label} — ${capability.hint}${requirements}`);
+	}
+	lines.push("", "Host prerequisites: creator, web, and CLI output run on macOS, Linux, and Windows; Mac code needs macOS 14+ and Swift 6; Rust needs Rust 1.97.1.");
+	process.stdout.write(`${lines.join("\n")}\n`);
+}
+function printPlan(directory, name, apps, rust, template, install, git) {
+	const actions = ["create files"];
+	if (install) actions.push("install dependencies");
+	if (git) actions.push("initialize local Git");
+	const lines = [
+		`Plan for ${name}`,
+		`  destination: ${directory}`,
+		`  apps: ${apps.length === 0 ? "none" : apps.join(", ")}`,
+		`  libraries: ${rust ? "Rust search-index" : "none"}`,
+		`  files: ${template.files.length}`,
+		`  actions: ${actions.join(", ")}`
+	];
+	process.stdout.write(`${lines.join("\n")}\n`);
+	return actions;
+}
+function shellQuote(value) {
+	if (process.platform === "win32") return `Set-Location -LiteralPath '${value.replaceAll("'", "''")}'`;
+	return `cd -- '${value.replaceAll("'", "'\\''")}'`;
+}
+function nextSteps(directory, apps, rust, setup) {
+	const result = [shellQuote(directory)];
+	if (setup.install !== "completed") result.push("pnpm install --frozen-lockfile");
+	const first = apps[0];
+	if (first === "web") result.push("pnpm nx run web-example-app:build", "pnpm nx run web-example-app:dev");
+	else if (first === "cli") result.push("pnpm nx run cli-example-app:build", "pnpm nx run cli-example-app:start -- demo");
+	else if (first === "mac") result.push("pnpm nx run mac-example-app:build", "pnpm nx run mac-example-app:run");
+	else if (rust) result.push("pnpm nx run search-index:build", "pnpm nx run search-index:test");
+	else result.push("pnpm nx run-many -t typecheck build test lint");
+	return result;
+}
+function printSuccess(directory, name, apps, rust, template, setup, json, planned = false) {
+	const steps = nextSteps(directory, apps, rust, setup);
+	if (json) {
+		writeJson({
+			schemaVersion: 1,
+			status: planned ? "planned" : "created",
+			directory,
+			name,
+			apps,
+			rust,
+			templateVersion: template.creatorVersion,
+			templateDigest: template.digest,
+			setup: planned ? {
+				install: "skipped",
+				git: "skipped"
+			} : setup,
+			nextSteps: steps
+		});
+		return;
+	}
+	const heading = planned ? "Planned" : "Created";
+	process.stderr.write(`${pc.cyan(pc.bold(heading))} ${name}\n\n`);
+	process.stderr.write(`  ${directory}\n`);
+	process.stderr.write(`  apps: ${apps.length === 0 ? "none" : apps.join(", ")}${rust ? "; Rust search-index" : ""}\n`);
+	process.stderr.write(`  install: ${setup.install}; git: ${setup.git}\n\n`);
+	process.stderr.write(`${pc.bold("Next")}\n${steps.map((step) => `  ${step}`).join("\n")}\n`);
+	if (apps.includes("mac") && process.platform !== "darwin") process.stderr.write(`${pc.yellow("Warning")}: Mac commands require macOS 14+ and Swift 6.\n`);
+}
+function printError(result, json) {
+	if (json) {
+		writeJson(result);
+		return;
+	}
+	process.stderr.write(`${pc.red(pc.bold(result.status === "cancelled" ? "Cancelled" : "Error"))}: ${cleanDiagnostic(result.message)}\n`);
+	for (const step of result.nextSteps) process.stderr.write(`  Next: ${cleanDiagnostic(step)}\n`);
+}
+//#endregion
+//#region src/main.ts
+const packageMetadataUrl = new URL("../package.json", import.meta.url);
+const templateAssetUrl = new URL("../template.json", import.meta.url);
+function isTruthyCi(value) {
+	return value !== void 0 && value !== "" && value !== "0" && value !== "false";
+}
+function defaultSetup() {
+	return {
+		install: "skipped",
+		git: "skipped"
+	};
+}
+function errorCode(error) {
+	return error instanceof CreatorError ? error.code : "WRITE_FAILED";
+}
+function exitCode(error, signalCode) {
+	if (signalCode !== 0) return signalCode;
+	if (error instanceof CreatorError) {
+		if (error.code === "CANCELLED") return 130;
+		if (error.code === "INVALID_ARGUMENT" || error.code === "INVALID_CONFIG" || error.code === "UNSUPPORTED_OPTION" || error.code === "UNSUPPORTED_RUNTIME" || error.code === "TEMPLATE_MISMATCH" || error.code === "DESTINATION_CONFLICT") return 2;
+	}
+	return 1;
+}
+async function readPackageMetadata() {
+	const value = JSON.parse(await readFile(packageMetadataUrl, "utf8"));
+	if (typeof value !== "object" || value === null || typeof value.name !== "string" || typeof value.version !== "string") throw new CreatorError("INVALID_TEMPLATE", "The staged package manifest is invalid");
+	return value;
+}
+function selectionInConfig(config) {
+	return config.preset !== void 0 || config.apps !== void 0;
+}
+function checkTemplatePins(config, template) {
+	if (config.templateVersion !== void 0 && config.templateVersion !== template.creatorVersion) throw new CreatorError("TEMPLATE_MISMATCH", `Configuration requires creator version ${config.templateVersion}; use create-agentic-monorepo@${config.templateVersion} or remove the templateVersion pin`);
+	if (config.templateDigest !== void 0 && config.templateDigest !== template.digest) throw new CreatorError("TEMPLATE_MISMATCH", `Configuration requires template digest ${config.templateDigest}; use the pinned creator or remove the templateDigest pin`);
+}
+function noninteractive(args) {
+	return args.yes || args.json || isTruthyCi(process.env["CI"]) || !process.stdin.isTTY || !process.stdout.isTTY || !process.stderr.isTTY;
+}
+function makeErrorResult(error, directory, repositoryCreated, signalCode) {
+	const cancelled = signalCode !== 0 || error instanceof CreatorError && error.code === "CANCELLED";
+	const message = error instanceof Error ? error.message : "Creator failed";
+	const nextSteps = repositoryCreated ? ["cd to the generated directory", "pnpm install --frozen-lockfile"] : [];
+	return {
+		schemaVersion: 1,
+		status: cancelled ? "cancelled" : "error",
+		code: cancelled ? "CANCELLED" : errorCode(error),
+		message: cleanDiagnostic(message),
+		directory,
+		repositoryCreated,
+		nextSteps
+	};
+}
+async function run(argv) {
+	let args;
+	try {
+		args = parseCliArgs(argv);
+	} catch (error) {
+		const json = argv.includes("--json");
+		printError(makeErrorResult(error, null, false, 0), json);
+		return exitCode(error, 0);
+	}
+	if (args.help) {
+		printHelp();
+		return 0;
+	}
+	if (args.version) {
+		const metadata = await readPackageMetadata();
+		process.stdout.write(`${metadata.version}\n`);
+		return 0;
+	}
+	if (args.list) {
+		printList(presets, catalog, args.json);
+		return 0;
+	}
+	let destination = args.destination;
+	let repositoryCreated = false;
+	let signalCode = 0;
+	const controller = new AbortController();
+	const onInterrupt = () => {
+		signalCode = 130;
+		controller.abort();
+	};
+	const onTerminate = () => {
+		signalCode = 143;
+		controller.abort();
+	};
+	process.once("SIGINT", onInterrupt);
+	process.once("SIGTERM", onTerminate);
+	try {
+		const config = args.config === void 0 ? { schemaVersion: 1 } : await readConfig(args.config);
+		let overrides = toOverrides(args);
+		if (!noninteractive(args)) {
+			const { runWizard } = await import("./wizard-BFRKuEqB.mjs");
+			const wizardResult = await runWizard({
+				args,
+				config,
+				signal: controller.signal,
+				plain: args.plain || process.env["TERM"] === "dumb"
+			});
+			destination = wizardResult.destination;
+			overrides = wizardResult.overrides;
+		} else {
+			if (destination === void 0) throw new CreatorError("INVALID_ARGUMENT", "A destination is required in noninteractive mode; for example: create-agentic-monorepo my-product --preset web --yes");
+			if (!hasSelection(args) && !selectionInConfig(config)) {
+				if (args.yes) overrides = {
+					...overrides,
+					preset: "web"
+				};
+				else throw new CreatorError("INVALID_ARGUMENT", "A starter selection is required in noninteractive mode; use --preset web, --apps web, or --yes");
+			}
+		}
+		if (destination === void 0) throw new CreatorError("INVALID_ARGUMENT", "A destination is required");
+		const fallbackName = basename(resolve(destination));
+		const options = resolveOptions(config, overrides, fallbackName);
+		const template = await loadTemplate(templateAssetUrl);
+		const packageMetadata = await readPackageMetadata();
+		if (template.creatorVersion !== packageMetadata.version) throw new CreatorError("TEMPLATE_MISMATCH", `Bundled template ${template.creatorVersion} does not match creator ${packageMetadata.version}`);
+		checkTemplatePins(config, template);
+		const inspected = await inspectDestination(destination);
+		if (args.dryRun) {
+			if (args.json) printSuccess(inspected.path, options.name, options.apps, options.rust, template, defaultSetup(), true, true);
+			else printPlan(inspected.path, options.name, options.apps, options.rust, template, options.install, options.git);
+			return 0;
+		}
+		process.stderr.write("Validating destination and template...\n");
+		process.stderr.write("Creating files...\n");
+		await createRepository(template, options, inspected, controller.signal);
+		repositoryCreated = true;
+		let setup = defaultSetup();
+		if (options.install || options.git) {
+			process.stderr.write("Running requested setup...\n");
+			setup = await runSetup(destination, {
+				install: options.install,
+				git: options.git
+			}, controller.signal, (text) => {
+				process.stderr.write(`${cleanDiagnostic(text)}\n`);
+			});
+		}
+		printSuccess(inspected.path, options.name, options.apps, options.rust, template, setup, args.json);
+		return 0;
+	} catch (error) {
+		printError(makeErrorResult(error, destination === void 0 ? null : resolve(destination), repositoryCreated, signalCode), args.json);
+		return exitCode(error, signalCode);
+	} finally {
+		process.removeListener("SIGINT", onInterrupt);
+		process.removeListener("SIGTERM", onTerminate);
+	}
+}
+const exitStatus = await run(process.argv.slice(2));
+process.exitCode = exitStatus;
+//#endregion
+export {};