padrone 1.8.2 → 2.0.0

package/dist/extension/ink.mjs

@@ -0,0 +1,69 @@
+import { defineInterceptor } from "../core/interceptors.mjs";
+//#region src/extension/ink.ts
+const reactElement = Symbol.for("react.element");
+const reactTransitional = Symbol.for("react.transitional.element");
+/** Checks whether a value is a React element (JSX) by inspecting its `$$typeof` symbol. */
+function isReactElement(value) {
+	if (value === null || typeof value !== "object") return false;
+	const tag = value.$$typeof;
+	return tag === reactElement || tag === reactTransitional;
+}
+const inkMeta = {
+	id: "padrone:ink",
+	name: "padrone:ink",
+	order: -1050
+};
+function createInkInterceptor(rawOptions) {
+	return defineInterceptor(inkMeta).requires().factory(() => ({ execute(ctx, next) {
+		const options = {
+			...ctx.context?.inkConfig,
+			...rawOptions
+		};
+		const { waitUntilExit = true } = options;
+		const handleResult = async (e) => {
+			let value = e.result;
+			if (value instanceof Promise) value = await value;
+			if (!isReactElement(value)) return e;
+			const { render } = await import("ink");
+			const instance = render(value, options.render);
+			const onAbort = () => instance.unmount();
+			ctx.signal.addEventListener("abort", onAbort, { once: true });
+			if (waitUntilExit) try {
+				await instance.waitUntilExit();
+			} finally {
+				ctx.signal.removeEventListener("abort", onAbort);
+			}
+			return { result: void 0 };
+		};
+		const executedOrPromise = next();
+		if (executedOrPromise instanceof Promise) return executedOrPromise.then(handleResult);
+		return handleResult(executedOrPromise);
+	} }));
+}
+/**
+* Extension that renders React (Ink) components returned from command actions.
+*
+* When a command's action returns a React element (JSX), this extension
+* renders it using Ink instead of passing it to the normal output path.
+*
+* Requires `ink` and `react` as peer dependencies.
+*
+* ```ts
+* import { createPadrone } from 'padrone';
+* import { padroneInk } from 'padrone/ink';
+*
+* const program = createPadrone('my-tui')
+*   .extend(padroneInk())
+*   .command('dashboard', (c) =>
+*     c.action(() => <Dashboard />)
+*   );
+* ```
+*/
+function padroneInk(options) {
+	const interceptor = createInkInterceptor(options);
+	return ((builder) => builder.intercept(interceptor));
+}
+//#endregion
+export { isReactElement, padroneInk };
+
+//# sourceMappingURL=ink.mjs.map

package/dist/extension/ink.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ink.mjs","names":[],"sources":["../../src/extension/ink.ts"],"sourcesContent":["import { defineInterceptor } from '../core/interceptors.ts';\nimport type { AnyPadroneBuilder, CommandTypesBase } from '../types/index.ts';\nimport type { InterceptorExecuteResult } from '../types/interceptor.ts';\n\n// ── React element detection ─────────────────────────────────────────────\n\nconst reactElement = Symbol.for('react.element');\nconst reactTransitional = Symbol.for('react.transitional.element');\n\n/** Checks whether a value is a React element (JSX) by inspecting its `$$typeof` symbol. */\nexport function isReactElement(value: unknown): boolean {\n  if (value === null || typeof value !== 'object') return false;\n  const tag = (value as Record<string | symbol, unknown>).$$typeof;\n  return tag === reactElement || tag === reactTransitional;\n}\n\n// ── Types ───────────────────────────────────────────────────────────────\n\nexport type InkOptions = {\n  /** Whether to wait for the Ink app to unmount before resolving. Defaults to `true`. */\n  waitUntilExit?: boolean;\n  /** Options forwarded to Ink's `render()`. */\n  render?: import('ink').RenderOptions;\n};\n\n// ── Interceptor ─────────────────────────────────────────────────────────\n\nconst inkMeta = { id: 'padrone:ink', name: 'padrone:ink', order: -1050 } as const;\n\nfunction createInkInterceptor(rawOptions?: InkOptions) {\n  return defineInterceptor(inkMeta)\n    .requires<{ inkConfig?: InkOptions }>()\n    .factory(() => ({\n      execute(ctx, next) {\n        const ctxCfg = (ctx.context as Record<string, unknown> | undefined)?.inkConfig as InkOptions | undefined;\n        const options: InkOptions = { ...ctxCfg, ...rawOptions };\n        const { waitUntilExit = true } = options;\n\n        const handleResult = async (e: InterceptorExecuteResult): Promise<InterceptorExecuteResult> => {\n          let value = e.result;\n          if (value instanceof Promise) value = await value;\n          if (!isReactElement(value)) return e;\n\n          const { render } = await import('ink');\n          const instance = render(value as import('react').ReactElement, options.render);\n\n          // Unmount on abort so Ink cleans up stdin/stdout\n          const onAbort = () => instance.unmount();\n          ctx.signal.addEventListener('abort', onAbort, { once: true });\n\n          if (waitUntilExit) {\n            try {\n              await instance.waitUntilExit();\n            } finally {\n              ctx.signal.removeEventListener('abort', onAbort);\n            }\n          }\n\n          // Return undefined so auto-output skips this result\n          return { result: undefined };\n        };\n\n        const executedOrPromise = next();\n        if (executedOrPromise instanceof Promise) return executedOrPromise.then(handleResult);\n        return handleResult(executedOrPromise);\n      },\n    }));\n}\n\n// ── Extension ───────────────────────────────────────────────────────────\n\n/**\n * Extension that renders React (Ink) components returned from command actions.\n *\n * When a command's action returns a React element (JSX), this extension\n * renders it using Ink instead of passing it to the normal output path.\n *\n * Requires `ink` and `react` as peer dependencies.\n *\n * ```ts\n * import { createPadrone } from 'padrone';\n * import { padroneInk } from 'padrone/ink';\n *\n * const program = createPadrone('my-tui')\n *   .extend(padroneInk())\n *   .command('dashboard', (c) =>\n *     c.action(() => <Dashboard />)\n *   );\n * ```\n */\nexport function padroneInk(options?: InkOptions): <T extends CommandTypesBase>(builder: T) => T {\n  const interceptor = createInkInterceptor(options);\n  return ((builder: AnyPadroneBuilder) => builder.intercept(interceptor)) as any;\n}\n"],"mappings":";;AAMA,MAAM,eAAe,OAAO,IAAI,eAAe;AAC/C,MAAM,oBAAoB,OAAO,IAAI,4BAA4B;;AAGjE,SAAgB,eAAe,OAAyB;CACtD,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU,OAAO;CACxD,MAAM,MAAO,MAA2C;CACxD,OAAO,QAAQ,gBAAgB,QAAQ;AACzC;AAaA,MAAM,UAAU;CAAE,IAAI;CAAe,MAAM;CAAe,OAAO;AAAM;AAEvE,SAAS,qBAAqB,YAAyB;CACrD,OAAO,kBAAkB,OAAO,CAAC,CAC9B,SAAqC,CAAC,CACtC,eAAe,EACd,QAAQ,KAAK,MAAM;EAEjB,MAAM,UAAsB;GAAE,GADd,IAAI,SAAiD;GAC5B,GAAG;EAAW;EACvD,MAAM,EAAE,gBAAgB,SAAS;EAEjC,MAAM,eAAe,OAAO,MAAmE;GAC7F,IAAI,QAAQ,EAAE;GACd,IAAI,iBAAiB,SAAS,QAAQ,MAAM;GAC5C,IAAI,CAAC,eAAe,KAAK,GAAG,OAAO;GAEnC,MAAM,EAAE,WAAW,MAAM,OAAO;GAChC,MAAM,WAAW,OAAO,OAAuC,QAAQ,MAAM;GAG7E,MAAM,gBAAgB,SAAS,QAAQ;GACvC,IAAI,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;GAE5D,IAAI,eACF,IAAI;IACF,MAAM,SAAS,cAAc;GAC/B,UAAU;IACR,IAAI,OAAO,oBAAoB,SAAS,OAAO;GACjD;GAIF,OAAO,EAAE,QAAQ,KAAA,EAAU;EAC7B;EAEA,MAAM,oBAAoB,KAAK;EAC/B,IAAI,6BAA6B,SAAS,OAAO,kBAAkB,KAAK,YAAY;EACpF,OAAO,aAAa,iBAAiB;CACvC,EACF,EAAE;AACN;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,WAAW,SAAqE;CAC9F,MAAM,cAAc,qBAAqB,OAAO;CAChD,SAAS,YAA+B,QAAQ,UAAU,WAAW;AACvE"}

