@pencil-agent/nano-pencil 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/node_modules/@pencil-agent/tui/dist/editor-component.d.ts

@@ -0,0 +1,51 @@
+/**
+ * [WHO]: EditorComponent
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/lib/tui/src/index.ts
+ * [HERE]: core/lib/tui/src/editor-component.ts -
+ */
+import type { AutocompleteProvider } from "./autocomplete.js";
+import type { Component } from "./tui.js";
+/**
+ * Interface for custom editor components.
+ *
+ * This allows extensions to provide their own editor implementation
+ * (e.g., vim mode, emacs mode, custom keybindings) while maintaining
+ * compatibility with the core application.
+ */
+export interface EditorComponent extends Component {
+    /** Get the current text content */
+    getText(): string;
+    /** Set the text content */
+    setText(text: string): void;
+    /** Handle raw terminal input (key presses, paste sequences, etc.) */
+    handleInput(data: string): void;
+    /** Called when user submits (e.g., Enter key) */
+    onSubmit?: (text: string) => void;
+    /** Called when text changes */
+    onChange?: (text: string) => void;
+    /** Add text to history for up/down navigation */
+    addToHistory?(text: string): void;
+    /**
+     * Whether the cursor is on the first visual line (accounts for soft wrapping).
+     * Used to decide whether ↑ should leave the editor (e.g. into an attachments
+     * bar above it) instead of moving the cursor. Optional: callers fall back to a
+     * single-line check when an editor implementation does not provide it.
+     */
+    isCursorOnFirstVisualLine?(): boolean;
+    /** Insert text at current cursor position */
+    insertTextAtCursor?(text: string): void;
+    /**
+     * Get text with any markers expanded (e.g., paste markers).
+     * Falls back to getText() if not implemented.
+     */
+    getExpandedText?(): string;
+    /** Set the autocomplete provider */
+    setAutocompleteProvider?(provider: AutocompleteProvider): void;
+    /** Border color function */
+    borderColor?: (str: string) => string;
+    /** Set horizontal padding */
+    setPaddingX?(padding: number): void;
+    /** Set max visible items in autocomplete dropdown */
+    setAutocompleteMaxVisible?(maxVisible: number): void;
+}

package/dist/node_modules/@pencil-agent/tui/dist/editor-component.js

@@ -0,0 +1,7 @@
+/**
+ * [WHO]: EditorComponent
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/lib/tui/src/index.ts
+ * [HERE]: core/lib/tui/src/editor-component.ts -
+ */
+export {};

package/dist/node_modules/@pencil-agent/tui/dist/fuzzy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Fuzzy matching utilities.
+ * Matches if all query characters appear in order (not necessarily consecutive).
+ * Lower score = better match.
+ */
+/**
+ * [WHO]: FuzzyMatch, fuzzyMatch, fuzzyFilter
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/lib/tui/src/index.ts
+ * [HERE]: core/lib/tui/src/fuzzy.ts -
+ */
+export interface FuzzyMatch {
+    matches: boolean;
+    score: number;
+}
+export declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
+/**
+ * Filter and sort items by fuzzy match quality (best matches first).
+ * Supports space-separated tokens: all tokens must match.
+ */
+export declare function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[];
+/**
+ * Weighted fuzzy filter for command autocomplete.
+ * Scores items by multiple fields with different weights.
+ * Higher score = better match.
+ */
+export interface WeightedField<T> {
+    name: string;
+    getText: (item: T) => string;
+    weight: number;
+}
+export declare function weightedFuzzyFilter<T>(items: T[], query: string, fields: WeightedField<T>[]): T[];

package/dist/node_modules/@pencil-agent/tui/dist/fuzzy.js

