lcclaude 1.0.0

package/dist/src/keybindings/KeybindingContext.js

@@ -0,0 +1,170 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, useContext, useLayoutEffect, useMemo } from "react";
+import { getBindingDisplayText, resolveKeyWithChordState } from "./resolver.js";
+const KeybindingContext = createContext(null);
+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 = jsxDEV_7x81h0kn(KeybindingContext.Provider, {
+      value,
+      children
+    }, undefined, false, undefined, this);
+    $[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;
+}
+export function useOptionalKeybindingContext() {
+  return useContext(KeybindingContext);
+}
+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);
+}

package/dist/src/keybindings/KeybindingProviderSetup.js

@@ -0,0 +1,225 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import { useNotifications } from "../context/notifications.js";
+import { 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, loadKeybindingsSyncWithWarnings, subscribeToKeybindingChanges } from "./loadUserBindings.js";
+import { resolveKeyWithChordState } from "./resolver.js";
+const CHORD_TIMEOUT_MS = 1000;
+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 + " · /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
+}) {
+  const [{
+    bindings,
+    warnings
+  }, setLoadResult] = useState(() => {
+    const result = loadKeybindingsSyncWithWarnings();
+    logForDebugging(`[keybindings] KeybindingSetup initialized with ${result.bindings.length} bindings, ${result.warnings.length} warnings`);
+    return result;
+  });
+  const [isReload, setIsReload] = useState(false);
+  useKeybindingWarnings(warnings, isReload);
+  const pendingChordRef = useRef(null);
+  const [pendingChord, setPendingChordState] = useState(null);
+  const chordTimeoutRef = useRef(null);
+  const handlerRegistryRef = useRef(new Map);
+  const activeContextsRef = useRef(new Set);
+  const registerActiveContext = useCallback((context) => {
+    activeContextsRef.current.add(context);
+  }, []);
+  const unregisterActiveContext = useCallback((context_0) => {
+    activeContextsRef.current.delete(context_0);
+  }, []);
+  const clearChordTimeout = useCallback(() => {
+    if (chordTimeoutRef.current) {
+      clearTimeout(chordTimeoutRef.current);
+      chordTimeoutRef.current = null;
+    }
+  }, []);
+  const setPendingChord = useCallback((pending) => {
+    clearChordTimeout();
+    if (pending !== null) {
+      chordTimeoutRef.current = setTimeout((pendingChordRef_0, setPendingChordState_0) => {
+        logForDebugging("[keybindings] Chord timeout - cancelling");
+        pendingChordRef_0.current = null;
+        setPendingChordState_0(null);
+      }, CHORD_TIMEOUT_MS, pendingChordRef, setPendingChordState);
+    }
+    pendingChordRef.current = pending;
+    setPendingChordState(pending);
+  }, [clearChordTimeout]);
+  useEffect(() => {
+    initializeKeybindingWatcher();
+    const unsubscribe = subscribeToKeybindingChanges((result_0) => {
+      setIsReload(true);
+      setLoadResult(result_0);
+      logForDebugging(`[keybindings] Reloaded: ${result_0.bindings.length} bindings, ${result_0.warnings.length} warnings`);
+    });
+    return () => {
+      unsubscribe();
+      clearChordTimeout();
+    };
+  }, [clearChordTimeout]);
+  return jsxDEV_7x81h0kn(KeybindingProvider, {
+    bindings,
+    pendingChordRef,
+    pendingChord,
+    setPendingChord,
+    activeContexts: activeContextsRef.current,
+    registerActiveContext,
+    unregisterActiveContext,
+    handlerRegistryRef,
+    children: [
+      jsxDEV_7x81h0kn(ChordInterceptor, {
+        bindings,
+        pendingChordRef,
+        setPendingChord,
+        activeContexts: activeContextsRef.current,
+        handlerRegistryRef
+      }, undefined, false, undefined, this),
+      children
+    ]
+  }, undefined, true, undefined, this);
+}
+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;
+}

package/dist/src/keybindings/defaultBindings.js