package/dist/extension/interactive.d.mts

@@ -0,0 +1,16 @@
+import { CommandTypesBase } from "../types/command.mjs";
+//#region src/extension/interactive.d.ts
+/**
+ * Extension that handles interactive prompting for missing arguments.
+ * Extracts `--interactive` / `-i` flags, resolves effective interactivity,
+ * and prompts for missing fields before passing filled args to validation.
+ *
+ * Usage:
+ * ```ts
+ * createPadrone('my-cli').extend(padroneInteractive())
+ * ```
+ */
+declare function padroneInteractive(): <T extends CommandTypesBase>(builder: T) => T;
+//#endregion
+export { padroneInteractive };
+//# sourceMappingURL=interactive.d.mts.map

package/dist/extension/interactive.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactive.d.mts","names":[],"sources":["../../src/extension/interactive.ts"],"mappings":";;;;;AAwGA;;;;;;;iBAAgB,kBAAA,eAAiC,gBAAA,EAAkB,OAAA,EAAS,CAAA,KAAM,CAAA"}

package/dist/extension/interactive.mjs

@@ -0,0 +1,89 @@
+import { hasInteractiveConfig, thenMaybe } from "../core/results.mjs";
+import { defineInterceptor } from "../core/interceptors.mjs";
+import { buildCommandArgs, checkUnknownArgs } from "../core/validate.mjs";
+import { promptInteractiveFields } from "../feature/interactive.mjs";
+//#region src/extension/interactive.ts
+const interactiveInterceptor = defineInterceptor({
+	id: "padrone:interactive",
+	name: "padrone:interactive",
+	order: -999
+}, () => ({ validate(ctx, next) {
+	let flagInteractive;
+	if (hasInteractiveConfig(ctx.command.meta)) {
+		if (ctx.rawArgs.interactive !== void 0) {
+			flagInteractive = ctx.rawArgs.interactive !== false && ctx.rawArgs.interactive !== "false";
+			delete ctx.rawArgs.interactive;
+		}
+		if (ctx.rawArgs.i !== void 0) {
+			flagInteractive = ctx.rawArgs.i !== false && ctx.rawArgs.i !== "false";
+			delete ctx.rawArgs.i;
+		}
+	}
+	const { runtime, command } = ctx;
+	const runtimeDefault = runtime.interactive === "forced" ? true : runtime.interactive === "disabled" ? false : void 0;
+	const effectiveInteractive = flagInteractive ?? ctx.evalInteractive ?? runtimeDefault;
+	const stdinIsPiped = !!command.meta?.stdin && (runtime.stdin ? !runtime.stdin.isTTY : runtime.terminal?.isTTY !== true);
+	const interactivitySuppressed = runtime.interactive === "unsupported" || effectiveInteractive === false || stdinIsPiped && effectiveInteractive !== true;
+	const forceInteractive = !interactivitySuppressed && effectiveInteractive === true;
+	if (!(!interactivitySuppressed && runtime.prompt && hasInteractiveConfig(command.meta))) return next();
+	const { args: preprocessedArgs, issues: positionalIssues } = buildCommandArgs(command, ctx.rawArgs, ctx.positionalArgs);
+	if (positionalIssues) return {
+		args: void 0,
+		argsResult: { issues: positionalIssues }
+	};
+	const unknowns = checkUnknownArgs(command, preprocessedArgs);
+	if (unknowns.length > 0) return {
+		args: void 0,
+		argsResult: { issues: unknowns.map(({ key }) => ({
+			path: [key],
+			message: `Unknown option: "${key}"`
+		})) }
+	};
+	const earlyValidateAndPrompt = () => {
+		if (command.argsSchema) {
+			const providedKeys = new Set(Object.keys(preprocessedArgs).filter((k) => preprocessedArgs[k] !== void 0));
+			const earlyCheck = command.argsSchema["~standard"].validate(preprocessedArgs);
+			const checkForProvidedFieldErrors = (result) => {
+				if (!result.issues) return void 0;
+				const providedFieldIssues = result.issues.filter((issue) => {
+					const rootKey = issue.path?.[0];
+					return rootKey !== void 0 && providedKeys.has(String(rootKey));
+				});
+				if (providedFieldIssues.length > 0) return {
+					args: void 0,
+					argsResult: { issues: providedFieldIssues }
+				};
+			};
+			const earlyResult = thenMaybe(earlyCheck, (result) => checkForProvidedFieldErrors(result) ?? void 0);
+			if (earlyResult instanceof Promise) return earlyResult.then((err) => err ? err : doPrompt());
+			if (earlyResult) return earlyResult;
+		}
+		return doPrompt();
+	};
+	const doPrompt = () => {
+		return thenMaybe(promptInteractiveFields(preprocessedArgs, command, runtime, forceInteractive || void 0), (filledArgs) => {
+			return next({
+				rawArgs: filledArgs,
+				positionalArgs: []
+			});
+		});
+	};
+	return earlyValidateAndPrompt();
+} }));
+/**
+* Extension that handles interactive prompting for missing arguments.
+* Extracts `--interactive` / `-i` flags, resolves effective interactivity,
+* and prompts for missing fields before passing filled args to validation.
+*
+* Usage:
+* ```ts
+* createPadrone('my-cli').extend(padroneInteractive())
+* ```
+*/
+function padroneInteractive() {
+	return ((builder) => builder.intercept(interactiveInterceptor));
+}
+//#endregion
+export { padroneInteractive };
+
+//# sourceMappingURL=interactive.mjs.map

