@politty/zod 0.0.0

package/dist/index.js

@@ -0,0 +1,17 @@
+import { i as toKebabCase, r as toCamelCase } from "./field-meta-DMy5BcRr.js";
+import { t as arg$1 } from "./register-Bk0K83W2.js";
+import { n as generateCompileCacheShim } from "./src-KzC0g5CS.js";
+import { r as getUnknownKeysMode, t as extractFields } from "./schema-extractor-DMSozq40.js";
+import { n as defineCommand$1, t as createDefineCommand$1 } from "./command-k-4yAz4J.js";
+import { o as isLazyCommand, s as lazy } from "./subcommand-router-Cskpofdk.js";
+import { a as generateCompletion, p as generateBundledCompletionWorker, s as withCompletionCommand } from "./completion-gtWX3mwP.js";
+import { C as generateHelp, E as createDualCaseProxy, S as ReservedFieldNameError, T as renderMarkdown, _ as DuplicateFieldError, a as formatCommandValidationErrors, b as PositionalConfigError, c as validateCrossSchemaCollisions, d as validateDuplicateNegations, f as validatePositionalConfig, g as DuplicateAliasError, h as CaseVariantCollisionError, i as parseArgv, l as validateDuplicateAliases, m as validateReservedFieldNames, n as runMain, o as validateCaseVariantCollisions, p as validateReservedAliases, r as formatValidationErrors, s as validateCommand, t as runCommand, u as validateDuplicateFields, v as DuplicateNegationError, w as renderInline, x as ReservedAliasError, y as FieldTypeConflictError } from "./runner-D72I7wvK.js";
+import { a as symbols, i as styles, n as logger, r as setColorEnabled, t as isColorEnabled } from "./logger-i_bb-Jhc.js";
+
+//#region src/index.ts
+const defineCommand = defineCommand$1;
+const createDefineCommand = createDefineCommand$1;
+const arg = arg$1;
+
+//#endregion
+export { CaseVariantCollisionError, DuplicateAliasError, DuplicateFieldError, DuplicateNegationError, FieldTypeConflictError, PositionalConfigError, ReservedAliasError, ReservedFieldNameError, arg, createDefineCommand, createDualCaseProxy, defineCommand, extractFields, formatCommandValidationErrors, formatValidationErrors, generateBundledCompletionWorker, generateCompileCacheShim, generateCompletion, generateHelp, getUnknownKeysMode, isColorEnabled, isLazyCommand, lazy, logger, parseArgv, renderInline, renderMarkdown, runCommand, runMain, setColorEnabled, styles, symbols, toCamelCase, toKebabCase, validateCaseVariantCollisions, validateCommand, validateCrossSchemaCollisions, validateDuplicateAliases, validateDuplicateFields, validateDuplicateNegations, validatePositionalConfig, validateReservedAliases, validateReservedFieldNames, withCompletionCommand };

package/dist/log-collector-CoUkLVJB.js

