padrone 1.5.0 → 1.6.0

package/src/{formatter.ts → output/formatter.ts}

@@ -1,6 +1,25 @@
-import { camelToKebab } from './args.ts';
+import { camelToKebab } from '../util/shell-utils.ts';
 import { type ColorConfig, type ColorTheme, createColorizer } from './colorizer.ts';
 
+const DEFAULT_TERMINAL_WIDTH = 80;
+
+function wrapText(text: string, maxWidth: number): string[] {
+  if (maxWidth <= 0 || text.length <= maxWidth) return [text];
+  const words = text.split(' ');
+  const lines: string[] = [];
+  let current = '';
+  for (const word of words) {
+    if (current && current.length + 1 + word.length > maxWidth) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = current ? `${current} ${word}` : word;
+    }
+  }
+  if (current) lines.push(current);
+  return lines.length > 0 ? lines : [text];
+}
+
 export type HelpFormat = 'text' | 'ansi' | 'console' | 'markdown' | 'html' | 'json';
 export type HelpDetail = 'minimal' | 'standard' | 'full';
 
@@ -269,7 +288,7 @@ function createHtmlLayout(): LayoutConfig {
 /**
  * Creates a formatter that uses the given styler and layout configuration.
  */
-function createGenericFormatter(styler: Styler, layout: LayoutConfig, showAllBuiltins?: boolean): Formatter {
+function createGenericFormatter(styler: Styler, layout: LayoutConfig, showAllBuiltins?: boolean, terminalWidth?: number): Formatter {
   const { newline, indent, join, wrapDocument } = layout;
 
   function formatUsageSection(info: HelpInfo): string[] {
@@ -366,15 +385,53 @@ function createGenericFormatter(styler: Styler, layout: LayoutConfig, showAllBui
     lines.push(styler.section('Arguments:'));
 
     const maxNameLength = Math.min(32, Math.max(...args.map((a) => a.name.length)));
+    const descCol = 2 + maxNameLength + 2;
+    const posAvailWidth = terminalWidth ? terminalWidth - descCol : undefined;
+    const descColPad = ' '.repeat(descCol);
 
     for (const arg of args) {
       const padding = ' '.repeat(Math.max(2, maxNameLength - arg.name.length + 2));
-      const descParts: string[] = [];
-      if (arg.description) descParts.push(styler.description(arg.description));
-      if (info.usage.stdinField === arg.name) descParts.push(styler.meta('(stdin)'));
-      if (arg.enum) descParts.push(styler.meta(`(choices: ${arg.enum.join(', ')})`));
-      if (arg.default !== undefined) descParts.push(styler.meta(`(default: ${String(arg.default)})`));
-      lines.push(indent(1) + styler.arg(arg.name) + padding + join(descParts));
+      const prefix = indent(1) + styler.arg(arg.name) + padding;
+
+      const descPlain = arg.description ?? '';
+      const styledDesc = descPlain ? styler.description(descPlain) : '';
+
+      const metaParts: string[] = [];
+      const styledMetaParts: string[] = [];
+      if (info.usage.stdinField === arg.name) {
+        metaParts.push('(stdin)');
+        styledMetaParts.push(styler.meta('(stdin)'));
+      }
+      if (arg.enum) {
+        const text = `(choices: ${arg.enum.join(', ')})`;
+        metaParts.push(text);
+        styledMetaParts.push(styler.meta(text));
+      }
+      if (arg.default !== undefined) {
+        const text = `(default: ${String(arg.default)})`;
+        metaParts.push(text);
+        styledMetaParts.push(styler.meta(text));
+      }
+
+      const metaStyled = join(styledMetaParts);
+
+      if (posAvailWidth && posAvailWidth > 0) {
+        const metaPlain = metaParts.join(' ');
+        const fullPlain = [descPlain, metaPlain].filter(Boolean).join(' ');
+        if (fullPlain.length <= posAvailWidth) {
+          lines.push(prefix + [styledDesc, metaStyled].filter(Boolean).join(' '));
+        } else if (!descPlain || descPlain.length <= posAvailWidth) {
+          lines.push(prefix + styledDesc);
+          if (metaStyled) lines.push(descColPad + metaStyled);
+        } else {
+          const wrapped = wrapText(descPlain, posAvailWidth);
+          lines.push(prefix + styler.description(wrapped[0]!));
+          for (const wline of wrapped.slice(1)) lines.push(descColPad + styler.description(wline));
+          if (metaStyled) lines.push(descColPad + metaStyled);
+        }
+      } else {
+        lines.push(prefix + join([styledDesc, metaStyled]));
+      }
     }
 
     return lines;
@@ -413,6 +470,9 @@ function createGenericFormatter(styler: Styler, layout: LayoutConfig, showAllBui
     const maxNamesWidth = Math.min(32, Math.max(0, ...argColumns.map((c) => c.namesPlain.length)));
     const maxTypeWidth = Math.min(16, Math.max(0, ...argColumns.map((c) => c.typePlain.length)));
     const hasAnyFlags = maxFlagsWidth > 0;
+    const descCol = 2 + (hasAnyFlags ? maxFlagsWidth + 2 : 0) + maxNamesWidth + 2 + (maxTypeWidth > 0 ? maxTypeWidth + 2 : 0);
+    const argAvailWidth = terminalWidth ? terminalWidth - descCol : undefined;
+    const descColPad = ' '.repeat(descCol);
 
     // Split into ordered groups: ungrouped first as "Options:", then each group in first-seen order
     const grouped = Object.groupBy(argColumns, (c) => c.arg.group ?? '');
@@ -441,28 +501,65 @@ function createGenericFormatter(styler: Styler, layout: LayoutConfig, showAllBui
           parts.push(styledType + typePadding);
         }
 
-        // Line 1: description
-        const descParts: string[] = [];
-        if (arg.description) descParts.push(isDeprecated ? styler.deprecated(arg.description) : styler.description(arg.description));
-        lines.push(indent(1) + parts.join('') + join(descParts));
+        const prefix = indent(1) + parts.join('');
+        const contPad = argAvailWidth ? descColPad : indent(3);
+
+        // Build inline meta (deprecated no-reason, default, choices)
+        const inlineMeta: string[] = [];
+        const styledInlineMeta: string[] = [];
+        if (isDeprecated && typeof arg.deprecated !== 'string') {
+          inlineMeta.push('(deprecated)');
+          styledInlineMeta.push(styler.meta('(deprecated)'));
+        }
+        if (hasDefault(arg.default)) {
+          const text = `(default: ${String(arg.default)})`;
+          inlineMeta.push(text);
+          styledInlineMeta.push(styler.meta(text));
+        }
+        if (arg.enum) {
+          const text = `(choices: ${arg.enum.join(', ')})`;
+          inlineMeta.push(text);
+          styledInlineMeta.push(styler.meta(text));
+        }
 
-        // Line 2: deprecated (no reason), default, choices
-        const line2Parts: string[] = [];
-        if (isDeprecated && typeof arg.deprecated !== 'string') line2Parts.push(styler.meta('(deprecated)'));
-        if (hasDefault(arg.default)) line2Parts.push(styler.meta(`(default: ${String(arg.default)})`));
-        if (arg.enum) line2Parts.push(styler.meta(`(choices: ${arg.enum.join(', ')})`));
-        if (line2Parts.length > 0) lines.push(indent(3) + join(line2Parts));
+        const descPlain = arg.description ?? '';
+        const styledDesc = descPlain ? (isDeprecated ? styler.deprecated(descPlain) : styler.description(descPlain)) : '';
+        const metaStyled = join(styledInlineMeta);
+
+        if (argAvailWidth && argAvailWidth > 0) {
+          // Terminal-width-aware: try to fit description + meta on one line
+          const metaPlain = inlineMeta.join(' ');
+          const fullPlain = [descPlain, metaPlain].filter(Boolean).join(' ');
+          if (fullPlain.length <= argAvailWidth) {
+            lines.push(prefix + [styledDesc, metaStyled].filter(Boolean).join(' '));
+          } else if (!descPlain || descPlain.length <= argAvailWidth) {
+            lines.push(prefix + styledDesc);
+            if (metaStyled) lines.push(descColPad + metaStyled);
+          } else {
+            const wrapped = wrapText(descPlain, argAvailWidth);
+            const styleFn = isDeprecated ? styler.deprecated : styler.description;
+            lines.push(prefix + styleFn(wrapped[0]!));
+            for (const wline of wrapped.slice(1)) lines.push(descColPad + styleFn(wline));
+            if (metaStyled) lines.push(descColPad + metaStyled);
+          }
+        } else {
+          // No terminal width (markdown/html): description on line 1, meta on line 2
+          const descParts: string[] = [];
+          if (styledDesc) descParts.push(styledDesc);
+          lines.push(prefix + join(descParts));
+          if (styledInlineMeta.length > 0) lines.push(indent(3) + metaStyled);
+        }
 
-        // Line 3: deprecated (with reason), examples
+        // Deprecated (with reason), examples — always on separate line
         const line3Parts: string[] = [];
         if (isDeprecated && typeof arg.deprecated === 'string') line3Parts.push(styler.meta(`(deprecated: ${arg.deprecated})`));
         if (arg.examples && arg.examples.length > 0) {
           const exampleValues = arg.examples.map((example) => (typeof example === 'string' ? example : JSON.stringify(example))).join(', ');
           line3Parts.push(styler.example('Example:'), styler.exampleValue(exampleValues));
         }
-        if (line3Parts.length > 0) lines.push(indent(3) + join(line3Parts));
+        if (line3Parts.length > 0) lines.push(contPad + join(line3Parts));
 
-        // Line 4: stdin, env, config
+        // stdin, env, config — always on separate line
         const line4Parts: string[] = [];
         if (info.usage.stdinField === arg.name) line4Parts.push(styler.meta('(stdin)'));
         if (arg.env) {
@@ -472,7 +569,7 @@ function createGenericFormatter(styler: Styler, layout: LayoutConfig, showAllBui
         if (arg.configKey) {
           line4Parts.push(styler.example('Config:'), styler.exampleValue(arg.configKey));
         }
-        if (line4Parts.length > 0) lines.push(indent(3) + join(line4Parts));
+        if (line4Parts.length > 0) lines.push(contPad + join(line4Parts));
       }
     };
 
@@ -636,11 +733,10 @@ function createJsonFormatter(): Formatter {
 // Formatter Factory
 // ============================================================================
 
-function shouldUseAnsi(): boolean {
-  if (typeof process === 'undefined') return false;
-  if (process.env.NO_COLOR) return false;
-  if (process.env.CI) return false;
-  if (process.stdout && typeof process.stdout.isTTY === 'boolean') return process.stdout.isTTY;
+function shouldUseAnsi(env?: Record<string, string | undefined>, isTTY?: boolean): boolean {
+  if (env?.NO_COLOR) return false;
+  if (env?.CI) return false;
+  if (typeof isTTY === 'boolean') return isTTY;
   return false;
 }
 
@@ -673,13 +769,17 @@ export function createFormatter(
   detail: HelpDetail = 'standard',
   theme?: ColorTheme | ColorConfig,
   all?: boolean,
+  width?: number,
+  terminal?: { columns?: number; isTTY?: boolean },
+  env?: Record<string, string | undefined>,
 ): Formatter {
   if (detail === 'minimal') return createMinimalFormatter();
   if (format === 'json') return createJsonFormatter();
-  if (format === 'ansi' || (format === 'auto' && shouldUseAnsi()))
-    return createGenericFormatter(createAnsiStyler(theme), createTextLayout(), all);
-  if (format === 'console') return createGenericFormatter(createConsoleStyler(theme), createTextLayout(), all);
+  const tw = format === 'markdown' || format === 'html' ? undefined : (width ?? terminal?.columns ?? DEFAULT_TERMINAL_WIDTH);
+  if (format === 'ansi' || (format === 'auto' && shouldUseAnsi(env, terminal?.isTTY)))
+    return createGenericFormatter(createAnsiStyler(theme), createTextLayout(), all, tw);
+  if (format === 'console') return createGenericFormatter(createConsoleStyler(theme), createTextLayout(), all, tw);
   if (format === 'markdown') return createGenericFormatter(createMarkdownStyler(), createMarkdownLayout(), all);
   if (format === 'html') return createGenericFormatter(createHtmlStyler(), createHtmlLayout(), all);
-  return createGenericFormatter(createTextStyler(), createTextLayout(), all);
+  return createGenericFormatter(createTextStyler(), createTextLayout(), all, tw);
 }

package/src/{help.ts → output/help.ts}

@@ -1,7 +1,9 @@
 import type { StandardJSONSchemaV1 } from '@standard-schema/spec';
-import { extractSchemaMetadata, JSON_SCHEMA_OPTS, type PadroneArgsSchemaMeta, parsePositionalConfig, parseStdinConfig } from './args.ts';
+import { extractSchemaMetadata, getJsonSchema, type PadroneArgsSchemaMeta, parsePositionalConfig } from '../core/args.ts';
+import { findCommandByName } from '../core/commands.ts';
+import type { AnyPadroneCommand } from '../types/index.ts';
+import { getRootCommand } from '../util/utils.ts';
 import type { ColorConfig, ColorTheme } from './colorizer.ts';
-import { findCommandByName } from './command-utils.ts';
 import {
   createFormatter,
   type HelpArgumentInfo,
@@ -11,8 +13,6 @@ import {
   type HelpPositionalInfo,
   type HelpSubcommandInfo,
 } from './formatter.ts';
-import type { AnyPadroneCommand } from './types.ts';
-import { getRootCommand } from './utils.ts';
 
 export type HelpPreferences = {
   format?: HelpFormat | 'auto';
@@ -20,6 +20,12 @@ export type HelpPreferences = {
   theme?: ColorTheme | ColorConfig;
   /** Show all global commands and flags in full detail */
   all?: boolean;
+  /** Terminal width for text wrapping. Defaults to terminal columns or 80. */
+  width?: number;
+  /** Terminal capabilities for auto-detection of ANSI and width. */
+  terminal?: { columns?: number; isTTY?: boolean };
+  /** Environment variables for auto-detection (e.g., NO_COLOR, CI). */
+  env?: Record<string, string | undefined>;
 };
 
 /**
@@ -39,7 +45,7 @@ function extractPositionalArgsInfo(
   const positionalConfig = parsePositionalConfig(meta.positional);
 
   try {
-    const jsonSchema = schema['~standard'].jsonSchema.input(JSON_SCHEMA_OPTS) as Record<string, any>;
+    const jsonSchema = getJsonSchema(schema) as Record<string, any>;
 
     if (jsonSchema.type === 'object' && jsonSchema.properties) {
       const properties = jsonSchema.properties as Record<string, any>;
@@ -79,7 +85,7 @@ function extractArgsInfo(schema: StandardJSONSchemaV1, meta?: PadroneArgsSchemaM
   const argsMeta = meta?.fields;
 
   try {
-    const jsonSchema = schema['~standard'].jsonSchema.input(JSON_SCHEMA_OPTS) as Record<string, any>;
+    const jsonSchema = getJsonSchema(schema) as Record<string, any>;
 
     // Handle object: z.object({ key: z.string(), ... })
     if (jsonSchema.type === 'object' && jsonSchema.properties) {
@@ -190,7 +196,7 @@ export function getHelpInfo(cmd: AnyPadroneCommand, detail: HelpPreferences['det
       hasSubcommands: !!(cmd.commands && cmd.commands.length > 0),
       hasPositionals,
       hasArguments: false, // updated below after extracting arguments
-      stdinField: cmd.meta?.stdin ? parseStdinConfig(cmd.meta.stdin) : undefined,
+      stdinField: cmd.meta?.stdin,
     },
   };
 
@@ -366,6 +372,14 @@ export function getHelpInfo(cmd: AnyPadroneCommand, detail: HelpPreferences['det
 
 export function generateHelp(rootCommand: AnyPadroneCommand, commandObj: AnyPadroneCommand = rootCommand, prefs?: HelpPreferences): string {
   const helpInfo = getHelpInfo(commandObj, prefs?.detail, prefs?.all);
-  const formatter = createFormatter(prefs?.format ?? 'auto', prefs?.detail, prefs?.theme, prefs?.all);
+  const formatter = createFormatter(
+    prefs?.format ?? 'auto',
+    prefs?.detail,
+    prefs?.theme,
+    prefs?.all,
+    prefs?.width,
+    prefs?.terminal,
+    prefs?.env,
+  );
   return formatter.format(helpInfo);
 }

package/src/{zod.d.ts → schema/zod.d.ts}

@@ -1,4 +1,4 @@
-import type { PadroneFieldMeta } from './args.ts';
+import type { PadroneFieldMeta } from '../core/args.ts';
 
 declare module 'zod/v4/core' {
   export interface GlobalMeta extends PadroneFieldMeta {}

package/src/schema/zod.ts

@@ -0,0 +1,50 @@
+import * as z from 'zod/v4';
+import type { PadroneSchema } from '../types/index.ts';
+import { asyncStream } from '../util/stream.ts';
+
+/**
+ * Creates a Zod schema for an async stream field, ready to use in `.arguments()`.
+ * Wraps `z.custom<AsyncIterable<T>>()` with the `asyncStream()` metadata automatically.
+ *
+ * @param itemSchema - Optional item schema for per-item validation.
+ *
+ * @example
+ * ```ts
+ * import { zodAsyncStream } from 'padrone/zod';
+ *
+ * // String lines
+ * z.object({ lines: zodAsyncStream() })
+ *
+ * // Typed items — each line JSON.parse'd and validated
+ * const recordSchema = z.object({ name: z.string(), age: z.number() });
+ * z.object({ records: zodAsyncStream(jsonCodec(recordSchema)) })
+ * ```
+ */
+export function zodAsyncStream<T = string>(itemSchema?: PadroneSchema<unknown, T>) {
+  return z.custom<AsyncIterable<T>>().meta(asyncStream(itemSchema));
+}
+
+/**
+ * JSON codec for Zod schemas
+ * @see https://zod.dev/codecs?id=jsonschema
+ * Unlike the example in the docs, this codec also handles the case where the input is already an object
+ */
+export const jsonCodec = <T extends z.ZodType>(schema: T) =>
+  z.codec(z.union([z.string(), z.unknown()]), schema, {
+    decode: (jsonString, ctx) => {
+      try {
+        // HACK: in some cases the object is already deserialized, we just need to validate it
+        if (typeof jsonString !== 'string') return jsonString as z.input<T>;
+        return JSON.parse(jsonString) as z.input<T>;
+      } catch (err: any) {
+        ctx.issues.push({
+          code: 'invalid_format',
+          format: 'json',
+          input: typeof jsonString === 'string' ? jsonString : JSON.stringify(jsonString),
+          message: err.message,
+        });
+        return z.NEVER;
+      }
+    },
+    encode: (value) => JSON.stringify(value),
+  });

package/src/test.ts

@@ -1,276 +1,2 @@
-import type { InteractivePromptConfig, PadroneRuntime } from './runtime.ts';
-import type { AnyPadroneCommand, PadroneCommandResult } from './types.ts';
-
-/**
- * Result from a single command execution in test mode.
- * Extends the standard PadroneCommandResult with captured I/O.
- */
-export type TestCliResult = {
-  /** The matched command. */
-  command: AnyPadroneCommand;
-  /** Validated arguments (undefined if validation failed). */
-  args: unknown;
-  /** Action handler return value (undefined if validation failed or no action). */
-  result: unknown;
-  /** Validation issues, if any. */
-  issues: { message: string; path?: PropertyKey[] }[] | undefined;
-  /** All values passed to `runtime.output()`. */
-  stdout: unknown[];
-  /** All strings passed to `runtime.error()`. */
-  stderr: string[];
-  /** The thrown error, if the command threw (routing error, action error, etc.). */
-  error?: unknown;
-};
-
-/**
- * Result from a REPL test session.
- */
-export type TestReplResult = {
-  /** One entry per successfully executed command (validation errors are captured in stderr, not here). */
-  results: Omit<TestCliResult, 'stdout' | 'stderr'>[];
-  /** All output from the entire REPL session. */
-  stdout: unknown[];
-  /** All errors from the entire REPL session. */
-  stderr: string[];
-};
-
-/**
- * Fluent builder for setting up CLI test scenarios.
- */
-export type TestCliBuilder = {
-  /** Set the CLI input string (e.g. `'deploy --env production'`). */
-  args(input: string): TestCliBuilder;
-  /** Set environment variables visible to the command. */
-  env(vars: Record<string, string | undefined>): TestCliBuilder;
-  /** Provide mock answers for interactive prompts. Keys are field names. */
-  prompt(answers: Record<string, unknown>): TestCliBuilder;
-  /** Provide mock config files. Keys are file paths, values are parsed config objects. */
-  config(files: Record<string, Record<string, unknown>>): TestCliBuilder;
-  /** Provide mock stdin data (simulates piped input). */
-  stdin(data: string): TestCliBuilder;
-  /**
-   * Execute a single command via `eval()` and return the result with captured I/O.
-   * @param input - Optional CLI input string. Overrides `.args()` if provided.
-   */
-  run(input?: string): Promise<TestCliResult>;
-  /**
-   * Run a REPL session with the given sequence of inputs.
-   * Each string in the array is fed as one line of input.
-   * The session ends after all inputs are consumed (EOF).
-   */
-  repl(inputs: string[]): Promise<TestReplResult>;
-};
-
-/**
- * Creates a fluent test builder for a Padrone program.
- * Captures all I/O and provides a clean interface for assertions.
- *
- * Works with any test framework (bun:test, vitest, jest, node:test, etc.).
- *
- * @example
- * ```ts
- * import { testCli } from 'padrone/test'
- *
- * const result = await testCli(myProgram)
- *   .args('deploy --env production')
- *   .env({ API_KEY: 'xxx' })
- *   .run()
- *
- * expect(result.result).toBe('Deployed')
- * expect(result.stdout).toContain('Deploying...')
- * ```
- *
- * @example
- * ```ts
- * // Shorthand: pass input directly to run()
- * const result = await testCli(myProgram).run('deploy --env production')
- * ```
- *
- * @example
- * ```ts
- * // Test interactive prompts
- * const result = await testCli(myProgram)
- *   .args('init')
- *   .prompt({ name: 'myapp', template: 'react' })
- *   .run()
- *
- * expect(result.args).toEqual({ name: 'myapp', template: 'react' })
- * ```
- *
- * @example
- * ```ts
- * // Test REPL sessions
- * const { results } = await testCli(myProgram)
- *   .repl(['greet World', 'add --a=2 --b=3'])
- *
- * expect(results[0].result).toBe('Hello, World!')
- * expect(results[1].result).toBe(5)
- * ```
- */
-/**
- * Any program-like object that has `eval`, `runtime`, and `repl` methods.
- * Avoids strict variance issues with `AnyPadroneProgram`.
- */
-type TestableProgram = {
-  eval: (input: string, prefs?: { autoOutput?: boolean }) => any;
-  runtime: (runtime: PadroneRuntime) => TestableProgram;
-  repl: (options?: { greeting?: false; hint?: false }) => AsyncIterable<any>;
-};
-
-export function testCli(program: TestableProgram): TestCliBuilder {
-  let input: string | undefined;
-  let envVars: Record<string, string | undefined> | undefined;
-  let promptAnswers: Record<string, unknown> | undefined;
-  let configFiles: Record<string, Record<string, unknown>> | undefined;
-  let stdinData: string | undefined;
-
-  const builder: TestCliBuilder = {
-    args(args: string) {
-      input = args;
-      return builder;
-    },
-    env(vars) {
-      envVars = vars;
-      return builder;
-    },
-    prompt(answers) {
-      promptAnswers = answers;
-      return builder;
-    },
-    config(files) {
-      configFiles = files;
-      return builder;
-    },
-    stdin(data: string) {
-      stdinData = data;
-      return builder;
-    },
-
-    async run(runInput?: string) {
-      const stdout: unknown[] = [];
-      const stderr: string[] = [];
-
-      const runtime = buildRuntime(stdout, stderr, { envVars, promptAnswers, configFiles, stdinData });
-      const testProgram = program.runtime(runtime);
-
-      const evalResult = await testProgram.eval(runInput ?? input ?? '', { autoOutput: false });
-      if (evalResult.error) {
-        stderr.push(evalResult.error instanceof Error ? evalResult.error.message : String(evalResult.error));
-      }
-      return toTestResult(evalResult, stdout, stderr);
-    },
-
-    async repl(inputs: string[]) {
-      const stdout: unknown[] = [];
-      const stderr: string[] = [];
-
-      const runtime = buildRuntime(stdout, stderr, {
-        envVars,
-        promptAnswers,
-        configFiles,
-        readLine: createMockReadLine(inputs),
-      });
-
-      const testProgram = program.runtime(runtime);
-      const results: Omit<TestCliResult, 'stdout' | 'stderr'>[] = [];
-
-      for await (const r of testProgram.repl({ greeting: false, hint: false })) {
-        results.push({
-          command: r.command!,
-          args: r.args,
-          result: r.result,
-          issues: r.argsResult?.issues as TestCliResult['issues'],
-        });
-      }
-
-      return { results, stdout, stderr };
-    },
-  };
-
-  return builder;
-}
-
-function toTestResult(evalResult: PadroneCommandResult, stdout: unknown[], stderr: string[]): TestCliResult {
-  return {
-    command: evalResult.command!,
-    args: evalResult.args,
-    result: evalResult.result,
-    error: evalResult.error,
-    issues: evalResult.argsResult?.issues as TestCliResult['issues'],
-    stdout,
-    stderr,
-  };
-}
-
-function buildRuntime(
-  stdout: unknown[],
-  stderr: string[],
-  opts: {
-    envVars?: Record<string, string | undefined>;
-    promptAnswers?: Record<string, unknown>;
-    configFiles?: Record<string, Record<string, unknown>>;
-    readLine?: (prompt: string) => Promise<string | null>;
-    stdinData?: string;
-  },
-): PadroneRuntime {
-  const runtime: PadroneRuntime = {
-    output: (...args: unknown[]) => stdout.push(...args),
-    error: (text: string) => stderr.push(text),
-  };
-
-  if (opts.envVars) {
-    runtime.env = () => opts.envVars!;
-  }
-
-  if (opts.promptAnswers) {
-    runtime.interactive = 'supported';
-    runtime.prompt = async (config: InteractivePromptConfig) => opts.promptAnswers![config.name];
-  }
-
-  if (opts.configFiles) {
-    runtime.loadConfigFile = (path: string) => opts.configFiles![path];
-    runtime.findFile = (names: string[]) => names.find((n) => n in opts.configFiles!);
-  }
-
-  if (opts.readLine) {
-    runtime.readLine = opts.readLine;
-  }
-
-  if (opts.stdinData !== undefined) {
-    runtime.stdin = {
-      isTTY: false,
-      async text() {
-        return opts.stdinData!;
-      },
-      async *lines() {
-        const lines = opts.stdinData!.split('\n');
-        // Remove trailing empty line from final newline (matches readline behavior)
-        if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
-        for (const line of lines) {
-          yield line;
-        }
-      },
-    };
-  } else {
-    // No stdin data: simulate a TTY (no piped input) to avoid reading from process.stdin
-    runtime.stdin = {
-      isTTY: true,
-      async text() {
-        return '';
-      },
-      async *lines() {
-        // no lines
-      },
-    };
-  }
-
-  return runtime;
-}
-
-function createMockReadLine(inputs: string[]): (prompt: string) => Promise<string | null> {
-  let index = 0;
-  return async (_prompt: string): Promise<string | null> => {
-    if (index >= inputs.length) return null;
-    return inputs[index++] ?? null;
-  };
-}
+export type { TestCliBuilder, TestCliResult, TestReplResult } from './feature/test.ts';
+export { testCli } from './feature/test.ts';