@tyvm/knowhow 0.0.159 → 0.0.161

package/src/utils/InputQueueManager.ts

@@ -1,493 +0,0 @@
-import readline from "node:readline";
-
-// Callback type for notifying when a new history entry is added
-type OnNewHistoryEntry = (entry: string) => void;
-
-type AskOptions = {
-  question: string;
-  options?: string[];
-  history?: string[];
-  resolve: (value: string) => void;
-};
-
-export class InputQueueManager {
-  private stack: AskOptions[] = [];
-  private static instance: InputQueueManager | null = null;
-  private static rl: readline.Interface | null = null;
-  private static keypressListenerSetup = false;
-
-  // Tab completion state
-  private lastKeypressWasTab = false;
-
-  // We keep one "live" buffer shared across stacked questions
-  // (so typing is preserved when questions change)
-  private currentLine = "";
-
-  // Paste detection - buffer lines during paste operations
-  private pasteBuffer: string[] = [];
-  private pasteTimeout: NodeJS.Timeout | null = null;
-  private readonly PASTE_DELAY_MS = 10; // Time to wait for more paste lines
-
-  // History navigation state - uses only the history passed to ask()
-  private historyIndex = -1;
-  private savedLineBeforeHistory = "";
-
-  // Callback to notify caller when a new entry should be added to history
-  // 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.
-   */
-  setOnNewEntry(callback: OnNewHistoryEntry | undefined): void {
-    this.onNewEntry = callback;
-  }
-
-  private ensureRl(): readline.Interface {
-    if (InputQueueManager.rl) return InputQueueManager.rl;
-
-    InputQueueManager.rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      terminal: true,
-      // Disable readline's internal history - we manage history ourselves
-      historySize: 0,
-
-      /**
-       * Disable readline's built-in completion display - we handle Tab ourselves
-       * in the keypress listener to avoid readline's kRefreshLine overwriting
-       * small completion lists (lists that fit in 1-2 lines get erased).
-       */
-      completer: (line: string) => [[], line],
-    });
-
-    // When user presses Enter, buffer the line for paste detection
-    InputQueueManager.rl.on("line", (line) => {
-      const current = this.peek();
-      if (!current) return;
-
-      // Detect paste operation: if we receive a line while already processing lines,
-      // it's likely part of a paste. Buffer it and wait for more.
-      if (this.pasteTimeout) {
-        // Already in paste mode, add to buffer
-        this.pasteBuffer.push(line);
-        clearTimeout(this.pasteTimeout);
-        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
-      );
-    });
-
-    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)
-    InputQueueManager.rl.on("SIGINT", () => {
-      // If there's an active question, cancel it (like Esc)
-      if (this.stack.length > 0) {
-        const cancelled = this.stack.pop();
-        cancelled?.resolve("");
-        this.currentLine = "";
-        this.historyIndex = -1;
-        this.savedLineBeforeHistory = "";
-        this.renderTopOrClose();
-        return;
-      }
-      // Otherwise exit
-      this.close();
-      process.exit(0);
-    });
-
-    // Capture keypresses for ESC + history nav while still using readline.
-    // Tab is handled by rl completer.
-    // 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 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 = "";
-        }
-
-        // Handle Tab completion ourselves to avoid readline's kRefreshLine
-        // overwriting small completion lists (1-2 line lists get erased by readline).
-        if (key?.name === "tab") {
-          instance.handleTabCompletion();
-          return;
-        }
-
-        // Any non-tab keypress resets the "last was tab" state
-        instance.lastKeypressWasTab = false;
-
-        // 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 (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 InputQueueManager.rl;
-  }
-
-  private flushPasteBuffer(): void {
-    if (this.pasteBuffer.length === 0) return;
-
-    const answer = this.pasteBuffer.join("\n");
-    this.pasteBuffer = [];
-    this.pasteTimeout = null;
-
-    const current = this.peek();
-    if (!current) return;
-
-    // Pop & resolve current question with the combined paste content (or single line)
-    const resolved = this.stack.pop();
-    resolved?.resolve(answer);
-
-    // Notify caller about new entry
-    if (answer && this.onNewEntry) {
-      this.onNewEntry(answer);
-    }
-
-    // Reset preserved buffer + history nav state for the next question
-    this.currentLine = "";
-    this.historyIndex = -1;
-    this.savedLineBeforeHistory = "";
-
-    // Update prompt for next stacked question (if any)
-    this.renderTopOrClose();
-  }
-
-  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();
-
-      // IMPORTANT: snapshot readline's current buffer before we redraw/switch prompts.
-      // This prevents us from clobbering tab-completed text with a stale currentLine.
-      this.syncFromReadline();
-
-      // Update prompt to top-of-stack
-      this.render();
-
-      // Preserve what user typed so far
-      this.replaceLine(this.currentLine);
-
-      rl.prompt(true);
-    });
-  }
-
-  private peek(): AskOptions | undefined {
-    return this.stack[this.stack.length - 1];
-  }
-
-  private syncFromReadline(): void {
-    if (!InputQueueManager.rl) return;
-    this.currentLine = (InputQueueManager.rl as any).line ?? "";
-  }
-
-  private sanitizeHistoryEntry(value: string): string {
-    // Prevent embedded newlines from triggering readline's "line" event
-    return value.replace(/[\r\n]+/g, " ").trim();
-  }
-
-  /**
-   * Get history for navigation - simply uses the history passed to ask()
-   * Single source of truth: the caller (CliChatService) manages all history
-   */
-  private getHistory(): string[] {
-    const current = this.peek();
-    const history = current?.history ?? [];
-
-    // Sanitize entries
-    const out: string[] = [];
-    for (const item of history) {
-      const clean = this.sanitizeHistoryEntry(item);
-      if (clean) {
-        out.push(clean);
-      }
-    }
-
-    return out;
-  }
-
-  /**
-   * Handle Tab key completion manually.
-   *
-   * We do this ourselves instead of using readline's built-in completer because
-   * readline's kRefreshLine (called after displaying completions) uses
-   * clearScreenDown which erases small completion lists (1-2 lines) that fit
-   * within the terminal's current scroll region. Large lists scroll past and
-   * survive, but small lists get wiped out before the user can read them.
-   *
-   * Behavior:
-   * - First Tab: extend line to longest common prefix of matches (if possible)
-   * - Second consecutive Tab (no extension possible): print the matches list
-   */
-  private handleTabCompletion(): void {
-    const current = this.peek();
-    const opts = current?.options ?? [];
-
-    // Sync current line from readline before we do anything
-    this.syncFromReadline();
-    const line = this.currentLine;
-
-    if (opts.length === 0) {
-      this.lastKeypressWasTab = false;
-      return;
-    }
-
-    // Find the "word" to complete (everything after last space/tab)
-    const lastSpace = Math.max(line.lastIndexOf(" "), line.lastIndexOf("\t"));
-    const word = line.slice(lastSpace + 1);
-
-    const hits = opts.filter((c) => c.startsWith(word));
-
-    let effectiveHits: string[];
-    let completionWord: string; // the replacement for `word` in the line
-
-    if (hits.length > 0) {
-      // Exact prefix matches: use normal longest-common-prefix logic
-      effectiveHits = hits;
-      completionWord = this.longestCommonPrefix(effectiveHits);
-    } else {
-      // Contains matches: find options that contain the typed word somewhere
-      const containsHits = opts.filter((c) => c.includes(word));
-      effectiveHits = containsHits;
-
-      if (containsHits.length > 0) {
-        // If there's only one match, complete to the full option string
-        if (containsHits.length === 1) {
-          completionWord = containsHits[0];
-        } else {
-        // For each match, find the position of `word` inside it, then take
-        // the substring from that position and find the longest common prefix
-        // of all those suffixes. This gives us the longest unambiguous extension
-        // starting from the user's typed word.
-        const suffixes = containsHits.map((c) => {
-          const idx = c.indexOf(word);
-          return c.slice(idx); // e.g. "opus-4-5" from "anthropic/claude-opus-4-5"
-        });
-        completionWord = this.longestCommonPrefix(suffixes);
-        }
-      } else {
-        completionWord = word;
-      }
-    }
-
-    if (effectiveHits.length === 0) {
-      this.lastKeypressWasTab = false;
-      return;
-    }
-
-    if (completionWord.length > word.length) {
-      // Can extend - replace word with the longer completion
-      const before = line.slice(0, lastSpace + 1);
-      const newLine = before + completionWord;
-      this.replaceLine(newLine);
-      this.currentLine = newLine;
-      this.lastKeypressWasTab = false;
-      return;
-    }
-
-    // No extension possible - show list on second consecutive Tab
-    if (!this.lastKeypressWasTab) {
-      // First tab with no extension: just set flag, user needs to tab again
-      this.lastKeypressWasTab = true;
-      return;
-    }
-
-    // Second consecutive tab: print the completions list
-    this.lastKeypressWasTab = false;
-    const columns = process.stdout.columns || 80;
-    const maxWidth = Math.max(...effectiveHits.map((h) => h.length)) + 2;
-    const numCols = Math.max(1, Math.floor(columns / maxWidth));
-    const rows: string[] = [];
-    for (let i = 0; i < effectiveHits.length; i += numCols) {
-      const row = effectiveHits.slice(i, i + numCols);
-      rows.push(row.map((h) => h.padEnd(maxWidth)).join(""));
-    }
-    // Write completions. We intentionally do NOT call rl.prompt() here because
-    // readline tracks the cursor row internally. When prompt(true) is called,
-    // readline moves the cursor back UP to where it thinks the prompt is and
-    // redraws — overwriting any completion output that fit within the same scroll
-    // region (i.e., small lists that didn't cause the terminal to scroll).
-    //
-    // Instead, we write the completions and then a fresh prompt line manually,
-    // without involving readline's cursor tracking at all.
-    const promptText = current!.question;
-    const inputText = this.currentLine;
-    process.stdout.write("\r\n" + rows.join("\r\n") + "\r\n" + promptText + inputText);
-    // Now sync readline's internal state to match what we drew manually.
-    // We replace the line content via ctrl+u then re-type it so readline's
-    // internal `line` buffer and cursor position are correct.
-    InputQueueManager.rl?.write(null, { ctrl: true, name: "u" });
-    if (inputText) InputQueueManager.rl?.write(inputText);
-  }
-
-  private render(): void {
-    if (!InputQueueManager.rl) return;
-    const current = this.peek();
-    if (!current) return;
-
-    // Make prompt be the question (readline manages wrapping/cursor)
-    InputQueueManager.rl.setPrompt(current.question);
-    InputQueueManager.rl.prompt(true);
-  }
-
-  private renderTopOrClose(): void {
-    if (this.stack.length === 0) {
-      this.close();
-      return;
-    }
-
-    // IMPORTANT: snapshot readline's current buffer before we redraw/switch prompts.
-    // This prevents us from clobbering tab-completed text with a stale currentLine.
-    this.syncFromReadline();
-
-    this.render();
-    this.replaceLine(this.currentLine);
-    InputQueueManager.rl?.prompt(true);
-  }
-
-  private replaceLine(next: string): void {
-    if (!InputQueueManager.rl) return;
-
-    const safe = this.sanitizeHistoryEntry(next);
-
-    // Clear current line and write next input without affecting terminal scrollback
-    InputQueueManager.rl.write(null, { ctrl: true, name: "u" }); // Ctrl+U clears the line
-    if (safe) InputQueueManager.rl.write(safe);
-  }
-
-  /**
-   * Returns the longest common prefix of all strings in the array.
-   */
-  private longestCommonPrefix(items: string[]): string {
-    if (items.length === 0) return "";
-    let prefix = items[0];
-
-    for (let i = 1; i < items.length; i++) {
-      const s = items[i];
-      let j = 0;
-      while (j < prefix.length && j < s.length && prefix[j] === s[j]) j++;
-      prefix = prefix.slice(0, j);
-      if (!prefix) break;
-    }
-
-    return prefix;
-  }
-
-  private close(): void {
-    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 {
-        process.stdin.setRawMode(false);
-      } catch {
-        // ignore
-      }
-    }
-  }
-}