@@ -0,0 +1,114 @@
+//#region ../core/src/executor/log-collector.ts
+/**
+* Mapping from log level to output stream
+*/
+const LOG_STREAM_MAP = {
+	log: "stdout",
+	info: "stdout",
+	debug: "stdout",
+	warn: "stderr",
+	error: "stderr"
+};
+/**
+* All log levels
+*/
+const ALL_LOG_LEVELS = [
+	"log",
+	"info",
+	"debug",
+	"warn",
+	"error"
+];
+/**
+* Format console arguments to string
+*/
+function formatArgs(args) {
+	return args.map((arg) => {
+		if (arg instanceof Error) return arg.message;
+		if (typeof arg === "object" && arg !== null) try {
+			return JSON.stringify(arg);
+		} catch {
+			return String(arg);
+		}
+		return String(arg);
+	}).join(" ");
+}
+/**
+* Create a log collector that intercepts console methods
+*
+* @param options - Options for the log collector
+* @returns A log collector instance
+*
+* @example
+* ```ts
+* const collector = createLogCollector();
+* collector.start();
+*
+* console.log("Info message");
+* console.error("Something went wrong");
+* console.warn("This is a warning");
+*
+* collector.stop();
+* const logs = collector.getLogs();
+* // {
+* //   entries: [
+* //     { message: "Info message", level: "log", stream: "stdout", timestamp: ... },
+* //     { message: "Something went wrong", level: "error", stream: "stderr", timestamp: ... },
+* //     { message: "This is a warning", level: "warn", stream: "stderr", timestamp: ... }
+* //   ]
+* // }
+* ```
+*/
+function createLogCollector(options = {}) {
+	const entries = [];
+	const levels = options.levels ?? ALL_LOG_LEVELS;
+	const passthrough = options.passthrough ?? true;
+	let originals = null;
+	const createInterceptor = (level, original) => {
+		return (...args) => {
+			entries.push({
+				message: formatArgs(args),
+				timestamp: /* @__PURE__ */ new Date(),
+				level,
+				stream: LOG_STREAM_MAP[level]
+			});
+			if (passthrough) original.apply(console, args);
+		};
+	};
+	return {
+		getLogs() {
+			return { entries: [...entries] };
+		},
+		start() {
+			if (originals !== null) return;
+			originals = {
+				log: console.log,
+				info: console.info,
+				debug: console.debug,
+				warn: console.warn,
+				error: console.error
+			};
+			for (const level of levels) console[level] = createInterceptor(level, originals[level]);
+		},
+		stop() {
+			if (originals === null) return;
+			for (const level of levels) console[level] = originals[level];
+			originals = null;
+		}
+	};
+}
+/**
+* Merge multiple CollectedLogs into one (sorted by timestamp)
+*/
+function mergeLogs(...logsArray) {
+	return { entries: logsArray.flatMap((l) => l.entries).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime()) };
+}
+/**
+* Create an empty CollectedLogs object
+*/
+function emptyLogs() {
+	return { entries: [] };
+}
+
+//#endregion
+export { emptyLogs as n, mergeLogs as r, createLogCollector as t };

package/dist/logger-i_bb-Jhc.js

@@ -0,0 +1,133 @@
+import { styleText } from "node:util";
+
+//#region ../core/src/output/logger.ts
+/**
+* Check if color output should be disabled
+*/
+function shouldDisableColor() {
+	if (process.env.NO_COLOR !== void 0) return true;
+	if (process.env.FORCE_COLOR === "0") return true;
+	if (process.env.FORCE_COLOR) return false;
+	if (process.env.CI) return true;
+	if (!process.stdout.isTTY) return true;
+	return false;
+}
+/**
+* Global flag to control color output
+*/
+let colorDisabled = shouldDisableColor();
+/**
+* Enable or disable color output programmatically
+*/
+function setColorEnabled(enabled) {
+	colorDisabled = !enabled;
+}
+/**
+* Check if color output is currently enabled
+*/
+function isColorEnabled() {
+	return !colorDisabled;
+}
+/**
+* Create a style function that applies the given styles
+*/
+function createStyleFn(...styleArgs) {
+	return (text) => {
+		if (colorDisabled) return text;
+		let result = text;
+		for (const style of styleArgs) result = styleText(style, result);
+		return result;
+	};
+}
+/**
+* Semantic style functions for inline text styling
+*/
+const styles = {
+	success: createStyleFn("green"),
+	error: createStyleFn("red"),
+	warning: createStyleFn("yellow"),
+	info: createStyleFn("cyan"),
+	bold: createStyleFn("bold"),
+	dim: createStyleFn("dim"),
+	italic: createStyleFn("italic"),
+	underline: createStyleFn("underline"),
+	red: createStyleFn("red"),
+	green: createStyleFn("green"),
+	yellow: createStyleFn("yellow"),
+	blue: createStyleFn("blue"),
+	magenta: createStyleFn("magenta"),
+	cyan: createStyleFn("cyan"),
+	white: createStyleFn("white"),
+	gray: createStyleFn("gray"),
+	command: createStyleFn("bold"),
+	commandName: createStyleFn("bold", "underline", "cyan"),
+	option: createStyleFn("cyan"),
+	optionName: createStyleFn("bold"),
+	placeholder: createStyleFn("dim"),
+	defaultValue: createStyleFn("dim"),
+	required: createStyleFn("yellow"),
+	description: (text) => text,
+	sectionHeader: createStyleFn("bold", "underline"),
+	version: createStyleFn("dim")
+};
+/**
+* Standardized symbols for CLI output
+*/
+const symbols = {
+	success: styles.green("✓"),
+	error: styles.red("✖"),
+	warning: styles.yellow("⚠"),
+	info: styles.cyan("ℹ"),
+	bullet: styles.gray("•"),
+	arrow: styles.gray("→")
+};
+/**
+* Logger for CLI output
+*/
+const logger = {
+	/**
+	* Log informational message
+	*/
+	info(message) {
+		console.log(message);
+	},
+	/**
+	* Log success message
+	*/
+	success(message) {
+		console.log(`${symbols.success} ${styles.success(message)}`);
+	},
+	/**
+	* Log warning message
+	*/
+	warn(message) {
+		console.warn(`${symbols.warning} ${styles.warning(message)}`);
+	},
+	/**
+	* Log error message
+	*/
+	error(message) {
+		console.error(`${symbols.error} ${styles.error(message)}`);
+	},
+	/**
+	* Log raw message without prefix
+	*/
+	log(message) {
+		console.log(message);
+	},
+	/**
+	* Log empty line
+	*/
+	newline() {
+		console.log("");
+	},
+	/**
+	* Log debug message with dim color
+	*/
+	debug(message) {
+		console.log(styles.dim(message));
+	}
+};
+
+//#endregion
+export { symbols as a, styles as i, logger as n, setColorEnabled as r, isColorEnabled as t };

