fix: migrate post-rebase inquirer call sites to node:readline prompts

Author: sacOO7

src/commands/accounts/switch.ts

@@ -1,11 +1,14 @@
 import { Args } from "@oclif/core";
 import chalk from "chalk";
-import inquirer from "inquirer";
 
 import { ControlBaseCommand } from "../../control-base-command.js";
 import { endpointFlag } from "../../flags.js";
 import { type AccountSummary } from "../../services/control-api.js";
 import { formatResource } from "../../utils/output.js";
+import {
+  promptForSelection,
+  type SelectionChoice,
+} from "../../utils/prompt-selection.js";
 import { pickUniqueAlias, slugifyAccountName } from "../../utils/slugify.js";
 
 export default class AccountsSwitch extends ControlBaseCommand {
@@ -120,18 +123,15 @@ export default class AccountsSwitch extends ControlBaseCommand {
     // Remote accounts not already configured locally
     const remoteOnly = remoteAccounts.filter((r) => !localAccountIds.has(r.id));
 
-    type Choice = {
-      name: string;
-      value:
-        | { type: "local"; alias: string }
-        | { type: "remote"; account: AccountSummary };
-    };
+    type SelectedAccount =
+      | { type: "local"; alias: string }
+      | { type: "remote"; account: AccountSummary };
 
-    const choices: Array<Choice | inquirer.Separator> = [];
+    const choices: Array<SelectionChoice<SelectedAccount>> = [];
 
     // Local accounts section
     if (localAccounts.length > 0) {
-      choices.push(new inquirer.Separator("── Local accounts ──"));
+      choices.push({ separator: "── Local accounts ──" });
       for (const { account, alias } of localAccounts) {
         const isCurrent = alias === currentAlias;
         const name = account.accountName || account.accountId || "Unknown";
@@ -142,9 +142,9 @@ export default class AccountsSwitch extends ControlBaseCommand {
 
     // Remote-only accounts section
     if (remoteOnly.length > 0) {
-      choices.push(
-        new inquirer.Separator("── Other accounts (no login required) ──"),
-      );
+      choices.push({
+        separator: "── Other accounts (no login required) ──",
+      });
       for (const account of remoteOnly) {
         const label = `  ${account.name} ${chalk.dim(`(${account.id})`)}`;
         choices.push({ name: label, value: { type: "remote", account } });
@@ -156,18 +156,11 @@ export default class AccountsSwitch extends ControlBaseCommand {
       return false;
     }
 
-    const { selected } = (await inquirer.prompt([
-      {
-        choices,
-        message: "Select an account:",
-        name: "selected",
-        type: "list",
-      },
-    ])) as {
-      selected:
-        | { type: "local"; alias: string }
-        | { type: "remote"; account: AccountSummary };
-    };
+    const selected = await promptForSelection("Select an account:", choices);
+
+    if (!selected) {
+      return false;
+    }
 
     if (selected.type === "local") {
       await this.switchToLocalAccount(selected.alias, flags);

src/services/interactive-helper.ts

@@ -71,19 +71,12 @@ export class InteractiveHelper {
         return null;
       }
 
-      const { selectedAccount } = (await inquirer.prompt([
-        {
-          choices: accounts.map((account) => ({
-            name: `${account.name} (${account.id})`,
-            value: account,
-          })),
-          message: "Select an account:",
-          name: "selectedAccount",
-          type: "list",
-        },
-      ])) as { selectedAccount: AccountSummary };
-
-      return selectedAccount;
+      const choices = accounts.map((account) => ({
+        name: `${account.name} (${account.id})`,
+        value: account,
+      }));
+
+      return await promptForSelection("Select an account:", choices);
     } catch (error) {
       if (this.logErrors) {
         this.log(

src/utils/prompt-confirmation.ts

@@ -38,9 +38,7 @@ export function promptForConfirmation(
     const finish = (result: boolean) => {
       if (settled) return;
       settled = true;
-      if (!rl.closed) {
-        rl.close();
-      }
+      rl.close();
       resolve(result);
     };
 

src/utils/prompt-selection.ts

@@ -1,20 +1,39 @@
 import * as readline from "node:readline";
 
+/**
+ * A choice item is either selectable (has a value) or a separator (header line, not selectable).
+ */
+export type SelectionChoice<T> =
+  | { name: string; value: T }
+  | { separator: string };
+
+function isSeparator<T>(
+  choice: SelectionChoice<T>,
+): choice is { separator: string } {
+  return "separator" in choice;
+}
+
 /**
  * Prompts the user to select an item from a numbered list.
  * Displays choices as "[1] Choice one", "[2] Choice two", etc.
+ * Separator entries render as un-numbered header lines and cannot be selected.
  * Re-prompts on invalid input (out-of-range, non-numeric).
- * Returns null if the user enters empty input, stdin closes, or choices is empty.
+ * Returns null if the user enters empty input, stdin closes, the choices list
+ * has no selectable entries, or SIGINT is received.
  *
  * @param message - The prompt message displayed above the list
- * @param choices - Array of { name, value } pairs (same format as inquirer list choices)
+ * @param choices - Array of selectable items or separators
  * @returns Promise<T | null> - The selected item's value, or null if cancelled
  */
 export function promptForSelection<T>(
   message: string,
-  choices: Array<{ name: string; value: T }>,
+  choices: Array<SelectionChoice<T>>,
 ): Promise<T | null> {
-  if (choices.length === 0) {
+  const selectable = choices.filter(
+    (c): c is { name: string; value: T } => !isSeparator(c),
+  );
+
+  if (selectable.length === 0) {
     return Promise.resolve(null);
   }
 
@@ -23,10 +42,18 @@ export function promptForSelection<T>(
     output: process.stdout,
   });
 
-  // Display the list
+  // Display the list. Selectable items get sequential numbers; separators render as plain
+  // headers with a single leading space (matches inquirer's separator rendering in
+  // @inquirer/select, which prints ` ${separator}` so headers visually outdent from items).
   rl.write(`${message}\n`);
-  for (let i = 0; i < choices.length; i++) {
-    rl.write(`  [${i + 1}] ${choices[i]!.name}\n`);
+  let index = 0;
+  for (const choice of choices) {
+    if (isSeparator(choice)) {
+      rl.write(` ${choice.separator}\n`);
+    } else {
+      index += 1;
+      rl.write(`  [${index}] ${choice.name}\n`);
+    }
   }
 
   return new Promise<T | null>((resolve) => {
@@ -35,9 +62,7 @@ export function promptForSelection<T>(
     const finish = (result: T | null) => {
       if (settled) return;
       settled = true;
-      if (!rl.closed) {
-        rl.close();
-      }
+      rl.close();
       resolve(result);
     };
 
@@ -62,7 +87,7 @@ export function promptForSelection<T>(
         // Require the entire input to be a base-10 integer string
         if (!/^\d+$/.test(trimmed)) {
           rl.write(
-            `Invalid selection. Enter a number between 1 and ${choices.length}.\n`,
+            `Invalid selection. Enter a number between 1 and ${selectable.length}.\n`,
           );
           ask();
           return;
@@ -71,15 +96,15 @@ export function promptForSelection<T>(
         const num = Number.parseInt(trimmed, 10);
 
         // Out of range → re-prompt
-        if (num < 1 || num > choices.length) {
+        if (num < 1 || num > selectable.length) {
           rl.write(
-            `Invalid selection. Enter a number between 1 and ${choices.length}.\n`,
+            `Invalid selection. Enter a number between 1 and ${selectable.length}.\n`,
           );
           ask();
           return;
         }
 
-        finish(choices[num - 1]!.value);
+        finish(selectable[num - 1]!.value);
       });
     };
 

test/unit/hooks/interactive-did-you-mean.test.ts

@@ -290,10 +290,7 @@ describe("Did You Mean Hook - Interactive Mode", function () {
         expect(mockReadline.removeAllListeners).toHaveBeenCalledWith("line");
         expect(mockReadline.on.mock.calls.length).toBe(lineListeners.length);
         lineListeners.forEach((listener, index) => {
-          expect(mockReadline.on.mock.calls[index]).toEqual([
-            "line",
-            listener,
-          ]);
+          expect(mockReadline.on.mock.calls[index]).toEqual(["line", listener]);
         });
 
         // Verify terminal state was restored

test/unit/utils/prompt-selection.test.ts

@@ -187,4 +187,78 @@ describe("promptForSelection", () => {
     const result = await promptForSelection("Select:", choices);
     expect(result).toBeNull();
   });
+
+  describe("separators", () => {
+    it("renders separator entries un-numbered with single-space prefix", async () => {
+      mockQuestion = (_query, callback) => callback("1");
+      await promptForSelection("Select an account:", [
+        { separator: "── Local accounts ──" },
+        { name: "prod", value: "prod" },
+        { name: "staging", value: "staging" },
+        { separator: "── Other accounts ──" },
+        { name: "external", value: "external" },
+      ]);
+
+      // Separators: single leading space, no [N] marker (matches inquirer's render)
+      expect(mockWrite).toHaveBeenCalledWith(" ── Local accounts ──\n");
+      expect(mockWrite).toHaveBeenCalledWith(" ── Other accounts ──\n");
+      // Selectable items numbered sequentially, ignoring separators
+      expect(mockWrite).toHaveBeenCalledWith("  [1] prod\n");
+      expect(mockWrite).toHaveBeenCalledWith("  [2] staging\n");
+      expect(mockWrite).toHaveBeenCalledWith("  [3] external\n");
+    });
+
+    it("numbers only selectable items so '1' picks the first selectable", async () => {
+      mockQuestion = (_query, callback) => callback("1");
+      const result = await promptForSelection<string>("Pick:", [
+        { separator: "── Section ──" },
+        { name: "first", value: "first" },
+        { name: "second", value: "second" },
+      ]);
+      expect(result).toBe("first");
+    });
+
+    it("rejects out-of-range numbers based on selectable count, not total entries", async () => {
+      // 2 selectables + 2 separators = 4 entries. "3" must be rejected.
+      let callCount = 0;
+      mockQuestion = (_query, callback) => {
+        callCount++;
+        if (callCount === 1) {
+          callback("3");
+        } else {
+          callback("2");
+        }
+      };
+      const result = await promptForSelection<string>("Pick:", [
+        { separator: "── A ──" },
+        { name: "first", value: "first" },
+        { separator: "── B ──" },
+        { name: "second", value: "second" },
+      ]);
+      expect(result).toBe("second");
+      expect(callCount).toBe(2);
+      expect(mockWrite).toHaveBeenCalledWith(
+        "Invalid selection. Enter a number between 1 and 2.\n",
+      );
+    });
+
+    it("returns null when choices contain only separators (no selectables)", async () => {
+      const result = await promptForSelection("Pick:", [
+        { separator: "── A ──" },
+        { separator: "── B ──" },
+      ]);
+      expect(result).toBeNull();
+      expect(mockWrite).not.toHaveBeenCalled();
+    });
+
+    it("supports separators interleaved at any position", async () => {
+      mockQuestion = (_query, callback) => callback("2");
+      const result = await promptForSelection<string>("Pick:", [
+        { name: "alpha", value: "alpha" },
+        { separator: "── divider ──" },
+        { name: "beta", value: "beta" },
+      ]);
+      expect(result).toBe("beta");
+    });
+  });
 });