cliedit 0.1.3 → 0.3.0

package/README.md

@@ -18,6 +18,9 @@ It includes line wrapping, visual navigation, smart auto-indentation, undo/redo,
 - **Search & Replace:** `Ctrl+W` to find text, `Ctrl+R` to find and replace interactively.
 - **Go to Line:** `Ctrl+L` to quickly jump to a specific line number.
 - **Smart Auto-Indentation:** Automatically preserves indentation level when pressing Enter.
+- **Smart Navigation:** `Alt + Left/Right` to jump by words, `Ctrl + M` to jump between matching brackets.
+- **Piping Support:** Works with standard Unix pipes (e.g. `cat file.txt | cliedit`).
+- **Crash Recovery:** Automatically saves changes to a hidden swap file (e.g. `.filename.swp`) to prevent data loss.
 
 ## Installation
 ```bash
@@ -34,35 +37,61 @@ import path from 'path';
 
 async function getCommitMessage() {
   const tempFile = path.resolve(process.cwd(), 'COMMIT_MSG.txt');
-  console.log('Opening editor for commit message...');
+  
+  // Example with custom options
+  const options = {
+    tabSize: 2,
+    gutterWidth: 3
+  };
 
   try {
-    const result = await openEditor(tempFile);
-
-    // Give the terminal a moment to restore
-    await new Promise(res => setTimeout(res, 50));
+    const result = await openEditor(tempFile, options);
 
     if (result.saved) {
-      console.log('Message saved!');
-      console.log('---------------------');
-      console.log(result.content);
-      console.log('---------------------');
+      console.log('Message saved:', result.content);
     } else {
       console.log('Editor quit without saving.');
     }
   } catch (err) {
-    console.error('Editor failed to start:', err);
+    console.error('Editor failed:', err);
   }
 }
 
 getCommitMessage();
 ```
 
+### Piping Support
+
+`cliedit` supports standard input piping. When used in a pipeline, it reads the input content, then re-opens the TTY to allow interactive editing.
+
+```bash
+# Edit a file using cat
+cat README.md | node my-app.js
+
+# Edit the output of a command
+git diff | node my-app.js
+```
+
 ## Public API
 
-`openEditor(filepath: string)`
+`openEditor(filepath: string, options?: EditorOptions)`
+
+Opens the editor for the specified file.
+
+- **filepath**: Path to the file to edit.
+- **options**: (Optional) Configuration object.
+    - `tabSize`: Number of spaces for a tab (default: 4).
+    - `gutterWidth`: Width of the line number gutter (default: 5).
+
+  - **Returns:** `Promise<{ saved: boolean; content: string }>`
+      * `saved`: `true` if the user saved (Ctrl+S), `false` otherwise (Ctrl+Q).
+      * `content`: The final content of the file as a string.
+
+### Crash Recovery
+
+`cliedit` includes a built-in safety mechanism. It periodically saves the current content to a hidden swap file (e.g., `.myfile.txt.swp`) in the same directory. 
 
-Opens the editor for the specified file. If the file doesn't exist, it will be created upon saving.
+If the process crashes or is terminated abruptly, the next time you open the file, `cliedit` will detect the swap file and automatically recover the unsaved content, displaying a `RECOVERED FROM SWAP FILE` message.
 
   - **Returns:** `Promise<{ saved: boolean; content: string }>`
       * `saved`: `true` if the user saved (Ctrl+S), `false` otherwise (Ctrl+Q).

package/dist/constants.d.ts