package/dist/prompt-CEIZ-7H1.js

@@ -0,0 +1,171 @@
+//#region ../core/src/prompt/prompt-resolver.ts
+/**
+* Resolve prompt configuration for a field.
+*
+* Priority for prompt type:
+* 1. Explicit type from prompt.type
+* 2. Explicit choices from prompt.choices (forces "select")
+* 3. Inherited from completion metadata (file/directory -> "text")
+* 4. Auto-detected from the extracted field type (adapter-provided):
+*    - enum (has enumValues) -> "select"
+*    - boolean -> "confirm"
+*    - string/number/unknown -> "text"
+*
+* Returns null if the field has no prompt metadata or prompting is disabled.
+*/
+function resolvePromptConfig(field) {
+	const promptMeta = field.prompt;
+	if (!promptMeta || promptMeta.enabled === false) return null;
+	const message = promptMeta.message ?? field.description ?? field.name;
+	const rawType = resolvePromptType(field, promptMeta);
+	const choices = resolveChoices(field, promptMeta, rawType);
+	return {
+		field,
+		type: rawType === "select" && !choices ? "text" : rawType,
+		message,
+		...choices && { choices }
+	};
+}
+function hasChoices(list) {
+	return list !== void 0 && list.length > 0;
+}
+function resolvePromptType(field, promptMeta) {
+	if (promptMeta.type) return promptMeta.type === "file" || promptMeta.type === "directory" ? "text" : promptMeta.type;
+	if (hasChoices(promptMeta.choices)) return "select";
+	if (field.completion?.type === "file" || field.completion?.type === "directory") return "text";
+	if (hasChoices(field.enumValues)) return "select";
+	if (field.type === "boolean") return "confirm";
+	return "text";
+}
+function resolveChoices(field, promptMeta, type) {
+	if (hasChoices(promptMeta.choices)) return promptMeta.choices.map((c) => typeof c === "string" ? {
+		label: c,
+		value: c
+	} : c);
+	if (type === "select" && hasChoices(field.enumValues)) return field.enumValues.map((v) => ({
+		label: v,
+		value: v
+	}));
+}
+/**
+* Filter fields that need prompting (missing value + prompt configured).
+*
+* For discriminatedUnion schemas, variant-aware narrowing is handled by the
+* caller (promptMissingArgs) which prompts the discriminator first and then
+* passes only the active variant's fields. For plain union schemas, this
+* iterates all fields across every variant without narrowing.
+*
+* Fields with Zod defaults that also have prompt metadata will be prompted
+* when the raw value is undefined. This is intentional: `prompt: {}` is an
+* explicit opt-in to interactive input. Omit prompt metadata to let the
+* default apply silently.
+*/
+function getFieldsToPrompt(fields, rawArgs) {
+	const configs = [];
+	for (const field of fields) {
+		if (rawArgs[field.name] !== void 0) continue;
+		if (field.type === "array") continue;
+		const config = resolvePromptConfig(field);
+		if (config) configs.push(config);
+	}
+	return configs;
+}
+
+//#endregion
+//#region ../core/src/prompt/tty-detector.ts
+/**
+* Detect whether the current environment supports interactive prompts.
+* Returns false in CI, piped input, or non-TTY environments.
+*/
+function isInteractive() {
+	if (!process.stdin.isTTY) return false;
+	if (!process.stdout.isTTY) return false;
+	if (process.env.CI) return false;
+	if (process.env.POLITTY_NO_PROMPT) return false;
+	return true;
+}
+
+//#endregion
+//#region ../core/src/prompt/index.ts
+/**
+* Prompt for missing argument values interactively.
+*
+* Only prompts for fields that have `prompt` metadata set via `arg()` and
+* whose values are still undefined after CLI and env resolution.
+* Returns rawArgs unchanged in non-interactive environments.
+*/
+async function promptMissingArgs(rawArgs, extracted, options) {
+	if (!(options.interactive ?? isInteractive())) return rawArgs;
+	const adapter = options.adapter;
+	const result = { ...rawArgs };
+	if (extracted.schemaType === "discriminatedUnion" && extracted.discriminator && extracted.variants) await promptDiscriminatedUnion(adapter, result, extracted);
+	else if (extracted.schemaType === "union" || extracted.schemaType === "xor") {} else await promptAllFields(adapter, result, extracted.fields);
+	return result;
+}
+async function promptDiscriminatedUnion(adapter, result, extracted) {
+	const { discriminator, variants } = extracted;
+	if (!discriminator || !variants) return;
+	if (result[discriminator] === void 0) {
+		const discField = findDiscriminatorField(extracted.fields, variants, discriminator);
+		const discConfig = discField ? resolvePromptConfig(discField) : null;
+		if (discConfig) {
+			const allValues = variants.map((v) => v.discriminatorValue).filter(Boolean);
+			if (allValues.length > 0) {
+				discConfig.type = "select";
+				discConfig.choices = allValues.map((v) => ({
+					label: v,
+					value: v
+				}));
+			}
+			await promptAndCollect(adapter, result, discConfig);
+		}
+	}
+	const discValue = String(result[discriminator] ?? "");
+	const activeVariant = variants.find((v) => v.discriminatorValue === discValue);
+	if (activeVariant) await promptAllFields(adapter, result, activeVariant.fields.filter((f) => f.name !== discriminator));
+}
+/**
+* Find the discriminator field with prompt metadata, checking the
+* deduplicated top-level fields first, then scanning per-variant fields.
+*/
+function findDiscriminatorField(fields, variants, discriminator) {
+	const topLevel = fields.find((f) => f.name === discriminator);
+	if (topLevel?.prompt) return topLevel;
+	for (const variant of variants) {
+		const field = variant.fields.find((f) => f.name === discriminator);
+		if (field?.prompt) return field;
+	}
+}
+async function promptAllFields(adapter, result, fields) {
+	const fieldsToPrompt = getFieldsToPrompt(fields, result);
+	for (const config of fieldsToPrompt) await promptAndCollect(adapter, result, config);
+}
+async function promptAndCollect(adapter, result, config) {
+	const { message } = config;
+	let value;
+	switch (config.type) {
+		case "text":
+			value = await adapter.text({
+				message,
+				placeholder: config.field.placeholder
+			});
+			break;
+		case "password":
+			value = await adapter.password({ message });
+			break;
+		case "confirm":
+			value = await adapter.confirm({ message });
+			break;
+		case "select":
+			value = await adapter.select({
+				message,
+				options: config.choices ?? []
+			});
+			break;
+	}
+	if (adapter.isCancelled(value)) throw new Error("Prompt cancelled by user");
+	result[config.field.name] = value;
+}
+
+//#endregion
+export { resolvePromptConfig as i, isInteractive as n, getFieldsToPrompt as r, promptMissingArgs as t };

