@xelauvas/xela-cli 0.1.0

package/src/keybindings/KeybindingContext.tsx

@@ -0,0 +1,243 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, type RefObject, useContext, useLayoutEffect, useMemo } from 'react';
+import type { Key } from '../ink.js';
+import { type ChordResolveResult, getBindingDisplayText, resolveKeyWithChordState } from './resolver.js';
+import type { KeybindingContextName, ParsedBinding, ParsedKeystroke } from './types.js';
+
+/** Handler registration for action callbacks */
+type HandlerRegistration = {
+  action: string;
+  context: KeybindingContextName;
+  handler: () => void;
+};
+type KeybindingContextValue = {
+  /** Resolve a key input to an action name (with chord support) */
+  resolve: (input: string, key: Key, activeContexts: KeybindingContextName[]) => ChordResolveResult;
+
+  /** Update the pending chord state */
+  setPendingChord: (pending: ParsedKeystroke[] | null) => void;
+
+  /** Get display text for an action (e.g., "ctrl+t") */
+  getDisplayText: (action: string, context: KeybindingContextName) => string | undefined;
+
+  /** All parsed bindings (for help display) */
+  bindings: ParsedBinding[];
+
+  /** Current pending chord keystrokes (null if not in a chord) */
+  pendingChord: ParsedKeystroke[] | null;
+
+  /** Currently active keybinding contexts (for priority resolution) */
+  activeContexts: Set<KeybindingContextName>;
+
+  /** Register a context as active (call on mount) */
+  registerActiveContext: (context: KeybindingContextName) => void;
+
+  /** Unregister a context (call on unmount) */
+  unregisterActiveContext: (context: KeybindingContextName) => void;
+
+  /** Register a handler for an action (used by useKeybinding) */
+  registerHandler: (registration: HandlerRegistration) => () => void;
+
+  /** Invoke all handlers for an action (used by ChordInterceptor) */
+  invokeAction: (action: string) => boolean;
+};
+const KeybindingContext = createContext<KeybindingContextValue | null>(null);
+type ProviderProps = {
+  bindings: ParsedBinding[];
+  /** Ref for immediate access to pending chord (avoids React state delay) */
+  pendingChordRef: RefObject<ParsedKeystroke[] | null>;
+  /** State value for re-renders (UI updates) */
+  pendingChord: ParsedKeystroke[] | null;
+  setPendingChord: (pending: ParsedKeystroke[] | null) => void;
+  activeContexts: Set<KeybindingContextName>;
+  registerActiveContext: (context: KeybindingContextName) => void;
+  unregisterActiveContext: (context: KeybindingContextName) => void;
+  /** Ref to handler registry (used by ChordInterceptor) */
+  handlerRegistryRef: RefObject<Map<string, Set<HandlerRegistration>>>;
+  children: React.ReactNode;
+};
+export function KeybindingProvider(t0) {
+  const $ = _c(24);
+  const {
+    bindings,
+    pendingChordRef,
+    pendingChord,
+    setPendingChord,
+    activeContexts,
+    registerActiveContext,
+    unregisterActiveContext,
+    handlerRegistryRef,
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== bindings) {
+    t1 = (action, context) => getBindingDisplayText(action, context, bindings);
+    $[0] = bindings;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const getDisplay = t1;
+  let t2;
+  if ($[2] !== handlerRegistryRef) {
+    t2 = registration => {
+      const registry = handlerRegistryRef.current;
+      if (!registry) {
+        return _temp;
+      }
+      if (!registry.has(registration.action)) {
+        registry.set(registration.action, new Set());
+      }
+      registry.get(registration.action).add(registration);
+      return () => {
+        const handlers = registry.get(registration.action);
+        if (handlers) {
+          handlers.delete(registration);
+          if (handlers.size === 0) {
+            registry.delete(registration.action);
+          }
+        }
+      };
+    };
+    $[2] = handlerRegistryRef;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const registerHandler = t2;
+  let t3;
+  if ($[4] !== activeContexts || $[5] !== handlerRegistryRef) {
+    t3 = action_0 => {
+      const registry_0 = handlerRegistryRef.current;
+      if (!registry_0) {
+        return false;
+      }
+      const handlers_0 = registry_0.get(action_0);
+      if (!handlers_0 || handlers_0.size === 0) {
+        return false;
+      }
+      for (const registration_0 of handlers_0) {
+        if (activeContexts.has(registration_0.context)) {
+          registration_0.handler();
+          return true;
+        }
+      }
+      return false;
+    };
+    $[4] = activeContexts;
+    $[5] = handlerRegistryRef;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  const invokeAction = t3;
+  let t4;
+  if ($[7] !== bindings || $[8] !== pendingChordRef) {
+    t4 = (input, key, contexts) => resolveKeyWithChordState(input, key, contexts, bindings, pendingChordRef.current);
+    $[7] = bindings;
+    $[8] = pendingChordRef;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] !== activeContexts || $[11] !== bindings || $[12] !== getDisplay || $[13] !== invokeAction || $[14] !== pendingChord || $[15] !== registerActiveContext || $[16] !== registerHandler || $[17] !== setPendingChord || $[18] !== t4 || $[19] !== unregisterActiveContext) {
+    t5 = {
+      resolve: t4,
+      setPendingChord,
+      getDisplayText: getDisplay,
+      bindings,
+      pendingChord,
+      activeContexts,
+      registerActiveContext,
+      unregisterActiveContext,
+      registerHandler,
+      invokeAction
+    };
+    $[10] = activeContexts;
+    $[11] = bindings;
+    $[12] = getDisplay;
+    $[13] = invokeAction;
+    $[14] = pendingChord;
+    $[15] = registerActiveContext;
+    $[16] = registerHandler;
+    $[17] = setPendingChord;
+    $[18] = t4;
+    $[19] = unregisterActiveContext;
+    $[20] = t5;
+  } else {
+    t5 = $[20];
+  }
+  const value = t5;
+  let t6;
+  if ($[21] !== children || $[22] !== value) {
+    t6 = <KeybindingContext.Provider value={value}>{children}</KeybindingContext.Provider>;
+    $[21] = children;
+    $[22] = value;
+    $[23] = t6;
+  } else {
+    t6 = $[23];
+  }
+  return t6;
+}
+function _temp() {}
+export function useKeybindingContext() {
+  const ctx = useContext(KeybindingContext);
+  if (!ctx) {
+    throw new Error("useKeybindingContext must be used within KeybindingProvider");
+  }
+  return ctx;
+}
+
+/**
+ * Optional hook that returns undefined outside of KeybindingProvider.
+ * Useful for components that may render before provider is available.
+ */
+export function useOptionalKeybindingContext() {
+  return useContext(KeybindingContext);
+}
+
+/**
+ * Hook to register a keybinding context as active while the component is mounted.
+ *
+ * When a context is registered, its keybindings take precedence over Global bindings.
+ * This allows context-specific bindings (like ThemePicker's ctrl+t) to override
+ * global bindings (like the todo toggle) when the context is active.
+ *
+ * @example
+ * ```tsx
+ * function ThemePicker() {
+ *   useRegisterKeybindingContext('ThemePicker')
+ *   // Now ThemePicker's ctrl+t binding takes precedence over Global
+ * }
+ * ```
+ */
+export function useRegisterKeybindingContext(context, t0) {
+  const $ = _c(5);
+  const isActive = t0 === undefined ? true : t0;
+  const keybindingContext = useOptionalKeybindingContext();
+  let t1;
+  let t2;
+  if ($[0] !== context || $[1] !== isActive || $[2] !== keybindingContext) {
+    t1 = () => {
+      if (!keybindingContext || !isActive) {
+        return;
+      }
+      keybindingContext.registerActiveContext(context);
+      return () => {
+        keybindingContext.unregisterActiveContext(context);
+      };
+    };
+    t2 = [context, keybindingContext, isActive];
+    $[0] = context;
+    $[1] = isActive;
+    $[2] = keybindingContext;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t1 = $[3];
+    t2 = $[4];
+  }
+  useLayoutEffect(t1, t2);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","createContext","RefObject","useContext","useLayoutEffect","useMemo","Key","ChordResolveResult","getBindingDisplayText","resolveKeyWithChordState","KeybindingContextName","ParsedBinding","ParsedKeystroke","HandlerRegistration","action","context","handler","KeybindingContextValue","resolve","input","key","activeContexts","setPendingChord","pending","getDisplayText","bindings","pendingChord","Set","registerActiveContext","unregisterActiveContext","registerHandler","registration","invokeAction","KeybindingContext","ProviderProps","pendingChordRef","handlerRegistryRef","Map","children","ReactNode","KeybindingProvider","t0","$","_c","t1","getDisplay","t2","registry","current","_temp","has","set","get","add","handlers","delete","size","t3","action_0","registry_0","handlers_0","registration_0","t4","contexts","t5","value","t6","useKeybindingContext","ctx","Error","useOptionalKeybindingContext","useRegisterKeybindingContext","isActive","undefined","keybindingContext"],"sources":["KeybindingContext.tsx"],"sourcesContent":["import React, {\n  createContext,\n  type RefObject,\n  useContext,\n  useLayoutEffect,\n  useMemo,\n} from 'react'\nimport type { Key } from '../ink.js'\nimport {\n  type ChordResolveResult,\n  getBindingDisplayText,\n  resolveKeyWithChordState,\n} from './resolver.js'\nimport type {\n  KeybindingContextName,\n  ParsedBinding,\n  ParsedKeystroke,\n} from './types.js'\n\n/** Handler registration for action callbacks */\ntype HandlerRegistration = {\n  action: string\n  context: KeybindingContextName\n  handler: () => void\n}\n\ntype KeybindingContextValue = {\n  /** Resolve a key input to an action name (with chord support) */\n  resolve: (\n    input: string,\n    key: Key,\n    activeContexts: KeybindingContextName[],\n  ) => ChordResolveResult\n\n  /** Update the pending chord state */\n  setPendingChord: (pending: ParsedKeystroke[] | null) => void\n\n  /** Get display text for an action (e.g., \"ctrl+t\") */\n  getDisplayText: (\n    action: string,\n    context: KeybindingContextName,\n  ) => string | undefined\n\n  /** All parsed bindings (for help display) */\n  bindings: ParsedBinding[]\n\n  /** Current pending chord keystrokes (null if not in a chord) */\n  pendingChord: ParsedKeystroke[] | null\n\n  /** Currently active keybinding contexts (for priority resolution) */\n  activeContexts: Set<KeybindingContextName>\n\n  /** Register a context as active (call on mount) */\n  registerActiveContext: (context: KeybindingContextName) => void\n\n  /** Unregister a context (call on unmount) */\n  unregisterActiveContext: (context: KeybindingContextName) => void\n\n  /** Register a handler for an action (used by useKeybinding) */\n  registerHandler: (registration: HandlerRegistration) => () => void\n\n  /** Invoke all handlers for an action (used by ChordInterceptor) */\n  invokeAction: (action: string) => boolean\n}\n\nconst KeybindingContext = createContext<KeybindingContextValue | null>(null)\n\ntype ProviderProps = {\n  bindings: ParsedBinding[]\n  /** Ref for immediate access to pending chord (avoids React state delay) */\n  pendingChordRef: RefObject<ParsedKeystroke[] | null>\n  /** State value for re-renders (UI updates) */\n  pendingChord: ParsedKeystroke[] | null\n  setPendingChord: (pending: ParsedKeystroke[] | null) => void\n  activeContexts: Set<KeybindingContextName>\n  registerActiveContext: (context: KeybindingContextName) => void\n  unregisterActiveContext: (context: KeybindingContextName) => void\n  /** Ref to handler registry (used by ChordInterceptor) */\n  handlerRegistryRef: RefObject<Map<string, Set<HandlerRegistration>>>\n  children: React.ReactNode\n}\n\nexport function KeybindingProvider({\n  bindings,\n  pendingChordRef,\n  pendingChord,\n  setPendingChord,\n  activeContexts,\n  registerActiveContext,\n  unregisterActiveContext,\n  handlerRegistryRef,\n  children,\n}: ProviderProps): React.ReactNode {\n  const value = useMemo<KeybindingContextValue>(() => {\n    const getDisplay = (action: string, context: KeybindingContextName) =>\n      getBindingDisplayText(action, context, bindings)\n\n    // Register a handler for an action\n    const registerHandler = (registration: HandlerRegistration) => {\n      const registry = handlerRegistryRef.current\n      if (!registry) return () => {}\n\n      if (!registry.has(registration.action)) {\n        registry.set(registration.action, new Set())\n      }\n      registry.get(registration.action)!.add(registration)\n\n      // Return unregister function\n      return () => {\n        const handlers = registry.get(registration.action)\n        if (handlers) {\n          handlers.delete(registration)\n          if (handlers.size === 0) {\n            registry.delete(registration.action)\n          }\n        }\n      }\n    }\n\n    // Invoke all handlers for an action\n    const invokeAction = (action: string): boolean => {\n      const registry = handlerRegistryRef.current\n      if (!registry) return false\n\n      const handlers = registry.get(action)\n      if (!handlers || handlers.size === 0) return false\n\n      // Find handlers whose context is active\n      for (const registration of handlers) {\n        if (activeContexts.has(registration.context)) {\n          registration.handler()\n          return true\n        }\n      }\n      return false\n    }\n\n    return {\n      // Use ref for immediate access to pending chord, avoiding React state delay\n      // This is critical for chord sequences where the second key might be pressed\n      // before React re-renders with the updated pendingChord state\n      resolve: (input, key, contexts) =>\n        resolveKeyWithChordState(\n          input,\n          key,\n          contexts,\n          bindings,\n          pendingChordRef.current,\n        ),\n      setPendingChord,\n      getDisplayText: getDisplay,\n      bindings,\n      pendingChord,\n      activeContexts,\n      registerActiveContext,\n      unregisterActiveContext,\n      registerHandler,\n      invokeAction,\n    }\n  }, [\n    bindings,\n    pendingChordRef,\n    pendingChord,\n    setPendingChord,\n    activeContexts,\n    registerActiveContext,\n    unregisterActiveContext,\n    handlerRegistryRef,\n  ])\n\n  return (\n    <KeybindingContext.Provider value={value}>\n      {children}\n    </KeybindingContext.Provider>\n  )\n}\n\nexport function useKeybindingContext(): KeybindingContextValue {\n  const ctx = useContext(KeybindingContext)\n  if (!ctx) {\n    throw new Error(\n      'useKeybindingContext must be used within KeybindingProvider',\n    )\n  }\n  return ctx\n}\n\n/**\n * Optional hook that returns undefined outside of KeybindingProvider.\n * Useful for components that may render before provider is available.\n */\nexport function useOptionalKeybindingContext(): KeybindingContextValue | null {\n  return useContext(KeybindingContext)\n}\n\n/**\n * Hook to register a keybinding context as active while the component is mounted.\n *\n * When a context is registered, its keybindings take precedence over Global bindings.\n * This allows context-specific bindings (like ThemePicker's ctrl+t) to override\n * global bindings (like the todo toggle) when the context is active.\n *\n * @example\n * ```tsx\n * function ThemePicker() {\n *   useRegisterKeybindingContext('ThemePicker')\n *   // Now ThemePicker's ctrl+t binding takes precedence over Global\n * }\n * ```\n */\nexport function useRegisterKeybindingContext(\n  context: KeybindingContextName,\n  isActive: boolean = true,\n): void {\n  const keybindingContext = useOptionalKeybindingContext()\n\n  useLayoutEffect(() => {\n    if (!keybindingContext || !isActive) return\n\n    keybindingContext.registerActiveContext(context)\n    return () => {\n      keybindingContext.unregisterActiveContext(context)\n    }\n  }, [context, keybindingContext, isActive])\n}\n"],"mappings":"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","ignoreList":[]}

package/src/keybindings/KeybindingProviderSetup.tsx

@@ -0,0 +1,308 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Setup utilities for integrating KeybindingProvider into the app.
+ *
+ * This file provides the bindings and a composed provider that can be
+ * added to the app's component tree. It loads both default bindings and
+ * user-defined bindings from ~/.claude/keybindings.json, with hot-reload
+ * support when the file changes.
+ */
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { useNotifications } from '../context/notifications.js';
+import type { InputEvent } from '../ink/events/input-event.js';
+// ChordInterceptor intentionally uses useInput to intercept all keystrokes before
+// other handlers process them - this is required for chord sequence support
+// eslint-disable-next-line custom-rules/prefer-use-keybindings
+import { type Key, useInput } from '../ink.js';
+import { count } from '../utils/array.js';
+import { logForDebugging } from '../utils/debug.js';
+import { plural } from '../utils/stringUtils.js';
+import { KeybindingProvider } from './KeybindingContext.js';
+import { initializeKeybindingWatcher, type KeybindingsLoadResult, loadKeybindingsSyncWithWarnings, subscribeToKeybindingChanges } from './loadUserBindings.js';
+import { resolveKeyWithChordState } from './resolver.js';
+import type { KeybindingContextName, ParsedBinding, ParsedKeystroke } from './types.js';
+import type { KeybindingWarning } from './validate.js';
+
+/**
+ * Timeout for chord sequences in milliseconds.
+ * If the user doesn't complete the chord within this time, it's cancelled.
+ */
+const CHORD_TIMEOUT_MS = 1000;
+type Props = {
+  children: React.ReactNode;
+};
+
+/**
+ * Keybinding provider with default + user bindings and hot-reload support.
+ *
+ * Usage: Wrap your app with this provider to enable keybinding support.
+ *
+ * ```tsx
+ * <AppStateProvider>
+ *   <KeybindingSetup>
+ *     <REPL ... />
+ *   </KeybindingSetup>
+ * </AppStateProvider>
+ * ```
+ *
+ * Features:
+ * - Loads default bindings from code
+ * - Merges with user bindings from ~/.claude/keybindings.json
+ * - Watches for file changes and reloads automatically (hot-reload)
+ * - User bindings override defaults (later entries win)
+ * - Chord support with automatic timeout
+ */
+/**
+ * Display keybinding warnings to the user via notifications.
+ * Shows a brief message pointing to /doctor for details.
+ */
+function useKeybindingWarnings(warnings, isReload) {
+  const $ = _c(9);
+  const {
+    addNotification,
+    removeNotification
+  } = useNotifications();
+  let t0;
+  if ($[0] !== addNotification || $[1] !== removeNotification || $[2] !== warnings) {
+    t0 = () => {
+      if (warnings.length === 0) {
+        removeNotification("keybinding-config-warning");
+        return;
+      }
+      const errorCount = count(warnings, _temp);
+      const warnCount = count(warnings, _temp2);
+      let message;
+      if (errorCount > 0 && warnCount > 0) {
+        message = `Found ${errorCount} keybinding ${plural(errorCount, "error")} and ${warnCount} ${plural(warnCount, "warning")}`;
+      } else {
+        if (errorCount > 0) {
+          message = `Found ${errorCount} keybinding ${plural(errorCount, "error")}`;
+        } else {
+          message = `Found ${warnCount} keybinding ${plural(warnCount, "warning")}`;
+        }
+      }
+      message = message + " \xB7 /doctor for details";
+      addNotification({
+        key: "keybinding-config-warning",
+        text: message,
+        color: errorCount > 0 ? "error" : "warning",
+        priority: errorCount > 0 ? "immediate" : "high",
+        timeoutMs: 60000
+      });
+    };
+    $[0] = addNotification;
+    $[1] = removeNotification;
+    $[2] = warnings;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  let t1;
+  if ($[4] !== addNotification || $[5] !== isReload || $[6] !== removeNotification || $[7] !== warnings) {
+    t1 = [warnings, isReload, addNotification, removeNotification];
+    $[4] = addNotification;
+    $[5] = isReload;
+    $[6] = removeNotification;
+    $[7] = warnings;
+    $[8] = t1;
+  } else {
+    t1 = $[8];
+  }
+  useEffect(t0, t1);
+}
+function _temp2(w_0) {
+  return w_0.severity === "warning";
+}
+function _temp(w) {
+  return w.severity === "error";
+}
+export function KeybindingSetup({
+  children
+}: Props): React.ReactNode {
+  // Load bindings synchronously for initial render
+  const [{
+    bindings,
+    warnings
+  }, setLoadResult] = useState<KeybindingsLoadResult>(() => {
+    const result = loadKeybindingsSyncWithWarnings();
+    logForDebugging(`[keybindings] KeybindingSetup initialized with ${result.bindings.length} bindings, ${result.warnings.length} warnings`);
+    return result;
+  });
+
+  // Track if this is a reload (not initial load)
+  const [isReload, setIsReload] = useState(false);
+
+  // Display warnings via notifications
+  useKeybindingWarnings(warnings, isReload);
+
+  // Chord state management - use ref for immediate access, state for re-renders
+  // The ref is used by resolve() to get the current value without waiting for re-render
+  // The state is used to trigger re-renders when needed (e.g., for UI updates)
+  const pendingChordRef = useRef<ParsedKeystroke[] | null>(null);
+  const [pendingChord, setPendingChordState] = useState<ParsedKeystroke[] | null>(null);
+  const chordTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+
+  // Handler registry for action callbacks (used by ChordInterceptor to invoke handlers)
+  const handlerRegistryRef = useRef(new Map<string, Set<{
+    action: string;
+    context: KeybindingContextName;
+    handler: () => void;
+  }>>());
+
+  // Active context tracking for keybinding priority resolution
+  // Using a ref instead of state for synchronous updates - input handlers need
+  // to see the current value immediately, not after a React render cycle.
+  const activeContextsRef = useRef<Set<KeybindingContextName>>(new Set());
+  const registerActiveContext = useCallback((context: KeybindingContextName) => {
+    activeContextsRef.current.add(context);
+  }, []);
+  const unregisterActiveContext = useCallback((context_0: KeybindingContextName) => {
+    activeContextsRef.current.delete(context_0);
+  }, []);
+
+  // Clear chord timeout when component unmounts or chord changes
+  const clearChordTimeout = useCallback(() => {
+    if (chordTimeoutRef.current) {
+      clearTimeout(chordTimeoutRef.current);
+      chordTimeoutRef.current = null;
+    }
+  }, []);
+
+  // Wrapper for setPendingChord that manages timeout and syncs ref+state
+  const setPendingChord = useCallback((pending: ParsedKeystroke[] | null) => {
+    clearChordTimeout();
+    if (pending !== null) {
+      // Set timeout to cancel chord if not completed
+      chordTimeoutRef.current = setTimeout((pendingChordRef_0, setPendingChordState_0) => {
+        logForDebugging('[keybindings] Chord timeout - cancelling');
+        pendingChordRef_0.current = null;
+        setPendingChordState_0(null);
+      }, CHORD_TIMEOUT_MS, pendingChordRef, setPendingChordState);
+    }
+
+    // Update ref immediately for synchronous access in resolve()
+    pendingChordRef.current = pending;
+    // Update state to trigger re-renders for UI updates
+    setPendingChordState(pending);
+  }, [clearChordTimeout]);
+  useEffect(() => {
+    // Initialize file watcher (idempotent - only runs once)
+    void initializeKeybindingWatcher();
+
+    // Subscribe to changes
+    const unsubscribe = subscribeToKeybindingChanges(result_0 => {
+      // Any callback invocation is a reload since initial load happens
+      // synchronously in useState, not via this subscription
+      setIsReload(true);
+      setLoadResult(result_0);
+      logForDebugging(`[keybindings] Reloaded: ${result_0.bindings.length} bindings, ${result_0.warnings.length} warnings`);
+    });
+    return () => {
+      unsubscribe();
+      clearChordTimeout();
+    };
+  }, [clearChordTimeout]);
+  return <KeybindingProvider bindings={bindings} pendingChordRef={pendingChordRef} pendingChord={pendingChord} setPendingChord={setPendingChord} activeContexts={activeContextsRef.current} registerActiveContext={registerActiveContext} unregisterActiveContext={unregisterActiveContext} handlerRegistryRef={handlerRegistryRef}>
+      <ChordInterceptor bindings={bindings} pendingChordRef={pendingChordRef} setPendingChord={setPendingChord} activeContexts={activeContextsRef.current} handlerRegistryRef={handlerRegistryRef} />
+      {children}
+    </KeybindingProvider>;
+}
+
+/**
+ * Global chord interceptor that registers useInput FIRST (before children).
+ *
+ * This component intercepts keystrokes that are part of chord sequences and
+ * stops propagation before other handlers (like PromptInput) can see them.
+ *
+ * Without this, the second key of a chord (e.g., 'r' in "ctrl+c r") would be
+ * captured by PromptInput and added to the input field before the keybinding
+ * system could recognize it as completing a chord.
+ */
+type HandlerRegistration = {
+  action: string;
+  context: KeybindingContextName;
+  handler: () => void;
+};
+function ChordInterceptor(t0) {
+  const $ = _c(6);
+  const {
+    bindings,
+    pendingChordRef,
+    setPendingChord,
+    activeContexts,
+    handlerRegistryRef
+  } = t0;
+  let t1;
+  if ($[0] !== activeContexts || $[1] !== bindings || $[2] !== handlerRegistryRef || $[3] !== pendingChordRef || $[4] !== setPendingChord) {
+    t1 = (input, key, event) => {
+      if ((key.wheelUp || key.wheelDown) && pendingChordRef.current === null) {
+        return;
+      }
+      const registry = handlerRegistryRef.current;
+      const handlerContexts = new Set();
+      if (registry) {
+        for (const handlers of registry.values()) {
+          for (const registration of handlers) {
+            handlerContexts.add(registration.context);
+          }
+        }
+      }
+      const contexts = [...handlerContexts, ...activeContexts, "Global"];
+      const wasInChord = pendingChordRef.current !== null;
+      const result = resolveKeyWithChordState(input, key, contexts, bindings, pendingChordRef.current);
+      bb23: switch (result.type) {
+        case "chord_started":
+          {
+            setPendingChord(result.pending);
+            event.stopImmediatePropagation();
+            break bb23;
+          }
+        case "match":
+          {
+            setPendingChord(null);
+            if (wasInChord) {
+              const contextsSet = new Set(contexts);
+              if (registry) {
+                const handlers_0 = registry.get(result.action);
+                if (handlers_0 && handlers_0.size > 0) {
+                  for (const registration_0 of handlers_0) {
+                    if (contextsSet.has(registration_0.context)) {
+                      registration_0.handler();
+                      event.stopImmediatePropagation();
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+            break bb23;
+          }
+        case "chord_cancelled":
+          {
+            setPendingChord(null);
+            event.stopImmediatePropagation();
+            break bb23;
+          }
+        case "unbound":
+          {
+            setPendingChord(null);
+            event.stopImmediatePropagation();
+            break bb23;
+          }
+        case "none":
+      }
+    };
+    $[0] = activeContexts;
+    $[1] = bindings;
+    $[2] = handlerRegistryRef;
+    $[3] = pendingChordRef;
+    $[4] = setPendingChord;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const handleInput = t1;
+  useInput(handleInput);
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useRef","useState","useNotifications","InputEvent","Key","useInput","count","logForDebugging","plural","KeybindingProvider","initializeKeybindingWatcher","KeybindingsLoadResult","loadKeybindingsSyncWithWarnings","subscribeToKeybindingChanges","resolveKeyWithChordState","KeybindingContextName","ParsedBinding","ParsedKeystroke","KeybindingWarning","CHORD_TIMEOUT_MS","Props","children","ReactNode","useKeybindingWarnings","warnings","isReload","$","_c","addNotification","removeNotification","t0","length","errorCount","_temp","warnCount","_temp2","message","key","text","color","priority","timeoutMs","t1","w_0","w","severity","KeybindingSetup","bindings","setLoadResult","result","setIsReload","pendingChordRef","pendingChord","setPendingChordState","chordTimeoutRef","NodeJS","Timeout","handlerRegistryRef","Map","Set","action","context","handler","activeContextsRef","registerActiveContext","current","add","unregisterActiveContext","delete","clearChordTimeout","clearTimeout","setPendingChord","pending","setTimeout","unsubscribe","HandlerRegistration","ChordInterceptor","activeContexts","input","event","wheelUp","wheelDown","registry","handlerContexts","handlers","values","registration","contexts","wasInChord","bb23","type","stopImmediatePropagation","contextsSet","handlers_0","get","size","registration_0","has","handleInput"],"sources":["KeybindingProviderSetup.tsx"],"sourcesContent":["/**\n * Setup utilities for integrating KeybindingProvider into the app.\n *\n * This file provides the bindings and a composed provider that can be\n * added to the app's component tree. It loads both default bindings and\n * user-defined bindings from ~/.claude/keybindings.json, with hot-reload\n * support when the file changes.\n */\nimport React, { useCallback, useEffect, useRef, useState } from 'react'\nimport { useNotifications } from '../context/notifications.js'\nimport type { InputEvent } from '../ink/events/input-event.js'\n// ChordInterceptor intentionally uses useInput to intercept all keystrokes before\n// other handlers process them - this is required for chord sequence support\n// eslint-disable-next-line custom-rules/prefer-use-keybindings\nimport { type Key, useInput } from '../ink.js'\nimport { count } from '../utils/array.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { plural } from '../utils/stringUtils.js'\nimport { KeybindingProvider } from './KeybindingContext.js'\nimport {\n  initializeKeybindingWatcher,\n  type KeybindingsLoadResult,\n  loadKeybindingsSyncWithWarnings,\n  subscribeToKeybindingChanges,\n} from './loadUserBindings.js'\nimport { resolveKeyWithChordState } from './resolver.js'\nimport type {\n  KeybindingContextName,\n  ParsedBinding,\n  ParsedKeystroke,\n} from './types.js'\nimport type { KeybindingWarning } from './validate.js'\n\n/**\n * Timeout for chord sequences in milliseconds.\n * If the user doesn't complete the chord within this time, it's cancelled.\n */\nconst CHORD_TIMEOUT_MS = 1000\n\ntype Props = {\n  children: React.ReactNode\n}\n\n/**\n * Keybinding provider with default + user bindings and hot-reload support.\n *\n * Usage: Wrap your app with this provider to enable keybinding support.\n *\n * ```tsx\n * <AppStateProvider>\n *   <KeybindingSetup>\n *     <REPL ... />\n *   </KeybindingSetup>\n * </AppStateProvider>\n * ```\n *\n * Features:\n * - Loads default bindings from code\n * - Merges with user bindings from ~/.claude/keybindings.json\n * - Watches for file changes and reloads automatically (hot-reload)\n * - User bindings override defaults (later entries win)\n * - Chord support with automatic timeout\n */\n/**\n * Display keybinding warnings to the user via notifications.\n * Shows a brief message pointing to /doctor for details.\n */\nfunction useKeybindingWarnings(\n  warnings: KeybindingWarning[],\n  isReload: boolean,\n): void {\n  const { addNotification, removeNotification } = useNotifications()\n\n  useEffect(() => {\n    const notificationKey = 'keybinding-config-warning'\n\n    if (warnings.length === 0) {\n      removeNotification(notificationKey)\n      return\n    }\n\n    const errorCount = count(warnings, w => w.severity === 'error')\n    const warnCount = count(warnings, w => w.severity === 'warning')\n\n    let message: string\n    if (errorCount > 0 && warnCount > 0) {\n      message = `Found ${errorCount} keybinding ${plural(errorCount, 'error')} and ${warnCount} ${plural(warnCount, 'warning')}`\n    } else if (errorCount > 0) {\n      message = `Found ${errorCount} keybinding ${plural(errorCount, 'error')}`\n    } else {\n      message = `Found ${warnCount} keybinding ${plural(warnCount, 'warning')}`\n    }\n    message += ' · /doctor for details'\n\n    addNotification({\n      key: notificationKey,\n      text: message,\n      color: errorCount > 0 ? 'error' : 'warning',\n      priority: errorCount > 0 ? 'immediate' : 'high',\n      // Keep visible for 60 seconds like settings errors\n      timeoutMs: 60000,\n    })\n  }, [warnings, isReload, addNotification, removeNotification])\n}\n\nexport function KeybindingSetup({ children }: Props): React.ReactNode {\n  // Load bindings synchronously for initial render\n  const [{ bindings, warnings }, setLoadResult] =\n    useState<KeybindingsLoadResult>(() => {\n      const result = loadKeybindingsSyncWithWarnings()\n      logForDebugging(\n        `[keybindings] KeybindingSetup initialized with ${result.bindings.length} bindings, ${result.warnings.length} warnings`,\n      )\n      return result\n    })\n\n  // Track if this is a reload (not initial load)\n  const [isReload, setIsReload] = useState(false)\n\n  // Display warnings via notifications\n  useKeybindingWarnings(warnings, isReload)\n\n  // Chord state management - use ref for immediate access, state for re-renders\n  // The ref is used by resolve() to get the current value without waiting for re-render\n  // The state is used to trigger re-renders when needed (e.g., for UI updates)\n  const pendingChordRef = useRef<ParsedKeystroke[] | null>(null)\n  const [pendingChord, setPendingChordState] = useState<\n    ParsedKeystroke[] | null\n  >(null)\n  const chordTimeoutRef = useRef<NodeJS.Timeout | null>(null)\n\n  // Handler registry for action callbacks (used by ChordInterceptor to invoke handlers)\n  const handlerRegistryRef = useRef(\n    new Map<\n      string,\n      Set<{\n        action: string\n        context: KeybindingContextName\n        handler: () => void\n      }>\n    >(),\n  )\n\n  // Active context tracking for keybinding priority resolution\n  // Using a ref instead of state for synchronous updates - input handlers need\n  // to see the current value immediately, not after a React render cycle.\n  const activeContextsRef = useRef<Set<KeybindingContextName>>(new Set())\n\n  const registerActiveContext = useCallback(\n    (context: KeybindingContextName) => {\n      activeContextsRef.current.add(context)\n    },\n    [],\n  )\n\n  const unregisterActiveContext = useCallback(\n    (context: KeybindingContextName) => {\n      activeContextsRef.current.delete(context)\n    },\n    [],\n  )\n\n  // Clear chord timeout when component unmounts or chord changes\n  const clearChordTimeout = useCallback(() => {\n    if (chordTimeoutRef.current) {\n      clearTimeout(chordTimeoutRef.current)\n      chordTimeoutRef.current = null\n    }\n  }, [])\n\n  // Wrapper for setPendingChord that manages timeout and syncs ref+state\n  const setPendingChord = useCallback(\n    (pending: ParsedKeystroke[] | null) => {\n      clearChordTimeout()\n\n      if (pending !== null) {\n        // Set timeout to cancel chord if not completed\n        chordTimeoutRef.current = setTimeout(\n          (pendingChordRef, setPendingChordState) => {\n            logForDebugging('[keybindings] Chord timeout - cancelling')\n            pendingChordRef.current = null\n            setPendingChordState(null)\n          },\n          CHORD_TIMEOUT_MS,\n          pendingChordRef,\n          setPendingChordState,\n        )\n      }\n\n      // Update ref immediately for synchronous access in resolve()\n      pendingChordRef.current = pending\n      // Update state to trigger re-renders for UI updates\n      setPendingChordState(pending)\n    },\n    [clearChordTimeout],\n  )\n\n  useEffect(() => {\n    // Initialize file watcher (idempotent - only runs once)\n    void initializeKeybindingWatcher()\n\n    // Subscribe to changes\n    const unsubscribe = subscribeToKeybindingChanges(result => {\n      // Any callback invocation is a reload since initial load happens\n      // synchronously in useState, not via this subscription\n      setIsReload(true)\n\n      setLoadResult(result)\n      logForDebugging(\n        `[keybindings] Reloaded: ${result.bindings.length} bindings, ${result.warnings.length} warnings`,\n      )\n    })\n\n    return () => {\n      unsubscribe()\n      clearChordTimeout()\n    }\n  }, [clearChordTimeout])\n\n  return (\n    <KeybindingProvider\n      bindings={bindings}\n      pendingChordRef={pendingChordRef}\n      pendingChord={pendingChord}\n      setPendingChord={setPendingChord}\n      activeContexts={activeContextsRef.current}\n      registerActiveContext={registerActiveContext}\n      unregisterActiveContext={unregisterActiveContext}\n      handlerRegistryRef={handlerRegistryRef}\n    >\n      <ChordInterceptor\n        bindings={bindings}\n        pendingChordRef={pendingChordRef}\n        setPendingChord={setPendingChord}\n        activeContexts={activeContextsRef.current}\n        handlerRegistryRef={handlerRegistryRef}\n      />\n      {children}\n    </KeybindingProvider>\n  )\n}\n\n/**\n * Global chord interceptor that registers useInput FIRST (before children).\n *\n * This component intercepts keystrokes that are part of chord sequences and\n * stops propagation before other handlers (like PromptInput) can see them.\n *\n * Without this, the second key of a chord (e.g., 'r' in \"ctrl+c r\") would be\n * captured by PromptInput and added to the input field before the keybinding\n * system could recognize it as completing a chord.\n */\ntype HandlerRegistration = {\n  action: string\n  context: KeybindingContextName\n  handler: () => void\n}\n\nfunction ChordInterceptor({\n  bindings,\n  pendingChordRef,\n  setPendingChord,\n  activeContexts,\n  handlerRegistryRef,\n}: {\n  bindings: ParsedBinding[]\n  pendingChordRef: React.RefObject<ParsedKeystroke[] | null>\n  setPendingChord: (pending: ParsedKeystroke[] | null) => void\n  activeContexts: Set<KeybindingContextName>\n  handlerRegistryRef: React.RefObject<Map<string, Set<HandlerRegistration>>>\n}): null {\n  const handleInput = useCallback(\n    (input: string, key: Key, event: InputEvent) => {\n      // Wheel events can never start chord sequences — scroll:lineUp/Down are\n      // single-key bindings handled by per-component useKeybindings hooks, not\n      // here. Skip the registry scan. Mid-chord wheel still falls through so\n      // scrolling cancels the pending chord like any other non-matching key.\n      if ((key.wheelUp || key.wheelDown) && pendingChordRef.current === null) {\n        return\n      }\n\n      // Build context list from registered handlers + activeContexts + Global\n      // This ensures we can resolve chords for all contexts that have handlers\n      const registry = handlerRegistryRef.current\n      const handlerContexts = new Set<KeybindingContextName>()\n      if (registry) {\n        for (const handlers of registry.values()) {\n          for (const registration of handlers) {\n            handlerContexts.add(registration.context)\n          }\n        }\n      }\n      const contexts: KeybindingContextName[] = [\n        ...handlerContexts,\n        ...activeContexts,\n        'Global',\n      ]\n\n      // Track whether we're completing a chord (pending was non-null)\n      const wasInChord = pendingChordRef.current !== null\n\n      // Check if this keystroke is part of a chord sequence\n      const result = resolveKeyWithChordState(\n        input,\n        key,\n        contexts,\n        bindings,\n        pendingChordRef.current,\n      )\n\n      switch (result.type) {\n        case 'chord_started':\n          // This key starts a chord - store pending state and stop propagation\n          setPendingChord(result.pending)\n          event.stopImmediatePropagation()\n          break\n\n        case 'match': {\n          // Clear pending state\n          setPendingChord(null)\n\n          // Only invoke handlers and stop propagation for chord completions\n          // (multi-keystroke sequences). Single-keystroke matches should propagate\n          // to per-hook handlers to avoid interfering with other input handling\n          // (e.g., Enter needs to reach useTypeahead for autocomplete acceptance\n          // before the submit handler fires).\n          if (wasInChord) {\n            // Find and invoke the handler for this action\n            // We need to check that the handler's context is in our resolved contexts\n            // (which includes handlerContexts + activeContexts + Global)\n            const contextsSet = new Set(contexts)\n            if (registry) {\n              const handlers = registry.get(result.action)\n              if (handlers && handlers.size > 0) {\n                // Find handlers whose context is in our resolved contexts\n                for (const registration of handlers) {\n                  if (contextsSet.has(registration.context)) {\n                    registration.handler()\n                    event.stopImmediatePropagation()\n                    break // Only invoke the first matching handler\n                  }\n                }\n              }\n            }\n          }\n          break\n        }\n\n        case 'chord_cancelled':\n          // Invalid key during chord - clear pending state and swallow the\n          // keystroke so it doesn't propagate as a standalone action\n          // (e.g., ctrl+x ctrl+c should not fire app:interrupt).\n          setPendingChord(null)\n          event.stopImmediatePropagation()\n          break\n\n        case 'unbound':\n          // Key is explicitly unbound - clear pending state and swallow\n          // the keystroke (it was part of a chord sequence).\n          setPendingChord(null)\n          event.stopImmediatePropagation()\n          break\n\n        case 'none':\n          // No chord involvement - let other handlers process\n          break\n      }\n    },\n    [\n      bindings,\n      pendingChordRef,\n      setPendingChord,\n      activeContexts,\n      handlerRegistryRef,\n    ],\n  )\n\n  useInput(handleInput)\n\n  return null\n}\n"],"mappings":"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","ignoreList":[]}