@fractaal/pi-tui 0.85.4 → 0.86.1

package/dist/components/editor.js

@@ -1,9 +1,9 @@
 import { getKeybindings } from "../keybindings.js";
 import { decodePrintableKey, matchesKey } from "../keys.js";
 import { KillRing } from "../kill-ring.js";
-import { CURSOR_MARKER } from "../tui.js";
+import { CURSOR_MARKER, } from "../tui.js";
 import { UndoStack } from "../undo-stack.js";
-import { cjkBreakRegex, getGraphemeSegmenter, getWordSegmenter, isWhitespaceChar, sliceByColumn, visibleWidth, } from "../utils.js";
+import { autocompleteBoundaryRegex, autocompleteSeparatorRegex, cjkBreakRegex, getGraphemeSegmenter, getWordSegmenter, isWhitespaceChar, sliceByColumn, visibleWidth, } from "../utils.js";
 import { findWordBackward, findWordForward } from "../word-navigation.js";
 import { SelectList } from "./select-list.js";
 const graphemeSegmenter = getGraphemeSegmenter();
@@ -168,18 +168,28 @@ const SLASH_COMMAND_SELECT_LIST_LAYOUT = {
 };
 const ATTACHMENT_AUTOCOMPLETE_DEBOUNCE_MS = 20;
 const DEFAULT_AUTOCOMPLETE_TRIGGER_CHARACTERS = ["@", "#"];