package/dist/prompt-clack.d.ts

@@ -0,0 +1,16 @@
+import { I as PromptResolver } from "./arg-registry-YaWTVu_x.js";
+//#region ../core/src/prompt/clack/index.d.ts
+/**
+ * Prompt resolver backed by @clack/prompts.
+ *
+ * @example
+ * ```ts
+ * import { runMain, defineCommand } from "politty";
+ * import { prompt } from "politty/prompt/clack";
+ *
+ * runMain(cmd, { version: "1.0.0", prompt });
+ * ```
+ */
+declare const prompt: PromptResolver;
+//#endregion
+export { prompt };

package/dist/prompt-clack.js

@@ -0,0 +1,32 @@
+import "./register-Bk0K83W2.js";
+import { t as promptMissingArgs } from "./prompt-CEIZ-7H1.js";
+import { confirm, isCancel, password, select, text } from "@clack/prompts";
+
+//#region ../core/src/prompt/clack/index.ts
+function createClackAdapter() {
+	return {
+		text: (config) => text({
+			message: config.message,
+			...config.placeholder !== void 0 && { placeholder: config.placeholder }
+		}),
+		password: (config) => password(config),
+		confirm: (config) => confirm(config),
+		select: (config) => select(config),
+		isCancelled: isCancel
+	};
+}
+/**
+* Prompt resolver backed by @clack/prompts.
+*
+* @example
+* ```ts
+* import { runMain, defineCommand } from "politty";
+* import { prompt } from "politty/prompt/clack";
+*
+* runMain(cmd, { version: "1.0.0", prompt });
+* ```
+*/
+const prompt = (rawArgs, extracted) => promptMissingArgs(rawArgs, extracted, { adapter: createClackAdapter() });
+
+//#endregion
+export { prompt };

