@tyvm/knowhow 0.0.60 → 0.0.62

package/src/utils/InputQueueManager.ts

@@ -12,7 +12,9 @@ type AskOptions = {
 
 export class InputQueueManager {
   private stack: AskOptions[] = [];
-  private rl: readline.Interface | null = null;
+  private static instance: InputQueueManager | null = null;
+  private static rl: readline.Interface | null = null;
+  private static keypressListenerSetup = false;
 
   // We keep one "live" buffer shared across stacked questions
   // (so typing is preserved when questions change)
@@ -31,6 +33,11 @@ export class InputQueueManager {
   // This allows CliChatService to update inputHistory immediately
   private onNewEntry?: OnNewHistoryEntry;
 
+  constructor() {
+    // Store the current instance as the singleton
+    InputQueueManager.instance = this;
+  }
+
   /**
    * Set a callback to be notified when user enters a new history entry.
    * This allows the caller to update their history source immediately.
@@ -40,9 +47,9 @@ export class InputQueueManager {
   }
 
   private ensureRl(): readline.Interface {
-    if (this.rl) return this.rl;
+    if (InputQueueManager.rl) return InputQueueManager.rl;
 
-    this.rl = readline.createInterface({
+    InputQueueManager.rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
       terminal: true,
@@ -74,7 +81,7 @@ export class InputQueueManager {
     });
 
     // When user presses Enter, buffer the line for paste detection
-    this.rl.on("line", (line) => {
+    InputQueueManager.rl.on("line", (line) => {
       const current = this.peek();
       if (!current) return;
 
@@ -84,25 +91,32 @@ export class InputQueueManager {
         // Already in paste mode, add to buffer
         this.pasteBuffer.push(line);
         clearTimeout(this.pasteTimeout);
-        this.pasteTimeout = setTimeout(() => this.flushPasteBuffer(), this.PASTE_DELAY_MS);
+        this.pasteTimeout = setTimeout(
+          () => this.flushPasteBuffer(),
+          this.PASTE_DELAY_MS
+        );
         return;
       }
 
       // Start paste detection mode - buffer this line and wait to see if more come
       this.pasteBuffer.push(line);
-      this.pasteTimeout = setTimeout(() => this.flushPasteBuffer(), this.PASTE_DELAY_MS);
+      this.pasteTimeout = setTimeout(
+        () => this.flushPasteBuffer(),
+        this.PASTE_DELAY_MS
+      );
     });
 
-    this.rl.on("close", () => {
+    InputQueueManager.rl.on("close", () => {
       // Flush any remaining paste buffer on close
       if (this.pasteTimeout) {
         clearTimeout(this.pasteTimeout);
         this.flushPasteBuffer();
+        this.historyIndex = -1;
       }
     });
 
     // Handle Ctrl+C (readline SIGINT)
-    this.rl.on("SIGINT", () => {
+    InputQueueManager.rl.on("SIGINT", () => {
       // If there's an active question, cancel it (like Esc)
       if (this.stack.length > 0) {
         const cancelled = this.stack.pop();
@@ -120,91 +134,98 @@ export class InputQueueManager {
 
     // Capture keypresses for ESC + history nav while still using readline.
     // Tab is handled by rl completer.
-    readline.emitKeypressEvents(process.stdin);
-    if (process.stdin.isTTY) process.stdin.setRawMode(true);
-
-    process.stdin.on("keypress", (_str, key) => {
-      // Handle Ctrl+C in raw mode (some terminals deliver this here instead of SIGINT)
-      if (key?.ctrl && key?.name === "c") {
-        if (this.stack.length > 0) {
-          const cancelled = this.stack.pop();
-          cancelled?.resolve("");
-          this.currentLine = "";
-        }
-        this.close();
-        process.exit(0);
-      }
-
-      // If RL is closed or nothing to ask, ignore
-      if (!this.rl || this.stack.length === 0) return;
-
-      // Keep our buffer in sync with readline's live line
-      this.syncFromReadline();
-
-      // Any "real typing" should exit history mode
-      // (we'll treat left/right as not exiting; you can tweak)
-      const exitsHistoryMode =
-        key &&
-        (key.name === "return" ||
-          key.name === "enter" ||
-          key.name === "backspace" ||
-          (key.sequence &&
-            key.sequence.length === 1 &&
-            !key.ctrl &&
-            !key.meta));
-      if (exitsHistoryMode && this.historyIndex !== -1) {
-        this.historyIndex = -1;
-        this.savedLineBeforeHistory = "";
-      }
-
-      // Custom Up/Down history navigation using only passed-in history
-      if (key?.name === "up") {
-        const history = this.getHistory();
-        if (history.length === 0) return;
-
-        if (this.historyIndex === -1) {
-          // entering history mode: remember current typed text
-          this.savedLineBeforeHistory = this.currentLine;
+    // Only set up keypress listener once to avoid multiple handlers
+    if (!InputQueueManager.keypressListenerSetup) {
+      InputQueueManager.keypressListenerSetup = true;
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+      process.stdin.on("keypress", (_str, key) => {
+        // Handle Ctrl+C in raw mode (some terminals deliver this here instead of SIGINT)
+        const instance = InputQueueManager.instance;
+        if (!instance) return;
+
+        if (key?.ctrl && key?.name === "c") {
+          if (instance.stack.length > 0) {
+            const cancelled = instance.stack.pop();
+            cancelled?.resolve("");
+            instance.currentLine = "";
+          }
+          instance.close();
+          process.exit(0);
         }
 
-        if (this.historyIndex < history.length - 1) {
-          this.historyIndex++;
-          const next =
-            history[history.length - 1 - this.historyIndex] ?? "";
-          this.replaceLine(next);
-          this.currentLine = next;
+        // If RL is closed or nothing to ask, ignore
+        if (!InputQueueManager.rl || instance.stack.length === 0) return;
+
+        // Keep our buffer in sync with readline's live line
+        instance.syncFromReadline();
+
+        // Any "real typing" should exit history mode
+        // (we'll treat left/right as not exiting; you can tweak)
+        const exitsHistoryMode =
+          key &&
+          (key.name === "return" ||
+            key.name === "enter" ||
+            key.name === "backspace" ||
+            (key.sequence &&
+              key.sequence.length === 1 &&
+              !key.ctrl &&
+              !key.meta));
+        if (exitsHistoryMode && instance.historyIndex !== -1) {
+          instance.historyIndex = -1;
+          instance.savedLineBeforeHistory = "";
         }
-        return;
-      }
-
-      if (key?.name === "down") {
-        const history = this.getHistory();
-        if (history.length === 0) return;
 
-        if (this.historyIndex > 0) {
-          this.historyIndex--;
-          const next =
-            history[history.length - 1 - this.historyIndex] ?? "";
-          this.replaceLine(next);
-          this.currentLine = next;
+        // Custom Up/Down history navigation using only passed-in history
+        if (key?.name === "up") {
+          const history = instance.getHistory();
+          if (history.length === 0) return;
+
+          if (instance.historyIndex === -1) {
+            // entering history mode: remember current typed text
+            instance.savedLineBeforeHistory = instance.currentLine;
+          }
+
+          if (instance.historyIndex < history.length - 1) {
+            instance.historyIndex++;
+            const index = history.length - 1 - instance.historyIndex;
+            const next = history[index] ?? "";
+            instance.replaceLine(next);
+            instance.currentLine = next;
+          }
           return;
         }
 
-        if (this.historyIndex === 0) {
-          // leave history mode, restore what user was typing
-          this.historyIndex = -1;
-          const restore = this.savedLineBeforeHistory ?? "";
-          this.savedLineBeforeHistory = "";
-          this.replaceLine(restore);
-          this.currentLine = restore;
+        if (key?.name === "down") {
+          const history = instance.getHistory();
+          if (history.length === 0) return;
+
+          if (instance.historyIndex > 0) {
+            instance.historyIndex--;
+            const index = history.length - 1 - instance.historyIndex;
+            const next = history[index] ?? "";
+            instance.replaceLine(next);
+            instance.currentLine = next;
+            return;
+          }
+
+          if (instance.historyIndex === 0) {
+            // leave history mode, restore what user was typing
+            instance.historyIndex = -1;
+            const restore = instance.savedLineBeforeHistory ?? "";
+            instance.savedLineBeforeHistory = "";
+            instance.replaceLine(restore);
+            instance.currentLine = restore;
+            return;
+          }
+
           return;
         }
+      });
+    }
 
-        return;
-      }
-    });
-
-    return this.rl;
+    return InputQueueManager.rl;
   }
 
   private flushPasteBuffer(): void {
@@ -238,6 +259,7 @@ export class InputQueueManager {
   async ask(question: string, options: string[] = [], history: string[] = []) {
     return new Promise<string>((resolve) => {
       this.stack.push({ question, options, history, resolve });
+      this.historyIndex = -1; // reset history nav when a new question is asked
 
       const rl = this.ensureRl();
 
@@ -260,8 +282,8 @@ export class InputQueueManager {
   }
 
   private syncFromReadline(): void {
-    if (!this.rl) return;
-    this.currentLine = (this.rl as any).line ?? "";
+    if (!InputQueueManager.rl) return;
+    this.currentLine = (InputQueueManager.rl as any).line ?? "";
   }
 
   private sanitizeHistoryEntry(value: string): string {
@@ -290,13 +312,13 @@ export class InputQueueManager {
   }
 
   private render(): void {
-    if (!this.rl) return;
+    if (!InputQueueManager.rl) return;
     const current = this.peek();
     if (!current) return;
 
     // Make prompt be the question (readline manages wrapping/cursor)
-    this.rl.setPrompt(current.question);
-    this.rl.prompt(true);
+    InputQueueManager.rl.setPrompt(current.question);
+    InputQueueManager.rl.prompt(true);
   }
 
   private renderTopOrClose(): void {
@@ -311,17 +333,17 @@ export class InputQueueManager {
 
     this.render();
     this.replaceLine(this.currentLine);
-    this.rl?.prompt(true);
+    InputQueueManager.rl?.prompt(true);
   }
 
   private replaceLine(next: string): void {
-    if (!this.rl) return;
+    if (!InputQueueManager.rl) return;
 
     const safe = this.sanitizeHistoryEntry(next);
 
     // Clear current line and write next input without affecting terminal scrollback
-    this.rl.write(null, { ctrl: true, name: "u" }); // Ctrl+U clears the line
-    if (safe) this.rl.write(safe);
+    InputQueueManager.rl.write(null, { ctrl: true, name: "u" }); // Ctrl+U clears the line
+    if (safe) InputQueueManager.rl.write(safe);
   }
 
   /**
@@ -343,9 +365,11 @@ export class InputQueueManager {
   }
 
   private close(): void {
-    if (!this.rl) return;
-    this.rl.close();
-    this.rl = null;
+    if (!InputQueueManager.rl) return;
+    InputQueueManager.rl.close();
+    InputQueueManager.rl = null;
+    // Note: We don't reset keypressListenerSetup because the listener stays attached to process.stdin
+    // and will continue to work for the next readline interface
 
     if (process.stdin.isTTY) {
       try {