@@ -0,0 +1,228 @@
+import { satisfies } from "../utils/semver.js";
+import { isRunningWithBun } from "../utils/bundledMode.js";
+import { getPlatform } from "../utils/platform.js";
+const IMAGE_PASTE_KEY = getPlatform() === "windows" ? "alt+v" : "ctrl+v";
+const SUPPORTS_TERMINAL_VT_MODE = getPlatform() !== "windows" || (isRunningWithBun() ? satisfies(process.versions.bun, ">=1.2.23") : satisfies(process.versions.node, ">=22.17.0 <23.0.0 || >=24.2.0"));
+const MODE_CYCLE_KEY = SUPPORTS_TERMINAL_VT_MODE ? "shift+tab" : "meta+m";
+export const DEFAULT_BINDINGS = [
+  {
+    context: "Global",
+    bindings: {
+      "ctrl+c": "app:interrupt",
+      "ctrl+d": "app:exit",
+      "ctrl+l": "app:redraw",
+      "ctrl+t": "app:toggleTodos",
+      "ctrl+o": "app:toggleTranscript",
+      ...{},
+      "ctrl+shift+o": "app:toggleTeammatePreview",
+      "ctrl+r": "history:search",
+      ...{},
+      ...{}
+    }
+  },
+  {
+    context: "Chat",
+    bindings: {
+      escape: "chat:cancel",
+      "ctrl+x ctrl+k": "chat:killAgents",
+      [MODE_CYCLE_KEY]: "chat:cycleMode",
+      "meta+p": "chat:modelPicker",
+      "meta+o": "chat:fastMode",
+      "meta+t": "chat:thinkingToggle",
+      enter: "chat:submit",
+      up: "history:previous",
+      down: "history:next",
+      "ctrl+_": "chat:undo",
+      "ctrl+shift+-": "chat:undo",
+      "ctrl+x ctrl+e": "chat:externalEditor",
+      "ctrl+g": "chat:externalEditor",
+      "ctrl+s": "chat:stash",
+      [IMAGE_PASTE_KEY]: "chat:imagePaste",
+      ...{},
+      ...{}
+    }
+  },
+  {
+    context: "Autocomplete",
+    bindings: {
+      tab: "autocomplete:accept",
+      escape: "autocomplete:dismiss",
+      up: "autocomplete:previous",
+      down: "autocomplete:next"
+    }
+  },
+  {
+    context: "Settings",
+    bindings: {
+      escape: "confirm:no",
+      up: "select:previous",
+      down: "select:next",
+      k: "select:previous",
+      j: "select:next",
+      "ctrl+p": "select:previous",
+      "ctrl+n": "select:next",
+      space: "select:accept",
+      enter: "settings:close",
+      "/": "settings:search",
+      r: "settings:retry"
+    }
+  },
+  {
+    context: "Confirmation",
+    bindings: {
+      y: "confirm:yes",
+      n: "confirm:no",
+      enter: "confirm:yes",
+      escape: "confirm:no",
+      up: "confirm:previous",
+      down: "confirm:next",
+      tab: "confirm:nextField",
+      space: "confirm:toggle",
+      "shift+tab": "confirm:cycleMode",
+      "ctrl+e": "confirm:toggleExplanation",
+      "ctrl+d": "permission:toggleDebug"
+    }
+  },
+  {
+    context: "Tabs",
+    bindings: {
+      tab: "tabs:next",
+      "shift+tab": "tabs:previous",
+      right: "tabs:next",
+      left: "tabs:previous"
+    }
+  },
+  {
+    context: "Transcript",
+    bindings: {
+      "ctrl+e": "transcript:toggleShowAll",
+      "ctrl+c": "transcript:exit",
+      escape: "transcript:exit",
+      q: "transcript:exit"
+    }
+  },
+  {
+    context: "HistorySearch",
+    bindings: {
+      "ctrl+r": "historySearch:next",
+      escape: "historySearch:accept",
+      tab: "historySearch:accept",
+      "ctrl+c": "historySearch:cancel",
+      enter: "historySearch:execute"
+    }
+  },
+  {
+    context: "Task",
+    bindings: {
+      "ctrl+b": "task:background"
+    }
+  },
+  {
+    context: "ThemePicker",
+    bindings: {
+      "ctrl+t": "theme:toggleSyntaxHighlighting"
+    }
+  },
+  {
+    context: "Scroll",
+    bindings: {
+      pageup: "scroll:pageUp",
+      pagedown: "scroll:pageDown",
+      wheelup: "scroll:lineUp",
+      wheeldown: "scroll:lineDown",
+      "ctrl+home": "scroll:top",
+      "ctrl+end": "scroll:bottom",
+      "ctrl+shift+c": "selection:copy",
+      "cmd+c": "selection:copy"
+    }
+  },
+  {
+    context: "Help",
+    bindings: {
+      escape: "help:dismiss"
+    }
+  },
+  {
+    context: "Attachments",
+    bindings: {
+      right: "attachments:next",
+      left: "attachments:previous",
+      backspace: "attachments:remove",
+      delete: "attachments:remove",
+      down: "attachments:exit",
+      escape: "attachments:exit"
+    }
+  },
+  {
+    context: "Footer",
+    bindings: {
+      up: "footer:up",
+      "ctrl+p": "footer:up",
+      down: "footer:down",
+      "ctrl+n": "footer:down",
+      right: "footer:next",
+      left: "footer:previous",
+      enter: "footer:openSelected",
+      escape: "footer:clearSelection"
+    }
+  },
+  {
+    context: "MessageSelector",
+    bindings: {
+      up: "messageSelector:up",
+      down: "messageSelector:down",
+      k: "messageSelector:up",
+      j: "messageSelector:down",
+      "ctrl+p": "messageSelector:up",
+      "ctrl+n": "messageSelector:down",
+      "ctrl+up": "messageSelector:top",
+      "shift+up": "messageSelector:top",
+      "meta+up": "messageSelector:top",
+      "shift+k": "messageSelector:top",
+      "ctrl+down": "messageSelector:bottom",
+      "shift+down": "messageSelector:bottom",
+      "meta+down": "messageSelector:bottom",
+      "shift+j": "messageSelector:bottom",
+      enter: "messageSelector:select"
+    }
+  },
+  ...[],
+  {
+    context: "DiffDialog",
+    bindings: {
+      escape: "diff:dismiss",
+      left: "diff:previousSource",
+      right: "diff:nextSource",
+      up: "diff:previousFile",
+      down: "diff:nextFile",
+      enter: "diff:viewDetails"
+    }
+  },
+  {
+    context: "ModelPicker",
+    bindings: {
+      left: "modelPicker:decreaseEffort",
+      right: "modelPicker:increaseEffort"
+    }
+  },
+  {
+    context: "Select",
+    bindings: {
+      up: "select:previous",
+      down: "select:next",
+      j: "select:next",
+      k: "select:previous",
+      "ctrl+n": "select:next",
+      "ctrl+p": "select:previous",
+      enter: "select:accept",
+      escape: "select:cancel"
+    }
+  },
+  {
+    context: "Plugin",
+    bindings: {
+      space: "plugin:toggle",
+      i: "plugin:install"
+    }
+  }
+];