package/dist/prompt-inquirer.d.ts

@@ -0,0 +1,16 @@
+import { I as PromptResolver } from "./arg-registry-YaWTVu_x.js";
+//#region ../core/src/prompt/inquirer/index.d.ts
+/**
+ * Prompt resolver backed by @inquirer/prompts.
+ *
+ * @example
+ * ```ts
+ * import { runMain, defineCommand } from "politty";
+ * import { prompt } from "politty/prompt/inquirer";
+ *
+ * runMain(cmd, { version: "1.0.0", prompt });
+ * ```
+ */
+declare const prompt: PromptResolver;
+//#endregion
+export { prompt };

package/dist/prompt-inquirer.js

@@ -0,0 +1,47 @@
+import "./register-Bk0K83W2.js";
+import { t as promptMissingArgs } from "./prompt-CEIZ-7H1.js";
+import { confirm, input, password, select } from "@inquirer/prompts";
+
+//#region ../core/src/prompt/inquirer/index.ts
+const cancelSymbol = Symbol("inquirer-cancel");
+async function wrapCancellation(fn) {
+	try {
+		return await fn();
+	} catch (error) {
+		if (error instanceof Error && error.name === "ExitPromptError") return cancelSymbol;
+		throw error;
+	}
+}
+function createInquirerAdapter() {
+	return {
+		text: (config) => wrapCancellation(() => input({
+			message: config.message,
+			...config.placeholder !== void 0 && { default: config.placeholder }
+		})),
+		password: (config) => wrapCancellation(() => password({ message: config.message })),
+		confirm: (config) => wrapCancellation(() => confirm({ message: config.message })),
+		select: (config) => wrapCancellation(() => select({
+			message: config.message,
+			choices: config.options.map((o) => ({
+				name: o.label,
+				value: o.value
+			}))
+		})),
+		isCancelled: (value) => value === cancelSymbol
+	};
+}
+/**
+* Prompt resolver backed by @inquirer/prompts.
+*
+* @example
+* ```ts
+* import { runMain, defineCommand } from "politty";
+* import { prompt } from "politty/prompt/inquirer";
+*
+* runMain(cmd, { version: "1.0.0", prompt });
+* ```
+*/
+const prompt = (rawArgs, extracted) => promptMissingArgs(rawArgs, extracted, { adapter: createInquirerAdapter() });
+
+//#endregion
+export { prompt };

package/dist/prompt.d.ts

