@devries-cameron20 / t3code-1 / commits / e78f580468
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

refactor(web): composer key handling lives in useComposerCommandKey (#23060)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Oct 21, 2026 at 13:23 UTC e78f58046876271109bf6985e8f46769d8e7505d
4 files changed +328 -158
apps/web/src/components/chat/ChatComposer.tsx
+39 -158
@@ -64,16 +64,15 @@ import {
64 type ComposerSubmissionIntent,
65 collapseExpandedComposerCursor,
66 composerRequiresModifier,
67 - composerSubmissionIntentForKey,
67 composerStateAtPromptEnd,
68 detectComposerTrigger,
69 expandCollapsedComposerCursor,
70 formatAssistantCitationForComposer,
71 isPathSuggestionCurrent,
72 + extendReplacementRangeForTrailingSpace,
73 replaceTextRange,
74 } from "../../composer-logic";
75 import { DISCONNECTED_COMPOSER_PLACEHOLDER } from "../../composerPlaceholder";
76 -import { listContinuationForEnter, listIndentForTab } from "../../composer-list-continuation";
76 import {
77 deriveComposerSendState,
78 getAntigravitySendBlockReason,
@@ -259,11 +258,7 @@ import {
258 type Thread,
259 type ThreadShell,
260 } from "../../types";
262 -import {
263 - buildComposerPromptHistoryEntries,
264 - stepComposerPromptHistory,
265 - type ComposerPromptHistoryPosition,
266 -} from "./composerPromptHistory";
261 +import { type ComposerPromptHistoryPosition } from "./composerPromptHistory";
262 import type { PendingUserInputDraftAnswer } from "../../pendingUserInput";
263 import type {
264 LatestProposedPlanState,
@@ -296,6 +291,7 @@ import { useComposerStash } from "./useComposerStash";
291 import { useComposerContextImport } from "./useComposerContextImport";
292 import { useComposerAttachmentIntake } from "./useComposerAttachmentIntake";
293 import { ComposerControlsBar } from "./ComposerControlsBar";
294 +import { useComposerCommandKey } from "./useComposerCommandKey";
295
296 /** Reads and disarms a paste-as-text deadline: the shortcut applies to one paste only. */
297 function consumePasteAsTextShortcut(deadline: { current: number }): boolean {
@@ -304,17 +300,6 @@ function consumePasteAsTextShortcut(deadline: { current: number }): boolean {
300 return armed;
301 }
302
307 -const extendReplacementRangeForTrailingSpace = (
308 - text: string,
309 - rangeEnd: number,
310 - replacement: string,
311 -): number => {
312 - if (!replacement.endsWith(" ")) {
313 - return rangeEnd;
314 - }
315 - return text[rangeEnd] === " " ? rangeEnd + 1 : rangeEnd;
316 -};
317 -
303 const runtimeModeOptions = runtimeModes.map((mode) => ({ mode, ...runtimeModeConfig[mode] }));
304
305 export interface ChatComposerHandle {
@@ -2258,148 +2243,44 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
2243 };
2244 const expandMobileComposerStable = useStableCallback(expandMobileComposer);
2245
2261 - // Entries are built on the keypress, not per render: the timeline changes
2262 - // on every streamed delta and ArrowUp is rare.
2263 - const promptHistoryMessagesRef = useRef(promptHistoryMessages);
2264 - useLayoutEffect(() => {
2265 - promptHistoryMessagesRef.current = promptHistoryMessages;
2246 + const { onComposerCommandKey } = useComposerCommandKey({
2247 + keybindings,
2248 + sendShortcut: settings.sendShortcut,
2249 + routeKind,
2250 + phase,
2251 + isCompacting,
2252 + followUpBehavior,
2253 + isSoftwareKeyboardOpen,
2254 + planModeUiEnabled,
2255 + isLiteralPendingAnswer,
2256 + pendingUserInputs,
2257 + promptHistoryMessages,
2258 + promptHistoryPositionRef,
2259 + composerDraftTarget,
2260 + promptRef,
2261 + composerImagesRef,
2262 + composerFilesRef,
2263 + composerTerminalContextsRef,
2264 + composerPreviewAnnotations,
2265 + composerReviewComments,
2266 + composerEditorRef,
2267 + composerMenuOpenRef,
2268 + composerMenuItemsRef,
2269 + activeComposerMenuItemRef,
2270 + setComposerDraftPrompt,
2271 + setComposerCursor,
2272 + setComposerTrigger,
2273 + setComposerHighlightedItemId,
2274 + dismissComposerTrigger,
2275 + toggleInteractionMode,
2276 + nudgeComposerMenuHighlight,
2277 + onSelectComposerItem,
2278 + resolveActiveComposerTrigger,
2279 + readComposerSnapshot,
2280 + applyPromptReplacement,
2281 + submitComposer,
2282 });
2283
2268 - // The composer persists across threads. A recall from thread A must not
2269 - // be treated as active in thread B, where the text-match fallback could
2270 - // otherwise turn B's own draft into a browsing position.
2271 - const promptHistoryTargetKey = composerTargetKey(composerDraftTarget);
2272 -
2273 - const replacePromptFromHistory = (nextPrompt: string) => {
2274 - promptRef.current = nextPrompt;
2275 - setComposerDraftPrompt(composerDraftTarget, nextPrompt);
2276 - setComposerCursor(collapseExpandedComposerCursor(nextPrompt, nextPrompt.length));
2277 - setComposerTrigger(null);
2278 - setComposerHighlightedItemId(null);
2279 - };
2280 -
2281 - const navigatePromptHistory = (
2282 - direction: "backward" | "forward",
2283 - event: KeyboardEvent,
2284 - ): boolean => {
2285 - if (event.shiftKey || event.altKey || event.metaKey || event.ctrlKey || event.isComposing) {
2286 - return false;
2287 - }
2288 - if (pendingUserInputs.length > 0) return false;
2289 - if (
2290 - composerImagesRef.current.length > 0 ||
2291 - composerFilesRef.current.length > 0 ||
2292 - composerTerminalContextsRef.current.length > 0 ||
2293 - composerPreviewAnnotations.length > 0 ||
2294 - composerReviewComments.length > 0
2295 - ) {
2296 - return false;
2297 - }
2298 - const recalled = promptHistoryPositionRef.current;
2299 - const position = recalled?.targetKey === promptHistoryTargetKey ? recalled.position : null;
2300 - if (position === null && promptRef.current.length > 0) {
2301 - return false;
2302 - }
2303 - const editor = composerEditorRef.current;
2304 - if (!editor?.isCaretOnVisualEdge(direction === "backward" ? "start" : "end")) {
2305 - return false;
2306 - }
2307 - const step = stepComposerPromptHistory({
2308 - direction,
2309 - entries: buildComposerPromptHistoryEntries(promptHistoryMessagesRef.current),
2310 - position,
2311 - currentPrompt: promptRef.current,
2312 - });
2313 - if (!step) return false;
2314 - promptHistoryPositionRef.current = step.position
2315 - ? { targetKey: promptHistoryTargetKey, position: step.position }
2316 - : null;
2317 - replacePromptFromHistory(step.prompt);
2318 - return true;
2319 - };
2320 -
2321 - const onComposerCommandKey = (key: string, event: KeyboardEvent, isTaskItem = false) => {
2322 - const submissionIntent = composerSubmissionIntentForKey({
2323 - event,
2324 - keybindings,
2325 - isSoftwareKeyboardOpen,
2326 - isDraftThread: routeKind === "draft",
2327 - isRunning: phase === "running",
2328 - sendShortcut: settings.sendShortcut,
2329 - prompt: promptRef.current,
2330 - });
2331 - if (key === "Tab" && event.shiftKey && submissionIntent === null) {
2332 - if (!planModeUiEnabled) return false;
2333 - toggleInteractionMode();
2334 - return true;
2335 - }
2336 - const { trigger } = resolveActiveComposerTrigger();
2337 - const menuIsActive =
2338 - !isLiteralPendingAnswer && (composerMenuOpenRef.current || trigger !== null);
2339 - if (key === "Escape") {
2340 - if (!menuIsActive || event.isComposing || event.keyCode === 229) return false;
2341 - dismissComposerTrigger(trigger);
2342 - composerMenuOpenRef.current = false;
2343 - return true;
2344 - }
2345 - if (menuIsActive && (submissionIntent === null || submissionIntent === "foreground")) {
2346 - const currentItems = composerMenuItemsRef.current;
2347 - const selectedItem = activeComposerMenuItemRef.current ?? currentItems[0];
2348 - if (key === "ArrowDown" && currentItems.length > 0) {
2349 - nudgeComposerMenuHighlight("ArrowDown");
2350 - return true;
2351 - }
2352 - if (key === "ArrowUp" && currentItems.length > 0) {
2353 - nudgeComposerMenuHighlight("ArrowUp");
2354 - return true;
2355 - }
2356 - if ((key === "Enter" || key === "Tab") && selectedItem) {
2357 - onSelectComposerItem(selectedItem);
2358 - return true;
2359 - }
2360 - }
2361 - if ((key === "ArrowUp" || key === "ArrowDown") && submissionIntent === null) {
2362 - return navigatePromptHistory(key === "ArrowUp" ? "backward" : "forward", event);
2363 - }
2364 - if (submissionIntent) {
2365 - submitComposer(
2366 - undefined,
2367 - resolveComposerDispatchMode({
2368 - running: phase === "running",
2369 - alternateModifier: submissionIntent === "alternate",
2370 - activeTurnDefault: followUpBehavior,
2371 - canSteer: !isCompacting,
2372 - }),
2373 - submissionIntent,
2374 - );
2375 - return true;
2376 - }
2377 - if (key === "Enter" && isTaskItem) return false;
2378 - if (
2379 - !isLiteralPendingAnswer &&
2380 - !event.isComposing &&
2381 - (key === "Enter" || (key === "Tab" && !event.shiftKey))
2382 - ) {
2383 - const selection = composerEditorRef.current?.readSelectionRange();
2384 - const snapshot = readComposerSnapshot();
2385 - if (selection && selection.start === selection.end && snapshot.value === promptRef.current) {
2386 - const edit =
2387 - key === "Enter"
2388 - ? listContinuationForEnter(snapshot.value, selection.start)
2389 - : listIndentForTab(snapshot.value, selection.start, selection.end);
2390 - if (
2391 - edit &&
2392 - applyPromptReplacement(edit.start, edit.end, edit.replacement, {
2393 - expandedCursorAfterReplace: edit.cursorAfter,
2394 - })
2395 - ) {
2396 - return true;
2397 - }
2398 - }
2399 - }
2400 - return false;
2401 - };
2402 -
2284 const {
2285 stashQueue,
2286 isStashMenuOpen,
apps/web/src/components/chat/useComposerCommandKey.ts new
+264
@@ -0,0 +1,264 @@
1 +import type { ChatComposerProps } from "./ChatComposer";
2 +import { type ComposerCommandItem } from "./ComposerCommandMenu";
3 +import {
4 + type ComposerDispatchMode,
5 + resolveComposerDispatchMode,
6 +} from "@t3tools/client-runtime/state/composer-dispatch";
7 +import { type ComposerPromptEditorHandle } from "../ComposerPromptEditor";
8 +import {
9 + type ComposerPromptHistoryPosition,
10 + buildComposerPromptHistoryEntries,
11 + stepComposerPromptHistory,
12 +} from "./composerPromptHistory";
13 +import {
14 + type ComposerSubmissionIntent,
15 + type ComposerTrigger,
16 + collapseExpandedComposerCursor,
17 + composerSubmissionIntentForKey,
18 +} from "../../composer-logic";
19 +import { type PendingUserInput } from "../../session-logic";
20 +import { type PreviewAnnotationPayload } from "@t3tools/contracts";
21 +import { type ReviewCommentContext } from "../../reviewCommentContext";
22 +import { composerTargetKey } from "../../composerDraftStore";
23 +import { listContinuationForEnter, listIndentForTab } from "../../composer-list-continuation";
24 +import { type Dispatch, type RefObject, type SetStateAction, useLayoutEffect, useRef } from "react";
25 +
26 +/**
27 + * The composer's key handling inside the editor: send shortcuts, the slash/mention menu,
28 + * prompt history on ArrowUp/ArrowDown, plan-mode toggle, and list continuation.
29 + */
30 +export function useComposerCommandKey(input: {
31 + readonly keybindings: ChatComposerProps["keybindings"];
32 + readonly sendShortcut: ChatComposerProps["settings"]["sendShortcut"];
33 + readonly routeKind: ChatComposerProps["routeKind"];
34 + readonly phase: ChatComposerProps["phase"];
35 + readonly isCompacting: boolean;
36 + readonly followUpBehavior: ChatComposerProps["settings"]["followUpBehavior"];
37 + readonly isSoftwareKeyboardOpen: boolean;
38 + readonly planModeUiEnabled: boolean;
39 + readonly isLiteralPendingAnswer: boolean;
40 + readonly pendingUserInputs: ReadonlyArray<PendingUserInput>;
41 + readonly promptHistoryMessages: ChatComposerProps["promptHistoryMessages"];
42 + readonly promptHistoryPositionRef: RefObject<{
43 + targetKey: string;
44 + position: ComposerPromptHistoryPosition;
45 + } | null>;
46 + readonly composerDraftTarget: ChatComposerProps["composerDraftTarget"];
47 + readonly promptRef: ChatComposerProps["promptRef"];
48 + readonly composerImagesRef: ChatComposerProps["composerImagesRef"];
49 + readonly composerFilesRef: ChatComposerProps["composerFilesRef"];
50 + readonly composerTerminalContextsRef: ChatComposerProps["composerTerminalContextsRef"];
51 + readonly composerPreviewAnnotations: ReadonlyArray<PreviewAnnotationPayload>;
52 + readonly composerReviewComments: ReadonlyArray<ReviewCommentContext>;
53 + readonly composerEditorRef: RefObject<ComposerPromptEditorHandle | null>;
54 + readonly composerMenuOpenRef: RefObject<boolean>;
55 + readonly composerMenuItemsRef: RefObject<ComposerCommandItem[]>;
56 + readonly activeComposerMenuItemRef: RefObject<ComposerCommandItem | null>;
57 + readonly setComposerDraftPrompt: (
58 + target: ChatComposerProps["composerDraftTarget"],
59 + prompt: string,
60 + ) => void;
61 + readonly setComposerCursor: Dispatch<SetStateAction<number>>;
62 + readonly setComposerTrigger: (trigger: ComposerTrigger | null) => void;
63 + readonly setComposerHighlightedItemId: Dispatch<SetStateAction<string | null>>;
64 + readonly dismissComposerTrigger: (trigger: ComposerTrigger | null) => void;
65 + readonly toggleInteractionMode: () => void;
66 + readonly nudgeComposerMenuHighlight: (key: "ArrowDown" | "ArrowUp") => void;
67 + readonly onSelectComposerItem: (item: ComposerCommandItem) => void;
68 + readonly resolveActiveComposerTrigger: () => { trigger: ComposerTrigger | null };
69 + readonly readComposerSnapshot: () => { value: string };
70 + readonly applyPromptReplacement: (
71 + rangeStart: number,
72 + rangeEnd: number,
73 + replacement: string,
74 + options?: { expandedCursorAfterReplace?: number },
75 + ) => boolean;
76 + readonly submitComposer: (
77 + event: undefined,
78 + dispatchMode: ComposerDispatchMode,
79 + submissionIntent: ComposerSubmissionIntent,
80 + ) => void;
81 +}) {
82 + const {
83 + keybindings,
84 + sendShortcut,
85 + routeKind,
86 + phase,
87 + isCompacting,
88 + followUpBehavior,
89 + isSoftwareKeyboardOpen,
90 + planModeUiEnabled,
91 + isLiteralPendingAnswer,
92 + pendingUserInputs,
93 + promptHistoryMessages,
94 + promptHistoryPositionRef,
95 + composerDraftTarget,
96 + promptRef,
97 + composerImagesRef,
98 + composerFilesRef,
99 + composerTerminalContextsRef,
100 + composerPreviewAnnotations,
101 + composerReviewComments,
102 + composerEditorRef,
103 + composerMenuOpenRef,
104 + composerMenuItemsRef,
105 + activeComposerMenuItemRef,
106 + setComposerDraftPrompt,
107 + setComposerCursor,
108 + setComposerTrigger,
109 + setComposerHighlightedItemId,
110 + dismissComposerTrigger,
111 + toggleInteractionMode,
112 + nudgeComposerMenuHighlight,
113 + onSelectComposerItem,
114 + resolveActiveComposerTrigger,
115 + readComposerSnapshot,
116 + applyPromptReplacement,
117 + submitComposer,
118 + } = input;
119 + // Entries are built on the keypress, not per render: the timeline changes
120 + // on every streamed delta and ArrowUp is rare.
121 + const promptHistoryMessagesRef = useRef(promptHistoryMessages);
122 + useLayoutEffect(() => {
123 + promptHistoryMessagesRef.current = promptHistoryMessages;
124 + });
125 +
126 + // The composer persists across threads. A recall from thread A must not
127 + // be treated as active in thread B, where the text-match fallback could
128 + // otherwise turn B's own draft into a browsing position.
129 + const promptHistoryTargetKey = composerTargetKey(composerDraftTarget);
130 +
131 + const replacePromptFromHistory = (nextPrompt: string) => {
132 + promptRef.current = nextPrompt;
133 + setComposerDraftPrompt(composerDraftTarget, nextPrompt);
134 + setComposerCursor(collapseExpandedComposerCursor(nextPrompt, nextPrompt.length));
135 + setComposerTrigger(null);
136 + setComposerHighlightedItemId(null);
137 + };
138 +
139 + const navigatePromptHistory = (
140 + direction: "backward" | "forward",
141 + event: KeyboardEvent,
142 + ): boolean => {
143 + if (event.shiftKey || event.altKey || event.metaKey || event.ctrlKey || event.isComposing) {
144 + return false;
145 + }
146 + if (pendingUserInputs.length > 0) return false;
147 + if (
148 + composerImagesRef.current.length > 0 ||
149 + composerFilesRef.current.length > 0 ||
150 + composerTerminalContextsRef.current.length > 0 ||
151 + composerPreviewAnnotations.length > 0 ||
152 + composerReviewComments.length > 0
153 + ) {
154 + return false;
155 + }
156 + const recalled = promptHistoryPositionRef.current;
157 + const position = recalled?.targetKey === promptHistoryTargetKey ? recalled.position : null;
158 + if (position === null && promptRef.current.length > 0) {
159 + return false;
160 + }
161 + const editor = composerEditorRef.current;
162 + if (!editor?.isCaretOnVisualEdge(direction === "backward" ? "start" : "end")) {
163 + return false;
164 + }
165 + const step = stepComposerPromptHistory({
166 + direction,
167 + entries: buildComposerPromptHistoryEntries(promptHistoryMessagesRef.current),
168 + position,
169 + currentPrompt: promptRef.current,
170 + });
171 + if (!step) return false;
172 + promptHistoryPositionRef.current = step.position
173 + ? { targetKey: promptHistoryTargetKey, position: step.position }
174 + : null;
175 + replacePromptFromHistory(step.prompt);
176 + return true;
177 + };
178 +
179 + const onComposerCommandKey = (key: string, event: KeyboardEvent, isTaskItem = false) => {
180 + const submissionIntent = composerSubmissionIntentForKey({
181 + event,
182 + keybindings,
183 + isSoftwareKeyboardOpen,
184 + isDraftThread: routeKind === "draft",
185 + isRunning: phase === "running",
186 + sendShortcut,
187 + prompt: promptRef.current,
188 + });
189 + if (key === "Tab" && event.shiftKey && submissionIntent === null) {
190 + if (!planModeUiEnabled) return false;
191 + toggleInteractionMode();
192 + return true;
193 + }
194 + const { trigger } = resolveActiveComposerTrigger();
195 + const menuIsActive =
196 + !isLiteralPendingAnswer && (composerMenuOpenRef.current || trigger !== null);
197 + if (key === "Escape") {
198 + if (!menuIsActive || event.isComposing || event.keyCode === 229) return false;
199 + dismissComposerTrigger(trigger);
200 + composerMenuOpenRef.current = false;
201 + return true;
202 + }
203 + if (menuIsActive && (submissionIntent === null || submissionIntent === "foreground")) {
204 + const currentItems = composerMenuItemsRef.current;
205 + const selectedItem = activeComposerMenuItemRef.current ?? currentItems[0];
206 + if (key === "ArrowDown" && currentItems.length > 0) {
207 + nudgeComposerMenuHighlight("ArrowDown");
208 + return true;
209 + }
210 + if (key === "ArrowUp" && currentItems.length > 0) {
211 + nudgeComposerMenuHighlight("ArrowUp");
212 + return true;
213 + }
214 + if ((key === "Enter" || key === "Tab") && selectedItem) {
215 + onSelectComposerItem(selectedItem);
216 + return true;
217 + }
218 + }
219 + if ((key === "ArrowUp" || key === "ArrowDown") && submissionIntent === null) {
220 + return navigatePromptHistory(key === "ArrowUp" ? "backward" : "forward", event);
221 + }
222 + if (submissionIntent) {
223 + submitComposer(
224 + undefined,
225 + resolveComposerDispatchMode({
226 + running: phase === "running",
227 + alternateModifier: submissionIntent === "alternate",
228 + activeTurnDefault: followUpBehavior,
229 + canSteer: !isCompacting,
230 + }),
231 + submissionIntent,
232 + );
233 + return true;
234 + }
235 + if (key === "Enter" && isTaskItem) return false;
236 + if (
237 + !isLiteralPendingAnswer &&
238 + !event.isComposing &&
239 + (key === "Enter" || (key === "Tab" && !event.shiftKey))
240 + ) {
241 + const selection = composerEditorRef.current?.readSelectionRange();
242 + const snapshot = readComposerSnapshot();
243 + if (selection && selection.start === selection.end && snapshot.value === promptRef.current) {
244 + const edit =
245 + key === "Enter"
246 + ? listContinuationForEnter(snapshot.value, selection.start)
247 + : listIndentForTab(snapshot.value, selection.start, selection.end);
248 + if (
249 + edit &&
250 + applyPromptReplacement(edit.start, edit.end, edit.replacement, {
251 + expandedCursorAfterReplace: edit.cursorAfter,
252 + })
253 + ) {
254 + return true;
255 + }
256 + }
257 + }
258 + return false;
259 + };
260 +
261 + return {
262 + onComposerCommandKey,
263 + };
264 +}
apps/web/src/composer-logic.test.ts
+10
@@ -19,6 +19,7 @@ import {
19 composerStateAtPromptEnd,
20 detectComposerTrigger,
21 expandCollapsedComposerCursor,
22 + extendReplacementRangeForTrailingSpace,
23 formatAssistantCitationForComposer,
24 isCollapsedCursorAdjacentToInlineToken,
25 isPathSuggestionCurrent,
@@ -551,3 +552,12 @@ describe("literal editor answer cursor state", () => {
552 expect(composerStateAtPromptEnd("Use $my").trigger?.kind).toBe("skill");
553 });
554 });
555 +
556 +describe("extendReplacementRangeForTrailingSpace", () => {
557 + it("swallows one existing space after the range when the replacement ends with one", () => {
558 + expect(extendReplacementRangeForTrailingSpace("@fi rest", 3, "@file ")).toBe(4);
559 + expect(extendReplacementRangeForTrailingSpace("@firest", 3, "@file ")).toBe(3);
560 + expect(extendReplacementRangeForTrailingSpace("@fi rest", 3, "@file")).toBe(3);
561 + expect(extendReplacementRangeForTrailingSpace("@fi", 3, "@file ")).toBe(3);
562 + });
563 +});
apps/web/src/composer-logic.ts
+15
@@ -359,6 +359,21 @@ export function parseStandaloneComposerSlashCommand(
359 return "default";
360 }
361
362 +/**
363 + * A replacement ending in a space swallows one space already after the range, so inserting
364 + * `@file ` before existing text does not leave a double space.
365 + */
366 +export function extendReplacementRangeForTrailingSpace(
367 + text: string,
368 + rangeEnd: number,
369 + replacement: string,
370 +): number {
371 + if (!replacement.endsWith(" ")) {
372 + return rangeEnd;
373 + }
374 + return text[rangeEnd] === " " ? rangeEnd + 1 : rangeEnd;
375 +}
376 +
377 export function replaceTextRange(
378 text: string,
379 rangeStart: number,