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

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

@@ -0,0 +1,33 @@
+/**
+ * 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).
+ */
+/**
+ * [WHO]: KillRing
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/lib/tui/src/index.ts
+ * [HERE]: core/lib/tui/src/kill-ring.ts -
+ */
+export declare class KillRing {
+    private 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: string, opts: {
+        prepend: boolean;
+        accumulate?: boolean;
+    }): void;
+    /** Get most recent entry without modifying the ring. */
+    peek(): string | undefined;
+    /** Move last entry to front (for yank-pop cycling). */
+    rotate(): void;
+    get length(): number;
+}

package/dist/node_modules/@pencil-agent/tui/dist/kill-ring.js

@@ -0,0 +1,49 @@
+/**
+ * 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).
+ */
+/**
+ * [WHO]: KillRing
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/lib/tui/src/index.ts
+ * [HERE]: core/lib/tui/src/kill-ring.ts -
+ */
+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;
+    }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * [WHO]: StdinBuffer class - buffers input and emits complete sequences
+ * [FROM]: Depends on node:events
+ * [TO]: Consumed by core/lib/tui/src/index.ts, TUI input handling
+ * [HERE]: core/lib/tui/src/stdin-buffer.ts - input buffering for terminal sequences
+ *
+ * Buffers stdin data events that arrive in partial chunks, especially for
+ * escape sequences like mouse events. Based on OpenTUI.
+ */
+import { EventEmitter } from "events";
+export type StdinBufferOptions = {
+    /**
+     * Maximum time to wait for sequence completion (default: 10ms)
+     * After this time, the buffer is flushed even if incomplete
+     */
+    timeout?: number;
+};
+export type StdinBufferEventMap = {
+    data: [string];
+    paste: [string];
+};
+/**
+ * Buffers stdin input and emits complete sequences via the 'data' event.
+ * Handles partial escape sequences that arrive across multiple chunks.
+ */
+export declare class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
+    private buffer;
+    private timeout;
+    private readonly timeoutMs;
+    private pasteMode;
+    private pasteBuffer;
+    constructor(options?: StdinBufferOptions);
+    process(data: string | Buffer): void;
+    flush(): string[];
+    clear(): void;
+    getBuffer(): string;
+    destroy(): void;
+}

package/dist/node_modules/@pencil-agent/tui/dist/stdin-buffer.js

@@ -0,0 +1,307 @@
+/**
+ * [WHO]: StdinBuffer class - buffers input and emits complete sequences
+ * [FROM]: Depends on node:events
+ * [TO]: Consumed by core/lib/tui/src/index.ts, TUI input handling
+ * [HERE]: core/lib/tui/src/stdin-buffer.ts - input buffering for terminal sequences
+ *
+ * Buffers stdin data events that arrive in partial chunks, especially for
+ * escape sequences like mouse events. Based on 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();
+    }
+}

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

@@ -0,0 +1,73 @@
+/**
+ * [WHO]: ImageProtocol, TerminalCapabilities, CellDimensions, ImageDimensions, ImageLayout
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by core/lib/tui/src/index.ts
+ * [HERE]: core/lib/tui/src/terminal-image.ts - terminal image protocol support
+ */
+export type ImageProtocol = "kitty" | "iterm2" | null;
+export interface TerminalCapabilities {
+    images: ImageProtocol;
+    trueColor: boolean;
+    hyperlinks: boolean;
+}
+export interface CellDimensions {
+    widthPx: number;
+    heightPx: number;
+}
+export interface ImageDimensions {
+    widthPx: number;
+    heightPx: number;
+}
+export interface ImageRenderOptions {
+    maxWidthCells?: number;
+    maxHeightCells?: number;
+    preserveAspectRatio?: boolean;
+    /** Kitty image ID. If provided, reuses/replaces existing image with this ID. */
+    imageId?: number;
+}
+export declare function getCellDimensions(): CellDimensions;
+export declare function setCellDimensions(dims: CellDimensions): void;
+export declare function detectCapabilities(): TerminalCapabilities;
+export declare function getCapabilities(): TerminalCapabilities;
+export declare function resetCapabilitiesCache(): void;
+export declare function isImageLine(line: string): boolean;
+/**
+ * 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 declare function allocateImageId(): number;
+export declare function encodeKitty(base64Data: string, options?: {
+    columns?: number;
+    rows?: number;
+    imageId?: number;
+}): string;
+/**
+ * Delete a Kitty graphics image by ID.
+ * Uses uppercase 'I' to also free the image data.
+ */
+export declare function deleteKittyImage(imageId: number): string;
+/**
+ * Delete all visible Kitty graphics images.
+ * Uses uppercase 'A' to also free the image data.
+ */
+export declare function deleteAllKittyImages(): string;
+export declare function encodeITerm2(base64Data: string, options?: {
+    width?: number | string;
+    height?: number | string;
+    name?: string;
+    preserveAspectRatio?: boolean;
+    inline?: boolean;
+}): string;
+export declare function calculateImageRows(imageDimensions: ImageDimensions, targetWidthCells: number, cellDimensions?: CellDimensions): number;
+export declare function getPngDimensions(base64Data: string): ImageDimensions | null;
+export declare function getJpegDimensions(base64Data: string): ImageDimensions | null;
+export declare function getGifDimensions(base64Data: string): ImageDimensions | null;
+export declare function getWebpDimensions(base64Data: string): ImageDimensions | null;
+export declare function getImageDimensions(base64Data: string, mimeType: string): ImageDimensions | null;
+export declare function renderImage(base64Data: string, imageDimensions: ImageDimensions, options?: ImageRenderOptions): {
+    sequence: string;
+    rows: number;
+    imageId?: number;
+} | null;
+export declare function imageFallback(mimeType: string, dimensions?: ImageDimensions, filename?: string): string;