package/dist/extension/interactive.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactive.mjs","names":[],"sources":["../../src/extension/interactive.ts"],"sourcesContent":["import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { defineInterceptor } from '../core/interceptors.ts';\nimport { hasInteractiveConfig, thenMaybe } from '../core/results.ts';\nimport { buildCommandArgs, checkUnknownArgs } from '../core/validate.ts';\nimport { promptInteractiveFields } from '../feature/interactive.ts';\nimport type { AnyPadroneBuilder, CommandTypesBase, InterceptorValidateContext, InterceptorValidateResult } from '../types/index.ts';\n\n// ── Interceptor ─────────────────────────────────────────────────────────\n\nconst interactiveInterceptor = defineInterceptor({ id: 'padrone:interactive', name: 'padrone:interactive', order: -999 }, () => ({\n  validate(ctx: InterceptorValidateContext, next) {\n    // Extract --interactive / -i flags from rawArgs\n    let flagInteractive: boolean | undefined;\n    if (hasInteractiveConfig(ctx.command.meta)) {\n      if (ctx.rawArgs.interactive !== undefined) {\n        flagInteractive = ctx.rawArgs.interactive !== false && ctx.rawArgs.interactive !== 'false';\n        delete ctx.rawArgs.interactive;\n      }\n      if (ctx.rawArgs.i !== undefined) {\n        flagInteractive = ctx.rawArgs.i !== false && ctx.rawArgs.i !== 'false';\n        delete ctx.rawArgs.i;\n      }\n    }\n\n    // Resolve effective interactivity\n    const { runtime, command } = ctx;\n    const runtimeDefault: boolean | undefined =\n      runtime.interactive === 'forced' ? true : runtime.interactive === 'disabled' ? false : undefined;\n    const effectiveInteractive: boolean | undefined = flagInteractive ?? ctx.evalInteractive ?? runtimeDefault;\n    const commandUsesStdin = !!command.meta?.stdin;\n    const stdinIsPiped = commandUsesStdin && (runtime.stdin ? !runtime.stdin.isTTY : runtime.terminal?.isTTY !== true);\n    const interactivitySuppressed =\n      runtime.interactive === 'unsupported' || effectiveInteractive === false || (stdinIsPiped && effectiveInteractive !== true);\n    const forceInteractive = !interactivitySuppressed && effectiveInteractive === true;\n\n    const willPrompt = !interactivitySuppressed && runtime.prompt && hasInteractiveConfig(command.meta);\n    if (!willPrompt) return next();\n\n    // Preprocess args to determine what's missing\n    const { args: preprocessedArgs, issues: positionalIssues } = buildCommandArgs(command, ctx.rawArgs, ctx.positionalArgs);\n    if (positionalIssues) return { args: undefined, argsResult: { issues: positionalIssues } } as any;\n\n    // Check for unknown args before prompting\n    const unknowns = checkUnknownArgs(command, preprocessedArgs);\n    if (unknowns.length > 0) {\n      const issues: StandardSchemaV1.Issue[] = unknowns.map(({ key }) => ({\n        path: [key],\n        message: `Unknown option: \"${key}\"`,\n      }));\n      return { args: undefined, argsResult: { issues } } as any;\n    }\n\n    // Early-validate provided fields — fail fast on user-supplied errors before prompting\n    const earlyValidateAndPrompt = (): InterceptorValidateResult | Promise<InterceptorValidateResult> => {\n      if (command.argsSchema) {\n        const providedKeys = new Set(Object.keys(preprocessedArgs).filter((k) => preprocessedArgs[k] !== undefined));\n        const earlyCheck = command.argsSchema['~standard'].validate(preprocessedArgs);\n\n        const checkForProvidedFieldErrors = (result: StandardSchemaV1.Result<unknown>): InterceptorValidateResult | undefined => {\n          if (!result.issues) return undefined;\n          const providedFieldIssues = result.issues.filter((issue: StandardSchemaV1.Issue) => {\n            const rootKey = issue.path?.[0];\n            return rootKey !== undefined && providedKeys.has(String(rootKey));\n          });\n          if (providedFieldIssues.length > 0) return { args: undefined, argsResult: { issues: providedFieldIssues } as any };\n          return undefined;\n        };\n\n        const earlyResult = thenMaybe(earlyCheck, (result) => checkForProvidedFieldErrors(result) ?? undefined);\n        if (earlyResult instanceof Promise) {\n          return earlyResult.then((err) => (err ? err : doPrompt()));\n        }\n        if (earlyResult) return earlyResult;\n      }\n\n      return doPrompt();\n    };\n\n    // Prompt for missing fields, then pass filled args to downstream validation via next()\n    const doPrompt = (): InterceptorValidateResult | Promise<InterceptorValidateResult> => {\n      const afterInteractive = promptInteractiveFields(preprocessedArgs, command, runtime, forceInteractive || undefined);\n\n      return thenMaybe(afterInteractive, (filledArgs) => {\n        // Pass preprocessed+prompted args downstream with empty positionalArgs (already mapped)\n        return next({ rawArgs: filledArgs, positionalArgs: [] });\n      });\n    };\n\n    return earlyValidateAndPrompt();\n  },\n}));\n\n// ── Extension ────────────────────────────────────────────────────────────\n\n/**\n * Extension that handles interactive prompting for missing arguments.\n * Extracts `--interactive` / `-i` flags, resolves effective interactivity,\n * and prompts for missing fields before passing filled args to validation.\n *\n * Usage:\n * ```ts\n * createPadrone('my-cli').extend(padroneInteractive())\n * ```\n */\nexport function padroneInteractive(): <T extends CommandTypesBase>(builder: T) => T {\n  return ((builder: AnyPadroneBuilder) => builder.intercept(interactiveInterceptor)) as any;\n}\n"],"mappings":";;;;;AASA,MAAM,yBAAyB,kBAAkB;CAAE,IAAI;CAAuB,MAAM;CAAuB,OAAO;AAAK,UAAU,EAC/H,SAAS,KAAiC,MAAM;CAE9C,IAAI;CACJ,IAAI,qBAAqB,IAAI,QAAQ,IAAI,GAAG;EAC1C,IAAI,IAAI,QAAQ,gBAAgB,KAAA,GAAW;GACzC,kBAAkB,IAAI,QAAQ,gBAAgB,SAAS,IAAI,QAAQ,gBAAgB;GACnF,OAAO,IAAI,QAAQ;EACrB;EACA,IAAI,IAAI,QAAQ,MAAM,KAAA,GAAW;GAC/B,kBAAkB,IAAI,QAAQ,MAAM,SAAS,IAAI,QAAQ,MAAM;GAC/D,OAAO,IAAI,QAAQ;EACrB;CACF;CAGA,MAAM,EAAE,SAAS,YAAY;CAC7B,MAAM,iBACJ,QAAQ,gBAAgB,WAAW,OAAO,QAAQ,gBAAgB,aAAa,QAAQ,KAAA;CACzF,MAAM,uBAA4C,mBAAmB,IAAI,mBAAmB;CAE5F,MAAM,eAAe,CADK,CAAC,QAAQ,MAAM,UACC,QAAQ,QAAQ,CAAC,QAAQ,MAAM,QAAQ,QAAQ,UAAU,UAAU;CAC7G,MAAM,0BACJ,QAAQ,gBAAgB,iBAAiB,yBAAyB,SAAU,gBAAgB,yBAAyB;CACvH,MAAM,mBAAmB,CAAC,2BAA2B,yBAAyB;CAG9E,IAAI,EADe,CAAC,2BAA2B,QAAQ,UAAU,qBAAqB,QAAQ,IAAI,IACjF,OAAO,KAAK;CAG7B,MAAM,EAAE,MAAM,kBAAkB,QAAQ,qBAAqB,iBAAiB,SAAS,IAAI,SAAS,IAAI,cAAc;CACtH,IAAI,kBAAkB,OAAO;EAAE,MAAM,KAAA;EAAW,YAAY,EAAE,QAAQ,iBAAiB;CAAE;CAGzF,MAAM,WAAW,iBAAiB,SAAS,gBAAgB;CAC3D,IAAI,SAAS,SAAS,GAKpB,OAAO;EAAE,MAAM,KAAA;EAAW,YAAY,EAAE,QAJC,SAAS,KAAK,EAAE,WAAW;GAClE,MAAM,CAAC,GAAG;GACV,SAAS,oBAAoB,IAAI;EACnC,EAC6C,EAAE;CAAE;CAInD,MAAM,+BAA+F;EACnG,IAAI,QAAQ,YAAY;GACtB,MAAM,eAAe,IAAI,IAAI,OAAO,KAAK,gBAAgB,CAAC,CAAC,QAAQ,MAAM,iBAAiB,OAAO,KAAA,CAAS,CAAC;GAC3G,MAAM,aAAa,QAAQ,WAAW,YAAY,CAAC,SAAS,gBAAgB;GAE5E,MAAM,+BAA+B,WAAoF;IACvH,IAAI,CAAC,OAAO,QAAQ,OAAO,KAAA;IAC3B,MAAM,sBAAsB,OAAO,OAAO,QAAQ,UAAkC;KAClF,MAAM,UAAU,MAAM,OAAO;KAC7B,OAAO,YAAY,KAAA,KAAa,aAAa,IAAI,OAAO,OAAO,CAAC;IAClE,CAAC;IACD,IAAI,oBAAoB,SAAS,GAAG,OAAO;KAAE,MAAM,KAAA;KAAW,YAAY,EAAE,QAAQ,oBAAoB;IAAS;GAEnH;GAEA,MAAM,cAAc,UAAU,aAAa,WAAW,4BAA4B,MAAM,KAAK,KAAA,CAAS;GACtG,IAAI,uBAAuB,SACzB,OAAO,YAAY,MAAM,QAAS,MAAM,MAAM,SAAS,CAAE;GAE3D,IAAI,aAAa,OAAO;EAC1B;EAEA,OAAO,SAAS;CAClB;CAGA,MAAM,iBAAiF;EAGrF,OAAO,UAFkB,wBAAwB,kBAAkB,SAAS,SAAS,oBAAoB,KAAA,CAEzE,IAAI,eAAe;GAEjD,OAAO,KAAK;IAAE,SAAS;IAAY,gBAAgB,CAAC;GAAE,CAAC;EACzD,CAAC;CACH;CAEA,OAAO,uBAAuB;AAChC,EACF,EAAE;;;;;;;;;;;AAcF,SAAgB,qBAAoE;CAClF,SAAS,YAA+B,QAAQ,UAAU,sBAAsB;AAClF"}

