padrone 1.6.0 → 1.7.1

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import { _ as resolveStdin, c as getCommandRuntime, d as repathCommandTree, f as resolveAllCommands, g as createTerminalReplSession, h as suggestSimilar, i as commandSymbol, l as lazyResolver, n as buildReplCompleter, o as findCommandByName, p as resolveCommand, u as mergeCommands, v as resolveStdinAlways, y as REPL_SIGINT } from "./commands-B_gufyR9.mjs";
 import { a as getJsonSchema, c as parsePositionalConfig, i as extractSchemaMetadata, l as preprocessArgs, n as coerceArgs, o as isArrayField, r as detectUnknownArgs, s as isAsyncStreamField, t as applyValues } from "./args-Cnq0nwSM.mjs";
 import { i as createStdinStream, r as concatBytes, t as asyncStream } from "./stream-DC4H8YTx.mjs";
-import { a as SignalError, i as RoutingError, n as ConfigError, o as ValidationError, r as PadroneError, s as signalExitCode, t as ActionError } from "./errors-CL63UOzt.mjs";
-import { a as getVersion, i as getRootCommand, r as colorThemes, t as generateHelp } from "./help-B5Kk83of.mjs";
+import { a as escapeHtml, i as getVersion, o as resolveOutputFormat, r as getRootCommand, s as colorThemes, t as generateHelp } from "./help-BtxLgrF_.mjs";
+import { a as SignalError, i as RoutingError, n as ConfigError, o as ValidationError, r as PadroneError, s as signalExitCode, t as ActionError } from "./errors-DA4KzK1M.mjs";
 //#region src/core/results.ts
 /**
 * Brands a schema as async, signaling that its `validate()` may return a Promise.
@@ -326,6 +326,258 @@ function wrapWithLifecycle(interceptors, command, input, pipeline, wrapErrorResu
 	return handleSuccess(result);
 }
 //#endregion
+//#region src/output/primitives.ts
+function stringifyCell(value) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+}
+function truncate(text, max) {
+	if (max <= 0 || text.length <= max) return text;
+	return max <= 1 ? "…" : `${text.slice(0, max - 1)}…`;
+}
+function padCell(text, width, alignment = "left") {
+	const pad = width - text.length;
+	if (pad <= 0) return text;
+	if (alignment === "right") return " ".repeat(pad) + text;
+	if (alignment === "center") {
+		const left = Math.floor(pad / 2);
+		return " ".repeat(left) + text + " ".repeat(pad - left);
+	}
+	return text + " ".repeat(pad);
+}
+function renderTable(data, options, ctx) {
+	if (data.length === 0) return "";
+	if (ctx.format === "json") return JSON.stringify(data, null, 2);
+	const columns = options?.columns ?? Object.keys(data[0]);
+	if (columns.length === 0) return "";
+	const headers = columns.map((col) => options?.headers?.[col] ?? col);
+	const maxCol = options?.maxColumnWidth;
+	const rows = data.map((row) => columns.map((col) => {
+		const text = stringifyCell(row[col]);
+		return maxCol ? truncate(text, maxCol) : text;
+	}));
+	const colWidths = columns.map((_, i) => {
+		const headerWidth = headers[i].length;
+		const maxCellWidth = rows.reduce((max, row) => Math.max(max, row[i].length), 0);
+		return Math.max(headerWidth, maxCellWidth);
+	});
+	const getAlign = (i) => options?.align?.[columns[i]] ?? "left";
+	if (ctx.format === "markdown") return renderTableMarkdown(headers, rows, colWidths, getAlign);
+	if (ctx.format === "html") return renderTableHtml(columns, headers, rows, data, getAlign);
+	return renderTableText(headers, rows, colWidths, getAlign, options?.border !== false, ctx);
+}
+function renderTableText(headers, rows, colWidths, getAlign, border, ctx) {
+	const { styler } = ctx;
+	const formatRow = (cells, style) => cells.map((cell, i) => {
+		const padded = padCell(cell, colWidths[i], getAlign(i));
+		return style ? style(padded) : padded;
+	});
+	if (border) {
+		const sep = ctx.styler.meta("─");
+		const divider = colWidths.map((w) => sep.repeat(w + 2)).join(styler.meta("┼"));
+		const row = (cells) => cells.map((c, i) => ` ${padCell(c, colWidths[i], getAlign(i))} `).join(styler.meta("│"));
+		const headerRow = row(headers.map((h) => styler.label(h)));
+		const dataRows = rows.map((r) => row(r.map((c) => styler.description(c))));
+		return [
+			headerRow,
+			styler.meta("─") + divider + styler.meta("─"),
+			...dataRows
+		].join("\n");
+	}
+	const headerCells = formatRow(headers, styler.label);
+	const dataCells = rows.map((r) => formatRow(r, styler.description));
+	const gap = "  ";
+	return [headerCells.join(gap), ...dataCells.map((r) => r.join(gap))].join("\n");
+}
+function renderTableMarkdown(headers, rows, colWidths, getAlign) {
+	return [
+		`| ${headers.map((h, i) => padCell(h, colWidths[i], "left")).join(" | ")} |`,
+		"| " + colWidths.map((w, i) => {
+			const a = getAlign(i);
+			const dashes = "─".repeat(Math.max(w, 3));
+			if (a === "center") return `:${dashes}:`;
+			if (a === "right") return `${dashes}:`;
+			return dashes;
+		}).join(" | ") + " |",
+		...rows.map((r) => `| ${r.map((c, i) => padCell(c, colWidths[i], "left")).join(" | ")} |`)
+	].join("\n");
+}
+function renderTableHtml(columns, headers, _rows, data, getAlign) {
+	const ths = headers.map((h, i) => {
+		const a = getAlign(i);
+		return `<th${a !== "left" ? ` style="text-align: ${a};"` : ""}>${escapeHtml(h)}</th>`;
+	});
+	const trs = data.map((row) => "<tr>" + columns.map((col, i) => {
+		const a = getAlign(i);
+		return `<td${a !== "left" ? ` style="text-align: ${a};"` : ""}>${escapeHtml(stringifyCell(row[col]))}</td>`;
+	}).join("") + "</tr>");
+	return `<table><thead><tr>${ths.join("")}</tr></thead><tbody>${trs.join("")}</tbody></table>`;
+}
+function renderTree(data, options, ctx) {
+	const nodes = Array.isArray(data) ? data : [data];
+	if (nodes.length === 0) return "";
+	if (ctx.format === "json") return JSON.stringify(nodes, null, 2);
+	if (ctx.format === "markdown") return renderTreeMarkdown(nodes, 0);
+	if (ctx.format === "html") return renderTreeHtml(nodes);
+	return renderTreeText(nodes, "", options?.guides !== false, ctx).join("\n");
+}
+function renderTreeText(nodes, prefix, guides, ctx) {
+	const lines = [];
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		const isLast = i === nodes.length - 1;
+		if (guides) {
+			const connector = isLast ? "└── " : "├── ";
+			const childPrefix = isLast ? "    " : "│   ";
+			lines.push(prefix + ctx.styler.meta(connector) + ctx.styler.label(node.label));
+			if (node.children?.length) lines.push(...renderTreeText(node.children, prefix + ctx.styler.meta(childPrefix), guides, ctx));
+		} else {
+			const indent = prefix ? `${prefix}  ` : "";
+			lines.push(indent + ctx.styler.label(node.label));
+			if (node.children?.length) lines.push(...renderTreeText(node.children, indent, guides, ctx));
+		}
+	}
+	return lines;
+}
+function renderTreeMarkdown(nodes, depth) {
+	return nodes.map((node) => {
+		const line = `${"  ".repeat(depth)}- ${node.label}`;
+		if (!node.children?.length) return line;
+		return `${line}\n${renderTreeMarkdown(node.children, depth + 1)}`;
+	}).join("\n");
+}
+function renderTreeHtml(nodes) {
+	return `<ul>${nodes.map((node) => {
+		const label = escapeHtml(node.label);
+		if (!node.children?.length) return `<li>${label}</li>`;
+		return `<li>${label}${renderTreeHtml(node.children)}</li>`;
+	}).join("")}</ul>`;
+}
+function renderList(data, options, ctx) {
+	if (data.length === 0) return "";
+	if (ctx.format === "json") {
+		const normalized = data.map((item) => typeof item === "string" ? { label: item } : item);
+		return JSON.stringify(normalized, null, 2);
+	}
+	if (ctx.format === "markdown") return renderListMarkdown(data, options);
+	if (ctx.format === "html") return renderListHtml(data, options);
+	return renderListText(data, options, ctx);
+}
+function renderListText(data, options, ctx) {
+	const { styler } = ctx;
+	const numbered = options?.numbered ?? false;
+	const bullet = options?.bullet ?? (ctx.format === "ansi" ? "•" : "-");
+	const baseIndent = "  ".repeat(options?.indent ?? 0);
+	return data.map((item, i) => {
+		const prefix = numbered ? `${i + 1}.` : bullet;
+		const label = typeof item === "string" ? item : item.label;
+		const desc = typeof item === "object" && item.description ? item.description : void 0;
+		const line = `${baseIndent}${styler.meta(prefix)} ${styler.label(label)}`;
+		if (!desc) return line;
+		return `${line}  ${styler.description(desc)}`;
+	}).join("\n");
+}
+function renderListMarkdown(data, options) {
+	const numbered = options?.numbered ?? false;
+	return data.map((item, i) => {
+		const prefix = numbered ? `${i + 1}.` : "-";
+		const label = typeof item === "string" ? item : item.label;
+		const desc = typeof item === "object" && item.description ? item.description : void 0;
+		if (!desc) return `${prefix} ${label}`;
+		return `${prefix} **${label}** — ${desc}`;
+	}).join("\n");
+}
+function renderListHtml(data, options) {
+	const tag = options?.numbered ? "ol" : "ul";
+	return `<${tag}>${data.map((item) => {
+		const label = typeof item === "string" ? item : item.label;
+		const desc = typeof item === "object" && item.description ? item.description : void 0;
+		if (!desc) return `<li>${escapeHtml(label)}</li>`;
+		return `<li><strong>${escapeHtml(label)}</strong> — ${escapeHtml(desc)}</li>`;
+	}).join("")}</${tag}>`;
+}
+function renderKeyValue(data, options, ctx) {
+	const entries = Object.entries(data);
+	if (entries.length === 0) return "";
+	if (ctx.format === "json") return JSON.stringify(data, null, 2);
+	if (ctx.format === "markdown") return renderKeyValueMarkdown(entries, options);
+	if (ctx.format === "html") return renderKeyValueHtml(entries, options);
+	return renderKeyValueText(entries, options, ctx);
+}
+function getLabel(key, labels) {
+	return labels?.[key] ?? key;
+}
+function renderKeyValueText(entries, options, ctx) {
+	const { styler } = ctx;
+	const sep = options?.separator ?? ": ";
+	const shouldAlign = options?.align !== false;
+	const displayLabels = entries.map(([k]) => getLabel(k, options?.labels));
+	const maxWidth = shouldAlign ? Math.max(...displayLabels.map((l) => l.length)) : 0;
+	return entries.map(([_key, value], i) => {
+		const label = displayLabels[i];
+		const paddedLabel = shouldAlign ? label + " ".repeat(maxWidth - label.length) : label;
+		return `${styler.label(paddedLabel)}${styler.meta(sep)}${styler.description(stringifyCell(value))}`;
+	}).join("\n");
+}
+function renderKeyValueMarkdown(entries, options) {
+	return entries.map(([key, value]) => `- **${getLabel(key, options?.labels)}**: ${stringifyCell(value)}`).join("\n");
+}
+function renderKeyValueHtml(entries, options) {
+	return `<dl>${entries.map(([key, value]) => `<dt>${escapeHtml(getLabel(key, options?.labels))}</dt><dd>${escapeHtml(stringifyCell(value))}</dd>`).join("")}</dl>`;
+}
+//#endregion
+//#region src/output/output-indicator.ts
+/** Create an output indicator that renders through the given output function and format context. */
+function createOutputIndicator(outputFn, ctx) {
+	let _called = false;
+	const emit = (rendered) => {
+		_called = true;
+		outputFn(rendered);
+	};
+	return {
+		table(data, options) {
+			emit(renderTable(data, options, ctx));
+		},
+		tree(data, options) {
+			emit(renderTree(data, options, ctx));
+		},
+		list(data, options) {
+			emit(renderList(data, options, ctx));
+		},
+		kv(data, options) {
+			emit(renderKeyValue(data, options, ctx));
+		},
+		raw(...args) {
+			_called = true;
+			outputFn(...args);
+		},
+		get called() {
+			return _called;
+		}
+	};
+}
+/** Format a return value using a declarative output config. */
+function formatDeclarativeOutput(value, config, ctx) {
+	const type = typeof config === "string" ? config : config.type;
+	const options = typeof config === "object" ? config.options : void 0;
+	switch (type) {
+		case "table":
+			if (!Array.isArray(value)) return void 0;
+			return renderTable(value, options, ctx);
+		case "tree": return renderTree(value, options, ctx);
+		case "list":
+			if (!Array.isArray(value)) return void 0;
+			return renderList(value, options, ctx);
+		case "kv":
+			if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+			return renderKeyValue(value, options, ctx);
+		case "json": return JSON.stringify(value, null, 2);
+		default: return;
+	}
+}
+//#endregion
 //#region src/extension/auto-output.ts
 /**
 * Outputs each value and collects into a result.
@@ -366,17 +618,36 @@ const autoOutputMeta = {
 	name: "padrone:auto-output",
 	order: -1100
 };
-const autoOutputInterceptor = defineInterceptor(autoOutputMeta, () => ({ execute(ctx, next) {
-	const handleResult = (e) => {
-		if (e.result instanceof Promise) return { result: e.result.then((value) => outputAndCollect(value, ctx.runtime.output)) };
-		const collected = outputAndCollect(e.result, ctx.runtime.output);
-		if (collected instanceof Promise) return collected.then((v) => ({ result: v }));
-		return { result: collected };
-	};
-	const executedOrPromise = next();
-	if (executedOrPromise instanceof Promise) return executedOrPromise.then(handleResult);
-	return handleResult(executedOrPromise);
-} }));
+function createAutoOutputInterceptor(outputConfig) {
+	return defineInterceptor(autoOutputMeta, () => ({ execute(ctx, next) {
+		const outputCtx = resolveOutputFormat(ctx.runtime, ctx.caller);
+		const indicator = createOutputIndicator(ctx.runtime.output, outputCtx);
+		const handleResult = (e) => {
+			if (indicator.called) return e;
+			const autoOutput = (value) => {
+				if (value == null) return value;
+				if (outputConfig) {
+					const rendered = formatDeclarativeOutput(value, outputConfig, outputCtx);
+					if (rendered !== void 0) {
+						ctx.runtime.output(rendered);
+						return value;
+					}
+				}
+				return outputAndCollect(value, ctx.runtime.output);
+			};
+			if (e.result instanceof Promise) return { result: e.result.then(autoOutput) };
+			const collected = autoOutput(e.result);
+			if (collected instanceof Promise) return collected.then((v) => ({ result: v }));
+			return { result: collected };
+		};
+		const executedOrPromise = next({ context: {
+			...ctx.context,
+			output: indicator
+		} });
+		if (executedOrPromise instanceof Promise) return executedOrPromise.then(handleResult);
+		return handleResult(executedOrPromise);
+	} }));
+}
 /**
 * Extension that automatically writes a command's return value to output after execution.
 *
@@ -386,12 +657,15 @@ const autoOutputInterceptor = defineInterceptor(autoOutputMeta, () => ({ execute
 *   The result is replaced with the collected array so `drain()` still works.
 * - `undefined` and `null` results produce no output.
 *
+* Also injects `ctx.context.output` with format-aware output primitives (table, tree, list, kv).
+* When action handlers use these methods, auto-output skips to avoid double output.
+*
 * Included in the default extensions. Can also be applied per-command:
 * ```ts
 * createPadrone('my-cli')
-*   .command('greet', (c) =>
-*     c.extend(padroneAutoOutput())
-*       .action(() => 'hello')
+*   .command('users', (c) =>
+*     c.extend(padroneAutoOutput({ output: 'table' }))
+*       .action(() => fetchUsers())
 *   )
 * ```
 */
