politty 0.4.4 → 0.4.7

package/dist/{zsh-DR47Ccac.cjs → completion-Df0eZ70u.cjs}

@@ -1,5 +1,5 @@
-const require_subcommand_router = require('./subcommand-router-ZjNjFaUL.cjs');
-const require_lazy = require('./lazy-BEDnSR0m.cjs');
+const require_subcommand_router = require('./subcommand-router-sZHhUP7b.cjs');
+const require_lazy = require('./lazy-DHlvJiQQ.cjs');
 let zod = require("zod");
 let node_child_process = require("node:child_process");
 
@@ -17,6 +17,30 @@ function defineCommand(config) {
 		examples: config.examples
 	};
 }
+/**
+* Create a typed defineCommand factory with pre-bound global args type.
+* This is the recommended pattern for type-safe global options.
+*
+* @example
+* ```ts
+* // global-args.ts
+* type GlobalArgsType = { verbose: boolean; config?: string };
+* export const defineAppCommand = createDefineCommand<GlobalArgsType>();
+*
+* // commands/build.ts
+* export const buildCommand = defineAppCommand({
+*   name: "build",
+*   args: z.object({ output: arg(z.string().default("dist")) }),
+*   run: (args) => {
+*     args.verbose; // typed via GlobalArgsType
+*     args.output;  // typed via local args
+*   },
+* });
+* ```
+*/
+function createDefineCommand() {
+	return defineCommand;
+}
 
 //#endregion
 //#region src/completion/value-completion-resolver.ts
@@ -201,14 +225,34 @@ function isSubcmdCaseLines(routeEntries) {
 	return routeEntries.map((r) => `        ${r.lookupPattern}) return 0 ;;`);
 }
 /**
+* Recursively merge global options into a subcommand and all its descendants.
+* Avoids duplicates by checking existing option names.
+*/
+function propagateGlobalOptions(sub, globalOptions) {
+	const existingNames = new Set(sub.options.map((o) => o.name));
+	const newOpts = globalOptions.filter((o) => !existingNames.has(o.name));
+	sub.options = [...sub.options, ...newOpts];
+	for (const child of sub.subcommands) propagateGlobalOptions(child, globalOptions);
+}
+/**
 * Extract completion data from a command tree
+*
+* @param command - The root command
+* @param programName - Program name for completion scripts
+* @param globalArgsSchema - Optional global args schema. When provided, global options
+*   are derived from this schema instead of the root command's options.
 */
-function extractCompletionData(command, programName) {
+function extractCompletionData(command, programName, globalArgsSchema) {
 	const rootSubcommand = extractSubcommand(programName, command);
+	let globalOptions;
+	if (globalArgsSchema) {
+		globalOptions = require_lazy.extractFields(globalArgsSchema).fields.filter((field) => !field.positional).map(fieldToOption);
+		propagateGlobalOptions(rootSubcommand, globalOptions);
+	} else globalOptions = rootSubcommand.options;
 	return {
 		command: rootSubcommand,
 		programName,
-		globalOptions: rootSubcommand.options
+		globalOptions
 	};
 }
 
@@ -383,7 +427,7 @@ function generateSubHandler$2(sub, fn, path) {
 }
 function generateBashCompletion(command, options) {
 	const { programName } = options;
-	const data = extractCompletionData(command, programName);
+	const data = extractCompletionData(command, programName, options.globalArgsSchema);
 	const fn = sanitize(programName);
 	const root = data.command;
 	const visibleSubs = getVisibleSubs(root.subcommands);
@@ -1200,7 +1244,7 @@ function optTakesValueCases(sub, parentPath) {
 }
 function generateFishCompletion(command, options) {
 	const { programName } = options;
-	const data = extractCompletionData(command, programName);
+	const data = extractCompletionData(command, programName, options.globalArgsSchema);
 	const fn = sanitize(programName);
 	const root = data.command;
 	const visibleSubs = getVisibleSubs(root.subcommands);
@@ -1452,7 +1496,7 @@ function generateSubHandler(sub, fn, path) {
 }
 function generateZshCompletion(command, options) {
 	const { programName } = options;
-	const data = extractCompletionData(command, programName);
+	const data = extractCompletionData(command, programName, options.globalArgsSchema);
 	const fn = sanitize(programName);
 	const root = data.command;
 	const visibleSubs = getVisibleSubs(root.subcommands);
@@ -1581,6 +1625,156 @@ source ~/.zshrc`
 	};
 }
 
+//#endregion
+//#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 = 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, globalArgsSchema) {
+	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,
+				...globalArgsSchema !== void 0 && { globalArgsSchema }
+			});
+			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, globalArgsSchema } = typeof options === "string" ? { programName: options } : options ?? {};
+	const wrappedCommand = { ...command };
+	wrappedCommand.subCommands = {
+		...command.subCommands,
+		completion: createCompletionCommand(wrappedCommand, programName, globalArgsSchema),
+		__complete: createDynamicCompleteCommand(wrappedCommand, programName)
+	};
+	return wrappedCommand;
+}
+
 //#endregion
 Object.defineProperty(exports, 'CompletionDirective', {
   enumerable: true,
@@ -1588,6 +1782,18 @@ Object.defineProperty(exports, 'CompletionDirective', {
     return CompletionDirective;
   }
 });
+Object.defineProperty(exports, 'createCompletionCommand', {
+  enumerable: true,
+  get: function () {
+    return createCompletionCommand;
+  }
+});
+Object.defineProperty(exports, 'createDefineCommand', {
+  enumerable: true,
+  get: function () {
+    return createDefineCommand;
+  }
+});
 Object.defineProperty(exports, 'createDynamicCompleteCommand', {
   enumerable: true,
   get: function () {
@@ -1600,6 +1806,12 @@ Object.defineProperty(exports, 'defineCommand', {
     return defineCommand;
   }
 });
+Object.defineProperty(exports, 'detectShell', {
+  enumerable: true,
+  get: function () {
+    return detectShell;
+  }
+});
 Object.defineProperty(exports, 'extractCompletionData', {
   enumerable: true,
   get: function () {
@@ -1618,28 +1830,22 @@ Object.defineProperty(exports, 'formatForShell', {
     return formatForShell;
   }
 });
-Object.defineProperty(exports, 'generateBashCompletion', {
-  enumerable: true,
-  get: function () {
-    return generateBashCompletion;
-  }
-});
 Object.defineProperty(exports, 'generateCandidates', {
   enumerable: true,
   get: function () {
     return generateCandidates;
   }
 });
-Object.defineProperty(exports, 'generateFishCompletion', {
+Object.defineProperty(exports, 'generateCompletion', {
   enumerable: true,
   get: function () {
-    return generateFishCompletion;
+    return generateCompletion;
   }
 });
-Object.defineProperty(exports, 'generateZshCompletion', {
+Object.defineProperty(exports, 'getSupportedShells', {
   enumerable: true,
   get: function () {
-    return generateZshCompletion;
+    return getSupportedShells;
   }
 });
 Object.defineProperty(exports, 'hasCompleteCommand', {
@@ -1660,4 +1866,10 @@ Object.defineProperty(exports, 'resolveValueCompletion', {
     return resolveValueCompletion;
   }
 });
-//# sourceMappingURL=zsh-DR47Ccac.cjs.map
+Object.defineProperty(exports, 'withCompletionCommand', {
+  enumerable: true,
+  get: function () {
+    return withCompletionCommand;
+  }
+});
+//# sourceMappingURL=completion-Df0eZ70u.cjs.map