padrone 1.4.0 → 1.6.0

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

@@ -1,8 +1,8 @@
-import { extractSchemaMetadata } from './args.ts';
-import { detectShell, getRcFile, type ShellType, writeToRcFile } from './shell-utils.ts';
-import type { AnyPadroneCommand } from './types.ts';
+import { extractSchemaMetadata, getJsonSchema } from '../core/args.ts';
+import type { AnyPadroneCommand } from '../types/index.ts';
+import { detectShell, getRcFile, type ShellType, writeToRcFile } from '../util/shell-utils.ts';
 
-export { detectShell, escapeRegExp, getRcFile, type ShellType, writeToRcFile } from './shell-utils.ts';
+export { detectShell, escapeRegExp, getRcFile, type ShellType, writeToRcFile } from '../util/shell-utils.ts';
 
 /**
  * Collects all commands from a program recursively.
@@ -22,11 +22,19 @@ function collectAllCommands(cmd: AnyPadroneCommand): AnyPadroneCommand[] {
   return result;
 }
 
+interface ExtractedArg {
+  name: string;
+  alias?: string;
+  isBoolean: boolean;
+  enum?: string[];
+  description?: string;
+}
+
 /**
  * Extracts all argument names from a command's schema.
  */
-function extractArguments(cmd: AnyPadroneCommand): { name: string; alias?: string; isBoolean: boolean }[] {
-  const argList: { name: string; alias?: string; isBoolean: boolean }[] = [];
+function extractArguments(cmd: AnyPadroneCommand): ExtractedArg[] {
+  const argList: ExtractedArg[] = [];
 
   if (!cmd.argsSchema) return argList;
 
@@ -34,21 +42,24 @@ function extractArguments(cmd: AnyPadroneCommand): { name: string; alias?: strin
     const argsMeta = cmd.meta?.fields;
     const { aliases } = extractSchemaMetadata(cmd.argsSchema, argsMeta, cmd.meta?.autoAlias);
 
-    // Reverse aliases map (alias -> arg name)
-    const aliasToArgument: Record<string, string> = {};
-    for (const [arg, alias] of Object.entries(aliases)) {
-      aliasToArgument[alias] = arg;
+    // Build reverse map: argName → aliasName
+    const argToAlias: Record<string, string> = {};
+    for (const [aliasName, argName] of Object.entries(aliases)) {
+      if (!argToAlias[argName]) argToAlias[argName] = aliasName;
     }
 
-    const jsonSchema = cmd.argsSchema['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) as Record<string, any>;
+    const jsonSchema = getJsonSchema(cmd.argsSchema) as Record<string, any>;
 
     if (jsonSchema.type === 'object' && jsonSchema.properties) {
       for (const [key, prop] of Object.entries(jsonSchema.properties as Record<string, any>)) {
-        const alias = Object.entries(aliases).find(([arg]) => arg === key)?.[1];
+        const enumValues = (prop.enum ?? prop.items?.enum) as string[] | undefined;
+        const optMeta = argsMeta?.[key];
         argList.push({
           name: key,
-          alias: alias,
+          alias: argToAlias[key],
           isBoolean: prop?.type === 'boolean',
+          enum: enumValues,
+          description: optMeta?.description ?? prop.description,
         });
       }
     }
@@ -59,6 +70,23 @@ function extractArguments(cmd: AnyPadroneCommand): { name: string; alias?: strin
   return argList;
 }
 
+/**
+ * Collects unique args across all commands, preserving first-seen enum values.
+ */
+function collectUniqueArgs(program: AnyPadroneCommand, commands: AnyPadroneCommand[]): Map<string, ExtractedArg> {
+  const seen = new Map<string, ExtractedArg>();
+
+  for (const cmd of [program, ...commands]) {
+    for (const arg of extractArguments(cmd)) {
+      if (!seen.has(arg.name)) {
+        seen.set(arg.name, arg);
+      }
+    }
+  }
+
+  return seen;
+}
+
 /**
  * Generates a Bash completion script for the program.
  */
@@ -66,21 +94,41 @@ export function generateBashCompletion(program: AnyPadroneCommand): string {
   const programName = program.name;
   const commands = collectAllCommands(program);
   const commandNames = commands.map((c) => c.name).join(' ');
+  const uniqueArgs = collectUniqueArgs(program, commands);
 
-  // Collect all args from all commands
+  // Collect all option names
   const allArguments = new Set<string>();
   allArguments.add('--help');
   allArguments.add('--version');
 
-  for (const cmd of [program, ...commands]) {
-    for (const arg of extractArguments(cmd)) {
-      allArguments.add(`--${arg.name}`);
-      if (arg.alias) allArguments.add(`-${arg.alias}`);
-    }
+  for (const arg of uniqueArgs.values()) {
+    allArguments.add(`--${arg.name}`);
+    if (arg.alias) allArguments.add(`--${arg.alias}`);
   }
 
   const argsList = Array.from(allArguments).join(' ');
 
+  // Build case branches for options with enum values
+  const enumCases: string[] = [];
+  for (const arg of uniqueArgs.values()) {
+    if (!arg.enum || arg.enum.length === 0) continue;
+    const values = arg.enum.join(' ');
+    const patterns = [`--${arg.name}`];
+    if (arg.alias) patterns.push(`--${arg.alias}`);
+    enumCases.push(`      ${patterns.join('|')}) COMPREPLY=($(compgen -W "${values}" -- "$cur")); return 0 ;;`);
+  }
+
+  const enumBlock =
+    enumCases.length > 0
+      ? `
+    # Complete option values
+    case "$prev" in
+${enumCases.join('\n')}
+    esac
+
+`
+      : '\n';
+
   return `###-begin-${programName}-completion-###
 #
 # ${programName} command completion script
@@ -104,8 +152,7 @@ if type complete &>/dev/null; then
 
     local commands="${commandNames}"
     local args="${argsList}"
-
-    # Complete args when current word starts with -
+${enumBlock}    # Complete args when current word starts with -
     if [[ "$cur" == -* ]]; then
       COMPREPLY=($(compgen -W "$args" -- "$cur"))
       return 0
@@ -161,26 +208,24 @@ export function generateZshCompletion(program: AnyPadroneCommand): string {
     })
     .join('\n');
 
-  // Collect all args with descriptions
+  // Collect all args with descriptions and enum values
   const argumentCompletions: string[] = [];
   argumentCompletions.push("      '--help[Show help information]'");
   argumentCompletions.push("      '--version[Show version number]'");
 
-  const seenArgs = new Set<string>(['help', 'version']);
+  const uniqueArgs = collectUniqueArgs(program, commands);
 
-  for (const cmd of [program, ...commands]) {
-    for (const arg of extractArguments(cmd)) {
-      if (seenArgs.has(arg.name)) continue;
-      seenArgs.add(arg.name);
+  for (const arg of uniqueArgs.values()) {
+    const desc = arg.description || '';
+    const escapedDesc = desc.replace(/'/g, "'\\''").replace(/\[/g, '\\[').replace(/\]/g, '\\]');
 
-      const desc = cmd.meta?.fields?.[arg.name]?.description || '';
-      const escapedDesc = desc.replace(/'/g, "'\\''").replace(/\[/g, '\\[').replace(/\]/g, '\\]');
+    // Zsh action spec for enum values: :label:(val1 val2 val3)
+    const valueAction = arg.enum?.length ? `: :(${arg.enum.join(' ')})` : '';
 
-      if (arg.alias) {
-        argumentCompletions.push(`      {-${arg.alias},--${arg.name}}'[${escapedDesc}]'`);
-      } else {
-        argumentCompletions.push(`      '--${arg.name}[${escapedDesc}]'`);
-      }
+    if (arg.alias) {
+      argumentCompletions.push(`      {--${arg.alias},--${arg.name}}'[${escapedDesc}]${valueAction}'`);
+    } else {
+      argumentCompletions.push(`      '--${arg.name}[${escapedDesc}]${valueAction}'`);
     }
   }
 
@@ -253,21 +298,18 @@ export function generateFishCompletion(program: AnyPadroneCommand): string {
   lines.push(`complete -c ${programName} -l help -d 'Show help information'`);
   lines.push(`complete -c ${programName} -l version -d 'Show version number'`);
 
-  const seenArgs = new Set<string>(['help', 'version']);
+  const uniqueArgs = collectUniqueArgs(program, commands);
 
-  for (const cmd of [program, ...commands]) {
-    for (const arg of extractArguments(cmd)) {
-      if (seenArgs.has(arg.name)) continue;
-      seenArgs.add(arg.name);
-
-      const desc = cmd.meta?.fields?.[arg.name]?.description || '';
-      const escapedDesc = desc.replace(/'/g, "\\'");
+  for (const arg of uniqueArgs.values()) {
+    const desc = arg.description || '';
+    const escapedDesc = desc.replace(/'/g, "\\'");
+    // Fish: -xa 'val1 val2' provides exclusive value completions
+    const valueFlag = arg.enum?.length ? ` -xa '${arg.enum.join(' ')}'` : '';
 
-      if (arg.alias) {
-        lines.push(`complete -c ${programName} -s ${arg.alias} -l ${arg.name} -d '${escapedDesc}'`);
-      } else {
-        lines.push(`complete -c ${programName} -l ${arg.name} -d '${escapedDesc}'`);
-      }
+    if (arg.alias) {
+      lines.push(`complete -c ${programName} -l ${arg.name} -s ${arg.alias} -d '${escapedDesc}'${valueFlag}`);
+    } else {
+      lines.push(`complete -c ${programName} -l ${arg.name} -d '${escapedDesc}'${valueFlag}`);
     }
   }
 
@@ -282,9 +324,41 @@ export function generateFishCompletion(program: AnyPadroneCommand): string {
 export function generatePowerShellCompletion(program: AnyPadroneCommand): string {
   const programName = program.name;
   const commands = collectAllCommands(program);
+  const uniqueArgs = collectUniqueArgs(program, commands);
 
   const commandNames = commands.map((c) => `'${c.name}'`).join(', ');
 
+  // Collect all option names
+  const argNames: string[] = ["'--help'", "'--version'"];
+  for (const arg of uniqueArgs.values()) {
+    argNames.push(`'--${arg.name}'`);
+    if (arg.alias) argNames.push(`'--${arg.alias}'`);
+  }
+
+  // Build switch cases for option value completion
+  const enumCases: string[] = [];
+  for (const arg of uniqueArgs.values()) {
+    if (!arg.enum || arg.enum.length === 0) continue;
+    const values = arg.enum.map((v) => `'${v}'`).join(', ');
+    const patterns = [`'--${arg.name}'`];
+    if (arg.alias) patterns.push(`'--${arg.alias}'`);
+    enumCases.push(`      ${patterns.join(', ')} { @(${values}) | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+        [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+      }; return }`);
+  }
+
+  const enumBlock =
+    enumCases.length > 0
+      ? `
+  # Complete option values
+  $prevWord = $commandAst.CommandElements | Select-Object -Last 2 | Select-Object -First 1
+  switch ($prevWord) {
+${enumCases.join('\n')}
+  }
+
+`
+      : '\n';
+
   return `###-begin-${programName}-completion-###
 #
 # ${programName} command completion script for PowerShell
@@ -296,9 +370,8 @@ Register-ArgumentCompleter -Native -CommandName ${programName} -ScriptBlock {
   param($wordToComplete, $commandAst, $cursorPosition)
 
   $commands = @(${commandNames})
-  $args = @('--help', '--version')
-
-  if ($wordToComplete -like '-*') {
+  $args = @(${argNames.join(', ')})
+${enumBlock}  if ($wordToComplete -like '-*') {
     $args | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
       [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
     }
@@ -366,7 +439,7 @@ ${programName} completion powershell >> $PROFILE`;
  * Generates the completion output with automatic shell detection.
  * If shell is not specified, detects the current shell and provides instructions.
  */
-export function generateCompletionOutput(program: AnyPadroneCommand, shell?: ShellType): string {
+export async function generateCompletionOutput(program: AnyPadroneCommand, shell?: ShellType): Promise<string> {
   const programName = program.name;
 
   if (shell) {
@@ -374,7 +447,7 @@ export function generateCompletionOutput(program: AnyPadroneCommand, shell?: She
   }
 
   // Auto-detect shell and provide instructions
-  const detectedShell = detectShell();
+  const detectedShell = await detectShell();
 
   if (detectedShell) {
     const instructions = getCompletionInstallInstructions(programName, detectedShell);
@@ -419,10 +492,10 @@ export interface SetupCompletionsResult {
  * Sets up shell completions by writing an eval snippet to the appropriate shell config file.
  * Uses marker comments for idempotency — re-running replaces the existing block.
  */
-export function setupCompletions(programName: string, shell: ShellType): SetupCompletionsResult {
-  const { existsSync, mkdirSync, writeFileSync } = require('node:fs') as typeof import('node:fs');
-  const { join } = require('node:path') as typeof import('node:path');
-  const { homedir } = require('node:os') as typeof import('node:os');
+export async function setupCompletions(programName: string, shell: ShellType): Promise<SetupCompletionsResult> {
+  const { existsSync, mkdirSync, writeFileSync } = await import('node:fs');
+  const { join } = await import('node:path');
+  const { homedir } = await import('node:os');
 
   const beginMarker = `###-begin-${programName}-completion-###`;
   const endMarker = `###-end-${programName}-completion-###`;
@@ -437,7 +510,7 @@ export function setupCompletions(programName: string, shell: ShellType): SetupCo
     return { file: filePath, updated: existed };
   }
 
-  const rcFile = getRcFile(shell);
+  const rcFile = await getRcFile(shell);
   if (!rcFile) {
     throw new Error(`Could not determine config file for ${shell}.`);
   }

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

@@ -1,5 +1,6 @@
-import type { InteractivePromptConfig, ResolvedPadroneRuntime } from './runtime.ts';
-import type { AnyPadroneCommand } from './types.ts';
+import { getJsonSchema } from '../core/args.ts';
+import type { InteractivePromptConfig, ResolvedPadroneRuntime } from '../core/runtime.ts';
+import type { AnyPadroneCommand } from '../types/index.ts';
 
 /**
  * Auto-detect the prompt type for a field based on its JSON schema property definition.
@@ -44,6 +45,46 @@ export function detectPromptConfig(
   return { name, message, type: 'input', default: propSchema.default };
 }
 
+/**
+ * Prompt a single field and validate it against the command's schema.
+ * Re-prompts with a warning until the user provides a valid value.
+ */
+async function promptWithValidation(
+  field: string,
+  config: InteractivePromptConfig,
+  currentData: Record<string, unknown>,
+  command: AnyPadroneCommand,
+  runtime: ResolvedPadroneRuntime,
+): Promise<unknown> {
+  let promptConfig = config;
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const value = await runtime.prompt!(promptConfig);
+
+    if (!command.argsSchema) return value;
+
+    // Validate the full object with the new value to catch field-level issues
+    const testData = { ...currentData, [field]: value };
+    const validated = await command.argsSchema['~standard'].validate(testData);
+
+    if (!validated.issues) return value;
+
+    // Only keep issues whose path starts with this field
+    const fieldIssues = validated.issues.filter((issue: { path?: ReadonlyArray<PropertyKey> }) => {
+      const rootKey = issue.path?.[0];
+      return rootKey !== undefined && String(rootKey) === field;
+    });
+
+    if (fieldIssues.length === 0) return value;
+
+    // Warn the user and re-prompt with the invalid value as default
+    const messages = fieldIssues.map((i: { message: string }) => i.message).join('; ');
+    runtime.error(`Invalid value for "${field}": ${messages}`);
+    promptConfig = { ...config, default: value };
+  }
+}
+
 /**
  * Prompt for missing interactive fields.
  * Runs after env/config preprocessing and before schema validation.
@@ -69,7 +110,7 @@ export async function promptInteractiveFields(
   let requiredFields: Set<string> = new Set();
   if (command.argsSchema) {
     try {
-      const jsonSchema = command.argsSchema['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) as Record<string, any>;
+      const jsonSchema = getJsonSchema(command.argsSchema) as Record<string, any>;
       if (jsonSchema.type === 'object' && jsonSchema.properties) {
         jsonProperties = jsonSchema.properties;
       }
@@ -108,14 +149,14 @@ export async function promptInteractiveFields(
     }
   }
 
-  // Prompt each required interactive field
+  // Prompt each required interactive field with per-field validation
   for (const field of fieldsToPrompt) {
     const config = detectPromptConfig(field, jsonProperties[field], fieldDescriptions[field]);
     // When forced, use the current value as the default
     if (force && result[field] !== undefined) {
       config.default = result[field];
     }
-    result[field] = await runtime.prompt(config);
+    result[field] = await promptWithValidation(field, config, result, command, runtime);
   }
 
   // Determine optional interactive fields
@@ -160,7 +201,7 @@ export async function promptInteractiveFields(
         if (force && result[field] !== undefined) {
           config.default = result[field];
         }
-        result[field] = await runtime.prompt(config);
+        result[field] = await promptWithValidation(field, config, result, command, runtime);
       }
     }
   }