politty 0.9.0 → 0.9.2

package/README.md

@@ -15,6 +15,7 @@ From simple scripts to complex CLI tools with subcommands, validation, and auto-
 - **Auto Help Generation**: Automatically generate help text from definitions
 - **Interactive Prompts**: Prompt for missing arguments with pluggable adapters (clack, inquirer)
 - **Discriminated Union**: Support for mutually exclusive argument sets
+- **Skill Management**: Manage agent skills (SKILL.md) with file-based install/uninstall
 
 ## Requirements
 
@@ -422,6 +423,61 @@ const command = defineCommand({
 });
 ```
 
+## Skill Management
+
+politty manages SKILL.md-based agent skills distributed via npm packages.
+
+### Quick Setup
+
+Use `withSkillCommand` to add skill management to your CLI:
+
+```typescript
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineCommand, runMain } from "politty";
+import { withSkillCommand } from "politty/skill";
+
+// Resolves to ../skills from both src/ and dist/
+const sourceDir = resolve(dirname(fileURLToPath(import.meta.url)), "../skills");
+
+const cli = withSkillCommand(
+  defineCommand({
+    name: "my-agent",
+    subCommands: {
+      /* ... */
+    },
+  }),
+  { sourceDir, package: "@my-agent/skills" },
+);
+
+runMain(cli);
+```
+
+`package` identifies who owns these skills. It is combined with the command name as `"{package}:{cliName}"` and must match the `metadata["politty-cli"]` stamp pre-declared in each source SKILL.md — `skills add`/`sync` refuse mismatches, and `remove`/`sync` refuse to delete skills belonging to another tool. The default install mode is `"symlink"` (`.agents/skills/<name>` -> source, `.claude/skills/<name>` -> canonical), so source updates propagate live; on filesystems without symlink support (e.g. Windows without Developer Mode) install throws with guidance to retry with `mode: "copy"`, which recursively copies instead (source updates then require re-running `sync`). See [Skill Management](./docs/skill-management.md) for details.
+
+Skills are SKILL.md files with YAML frontmatter (spec-compliant: https://agentskills.io/specification). The `metadata["politty-cli"]` stamp is authored by the skill package:
+
+```markdown
+---
+name: commit
+description: Git commit message generation
+license: MIT
+metadata:
+  politty-cli: "@my-agent/skills:my-agent"
+---
+
+# Instructions for the agent...
+```
+
+Then users can manage skills:
+
+```bash
+my-agent skills sync              # Remove and reinstall all skills
+my-agent skills add commit        # Install a specific skill
+my-agent skills remove commit     # Remove a specific skill
+my-agent skills list              # List available skills
+```
+
 ## Documentation
 
 For detailed documentation, see the `docs/` directory:
@@ -431,6 +487,7 @@ For detailed documentation, see the `docs/` directory:
 - [Advanced Features](./docs/advanced-features.md) - Subcommands, Discriminated Union
 - [Interactive Prompts](./docs/interactive-prompts.md) - Prompt for missing arguments interactively
 - [Recipes](./docs/recipes.md) - Testing, configuration, error handling
+- [Skill Management](./docs/skill-management.md) - Agent skill management (SKILL.md-based)
 - [API Reference](./docs/api-reference.md) - Detailed API reference
 - [Doc Generation](./docs/doc-generation.md) - Automatic documentation generation
 

package/dist/arg-registry-BeLLAW5-.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+
+//#region src/core/arg-registry.ts
+/**
+* Custom registry for politty argument metadata
+* This avoids polluting Zod's GlobalMeta
+*/
+const argRegistry = z.registry();
+function arg(schema, meta) {
+	if (meta) argRegistry.add(schema, meta);
+	return schema;
+}
+/**
+* Get metadata for a schema from the registry
+*
+* @param schema - The Zod schema
+* @returns The metadata if registered, undefined otherwise
+*/
+function getArgMeta(schema) {
+	return argRegistry.get(schema);
+}
+
+//#endregion
+export { getArgMeta as n, arg as t };
+//# sourceMappingURL=arg-registry-BeLLAW5-.js.map

package/dist/cli.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-import { n as runMain } from "./runner-APRZYXUS.js";
-import { h as arg } from "./schema-extractor-Dqe7_kyQ.js";
-import { S as defineCommand, p as generateBundledCompletionWorker } from "./completion-DHnVx9Zk.js";
+import { n as runMain } from "./runner-BmWR9TLM.js";
+import { t as arg } from "./arg-registry-BeLLAW5-.js";
+import { n as defineCommand } from "./command-B4yA4LXX.js";
+import { p as generateBundledCompletionWorker } from "./completion-DwTFOtQk.js";
 import "./index.js";
 import { z } from "zod";
 

package/dist/command-B4yA4LXX.js

@@ -0,0 +1,43 @@
+//#region src/core/command.ts
+function defineCommand(config) {
+	return {
+		name: config.name,
+		description: config.description,
+		aliases: config.aliases,
+		args: config.args,
+		subCommands: config.subCommands,
+		setup: config.setup,
+		run: config.run,
+		cleanup: config.cleanup,
+		notes: config.notes,
+		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
+export { defineCommand as n, createDefineCommand as t };
+//# sourceMappingURL=command-B4yA4LXX.js.map

package/dist/completion/index.js

@@ -1,3 +1,3 @@
-import { _ as CompletionDirective, a as generateCompletion, b as resolveValueCompletion, c as createDynamicCompleteCommand, d as bundledWorkerShellExtension, f as defaultBundledWorkerOutputPath, g as extractPositionals, h as extractCompletionData, i as detectShell, l as hasCompleteCommand, m as validateBundledWorkerFile, n as createCompletionWorkerPathCommand, o as getSupportedShells, p as generateBundledCompletionWorker, r as createRefreshCompletionCommand, s as withCompletionCommand, t as createCompletionCommand, u as formatForShell, v as generateCandidates, y as parseCompletionContext } from "../completion-DHnVx9Zk.js";
+import { _ as CompletionDirective, a as generateCompletion, b as resolveValueCompletion, c as createDynamicCompleteCommand, d as bundledWorkerShellExtension, f as defaultBundledWorkerOutputPath, g as extractPositionals, h as extractCompletionData, i as detectShell, l as hasCompleteCommand, m as validateBundledWorkerFile, n as createCompletionWorkerPathCommand, o as getSupportedShells, p as generateBundledCompletionWorker, r as createRefreshCompletionCommand, s as withCompletionCommand, t as createCompletionCommand, u as formatForShell, v as generateCandidates, y as parseCompletionContext } from "../completion-DwTFOtQk.js";
 
 export { CompletionDirective, bundledWorkerShellExtension, createCompletionCommand, createCompletionWorkerPathCommand, createDynamicCompleteCommand, createRefreshCompletionCommand, defaultBundledWorkerOutputPath, detectShell, extractCompletionData, extractPositionals, formatForShell, generateBundledCompletionWorker, generateCandidates, generateCompletion, getSupportedShells, hasCompleteCommand, parseCompletionContext, resolveValueCompletion, validateBundledWorkerFile, withCompletionCommand };

package/dist/{completion-DHnVx9Zk.js → completion-DwTFOtQk.js}

@@ -1,51 +1,12 @@
-import { a as toCamelCase, h as arg, m as resolveSubCommandMeta, n as getAllAliases, t as extractFields, u as resolveSubCommandAlias } from "./schema-extractor-Dqe7_kyQ.js";
+import { t as arg } from "./arg-registry-BeLLAW5-.js";
+import { n as defineCommand } from "./command-B4yA4LXX.js";
+import { a as toCamelCase, m as resolveSubCommandMeta, n as getAllAliases, t as extractFields, u as resolveSubCommandAlias } from "./schema-extractor-CVHWm23M.js";
 import { z } from "zod";
 import { execFile, execSync, spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 
-//#region src/core/command.ts
-function defineCommand(config) {
-	return {
-		name: config.name,
-		description: config.description,
-		aliases: config.aliases,
-		args: config.args,
-		subCommands: config.subCommands,
-		setup: config.setup,
-		run: config.run,
-		cleanup: config.cleanup,
-		notes: config.notes,
-		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/shell-shared.ts
 /**
 * Helpers shared across the bash/zsh/fish completion generators.
@@ -5634,5 +5595,5 @@ function maybeSpawnRefresh(argv, ctx) {
 }
 
 //#endregion
-export { defineCommand as S, CompletionDirective as _, generateCompletion as a, resolveValueCompletion as b, createDynamicCompleteCommand as c, bundledWorkerShellExtension as d, defaultBundledWorkerOutputPath as f, extractPositionals as g, extractCompletionData as h, detectShell as i, hasCompleteCommand as l, validateBundledWorkerFile as m, createCompletionWorkerPathCommand as n, getSupportedShells as o, generateBundledCompletionWorker as p, createRefreshCompletionCommand as r, withCompletionCommand as s, createCompletionCommand as t, formatForShell as u, generateCandidates as v, createDefineCommand as x, parseCompletionContext as y };
-//# sourceMappingURL=completion-DHnVx9Zk.js.map
+export { CompletionDirective as _, generateCompletion as a, resolveValueCompletion as b, createDynamicCompleteCommand as c, bundledWorkerShellExtension as d, defaultBundledWorkerOutputPath as f, extractPositionals as g, extractCompletionData as h, detectShell as i, hasCompleteCommand as l, validateBundledWorkerFile as m, createCompletionWorkerPathCommand as n, getSupportedShells as o, generateBundledCompletionWorker as p, createRefreshCompletionCommand as r, withCompletionCommand as s, createCompletionCommand as t, formatForShell as u, generateCandidates as v, parseCompletionContext as y };
+//# sourceMappingURL=completion-DwTFOtQk.js.map

package/dist/docs/index.js

@@ -1,4 +1,4 @@
-import { l as resolveLazyCommand, r as getExtractedFields, t as extractFields } from "../schema-extractor-Dqe7_kyQ.js";
+import { l as resolveLazyCommand, r as getExtractedFields, t as extractFields } from "../schema-extractor-CVHWm23M.js";
 import { t as createLogCollector } from "../log-collector-DK32-73m.js";
 import { z } from "zod";
 import * as fs from "node:fs";
@@ -131,7 +131,8 @@ function formatDefaultValue$1(value) {
 function renderUsage(info) {
 	const parts = [info.fullCommandPath];
 	if (info.options.length > 0) parts.push("[options]");
-	if (info.subCommands.length > 0) parts.push("[command]");
+	if (info.subCommands.length > 0) if (info.command.run) parts.push("[command]");
+	else parts.push("<command>");
 	for (const arg of info.positionalArgs) if (arg.required) parts.push(`<${arg.name}>`);
 	else parts.push(`[${arg.name}]`);
 	return parts.join(" ");
@@ -874,7 +875,7 @@ async function executeSingleExample(example, rootCommand, commandPath) {
 	collector.start();
 	let success = true;
 	try {
-		const { runCommand } = await import("../runner-APRZYXUS.js").then((n) => n.r);
+		const { runCommand } = await import("../runner-BmWR9TLM.js").then((n) => n.r);
 		const result = await runCommand(rootCommand, argv);
 		success = result.success;
 		if (!result.success && result.error) console.error(result.error.message);

package/dist/index.js

@@ -1,5 +1,8 @@
-import { C as renderMarkdown, D as styles, E as setColorEnabled, O as symbols, S as renderInline, T as logger, _ as DuplicateFieldError, a as parseArgv, b as ReservedAliasError, c as validateCommand, d as validateDuplicateFields, f as validateDuplicateNegations, g as DuplicateAliasError, h as CaseVariantCollisionError, i as formatValidationErrors, k as createDualCaseProxy, l as validateCrossSchemaCollisions, m as validateReservedAliases, n as runMain, o as formatCommandValidationErrors, p as validatePositionalConfig, s as validateCaseVariantCollisions, t as runCommand, u as validateDuplicateAliases, v as DuplicateNegationError, w as isColorEnabled, x as generateHelp, y as PositionalConfigError } from "./runner-APRZYXUS.js";
-import { a as toCamelCase, f as isLazyCommand, h as arg, i as getUnknownKeysMode, o as toKebabCase, p as lazy, t as extractFields } from "./schema-extractor-Dqe7_kyQ.js";
-import { S as defineCommand, a as generateCompletion, p as generateBundledCompletionWorker, s as withCompletionCommand, x as createDefineCommand } from "./completion-DHnVx9Zk.js";
+import { C as renderMarkdown, S as renderInline, _ as DuplicateFieldError, a as parseArgv, b as ReservedAliasError, c as validateCommand, d as validateDuplicateFields, f as validateDuplicateNegations, g as DuplicateAliasError, h as CaseVariantCollisionError, i as formatValidationErrors, l as validateCrossSchemaCollisions, m as validateReservedAliases, n as runMain, o as formatCommandValidationErrors, p as validatePositionalConfig, s as validateCaseVariantCollisions, t as runCommand, u as validateDuplicateAliases, v as DuplicateNegationError, w as createDualCaseProxy, x as generateHelp, y as PositionalConfigError } from "./runner-BmWR9TLM.js";
+import { t as arg } from "./arg-registry-BeLLAW5-.js";
+import { n as defineCommand, t as createDefineCommand } from "./command-B4yA4LXX.js";
+import { a as toCamelCase, f as isLazyCommand, i as getUnknownKeysMode, o as toKebabCase, p as lazy, t as extractFields } from "./schema-extractor-CVHWm23M.js";
+import { a as generateCompletion, p as generateBundledCompletionWorker, s as withCompletionCommand } from "./completion-DwTFOtQk.js";
+import { a as symbols, i as styles, n as logger, r as setColorEnabled, t as isColorEnabled } from "./logger-DbDkjdfO.js";
 
 export { CaseVariantCollisionError, DuplicateAliasError, DuplicateFieldError, DuplicateNegationError, PositionalConfigError, ReservedAliasError, arg, createDefineCommand, createDualCaseProxy, defineCommand, extractFields, formatCommandValidationErrors, formatValidationErrors, generateBundledCompletionWorker, 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, withCompletionCommand };

package/dist/logger-DbDkjdfO.js

@@ -0,0 +1,134 @@
+import { styleText } from "node:util";
+
+//#region 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 };
+//# sourceMappingURL=logger-DbDkjdfO.js.map

package/dist/{runner-APRZYXUS.js → runner-BmWR9TLM.js}

@@ -1,6 +1,7 @@
-import { a as toCamelCase, c as listSubCommands, d as resolveSubcommandWithAlias, f as isLazyCommand, l as resolveLazyCommand, m as resolveSubCommandMeta, n as getAllAliases, o as toKebabCase, r as getExtractedFields, s as listSubCommandNamesWithAliases, t as extractFields } from "./schema-extractor-Dqe7_kyQ.js";
+import { a as toCamelCase, c as listSubCommands, d as resolveSubcommandWithAlias, f as isLazyCommand, l as resolveLazyCommand, m as resolveSubCommandMeta, n as getAllAliases, o as toKebabCase, r as getExtractedFields, s as listSubCommandNamesWithAliases, t as extractFields } from "./schema-extractor-CVHWm23M.js";
 import { n as emptyLogs, r as mergeLogs, t as createLogCollector } from "./log-collector-DK32-73m.js";
-import { stripVTControlCharacters, styleText } from "node:util";
+import { a as symbols, i as styles } from "./logger-DbDkjdfO.js";
+import { stripVTControlCharacters } from "node:util";
 
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -149,136 +150,6 @@ async function executeLifecycle(command, args, _options = {}) {
 	};
 }
 
-//#endregion
-//#region 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
 //#region src/output/string-width.ts
 /**
@@ -705,10 +576,12 @@ function renderUsageLine(command, context) {
 	if (extracted) {
 		const positionals = extracted.fields.filter((a) => a.positional);
 		if (extracted.fields.filter((a) => !a.positional).length > 0) parts.push(styles.placeholder("[options]"));
-		if (command.subCommands && getVisibleSubcommandEntries(command.subCommands).length > 0) parts.push(styles.placeholder("[command]"));
+		if (command.subCommands && getVisibleSubcommandEntries(command.subCommands).length > 0) if (command.run) parts.push(styles.placeholder("[command]"));
+		else parts.push(styles.option("<command>"));
 		for (const arg of positionals) if (arg.required) parts.push(styles.option(`<${arg.name}>`));
 		else parts.push(styles.placeholder(`[${arg.name}]`));
-	} else if (command.subCommands && getVisibleSubcommandEntries(command.subCommands).length > 0) parts.push(styles.placeholder("[command]"));
+	} else if (command.subCommands && getVisibleSubcommandEntries(command.subCommands).length > 0) if (command.run) parts.push(styles.placeholder("[command]"));
+	else parts.push(styles.option("<command>"));
 	return parts.join(" ");
 }
 /**
@@ -2775,5 +2648,5 @@ function extractAndValidateGlobal(options) {
 }
 
 //#endregion
-export { renderMarkdown as C, styles as D, setColorEnabled as E, symbols as O, renderInline as S, logger as T, DuplicateFieldError as _, parseArgv as a, ReservedAliasError as b, validateCommand as c, validateDuplicateFields as d, validateDuplicateNegations as f, DuplicateAliasError as g, CaseVariantCollisionError as h, formatValidationErrors as i, createDualCaseProxy as k, validateCrossSchemaCollisions as l, validateReservedAliases as m, runMain as n, formatCommandValidationErrors as o, validatePositionalConfig as p, runner_exports as r, validateCaseVariantCollisions as s, runCommand as t, validateDuplicateAliases as u, DuplicateNegationError as v, isColorEnabled as w, generateHelp as x, PositionalConfigError as y };
-//# sourceMappingURL=runner-APRZYXUS.js.map
+export { renderMarkdown as C, renderInline as S, DuplicateFieldError as _, parseArgv as a, ReservedAliasError as b, validateCommand as c, validateDuplicateFields as d, validateDuplicateNegations as f, DuplicateAliasError as g, CaseVariantCollisionError as h, formatValidationErrors as i, validateCrossSchemaCollisions as l, validateReservedAliases as m, runMain as n, formatCommandValidationErrors as o, validatePositionalConfig as p, runner_exports as r, validateCaseVariantCollisions as s, runCommand as t, validateDuplicateAliases as u, DuplicateNegationError as v, createDualCaseProxy as w, generateHelp as x, PositionalConfigError as y };
+//# sourceMappingURL=runner-BmWR9TLM.js.map

package/dist/{schema-extractor-Dqe7_kyQ.js → schema-extractor-CVHWm23M.js}

@@ -1,26 +1,5 @@
-import { z } from "zod";
+import { n as getArgMeta$1 } from "./arg-registry-BeLLAW5-.js";
 
-//#region src/core/arg-registry.ts
-/**
-* Custom registry for politty argument metadata
-* This avoids polluting Zod's GlobalMeta
-*/
-const argRegistry = z.registry();
-function arg(schema, meta) {
-	if (meta) argRegistry.add(schema, meta);
-	return schema;
-}
-/**
-* Get metadata for a schema from the registry
-*
-* @param schema - The Zod schema
-* @returns The metadata if registered, undefined otherwise
-*/
-function getArgMeta$1(schema) {
-	return argRegistry.get(schema);
-}
-
-//#endregion
 //#region src/lazy.ts
 /**
 * Marker property for LazyCommand identification
@@ -617,5 +596,5 @@ function getExtractedFields(command) {
 }
 
 //#endregion
-export { toCamelCase as a, listSubCommands as c, resolveSubcommandWithAlias as d, isLazyCommand as f, arg as h, getUnknownKeysMode as i, resolveLazyCommand as l, resolveSubCommandMeta as m, getAllAliases as n, toKebabCase as o, lazy as p, getExtractedFields as r, listSubCommandNamesWithAliases as s, extractFields as t, resolveSubCommandAlias as u };
-//# sourceMappingURL=schema-extractor-Dqe7_kyQ.js.map
+export { toCamelCase as a, listSubCommands as c, resolveSubcommandWithAlias as d, isLazyCommand as f, getUnknownKeysMode as i, resolveLazyCommand as l, resolveSubCommandMeta as m, getAllAliases as n, toKebabCase as o, lazy as p, getExtractedFields as r, listSubCommandNamesWithAliases as s, extractFields as t, resolveSubCommandAlias as u };
+//# sourceMappingURL=schema-extractor-CVHWm23M.js.map