package/dist/extension/logger.d.mts

@@ -0,0 +1,67 @@
+import { WithInterceptor } from "../util/type-utils.mjs";
+import { CommandTypesBase } from "../types/command.mjs";
+//#region src/extension/logger.d.ts
+/** Log level values ordered by severity. */
+type PadroneLogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/** Logger instance injected into the command context. */
+type PadroneLogger = {
+  trace: (...args: unknown[]) => void;
+  debug: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void; /** The current effective log level. */
+  level: PadroneLogLevel; /** Create a child logger with a prefix label. */
+  child: (label: string) => PadroneLogger;
+};
+/** Configuration for the logger extension. */
+type PadroneLoggerConfig = {
+  /** Minimum log level to output. Defaults to `'info'`. */level?: PadroneLogLevel; /** Prefix prepended to every log message. */
+  prefix?: string; /** Include timestamps in log output. Defaults to `false`. */
+  timestamps?: boolean;
+};
+/** Builder/program type after applying `padroneLogger()`. Adds `{ logger: PadroneLogger }` to the command context. */
+type WithLogger<T> = WithInterceptor<T, {
+  logger: PadroneLogger;
+}>;
+/**
+ * Extension that injects a structured logger into the command context.
+ *
+ * The logger respects a configurable log level threshold, supports prefixed
+ * child loggers, and routes output through the runtime's `output`/`error`
+ * functions so it works in any environment (terminal, test, web).
+ *
+ * Supports CLI flags for runtime level overrides:
+ * - `--trace` → sets level to `trace`
+ * - `--verbose` or `--debug` → sets level to `debug`
+ * - `--silent` or `--quiet` → sets level to `silent`
+ * - `--log-level=<level>` → sets an explicit level (`trace`, `debug`, `info`, `warn`, `error`, `silent`)
+ *
+ * CLI flags take precedence over the programmatic config.
+ *
+ * Provides `{ logger: PadroneLogger }` on the command context.
+ * Access it in action handlers as `ctx.context.logger`.
+ *
+ * Usage:
+ * ```ts
+ * createPadrone('my-cli')
+ *   .extend(padroneLogger({ level: 'info' }))
+ *   .command('sync', (c) =>
+ *     c.action((_args, ctx) => {
+ *       ctx.context.logger.info('starting sync');
+ *       const db = ctx.context.logger.child('db');
+ *       db.debug('connecting...');
+ *     })
+ *   )
+ * ```
+ *
+ * Then run:
+ * ```sh
+ * my-cli sync --verbose      # debug level
+ * my-cli sync --quiet        # silent
+ * my-cli sync --log-level=warn
+ * ```
+ */
+declare function padroneLogger<T extends CommandTypesBase>(config?: PadroneLoggerConfig): (builder: T) => WithLogger<T>;
+//#endregion
+export { PadroneLogLevel, PadroneLogger, PadroneLoggerConfig, WithLogger, padroneLogger };
+//# sourceMappingURL=logger.d.mts.map

