@chengchenccc/tui 0.1.1-rc.1

package/dist/virtual-terminal.js

@@ -0,0 +1,284 @@
+import xterm from "@xterm/headless";
+// Extract Terminal class from the module
+const XtermTerminal = xterm.Terminal;
+/**
+ * Virtual terminal for testing using xterm.js for accurate terminal emulation
+ */
+export class VirtualTerminal {
+    xterm;
+    inputHandler;
+    resizeHandler;
+    _columns;
+    _rows;
+    constructor(columns = 80, rows = 24) {
+        this._columns = columns;
+        this._rows = rows;
+        // Create xterm instance with specified dimensions
+        this.xterm = new XtermTerminal({
+            cols: columns,
+            rows: rows,
+            // Disable all interactive features for testing
+            disableStdin: true,
+            allowProposedApi: true,
+        });
+    }
+    start(onInput, onResize) {
+        this.inputHandler = onInput;
+        this.resizeHandler = onResize;
+        // Enable bracketed paste mode for consistency with ProcessTerminal
+        this.xterm.write("\x1b[?2004h");
+    }
+    async drainInput(_maxMs, _idleMs) {
+        // No-op for virtual terminal - no stdin to drain
+    }
+    stop() {
+        // Disable bracketed paste mode
+        this.xterm.write("\x1b[?2004l");
+        this.inputHandler = undefined;
+        this.resizeHandler = undefined;
+    }
+    write(data) {
+        this.xterm.write(data);
+    }
+    get columns() {
+        return this._columns;
+    }
+    get rows() {
+        return this._rows;
+    }
+    get kittyProtocolActive() {
+        // Virtual terminal always reports Kitty protocol as active for testing
+        return true;
+    }
+    moveBy(lines) {
+        if (lines > 0) {
+            // Move down
+            this.xterm.write(`\x1b[${lines}B`);
+        }
+        else if (lines < 0) {
+            // Move up
+            this.xterm.write(`\x1b[${-lines}A`);
+        }
+        // lines === 0: no movement
+    }
+    hideCursor() {
+        this.xterm.write("\x1b[?25l");
+    }
+    showCursor() {
+        this.xterm.write("\x1b[?25h");
+    }
+    clearLine() {
+        this.xterm.write("\x1b[K");
+    }
+    clearFromCursor() {
+        this.xterm.write("\x1b[J");
+    }
+    clearScreen() {
+        this.xterm.write("\x1b[2J\x1b[H"); // Clear screen and move to home (1,1)
+    }
+    setTitle(title) {
+        // OSC 0;title BEL - set terminal window title
+        this.xterm.write(`\x1b]0;${title}\x07`);
+    }
+    setProgress(_active) { }
+    // Test-specific methods not in Terminal interface
+    /**
+     * Simulate keyboard input
+     */
+    sendInput(data) {
+        if (this.inputHandler) {
+            this.inputHandler(data);
+        }
+    }
+    /**
+     * Resize the terminal
+     */
+    resize(columns, rows) {
+        this._columns = columns;
+        this._rows = rows;
+        this.xterm.resize(columns, rows);
+        if (this.resizeHandler) {
+            this.resizeHandler();
+        }
+    }
+    /**
+     * Wait for all pending writes to complete. Viewport and scroll buffer will be updated.
+     */
+    async flush() {
+        // Write an empty string to ensure all previous writes are flushed
+        return new Promise((resolve) => {
+            this.xterm.write("", () => resolve());
+        });
+    }
+    /**
+     * Flush and get viewport - convenience method for tests
+     */
+    async flushAndGetViewport() {
+        await this.flush();
+        return this.getViewport();
+    }
+    /**
+     * Get the visible viewport (what's currently on screen)
+     * Note: You should use getViewportAfterWrite() for testing after writing data
+     */
+    getViewport() {
+        const lines = [];
+        const buffer = this.xterm.buffer.active;
+        // Get only the visible lines (viewport)
+        for (let i = 0; i < this.xterm.rows; i++) {
+            const line = buffer.getLine(buffer.viewportY + i);
+            if (line) {
+                lines.push(line.translateToString(true));
+            }
+            else {
+                lines.push("");
+            }
+        }
+        return lines;
+    }
+    /**
+     * Get the entire scroll buffer
+     */
+    /**
+     * Like getViewport() but re-emits per-cell SGR styling (fg/bg/bold/dim/…)
+     * so snapshot tooling can see colors and backgrounds, not just text.
+     */
+    getViewportAnsi() {
+        const lines = [];
+        const buffer = this.xterm.buffer.active;
+        for (let i = 0; i < this.xterm.rows; i++) {
+            const line = buffer.getLine(buffer.viewportY + i);
+            if (!line) {
+                lines.push("");
+                continue;
+            }
+            lines.push(lineToAnsi(line));
+        }
+        return lines;
+    }
+    /** Scrollback + viewport with per-cell SGR re-emitted. */
+    getScrollBufferAnsi() {
+        const lines = [];
+        const buffer = this.xterm.buffer.active;
+        for (let i = 0; i < buffer.length; i++) {
+            const line = buffer.getLine(i);
+            lines.push(line ? lineToAnsi(line) : "");
+        }
+        return lines;
+    }
+    getScrollBuffer() {
+        const lines = [];
+        const buffer = this.xterm.buffer.active;
+        // Get all lines in the buffer (including scrollback)
+        for (let i = 0; i < buffer.length; i++) {
+            const line = buffer.getLine(i);
+            if (line) {
+                lines.push(line.translateToString(true));
+            }
+            else {
+                lines.push("");
+            }
+        }
+        return lines;
+    }
+    /**
+     * Clear the terminal viewport
+     */
+    clear() {
+        this.xterm.clear();
+    }
+    /**
+     * Reset the terminal completely
+     */
+    reset() {
+        this.xterm.reset();
+    }
+    /**
+     * Get cursor position
+     */
+    getCursorPosition() {
+        const buffer = this.xterm.buffer.active;
+        return {
+            x: buffer.cursorX,
+            y: buffer.cursorY,
+        };
+    }
+    /** Wait for TUI's throttled render pipeline to settle. */
+    async waitForRender() {
+        await new Promise((resolve) => process.nextTick(resolve));
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        await this.flush();
+    }
+}
+/** SGR escape for one cell's styling; empty string means default attrs. */
+function cellSgr(cell) {
+    const codes = [];
+    if (cell.isBold())
+        codes.push("1");
+    if (cell.isDim())
+        codes.push("2");
+    if (cell.isItalic())
+        codes.push("3");
+    if (cell.isUnderline())
+        codes.push("4");
+    if (cell.isInverse())
+        codes.push("7");
+    if (cell.isStrikethrough())
+        codes.push("9");
+    const fg = colorCode(cell.getFgColor(), cell.getFgColorMode(), 30);
+    if (fg)
+        codes.push(fg);
+    const bg = colorCode(cell.getBgColor(), cell.getBgColorMode(), 40);
+    if (bg)
+        codes.push(bg);
+    return codes.length > 0 ? `\x1b[${codes.join(";")}m` : "";
+}
+/** Map xterm color (palette index or packed rgb) to an SGR parameter. */
+function colorCode(color, mode, base) {
+    // xterm packs the color mode in bits 24-25: 0 = default, 1 = P16 palette,
+    // 2 = P256 palette, 3 = RGB.
+    const kind = mode >>> 24;
+    if (kind === 1) {
+        if (color < 8)
+            return `${base + color}`;
+        return `${base + 60 + color - 8}`;
+    }
+    if (kind === 2)
+        return `${base + 8};5;${color}`;
+    if (kind === 3) {
+        const r = (color >> 16) & 0xff;
+        const g = (color >> 8) & 0xff;
+        const b = color & 0xff;
+        return `${base + 8};2;${r};${g};${b}`;
+    }
+    return null;
+}
+/** One buffer row with SGR codes re-emitted between attribute runs. */
+export function lineToAnsi(line) {
+    let out = "";
+    let current = "";
+    let x = 0;
+    while (x < line.length) {
+        const cell = line.getCell(x);
+        if (!cell)
+            break;
+        const sgr = cellSgr(cell);
+        if (sgr !== current) {
+            current = sgr;
+            out += "\x1b[0m";
+            out += sgr;
+        }
+        const width = cell.getWidth();
+        if (width === 0) {
+            // Zero-width cell (e.g. after a wide char): escape only, no glyph.
+            out += cell.getChars();
+            x += 1;
+            continue;
+        }
+        out += cell.getChars() || " ";
+        x += width;
+    }
+    if (current)
+        out += "\x1b[0m";
+    return out;
+}