@@ -399,7 +673,7 @@ function padroneAutoOutput(options) {
 	const interceptor = options?.disabled ? defineInterceptor({
 		...autoOutputMeta,
 		disabled: true
-	}, () => ({})) : autoOutputInterceptor;
+	}, () => ({})) : createAutoOutputInterceptor(options?.output);
 	return ((builder) => builder.intercept(interceptor));
 }
 //#endregion
@@ -2188,12 +2462,12 @@ function createProgramMethods(ctx, evalCommand) {
 	};
 	const mcp = async (prefs) => {
 		resolveAllCommands(rootCommand);
-		const { startMcpServer } = await import("./mcp-BM-d0nZi.mjs");
+		const { startMcpServer } = await import("./mcp-6-Jw4Bpq.mjs");
 		return startMcpServer(ctx.builder, rootCommand, evalCommand, prefs);
 	};
 	const serve = async (prefs) => {
 		resolveAllCommands(rootCommand);
-		const { startServeServer } = await import("./serve-Bk0JUlCj.mjs");
+		const { startServeServer } = await import("./serve-YVTPzBCl.mjs");
 		return startServeServer(ctx.builder, rootCommand, evalCommand, prefs);
 	};
 	return {
@@ -2414,6 +2688,34 @@ function createPadroneBuilder(inputCommand) {
 	execCtx.builder = builder;
 	return builder;
 }
+/**
+* Identity helper that contextually types a command builder callback while preserving its full return type.
+* Use this when defining commands in separate files — the parent program retains exact type information
+* about the subcommand's args, result, and nested commands.
+*
+* @example
+* ```ts
+* // my-command.ts
+* export const myCommand = defineCommand((c) =>
+*   c.arguments(z.object({ name: z.string() }))
+*    .action((args) => console.log(args.name))
+* );
+*
+* // cli.ts
+* createPadrone('test').command('my-command', myCommand)
+* ```
+*
+* @example With context
+* ```ts
+* export const myCommand = defineCommand<{ db: Database }>((c) =>
+*   c.arguments(z.object({ id: z.string() }))
+*    .action((args, ctx) => ctx.context.db.find(args.id))
+* );
+* ```
+*/
+function defineCommand(fn) {
+	return fn;
+}
 //#endregion
 //#region src/extension/completion.ts
 /**
@@ -2507,7 +2809,10 @@ function loadConfigSync(fs, path, files, xdgAppName) {
 			return Bun.JSONC.parse(getContent());
 		}
 	}
-	if (ext === ".js" || ext === ".cjs" || ext === ".mjs" || ext === ".ts" || ext === ".cts" || ext === ".mts") return import(absolutePath).then((mod) => mod.default ?? mod);
+	if (ext === ".js" || ext === ".cjs" || ext === ".mjs" || ext === ".ts" || ext === ".cts" || ext === ".mts") return import(
+		/* @vite-ignore */
+		absolutePath
+).then((mod) => mod.default ?? mod);
 	try {
 		return JSON.parse(getContent());
 	} catch {
@@ -2886,6 +3191,40 @@ const LEVEL_LABELS = {
 	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;
@@ -2925,7 +3264,7 @@ function createLogger(runtime, level, config, tracing) {
 		if (config.timestamps) parts.push((/* @__PURE__ */ new Date()).toISOString());
 		parts.push(`[${LEVEL_LABELS[lvl]}]`);
 		if (prefix) parts.push(prefix);
-		parts.push(args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" "));
+		parts.push(formatArgs(args));
 		return parts.join(" ");
 	}
 	function makeLogger(prefix) {
@@ -3075,7 +3414,7 @@ function padroneMcp(defaults) {
 	}), { positional: ["transport"] }).async().action(async (args, ctx) => {
 		const rootCommand = getRootCommand(ctx.command);
 		resolveAllCommands(rootCommand);
-		const { startMcpServer } = await import("./mcp-BM-d0nZi.mjs");
+		const { startMcpServer } = await import("./mcp-6-Jw4Bpq.mjs");
 		const transport = args.transport === "stdio" || args.transport === "http" ? args.transport : void 0;
 		const port = args.port ? parseInt(args.port, 10) : void 0;
 		const prefs = {
@@ -3612,7 +3951,7 @@ function padroneServe(defaults) {
 	})).async().action(async (args, ctx) => {
 		const rootCommand = getRootCommand(ctx.command);
 		resolveAllCommands(rootCommand);
-		const { startServeServer } = await import("./serve-Bk0JUlCj.mjs");
+		const { startServeServer } = await import("./serve-YVTPzBCl.mjs");
 		const port = args.port ? parseInt(args.port, 10) : void 0;
 		const prefs = {
 			...defaults,
@@ -3850,6 +4189,6 @@ function padroneUpdateCheck(config = {}) {
 	return ((builder) => builder.intercept(createUpdateCheckInterceptor(config)));
 }
 //#endregion
-export { ActionError, ConfigError, PadroneError, REPL_SIGINT, RoutingError, SignalError, ValidationError, asyncSchema, asyncStream, buildReplCompleter, colorThemes, createPadrone, createTerminalProgress, defineInterceptor, isReactElement, padroneAutoOutput, padroneColor, padroneCompletion, padroneConfig, padroneEnv, padroneHelp, padroneInk, padroneInteractive, padroneLogger, padroneMan, padroneMcp, padroneProgress, padroneRepl, padroneServe, padroneSignalHandling, padroneStdin, padroneSuggestions, padroneTiming, padroneTracing, padroneUpdateCheck, padroneVersion };
+export { ActionError, ConfigError, PadroneError, REPL_SIGINT, RoutingError, SignalError, ValidationError, asyncSchema, asyncStream, buildReplCompleter, colorThemes, createPadrone, createTerminalProgress, defineCommand, defineInterceptor, isReactElement, padroneAutoOutput, padroneColor, padroneCompletion, padroneConfig, padroneEnv, padroneHelp, padroneInk, padroneInteractive, padroneLogger, padroneMan, padroneMcp, padroneProgress, padroneRepl, padroneServe, padroneSignalHandling, padroneStdin, padroneSuggestions, padroneTiming, padroneTracing, padroneUpdateCheck, padroneVersion };
 
 //# sourceMappingURL=index.mjs.map