@chengchenccc/tui 0.1.1-rc.1

package/dist/kill-ring.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 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;
+}
+//# sourceMappingURL=kill-ring.d.ts.map

package/dist/kill-ring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kill-ring.d.ts","sourceRoot":"","sources":["../src/kill-ring.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,IAAI,CAAgB;IAE5B;;;;;;;OAOG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IAW1E,wDAAwD;IACxD,IAAI,IAAI,MAAM,GAAG,SAAS;IAI1B,uDAAuD;IACvD,MAAM,IAAI,IAAI;IAOd,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF"}

package/dist/kill-ring.js

@@ -0,0 +1,43 @@
+/**
+ * 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;
+    }
+}

package/dist/mermaid.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Mermaid ASCII rendering helper (omp mermaid-cache equivalent).
+ *
+ * The vendored `beautiful-mermaid` fork supports a `direction` override, so a
+ * wide diagram can be re-laid-out top-down (or left-right) to fit a terminal
+ * width. We memoize renders by source + options + direction and only choose a
+ * forced direction when the base layout overflows the requested maxWidth.
+ */
+import { type AsciiRenderOptions } from "./vendor/mermaid-ascii/index.ts";
+export type { AsciiRenderOptions as MermaidAsciiRenderOptions };
+export declare function renderMermaidAsciiSafe(source: string, options?: AsciiRenderOptions): string | null;
+export interface MermaidResolveOptions extends AsciiRenderOptions {
+    /** Maximum display width (terminal columns) the diagram should occupy. */
+    maxWidth?: number;
+}
+/**
+ * Resolve mermaid ASCII for a fenced block.
+ * Returns null on failure, memoizing failures to avoid repeated work.
+ */
+export declare function resolveMermaidAscii(source: string, options?: MermaidResolveOptions): string | null;
+/** Clear the mermaid cache (used on session reset). */
+export declare function clearMermaidCache(): void;
+//# sourceMappingURL=mermaid.d.ts.map

package/dist/mermaid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mermaid.d.ts","sourceRoot":"","sources":["../src/mermaid.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,iCAAiC,CAAC;AAE9F,YAAY,EAAE,kBAAkB,IAAI,yBAAyB,EAAE,CAAC;AA+BhE,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,kBAAkB,GAC3B,MAAM,GAAG,IAAI,CAMf;AAED,MAAM,WAAW,qBAAsB,SAAQ,kBAAkB;IAC/D,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,qBAAqB,GAC9B,MAAM,GAAG,IAAI,CA4Bf;AAED,uDAAuD;AACvD,wBAAgB,iBAAiB,IAAI,IAAI,CAExC"}

package/dist/mermaid.js