+// Unquoted completions end at whitespace or CJK punctuation; quoted paths may contain either.
+const unquotedAutocompleteSuffixRegex = new RegExp(`(?:(?!${autocompleteSeparatorRegex.source}).)*`, "u");
+// Trigger tokens may be wrapped in prose, e.g. "(@src/foo" or "`@src/foo".
+const autocompleteTokenStartSource = `${autocompleteBoundaryRegex.source}[([{<\`]*`;
 function escapeCharacterClass(value) {
     return value.replace(/[\\^$.*+?()[\]{}|-]/g, "\\$&");
 }
 function buildTriggerPattern(triggerCharacters) {
-    return new RegExp(`(?:^|[\\s])[${triggerCharacters.map(escapeCharacterClass).join("")}][^\\s]*$`);
+    return new RegExp(`${autocompleteTokenStartSource}(?:@"[^"]*|[${triggerCharacters.map(escapeCharacterClass).join("")}]${unquotedAutocompleteSuffixRegex.source})$`, "u");
 }
 function buildDebouncePattern(triggerCharacters) {
     const escapedWithoutAt = triggerCharacters.filter((character) => character !== "@").map(escapeCharacterClass);
-    return new RegExp(`(?:^|[ \\t])(?:@(?:"[^"]*|[^\\s]*)|[${escapedWithoutAt.join("")}][^\\s]*)$`);
+    return new RegExp(`${autocompleteTokenStartSource}(?:@(?:"[^"]*|${unquotedAutocompleteSuffixRegex.source})|[${escapedWithoutAt.join("")}]${unquotedAutocompleteSuffixRegex.source})$`, "u");
 }
 function createScrollBorder(direction, hiddenLineCount, width) {
     const availableWidth = Math.max(0, width);
+    const label = ` ${direction} ${hiddenLineCount} more `;
+    const labelWidth = visibleWidth(label);
+    if (labelWidth + 2 <= availableWidth) {
+        const leftWidth = Math.floor((availableWidth - labelWidth) / 2);
+        return "─".repeat(leftWidth) + label + "─".repeat(availableWidth - leftWidth - labelWidth);
+    }
     const indicator = `─── ${direction} ${hiddenLineCount} more `;
     const remaining = availableWidth - visibleWidth(indicator);
     if (remaining >= 0)
@@ -199,8 +209,10 @@ export class Editor {
     tui;
     theme;
     paddingX = 0;
-    // Store last render width for cursor navigation
+    // Store last render geometry for cursor navigation and mouse hit-testing.
     lastWidth = 80;
+    renderedVisibleLineCount = 1;
+    renderedAutocompleteHeight = 0;
     // Vertical scrolling support
     scrollOffset = 0;
     // Border color (can be changed dynamically)
@@ -370,6 +382,14 @@ export class Editor {
     invalidate() {
         // No cached state to invalidate currently
     }
+    renderTopBorder(width, hiddenLineCount) {
+        const border = hiddenLineCount > 0 ? createScrollBorder("↑", hiddenLineCount, width) : "─".repeat(width);
+        return this.borderColor(border);
+    }
+    renderBottomBorder(width, hiddenLineCount) {
+        const border = hiddenLineCount > 0 ? createScrollBorder("↓", hiddenLineCount, width) : "─".repeat(width);
+        return this.borderColor(border);
+    }
     render(width) {
         const maxPadding = Math.max(0, Math.floor((width - 1) / 2));
         const paddingX = Math.min(this.paddingX, maxPadding);
@@ -379,7 +399,6 @@ export class Editor {
         const layoutWidth = Math.max(1, contentWidth - (paddingX ? 0 : 1));
         // Store for cursor navigation (must match wrapping width)
         this.lastWidth = layoutWidth;
-        const horizontal = this.borderColor("─");
         // Layout the text
         const layoutLines = this.layoutText(layoutWidth);
         // Calculate max visible lines: 30% of terminal height, minimum 5 lines
@@ -401,17 +420,12 @@ export class Editor {
         this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxScrollOffset));
         // Get visible lines slice
         const visibleLines = layoutLines.slice(this.scrollOffset, this.scrollOffset + maxVisibleLines);
+        this.renderedVisibleLineCount = visibleLines.length;
         const result = [];
         const leftPadding = " ".repeat(paddingX);
         const rightPadding = leftPadding;
         // Render top border (with scroll indicator if scrolled down)
-        if (this.scrollOffset > 0) {
-            const border = createScrollBorder("↑", this.scrollOffset, width);
-            result.push(this.borderColor(border));
-        }
-        else {
-            result.push(horizontal.repeat(width));
-        }
+        result.push(this.renderTopBorder(width, this.scrollOffset));
         // Render each visible layout line
         // Emit hardware cursor marker when focused so TUI can position the
         // hardware cursor for IME candidate-window placement even while
@@ -456,16 +470,12 @@ export class Editor {
         }
         // Render bottom border (with scroll indicator if more content below)
         const linesBelow = layoutLines.length - (this.scrollOffset + visibleLines.length);
-        if (linesBelow > 0) {
-            const border = createScrollBorder("↓", linesBelow, width);
-            result.push(this.borderColor(border));
-        }
-        else {
-            result.push(horizontal.repeat(width));
-        }
+        result.push(this.renderBottomBorder(width, linesBelow));
         // Add autocomplete list if active
+        this.renderedAutocompleteHeight = 0;
         if (this.autocompleteState && this.autocompleteList) {
             const autocompleteResult = this.autocompleteList.render(contentWidth);
+            this.renderedAutocompleteHeight = autocompleteResult.length;
             for (const line of autocompleteResult) {
                 const lineWidth = visibleWidth(line);
                 const linePadding = " ".repeat(Math.max(0, contentWidth - lineWidth));
@@ -474,6 +484,67 @@ export class Editor {
         }
         return result;
     }
+    handleMouse(event) {
+        const autocompleteStartRow = this.renderedVisibleLineCount + 2;
+        if (this.autocompleteState &&
+            this.autocompleteList &&
+            event.y >= autocompleteStartRow &&
+            event.y < autocompleteStartRow + this.renderedAutocompleteHeight) {
+            const maxPadding = Math.max(0, Math.floor((event.width - 1) / 2));
+            const paddingX = Math.min(this.paddingX, maxPadding);
+            const contentWidth = Math.max(1, event.width - paddingX * 2);
+            const result = this.autocompleteList.handleMouse?.({
+                ...event,
+                x: event.x - paddingX,
+                y: event.y - autocompleteStartRow,
+                width: contentWidth,
+                height: this.renderedAutocompleteHeight,
+            });
+            return result ? { ...result, focus: true } : undefined;
+        }
+        // Leave press/drag/release unhandled so the renderer's screen-level text
+        // selection can run over the editor rows (drag to select, release to copy).
+        // The renderer synthesizes a click when press and release land on the same
+        // cell without movement, which is the gesture that positions the cursor.
+        if (event.type !== "click" || event.button !== "left")
+            return undefined;
+        if (event.y <= 0 || event.y > this.renderedVisibleLineCount)
+            return { handled: true, focus: true };
+        const visualLines = this.buildVisualLineMap(this.lastWidth);
+        const visualLineIndex = this.scrollOffset + event.y - 1;
+        const visualLine = visualLines[visualLineIndex];
+        if (!visualLine)
+            return { handled: true, focus: true };
+        const logicalLine = this.state.lines[visualLine.logicalLine] ?? "";
+        const chunkEnd = visualLine.startCol + visualLine.length;
+        const chunk = logicalLine.slice(visualLine.startCol, chunkEnd);
+        const maxPadding = Math.max(0, Math.floor((event.width - 1) / 2));
+        const paddingX = Math.min(this.paddingX, maxPadding);
+        const targetColumn = Math.max(0, event.x - paddingX);
+        let visibleColumn = 0;
+        let targetIndex = chunk.length;
+        let lastGraphemeIndex = 0;
+        for (const grapheme of this.segment(chunk, "grapheme")) {
+            const nextColumn = visibleColumn + visibleWidth(grapheme.segment);
+            lastGraphemeIndex = grapheme.index;
+            if (targetColumn < nextColumn) {
+                targetIndex = grapheme.index;
+                break;
+            }
+            visibleColumn = nextColumn;
+        }
+        const isLastSegment = visualLineIndex === visualLines.length - 1 ||
+            visualLines[visualLineIndex + 1]?.logicalLine !== visualLine.logicalLine;
+        if (!isLastSegment && targetIndex === chunk.length && chunk.length > 0)
+            targetIndex = lastGraphemeIndex;
+        this.state.cursorLine = visualLine.logicalLine;
+        this.setCursorCol(visualLine.startCol + targetIndex);
+        this.lastAction = null;
+        this.exitHistoryBrowsing();
+        if (this.autocompleteState)
+            this.updateAutocomplete();
+        return { handled: true, focus: true };
+    }
     handleInput(data) {
         const kb = getKeybindings();
         // Handle character jump mode (awaiting next character to jump to)
@@ -613,6 +684,17 @@ export class Editor {
             this.yankPop();
             return;
         }
+        // Dedicated history actions always browse entries instead of moving the cursor.
+        if (kb.matches(data, "tui.editor.historyPrevious")) {
+            this.cancelAutocomplete();
+            this.navigateHistory(-1);
+            return;
+        }
+        if (kb.matches(data, "tui.editor.historyNext")) {
+            this.cancelAutocomplete();
+            this.navigateHistory(1);
+            return;
+        }
         // Cursor movement actions
         if (kb.matches(data, "tui.editor.cursorLineStart")) {
             this.moveToLineStart();
@@ -943,13 +1025,12 @@ export class Editor {
             else if (this.autocompleteTriggerCharacters.includes(char)) {
                 const currentLine = this.state.lines[this.state.cursorLine] || "";
                 const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
-                const charBeforeSymbol = textBeforeCursor[textBeforeCursor.length - 2];
-                if (textBeforeCursor.length === 1 || charBeforeSymbol === " " || charBeforeSymbol === "\t") {
+                if (this.autocompleteTriggerPattern.test(textBeforeCursor)) {
                     this.tryTriggerAutocomplete();
                 }
             }
             // Also auto-trigger when typing letters in a slash command or symbol completion context
-            else if (/[a-zA-Z0-9.\-_]/.test(char)) {
+            else if (/[a-zA-Z0-9.\-_]/.test(char) || cjkBreakRegex.test(char)) {
                 const currentLine = this.state.lines[this.state.cursorLine] || "";
                 const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
                 // Check if we're in a slash command (with or without space for arguments)
@@ -1793,7 +1874,20 @@ export class Editor {
     }
     createAutocompleteList(prefix, items) {
         const layout = prefix.startsWith("/") ? SLASH_COMMAND_SELECT_LIST_LAYOUT : undefined;
-        return new SelectList(items, this.autocompleteMaxVisible, this.theme.selectList, layout);
+        const list = new SelectList(items, this.autocompleteMaxVisible, this.theme.selectList, layout);
+        list.onSelect = (selected) => {
+            if (!this.autocompleteProvider)
+                return;
+            this.pushUndoSnapshot();
+            this.lastAction = null;
+            const result = this.autocompleteProvider.applyCompletion(this.state.lines, this.state.cursorLine, this.state.cursorCol, selected, this.autocompletePrefix);
+            this.state.lines = result.lines;
+            this.state.cursorLine = result.cursorLine;
+            this.setCursorCol(result.cursorCol);
+            this.cancelAutocomplete();
+            this.onChange?.(this.getText());
+        };
+        return list;
     }
     tryTriggerAutocomplete(explicitTab = false) {
         this.requestAutocomplete({ force: false, explicitTab });