package/dist/extension/logger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.mts","names":[],"sources":["../../src/extension/logger.ts"],"mappings":";;;;KAYY,eAAA;;KAGA,aAAA;EACV,KAAA,MAAW,IAAA;EACX,KAAA,MAAW,IAAA;EACX,IAAA,MAAU,IAAA;EACV,IAAA,MAAU,IAAA;EACV,KAAA,MAAW,IAAA,sBALY;EAOvB,KAAA,EAAO,eAAA,EAEgC;EAAvC,KAAA,GAAQ,KAAA,aAAkB,aAAa;AAAA;;KAI7B,mBAAA;EAVV,yDAYA,KAAA,GAAQ,eAAe,EAXvB;EAaA,MAAA,WAZA;EAcA,UAAA;AAAA;;KAIU,UAAA,MAAgB,eAAA,CAAgB,CAAA;EAAK,MAAA,EAAQ,aAAA;AAAA;;AAdhB;AAIzC;;;;;;;;;AAMY;AAIZ;;;;;;;;;;;;;;AAAsE;AA6NtE;;;;;;;;;;;iBAAgB,aAAA,WAAwB,gBAAA,EAAkB,MAAA,GAAS,mBAAA,IAAuB,OAAA,EAAS,CAAA,KAAM,UAAA,CAAW,CAAA"}

package/dist/extension/logger.mjs

@@ -0,0 +1,188 @@
+import { thenMaybe } from "../core/results.mjs";
+import { defineInterceptor } from "../core/interceptors.mjs";
+//#region src/extension/logger.ts
+const LEVEL_ORDER = {
+	trace: 0,
+	debug: 1,
+	info: 2,
+	warn: 3,
+	error: 4,
+	silent: 5
+};
+const LEVEL_LABELS = {
+	trace: "TRACE",
+	debug: "DEBUG",
+	info: "INFO",
+	warn: "WARN",
+	error: "ERROR"
+};
+const VALID_LEVELS = new Set(Object.keys(LEVEL_ORDER));
+/** Format specifier pattern: matches %s, %d, %i, %f, %o, %O, %j, %% */
+const FORMAT_PATTERN = /%%|%[sdifjoO]/g;
+/**
+* Applies printf-style format specifiers to args, following the WHATWG Console Standard
+* and Node.js `util.format` conventions. Remaining args are appended space-separated.
+*/
+function formatArgs(args) {
+	if (args.length === 0) return "";
+	if (typeof args[0] !== "string" || !FORMAT_PATTERN.test(args[0])) return args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+	const template = args[0];
+	let argIndex = 1;
+	const result = template.replace(FORMAT_PATTERN, (token) => {
+		if (token === "%%") return "%";
+		if (argIndex >= args.length) return token;
+		const val = args[argIndex++];
+		switch (token) {
+			case "%s": return String(val);
+			case "%d":
+			case "%i": return String(Math.trunc(Number(val)));
+			case "%f": return String(Number(val));
+			case "%j": try {
+				return JSON.stringify(val);
+			} catch {
+				return "[Circular]";
+			}
+			case "%o":
+			case "%O": return typeof val === "string" ? val : JSON.stringify(val);
+			default: return token;
+		}
+	});
+	const remaining = args.slice(argIndex);
+	if (remaining.length === 0) return result;
+	return `${result} ${remaining.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}`;
+}
+function resolveCliLevel(rawArgs) {
+	if ("trace" in rawArgs) {
+		const t = rawArgs.trace;
+		delete rawArgs.trace;
+		if (t !== false) return "trace";
+	}
+	if ("verbose" in rawArgs) {
+		const v = rawArgs.verbose;
+		delete rawArgs.verbose;
+		if (v !== false) return "debug";
+	}
+	if ("debug" in rawArgs) {
+		const d = rawArgs.debug;
+		delete rawArgs.debug;
+		if (d !== false) return "debug";
+	}
+	if ("silent" in rawArgs) {
+		const s = rawArgs.silent;
+		delete rawArgs.silent;
+		if (s !== false) return "silent";
+	}
+	if ("quiet" in rawArgs) {
+		const q = rawArgs.quiet;
+		delete rawArgs.quiet;
+		if (q !== false) return "silent";
+	}
+	if ("log-level" in rawArgs) {
+		const val = rawArgs["log-level"];
+		delete rawArgs["log-level"];
+		if (typeof val === "string" && VALID_LEVELS.has(val)) return val;
+	}
+}
+function createLogger(runtime, level, config, tracing) {
+	const threshold = LEVEL_ORDER[level];
+	function format(lvl, prefix, args) {
+		const parts = [];
+		if (config.timestamps) parts.push((/* @__PURE__ */ new Date()).toISOString());
+		parts.push(`[${LEVEL_LABELS[lvl]}]`);
+		if (prefix) parts.push(prefix);
+		parts.push(formatArgs(args));
+		return parts.join(" ");
+	}
+	function makeLogger(prefix) {
+		const emit = (lvl, args) => {
+			if (LEVEL_ORDER[lvl] < threshold) return;
+			const message = format(lvl, prefix, args);
+			tracing?.rootSpan.addEvent("log", {
+				"log.level": lvl,
+				"log.message": args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")
+			});
+			if (lvl === "error" || lvl === "warn") runtime.error(message);
+			else runtime.output(message);
+		};
+		return {
+			trace: (...args) => emit("trace", args),
+			debug: (...args) => emit("debug", args),
+			info: (...args) => emit("info", args),
+			warn: (...args) => emit("warn", args),
+			error: (...args) => emit("error", args),
+			level,
+			child: (label) => makeLogger(prefix ? `${prefix} [${label}]` : `[${label}]`)
+		};
+	}
+	return makeLogger(config.prefix);
+}
+function loggerInterceptor(rawConfig) {
+	return defineInterceptor({
+		id: "padrone:logger",
+		name: "padrone:logger"
+	}).requires().factory(() => {
+		let cliLevel;
+		return {
+			parse(_ctx, next) {
+				return thenMaybe(next(), (res) => {
+					cliLevel = resolveCliLevel(res.rawArgs);
+					return res;
+				});
+			},
+			execute(ctx, next) {
+				const ctxCfg = ctx.context?.loggerConfig;
+				const resolved = {
+					level: cliLevel ?? rawConfig?.level ?? ctxCfg?.level ?? "info",
+					prefix: rawConfig?.prefix ?? "",
+					timestamps: rawConfig?.timestamps ?? ctxCfg?.timestamps ?? false
+				};
+				return next({ context: { logger: createLogger(ctx.runtime, resolved.level, resolved, ctx.context?.tracing) } });
+			}
+		};
+	});
+}
+/**
+* Extension that injects a structured logger into the command context.
+*
+* The logger respects a configurable log level threshold, supports prefixed
+* child loggers, and routes output through the runtime's `output`/`error`
+* functions so it works in any environment (terminal, test, web).
+*
+* Supports CLI flags for runtime level overrides:
+* - `--trace` → sets level to `trace`
+* - `--verbose` or `--debug` → sets level to `debug`
+* - `--silent` or `--quiet` → sets level to `silent`
+* - `--log-level=<level>` → sets an explicit level (`trace`, `debug`, `info`, `warn`, `error`, `silent`)
+*
+* CLI flags take precedence over the programmatic config.
+*
+* Provides `{ logger: PadroneLogger }` on the command context.
+* Access it in action handlers as `ctx.context.logger`.
+*
+* Usage:
+* ```ts
+* createPadrone('my-cli')
+*   .extend(padroneLogger({ level: 'info' }))
+*   .command('sync', (c) =>
+*     c.action((_args, ctx) => {
+*       ctx.context.logger.info('starting sync');
+*       const db = ctx.context.logger.child('db');
+*       db.debug('connecting...');
+*     })
+*   )
+* ```
+*
+* Then run:
+* ```sh
+* my-cli sync --verbose      # debug level
+* my-cli sync --quiet        # silent
+* my-cli sync --log-level=warn
+* ```
+*/
+function padroneLogger(config) {
+	return ((builder) => builder.intercept(loggerInterceptor(config)));
+}
+//#endregion
+export { padroneLogger };
+
+//# sourceMappingURL=logger.mjs.map