@@ -0,0 +1,77 @@
+/**
+ * Mermaid ASCII rendering helper (omp mermaid-cache equivalent).
+ *
+ * The vendored `beautiful-mermaid` fork supports a `direction` override, so a
+ * wide diagram can be re-laid-out top-down (or left-right) to fit a terminal
+ * width. We memoize renders by source + options + direction and only choose a
+ * forced direction when the base layout overflows the requested maxWidth.
+ */
+import { renderMermaidASCII } from "./vendor/mermaid-ascii/index.js";
+/** Memoized renders (and failures), keyed on source + options + direction. */
+const cache = new Map();
+/** Widest rendered row in display columns (Bun wcwidth-style). */
+function asciiDisplayWidth(ascii) {
+    let max = 0;
+    for (const line of ascii.split("\n")) {
+        const width = Bun.stringWidth(line);
+        if (width > max)
+            max = width;
+    }
+    return max;
+}
+function renderVariant(source, baseOptions, baseKey, direction) {
+    const key = `${baseKey}\x00${direction ?? ""}\x00${source}`;
+    const cached = cache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const options = direction ? { ...baseOptions, direction } : baseOptions;
+    const ascii = renderMermaidAsciiSafe(source, options);
+    cache.set(key, ascii);
+    return ascii;
+}
+export function renderMermaidAsciiSafe(source, options) {
+    try {
+        return renderMermaidASCII(source, options);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve mermaid ASCII for a fenced block.
+ * Returns null on failure, memoizing failures to avoid repeated work.
+ */
+export function resolveMermaidAscii(source, options) {
+    const normalized = source.replace(/\r\n?/g, "\n").trim();
+    if (!normalized)
+        return null;
+    const { maxWidth, ...rest } = options ?? {};
+    const baseOptions = { colorMode: "none", ...rest };
+    const baseKey = JSON.stringify(baseOptions);
+    const base = renderVariant(normalized, baseOptions, baseKey, null);
+    if (base === null)
+        return null;
+    if (maxWidth === undefined)
+        return base;
+    let best = base;
+    let bestWidth = asciiDisplayWidth(base);
+    if (bestWidth <= maxWidth)
+        return base;
+    // As-authored layout overflows. Render both forced orientations and keep the
+    // narrowest; clipping at the call site handles any residual overflow.
+    for (const direction of ["TD", "LR"]) {
+        const variant = renderVariant(normalized, baseOptions, baseKey, direction);
+        if (variant === null)
+            continue;
+        const variantWidth = asciiDisplayWidth(variant);
+        if (variantWidth < bestWidth) {
+            best = variant;
+            bestWidth = variantWidth;
+        }
+    }
+    return best;
+}
+/** Clear the mermaid cache (used on session reset). */
+export function clearMermaidCache() {
+    cache.clear();
+}

package/dist/mouse.d.ts

@@ -0,0 +1,40 @@
+/** SGR mouse report parsing (`\x1b[<button;col;rowM` / `…m`).
+ *
+ * Mouse tracking (modes 1000 + 1006) is enabled by the APPLICATION (oma
+ * enables it for the whole session so the wheel can scroll the transcript —
+ * our TUI keeps no native-scrollback copy of history). Consumers get 0-based
+ * col/row for direct indexing into rendered lines.
+ *
+ * ponytail: wheel-only consumer for now; click/hover routing (pi's
+ * SelectListMouseTarget helpers) can be ported when an overlay needs it.
+ *
+ * Ported from pi's packages/tui/src/mouse.ts. */
+/** A decoded SGR mouse report. */
+export interface SgrMouseEvent {
+    /** Raw button code (bit 32 = motion, bit 64 = wheel, low bits = button). */
+    button: number;
+    /** 0-based column of the event. */
+    col: number;
+    /** 0-based row of the event. */
+    row: number;
+    /** True for a release report (`m` suffix). */
+    release: boolean;
+    /** Wheel direction: -1 up, 1 down, null when not a wheel event. */
+    wheel: -1 | 1 | null;
+    /** True when the pointer moved (hover or drag) rather than clicked. */
+    motion: boolean;
+    /** True for a left-button press (not motion, not release, not wheel). */
+    leftClick: boolean;
+}
+/** Decode an SGR mouse report, or return null when `data` is not one.
+ *  Callers on hot keypress paths should pre-check `data.startsWith("\x1b[<")`
+ *  before paying for the regex. */
+export declare function parseSgrMouse(data: string): SgrMouseEvent | null;
+/** Handler invoked with a decoded SGR event; returning `false` reports unhandled. */
+export type SgrMouseHandler = (event: SgrMouseEvent) => boolean | undefined;
+/** Decode an SGR mouse report and forward it to `handler`. Returns `false`
+ *  when `data` is not an SGR mouse report (or fails to parse), so callers can
+ *  fall through to other input handling. Centralizes the repeated
+ *  `data.startsWith("\x1b[<")` + `parseSgrMouse()` pattern. */
+export declare function routeSgrMouseInput(data: string, handler: SgrMouseHandler): boolean;
+//# sourceMappingURL=mouse.d.ts.map

package/dist/mouse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mouse.d.ts","sourceRoot":"","sources":["../src/mouse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;iDAUiD;AAEjD,kCAAkC;AAClC,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,gCAAgC;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAC;IACjB,mEAAmE;IACnE,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACrB,uEAAuE;IACvE,MAAM,EAAE,OAAO,CAAC;IAChB,yEAAyE;IACzE,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;mCAEmC;AACnC,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAWhE;AAED,qFAAqF;AACrF,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,GAAG,SAAS,CAAC;AAE5E;;;+DAG+D;AAC/D,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAKlF"}

package/dist/mouse.js

@@ -0,0 +1,39 @@
+/** SGR mouse report parsing (`\x1b[<button;col;rowM` / `…m`).
+ *
+ * Mouse tracking (modes 1000 + 1006) is enabled by the APPLICATION (oma
+ * enables it for the whole session so the wheel can scroll the transcript —
+ * our TUI keeps no native-scrollback copy of history). Consumers get 0-based
+ * col/row for direct indexing into rendered lines.
+ *
+ * ponytail: wheel-only consumer for now; click/hover routing (pi's
+ * SelectListMouseTarget helpers) can be ported when an overlay needs it.
+ *
+ * Ported from pi's packages/tui/src/mouse.ts. */
+/** Decode an SGR mouse report, or return null when `data` is not one.
+ *  Callers on hot keypress paths should pre-check `data.startsWith("\x1b[<")`
+ *  before paying for the regex. */
+export function parseSgrMouse(data) {
+    const match = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/.exec(data);
+    if (!match)
+        return null;
+    const button = Number(match[1]);
+    const col = Number(match[2]) - 1;
+    const row = Number(match[3]) - 1;
+    const release = match[4] === "m";
+    const wheel = button & 64 ? (button & 1 ? 1 : -1) : null;
+    const motion = (button & 32) !== 0 && wheel === null;
+    const leftClick = !release && wheel === null && !motion && (button & 3) === 0;
+    return { button, col, row, release, wheel, motion, leftClick };
+}
+/** Decode an SGR mouse report and forward it to `handler`. Returns `false`
+ *  when `data` is not an SGR mouse report (or fails to parse), so callers can
+ *  fall through to other input handling. Centralizes the repeated
+ *  `data.startsWith("\x1b[<")` + `parseSgrMouse()` pattern. */
+export function routeSgrMouseInput(data, handler) {
+    if (!data.startsWith("\x1b[<"))
+        return false;
+    const event = parseSgrMouse(data);
+    if (!event)
+        return false;
+    return handler(event) !== false;
+}

package/dist/mouse.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mouse.test.d.ts.map

package/dist/mouse.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mouse.test.d.ts","sourceRoot":"","sources":["../src/mouse.test.ts"],"names":[],"mappings":""}

package/dist/mouse.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+import { parseSgrMouse, routeSgrMouseInput } from "./mouse.js";
+describe("parseSgrMouse", () => {
+    test("wheel up (button 64) and wheel down (button 65)", () => {
+        const up = parseSgrMouse("\x1b[<64;10;5M");
+        expect(up).toMatchObject({ button: 64, col: 9, row: 4, wheel: -1, release: false });
+        const down = parseSgrMouse("\x1b[<65;1;1M");
+        expect(down).toMatchObject({ button: 65, wheel: 1, col: 0, row: 0 });
+    });
+    test("left click press vs release vs motion", () => {
+        expect(parseSgrMouse("\x1b[<0;3;3M")).toMatchObject({ leftClick: true, motion: false });
+        expect(parseSgrMouse("\x1b[<0;3;3m")).toMatchObject({ release: true, leftClick: false });
+        expect(parseSgrMouse("\x1b[<32;3;3M")).toMatchObject({ motion: true, leftClick: false });
+    });
+    test("non-mouse input returns null", () => {
+        expect(parseSgrMouse("\x1b[A")).toBeNull();
+        expect(parseSgrMouse("\x1b[5~")).toBeNull();
+        expect(parseSgrMouse("x")).toBeNull();
+    });
+});
+describe("routeSgrMouseInput", () => {
+    test("routes wheel and reports consumed; falls through on other input", () => {
+        const wheels = [];
+        const consumed = routeSgrMouseInput("\x1b[<64;1;1M", (event) => {
+            if (event.wheel)
+                wheels.push(event.wheel);
+            return true;
+        });
+        expect(consumed).toBe(true);
+        // Not an SGR report: handler must not run.
+        expect(routeSgrMouseInput("\x1b[5~", () => {
+            wheels.push(99);
+        })).toBe(false);
+        expect(wheels).toEqual([-1]);
+    });
+});

package/dist/native-modifiers.d.ts

@@ -0,0 +1,3 @@
+export type ModifierKey = "shift" | "command" | "control" | "option";
+export declare function isNativeModifierPressed(key: ModifierKey): boolean;
+//# sourceMappingURL=native-modifiers.d.ts.map

package/dist/native-modifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-modifiers.d.ts","sourceRoot":"","sources":["../src/native-modifiers.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;AAkDrE,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAQjE"}

package/dist/native-modifiers.js

@@ -0,0 +1,52 @@
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+const cjsRequire = createRequire(import.meta.url);
+let nativeModifiersHelper;
+function isNativeModifiersHelper(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const candidate = value.isModifierPressed;
+    return typeof candidate === "function";
+}
+function loadNativeModifiersHelper() {
+    if (nativeModifiersHelper !== undefined)
+        return nativeModifiersHelper ?? undefined;
+    nativeModifiersHelper = null;
+    if (process.platform !== "darwin")
+        return undefined;
+    const arch = process.arch;
+    if (arch !== "x64" && arch !== "arm64")
+        return undefined;
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const nativePath = path.join("native", "darwin", "prebuilds", `darwin-${arch}`, "darwin-modifiers.node");
+    const candidates = [
+        path.join(moduleDir, "..", nativePath),
+        path.join(moduleDir, nativePath),
+        path.join(path.dirname(process.execPath), nativePath),
+    ];
+    for (const modulePath of candidates) {
+        try {
+            const helper = cjsRequire(modulePath);
+            if (isNativeModifiersHelper(helper)) {
+                nativeModifiersHelper = helper;
+                return helper;
+            }
+        }
+        catch {
+            // Try the next possible packaging location.
+        }
+    }
+    return undefined;
+}
+export function isNativeModifierPressed(key) {
+    const helper = loadNativeModifiersHelper();
+    if (!helper)
+        return false;
+    try {
+        return helper.isModifierPressed(key) === true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/stdin-buffer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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";
+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;
+    private pendingKittyPrintableCodepoint;
+    constructor(options?: StdinBufferOptions);
+    process(data: string | Buffer): void;
+    private emitDataSequence;
+    flush(): string[];
+    clear(): void;
+    getBuffer(): string;
+    destroy(): void;
+}
+//# sourceMappingURL=stdin-buffer.d.ts.map

package/dist/stdin-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdin-buffer.d.ts","sourceRoot":"","sources":["../src/stdin-buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAgPtC,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC;IACf,KAAK,EAAE,CAAC,MAAM,CAAC,CAAC;CACjB,CAAC;AAEF;;;GAGG;AACH,qBAAa,WAAY,SAAQ,YAAY,CAAC,mBAAmB,CAAC;IAChE,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,OAAO,CAA8C;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,8BAA8B,CAAqB;gBAE/C,OAAO,GAAE,kBAAuB;IAKrC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAsG3C,OAAO,CAAC,gBAAgB;IAWxB,KAAK,IAAI,MAAM,EAAE;IAgBjB,KAAK,IAAI,IAAI;IAWb,SAAS,IAAI,MAAM;IAInB,OAAO,IAAI,IAAI;CAGhB"}