padrone 1.4.0 → 1.6.0

package/src/{update-check.ts → feature/update-check.ts}

@@ -1,4 +1,4 @@
-import type { ResolvedPadroneRuntime } from './runtime.ts';
+import type { ResolvedPadroneRuntime } from '../core/runtime.ts';
 
 /**
  * Configuration for the update check feature.
@@ -92,9 +92,9 @@ export function isNewerVersion(current: string, latest: string): boolean {
 /**
  * Reads the update check cache file.
  */
-function readCache(cachePath: string): CacheData | undefined {
+async function readCache(cachePath: string): Promise<CacheData | undefined> {
   try {
-    const { existsSync, readFileSync } = require('node:fs') as typeof import('node:fs');
+    const { existsSync, readFileSync } = await import('node:fs');
     if (!existsSync(cachePath)) return undefined;
     const data = JSON.parse(readFileSync(cachePath, 'utf-8'));
     if (typeof data.lastCheck === 'number' && typeof data.latestVersion === 'string') {
@@ -109,10 +109,10 @@ function readCache(cachePath: string): CacheData | undefined {
 /**
  * Writes the update check cache file.
  */
-function writeCache(cachePath: string, data: CacheData): void {
+async function writeCache(cachePath: string, data: CacheData): Promise<void> {
   try {
-    const { existsSync, mkdirSync, writeFileSync } = require('node:fs') as typeof import('node:fs');
-    const { dirname } = require('node:path') as typeof import('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 });
@@ -126,9 +126,9 @@ function writeCache(cachePath: string, data: CacheData): void {
 /**
  * Resolves the cache path, expanding `~` to the home directory.
  */
-function resolveCachePath(cachePath: string): string {
-  const { homedir } = require('node:os') as typeof import('node:os');
-  const { resolve } = require('node:path') as typeof import('node:path');
+async function resolveCachePath(cachePath: string): Promise<string> {
+  const { homedir } = await import('node:os');
+  const { resolve } = await import('node:path');
   if (cachePath.startsWith('~')) {
     return cachePath.replace('~', homedir());
   }
@@ -173,28 +173,28 @@ export function formatUpdateMessage(currentVersion: string, latestVersion: strin
  * This is designed to be non-blocking: the check starts immediately but the
  * result is only consumed after command execution completes.
  */
-export function createUpdateChecker(
+export async function createUpdateChecker(
   programName: string,
   currentVersion: string,
   config: UpdateCheckConfig,
   runtime: ResolvedPadroneRuntime,
-): () => void {
+): Promise<() => void> {
   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);
 
   // Check if disabled
   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;
+  if (runtime.terminal && !runtime.terminal.isTTY) return noop;
 
   // Check cache — if we checked recently, use cached result
-  const cached = readCache(cachePath);
+  const cached = await readCache(cachePath);
   if (cached && Date.now() - cached.lastCheck < intervalMs) {
     // Use cached version for display
     if (isNewerVersion(currentVersion, cached.latestVersion)) {
@@ -206,9 +206,9 @@ export function createUpdateChecker(
   }
 
   // Start background fetch
-  const fetchPromise = fetchLatestVersion(packageName, registry).then((latestVersion) => {
+  const fetchPromise = fetchLatestVersion(packageName, registry).then(async (latestVersion) => {
     if (latestVersion) {
-      writeCache(cachePath, { lastCheck: Date.now(), latestVersion });
+      await writeCache(cachePath, { lastCheck: Date.now(), latestVersion });
       if (isNewerVersion(currentVersion, latestVersion)) {
         return latestVersion;
       }

package/src/{wrap.ts → feature/wrap.ts}

@@ -1,6 +1,7 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { ValidationError } from './errors.ts';
-import type { PadroneSchema } from './types.ts';
+import { ValidationError } from '../core/errors.ts';
+import type { PadroneSchema } from '../types/index.ts';
+import { concatBytes } from '../util/stream.ts';
 
 /**
  * Configuration for wrapping an external CLI tool.
@@ -58,7 +59,7 @@ export type WrapResult = {
 /**
  * Converts parsed arguments to CLI arguments for an external command.
  */
-function argsToCliArgs(input: Record<string, unknown> | undefined, positional: string[] = []): string[] {
+function argsToCliArgs(input: Record<string, unknown> | undefined, positional: readonly string[] = []): string[] {
   const args: string[] = [];
 
   // Handle undefined or null input
@@ -122,7 +123,7 @@ function argsToCliArgs(input: Record<string, unknown> | undefined, positional: s
 export function createWrapHandler<TCommandArgs extends PadroneSchema, TWrapArgs extends PadroneSchema>(
   config: WrapConfig<TCommandArgs, TWrapArgs>,
   commandArguments: TCommandArgs,
-  commandPositional?: string[],
+  commandPositional?: readonly string[],
 ): (args: StandardSchemaV1.InferOutput<TCommandArgs>) => Promise<WrapResult> {
   return async (args: StandardSchemaV1.InferOutput<TCommandArgs>): Promise<WrapResult> => {
     const { command, args: fixedArgs = [], inheritStdio = true, positional = commandPositional, schema: wrapSchema } = config;
@@ -153,33 +154,32 @@ export function createWrapHandler<TCommandArgs extends PadroneSchema, TWrapArgs
     const allArgs = [...fixedArgs, ...regularArgs];
 
     // Execute the external command
-    const proc = Bun.spawn([command, ...allArgs], {
-      stdout: inheritStdio ? 'inherit' : 'pipe',
-      stderr: inheritStdio ? 'inherit' : 'pipe',
-      stdin: inheritStdio ? 'inherit' : 'ignore',
-    });
+    const { spawn } = await import('node:child_process');
 
-    const exitCode = await proc.exited;
+    return new Promise<WrapResult>((resolve, reject) => {
+      const proc = spawn(command, allArgs, {
+        stdio: inheritStdio ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+      });
 
-    let stdout: string | undefined;
-    let stderr: string | undefined;
+      const stdoutChunks: Uint8Array[] = [];
+      const stderrChunks: Uint8Array[] = [];
 
-    if (!inheritStdio) {
-      if (proc.stdout) {
-        const stdoutBuffer = await new Response(proc.stdout).arrayBuffer();
-        stdout = new TextDecoder().decode(stdoutBuffer);
-      }
-      if (proc.stderr) {
-        const stderrBuffer = await new Response(proc.stderr).arrayBuffer();
-        stderr = new TextDecoder().decode(stderrBuffer);
+      if (!inheritStdio) {
+        proc.stdout!.on('data', (chunk: Uint8Array) => stdoutChunks.push(chunk));
+        proc.stderr!.on('data', (chunk: Uint8Array) => stderrChunks.push(chunk));
       }
-    }
 
-    return {
-      exitCode,
-      stdout,
-      stderr,
-      success: exitCode === 0,
-    };
+      const decoder = new TextDecoder();
+      proc.on('error', reject);
+      proc.on('close', (code) => {
+        const exitCode = code ?? 1;
+        resolve({
+          exitCode,
+          stdout: inheritStdio ? undefined : decoder.decode(concatBytes(stdoutChunks)),
+          stderr: inheritStdio ? undefined : decoder.decode(concatBytes(stderrChunks)),
+          success: exitCode === 0,
+        });
+      });
+    });
   };
 }

package/src/index.ts

@@ -1,23 +1,132 @@
-export { asyncSchema, buildReplCompleter, createPadrone } from './create.ts';
-export type { PadroneErrorOptions } from './errors.ts';
-export { ActionError, ConfigError, PadroneError, RoutingError, ValidationError } from './errors.ts';
-export type { HelpInfo } from './formatter.ts';
-export type { InteractiveMode, InteractivePromptConfig, PadroneRuntime } from './runtime.ts';
-export { REPL_SIGINT } from './runtime.ts';
-export type { InferArgsInput, InferArgsOutput, InferCommand } from './type-helpers.ts';
+export { buildReplCompleter } from './core/commands.ts';
+export type { PadroneOptions } from './core/create.ts';
+export { createPadrone } from './core/create.ts';
+export type { PadroneErrorOptions } from './core/errors.ts';
+export { ActionError, ConfigError, PadroneError, RoutingError, SignalError, ValidationError } from './core/errors.ts';
+export { defineInterceptor } from './core/interceptors.ts';
+export { asyncSchema } from './core/results.ts';
+export type {
+  InteractiveMode,
+  InteractivePromptConfig,
+  PadroneBarAnimation,
+  PadroneBarChar,
+  PadroneBarConfig,
+  PadroneProgressIndicator,
+  PadroneProgressOptions,
+  PadroneProgressShow,
+  PadroneProgressUpdate,
+  PadroneRuntime,
+  PadroneSignal,
+  PadroneSpinnerConfig,
+  PadroneSpinnerPreset,
+} from './core/runtime.ts';
+export { REPL_SIGINT } from './core/runtime.ts';
+export type {
+  HelpCommand,
+  InkOptions,
+  OtelSpan,
+  OtelTracer,
+  OtelTracerProvider,
+  PadroneLogger,
+  PadroneLoggerConfig,
+  PadroneLogLevel,
+  PadroneProgressConfig,
+  PadroneProgressDefaults,
+  PadroneProgressMessage,
+  PadroneProgressMessages,
+  PadroneProgressRenderer,
+  PadroneTracer,
+  PadroneTracingConfig,
+  VersionCommand,
+  WithCompletion,
+  WithHelp,
+  WithLogger,
+  WithMan,
+  WithMcp,
+  WithProgress,
+  WithRepl,
+  WithServe,
+  WithTracing,
+  WithVersion,
+} from './extension/index.ts';
+export {
+  createTerminalProgress,
+  isReactElement,
+  padroneAutoOutput,
+  padroneColor,
+  padroneCompletion,
+  padroneConfig,
+  padroneEnv,
+  padroneHelp,
+  padroneInk,
+  padroneInteractive,
+  padroneLogger,
+  padroneMan,
+  padroneMcp,
+  padroneProgress,
+  padroneRepl,
+  padroneServe,
+  padroneSignalHandling,
+  padroneStdin,
+  padroneSuggestions,
+  padroneTiming,
+  padroneTracing,
+  padroneUpdateCheck,
+  padroneVersion,
+} from './extension/index.ts';
+export type { PadroneMcpPreferences } from './feature/mcp.ts';
+export type { UpdateCheckConfig } from './feature/update-check.ts';
+export type { WrapConfig, WrapResult } from './feature/wrap.ts';
+export type { AnsiStyle, ColorConfig, ColorTheme } from './output/colorizer.ts';
+export { colorThemes } from './output/colorizer.ts';
+export type { HelpInfo } from './output/formatter.ts';
 export type {
   AnyPadroneBuilder,
   AnyPadroneCommand,
   AnyPadroneProgram,
   AsyncPadroneSchema,
+  CommandTypesBase,
+  ExtractInterceptorContext,
+  ExtractInterceptorRequires,
+  GetArgsMeta,
+  InterceptorBaseContext,
+  InterceptorDefBuilder,
+  InterceptorErrorContext,
+  InterceptorErrorResult,
+  InterceptorExecuteContext,
+  InterceptorExecuteResult,
+  InterceptorFactory,
+  InterceptorMeta,
+  InterceptorParseContext,
+  InterceptorParseResult,
+  InterceptorPhases,
+  InterceptorShutdownContext,
+  InterceptorStartContext,
+  InterceptorValidateContext,
+  InterceptorValidateResult,
   PadroneActionContext,
   PadroneBuilder,
   PadroneCommand,
   PadroneCommandResult,
+  PadroneContextInterceptor,
+  PadroneDrainResult,
+  PadroneExtension,
+  PadroneInterceptor,
+  PadroneInterceptorFn,
   PadroneParseResult,
-  PadronePlugin,
   PadroneProgram,
+  PadroneProgramMeta,
   PadroneSchema,
-} from './types.ts';
-export type { UpdateCheckConfig } from './update-check.ts';
-export type { WrapConfig, WrapResult } from './wrap.ts';
+} from './types/index.ts';
+export type { AsyncStreamMeta } from './util/stream.ts';
+export { asyncStream } from './util/stream.ts';
+export type {
+  InferArgsInput,
+  InferArgsOutput,
+  InferCommand,
+  InferContext,
+  InferContextProvided,
+  InferInterceptorContext,
+  InferInterceptorRequires,
+} from './util/type-helpers.ts';
+export type { Drained } from './util/type-utils.ts';

package/src/output/colorizer.ts

@@ -0,0 +1,154 @@
+// ANSI color/style codes
+const ansiCodes: Record<AnsiStyle, string> = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  strikethrough: '\x1b[9m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+};
+
+/**
+ * Available ANSI styles that can be combined for each color role.
+ */
+export type AnsiStyle =
+  | 'reset'
+  | 'bold'
+  | 'dim'
+  | 'italic'
+  | 'underline'
+  | 'strikethrough'
+  | 'red'
+  | 'green'
+  | 'yellow'
+  | 'blue'
+  | 'magenta'
+  | 'cyan'
+  | 'white'
+  | 'gray';
+
+/**
+ * Maps each semantic color role to an array of ANSI styles.
+ * Partial configs are merged with the default theme.
+ */
+export type ColorConfig = {
+  command?: AnsiStyle[];
+  arg?: AnsiStyle[];
+  type?: AnsiStyle[];
+  description?: AnsiStyle[];
+  label?: AnsiStyle[];
+  meta?: AnsiStyle[];
+  example?: AnsiStyle[];
+  exampleValue?: AnsiStyle[];
+  deprecated?: AnsiStyle[];
+};
+
+export type Colorizer = {
+  command: (text: string) => string;
+  arg: (text: string) => string;
+  type: (text: string) => string;
+  description: (text: string) => string;
+  label: (text: string) => string;
+  meta: (text: string) => string;
+  example: (text: string) => string;
+  exampleValue: (text: string) => string;
+  deprecated: (text: string) => string;
+};
+
+// ============================================================================
+// Predefined Themes
+// ============================================================================
+
+const defaultTheme: Required<ColorConfig> = {
+  command: ['cyan', 'bold'],
+  arg: ['green'],
+  type: ['yellow'],
+  description: ['dim'],
+  label: ['bold'],
+  meta: ['gray'],
+  example: ['underline'],
+  exampleValue: ['italic'],
+  deprecated: ['strikethrough', 'gray'],
+};
+
+const oceanTheme: Required<ColorConfig> = {
+  command: ['blue', 'bold'],
+  arg: ['cyan'],
+  type: ['green'],
+  description: ['dim'],
+  label: ['bold'],
+  meta: ['gray'],
+  example: ['underline', 'cyan'],
+  exampleValue: ['italic'],
+  deprecated: ['strikethrough', 'gray'],
+};
+
+const warmTheme: Required<ColorConfig> = {
+  command: ['yellow', 'bold'],
+  arg: ['red'],
+  type: ['magenta'],
+  description: ['dim'],
+  label: ['bold'],
+  meta: ['gray'],
+  example: ['underline', 'yellow'],
+  exampleValue: ['italic'],
+  deprecated: ['strikethrough', 'gray'],
+};
+
+const monochromeTheme: Required<ColorConfig> = {
+  command: ['bold'],
+  arg: ['underline'],
+  type: ['dim'],
+  description: ['dim'],
+  label: ['bold'],
+  meta: ['dim'],
+  example: ['underline'],
+  exampleValue: ['italic'],
+  deprecated: ['strikethrough', 'dim'],
+};
+
+/**
+ * Available predefined color themes.
+ */
+export type ColorTheme = 'default' | 'ocean' | 'warm' | 'monochrome';
+
+export const colorThemes: Record<ColorTheme, Required<ColorConfig>> = {
+  default: defaultTheme,
+  ocean: oceanTheme,
+  warm: warmTheme,
+  monochrome: monochromeTheme,
+};
+
+function makeStyleFn(styles: AnsiStyle[]): (text: string) => string {
+  const prefix = styles.map((s) => ansiCodes[s]).join('');
+  return (text: string) => `${prefix}${text}${ansiCodes.reset}`;
+}
+
+function resolveConfig(config?: ColorTheme | ColorConfig): Required<ColorConfig> {
+  if (!config) return defaultTheme;
+  if (typeof config === 'string') return colorThemes[config] ?? defaultTheme;
+  return { ...defaultTheme, ...config };
+}
+
+export function createColorizer(config?: ColorTheme | ColorConfig): Colorizer {
+  const resolved = resolveConfig(config);
+  return {
+    command: makeStyleFn(resolved.command),
+    arg: makeStyleFn(resolved.arg),
+    type: makeStyleFn(resolved.type),
+    description: makeStyleFn(resolved.description),
+    label: makeStyleFn(resolved.label),
+    meta: makeStyleFn(resolved.meta),
+    example: makeStyleFn(resolved.example),
+    exampleValue: makeStyleFn(resolved.exampleValue),
+    deprecated: makeStyleFn(resolved.deprecated),
+  };
+}