@@ -0,0 +1,152 @@
+/**
+ * Fuzzy matching utilities.
+ * Matches if all query characters appear in order (not necessarily consecutive).
+ * Lower score = better match.
+ */
+/**
+ * [WHO]: FuzzyMatch, fuzzyMatch, fuzzyFilter
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/lib/tui/src/index.ts
+ * [HERE]: core/lib/tui/src/fuzzy.ts -
+ */
+export function fuzzyMatch(query, text) {
+    const queryLower = query.toLowerCase();
+    const textLower = text.toLowerCase();
+    const matchQuery = (normalizedQuery) => {
+        if (normalizedQuery.length === 0) {
+            return { matches: true, score: 0 };
+        }
+        if (normalizedQuery.length > textLower.length) {
+            return { matches: false, score: 0 };
+        }
+        let queryIndex = 0;
+        let score = 0;
+        let lastMatchIndex = -1;
+        let consecutiveMatches = 0;
+        for (let i = 0; i < textLower.length && queryIndex < normalizedQuery.length; i++) {
+            if (textLower[i] === normalizedQuery[queryIndex]) {
+                const isWordBoundary = i === 0 || /[\s\-_./:]/.test(textLower[i - 1]);
+                // Reward consecutive matches
+                if (lastMatchIndex === i - 1) {
+                    consecutiveMatches++;
+                    score -= consecutiveMatches * 5;
+                }
+                else {
+                    consecutiveMatches = 0;
+                    // Penalize gaps
+                    if (lastMatchIndex >= 0) {
+                        score += (i - lastMatchIndex - 1) * 2;
+                    }
+                }
+                // Reward word boundary matches
+                if (isWordBoundary) {
+                    score -= 10;
+                }
+                // Slight penalty for later matches
+                score += i * 0.1;
+                lastMatchIndex = i;
+                queryIndex++;
+            }
+        }
+        if (queryIndex < normalizedQuery.length) {
+            return { matches: false, score: 0 };
+        }
+        return { matches: true, score };
+    };
+    const primaryMatch = matchQuery(queryLower);
+    if (primaryMatch.matches) {
+        return primaryMatch;
+    }
+    const alphaNumericMatch = queryLower.match(/^(?<letters>[a-z]+)(?<digits>[0-9]+)$/);
+    const numericAlphaMatch = queryLower.match(/^(?<digits>[0-9]+)(?<letters>[a-z]+)$/);
+    const swappedQuery = alphaNumericMatch
+        ? `${alphaNumericMatch.groups?.digits ?? ""}${alphaNumericMatch.groups?.letters ?? ""}`
+        : numericAlphaMatch
+            ? `${numericAlphaMatch.groups?.letters ?? ""}${numericAlphaMatch.groups?.digits ?? ""}`
+            : "";
+    if (!swappedQuery) {
+        return primaryMatch;
+    }
+    const swappedMatch = matchQuery(swappedQuery);
+    if (!swappedMatch.matches) {
+        return primaryMatch;
+    }
+    return { matches: true, score: swappedMatch.score + 5 };
+}
+/**
+ * Filter and sort items by fuzzy match quality (best matches first).
+ * Supports space-separated tokens: all tokens must match.
+ */
+export function fuzzyFilter(items, query, getText) {
+    if (!query.trim()) {
+        return items;
+    }
+    const tokens = query
+        .trim()
+        .split(/\s+/)
+        .filter((t) => t.length > 0);
+    if (tokens.length === 0) {
+        return items;
+    }
+    const results = [];
+    for (const item of items) {
+        const text = getText(item);
+        let totalScore = 0;
+        let allMatch = true;
+        for (const token of tokens) {
+            const match = fuzzyMatch(token, text);
+            if (match.matches) {
+                totalScore += match.score;
+            }
+            else {
+                allMatch = false;
+                break;
+            }
+        }
+        if (allMatch) {
+            results.push({ item, totalScore });
+        }
+    }
+    results.sort((a, b) => a.totalScore - b.totalScore);
+    return results.map((r) => r.item);
+}
+export function weightedFuzzyFilter(items, query, fields) {
+    if (!query.trim()) {
+        return items;
+    }
+    const tokens = query
+        .trim()
+        .split(/\s+/)
+        .filter((t) => t.length > 0);
+    if (tokens.length === 0) {
+        return items;
+    }
+    const results = [];
+    for (const item of items) {
+        let totalWeightedScore = 0;
+        let hasMatch = false;
+        for (const field of fields) {
+            const text = field.getText(item);
+            let fieldScore = 0;
+            for (const token of tokens) {
+                const match = fuzzyMatch(token, text);
+                if (match.matches) {
+                    fieldScore += match.score;
+                }
+                else {
+                    fieldScore = Infinity; // Token didn't match this field
+                    break;
+                }
+            }
+            if (fieldScore !== Infinity) {
+                totalWeightedScore += fieldScore * field.weight;
+                hasMatch = true;
+            }
+        }
+        if (hasMatch) {
+            results.push({ item, totalScore: totalWeightedScore });
+        }
+    }
+    results.sort((a, b) => a.totalScore - b.totalScore);
+    return results.map((r) => r.item);
+}

