mixdog 0.9.174 → 1.0.0

package/src/tui/components/picker/use-picker-input.mjs

@@ -0,0 +1,165 @@
+/*
+ * components/picker/use-picker-input.mjs — Picker keyboard handling.
+ */
+import { useCallback } from 'react';
+import { useInput } from 'ink';
+
+export function usePickerInput({
+  items,
+  selectedIndex,
+  setSelectedIndex,
+  confirmFocus,
+  setConfirmFocus,
+  lastTabAtRef,
+  onSelect,
+  onCancel,
+  onLeft,
+  onRight,
+  onTab,
+  onKey,
+  effectiveVisibleLimit,
+  hasConfirm,
+  confirmButtons,
+  confirmBar,
+}) {
+  useInput(
+    useCallback(
+      (input, key) => {
+        if (key.upArrow) {
+          // Single vertical loop over [list items...] + [confirm buttons...].
+          if (hasConfirm) {
+            const last = items.length - 1;
+            if (confirmFocus > 0) {
+              setConfirmFocus((f) => f - 1);
+              return;
+            }
+            if (confirmFocus === 0) {
+              setConfirmFocus(-1);
+              setSelectedIndex(Math.max(0, last));
+              return;
+            }
+            // list focus: first row ↑ → last confirm button.
+            if (items.length === 0 || selectedIndex === 0) {
+              setConfirmFocus(confirmButtons.length - 1);
+              return;
+            }
+            setSelectedIndex((i) => i - 1);
+            return;
+          }
+          setSelectedIndex((i) => {
+            const total = items.length;
+            return total > 0 ? (i - 1 + total) % total : 0;
+          });
+          return;
+        }
+        if (key.downArrow) {
+          if (hasConfirm) {
+            const last = items.length - 1;
+            const lastBtn = confirmButtons.length - 1;
+            if (confirmFocus >= 0) {
+              if (confirmFocus < lastBtn) {
+                setConfirmFocus((f) => f + 1);
+                return;
+              }
+              // last button ↓ → first list row.
+              setConfirmFocus(-1);
+              setSelectedIndex(0);
+              return;
+            }
+            // list focus: last row ↓ → first confirm button.
+            if (items.length === 0 || selectedIndex === last) {
+              setConfirmFocus(0);
+              return;
+            }
+            setSelectedIndex((i) => i + 1);
+            return;
+          }
+          setSelectedIndex((i) => {
+            const total = items.length;
+            return total > 0 ? (i + 1) % total : 0;
+          });
+          return;
+        }
+        if (key.pageUp) {
+          setSelectedIndex((i) => Math.max(0, i - effectiveVisibleLimit));
+          return;
+        }
+        if (key.pageDown) {
+          setSelectedIndex((i) => Math.min(items.length - 1, i + effectiveVisibleLimit));
+          return;
+        }
+        if (key.home) {
+          setSelectedIndex(0);
+          return;
+        }
+        if (key.end) {
+          setSelectedIndex(items.length - 1);
+          return;
+        }
+        if (key.leftArrow) {
+          if (hasConfirm) {
+            setConfirmFocus((f) => (f <= 0 ? -1 : f - 1));
+            return;
+          }
+          if (onLeft) onLeft(items[selectedIndex], selectedIndex);
+          return;
+        }
+        if (key.rightArrow) {
+          if (hasConfirm) {
+            setConfirmFocus((f) => (f < 0 ? 0 : Math.min(confirmButtons.length - 1, f + 1)));
+            return;
+          }
+          if (onRight) onRight(items[selectedIndex], selectedIndex);
+          return;
+        }
+        if (key.tab || input === '\t') {
+          const now = Date.now();
+          if (now - lastTabAtRef.current < 120) return;
+          lastTabAtRef.current = now;
+          if (hasConfirm) {
+            setConfirmFocus((f) => {
+              if (f < 0) return 0;
+              return f + 1 > confirmButtons.length - 1 ? -1 : f + 1;
+            });
+            return;
+          }
+          if (onTab) onTab(items[selectedIndex], selectedIndex);
+          return;
+        }
+        if (key.return) {
+          if (hasConfirm && confirmFocus >= 0) {
+            const button = confirmButtons[confirmFocus];
+            if (button && confirmBar?.onConfirm) confirmBar.onConfirm(button, confirmFocus);
+            return;
+          }
+          const selected = items[selectedIndex];
+          if (selected && onSelect) onSelect(selected.value, selected);
+          return;
+        }
+        if (key.escape) {
+          onCancel();
+          return;
+        }
+        if (key.ctrl && (input === 'c' || input === 'C')) {
+          return;
+        }
+        if (onKey) onKey(input, key, items[selectedIndex], selectedIndex);
+      },
+      [
+        items,
+        selectedIndex,
+        onSelect,
+        onCancel,
+        onLeft,
+        onRight,
+        onTab,
+        onKey,
+        effectiveVisibleLimit,
+        hasConfirm,
+        confirmFocus,
+        confirmButtons,
+        confirmBar,
+      ]
+    )
+  );
+}

