mixdog 0.9.3 → 0.9.4

package/src/tui/app/use-prompt-handlers.mjs

@@ -0,0 +1,310 @@
+/**
+ * use-prompt-handlers.mjs — the PROMPT HANDLER cluster extracted from App.jsx
+ * (pass-7 split).
+ *
+ * Exports usePromptHandlers(), which owns the five useCallback handlers wired to
+ * PromptInput: handleVoiceToggle / handlePromptPaste / handlePromptHistoryNavigate
+ * / handlePromptEscape / handlePromptInterrupt. Every ref, setter, store value and
+ * derived value the handlers close over is threaded in explicitly so the deps
+ * arrays stay byte-identical to the original inline hooks. Import-level helpers
+ * (voice recorder + paste attachments) are imported directly here.
+ */
+import { useCallback } from 'react';
+import {
+  readClipboardImageAttachment,
+  readImageAttachmentFromPath,
+  splitPastedImagePathCandidates,
+} from '../paste-attachments.mjs';
+import {
+  shouldFoldPastedText,
+} from '../paste-attachments.mjs';
+import {
+  isVoiceEnabled,
+  getRecorderState,
+  startRecording,
+  stopRecording,
+  cancelRecording,
+} from '../lib/voice-recorder.mjs';
+import { promptHistoryKey } from '../prompt-history-store.mjs';
+
+export function usePromptHandlers({
+  store,
+  state,
+  // refs
+  promptValueRef,
+  pastedImagesRef,
+  nextPastedImageIdRef,
+  pastedTextsRef,
+  nextPastedTextIdRef,
+  promptHistoryNavRef,
+  promptHistoryDraftChangeRef,
+  // setters
+  setPastedImages,
+  setPastedTexts,
+  setPromptDraftOverride,
+  setVoiceRecPhase,
+  setContextPanel,
+  // derived / helper values + callbacks
+  setVoiceStatusHint,
+  syncPromptLayoutRows,
+  showPromptHint,
+  clearPromptHint,
+  recentPromptHistory,
+  resetPromptHistoryNav,
+  restoreQueuedToPrompt,
+  usagePanel,
+  closeUsagePanel,
+  contextPanel,
+  // paste-attachment helpers (owned by App, threaded in explicitly)
+  installPastedImages,
+  clearPastedImagesSnapshot,
+  registerPastedImage,
+  installPastedTexts,
+  clearPastedTextsSnapshot,
+  registerPastedText,
+}) {
+  // Ctrl+Space handler wired to PromptInput's onVoiceToggle. Dispatches on the
+  // recorder's CURRENT state (idle/recording/transcribing) — see
+  // src/tui/lib/voice-recorder.mjs for the state machine itself.
+  const handleVoiceToggle = useCallback(async () => {
+    if (!isVoiceEnabled()) {
+      store.pushNotice('Voice is off — run /voice to turn it on', 'warn');
+      return;
+    }
+    const recState = getRecorderState();
+    if (recState === 'transcribing') {
+      store.pushNotice('Voice: already transcribing…', 'info');
+      return;
+    }
+    if (recState === 'recording') {
+      setVoiceStatusHint('… transcribing', 'info');
+      setVoiceRecPhase('transcribing');
+      let result;
+      try {
+        result = await stopRecording();
+      } catch (e) {
+        result = { ok: false, reason: e?.message || String(e) };
+      }
+      setVoiceStatusHint('', 'info');
+      setVoiceRecPhase('idle');
+      if (!result) return; // race: recorder was no longer RECORDING
+      if (!result.ok) {
+        store.pushNotice(`Voice: ${result.reason || 'transcription failed'}`, 'error');
+        return;
+      }
+      const text = String(result.text || '').trim();
+      if (!text) {
+        store.pushNotice('Voice: no speech detected', 'warn');
+        return;
+      }
+      // End-of-draft insertion via promptDraftOverride (approved design —
+      // no cursor-position insert; see gamerscroll skill's out-of-scope note
+      // on PromptInput's imperative surface).
+      // Med-4: promptValueRef.current is read HERE — after `await
+      // stopRecording()` has already resolved — not captured earlier before
+      // the await. PromptInput keeps valueRef.current live on every
+      // keystroke (commitDraft), so this always reflects whatever the user
+      // typed during the recording+transcribe window; nothing typed in that
+      // gap is overwritten.
+      const current = promptValueRef.current || '';
+      const next = current ? `${current}${/\s$/.test(current) ? '' : ' '}${text}` : text;
+      syncPromptLayoutRows(next);
+      setPromptDraftOverride({ id: Date.now(), value: next });
+      return;
+    }
+    // idle -> recording
+    let result;
+    try {
+      result = await startRecording();
+    } catch (e) {
+      result = { ok: false, reason: e?.message || String(e) };
+    }
+    if (!result?.ok) {
+      store.pushNotice(`Voice: ${result?.reason || 'failed to start recording'}`, 'error');
+      return;
+    }
+    setVoiceStatusHint('● REC', 'error');
+    setVoiceRecPhase('recording');
+  }, [store, setVoiceStatusHint, syncPromptLayoutRows]);
+
+  const handlePromptPaste = useCallback((text, meta = {}) => {
+    const source = String(meta?.source || 'paste');
+    const value = String(text ?? '');
+    if (source === 'clipboard-image-shortcut' && !value) {
+      return readClipboardImageAttachment()
+        .then((image) => {
+          if (!image) {
+            showPromptHint('no image found on clipboard', 'plain');
+            return false;
+          }
+          const ref = registerPastedImage(image);
+          showPromptHint(`attached ${image.filename || 'clipboard image'}`, 'plain');
+          return ref;
+        })
+        .catch((e) => {
+          showPromptHint(`image paste failed: ${e?.message || e}`, 'warn');
+          return false;
+        });
+    }
+
+    const chunks = splitPastedImagePathCandidates(value);
+    const hasImagePath = chunks.some((chunk) => chunk.imagePath);
+    // No image paths in the paste: fold the whole text into a token when it is
+    // large, otherwise let PromptInput insert it raw (return undefined).
+    if (!hasImagePath) {
+      if (shouldFoldPastedText(value)) return registerPastedText(value);
+      return undefined;
+    }
+    // Mixed paste: resolve each image chunk to an image ref, then fold each
+    // CONTIGUOUS run of non-image text into its own token (only if over
+    // threshold) so content order around image refs is preserved. '\n'
+    // separator chunks are plain text and stay inside their surrounding run.
+    return Promise.all(chunks.map(async (chunk) => {
+      if (!chunk.imagePath) return chunk.text;
+      try {
+        const image = await readImageAttachmentFromPath(chunk.text, state.cwd || process.cwd());
+        if (!image) return chunk.text;
+        const ref = registerPastedImage(image);
+        showPromptHint(`attached ${image.filename || 'image'}`, 'plain');
+        return ref;
+      } catch (e) {
+        showPromptHint(`image attach failed: ${e?.message || e}`, 'warn');
+        return chunk.text;
+      }
+    })).then((parts) => {
+      let out = '';
+      let run = '';
+      const flushRun = () => {
+        if (!run) return;
+        out += shouldFoldPastedText(run) ? registerPastedText(run) : run;
+        run = '';
+      };
+      for (let i = 0; i < chunks.length; i += 1) {
+        if (chunks[i].imagePath) {
+          flushRun();
+          out += parts[i];
+        } else {
+          run += parts[i];
+        }
+      }
+      flushRun();
+      return out;
+    });
+  }, [registerPastedImage, registerPastedText, showPromptHint, state.cwd]);
+
+  const handlePromptHistoryNavigate = useCallback((direction, currentText = '', meta = {}) => {
+    const currentValue = String(currentText || '');
+    const currentKey = promptHistoryKey(currentValue);
+    const nav = promptHistoryNavRef.current || { active: false, index: -1, seed: '', lastValue: '' };
+
+    if (meta.emptyDraft && direction === 'down') {
+      resetPromptHistoryNav();
+      clearPromptHint();
+      return undefined;
+    }
+
+    if (recentPromptHistory.length === 0) {
+      resetPromptHistoryNav();
+      clearPromptHint();
+      return undefined;
+    }
+
+    if (direction === 'down' && !nav.active) {
+      clearPromptHint();
+      return undefined;
+    }
+
+    const active = nav.active && (currentValue === nav.lastValue || currentValue === nav.seed);
+    const seed = active ? nav.seed : currentValue;
+    const step = direction === 'down' ? -1 : 1;
+    let nextIndex = (active ? nav.index : -1) + step;
+
+    if (nextIndex < 0) {
+      resetPromptHistoryNav();
+      clearPromptHint();
+      promptHistoryDraftChangeRef.current = true;
+      return seed;
+    }
+
+    while (nextIndex >= 0 && nextIndex < recentPromptHistory.length && promptHistoryKey(recentPromptHistory[nextIndex]) === currentKey) {
+      nextIndex += step;
+    }
+
+    if (nextIndex < 0) {
+      resetPromptHistoryNav();
+      clearPromptHint();
+      promptHistoryDraftChangeRef.current = true;
+      return seed;
+    }
+
+    if (nextIndex >= recentPromptHistory.length) {
+      clearPromptHint();
+      return undefined;
+    }
+
+    const nextValue = recentPromptHistory[nextIndex];
+    promptHistoryNavRef.current = { active: true, index: nextIndex, seed, lastValue: nextValue };
+    clearPromptHint();
+    promptHistoryDraftChangeRef.current = true;
+    return nextValue;
+  }, [recentPromptHistory, resetPromptHistoryNav, clearPromptHint]);
+
+  // ESC / Up handling (prompt input):
+  // - prompt-local overlays such as the slash palette close first.
+  // - queued editable messages pop back into the prompt before clear/interrupt.
+  // - non-empty prompt text is cleared by PromptInput and must never interrupt
+  //   the active turn on the same Esc press.
+  // - empty prompt + active turn interrupts the active turn.
+  const handlePromptEscape = useCallback((text = '', meta = {}) => {
+    // Recording takes priority over every other Esc branch (usage/context
+    // panels, slash-clear, queue-restore, turn-interrupt): a live mic capture
+    // must never silently keep running because Esc was consumed by something
+    // else first. Only consumes Esc while actually RECORDING — transcribing
+    // (already stopped, awaiting the HTTP round-trip) and idle fall through
+    // to the existing branches unchanged.
+    if (getRecorderState() === 'recording') {
+      cancelRecording();
+      setVoiceStatusHint('', 'info');
+      setVoiceRecPhase('idle');
+      store.pushNotice('Voice: recording cancelled', 'plain');
+      return true;
+    }
+    if (usagePanel) { closeUsagePanel(); return true; }
+    if (contextPanel) { setContextPanel(null); return true; }
+
+    if (meta.phase === 'clear') {
+      clearPastedImagesSnapshot();
+      clearPromptHint();
+      return false;
+    }
+    if (meta.phase === 'empty') {
+      return restoreQueuedToPrompt({ restoreDraft: true, showHint: false, currentText: text });
+    }
+    // Idle + empty + nothing to restore: nothing (double-press from empty
+    // opens message selector, but we don't have that feature yet).
+    return false;
+  }, [contextPanel, usagePanel, closeUsagePanel, restoreQueuedToPrompt, clearPromptHint, clearPastedImagesSnapshot, setVoiceStatusHint, store]);
+
+  const handlePromptInterrupt = useCallback((currentText = '') => {
+    const result = store.abort?.();
+    if (result?.aborted === false) return undefined;
+    if (result?.pastedImages) installPastedImages(result.pastedImages, { merge: true });
+    if (result?.discardPastedImages) clearPastedImagesSnapshot(result.discardPastedImages);
+    if (result?.pastedTexts) installPastedTexts(result.pastedTexts, { merge: true });
+    if (result?.discardPastedTexts) clearPastedTextsSnapshot(result.discardPastedTexts);
+    const restoreText = String(result?.restoreText || '').trim();
+    if (!restoreText) return undefined;
+    const existingText = String(currentText || '').trim();
+    const nextText = [restoreText, existingText].filter(Boolean).join('\n');
+    clearPromptHint();
+    return nextText;
+  }, [store, clearPromptHint, installPastedImages, clearPastedImagesSnapshot]);
+
+  return {
+    handleVoiceToggle,
+    handlePromptPaste,
+    handlePromptHistoryNavigate,
+    handlePromptEscape,
+    handlePromptInterrupt,
+  };
+}