@lousy-agents/cli 5.8.1 → 5.8.2

package/api/copilot-with-fastify/.devcontainer/devcontainer.json

@@ -10,7 +10,7 @@
         },
         "ghcr.io/devcontainers/features/copilot-cli:1.0.0": {},
         "ghcr.io/anthropics/devcontainer-features/claude-code:1": {
-            "version": "v2.1.86"
+            "version": "v2.1.90"
         },
         "ghcr.io/rocker-org/devcontainer-features/apt-packages:1.0.2": {
             "packages": "yamllint, shellcheck",

package/cli/copilot-with-citty/.devcontainer/devcontainer.json

@@ -10,7 +10,7 @@
         },
         "ghcr.io/devcontainers/features/copilot-cli:1.0.0": {},
         "ghcr.io/anthropics/devcontainer-features/claude-code:1": {
-            "version": "v2.1.86"
+            "version": "v2.1.90"
         },
         "ghcr.io/rocker-org/devcontainer-features/apt-packages:1.0.2": {
             "packages": "yamllint, shellcheck",

package/cli/copilot-with-citty/package.json

@@ -14,7 +14,7 @@
         "lint:yaml": "yamllint ."
     },
     "dependencies": {
-        "citty": "0.2.1",
+        "citty": "0.2.2",
         "consola": "3.4.2",
         "zod": "4.3.6"
     },

package/dist/index.js

