move the package manager completion logic directly into the parse method

Author: AmirSa12

bin/completion-handlers.ts

@@ -71,80 +71,13 @@ export function setupCompletionForPackageManager(
     setupBunCompletions(completion);
   }
 
-  completion.onBeforeParse(async (args: string[]) => {
-    debugLog(`onBeforeParse: args =`, args);
-
-    if (args.length >= 1) {
-      const potentialCliName = args[0];
-      const knownCommands = [...completion.commands.keys()];
-
-      debugLog(
-        `Potential CLI: ${potentialCliName}, Known commands:`,
-        knownCommands
-      );
-
-      if (knownCommands.includes(potentialCliName)) {
-        debugLog(`${potentialCliName} is a known command, skipping CLI check`);
-        return;
-      }
-
-      const hasCompletions = await checkCliHasCompletions(
-        potentialCliName,
-        packageManager
-      );
-      if (hasCompletions) {
-        debugLog(
-          `${potentialCliName} supports completions, getting suggestions`
-        );
-
-        const cliArgs = args.slice(1);
-        const suggestions = await getCliCompletions(
-          potentialCliName,
-          packageManager,
-          cliArgs
-        );
-
-        if (suggestions.length > 0) {
-          debugLog(`Processing ${suggestions.length} suggestions`);
-
-          completion.result.suppressDefault = true;
-
-          for (const suggestion of suggestions) {
-            if (suggestion.startsWith(':')) {
-              debugLog(`Skipping directive: ${suggestion}`);
-              continue;
-            }
-
-            if (suggestion.includes('\t')) {
-              const [value, description] = suggestion.split('\t');
-              debugLog(
-                `Adding completion with description: ${value} -> ${description}`
-              );
-              completion.result.items.push({ value, description });
-            } else {
-              debugLog(`Adding completion without description: ${suggestion}`);
-              completion.result.items.push({ value: suggestion });
-            }
-          }
-        } else {
-          debugLog(`No suggestions found for ${potentialCliName}`);
-        }
-      } else {
-        debugLog(`${potentialCliName} does not support completions`);
-      }
-    }
-  });
+  completion.setPackageManager(packageManager);
 }
 
 export function setupPnpmCompletions(completion: Completion) {
   completion.addCommand('add', 'Install a package', [], async () => []);
   completion.addCommand('remove', 'Remove a package', [], async () => []);
-  completion.addCommand(
-    'install',
-    'Install all dependencies',
-    [],
-    async () => []
-  );
+  completion.addCommand('install', 'Install all dependencies', [], async () => []);
   completion.addCommand('update', 'Update packages', [], async () => []);
   completion.addCommand('exec', 'Execute a command', [], async () => []);
   completion.addCommand('run', 'Run a script', [], async () => []);

src/index.ts

@@ -2,6 +2,63 @@ import * as zsh from './zsh';
 import * as bash from './bash';
 import * as fish from './fish';
 import * as powershell from './powershell';
+import { execSync } from 'child_process';
+
+const DEBUG = false;
+
+function debugLog(...args: any[]) {
+  if (DEBUG) {
+    console.error('[DEBUG]', ...args);
+  }
+}
+
+async function checkCliHasCompletions(
+  cliName: string,
+  packageManager: string
+): Promise<boolean> {
+  try {
+    debugLog(`Checking if ${cliName} has completions via ${packageManager}`);
+    const command = `${packageManager} ${cliName} complete --`;
+    const result = execSync(command, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+      timeout: 1000,
+    });
+    const hasCompletions = !!result.trim();
+    debugLog(`${cliName} supports completions: ${hasCompletions}`);
+    return hasCompletions;
+  } catch (error) {
+    debugLog(`Error checking completions for ${cliName}:`, error);
+    return false;
+  }
+}
+
+async function getCliCompletions(
+  cliName: string,
+  packageManager: string,
+  args: string[]
+): Promise<string[]> {
+  try {
+    const completeArgs = args.map((arg) =>
+      arg.includes(' ') ? `"${arg}"` : arg
+    );
+    const completeCommand = `${packageManager} ${cliName} complete -- ${completeArgs.join(' ')}`;
+    debugLog(`Getting completions with command: ${completeCommand}`);
+
+    const result = execSync(completeCommand, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+      timeout: 1000,
+    });
+
+    const completions = result.trim().split('\n').filter(Boolean);
+    debugLog(`Got ${completions.length} completions from ${cliName}`);
+    return completions;
+  } catch (error) {
+    debugLog(`Error getting completions from ${cliName}:`, error);
+    return [];
+  }
+}
 
 // ShellCompRequestCmd is the name of the hidden command that is used to request
 // completion results from the program. It is used by the shell completion scripts.
@@ -97,10 +154,10 @@ export class Completion {
   completions: Item[] = [];
   directive = ShellCompDirective.ShellCompDirectiveDefault;
   result: CompletionResult = { items: [], suppressDefault: false };
-  private beforeParseFn: ((args: string[]) => Promise<void>) | null = null;
+  private packageManager: string | null = null;
 
-  onBeforeParse(fn: (args: string[]) => Promise<void>) {
-    this.beforeParseFn = fn;
+  setPackageManager(packageManager: string) {
+    this.packageManager = packageManager;
   }
 
   // vite <entry> <another> [...files]
@@ -184,12 +241,44 @@ export class Completion {
   async parse(args: string[]) {
     this.result = { items: [], suppressDefault: false };
 
-    if (this.beforeParseFn) {
-      await this.beforeParseFn(args);
-      if (this.result.suppressDefault && this.result.items.length > 0) {
-        this.completions = this.result.items;
-        this.complete('');
-        return;
+    // Handle package manager completions first
+    if (this.packageManager && args.length >= 1) {
+      const potentialCliName = args[0];
+      const knownCommands = [...this.commands.keys()];
+
+      if (!knownCommands.includes(potentialCliName)) {
+        const hasCompletions = await checkCliHasCompletions(
+          potentialCliName,
+          this.packageManager
+        );
+
+        if (hasCompletions) {
+          const cliArgs = args.slice(1);
+          const suggestions = await getCliCompletions(
+            potentialCliName,
+            this.packageManager,
+            cliArgs
+          );
+
+          if (suggestions.length > 0) {
+            this.result.suppressDefault = true;
+
+            for (const suggestion of suggestions) {
+              if (suggestion.startsWith(':')) continue;
+
+              if (suggestion.includes('\t')) {
+                const [value, description] = suggestion.split('\t');
+                this.result.items.push({ value, description });
+              } else {
+                this.result.items.push({ value: suggestion });
+              }
+            }
+
+            this.completions = this.result.items;
+            this.complete('');
+            return;
+          }
+        }
       }
     }