package/src/tui/components/picker/use-picker-selection.mjs

@@ -0,0 +1,67 @@
+/*
+ * components/picker/use-picker-selection.mjs — selected-row / confirm-bar focus
+ * state and its stability effects for Picker.
+ */
+import { useEffect, useRef, useState } from 'react';
+import { clampItemIndex } from './picker-layout.mjs';
+
+export function usePickerSelection({ items, initialIndex, onHighlight, confirmButtons, confirmBar }) {
+  const [selectedIndex, setSelectedIndex] = useState(() => clampItemIndex(initialIndex, items.length));
+  // -1 = list focus; 0..n-1 = confirm-bar button focus.
+  const [confirmFocus, setConfirmFocus] = useState(-1);
+  const lastTabAtRef = useRef(0);
+  useEffect(() => {
+    // Reset to list focus whenever the bar identity/shape changes (step switch).
+    setConfirmFocus(-1);
+  }, [confirmButtons.length, confirmBar]);
+
+  // Selection stability across owner-driven reopens: command pickers
+  // (settings/hooks/skills/channels toggles) rebuild their item list and call
+  // repaint the surface on every ←/→ toggle. Follow the previously selected
+  // item's `value` into the new list instead of snapping back to row 0.
+  // (useState-backed ref: mutation must never trigger a re-render.)
+  const [selectionMemo] = useState(() => ({ value: null, initialIndex }));
+  useEffect(() => {
+    const item = items[selectedIndex];
+    if (item && item.value != null) selectionMemo.value = item.value;
+  }, [items, selectedIndex, selectionMemo]);
+
+  useEffect(() => {
+    setSelectedIndex((i) => {
+      if (selectionMemo.value != null) {
+        const found = items.findIndex((entry) => entry && entry.value === selectionMemo.value);
+        if (found >= 0) return found;
+        // Previous selection no longer exists — this is a different picker
+        // (or the row was removed). Start from the owner's initialIndex/top
+        // instead of carrying a stale row number across picker transitions.
+        selectionMemo.value = null;
+        return clampItemIndex(initialIndex, items.length);
+      }
+      return Math.min(Math.max(0, i), Math.max(0, items.length - 1));
+    });
+  }, [items, selectionMemo, initialIndex]);
+
+  useEffect(() => {
+    // Explicit highlight target: honor initialIndex only when the owner
+    // actually provides a *new* one. A reopen that drops initialIndex
+    // (prop -> null default) must not reset the user's position to row 0.
+    if (initialIndex == null) {
+      selectionMemo.initialIndex = null;
+      return;
+    }
+    if (selectionMemo.initialIndex === initialIndex) return;
+    selectionMemo.initialIndex = initialIndex;
+    setSelectedIndex(clampItemIndex(initialIndex, items.length));
+  }, [initialIndex, items.length, selectionMemo]);
+
+  // Live-preview hook: notify the owner whenever the highlighted row changes
+  // (arrow keys, paging, initial mount). The /theme picker uses this to apply a
+  // non-persisted palette preview as the selection moves. Kept side-effect-free
+  // for pickers that do not pass onHighlight.
+  useEffect(() => {
+    if (typeof onHighlight !== 'function') return;
+    const item = items[selectedIndex];
+    if (item) onHighlight(item.value, item, selectedIndex);
+  }, [onHighlight, items, selectedIndex]);
+  return { selectedIndex, setSelectedIndex, confirmFocus, setConfirmFocus, lastTabAtRef };
+}

package/src/tui/components/prompt-input/edit-chords.mjs

