padrone 1.1.0 → 1.3.0

package/src/completion.ts

@@ -1,46 +1,8 @@
-import { extractSchemaMetadata } from './options.ts';
+import { extractSchemaMetadata } from './args.ts';
+import { detectShell, getRcFile, type ShellType, writeToRcFile } from './shell-utils.ts';
 import type { AnyPadroneCommand } from './types.ts';
 
-export type ShellType = 'bash' | 'zsh' | 'fish' | 'powershell';
-
-/**
- * Detects the current shell from environment variables and process info.
- * @returns The detected shell type, or undefined if unknown
- */
-export function detectShell(): ShellType | undefined {
-  if (typeof process === 'undefined') return undefined;
-
-  // Method 1: Check SHELL environment variable (most common)
-  const shellEnv = process.env.SHELL || '';
-  if (shellEnv.includes('zsh')) return 'zsh';
-  if (shellEnv.includes('bash')) return 'bash';
-  if (shellEnv.includes('fish')) return 'fish';
-
-  // Method 2: Check Windows-specific shells
-  if (process.env.PSModulePath || process.env.POWERSHELL_DISTRIBUTION_CHANNEL) {
-    return 'powershell';
-  }
-
-  // Method 3: Check parent process on Unix-like systems
-  try {
-    const { execSync } = require('node:child_process');
-    const ppid = process.ppid;
-    if (ppid) {
-      const processName = execSync(`ps -p ${ppid} -o comm=`, {
-        encoding: 'utf-8',
-        stdio: ['pipe', 'pipe', 'ignore'],
-      }).trim();
-
-      if (processName.includes('zsh')) return 'zsh';
-      if (processName.includes('bash')) return 'bash';
-      if (processName.includes('fish')) return 'fish';
-    }
-  } catch {
-    // Ignore errors (e.g., ps not available)
-  }
-
-  return undefined;
-}
+export { detectShell, escapeRegExp, getRcFile, type ShellType, writeToRcFile } from './shell-utils.ts';
 
 /**
  * Collects all commands from a program recursively.
@@ -61,29 +23,29 @@ function collectAllCommands(cmd: AnyPadroneCommand): AnyPadroneCommand[] {
 }
 
 /**
- * Extracts all option names from a command's schema.
+ * Extracts all argument names from a command's schema.
  */