@@ -29,6 +29,7 @@ export declare const KEYS: {
     CTRL_U: string;
     CTRL_X: string;
     CTRL_V: string;
+    CTRL_M: string;
     CTRL_ARROW_UP: string;
     CTRL_ARROW_DOWN: string;
     CTRL_ARROW_RIGHT: string;

package/dist/constants.js

@@ -31,6 +31,7 @@ export const KEYS = {
     CTRL_U: '\x15', // Paste/Un-kill
     CTRL_X: '\x18', // Cut Selection
     CTRL_V: '\x16', // Paste Selection
+    CTRL_M: '\x0d', // Match Bracket (Ctrl+M is often Enter, but we distinguish if possible or rely on context)
     // Selection Keys (Mapped to Ctrl+Arrow for reliable detection)
     CTRL_ARROW_UP: 'C-up',
     CTRL_ARROW_DOWN: 'C-down',

package/dist/editor.d.ts

@@ -1,5 +1,6 @@
 import { HistoryManager } from './history.js';
-import { VisualRow, EditorMode } from './types.js';
+import { VisualRow, EditorMode, EditorOptions } from './types.js';
+import { SwapManager } from './editor.swap.js';
 import { editingMethods } from './editor.editing.js';
 import { clipboardMethods } from './editor.clipboard.js';
 import { navigationMethods } from './editor.navigation.js';
@@ -35,6 +36,7 @@ export declare class CliEditor {
     screenRows: number;
     screenCols: number;
     gutterWidth: number;
+    tabSize: number;
     screenStartRow: number;
     visualRows: VisualRow[];
     mode: EditorMode;
@@ -50,16 +52,22 @@ export declare class CliEditor {
         y: number;
         x: number;
     }[];
+    searchResultMap: Map<number, Array<{
+        start: number;
+        end: number;
+    }>>;
     searchResultIndex: number;
     history: HistoryManager;
+    swapManager: SwapManager;
     isCleanedUp: boolean;
     resolvePromise: ((value: {
         saved: boolean;
         content: string;
     }) => void) | null;
     rejectPromise: ((reason?: any) => void) | null;
+    inputStream: any;
     isExiting: boolean;
-    constructor(initialContent: string, filepath: string);
+    constructor(initialContent: string, filepath: string, options?: EditorOptions);
     run(): Promise<{
         saved: boolean;
         content: string;

package/dist/editor.editing.d.ts

@@ -13,7 +13,7 @@ declare function insertContentAtCursor(this: CliEditor, contentLines: string[]):
  */
 declare function insertCharacter(this: CliEditor, char: string): void;
 /**
- * Inserts a soft tab (4 spaces).
+ * Inserts a soft tab (using configured tabSize).
  */
 declare function insertSoftTab(this: CliEditor): void;
 /**

package/dist/editor.editing.js

@@ -44,10 +44,11 @@ function insertCharacter(char) {
     this.cursorX += char.length;
 }
 /**
- * Inserts a soft tab (4 spaces).
+ * Inserts a soft tab (using configured tabSize).
  */
 function insertSoftTab() {
-    this.insertCharacter('    ');
+    const spaces = ' '.repeat(this.tabSize || 4);
+    this.insertCharacter(spaces);
 }
 /**
  * Inserts a new line, splitting the current line at the cursor position.

package/dist/editor.io.js

@@ -16,6 +16,7 @@ async function saveFile() {
     const content = this.lines.join('\n');
     try {
         await fs.writeFile(this.filepath, content, 'utf-8');
+        await this.swapManager.clear(); // Clear swap on successful save
         this.isDirty = false; // Reset dirty flag
         this.quitConfirm = false; // Reset quit confirmation
         this.setStatusMessage(`Saved: ${this.filepath}`, 2000);

package/dist/editor.js

@@ -2,6 +2,7 @@
 import keypress from './vendor/keypress.js';
 import { ANSI } from './constants.js';
 import { HistoryManager } from './history.js';
+import { SwapManager } from './editor.swap.js';
 // Block `declare module 'keypress'` đã bị xóa
 // Import all functional modules
 import { editingMethods } from './editor.editing.js';
@@ -18,7 +19,7 @@ const DEFAULT_STATUS = 'HELP: Ctrl+S = Save | Ctrl+Q = Quit | Ctrl+W = Find | Ct
  * Main editor class managing application state, TTY interaction, and rendering.
  */
 export class CliEditor {
-    constructor(initialContent, filepath) {
+    constructor(initialContent, filepath, options = {}) {
         this.isDirty = false;
         this.cursorX = 0;
         this.cursorY = 0;
@@ -27,6 +28,7 @@ export class CliEditor {
         this.screenRows = 0;
         this.screenCols = 0;
         this.gutterWidth = 5;
+        this.tabSize = 4;
         this.screenStartRow = 1;
         this.visualRows = [];
         this.mode = 'edit';
@@ -39,6 +41,8 @@ export class CliEditor {
         this.replaceQuery = null; // null = Find mode, string = Replace mode
         this.goToLineQuery = ''; // For Go to Line prompt
         this.searchResults = [];
+        // Map<lineNumber, Array<{ start, end }>> for fast rendering lookup
+        this.searchResultMap = new Map();
         this.searchResultIndex = -1;
         this.isCleanedUp = false;
         this.resolvePromise = null;
@@ -50,29 +54,39 @@ export class CliEditor {
             this.lines = [''];
         }
         this.filepath = filepath;
+        this.gutterWidth = options.gutterWidth ?? 5;
+        this.tabSize = options.tabSize ?? 4;
+        this.inputStream = options.inputStream || process.stdin;
         this.history = new HistoryManager();
         this.saveState(true);
+        // Initialize SwapManager
+        this.swapManager = new SwapManager(this.filepath, () => this.lines.join('\n'));
     }
     // --- Lifecycle Methods ---
     run() {
         this.setupTerminal();
         this.render();
+        this.swapManager.start();
         return new Promise((resolve, reject) => {
             const performCleanup = (callback) => {
+                this.swapManager.stop(); // Stop swap interval
                 if (this.isCleanedUp) {
                     if (callback)
                         callback();
                     return;
                 }
                 // 1. Remove listeners immediately
-                process.stdin.removeAllListeners('keypress');
+                this.inputStream.removeAllListeners('keypress');
                 process.stdout.removeAllListeners('resize');
                 // 2. (FIX GHOST TUI) Write exit sequence and use callback to ensure it's written 
                 // before Node.js fully releases the TTY.
-                process.stdout.write(ANSI.CLEAR_SCREEN + ANSI.MOVE_CURSOR_TOP_LEFT + ANSI.SHOW_CURSOR + ANSI.EXIT_ALTERNATE_SCREEN, () => {
+                // Disable mouse tracking (1000 and 1006)
+                process.stdout.write(ANSI.CLEAR_SCREEN + ANSI.MOVE_CURSOR_TOP_LEFT + ANSI.SHOW_CURSOR + ANSI.EXIT_ALTERNATE_SCREEN + '\x1b[?1000l' + '\x1b[?1006l', () => {
                     // 3. Disable TTY raw mode and pause stdin after screen is cleared
-                    process.stdin.setRawMode(false);
-                    process.stdin.pause();
+                    if (this.inputStream.setRawMode) {
+                        this.inputStream.setRawMode(false);
+                    }
+                    this.inputStream.pause();
                     this.isCleanedUp = true;
                     if (callback)
                         callback();
@@ -87,19 +101,27 @@ export class CliEditor {
         });
     }
     setupTerminal() {
-        if (!process.stdin.isTTY || !process.stdout.isTTY) {
-            throw new Error('Editor requires a TTY environment.');
+        // If we are using a custom inputStream (re-opened TTY), it might be a ReadStream which is TTY.
+        // Check if it is TTY
+        if (!this.inputStream.isTTY && !process.stdin.isTTY) {
+            // If both are not TTY, we have a problem.
+            // But if inputStream is our manually opened TTY, isTTY should be true.
+        }
+        if (!process.stdout.isTTY) {
+            throw new Error('Editor requires a TTY environment (stdout).');
         }
         this.updateScreenSize();
         this.recalculateVisualRows();
-        // Enter alternate screen and hide cursor
-        process.stdout.write(ANSI.ENTER_ALTERNATE_SCREEN + ANSI.HIDE_CURSOR + ANSI.CLEAR_SCREEN);
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.setEncoding('utf-8');
+        // Enter alternate screen and hide cursor + Enable SGR Mouse (1006) and Button Event (1000)
+        process.stdout.write(ANSI.ENTER_ALTERNATE_SCREEN + ANSI.HIDE_CURSOR + ANSI.CLEAR_SCREEN + '\x1b[?1000h' + '\x1b[?1006h');
+        if (this.inputStream.setRawMode) {
+            this.inputStream.setRawMode(true);
+        }
+        this.inputStream.resume();
+        this.inputStream.setEncoding('utf-8');
         // Setup keypress listener
-        keypress(process.stdin);
-        process.stdin.on('keypress', this.handleKeypressEvent.bind(this));
+        keypress(this.inputStream);
+        this.inputStream.on('keypress', this.handleKeypressEvent.bind(this));
         process.stdout.on('resize', this.handleResize.bind(this));
     }
     handleResize() {

package/dist/editor.keys.d.ts

@@ -10,5 +10,6 @@ export type TKeyHandlingMethods = {
     handleCharacterKey: (ch: string) => void;
     cutSelection: () => Promise<void>;
     handleSave: () => Promise<void>;
+    handleAltArrows: (keyName: string) => void;
 };
 export declare const keyHandlingMethods: TKeyHandlingMethods;

package/dist/editor.keys.js

@@ -81,6 +81,15 @@ function handleKeypressEvent(ch, key) {
             keyName = KEYS.ENTER;
         else if (key.name === 'tab')
             keyName = KEYS.TAB;
+        else if (key.meta && key.name === 'left')
+            keyName = 'ALT_LEFT';
+        else if (key.meta && key.name === 'right')
+            keyName = 'ALT_RIGHT';
+        // Handle Mouse Scroll events explicitly
+        else if (key.name === 'scrollup')
+            keyName = 'SCROLL_UP';
+        else if (key.name === 'scrolldown')
+            keyName = 'SCROLL_DOWN';
         else
             keyName = key.sequence;
     }
@@ -114,7 +123,55 @@ function handleKeypressEvent(ch, key) {
                 return;
         }
         // 5. Xử lý tất cả các phím lệnh/chỉnh sửa khác
-        edited = this.handleEditKeys(keyName || ch);
+        if (keyName === 'SCROLL_UP') {
+            const scrollAmount = 3;
+            this.rowOffset = Math.max(0, this.rowOffset - scrollAmount);
+            // Adjust cursor if it falls out of view (below the viewport)
+            // Actually if we scroll UP, the viewport moves UP. The cursor might be BELOW the viewport.
+            // Wait, scroll UP means viewing lines ABOVE. Viewport index decreases.
+            // Cursor (if previously in view) might now be >= rowOffset + screenRows.
+            // We need to ensure cursor is within [rowOffset, rowOffset + screenRows - 1]
+            // But verify after setting rowOffset.
+            const currentVisualRow = this.findCurrentVisualRowIndex();
+            const bottomEdge = this.rowOffset + this.screenRows - 1;
+            if (currentVisualRow > bottomEdge) {
+                const targetRow = this.visualRows[bottomEdge];
+                this.cursorY = targetRow.logicalY;
+                this.cursorX = targetRow.logicalXStart;
+            }
+            else if (currentVisualRow < this.rowOffset) {
+                // Should not happen when scrolling up (moving viewport up), unless cursor was already above?
+                // If we scroll up, rowOffset decreases. Current row stays same. 
+                // So current row > new rowOffset.
+                // It might be > bottomEdge.
+            }
+            // However, to be safe against 'scroll' method resetting it:
+            // The 'scroll' method checks:
+            // if (currentVisualRow < this.rowOffset) -> this.rowOffset = currentVisualRow
+            // if (currentVisualRow >= this.rowOffset + this.screenRows) -> this.rowOffset = ...
+            // So we MUST move cursor inside the new viewport.
+            if (currentVisualRow > bottomEdge) {
+                const targetRow = this.visualRows[bottomEdge];
+                this.cursorY = targetRow.logicalY;
+                this.cursorX = targetRow.logicalXStart;
+            }
+        }
+        else if (keyName === 'SCROLL_DOWN') {
+            const scrollAmount = 3;
+            const maxOffset = Math.max(0, this.visualRows.length - this.screenRows);
+            this.rowOffset = Math.min(maxOffset, this.rowOffset + scrollAmount);
+            // Scroll DOWN means viewport index increases.
+            // Cursor might be ABOVE the new viewport (currentVisualRow < rowOffset).
+            const currentVisualRow = this.findCurrentVisualRowIndex();
+            if (currentVisualRow < this.rowOffset) {
+                const targetRow = this.visualRows[this.rowOffset];
+                this.cursorY = targetRow.logicalY;
+                this.cursorX = targetRow.logicalXStart;
+            }
+        }
+        else {
+            edited = this.handleEditKeys(keyName || ch);
+        }
     }
     // 6. Cập nhật Trạng thái và Render
     if (edited) {
@@ -125,6 +182,13 @@ function handleKeypressEvent(ch, key) {
         this.render(); // Render cuối cùng (với visual rows đã được cập nhật nếu cần)
     }
 }
+function handleAltArrows(keyName) {
+    this.clearSearchResults(); // Clear highlights on smart navigation
+    if (keyName === 'ALT_LEFT')
+        this.moveCursorByWord('left');
+    else if (keyName === 'ALT_RIGHT')
+        this.moveCursorByWord('right');
+}
 /**
  * Handles all command keys in 'edit' mode.
  * Returns true if content was modified.
@@ -137,6 +201,7 @@ function handleEditKeys(key) {
     ].includes(key);
     if (isNavigation) {
         this.cancelSelection();
+        this.clearSearchResults(); // Clear highlights on navigation
         if (this.isMessageCustom) {
             this.setStatusMessage(this.DEFAULT_STATUS, 0);
         }
@@ -179,9 +244,11 @@ function handleEditKeys(key) {
             return false;
         // --- Editing ---
         case KEYS.ENTER:
+            this.clearSearchResults();
             this.insertNewLine();
             return true;
         case KEYS.BACKSPACE:
+            this.clearSearchResults();
             // Handle auto-pair deletion
             const line = this.lines[this.cursorY] || '';
             const charBefore = line[this.cursorX - 1];
@@ -202,12 +269,14 @@ function handleEditKeys(key) {
             }
             return true;
         case KEYS.DELETE:
+            this.clearSearchResults();
             if (this.selectionAnchor)
                 this.deleteSelectedText();
             else
                 this.deleteForward();
             return true;
         case KEYS.TAB:
+            this.clearSearchResults();
             this.insertSoftTab();
             return true;
         // --- Search & History ---
@@ -223,6 +292,20 @@ function handleEditKeys(key) {
         case KEYS.CTRL_G:
             this.findNext();
             return false;
+        // --- Smart Navigation ---
+        case 'ALT_LEFT':
+            this.moveCursorByWord('left');
+            return false;
+        case 'ALT_RIGHT':
+            this.moveCursorByWord('right');
+            return false;
+        case KEYS.CTRL_M: // Or any key for Bracket Match. Ctrl+M is technically Enter in some terms but if available...
+            // Let's use Ctrl+B (Bracket) if not taken? Ctrl+B is often bold, but here it's CLI.
+            // Or just check if key is match bracket key.
+            // Let's try to map a specific key or use Meta.
+            // For now, let's use Ctrl+B?
+            this.matchBracket();
+            return false;
         // ***** SỬA LỖI VISUAL *****
         // Sau khi undo/redo, chúng ta PHẢI tính toán lại visual rows
         case KEYS.CTRL_Z:
@@ -249,6 +332,7 @@ function handleEditKeys(key) {
         // Xử lý Ký tự in được
         default:
             if (key.length === 1 && key >= ' ' && key <= '~') {
+                this.clearSearchResults();
                 this.handleCharacterKey(key);
                 return true;
             }
@@ -465,4 +549,5 @@ export const keyHandlingMethods = {
     handleCharacterKey,
     cutSelection,
     handleSave,
+    handleAltArrows,
 };

package/dist/editor.navigation.d.ts

@@ -48,5 +48,9 @@ export declare const navigationMethods: {
     scroll: typeof scroll;
     jumpToLine: typeof jumpToLine;
     enterGoToLineMode: typeof enterGoToLineMode;
+    moveCursorByWord: typeof moveCursorByWord;
+    matchBracket: typeof matchBracket;
 };
+declare function moveCursorByWord(this: CliEditor, direction: 'left' | 'right'): void;
+declare function matchBracket(this: CliEditor): void;
 export {};

package/dist/editor.navigation.js

@@ -153,4 +153,95 @@ export const navigationMethods = {
     scroll,
     jumpToLine,
     enterGoToLineMode,
+    moveCursorByWord,
+    matchBracket,
 };
+function moveCursorByWord(direction) {
+    const line = this.lines[this.cursorY];
+    if (direction === 'left') {
+        if (this.cursorX === 0) {
+            if (this.cursorY > 0) {
+                this.cursorY--;
+                this.cursorX = this.lines[this.cursorY].length;
+            }
+        }
+        else {
+            // Move left until we hit a non-word char, then until we hit a word char
+            // Simple logic: skip whitespace, then skip word chars
+            let i = this.cursorX - 1;
+            // 1. Skip spaces if we are currently on a space
+            while (i > 0 && line[i] === ' ')
+                i--;
+            // 2. Skip non-spaces
+            while (i > 0 && line[i - 1] !== ' ')
+                i--;
+            this.cursorX = i;
+        }
+    }
+    else {
+        if (this.cursorX >= line.length) {
+            if (this.cursorY < this.lines.length - 1) {
+                this.cursorY++;
+                this.cursorX = 0;
+            }
+        }
+        else {
+            let i = this.cursorX;
+            // 1. Skip current word chars
+            while (i < line.length && line[i] !== ' ')
+                i++;
+            // 2. Skip spaces
+            while (i < line.length && line[i] === ' ')
+                i++;
+            this.cursorX = i;
+        }
+    }
+}
+function matchBracket() {
+    const line = this.lines[this.cursorY];
+    const char = line[this.cursorX];
+    const pairs = { '(': ')', '[': ']', '{': '}' };
+    const revPairs = { ')': '(', ']': '[', '}': '{' };
+    if (pairs[char]) {
+        // Find closing
+        let depth = 1;
+        // Search forward
+        for (let y = this.cursorY; y < this.lines.length; y++) {
+            const l = this.lines[y];
+            const startX = (y === this.cursorY) ? this.cursorX + 1 : 0;
+            for (let x = startX; x < l.length; x++) {
+                if (l[x] === char)
+                    depth++;
+                else if (l[x] === pairs[char])
+                    depth--;
+                if (depth === 0) {
+                    this.cursorY = y;
+                    this.cursorX = x;
+                    this.scroll();
+                    return;
+                }
+            }
+        }
+    }
+    else if (revPairs[char]) {
+        // Find opening
+        let depth = 1;
+        // Search backward
+        for (let y = this.cursorY; y >= 0; y--) {
+            const l = this.lines[y];
+            const startX = (y === this.cursorY) ? this.cursorX - 1 : l.length - 1;
+            for (let x = startX; x >= 0; x--) {
+                if (l[x] === char)
+                    depth++;
+                else if (l[x] === revPairs[char])
+                    depth--;
+                if (depth === 0) {
+                    this.cursorY = y;
+                    this.cursorX = x;
+                    this.scroll();
+                    return;
+                }
+            }
+        }
+    }
+}

package/dist/editor.rendering.js

@@ -41,6 +41,11 @@ function render() {
     const displayX = cursorVisualX + this.gutterWidth;
     const displayY = this.screenStartRow + (currentVisualRowIndex - this.rowOffset);
     const selectionRange = this.getNormalizedSelection();
+    // Scrollbar calculations
+    const totalLines = this.visualRows.length;
+    const showScrollbar = totalLines > this.screenRows;
+    const thumbHeight = showScrollbar ? Math.max(1, Math.floor((this.screenRows / totalLines) * this.screenRows)) : 0;
+    const thumbStart = showScrollbar ? Math.floor((this.rowOffset / totalLines) * this.screenRows) : 0;
     // Draw visual rows
     for (let y = 0; y < this.screenRows; y++) {
         const visualRowIndex = y + this.rowOffset;
@@ -66,7 +71,19 @@ function render() {
                 const isCursorPosition = (visualRowIndex === currentVisualRowIndex && i === cursorVisualX);
                 const isSelected = selectionRange && this.isPositionInSelection(logicalY, logicalX, selectionRange);
                 // Highlight search result under cursor
-                const isSearchResult = (this.searchResultIndex !== -1 &&
+                // Check if this character is part of ANY search result
+                let isGlobalSearchResult = false;
+                if (this.searchResultMap.has(logicalY)) {
+                    const matches = this.searchResultMap.get(logicalY);
+                    for (const match of matches) {
+                        if (logicalX >= match.start && logicalX < match.end) {
+                            isGlobalSearchResult = true;
+                            break;
+                        }
+                    }
+                }
+                // Check if this character is part of the CURRENTLY SELECTED search result
+                const isCurrentSearchResult = (this.searchResultIndex !== -1 &&
                     this.searchResults[this.searchResultIndex]?.y === logicalY &&
                     logicalX >= this.searchResults[this.searchResultIndex]?.x &&
                     logicalX < (this.searchResults[this.searchResultIndex]?.x + this.searchQuery.length));
@@ -77,8 +94,12 @@ function render() {
                     // Cursor is a single inverted character if not already covered by selection
                     buffer += ANSI.INVERT_COLORS + char + ANSI.RESET_COLORS;
                 }
-                else if (isSearchResult) {
-                    // Highlight search result
+                else if (isCurrentSearchResult) {
+                    // Selected Match: Invert + Underline (if supported) or just Invert
+                    buffer += ANSI.INVERT_COLORS + '\x1b[4m' + char + ANSI.RESET_COLORS;
+                }
+                else if (isGlobalSearchResult) {
+                    // Global Match: Invert only
                     buffer += ANSI.INVERT_COLORS + char + ANSI.RESET_COLORS;
                 }
                 else {
@@ -93,6 +114,13 @@ function render() {
             }
             buffer += `${ANSI.CLEAR_LINE}`;
         }
+        // Draw Scrollbar (Phase 2)
+        if (showScrollbar) {
+            const isThumb = y >= thumbStart && y < thumbStart + thumbHeight;
+            const scrollChar = isThumb ? '┃' : '│';
+            // Move to last column and draw
+            buffer += `\x1b[${this.screenStartRow + y};${this.screenCols}H${ANSI.RESET_COLORS}${scrollChar}`;
+        }
     }
     // Draw status bar
     buffer += `\x1b[${this.screenRows + this.screenStartRow};1H`;

package/dist/editor.search.d.ts

@@ -33,6 +33,10 @@ declare function jumpToResult(this: CliEditor, result: {
     y: number;
     x: number;
 }): void;
+/**
+ * Clears the current search results and highlights.
+ */
+declare function clearSearchResults(this: CliEditor): void;
 export declare const searchMethods: {
     enterFindMode: typeof enterFindMode;
     enterReplaceMode: typeof enterReplaceMode;
@@ -41,5 +45,6 @@ export declare const searchMethods: {
     replaceCurrentAndFindNext: typeof replaceCurrentAndFindNext;
     replaceAll: typeof replaceAll;
     jumpToResult: typeof jumpToResult;
+    clearSearchResults: typeof clearSearchResults;
 };
 export {};

package/dist/editor.search.js

@@ -29,13 +29,20 @@ function enterReplaceMode() {
  */
 function executeSearch() {
     this.searchResults = [];
+    this.searchResultMap.clear();
     if (this.searchQuery === '')
         return;
+    const queryLen = this.searchQuery.length;
     for (let y = 0; y < this.lines.length; y++) {
         const line = this.lines[y];
         let index = -1;
+        const lineMatches = [];
         while ((index = line.indexOf(this.searchQuery, index + 1)) !== -1) {
             this.searchResults.push({ y, x: index });
+            lineMatches.push({ start: index, end: index + queryLen });
+        }
+        if (lineMatches.length > 0) {
+            this.searchResultMap.set(y, lineMatches);
         }
     }
     this.searchResultIndex = -1;
@@ -158,6 +165,14 @@ function jumpToResult(result) {
     // Calculate new scroll offset to center the result visually
     this.rowOffset = Math.max(0, visualRowIndex - Math.floor(this.screenRows / 2));
 }
+/**
+ * Clears the current search results and highlights.
+ */
+function clearSearchResults() {
+    this.searchResults = [];
+    this.searchResultMap.clear();
+    this.searchResultIndex = -1;
+}
 export const searchMethods = {
     enterFindMode,
     enterReplaceMode,
@@ -166,4 +181,5 @@ export const searchMethods = {
     replaceCurrentAndFindNext,
     replaceAll,
     jumpToResult,
+    clearSearchResults,
 };

package/dist/editor.swap.d.ts

@@ -0,0 +1,17 @@
+export declare class SwapManager {
+    private filepath;
+    private swapPath;
+    private intervalId;
+    private contentGetter;
+    private lastSavedContent;
+    private intervalMs;
+    constructor(filepath: string, contentGetter: () => string);
+    start(): void;
+    stop(): void;
+    update(): Promise<void>;
+    private saveSwap;
+    clear(): Promise<void>;
+    static getSwapPath(filepath: string): string;
+    static check(filepath: string): Promise<boolean>;
+    static read(filepath: string): Promise<string>;
+}

package/dist/editor.swap.js

@@ -0,0 +1,83 @@
+// src/editor.swap.ts
+import { promises as fs } from 'fs';
+import * as path from 'path';
+export class SwapManager {
+    constructor(filepath, contentGetter) {
+        this.intervalId = null;
+        this.lastSavedContent = '';
+        this.intervalMs = 2000; // 2 seconds
+        this.filepath = filepath;
+        // If filepath is empty (e.g. untitled/piped), we can't really make a relative swap file easily.
+        // We will default to a temp file or current dir if filepath is empty.
+        // For now, let's assume if filepath is provided, we use it.
+        if (!filepath) {
+            this.swapPath = path.resolve('.untitled.swp');
+        }
+        else {
+            const dir = path.dirname(filepath);
+            const file = path.basename(filepath);
+            this.swapPath = path.join(dir, '.' + file + '.swp');
+        }
+        this.contentGetter = contentGetter;
+    }
+    start() {
+        if (this.intervalId)
+            return;
+        this.intervalId = setInterval(() => this.saveSwap(), this.intervalMs);
+    }
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    // Explicitly update swap (can be called on keypress if we want instant-ish updates)
+    async update() {
+        await this.saveSwap();
+    }
+    async saveSwap() {
+        const currentContent = this.contentGetter();
+        // Optimization: Don't write if nothing changed since last swap save
+        if (currentContent === this.lastSavedContent)
+            return;
+        try {
+            await fs.writeFile(this.swapPath, currentContent, 'utf-8');
+            this.lastSavedContent = currentContent;
+        }
+        catch (error) {
+            // Silently ignore swap errors to not disrupt user flow
+        }
+    }
+    async clear() {
+        this.stop();
+        try {
+            await fs.unlink(this.swapPath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                // ignore
+            }
+        }
+    }
+    static getSwapPath(filepath) {
+        if (!filepath)
+            return path.resolve('.untitled.swp');
+        const dir = path.dirname(filepath);
+        const file = path.basename(filepath);
+        return path.join(dir, '.' + file + '.swp');
+    }
+    static async check(filepath) {
+        const swapPath = SwapManager.getSwapPath(filepath);
+        try {
+            await fs.access(swapPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async read(filepath) {
+        const swapPath = SwapManager.getSwapPath(filepath);
+        return fs.readFile(swapPath, 'utf-8');
+    }
+}

package/dist/index.d.ts

@@ -1,8 +1,9 @@
+import { EditorOptions } from './types.js';
 /**
  * Public API function: Opens the editor.
  * Reads the file and initializes CliEditor.
  */
-export declare function openEditor(filepath: string): Promise<{
+export declare function openEditor(filepath: string, options?: EditorOptions): Promise<{
     saved: boolean;
     content: string;
 }>;

package/dist/index.js

@@ -1,24 +1,62 @@
 // src/index.ts
 import { promises as fs } from 'fs';
 import { CliEditor } from './editor.js';
+import { SwapManager } from './editor.swap.js';
 /**
  * Public API function: Opens the editor.
  * Reads the file and initializes CliEditor.
  */
-export async function openEditor(filepath) {
-    let initialContent = '';
-    try {
-        // 1. Read file
-        initialContent = await fs.readFile(filepath, 'utf-8');
+export async function openEditor(filepath, options) {
+    // 0. Handle Piping (Stdin)
+    let pipedContent = '';
+    if (!process.stdin.isTTY) {
+        try {
+            const chunks = [];
+            for await (const chunk of process.stdin) {
+                chunks.push(chunk);
+            }
+            pipedContent = Buffer.concat(chunks).toString('utf-8');
+            // CRITICAL: Re-open TTY for user input!
+            // We need to bypass the consumed stdin and open the actual terminal device.
+            const ttyPath = process.platform === 'win32' ? 'CONIN$' : '/dev/tty';
+            const ttyFd = await fs.open(ttyPath, 'r');
+            // Let's rely on the fact that we can construct a new ReadStream.
+            const { ReadStream } = await import('tty');
+            const ttyReadStream = new ReadStream(ttyFd.fd);
+            if (options) {
+                options.inputStream = ttyReadStream;
+            }
+            else {
+                options = { inputStream: ttyReadStream };
+            }
+        }
+        catch (e) {
+            console.error('Failed to read from stdin or open TTY:', e);
+        }
     }
-    catch (err) {
-        // 2. If file does not exist (ENOENT), treat it as a new file
-        if (err.code !== 'ENOENT') {
-            throw err; // Throw error if not 'File not found'
+    // Check for swap file (only if filepath provided)
+    if (filepath && await SwapManager.check(filepath)) {
+        console.log(`\x1b[33mWarning: Swap file detected for ${filepath}. Recovering content...\x1b[0m`);
+        await new Promise(r => setTimeout(r, 1500));
+        const swapContent = await SwapManager.read(filepath);
+        const editor = new CliEditor(swapContent, filepath, options);
+        editor.isDirty = true; // Mark as dirty manually to avoid potential mixin issues
+        editor.statusMessage = 'RECOVERED FROM SWAP FILE';
+        return editor.run();
+    }
+    let initialContent = pipedContent; // Default to piped content
+    if (filepath && !initialContent) {
+        try {
+            initialContent = await fs.readFile(filepath, 'utf-8');
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
         }
     }
     // 3. Initialize and run editor
-    const editor = new CliEditor(initialContent, filepath);
+    const editor = new CliEditor(initialContent, filepath, options);
     return editor.run();
 }
 // --- Public Exports ---

package/dist/types.d.ts

@@ -16,3 +16,8 @@ export interface VisualRow {
     content: string;
 }
 export type EditorMode = 'edit' | 'search_find' | 'search_replace' | 'search_confirm' | 'goto_line';
+export interface EditorOptions {
+    tabSize?: number;
+    gutterWidth?: number;
+    inputStream?: any;
+}

package/dist/vendor/keypress.js

@@ -18,6 +18,7 @@ if (!listenerCount) {
  */
 const metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
 const functionKeyCodeRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
+const mouseSgrRe = /^\x1b\[<(\d+);(\d+);(\d+)([mM])/;
 /**
  * Hàm chính, chấp nhận một Readable Stream và làm cho nó
  * phát ra sự kiện "keypress".
@@ -421,7 +422,32 @@ function emitKey(stream, s) {
         }
         return;
     }
-    // XXX: code phân tích "mouse" đã bị XÓA theo yêu cầu.
+    // Mouse handling (SGR 1006)
+    if ((parts = mouseSgrRe.exec(s))) {
+        // SGR Mode: \x1b[< b; x; y M/m
+        // b: button code
+        // x, y: coordinates (1-based)
+        // M/m: Press/Release
+        const b = parseInt(parts[1], 10);
+        const x = parseInt(parts[2], 10);
+        const y = parseInt(parts[3], 10);
+        const type = parts[4]; // M=press, m=release
+        key.name = 'mouse';
+        key.ctrl = false;
+        key.meta = false;
+        key.shift = false;
+        // Check for Scroll (Button 64 = Up, 65 = Down)
+        if (b === 64) {
+            key.name = 'scrollup';
+            key.code = 'scrollup';
+        }
+        else if (b === 65) {
+            key.name = 'scrolldown';
+            key.code = 'scrolldown';
+        }
+        // We can handle click here if needed (b=0 left, b=1 middle, b=2 right)
+        // but for now only scroll is requested.
+    }
     // Không phát ra key nếu không tìm thấy tên
     if (key.name === undefined) {
         return; // key = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cliedit",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "A lightweight, raw-mode terminal editor utility for Node.js CLI applications, with line wrapping and undo/redo support.",
   "repository": "https://github.com/CodeTease/cliedit",
   "type": "module",
@@ -21,7 +21,7 @@
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "demo": "npm run build && cross-env NODE_ENV=development node dist/demo.js",
+    "demo": "npm run build && cross-env NODE_ENV=development tsx src/demo.ts",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
@@ -35,10 +35,9 @@
   "author": "CodeTease",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^20.12.12",
-    "cross-env": "^7.0.3",
-    "typescript": "^5.4.5"
-  },
-  "dependencies": {
+    "@types/node": "^22",
+    "cross-env": "^7",
+    "tsx": "^4",
+    "typescript": "^5"
   }
-}
+}