@@ -0,0 +1,87 @@
+/*
+ * components/prompt-input/edit-chords.mjs — draft edits shared verbatim by
+ * PromptInput and TextEntryPanel.
+ */
+import {
+  deleteBackwardWord,
+  deleteForwardWord,
+  deleteToLineEnd,
+  deleteToLineStart,
+  moveCursor,
+  nextOffset,
+  nextWordOffset,
+  previousOffset,
+  previousWordOffset,
+  verticalOffset,
+} from '../../input-editing.mjs';
+import { deleteBackwardChar, deleteForwardChar } from './edit-helpers.mjs';
+
+// Character/word motion and deletion chords. Returns true when the key was one
+// of them (the draft was updated), false to let the caller keep dispatching.
+export function applyEditChord(key, inputKey, updateDraft) {
+  // ctrl+b / ctrl+f — character left / right.
+  if (key.ctrl && inputKey === 'b') {
+    updateDraft((d) => moveCursor(d, previousOffset(d.value, d.cursor), { extend: key.shift }));
+    return true;
+  }
+  if (key.ctrl && inputKey === 'f') {
+    updateDraft((d) => moveCursor(d, nextOffset(d.value, d.cursor), { extend: key.shift }));
+    return true;
+  }
+  // alt/option+b / alt/option+f — word left / right.
+  if (key.meta && inputKey === 'b') {
+    updateDraft((d) => moveCursor(d, previousWordOffset(d.value, d.cursor), { extend: key.shift }));
+    return true;
+  }
+  if (key.meta && inputKey === 'f') {
+    updateDraft((d) => moveCursor(d, nextWordOffset(d.value, d.cursor), { extend: key.shift }));
+    return true;
+  }
+  // ctrl+u / ctrl+k — delete to line start / end.
+  if (key.ctrl && inputKey === 'u') {
+    updateDraft(deleteToLineStart);
+    return true;
+  }
+  if (key.ctrl && inputKey === 'k') {
+    updateDraft(deleteToLineEnd);
+    return true;
+  }
+  // ctrl+w / alt+backspace — delete previous word.
+  if ((key.ctrl && inputKey === 'w') || ((key.ctrl || key.meta) && key.backspace)) {
+    updateDraft(deleteBackwardWord);
+    return true;
+  }
+  // alt+d / ctrl+delete — delete next word.
+  if ((key.meta && inputKey === 'd') || (key.ctrl && key.delete)) {
+    updateDraft(deleteForwardWord);
+    return true;
+  }
+  if (key.backspace) {
+    updateDraft(deleteBackwardChar);
+    return true;
+  }
+  if (key.delete) {
+    updateDraft(deleteForwardChar);
+    return true;
+  }
+  return false;
+}
+
+// Visual-line cursor motion that remembers the preferred column across a run
+// of vertical moves. Returns false when the cursor could not move.
+export function createVerticalMover({ draftRef, contentWidthRef, preferredColumnRef, commitDraft }) {
+  return (direction, { extend = false } = {}) => {
+    const current = draftRef.current;
+    const moved = verticalOffset(
+      current.value,
+      current.cursor,
+      contentWidthRef.current,
+      direction,
+      preferredColumnRef.current
+    );
+    preferredColumnRef.current = moved.preferredColumn;
+    if (moved.cursor === current.cursor) return false;
+    commitDraft(moveCursor(current, moved.cursor, { extend }), { keepPreferredColumn: true });
+    return true;
+  };
+}

package/src/tui/components/prompt-input/edit-helpers.mjs

@@ -91,23 +91,26 @@ export function csiBody(text) {
   return text.startsWith('[') ? text.slice(1) : '';
 }
 
