clean bun handler

Author: AmirSa12

bin/handlers/bun-handler.ts

@@ -8,7 +8,6 @@ import {
   setupCommandArguments,
   safeExec,
   safeExecSync,
-  // createLogLevelHandler,
 } from '../utils/shared.js';
 
 const COMMANDS_SECTION_RE = /^Commands:\s*$/i;
@@ -22,39 +21,51 @@ const CONTINUATION_COMMAND_RE = /^\s{12,}([a-z][a-z0-9-]*)\s+(.+)$/;
 const EMPTY_LINE_FOLLOWED_BY_NON_COMMAND_RE = /^\s+[a-z]/;
 const DESCRIPTION_SPLIT_RE = /\s{2,}/;
 const CAPITAL_LETTER_START_RE = /^[A-Z]/;
+const LINE_SPLIT_RE = /\r?\n/;
+
+function toLines(text: string): string[] {
+  return stripAnsiEscapes(text).split(LINE_SPLIT_RE);
+}
+
+function findSectionStart(lines: string[], header: RegExp): number {
+  for (let i = 0; i < lines.length; i++) {
+    if (header.test(lines[i].trim())) return i + 1;
+  }
+  return -1;
+}
 
 const bunOptionHandlers: OptionHandlers = {
   ...commonOptionHandlers,
 
-  silent: function (complete) {
+  silent(complete) {
     complete('true', 'Enable silent mode');
     complete('false', 'Disable silent mode');
   },
 
-  backend: function (complete) {
+  backend(complete) {
     complete('clonefile', 'Clone files (default, fastest)');
     complete('hardlink', 'Use hard links');
     complete('symlink', 'Use symbolic links');
     complete('copyfile', 'Copy files');
   },
 
-  linker: function (complete) {
+  linker(complete) {
     complete('isolated', 'Isolated linker strategy');
     complete('hoisted', 'Hoisted linker strategy');
   },
 
-  omit: function (complete) {
+  omit(complete) {
     complete('dev', 'Omit devDependencies');
     complete('optional', 'Omit optionalDependencies');
     complete('peer', 'Omit peerDependencies');
   },
 
-  shell: function (complete) {
+  shell(complete) {
     complete('bun', 'Use Bun shell');
     complete('system', 'Use system shell');
   },
 
-  'unhandled-rejections': function (complete) {
+  'unhandled-rejections'(complete) {
     complete('strict', 'Strict unhandled rejection handling');
     complete('throw', 'Throw on unhandled rejections');
     complete('warn', 'Warn on unhandled rejections');
@@ -63,61 +74,54 @@ const bunOptionHandlers: OptionHandlers = {
   },
 };
 
+/** ---------- Commands ---------- */
 export function parseBunHelp(helpText: string): Record<string, string> {
-  const helpLines = stripAnsiEscapes(helpText).split(/\r?\n/);
-
-  let startIndex = -1;
-  for (let i = 0; i < helpLines.length; i++) {
-    if (COMMANDS_SECTION_RE.test(helpLines[i].trim())) {
-      startIndex = i + 1;
-      break;
-    }
-  }
+  const lines = toLines(helpText);
 
+  const startIndex = findSectionStart(lines, COMMANDS_SECTION_RE);
   if (startIndex === -1) return {};
 
   const commands: Record<string, string> = {};
 
-  // parse bun's unique command format
-  for (let i = startIndex; i < helpLines.length; i++) {
-    const line = helpLines[i];
+  for (let i = startIndex; i < lines.length; i++) {
+    const line = lines[i];
 
     // stop when we hit Flags section or empty line followed by non-command content
     if (
       FLAGS_SECTION_RE.test(line.trim()) ||
       (line.trim() === '' &&
-        i + 1 < helpLines.length &&
-        !helpLines[i + 1].match(EMPTY_LINE_FOLLOWED_BY_NON_COMMAND_RE))
-    )
+        i + 1 < lines.length &&
+        !lines[i + 1].match(EMPTY_LINE_FOLLOWED_BY_NON_COMMAND_RE))
+    ) {
       break;
+    }
 
-    // Skip empty lines
-    if (line.trim() === '') continue;
+    if (!line.trim()) continue;
 
-    const mainCommandMatch = line.match(MAIN_COMMAND_RE);
-    if (mainCommandMatch) {
-      const [, command, rest] = mainCommandMatch;
+    // main command row
+    const main = line.match(MAIN_COMMAND_RE);
+    if (main) {
+      const [, command, rest] = main;
       if (COMMAND_VALIDATION_RE.test(command)) {
         const parts = rest.split(DESCRIPTION_SPLIT_RE);
-        let description = parts[parts.length - 1];
+        let desc = parts[parts.length - 1];
 
-        // If the last part starts with  capital letter, it's likely the description
-        if (description && CAPITAL_LETTER_START_RE.test(description)) {
-          commands[command] = description.trim();
+        if (desc && CAPITAL_LETTER_START_RE.test(desc)) {
+          commands[command] = desc.trim();
         } else if (parts.length > 1) {
-          for (const part of parts) {
-            if (CAPITAL_LETTER_START_RE.test(part)) {
-              commands[command] = part.trim();
+          for (const p of parts) {
+            if (CAPITAL_LETTER_START_RE.test(p)) {
+              commands[command] = p.trim();
               break;
             }
           }
         }
       }
     }
 
-    const continuationMatch = line.match(CONTINUATION_COMMAND_RE);
-    if (continuationMatch) {
-      const [, command, description] = continuationMatch;
+    const cont = line.match(CONTINUATION_COMMAND_RE);
+    if (cont) {
+      const [, command, description] = cont;
       if (COMMAND_VALIDATION_RE.test(command)) {
         commands[command] = description.trim();
       }
@@ -134,90 +138,63 @@ export async function getBunCommandsFromMainHelp(): Promise<
   return output ? parseBunHelp(output) : {};
 }
 
-// Parse bun options from help text
 export function parseBunOptions(
   helpText: string,
   { flagsOnly = true }: { flagsOnly?: boolean } = {}
 ): ParsedOption[] {
-  const helpLines = stripAnsiEscapes(helpText).split(/\r?\n/);
-  const optionsOut: ParsedOption[] = [];
-
-  // Find the Flags: section
-  let optionsStartIndex = -1;
-  for (let i = 0; i < helpLines.length; i++) {
-    if (FLAGS_SECTION_RE.test(helpLines[i].trim())) {
-      optionsStartIndex = i + 1;
-      break;
-    }
-  }
-
-  if (optionsStartIndex === -1) return [];
+  const lines = toLines(helpText);
+  const out: ParsedOption[] = [];
 
-  // Parse bun's flag format
-  for (let i = optionsStartIndex; i < helpLines.length; i++) {
-    const line = helpLines[i];
+  const start = findSectionStart(lines, FLAGS_SECTION_RE);
+  if (start === -1) return out;
 
-    // Stop at examples or other sections
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i];
     if (SECTION_END_RE.test(line.trim())) break;
 
-    // Parse option lines like: "  -c, --config=<val>                 Specify path to config file"
-    const optionMatch = line.match(BUN_OPTION_RE);
+    const m = line.match(BUN_OPTION_RE);
+    if (!m) continue;
 
-    if (optionMatch) {
-      const [, short, long, desc] = optionMatch;
+    const [, short, long, desc] = m;
+    const takesValue = line.includes('=<'); // bun shows value as --opt=<val>
+    if (flagsOnly && takesValue) continue;
 
-      // Check if this option takes a value (has =<val>)
-      const takesValue = line.includes('=<');
-
-      if (flagsOnly && takesValue) continue;
-
-      optionsOut.push({
-        short: short || undefined,
-        long,
-        desc: desc.trim(),
-      });
-    }
+    out.push({
+      short: short || undefined,
+      long,
+      desc: desc.trim(),
+    });
   }
 
-  return optionsOut;
+  return out;
 }
 
-// load dynamic options synchronously when requested
 function loadBunOptionsSync(cmd: LazyCommand, command: string): void {
   const output = safeExecSync(`bun ${command} --help`);
   if (!output) return;
 
-  const allOptions = parseBunOptions(output, { flagsOnly: false });
+  const options = parseBunOptions(output, { flagsOnly: false });
 
-  for (const { long, short, desc } of allOptions) {
-    const alreadyDefined = cmd.optionsRaw?.get?.(long);
-    if (!alreadyDefined) {
-      const handler = bunOptionHandlers[long];
-      if (handler) {
-        cmd.option(long, desc, handler, short);
-      } else {
-        cmd.option(long, desc, short);
-      }
-    }
+  for (const { long, short, desc } of options) {
+    const exists = cmd.optionsRaw?.get?.(long);
+    if (exists) continue;
+
+    const handler = bunOptionHandlers[long];
+    if (handler) cmd.option(long, desc, handler, short);
+    else cmd.option(long, desc, short);
   }
 }
 
 export async function setupBunCompletions(
   completion: PackageManagerCompletion
 ): Promise<void> {
   try {
-    const commandsWithDescriptions = await getBunCommandsFromMainHelp();
-
-    for (const [command, description] of Object.entries(
-      commandsWithDescriptions
-    )) {
-      const cmd = completion.command(command, description);
-
-      // Setup common argument patterns
-      setupCommandArguments(cmd, command, 'bun');
+    const commands = await getBunCommandsFromMainHelp();
 
-      // Setup lazy option loading
-      setupLazyOptionLoading(cmd, command, 'bun', loadBunOptionsSync);
+    for (const [command, description] of Object.entries(commands)) {
+      const c = completion.command(command, description);
+      setupCommandArguments(c, command, 'bun');
+      setupLazyOptionLoading(c, command, 'bun', loadBunOptionsSync);
     }
-  } catch (_err) {}
+  } catch {}
 }