@@ -9694,6 +9694,7 @@ __webpack_require__.d(constructs_namespaceObject, {
 
 
 ;// CONCATENATED MODULE: ../../node_modules/citty/dist/_chunks/libs/scule.mjs
+//#region node_modules/.pnpm/scule@1.3.0/node_modules/scule/dist/index.mjs
 const NUMBER_CHAR_RE = /\d/;
 const STR_SPLITTERS = [
 	"-",
@@ -9758,6 +9759,10 @@ function camelCase(str, opts) {
 function kebabCase(str, joiner) {
 	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
 }
+function snakeCase(str) {
+	return kebabCase(str || "", "_");
+}
+//#endregion
 
 
 // EXTERNAL MODULE: external "node:util"
@@ -9765,6 +9770,7 @@ var external_node_util_ = __webpack_require__(7975);
 ;// CONCATENATED MODULE: ../../node_modules/citty/dist/index.mjs
 
 
+//#region src/_utils.ts
 function toArray(val) {
 	if (Array.isArray(val)) return val;
 	return val === void 0 ? [] : [val];
@@ -9785,6 +9791,8 @@ var CLIError = class extends Error {
 		this.code = code;
 	}
 };
+//#endregion
+//#region src/_parser.ts
 function parseRawArgs(args = [], opts = {}) {
 	const booleans = new Set(opts.boolean || []);
 	const strings = new Set(opts.string || []);
@@ -9810,6 +9818,12 @@ function parseRawArgs(args = [], opts = {}) {
 		for (const alias of aliases) if (booleans.has(alias)) return "boolean";
 		return "string";
 	}
+	function isStringType(name) {
+		if (strings.has(name)) return true;
+		const aliases = mainToAliases.get(name) || [];
+		for (const alias of aliases) if (strings.has(alias)) return true;
+		return false;
+	}
 	const allOptions = new Set([
 		...booleans,
 		...strings,
@@ -9853,7 +9867,12 @@ function parseRawArgs(args = [], opts = {}) {
 	}
 	const out = { _: [] };
 	out._ = parsed.positionals;
-	for (const [key, value] of Object.entries(parsed.values)) out[key] = value;
+	for (const [key, value] of Object.entries(parsed.values)) {
+		let coerced = value;
+		if (getType(key) === "boolean" && typeof value === "string") coerced = value !== "false";
+		else if (isStringType(key) && typeof value === "boolean") coerced = "";
+		out[key] = coerced;
+	}
 	for (const [name] of Object.entries(negatedFlags)) {
 		out[name] = false;
 		const mainName = aliasToMain.get(name);
@@ -9864,9 +9883,12 @@ function parseRawArgs(args = [], opts = {}) {
 	for (const [alias, main] of aliasToMain.entries()) {
 		if (out[alias] !== void 0 && out[main] === void 0) out[main] = out[alias];
 		if (out[main] !== void 0 && out[alias] === void 0) out[alias] = out[main];
+		if (out[alias] !== out[main] && defaults[main] === out[main]) out[main] = out[alias];
 	}
 	return out;
 }
+//#endregion
+//#region src/_color.ts
 const noColor = /* @__PURE__ */ (() => {
 	const env = globalThis.process?.env ?? {};
 	return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
@@ -9876,6 +9898,8 @@ const bold = /* @__PURE__ */ _c(1, 22);
 const cyan = /* @__PURE__ */ _c(36);
 const gray = /* @__PURE__ */ _c(90);
 const underline = /* @__PURE__ */ _c(4, 24);
+//#endregion
+//#region src/args.ts
 function parseArgs(rawArgs, argsDef) {
 	const parseOptions = {
 		boolean: [],
@@ -9925,6 +9949,16 @@ function resolveArgs(argsDef) {
 	});
 	return args;
 }
+//#endregion
+//#region src/plugin.ts
+function defineCittyPlugin(plugin) {
+	return plugin;
+}
+async function resolvePlugins(plugins) {
+	return Promise.all(plugins.map((p) => resolveValue(p)));
+}
+//#endregion
+//#region src/command.ts
 function defineCommand(def) {
 	return def;
 }
@@ -9937,35 +9971,94 @@ async function dist_runCommand(cmd, opts) {
 		data: opts.data,
 		cmd
 	};
-	if (typeof cmd.setup === "function") await cmd.setup(context);
+	const plugins = await resolvePlugins(cmd.plugins ?? []);
 	let result;
+	let runError;
 	try {
+		for (const plugin of plugins) await plugin.setup?.(context);
+		if (typeof cmd.setup === "function") await cmd.setup(context);
 		const subCommands = await resolveValue(cmd.subCommands);
 		if (subCommands && Object.keys(subCommands).length > 0) {
-			const subCommandArgIndex = opts.rawArgs.findIndex((arg) => !arg.startsWith("-"));
-			const subCommandName = opts.rawArgs[subCommandArgIndex];
-			if (subCommandName) {
-				if (!subCommands[subCommandName]) throw new CLIError(`Unknown command ${cyan(subCommandName)}`, "E_UNKNOWN_COMMAND");
-				const subCommand = await resolveValue(subCommands[subCommandName]);
-				if (subCommand) await dist_runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
-			} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+			const subCommandArgIndex = findSubCommandIndex(opts.rawArgs, cmdArgs);
+			const explicitName = opts.rawArgs[subCommandArgIndex];
+			if (explicitName) {
+				const subCommand = await _findSubCommand(subCommands, explicitName);
+				if (!subCommand) throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
+				await dist_runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+			} else {
+				const defaultSubCommand = await resolveValue(cmd.default);
+				if (defaultSubCommand) {
+					if (cmd.run) throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
+					const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
+					if (!subCommand) throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
+					await dist_runCommand(subCommand, { rawArgs: opts.rawArgs });
+				} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+			}
 		}
 		if (typeof cmd.run === "function") result = await cmd.run(context);
-	} finally {
-		if (typeof cmd.cleanup === "function") await cmd.cleanup(context);
+	} catch (error) {
+		runError = error;
+	}
+	const cleanupErrors = [];
+	if (typeof cmd.cleanup === "function") try {
+		await cmd.cleanup(context);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	for (const plugin of [...plugins].reverse()) try {
+		await plugin.cleanup?.(context);
+	} catch (error) {
+		cleanupErrors.push(error);
 	}
+	if (runError) throw runError;
+	if (cleanupErrors.length === 1) throw cleanupErrors[0];
+	if (cleanupErrors.length > 1) throw new Error("Multiple cleanup errors", { cause: cleanupErrors });
 	return { result };
 }
 async function resolveSubCommand(cmd, rawArgs, parent) {
 	const subCommands = await resolveValue(cmd.subCommands);
 	if (subCommands && Object.keys(subCommands).length > 0) {
-		const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
+		const subCommandArgIndex = findSubCommandIndex(rawArgs, await resolveValue(cmd.args || {}));
 		const subCommandName = rawArgs[subCommandArgIndex];
-		const subCommand = await resolveValue(subCommands[subCommandName]);
+		const subCommand = await _findSubCommand(subCommands, subCommandName);
 		if (subCommand) return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
 	}
 	return [cmd, parent];
 }
+async function _findSubCommand(subCommands, name) {
+	if (name in subCommands) return resolveValue(subCommands[name]);
+	for (const sub of Object.values(subCommands)) {
+		const resolved = await resolveValue(sub);
+		const meta = await resolveValue(resolved?.meta);
+		if (meta?.alias) {
+			if (toArray(meta.alias).includes(name)) return resolved;
+		}
+	}
+}
+function findSubCommandIndex(rawArgs, argsDef) {
+	for (let i = 0; i < rawArgs.length; i++) {
+		const arg = rawArgs[i];
+		if (arg === "--") return -1;
+		if (arg.startsWith("-")) {
+			if (!arg.includes("=") && _isValueFlag(arg, argsDef)) i++;
+			continue;
+		}
+		return i;
+	}
+	return -1;
+}
+function _isValueFlag(flag, argsDef) {
+	const name = flag.replace(/^-{1,2}/, "");
+	const normalized = camelCase(name);
+	for (const [key, def] of Object.entries(argsDef)) {
+		if (def.type !== "string" && def.type !== "enum") continue;
+		if (normalized === camelCase(key)) return true;
+		if ((Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : []).includes(name)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/usage.ts
 async function showUsage(cmd, parent) {
 	try {
 		console.log(await renderUsage(cmd, parent) + "\n");
@@ -9986,22 +10079,22 @@ async function renderUsage(cmd, parent) {
 	for (const arg of cmdArgs) if (arg.type === "positional") {
 		const name = arg.name.toUpperCase();
 		const isRequired = arg.required !== false && arg.default === void 0;
-		const defaultHint = arg.default ? `="${arg.default}"` : "";
-		posLines.push([
-			cyan(name + defaultHint),
-			arg.description || "",
-			arg.valueHint ? `<${arg.valueHint}>` : ""
-		]);
+		posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
 		usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
 	} else {
 		const isRequired = arg.required === true && arg.default === void 0;
-		const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "") + (arg.type === "enum" && arg.options ? `=<${arg.options.join("|")}>` : "");
-		argLines.push([cyan(argStr + (isRequired ? " (required)" : "")), arg.description || ""]);
+		const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
+		argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
+		/**
+		* print negative boolean arg variant usage when
+		* - enabled by default or has `negativeDescription`
+		* - not prefixed with `no-` or `no[A-Z]`
+		*/
 		if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
 			const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
-			argLines.push([cyan(negativeArgStr + (isRequired ? " (required)" : "")), arg.negativeDescription || ""]);
+			argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
 		}
-		if (isRequired) usageLine.push(argStr);
+		if (isRequired) usageLine.push(`--${arg.name}` + renderValueHint(arg));
 	}
 	if (cmd.subCommands) {
 		const commandNames = [];
@@ -10009,8 +10102,10 @@ async function renderUsage(cmd, parent) {
 		for (const [name, sub] of Object.entries(subCommands)) {
 			const meta = await resolveValue((await resolveValue(sub))?.meta);
 			if (meta?.hidden) continue;
-			commandsLines.push([cyan(name), meta?.description || ""]);
-			commandNames.push(name);
+			const aliases = toArray(meta?.alias);
+			const label = [name, ...aliases].join(", ");
+			commandsLines.push([cyan(label), meta?.description || ""]);
+			commandNames.push(name, ...aliases);
 		}
 		usageLine.push(commandNames.join("|"));
 	}
@@ -10036,14 +10131,33 @@ async function renderUsage(cmd, parent) {
 	}
 	return usageLines.filter((l) => typeof l === "string").join("\n");
 }
+function renderValueHint(arg) {
+	const valueHint = arg.valueHint ? `=<${arg.valueHint}>` : "";
+	const fallbackValueHint = valueHint || `=<${snakeCase(arg.name)}>`;
+	if (!arg.type || arg.type === "positional" || arg.type === "boolean") return valueHint;
+	if (arg.type === "enum" && arg.options?.length) return `=<${arg.options.join("|")}>`;
+	return fallbackValueHint;
+}
+function renderDescription(arg, required) {
+	const requiredHint = required ? gray("(Required)") : "";
+	const defaultHint = arg.default === void 0 ? "" : gray(`(Default: ${arg.default})`);
+	return [
+		arg.description,
+		requiredHint,
+		defaultHint
+	].filter(Boolean).join(" ");
+}
+//#endregion
+//#region src/main.ts
 async function runMain(cmd, opts = {}) {
 	const rawArgs = opts.rawArgs || process.argv.slice(2);
 	const showUsage$1 = opts.showUsage || showUsage;
 	try {
-		if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+		const builtinFlags = await _resolveBuiltinFlags(cmd);
+		if (builtinFlags.help.length > 0 && rawArgs.some((arg) => builtinFlags.help.includes(arg))) {
 			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
 			process.exit(0);
-		} else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
+		} else if (rawArgs.length === 1 && builtinFlags.version.includes(rawArgs[0])) {
 			const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
 			if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
 			console.log(meta.version);
@@ -10059,6 +10173,25 @@ async function runMain(cmd, opts = {}) {
 function createMain(cmd) {
 	return (opts = {}) => runMain(cmd, opts);
 }
+async function _resolveBuiltinFlags(cmd) {
+	const argsDef = await resolveValue(cmd.args || {});
+	const userNames = /* @__PURE__ */ new Set();
+	const userAliases = /* @__PURE__ */ new Set();
+	for (const [name, def] of Object.entries(argsDef)) {
+		userNames.add(name);
+		for (const alias of toArray(def.alias)) userAliases.add(alias);
+	}
+	return {
+		help: _getBuiltinFlags("help", "h", userNames, userAliases),
+		version: _getBuiltinFlags("version", "v", userNames, userAliases)
+	};
+}
+function _getBuiltinFlags(long, short, userNames, userAliases) {
+	if (userNames.has(long) || userAliases.has(long)) return [];
+	if (userNames.has(short) || userAliases.has(short)) return [`--${long}`];
+	return [`--${long}`, `-${short}`];
+}
+//#endregion
 
 
 // EXTERNAL MODULE: external "node:fs/promises"
@@ -13378,7 +13511,7 @@ function partial(Class, schema, mask) {
     });
     return clone(schema, def);
 }
-function required(Class, schema, mask) {
+function util_required(Class, schema, mask) {
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const oldShape = schema._zod.def.shape;
@@ -25300,7 +25433,7 @@ const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
     inst.pick = (mask) => pick(inst, mask);
     inst.omit = (mask) => omit(inst, mask);
     inst.partial = (...args) => partial(ZodOptional, inst, args[0]);
-    inst.required = (...args) => required(ZodNonOptional, inst, args[0]);
+    inst.required = (...args) => util_required(ZodNonOptional, inst, args[0]);
 });
 function schemas_object(shape, params) {
     const def = {