politty 0.4.3 → 0.4.6

package/dist/{arg-registry-BUUhZ7JR.d.ts → arg-registry-2m40k1Et.d.ts}

@@ -141,4 +141,4 @@ declare function arg<T extends z.ZodType>(schema: T): T;
 declare function arg<T extends z.ZodType, M extends ArgMeta>(schema: T, meta: ValidateArgMeta<M>): T;
 //#endregion
 export { arg as a, CustomCompletion as i, CompletionMeta as n, CompletionType as r, ArgMeta as t };
-//# sourceMappingURL=arg-registry-BUUhZ7JR.d.ts.map
+//# sourceMappingURL=arg-registry-2m40k1Et.d.ts.map

package/dist/{arg-registry-BUUhZ7JR.d.ts.map → arg-registry-2m40k1Et.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"arg-registry-BUUhZ7JR.d.ts","names":[],"sources":["../src/core/arg-registry.ts"],"mappings":";;;;;AAKA;KAAY,cAAA;;;;UAKK,gBAAA;EAAgB;EAE/B,OAAA;EAAA;EAEA,YAAA;AAAA;;;;;;;;;;;;;;AAqDF;;;;;;;;;;;;AA6BA;;;;;AAQA;KAxDY,cAAA;iCAEV,IAAA,GAAO,cAAA,EAsDuC;EApD9C,MAAA,GAAS,gBAAA;AAAA;EAwDW,+DArDgD,UAAA;EAChE,OAAA;AAAA;EA0Da,yEAvD6D,OAAA;EAC1E,UAAA;AAAA;;AA4D2C;;UArDhC,WAAA;EAkFS;EAhFxB,WAAA;EAkFI;EAhFJ,UAAA;EAkFsB;EAhFtB,WAAA;EAoFE;;;;;;;;;;;;;;EArEF,GAAA;EAqEG;EAnEH,UAAA,GAAa,cAAA;AAAA;;;;UAME,cAAA,SAAuB,WAAA;EA+Da;EA7DnD,KAAA;AAAA;;;;UAMe,sBAAA,SAA+B,WAAA;EAuDP;EArDvC,KAAA;EAqDoD;EAnDpD,oBAAA;AAAA;;;;KAMU,OAAA,GAAU,cAAA,GAAiB,sBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmClC,eAAA,MAAqB,CAAA;EAAY,KAAA;AAAA,IAClC,CAAA;EAAY,oBAAA;AAAA,IACV,CAAA,iBAEc,CAAA,GAAI,CAAA,CAAE,CAAA;EAElB,WAAA;AAAA,IAEJ,CAAA;AAAA,iBAEY,GAAA,WAAc,CAAA,CAAE,OAAA,CAAA,CAAS,MAAA,EAAQ,CAAA,GAAI,CAAA;AAAA,iBACrC,GAAA,WAAc,CAAA,CAAE,OAAA,YAAmB,OAAA,CAAA,CAAS,MAAA,EAAQ,CAAA,EAAG,IAAA,EAAM,eAAA,CAAgB,CAAA,IAAK,CAAA"}
+{"version":3,"file":"arg-registry-2m40k1Et.d.ts","names":[],"sources":["../src/core/arg-registry.ts"],"mappings":";;;;;AAKA;KAAY,cAAA;;;;UAKK,gBAAA;EAAgB;EAE/B,OAAA;EAAA;EAEA,YAAA;AAAA;;;;;;;;;;;;;;AAqDF;;;;;;;;;;;;AA6BA;;;;;AAQA;KAxDY,cAAA;iCAEV,IAAA,GAAO,cAAA,EAsDuC;EApD9C,MAAA,GAAS,gBAAA;AAAA;EAwDW,+DArDgD,UAAA;EAChE,OAAA;AAAA;EA0Da,yEAvD6D,OAAA;EAC1E,UAAA;AAAA;;AA4D2C;;UArDhC,WAAA;EAkFS;EAhFxB,WAAA;EAkFI;EAhFJ,UAAA;EAkFsB;EAhFtB,WAAA;EAoFE;;;;;;;;;;;;;;EArEF,GAAA;EAqEG;EAnEH,UAAA,GAAa,cAAA;AAAA;;;;UAME,cAAA,SAAuB,WAAA;EA+Da;EA7DnD,KAAA;AAAA;;;;UAMe,sBAAA,SAA+B,WAAA;EAuDP;EArDvC,KAAA;EAqDoD;EAnDpD,oBAAA;AAAA;;;;KAMU,OAAA,GAAU,cAAA,GAAiB,sBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmClC,eAAA,MAAqB,CAAA;EAAY,KAAA;AAAA,IAClC,CAAA;EAAY,oBAAA;AAAA,IACV,CAAA,iBAEc,CAAA,GAAI,CAAA,CAAE,CAAA;EAElB,WAAA;AAAA,IAEJ,CAAA;AAAA,iBAEY,GAAA,WAAc,CAAA,CAAE,OAAA,CAAA,CAAS,MAAA,EAAQ,CAAA,GAAI,CAAA;AAAA,iBACrC,GAAA,WAAc,CAAA,CAAE,OAAA,YAAmB,OAAA,CAAA,CAAS,MAAA,EAAQ,CAAA,EAAG,IAAA,EAAM,eAAA,CAAgB,CAAA,IAAK,CAAA"}

