padrone 1.4.0 → 1.5.0

package/src/cli/doctor.ts

@@ -1,9 +1,11 @@
 import { resolve } from 'node:path';
-import { commandSymbol } from '../command-utils.ts';
+import { JSON_SCHEMA_OPTS } from '../args.ts';
+import { getCommand, isPadroneProgram } from '../command-utils.ts';
 import type { AnyPadroneCommand, PadroneActionContext } from '../types.ts';
+import { detectEntry } from './link.ts';
 
 interface DoctorArgs {
-  entry: string;
+  entry?: string;
 }
 
 type Severity = 'error' | 'warning';
@@ -15,7 +17,18 @@ interface Diagnostic {
 }
 
 export async function runDoctor(args: DoctorArgs, _ctx: PadroneActionContext) {
-  const entryPath = resolve(args.entry);
+  let entryPath: string;
+
+  if (args.entry) {
+    entryPath = resolve(args.entry);
+  } else {
+    const detected = detectEntry(process.cwd());
+    if (!detected) {
+      console.error('Could not detect entry point. Provide an entry file or add a "bin" field to package.json.');
+      process.exit(1);
+    }
+    entryPath = detected.entry;
+  }
 
   let mod: Record<string, unknown>;
   try {
@@ -33,7 +46,7 @@ export async function runDoctor(args: DoctorArgs, _ctx: PadroneActionContext) {
     process.exit(1);
   }
 
-  const cmd = (program as any)[commandSymbol] as AnyPadroneCommand;
+  const cmd = getCommand(program as object);
   const diagnostics: Diagnostic[] = [];
 
   collectDiagnostics(cmd, diagnostics);
@@ -63,6 +76,8 @@ export async function runDoctor(args: DoctorArgs, _ctx: PadroneActionContext) {
 }
 
 function collectDiagnostics(cmd: AnyPadroneCommand, diagnostics: Diagnostic[]) {
+  checkCircularParentRefs(cmd, diagnostics);
+
   const allCommands = flattenCommands(cmd);
 
   checkDuplicateAliases(allCommands, diagnostics);
@@ -71,6 +86,11 @@ function collectDiagnostics(cmd: AnyPadroneCommand, diagnostics: Diagnostic[]) {
   checkSchemasWithoutDescriptions(allCommands, diagnostics);
   checkConflictingPositionals(allCommands, diagnostics);
   checkUnusedPlugins(allCommands, diagnostics);
+  checkDuplicateOptionFlagsAndAliases(allCommands, diagnostics);
+  checkUnreachableCommands(allCommands, diagnostics);
+  checkMissingCommandDescriptions(allCommands, diagnostics);
+  checkEmptyCommandGroups(allCommands, diagnostics);
+  checkDeprecatedWithoutHint(allCommands, diagnostics);
 }
 
 function flattenCommands(cmd: AnyPadroneCommand): AnyPadroneCommand[] {
@@ -90,7 +110,7 @@ function commandDisplayName(cmd: AnyPadroneCommand): string {
 function getJsonSchema(cmd: AnyPadroneCommand): Record<string, any> | null {
   try {
     if (!cmd.argsSchema) return null;
-    return cmd.argsSchema['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) as Record<string, any>;
+    return cmd.argsSchema['~standard'].jsonSchema.input(JSON_SCHEMA_OPTS) as Record<string, any>;
   } catch {
     return null;
   }
@@ -313,6 +333,176 @@ function checkUnusedPlugins(commands: AnyPadroneCommand[], diagnostics: Diagnost
   }
 }
 
+/**
+ * Check for circular parent references in the command tree.
+ * Uses a visited set to detect cycles before flattening.
+ */
+function checkCircularParentRefs(cmd: AnyPadroneCommand, diagnostics: Diagnostic[]) {
+  const visited = new Set<AnyPadroneCommand>();
+
+  function walk(node: AnyPadroneCommand) {
+    if (visited.has(node)) {
+      diagnostics.push({
+        severity: 'error',
+        command: commandDisplayName(node),
+        message: 'Circular reference detected in command tree.',
+      });
+      return;
+    }
+    visited.add(node);
+    if (node.commands) {
+      for (const sub of node.commands) {
+        walk(sub);
+      }
+    }
+  }
+
+  walk(cmd);
+}
+
+/**
+ * Check for duplicate flags or aliases within a single command's meta fields.
+ * e.g., two different options both using `-v` or both aliased to `--output`.
+ */
+function checkDuplicateOptionFlagsAndAliases(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+  for (const cmd of commands) {
+    if (!cmd.meta?.fields) continue;
+
+    const seenFlags = new Map<string, string>();
+    const seenAliases = new Map<string, string>();
+
+    for (const [fieldName, fieldMeta] of Object.entries(cmd.meta.fields)) {
+      if (!fieldMeta) continue;
+
+      if (fieldMeta.flags) {
+        const flagList = typeof fieldMeta.flags === 'string' ? [fieldMeta.flags] : fieldMeta.flags;
+        for (const flag of flagList) {
+          const existing = seenFlags.get(flag);
+          if (existing) {
+            diagnostics.push({
+              severity: 'error',
+              command: commandDisplayName(cmd),
+              message: `Flag "-${flag}" is used by both "${existing}" and "${fieldName}".`,
+            });
+          } else {
+            seenFlags.set(flag, fieldName);
+          }
+        }
+      }
+
+      if (fieldMeta.alias) {
+        const aliasList = typeof fieldMeta.alias === 'string' ? [fieldMeta.alias] : fieldMeta.alias;
+        for (const alias of aliasList) {
+          const existing = seenAliases.get(alias);
+          if (existing) {
+            diagnostics.push({
+              severity: 'error',
+              command: commandDisplayName(cmd),
+              message: `Alias "--${alias}" is used by both "${existing}" and "${fieldName}".`,
+            });
+          } else {
+            seenAliases.set(alias, fieldName);
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Check for commands that are unreachable because a parent is hidden.
+ * A hidden parent makes all its children effectively invisible to users.
+ */
+function checkUnreachableCommands(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+  for (const cmd of commands) {
+    if (!cmd.parent || cmd.hidden) continue;
+
+    let ancestor: AnyPadroneCommand | undefined = cmd.parent;
+    while (ancestor) {
+      if (ancestor.hidden && ancestor.parent) {
+        diagnostics.push({
+          severity: 'warning',
+          command: commandDisplayName(cmd),
+          message: `Command is unreachable because parent "${commandDisplayName(ancestor)}" is hidden.`,
+        });
+        break;
+      }
+      ancestor = ancestor.parent;
+    }
+  }
+}
+
+/**
+ * Check for non-root commands without a title or description.
+ */
+function checkMissingCommandDescriptions(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+  for (const cmd of commands) {
+    if (!cmd.parent) continue;
+    if (cmd.hidden) continue;
+
+    if (!cmd.title && !cmd.description) {
+      diagnostics.push({
+        severity: 'warning',
+        command: commandDisplayName(cmd),
+        message: 'Command has no title or description.',
+      });
+    }
+  }
+}
+
+/**
+ * Check for branch commands (have subcommands) that have no leaf descendants.
+ * This catches empty command groups where all subcommands are also empty branches.
+ */
+function checkEmptyCommandGroups(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+  function hasLeafDescendant(cmd: AnyPadroneCommand): boolean {
+    if (!cmd.commands || cmd.commands.length === 0) return true;
+    return cmd.commands.some(hasLeafDescendant);
+  }
+
+  for (const cmd of commands) {
+    if (!cmd.commands || cmd.commands.length === 0) continue;
+
+    const allSubsEmpty = cmd.commands.every((sub) => sub.commands && sub.commands.length > 0 && !hasLeafDescendant(sub));
+
+    if (allSubsEmpty) {
+      diagnostics.push({
+        severity: 'warning',
+        command: commandDisplayName(cmd),
+        message: 'Command group has no reachable leaf commands.',
+      });
+    }
+  }
+}
+
+/**
+ * Check for deprecated commands that use `deprecated: true` without a hint message.
+ */
+function checkDeprecatedWithoutHint(commands: AnyPadroneCommand[], diagnostics: Diagnostic[]) {
+  for (const cmd of commands) {
+    if (cmd.deprecated === true) {
+      diagnostics.push({
+        severity: 'warning',
+        command: commandDisplayName(cmd),
+        message: 'Command is deprecated without a replacement hint. Use a string to provide guidance (e.g., "Use \'new-cmd\' instead").',
+      });
+    }
+
+    // Also check deprecated option fields
+    if (cmd.meta?.fields) {
+      for (const [fieldName, fieldMeta] of Object.entries(cmd.meta.fields)) {
+        if (fieldMeta?.deprecated === true) {
+          diagnostics.push({
+            severity: 'warning',
+            command: commandDisplayName(cmd),
+            message: `Option "${fieldName}" is deprecated without a replacement hint.`,
+          });
+        }
+      }
+    }
+  }
+}
+
 function findProgram(mod: Record<string, unknown>): unknown | null {
   const defaultExport = mod.default;
   if (isPadroneProgram(defaultExport)) return defaultExport;
@@ -323,8 +513,3 @@ function findProgram(mod: Record<string, unknown>): unknown | null {
 
   return null;
 }
-
-function isPadroneProgram(value: unknown): boolean {
-  if (!value || typeof value !== 'object') return false;
-  return commandSymbol in value;
-}

package/src/cli/index.ts

@@ -60,7 +60,7 @@ const PadroneCLI = createPadrone('padrone')
       })
       .arguments(
         z.object({
-          entry: z.string().describe('Entry file that exports a Padrone program'),
+          entry: z.string().optional().describe('Entry file that exports a Padrone program (auto-detected from package.json if omitted)'),
         }),
         {
           positional: ['entry'],

package/src/cli/init.ts

@@ -16,9 +16,7 @@ const packageJsonTemplate = template(`{
   "private": true,
   "type": "module",
   "module": "src/index.ts",
-  "bin": {
-    "{{name}}": "src/index.ts"
-  },
+  "bin": "src/index.ts",
   "scripts": {
     "start": "bun src/index.ts",
     "dev": "bun --watch src/index.ts",
@@ -131,5 +129,6 @@ export async function runInit(args: InitArgs, ctx: PadroneActionContext) {
     output(`  cd ${dir}`);
   }
   output('  bun install');
+  output('  bun update');
   output('  bun run dev');
 }

package/src/cli/link.ts

@@ -49,7 +49,7 @@ function writeLinks(links: LinksData) {
   writeFileSync(LINKS_FILE, `${JSON.stringify(links, null, 2)}\n`);
 }
 
-interface DetectedEntry {
+export interface DetectedEntry {
   entry: string;
   name: string;
   /** Full run command prefix parsed from scripts (e.g. "bun --conditions=padrone@dev") */
@@ -70,7 +70,7 @@ function parseRunPrefix(script: string, entryRelative: string, dir: string): str
   return undefined;
 }
 
-function detectEntry(dir: string): DetectedEntry | undefined {
+export function detectEntry(dir: string): DetectedEntry | undefined {
   const pkgPath = resolve(dir, 'package.json');
   if (!existsSync(pkgPath)) return undefined;
 

package/src/codegen/discovery.ts

@@ -1,15 +1,23 @@
+import { execFile } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+
+import { parseBashCompletions } from './parsers/bash.ts';
 import { parseFishCompletions } from './parsers/fish.ts';
 import { parseHelpOutput } from './parsers/help.ts';
 import { mergeCommandMeta } from './parsers/merge.ts';
 import { parseZshCompletions } from './parsers/zsh.ts';
 import type { CommandMeta, GeneratorLogger } from './types.ts';
 
-export type DiscoverySource = 'help' | 'fish' | 'zsh';
+export type DiscoverySource = 'help' | 'completion' | 'bash' | 'fish' | 'zsh';
 
 export interface DiscoveryOptions {
   /** The command to discover (e.g. 'gh', 'docker', 'kubectl'). */
   command: string;
-  /** Which parsing sources to use. Default: ['help'] */
+  /**
+   * Which parsing sources to use. Default: ['help'].
+   * Use `'completion'` to auto-detect the best shell completion source
+   * by probing `<cmd> completion <shell>` (bash → fish → zsh).
+   */
   sources?: DiscoverySource[];
   /** Max subcommand depth. 0 = root only, undefined = unlimited. */
   depth?: number;
@@ -35,7 +43,10 @@ export interface DiscoveryResult {
  * parsing shell completion scripts.
  */
 export async function discoverCli(options: DiscoveryOptions): Promise<DiscoveryResult> {
-  const { command, sources = ['help'], depth, delay = 50, log, timeout = 10000 } = options;
+  const { command, sources: rawSources = ['help'], depth, delay = 50, log, timeout = 10000 } = options;
+
+  // Resolve 'completion' source by probing for the best available shell
+  const sources = await resolveSources(rawSources, command, timeout, log);
 
   const warnings: string[] = [];
   let invocations = 0;
@@ -60,7 +71,18 @@ export async function discoverCli(options: DiscoveryOptions): Promise<DiscoveryR
     results.push(helpResult);
   }
 
-  // Source 2: Fish completions
+  // Source 2: Bash completions
+  if (sources.includes('bash')) {
+    log?.info(`Parsing bash completions for ${command}...`);
+    const bashText = await getCompletionScript(command, 'bash', timeout);
+    if (bashText) {
+      results.push(parseBashCompletions(bashText));
+    } else {
+      warnings.push('Could not obtain bash completion script');
+    }
+  }
+
+  // Source 3: Fish completions
   if (sources.includes('fish')) {
     log?.info(`Parsing fish completions for ${command}...`);
     const fishText = await getCompletionScript(command, 'fish', timeout);
@@ -71,7 +93,7 @@ export async function discoverCli(options: DiscoveryOptions): Promise<DiscoveryR
     }
   }
 
-  // Source 3: Zsh completions
+  // Source 4: Zsh completions
   if (sources.includes('zsh')) {
     log?.info(`Parsing zsh completions for ${command}...`);
     const zshText = await getCompletionScript(command, 'zsh', timeout);
@@ -163,25 +185,13 @@ async function runHelp(command: string, args: string[], timeout: number): Promis
  */
 async function runCommand(command: string, args: string[], timeout: number): Promise<string | null> {
   try {
-    const proc = Bun.spawn([command, ...args], {
-      stdout: 'pipe',
-      stderr: 'pipe',
-      stdin: 'ignore',
+    const { stdout, stderr } = await new Promise<{ stdout: string; stderr: string }>((resolve) => {
+      execFile(command, args, { timeout, maxBuffer: 10 * 1024 * 1024 }, (_error, stdout, stderr) => {
+        // Resolve even on non-zero exit — many CLIs exit non-zero on --help
+        resolve({ stdout: (stdout ?? '').trim(), stderr: (stderr ?? '').trim() });
+      });
     });
 
-    const timer = setTimeout(() => proc.kill(), timeout);
-
-    const [_exitCode, stdoutBuf, stderrBuf] = await Promise.all([
-      proc.exited,
-      new Response(proc.stdout).arrayBuffer(),
-      new Response(proc.stderr).arrayBuffer(),
-    ]);
-
-    clearTimeout(timer);
-
-    const stdout = new TextDecoder().decode(stdoutBuf).trim();
-    const stderr = new TextDecoder().decode(stderrBuf).trim();
-
     // Some CLIs output help to stderr, some exit non-zero on --help
     const combined = stdout || stderr;
     if (!combined) return null;
@@ -199,7 +209,7 @@ async function runCommand(command: string, args: string[], timeout: number): Pro
  * Try to get a shell completion script for a command.
  * Checks both `<cmd> completion <shell>` and well-known file paths.
  */
-async function getCompletionScript(command: string, shell: 'fish' | 'zsh', timeout: number): Promise<string | null> {
+async function getCompletionScript(command: string, shell: 'bash' | 'fish' | 'zsh', timeout: number): Promise<string | null> {
   // Try `<cmd> completion <shell>`
   const completionArgs = ['completion', shell];
   let result = await runCommand(command, completionArgs, timeout);
@@ -213,20 +223,62 @@ async function getCompletionScript(command: string, shell: 'fish' | 'zsh', timeo
   const paths =
     shell === 'fish'
       ? [`/usr/share/fish/vendor_completions.d/${command}.fish`, `/usr/local/share/fish/vendor_completions.d/${command}.fish`]
-      : [`/usr/share/zsh/site-functions/_${command}`, `/usr/local/share/zsh/site-functions/_${command}`];
+      : shell === 'bash'
+        ? [
+            `/usr/share/bash-completion/completions/${command}`,
+            `/usr/local/share/bash-completion/completions/${command}`,
+            `/etc/bash_completion.d/${command}`,
+          ]
+        : [`/usr/share/zsh/site-functions/_${command}`, `/usr/local/share/zsh/site-functions/_${command}`];
 
   for (const path of paths) {
     try {
-      const file = Bun.file(path);
-      if (await file.exists()) {
-        return await file.text();
-      }
+      return await readFile(path, 'utf-8');
     } catch {}
   }
 
   return null;
 }
 
+/**
+ * Detect the best shell for completion parsing by probing the command.
+ * Tries `<cmd> completion <shell>` for bash, fish, zsh (in that order).
+ * Returns the shell name if successful, or null if no completion command exists.
+ */
+export async function detectCompletionShell(command: string, timeout = 5000): Promise<'bash' | 'fish' | 'zsh' | null> {
+  for (const shell of ['bash', 'fish', 'zsh'] as const) {
+    const result = await getCompletionScript(command, shell, timeout);
+    if (result) return shell;
+  }
+  return null;
+}
+
+/**
+ * Resolve 'completion' entries in the sources array by probing for the best available shell.
+ * Other sources are passed through unchanged.
+ */
+async function resolveSources(
+  sources: DiscoverySource[],
+  command: string,
+  timeout: number,
+  log?: GeneratorLogger,
+): Promise<DiscoverySource[]> {
+  if (!sources.includes('completion')) return sources;
+
+  log?.info(`Probing ${command} for completion command...`);
+  const shell = await detectCompletionShell(command, timeout);
+
+  return sources.flatMap((s) => {
+    if (s !== 'completion') return s;
+    if (shell) {
+      log?.info(`  Found ${shell} completion support`);
+      return shell;
+    }
+    log?.info('  No completion command found, skipping');
+    return [];
+  });
+}
+
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/codegen/index.ts

@@ -4,7 +4,7 @@
 export { createCodeBuilder } from './code-builder.ts';
 export type { DiscoveryOptions, DiscoveryResult, DiscoverySource } from './discovery.ts';
 // Discovery
-export { discoverCli } from './discovery.ts';
+export { detectCompletionShell, discoverCli } from './discovery.ts';
 export { createFileEmitter } from './file-emitter.ts';
 // Generators
 export { generateBarrelFile } from './generators/barrel-file.ts';
@@ -13,6 +13,7 @@ export { generateCommandFile } from './generators/command-file.ts';
 export type { CommandTreeOptions } from './generators/command-tree.ts';
 export { generateCommandTree } from './generators/command-tree.ts';
 // Parsers
+export { parseBashCompletions } from './parsers/bash.ts';
 export { parseFishCompletions } from './parsers/fish.ts';
 export { parseHelpOutput } from './parsers/help.ts';
 export { mergeCommandMeta } from './parsers/merge.ts';

package/src/codegen/parsers/bash.ts

@@ -0,0 +1,179 @@
+import type { CommandMeta, FieldMeta } from '../types.ts';
+
+/**
+ * Parse bash completion scripts into CommandMeta.
+ *
+ * Bash completions typically use `complete -F <func> <command>` and define
+ * a function that sets COMPREPLY. Common patterns:
+ *
+ *   local commands="init build deploy"
+ *   local args="--verbose --output --format"
+ *   case "$prev" in --format) COMPREPLY=($(compgen -W "json yaml toml" ...)) ;;
+ *   COMPREPLY=($(compgen -W "$commands" ...))
+ *   COMPREPLY=($(compgen -W "$args" ...))
+ */
+export function parseBashCompletions(text: string): CommandMeta {
+  const result: CommandMeta = {
+    name: '',
+    arguments: [],
+    subcommands: [],
+  };
+
+  // Detect command name from `complete -F _func <command>` or `complete -o ... -F _func <command>`
+  const completeMatch = text.match(/complete\s+(?:[^-]|-[^F])*-F\s+\S+\s+(\S+)/);
+  if (completeMatch) {
+    result.name = completeMatch[1]!;
+  }
+
+  // Fallback: detect from marker comments like ###-begin-<name>-completion-###
+  if (!result.name) {
+    const markerMatch = text.match(/###-begin-(\S+)-completion-###/);
+    if (markerMatch) {
+      result.name = markerMatch[1]!;
+    }
+  }
+
+  // Join continuation lines for easier parsing
+  const joined = text.replace(/\\\n\s*/g, ' ');
+
+  // Collect variable values: local commands="..." or local args="..."
+  const variables = extractVariables(joined);
+
+  // Extract subcommand names from commands variable or compgen -W "cmd1 cmd2"
+  const commandWords = variables.get('commands') ?? variables.get('cmds') ?? variables.get('subcommands');
+  if (commandWords) {
+    for (const name of splitWords(commandWords)) {
+      result.subcommands!.push({ name });
+    }
+  }
+
+  // Extract option names from args/opts/options variable
+  const argWords = variables.get('args') ?? variables.get('opts') ?? variables.get('options') ?? variables.get('flags');
+  const optionNames = new Set<string>();
+
+  if (argWords) {
+    for (const word of splitWords(argWords)) {
+      if (word.startsWith('-')) {
+        optionNames.add(word);
+      }
+    }
+  }
+
+  // Also scan for compgen -W patterns not tied to a case statement
+  const compgenRegex = /compgen\s+-W\s+["']([^"']+)["']/g;
+  let compgenMatch: RegExpExecArray | null;
+  while ((compgenMatch = compgenRegex.exec(joined)) !== null) {
+    // Skip variable references like $args, $commands
+    if (compgenMatch[1]!.startsWith('$')) continue;
+    for (const word of splitWords(compgenMatch[1]!)) {
+      if (word.startsWith('-')) {
+        optionNames.add(word);
+      }
+    }
+  }
+
+  // Parse case statement for option value completions (enum detection)
+  const enumMap = parseCaseStatement(joined);
+
+  // Build argument fields
+  const seenArgs = new Set<string>();
+
+  for (const rawName of optionNames) {
+    // Skip builtins
+    if (rawName === '--help' || rawName === '-h' || rawName === '--version' || rawName === '-V') continue;
+
+    const name = rawName.replace(/^-+/, '').replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());
+    if (!name || seenArgs.has(name)) continue;
+    seenArgs.add(name);
+
+    // Check if this option has enum values from case statement
+    const enumValues = enumMap.get(rawName);
+
+    const isShort = rawName.startsWith('-') && !rawName.startsWith('--') && rawName.length === 2;
+    const field: FieldMeta = {
+      name,
+      type: enumValues ? 'enum' : 'string',
+      enumValues,
+      ambiguous: !enumValues,
+    };
+
+    // If there's a corresponding long-form, record alias
+    if (isShort) {
+      field.aliases = [rawName];
+    }
+
+    result.arguments!.push(field);
+  }
+
+  if (result.arguments!.length === 0) delete result.arguments;
+  if (result.subcommands!.length === 0) delete result.subcommands;
+
+  return result;
+}
+
+/**
+ * Extract variable assignments: `local VAR="value"`, `VAR="value"`, `local VAR='value'`
+ */
+function extractVariables(text: string): Map<string, string> {
+  const vars = new Map<string, string>();
+  const regex = /(?:local\s+)?(\w+)=["']([^"']+)["']/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = regex.exec(text)) !== null) {
+    vars.set(match[1]!, match[2]!);
+  }
+
+  return vars;
+}
+
+/**
+ * Parse case statements to find option → enum value mappings.
+ *
+ * Matches patterns like:
+ *   case "$prev" in
+ *     --format) COMPREPLY=($(compgen -W "json yaml toml" ...)) ;;
+ *     --env|--environment) COMPREPLY=($(compgen -W "dev staging prod" ...)) ;;
+ */
+function parseCaseStatement(text: string): Map<string, string[]> {
+  const result = new Map<string, string[]>();
+
+  // Find case blocks on $prev or similar variables
+  const caseRegex = /case\s+[^i]*\bin\b\s*([\s\S]*?)esac/g;
+  let caseMatch: RegExpExecArray | null;
+
+  while ((caseMatch = caseRegex.exec(text)) !== null) {
+    const body = caseMatch[1]!;
+
+    // Split into branches by ;; delimiter
+    const branches = body.split(';;');
+    for (const branch of branches) {
+      // Match pattern: --opt1|--opt2) ... compgen -W "values" ...
+      const patternMatch = branch.match(/^\s*([-\w|]+)\)/);
+      if (!patternMatch) continue;
+
+      // Find compgen -W "values" within this branch
+      const compgenMatch = branch.match(/compgen\s+-W\s+["']([^"']+)["']/);
+      if (!compgenMatch) continue;
+
+      const values = compgenMatch[1]!;
+      const words = splitWords(values).filter((w) => !w.startsWith('$'));
+      if (words.length === 0) continue;
+
+      for (const pattern of patternMatch[1]!.split('|')) {
+        const trimmed = pattern.trim();
+        if (trimmed.startsWith('-')) {
+          result.set(trimmed, words);
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Split a space-separated word list, filtering empty strings.
+ */
+function splitWords(text: string): string[] {
+  return text.split(/\s+/).filter(Boolean);
+}

package/src/codegen/schema-to-code.ts

@@ -1,4 +1,5 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { JSON_SCHEMA_OPTS } from '../args.ts';
 import type { FieldMeta } from './types.ts';
 
 interface SchemaToCodeResult {
@@ -57,7 +58,7 @@ function jsonSchemaPropertyToZod(prop: Record<string, any>, required: boolean, a
  */
 export function schemaToCode(schema: StandardSchemaV1): SchemaToCodeResult {
   try {
-    const jsonSchema = (schema as any)['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) as Record<string, any>;
+    const jsonSchema = (schema as any)['~standard'].jsonSchema.input(JSON_SCHEMA_OPTS) as Record<string, any>;
     return jsonSchemaToCode(jsonSchema);
   } catch {
     return { code: 'z.unknown()', imports: ['z'] };