package/dist/word-navigation.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Options for word navigation functions.
+ * When omitted, uses the default Intl.Segmenter word segmentation.
+ */
+export interface WordNavigationOptions {
+    /** Custom segmenter returning word segments for the given text. */
+    segment?: (text: string) => Iterable<Intl.SegmentData>;
+    /** Predicate identifying atomic segments that should be treated as single units (e.g. paste markers). */
+    isAtomicSegment?: (segment: string) => boolean;
+}
+/**
+ * Find the cursor position after moving one word backward from `cursor` in `text`.
+ * Skips trailing whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export declare function findWordBackward(text: string, cursor: number, options?: WordNavigationOptions): number;
+/**
+ * Find the cursor position after moving one word forward from `cursor` in `text`.
+ * Skips leading whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export declare function findWordForward(text: string, cursor: number, options?: WordNavigationOptions): number;
+//# sourceMappingURL=word-navigation.d.ts.map

package/dist/word-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"word-navigation.d.ts","sourceRoot":"","sources":["../src/word-navigation.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,mEAAmE;IACnE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACvD,yGAAyG;IACzG,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;CAChD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,qBAAqB,GAC9B,MAAM,CAkDR;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,qBAAqB,GAC9B,MAAM,CAuCR"}

package/dist/word-navigation.js

@@ -0,0 +1,97 @@
+import { getWordSegmenter, isWhitespaceChar, PUNCTUATION_REGEX } from "./utils.js";
+const wordSegmenter = getWordSegmenter();
+/**
+ * Find the cursor position after moving one word backward from `cursor` in `text`.
+ * Skips trailing whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export function findWordBackward(text, cursor, options) {
+    if (cursor <= 0)
+        return 0;
+    const textBeforeCursor = text.slice(0, cursor);
+    const segmentFn = options?.segment;
+    const isAtomic = options?.isAtomicSegment;
+    const segments = segmentFn
+        ? [...segmentFn(textBeforeCursor)]
+        : [...wordSegmenter.segment(textBeforeCursor)];
+    let newCursor = cursor;
+    // Skip trailing whitespace
+    while (segments.length > 0 &&
+        !isAtomic?.(segments[segments.length - 1]?.segment || "") &&
+        isWhitespaceChar(segments[segments.length - 1]?.segment || "")) {
+        newCursor -= segments.pop()?.segment.length || 0;
+    }
+    if (segments.length === 0)
+        return newCursor;
+    const last = segments[segments.length - 1];
+    if (isAtomic?.(last.segment)) {
+        // Skip one atomic segment.
+        newCursor -= last.segment.length;
+    }
+    else if (last.isWordLike) {
+        // Skip inside one word-like segment, preserving ASCII punctuation boundaries.
+        const segment = last.segment;
+        const matches = [...segment.matchAll(new RegExp(PUNCTUATION_REGEX, "g"))];
+        if (matches.length <= 0) {
+            newCursor -= segment.length;
+        }
+        else {
+            const lastMatch = matches[matches.length - 1];
+            newCursor -= segment.length - (lastMatch.index + lastMatch[0].length);
+        }
+    }
+    else {
+        // Skip non-word non-whitespace run (punctuation)
+        while (segments.length > 0 &&
+            !isAtomic?.(segments[segments.length - 1]?.segment || "") &&
+            !segments[segments.length - 1]?.isWordLike &&
+            !isWhitespaceChar(segments[segments.length - 1]?.segment || "")) {
+            newCursor -= segments.pop()?.segment.length || 0;
+        }
+    }
+    return newCursor;
+}
+/**
+ * Find the cursor position after moving one word forward from `cursor` in `text`.
+ * Skips leading whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export function findWordForward(text, cursor, options) {
+    if (cursor >= text.length)
+        return text.length;
+    const textAfterCursor = text.slice(cursor);
+    const segmentFn = options?.segment;
+    const isAtomic = options?.isAtomicSegment;
+    const segments = segmentFn ? segmentFn(textAfterCursor) : wordSegmenter.segment(textAfterCursor);
+    const iterator = segments[Symbol.iterator]();
+    let next = iterator.next();
+    let newCursor = cursor;
+    // Skip leading whitespace
+    while (!next.done && !isAtomic?.(next.value.segment) && isWhitespaceChar(next.value.segment)) {
+        newCursor += next.value.segment.length;
+        next = iterator.next();
+    }
+    if (next.done)
+        return newCursor;
+    if (isAtomic?.(next.value.segment)) {
+        // Skip one atomic segment.
+        newCursor += next.value.segment.length;
+    }
+    else if (next.value.isWordLike) {
+        // Skip inside one word-like segment, preserving ASCII punctuation boundaries.
+        newCursor += PUNCTUATION_REGEX.exec(next.value.segment)?.index ?? next.value.segment.length;
+    }
+    else {
+        // Skip non-word non-whitespace run (punctuation)
+        while (!next.done &&
+            !isAtomic?.(next.value.segment) &&
+            !next.value.isWordLike &&
+            !isWhitespaceChar(next.value.segment)) {
+            newCursor += next.value.segment.length;
+            next = iterator.next();
+        }
+    }
+    return newCursor;
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@chengchenccc/tui",
+  "version": "0.1.1-rc.1",
+  "description": "Terminal UI library with differential rendering (vendored from @earendil-works/pi-tui, MIT)",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/virtual-terminal.d.ts",
+      "default": "./dist/virtual-terminal.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "biome check . && eslint .",
+    "test": "bun test --pass-with-no-tests",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit"
+  },
+  "dependencies": {
+    "get-east-asian-width": "^1.6.0",
+    "marked": "^18.0.5"
+  },
+  "devDependencies": {
+    "@xterm/headless": "5.5.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Chengchcc/my-agent-team.git",
+    "directory": "packages/tui"
+  }
+}