package/dist/extension/logger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.mjs","names":[],"sources":["../../src/extension/logger.ts"],"sourcesContent":["import { defineInterceptor } from '#src/core/interceptors.ts';\nimport { thenMaybe } from '#src/core/results.ts';\nimport type { ResolvedPadroneRuntime } from '#src/core/runtime.ts';\nimport type { AnyPadroneBuilder, CommandTypesBase } from '#src/types/index.ts';\nimport type { WithInterceptor } from '#src/util/type-utils.ts';\nimport type { PadroneTracer } from './tracing.ts';\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/** Log level values ordered by severity. */\nexport type PadroneLogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';\n\n/** Logger instance injected into the command context. */\nexport type PadroneLogger = {\n  trace: (...args: unknown[]) => void;\n  debug: (...args: unknown[]) => void;\n  info: (...args: unknown[]) => void;\n  warn: (...args: unknown[]) => void;\n  error: (...args: unknown[]) => void;\n  /** The current effective log level. */\n  level: PadroneLogLevel;\n  /** Create a child logger with a prefix label. */\n  child: (label: string) => PadroneLogger;\n};\n\n/** Configuration for the logger extension. */\nexport type PadroneLoggerConfig = {\n  /** Minimum log level to output. Defaults to `'info'`. */\n  level?: PadroneLogLevel;\n  /** Prefix prepended to every log message. */\n  prefix?: string;\n  /** Include timestamps in log output. Defaults to `false`. */\n  timestamps?: boolean;\n};\n\n/** Builder/program type after applying `padroneLogger()`. Adds `{ logger: PadroneLogger }` to the command context. */\nexport type WithLogger<T> = WithInterceptor<T, { logger: PadroneLogger }>;\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nconst LEVEL_ORDER: Record<PadroneLogLevel, number> = { trace: 0, debug: 1, info: 2, warn: 3, error: 4, silent: 5 };\nconst LEVEL_LABELS: Record<Exclude<PadroneLogLevel, 'silent'>, string> = {\n  trace: 'TRACE',\n  debug: 'DEBUG',\n  info: 'INFO',\n  warn: 'WARN',\n  error: 'ERROR',\n};\nconst VALID_LEVELS = new Set<string>(Object.keys(LEVEL_ORDER));\n\n/** Format specifier pattern: matches %s, %d, %i, %f, %o, %O, %j, %% */\nconst FORMAT_PATTERN = /%%|%[sdifjoO]/g;\n\n/**\n * Applies printf-style format specifiers to args, following the WHATWG Console Standard\n * and Node.js `util.format` conventions. Remaining args are appended space-separated.\n */\nfunction formatArgs(args: unknown[]): string {\n  if (args.length === 0) return '';\n  if (typeof args[0] !== 'string' || !FORMAT_PATTERN.test(args[0])) {\n    return args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ');\n  }\n\n  const template = args[0];\n  let argIndex = 1;\n  const result = template.replace(FORMAT_PATTERN, (token) => {\n    if (token === '%%') return '%';\n    if (argIndex >= args.length) return token;\n    const val = args[argIndex++];\n    switch (token) {\n      case '%s':\n        return String(val);\n      case '%d':\n      case '%i':\n        return String(Math.trunc(Number(val)));\n      case '%f':\n        return String(Number(val));\n      case '%j':\n        try {\n          return JSON.stringify(val);\n        } catch {\n          return '[Circular]';\n        }\n      case '%o':\n      case '%O':\n        return typeof val === 'string' ? val : JSON.stringify(val);\n      default:\n        return token;\n    }\n  });\n\n  // Append remaining args that weren't consumed by specifiers\n  const remaining = args.slice(argIndex);\n  if (remaining.length === 0) return result;\n  const tail = remaining.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ');\n  return `${result} ${tail}`;\n}\n\nfunction resolveCliLevel(rawArgs: Record<string, unknown>): PadroneLogLevel | undefined {\n  // --trace → trace level\n  if ('trace' in rawArgs) {\n    const t = rawArgs.trace;\n    delete rawArgs.trace;\n    if (t !== false) return 'trace';\n  }\n  // --verbose / --debug → debug level\n  if ('verbose' in rawArgs) {\n    const v = rawArgs.verbose;\n    delete rawArgs.verbose;\n    if (v !== false) return 'debug';\n  }\n  if ('debug' in rawArgs) {\n    const d = rawArgs.debug;\n    delete rawArgs.debug;\n    if (d !== false) return 'debug';\n  }\n  // --silent / --quiet → suppress all output\n  if ('silent' in rawArgs) {\n    const s = rawArgs.silent;\n    delete rawArgs.silent;\n    if (s !== false) return 'silent';\n  }\n  if ('quiet' in rawArgs) {\n    const q = rawArgs.quiet;\n    delete rawArgs.quiet;\n    if (q !== false) return 'silent';\n  }\n  // --log-level=<level> → explicit level (parser keeps kebab-case)\n  if ('log-level' in rawArgs) {\n    const val = rawArgs['log-level'];\n    delete rawArgs['log-level'];\n    if (typeof val === 'string' && VALID_LEVELS.has(val)) return val as PadroneLogLevel;\n  }\n  return undefined;\n}\n\nfunction createLogger(\n  runtime: ResolvedPadroneRuntime,\n  level: PadroneLogLevel,\n  config: ResolvedLoggerConfig,\n  tracing?: PadroneTracer,\n): PadroneLogger {\n  const threshold = LEVEL_ORDER[level];\n\n  function format(lvl: Exclude<PadroneLogLevel, 'silent'>, prefix: string, args: unknown[]): string {\n    const parts: string[] = [];\n    if (config.timestamps) parts.push(new Date().toISOString());\n    parts.push(`[${LEVEL_LABELS[lvl]}]`);\n    if (prefix) parts.push(prefix);\n    parts.push(formatArgs(args));\n    return parts.join(' ');\n  }\n\n  function makeLogger(prefix: string): PadroneLogger {\n    const emit = (lvl: Exclude<PadroneLogLevel, 'silent'>, args: unknown[]) => {\n      if (LEVEL_ORDER[lvl] < threshold) return;\n      const message = format(lvl, prefix, args);\n      tracing?.rootSpan.addEvent('log', {\n        'log.level': lvl,\n        'log.message': args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '),\n      });\n      if (lvl === 'error' || lvl === 'warn') runtime.error(message);\n      else runtime.output(message);\n    };\n\n    return {\n      trace: (...args) => emit('trace', args),\n      debug: (...args) => emit('debug', args),\n      info: (...args) => emit('info', args),\n      warn: (...args) => emit('warn', args),\n      error: (...args) => emit('error', args),\n      level,\n      child: (label) => makeLogger(prefix ? `${prefix} [${label}]` : `[${label}]`),\n    };\n  }\n\n  return makeLogger(config.prefix);\n}\n\n// ---------------------------------------------------------------------------\n// Interceptor\n// ---------------------------------------------------------------------------\n\ntype ResolvedLoggerConfig = { level: PadroneLogLevel; prefix: string; timestamps: boolean };\n\nfunction loggerInterceptor(rawConfig?: PadroneLoggerConfig) {\n  return defineInterceptor({ id: 'padrone:logger', name: 'padrone:logger' })\n    .requires<{ tracing?: PadroneTracer; loggerConfig?: PadroneLoggerConfig }>()\n    .factory(() => {\n      let cliLevel: PadroneLogLevel | undefined;\n\n      return {\n        parse(_ctx, next) {\n          return thenMaybe(next(), (res) => {\n            cliLevel = resolveCliLevel(res.rawArgs);\n            return res;\n          });\n        },\n\n        execute(ctx, next) {\n          const ctxCfg = (ctx.context as Record<string, unknown> | undefined)?.loggerConfig as PadroneLoggerConfig | undefined;\n          const resolved: ResolvedLoggerConfig = {\n            level: cliLevel ?? rawConfig?.level ?? ctxCfg?.level ?? 'info',\n            prefix: rawConfig?.prefix ?? '',\n            timestamps: rawConfig?.timestamps ?? ctxCfg?.timestamps ?? false,\n          };\n          const logger = createLogger(ctx.runtime, resolved.level, resolved, ctx.context?.tracing);\n          return next({ context: { logger } });\n        },\n      };\n    });\n}\n\n// ---------------------------------------------------------------------------\n// Extension\n// ---------------------------------------------------------------------------\n\n/**\n * Extension that injects a structured logger into the command context.\n *\n * The logger respects a configurable log level threshold, supports prefixed\n * child loggers, and routes output through the runtime's `output`/`error`\n * functions so it works in any environment (terminal, test, web).\n *\n * Supports CLI flags for runtime level overrides:\n * - `--trace` → sets level to `trace`\n * - `--verbose` or `--debug` → sets level to `debug`\n * - `--silent` or `--quiet` → sets level to `silent`\n * - `--log-level=<level>` → sets an explicit level (`trace`, `debug`, `info`, `warn`, `error`, `silent`)\n *\n * CLI flags take precedence over the programmatic config.\n *\n * Provides `{ logger: PadroneLogger }` on the command context.\n * Access it in action handlers as `ctx.context.logger`.\n *\n * Usage:\n * ```ts\n * createPadrone('my-cli')\n *   .extend(padroneLogger({ level: 'info' }))\n *   .command('sync', (c) =>\n *     c.action((_args, ctx) => {\n *       ctx.context.logger.info('starting sync');\n *       const db = ctx.context.logger.child('db');\n *       db.debug('connecting...');\n *     })\n *   )\n * ```\n *\n * Then run:\n * ```sh\n * my-cli sync --verbose      # debug level\n * my-cli sync --quiet        # silent\n * my-cli sync --log-level=warn\n * ```\n */\nexport function padroneLogger<T extends CommandTypesBase>(config?: PadroneLoggerConfig): (builder: T) => WithLogger<T> {\n  return ((builder: AnyPadroneBuilder) => builder.intercept(loggerInterceptor(config))) as any;\n}\n"],"mappings":"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"}

