padrone 1.4.0 → 1.6.0

package/dist/test.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"test.mjs","names":[],"sources":["../src/test.ts"],"sourcesContent":["import type { InteractivePromptConfig, PadroneRuntime } from './runtime.ts';\nimport type { AnyPadroneCommand, PadroneCommandResult } from './types.ts';\n\n/**\n * Result from a single command execution in test mode.\n * Extends the standard PadroneCommandResult with captured I/O.\n */\nexport type TestCliResult = {\n  /** The matched command. */\n  command: AnyPadroneCommand;\n  /** Validated arguments (undefined if validation failed). */\n  args: unknown;\n  /** Action handler return value (undefined if validation failed or no action). */\n  result: unknown;\n  /** Validation issues, if any. */\n  issues: { message: string; path?: PropertyKey[] }[] | undefined;\n  /** All values passed to `runtime.output()`. */\n  stdout: unknown[];\n  /** All strings passed to `runtime.error()`. */\n  stderr: string[];\n  /** The thrown error, if the command threw (routing error, action error, etc.). */\n  error?: unknown;\n};\n\n/**\n * Result from a REPL test session.\n */\nexport type TestReplResult = {\n  /** One entry per successfully executed command (validation errors are captured in stderr, not here). */\n  results: Omit<TestCliResult, 'stdout' | 'stderr'>[];\n  /** All output from the entire REPL session. */\n  stdout: unknown[];\n  /** All errors from the entire REPL session. */\n  stderr: string[];\n};\n\n/**\n * Fluent builder for setting up CLI test scenarios.\n */\nexport type TestCliBuilder = {\n  /** Set the CLI input string (e.g. `'deploy --env production'`). */\n  args(input: string): TestCliBuilder;\n  /** Set environment variables visible to the command. */\n  env(vars: Record<string, string | undefined>): TestCliBuilder;\n  /** Provide mock answers for interactive prompts. Keys are field names. */\n  prompt(answers: Record<string, unknown>): TestCliBuilder;\n  /** Provide mock config files. Keys are file paths, values are parsed config objects. */\n  config(files: Record<string, Record<string, unknown>>): TestCliBuilder;\n  /** Provide mock stdin data (simulates piped input). */\n  stdin(data: string): TestCliBuilder;\n  /**\n   * Execute a single command via `eval()` and return the result with captured I/O.\n   * @param input - Optional CLI input string. Overrides `.args()` if provided.\n   */\n  run(input?: string): Promise<TestCliResult>;\n  /**\n   * Run a REPL session with the given sequence of inputs.\n   * Each string in the array is fed as one line of input.\n   * The session ends after all inputs are consumed (EOF).\n   */\n  repl(inputs: string[]): Promise<TestReplResult>;\n};\n\n/**\n * Creates a fluent test builder for a Padrone program.\n * Captures all I/O and provides a clean interface for assertions.\n *\n * Works with any test framework (bun:test, vitest, jest, node:test, etc.).\n *\n * @example\n * ```ts\n * import { testCli } from 'padrone/test'\n *\n * const result = await testCli(myProgram)\n *   .args('deploy --env production')\n *   .env({ API_KEY: 'xxx' })\n *   .run()\n *\n * expect(result.result).toBe('Deployed')\n * expect(result.stdout).toContain('Deploying...')\n * ```\n *\n * @example\n * ```ts\n * // Shorthand: pass input directly to run()\n * const result = await testCli(myProgram).run('deploy --env production')\n * ```\n *\n * @example\n * ```ts\n * // Test interactive prompts\n * const result = await testCli(myProgram)\n *   .args('init')\n *   .prompt({ name: 'myapp', template: 'react' })\n *   .run()\n *\n * expect(result.args).toEqual({ name: 'myapp', template: 'react' })\n * ```\n *\n * @example\n * ```ts\n * // Test REPL sessions\n * const { results } = await testCli(myProgram)\n *   .repl(['greet World', 'add --a=2 --b=3'])\n *\n * expect(results[0].result).toBe('Hello, World!')\n * expect(results[1].result).toBe(5)\n * ```\n */\n/**\n * Any program-like object that has `eval`, `runtime`, and `repl` methods.\n * Avoids strict variance issues with `AnyPadroneProgram`.\n */\ntype TestableProgram = {\n  eval: (input: string, prefs?: { autoOutput?: boolean }) => any;\n  runtime: (runtime: PadroneRuntime) => TestableProgram;\n  repl: (options?: { greeting?: false; hint?: false }) => AsyncIterable<any>;\n};\n\nexport function testCli(program: TestableProgram): TestCliBuilder {\n  let input: string | undefined;\n  let envVars: Record<string, string | undefined> | undefined;\n  let promptAnswers: Record<string, unknown> | undefined;\n  let configFiles: Record<string, Record<string, unknown>> | undefined;\n  let stdinData: string | undefined;\n\n  const builder: TestCliBuilder = {\n    args(args: string) {\n      input = args;\n      return builder;\n    },\n    env(vars) {\n      envVars = vars;\n      return builder;\n    },\n    prompt(answers) {\n      promptAnswers = answers;\n      return builder;\n    },\n    config(files) {\n      configFiles = files;\n      return builder;\n    },\n    stdin(data: string) {\n      stdinData = data;\n      return builder;\n    },\n\n    async run(runInput?: string) {\n      const stdout: unknown[] = [];\n      const stderr: string[] = [];\n\n      const runtime = buildRuntime(stdout, stderr, { envVars, promptAnswers, configFiles, stdinData });\n      const testProgram = program.runtime(runtime);\n\n      try {\n        const evalResult = await testProgram.eval(runInput ?? input ?? '', { autoOutput: false });\n        return toTestResult(evalResult, stdout, stderr);\n      } catch (err) {\n        stderr.push(err instanceof Error ? err.message : String(err));\n        return {\n          command: undefined as unknown as AnyPadroneCommand,\n          args: undefined,\n          result: undefined,\n          issues: undefined,\n          stdout,\n          stderr,\n          error: err,\n        };\n      }\n    },\n\n    async repl(inputs: string[]) {\n      const stdout: unknown[] = [];\n      const stderr: string[] = [];\n\n      const runtime = buildRuntime(stdout, stderr, {\n        envVars,\n        promptAnswers,\n        configFiles,\n        readLine: createMockReadLine(inputs),\n      });\n\n      const testProgram = program.runtime(runtime);\n      const results: Omit<TestCliResult, 'stdout' | 'stderr'>[] = [];\n\n      for await (const r of testProgram.repl({ greeting: false, hint: false })) {\n        results.push({\n          command: r.command,\n          args: r.args,\n          result: r.result,\n          issues: r.argsResult?.issues as TestCliResult['issues'],\n        });\n      }\n\n      return { results, stdout, stderr };\n    },\n  };\n\n  return builder;\n}\n\nfunction toTestResult(evalResult: PadroneCommandResult, stdout: unknown[], stderr: string[]): TestCliResult {\n  return {\n    command: evalResult.command,\n    args: evalResult.args,\n    result: evalResult.result,\n    issues: evalResult.argsResult?.issues as TestCliResult['issues'],\n    stdout,\n    stderr,\n  };\n}\n\nfunction buildRuntime(\n  stdout: unknown[],\n  stderr: string[],\n  opts: {\n    envVars?: Record<string, string | undefined>;\n    promptAnswers?: Record<string, unknown>;\n    configFiles?: Record<string, Record<string, unknown>>;\n    readLine?: (prompt: string) => Promise<string | null>;\n    stdinData?: string;\n  },\n): PadroneRuntime {\n  const runtime: PadroneRuntime = {\n    output: (...args: unknown[]) => stdout.push(...args),\n    error: (text: string) => stderr.push(text),\n  };\n\n  if (opts.envVars) {\n    runtime.env = () => opts.envVars!;\n  }\n\n  if (opts.promptAnswers) {\n    runtime.interactive = 'supported';\n    runtime.prompt = async (config: InteractivePromptConfig) => opts.promptAnswers![config.name];\n  }\n\n  if (opts.configFiles) {\n    runtime.loadConfigFile = (path: string) => opts.configFiles![path];\n    runtime.findFile = (names: string[]) => names.find((n) => n in opts.configFiles!);\n  }\n\n  if (opts.readLine) {\n    runtime.readLine = opts.readLine;\n  }\n\n  if (opts.stdinData !== undefined) {\n    runtime.stdin = {\n      isTTY: false,\n      async text() {\n        return opts.stdinData!;\n      },\n      async *lines() {\n        const lines = opts.stdinData!.split('\\n');\n        // Remove trailing empty line from final newline (matches readline behavior)\n        if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();\n        for (const line of lines) {\n          yield line;\n        }\n      },\n    };\n  } else {\n    // No stdin data: simulate a TTY (no piped input) to avoid reading from process.stdin\n    runtime.stdin = {\n      isTTY: true,\n      async text() {\n        return '';\n      },\n      async *lines() {\n        // no lines\n      },\n    };\n  }\n\n  return runtime;\n}\n\nfunction createMockReadLine(inputs: string[]): (prompt: string) => Promise<string | null> {\n  let index = 0;\n  return async (_prompt: string): Promise<string | null> => {\n    if (index >= inputs.length) return null;\n    return inputs[index++] ?? null;\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"test.mjs","names":[],"sources":["../src/feature/test.ts"],"sourcesContent":["import type { InteractivePromptConfig, PadroneRuntime } from '../core/runtime.ts';\nimport type { AnyPadroneCommand, PadroneCommandResult } from '../types/index.ts';\n\n/**\n * Result from a single command execution in test mode.\n * Extends the standard PadroneCommandResult with captured I/O.\n */\nexport type TestCliResult = {\n  /** The matched command. */\n  command: AnyPadroneCommand;\n  /** Validated arguments (undefined if validation failed). */\n  args: unknown;\n  /** Action handler return value (undefined if validation failed or no action). */\n  result: unknown;\n  /** Validation issues, if any. */\n  issues: { message: string; path?: PropertyKey[] }[] | undefined;\n  /** All values passed to `runtime.output()`. */\n  stdout: unknown[];\n  /** All strings passed to `runtime.error()`. */\n  stderr: string[];\n  /** The thrown error, if the command threw (routing error, action error, etc.). */\n  error?: unknown;\n};\n\n/**\n * Result from a REPL test session.\n */\nexport type TestReplResult = {\n  /** One entry per successfully executed command (validation errors are captured in stderr, not here). */\n  results: Omit<TestCliResult, 'stdout' | 'stderr'>[];\n  /** All output from the entire REPL session. */\n  stdout: unknown[];\n  /** All errors from the entire REPL session. */\n  stderr: string[];\n};\n\n/**\n * Fluent builder for setting up CLI test scenarios.\n */\nexport type TestCliBuilder = {\n  /** Set the CLI input string (e.g. `'deploy --env production'`). */\n  args(input: string): TestCliBuilder;\n  /** Set environment variables visible to the command. */\n  env(vars: Record<string, string | undefined>): TestCliBuilder;\n  /** Provide mock answers for interactive prompts. Keys are field names. */\n  prompt(answers: Record<string, unknown>): TestCliBuilder;\n  /** Provide mock stdin data (simulates piped input). */\n  stdin(data: string): TestCliBuilder;\n  /**\n   * Execute a single command via `eval()` and return the result with captured I/O.\n   * @param input - Optional CLI input string. Overrides `.args()` if provided.\n   */\n  run(input?: string): Promise<TestCliResult>;\n  /**\n   * Run a REPL session with the given sequence of inputs.\n   * Each string in the array is fed as one line of input.\n   * The session ends after all inputs are consumed (EOF).\n   */\n  repl(inputs: string[]): Promise<TestReplResult>;\n};\n\n/**\n * Creates a fluent test builder for a Padrone program.\n * Captures all I/O and provides a clean interface for assertions.\n *\n * Works with any test framework (bun:test, vitest, jest, node:test, etc.).\n *\n * @example\n * ```ts\n * import { testCli } from 'padrone/test'\n *\n * const result = await testCli(myProgram)\n *   .args('deploy --env production')\n *   .env({ API_KEY: 'xxx' })\n *   .run()\n *\n * expect(result.result).toBe('Deployed')\n * expect(result.stdout).toContain('Deploying...')\n * ```\n *\n * @example\n * ```ts\n * // Shorthand: pass input directly to run()\n * const result = await testCli(myProgram).run('deploy --env production')\n * ```\n *\n * @example\n * ```ts\n * // Test interactive prompts\n * const result = await testCli(myProgram)\n *   .args('init')\n *   .prompt({ name: 'myapp', template: 'react' })\n *   .run()\n *\n * expect(result.args).toEqual({ name: 'myapp', template: 'react' })\n * ```\n *\n * @example\n * ```ts\n * // Test REPL sessions\n * const { results } = await testCli(myProgram)\n *   .repl(['greet World', 'add --a=2 --b=3'])\n *\n * expect(results[0].result).toBe('Hello, World!')\n * expect(results[1].result).toBe(5)\n * ```\n */\n/**\n * Any program-like object that has `eval`, `runtime`, and `repl` methods.\n * Avoids strict variance issues with `AnyPadroneProgram`.\n */\ntype TestableProgram = {\n  eval: (input: string, prefs?: Record<string, unknown>) => any;\n  runtime: (runtime: PadroneRuntime) => TestableProgram;\n  repl: (options?: { greeting?: false; hint?: false }) => AsyncIterable<any>;\n};\n\nexport function testCli(program: TestableProgram): TestCliBuilder {\n  let input: string | undefined;\n  let envVars: Record<string, string | undefined> | undefined;\n  let promptAnswers: Record<string, unknown> | undefined;\n  let stdinData: string | undefined;\n\n  const builder: TestCliBuilder = {\n    args(args: string) {\n      input = args;\n      return builder;\n    },\n    env(vars) {\n      envVars = vars;\n      return builder;\n    },\n    prompt(answers) {\n      promptAnswers = answers;\n      return builder;\n    },\n    stdin(data: string) {\n      stdinData = data;\n      return builder;\n    },\n\n    async run(runInput?: string) {\n      const stdout: unknown[] = [];\n      const stderr: string[] = [];\n\n      const runtime = buildRuntime(stdout, stderr, { envVars, promptAnswers, stdinData });\n      const testProgram = program.runtime(runtime);\n\n      const evalResult = await testProgram.eval(runInput ?? input ?? '', {});\n      if (evalResult.error) {\n        stderr.push(evalResult.error instanceof Error ? evalResult.error.message : String(evalResult.error));\n      }\n      return toTestResult(evalResult, stdout, stderr);\n    },\n\n    async repl(inputs: string[]) {\n      const stdout: unknown[] = [];\n      const stderr: string[] = [];\n\n      const runtime = buildRuntime(stdout, stderr, {\n        envVars,\n        promptAnswers,\n        readLine: createMockReadLine(inputs),\n      });\n\n      const testProgram = program.runtime(runtime);\n      const results: Omit<TestCliResult, 'stdout' | 'stderr'>[] = [];\n\n      for await (const r of testProgram.repl({ greeting: false, hint: false })) {\n        results.push({\n          command: r.command!,\n          args: r.args,\n          result: r.result,\n          issues: r.argsResult?.issues as TestCliResult['issues'],\n        });\n      }\n\n      return { results, stdout, stderr };\n    },\n  };\n\n  return builder;\n}\n\nfunction toTestResult(evalResult: PadroneCommandResult, stdout: unknown[], stderr: string[]): TestCliResult {\n  return {\n    command: evalResult.command!,\n    args: evalResult.args,\n    result: evalResult.result,\n    error: evalResult.error,\n    issues: evalResult.argsResult?.issues as TestCliResult['issues'],\n    stdout,\n    stderr,\n  };\n}\n\nfunction buildRuntime(\n  stdout: unknown[],\n  stderr: string[],\n  opts: {\n    envVars?: Record<string, string | undefined>;\n    promptAnswers?: Record<string, unknown>;\n    readLine?: (prompt: string) => Promise<string | null>;\n    stdinData?: string;\n  },\n): PadroneRuntime {\n  const runtime: PadroneRuntime = {\n    output: (...args: unknown[]) => stdout.push(...args),\n    error: (text: string) => stderr.push(text),\n  };\n\n  if (opts.envVars) {\n    runtime.env = () => opts.envVars!;\n  }\n\n  if (opts.promptAnswers) {\n    runtime.interactive = 'supported';\n    runtime.prompt = async (config: InteractivePromptConfig) => opts.promptAnswers![config.name];\n  }\n\n  if (opts.readLine) {\n    runtime.readLine = opts.readLine;\n  }\n\n  if (opts.stdinData !== undefined) {\n    runtime.stdin = {\n      isTTY: false,\n      async text() {\n        return opts.stdinData!;\n      },\n      async *lines() {\n        const lines = opts.stdinData!.split('\\n');\n        // Remove trailing empty line from final newline (matches readline behavior)\n        if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();\n        for (const line of lines) {\n          yield line;\n        }\n      },\n    };\n  } else {\n    // No stdin data: simulate a TTY (no piped input) to avoid reading from process.stdin\n    runtime.stdin = {\n      isTTY: true,\n      async text() {\n        return '';\n      },\n      async *lines() {\n        // no lines\n      },\n    };\n  }\n\n  return runtime;\n}\n\nfunction createMockReadLine(inputs: string[]): (prompt: string) => Promise<string | null> {\n  let index = 0;\n  return async (_prompt: string): Promise<string | null> => {\n    if (index >= inputs.length) return null;\n    return inputs[index++] ?? null;\n  };\n}\n"],"mappings":";AAqHA,SAAgB,QAAQ,SAA0C;CAChE,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,MAAM,UAA0B;EAC9B,KAAK,MAAc;AACjB,WAAQ;AACR,UAAO;;EAET,IAAI,MAAM;AACR,aAAU;AACV,UAAO;;EAET,OAAO,SAAS;AACd,mBAAgB;AAChB,UAAO;;EAET,MAAM,MAAc;AAClB,eAAY;AACZ,UAAO;;EAGT,MAAM,IAAI,UAAmB;GAC3B,MAAM,SAAoB,EAAE;GAC5B,MAAM,SAAmB,EAAE;GAE3B,MAAM,UAAU,aAAa,QAAQ,QAAQ;IAAE;IAAS;IAAe;IAAW,CAAC;GAGnF,MAAM,aAAa,MAFC,QAAQ,QAAQ,QAAQ,CAEP,KAAK,YAAY,SAAS,IAAI,EAAE,CAAC;AACtE,OAAI,WAAW,MACb,QAAO,KAAK,WAAW,iBAAiB,QAAQ,WAAW,MAAM,UAAU,OAAO,WAAW,MAAM,CAAC;AAEtG,UAAO,aAAa,YAAY,QAAQ,OAAO;;EAGjD,MAAM,KAAK,QAAkB;GAC3B,MAAM,SAAoB,EAAE;GAC5B,MAAM,SAAmB,EAAE;GAE3B,MAAM,UAAU,aAAa,QAAQ,QAAQ;IAC3C;IACA;IACA,UAAU,mBAAmB,OAAO;IACrC,CAAC;GAEF,MAAM,cAAc,QAAQ,QAAQ,QAAQ;GAC5C,MAAM,UAAsD,EAAE;AAE9D,cAAW,MAAM,KAAK,YAAY,KAAK;IAAE,UAAU;IAAO,MAAM;IAAO,CAAC,CACtE,SAAQ,KAAK;IACX,SAAS,EAAE;IACX,MAAM,EAAE;IACR,QAAQ,EAAE;IACV,QAAQ,EAAE,YAAY;IACvB,CAAC;AAGJ,UAAO;IAAE;IAAS;IAAQ;IAAQ;;EAErC;AAED,QAAO;;AAGT,SAAS,aAAa,YAAkC,QAAmB,QAAiC;AAC1G,QAAO;EACL,SAAS,WAAW;EACpB,MAAM,WAAW;EACjB,QAAQ,WAAW;EACnB,OAAO,WAAW;EAClB,QAAQ,WAAW,YAAY;EAC/B;EACA;EACD;;AAGH,SAAS,aACP,QACA,QACA,MAMgB;CAChB,MAAM,UAA0B;EAC9B,SAAS,GAAG,SAAoB,OAAO,KAAK,GAAG,KAAK;EACpD,QAAQ,SAAiB,OAAO,KAAK,KAAK;EAC3C;AAED,KAAI,KAAK,QACP,SAAQ,YAAY,KAAK;AAG3B,KAAI,KAAK,eAAe;AACtB,UAAQ,cAAc;AACtB,UAAQ,SAAS,OAAO,WAAoC,KAAK,cAAe,OAAO;;AAGzF,KAAI,KAAK,SACP,SAAQ,WAAW,KAAK;AAG1B,KAAI,KAAK,cAAc,KAAA,EACrB,SAAQ,QAAQ;EACd,OAAO;EACP,MAAM,OAAO;AACX,UAAO,KAAK;;EAEd,OAAO,QAAQ;GACb,MAAM,QAAQ,KAAK,UAAW,MAAM,KAAK;AAEzC,OAAI,MAAM,SAAS,KAAK,MAAM,MAAM,SAAS,OAAO,GAAI,OAAM,KAAK;AACnE,QAAK,MAAM,QAAQ,MACjB,OAAM;;EAGX;KAGD,SAAQ,QAAQ;EACd,OAAO;EACP,MAAM,OAAO;AACX,UAAO;;EAET,OAAO,QAAQ;EAGhB;AAGH,QAAO;;AAGT,SAAS,mBAAmB,QAA8D;CACxF,IAAI,QAAQ;AACZ,QAAO,OAAO,YAA4C;AACxD,MAAI,SAAS,OAAO,OAAQ,QAAO;AACnC,SAAO,OAAO,YAAY"}

package/dist/{update-check-EbNDkzyV.mjs → update-check-CZ2VqjnV.mjs}

@@ -1,5 +1,4 @@
-import { t as __require } from "./chunk-y_GBKt04.mjs";
-//#region src/update-check.ts
+//#region src/feature/update-check.ts
 /**
 * Parses an interval string like '1d', '12h', '30m', '1w' into milliseconds.
 */
@@ -43,9 +42,9 @@ function isNewerVersion(current, latest) {
 /**
 * Reads the update check cache file.
 */
-function readCache(cachePath) {
+async function readCache(cachePath) {
 	try {
-		const { existsSync, readFileSync } = __require("node:fs");
+		const { existsSync, readFileSync } = await import("node:fs");
 		if (!existsSync(cachePath)) return void 0;
 		const data = JSON.parse(readFileSync(cachePath, "utf-8"));
 		if (typeof data.lastCheck === "number" && typeof data.latestVersion === "string") return data;
@@ -54,10 +53,10 @@ function readCache(cachePath) {
 /**
 * Writes the update check cache file.
 */
-function writeCache(cachePath, data) {
+async function writeCache(cachePath, data) {
 	try {
-		const { existsSync, mkdirSync, writeFileSync } = __require("node:fs");
-		const { dirname } = __require("node:path");
+		const { existsSync, mkdirSync, writeFileSync } = await import("node:fs");
+		const { dirname } = await import("node:path");
 		const dir = dirname(cachePath);
 		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 		writeFileSync(cachePath, JSON.stringify(data), "utf-8");
@@ -66,9 +65,9 @@ function writeCache(cachePath, data) {
 /**
 * Resolves the cache path, expanding `~` to the home directory.
 */
-function resolveCachePath(cachePath) {
-	const { homedir } = __require("node:os");
-	const { resolve } = __require("node:path");
+async function resolveCachePath(cachePath) {
+	const { homedir } = await import("node:os");
+	const { resolve } = await import("node:path");
 	if (cachePath.startsWith("~")) return cachePath.replace("~", homedir());
 	return resolve(cachePath);
 }
@@ -99,27 +98,27 @@ function formatUpdateMessage(currentVersion, latestVersion, packageName) {
 * This is designed to be non-blocking: the check starts immediately but the
 * result is only consumed after command execution completes.
 */
-function createUpdateChecker(programName, currentVersion, config, runtime) {
+async function createUpdateChecker(programName, currentVersion, config, runtime) {
 	const packageName = config.packageName ?? programName;
 	const registry = config.registry ?? "npm";
 	const intervalMs = parseInterval(config.interval ?? "1d");
 	const disableEnvVar = config.disableEnvVar ?? `${programName.toUpperCase().replace(/-/g, "_")}_NO_UPDATE_CHECK`;
 	const defaultCachePath = `~/.config/${programName}-update-check.json`;
-	const cachePath = resolveCachePath(config.cache ?? defaultCachePath);
+	const cachePath = await resolveCachePath(config.cache ?? defaultCachePath);
 	const env = runtime.env();
 	if (env.CI || env.CONTINUOUS_INTEGRATION) return noop;
 	if (env[disableEnvVar]) return noop;
-	if (typeof process !== "undefined" && !process.stdout?.isTTY) return noop;
-	const cached = readCache(cachePath);
+	if (runtime.terminal && !runtime.terminal.isTTY) return noop;
+	const cached = await readCache(cachePath);
 	if (cached && Date.now() - cached.lastCheck < intervalMs) {
 		if (isNewerVersion(currentVersion, cached.latestVersion)) return () => {
 			runtime.error(formatUpdateMessage(currentVersion, cached.latestVersion, packageName));
 		};
 		return noop;
 	}
-	const fetchPromise = fetchLatestVersion(packageName, registry).then((latestVersion) => {
+	const fetchPromise = fetchLatestVersion(packageName, registry).then(async (latestVersion) => {
 		if (latestVersion) {
-			writeCache(cachePath, {
+			await writeCache(cachePath, {
 				lastCheck: Date.now(),
 				latestVersion
 			});
@@ -143,4 +142,4 @@ function noop() {}
 //#endregion
 export { createUpdateChecker };
 
-//# sourceMappingURL=update-check-EbNDkzyV.mjs.map
+//# sourceMappingURL=update-check-CZ2VqjnV.mjs.map

package/dist/update-check-CZ2VqjnV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-check-CZ2VqjnV.mjs","names":[],"sources":["../src/feature/update-check.ts"],"sourcesContent":["import type { ResolvedPadroneRuntime } from '../core/runtime.ts';\n\n/**\n * Configuration for the update check feature.\n */\nexport type UpdateCheckConfig = {\n  /**\n   * The npm package name to check. Defaults to the program name.\n   */\n  packageName?: string;\n  /**\n   * Registry to check for updates.\n   * - `'npm'` — checks the npm registry (default)\n   * - A URL string — custom registry endpoint that returns JSON with a `version` or `dist-tags.latest` field\n   */\n  registry?: 'npm' | string;\n  /**\n   * How often to check for updates. Accepts shorthand like `'1d'`, `'12h'`, `'30m'`.\n   * Defaults to `'1d'` (once per day).\n   */\n  interval?: string;\n  /**\n   * Path to the cache file for storing the last check timestamp and latest version.\n   * Defaults to `~/.config/<programName>-update-check.json`.\n   */\n  cache?: string;\n  /**\n   * Environment variable name to disable update checks (e.g. `'MYAPP_NO_UPDATE_CHECK'`).\n   * When set to a truthy value, update checks are skipped.\n   * Defaults to `'<PROGRAM_NAME>_NO_UPDATE_CHECK'` (uppercased, hyphens to underscores).\n   */\n  disableEnvVar?: string;\n};\n\ntype CacheData = {\n  lastCheck: number;\n  latestVersion: string;\n};\n\n/**\n * Parses an interval string like '1d', '12h', '30m', '1w' into milliseconds.\n */\nexport function parseInterval(interval: string): number {\n  const match = interval.match(/^(\\d+)\\s*(ms|s|m|h|d|w)$/);\n  if (!match) return 86_400_000; // default 1d\n\n  const value = parseInt(match[1]!, 10);\n  const unit = match[2]!;\n\n  switch (unit) {\n    case 'ms':\n      return value;\n    case 's':\n      return value * 1000;\n    case 'm':\n      return value * 60_000;\n    case 'h':\n      return value * 3_600_000;\n    case 'd':\n      return value * 86_400_000;\n    case 'w':\n      return value * 604_800_000;\n    default:\n      return 86_400_000;\n  }\n}\n\n/**\n * Compares two semver version strings.\n * Returns true if `latest` is newer than `current`.\n */\nexport function isNewerVersion(current: string, latest: string): boolean {\n  const parse = (v: string) => {\n    const cleaned = v.replace(/^v/, '');\n    const parts = cleaned.split('-');\n    const nums = parts[0]!.split('.').map(Number);\n    return { major: nums[0] ?? 0, minor: nums[1] ?? 0, patch: nums[2] ?? 0, prerelease: parts[1] };\n  };\n\n  const c = parse(current);\n  const l = parse(latest);\n\n  // Don't notify about pre-release versions unless user is already on a pre-release\n  if (l.prerelease && !c.prerelease) return false;\n\n  if (l.major !== c.major) return l.major > c.major;\n  if (l.minor !== c.minor) return l.minor > c.minor;\n  if (l.patch !== c.patch) return l.patch > c.patch;\n  return false;\n}\n\n/**\n * Reads the update check cache file.\n */\nasync function readCache(cachePath: string): Promise<CacheData | undefined> {\n  try {\n    const { existsSync, readFileSync } = await import('node:fs');\n    if (!existsSync(cachePath)) return undefined;\n    const data = JSON.parse(readFileSync(cachePath, 'utf-8'));\n    if (typeof data.lastCheck === 'number' && typeof data.latestVersion === 'string') {\n      return data as CacheData;\n    }\n  } catch {\n    // Ignore errors\n  }\n  return undefined;\n}\n\n/**\n * Writes the update check cache file.\n */\nasync function writeCache(cachePath: string, data: CacheData): Promise<void> {\n  try {\n    const { existsSync, mkdirSync, writeFileSync } = await import('node:fs');\n    const { dirname } = await import('node:path');\n    const dir = dirname(cachePath);\n    if (!existsSync(dir)) {\n      mkdirSync(dir, { recursive: true });\n    }\n    writeFileSync(cachePath, JSON.stringify(data), 'utf-8');\n  } catch {\n    // Ignore errors — cache is best-effort\n  }\n}\n\n/**\n * Resolves the cache path, expanding `~` to the home directory.\n */\nasync function resolveCachePath(cachePath: string): Promise<string> {\n  const { homedir } = await import('node:os');\n  const { resolve } = await import('node:path');\n  if (cachePath.startsWith('~')) {\n    return cachePath.replace('~', homedir());\n  }\n  return resolve(cachePath);\n}\n\n/**\n * Fetches the latest version from the registry.\n */\nasync function fetchLatestVersion(packageName: string, registry: string): Promise<string | undefined> {\n  const url = registry === 'npm' ? `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest` : registry;\n\n  try {\n    const response = await fetch(url);\n    if (!response.ok) return undefined;\n    const data = (await response.json()) as Record<string, unknown>;\n\n    // npm registry returns { version: \"x.y.z\" }\n    if (typeof data.version === 'string') return data.version;\n\n    // Custom endpoint may return { \"dist-tags\": { latest: \"x.y.z\" } }\n    const distTags = data['dist-tags'] as Record<string, string> | undefined;\n    if (distTags?.latest) return distTags.latest;\n  } catch {\n    // Network errors are expected (offline, firewall, etc.)\n  }\n  return undefined;\n}\n\n/**\n * Formats the update notification message.\n */\nexport function formatUpdateMessage(currentVersion: string, latestVersion: string, packageName: string): string {\n  const updateCommand = `npm update -g ${packageName}`;\n  return `\\n  Update available: ${currentVersion} \\u2192 ${latestVersion}\\n  Run \"${updateCommand}\" to update\\n`;\n}\n\n/**\n * Checks for updates in the background. Returns a function that, when called,\n * prints the update notification if a newer version was found.\n *\n * This is designed to be non-blocking: the check starts immediately but the\n * result is only consumed after command execution completes.\n */\nexport async function createUpdateChecker(\n  programName: string,\n  currentVersion: string,\n  config: UpdateCheckConfig,\n  runtime: ResolvedPadroneRuntime,\n): Promise<() => void> {\n  const packageName = config.packageName ?? programName;\n  const registry = config.registry ?? 'npm';\n  const intervalMs = parseInterval(config.interval ?? '1d');\n  const disableEnvVar = config.disableEnvVar ?? `${programName.toUpperCase().replace(/-/g, '_')}_NO_UPDATE_CHECK`;\n\n  const defaultCachePath = `~/.config/${programName}-update-check.json`;\n  const cachePath = await resolveCachePath(config.cache ?? defaultCachePath);\n\n  // Check if disabled\n  const env = runtime.env();\n  if (env.CI || env.CONTINUOUS_INTEGRATION) return noop;\n  if (env[disableEnvVar]) return noop;\n  if (runtime.terminal && !runtime.terminal.isTTY) return noop;\n\n  // Check cache — if we checked recently, use cached result\n  const cached = await readCache(cachePath);\n  if (cached && Date.now() - cached.lastCheck < intervalMs) {\n    // Use cached version for display\n    if (isNewerVersion(currentVersion, cached.latestVersion)) {\n      return () => {\n        runtime.error(formatUpdateMessage(currentVersion, cached.latestVersion, packageName));\n      };\n    }\n    return noop;\n  }\n\n  // Start background fetch\n  const fetchPromise = fetchLatestVersion(packageName, registry).then(async (latestVersion) => {\n    if (latestVersion) {\n      await writeCache(cachePath, { lastCheck: Date.now(), latestVersion });\n      if (isNewerVersion(currentVersion, latestVersion)) {\n        return latestVersion;\n      }\n    }\n    return undefined;\n  });\n\n  // Return a function that blocks on the result (briefly — the fetch should be done by now)\n  let resolved: string | undefined | null = null; // null = not yet resolved\n  fetchPromise.then(\n    (v) => {\n      resolved = v;\n    },\n    () => {\n      resolved = undefined;\n    },\n  );\n\n  return () => {\n    // If the fetch already resolved, use the result synchronously\n    if (resolved !== null) {\n      if (resolved) {\n        runtime.error(formatUpdateMessage(currentVersion, resolved, packageName));\n      }\n      return;\n    }\n\n    // Otherwise, we can't block — just skip this time.\n    // The cache will be written when the promise resolves, so next invocation will show the message.\n  };\n}\n\nfunction noop() {}\n"],"mappings":"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"}

package/dist/zod.d.mts

@@ -0,0 +1,32 @@
+import { H as PadroneSchema } from "./index-BaU3X6dY.mjs";
+import * as z from "zod/v4";
+
+//#region src/schema/zod.d.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)) })
+ * ```
+ */
+declare function zodAsyncStream<T = string>(itemSchema?: PadroneSchema<unknown, T>): z.ZodCustom<AsyncIterable<T>, AsyncIterable<T>>;
+/**
+ * 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
+ */
+declare const jsonCodec: <T extends z.ZodType>(schema: T) => z.ZodCodec<z.ZodUnion<readonly [z.ZodString, z.ZodUnknown]>, T>;
+//#endregion
+export { jsonCodec, zodAsyncStream };
+//# sourceMappingURL=zod.d.mts.map

package/dist/zod.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.mts","names":[],"sources":["../src/schema/zod.ts"],"mappings":";;;;;;AAsBA;;;;;;;;;;;;;;;;iBAAgB,cAAA,YAAA,CAA2B,UAAA,GAAa,aAAA,UAAuB,CAAA,IAAE,CAAA,CAAA,SAAA,CAAA,aAAA,CAAA,CAAA,GAAA,aAAA,CAAA,CAAA;;;;;;cASpE,SAAA,aAAuB,CAAA,CAAE,OAAA,EAAS,MAAA,EAAQ,CAAA,KAAC,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,QAAA,WAAA,CAAA,CAAA,SAAA,EAAA,CAAA,CAAA,UAAA,IAAA,CAAA"}

package/dist/zod.mjs

@@ -0,0 +1,50 @@
+import { t as asyncStream } from "./stream-DC4H8YTx.mjs";
+import * as z from "zod/v4";
+//#region src/schema/zod.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)) })
+* ```
+*/
+function zodAsyncStream(itemSchema) {
+	return z.custom().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
+*/
+const jsonCodec = (schema) => z.codec(z.union([z.string(), z.unknown()]), schema, {
+	decode: (jsonString, ctx) => {
+		try {
+			if (typeof jsonString !== "string") return jsonString;
+			return JSON.parse(jsonString);
+		} catch (err) {
+			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)
+});
+//#endregion
+export { jsonCodec, zodAsyncStream };
+
+//# sourceMappingURL=zod.mjs.map

package/dist/zod.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.mjs","names":[],"sources":["../src/schema/zod.ts"],"sourcesContent":["import * as z from 'zod/v4';\nimport type { PadroneSchema } from '../types/index.ts';\nimport { asyncStream } from '../util/stream.ts';\n\n/**\n * Creates a Zod schema for an async stream field, ready to use in `.arguments()`.\n * Wraps `z.custom<AsyncIterable<T>>()` with the `asyncStream()` metadata automatically.\n *\n * @param itemSchema - Optional item schema for per-item validation.\n *\n * @example\n * ```ts\n * import { zodAsyncStream } from 'padrone/zod';\n *\n * // String lines\n * z.object({ lines: zodAsyncStream() })\n *\n * // Typed items — each line JSON.parse'd and validated\n * const recordSchema = z.object({ name: z.string(), age: z.number() });\n * z.object({ records: zodAsyncStream(jsonCodec(recordSchema)) })\n * ```\n */\nexport function zodAsyncStream<T = string>(itemSchema?: PadroneSchema<unknown, T>) {\n  return z.custom<AsyncIterable<T>>().meta(asyncStream(itemSchema));\n}\n\n/**\n * JSON codec for Zod schemas\n * @see https://zod.dev/codecs?id=jsonschema\n * Unlike the example in the docs, this codec also handles the case where the input is already an object\n */\nexport const jsonCodec = <T extends z.ZodType>(schema: T) =>\n  z.codec(z.union([z.string(), z.unknown()]), schema, {\n    decode: (jsonString, ctx) => {\n      try {\n        // HACK: in some cases the object is already deserialized, we just need to validate it\n        if (typeof jsonString !== 'string') return jsonString as z.input<T>;\n        return JSON.parse(jsonString) as z.input<T>;\n      } catch (err: any) {\n        ctx.issues.push({\n          code: 'invalid_format',\n          format: 'json',\n          input: typeof jsonString === 'string' ? jsonString : JSON.stringify(jsonString),\n          message: err.message,\n        });\n        return z.NEVER;\n      }\n    },\n    encode: (value) => JSON.stringify(value),\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,eAA2B,YAAwC;AACjF,QAAO,EAAE,QAA0B,CAAC,KAAK,YAAY,WAAW,CAAC;;;;;;;AAQnE,MAAa,aAAkC,WAC7C,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,EAAE,QAAQ;CAClD,SAAS,YAAY,QAAQ;AAC3B,MAAI;AAEF,OAAI,OAAO,eAAe,SAAU,QAAO;AAC3C,UAAO,KAAK,MAAM,WAAW;WACtB,KAAU;AACjB,OAAI,OAAO,KAAK;IACd,MAAM;IACN,QAAQ;IACR,OAAO,OAAO,eAAe,WAAW,aAAa,KAAK,UAAU,WAAW;IAC/E,SAAS,IAAI;IACd,CAAC;AACF,UAAO,EAAE;;;CAGb,SAAS,UAAU,KAAK,UAAU,MAAM;CACzC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "padrone",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Create type-safe, interactive CLI apps with Zod schemas",
   "license": "MIT",
   "type": "module",
@@ -81,18 +81,18 @@
       },
       "source": "./src/docs/index.ts"
     },
-    "./completion": {
-      "padrone@dev": "./src/completion.ts",
+    "./zod": {
+      "padrone@dev": "./src/zod.ts",
       "import": {
-        "types": "./dist/completion.d.mts",
-        "default": "./dist/completion.mjs"
+        "types": "./dist/zod.d.mts",
+        "default": "./dist/zod.mjs"
       },
-      "source": "./src/completion.ts"
+      "source": "./src/zod.ts"
     },
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "tsdown src/index.ts src/test.ts src/codegen/index.ts src/docs/index.ts src/completion.ts --dts --sourcemap",
+    "build": "tsdown src/index.ts src/test.ts src/zod.ts src/codegen/index.ts src/docs/index.ts --dts --sourcemap",
     "start": "bun --conditions=padrone@dev src/cli/index.ts",
     "dev": "bun --conditions=padrone@dev --watch src/cli/index.ts",
     "test": "bun test --conditions=padrone@dev",
@@ -105,18 +105,29 @@
     "enquirer": "^2.4.1"
   },
   "devDependencies": {
-    "ai": "^6.0.116",
-    "tsdown": "^0.21.4",
+    "@types/react": "^19.2.14",
+    "ai": "^6.0.141",
+    "ink": "^6.8.0",
+    "react": "^19.2.4",
+    "tsdown": "^0.21.6",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
     "ai": "5 || 6",
+    "ink": "^6.0.0",
+    "react": ">=18.0.0",
     "zod": "^3.25.0 || ^4.0.0"
   },
   "peerDependenciesMeta": {
     "ai": {
       "optional": true
     },
+    "ink": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
     "zod": {
       "optional": true
     }

package/src/cli/completions.ts

@@ -1,16 +1,19 @@
-import { basename } from 'node:path';
-import { detectShell, getCompletionInstallInstructions, type ShellType, setupCompletions } from '../completion.ts';
-import type { PadroneActionContext } from '../types.ts';
+import * as z from 'zod/v4';
+import { detectShell, getCompletionInstallInstructions, setupCompletions } from '../feature/completion.ts';
+import type { PadroneActionContext } from '../types/index.ts';
 
-interface CompletionsArgs {
-  appPath?: string;
-  for?: ShellType;
-  setup?: boolean;
-}
+export const completionsSchema = z.object({
+  appPath: z.string().optional().describe('Path or name of the CLI program (defaults to padrone)'),
+  for: z.enum(['bash', 'zsh', 'fish', 'powershell']).optional().describe('Target shell (auto-detected if omitted)'),
+  setup: z.boolean().optional().default(false).describe('Write completions to shell config file'),
+});
+
+type CompletionsArgs = z.infer<typeof completionsSchema>;
 
-export function runCompletions(args: CompletionsArgs, _ctx: PadroneActionContext) {
+export async function runCompletions(args: CompletionsArgs, _ctx: PadroneActionContext) {
+  const { basename } = await import('node:path');
   const programName = args.appPath ? basename(args.appPath).replace(/\.[cm]?[jt]sx?$/, '') : 'padrone';
-  const shell = args.for ?? detectShell();
+  const shell = args.for ?? (await detectShell());
 
   if (!shell) {
     console.error('Could not detect shell. Use --for to specify one: bash, zsh, fish, powershell');
@@ -18,7 +21,7 @@ export function runCompletions(args: CompletionsArgs, _ctx: PadroneActionContext
   }
 
   if (args.setup) {
-    const result = setupCompletions(programName, shell);
+    const result = await setupCompletions(programName, shell);
     const verb = result.updated ? 'Updated' : 'Added';
     console.log(`${verb} ${programName} completions in ${result.file}`);
     return;

package/src/cli/docs.ts

@@ -1,15 +1,18 @@
 import { resolve } from 'node:path';
-import { commandSymbol } from '../command-utils.ts';
-import { type DocsFormat, generateDocs } from '../docs/index.ts';
-import type { PadroneActionContext } from '../types.ts';
+import * as z from 'zod/v4';
+import { isPadroneProgram } from '../core/commands.ts';
+import { generateDocs } from '../docs/index.ts';
+import type { PadroneActionContext } from '../types/index.ts';
 
-interface DocsArgs {
-  entry: string;
-  output?: string;
-  format?: DocsFormat;
-  includeHidden?: boolean;
-  dryRun?: boolean;
-}
+export const docsSchema = z.object({
+  entry: z.string().describe('Entry file that exports a Padrone program'),
+  output: z.string().optional().default('./docs/cli').describe('Output directory'),
+  format: z.enum(['markdown', 'html', 'man', 'json']).optional().default('markdown').describe('Output format'),
+  includeHidden: z.boolean().optional().default(false).describe('Include hidden commands and options'),
+  dryRun: z.boolean().optional().default(false).describe('Print what would be generated without writing'),
+});
+
+type DocsArgs = z.infer<typeof docsSchema>;
 
 export async function runDocs(args: DocsArgs, _ctx: PadroneActionContext) {
   const entryPath = resolve(args.entry);
@@ -78,9 +81,3 @@ function findProgram(mod: Record<string, unknown>): any {
 
   return null;
 }
-
-function isPadroneProgram(value: unknown): boolean {
-  if (!value || typeof value !== 'object') return false;
-  // A PadroneProgram has the internal command symbol (set by createPadrone)
-  return commandSymbol in value;
-}