-export function isModifiedEnterSequence(input) {
+const KITTY_ENTER_RE = /^13;(\d+)(?::\d+)?(?:;[\d:]+)?u$/;
+const MODIFY_OTHER_KEYS_ENTER_RE = /^27;(\d+);13~$/;
+
+/** The modifier bitmask (xterm param - 1) of an Enter sequence; null for anything else. */
+function enterModifierBits(input) {
   const body = csiBody(String(input ?? ''));
-  if (!body) return false;
-  const kitty = /^13;(\d+)(?::\d+)?(?:;[\d:]+)?u$/.exec(body);
-  if (kitty) return ((Number(kitty[1]) - 1) & MODIFIED_ENTER_NEWLINE) !== 0;
-  const modifyOtherKeys = /^27;(\d+);13~$/.exec(body);
-  return Boolean(modifyOtherKeys && ((Number(modifyOtherKeys[1]) - 1) & MODIFIED_ENTER_NEWLINE) !== 0);
+  if (!body) return null;
+  const match = KITTY_ENTER_RE.exec(body) || MODIFY_OTHER_KEYS_ENTER_RE.exec(body);
+  return match ? Number(match[1]) - 1 : null;
+}
+
+export function isModifiedEnterSequence(input) {
+  const bits = enterModifierBits(input);
+  return bits !== null && (bits & MODIFIED_ENTER_NEWLINE) !== 0;
 }
 
 // Recognize ANY modified Enter. Used to consume uncommon modifier combinations
 // outside the Shift/Alt/Ctrl newline set so raw CSI bytes never reach the draft.
 // Plain Enter (mod param = 1, bitmask 0) intentionally remains a submit.
 export function isAnyModifiedEnterSequence(input) {
-  const body = csiBody(String(input ?? ''));
-  if (!body) return false;
-  const kitty = /^13;(\d+)(?::\d+)?(?:;[\d:]+)?u$/.exec(body);
-  if (kitty) return Number(kitty[1]) - 1 !== 0;
-  const modifyOtherKeys = /^27;(\d+);13~$/.exec(body);
-  return Boolean(modifyOtherKeys && Number(modifyOtherKeys[1]) - 1 !== 0);
+  const bits = enterModifierBits(input);
+  return bits !== null && bits !== 0;
 }

package/src/tui/components/prompt-input/escape-key.mjs

@@ -0,0 +1,87 @@
+/*
+ * components/prompt-input/escape-key.mjs — Escape handling for PromptInput.
+ *
+ * Every path ends the key event; the caller returns right after invoking it.
+ */
+import { clearSelection, selectionRange } from '../../input-editing.mjs';
+import { classifyPromptEscape } from './escape-policy.mjs';
+
+export function handleEscapeKey(ctx) {
+  const {
+    draftRef,
+    commitDraft,
+    commandPaletteOpen,
+    onCommandPaletteCancel,
+    onEscape,
+    onInterrupt,
+    interruptActive,
+    hasQueuedMessages,
+    hasMessages,
+    escapeClearAtRef,
+    restoreQueuedToDraft,
+  } = ctx;
+  if (commandPaletteOpen) {
+    onCommandPaletteCancel?.(draftRef.current.value);
+    return;
+  }
+  if (selectionRange(draftRef.current)) {
+    commitDraft(clearSelection(draftRef.current));
+    return;
+  }
+  const currentValue = draftRef.current.value;
+  if (onEscape?.(currentValue, { phase: 'before' }) === true) {
+    return;
+  }
+  let escapeDecision = classifyPromptEscape({
+    interruptActive,
+    hasQueuedMessages,
+    hasMessages,
+    value: currentValue,
+    lastClearPressAt: escapeClearAtRef.current,
+  });
+  if (escapeDecision.action === 'restore-queue') {
+    if (restoreQueuedToDraft()) {
+      escapeClearAtRef.current = 0;
+      return;
+    }
+    // A stale projected queue can empty between render and key handling.
+    // Fall through to the normal draft/idle action in that case.
+    escapeDecision = classifyPromptEscape({
+      interruptActive,
+      hasMessages,
+      value: currentValue,
+      lastClearPressAt: escapeClearAtRef.current,
+    });
+  }
+  escapeClearAtRef.current = escapeDecision.nextClearPressAt;
+  // Active work always wins, even if the user has already typed a steering
+  // draft. The draft is preserved; the old submitted prompt is restored only
+  // when this box is still empty after cancellation.
+  if (escapeDecision.action === 'interrupt') {
+    const restoredText = onInterrupt?.(currentValue);
+    if (!currentValue && typeof restoredText === 'string') {
+      commitDraft({ value: restoredText, cursor: restoredText.length, selectionAnchor: null });
+    }
+    return;
+  }
+  if (escapeDecision.action === 'arm-clear') {
+    onEscape?.(currentValue, { phase: 'clear-arm' });
+    return;
+  }
+  if (escapeDecision.action === 'clear') {
+    onEscape?.(currentValue, { phase: 'clear' });
+    commitDraft({ value: '', cursor: 0, selectionAnchor: null });
+    return;
+  }
+  // Empty draft + conversation history: first press arms, the second
+  // opens the message selector.
+  if (escapeDecision.action === 'arm-select') {
+    onEscape?.('', { phase: 'select-arm' });
+    return;
+  }
+  if (escapeDecision.action === 'message-selector') {
+    onEscape?.('', { phase: 'select' });
+    return;
+  }
+  onEscape?.('', { phase: 'empty' });
+}