diff --git a/packages/coding-agent/src/modes/interactive/components/custom-editor.ts b/packages/coding-agent/src/modes/interactive/components/custom-editor.ts index a63932bd..92b8ab0c 100644 --- a/packages/coding-agent/src/modes/interactive/components/custom-editor.ts +++ b/packages/coding-agent/src/modes/interactive/components/custom-editor.ts @@ -1,4 +1,4 @@ -import { Editor } from "@mariozechner/pi-tui"; +import { Editor, isCtrlC, isCtrlD, isCtrlO, isCtrlP, isCtrlT, isShiftTab } from "@mariozechner/pi-tui"; /** * Custom editor that handles Escape and Ctrl+C keys for coding-agent @@ -6,6 +6,7 @@ import { Editor } from "@mariozechner/pi-tui"; export class CustomEditor extends Editor { public onEscape?: () => void; public onCtrlC?: () => void; + public onCtrlD?: () => void; public onShiftTab?: () => void; public onCtrlP?: () => void; public onCtrlO?: () => void; @@ -13,25 +14,25 @@ export class CustomEditor extends Editor { handleInput(data: string): void { // Intercept Ctrl+T for thinking block visibility toggle - if (data === "\x14" && this.onCtrlT) { + if (isCtrlT(data) && this.onCtrlT) { this.onCtrlT(); return; } // Intercept Ctrl+O for tool output expansion - if (data === "\x0f" && this.onCtrlO) { + if (isCtrlO(data) && this.onCtrlO) { this.onCtrlO(); return; } // Intercept Ctrl+P for model cycling - if (data === "\x10" && this.onCtrlP) { + if (isCtrlP(data) && this.onCtrlP) { this.onCtrlP(); return; } // Intercept Shift+Tab for thinking level cycling - if (data === "\x1b[Z" && this.onShiftTab) { + if (isShiftTab(data) && this.onShiftTab) { this.onShiftTab(); return; } @@ -44,11 +45,20 @@ export class CustomEditor extends Editor { } // Intercept Ctrl+C - if (data === "\x03" && this.onCtrlC) { + if (isCtrlC(data) && this.onCtrlC) { this.onCtrlC(); return; } + // Intercept Ctrl+D (only when editor is empty) + if (isCtrlD(data)) { + if (this.getText().length === 0 && this.onCtrlD) { + this.onCtrlD(); + } + // Always consume Ctrl+D (don't pass to parent) + return; + } + // Pass to parent for normal handling super.handleInput(data); } diff --git a/packages/coding-agent/src/modes/interactive/components/session-selector.ts b/packages/coding-agent/src/modes/interactive/components/session-selector.ts index 3db54b8a..cbc96696 100644 --- a/packages/coding-agent/src/modes/interactive/components/session-selector.ts +++ b/packages/coding-agent/src/modes/interactive/components/session-selector.ts @@ -1,4 +1,4 @@ -import { type Component, Container, Input, Spacer, Text, truncateToWidth } from "@mariozechner/pi-tui"; +import { type Component, Container, Input, isCtrlC, Spacer, Text, truncateToWidth } from "@mariozechner/pi-tui"; import type { SessionManager } from "../../../core/session-manager.js"; import { fuzzyFilter } from "../../../utils/fuzzy.js"; import { theme } from "../theme/theme.js"; @@ -145,7 +145,7 @@ class SessionList implements Component { } } // Ctrl+C - exit process - else if (keyData === "\x03") { + else if (isCtrlC(keyData)) { process.exit(0); } // Pass everything else to search input diff --git a/packages/coding-agent/src/modes/interactive/components/user-message-selector.ts b/packages/coding-agent/src/modes/interactive/components/user-message-selector.ts index 4c2816ab..d66a8ca1 100644 --- a/packages/coding-agent/src/modes/interactive/components/user-message-selector.ts +++ b/packages/coding-agent/src/modes/interactive/components/user-message-selector.ts @@ -1,4 +1,4 @@ -import { type Component, Container, Spacer, Text, truncateToWidth } from "@mariozechner/pi-tui"; +import { type Component, Container, isCtrlC, Spacer, Text, truncateToWidth } from "@mariozechner/pi-tui"; import { theme } from "../theme/theme.js"; import { DynamicBorder } from "./dynamic-border.js"; @@ -100,7 +100,7 @@ class UserMessageList implements Component { } } // Ctrl+C - cancel - else if (keyData === "\x03") { + else if (isCtrlC(keyData)) { if (this.onCancel) { this.onCancel(); } diff --git a/packages/coding-agent/src/modes/interactive/interactive-mode.ts b/packages/coding-agent/src/modes/interactive/interactive-mode.ts index f0d53ece..9fade6ea 100644 --- a/packages/coding-agent/src/modes/interactive/interactive-mode.ts +++ b/packages/coding-agent/src/modes/interactive/interactive-mode.ts @@ -573,6 +573,7 @@ export class InteractiveMode { }; this.editor.onCtrlC = () => this.handleCtrlC(); + this.editor.onCtrlD = () => this.handleCtrlD(); this.editor.onShiftTab = () => this.cycleThinkingLevel(); this.editor.onCtrlP = () => this.cycleModel(); this.editor.onCtrlO = () => this.toggleToolOutputExpansion(); @@ -1144,6 +1145,12 @@ export class InteractiveMode { } } + private handleCtrlD(): void { + // Only called when editor is empty (enforced by CustomEditor) + this.stop(); + process.exit(0); + } + private updateEditorBorderColor(): void { if (this.isBashMode) { this.editor.borderColor = theme.getBashModeBorderColor(); diff --git a/packages/tui/src/components/editor.ts b/packages/tui/src/components/editor.ts index 522f2025..da56d285 100644 --- a/packages/tui/src/components/editor.ts +++ b/packages/tui/src/components/editor.ts @@ -1,4 +1,5 @@ import type { AutocompleteProvider, CombinedAutocompleteProvider } from "../autocomplete.js"; +import { isAltBackspace, isCtrlA, isCtrlC, isCtrlE, isCtrlK, isCtrlU, isCtrlW, Keys } from "../keys.js"; import type { Component } from "../tui.js"; import { visibleWidth } from "../utils.js"; import { SelectList, type SelectListTheme } from "./select-list.js"; @@ -259,7 +260,7 @@ export class Editor implements Component { // Handle special key combinations first // Ctrl+C - Exit (let parent handle this) - if (data.charCodeAt(0) === 3) { + if (isCtrlC(data)) { return; } @@ -359,34 +360,36 @@ export class Editor implements Component { // Continue with rest of input handling // Ctrl+K - Delete to end of line - if (data.charCodeAt(0) === 11) { + if (isCtrlK(data)) { this.deleteToEndOfLine(); } // Ctrl+U - Delete to start of line - else if (data.charCodeAt(0) === 21) { + else if (isCtrlU(data)) { this.deleteToStartOfLine(); } // Ctrl+W - Delete word backwards - else if (data.charCodeAt(0) === 23) { + else if (isCtrlW(data)) { this.deleteWordBackwards(); } - // Option/Alt+Backspace (e.g. Ghostty sends ESC + DEL) - else if (data === "\x1b\x7f") { + // Option/Alt+Backspace - Delete word backwards + else if (isAltBackspace(data)) { this.deleteWordBackwards(); } // Ctrl+A - Move to start of line - else if (data.charCodeAt(0) === 1) { + else if (isCtrlA(data)) { this.moveToLineStart(); } // Ctrl+E - Move to end of line - else if (data.charCodeAt(0) === 5) { + else if (isCtrlE(data)) { this.moveToLineEnd(); } // New line shortcuts (but not plain LF/CR which should be submit) else if ( (data.charCodeAt(0) === 10 && data.length > 1) || // Ctrl+Enter with modifiers - data === "\x1b\r" || // Option+Enter in some terminals - data === "\x1b[13;2~" || // Shift+Enter in some terminals + data === "\x1b\r" || // Option+Enter in some terminals (legacy) + data === "\x1b[13;2~" || // Shift+Enter in some terminals (legacy format) + data === Keys.SHIFT_ENTER || // Shift+Enter in Kitty keyboard protocol + data === Keys.ALT_ENTER || // Alt+Enter in Kitty keyboard protocol (data.length > 1 && data.includes("\x1b") && data.includes("\r")) || (data === "\n" && data.length === 1) || // Shift+Enter from iTerm2 mapping data === "\\\r" // Shift+Enter in VS Code terminal diff --git a/packages/tui/src/components/input.ts b/packages/tui/src/components/input.ts index dbf8c801..8a60e11b 100644 --- a/packages/tui/src/components/input.ts +++ b/packages/tui/src/components/input.ts @@ -1,3 +1,4 @@ +import { isAltBackspace, isCtrlA, isCtrlE, isCtrlK, isCtrlU, isCtrlW } from "../keys.js"; import type { Component } from "../tui.js"; import { visibleWidth } from "../utils.js"; @@ -101,38 +102,38 @@ export class Input implements Component { return; } - if (data === "\x01") { + if (isCtrlA(data)) { // Ctrl+A - beginning of line this.cursor = 0; return; } - if (data === "\x05") { + if (isCtrlE(data)) { // Ctrl+E - end of line this.cursor = this.value.length; return; } - if (data.charCodeAt(0) === 23) { + if (isCtrlW(data)) { // Ctrl+W - delete word backwards this.deleteWordBackwards(); return; } - if (data === "\x1b\x7f") { + if (isAltBackspace(data)) { // Option/Alt+Backspace - delete word backwards this.deleteWordBackwards(); return; } - if (data.charCodeAt(0) === 21) { + if (isCtrlU(data)) { // Ctrl+U - delete from cursor to start of line this.value = this.value.slice(this.cursor); this.cursor = 0; return; } - if (data.charCodeAt(0) === 11) { + if (isCtrlK(data)) { // Ctrl+K - delete from cursor to end of line this.value = this.value.slice(0, this.cursor); return; diff --git a/packages/tui/src/components/select-list.ts b/packages/tui/src/components/select-list.ts index 357a4fa7..ab2f5e33 100644 --- a/packages/tui/src/components/select-list.ts +++ b/packages/tui/src/components/select-list.ts @@ -1,3 +1,4 @@ +import { isCtrlC } from "../keys.js"; import type { Component } from "../tui.js"; import { truncateToWidth } from "../utils.js"; @@ -162,7 +163,7 @@ export class SelectList implements Component { } } // Escape or Ctrl+C - else if (keyData === "\x1b" || keyData === "\x03") { + else if (keyData === "\x1b" || isCtrlC(keyData)) { if (this.onCancel) { this.onCancel(); } diff --git a/packages/tui/src/index.ts b/packages/tui/src/index.ts index ed3daab7..b03c0cf3 100644 --- a/packages/tui/src/index.ts +++ b/packages/tui/src/index.ts @@ -18,6 +18,22 @@ export { type SelectItem, SelectList, type SelectListTheme } from "./components/ export { Spacer } from "./components/spacer.js"; export { Text } from "./components/text.js"; export { TruncatedText } from "./components/truncated-text.js"; +// Kitty keyboard protocol helpers +export { + isAltBackspace, + isCtrlA, + isCtrlC, + isCtrlD, + isCtrlE, + isCtrlK, + isCtrlO, + isCtrlP, + isCtrlT, + isCtrlU, + isCtrlW, + isShiftTab, + Keys, +} from "./keys.js"; // Terminal interface and implementations export { ProcessTerminal, type Terminal } from "./terminal.js"; // Terminal image support diff --git a/packages/tui/src/keys.ts b/packages/tui/src/keys.ts new file mode 100644 index 00000000..bac4557d --- /dev/null +++ b/packages/tui/src/keys.ts @@ -0,0 +1,196 @@ +/** + * Kitty keyboard protocol key sequence helpers. + * + * The Kitty keyboard protocol sends enhanced escape sequences in the format: + * \x1b[;u + * + * Modifier values (added to 1): + * - Shift: 1 (value 2) + * - Alt: 2 (value 3) + * - Ctrl: 4 (value 5) + * - Super: 8 (value 9) + * + * See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/ + */ + +// Common codepoints +const CODEPOINTS = { + // Letters (lowercase ASCII) + a: 97, + c: 99, + d: 100, + e: 101, + k: 107, + o: 111, + p: 112, + t: 116, + u: 117, + w: 119, + + // Special keys + tab: 9, + enter: 13, + backspace: 127, +} as const; + +// Modifier bits (before adding 1) +const MODIFIERS = { + shift: 1, + alt: 2, + ctrl: 4, + super: 8, +} as const; + +/** + * Build a Kitty keyboard protocol sequence for a key with modifier. + */ +function kittySequence(codepoint: number, modifier: number): string { + return `\x1b[${codepoint};${modifier + 1}u`; +} + +// Pre-built sequences for common key combinations +export const Keys = { + // Ctrl+ combinations + CTRL_A: kittySequence(CODEPOINTS.a, MODIFIERS.ctrl), + CTRL_C: kittySequence(CODEPOINTS.c, MODIFIERS.ctrl), + CTRL_D: kittySequence(CODEPOINTS.d, MODIFIERS.ctrl), + CTRL_E: kittySequence(CODEPOINTS.e, MODIFIERS.ctrl), + CTRL_K: kittySequence(CODEPOINTS.k, MODIFIERS.ctrl), + CTRL_O: kittySequence(CODEPOINTS.o, MODIFIERS.ctrl), + CTRL_P: kittySequence(CODEPOINTS.p, MODIFIERS.ctrl), + CTRL_T: kittySequence(CODEPOINTS.t, MODIFIERS.ctrl), + CTRL_U: kittySequence(CODEPOINTS.u, MODIFIERS.ctrl), + CTRL_W: kittySequence(CODEPOINTS.w, MODIFIERS.ctrl), + + // Enter combinations + SHIFT_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.shift), + ALT_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.alt), + CTRL_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.ctrl), + + // Tab combinations + SHIFT_TAB: kittySequence(CODEPOINTS.tab, MODIFIERS.shift), + + // Backspace combinations + ALT_BACKSPACE: kittySequence(CODEPOINTS.backspace, MODIFIERS.alt), +} as const; + +/** + * Check if input matches a Kitty protocol Ctrl+ sequence. + * @param data - The input data to check + * @param key - Single lowercase letter (e.g., 'c' for Ctrl+C) + */ +export function isKittyCtrl(data: string, key: string): boolean { + if (key.length !== 1) return false; + const codepoint = key.charCodeAt(0); + return data === kittySequence(codepoint, MODIFIERS.ctrl); +} + +/** + * Check if input matches a Kitty protocol key sequence with specific modifier. + * @param data - The input data to check + * @param codepoint - ASCII codepoint of the key + * @param modifier - Modifier value (use MODIFIERS constants) + */ +export function isKittyKey(data: string, codepoint: number, modifier: number): boolean { + return data === kittySequence(codepoint, modifier); +} + +// Raw control character codes +const RAW = { + CTRL_A: "\x01", + CTRL_C: "\x03", + CTRL_D: "\x04", + CTRL_E: "\x05", + CTRL_K: "\x0b", + CTRL_O: "\x0f", + CTRL_P: "\x10", + CTRL_T: "\x14", + CTRL_U: "\x15", + CTRL_W: "\x17", + ALT_BACKSPACE: "\x1b\x7f", + SHIFT_TAB: "\x1b[Z", +} as const; + +/** + * Check if input matches Ctrl+A (raw byte or Kitty protocol). + */ +export function isCtrlA(data: string): boolean { + return data === RAW.CTRL_A || data === Keys.CTRL_A; +} + +/** + * Check if input matches Ctrl+C (raw byte or Kitty protocol). + */ +export function isCtrlC(data: string): boolean { + return data === RAW.CTRL_C || data === Keys.CTRL_C; +} + +/** + * Check if input matches Ctrl+D (raw byte or Kitty protocol). + */ +export function isCtrlD(data: string): boolean { + return data === RAW.CTRL_D || data === Keys.CTRL_D; +} + +/** + * Check if input matches Ctrl+E (raw byte or Kitty protocol). + */ +export function isCtrlE(data: string): boolean { + return data === RAW.CTRL_E || data === Keys.CTRL_E; +} + +/** + * Check if input matches Ctrl+K (raw byte or Kitty protocol). + */ +export function isCtrlK(data: string): boolean { + return data === RAW.CTRL_K || data === Keys.CTRL_K; +} + +/** + * Check if input matches Ctrl+O (raw byte or Kitty protocol). + */ +export function isCtrlO(data: string): boolean { + return data === RAW.CTRL_O || data === Keys.CTRL_O; +} + +/** + * Check if input matches Ctrl+P (raw byte or Kitty protocol). + */ +export function isCtrlP(data: string): boolean { + return data === RAW.CTRL_P || data === Keys.CTRL_P; +} + +/** + * Check if input matches Ctrl+T (raw byte or Kitty protocol). + */ +export function isCtrlT(data: string): boolean { + return data === RAW.CTRL_T || data === Keys.CTRL_T; +} + +/** + * Check if input matches Ctrl+U (raw byte or Kitty protocol). + */ +export function isCtrlU(data: string): boolean { + return data === RAW.CTRL_U || data === Keys.CTRL_U; +} + +/** + * Check if input matches Ctrl+W (raw byte or Kitty protocol). + */ +export function isCtrlW(data: string): boolean { + return data === RAW.CTRL_W || data === Keys.CTRL_W; +} + +/** + * Check if input matches Alt+Backspace (legacy or Kitty protocol). + */ +export function isAltBackspace(data: string): boolean { + return data === RAW.ALT_BACKSPACE || data === Keys.ALT_BACKSPACE; +} + +/** + * Check if input matches Shift+Tab (legacy or Kitty protocol). + */ +export function isShiftTab(data: string): boolean { + return data === RAW.SHIFT_TAB || data === Keys.SHIFT_TAB; +} diff --git a/packages/tui/src/terminal.ts b/packages/tui/src/terminal.ts index 68c4d4e7..9b27c12f 100644 --- a/packages/tui/src/terminal.ts +++ b/packages/tui/src/terminal.ts @@ -51,6 +51,12 @@ export class ProcessTerminal implements Terminal { // Enable bracketed paste mode - terminal will wrap pastes in \x1b[200~ ... \x1b[201~ process.stdout.write("\x1b[?2004h"); + // Enable Kitty keyboard protocol (disambiguate escape codes) + // This makes terminals like Ghostty, Kitty, WezTerm send enhanced key sequences + // e.g., Shift+Enter becomes \x1b[13;2u instead of just \r + // See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/ + process.stdout.write("\x1b[>1u"); + // Set up event handlers process.stdin.on("data", this.inputHandler); process.stdout.on("resize", this.resizeHandler); @@ -60,6 +66,9 @@ export class ProcessTerminal implements Terminal { // Disable bracketed paste mode process.stdout.write("\x1b[?2004l"); + // Disable Kitty keyboard protocol (pop the flags we pushed) + process.stdout.write("\x1b[ { tui.stop(); console.log("\nExiting...");