indusagi 0.12.24 → 0.12.26

package/dist/ui/tui.js

@@ -1,928 +0,0 @@
-/**
- * Minimal TUI implementation with differential rendering
- */
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { isKeyRelease, matchesKey } from "./keys.js";
-import { getCapabilities, setCellDimensions } from "./terminal-image.js";
-import { extractSegments, sliceByColumn, sliceWithWidth, truncateToWidth, visibleWidth } from "./utils.js";
-export class ComponentBase {
-    _cachedWidth;
-    _cachedRender;
-    wantsKeyRelease;
-    invalidate() {
-        this._cachedWidth = undefined;
-        this._cachedRender = undefined;
-    }
-    renderCached(width, renderFn) {
-        if (this._cachedRender && this._cachedWidth === width) {
-            return this._cachedRender;
-        }
-        const rendered = renderFn();
-        this._cachedWidth = width;
-        this._cachedRender = rendered;
-        return rendered;
-    }
-}
-/** Type guard to check if a component implements Focusable */
-export function isFocusable(component) {
-    return component !== null && "focused" in component;
-}
-/**
- * Cursor position marker - APC (Application Program Command) sequence.
- * This is a zero-width escape sequence that terminals ignore.
- * Components emit this at the cursor position when focused.
- * TUI finds and strips this marker, then positions the hardware cursor there.
- */
-export const CURSOR_MARKER = "\x1b_pi:c\x07";
-export { visibleWidth };
-/** Parse a SizeValue into absolute value given a reference size */
-function parseSizeValue(value, referenceSize) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value === "number")
-        return value;
-    // Parse percentage string like "50%"
-    const match = value.match(/^(\d+(?:\.\d+)?)%$/);
-    if (match) {
-        return Math.floor((referenceSize * parseFloat(match[1])) / 100);
-    }
-    return undefined;
-}
-export class FocusManager {
-    focused = null;
-    setFocus(component) {
-        const previous = this.focused;
-        if (isFocusable(previous))
-            previous.focused = false;
-        previous?.onBlur?.();
-        this.focused = component;
-        if (isFocusable(component))
-            component.focused = true;
-        component?.onFocus?.();
-        return { previous, current: component };
-    }
-    getFocus() {
-        return this.focused;
-    }
-}
-export class RenderEngine {
-    diffLines(oldLines, newLines) {
-        let firstChanged = -1;
-        let lastChanged = -1;
-        const maxLines = Math.max(newLines.length, oldLines.length);
-        for (let i = 0; i < maxLines; i++) {
-            const oldLine = i < oldLines.length ? oldLines[i] : "";
-            const newLine = i < newLines.length ? newLines[i] : "";
-            if (oldLine !== newLine) {
-                if (firstChanged === -1)
-                    firstChanged = i;
-                lastChanged = i;
-            }
-        }
-        const appended = newLines.length > oldLines.length;
-        if (appended) {
-            if (firstChanged === -1)
-                firstChanged = oldLines.length;
-            lastChanged = newLines.length - 1;
-        }
-        return { firstChanged, lastChanged, appended };
-    }
-}
-export class LayoutEngine {
-    resolveOverlayLayout(options, overlayHeight, termWidth, termHeight) {
-        const opt = options ?? {};
-        const margin = typeof opt.margin === "number"
-            ? { top: opt.margin, right: opt.margin, bottom: opt.margin, left: opt.margin }
-            : (opt.margin ?? {});
-        const marginTop = Math.max(0, margin.top ?? 0);
-        const marginRight = Math.max(0, margin.right ?? 0);
-        const marginBottom = Math.max(0, margin.bottom ?? 0);
-        const marginLeft = Math.max(0, margin.left ?? 0);
-        const availWidth = Math.max(1, termWidth - marginLeft - marginRight);
-        const availHeight = Math.max(1, termHeight - marginTop - marginBottom);
-        let width = parseSizeValue(opt.width, termWidth) ?? Math.min(80, availWidth);
-        if (opt.minWidth !== undefined)
-            width = Math.max(width, opt.minWidth);
-        width = Math.max(1, Math.min(width, availWidth));
-        let maxHeight = parseSizeValue(opt.maxHeight, termHeight);
-        if (maxHeight !== undefined)
-            maxHeight = Math.max(1, Math.min(maxHeight, availHeight));
-        const effectiveHeight = maxHeight !== undefined ? Math.min(overlayHeight, maxHeight) : overlayHeight;
-        let row;
-        let col;
-        if (opt.row !== undefined) {
-            if (typeof opt.row === "string") {
-                const match = opt.row.match(/^(\d+(?:\.\d+)?)%$/);
-                if (match) {
-                    const maxRow = Math.max(0, availHeight - effectiveHeight);
-                    row = marginTop + Math.floor(maxRow * (parseFloat(match[1]) / 100));
-                }
-                else
-                    row = this.resolveAnchorRow("center", effectiveHeight, availHeight, marginTop);
-            }
-            else
-                row = opt.row;
-        }
-        else
-            row = this.resolveAnchorRow(opt.anchor ?? "center", effectiveHeight, availHeight, marginTop);
-        if (opt.col !== undefined) {
-            if (typeof opt.col === "string") {
-                const match = opt.col.match(/^(\d+(?:\.\d+)?)%$/);
-                if (match) {
-                    const maxCol = Math.max(0, availWidth - width);
-                    col = marginLeft + Math.floor(maxCol * (parseFloat(match[1]) / 100));
-                }
-                else
-                    col = this.resolveAnchorCol("center", width, availWidth, marginLeft);
-            }
-            else
-                col = opt.col;
-        }
-        else
-            col = this.resolveAnchorCol(opt.anchor ?? "center", width, availWidth, marginLeft);
-        if (opt.offsetY !== undefined)
-            row += opt.offsetY;
-        if (opt.offsetX !== undefined)
-            col += opt.offsetX;
-        row = Math.max(marginTop, Math.min(row, termHeight - marginBottom - effectiveHeight));
-        col = Math.max(marginLeft, Math.min(col, termWidth - marginRight - width));
-        return { width, row, col, maxHeight };
-    }
-    resolveAnchorRow(anchor, height, availHeight, marginTop) {
-        switch (anchor) {
-            case "top-left":
-            case "top-center":
-            case "top-right":
-                return marginTop;
-            case "bottom-left":
-            case "bottom-center":
-            case "bottom-right":
-                return marginTop + availHeight - height;
-            default:
-                return marginTop + Math.floor((availHeight - height) / 2);
-        }
-    }
-    resolveAnchorCol(anchor, width, availWidth, marginLeft) {
-        switch (anchor) {
-            case "top-left":
-            case "left-center":
-            case "bottom-left":
-                return marginLeft;
-            case "top-right":
-            case "right-center":
-            case "bottom-right":
-                return marginLeft + availWidth - width;
-            default:
-                return marginLeft + Math.floor((availWidth - width) / 2);
-        }
-    }
-}
-/**
- * Container - a component that contains other components
- */
-export class Container extends ComponentBase {
-    children = [];
-    addChild(component) {
-        this.children.push(component);
-        component.onMount?.();
-    }
-    removeChild(component) {
-        const index = this.children.indexOf(component);
-        if (index !== -1) {
-            this.children.splice(index, 1);
-            component.onUnmount?.();
-        }
-    }
-    clear() {
-        for (const child of this.children)
-            child.onUnmount?.();
-        this.children = [];
-    }
-    invalidate() {
-        for (const child of this.children) {
-            child.invalidate?.();
-        }
-    }
-    render(width) {
-        const lines = [];
-        for (const child of this.children) {
-            lines.push(...child.render(width));
-        }
-        return lines;
-    }
-}
-class OverlayRegistry {
-    stack = [];
-    create(component, options, preFocus) {
-        const entry = { component, options, preFocus, hidden: false };
-        this.stack.push(entry);
-        return entry;
-    }
-    remove(entry) {
-        const index = this.stack.indexOf(entry);
-        if (index === -1)
-            return false;
-        this.stack.splice(index, 1);
-        return true;
-    }
-    pop() {
-        return this.stack.pop();
-    }
-    values() {
-        return this.stack;
-    }
-    count() {
-        return this.stack.length;
-    }
-    isVisible(entry, termWidth, termHeight) {
-        if (entry.hidden)
-            return false;
-        if (!entry.options?.visible)
-            return true;
-        return entry.options.visible(termWidth, termHeight);
-    }
-    topVisible(termWidth, termHeight) {
-        for (let i = this.stack.length - 1; i >= 0; i--) {
-            const entry = this.stack[i];
-            if (this.isVisible(entry, termWidth, termHeight))
-                return entry;
-        }
-        return undefined;
-    }
-    hasVisible(termWidth, termHeight) {
-        return this.stack.some((entry) => this.isVisible(entry, termWidth, termHeight));
-    }
-}
-class InputDispatchEngine {
-    applyListeners(data, listeners) {
-        if (listeners.size === 0)
-            return data;
-        let current = data;
-        for (const listener of listeners) {
-            const result = listener(current);
-            if (result?.consume)
-                return null;
-            if (result?.data !== undefined)
-                current = result.data;
-        }
-        return current.length > 0 ? current : null;
-    }
-    dispatchToFocused(data, focused) {
-        if (!focused?.handleInput)
-            return false;
-        if (isKeyRelease(data) && !focused.wantsKeyRelease)
-            return false;
-        focused.handleInput(data);
-        return true;
-    }
-}
-class CursorPlacementResolver {
-    static extract(lines) {
-        for (let row = 0; row < lines.length; row++) {
-            const line = lines[row];
-            const markerIndex = line.indexOf(CURSOR_MARKER);
-            if (markerIndex === -1)
-                continue;
-            const col = visibleWidth(line.slice(0, markerIndex));
-            lines[row] = line.slice(0, markerIndex) + line.slice(markerIndex + CURSOR_MARKER.length);
-            return { row, col };
-        }
-        return null;
-    }
-}
-/**
- * TUI - Main class for managing terminal UI with differential rendering
- */
-export class TUI extends Container {
-    terminal;
-    previousLines = [];
-    previousWidth = 0;
-    focusedComponent = null;
-    inputListeners = new Set();
-    focusManager = new FocusManager();
-    renderEngine = new RenderEngine();
-    layoutEngine = new LayoutEngine();
-    inputDispatcher = new InputDispatchEngine();
-    overlayRegistry = new OverlayRegistry();
-    /** Global callback for debug key (Shift+Ctrl+D). Called before input is forwarded to focused component. */
-    onDebug;
-    renderRequested = false;
-    cursorRow = 0; // Logical cursor row (end of rendered content)
-    hardwareCursorRow = 0; // Actual terminal cursor row (may differ due to IME positioning)
-    inputBuffer = ""; // Buffer for parsing terminal responses
-    cellSizeQueryPending = false;
-    showHardwareCursor = process.env.INDUSAGI_HARDWARE_CURSOR === "1";
-    maxLinesRendered = 0; // Track terminal's working area (max lines ever rendered)
-    previousViewportTop = 0; // Track previous viewport top for resize-aware cursor moves
-    fullRedrawCount = 0;
-    // Overlay stack for modal components rendered on top of base content is maintained by OverlayRegistry
-    constructor(terminal, showHardwareCursor) {
-        super();
-        this.terminal = terminal;
-        if (showHardwareCursor !== undefined) {
-            this.showHardwareCursor = showHardwareCursor;
-        }
-    }
-    get fullRedraws() {
-        return this.fullRedrawCount;
-    }
-    getShowHardwareCursor() {
-        return this.showHardwareCursor;
-    }
-    setShowHardwareCursor(enabled) {
-        if (this.showHardwareCursor === enabled)
-            return;
-        this.showHardwareCursor = enabled;
-        if (!enabled) {
-            this.terminal.hideCursor();
-        }
-        this.requestRender();
-    }
-    setFocus(component) {
-        this.focusManager.setFocus(component);
-        this.focusedComponent = this.focusManager.getFocus();
-    }
-    /**
-     * Show an overlay component with configurable positioning and sizing.
-     * Returns a handle to control the overlay's visibility.
-     */
-    showOverlay(component, options) {
-        const entry = this.overlayRegistry.create(component, options, this.focusedComponent);
-        if (this.isOverlayVisible(entry)) {
-            this.setFocus(component);
-        }
-        this.terminal.hideCursor();
-        this.requestRender();
-        return {
-            hide: () => {
-                if (!this.overlayRegistry.remove(entry))
-                    return;
-                if (this.focusedComponent === component) {
-                    const topVisible = this.getTopmostVisibleOverlay();
-                    this.setFocus(topVisible?.component ?? entry.preFocus);
-                }
-                if (this.overlayRegistry.count() === 0)
-                    this.terminal.hideCursor();
-                this.requestRender();
-            },
-            setHidden: (hidden) => {
-                if (entry.hidden === hidden)
-                    return;
-                entry.hidden = hidden;
-                if (hidden) {
-                    if (this.focusedComponent === component) {
-                        const topVisible = this.getTopmostVisibleOverlay();
-                        this.setFocus(topVisible?.component ?? entry.preFocus);
-                    }
-                }
-                else if (this.isOverlayVisible(entry)) {
-                    this.setFocus(component);
-                }
-                this.requestRender();
-            },
-            isHidden: () => entry.hidden,
-        };
-    }
-    /** Hide the topmost overlay and restore previous focus. */
-    hideOverlay() {
-        const overlay = this.overlayRegistry.pop();
-        if (!overlay)
-            return;
-        const topVisible = this.getTopmostVisibleOverlay();
-        this.setFocus(topVisible?.component ?? overlay.preFocus);
-        if (this.overlayRegistry.count() === 0)
-            this.terminal.hideCursor();
-        this.requestRender();
-    }
-    /** Check if there are any visible overlays */
-    hasOverlay() {
-        return this.overlayRegistry.hasVisible(this.terminal.columns, this.terminal.rows);
-    }
-    /** Check if an overlay entry is currently visible */
-    isOverlayVisible(entry) {
-        return this.overlayRegistry.isVisible(entry, this.terminal.columns, this.terminal.rows);
-    }
-    /** Find the topmost visible overlay, if any */
-    getTopmostVisibleOverlay() {
-        return this.overlayRegistry.topVisible(this.terminal.columns, this.terminal.rows);
-    }
-    invalidate() {
-        super.invalidate();
-        for (const overlay of this.overlayRegistry.values()) {
-            overlay.component.invalidate?.();
-        }
-    }
-    start() {
-        this.terminal.start((data) => this.handleInput(data), () => this.requestRender());
-        this.terminal.hideCursor();
-        this.queryCellSize();
-        this.requestRender();
-    }
-    addInputListener(listener) {
-        this.inputListeners.add(listener);
-        return () => {
-            this.inputListeners.delete(listener);
-        };
-    }
-    removeInputListener(listener) {
-        this.inputListeners.delete(listener);
-    }
-    queryCellSize() {
-        // Only query if terminal supports images (cell size is only used for image rendering)
-        if (!getCapabilities().images) {
-            return;
-        }
-        // Query terminal for cell size in pixels: CSI 16 t
-        // Response format: CSI 6 ; height ; width t
-        this.cellSizeQueryPending = true;
-        this.terminal.write("\x1b[16t");
-    }
-    stop() {
-        // Move cursor to the end of the content to prevent overwriting/artifacts on exit
-        if (this.previousLines.length > 0) {
-            const targetRow = this.previousLines.length; // Line after the last content
-            const lineDiff = targetRow - this.hardwareCursorRow;
-            if (lineDiff > 0) {
-                this.terminal.write(`\x1b[${lineDiff}B`);
-            }
-            else if (lineDiff < 0) {
-                this.terminal.write(`\x1b[${-lineDiff}A`);
-            }
-            this.terminal.write("\r\n");
-        }
-        this.terminal.showCursor();
-        this.terminal.stop();
-    }
-    requestRender(force = false) {
-        if (force) {
-            this.previousLines = [];
-            this.previousWidth = -1; // -1 triggers widthChanged, forcing a full clear
-            this.cursorRow = 0;
-            this.hardwareCursorRow = 0;
-            this.maxLinesRendered = 0;
-            this.previousViewportTop = 0;
-        }
-        if (this.renderRequested)
-            return;
-        this.renderRequested = true;
-        process.nextTick(() => {
-            this.renderRequested = false;
-            this.doRender();
-        });
-    }
-    handleInput(data) {
-        const listenerData = this.inputDispatcher.applyListeners(data, this.inputListeners);
-        if (listenerData === null)
-            return;
-        data = listenerData;
-        if (this.cellSizeQueryPending) {
-            this.inputBuffer += data;
-            const filtered = this.parseCellSizeResponse();
-            if (filtered.length === 0)
-                return;
-            data = filtered;
-        }
-        if (matchesKey(data, "shift+ctrl+d") && this.onDebug) {
-            this.onDebug();
-            return;
-        }
-        const focusedOverlay = this.overlayRegistry.values().find((entry) => entry.component === this.focusedComponent);
-        if (focusedOverlay && !this.isOverlayVisible(focusedOverlay)) {
-            const topVisible = this.getTopmostVisibleOverlay();
-            this.setFocus(topVisible?.component ?? focusedOverlay.preFocus);
-        }
-        if (this.inputDispatcher.dispatchToFocused(data, this.focusedComponent)) {
-            this.requestRender();
-        }
-    }
-    parseCellSizeResponse() {
-        // Response format: ESC [ 6 ; height ; width t
-        // Match the response pattern
-        const responsePattern = /\x1b\[6;(\d+);(\d+)t/;
-        const match = this.inputBuffer.match(responsePattern);
-        if (match) {
-            const heightPx = parseInt(match[1], 10);
-            const widthPx = parseInt(match[2], 10);
-            if (heightPx > 0 && widthPx > 0) {
-                setCellDimensions({ widthPx, heightPx });
-                // Invalidate all components so images re-render with correct dimensions
-                this.invalidate();
-                this.requestRender();
-            }
-            // Remove the response from buffer
-            this.inputBuffer = this.inputBuffer.replace(responsePattern, "");
-            this.cellSizeQueryPending = false;
-        }
-        // Check if we have a partial cell size response starting (wait for more data)
-        // Patterns that could be incomplete cell size response: \x1b, \x1b[, \x1b[6, \x1b[6;...(no t yet)
-        const partialCellSizePattern = /\x1b(\[6?;?[\d;]*)?$/;
-        if (partialCellSizePattern.test(this.inputBuffer)) {
-            // Check if it's actually a complete different escape sequence (ends with a letter)
-            // Cell size response ends with 't', Kitty keyboard ends with 'u', arrows end with A-D, etc.
-            const lastChar = this.inputBuffer[this.inputBuffer.length - 1];
-            if (!/[a-zA-Z~]/.test(lastChar)) {
-                // Doesn't end with a terminator, might be incomplete - wait for more
-                return "";
-            }
-        }
-        // No cell size response found, return buffered data as user input
-        const result = this.inputBuffer;
-        this.inputBuffer = "";
-        this.cellSizeQueryPending = false; // Give up waiting
-        return result;
-    }
-    containsImage(line) {
-        return line.includes("\x1b_G") || line.includes("\x1b]1337;File=");
-    }
-    /**
-     * Resolve overlay layout from options.
-     * Returns { width, row, col, maxHeight } for rendering.
-     */
-    resolveOverlayLayout(options, overlayHeight, termWidth, termHeight) {
-        return this.layoutEngine.resolveOverlayLayout(options, overlayHeight, termWidth, termHeight);
-    }
-    /** Composite all overlays into content lines (in stack order, later = on top). */
-    compositeOverlays(lines, termWidth, termHeight) {
-        const overlays = this.overlayRegistry.values();
-        if (overlays.length === 0)
-            return lines;
-        const result = [...lines];
-        const rendered = this.collectRenderedOverlays(overlays, termWidth, termHeight, result.length);
-        this.ensureOverlayWorkingHeight(result, rendered.minLinesNeeded);
-        const viewportStart = Math.max(0, result.length - termHeight);
-        const modified = this.compositeRenderedOverlays(result, rendered.items, viewportStart, termWidth);
-        this.clampCompositeWidth(result, modified, termWidth);
-        return result;
-    }
-    collectRenderedOverlays(overlays, termWidth, termHeight, initialMinLines) {
-        const items = [];
-        let minLinesNeeded = initialMinLines;
-        for (const entry of overlays) {
-            if (!this.isOverlayVisible(entry))
-                continue;
-            const { width, maxHeight } = this.resolveOverlayLayout(entry.options, 0, termWidth, termHeight);
-            const rawLines = entry.component.render(width);
-            const overlayLines = maxHeight !== undefined && rawLines.length > maxHeight ? rawLines.slice(0, maxHeight) : rawLines;
-            const finalPos = this.resolveOverlayLayout(entry.options, overlayLines.length, termWidth, termHeight);
-            items.push({ overlayLines, row: finalPos.row, col: finalPos.col, width });
-            minLinesNeeded = Math.max(minLinesNeeded, finalPos.row + overlayLines.length);
-        }
-        return { items, minLinesNeeded };
-    }
-    ensureOverlayWorkingHeight(result, minLinesNeeded) {
-        const workingHeight = Math.max(this.maxLinesRendered, minLinesNeeded);
-        while (result.length < workingHeight) {
-            result.push("");
-        }
-    }
-    compositeRenderedOverlays(result, rendered, viewportStart, termWidth) {
-        const modifiedLines = new Set();
-        for (const renderedOverlay of rendered) {
-            for (let localRow = 0; localRow < renderedOverlay.overlayLines.length; localRow++) {
-                const targetRow = viewportStart + renderedOverlay.row + localRow;
-                if (targetRow < 0 || targetRow >= result.length)
-                    continue;
-                const originalOverlayLine = renderedOverlay.overlayLines[localRow];
-                const overlayLine = visibleWidth(originalOverlayLine) > renderedOverlay.width
-                    ? sliceByColumn(originalOverlayLine, 0, renderedOverlay.width, true)
-                    : originalOverlayLine;
-                result[targetRow] = this.compositeLineAt(result[targetRow], overlayLine, renderedOverlay.col, renderedOverlay.width, termWidth);
-                modifiedLines.add(targetRow);
-            }
-        }
-        return modifiedLines;
-    }
-    clampCompositeWidth(result, modified, termWidth) {
-        for (const row of modified) {
-            if (visibleWidth(result[row]) <= termWidth)
-                continue;
-            result[row] = sliceByColumn(result[row], 0, termWidth, true);
-        }
-    }
-    static SEGMENT_RESET = "\x1b[0m\x1b]8;;\x07";
-    applyLineResets(lines) {
-        const reset = TUI.SEGMENT_RESET;
-        return lines.map((line) => (this.containsImage(line) ? line : line + reset));
-    }
-    /** Splice overlay content into a base line at a specific column. Single-pass optimized. */
-    compositeLineAt(baseLine, overlayLine, startCol, overlayWidth, totalWidth) {
-        if (this.containsImage(baseLine))
-            return baseLine;
-        // Single pass through baseLine extracts both before and after segments
-        const afterStart = startCol + overlayWidth;
-        const base = extractSegments(baseLine, startCol, afterStart, totalWidth - afterStart, true);
-        // Extract overlay with width tracking (strict=true to exclude wide chars at boundary)
-        const overlay = sliceWithWidth(overlayLine, 0, overlayWidth, true);
-        // Pad segments to target widths
-        const beforePad = Math.max(0, startCol - base.beforeWidth);
-        const overlayPad = Math.max(0, overlayWidth - overlay.width);
-        const actualBeforeWidth = Math.max(startCol, base.beforeWidth);
-        const actualOverlayWidth = Math.max(overlayWidth, overlay.width);
-        const afterTarget = Math.max(0, totalWidth - actualBeforeWidth - actualOverlayWidth);
-        const afterPad = Math.max(0, afterTarget - base.afterWidth);
-        // Compose result
-        const r = TUI.SEGMENT_RESET;
-        const result = base.before +
-            " ".repeat(beforePad) +
-            r +
-            overlay.text +
-            " ".repeat(overlayPad) +
-            r +
-            base.after +
-            " ".repeat(afterPad);
-        // CRITICAL: Always verify and truncate to terminal width.
-        // This is the final safeguard against width overflow which would crash the TUI.
-        // Width tracking can drift from actual visible width due to:
-        // - Complex ANSI/OSC sequences (hyperlinks, colors)
-        // - Wide characters at segment boundaries
-        // - Edge cases in segment extraction
-        const resultWidth = visibleWidth(result);
-        if (resultWidth <= totalWidth) {
-            return result;
-        }
-        // Truncate with strict=true to ensure we don't exceed totalWidth
-        return sliceByColumn(result, 0, totalWidth, true);
-    }
-    /**
-     * Find and extract cursor position from rendered lines.
-     * Searches for CURSOR_MARKER, calculates its position, and strips it from the output.
-     * @returns Cursor position { row, col } or null if no marker found
-     */
-    extractCursorPosition(lines) {
-        return CursorPlacementResolver.extract(lines);
-    }
-    renderFullFrame(newLines, width, height, cursorPos, clear) {
-        this.fullRedrawCount += 1;
-        let buffer = "\x1b[?2026h";
-        if (clear)
-            buffer += "\x1b[3J\x1b[2J\x1b[H";
-        for (let i = 0; i < newLines.length; i++) {
-            if (i > 0)
-                buffer += "\r\n";
-            buffer += newLines[i];
-        }
-        buffer += "\x1b[?2026l";
-        this.terminal.write(buffer);
-        this.cursorRow = Math.max(0, newLines.length - 1);
-        this.hardwareCursorRow = this.cursorRow;
-        if (clear) {
-            this.maxLinesRendered = newLines.length;
-        }
-        else {
-            this.maxLinesRendered = Math.max(this.maxLinesRendered, newLines.length);
-        }
-        this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
-        this.positionHardwareCursor(cursorPos, newLines.length);
-        this.previousLines = newLines;
-        this.previousWidth = width;
-    }
-    prepareRenderFrame(width, height) {
-        let newLines = this.render(width);
-        if (this.overlayRegistry.count() > 0) {
-            newLines = this.compositeOverlays(newLines, width, height);
-        }
-        const cursorPos = this.extractCursorPosition(newLines);
-        newLines = this.applyLineResets(newLines);
-        return { newLines, cursorPos };
-    }
-    computeRenderDiff(newLines) {
-        const { firstChanged, lastChanged, appended: appendedLines } = this.renderEngine.diffLines(this.previousLines, newLines);
-        const appendStart = appendedLines && firstChanged === this.previousLines.length && firstChanged > 0;
-        return { firstChanged, lastChanged, appendedLines, appendStart };
-    }
-    doRender() {
-        const width = this.terminal.columns;
-        const height = this.terminal.rows;
-        let viewportTop = Math.max(0, this.maxLinesRendered - height);
-        let prevViewportTop = this.previousViewportTop;
-        let hardwareCursorRow = this.hardwareCursorRow;
-        const computeLineDiff = (targetRow) => {
-            const currentScreenRow = hardwareCursorRow - prevViewportTop;
-            const targetScreenRow = targetRow - viewportTop;
-            return targetScreenRow - currentScreenRow;
-        };
-        const { newLines, cursorPos } = this.prepareRenderFrame(width, height);
-        // Width changed - need full re-render
-        const widthChanged = this.previousWidth !== 0 && this.previousWidth !== width;
-        const fullRender = (clear) => {
-            this.renderFullFrame(newLines, width, height, cursorPos, clear);
-        };
-        // First render - just output everything without clearing (assumes clean screen)
-        if (this.previousLines.length === 0 && !widthChanged) {
-            fullRender(false);
-            return;
-        }
-        // Width changed - full re-render
-        if (widthChanged) {
-            fullRender(true);
-            return;
-        }
-        // Find first and last changed lines via RenderEngine
-        let { firstChanged, lastChanged, appendedLines, appendStart } = this.computeRenderDiff(newLines);
-        // No changes - but still need to update hardware cursor position if it moved
-        if (firstChanged === -1) {
-            this.positionHardwareCursor(cursorPos, newLines.length);
-            this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
-            return;
-        }
-        // All changes are in deleted lines (nothing to render, just clear)
-        if (firstChanged >= newLines.length) {
-            if (this.previousLines.length > newLines.length) {
-                let buffer = "\x1b[?2026h";
-                // Move to end of new content (clamp to 0 for empty content)
-                const targetRow = Math.max(0, newLines.length - 1);
-                const lineDiff = computeLineDiff(targetRow);
-                if (lineDiff > 0)
-                    buffer += `\x1b[${lineDiff}B`;
-                else if (lineDiff < 0)
-                    buffer += `\x1b[${-lineDiff}A`;
-                buffer += "\r";
-                // Clear extra lines without scrolling
-                const extraLines = this.previousLines.length - newLines.length;
-                if (extraLines > height) {
-                    fullRender(true);
-                    return;
-                }
-                if (extraLines > 0) {
-                    buffer += "\x1b[1B";
-                }
-                for (let i = 0; i < extraLines; i++) {
-                    buffer += "\r\x1b[2K";
-                    if (i < extraLines - 1)
-                        buffer += "\x1b[1B";
-                }
-                if (extraLines > 0) {
-                    buffer += `\x1b[${extraLines}A`;
-                }
-                buffer += "\x1b[?2026l";
-                this.terminal.write(buffer);
-                this.cursorRow = targetRow;
-                this.hardwareCursorRow = targetRow;
-            }
-            this.positionHardwareCursor(cursorPos, newLines.length);
-            this.previousLines = newLines;
-            this.previousWidth = width;
-            this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
-            return;
-        }
-        // Check if firstChanged is outside the viewport
-        // Viewport is based on max lines ever rendered (terminal's working area)
-        if (firstChanged < viewportTop) {
-            // First change is above viewport - need full re-render
-            fullRender(true);
-            return;
-        }
-        // Render from first changed line to end
-        // Build buffer with all updates wrapped in synchronized output
-        let buffer = "\x1b[?2026h"; // Begin synchronized output
-        const prevViewportBottom = prevViewportTop + height - 1;
-        const moveTargetRow = appendStart ? firstChanged - 1 : firstChanged;
-        if (moveTargetRow > prevViewportBottom) {
-            const currentScreenRow = Math.max(0, Math.min(height - 1, hardwareCursorRow - prevViewportTop));
-            const moveToBottom = height - 1 - currentScreenRow;
-            if (moveToBottom > 0) {
-                buffer += `\x1b[${moveToBottom}B`;
-            }
-            const scroll = moveTargetRow - prevViewportBottom;
-            buffer += "\r\n".repeat(scroll);
-            prevViewportTop += scroll;
-            viewportTop += scroll;
-            hardwareCursorRow = moveTargetRow;
-        }
-        // Move cursor to first changed line (use hardwareCursorRow for actual position)
-        const lineDiff = computeLineDiff(moveTargetRow);
-        if (lineDiff > 0) {
-            buffer += `\x1b[${lineDiff}B`; // Move down
-        }
-        else if (lineDiff < 0) {
-            buffer += `\x1b[${-lineDiff}A`; // Move up
-        }
-        buffer += appendStart ? "\r\n" : "\r"; // Move to column 0
-        // Only render changed lines (firstChanged to lastChanged), not all lines to end
-        // This reduces flicker when only a single line changes (e.g., spinner animation)
-        const renderEnd = Math.min(lastChanged, newLines.length - 1);
-        for (let i = firstChanged; i <= renderEnd; i++) {
-            if (i > firstChanged)
-                buffer += "\r\n";
-            buffer += "\x1b[2K"; // Clear current line
-            const line = newLines[i];
-            const isImageLine = this.containsImage(line);
-            if (!isImageLine && visibleWidth(line) > width) {
-                // Log all lines to crash file for debugging
-                const crashLogPath = path.join(os.homedir(), ".indusagi", "agent", "indus-crash.log");
-                const crashData = [
-                    `Overflow at ${new Date().toISOString()}`,
-                    `Terminal width: ${width}`,
-                    `Line ${i} visible width: ${visibleWidth(line)}`,
-                    "",
-                    "=== All rendered lines ===",
-                    ...newLines.map((l, idx) => `[${idx}] (w=${visibleWidth(l)}) ${l}`),
-                    "",
-                ].join("\n");
-                fs.mkdirSync(path.dirname(crashLogPath), { recursive: true });
-                fs.writeFileSync(crashLogPath, crashData);
-                buffer += truncateToWidth(line, width, "");
-                continue;
-            }
-            buffer += line;
-        }
-        // Track where cursor ended up after rendering
-        let finalCursorRow = renderEnd;
-        // If we had more lines before, clear them and move cursor back
-        if (this.previousLines.length > newLines.length) {
-            // Move to end of new content first if we stopped before it
-            if (renderEnd < newLines.length - 1) {
-                const moveDown = newLines.length - 1 - renderEnd;
-                buffer += `\x1b[${moveDown}B`;
-                finalCursorRow = newLines.length - 1;
-            }
-            const extraLines = this.previousLines.length - newLines.length;
-            for (let i = newLines.length; i < this.previousLines.length; i++) {
-                buffer += "\r\n\x1b[2K";
-            }
-            // Move cursor back to end of new content
-            buffer += `\x1b[${extraLines}A`;
-        }
-        buffer += "\x1b[?2026l"; // End synchronized output
-        if (process.env.INDUSAGI_TUI_DEBUG === "1") {
-            const debugDir = "/tmp/tui";
-            fs.mkdirSync(debugDir, { recursive: true });
-            const debugPath = path.join(debugDir, `render-${Date.now()}-${Math.random().toString(36).slice(2)}.log`);
-            const debugData = [
-                `firstChanged: ${firstChanged}`,
-                `viewportTop: ${viewportTop}`,
-                `cursorRow: ${this.cursorRow}`,
-                `height: ${height}`,
-                `lineDiff: ${lineDiff}`,
-                `hardwareCursorRow: ${hardwareCursorRow}`,
-                `renderEnd: ${renderEnd}`,
-                `finalCursorRow: ${finalCursorRow}`,
-                `cursorPos: ${JSON.stringify(cursorPos)}`,
-                `newLines.length: ${newLines.length}`,
-                `previousLines.length: ${this.previousLines.length}`,
-                "",
-                "=== newLines ===",
-                JSON.stringify(newLines, null, 2),
-                "",
-                "=== previousLines ===",
-                JSON.stringify(this.previousLines, null, 2),
-                "",
-                "=== buffer ===",
-                JSON.stringify(buffer),
-            ].join("\n");
-            fs.writeFileSync(debugPath, debugData);
-        }
-        // Write entire buffer at once
-        this.terminal.write(buffer);
-        // Track cursor position for next render
-        // cursorRow tracks end of content (for viewport calculation)
-        // hardwareCursorRow tracks actual terminal cursor position (for movement)
-        this.cursorRow = Math.max(0, newLines.length - 1);
-        this.hardwareCursorRow = finalCursorRow;
-        // Track terminal's working area (grows but doesn't shrink unless cleared)
-        this.maxLinesRendered = Math.max(this.maxLinesRendered, newLines.length);
-        this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
-        // Position hardware cursor for IME
-        this.positionHardwareCursor(cursorPos, newLines.length);
-        this.previousLines = newLines;
-        this.previousWidth = width;
-    }
-    /**
-     * Position the hardware cursor for IME candidate window.
-     * @param cursorPos The cursor position extracted from rendered output, or null
-     * @param totalLines Total number of rendered lines
-     */
-    positionHardwareCursor(cursorPos, totalLines) {
-        if (!cursorPos || totalLines <= 0) {
-            this.terminal.hideCursor();
-            return;
-        }
-        // Clamp cursor position to valid range
-        const targetRow = Math.max(0, Math.min(cursorPos.row, totalLines - 1));
-        const targetCol = Math.max(0, cursorPos.col);
-        // Move cursor from current position to target
-        const rowDelta = targetRow - this.hardwareCursorRow;
-        let buffer = "";
-        if (rowDelta > 0) {
-            buffer += `\x1b[${rowDelta}B`; // Move down
-        }
-        else if (rowDelta < 0) {
-            buffer += `\x1b[${-rowDelta}A`; // Move up
-        }
-        // Move to absolute column (1-indexed)
-        buffer += `\x1b[${targetCol + 1}G`;
-        if (buffer) {
-            this.terminal.write(buffer);
-        }
-        this.hardwareCursorRow = targetRow;
-        if (this.showHardwareCursor) {
-            this.terminal.showCursor();
-        }
-        else {
-            this.terminal.hideCursor();
-        }
-    }
-}
-//# sourceMappingURL=tui.js.map