package/dist/node_modules/@pencil-agent/tui/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * [WHO]: TUI barrel exports
+ * [FROM]: Depends on all tui components
+ * [TO]: Consumed by @pencil-agent/tui package consumers (modes, core/extensions-host, cli)
+ * [HERE]: core/lib/tui/src/index.ts - TUI package entry point
+ */
+export { type ArgumentCompletionContext, type AutocompleteItem, type AutocompleteProvider, CombinedAutocompleteProvider, type SlashCommand, } from "./autocomplete.js";
+export { Box } from "./components/box.js";
+export { CancellableLoader } from "./components/cancellable-loader.js";
+export { Editor, type EditorOptions, type EditorTheme } from "./components/editor.js";
+export { Image, type ImageOptions, type ImageTheme } from "./components/image.js";
+export { Input } from "./components/input.js";
+export { Loader } from "./components/loader.js";
+export { type DefaultTextStyle, Markdown, type MarkdownTheme } from "./components/markdown.js";
+export { type SelectItem, SelectList, type SelectListTheme } from "./components/select-list.js";
+export { type SettingItem, SettingsList, type SettingsListTheme } from "./components/settings-list.js";
+export { Spacer } from "./components/spacer.js";
+export { Text } from "./components/text.js";
+export { TruncatedText } from "./components/truncated-text.js";
+export type { EditorComponent } from "./editor-component.js";
+export { type FuzzyMatch, type WeightedField, fuzzyFilter, fuzzyMatch, weightedFuzzyFilter } from "./fuzzy.js";
+export { DEFAULT_EDITOR_KEYBINDINGS, type EditorAction, type EditorKeybindingsConfig, EditorKeybindingsManager, getEditorKeybindings, setEditorKeybindings, } from "./keybindings.js";
+export { isKeyRelease, isKeyRepeat, isKittyProtocolActive, Key, type KeyEventType, type KeyId, matchesKey, parseKey, setKittyProtocolActive, } from "./keys.js";
+export { StdinBuffer, type StdinBufferEventMap, type StdinBufferOptions } from "./stdin-buffer.js";
+export { ProcessTerminal, type Terminal } from "./terminal.js";
+export { allocateImageId, type CellDimensions, calculateImageRows, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getWebpDimensions, type ImageDimensions, type ImageProtocol, type ImageRenderOptions, imageFallback, renderImage, resetCapabilitiesCache, setCellDimensions, type TerminalCapabilities, } from "./terminal-image.js";
+export { type Component, Container, CURSOR_MARKER, type Focusable, isFocusable, type OverlayAnchor, type OverlayHandle, type OverlayMargin, type OverlayOptions, type SizeValue, TUI, } from "./tui.js";
+export { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "./utils.js";

package/dist/node_modules/@pencil-agent/tui/dist/index.js

@@ -0,0 +1,37 @@
+/**
+ * [WHO]: TUI barrel exports
+ * [FROM]: Depends on all tui components
+ * [TO]: Consumed by @pencil-agent/tui package consumers (modes, core/extensions-host, cli)
+ * [HERE]: core/lib/tui/src/index.ts - TUI package entry point
+ */
+// Core TUI interfaces and classes
+// Autocomplete support
+export { CombinedAutocompleteProvider, } from "./autocomplete.js";
+// Components
+export { Box } from "./components/box.js";
+export { CancellableLoader } from "./components/cancellable-loader.js";
+export { Editor } from "./components/editor.js";
+export { Image } from "./components/image.js";
+export { Input } from "./components/input.js";
+export { Loader } from "./components/loader.js";
+export { Markdown } from "./components/markdown.js";
+export { SelectList } from "./components/select-list.js";
+export { SettingsList } from "./components/settings-list.js";
+export { Spacer } from "./components/spacer.js";
+export { Text } from "./components/text.js";
+export { TruncatedText } from "./components/truncated-text.js";
+// Fuzzy matching
+export { fuzzyFilter, fuzzyMatch, weightedFuzzyFilter } from "./fuzzy.js";
+// Keybindings
+export { DEFAULT_EDITOR_KEYBINDINGS, EditorKeybindingsManager, getEditorKeybindings, setEditorKeybindings, } from "./keybindings.js";
+// Keyboard input handling
+export { isKeyRelease, isKeyRepeat, isKittyProtocolActive, Key, matchesKey, parseKey, setKittyProtocolActive, } from "./keys.js";
+// Input buffering for batch splitting
+export { StdinBuffer } from "./stdin-buffer.js";
+// Terminal interface and implementations
+export { ProcessTerminal } from "./terminal.js";
+// Terminal image support
+export { allocateImageId, calculateImageRows, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getWebpDimensions, imageFallback, renderImage, resetCapabilitiesCache, setCellDimensions, } from "./terminal-image.js";
+export { Container, CURSOR_MARKER, isFocusable, TUI, } from "./tui.js";
+// Utilities
+export { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "./utils.js";

package/dist/node_modules/@pencil-agent/tui/dist/keybindings.d.ts

@@ -0,0 +1,44 @@
+/**
+ * [WHO]: DEFAULT_EDITOR_KEYBINDINGS, EditorKeybindingsManager, getEditorKeybindings, setEditorKeybindings
+ * [FROM]: Depends on ./keys.js
+ * [TO]: Consumed by core/lib/tui/src/index.ts
+ * [HERE]: core/lib/tui/src/keybindings.ts -
+ */
+import { type KeyId } from "./keys.js";
+/**
+ * Editor actions that can be bound to keys.
+ */
+export type EditorAction = "cursorUp" | "cursorDown" | "cursorLeft" | "cursorRight" | "cursorWordLeft" | "cursorWordRight" | "cursorLineStart" | "cursorLineEnd" | "jumpForward" | "jumpBackward" | "pageUp" | "pageDown" | "deleteCharBackward" | "deleteCharForward" | "deleteWordBackward" | "deleteWordForward" | "deleteToLineStart" | "deleteToLineEnd" | "newLine" | "submit" | "tab" | "selectUp" | "selectDown" | "selectPageUp" | "selectPageDown" | "selectConfirm" | "selectCancel" | "copy" | "yank" | "yankPop" | "undo" | "expandTools" | "toggleSessionPath" | "toggleSessionSort" | "renameSession" | "deleteSession" | "deleteSessionNoninvasive";
+export type { KeyId };
+/**
+ * Editor keybindings configuration.
+ */
+export type EditorKeybindingsConfig = {
+    [K in EditorAction]?: KeyId | KeyId[];
+};
+/**
+ * Default editor keybindings.
+ */
+export declare const DEFAULT_EDITOR_KEYBINDINGS: Required<EditorKeybindingsConfig>;
+/**
+ * Manages keybindings for the editor.
+ */
+export declare class EditorKeybindingsManager {
+    private actionToKeys;
+    constructor(config?: EditorKeybindingsConfig);
+    private buildMaps;
+    /**
+     * Check if input matches a specific action.
+     */
+    matches(data: string, action: EditorAction): boolean;
+    /**
+     * Get keys bound to an action.
+     */
+    getKeys(action: EditorAction): KeyId[];
+    /**
+     * Update configuration.
+     */
+    setConfig(config: EditorKeybindingsConfig): void;
+}
+export declare function getEditorKeybindings(): EditorKeybindingsManager;
+export declare function setEditorKeybindings(manager: EditorKeybindingsManager): void;

package/dist/node_modules/@pencil-agent/tui/dist/keybindings.js

@@ -0,0 +1,119 @@
+/**
+ * [WHO]: DEFAULT_EDITOR_KEYBINDINGS, EditorKeybindingsManager, getEditorKeybindings, setEditorKeybindings
+ * [FROM]: Depends on ./keys.js
+ * [TO]: Consumed by core/lib/tui/src/index.ts
+ * [HERE]: core/lib/tui/src/keybindings.ts -
+ */
+import { matchesKey } from "./keys.js";
+/**
+ * Default editor keybindings.
+ */
+export const DEFAULT_EDITOR_KEYBINDINGS = {
+    // Cursor movement
+    cursorUp: "up",
+    cursorDown: "down",
+    cursorLeft: ["left", "ctrl+b"],
+    cursorRight: ["right", "ctrl+f"],
+    cursorWordLeft: ["alt+left", "ctrl+left", "alt+b"],
+    cursorWordRight: ["alt+right", "ctrl+right", "alt+f"],
+    cursorLineStart: ["home", "ctrl+a"],
+    cursorLineEnd: ["end", "ctrl+e"],
+    jumpForward: "ctrl+]",
+    jumpBackward: "ctrl+alt+]",
+    pageUp: "pageUp",
+    pageDown: "pageDown",
+    // Deletion
+    deleteCharBackward: "backspace",
+    deleteCharForward: ["delete", "ctrl+d"],
+    deleteWordBackward: ["ctrl+w", "alt+backspace"],
+    deleteWordForward: ["alt+d", "alt+delete"],
+    deleteToLineStart: "ctrl+u",
+    deleteToLineEnd: "ctrl+k",
+    // Text input
+    newLine: "shift+enter",
+    submit: "enter",
+    tab: "tab",
+    // Selection/autocomplete
+    selectUp: "up",
+    selectDown: "down",
+    selectPageUp: "pageUp",
+    selectPageDown: "pageDown",
+    selectConfirm: "enter",
+    selectCancel: ["escape", "ctrl+c"],
+    // Clipboard
+    copy: "ctrl+c",
+    // Kill ring
+    yank: "ctrl+y",
+    yankPop: "alt+y",
+    // Undo
+    undo: "ctrl+-",
+    // Tool output
+    expandTools: "ctrl+o",
+    // Session
+    toggleSessionPath: "ctrl+p",
+    toggleSessionSort: "ctrl+s",
+    renameSession: "ctrl+r",
+    deleteSession: "ctrl+d",
+    deleteSessionNoninvasive: "ctrl+backspace",
+};
+/**
+ * Manages keybindings for the editor.
+ */
+export class EditorKeybindingsManager {
+    actionToKeys;
+    constructor(config = {}) {
+        this.actionToKeys = new Map();
+        this.buildMaps(config);
+    }
+    buildMaps(config) {
+        this.actionToKeys.clear();
+        // Start with defaults
+        for (const [action, keys] of Object.entries(DEFAULT_EDITOR_KEYBINDINGS)) {
+            const keyArray = Array.isArray(keys) ? keys : [keys];
+            this.actionToKeys.set(action, [...keyArray]);
+        }
+        // Override with user config
+        for (const [action, keys] of Object.entries(config)) {
+            if (keys === undefined)
+                continue;
+            const keyArray = Array.isArray(keys) ? keys : [keys];
+            this.actionToKeys.set(action, keyArray);
+        }
+    }
+    /**
+     * Check if input matches a specific action.
+     */
+    matches(data, action) {
+        const keys = this.actionToKeys.get(action);
+        if (!keys)
+            return false;
+        for (const key of keys) {
+            if (matchesKey(data, key))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Get keys bound to an action.
+     */
+    getKeys(action) {
+        return this.actionToKeys.get(action) ?? [];
+    }
+    /**
+     * Update configuration.
+     */
+    setConfig(config) {
+        this.buildMaps(config);
+    }
+}
+// Global instance
+let globalEditorKeybindings = null;
+export function getEditorKeybindings() {
+    if (!globalEditorKeybindings) {
+        globalEditorKeybindings = new EditorKeybindingsManager();
+    }
+    return globalEditorKeybindings;
+}
+export function setEditorKeybindings(manager) {
+    globalEditorKeybindings = manager;
+}

package/dist/node_modules/@pencil-agent/tui/dist/keys.d.ts

@@ -0,0 +1,149 @@
+/**
+ * [WHO]: Keyboard input handling - setKittyProtocolActive, isKittyProtocolActive, Key, matchesKey, parseKey
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/lib/tui/src/index.ts, TUI components
+ * [HERE]: core/lib/tui/src/keys.ts - keyboard input handling for terminal applications
+ *
+ * Supports both legacy terminal sequences and Kitty keyboard protocol.
+ * See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+ */
+/**
+ * Set the global Kitty keyboard protocol state.
+ * Called by ProcessTerminal after detecting protocol support.
+ */
+export declare function setKittyProtocolActive(active: boolean): void;
+/**
+ * Query whether Kitty keyboard protocol is currently active.
+ */
+export declare function isKittyProtocolActive(): boolean;
+type Letter = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+type SymbolKey = "`" | "-" | "=" | "[" | "]" | "\\" | ";" | "'" | "," | "." | "/" | "!" | "@" | "#" | "$" | "%" | "^" | "&" | "*" | "(" | ")" | "_" | "+" | "|" | "~" | "{" | "}" | ":" | "<" | ">" | "?";
+type SpecialKey = "escape" | "esc" | "enter" | "return" | "tab" | "space" | "backspace" | "delete" | "insert" | "clear" | "home" | "end" | "pageUp" | "pageDown" | "up" | "down" | "left" | "right" | "f1" | "f2" | "f3" | "f4" | "f5" | "f6" | "f7" | "f8" | "f9" | "f10" | "f11" | "f12";
+type BaseKey = Letter | SymbolKey | SpecialKey;
+/**
+ * Union type of all valid key identifiers.
+ * Provides autocomplete and catches typos at compile time.
+ */
+export type KeyId = BaseKey | `ctrl+${BaseKey}` | `shift+${BaseKey}` | `alt+${BaseKey}` | `ctrl+shift+${BaseKey}` | `shift+ctrl+${BaseKey}` | `ctrl+alt+${BaseKey}` | `alt+ctrl+${BaseKey}` | `shift+alt+${BaseKey}` | `alt+shift+${BaseKey}` | `ctrl+shift+alt+${BaseKey}` | `ctrl+alt+shift+${BaseKey}` | `shift+ctrl+alt+${BaseKey}` | `shift+alt+ctrl+${BaseKey}` | `alt+ctrl+shift+${BaseKey}` | `alt+shift+ctrl+${BaseKey}`;
+/**
+ * Helper object for creating typed key identifiers with autocomplete.
+ *
+ * Usage:
+ * - Key.escape, Key.enter, Key.tab, etc. for special keys
+ * - Key.backtick, Key.comma, Key.period, etc. for symbol keys
+ * - Key.ctrl("c"), Key.alt("x") for single modifier
+ * - Key.ctrlShift("p"), Key.ctrlAlt("x") for combined modifiers
+ */
+export declare const Key: {
+    readonly escape: "escape";
+    readonly esc: "esc";
+    readonly enter: "enter";
+    readonly return: "return";
+    readonly tab: "tab";
+    readonly space: "space";
+    readonly backspace: "backspace";
+    readonly delete: "delete";
+    readonly insert: "insert";
+    readonly clear: "clear";
+    readonly home: "home";
+    readonly end: "end";
+    readonly pageUp: "pageUp";
+    readonly pageDown: "pageDown";
+    readonly up: "up";
+    readonly down: "down";
+    readonly left: "left";
+    readonly right: "right";
+    readonly f1: "f1";
+    readonly f2: "f2";
+    readonly f3: "f3";
+    readonly f4: "f4";
+    readonly f5: "f5";
+    readonly f6: "f6";
+    readonly f7: "f7";
+    readonly f8: "f8";
+    readonly f9: "f9";
+    readonly f10: "f10";
+    readonly f11: "f11";
+    readonly f12: "f12";
+    readonly backtick: "`";
+    readonly hyphen: "-";
+    readonly equals: "=";
+    readonly leftbracket: "[";
+    readonly rightbracket: "]";
+    readonly backslash: "\\";
+    readonly semicolon: ";";
+    readonly quote: "'";
+    readonly comma: ",";
+    readonly period: ".";
+    readonly slash: "/";
+    readonly exclamation: "!";
+    readonly at: "@";
+    readonly hash: "#";
+    readonly dollar: "$";
+    readonly percent: "%";
+    readonly caret: "^";
+    readonly ampersand: "&";
+    readonly asterisk: "*";
+    readonly leftparen: "(";
+    readonly rightparen: ")";
+    readonly underscore: "_";
+    readonly plus: "+";
+    readonly pipe: "|";
+    readonly tilde: "~";
+    readonly leftbrace: "{";
+    readonly rightbrace: "}";
+    readonly colon: ":";
+    readonly lessthan: "<";
+    readonly greaterthan: ">";
+    readonly question: "?";
+    readonly ctrl: <K extends BaseKey>(key: K) => `ctrl+${K}`;
+    readonly shift: <K extends BaseKey>(key: K) => `shift+${K}`;
+    readonly alt: <K extends BaseKey>(key: K) => `alt+${K}`;
+    readonly ctrlShift: <K extends BaseKey>(key: K) => `ctrl+shift+${K}`;
+    readonly shiftCtrl: <K extends BaseKey>(key: K) => `shift+ctrl+${K}`;
+    readonly ctrlAlt: <K extends BaseKey>(key: K) => `ctrl+alt+${K}`;
+    readonly altCtrl: <K extends BaseKey>(key: K) => `alt+ctrl+${K}`;
+    readonly shiftAlt: <K extends BaseKey>(key: K) => `shift+alt+${K}`;
+    readonly altShift: <K extends BaseKey>(key: K) => `alt+shift+${K}`;
+    readonly ctrlShiftAlt: <K extends BaseKey>(key: K) => `ctrl+shift+alt+${K}`;
+};
+/**
+ * Event types from Kitty keyboard protocol (flag 2)
+ * 1 = key press, 2 = key repeat, 3 = key release
+ */
+export type KeyEventType = "press" | "repeat" | "release";
+/**
+ * Check if the last parsed key event was a key release.
+ * Only meaningful when Kitty keyboard protocol with flag 2 is active.
+ */
+export declare function isKeyRelease(data: string): boolean;
+/**
+ * Check if the last parsed key event was a key repeat.
+ * Only meaningful when Kitty keyboard protocol with flag 2 is active.
+ */
+export declare function isKeyRepeat(data: string): boolean;
+/**
+ * Match input data against a key identifier string.
+ *
+ * Supported key identifiers:
+ * - Single keys: "escape", "tab", "enter", "backspace", "delete", "home", "end", "space"
+ * - Arrow keys: "up", "down", "left", "right"
+ * - Ctrl combinations: "ctrl+c", "ctrl+z", etc.
+ * - Shift combinations: "shift+tab", "shift+enter"
+ * - Alt combinations: "alt+enter", "alt+backspace"
+ * - Combined modifiers: "shift+ctrl+p", "ctrl+alt+x"
+ *
+ * Use the Key helper for autocomplete: Key.ctrl("c"), Key.escape, Key.ctrlShift("p")
+ *
+ * @param data - Raw input data from terminal
+ * @param keyId - Key identifier (e.g., "ctrl+c", "escape", Key.ctrl("c"))
+ */
+export declare function matchesKey(data: string, keyId: KeyId): boolean;
+/**
+ * Parse input data and return the key identifier if recognized.
+ *
+ * @param data - Raw input data from terminal
+ * @returns Key identifier string (e.g., "ctrl+c") or undefined
+ */
+export declare function parseKey(data: string): string | undefined;
+export {};