package/src/utils/http.ts

@@ -1,150 +0,0 @@
-/**
- * Thin native-fetch wrapper that returns { data: T } for backward compatibility.
- * Replaces axios throughout the codebase.
- */
-
-export interface HttpResponse<T = any> {
-  data: T;
-  status: number;
-  headers: Headers;
-}
-
-export class HttpError extends Error {
-  constructor(
-    public status: number,
-    public response: Response,
-    message: string,
-    public body?: any,
-  ) {
-    super(message);
-    this.name = "HttpError";
-  }
-}
-
-/**
- * Optional, non-enumerable hook carried by an authenticated headers object.
- * The hook may replace an expired credential before one safe 401 retry.
- */
-export const HTTP_UNAUTHORIZED_HANDLER = Symbol("httpUnauthorizedHandler");
-export type RefreshableHeaders = Record<string, string> & {
-  [HTTP_UNAUTHORIZED_HANDLER]?: () => Promise<void>;
-};
-
-async function parseBody<T>(response: Response, responseType?: string): Promise<T> {
-  if (responseType === "arraybuffer") {
-    return (await response.arrayBuffer()) as unknown as T;
-  }
-  if (responseType === "stream") {
-    return response.body as unknown as T;
-  }
-  const text = await response.text();
-  if (!text) return undefined as unknown as T;
-  try {
-    return JSON.parse(text) as T;
-  } catch {
-    return text as unknown as T;
-  }
-}
-
-async function request<T = any>(
-  url: string,
-  options: {
-    method?: string;
-    headers?: RefreshableHeaders;
-    body?: any;
-    responseType?: "json" | "arraybuffer" | "stream" | "text";
-    params?: Record<string, any>;
-    /** Timeout in milliseconds. Default: 30000 (30s). Use 0 to disable. */
-    timeout?: number;
-  } = {},
-  mayRefresh = true
-): Promise<HttpResponse<T>> {
-  const { method = "GET", headers = {}, body, responseType, params, timeout = 30000 } = options;
-
-  let fullUrl = url;
-  if (params && Object.keys(params).length > 0) {
-    const searchParams = new URLSearchParams();
-    for (const [k, v] of Object.entries(params)) {
-      if (v !== undefined && v !== null) {
-        searchParams.set(k, String(v));
-      }
-    }
-    fullUrl = `${url}?${searchParams.toString()}`;
-  }
-
-  const fetchOptions: RequestInit = {
-    method,
-    headers: { ...headers },
-  };
-
-  if (body !== undefined && body !== null) {
-    if (body instanceof Buffer || body instanceof Uint8Array || typeof (body as any).pipe === "function") {
-      // Stream or buffer — pass directly, Node fetch supports ReadableStream
-      fetchOptions.body = body;
-    } else if (typeof body === "object" && !(body instanceof FormData)) {
-      fetchOptions.body = JSON.stringify(body);
-      (fetchOptions.headers as Record<string, string>)["Content-Type"] = "application/json";
-    } else {
-      fetchOptions.body = body;
-    }
-  }
-
-  // Apply timeout via AbortController
-  let timeoutId: ReturnType<typeof setTimeout> | undefined;
-  if (timeout > 0) {
-    const controller = new AbortController();
-    fetchOptions.signal = controller.signal;
-    timeoutId = setTimeout(() => {
-      controller.abort();
-    }, timeout);
-  }
-
-  let response: Response;
-  try {
-    response = await fetch(fullUrl, fetchOptions);
-  } catch (e: any) {
-    if (e?.name === "AbortError") {
-      throw new HttpError(408, undefined as any, `Request timeout after ${timeout}ms: ${url}`);
-    }
-    throw e;
-  } finally {
-    if (timeoutId !== undefined) clearTimeout(timeoutId);
-  }
-
-  if (!response.ok) {
-    const refresh = headers[HTTP_UNAUTHORIZED_HANDLER];
-    if (response.status === 401 && mayRefresh && refresh) {
-      await refresh();
-      return request<T>(url, options, false);
-    }
-
-    const text = await response.text().catch(() => "");
-    let parsedBody: any;
-    try {
-      parsedBody = JSON.parse(text);
-    } catch {
-      parsedBody = { message: text };
-    }
-    throw new HttpError(response.status, response, `HTTP ${response.status}: ${text}`, parsedBody);
-  }
-
-  const data = await parseBody<T>(response, responseType);
-
-  return { data, status: response.status, headers: response.headers };
-}
-
-export const http = {
-  get: <T = any>(url: string, options?: Omit<Parameters<typeof request>[1], "method">) =>
-    request<T>(url, { ...options, method: "GET" }),
-  post: <T = any>(url: string, body?: any, options?: Omit<Parameters<typeof request>[1], "method" | "body">) =>
-    request<T>(url, { ...options, method: "POST", body }),
-  put: <T = any>(url: string, body?: any, options?: Omit<Parameters<typeof request>[1], "method" | "body">) =>
-    request<T>(url, { ...options, method: "PUT", body }),
-  patch: <T = any>(url: string, body?: any, options?: Omit<Parameters<typeof request>[1], "method" | "body">) =>
-    request<T>(url, { ...options, method: "PATCH", body }),
-  delete: <T = any>(url: string, options?: Omit<Parameters<typeof request>[1], "method">) =>
-    request<T>(url, { ...options, method: "DELETE" }),
-  isHttpError: (e: any): e is HttpError => e instanceof HttpError,
-};
-
-export default http;