@ashx-j/lunr-tui 0.2.39 → 0.2.40

package/dist/tui.js

@@ -129,7 +129,7 @@ export class TUI extends Container {
     previousWidth = 0;
     previousHeight = 0;
     focusedComponent = null;
-    inputListeners = new Set();
+    inputListeners = new Map();
     /** Global callback for debug key (Shift+Ctrl+D). Called before input is forwarded to focused component. */
     onDebug;
     /** Kept for callers; left-drag no longer selects. Shift+drag stays native terminal selection. */
@@ -448,36 +448,6 @@ export class TUI extends Container {
         }
         return start;
     }
-    findChatAnchor(previous, next, start, viewH) {
-        for (let offset = 0; offset < Math.min(4, viewH, previous.length - start); offset++) {
-            const line = previous[start + offset];
-            if (!line || visibleWidth(line) === 0)
-                continue;
-            const following = previous[start + offset + 1];
-            let best;
-            let bestScore = 0;
-            for (let match = next.indexOf(line); match !== -1; match = next.indexOf(line, match + 1)) {
-                if (following !== undefined && next[match + 1] !== following)
-                    continue;
-                const candidate = match - offset;
-                if (candidate < 0)
-                    continue;
-                let score = 1;
-                while (score < 12 &&
-                    start + offset + score < previous.length &&
-                    previous[start + offset + score] === next[match + score])
-                    score++;
-                if (score > bestScore ||
-                    (score === bestScore && (best === undefined || Math.abs(candidate - start) < Math.abs(best - start)))) {
-                    best = candidate;
-                    bestScore = score;
-                }
-            }
-            if (best !== undefined)
-                return best;
-        }
-        return undefined;
-    }
     render(width) {
         const pinIndex = this.getPinIndex();
         if (pinIndex < 0) {
@@ -551,7 +521,8 @@ export class TUI extends Container {
             const scrollMax = scrollLines.length - viewH;
             if (this.chatScrollOffset > 0) {
                 const anchor = cache && !fromCache
-                    ? (this.findChatAnchor(cache.scrollLines, scrollLines, this.lastChatStart, this.lastChatViewportHeight) ?? this.lastChatStart)
+                    ? (findChatAnchor(cache.scrollLines, scrollLines, this.lastChatStart, this.lastChatViewportHeight) ??
+                        this.lastChatStart)
                     : this.lastChatStart;
                 const pendingScroll = this.chatScrollOffset - (this.lastChatScrollMax - this.lastChatStart);
                 this.chatScrollOffset = scrollMax - anchor + pendingScroll;
@@ -759,8 +730,12 @@ export class TUI extends Container {
         this.queryCellSize();
         this.requestRender();
     }
-    addInputListener(listener) {
-        this.inputListeners.add(listener);
+    /**
+     * Run `listener` on raw input before the focused component sees it. Listeners skip
+     * Kitty key-release events unless they pass `{ wantsKeyRelease: true }`.
+     */
+    addInputListener(listener, options = {}) {
+        this.inputListeners.set(listener, options);
         return () => {
             this.inputListeners.delete(listener);
         };
@@ -825,7 +800,10 @@ export class TUI extends Container {
         // Response format: CSI 6 ; height ; width t
         this.terminal.write("\x1b[16t");
     }
+    /** Restore the terminal. Safe to call more than once: later calls before the next `start()` do nothing. */
     stop() {
+        if (this.stopped)
+            return;
         this.stopped = true;
         this.started = false;
         if (this.renderTimer) {
@@ -1060,7 +1038,9 @@ export class TUI extends Container {
         }
         if (this.inputListeners.size > 0) {
             let current = data;
-            for (const listener of this.inputListeners) {
+            for (const [listener, options] of this.inputListeners) {
+                if (!options.wantsKeyRelease && isKeyRelease(current))
+                    continue;
                 const result = listener(current);
                 if (result?.consume) {
                     return;
@@ -1347,16 +1327,50 @@ export class TUI extends Container {
         return result;
     }
     static SEGMENT_RESET = "\x1b[0m\x1b]8;;\x07";
-    applyLineResets(lines) {
+    /**
+     * Normalize each text line, cut it to the terminal width and close its styles. Full and
+     * partial redraws both write these lines, so an overflowing component cannot wrap the screen.
+     * The first overflow per TUI writes the rendered lines to pi-crash.log for debugging.
+     */
+    applyLineResets(lines, width) {
         const reset = TUI.SEGMENT_RESET;
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
-            if (!isImageLine(line)) {
-                lines[i] = normalizeTerminalOutput(line) + reset;
+            if (isImageLine(line))
+                continue;
+            let normalized = normalizeTerminalOutput(line);
+            if (visibleWidth(normalized) > width) {
+                this.logWidthOverflow(lines, i, width);
+                normalized = sliceByColumn(normalized, 0, width, true);
             }
+            lines[i] = normalized + reset;
         }
         return lines;
     }
+    widthOverflowLogged = false;
+    logWidthOverflow(lines, index, width) {
+        if (this.widthOverflowLogged)
+            return;
+        this.widthOverflowLogged = true;
+        // lunr: tui cannot import coding-agent (layering) — env-first with .lunr fallback (was ~/.pi/agent)
+        const logPath = path.join(process.env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".lunr", "agent"), "pi-crash.log");
+        const data = [
+            `Line wider than the terminal at ${new Date().toISOString()}; truncated. A component is not truncating its output (use truncateToWidth()).`,
+            `Terminal width: ${width}`,
+            `Line ${index} visible width: ${visibleWidth(lines[index] ?? "")}`,
+            "",
+            "=== All rendered lines ===",
+            ...lines.map((l, idx) => `[${idx}] (w=${visibleWidth(l)}) ${l}`),
+            "",
+        ].join("\n");
+        try {
+            fs.mkdirSync(path.dirname(logPath), { recursive: true });
+            fs.writeFileSync(logPath, data);
+        }
+        catch {
+            // a debug log must not break rendering
+        }
+    }
     collectKittyImageIds(lines) {
         const ids = new Set();
         for (const line of lines) {
@@ -1505,7 +1519,7 @@ export class TUI extends Container {
         }
         // Extract cursor position before applying line resets (marker must be found first)
         const cursorPos = this.extractCursorPosition(newLines, height);
-        newLines = this.applyLineResets(newLines);
+        newLines = this.applyLineResets(newLines, width);
         // Helper to clear scrollback and viewport and render all new lines
         const fullRender = (clear) => {
             this.fullRedrawCount += 1;
@@ -1735,33 +1749,6 @@ export class TUI extends Container {
                 continue;
             }
             buffer += "\x1b[2K"; // Clear current line
-            if (!isImage && visibleWidth(line) > width) {
-                // Log all lines to crash file for debugging
-                // lunr: tui cannot import coding-agent (layering) — env-first with .lunr fallback (was ~/.pi/agent)
-                const crashLogPath = path.join(process.env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".lunr", "agent"), "pi-crash.log");
-                const crashData = [
-                    `Crash 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);
-                // Clean up terminal state before throwing
-                this.stop();
-                const errorMsg = [
-                    `Rendered line ${i} exceeds terminal width (${visibleWidth(line)} > ${width}).`,
-                    "",
-                    "This is likely caused by a custom TUI component not truncating its output.",
-                    "Use visibleWidth() to measure and truncateToWidth() to truncate lines.",
-                    "",
-                    `Debug log written to: ${crashLogPath}`,
-                ].join("\n");
-                throw new Error(errorMsg);
-            }
             buffer += line;
         }
         // Track where cursor ended up after rendering
@@ -1915,6 +1902,56 @@ export class TUI extends Container {
         });
     }
 }
+/**
+ * Finds the start row in `next` that keeps a scrolled-up chat view on the same content it showed at
+ * `previous[start]` after a re-layout. Up to four leading non-blank visible lines are tried in order.
+ * For each, the copy in `next` whose following lines match longest (up to 12) wins, ties going to the
+ * copy closest to `start` and then to the earlier one. Returns undefined when no line matches, so the
+ * caller keeps the old position (the width-reflow case).
+ *
+ * Copies are visited nearest-first and the search stops once a copy matches the longest possible run,
+ * so long runs of identical rows cost a few comparisons instead of a scan of the whole chat. When no
+ * copy reaches that run (the visible lines changed), it still checks every copy.
+ * Exported for tests only.
+ */
+export function findChatAnchor(previous, next, start, viewH) {
+    for (let offset = 0; offset < Math.min(4, viewH, previous.length - start); offset++) {
+        const at = start + offset;
+        const line = previous[at];
+        if (!line || visibleWidth(line) === 0)
+            continue;
+        const following = previous[at + 1];
+        const maxScore = Math.min(12, previous.length - at);
+        // A copy at `match` anchors the view at `match - offset`, which must not be negative.
+        const lo = Math.max(offset, next.indexOf(line));
+        const hi = next.lastIndexOf(line);
+        if (hi < lo)
+            continue;
+        let best;
+        let bestScore = 0;
+        // Visit rows at, at-1, at+1, at-2, at+2, ... so the order already encodes the distance tie-break
+        // and only a strictly longer run replaces the best.
+        const steps = 2 * Math.max(at - lo, hi - at);
+        for (let step = 0; step <= steps && bestScore < maxScore; step++) {
+            const distance = (step + 1) >> 1;
+            const match = step % 2 === 1 ? at - distance : at + distance;
+            if (match < lo || match > hi || next[match] !== line)
+                continue;
+            if (following !== undefined && next[match + 1] !== following)
+                continue;
+            let score = 1;
+            while (score < 12 && at + score < previous.length && previous[at + score] === next[match + score])
+                score++;
+            if (score > bestScore) {
+                best = match - offset;
+                bestScore = score;
+            }
+        }
+        if (best !== undefined)
+            return best;
+    }
+    return undefined;
+}
 function padToWidth(line, width) {
     const vis = visibleWidth(line);
     if (vis >= width)