package/dist/augment.d.ts

@@ -1,4 +1,4 @@
-import { t as ArgMeta } from "./arg-registry-BUUhZ7JR.js";
+import { t as ArgMeta } from "./arg-registry-2m40k1Et.js";
 
 //#region src/augment.d.ts
 declare module "zod" {

package/dist/completion/index.cjs

@@ -1,170 +1,18 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_subcommand_router = require('../subcommand-router-ZjNjFaUL.cjs');
-const require_lazy = require('../lazy-BEDnSR0m.cjs');
-const require_zsh = require('../zsh-CASZWn0o.cjs');
-let zod = require("zod");
+require('../lazy-DHlvJiQQ.cjs');
+const require_completion = require('../completion-Df0eZ70u.cjs');
 
-//#region src/completion/index.ts
-/**
-* Shell completion generation module
-*
-* Provides utilities to generate shell completion scripts for bash, zsh, and fish.
-*
-* @example
-* ```typescript
-* import { generateCompletion, createCompletionCommand } from "politty/completion";
-*
-* // Generate completion script directly
-* const result = generateCompletion(myCommand, {
-*   shell: "bash",
-*   programName: "mycli"
-* });
-* console.log(result.script);
-*
-* // Or add a completion subcommand to your CLI
-* const mainCommand = withCompletionCommand(
-*   defineCommand({
-*     name: "mycli",
-*     subCommands: { ... },
-*   }),
-* );
-* ```
-*/
-/**
-* Generate completion script for the specified shell
-*/
-function generateCompletion(command, options) {
-	switch (options.shell) {
-		case "bash": return require_zsh.generateBashCompletion(command, options);
-		case "zsh": return require_zsh.generateZshCompletion(command, options);
-		case "fish": return require_zsh.generateFishCompletion(command, options);
-		default: throw new Error(`Unsupported shell: ${options.shell}`);
-	}
-}
-/**
-* Get the list of supported shells
-*/
-function getSupportedShells() {
-	return [
-		"bash",
-		"zsh",
-		"fish"
-	];
-}
-/**
-* Detect the current shell from environment
-*/
-function detectShell() {
-	const shellName = (process.env.SHELL || "").split("/").pop()?.toLowerCase() || "";
-	if (shellName.includes("bash")) return "bash";
-	if (shellName.includes("zsh")) return "zsh";
-	if (shellName.includes("fish")) return "fish";
-	return null;
-}
-/**
-* Schema for the completion command arguments
-*/
-const completionArgsSchema = zod.z.object({
-	shell: require_lazy.arg(zod.z.enum([
-		"bash",
-		"zsh",
-		"fish"
-	]).optional().describe("Shell type (auto-detected if not specified)"), {
-		positional: true,
-		description: "Shell type (bash, zsh, or fish)",
-		placeholder: "SHELL"
-	}),
-	instructions: require_lazy.arg(zod.z.boolean().default(false), {
-		alias: "i",
-		description: "Show installation instructions"
-	})
-});
-/**
-* Create a completion subcommand for your CLI
-*
-* This creates a ready-to-use subcommand that generates completion scripts.
-*
-* @example
-* ```typescript
-* const mainCommand = defineCommand({
-*   name: "mycli",
-*   subCommands: {
-*     completion: createCompletionCommand(mainCommand)
-*   }
-* });
-* ```
-*/
-function createCompletionCommand(rootCommand, programName) {
-	const resolvedProgramName = programName ?? rootCommand.name;
-	if (!rootCommand.subCommands?.__complete) rootCommand.subCommands = {
-		...rootCommand.subCommands,
-		__complete: require_zsh.createDynamicCompleteCommand(rootCommand, resolvedProgramName)
-	};
-	return require_zsh.defineCommand({
-		name: "completion",
-		description: "Generate shell completion script",
-		args: completionArgsSchema,
-		run(args) {
-			const shellType = args.shell || detectShell();
-			if (!shellType) {
-				console.error("Could not detect shell type. Please specify one of: bash, zsh, fish");
-				process.exitCode = 1;
-				return;
-			}
-			const result = generateCompletion(rootCommand, {
-				shell: shellType,
-				programName: resolvedProgramName,
-				includeDescriptions: true
-			});
-			if (args.instructions) console.log(result.installInstructions);
-			else console.log(result.script);
-		}
-	});
-}
-/**
-* Wrap a command with a completion subcommand
-*
-* This avoids circular references that occur when a command references itself
-* in its subCommands (e.g., for completion generation).
-*
-* @param command - The command to wrap
-* @param options - Options including programName
-* @returns A new command with the completion subcommand added
-*
-* @example
-* ```typescript
-* const mainCommand = withCompletionCommand(
-*   defineCommand({
-*     name: "mycli",
-*     subCommands: { ... },
-*   }),
-* );
-* ```
-*/
-function withCompletionCommand(command, options) {
-	const { programName } = typeof options === "string" ? { programName: options } : options ?? {};
-	const wrappedCommand = { ...command };
-	wrappedCommand.subCommands = {
-		...command.subCommands,
-		completion: createCompletionCommand(wrappedCommand, programName),
-		__complete: require_zsh.createDynamicCompleteCommand(wrappedCommand, programName)
-	};
-	return wrappedCommand;
-}
-
-//#endregion
-exports.CompletionDirective = require_zsh.CompletionDirective;
-exports.createCompletionCommand = createCompletionCommand;
-exports.createDynamicCompleteCommand = require_zsh.createDynamicCompleteCommand;
-exports.detectShell = detectShell;
-exports.extractCompletionData = require_zsh.extractCompletionData;
-exports.extractPositionals = require_zsh.extractPositionals;
-exports.formatForShell = require_zsh.formatForShell;
-exports.generateCandidates = require_zsh.generateCandidates;
-exports.generateCompletion = generateCompletion;
-exports.getSupportedShells = getSupportedShells;
-exports.hasCompleteCommand = require_zsh.hasCompleteCommand;
-exports.parseCompletionContext = require_zsh.parseCompletionContext;
-exports.resolveValueCompletion = require_zsh.resolveValueCompletion;
-exports.withCompletionCommand = withCompletionCommand;
-//# sourceMappingURL=index.cjs.map
+exports.CompletionDirective = require_completion.CompletionDirective;
+exports.createCompletionCommand = require_completion.createCompletionCommand;
+exports.createDynamicCompleteCommand = require_completion.createDynamicCompleteCommand;
+exports.detectShell = require_completion.detectShell;
+exports.extractCompletionData = require_completion.extractCompletionData;
+exports.extractPositionals = require_completion.extractPositionals;
+exports.formatForShell = require_completion.formatForShell;
+exports.generateCandidates = require_completion.generateCandidates;
+exports.generateCompletion = require_completion.generateCompletion;
+exports.getSupportedShells = require_completion.getSupportedShells;
+exports.hasCompleteCommand = require_completion.hasCompleteCommand;
+exports.parseCompletionContext = require_completion.parseCompletionContext;
+exports.resolveValueCompletion = require_completion.resolveValueCompletion;
+exports.withCompletionCommand = require_completion.withCompletionCommand;

package/dist/completion/index.d.cts

@@ -1,77 +1,2 @@
-import "../arg-registry-BNoIwnNr.cjs";
-import { d as Command, s as AnyCommand } from "../schema-extractor-DFaAZzaY.cjs";
-import { S as ShellType, _ as CompletableSubcommand, a as ShellFormatOptions, b as CompletionOptions, c as hasCompleteCommand, d as CompletionDirective, f as generateCandidates, g as CompletableOption, h as parseCompletionContext, i as extractPositionals, l as CandidateResult, m as CompletionType, n as resolveValueCompletion, o as formatForShell, p as CompletionContext, r as extractCompletionData, s as createDynamicCompleteCommand, t as ValueCompletionField, u as CompletionCandidate, v as CompletionData, x as CompletionResult, y as CompletionGenerator } from "../value-completion-resolver-BQgHsX7b.cjs";
-import { z } from "zod";
-
-//#region src/completion/index.d.ts
-/**
- * Generate completion script for the specified shell
- */
-declare function generateCompletion(command: AnyCommand, options: CompletionOptions): CompletionResult;
-/**
- * Get the list of supported shells
- */
-declare function getSupportedShells(): ShellType[];
-/**
- * Detect the current shell from environment
- */
-declare function detectShell(): ShellType | null;
-/**
- * Schema for the completion command arguments
- */
-declare const completionArgsSchema: z.ZodObject<{
-  shell: z.ZodOptional<z.ZodEnum<{
-    bash: "bash";
-    zsh: "zsh";
-    fish: "fish";
-  }>>;
-  instructions: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-type CompletionArgs = z.infer<typeof completionArgsSchema>;
-/**
- * Create a completion subcommand for your CLI
- *
- * This creates a ready-to-use subcommand that generates completion scripts.
- *
- * @example
- * ```typescript
- * const mainCommand = defineCommand({
- *   name: "mycli",
- *   subCommands: {
- *     completion: createCompletionCommand(mainCommand)
- *   }
- * });
- * ```
- */
-declare function createCompletionCommand(rootCommand: AnyCommand, programName?: string): Command<typeof completionArgsSchema, CompletionArgs, any>;
-/**
- * Options for withCompletionCommand
- */
-interface WithCompletionOptions {
-  /** Override the program name (defaults to command.name) */
-  programName?: string;
-}
-/**
- * Wrap a command with a completion subcommand
- *
- * This avoids circular references that occur when a command references itself
- * in its subCommands (e.g., for completion generation).
- *
- * @param command - The command to wrap
- * @param options - Options including programName
- * @returns A new command with the completion subcommand added
- *
- * @example
- * ```typescript
- * const mainCommand = withCompletionCommand(
- *   defineCommand({
- *     name: "mycli",
- *     subCommands: { ... },
- *   }),
- * );
- * ```
- */
-declare function withCompletionCommand<T extends AnyCommand>(command: T, options?: string | WithCompletionOptions): T;
-//#endregion
-export { type CandidateResult, type CompletableOption, type CompletableSubcommand, type CompletionCandidate, type CompletionContext, type CompletionData, CompletionDirective, type CompletionGenerator, type CompletionOptions, type CompletionResult, type CompletionType, type ShellFormatOptions, type ShellType, type ValueCompletionField, WithCompletionOptions, createCompletionCommand, createDynamicCompleteCommand, detectShell, extractCompletionData, extractPositionals, formatForShell, generateCandidates, generateCompletion, getSupportedShells, hasCompleteCommand, parseCompletionContext, resolveValueCompletion, withCompletionCommand };
-//# sourceMappingURL=index.d.cts.map
+import { C as CompletableSubcommand, D as CompletionResult, E as CompletionOptions, O as ShellType, S as CompletableOption, T as CompletionGenerator, _ as CompletionDirective, a as getSupportedShells, b as CompletionType, c as resolveValueCompletion, d as ShellFormatOptions, f as formatForShell, g as CompletionCandidate, h as CandidateResult, i as generateCompletion, l as extractCompletionData, m as hasCompleteCommand, n as createCompletionCommand, o as withCompletionCommand, p as createDynamicCompleteCommand, r as detectShell, s as ValueCompletionField, t as WithCompletionOptions, u as extractPositionals, v as generateCandidates, w as CompletionData, x as parseCompletionContext, y as CompletionContext } from "../index-C5-0RXiH.cjs";
+export { CandidateResult, CompletableOption, CompletableSubcommand, CompletionCandidate, CompletionContext, CompletionData, CompletionDirective, CompletionGenerator, CompletionOptions, CompletionResult, CompletionType, ShellFormatOptions, ShellType, ValueCompletionField, WithCompletionOptions, createCompletionCommand, createDynamicCompleteCommand, detectShell, extractCompletionData, extractPositionals, formatForShell, generateCandidates, generateCompletion, getSupportedShells, hasCompleteCommand, parseCompletionContext, resolveValueCompletion, withCompletionCommand };

package/dist/completion/index.d.ts

@@ -1,77 +1,2 @@
-import "../arg-registry-BUUhZ7JR.js";
-import { d as Command, s as AnyCommand } from "../schema-extractor-n9288WJ6.js";
-import { S as ShellType, _ as CompletableSubcommand, a as ShellFormatOptions, b as CompletionOptions, c as hasCompleteCommand, d as CompletionDirective, f as generateCandidates, g as CompletableOption, h as parseCompletionContext, i as extractPositionals, l as CandidateResult, m as CompletionType, n as resolveValueCompletion, o as formatForShell, p as CompletionContext, r as extractCompletionData, s as createDynamicCompleteCommand, t as ValueCompletionField, u as CompletionCandidate, v as CompletionData, x as CompletionResult, y as CompletionGenerator } from "../value-completion-resolver-C9LTGr0O.js";
-import { z } from "zod";
-
-//#region src/completion/index.d.ts
-/**
- * Generate completion script for the specified shell
- */
-declare function generateCompletion(command: AnyCommand, options: CompletionOptions): CompletionResult;
-/**
- * Get the list of supported shells
- */
-declare function getSupportedShells(): ShellType[];
-/**
- * Detect the current shell from environment
- */
-declare function detectShell(): ShellType | null;
-/**
- * Schema for the completion command arguments
- */
-declare const completionArgsSchema: z.ZodObject<{
-  shell: z.ZodOptional<z.ZodEnum<{
-    bash: "bash";
-    zsh: "zsh";
-    fish: "fish";
-  }>>;
-  instructions: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-type CompletionArgs = z.infer<typeof completionArgsSchema>;
-/**
- * Create a completion subcommand for your CLI
- *
- * This creates a ready-to-use subcommand that generates completion scripts.
- *
- * @example
- * ```typescript
- * const mainCommand = defineCommand({
- *   name: "mycli",
- *   subCommands: {
- *     completion: createCompletionCommand(mainCommand)
- *   }
- * });
- * ```
- */
-declare function createCompletionCommand(rootCommand: AnyCommand, programName?: string): Command<typeof completionArgsSchema, CompletionArgs, any>;
-/**
- * Options for withCompletionCommand
- */
-interface WithCompletionOptions {
-  /** Override the program name (defaults to command.name) */
-  programName?: string;
-}
-/**
- * Wrap a command with a completion subcommand
- *
- * This avoids circular references that occur when a command references itself
- * in its subCommands (e.g., for completion generation).
- *
- * @param command - The command to wrap
- * @param options - Options including programName
- * @returns A new command with the completion subcommand added
- *
- * @example
- * ```typescript
- * const mainCommand = withCompletionCommand(
- *   defineCommand({
- *     name: "mycli",
- *     subCommands: { ... },
- *   }),
- * );
- * ```
- */
-declare function withCompletionCommand<T extends AnyCommand>(command: T, options?: string | WithCompletionOptions): T;
-//#endregion
-export { type CandidateResult, type CompletableOption, type CompletableSubcommand, type CompletionCandidate, type CompletionContext, type CompletionData, CompletionDirective, type CompletionGenerator, type CompletionOptions, type CompletionResult, type CompletionType, type ShellFormatOptions, type ShellType, type ValueCompletionField, WithCompletionOptions, createCompletionCommand, createDynamicCompleteCommand, detectShell, extractCompletionData, extractPositionals, formatForShell, generateCandidates, generateCompletion, getSupportedShells, hasCompleteCommand, parseCompletionContext, resolveValueCompletion, withCompletionCommand };
-//# sourceMappingURL=index.d.ts.map
+import { C as CompletableSubcommand, D as CompletionResult, E as CompletionOptions, O as ShellType, S as CompletableOption, T as CompletionGenerator, _ as CompletionDirective, a as getSupportedShells, b as CompletionType, c as resolveValueCompletion, d as ShellFormatOptions, f as formatForShell, g as CompletionCandidate, h as CandidateResult, i as generateCompletion, l as extractCompletionData, m as hasCompleteCommand, n as createCompletionCommand, o as withCompletionCommand, p as createDynamicCompleteCommand, r as detectShell, s as ValueCompletionField, t as WithCompletionOptions, u as extractPositionals, v as generateCandidates, w as CompletionData, x as parseCompletionContext, y as CompletionContext } from "../index-BZalbMeu.js";
+export { CandidateResult, CompletableOption, CompletableSubcommand, CompletionCandidate, CompletionContext, CompletionData, CompletionDirective, CompletionGenerator, CompletionOptions, CompletionResult, CompletionType, ShellFormatOptions, ShellType, ValueCompletionField, WithCompletionOptions, createCompletionCommand, createDynamicCompleteCommand, detectShell, extractCompletionData, extractPositionals, formatForShell, generateCandidates, generateCompletion, getSupportedShells, hasCompleteCommand, parseCompletionContext, resolveValueCompletion, withCompletionCommand };

package/dist/completion/index.js

@@ -1,155 +1,4 @@
-import { c as arg } from "../lazy-BrEg8SgI.js";
-import { a as formatForShell, c as generateCandidates, d as extractPositionals, f as resolveValueCompletion, i as hasCompleteCommand, l as generateBashCompletion, n as generateFishCompletion, o as parseCompletionContext, p as defineCommand, r as createDynamicCompleteCommand, s as CompletionDirective, t as generateZshCompletion, u as extractCompletionData } from "../zsh-hjvdI8uZ.js";
-import { z } from "zod";
+import "../lazy-DSyfzR-F.js";
+import { a as withCompletionCommand, c as formatForShell, d as generateCandidates, f as extractCompletionData, i as getSupportedShells, l as parseCompletionContext, m as resolveValueCompletion, n as detectShell, o as createDynamicCompleteCommand, p as extractPositionals, r as generateCompletion, s as hasCompleteCommand, t as createCompletionCommand, u as CompletionDirective } from "../completion-_AnQsWh9.js";
 
-//#region src/completion/index.ts
-/**
-* Shell completion generation module
-*
-* Provides utilities to generate shell completion scripts for bash, zsh, and fish.
-*
-* @example
-* ```typescript
-* import { generateCompletion, createCompletionCommand } from "politty/completion";
-*
-* // Generate completion script directly
-* const result = generateCompletion(myCommand, {
-*   shell: "bash",
-*   programName: "mycli"
-* });
-* console.log(result.script);
-*
-* // Or add a completion subcommand to your CLI
-* const mainCommand = withCompletionCommand(
-*   defineCommand({
-*     name: "mycli",
-*     subCommands: { ... },
-*   }),
-* );
-* ```
-*/
-/**
-* Generate completion script for the specified shell
-*/
-function generateCompletion(command, options) {
-	switch (options.shell) {
-		case "bash": return generateBashCompletion(command, options);
-		case "zsh": return generateZshCompletion(command, options);
-		case "fish": return generateFishCompletion(command, options);
-		default: throw new Error(`Unsupported shell: ${options.shell}`);
-	}
-}
-/**
-* Get the list of supported shells
-*/
-function getSupportedShells() {
-	return [
-		"bash",
-		"zsh",
-		"fish"
-	];
-}
-/**
-* Detect the current shell from environment
-*/
-function detectShell() {
-	const shellName = (process.env.SHELL || "").split("/").pop()?.toLowerCase() || "";
-	if (shellName.includes("bash")) return "bash";
-	if (shellName.includes("zsh")) return "zsh";
-	if (shellName.includes("fish")) return "fish";
-	return null;
-}
-/**
-* Schema for the completion command arguments
-*/
-const completionArgsSchema = z.object({
-	shell: arg(z.enum([
-		"bash",
-		"zsh",
-		"fish"
-	]).optional().describe("Shell type (auto-detected if not specified)"), {
-		positional: true,
-		description: "Shell type (bash, zsh, or fish)",
-		placeholder: "SHELL"
-	}),
-	instructions: arg(z.boolean().default(false), {
-		alias: "i",
-		description: "Show installation instructions"
-	})
-});
-/**
-* Create a completion subcommand for your CLI
-*
-* This creates a ready-to-use subcommand that generates completion scripts.
-*
-* @example
-* ```typescript
-* const mainCommand = defineCommand({
-*   name: "mycli",
-*   subCommands: {
-*     completion: createCompletionCommand(mainCommand)
-*   }
-* });
-* ```
-*/
-function createCompletionCommand(rootCommand, programName) {
-	const resolvedProgramName = programName ?? rootCommand.name;
-	if (!rootCommand.subCommands?.__complete) rootCommand.subCommands = {
-		...rootCommand.subCommands,
-		__complete: createDynamicCompleteCommand(rootCommand, resolvedProgramName)
-	};
-	return defineCommand({
-		name: "completion",
-		description: "Generate shell completion script",
-		args: completionArgsSchema,
-		run(args) {
-			const shellType = args.shell || detectShell();
-			if (!shellType) {
-				console.error("Could not detect shell type. Please specify one of: bash, zsh, fish");
-				process.exitCode = 1;
-				return;
-			}
-			const result = generateCompletion(rootCommand, {
-				shell: shellType,
-				programName: resolvedProgramName,
-				includeDescriptions: true
-			});
-			if (args.instructions) console.log(result.installInstructions);
-			else console.log(result.script);
-		}
-	});
-}
-/**
-* Wrap a command with a completion subcommand
-*
-* This avoids circular references that occur when a command references itself
-* in its subCommands (e.g., for completion generation).
-*
-* @param command - The command to wrap
-* @param options - Options including programName
-* @returns A new command with the completion subcommand added
-*
-* @example
-* ```typescript
-* const mainCommand = withCompletionCommand(
-*   defineCommand({
-*     name: "mycli",
-*     subCommands: { ... },
-*   }),
-* );
-* ```
-*/
-function withCompletionCommand(command, options) {
-	const { programName } = typeof options === "string" ? { programName: options } : options ?? {};
-	const wrappedCommand = { ...command };
-	wrappedCommand.subCommands = {
-		...command.subCommands,
-		completion: createCompletionCommand(wrappedCommand, programName),
-		__complete: createDynamicCompleteCommand(wrappedCommand, programName)
-	};
-	return wrappedCommand;
-}
-
-//#endregion
-export { CompletionDirective, createCompletionCommand, createDynamicCompleteCommand, detectShell, extractCompletionData, extractPositionals, formatForShell, generateCandidates, generateCompletion, getSupportedShells, hasCompleteCommand, parseCompletionContext, resolveValueCompletion, withCompletionCommand };
-//# sourceMappingURL=index.js.map
+export { CompletionDirective, createCompletionCommand, createDynamicCompleteCommand, detectShell, extractCompletionData, extractPositionals, formatForShell, generateCandidates, generateCompletion, getSupportedShells, hasCompleteCommand, parseCompletionContext, resolveValueCompletion, withCompletionCommand };