Open History to see the last commit
1import type { ChatComposerProps } from "./ChatComposer";
2import { type ComposerCommandItem } from "./ComposerCommandMenu";
3import {
4 type ComposerDispatchMode,
5 resolveComposerDispatchMode,
6} from "@t3tools/client-runtime/state/composer-dispatch";
7import { type ComposerPromptEditorHandle } from "../ComposerPromptEditorTiptap";
8import {
9 type ComposerPromptHistoryPosition,
10 buildComposerPromptHistoryEntries,
11 stepComposerPromptHistory,
12} from "./composerPromptHistory";
13import {
14 type ComposerSubmissionIntent,
15 type ComposerTrigger,
16 collapseExpandedComposerCursor,
17 composerSubmissionIntentForKey,
18} from "../../composer-logic";
19import { type PendingUserInput } from "../../session-logic";
20import { type PreviewAnnotationPayload } from "@t3tools/contracts";
21import { type ReviewCommentContext } from "../../reviewCommentContext";
22import { composerTargetKey } from "../../composerDraftStore";
23import {
24 type ComposerListEdit,
25 listContinuationForEnter,
26 listIndentForTab,
27 listOutdentForTab,
28} from "../../composer-list-continuation";
29import type { Dispatch, RefObject, SetStateAction } from "react";
30
31/**
32 * The composer's key handling inside the editor: send shortcuts, the slash/mention menu,
33 * prompt history on ArrowUp/ArrowDown, plan-mode toggle, prompt suggestions on Tab, and list continuation.
34 * Returns the editor's key handler; it reads the inputs captured by the render that built it.
35 */
36export function composerCommandKeyHandler(input: {
37 readonly keybindings: ChatComposerProps["keybindings"];
38 readonly sendShortcut: ChatComposerProps["settings"]["sendShortcut"];
39 readonly routeKind: ChatComposerProps["routeKind"];
40 readonly phase: ChatComposerProps["phase"];
41 readonly canSteer: boolean;
42 readonly followUpBehavior: ChatComposerProps["settings"]["followUpBehavior"];
43 readonly isSoftwareKeyboardOpen: boolean;
44 readonly isLiteralPendingAnswer: boolean;
45 readonly pendingUserInputs: ReadonlyArray<PendingUserInput>;
46 readonly promptHistoryEntries: ChatComposerProps["promptHistoryEntries"];
47 readonly promptHistoryPositionRef: RefObject<{
48 targetKey: string;
49 position: ComposerPromptHistoryPosition;
50 } | null>;
51 readonly composerDraftTarget: ChatComposerProps["composerDraftTarget"];
52 readonly promptRef: ChatComposerProps["promptRef"];
53 readonly composerImagesRef: ChatComposerProps["composerImagesRef"];
54 readonly composerFilesRef: ChatComposerProps["composerFilesRef"];
55 readonly composerTerminalContextsRef: ChatComposerProps["composerTerminalContextsRef"];
56 readonly composerPreviewAnnotations: ReadonlyArray<PreviewAnnotationPayload>;
57 readonly composerReviewComments: ReadonlyArray<ReviewCommentContext>;
58 readonly composerEditorRef: RefObject<ComposerPromptEditorHandle | null>;
59 readonly composerMenuOpenRef: RefObject<boolean>;
60 readonly composerMenuItemsRef: RefObject<ComposerCommandItem[]>;
61 readonly activeComposerMenuItemRef: RefObject<ComposerCommandItem | null>;
62 readonly setComposerDraftPrompt: (
63 target: ChatComposerProps["composerDraftTarget"],
64 prompt: string,
65 ) => void;
66 readonly setComposerCursor: Dispatch<SetStateAction<number>>;
67 readonly setComposerTrigger: (trigger: ComposerTrigger | null) => void;
68 readonly setComposerHighlightedItemId: Dispatch<SetStateAction<string | null>>;
69 readonly dismissComposerTrigger: (trigger: ComposerTrigger | null) => void;
70 readonly nudgeComposerMenuHighlight: (key: "ArrowDown" | "ArrowUp") => void;
71 readonly onSelectComposerItem: (item: ComposerCommandItem) => void;
72 readonly resolveActiveComposerTrigger: () => { trigger: ComposerTrigger | null };
73 readonly readComposerSnapshot: () => { value: string };
74 readonly applyPromptReplacement: (
75 rangeStart: number,
76 rangeEnd: number,
77 replacement: string,
78 options?: { expandedCursorAfterReplace?: number },
79 ) => boolean;
80 readonly submitComposer: (
81 event: undefined,
82 dispatchMode: ComposerDispatchMode,
83 submissionIntent: ComposerSubmissionIntent,
84 ) => void;
85 /** Predicted next prompt that Tab fills into an empty composer; Escape dismisses it. */
86 readonly promptSuggestion: string | null;
87 readonly dismissPromptSuggestion: () => void;
88}) {
89 const {
90 keybindings,
91 sendShortcut,
92 routeKind,
93 phase,
94 canSteer,
95 followUpBehavior,
96 isSoftwareKeyboardOpen,
97 isLiteralPendingAnswer,
98 pendingUserInputs,
99 promptHistoryEntries,
100 promptHistoryPositionRef,
101 composerDraftTarget,
102 promptRef,
103 composerImagesRef,
104 composerFilesRef,
105 composerTerminalContextsRef,
106 composerPreviewAnnotations,
107 composerReviewComments,
108 composerEditorRef,
109 composerMenuOpenRef,
110 composerMenuItemsRef,
111 activeComposerMenuItemRef,
112 setComposerDraftPrompt,
113 setComposerCursor,
114 setComposerTrigger,
115 setComposerHighlightedItemId,
116 dismissComposerTrigger,
117 nudgeComposerMenuHighlight,
118 onSelectComposerItem,
119 resolveActiveComposerTrigger,
120 readComposerSnapshot,
121 applyPromptReplacement,
122 submitComposer,
123 promptSuggestion,
124 dismissPromptSuggestion,
125 } = input;
126
127 // The composer persists across threads. A recall from thread A must not
128 // be treated as active in thread B, where the text-match fallback could
129 // otherwise turn B's own draft into a browsing position.
130 const promptHistoryTargetKey = composerTargetKey(composerDraftTarget);
131
132 const replacePromptFromHistory = (nextPrompt: string) => {
133 promptRef.current = nextPrompt;
134 setComposerDraftPrompt(composerDraftTarget, nextPrompt);
135 setComposerCursor(collapseExpandedComposerCursor(nextPrompt, nextPrompt.length));
136 setComposerTrigger(null);
137 setComposerHighlightedItemId(null);
138 };
139
140 const navigatePromptHistory = (
141 direction: "backward" | "forward",
142 event: KeyboardEvent,
143 ): boolean => {
144 if (event.shiftKey || event.altKey || event.metaKey || event.ctrlKey || event.isComposing) {
145 return false;
146 }
147 if (pendingUserInputs.length > 0) return false;
148 if (
149 composerImagesRef.current.length > 0 ||
150 composerFilesRef.current.length > 0 ||
151 composerTerminalContextsRef.current.length > 0 ||
152 composerPreviewAnnotations.length > 0 ||
153 composerReviewComments.length > 0
154 ) {
155 return false;
156 }
157 const recalled = promptHistoryPositionRef.current;
158 const position = recalled?.targetKey === promptHistoryTargetKey ? recalled.position : null;
159 if (position === null && promptRef.current.length > 0) {
160 return false;
161 }
162 const editor = composerEditorRef.current;
163 if (!editor?.isCaretOnVisualEdge(direction === "backward" ? "start" : "end")) {
164 return false;
165 }
166 const step = stepComposerPromptHistory({
167 direction,
168 // Built on the keypress, not per render: the timeline changes on every streamed delta.
169 entries: buildComposerPromptHistoryEntries(
170 promptHistoryEntries.flatMap((entry) => (entry.kind === "message" ? [entry.message] : [])),
171 ),
172 position,
173 currentPrompt: promptRef.current,
174 });
175 if (!step) return false;
176 promptHistoryPositionRef.current = step.position
177 ? { targetKey: promptHistoryTargetKey, position: step.position }
178 : null;
179 replacePromptFromHistory(step.prompt);
180 return true;
181 };
182
183 const applyListEdit = (
184 event: KeyboardEvent,
185 listEdit: (value: string, start: number, end: number) => ComposerListEdit | null,
186 ): boolean => {
187 if (isLiteralPendingAnswer || event.isComposing) return false;
188 const selection = composerEditorRef.current?.readSelectionRange();
189 const snapshot = readComposerSnapshot();
190 if (!selection || selection.start !== selection.end || snapshot.value !== promptRef.current) {
191 return false;
192 }
193 const edit = listEdit(snapshot.value, selection.start, selection.end);
194 return (
195 edit !== null &&
196 applyPromptReplacement(edit.start, edit.end, edit.replacement, {
197 expandedCursorAfterReplace: edit.cursorAfter,
198 })
199 );
200 };
201
202 const onComposerCommandKey = (key: string, event: KeyboardEvent, isTaskItem = false) => {
203 const submissionIntent = composerSubmissionIntentForKey({
204 event,
205 keybindings,
206 isSoftwareKeyboardOpen,
207 isDraftThread: routeKind === "draft",
208 isRunning: phase === "running" || phase === "connecting",
209 sendShortcut,
210 prompt: promptRef.current,
211 });
212 if (key === "Tab" && event.shiftKey && submissionIntent === null) {
213 return applyListEdit(event, listOutdentForTab);
214 }
215 const { trigger } = resolveActiveComposerTrigger();
216 const menuIsActive =
217 !isLiteralPendingAnswer && (composerMenuOpenRef.current || trigger !== null);
218 if (key === "Escape") {
219 if (event.isComposing || event.keyCode === 229) return false;
220 if (!menuIsActive && promptSuggestion !== null && promptRef.current.length === 0) {
221 dismissPromptSuggestion();
222 return true;
223 }
224 if (!menuIsActive) return false;
225 dismissComposerTrigger(trigger);
226 composerMenuOpenRef.current = false;
227 return true;
228 }
229 if (menuIsActive && (submissionIntent === null || submissionIntent === "foreground")) {
230 const currentItems = composerMenuItemsRef.current;
231 const selectedItem = activeComposerMenuItemRef.current ?? currentItems[0];
232 if (key === "ArrowDown" && currentItems.length > 0) {
233 nudgeComposerMenuHighlight("ArrowDown");
234 return true;
235 }
236 if (key === "ArrowUp" && currentItems.length > 0) {
237 nudgeComposerMenuHighlight("ArrowUp");
238 return true;
239 }
240 if ((key === "Enter" || key === "Tab") && selectedItem) {
241 onSelectComposerItem(selectedItem);
242 return true;
243 }
244 }
245 if (
246 key === "Tab" &&
247 promptSuggestion !== null &&
248 promptRef.current.length === 0 &&
249 !menuIsActive &&
250 !event.shiftKey &&
251 !event.altKey &&
252 !event.metaKey &&
253 !event.ctrlKey &&
254 !event.isComposing &&
255 event.keyCode !== 229
256 ) {
257 // The typing guard must see this draft, so an approval that lands next is not answered with it.
258 return applyPromptReplacement(0, 0, promptSuggestion);
259 }
260 if ((key === "ArrowUp" || key === "ArrowDown") && submissionIntent === null) {
261 return navigatePromptHistory(key === "ArrowUp" ? "backward" : "forward", event);
262 }
263 if (submissionIntent) {
264 submitComposer(
265 undefined,
266 resolveComposerDispatchMode({
267 running: phase === "running" || phase === "connecting",
268 alternateModifier: submissionIntent === "alternate",
269 activeTurnDefault: followUpBehavior,
270 canSteer,
271 }),
272 submissionIntent,
273 );
274 return true;
275 }
276 if (key === "Enter" && isTaskItem) return false;
277 if (key === "Enter" || (key === "Tab" && !event.shiftKey)) {
278 return applyListEdit(event, key === "Enter" ? listContinuationForEnter : listIndentForTab);
279 }
280 return false;
281 };
282
283 return onComposerCommandKey;
284}