@@ -0,0 +1,106 @@
+import { X as ResolvedFieldMeta, Y as ExtractedFields } from "./arg-registry-YaWTVu_x.js";
+//#region ../core/src/prompt/types.d.ts
+/**
+ * Resolved prompt configuration for a single field
+ */
+interface ResolvedPromptConfig {
+  /** Field metadata */
+  field: ResolvedFieldMeta;
+  /** Resolved prompt type */
+  type: "text" | "password" | "confirm" | "select";
+  /** Message to display to the user */
+  message: string;
+  /** Choices for select prompts */
+  choices?: Array<{
+    label: string;
+    value: string;
+  }>;
+}
+/**
+ * Adapter interface for prompt rendering.
+ * Implement this to use a custom prompt library instead of the default @clack/prompts.
+ */
+interface PromptAdapter {
+  /** Prompt for free-form text input */
+  text(config: {
+    message: string;
+    placeholder?: string | undefined;
+  }): Promise<string | symbol>;
+  /** Prompt for masked text input */
+  password(config: {
+    message: string;
+  }): Promise<string | symbol>;
+  /** Prompt for yes/no confirmation */
+  confirm(config: {
+    message: string;
+  }): Promise<boolean | symbol>;
+  /** Prompt for single selection from options */
+  select(config: {
+    message: string;
+    options: Array<{
+      label: string;
+      value: string;
+    }>;
+  }): Promise<string | symbol>;
+  /** Check if a prompt result indicates user cancellation */
+  isCancelled(value: unknown): boolean;
+}
+//#endregion
+//#region ../core/src/prompt/prompt-resolver.d.ts
+/**
+ * Resolve prompt configuration for a field.
+ *
+ * Priority for prompt type:
+ * 1. Explicit type from prompt.type
+ * 2. Explicit choices from prompt.choices (forces "select")
+ * 3. Inherited from completion metadata (file/directory -> "text")
+ * 4. Auto-detected from the extracted field type (adapter-provided):
+ *    - enum (has enumValues) -> "select"
+ *    - boolean -> "confirm"
+ *    - string/number/unknown -> "text"
+ *
+ * Returns null if the field has no prompt metadata or prompting is disabled.
+ */
+declare function resolvePromptConfig(field: ResolvedFieldMeta): ResolvedPromptConfig | null;
+/**
+ * Filter fields that need prompting (missing value + prompt configured).
+ *
+ * For discriminatedUnion schemas, variant-aware narrowing is handled by the
+ * caller (promptMissingArgs) which prompts the discriminator first and then
+ * passes only the active variant's fields. For plain union schemas, this
+ * iterates all fields across every variant without narrowing.
+ *
+ * Fields with Zod defaults that also have prompt metadata will be prompted
+ * when the raw value is undefined. This is intentional: `prompt: {}` is an
+ * explicit opt-in to interactive input. Omit prompt metadata to let the
+ * default apply silently.
+ */
+declare function getFieldsToPrompt(fields: ResolvedFieldMeta[], rawArgs: Record<string, unknown>): ResolvedPromptConfig[];
+//#endregion
+//#region ../core/src/prompt/tty-detector.d.ts
+/**
+ * Detect whether the current environment supports interactive prompts.
+ * Returns false in CI, piped input, or non-TTY environments.
+ */
+declare function isInteractive(): boolean;
+//#endregion
+//#region ../core/src/prompt/index.d.ts
+/**
+ * Options for promptMissingArgs behavior
+ */
+interface PromptOptions {
+  /** Prompt adapter to use for rendering prompts */
+  adapter: PromptAdapter;
+  /** Override interactive detection (force enable/disable prompts) */
+  interactive?: boolean;
+}
+/**
+ * Prompt for missing argument values interactively.
+ *
+ * Only prompts for fields that have `prompt` metadata set via `arg()` and
+ * whose values are still undefined after CLI and env resolution.
+ * Returns rawArgs unchanged in non-interactive environments.
+ */
+declare function promptMissingArgs(rawArgs: Record<string, unknown>, extracted: ExtractedFields, options: PromptOptions): Promise<Record<string, unknown>>;
+//#endregion
+export { type PromptAdapter, PromptOptions, type ResolvedPromptConfig, getFieldsToPrompt, isInteractive, promptMissingArgs, resolvePromptConfig };

package/dist/prompt.js

@@ -0,0 +1,4 @@
+import "./register-Bk0K83W2.js";
+import { i as resolvePromptConfig, n as isInteractive, r as getFieldsToPrompt, t as promptMissingArgs } from "./prompt-CEIZ-7H1.js";
+
+export { getFieldsToPrompt, isInteractive, promptMissingArgs, resolvePromptConfig };