-function extractOptions(cmd: AnyPadroneCommand): { name: string; alias?: string; isBoolean: boolean }[] {
-  const options: { name: string; alias?: string; isBoolean: boolean }[] = [];
+function extractArguments(cmd: AnyPadroneCommand): { name: string; alias?: string; isBoolean: boolean }[] {
+  const argList: { name: string; alias?: string; isBoolean: boolean }[] = [];
 
-  if (!cmd.options) return options;
+  if (!cmd.argsSchema) return argList;
 
   try {
-    const optionsMeta = cmd.meta?.options;
-    const { aliases } = extractSchemaMetadata(cmd.options, optionsMeta);
+    const argsMeta = cmd.meta?.fields;
+    const { aliases } = extractSchemaMetadata(cmd.argsSchema, argsMeta, cmd.meta?.autoAlias);
 
-    // Reverse aliases map (alias -> option name)
-    const aliasToOption: Record<string, string> = {};
-    for (const [opt, alias] of Object.entries(aliases)) {
-      aliasToOption[alias] = opt;
+    // Reverse aliases map (alias -> arg name)
+    const aliasToArgument: Record<string, string> = {};
+    for (const [arg, alias] of Object.entries(aliases)) {
+      aliasToArgument[alias] = arg;
     }
 
-    const jsonSchema = cmd.options['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) as Record<string, any>;
+    const jsonSchema = cmd.argsSchema['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) 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(([opt]) => opt === key)?.[1];
-        options.push({
+        const alias = Object.entries(aliases).find(([arg]) => arg === key)?.[1];
+        argList.push({
           name: key,
           alias: alias,
           isBoolean: prop?.type === 'boolean',
@@ -94,7 +56,7 @@ function extractOptions(cmd: AnyPadroneCommand): { name: string; alias?: string;
     // Ignore schema parsing errors
   }
 
-  return options;
+  return argList;
 }
 
 /**
@@ -105,19 +67,19 @@ export function generateBashCompletion(program: AnyPadroneCommand): string {
   const commands = collectAllCommands(program);
   const commandNames = commands.map((c) => c.name).join(' ');
 
-  // Collect all options from all commands
-  const allOptions = new Set<string>();
-  allOptions.add('--help');
-  allOptions.add('--version');
+  // Collect all args from all commands
+  const allArguments = new Set<string>();
+  allArguments.add('--help');
+  allArguments.add('--version');
 
   for (const cmd of [program, ...commands]) {
-    for (const opt of extractOptions(cmd)) {
-      allOptions.add(`--${opt.name}`);
-      if (opt.alias) allOptions.add(`-${opt.alias}`);
+    for (const arg of extractArguments(cmd)) {
+      allArguments.add(`--${arg.name}`);
+      if (arg.alias) allArguments.add(`-${arg.alias}`);
     }
   }
 
-  const optionsList = Array.from(allOptions).join(' ');
+  const argsList = Array.from(allArguments).join(' ');
 
   return `###-begin-${programName}-completion-###
 #
@@ -141,11 +103,11 @@ if type complete &>/dev/null; then
     prev="\${words[cword-1]}"
 
     local commands="${commandNames}"
-    local options="${optionsList}"
+    local args="${argsList}"
 
-    # Complete options when current word starts with -
+    # Complete args when current word starts with -
     if [[ "$cur" == -* ]]; then
-      COMPREPLY=($(compgen -W "$options" -- "$cur"))
+      COMPREPLY=($(compgen -W "$args" -- "$cur"))
       return 0
     fi
 
@@ -157,10 +119,10 @@ elif type compdef &>/dev/null; then
   _${programName}_completion() {
     local si=$IFS
     local commands="${commandNames}"
-    local options="${optionsList}"
+    local args="${argsList}"
 
     if [[ "\${words[CURRENT]}" == -* ]]; then
-      compadd -- \${=options}
+      compadd -- \${=args}
     else
       compadd -- \${=commands}
     fi
@@ -170,10 +132,10 @@ elif type compdef &>/dev/null; then
 elif type compctl &>/dev/null; then
   _${programName}_completion() {
     local commands="${commandNames}"
-    local options="${optionsList}"
+    local args="${argsList}"
 
     if [[ "\${words[CURRENT]}" == -* ]]; then
-      reply=(\${=options})
+      reply=(\${=args})
     else
       reply=(\${=commands})
     fi
@@ -199,25 +161,25 @@ export function generateZshCompletion(program: AnyPadroneCommand): string {
     })
     .join('\n');
 
-  // Collect all options with descriptions
-  const optionCompletions: string[] = [];
-  optionCompletions.push("      '--help[Show help information]'");
-  optionCompletions.push("      '--version[Show version number]'");
+  // Collect all args with descriptions
+  const argumentCompletions: string[] = [];
+  argumentCompletions.push("      '--help[Show help information]'");
+  argumentCompletions.push("      '--version[Show version number]'");
 
-  const seenOptions = new Set<string>(['help', 'version']);
+  const seenArgs = new Set<string>(['help', 'version']);
 
   for (const cmd of [program, ...commands]) {
-    for (const opt of extractOptions(cmd)) {
-      if (seenOptions.has(opt.name)) continue;
-      seenOptions.add(opt.name);
+    for (const arg of extractArguments(cmd)) {
+      if (seenArgs.has(arg.name)) continue;
+      seenArgs.add(arg.name);
 
-      const desc = cmd.meta?.options?.[opt.name]?.description || '';
+      const desc = cmd.meta?.fields?.[arg.name]?.description || '';
       const escapedDesc = desc.replace(/'/g, "'\\''").replace(/\[/g, '\\[').replace(/\]/g, '\\]');
 
-      if (opt.alias) {
-        optionCompletions.push(`      {-${opt.alias},--${opt.name}}'[${escapedDesc}]'`);
+      if (arg.alias) {
+        argumentCompletions.push(`      {-${arg.alias},--${arg.name}}'[${escapedDesc}]'`);
       } else {
-        optionCompletions.push(`      '--${opt.name}[${escapedDesc}]'`);
+        argumentCompletions.push(`      '--${arg.name}[${escapedDesc}]'`);
       }
     }
   }
@@ -233,18 +195,18 @@ export function generateZshCompletion(program: AnyPadroneCommand): string {
 
 _${programName}() {
   local -a commands
-  local -a options
+  local -a args
 
   commands=(
 ${commandCompletions}
   )
 
-  options=(
-${optionCompletions.join('\n')}
+  args=(
+${argumentCompletions.join('\n')}
   )
 
   _arguments -s \\
-    $options \\
+    $args \\
     '1: :->command' \\
     '*::arg:->args'
 
@@ -287,24 +249,24 @@ export function generateFishCompletion(program: AnyPadroneCommand): string {
   }
 
   lines.push('');
-  lines.push('# Global options');
+  lines.push('# Global arguments');
   lines.push(`complete -c ${programName} -l help -d 'Show help information'`);
   lines.push(`complete -c ${programName} -l version -d 'Show version number'`);
 
-  const seenOptions = new Set<string>(['help', 'version']);
+  const seenArgs = new Set<string>(['help', 'version']);
 
   for (const cmd of [program, ...commands]) {
-    for (const opt of extractOptions(cmd)) {
-      if (seenOptions.has(opt.name)) continue;
-      seenOptions.add(opt.name);
+    for (const arg of extractArguments(cmd)) {
+      if (seenArgs.has(arg.name)) continue;
+      seenArgs.add(arg.name);
 
-      const desc = cmd.meta?.options?.[opt.name]?.description || '';
+      const desc = cmd.meta?.fields?.[arg.name]?.description || '';
       const escapedDesc = desc.replace(/'/g, "\\'");
 
-      if (opt.alias) {
-        lines.push(`complete -c ${programName} -s ${opt.alias} -l ${opt.name} -d '${escapedDesc}'`);
+      if (arg.alias) {
+        lines.push(`complete -c ${programName} -s ${arg.alias} -l ${arg.name} -d '${escapedDesc}'`);
       } else {
-        lines.push(`complete -c ${programName} -l ${opt.name} -d '${escapedDesc}'`);
+        lines.push(`complete -c ${programName} -l ${arg.name} -d '${escapedDesc}'`);
       }
     }
   }
@@ -334,10 +296,10 @@ Register-ArgumentCompleter -Native -CommandName ${programName} -ScriptBlock {
   param($wordToComplete, $commandAst, $cursorPosition)
 
   $commands = @(${commandNames})
-  $options = @('--help', '--version')
+  $args = @('--help', '--version')
 
   if ($wordToComplete -like '-*') {
-    $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+    $args | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
       [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
     }
   } else {
@@ -445,3 +407,54 @@ ${script}`;
 #   ${programName} completion fish > ~/.config/fish/completions/${programName}.fish
 #   ${programName} completion powershell >> $PROFILE`;
 }
+
+export interface SetupCompletionsResult {
+  /** The file that was written to. */
+  file: string;
+  /** Whether an existing completion block was replaced (true) or a new one was appended (false). */
+  updated: boolean;
+}
+
+/**
+ * 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');
+
+  const beginMarker = `###-begin-${programName}-completion-###`;
+  const endMarker = `###-end-${programName}-completion-###`;
+  const snippet = buildSetupSnippet(programName, shell, beginMarker, endMarker);
+
+  if (shell === 'fish') {
+    const completionsDir = join(homedir(), '.config', 'fish', 'completions');
+    const filePath = join(completionsDir, `${programName}.fish`);
+    mkdirSync(completionsDir, { recursive: true });
+    const existed = existsSync(filePath);
+    writeFileSync(filePath, `${snippet}\n`);
+    return { file: filePath, updated: existed };
+  }
+
+  const rcFile = getRcFile(shell);
+  if (!rcFile) {
+    throw new Error(`Could not determine config file for ${shell}.`);
+  }
+
+  return writeToRcFile(rcFile, snippet, beginMarker, endMarker);
+}
+
+function buildSetupSnippet(programName: string, shell: ShellType, beginMarker: string, endMarker: string): string {
+  const evalCmd = `${programName} completion ${shell}`;
+
+  switch (shell) {
+    case 'bash':
+    case 'zsh':
+      return `${beginMarker}\neval "$(${evalCmd})"\n${endMarker}`;
+    case 'fish':
+      return `${beginMarker}\n${evalCmd} | source\n${endMarker}`;
+    case 'powershell':
+      return `${beginMarker}\n${evalCmd} | Invoke-Expression\n${endMarker}`;
+  }
+}