shortcutxl 0.2.0

package/dist/tui/kill-ring.js

@@ -0,0 +1,44 @@
+/**
+ * Ring buffer for Emacs-style kill/yank operations.
+ *
+ * Tracks killed (deleted) text entries. Consecutive kills can accumulate
+ * into a single entry. Supports yank (paste most recent) and yank-pop
+ * (cycle through older entries).
+ */
+export class KillRing {
+    ring = [];
+    /**
+     * Add text to the kill ring.
+     *
+     * @param text - The killed text to add
+     * @param opts - Push options
+     * @param opts.prepend - If accumulating, prepend (backward deletion) or append (forward deletion)
+     * @param opts.accumulate - Merge with the most recent entry instead of creating a new one
+     */
+    push(text, opts) {
+        if (!text)
+            return;
+        if (opts.accumulate && this.ring.length > 0) {
+            const last = this.ring.pop();
+            this.ring.push(opts.prepend ? text + last : last + text);
+        }
+        else {
+            this.ring.push(text);
+        }
+    }
+    /** Get most recent entry without modifying the ring. */
+    peek() {
+        return this.ring.length > 0 ? this.ring[this.ring.length - 1] : undefined;
+    }
+    /** Move last entry to front (for yank-pop cycling). */
+    rotate() {
+        if (this.ring.length > 1) {
+            const last = this.ring.pop();
+            this.ring.unshift(last);
+        }
+    }
+    get length() {
+        return this.ring.length;
+    }
+}
+//# sourceMappingURL=kill-ring.js.map

package/dist/tui/stdin-buffer.js

