useArrowKeyHistory.tsx

Full source

import React, { useCallback, useRef, useState } from 'react';
import { getModeFromInput } from 'src/components/PromptInput/inputModes.js';
import { useNotifications } from 'src/context/notifications.js';
import { ConfigurableShortcutHint } from '../components/ConfigurableShortcutHint.js';
import { FOOTER_TEMPORARY_STATUS_TIMEOUT } from '../components/PromptInput/Notifications.js';
import { getHistory } from '../history.js';
import { Text } from '../ink.js';
import type { PromptInputMode } from '../types/textInputTypes.js';
import type { HistoryEntry, PastedContent } from '../utils/config.js';
export type HistoryMode = PromptInputMode;

// Load history entries in chunks to reduce disk reads on rapid keypresses
const HISTORY_CHUNK_SIZE = 10;

// Shared state for batching concurrent load requests into a single disk read
// Mode filter is included to ensure we don't mix filtered and unfiltered caches
let pendingLoad: Promise<HistoryEntry[]> | null = null;
let pendingLoadTarget = 0;
let pendingLoadModeFilter: HistoryMode | undefined = undefined;
async function loadHistoryEntries(minCount: number, modeFilter?: HistoryMode): Promise<HistoryEntry[]> {
  // Round up to next chunk to avoid repeated small reads
  const target = Math.ceil(minCount / HISTORY_CHUNK_SIZE) * HISTORY_CHUNK_SIZE;

  // If a load is already pending with the same mode filter and will satisfy our needs, wait for it
  if (pendingLoad && pendingLoadTarget >= target && pendingLoadModeFilter === modeFilter) {
    return pendingLoad;
  }

  // If a load is pending but won't satisfy our needs or has different filter, we need to wait for it
  // to complete first, then start a new one (can't interrupt an ongoing read)
  if (pendingLoad) {
    await pendingLoad;
  }

  // Start a new load
  pendingLoadTarget = target;
  pendingLoadModeFilter = modeFilter;
  pendingLoad = (async () => {
    const entries: HistoryEntry[] = [];
    let loaded = 0;
    for await (const entry of getHistory()) {
      // If mode filter is specified, only include entries that match the mode
      if (modeFilter) {
        const entryMode = getModeFromInput(entry.display);
        if (entryMode !== modeFilter) {
          continue;
        }
      }
      entries.push(entry);
      loaded++;
      if (loaded >= pendingLoadTarget) break;
    }
    return entries;
  })();
  try {
    return await pendingLoad;
  } finally {
    pendingLoad = null;
    pendingLoadTarget = 0;
    pendingLoadModeFilter = undefined;
  }
}
export function useArrowKeyHistory(onSetInput: (value: string, mode: HistoryMode, pastedContents: Record<number, PastedContent>) => void, currentInput: string, pastedContents: Record<number, PastedContent>, setCursorOffset?: (offset: number) => void, currentMode?: HistoryMode): {
  historyIndex: number;
  setHistoryIndex: (index: number) => void;
  onHistoryUp: () => void;
  onHistoryDown: () => boolean;
  resetHistory: () => void;
  dismissSearchHint: () => void;
} {
  const [historyIndex, setHistoryIndex] = useState(0);
  const [lastShownHistoryEntry, setLastShownHistoryEntry] = useState<(HistoryEntry & {
    mode?: HistoryMode;
  }) | undefined>(undefined);
  const hasShownSearchHintRef = useRef(false);
  const {
    addNotification,
    removeNotification
  } = useNotifications();

  // Cache loaded history entries
  const historyCache = useRef<HistoryEntry[]>([]);
  // Track which mode filter the cache was loaded with
  const historyCacheModeFilter = useRef<HistoryMode | undefined>(undefined);

  // Synchronous tracker for history index to avoid stale closure issues
  // React state updates are async, so rapid keypresses can see stale values
  const historyIndexRef = useRef(0);

  // Track the mode filter that was active when history navigation started
  // This is set on the first arrow press and stays fixed until reset
  const initialModeFilterRef = useRef<HistoryMode | undefined>(undefined);

  // Refs to track current input values for draft preservation
  // These ensure we capture the draft with the latest values, not stale closure values
  const currentInputRef = useRef(currentInput);
  const pastedContentsRef = useRef(pastedContents);
  const currentModeRef = useRef(currentMode);

  // Keep refs in sync with props (synchronous update on each render)
  currentInputRef.current = currentInput;
  pastedContentsRef.current = pastedContents;
  currentModeRef.current = currentMode;
  const setInputWithCursor = useCallback((value: string, mode: HistoryMode, contents: Record<number, PastedContent>, cursorToStart = false): void => {
    onSetInput(value, mode, contents);
    setCursorOffset?.(cursorToStart ? 0 : value.length);
  }, [onSetInput, setCursorOffset]);
  const updateInput = useCallback((input: HistoryEntry | undefined, cursorToStart_0 = false): void => {
    if (!input || !input.display) return;
    const mode_0 = getModeFromInput(input.display);
    const value_0 = mode_0 === 'bash' ? input.display.slice(1) : input.display;
    setInputWithCursor(value_0, mode_0, input.pastedContents ?? {}, cursorToStart_0);
  }, [setInputWithCursor]);
  const showSearchHint = useCallback((): void => {
    addNotification({
      key: 'search-history-hint',
      jsx: <Text dimColor>
          <ConfigurableShortcutHint action="history:search" context="Global" fallback="ctrl+r" description="search history" />
        </Text>,
      priority: 'immediate',
      timeoutMs: FOOTER_TEMPORARY_STATUS_TIMEOUT
    });
  }, [addNotification]);
  const onHistoryUp = useCallback((): void => {
    // Capture and increment synchronously to handle rapid keypresses
    const targetIndex = historyIndexRef.current;
    historyIndexRef.current++;
    const inputAtPress = currentInputRef.current;
    const pastedContentsAtPress = pastedContentsRef.current;
    const modeAtPress = currentModeRef.current;
    if (targetIndex === 0) {
      initialModeFilterRef.current = modeAtPress === 'bash' ? modeAtPress : undefined;

      // Save draft synchronously using refs for the latest values
      // This ensures we capture the draft before any async operations or re-renders
      const hasInput = inputAtPress.trim() !== '';
      setLastShownHistoryEntry(hasInput ? {
        display: inputAtPress,
        pastedContents: pastedContentsAtPress,
        mode: modeAtPress
      } : undefined);
    }
    const modeFilter = initialModeFilterRef.current;
    void (async () => {
      const neededCount = targetIndex + 1; // How many entries we need

      // If mode filter changed, invalidate cache
      if (historyCacheModeFilter.current !== modeFilter) {
        historyCache.current = [];
        historyCacheModeFilter.current = modeFilter;
        historyIndexRef.current = 0;
      }

      // Load more entries if needed
      if (historyCache.current.length < neededCount) {
        // Batches concurrent requests - rapid keypresses share a single disk read
        const entries = await loadHistoryEntries(neededCount, modeFilter);
        // Only update cache if we loaded more than currently cached
        // (handles race condition where multiple loads complete out of order)
        if (entries.length > historyCache.current.length) {
          historyCache.current = entries;
        }
      }

      // Check if we can navigate
      if (targetIndex >= historyCache.current.length) {
        // Rollback the ref since we can't navigate
        historyIndexRef.current--;
        // Keep the draft intact - user stays on their current input
        return;
      }
      const newIndex = targetIndex + 1;
      setHistoryIndex(newIndex);
      updateInput(historyCache.current[targetIndex], true);

      // Show hint once per session after navigating through 2 history entries
      if (newIndex >= 2 && !hasShownSearchHintRef.current) {
        hasShownSearchHintRef.current = true;
        showSearchHint();
      }
    })();
  }, [updateInput, showSearchHint]);
  const onHistoryDown = useCallback((): boolean => {
    // Use the ref for consistent reads
    const currentIndex = historyIndexRef.current;
    if (currentIndex > 1) {
      historyIndexRef.current--;
      setHistoryIndex(currentIndex - 1);
      updateInput(historyCache.current[currentIndex - 2]);
    } else if (currentIndex === 1) {
      historyIndexRef.current = 0;
      setHistoryIndex(0);
      if (lastShownHistoryEntry) {
        // Restore the draft with its saved mode if available
        const savedMode = lastShownHistoryEntry.mode;
        if (savedMode) {
          setInputWithCursor(lastShownHistoryEntry.display, savedMode, lastShownHistoryEntry.pastedContents ?? {});
        } else {
          updateInput(lastShownHistoryEntry);
        }
      } else {
        // When in filtered mode, stay in that mode when clearing input
        setInputWithCursor('', initialModeFilterRef.current ?? 'prompt', {});
      }
    }
    return currentIndex <= 0;
  }, [lastShownHistoryEntry, updateInput, setInputWithCursor]);
  const resetHistory = useCallback((): void => {
    setLastShownHistoryEntry(undefined);
    setHistoryIndex(0);
    historyIndexRef.current = 0;
    initialModeFilterRef.current = undefined;
    removeNotification('search-history-hint');
    historyCache.current = [];
    historyCacheModeFilter.current = undefined;
  }, [removeNotification]);
  const dismissSearchHint = useCallback((): void => {
    removeNotification('search-history-hint');
  }, [removeNotification]);
  return {
    historyIndex,
    setHistoryIndex,
    onHistoryUp,
    onHistoryDown,
    resetHistory,
    dismissSearchHint
  };
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useRef","useState","getModeFromInput","useNotifications","ConfigurableShortcutHint","FOOTER_TEMPORARY_STATUS_TIMEOUT","getHistory","Text","PromptInputMode","HistoryEntry","PastedContent","HistoryMode","HISTORY_CHUNK_SIZE","pendingLoad","Promise","pendingLoadTarget","pendingLoadModeFilter","undefined","loadHistoryEntries","minCount","modeFilter","target","Math","ceil","entries","loaded","entry","entryMode","display","push","useArrowKeyHistory","onSetInput","value","mode","pastedContents","Record","currentInput","setCursorOffset","offset","currentMode","historyIndex","setHistoryIndex","index","onHistoryUp","onHistoryDown","resetHistory","dismissSearchHint","lastShownHistoryEntry","setLastShownHistoryEntry","hasShownSearchHintRef","addNotification","removeNotification","historyCache","historyCacheModeFilter","historyIndexRef","initialModeFilterRef","currentInputRef","pastedContentsRef","currentModeRef","current","setInputWithCursor","contents","cursorToStart","length","updateInput","input","slice","showSearchHint","key","jsx","priority","timeoutMs","targetIndex","inputAtPress","pastedContentsAtPress","modeAtPress","hasInput","trim","neededCount","newIndex","currentIndex","savedMode"],"sources":["useArrowKeyHistory.tsx"],"sourcesContent":["import React, { useCallback, useRef, useState } from 'react'\nimport { getModeFromInput } from 'src/components/PromptInput/inputModes.js'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { ConfigurableShortcutHint } from '../components/ConfigurableShortcutHint.js'\nimport { FOOTER_TEMPORARY_STATUS_TIMEOUT } from '../components/PromptInput/Notifications.js'\nimport { getHistory } from '../history.js'\nimport { Text } from '../ink.js'\nimport type { PromptInputMode } from '../types/textInputTypes.js'\nimport type { HistoryEntry, PastedContent } from '../utils/config.js'\n\nexport type HistoryMode = PromptInputMode\n\n// Load history entries in chunks to reduce disk reads on rapid keypresses\nconst HISTORY_CHUNK_SIZE = 10\n\n// Shared state for batching concurrent load requests into a single disk read\n// Mode filter is included to ensure we don't mix filtered and unfiltered caches\nlet pendingLoad: Promise<HistoryEntry[]> | null = null\nlet pendingLoadTarget = 0\nlet pendingLoadModeFilter: HistoryMode | undefined = undefined\n\nasync function loadHistoryEntries(\n  minCount: number,\n  modeFilter?: HistoryMode,\n): Promise<HistoryEntry[]> {\n  // Round up to next chunk to avoid repeated small reads\n  const target = Math.ceil(minCount / HISTORY_CHUNK_SIZE) * HISTORY_CHUNK_SIZE\n\n  // If a load is already pending with the same mode filter and will satisfy our needs, wait for it\n  if (\n    pendingLoad &&\n    pendingLoadTarget >= target &&\n    pendingLoadModeFilter === modeFilter\n  ) {\n    return pendingLoad\n  }\n\n  // If a load is pending but won't satisfy our needs or has different filter, we need to wait for it\n  // to complete first, then start a new one (can't interrupt an ongoing read)\n  if (pendingLoad) {\n    await pendingLoad\n  }\n\n  // Start a new load\n  pendingLoadTarget = target\n  pendingLoadModeFilter = modeFilter\n  pendingLoad = (async () => {\n    const entries: HistoryEntry[] = []\n    let loaded = 0\n    for await (const entry of getHistory()) {\n      // If mode filter is specified, only include entries that match the mode\n      if (modeFilter) {\n        const entryMode = getModeFromInput(entry.display)\n        if (entryMode !== modeFilter) {\n          continue\n        }\n      }\n      entries.push(entry)\n      loaded++\n      if (loaded >= pendingLoadTarget) break\n    }\n    return entries\n  })()\n\n  try {\n    return await pendingLoad\n  } finally {\n    pendingLoad = null\n    pendingLoadTarget = 0\n    pendingLoadModeFilter = undefined\n  }\n}\n\nexport function useArrowKeyHistory(\n  onSetInput: (\n    value: string,\n    mode: HistoryMode,\n    pastedContents: Record<number, PastedContent>,\n  ) => void,\n  currentInput: string,\n  pastedContents: Record<number, PastedContent>,\n  setCursorOffset?: (offset: number) => void,\n  currentMode?: HistoryMode,\n): {\n  historyIndex: number\n  setHistoryIndex: (index: number) => void\n  onHistoryUp: () => void\n  onHistoryDown: () => boolean\n  resetHistory: () => void\n  dismissSearchHint: () => void\n} {\n  const [historyIndex, setHistoryIndex] = useState(0)\n  const [lastShownHistoryEntry, setLastShownHistoryEntry] = useState<\n    (HistoryEntry & { mode?: HistoryMode }) | undefined\n  >(undefined)\n  const hasShownSearchHintRef = useRef(false)\n  const { addNotification, removeNotification } = useNotifications()\n\n  // Cache loaded history entries\n  const historyCache = useRef<HistoryEntry[]>([])\n  // Track which mode filter the cache was loaded with\n  const historyCacheModeFilter = useRef<HistoryMode | undefined>(undefined)\n\n  // Synchronous tracker for history index to avoid stale closure issues\n  // React state updates are async, so rapid keypresses can see stale values\n  const historyIndexRef = useRef(0)\n\n  // Track the mode filter that was active when history navigation started\n  // This is set on the first arrow press and stays fixed until reset\n  const initialModeFilterRef = useRef<HistoryMode | undefined>(undefined)\n\n  // Refs to track current input values for draft preservation\n  // These ensure we capture the draft with the latest values, not stale closure values\n  const currentInputRef = useRef(currentInput)\n  const pastedContentsRef = useRef(pastedContents)\n  const currentModeRef = useRef(currentMode)\n\n  // Keep refs in sync with props (synchronous update on each render)\n  currentInputRef.current = currentInput\n  pastedContentsRef.current = pastedContents\n  currentModeRef.current = currentMode\n\n  const setInputWithCursor = useCallback(\n    (\n      value: string,\n      mode: HistoryMode,\n      contents: Record<number, PastedContent>,\n      cursorToStart = false,\n    ): void => {\n      onSetInput(value, mode, contents)\n      setCursorOffset?.(cursorToStart ? 0 : value.length)\n    },\n    [onSetInput, setCursorOffset],\n  )\n\n  const updateInput = useCallback(\n    (input: HistoryEntry | undefined, cursorToStart = false): void => {\n      if (!input || !input.display) return\n\n      const mode = getModeFromInput(input.display)\n      const value = mode === 'bash' ? input.display.slice(1) : input.display\n\n      setInputWithCursor(value, mode, input.pastedContents ?? {}, cursorToStart)\n    },\n    [setInputWithCursor],\n  )\n\n  const showSearchHint = useCallback((): void => {\n    addNotification({\n      key: 'search-history-hint',\n      jsx: (\n        <Text dimColor>\n          <ConfigurableShortcutHint\n            action=\"history:search\"\n            context=\"Global\"\n            fallback=\"ctrl+r\"\n            description=\"search history\"\n          />\n        </Text>\n      ),\n      priority: 'immediate',\n      timeoutMs: FOOTER_TEMPORARY_STATUS_TIMEOUT,\n    })\n  }, [addNotification])\n\n  const onHistoryUp = useCallback((): void => {\n    // Capture and increment synchronously to handle rapid keypresses\n    const targetIndex = historyIndexRef.current\n    historyIndexRef.current++\n\n    const inputAtPress = currentInputRef.current\n    const pastedContentsAtPress = pastedContentsRef.current\n    const modeAtPress = currentModeRef.current\n\n    if (targetIndex === 0) {\n      initialModeFilterRef.current =\n        modeAtPress === 'bash' ? modeAtPress : undefined\n\n      // Save draft synchronously using refs for the latest values\n      // This ensures we capture the draft before any async operations or re-renders\n      const hasInput = inputAtPress.trim() !== ''\n      setLastShownHistoryEntry(\n        hasInput\n          ? {\n              display: inputAtPress,\n              pastedContents: pastedContentsAtPress,\n              mode: modeAtPress,\n            }\n          : undefined,\n      )\n    }\n\n    const modeFilter = initialModeFilterRef.current\n\n    void (async () => {\n      const neededCount = targetIndex + 1 // How many entries we need\n\n      // If mode filter changed, invalidate cache\n      if (historyCacheModeFilter.current !== modeFilter) {\n        historyCache.current = []\n        historyCacheModeFilter.current = modeFilter\n        historyIndexRef.current = 0\n      }\n\n      // Load more entries if needed\n      if (historyCache.current.length < neededCount) {\n        // Batches concurrent requests - rapid keypresses share a single disk read\n        const entries = await loadHistoryEntries(neededCount, modeFilter)\n        // Only update cache if we loaded more than currently cached\n        // (handles race condition where multiple loads complete out of order)\n        if (entries.length > historyCache.current.length) {\n          historyCache.current = entries\n        }\n      }\n\n      // Check if we can navigate\n      if (targetIndex >= historyCache.current.length) {\n        // Rollback the ref since we can't navigate\n        historyIndexRef.current--\n        // Keep the draft intact - user stays on their current input\n        return\n      }\n\n      const newIndex = targetIndex + 1\n      setHistoryIndex(newIndex)\n      updateInput(historyCache.current[targetIndex], true)\n\n      // Show hint once per session after navigating through 2 history entries\n      if (newIndex >= 2 && !hasShownSearchHintRef.current) {\n        hasShownSearchHintRef.current = true\n        showSearchHint()\n      }\n    })()\n  }, [updateInput, showSearchHint])\n\n  const onHistoryDown = useCallback((): boolean => {\n    // Use the ref for consistent reads\n    const currentIndex = historyIndexRef.current\n    if (currentIndex > 1) {\n      historyIndexRef.current--\n      setHistoryIndex(currentIndex - 1)\n      updateInput(historyCache.current[currentIndex - 2])\n    } else if (currentIndex === 1) {\n      historyIndexRef.current = 0\n      setHistoryIndex(0)\n      if (lastShownHistoryEntry) {\n        // Restore the draft with its saved mode if available\n        const savedMode = lastShownHistoryEntry.mode\n        if (savedMode) {\n          setInputWithCursor(\n            lastShownHistoryEntry.display,\n            savedMode,\n            lastShownHistoryEntry.pastedContents ?? {},\n          )\n        } else {\n          updateInput(lastShownHistoryEntry)\n        }\n      } else {\n        // When in filtered mode, stay in that mode when clearing input\n        setInputWithCursor('', initialModeFilterRef.current ?? 'prompt', {})\n      }\n    }\n    return currentIndex <= 0\n  }, [lastShownHistoryEntry, updateInput, setInputWithCursor])\n\n  const resetHistory = useCallback((): void => {\n    setLastShownHistoryEntry(undefined)\n    setHistoryIndex(0)\n    historyIndexRef.current = 0\n    initialModeFilterRef.current = undefined\n    removeNotification('search-history-hint')\n    historyCache.current = []\n    historyCacheModeFilter.current = undefined\n  }, [removeNotification])\n\n  const dismissSearchHint = useCallback((): void => {\n    removeNotification('search-history-hint')\n  }, [removeNotification])\n\n  return {\n    historyIndex,\n    setHistoryIndex,\n    onHistoryUp,\n    onHistoryDown,\n    resetHistory,\n    dismissSearchHint,\n  }\n}\n"],"mappings":"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","ignoreList":[]}