pakhale 0.1.0

package/dist/cli.js

@@ -0,0 +1,2037 @@
+#!/usr/bin/env node
+import { copyFile, lstat, mkdir, readFile, readdir, readlink, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+import { parseArgs, styleText } from "node:util";
+import process$1, { stdin, stdout } from "node:process";
+import l__default from "node:readline";
+import { spawn } from "node:child_process";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i$1 = 0, n$2 = keys.length, key; i$1 < n$2; i$1++) {
+		key = keys[i$1];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJS({ "node_modules/picocolors/picocolors.js": ((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor$3 = 0;
+		do {
+			result += string.substring(cursor$3, index) + replace;
+			cursor$3 = index + close.length;
+			index = string.indexOf(close, cursor$3);
+		} while (~index);
+		return result + string.substring(cursor$3);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}) });
+
+//#endregion
+//#region config.ts
+var import_picocolors$3 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const config = {
+	agents: ["claude-code", "opencode"],
+	marketplaces: {
+		"claude-plugins-official": {
+			repo: "anthropics/claude-plugins-official",
+			builtin: true
+		},
+		plannotator: { repo: "backnotprop/plannotator" },
+		impeccable: { repo: "pbakaus/impeccable" }
+	},
+	extensions: [
+		{
+			name: "context7",
+			deliver: {
+				"claude-code": {
+					via: "claude-plugin",
+					marketplace: "claude-plugins-official",
+					plugin: "context7"
+				},
+				opencode: {
+					via: "mcp",
+					server: {
+						transport: "stdio",
+						command: [
+							"npx",
+							"-y",
+							"@upstash/context7-mcp"
+						]
+					}
+				}
+			}
+		},
+		{
+			name: "mattpocock-skills",
+			deliver: {
+				"claude-code": {
+					via: "claude-plugin",
+					marketplace: "claude-plugins-official",
+					plugin: "mattpocock-skills"
+				},
+				opencode: {
+					via: "skills",
+					repo: "mattpocock/skills"
+				}
+			}
+		},
+		{
+			name: "plannotator",
+			deliver: {
+				"claude-code": {
+					via: "claude-plugin",
+					marketplace: "plannotator",
+					plugin: "plannotator"
+				},
+				opencode: {
+					via: "opencode-plugin",
+					package: "@plannotator/opencode@latest"
+				}
+			}
+		},
+		{
+			name: "impeccable",
+			deliver: {
+				"claude-code": {
+					via: "claude-plugin",
+					marketplace: "impeccable",
+					plugin: "impeccable"
+				},
+				opencode: {
+					via: "skills",
+					repo: "pbakaus/impeccable",
+					skills: ["impeccable"]
+				}
+			}
+		},
+		{
+			name: "vercel-agent-skills",
+			deliver: { all: {
+				via: "skills",
+				repo: "vercel-labs/agent-skills",
+				skills: ["vercel-react-best-practices", "vercel-composition-patterns"]
+			} }
+		},
+		{
+			name: "gh-stack",
+			deliver: { all: {
+				via: "skills",
+				repo: "github/gh-stack",
+				skills: ["gh-stack"]
+			} }
+		}
+	],
+	authoredSkillsDir: "skills",
+	instructionsFile: "assets/instructions/AGENTS.md",
+	claudeCode: {
+		statuslineScript: "assets/statusline/claude-code.sh",
+		autoCompactWindow: 25e4,
+		tui: "fullscreen",
+		cleanupPeriodDays: 14,
+		voice: true,
+		autoDream: false,
+		agentPushNotifications: true,
+		permissions: {
+			defaultMode: "auto",
+			skipDangerousModePrompt: true,
+			skipAutoPrompt: true
+		}
+	}
+};
+
+//#endregion
+//#region src/util/log.ts
+const log = {
+	agent: (s) => console.log(`\n${import_picocolors$3.default.bold(import_picocolors$3.default.magenta(`■ ${s}`))}`),
+	section: (s) => console.log(`\n${import_picocolors$3.default.bold(import_picocolors$3.default.cyan(`▸ ${s}`))}`),
+	ok: (s) => console.log(`  ${import_picocolors$3.default.green("✓")} ${s}`),
+	skip: (s) => console.log(`  ${import_picocolors$3.default.dim("·")} ${import_picocolors$3.default.dim(s)}`),
+	warn: (s) => console.log(`  ${import_picocolors$3.default.yellow("!")} ${s}`),
+	fail: (s) => console.log(`  ${import_picocolors$3.default.red("✗")} ${s}`),
+	plan: (s) => console.log(`  ${import_picocolors$3.default.yellow("would")} ${s}`),
+	info: (s) => console.log(`  ${import_picocolors$3.default.dim(s)}`)
+};
+
+//#endregion
+//#region node_modules/fast-string-truncated-width/dist/utils.js
+const getCodePointsLength = (() => {
+	const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+	return (input) => {
+		let surrogatePairsNr = 0;
+		SURROGATE_PAIR_RE.lastIndex = 0;
+		while (SURROGATE_PAIR_RE.test(input)) surrogatePairsNr += 1;
+		return input.length - surrogatePairsNr;
+	};
+})();
+const isFullWidth = (x) => {
+	return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+const isWideNotCJKTNotEmoji = (x) => {
+	return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+//#endregion
+//#region node_modules/fast-string-truncated-width/dist/index.js
+const ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+const CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+const CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/uy;
+const TAB_RE = /\t{1,1000}/y;
+const EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/uy;
+const LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+const MODIFIER_RE = /\p{M}+/gu;
+const NO_TRUNCATION$1 = {
+	limit: Infinity,
+	ellipsis: ""
+};
+const getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+	const LIMIT = truncationOptions.limit ?? Infinity;
+	const ELLIPSIS = truncationOptions.ellipsis ?? "";
+	const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION$1, widthOptions).width : 0);
+	const ANSI_WIDTH = 0;
+	const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+	const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+	const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+	const FULL_WIDTH_WIDTH = 2;
+	const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+	const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+	const PARSE_BLOCKS = [
+		[LATIN_RE, REGULAR_WIDTH],
+		[ANSI_RE, ANSI_WIDTH],
+		[CONTROL_RE, CONTROL_WIDTH],
+		[TAB_RE, TAB_WIDTH],
+		[EMOJI_RE, EMOJI_WIDTH],
+		[CJKT_WIDE_RE, WIDE_WIDTH]
+	];
+	let indexPrev = 0;
+	let index = 0;
+	let length = input.length;
+	let lengthExtra = 0;
+	let truncationEnabled = false;
+	let truncationIndex = length;
+	let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+	let unmatchedStart = 0;
+	let unmatchedEnd = 0;
+	let width = 0;
+	let widthExtra = 0;
+	outer: while (true) {
+		if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+			const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+			lengthExtra = 0;
+			for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+				const codePoint = char.codePointAt(0) || 0;
+				if (isFullWidth(codePoint)) widthExtra = FULL_WIDTH_WIDTH;
+				else if (isWideNotCJKTNotEmoji(codePoint)) widthExtra = WIDE_WIDTH;
+				else widthExtra = REGULAR_WIDTH;
+				if (width + widthExtra > truncationLimit) truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+				if (width + widthExtra > LIMIT) {
+					truncationEnabled = true;
+					break outer;
+				}
+				lengthExtra += char.length;
+				width += widthExtra;
+			}
+			unmatchedStart = unmatchedEnd = 0;
+		}
+		if (index >= length) break outer;
+		for (let i$1 = 0, l = PARSE_BLOCKS.length; i$1 < l; i$1++) {
+			const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i$1];
+			BLOCK_RE.lastIndex = index;
+			if (BLOCK_RE.test(input)) {
+				lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+				widthExtra = lengthExtra * BLOCK_WIDTH;
+				if (width + widthExtra > truncationLimit) truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+				if (width + widthExtra > LIMIT) {
+					truncationEnabled = true;
+					break outer;
+				}
+				width += widthExtra;
+				unmatchedStart = indexPrev;
+				unmatchedEnd = index;
+				index = indexPrev = BLOCK_RE.lastIndex;
+				continue outer;
+			}
+		}
+		index += 1;
+	}
+	return {
+		width: truncationEnabled ? truncationLimit : width,
+		index: truncationEnabled ? truncationIndex : length,
+		truncated: truncationEnabled,
+		ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+	};
+};
+var dist_default$1 = getStringTruncatedWidth;
+
+//#endregion
+//#region node_modules/fast-string-width/dist/index.js
+const NO_TRUNCATION = {
+	limit: Infinity,
+	ellipsis: "",
+	ellipsisWidth: 0
+};
+const fastStringWidth = (input, options = {}) => {
+	return dist_default$1(input, NO_TRUNCATION, options).width;
+};
+var dist_default = fastStringWidth;
+
+//#endregion
+//#region node_modules/fast-wrap-ansi/lib/main.js
+const ESC$1 = "\x1B";
+const CSI$1 = "›";
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = "\x07";
+const ANSI_CSI = "[";
+const ANSI_OSC = "]";
+const ANSI_SGR_TERMINATOR = "m";
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+const GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+const getClosingCode = (openingCode) => {
+	if (openingCode >= 30 && openingCode <= 37) return 39;
+	if (openingCode >= 90 && openingCode <= 97) return 39;
+	if (openingCode >= 40 && openingCode <= 47) return 49;
+	if (openingCode >= 100 && openingCode <= 107) return 49;
+	if (openingCode === 1 || openingCode === 2) return 22;
+	if (openingCode === 3) return 23;
+	if (openingCode === 4) return 24;
+	if (openingCode === 7) return 27;
+	if (openingCode === 8) return 28;
+	if (openingCode === 9) return 29;
+	if (openingCode === 0) return 0;
+};
+const wrapAnsiCode = (code) => `${ESC$1}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = (url) => `${ESC$1}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+const wrapWord = (rows, word, columns) => {
+	const characters = word[Symbol.iterator]();
+	let isInsideEscape = false;
+	let isInsideLinkEscape = false;
+	let lastRow = rows.at(-1);
+	let visible = lastRow === void 0 ? 0 : dist_default(lastRow);
+	let currentCharacter = characters.next();
+	let nextCharacter = characters.next();
+	let rawCharacterIndex = 0;
+	while (!currentCharacter.done) {
+		const character = currentCharacter.value;
+		const characterLength = dist_default(character);
+		if (visible + characterLength <= columns) rows[rows.length - 1] += character;
+		else {
+			rows.push(character);
+			visible = 0;
+		}
+		if (character === ESC$1 || character === CSI$1) {
+			isInsideEscape = true;
+			isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+		}
+		if (isInsideEscape) {
+			if (isInsideLinkEscape) {
+				if (character === ANSI_ESCAPE_BELL) {
+					isInsideEscape = false;
+					isInsideLinkEscape = false;
+				}
+			} else if (character === ANSI_SGR_TERMINATOR) isInsideEscape = false;
+		} else {
+			visible += characterLength;
+			if (visible === columns && !nextCharacter.done) {
+				rows.push("");
+				visible = 0;
+			}
+		}
+		currentCharacter = nextCharacter;
+		nextCharacter = characters.next();
+		rawCharacterIndex += character.length;
+	}
+	lastRow = rows.at(-1);
+	if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) rows[rows.length - 2] += rows.pop();
+};
+const stringVisibleTrimSpacesRight = (string) => {
+	const words = string.split(" ");
+	let last = words.length;
+	while (last) {
+		if (dist_default(words[last - 1])) break;
+		last--;
+	}
+	if (last === words.length) return string;
+	return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+const exec = (string, columns, options = {}) => {
+	if (options.trim !== false && string.trim() === "") return "";
+	let returnValue = "";
+	let escapeCode;
+	let escapeUrl;
+	const words = string.split(" ");
+	let rows = [""];
+	let rowLength = 0;
+	for (let index = 0; index < words.length; index++) {
+		const word = words[index];
+		if (options.trim !== false) {
+			const row = rows.at(-1) ?? "";
+			const trimmed = row.trimStart();
+			if (row.length !== trimmed.length) {
+				rows[rows.length - 1] = trimmed;
+				rowLength = dist_default(trimmed);
+			}
+		}
+		if (index !== 0) {
+			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+				rows.push("");
+				rowLength = 0;
+			}
+			if (rowLength || options.trim === false) {
+				rows[rows.length - 1] += " ";
+				rowLength++;
+			}
+		}
+		const wordLength = dist_default(word);
+		if (options.hard && wordLength > columns) {
+			const remainingColumns = columns - rowLength;
+			const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+			if (Math.floor((wordLength - 1) / columns) < breaksStartingThisLine) rows.push("");
+			wrapWord(rows, word, columns);
+			rowLength = dist_default(rows.at(-1) ?? "");
+			continue;
+		}
+		if (rowLength + wordLength > columns && rowLength && wordLength) {
+			if (options.wordWrap === false && rowLength < columns) {
+				wrapWord(rows, word, columns);
+				rowLength = dist_default(rows.at(-1) ?? "");
+				continue;
+			}
+			rows.push("");
+			rowLength = 0;
+		}
+		if (rowLength + wordLength > columns && options.wordWrap === false) {
+			wrapWord(rows, word, columns);
+			rowLength = dist_default(rows.at(-1) ?? "");
+			continue;
+		}
+		rows[rows.length - 1] += word;
+		rowLength += wordLength;
+	}
+	if (options.trim !== false) rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+	const preString = rows.join("\n");
+	let inSurrogate = false;
+	for (let i$1 = 0; i$1 < preString.length; i$1++) {
+		const character = preString[i$1];
+		returnValue += character;
+		if (!inSurrogate) {
+			inSurrogate = character >= "\ud800" && character <= "\udbff";
+			if (inSurrogate) continue;
+		} else inSurrogate = false;
+		if (character === ESC$1 || character === CSI$1) {
+			GROUP_REGEX.lastIndex = i$1 + 1;
+			const groups = GROUP_REGEX.exec(preString)?.groups;
+			if (groups?.code !== void 0) {
+				const code = Number.parseFloat(groups.code);
+				escapeCode = code === END_CODE ? void 0 : code;
+			} else if (groups?.uri !== void 0) escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+		}
+		if (preString[i$1 + 1] === "\n") {
+			if (escapeUrl) returnValue += wrapAnsiHyperlink("");
+			const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+			if (escapeCode && closingCode) returnValue += wrapAnsiCode(closingCode);
+		} else if (character === "\n") {
+			if (escapeCode && getClosingCode(escapeCode)) returnValue += wrapAnsiCode(escapeCode);
+			if (escapeUrl) returnValue += wrapAnsiHyperlink(escapeUrl);
+		}
+	}
+	return returnValue;
+};
+const CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+	return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+
+//#endregion
+//#region node_modules/sisteransi/src/index.js
+var require_src = /* @__PURE__ */ __commonJS({ "node_modules/sisteransi/src/index.js": ((exports, module) => {
+	const ESC = "\x1B";
+	const CSI = `${ESC}[`;
+	const beep = "\x07";
+	const cursor$2 = {
+		to(x, y) {
+			if (!y) return `${CSI}${x + 1}G`;
+			return `${CSI}${y + 1};${x + 1}H`;
+		},
+		move(x, y) {
+			let ret = "";
+			if (x < 0) ret += `${CSI}${-x}D`;
+			else if (x > 0) ret += `${CSI}${x}C`;
+			if (y < 0) ret += `${CSI}${-y}A`;
+			else if (y > 0) ret += `${CSI}${y}B`;
+			return ret;
+		},
+		up: (count = 1) => `${CSI}${count}A`,
+		down: (count = 1) => `${CSI}${count}B`,
+		forward: (count = 1) => `${CSI}${count}C`,
+		backward: (count = 1) => `${CSI}${count}D`,
+		nextLine: (count = 1) => `${CSI}E`.repeat(count),
+		prevLine: (count = 1) => `${CSI}F`.repeat(count),
+		left: `${CSI}G`,
+		hide: `${CSI}?25l`,
+		show: `${CSI}?25h`,
+		save: `${ESC}7`,
+		restore: `${ESC}8`
+	};
+	const scroll = {
+		up: (count = 1) => `${CSI}S`.repeat(count),
+		down: (count = 1) => `${CSI}T`.repeat(count)
+	};
+	const erase$2 = {
+		screen: `${CSI}2J`,
+		up: (count = 1) => `${CSI}1J`.repeat(count),
+		down: (count = 1) => `${CSI}J`.repeat(count),
+		line: `${CSI}2K`,
+		lineEnd: `${CSI}K`,
+		lineStart: `${CSI}1K`,
+		lines(count) {
+			let clear = "";
+			for (let i$1 = 0; i$1 < count; i$1++) clear += this.line + (i$1 < count - 1 ? cursor$2.up() : "");
+			if (count) clear += cursor$2.left;
+			return clear;
+		}
+	};
+	module.exports = {
+		cursor: cursor$2,
+		scroll,
+		erase: erase$2,
+		beep
+	};
+}) });
+
+//#endregion
+//#region node_modules/@clack/core/dist/index.mjs
+var import_src$1 = /* @__PURE__ */ __toESM(require_src(), 1);
+function findCursor(s, o, l) {
+	if (!l.some((r$1) => !r$1.disabled)) return s;
+	const t = s + o, n$2 = Math.max(l.length - 1, 0), e = t < 0 ? n$2 : t > n$2 ? 0 : t;
+	return l[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l) : e;
+}
+const settings = {
+	actions: new Set([
+		"up",
+		"down",
+		"left",
+		"right",
+		"space",
+		"enter",
+		"cancel"
+	]),
+	aliases: /* @__PURE__ */ new Map([
+		["k", "up"],
+		["j", "down"],
+		["h", "left"],
+		["l", "right"],
+		["", "cancel"],
+		["escape", "cancel"]
+	]),
+	messages: {
+		cancel: "Canceled",
+		error: "Something went wrong"
+	},
+	withGuide: true,
+	date: {
+		monthNames: [...[
+			"January",
+			"February",
+			"March",
+			"April",
+			"May",
+			"June",
+			"July",
+			"August",
+			"September",
+			"October",
+			"November",
+			"December"
+		]],
+		messages: {
+			required: "Please enter a valid date",
+			invalidMonth: "There are only 12 months in a year",
+			invalidDay: (n$2, e) => `There are only ${n$2} days in ${e}`,
+			afterMin: (n$2) => `Date must be on or after ${n$2.toISOString().slice(0, 10)}`,
+			beforeMax: (n$2) => `Date must be on or before ${n$2.toISOString().slice(0, 10)}`
+		}
+	}
+};
+function isActionKey(n$2, e) {
+	if (typeof n$2 == "string") return settings.aliases.get(n$2) === e;
+	for (const s of n$2) if (s !== void 0 && isActionKey(s, e)) return true;
+	return false;
+}
+function diffLines(i$1, s) {
+	if (i$1 === s) return;
+	const e = i$1.split(`
+`), t = s.split(`
+`), r$1 = Math.max(e.length, t.length), f = [];
+	for (let n$2 = 0; n$2 < r$1; n$2++) e[n$2] !== t[n$2] && f.push(n$2);
+	return {
+		lines: f,
+		numLinesBefore: e.length,
+		numLinesAfter: t.length,
+		numLines: r$1
+	};
+}
+const R = globalThis.process.platform.startsWith("win");
+const CANCEL_SYMBOL = Symbol("clack:cancel");
+function isCancel(e) {
+	return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r$1) {
+	const o = e;
+	o.isTTY && o.setRawMode(r$1);
+}
+const getColumns = (e) => "columns" in e && typeof e.columns == "number" ? e.columns : 80, getRows = (e) => "rows" in e && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r$1, o, t = o, s = o, n$2) {
+	return wrapAnsi(r$1, getColumns(e ?? stdout) - o.length, {
+		hard: true,
+		trim: false
+	}).split(`
+`).map((c, i$1, m$1) => {
+		const d = n$2 ? n$2(c, i$1) : c;
+		return i$1 === 0 ? `${t}${d}` : i$1 === m$1.length - 1 ? `${s}${d}` : `${o}${d}`;
+	}).join(`
+`);
+}
+function runValidation(e, n$2) {
+	if ("~standard" in e) {
+		const a$1 = e["~standard"].validate(n$2);
+		if (a$1 instanceof Promise) throw new TypeError("Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic.");
+		return a$1.issues?.at(0)?.message;
+	}
+	return e(n$2);
+}
+var V = class {
+	input;
+	output;
+	_abortSignal;
+	rl;
+	opts;
+	_render;
+	_track = false;
+	_prevFrame = "";
+	_subscribers = /* @__PURE__ */ new Map();
+	_cursor = 0;
+	state = "initial";
+	error = "";
+	value;
+	userInput = "";
+	constructor(t, e = true) {
+		const { input: i$1 = stdin, output: n$2 = stdout, render: s, signal: r$1,...o } = t;
+		this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r$1, this.input = i$1, this.output = n$2;
+	}
+	/**
+	* Unsubscribe all listeners
+	*/
+	unsubscribe() {
+		this._subscribers.clear();
+	}
+	/**
+	* Set a subscriber with opts
+	* @param event - The event name
+	*/
+	setSubscriber(t, e) {
+		const i$1 = this._subscribers.get(t) ?? [];
+		i$1.push(e), this._subscribers.set(t, i$1);
+	}
+	/**
+	* Subscribe to an event
+	* @param event - The event name
+	* @param cb - The callback
+	*/
+	on(t, e) {
+		this.setSubscriber(t, { cb: e });
+	}
+	/**
+	* Subscribe to an event once
+	* @param event - The event name
+	* @param cb - The callback
+	*/
+	once(t, e) {
+		this.setSubscriber(t, {
+			cb: e,
+			once: true
+		});
+	}
+	/**
+	* Emit an event with data
+	* @param event - The event name
+	* @param data - The data to pass to the callback
+	*/
+	emit(t, ...e) {
+		const i$1 = this._subscribers.get(t) ?? [], n$2 = [];
+		for (const s of i$1) s.cb(...e), s.once && n$2.push(() => i$1.splice(i$1.indexOf(s), 1));
+		for (const s of n$2) s();
+	}
+	prompt() {
+		return new Promise((t) => {
+			if (this._abortSignal) {
+				if (this._abortSignal.aborted) return this.state = "cancel", this.close(), t(CANCEL_SYMBOL);
+				this._abortSignal.addEventListener("abort", () => {
+					this.state = "cancel", this.close();
+				}, { once: true });
+			}
+			this.rl = l__default.createInterface({
+				input: this.input,
+				tabSize: 2,
+				prompt: "",
+				escapeCodeTimeout: 50,
+				terminal: true
+			}), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+				this.output.write(import_src$1.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(this.value);
+			}), this.once("cancel", () => {
+				this.output.write(import_src$1.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(CANCEL_SYMBOL);
+			});
+		});
+	}
+	_isActionKey(t, e) {
+		return t === "	";
+	}
+	_shouldSubmit(t, e) {
+		return true;
+	}
+	_setValue(t) {
+		this.value = t, this.emit("value", this.value);
+	}
+	_setUserInput(t, e) {
+		this.userInput = t ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+	}
+	_clearUserInput() {
+		this.rl?.write(null, {
+			ctrl: true,
+			name: "u"
+		}), this._setUserInput("");
+	}
+	onKeypress(t, e) {
+		if (this._track && e.name !== "return" && (e.name && this._isActionKey(t, e) && this.rl?.write(null, {
+			ctrl: true,
+			name: "h"
+		}), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t && (t.toLowerCase() === "y" || t.toLowerCase() === "n") && this.emit("confirm", t.toLowerCase() === "y"), this.emit("key", t, e), e?.name === "return" && this._shouldSubmit(t, e)) {
+			if (this.opts.validate) {
+				const i$1 = runValidation(this.opts.validate, this.value);
+				i$1 && (this.error = i$1 instanceof Error ? i$1.message : i$1, this.state = "error", this.rl?.write(this.userInput));
+			}
+			this.state !== "error" && (this.state = "submit");
+		}
+		isActionKey([
+			t,
+			e?.name,
+			e?.sequence
+		], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+	}
+	close() {
+		this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+	}
+	restoreCursor() {
+		const t = wrapAnsi(this._prevFrame, process.stdout.columns, {
+			hard: true,
+			trim: false
+		}).split(`
+`).length - 1;
+		this.output.write(import_src$1.cursor.move(-999, t * -1));
+	}
+	render() {
+		const t = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+			hard: true,
+			trim: false
+		});
+		if (t !== this._prevFrame) {
+			if (this.state === "initial") this.output.write(import_src$1.cursor.hide);
+			else {
+				const e = diffLines(this._prevFrame, t), i$1 = getRows(this.output);
+				if (this.restoreCursor(), e) {
+					const n$2 = Math.max(0, e.numLinesAfter - i$1), s = Math.max(0, e.numLinesBefore - i$1);
+					let r$1 = e.lines.find((o) => o >= n$2);
+					if (r$1 === void 0) {
+						this._prevFrame = t;
+						return;
+					}
+					if (e.lines.length === 1) {
+						this.output.write(import_src$1.cursor.move(0, r$1 - s)), this.output.write(import_src$1.erase.lines(1));
+						const o = t.split(`
+`);
+						this.output.write(o[r$1]), this._prevFrame = t, this.output.write(import_src$1.cursor.move(0, o.length - r$1 - 1));
+						return;
+					} else if (e.lines.length > 1) {
+						if (n$2 < s) r$1 = n$2;
+						else {
+							const h$1 = r$1 - s;
+							h$1 > 0 && this.output.write(import_src$1.cursor.move(0, h$1));
+						}
+						this.output.write(import_src$1.erase.down());
+						const f = t.split(`
+`).slice(r$1);
+						this.output.write(f.join(`
+`)), this._prevFrame = t;
+						return;
+					}
+				}
+				this.output.write(import_src$1.erase.down());
+			}
+			this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
+		}
+	}
+};
+var a = class extends V {
+	options;
+	cursor = 0;
+	get _value() {
+		return this.options[this.cursor]?.value;
+	}
+	get _enabledOptions() {
+		return this.options.filter((e) => e.disabled !== true);
+	}
+	toggleAll() {
+		const e = this._enabledOptions;
+		this.value = this.value !== void 0 && this.value.length === e.length ? [] : e.map((t) => t.value);
+	}
+	toggleInvert() {
+		const e = this.value;
+		if (!e) return;
+		this.value = this._enabledOptions.filter((t) => !e.includes(t.value)).map((t) => t.value);
+	}
+	toggleValue() {
+		this.value === void 0 && (this.value = []);
+		this.value = this.value.includes(this._value) ? this.value.filter((i$1) => i$1 !== this._value) : [...this.value, this._value];
+	}
+	constructor(e) {
+		super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+		const i$1 = Math.max(this.options.findIndex(({ value: t }) => t === e.cursorAt), 0);
+		this.cursor = this.options[i$1]?.disabled ? findCursor(i$1, 1, this.options) : i$1, this.on("key", (t, l) => {
+			l.name === "a" && this.toggleAll(), l.name === "i" && this.toggleInvert();
+		}), this.on("cursor", (t) => {
+			switch (t) {
+				case "left":
+				case "up":
+					this.cursor = findCursor(this.cursor, -1, this.options);
+					break;
+				case "down":
+				case "right":
+					this.cursor = findCursor(this.cursor, 1, this.options);
+					break;
+				case "space":
+					this.toggleValue();
+					break;
+			}
+		});
+	}
+};
+
+//#endregion
+//#region node_modules/@clack/prompts/dist/index.mjs
+var import_src = /* @__PURE__ */ __toESM(require_src(), 1);
+function isUnicodeSupported() {
+	if (process$1.platform !== "win32") return process$1.env.TERM !== "linux";
+	return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+const unicode = isUnicodeSupported(), isCI = () => process.env.CI === "true", isTTY = (o) => o.isTTY === true, unicodeOr = (o, e) => unicode ? o : e, S_STEP_ACTIVE = unicodeOr("◆", "*"), S_STEP_CANCEL = unicodeOr("■", "x"), S_STEP_ERROR = unicodeOr("▲", "x"), S_STEP_SUBMIT = unicodeOr("◇", "o"), S_BAR_START = unicodeOr("┌", "T"), S_BAR = unicodeOr("│", "|"), S_BAR_END = unicodeOr("└", "—"), S_BAR_START_RIGHT = unicodeOr("┐", "T"), S_BAR_END_RIGHT = unicodeOr("┘", "—"), S_RADIO_ACTIVE = unicodeOr("●", ">"), S_RADIO_INACTIVE = unicodeOr("○", " "), S_CHECKBOX_ACTIVE = unicodeOr("◻", "[•]"), S_CHECKBOX_SELECTED = unicodeOr("◼", "[+]"), S_CHECKBOX_INACTIVE = unicodeOr("◻", "[ ]"), S_PASSWORD_MASK = unicodeOr("▪", "•"), S_BAR_H = unicodeOr("─", "-"), S_CORNER_TOP_RIGHT = unicodeOr("╮", "+"), S_CONNECT_LEFT = unicodeOr("├", "+"), S_CORNER_BOTTOM_RIGHT = unicodeOr("╯", "+"), S_CORNER_BOTTOM_LEFT = unicodeOr("╰", "+"), S_CORNER_TOP_LEFT = unicodeOr("╭", "+"), S_INFO = unicodeOr("●", "•"), S_SUCCESS = unicodeOr("◆", "*"), S_WARN = unicodeOr("▲", "!"), S_ERROR = unicodeOr("■", "x"), symbol = (o) => {
+	switch (o) {
+		case "initial":
+		case "active": return styleText("cyan", S_STEP_ACTIVE);
+		case "cancel": return styleText("red", S_STEP_CANCEL);
+		case "error": return styleText("yellow", S_STEP_ERROR);
+		case "submit": return styleText("green", S_STEP_SUBMIT);
+	}
+}, symbolBar = (o) => {
+	switch (o) {
+		case "initial":
+		case "active": return styleText("cyan", S_BAR);
+		case "cancel": return styleText("red", S_BAR);
+		case "error": return styleText("yellow", S_BAR);
+		case "submit": return styleText("green", S_BAR);
+	}
+};
+function formatInstructionFooter(o, e) {
+	const r$1 = [`${e ? `${styleText("cyan", S_BAR)}  ` : ""}${o.join(" • ")}`];
+	return e && r$1.push(styleText("cyan", S_BAR_END)), r$1;
+}
+const I = (l, e, w, p$1, b, C = false) => {
+	let r$1 = e, O = 0;
+	if (C) for (let i$1 = p$1 - 1; i$1 >= w; i$1--) {
+		const m$1 = l[i$1];
+		if (m$1 && (r$1 -= m$1.length), O++, r$1 <= b) break;
+	}
+	else for (let i$1 = w; i$1 < p$1; i$1++) {
+		const m$1 = l[i$1];
+		if (m$1 && (r$1 -= m$1.length), O++, r$1 <= b) break;
+	}
+	return {
+		lineCount: r$1,
+		removals: O
+	};
+};
+const limitOptions = ({ cursor: l, options: e, style: w, output: p$1 = process.stdout, maxItems: b = Number.POSITIVE_INFINITY, columnPadding: C = 0, rowPadding: r$1 = 4 }) => {
+	const i$1 = getColumns(p$1) - C, m$1 = getRows(p$1), M = styleText("dim", "..."), v = Math.max(m$1 - r$1, 0), a$1 = Math.max(Math.min(b, v), 5);
+	let f = 0;
+	l >= a$1 - 3 && (f = Math.max(Math.min(l - a$1 + 3, e.length - a$1), 0));
+	let d = a$1 < e.length && f > 0, c = a$1 < e.length && f + a$1 < e.length;
+	const W = Math.min(f + a$1, e.length), s = [];
+	let g = 0;
+	d && g++, c && g++;
+	const T = f + (d ? 1 : 0), y = W - (c ? 1 : 0);
+	for (let t = T; t < y; t++) {
+		const n$2 = e[t], h$1 = wrapAnsi(n$2 ? w(n$2, t === l) : "", i$1, {
+			hard: true,
+			trim: false
+		}).split(`
+`);
+		s.push(h$1), g += h$1.length;
+	}
+	if (g > v) {
+		let t = 0, n$2 = 0, o = g;
+		const h$1 = l - T;
+		let u$4 = v;
+		const L = () => I(s, o, 0, h$1, u$4), E = () => I(s, o, h$1 + 1, s.length, u$4, true);
+		d ? ({lineCount: o, removals: t} = L(), o > u$4 && (c || (u$4 -= 1), {lineCount: o, removals: n$2} = E())) : (c || (u$4 -= 1), {lineCount: o, removals: n$2} = E(), o > u$4 && (u$4 -= 1, {lineCount: o, removals: t} = L())), t > 0 && (d = true, s.splice(0, t)), n$2 > 0 && (c = true, s.splice(s.length - n$2, n$2));
+	}
+	const x = [];
+	d && x.push(M);
+	for (const t of s) for (const n$2 of t) x.push(n$2);
+	return c && x.push(M), x;
+};
+const MULTISELECT_INSTRUCTIONS = [
+	`${styleText("dim", "↑/↓")} to navigate`,
+	`${styleText("dim", "Space:")} select`,
+	`${styleText("dim", "Enter:")} confirm`
+];
+const m = (i$1, u$4) => i$1.split(`
+`).map((d) => u$4(d)).join(`
+`);
+const multiselect = (i$1) => {
+	const u$4 = (t, a$1) => {
+		const r$1 = t.label ?? String(t.value);
+		return a$1 === "disabled" ? `${styleText("gray", S_CHECKBOX_INACTIVE)} ${m(r$1, (o) => styleText(["strikethrough", "gray"], o))}${t.hint ? ` ${styleText("dim", `(${t.hint ?? "disabled"})`)}` : ""}` : a$1 === "active" ? `${styleText("cyan", S_CHECKBOX_ACTIVE)} ${r$1}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a$1 === "selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${m(r$1, (o) => styleText("dim", o))}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a$1 === "cancelled" ? `${m(r$1, (o) => styleText(["strikethrough", "dim"], o))}` : a$1 === "active-selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${r$1}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a$1 === "submitted" ? `${m(r$1, (o) => styleText("dim", o))}` : `${styleText("dim", S_CHECKBOX_INACTIVE)} ${m(r$1, (o) => styleText("dim", o))}`;
+	}, d = i$1.required ?? true, v = i$1.showInstructions ?? true;
+	return new a({
+		options: i$1.options,
+		signal: i$1.signal,
+		input: i$1.input,
+		output: i$1.output,
+		initialValues: i$1.initialValues,
+		required: d,
+		cursorAt: i$1.cursorAt,
+		validate(t) {
+			if (d && (t === void 0 || t.length === 0)) return `Please select at least one option.
+${styleText("reset", styleText("dim", `Press ${styleText([
+				"gray",
+				"bgWhite",
+				"inverse"
+			], " space ")} to select, ${styleText("gray", styleText("bgWhite", styleText("inverse", " enter ")))} to submit`))}`;
+		},
+		render() {
+			const t = i$1.withGuide ?? settings.withGuide, a$1 = wrapTextWithPrefix(i$1.output, i$1.message, t ? `${symbolBar(this.state)}  ` : "", `${symbol(this.state)}  `), r$1 = `${t ? `${styleText("gray", S_BAR)}
+` : ""}${a$1}
+`, o = this.value ?? [], p$1 = (n$2, l) => {
+				if (n$2.disabled) return u$4(n$2, "disabled");
+				const s = o.includes(n$2.value);
+				return l && s ? u$4(n$2, "active-selected") : s ? u$4(n$2, "selected") : u$4(n$2, l ? "active" : "inactive");
+			};
+			switch (this.state) {
+				case "submit": {
+					const n$2 = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u$4(s, "submitted")).join(styleText("dim", ", ")) || styleText("dim", "none");
+					return `${r$1}${wrapTextWithPrefix(i$1.output, n$2, t ? `${styleText("gray", S_BAR)}  ` : "")}`;
+				}
+				case "cancel": {
+					const n$2 = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u$4(s, "cancelled")).join(styleText("dim", ", "));
+					if (n$2.trim() === "") return `${r$1}${styleText("gray", S_BAR)}`;
+					return `${r$1}${wrapTextWithPrefix(i$1.output, n$2, t ? `${styleText("gray", S_BAR)}  ` : "")}${t ? `
+${styleText("gray", S_BAR)}` : ""}`;
+				}
+				case "error": {
+					const n$2 = t ? `${styleText("yellow", S_BAR)}  ` : "", l = this.error.split(`
+`).map(($, C) => C === 0 ? `${t ? `${styleText("yellow", S_BAR_END)}  ` : ""}${styleText("yellow", $)}` : `   ${$}`).join(`
+`), s = r$1.split(`
+`).length, h$1 = l.split(`
+`).length + 1;
+					return `${r$1}${n$2}${limitOptions({
+						output: i$1.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: i$1.maxItems,
+						columnPadding: n$2.length,
+						rowPadding: s + h$1,
+						style: p$1
+					}).join(`
+${n$2}`)}
+${l}
+`;
+				}
+				default: {
+					const n$2 = t ? `${styleText("cyan", S_BAR)}  ` : "", l = r$1.split(`
+`).length, s = v ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t) : t ? [styleText("cyan", S_BAR_END)] : [], h$1 = s.join(`
+`), $ = s.length + 1;
+					return `${r$1}${n$2}${limitOptions({
+						output: i$1.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: i$1.maxItems,
+						columnPadding: n$2.length,
+						rowPadding: l + $,
+						style: p$1
+					}).join(`
+${n$2}`)}
+${h$1}
+`;
+				}
+			}
+		}
+	}).prompt();
+};
+const cancel = (o = "", t) => {
+	const i$1 = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR_END)}  ` : "";
+	i$1.write(`${e}${styleText("red", o)}
+
+`);
+}, intro = (o = "", t) => {
+	const i$1 = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR_START)}  ` : "";
+	i$1.write(`${e}${o}
+`);
+}, outro = (o = "", t) => {
+	const i$1 = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR)}
+${styleText("gray", S_BAR_END)}  ` : "";
+	i$1.write(`${e}${o}
+
+`);
+};
+const u$3 = {
+	light: unicodeOr("─", "-"),
+	heavy: unicodeOr("━", "="),
+	block: unicodeOr("█", "#")
+};
+const SELECT_INSTRUCTIONS = [`${styleText("dim", "↑/↓")} to navigate`, `${styleText("dim", "Enter:")} confirm`];
+const i = `${styleText("gray", S_BAR)}  `;
+
+//#endregion
+//#region src/util/prompt.ts
+/** Space to toggle, `a` for all, enter to confirm. Cancelling selects nothing. */
+async function multiSelect(message, choices) {
+	if (!choices.length) return [];
+	const picked = await multiselect({
+		message,
+		options: choices.map((c) => ({
+			value: c.value,
+			label: c.label,
+			hint: c.hint
+		})),
+		initialValues: choices.map((c) => c.value),
+		required: false
+	});
+	if (isCancel(picked)) {
+		cancel("cancelled");
+		return [];
+	}
+	return picked;
+}
+function isInteractive() {
+	return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+/**
+* Ask only when the user has not already decided and someone is there to answer. A prompt in
+* a piped or scripted run would hang forever, so this is the one gate that must not regress.
+*/
+function shouldAsk(opts) {
+	return opts.requested === 0 && !opts.all && opts.interactive;
+}
+
+//#endregion
+//#region src/util/fs.ts
+async function exists(p$1) {
+	try {
+		await lstat(p$1);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function ensureDir(path) {
+	await mkdir(path, { recursive: true });
+}
+async function backup(path, archiveDir) {
+	if (!await exists(path)) return null;
+	const dest = join(archiveDir, basename(path));
+	await ensureDir(archiveDir);
+	await copyFile(path, dest);
+	return dest;
+}
+function stable(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+	return `{${Object.entries(value).sort(([a$1], [b]) => a$1 < b ? -1 : a$1 > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stable(v)}`).join(",")}}`;
+}
+async function writeJson(path, value) {
+	await ensureDir(dirname(path));
+	await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+//#endregion
+//#region src/commands/setup/agents/extensions.ts
+/** The delivery an extension uses on one agent, or null when it deliberately reaches none. */
+function deliveryFor(extension, agent) {
+	const declared = extension.deliver[agent] ?? extension.deliver.all;
+	if (!declared) throw new Error(`extension "${extension.name}" declares no delivery for ${agent}`);
+	return typeof declared === "string" ? null : declared;
+}
+function skillDeliveries(config$1, agent) {
+	const out = [];
+	for (const extension of config$1.extensions) {
+		const delivery = deliveryFor(extension, agent);
+		if (delivery?.via === "skills") out.push(delivery);
+	}
+	return out;
+}
+function claudePluginDeliveries(config$1) {
+	const out = [];
+	for (const extension of config$1.extensions) {
+		const delivery = deliveryFor(extension, "claude-code");
+		if (delivery?.via === "claude-plugin") out.push(delivery);
+	}
+	return out;
+}
+function opencodePluginPackages(config$1) {
+	const out = [];
+	for (const extension of config$1.extensions) {
+		const delivery = deliveryFor(extension, "opencode");
+		if (delivery?.via === "opencode-plugin") out.push(delivery.package);
+	}
+	return out;
+}
+/** MCP servers this agent should run, keyed by extension name. */
+function mcpServersFor(config$1, agent) {
+	const out = {};
+	for (const extension of config$1.extensions) {
+		const delivery = deliveryFor(extension, agent);
+		if (delivery?.via === "mcp") out[extension.name] = delivery.server;
+	}
+	return out;
+}
+/**
+* Every extension must resolve on every configured agent, and every `claude-plugin` delivery
+* must name a declared marketplace. Runs before any emitter so a gap fails the whole run
+* rather than silently under-installing one agent.
+*/
+function validateExtensions(config$1) {
+	const problems = [];
+	for (const extension of config$1.extensions) {
+		for (const agent of config$1.agents) if (!(extension.deliver[agent] ?? extension.deliver.all)) problems.push(`${extension.name}: no delivery for ${agent} — add one, or "unsupported"/"skip"`);
+		for (const [key, delivery] of Object.entries(extension.deliver)) {
+			if (key !== "all" && !config$1.agents.includes(key)) problems.push(`${extension.name}: delivery for "${key}", which is not in config.agents`);
+			if (typeof delivery === "object" && delivery.via === "claude-plugin") {
+				if (!config$1.marketplaces[delivery.marketplace]) problems.push(`${extension.name}: unknown marketplace "${delivery.marketplace}"`);
+			}
+		}
+	}
+	if (problems.length) throw new Error(`config.extensions is incomplete:\n  - ${problems.join("\n  - ")}`);
+}
+/** One line per extension showing how it reaches each agent — "does X cover opencode?". */
+function logCoverage(config$1) {
+	log.section("Extensions");
+	const rows = config$1.extensions.map((extension) => ({
+		name: extension.name,
+		cells: config$1.agents.map((agent) => {
+			const declared = extension.deliver[agent] ?? extension.deliver.all;
+			return `${agent} → ${typeof declared === "string" ? declared : declared.via}`;
+		})
+	}));
+	const nameWidth = Math.max(...rows.map((r$1) => r$1.name.length));
+	const cellWidths = config$1.agents.map((_, i$1) => Math.max(...rows.map((r$1) => r$1.cells[i$1].length)));
+	for (const { name: name$1, cells } of rows) {
+		const line = cells.map((c, i$1) => c.padEnd(cellWidths[i$1])).join("   ");
+		log.info(`${name$1.padEnd(nameWidth)}   ${line.trimEnd()}`);
+	}
+}
+
+//#endregion
+//#region src/commands/setup/agents/installs.ts
+const SKILL_LOCK = ".agents/.skill-lock.json";
+const MARKETPLACE_REGISTRY = ".claude/plugins/known_marketplaces.json";
+/**
+* `claude plugin` installs, preceded by the marketplaces they come from. Each marketplace
+* appears once however many plugins reference it; built-in ones ship with Claude Code.
+*/
+function claudePluginInstalls(config$1, home) {
+	const out = [];
+	const added = /* @__PURE__ */ new Set();
+	for (const { marketplace, plugin } of claudePluginDeliveries(config$1)) {
+		const market = config$1.marketplaces[marketplace];
+		if (!market.builtin && !added.has(marketplace)) {
+			added.add(marketplace);
+			out.push({
+				kind: "install",
+				label: `marketplace ${marketplace}`,
+				requires: "claude",
+				command: [
+					"claude",
+					"plugin",
+					"marketplace",
+					"add",
+					market.repo
+				],
+				probe: {
+					kind: "claude-marketplace",
+					name: marketplace,
+					registryFile: join(home, MARKETPLACE_REGISTRY)
+				}
+			});
+		}
+		const id = `${plugin}@${marketplace}`;
+		out.push({
+			kind: "install",
+			label: id,
+			requires: "claude",
+			command: [
+				"claude",
+				"plugin",
+				"install",
+				id
+			],
+			probe: {
+				kind: "claude-plugin",
+				id
+			}
+		});
+	}
+	return out;
+}
+/**
+* skills.sh installs into the shared `~/.agents` store. `linkDir` is where the agent expects
+* to find each skill afterwards — omit it for agents that read the store directly.
+*/
+function skillInstalls(config$1, agent, home, linkDir) {
+	return skillDeliveries(config$1, agent).map((delivery) => {
+		const command$1 = [
+			"npx",
+			"-y",
+			"skills",
+			"add",
+			delivery.repo,
+			"-g",
+			"-y",
+			"-a",
+			agent
+		];
+		if (delivery.skills?.length) command$1.push("-s", ...delivery.skills);
+		return {
+			kind: "install",
+			label: `${delivery.repo} (${delivery.skills?.length ?? "all"})`,
+			requires: "npx",
+			command: command$1,
+			probe: {
+				kind: "skills",
+				lockFile: join(home, SKILL_LOCK),
+				names: delivery.skills ?? [],
+				...linkDir && { linkDir }
+			}
+		};
+	});
+}
+
+//#endregion
+//#region src/commands/setup/agents/store.ts
+const AGENTS_STORE = ".agents/skills";
+async function authoredSkillNames(ctx) {
+	return (await readdir(join(ctx.repoRoot, ctx.config.authoredSkillsDir), { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+async function buildStorePlan(ctx) {
+	const src = join(ctx.repoRoot, ctx.config.authoredSkillsDir);
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+	const archiveDir = join(ctx.home, ".agents/.setup-backups", stamp);
+	return {
+		archiveDir,
+		groups: [{
+			section: "Skills store (~/.agents/skills)",
+			artifacts: (await authoredSkillNames(ctx)).map((name$1) => ({
+				kind: "symlink",
+				target: join(src, name$1),
+				linkPath: join(ctx.home, AGENTS_STORE, name$1),
+				archiveDisplaced: join(archiveDir, "skills")
+			}))
+		}]
+	};
+}
+
+//#endregion
+//#region src/commands/setup/agents/emitters/claude-code.ts
+const CONFIG_DIR$1 = ".claude";
+const ARCHIVE_DIR = ".setup-backups";
+const claudeCode = {
+	id: "claude-code",
+	configDir: CONFIG_DIR$1,
+	buildPlan: buildPlan$1
+};
+async function buildPlan$1(ctx) {
+	const root = join(ctx.home, CONFIG_DIR$1);
+	const archiveDir = join(root, ARCHIVE_DIR, (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-"));
+	const cc = ctx.config.claudeCode;
+	const statuslinePath = join(root, "statusline-command.sh");
+	const plugins = claudePluginDeliveries(ctx.config);
+	const groups = [
+		{
+			section: "Plugins",
+			artifacts: claudePluginInstalls(ctx.config, ctx.home)
+		},
+		{
+			section: "Skills (remote)",
+			artifacts: skillInstalls(ctx.config, "claude-code", ctx.home, join(root, "skills"))
+		},
+		{
+			section: "Skills (authored)",
+			artifacts: await authoredSkillLinks(ctx, root, archiveDir)
+		},
+		{
+			section: "Instructions & statusline",
+			artifacts: [{
+				kind: "file",
+				src: join(ctx.repoRoot, ctx.config.instructionsFile),
+				dest: join(root, "CLAUDE.md")
+			}, {
+				kind: "file",
+				src: join(ctx.repoRoot, cc.statuslineScript),
+				dest: statuslinePath,
+				mode: 493
+			}]
+		},
+		{
+			section: "settings.json",
+			artifacts: [{
+				kind: "jsonMerge",
+				dest: join(root, "settings.json"),
+				managed: settingsFor(cc),
+				derived: {
+					statusLine: {
+						type: "command",
+						command: `bash ${statuslinePath}`
+					},
+					enabledPlugins: enabledPluginsMap(plugins),
+					extraKnownMarketplaces: marketplacesMap(plugins, ctx.config.marketplaces)
+				}
+			}]
+		}
+	];
+	const mcpServers = mcpServersFor(ctx.config, "claude-code");
+	if (Object.keys(mcpServers).length) groups.push({
+		section: "~/.claude.json",
+		artifacts: [{
+			kind: "jsonMerge",
+			dest: join(ctx.home, ".claude.json"),
+			managed: {},
+			derived: { mcpServers: mapValues(mcpServers, claudeMcp) }
+		}]
+	});
+	if (cc.commandsDir) groups.push({
+		section: "Commands",
+		artifacts: await commandFiles(ctx.repoRoot, cc.commandsDir, root)
+	});
+	return {
+		archiveDir,
+		groups
+	};
+}
+function enabledPluginsMap(deliveries) {
+	return Object.fromEntries(deliveries.map((d) => [`${d.plugin}@${d.marketplace}`, true]));
+}
+function marketplacesMap(deliveries, marketplaces) {
+	const referenced = [...new Set(deliveries.map((d) => d.marketplace))];
+	return Object.fromEntries(referenced.filter((name$1) => !marketplaces[name$1].builtin).map((name$1) => [name$1, { source: {
+		source: "github",
+		repo: marketplaces[name$1].repo
+	} }]));
+}
+function claudeMcp(server) {
+	return server.transport === "stdio" ? {
+		type: "stdio",
+		command: server.command[0],
+		args: server.command.slice(1),
+		...server.env && { env: server.env }
+	} : {
+		type: "http",
+		url: server.url,
+		...server.headers && { headers: server.headers }
+	};
+}
+function mapValues(record, fn) {
+	return Object.fromEntries(Object.entries(record).map(([k, v]) => [k, fn(v)]));
+}
+async function authoredSkillLinks(ctx, root, archiveDir) {
+	return (await authoredSkillNames(ctx)).map((name$1) => ({
+		kind: "symlink",
+		target: `../../${AGENTS_STORE}/${name$1}`,
+		linkPath: join(root, "skills", name$1),
+		archiveDisplaced: join(archiveDir, "agent-skills")
+	}));
+}
+async function commandFiles(repoRoot, dir, root) {
+	const src = resolve(repoRoot, dir);
+	return (await readdir(src)).filter((f) => f.endsWith(".md")).sort().map((f) => ({
+		kind: "file",
+		src: join(src, f),
+		dest: join(root, "commands", f)
+	}));
+}
+function settingsFor(cc) {
+	const out = {};
+	if (cc.effort !== void 0) out.effortLevel = cc.effort;
+	if (cc.autoCompactWindow !== void 0) out.autoCompactWindow = cc.autoCompactWindow;
+	if (cc.tui !== void 0) out.tui = cc.tui;
+	if (cc.cleanupPeriodDays !== void 0) out.cleanupPeriodDays = cc.cleanupPeriodDays;
+	if (cc.voice !== void 0) out.voiceEnabled = cc.voice;
+	if (cc.autoDream !== void 0) out.autoDreamEnabled = cc.autoDream;
+	if (cc.agentPushNotifications !== void 0) out.agentPushNotifEnabled = cc.agentPushNotifications;
+	if (cc.permissions?.defaultMode !== void 0) out.permissions = { defaultMode: cc.permissions.defaultMode };
+	if (cc.permissions?.skipDangerousModePrompt !== void 0) out.skipDangerousModePermissionPrompt = cc.permissions.skipDangerousModePrompt;
+	if (cc.permissions?.skipAutoPrompt !== void 0) out.skipAutoPermissionPrompt = cc.permissions.skipAutoPrompt;
+	if (cc.hooks !== void 0) out.hooks = cc.hooks;
+	return out;
+}
+
+//#endregion
+//#region src/commands/setup/agents/emitters/opencode.ts
+const CONFIG_DIR = ".config/opencode";
+/** opencode accepts either name; write to whichever already exists so we never fork the config. */
+const CONFIG_FILES = ["opencode.jsonc", "opencode.json"];
+const opencode = {
+	id: "opencode",
+	configDir: CONFIG_DIR,
+	buildPlan
+};
+async function buildPlan(ctx) {
+	const root = join(ctx.home, CONFIG_DIR);
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+	const groups = [{
+		section: "Skills (remote)",
+		artifacts: skillInstalls(ctx.config, "opencode", ctx.home)
+	}, {
+		section: "Instructions",
+		artifacts: [{
+			kind: "file",
+			src: join(ctx.repoRoot, ctx.config.instructionsFile),
+			dest: join(root, "AGENTS.md")
+		}]
+	}];
+	const derived = configKeys(ctx.config);
+	if (Object.keys(derived).length) groups.push({
+		section: "opencode config",
+		artifacts: [{
+			kind: "jsonMerge",
+			dest: await configPath(root),
+			managed: {},
+			derived
+		}]
+	});
+	return {
+		archiveDir: join(root, ".setup-backups", stamp),
+		groups
+	};
+}
+async function configPath(root) {
+	for (const name$1 of CONFIG_FILES) if (await exists(join(root, name$1))) return join(root, name$1);
+	return join(root, CONFIG_FILES[1]);
+}
+function configKeys(config$1) {
+	const out = {};
+	const plugin = opencodePluginPackages(config$1);
+	if (plugin.length) out.plugin = plugin;
+	const servers = Object.entries(mcpServersFor(config$1, "opencode"));
+	if (servers.length) out.mcp = Object.fromEntries(servers.map(([name$1, server]) => [name$1, opencodeMcp(server)]));
+	return out;
+}
+function opencodeMcp(server) {
+	return server.transport === "stdio" ? {
+		type: "local",
+		command: server.command,
+		enabled: true,
+		...server.env && { environment: server.env }
+	} : {
+		type: "remote",
+		url: server.url,
+		enabled: true,
+		...server.headers && { headers: server.headers }
+	};
+}
+
+//#endregion
+//#region src/commands/setup/agents/emitters/index.ts
+const emitters = {
+	"claude-code": claudeCode,
+	opencode,
+	codex: null
+};
+
+//#endregion
+//#region src/util/exec.ts
+function run(cmd) {
+	return new Promise((resolve$1) => {
+		const [bin, ...args] = cmd;
+		const proc = spawn(bin, args);
+		let stdout$1 = "";
+		let stderr = "";
+		proc.stdout.on("data", (d) => stdout$1 += d);
+		proc.stderr.on("data", (d) => stderr += d);
+		proc.on("error", () => resolve$1({
+			ok: false,
+			stdout: stdout$1,
+			stderr
+		}));
+		proc.on("close", (code) => resolve$1({
+			ok: code === 0,
+			stdout: stdout$1,
+			stderr
+		}));
+	});
+}
+async function which(bin) {
+	return (await run([
+		"sh",
+		"-c",
+		`command -v ${bin}`
+	])).ok;
+}
+
+//#endregion
+//#region src/commands/setup/agents/diff.ts
+async function diff(plan) {
+	const probes = new Probes();
+	const sections = [];
+	for (const group of plan.groups) {
+		const changes = [];
+		for (const artifact of group.artifacts) changes.push(await changeFor(artifact, plan.archiveDir, probes));
+		sections.push({
+			title: group.section,
+			changes
+		});
+	}
+	return sections;
+}
+function changeFor(a$1, archiveDir, probes) {
+	switch (a$1.kind) {
+		case "file": return fileChange(a$1);
+		case "symlink": return symlinkChange(a$1);
+		case "jsonMerge": return jsonMergeChange(a$1, archiveDir);
+		case "install": return installChange(a$1, probes);
+	}
+}
+async function fileChange(a$1) {
+	const next = await readFile(a$1.src);
+	if ((await readFile(a$1.dest).catch(() => null))?.equals(next)) return {
+		status: "unchanged",
+		label: a$1.dest
+	};
+	return {
+		status: "pending",
+		label: a$1.dest,
+		action: {
+			do: "write-file",
+			src: a$1.src,
+			dest: a$1.dest,
+			...a$1.mode && { mode: a$1.mode }
+		}
+	};
+}
+async function symlinkChange(a$1) {
+	const label = `${a$1.linkPath} → ${a$1.target}`;
+	const link = {
+		do: "link",
+		target: a$1.target,
+		linkPath: a$1.linkPath
+	};
+	if (!await exists(a$1.linkPath)) return {
+		status: "pending",
+		label,
+		action: link
+	};
+	if ((await lstat(a$1.linkPath)).isSymbolicLink()) {
+		if (await readlink(a$1.linkPath) === a$1.target) return {
+			status: "unchanged",
+			label
+		};
+		return {
+			status: "pending",
+			label,
+			action: {
+				...link,
+				removeExisting: true
+			}
+		};
+	}
+	if (!a$1.archiveDisplaced) return {
+		status: "blocked",
+		label,
+		reason: `${a$1.linkPath} exists as a real directory`
+	};
+	const archiveTo = join(a$1.archiveDisplaced, basename(a$1.linkPath));
+	return {
+		status: "pending",
+		label,
+		action: {
+			...link,
+			archiveTo
+		}
+	};
+}
+async function jsonMergeChange(a$1, archiveDir) {
+	const label = basename(a$1.dest);
+	const raw = await readFile(a$1.dest, "utf8").catch(() => null);
+	let current = {};
+	if (raw !== null) try {
+		current = JSON.parse(raw);
+	} catch {
+		return {
+			status: "blocked",
+			label,
+			reason: "not parseable JSON (comments?)"
+		};
+	}
+	const value = {
+		...current,
+		...a$1.managed,
+		...a$1.derived
+	};
+	if (stable(current) === stable(value)) return {
+		status: "unchanged",
+		label
+	};
+	const notes = Object.keys(value).filter((k) => stable(current[k]) !== stable(value[k])).map((k) => `set ${k}${k in a$1.derived ? " (derived)" : ""}`);
+	const unmanaged = Object.keys(current).filter((k) => !(k in a$1.managed) && !(k in a$1.derived));
+	if (unmanaged.length) notes.push(`preserved unmanaged keys: ${unmanaged.join(", ")}`);
+	return {
+		status: "pending",
+		label,
+		action: {
+			do: "write-json",
+			dest: a$1.dest,
+			value,
+			backupTo: archiveDir
+		},
+		notes
+	};
+}
+async function installChange(a$1, probes) {
+	if (!await probes.onPath(a$1.requires)) return {
+		status: "blocked",
+		label: a$1.label,
+		reason: `\`${a$1.requires}\` not on PATH`
+	};
+	if (await probes.satisfied(a$1.probe)) return {
+		status: "unchanged",
+		label: a$1.label
+	};
+	return {
+		status: "pending",
+		label: a$1.label,
+		action: {
+			do: "run",
+			command: a$1.command
+		}
+	};
+}
+/** Memoised machine lookups — `claude plugin list` costs a process spawn, so it runs once. */
+var Probes = class {
+	onPathCache = /* @__PURE__ */ new Map();
+	jsonCache = /* @__PURE__ */ new Map();
+	plugins;
+	onPath(bin) {
+		let hit = this.onPathCache.get(bin);
+		if (!hit) this.onPathCache.set(bin, hit = which(bin));
+		return hit;
+	}
+	async satisfied(probe) {
+		switch (probe.kind) {
+			case "claude-plugin": return (await this.installedPlugins()).has(probe.id);
+			case "claude-marketplace": {
+				const registry = await this.json(probe.registryFile);
+				return !!registry && probe.name in registry;
+			}
+			case "skills": {
+				if (!probe.names.length) return false;
+				const skills = (await this.json(probe.lockFile))?.skills ?? {};
+				for (const name$1 of probe.names) {
+					if (!(name$1 in skills)) return false;
+					if (probe.linkDir && !await exists(join(probe.linkDir, name$1))) return false;
+				}
+				return true;
+			}
+		}
+	}
+	installedPlugins() {
+		this.plugins ??= run([
+			"claude",
+			"plugin",
+			"list"
+		]).then((res) => new Set(res.stdout.match(/[\w.-]+@[\w.-]+/g) ?? []));
+		return this.plugins;
+	}
+	json(file) {
+		let hit = this.jsonCache.get(file);
+		if (!hit) {
+			hit = readFile(file, "utf8").then((raw) => {
+				try {
+					return JSON.parse(raw);
+				} catch {
+					return null;
+				}
+			}, () => null);
+			this.jsonCache.set(file, hit);
+		}
+		return hit;
+	}
+};
+
+//#endregion
+//#region src/commands/setup/agents/executor.ts
+/** The one place `dryRun` is consulted: the same diff is either printed or committed. */
+async function runPlan(plan, dryRun) {
+	await walk(await diff(plan), dryRun ? render : commit);
+}
+async function walk(sections, handle) {
+	for (const { title, changes } of sections) {
+		log.section(title);
+		for (const change of changes) await handle(change);
+	}
+}
+function render(change) {
+	switch (change.status) {
+		case "unchanged": return log.skip(`${change.label} (unchanged)`);
+		case "blocked": return log.warn(`${change.label} — ${change.reason}, leaving it alone`);
+		case "pending":
+			log.plan(phrase(change.action));
+			for (const note of change.notes ?? []) log.info(note);
+	}
+}
+async function commit(change) {
+	switch (change.status) {
+		case "unchanged": return log.skip(`${change.label} (unchanged)`);
+		case "blocked": return log.fail(`${change.label} — ${change.reason}, leaving it alone`);
+		case "pending": {
+			const { ok, notes } = await perform(change.action);
+			if (!ok) return log.fail(`${change.label}: ${notes.join(" ")}`);
+			log.ok(change.label);
+			for (const note of [...notes, ...change.notes ?? []]) log.info(note);
+		}
+	}
+}
+async function perform(action) {
+	switch (action.do) {
+		case "write-file": {
+			const bytes = await readFile(action.src);
+			await ensureDir(dirname(action.dest));
+			await writeFile(action.dest, bytes, action.mode ? { mode: action.mode } : void 0);
+			return {
+				ok: true,
+				notes: []
+			};
+		}
+		case "link": {
+			const notes = [];
+			if (action.archiveTo) {
+				await ensureDir(dirname(action.archiveTo));
+				await rename(action.linkPath, action.archiveTo);
+				notes.push(`archived → ${action.archiveTo}`);
+			} else if (action.removeExisting) await rm(action.linkPath, {
+				recursive: true,
+				force: true
+			});
+			await ensureDir(dirname(action.linkPath));
+			await symlink(action.target, action.linkPath);
+			return {
+				ok: true,
+				notes
+			};
+		}
+		case "write-json": {
+			const bak = await backup(action.dest, action.backupTo);
+			await writeJson(action.dest, action.value);
+			return {
+				ok: true,
+				notes: bak ? [`backed up → ${bak}`] : []
+			};
+		}
+		case "run": {
+			const res = await run(action.command);
+			const output = res.stdout + res.stderr;
+			if (res.ok) return {
+				ok: true,
+				notes: []
+			};
+			if (/already/i.test(output)) return {
+				ok: true,
+				notes: ["already present"]
+			};
+			return {
+				ok: false,
+				notes: [output.trim().split("\n").slice(-1)[0] ?? "failed"]
+			};
+		}
+	}
+}
+function phrase(action) {
+	switch (action.do) {
+		case "write-file": return `write ${action.dest}`;
+		case "link":
+			if (action.archiveTo) return `archive ${action.linkPath} → ${action.archiveTo}, then link`;
+			return `${action.removeExisting ? "relink" : "link"} ${action.linkPath} → ${action.target}`;
+		case "write-json": return `write ${action.dest}`;
+		case "run": return action.command.join(" ");
+	}
+}
+
+//#endregion
+//#region src/commands/setup/agents/apply.ts
+/** An agent with no config directory is not on this machine — skip it, never create it. */
+function isInstalled(home, emitter) {
+	return exists(join(home, emitter.configDir));
+}
+async function applyAgents(ctx, ids, dryRun) {
+	validateExtensions(ctx.config);
+	logCoverage(ctx.config);
+	await runPlan(await buildStorePlan(ctx), dryRun);
+	for (const id of ids) {
+		const emitter = emitters[id];
+		if (!emitter) continue;
+		log.agent(id);
+		if (!await isInstalled(ctx.home, emitter)) {
+			log.warn(`${id} not installed on this machine — skipping`);
+			continue;
+		}
+		await runPlan(await emitter.buildPlan(ctx), dryRun);
+	}
+}
+
+//#endregion
+//#region src/commands/setup/agents/index.ts
+var import_picocolors$2 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const USAGE$1 = `Usage: pakhale setup agents [plan] [options]
+
+Apply the coding-agent workflow (plugins, skills, settings) to this machine.
+With a terminal and no --agent, you are asked which agents to apply to; piped or
+scripted runs apply to every configured agent.
+
+  plan               dry run — show every change, write nothing
+
+Options:
+  -n, --dry-run      same as plan
+  -a, --agent <id>   target one agent (repeatable) — skips the prompt
+      --all          every configured agent — skips the prompt
+      --home <dir>   apply against a different home directory
+  -h, --help         show this help`;
+const agents = {
+	name: "agents",
+	describe: "apply the coding-agent workflow (plugins, skills, settings) to this machine",
+	async run(argv$1, packageRoot$1) {
+		const { values, positionals } = parseArgs({
+			args: argv$1,
+			options: {
+				"dry-run": {
+					type: "boolean",
+					short: "n",
+					default: false
+				},
+				agent: {
+					type: "string",
+					short: "a",
+					multiple: true
+				},
+				all: {
+					type: "boolean",
+					default: false
+				},
+				home: { type: "string" },
+				help: {
+					type: "boolean",
+					short: "h",
+					default: false
+				}
+			},
+			allowPositionals: true
+		});
+		if (values.help) {
+			console.log(USAGE$1);
+			return 0;
+		}
+		const dryRun = values["dry-run"] || positionals.includes("plan");
+		const home = values.home ? resolve(values.home) : homedir();
+		const only = values.agent ?? [];
+		const available = (only.length ? only : config.agents).filter((id) => {
+			if (emitters[id]) return true;
+			log.warn(`no emitter for "${id}" yet — skipping`);
+			return false;
+		});
+		const selected = shouldAsk({
+			requested: only.length,
+			all: values.all,
+			interactive: isInteractive()
+		}) ? await chooseAgents(available, home) : available;
+		if (!selected.length) {
+			log.fail("nothing to do");
+			return 1;
+		}
+		const mode = dryRun ? ` ${import_picocolors$2.default.yellow("(dry run)")}` : "";
+		const where = home === homedir() ? "" : ` ${import_picocolors$2.default.magenta(`[home=${home}]`)}`;
+		console.log(`\npakhale setup agents${mode}${where} → ${selected.join(", ")}`);
+		await applyAgents({
+			home,
+			repoRoot: packageRoot$1,
+			config
+		}, selected, dryRun);
+		console.log(dryRun ? `\n${import_picocolors$2.default.yellow("dry run complete — nothing written")}\n` : `\n${import_picocolors$2.default.green("done")}\n`);
+		return 0;
+	}
+};
+async function chooseAgents(ids, home) {
+	return await multiSelect("Which agents?", await Promise.all(ids.map(async (id) => ({
+		value: id,
+		label: id,
+		hint: await isInstalled(home, emitters[id]) ? "" : "not installed here"
+	}))));
+}
+
+//#endregion
+//#region src/commands/setup/index.ts
+var import_picocolors$1 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+/** One entry per thing this machine can be set up from `config.ts`. */
+const targets = { [agents.name]: agents };
+const USAGE = `Usage: pakhale setup <target> [options]
+
+Set up part of this machine from the declarations in config.ts.
+
+Targets:
+${Object.values(targets).map((t) => `  ${t.name.padEnd(10)} ${t.describe}`).join("\n")}
+
+Run \`pakhale setup <target> --help\` for a target's own options.`;
+const setup = {
+	name: "setup",
+	describe: "set up this machine from config.ts",
+	async run(argv$1, packageRoot$1) {
+		const [name$1, ...rest$1] = argv$1;
+		if (!name$1) {
+			console.error(import_picocolors$1.default.red("setup needs a target\n"));
+			console.log(USAGE);
+			return 1;
+		}
+		if (name$1 === "--help" || name$1 === "-h") {
+			console.log(USAGE);
+			return 0;
+		}
+		const target = targets[name$1];
+		if (!target) {
+			console.error(import_picocolors$1.default.red(`unknown setup target: ${name$1}\n`));
+			console.log(USAGE);
+			return 1;
+		}
+		return target.run(rest$1, packageRoot$1);
+	}
+};
+
+//#endregion
+//#region src/commands/index.ts
+const commands = { [setup.name]: setup };
+
+//#endregion
+//#region src/cli.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const [name, ...rest] = process.argv.slice(2);
+async function version() {
+	return JSON.parse(await readFile(join(packageRoot, "package.json"), "utf8")).version;
+}
+function usage() {
+	console.log(`Usage: pakhale <command> [options]\n\nCommands:`);
+	for (const c of Object.values(commands)) console.log(`  ${c.name.padEnd(10)} ${c.describe}`);
+	console.log(`\nOptions:\n  -h, --help     show this help\n  -v, --version  show version`);
+}
+if (!name || name === "--help" || name === "-h") {
+	usage();
+	process.exit(0);
+}
+if (name === "--version" || name === "-v") {
+	console.log(await version());
+	process.exit(0);
+}
+const command = commands[name];
+if (!command) {
+	console.error(import_picocolors.default.red(`unknown command: ${name}\n`));
+	usage();
+	process.exit(1);
+}
+try {
+	process.exit(await command.run(rest, packageRoot));
+} catch (err) {
+	console.error(import_picocolors.default.red(err instanceof Error ? err.message : String(err)));
+	process.exit(1);
+}
+
+//#endregion
+export {  };