@@ -0,0 +1,317 @@
+/**
+ * StdinBuffer buffers input and emits complete sequences.
+ *
+ * This is necessary because stdin data events can arrive in partial chunks,
+ * especially for escape sequences like mouse events. Without buffering,
+ * partial sequences can be misinterpreted as regular keypresses.
+ *
+ * For example, the mouse SGR sequence `\x1b[<35;20;5m` might arrive as:
+ * - Event 1: `\x1b`
+ * - Event 2: `[<35`
+ * - Event 3: `;20;5m`
+ *
+ * The buffer accumulates these until a complete sequence is detected.
+ * Call the `process()` method to feed input data.
+ *
+ * Based on code from OpenTUI (https://github.com/anomalyco/opentui)
+ * MIT License - Copyright (c) 2025 opentui
+ */
+import { EventEmitter } from "events";
+const ESC = "\x1b";
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+/**
+ * Check if a string is a complete escape sequence or needs more data
+ */
+function isCompleteSequence(data) {
+    if (!data.startsWith(ESC)) {
+        return "not-escape";
+    }
+    if (data.length === 1) {
+        return "incomplete";
+    }
+    const afterEsc = data.slice(1);
+    // CSI sequences: ESC [
+    if (afterEsc.startsWith("[")) {
+        // Check for old-style mouse sequence: ESC[M + 3 bytes
+        if (afterEsc.startsWith("[M")) {
+            // Old-style mouse needs ESC[M + 3 bytes = 6 total
+            return data.length >= 6 ? "complete" : "incomplete";
+        }
+        return isCompleteCsiSequence(data);
+    }
+    // OSC sequences: ESC ]
+    if (afterEsc.startsWith("]")) {
+        return isCompleteOscSequence(data);
+    }
+    // DCS sequences: ESC P ... ESC \ (includes XTVersion responses)
+    if (afterEsc.startsWith("P")) {
+        return isCompleteDcsSequence(data);
+    }
+    // APC sequences: ESC _ ... ESC \ (includes Kitty graphics responses)
+    if (afterEsc.startsWith("_")) {
+        return isCompleteApcSequence(data);
+    }
+    // SS3 sequences: ESC O
+    if (afterEsc.startsWith("O")) {
+        // ESC O followed by a single character
+        return afterEsc.length >= 2 ? "complete" : "incomplete";
+    }
+    // Meta key sequences: ESC followed by a single character
+    if (afterEsc.length === 1) {
+        return "complete";
+    }
+    // Unknown escape sequence - treat as complete
+    return "complete";
+}
+/**
+ * Check if CSI sequence is complete
+ * CSI sequences: ESC [ ... followed by a final byte (0x40-0x7E)
+ */
+function isCompleteCsiSequence(data) {
+    if (!data.startsWith(`${ESC}[`)) {
+        return "complete";
+    }
+    // Need at least ESC [ and one more character
+    if (data.length < 3) {
+        return "incomplete";
+    }
+    const payload = data.slice(2);
+    // CSI sequences end with a byte in the range 0x40-0x7E (@-~)
+    // This includes all letters and several special characters
+    const lastChar = payload[payload.length - 1];
+    const lastCharCode = lastChar.charCodeAt(0);
+    if (lastCharCode >= 0x40 && lastCharCode <= 0x7e) {
+        // Special handling for SGR mouse sequences
+        // Format: ESC[<B;X;Ym or ESC[<B;X;YM
+        if (payload.startsWith("<")) {
+            // Must have format: <digits;digits;digits[Mm]
+            const mouseMatch = /^<\d+;\d+;\d+[Mm]$/.test(payload);
+            if (mouseMatch) {
+                return "complete";
+            }
+            // If it ends with M or m but doesn't match the pattern, still incomplete
+            if (lastChar === "M" || lastChar === "m") {
+                // Check if we have the right structure
+                const parts = payload.slice(1, -1).split(";");
+                if (parts.length === 3 && parts.every((p) => /^\d+$/.test(p))) {
+                    return "complete";
+                }
+            }
+            return "incomplete";
+        }
+        return "complete";
+    }
+    return "incomplete";
+}
+/**
+ * Check if OSC sequence is complete
+ * OSC sequences: ESC ] ... ST (where ST is ESC \ or BEL)
+ */
+function isCompleteOscSequence(data) {
+    if (!data.startsWith(`${ESC}]`)) {
+        return "complete";
+    }
+    // OSC sequences end with ST (ESC \) or BEL (\x07)
+    if (data.endsWith(`${ESC}\\`) || data.endsWith("\x07")) {
+        return "complete";
+    }
+    return "incomplete";
+}
+/**
+ * Check if DCS (Device Control String) sequence is complete
+ * DCS sequences: ESC P ... ST (where ST is ESC \)
+ * Used for XTVersion responses like ESC P >| ... ESC \
+ */
+function isCompleteDcsSequence(data) {
+    if (!data.startsWith(`${ESC}P`)) {
+        return "complete";
+    }
+    // DCS sequences end with ST (ESC \)
+    if (data.endsWith(`${ESC}\\`)) {
+        return "complete";
+    }
+    return "incomplete";
+}
+/**
+ * Check if APC (Application Program Command) sequence is complete
+ * APC sequences: ESC _ ... ST (where ST is ESC \)
+ * Used for Kitty graphics responses like ESC _ G ... ESC \
+ */
+function isCompleteApcSequence(data) {
+    if (!data.startsWith(`${ESC}_`)) {
+        return "complete";
+    }
+    // APC sequences end with ST (ESC \)
+    if (data.endsWith(`${ESC}\\`)) {
+        return "complete";
+    }
+    return "incomplete";
+}
+/**
+ * Split accumulated buffer into complete sequences
+ */
+function extractCompleteSequences(buffer) {
+    const sequences = [];
+    let pos = 0;
+    while (pos < buffer.length) {
+        const remaining = buffer.slice(pos);
+        // Try to extract a sequence starting at this position
+        if (remaining.startsWith(ESC)) {
+            // Find the end of this escape sequence
+            let seqEnd = 1;
+            while (seqEnd <= remaining.length) {
+                const candidate = remaining.slice(0, seqEnd);
+                const status = isCompleteSequence(candidate);
+                if (status === "complete") {
+                    sequences.push(candidate);
+                    pos += seqEnd;
+                    break;
+                }
+                else if (status === "incomplete") {
+                    seqEnd++;
+                }
+                else {
+                    // Should not happen when starting with ESC
+                    sequences.push(candidate);
+                    pos += seqEnd;
+                    break;
+                }
+            }
+            if (seqEnd > remaining.length) {
+                return { sequences, remainder: remaining };
+            }
+        }
+        else {
+            // Not an escape sequence - take a single character
+            sequences.push(remaining[0]);
+            pos++;
+        }
+    }
+    return { sequences, remainder: "" };
+}
+/**
+ * Buffers stdin input and emits complete sequences via the 'data' event.
+ * Handles partial escape sequences that arrive across multiple chunks.
+ */
+export class StdinBuffer extends EventEmitter {
+    buffer = "";
+    timeout = null;
+    timeoutMs;
+    pasteMode = false;
+    pasteBuffer = "";
+    constructor(options = {}) {
+        super();
+        this.timeoutMs = options.timeout ?? 10;
+    }
+    process(data) {
+        // Clear any pending timeout
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+        }
+        // Handle high-byte conversion (for compatibility with parseKeypress)
+        // If buffer has single byte > 127, convert to ESC + (byte - 128)
+        let str;
+        if (Buffer.isBuffer(data)) {
+            if (data.length === 1 && data[0] > 127) {
+                const byte = data[0] - 128;
+                str = `\x1b${String.fromCharCode(byte)}`;
+            }
+            else {
+                str = data.toString();
+            }
+        }
+        else {
+            str = data;
+        }
+        if (str.length === 0 && this.buffer.length === 0) {
+            this.emit("data", "");
+            return;
+        }
+        this.buffer += str;
+        if (this.pasteMode) {
+            this.pasteBuffer += this.buffer;
+            this.buffer = "";
+            const endIndex = this.pasteBuffer.indexOf(BRACKETED_PASTE_END);
+            if (endIndex !== -1) {
+                const pastedContent = this.pasteBuffer.slice(0, endIndex);
+                const remaining = this.pasteBuffer.slice(endIndex + BRACKETED_PASTE_END.length);
+                this.pasteMode = false;
+                this.pasteBuffer = "";
+                this.emit("paste", pastedContent);
+                if (remaining.length > 0) {
+                    this.process(remaining);
+                }
+            }
+            return;
+        }
+        const startIndex = this.buffer.indexOf(BRACKETED_PASTE_START);
+        if (startIndex !== -1) {
+            if (startIndex > 0) {
+                const beforePaste = this.buffer.slice(0, startIndex);
+                const result = extractCompleteSequences(beforePaste);
+                for (const sequence of result.sequences) {
+                    this.emit("data", sequence);
+                }
+            }
+            this.buffer = this.buffer.slice(startIndex + BRACKETED_PASTE_START.length);
+            this.pasteMode = true;
+            this.pasteBuffer = this.buffer;
+            this.buffer = "";
+            const endIndex = this.pasteBuffer.indexOf(BRACKETED_PASTE_END);
+            if (endIndex !== -1) {
+                const pastedContent = this.pasteBuffer.slice(0, endIndex);
+                const remaining = this.pasteBuffer.slice(endIndex + BRACKETED_PASTE_END.length);
+                this.pasteMode = false;
+                this.pasteBuffer = "";
+                this.emit("paste", pastedContent);
+                if (remaining.length > 0) {
+                    this.process(remaining);
+                }
+            }
+            return;
+        }
+        const result = extractCompleteSequences(this.buffer);
+        this.buffer = result.remainder;
+        for (const sequence of result.sequences) {
+            this.emit("data", sequence);
+        }
+        if (this.buffer.length > 0) {
+            this.timeout = setTimeout(() => {
+                const flushed = this.flush();
+                for (const sequence of flushed) {
+                    this.emit("data", sequence);
+                }
+            }, this.timeoutMs);
+        }
+    }
+    flush() {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+        }
+        if (this.buffer.length === 0) {
+            return [];
+        }
+        const sequences = [this.buffer];
+        this.buffer = "";
+        return sequences;
+    }
+    clear() {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+        }
+        this.buffer = "";
+        this.pasteMode = false;
+        this.pasteBuffer = "";
+    }
+    getBuffer() {
+        return this.buffer;
+    }
+    destroy() {
+        this.clear();
+    }
+}
+//# sourceMappingURL=stdin-buffer.js.map