package/dist/extension/man.d.mts

@@ -0,0 +1,25 @@
+import { PadroneSchema } from "../types/schema.mjs";
+import { WithCommand } from "../util/type-utils.mjs";
+import { CommandTypesBase, PadroneCommand } from "../types/command.mjs";
+//#region src/extension/man.d.ts
+type ManArgs = {
+  setup?: boolean;
+  remove?: boolean;
+};
+type ManCommand = PadroneCommand<'man', '', PadroneSchema<ManArgs>, string, [], [], true>;
+type WithMan<T> = WithCommand<T, 'man', ManCommand>;
+/**
+ * Extension that adds the `man` command for man page generation.
+ *
+ * Usage:
+ * ```ts
+ * import { createPadrone } from 'padrone';
+ * import { padroneMan } from 'padrone/man';
+ *
+ * createPadrone('my-cli').extend(padroneMan())
+ * ```
+ */
+declare function padroneMan(): <T extends CommandTypesBase>(builder: T) => WithMan<T>;
+//#endregion
+export { WithMan, padroneMan };
+//# sourceMappingURL=man.d.mts.map

package/dist/extension/man.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"man.d.mts","names":[],"sources":["../../src/extension/man.ts"],"mappings":";;;;KASK,OAAA;EAAY,KAAA;EAAiB,MAAM;AAAA;AAAA,KAEnC,UAAA,GAAa,cAAA,YAA0B,aAAA,CAAc,OAAA;AAAA,KAE9C,OAAA,MAAa,WAAA,CAAY,CAAA,SAAU,UAAA;;AAJP;AAAA;;;;;;;;;iBAmBxB,UAAA,eAAyB,gBAAA,EAAkB,OAAA,EAAS,CAAA,KAAM,OAAA,CAAQ,CAAA"}

package/dist/extension/man.mjs

@@ -0,0 +1,41 @@
+import { resolveAllCommands } from "../core/commands.mjs";
+import { getRootCommand } from "../util/utils.mjs";
+import { passthroughSchema } from "./utils.mjs";
+//#region src/extension/man.ts
+/**
+* Extension that adds the `man` command for man page generation.
+*
+* Usage:
+* ```ts
+* import { createPadrone } from 'padrone';
+* import { padroneMan } from 'padrone/man';
+*
+* createPadrone('my-cli').extend(padroneMan())
+* ```
+*/
+function padroneMan() {
+	return ((builder) => builder.command("man", (c) => c.configure({
+		description: "Generate man pages",
+		hidden: true
+	}).arguments(passthroughSchema({
+		setup: "boolean",
+		remove: "boolean"
+	})).async().action(async (args, ctx) => {
+		const rootCommand = getRootCommand(ctx.command);
+		resolveAllCommands(rootCommand);
+		const { setupManPages, removeManPages, generateDocs } = await import("../docs/index.mjs");
+		if (args.setup) {
+			const setupResult = await setupManPages(rootCommand);
+			return `${setupResult.updated ? "Updated" : "Installed"} ${setupResult.written.length} man page(s) in ${setupResult.dir}`;
+		}
+		if (args.remove) {
+			const removeResult = await removeManPages(rootCommand);
+			return removeResult.removed.length > 0 ? `Removed ${removeResult.removed.length} man page(s) from ${removeResult.dir}` : "No man pages found to remove.";
+		}
+		return generateDocs(rootCommand, { format: "man" }).pages[0]?.content ?? "";
+	})));
+}
+//#endregion
+export { padroneMan };
+
+//# sourceMappingURL=man.mjs.map