package/dist/tui/terminal-image.js

@@ -0,0 +1,288 @@
+let cachedCapabilities = null;
+// Default cell dimensions - updated by TUI when terminal responds to query
+let cellDimensions = { widthPx: 9, heightPx: 18 };
+export function getCellDimensions() {
+    return cellDimensions;
+}
+export function setCellDimensions(dims) {
+    cellDimensions = dims;
+}
+export function detectCapabilities() {
+    const termProgram = process.env.TERM_PROGRAM?.toLowerCase() || "";
+    const term = process.env.TERM?.toLowerCase() || "";
+    const colorTerm = process.env.COLORTERM?.toLowerCase() || "";
+    if (process.env.KITTY_WINDOW_ID || termProgram === "kitty") {
+        return { images: "kitty", trueColor: true, hyperlinks: true };
+    }
+    if (termProgram === "ghostty" || term.includes("ghostty") || process.env.GHOSTTY_RESOURCES_DIR) {
+        return { images: "kitty", trueColor: true, hyperlinks: true };
+    }
+    if (process.env.WEZTERM_PANE || termProgram === "wezterm") {
+        return { images: "kitty", trueColor: true, hyperlinks: true };
+    }
+    if (process.env.ITERM_SESSION_ID || termProgram === "iterm.app") {
+        return { images: "iterm2", trueColor: true, hyperlinks: true };
+    }
+    if (termProgram === "vscode") {
+        return { images: null, trueColor: true, hyperlinks: true };
+    }
+    if (termProgram === "alacritty") {
+        return { images: null, trueColor: true, hyperlinks: true };
+    }
+    const trueColor = colorTerm === "truecolor" || colorTerm === "24bit";
+    return { images: null, trueColor, hyperlinks: true };
+}
+export function getCapabilities() {
+    if (!cachedCapabilities) {
+        cachedCapabilities = detectCapabilities();
+    }
+    return cachedCapabilities;
+}
+export function resetCapabilitiesCache() {
+    cachedCapabilities = null;
+}
+const KITTY_PREFIX = "\x1b_G";
+const ITERM2_PREFIX = "\x1b]1337;File=";
+export function isImageLine(line) {
+    // Fast path: sequence at line start (single-row images)
+    if (line.startsWith(KITTY_PREFIX) || line.startsWith(ITERM2_PREFIX)) {
+        return true;
+    }
+    // Slow path: sequence elsewhere (multi-row images have cursor-up prefix)
+    return line.includes(KITTY_PREFIX) || line.includes(ITERM2_PREFIX);
+}
+/**
+ * Generate a random image ID for Kitty graphics protocol.
+ * Uses random IDs to avoid collisions between different module instances
+ * (e.g., main app vs extensions).
+ */
+export function allocateImageId() {
+    // Use random ID in range [1, 0xffffffff] to avoid collisions
+    return Math.floor(Math.random() * 0xfffffffe) + 1;
+}
+export function encodeKitty(base64Data, options = {}) {
+    const CHUNK_SIZE = 4096;
+    const params = ["a=T", "f=100", "q=2"];
+    if (options.columns)
+        params.push(`c=${options.columns}`);
+    if (options.rows)
+        params.push(`r=${options.rows}`);
+    if (options.imageId)
+        params.push(`i=${options.imageId}`);
+    if (base64Data.length <= CHUNK_SIZE) {
+        return `\x1b_G${params.join(",")};${base64Data}\x1b\\`;
+    }
+    const chunks = [];
+    let offset = 0;
+    let isFirst = true;
+    while (offset < base64Data.length) {
+        const chunk = base64Data.slice(offset, offset + CHUNK_SIZE);
+        const isLast = offset + CHUNK_SIZE >= base64Data.length;
+        if (isFirst) {
+            chunks.push(`\x1b_G${params.join(",")},m=1;${chunk}\x1b\\`);
+            isFirst = false;
+        }
+        else if (isLast) {
+            chunks.push(`\x1b_Gm=0;${chunk}\x1b\\`);
+        }
+        else {
+            chunks.push(`\x1b_Gm=1;${chunk}\x1b\\`);
+        }
+        offset += CHUNK_SIZE;
+    }
+    return chunks.join("");
+}
+/**
+ * Delete a Kitty graphics image by ID.
+ * Uses uppercase 'I' to also free the image data.
+ */
+export function deleteKittyImage(imageId) {
+    return `\x1b_Ga=d,d=I,i=${imageId}\x1b\\`;
+}
+/**
+ * Delete all visible Kitty graphics images.
+ * Uses uppercase 'A' to also free the image data.
+ */
+export function deleteAllKittyImages() {
+    return `\x1b_Ga=d,d=A\x1b\\`;
+}
+export function encodeITerm2(base64Data, options = {}) {
+    const params = [`inline=${options.inline !== false ? 1 : 0}`];
+    if (options.width !== undefined)
+        params.push(`width=${options.width}`);
+    if (options.height !== undefined)
+        params.push(`height=${options.height}`);
+    if (options.name) {
+        const nameBase64 = Buffer.from(options.name).toString("base64");
+        params.push(`name=${nameBase64}`);
+    }
+    if (options.preserveAspectRatio === false) {
+        params.push("preserveAspectRatio=0");
+    }
+    return `\x1b]1337;File=${params.join(";")}:${base64Data}\x07`;
+}
+export function calculateImageRows(imageDimensions, targetWidthCells, cellDimensions = { widthPx: 9, heightPx: 18 }) {
+    const targetWidthPx = targetWidthCells * cellDimensions.widthPx;
+    const scale = targetWidthPx / imageDimensions.widthPx;
+    const scaledHeightPx = imageDimensions.heightPx * scale;
+    const rows = Math.ceil(scaledHeightPx / cellDimensions.heightPx);
+    return Math.max(1, rows);
+}
+export function getPngDimensions(base64Data) {
+    try {
+        const buffer = Buffer.from(base64Data, "base64");
+        if (buffer.length < 24) {
+            return null;
+        }
+        if (buffer[0] !== 0x89 || buffer[1] !== 0x50 || buffer[2] !== 0x4e || buffer[3] !== 0x47) {
+            return null;
+        }
+        const width = buffer.readUInt32BE(16);
+        const height = buffer.readUInt32BE(20);
+        return { widthPx: width, heightPx: height };
+    }
+    catch {
+        return null;
+    }
+}
+export function getJpegDimensions(base64Data) {
+    try {
+        const buffer = Buffer.from(base64Data, "base64");
+        if (buffer.length < 2) {
+            return null;
+        }
+        if (buffer[0] !== 0xff || buffer[1] !== 0xd8) {
+            return null;
+        }
+        let offset = 2;
+        while (offset < buffer.length - 9) {
+            if (buffer[offset] !== 0xff) {
+                offset++;
+                continue;
+            }
+            const marker = buffer[offset + 1];
+            if (marker >= 0xc0 && marker <= 0xc2) {
+                const height = buffer.readUInt16BE(offset + 5);
+                const width = buffer.readUInt16BE(offset + 7);
+                return { widthPx: width, heightPx: height };
+            }
+            if (offset + 3 >= buffer.length) {
+                return null;
+            }
+            const length = buffer.readUInt16BE(offset + 2);
+            if (length < 2) {
+                return null;
+            }
+            offset += 2 + length;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getGifDimensions(base64Data) {
+    try {
+        const buffer = Buffer.from(base64Data, "base64");
+        if (buffer.length < 10) {
+            return null;
+        }
+        const sig = buffer.slice(0, 6).toString("ascii");
+        if (sig !== "GIF87a" && sig !== "GIF89a") {
+            return null;
+        }
+        const width = buffer.readUInt16LE(6);
+        const height = buffer.readUInt16LE(8);
+        return { widthPx: width, heightPx: height };
+    }
+    catch {
+        return null;
+    }
+}
+export function getWebpDimensions(base64Data) {
+    try {
+        const buffer = Buffer.from(base64Data, "base64");
+        if (buffer.length < 30) {
+            return null;
+        }
+        const riff = buffer.slice(0, 4).toString("ascii");
+        const webp = buffer.slice(8, 12).toString("ascii");
+        if (riff !== "RIFF" || webp !== "WEBP") {
+            return null;
+        }
+        const chunk = buffer.slice(12, 16).toString("ascii");
+        if (chunk === "VP8 ") {
+            if (buffer.length < 30)
+                return null;
+            const width = buffer.readUInt16LE(26) & 0x3fff;
+            const height = buffer.readUInt16LE(28) & 0x3fff;
+            return { widthPx: width, heightPx: height };
+        }
+        else if (chunk === "VP8L") {
+            if (buffer.length < 25)
+                return null;
+            const bits = buffer.readUInt32LE(21);
+            const width = (bits & 0x3fff) + 1;
+            const height = ((bits >> 14) & 0x3fff) + 1;
+            return { widthPx: width, heightPx: height };
+        }
+        else if (chunk === "VP8X") {
+            if (buffer.length < 30)
+                return null;
+            const width = (buffer[24] | (buffer[25] << 8) | (buffer[26] << 16)) + 1;
+            const height = (buffer[27] | (buffer[28] << 8) | (buffer[29] << 16)) + 1;
+            return { widthPx: width, heightPx: height };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getImageDimensions(base64Data, mimeType) {
+    if (mimeType === "image/png") {
+        return getPngDimensions(base64Data);
+    }
+    if (mimeType === "image/jpeg") {
+        return getJpegDimensions(base64Data);
+    }
+    if (mimeType === "image/gif") {
+        return getGifDimensions(base64Data);
+    }
+    if (mimeType === "image/webp") {
+        return getWebpDimensions(base64Data);
+    }
+    return null;
+}
+export function renderImage(base64Data, imageDimensions, options = {}) {
+    const caps = getCapabilities();
+    if (!caps.images) {
+        return null;
+    }
+    const maxWidth = options.maxWidthCells ?? 80;
+    const rows = calculateImageRows(imageDimensions, maxWidth, getCellDimensions());
+    if (caps.images === "kitty") {
+        // Only use imageId if explicitly provided - static images don't need IDs
+        const sequence = encodeKitty(base64Data, { columns: maxWidth, rows, imageId: options.imageId });
+        return { sequence, rows, imageId: options.imageId };
+    }
+    if (caps.images === "iterm2") {
+        const sequence = encodeITerm2(base64Data, {
+            width: maxWidth,
+            height: "auto",
+            preserveAspectRatio: options.preserveAspectRatio ?? true,
+        });
+        return { sequence, rows };
+    }
+    return null;
+}
+export function imageFallback(mimeType, dimensions, filename) {
+    const parts = [];
+    if (filename)
+        parts.push(filename);
+    parts.push(`[${mimeType}]`);
+    if (dimensions)
+        parts.push(`${dimensions.widthPx}x${dimensions.heightPx}`);
+    return `[Image: ${parts.join(" ")}]`;
+}
+//# sourceMappingURL=terminal-image.js.map