package/dist/extension/man.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"man.mjs","names":[],"sources":["../../src/extension/man.ts"],"sourcesContent":["import { resolveAllCommands } from '../core/commands.ts';\nimport type { AnyPadroneBuilder, CommandTypesBase, PadroneCommand } from '../types/index.ts';\nimport type { PadroneSchema } from '../types/schema.ts';\nimport type { WithCommand } from '../util/type-utils.ts';\nimport { getRootCommand } from '../util/utils.ts';\nimport { passthroughSchema } from './utils.ts';\n\n// ── Types ────────────────────────────────────────────────────────────────\n\ntype ManArgs = { setup?: boolean; remove?: boolean };\n\ntype ManCommand = PadroneCommand<'man', '', PadroneSchema<ManArgs>, string, [], [], true>;\n\nexport type WithMan<T> = WithCommand<T, 'man', ManCommand>;\n\n// ── Extension ────────────────────────────────────────────────────────────\n\n/**\n * Extension that adds the `man` command for man page generation.\n *\n * Usage:\n * ```ts\n * import { createPadrone } from 'padrone';\n * import { padroneMan } from 'padrone/man';\n *\n * createPadrone('my-cli').extend(padroneMan())\n * ```\n */\nexport function padroneMan(): <T extends CommandTypesBase>(builder: T) => WithMan<T> {\n  return ((builder: AnyPadroneBuilder) =>\n    builder.command('man', (c) =>\n      c\n        .configure({ description: 'Generate man pages', hidden: true })\n        .arguments(passthroughSchema({ setup: 'boolean', remove: 'boolean' }))\n        .async()\n        .action(async (args, ctx) => {\n          const rootCommand = getRootCommand(ctx.command);\n          resolveAllCommands(rootCommand);\n          const { setupManPages, removeManPages, generateDocs } = await import('../docs/index.ts');\n          if (args.setup) {\n            const setupResult = await setupManPages(rootCommand);\n            return `${setupResult.updated ? 'Updated' : 'Installed'} ${setupResult.written.length} man page(s) in ${setupResult.dir}`;\n          }\n          if (args.remove) {\n            const removeResult = await removeManPages(rootCommand);\n            return removeResult.removed.length > 0\n              ? `Removed ${removeResult.removed.length} man page(s) from ${removeResult.dir}`\n              : 'No man pages found to remove.';\n          }\n          const docsResult = generateDocs(rootCommand, { format: 'man' });\n          return docsResult.pages[0]?.content ?? '';\n        }),\n    )) as any;\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4BA,SAAgB,aAAqE;CACnF,SAAS,YACP,QAAQ,QAAQ,QAAQ,MACtB,EACG,UAAU;EAAE,aAAa;EAAsB,QAAQ;CAAK,CAAC,CAAC,CAC9D,UAAU,kBAAkB;EAAE,OAAO;EAAW,QAAQ;CAAU,CAAC,CAAC,CAAC,CACrE,MAAM,CAAC,CACP,OAAO,OAAO,MAAM,QAAQ;EAC3B,MAAM,cAAc,eAAe,IAAI,OAAO;EAC9C,mBAAmB,WAAW;EAC9B,MAAM,EAAE,eAAe,gBAAgB,iBAAiB,MAAM,OAAO;EACrE,IAAI,KAAK,OAAO;GACd,MAAM,cAAc,MAAM,cAAc,WAAW;GACnD,OAAO,GAAG,YAAY,UAAU,YAAY,YAAY,GAAG,YAAY,QAAQ,OAAO,kBAAkB,YAAY;EACtH;EACA,IAAI,KAAK,QAAQ;GACf,MAAM,eAAe,MAAM,eAAe,WAAW;GACrD,OAAO,aAAa,QAAQ,SAAS,IACjC,WAAW,aAAa,QAAQ,OAAO,oBAAoB,aAAa,QACxE;EACN;EAEA,OADmB,aAAa,aAAa,EAAE,QAAQ,MAAM,CAC7C,CAAC,CAAC,MAAM,EAAE,EAAE,WAAW;CACzC,CAAC,CACL;AACJ"}

package/dist/extension/mcp.d.mts

@@ -0,0 +1,28 @@
+import { PadroneSchema } from "../types/schema.mjs";
+import { WithCommand } from "../util/type-utils.mjs";
+import { PadroneMcpPreferences } from "../feature/mcp.mjs";
+import { CommandTypesBase, PadroneCommand } from "../types/command.mjs";
+//#region src/extension/mcp.d.ts
+type McpArgs = {
+  transport?: string;
+  port?: string;
+  host?: string;
+  basePath?: string;
+};
+type McpCommand = PadroneCommand<'mcp', '', PadroneSchema<McpArgs>, void, [], [], true>;
+type WithMcp<T> = WithCommand<T, 'mcp', McpCommand>;
+/**
+ * Extension that adds the `mcp` command for starting a Model Context Protocol server.
+ *
+ * Usage:
+ * ```ts
+ * import { createPadrone } from 'padrone';
+ * import { padroneMcp } from 'padrone/mcp';
+ *
+ * createPadrone('my-cli').extend(padroneMcp())
+ * ```
+ */
+declare function padroneMcp(defaults?: PadroneMcpPreferences): <T extends CommandTypesBase>(builder: T) => WithMcp<T>;
+//#endregion
+export { WithMcp, padroneMcp };
+//# sourceMappingURL=mcp.d.mts.map

package/dist/extension/mcp.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.mts","names":[],"sources":["../../src/extension/mcp.ts"],"mappings":";;;;;KAUK,OAAA;EAAY,SAAA;EAAoB,IAAA;EAAe,IAAA;EAAe,QAAA;AAAA;AAAA,KAE9D,UAAA,GAAa,cAAA,YAA0B,aAAA,CAAc,OAAA;AAAA,KAE9C,OAAA,MAAa,WAAA,CAAY,CAAA,SAAU,UAAA;;;;;AAJ4B;AAAA;;;;;;iBAmB3D,UAAA,CAAW,QAAA,GAAW,qBAAA,cAAmC,gBAAA,EAAkB,OAAA,EAAS,CAAA,KAAM,OAAA,CAAQ,CAAA"}