cliedit 0.1.1 → 0.1.3

package/ACKNOWLEDGEMENTS.md

@@ -0,0 +1,21 @@
+# Acknowledgements & Copyright (ACKNOWLEDGEMENTS)
+
+`cliedit` is an open-source project that utilizes components (or modified/converted versions thereof) from other open-source projects. We express our deep gratitude to the communities and authors who provided the foundation for these components.
+
+All components listed below are included as vendored code (integrated directly into the project source code) and have been adapted to fit **cliedit**'s TypeScript architecture and remove unnecessary features (e.g., mouse support).
+
+## Vendored Components List
+
+**Original Project Name: `keypress`**
+
+**Description & Origin:** Provides raw key event parsing logic for the TTY environment. The source code was converted from the original JavaScript version and optimized for Node.js.
+
+**Repository:** https://github.com/TooTallNate/keypress
+
+**License:** MIT
+
+**Copyright Notes:**
+
+- `keypress` was originally authored by **Nathan Rajlich** (tootallnate.net).
+- Copyright (c) 2012 Nathan Rajlich.
+- The module is based on the keypress logic found within the Node.js Core `readline` module.

package/README.md

@@ -4,7 +4,7 @@ A lightweight, zero-dependency, raw-mode terminal editor component for Node.js.
 
 `cliedit` is designed to be imported into your own CLI application to provide a full-featured, TTY-based text editing experience. It's perfect for applications that need to ask the user for multi-line input, edit configuration files, or write commit messages.
 
-It includes line wrapping, visual navigation, undo/redo, text selection, and clipboard support.
+It includes line wrapping, visual navigation, smart auto-indentation, undo/redo, text selection, Find/Replace, and cross-platform clipboard support.
 
 ## Features
 
@@ -13,18 +13,21 @@ It includes line wrapping, visual navigation, undo/redo, text selection, and cli
 - **Visual Navigation:** `Up`/`Down` arrows move by visual rows, not logical lines.
 - **Undo/Redo:** `Ctrl+Z` / `Ctrl+Y` for persistent history.
 - **Text Selection:** `Ctrl+Arrow` keys to select text.
-- **Clipboard Support:** `Ctrl+C` (Copy), `Ctrl+X` (Cut), `Ctrl+V` (Paste) for system clipboard (macOS/Windows).
+- **Clipboard Support:** `Ctrl+C` (Copy), `Ctrl+X` (Cut), `Ctrl+V` (Paste) for system clipboard (macOS, Windows, **and Linux** via `xclip`).
 - **File I/O:** Loads from and saves to the filesystem.
-- **Search:** `Ctrl+W` to find text.
+- **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.
 
 ## Installation
 ```bash
 npm install cliedit
-```
+````
 
 ## Usage
 
 The package exports an `async` function `openEditor` that returns a `Promise`. The promise resolves when the user quits the editor.
+
 ```javascript
 import { openEditor } from 'cliedit';
 import path from 'path';
@@ -60,13 +63,15 @@ getCommitMessage();
 `openEditor(filepath: string)`
 
 Opens the editor for the specified file. If the file doesn't exist, it will be created upon saving.
-- **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.
+
+  - **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.
 
 `CliEditor`
 
 The main editor class. You can import this directly if you need to extend or instantiate the editor with custom logic.
+
 ```javascript
 import { CliEditor } from 'cliedit';
 ```
@@ -74,6 +79,7 @@ import { CliEditor } from 'cliedit';
 ### Types
 
 Key types are also exported for convenience:
+
 ```javascript
 import type {
   DocumentState,

package/dist/constants.d.ts

@@ -20,7 +20,9 @@ export declare const KEYS: {
     CTRL_Q: string;
     CTRL_S: string;
     CTRL_W: string;
+    CTRL_R: string;
     CTRL_G: string;
+    CTRL_L: string;
     CTRL_Z: string;
     CTRL_Y: string;
     CTRL_K: string;

package/dist/constants.js

@@ -22,7 +22,9 @@ export const KEYS = {
     CTRL_Q: '\x11', // Quit
     CTRL_S: '\x13', // Save
     CTRL_W: '\x17', // Find (Where is)
+    CTRL_R: '\x12', // Replace
     CTRL_G: '\x07', // Go to next
+    CTRL_L: '\x0c', // Go to Line (L)
     CTRL_Z: '\x1a', // Undo
     CTRL_Y: '\x19', // Redo
     CTRL_K: '\x0b', // Cut/Kill line

package/dist/editor.clipboard.js

@@ -15,8 +15,11 @@ function setClipboard(text) {
             case 'win32':
                 command = 'clip';
                 break;
+            case 'linux': // <--- THÊM HỖ TRỢ LINUX
+                command = 'xclip -selection clipboard';
+                break;
             default:
-                this.setStatusMessage('Clipboard only supported on macOS/Windows for now');
+                this.setStatusMessage('Clipboard not supported on this platform');
                 return resolve();
         }
         const process = exec(command, (error) => {
@@ -43,8 +46,11 @@ function getClipboard() {
             case 'win32':
                 command = 'powershell -command "Get-Clipboard"';
                 break;
+            case 'linux': // <--- THÊM HỖ TRỢ LINUX
+                command = 'xclip -selection clipboard -o'; // -o (hoặc -out) để đọc
+                break;
             default:
-                this.setStatusMessage('Clipboard only supported on macOS/Windows for now');
+                this.setStatusMessage('Clipboard not supported on this platform');
                 return resolve('');
         }
         exec(command, (error, stdout) => {

package/dist/editor.d.ts

@@ -42,8 +42,10 @@ export declare class CliEditor {
     statusTimeout: NodeJS.Timeout | null;
     isMessageCustom: boolean;
     quitConfirm: boolean;
-    readonly DEFAULT_STATUS = "HELP: Ctrl+S = Save & Quit | Ctrl+Q = Quit | Ctrl+C = Copy All | Ctrl+Arrow = Select";
+    readonly DEFAULT_STATUS = "HELP: Ctrl+S = Save | Ctrl+Q = Quit | Ctrl+W = Find | Ctrl+R = Replace | Ctrl+L = Go to Line";
     searchQuery: string;
+    replaceQuery: string | null;
+    goToLineQuery: string;
     searchResults: {
         y: number;
         x: number;

package/dist/editor.editing.d.ts

@@ -18,6 +18,7 @@ declare function insertCharacter(this: CliEditor, char: string): void;
 declare function insertSoftTab(this: CliEditor): void;
 /**
  * Inserts a new line, splitting the current line at the cursor position.
+ * Implements auto-indent.
  */
 declare function insertNewLine(this: CliEditor): void;
 /**
@@ -28,6 +29,14 @@ declare function deleteBackward(this: CliEditor): void;
  * Deletes the character after the cursor, or joins the current line with the next one.
  */
 declare function deleteForward(this: CliEditor): void;
+/**
+ * Handles auto-pairing of brackets and quotes.
+ * If text is selected, it wraps the selection.
+ * Otherwise, it inserts the pair and places the cursor in the middle.
+ * @param openChar The opening character that was typed (e.g., '(', '[', '{').
+ * @param closeChar The corresponding closing character (e.g., ')', ']', '}').
+ */
+declare function handleAutoPair(this: CliEditor, openChar: string, closeChar: string): void;
 export declare const editingMethods: {
     insertContentAtCursor: typeof insertContentAtCursor;
     insertCharacter: typeof insertCharacter;
@@ -35,5 +44,6 @@ export declare const editingMethods: {
     insertNewLine: typeof insertNewLine;
     deleteBackward: typeof deleteBackward;
     deleteForward: typeof deleteForward;
+    handleAutoPair: typeof handleAutoPair;
 };
 export {};

package/dist/editor.editing.js

@@ -51,14 +51,19 @@ function insertSoftTab() {
 }
 /**
  * Inserts a new line, splitting the current line at the cursor position.
+ * Implements auto-indent.
  */
 function insertNewLine() {
     const line = this.lines[this.cursorY] || '';
+    // Find indentation of the current line
+    const match = line.match(/^(\s*)/);
+    const indent = match ? match[1] : '';
     const remainder = line.slice(this.cursorX);
     this.lines[this.cursorY] = line.slice(0, this.cursorX);
-    this.lines.splice(this.cursorY + 1, 0, remainder);
+    // Add new line with the same indentation + remainder
+    this.lines.splice(this.cursorY + 1, 0, indent + remainder);
     this.cursorY++;
-    this.cursorX = 0;
+    this.cursorX = indent.length; // Move cursor to end of indent
     this.setDirty();
 }
 /**
@@ -105,6 +110,36 @@ function deleteForward() {
     }
     this.setDirty();
 }
+/**
+ * Handles auto-pairing of brackets and quotes.
+ * If text is selected, it wraps the selection.
+ * Otherwise, it inserts the pair and places the cursor in the middle.
+ * @param openChar The opening character that was typed (e.g., '(', '[', '{').
+ * @param closeChar The corresponding closing character (e.g., ')', ']', '}').
+ */
+function handleAutoPair(openChar, closeChar) {
+    if (this.selectionAnchor) {
+        // There is a selection, so we need to wrap it.
+        const selection = this.getNormalizedSelection();
+        if (!selection)
+            return; // Should not happen if anchor exists, but good practice
+        const selectedText = this.getSelectedText();
+        // The deleteSelectedText() function automatically moves the cursor to the start
+        // of the selection, so we don't need to set it manually.
+        this.deleteSelectedText();
+        // Wrap the original selected text
+        const wrappedText = openChar + selectedText + closeChar;
+        this.insertContentAtCursor(wrappedText.split('\n'));
+        // The selection is already cancelled by deleteSelectedText().
+    }
+    else {
+        // No selection, just insert the opening and closing characters
+        this.insertCharacter(openChar + closeChar);
+        // Move cursor back one position to be in between the pair
+        this.cursorX--;
+    }
+    this.setDirty();
+}
 export const editingMethods = {
     insertContentAtCursor,
     insertCharacter,
@@ -112,4 +147,5 @@ export const editingMethods = {
     insertNewLine,
     deleteBackward,
     deleteForward,
+    handleAutoPair,
 };

package/dist/editor.js

@@ -13,7 +13,7 @@ import { historyMethods } from './editor.history.js';
 import { ioMethods } from './editor.io.js';
 import { keyHandlingMethods } from './editor.keys.js';
 import { selectionMethods } from './editor.selection.js';
-const DEFAULT_STATUS = 'HELP: Ctrl+S = Save & Quit | Ctrl+Q = Quit | Ctrl+C = Copy All | Ctrl+Arrow = Select';
+const DEFAULT_STATUS = 'HELP: Ctrl+S = Save | Ctrl+Q = Quit | Ctrl+W = Find | Ctrl+R = Replace | Ctrl+L = Go to Line';
 /**
  * Main editor class managing application state, TTY interaction, and rendering.
  */
@@ -36,6 +36,8 @@ export class CliEditor {
         this.quitConfirm = false;
         this.DEFAULT_STATUS = DEFAULT_STATUS;
         this.searchQuery = '';
+        this.replaceQuery = null; // null = Find mode, string = Replace mode
+        this.goToLineQuery = ''; // For Go to Line prompt
         this.searchResults = [];
         this.searchResultIndex = -1;
         this.isCleanedUp = false;

package/dist/editor.keys.d.ts

@@ -3,6 +3,8 @@ export type TKeyHandlingMethods = {
     handleKeypressEvent: (ch: string, key: KeypressEvent) => void;
     handleEditKeys: (key: string) => boolean;
     handleSearchKeys: (key: string) => void;
+    handleSearchConfirmKeys: (key: string) => void;
+    handleGoToLineKeys: (key: string) => void;
     handleCtrlQ: () => void;
     handleCopy: () => Promise<void>;
     handleCharacterKey: (ch: string) => void;

package/dist/editor.keys.js

@@ -1,5 +1,12 @@
 // src/editor.keys.ts
 import { KEYS } from './constants.js';
+const PAIR_MAP = {
+    '(': ')',
+    '[': ']',
+    '{': '}',
+    "'": "'",
+    '"': '"',
+};
 /**
  * Main router for standardized keypress events from the 'keypress' library.
  */
@@ -13,10 +20,21 @@ function handleKeypressEvent(ch, key) {
     // --- 1. Xử lý trường hợp key là null/undefined (Ký tự in được) ---
     if (!key) {
         if (ch && ch.length === 1 && ch >= ' ' && ch <= '~') {
-            edited = this.handleEditKeys(ch);
-            if (edited) {
-                this.saveState();
-                this.recalculateVisualRows(); // Phải tính toán lại sau khi gõ
+            if (this.mode === 'search_find' || this.mode === 'search_replace') {
+                this.handleSearchKeys(ch);
+            }
+            else if (this.mode === 'goto_line') {
+                this.handleGoToLineKeys(ch);
+            }
+            else if (this.mode === 'edit') {
+                edited = this.handleEditKeys(ch);
+                if (edited) {
+                    this.saveState();
+                    this.recalculateVisualRows(); // Phải tính toán lại sau khi gõ
+                }
+            }
+            else if (this.mode === 'search_confirm') {
+                this.handleSearchConfirmKeys(ch);
             }
             this.render();
             return;
@@ -67,9 +85,15 @@ function handleKeypressEvent(ch, key) {
             keyName = key.sequence;
     }
     // --- 3. Định tuyến theo Mode ---
-    if (this.mode === 'search') {
+    if (this.mode === 'search_find' || this.mode === 'search_replace') {
         this.handleSearchKeys(keyName || ch);
     }
+    else if (this.mode === 'search_confirm') {
+        this.handleSearchConfirmKeys(keyName || ch);
+    }
+    else if (this.mode === 'goto_line') {
+        this.handleGoToLineKeys(keyName || ch);
+    }
     else {
         // 4. Xử lý phím lựa chọn (Ctrl+Arrow) - Navigation
         switch (keyName) {
@@ -158,10 +182,24 @@ function handleEditKeys(key) {
             this.insertNewLine();
             return true;
         case KEYS.BACKSPACE:
-            if (this.selectionAnchor)
-                this.deleteSelectedText();
-            else
-                this.deleteBackward();
+            // Handle auto-pair deletion
+            const line = this.lines[this.cursorY] || '';
+            const charBefore = line[this.cursorX - 1];
+            const charAfter = line[this.cursorX];
+            if (!this.selectionAnchor &&
+                charBefore && charAfter &&
+                PAIR_MAP[charBefore] === charAfter) {
+                // Delete both characters of the pair
+                this.lines[this.cursorY] = line.slice(0, this.cursorX - 1) + line.slice(this.cursorX + 1);
+                this.cursorX--; // Move cursor back
+                this.setDirty();
+            }
+            else {
+                if (this.selectionAnchor)
+                    this.deleteSelectedText();
+                else
+                    this.deleteBackward();
+            }
             return true;
         case KEYS.DELETE:
             if (this.selectionAnchor)
@@ -174,7 +212,13 @@ function handleEditKeys(key) {
             return true;
         // --- Search & History ---
         case KEYS.CTRL_W:
-            this.enterSearchMode();
+            this.enterFindMode();
+            return false;
+        case KEYS.CTRL_R:
+            this.enterReplaceMode();
+            return false;
+        case KEYS.CTRL_L:
+            this.enterGoToLineMode();
             return false;
         case KEYS.CTRL_G:
             this.findNext();
@@ -215,11 +259,26 @@ function handleEditKeys(key) {
  * Handles insertion of a character, deleting selection first if it exists.
  */
 function handleCharacterKey(ch) {
-    if (this.selectionAnchor) {
-        this.deleteSelectedText();
+    const line = this.lines[this.cursorY] || '';
+    const charAfter = line[this.cursorX];
+    // If user types a closing character and it's what we expect, just move the cursor.
+    if (!this.selectionAnchor &&
+        (ch === ')' || ch === ']' || ch === '}' || ch === "'" || ch === '"') &&
+        charAfter === ch) {
+        this.cursorX++;
+        return;
+    }
+    const closeChar = PAIR_MAP[ch];
+    if (closeChar) {
+        this.handleAutoPair(ch, closeChar);
+    }
+    else {
+        if (this.selectionAnchor) {
+            this.deleteSelectedText();
+        }
+        this.insertCharacter(ch);
+        this.setDirty();
     }
-    this.insertCharacter(ch);
-    this.setDirty();
 }
 /**
  * Handles Ctrl+Q (Quit) sequence.
@@ -268,28 +327,130 @@ async function handleSave() {
     }
 }
 /**
- * Handles Search Mode input keys.
+ * Handles Search Mode input keys (for 'search_find' and 'search_replace').
  */
 function handleSearchKeys(key) {
+    const cancelSearch = () => {
+        this.mode = 'edit';
+        this.searchQuery = '';
+        this.replaceQuery = null;
+        this.searchResults = [];
+        this.searchResultIndex = -1;
+        this.setStatusMessage('Cancelled');
+    };
     switch (key) {
         case KEYS.ENTER:
-            this.executeSearch();
-            this.mode = 'edit';
+            if (this.mode === 'search_find') {
+                if (this.replaceQuery === null) {
+                    // Find-Only Flow: Execute search and find first
+                    this.executeSearch();
+                    this.mode = 'edit';
+                    this.findNext();
+                }
+                else {
+                    // Replace Flow: Transition to get replace string
+                    this.mode = 'search_replace';
+                    this.setStatusMessage('Replace with: ');
+                }
+            }
+            else if (this.mode === 'search_replace') {
+                // Replace Flow: We have both strings, execute and find first
+                this.executeSearch();
+                this.mode = 'edit';
+                this.findNext();
+            }
+            break;
+        case KEYS.ESCAPE:
+        case KEYS.CTRL_C:
+        case KEYS.CTRL_Q:
+            cancelSearch();
+            break;
+        case KEYS.BACKSPACE:
+            if (this.mode === 'search_find') {
+                this.searchQuery = this.searchQuery.slice(0, -1);
+            }
+            else {
+                this.replaceQuery = this.replaceQuery.slice(0, -1);
+            }
+            break;
+        default:
+            if (key.length === 1 && key >= ' ' && key <= '~') {
+                if (this.mode === 'search_find') {
+                    this.searchQuery += key;
+                }
+                else {
+                    this.replaceQuery += key;
+                }
+            }
+    }
+    // Update status bar message live (if not cancelling)
+    if (this.mode === 'search_find') {
+        this.setStatusMessage((this.replaceQuery === null ? 'Find: ' : 'Find: ') + this.searchQuery);
+    }
+    else if (this.mode === 'search_replace') {
+        this.setStatusMessage('Replace with: ' + this.replaceQuery);
+    }
+}
+/**
+ * Handles keypresses during the (y/n/a/q) confirmation step.
+ */
+function handleSearchConfirmKeys(key) {
+    switch (key.toLowerCase()) {
+        case 'y': // Yes
+            this.replaceCurrentAndFindNext();
+            break;
+        case 'n': // No
             this.findNext();
             break;
+        case 'a': // All
+            this.replaceAll();
+            break;
+        case 'q': // Quit
         case KEYS.ESCAPE:
         case KEYS.CTRL_C:
         case KEYS.CTRL_Q:
             this.mode = 'edit';
-            this.searchQuery = '';
-            this.setStatusMessage('Search cancelled');
+            this.searchResults = [];
+            this.searchResultIndex = -1;
+            this.setStatusMessage('Replace cancelled');
+            break;
+    }
+}
+/**
+ * Handles keypresses during the 'Go to Line' prompt.
+ */
+function handleGoToLineKeys(key) {
+    const cancel = () => {
+        this.mode = 'edit';
+        this.goToLineQuery = '';
+        this.setStatusMessage('Cancelled');
+    };
+    switch (key) {
+        case KEYS.ENTER:
+            const lineNumber = parseInt(this.goToLineQuery, 10);
+            if (!isNaN(lineNumber) && lineNumber > 0) {
+                this.jumpToLine(lineNumber);
+            }
+            else {
+                this.mode = 'edit';
+                this.setStatusMessage('Invalid line number');
+            }
+            this.goToLineQuery = '';
+            break;
+        case KEYS.ESCAPE:
+        case KEYS.CTRL_C:
+        case KEYS.CTRL_Q:
+            cancel();
             break;
         case KEYS.BACKSPACE:
-            this.searchQuery = this.searchQuery.slice(0, -1);
+            this.goToLineQuery = this.goToLineQuery.slice(0, -1);
+            this.setStatusMessage('Go to Line: ' + this.goToLineQuery);
             break;
         default:
-            if (key.length === 1 && key >= ' ' && key <= '~') {
-                this.searchQuery += key;
+            // Only accept digits
+            if (key.length === 1 && key >= '0' && key <= '9') {
+                this.goToLineQuery += key;
+                this.setStatusMessage('Go to Line: ' + this.goToLineQuery);
             }
     }
 }
@@ -297,6 +458,8 @@ export const keyHandlingMethods = {
     handleKeypressEvent,
     handleEditKeys,
     handleSearchKeys,
+    handleSearchConfirmKeys,
+    handleGoToLineKeys,
     handleCtrlQ,
     handleCopy,
     handleCharacterKey,

package/dist/editor.navigation.d.ts

@@ -30,6 +30,14 @@ declare function adjustCursorPosition(this: CliEditor): void;
  * Scrolls the viewport to keep the cursor visible.
  */
 declare function scroll(this: CliEditor): void;
+/**
+ * Jumps the cursor to a specific line number (1-based).
+ */
+declare function jumpToLine(this: CliEditor, lineNumber: number): void;
+/**
+ * Enters Go To Line mode.
+ */
+declare function enterGoToLineMode(this: CliEditor): void;
 export declare const navigationMethods: {
     findCurrentVisualRowIndex: typeof findCurrentVisualRowIndex;
     moveCursorLogically: typeof moveCursorLogically;
@@ -38,5 +46,7 @@ export declare const navigationMethods: {
     findVisualRowEnd: typeof findVisualRowEnd;
     adjustCursorPosition: typeof adjustCursorPosition;
     scroll: typeof scroll;
+    jumpToLine: typeof jumpToLine;
+    enterGoToLineMode: typeof enterGoToLineMode;
 };
 export {};

package/dist/editor.navigation.js

@@ -121,6 +121,28 @@ function scroll() {
         this.rowOffset = currentVisualRow - this.screenRows + 1;
     }
 }
+/**
+ * Jumps the cursor to a specific line number (1-based).
+ */
+function jumpToLine(lineNumber) {
+    const targetY = lineNumber - 1; // Convert 1-based to 0-based index
+    // Clamp targetY to valid range
+    this.cursorY = Math.max(0, Math.min(targetY, this.lines.length - 1));
+    this.cursorX = 0; // Move to start of line
+    // Adjust scroll
+    const visualRowIndex = this.findCurrentVisualRowIndex();
+    this.rowOffset = Math.max(0, visualRowIndex - Math.floor(this.screenRows / 2));
+    this.mode = 'edit';
+    this.setStatusMessage(`Jumped to line ${lineNumber}`, 1000);
+}
+/**
+ * Enters Go To Line mode.
+ */
+function enterGoToLineMode() {
+    this.mode = 'goto_line';
+    this.goToLineQuery = '';
+    this.setStatusMessage('Go to Line (ESC to cancel): ');
+}
 export const navigationMethods = {
     findCurrentVisualRowIndex,
     moveCursorLogically,
@@ -129,4 +151,6 @@ export const navigationMethods = {
     findVisualRowEnd,
     adjustCursorPosition,
     scroll,
+    jumpToLine,
+    enterGoToLineMode,
 };

package/dist/editor.rendering.js

@@ -65,6 +65,11 @@ function render() {
                 const logicalY = row.logicalY;
                 const isCursorPosition = (visualRowIndex === currentVisualRowIndex && i === cursorVisualX);
                 const isSelected = selectionRange && this.isPositionInSelection(logicalY, logicalX, selectionRange);
+                // Highlight search result under cursor
+                const isSearchResult = (this.searchResultIndex !== -1 &&
+                    this.searchResults[this.searchResultIndex]?.y === logicalY &&
+                    logicalX >= this.searchResults[this.searchResultIndex]?.x &&
+                    logicalX < (this.searchResults[this.searchResultIndex]?.x + this.searchQuery.length));
                 if (isSelected) {
                     buffer += ANSI.INVERT_COLORS + char + ANSI.RESET_COLORS;
                 }
@@ -72,6 +77,10 @@ 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
+                    buffer += ANSI.INVERT_COLORS + char + ANSI.RESET_COLORS;
+                }
                 else {
                     buffer += char;
                 }
@@ -123,24 +132,38 @@ function renderStatusBar() {
     let status = '';
     const contentWidth = this.screenCols;
     // --- Line 1: Mode, File Status, Position ---
-    if (this.mode === 'search') {
-        status = `SEARCH: ${this.searchQuery}`;
-    }
-    else {
-        const visualRowIndex = this.findCurrentVisualRowIndex();
-        const visualRow = this.visualRows[visualRowIndex];
-        const visualX = visualRow ? (this.cursorX - visualRow.logicalXStart) : 0;
-        const fileStatus = this.isDirty ? `* ${this.filepath}` : this.filepath;
-        const pos = `Ln ${this.cursorY + 1}, Col ${this.cursorX + 1} (View: ${visualRowIndex + 1},${visualX + 1})`;
-        const statusLeft = `[${fileStatus}]`.padEnd(Math.floor(contentWidth * 0.5));
-        const statusRight = pos.padStart(Math.floor(contentWidth * 0.5));
-        status = statusLeft + statusRight;
+    switch (this.mode) {
+        case 'search_find':
+            status = (this.replaceQuery === null ? 'Find: ' : 'Find: ') + this.searchQuery;
+            break;
+        case 'search_replace':
+            status = 'Replace with: ' + this.replaceQuery;
+            break;
+        case 'goto_line':
+            status = 'Go to Line: ' + this.goToLineQuery;
+            break;
+        case 'search_confirm':
+            // The (y/n/a/q) prompt is set via setStatusMessage
+            status = this.statusMessage;
+            break;
+        case 'edit':
+        default:
+            const visualRowIndex = this.findCurrentVisualRowIndex();
+            const visualRow = this.visualRows[visualRowIndex];
+            const visualX = visualRow ? (this.cursorX - visualRow.logicalXStart) : 0;
+            const fileStatus = this.isDirty ? `* ${this.filepath}` : this.filepath;
+            const pos = `Ln ${this.cursorY + 1}, Col ${this.cursorX + 1} (View: ${visualRowIndex + 1},${visualX + 1})`;
+            const statusLeft = `[${fileStatus}]`.padEnd(Math.floor(contentWidth * 0.5));
+            const statusRight = pos.padStart(Math.floor(contentWidth * 0.5));
+            status = statusLeft + statusRight;
+            break;
     }
     status = status.padEnd(contentWidth);
     let buffer = `${ANSI.INVERT_COLORS}${status}${ANSI.RESET_COLORS}`;
     // --- Line 2: Message/Help line ---
     buffer += `\x1b[${this.screenRows + this.screenStartRow + 1};1H`;
-    const message = this.statusMessage.padEnd(contentWidth);
+    // Show prompt message if in search mode, otherwise show default help
+    const message = (this.mode === 'edit' ? this.DEFAULT_STATUS : this.statusMessage).padEnd(contentWidth);
     buffer += `${message}${ANSI.CLEAR_LINE}`;
     return buffer;
 }

package/dist/editor.search.d.ts

@@ -1,11 +1,15 @@
 import { CliEditor } from './editor.js';
 /**
- * Methods related to Find/Search functionality.
+ * Methods related to Find/Search/Replace functionality.
  */
 /**
- * Enters search mode.
+ * Enters Find mode.
  */
-declare function enterSearchMode(this: CliEditor): void;
+declare function enterFindMode(this: CliEditor): void;
+/**
+ * Enters Replace mode (starting with the "Find" prompt).
+ */
+declare function enterReplaceMode(this: CliEditor): void;
 /**
  * Executes the search and populates results.
  */
@@ -14,6 +18,14 @@ declare function executeSearch(this: CliEditor): void;
  * Jumps to the next search result.
  */
 declare function findNext(this: CliEditor): void;
+/**
+ * Replaces the current highlighted search result and finds the next one.
+ */
+declare function replaceCurrentAndFindNext(this: CliEditor): void;
+/**
+ * Replaces all occurrences of the search query.
+ */
+declare function replaceAll(this: CliEditor): void;
 /**
  * Moves cursor and adjusts scroll offset to make the result visible.
  */
@@ -22,9 +34,12 @@ declare function jumpToResult(this: CliEditor, result: {
     x: number;
 }): void;
 export declare const searchMethods: {
-    enterSearchMode: typeof enterSearchMode;
+    enterFindMode: typeof enterFindMode;
+    enterReplaceMode: typeof enterReplaceMode;
     executeSearch: typeof executeSearch;
     findNext: typeof findNext;
+    replaceCurrentAndFindNext: typeof replaceCurrentAndFindNext;
+    replaceAll: typeof replaceAll;
     jumpToResult: typeof jumpToResult;
 };
 export {};

package/dist/editor.search.js

@@ -1,16 +1,28 @@
 // src/editor.search.ts
 /**
- * Methods related to Find/Search functionality.
+ * Methods related to Find/Search/Replace functionality.
  */
 /**
- * Enters search mode.
+ * Enters Find mode.
  */
-function enterSearchMode() {
-    this.mode = 'search';
+function enterFindMode() {
+    this.mode = 'search_find';
     this.searchQuery = '';
+    this.replaceQuery = null; // Mark as Find-Only
     this.searchResults = [];
     this.searchResultIndex = -1;
-    this.setStatusMessage('Search (ESC/Ctrl+Q/C to cancel, ENTER to find): ');
+    this.setStatusMessage('Find (ESC to cancel): ');
+}
+/**
+ * Enters Replace mode (starting with the "Find" prompt).
+ */
+function enterReplaceMode() {
+    this.mode = 'search_find';
+    this.searchQuery = '';
+    this.replaceQuery = ''; // Mark as Replace flow
+    this.searchResults = [];
+    this.searchResultIndex = -1;
+    this.setStatusMessage('Find (for Replace): ');
 }
 /**
  * Executes the search and populates results.
@@ -27,18 +39,114 @@ function executeSearch() {
         }
     }
     this.searchResultIndex = -1;
-    this.setStatusMessage(`Found ${this.searchResults.length} results for "${this.searchQuery}"`);
+    if (this.replaceQuery === null) { // Find-only flow
+        this.setStatusMessage(`Found ${this.searchResults.length} results for "${this.searchQuery}"`);
+    }
 }
 /**
  * Jumps to the next search result.
  */
 function findNext() {
+    if (this.searchQuery === '') {
+        this.enterFindMode();
+        return;
+    }
+    // Execute search if results are not yet populated
+    if (this.searchResults.length === 0 && this.searchResultIndex === -1) {
+        this.executeSearch();
+    }
     if (this.searchResults.length === 0) {
-        this.setStatusMessage('No search results');
+        this.setStatusMessage('No results found');
+        this.mode = 'edit';
         return;
     }
-    this.searchResultIndex = (this.searchResultIndex + 1) % this.searchResults.length;
+    this.searchResultIndex++;
+    if (this.searchResultIndex >= this.searchResults.length) {
+        this.setStatusMessage('End of file reached. Starting from top.');
+        this.searchResultIndex = 0;
+    }
+    const result = this.searchResults[this.searchResultIndex];
+    this.jumpToResult(result);
+    if (this.replaceQuery !== null) {
+        // Replace flow: Enter confirmation step
+        this.mode = 'search_confirm';
+        this.setStatusMessage(`Replace "${this.searchQuery}"? (y/n/a/q)`);
+    }
+    else {
+        // Find-only flow: Go back to edit
+        this.mode = 'edit';
+    }
+}
+/**
+ * Replaces the current highlighted search result and finds the next one.
+ */
+function replaceCurrentAndFindNext() {
+    if (this.searchResultIndex === -1 || !this.searchResults[this.searchResultIndex]) {
+        this.findNext();
+        return;
+    }
+    const result = this.searchResults[this.searchResultIndex];
+    const line = this.lines[result.y];
+    const before = line.substring(0, result.x);
+    const after = line.substring(result.x + this.searchQuery.length);
+    // Use replaceQuery (it's guaranteed to be a string here, not null)
+    this.lines[result.y] = before + this.replaceQuery + after;
+    this.setDirty();
+    // Store current position to find the *next* match after this one
+    const replacedResultY = result.y;
+    const replacedResultX = result.x;
+    // We MUST re-execute search as all indices may have changed
+    this.executeSearch();
+    this.recalculateVisualRows();
+    // Find the next result *after* the one we just replaced
+    let nextIndex = -1;
+    for (let i = 0; i < this.searchResults.length; i++) {
+        const res = this.searchResults[i];
+        if (res.y > replacedResultY || (res.y === replacedResultY && res.x > replacedResultX)) {
+            nextIndex = i;
+            break;
+        }
+    }
+    if (nextIndex === -1) {
+        this.setStatusMessage('No more results');
+        this.mode = 'edit';
+        this.searchResultIndex = -1; // Reset search
+        return;
+    }
+    // Found the next one
+    this.searchResultIndex = nextIndex;
     this.jumpToResult(this.searchResults[this.searchResultIndex]);
+    this.mode = 'search_confirm'; // Stay in confirm mode
+    this.setStatusMessage(`Replace "${this.searchQuery}"? (y/n/a/q)`);
+}
+/**
+ * Replaces all occurrences of the search query.
+ */
+function replaceAll() {
+    if (this.searchResults.length === 0) {
+        this.executeSearch();
+    }
+    if (this.searchResults.length === 0) {
+        this.setStatusMessage('No results found');
+        this.mode = 'edit';
+        return;
+    }
+    let count = 0;
+    // Iterate backwards to ensure indices remain valid during replacement
+    for (let i = this.searchResults.length - 1; i >= 0; i--) {
+        const result = this.searchResults[i];
+        const line = this.lines[result.y];
+        const before = line.substring(0, result.x);
+        const after = line.substring(result.x + this.searchQuery.length);
+        this.lines[result.y] = before + this.replaceQuery + after;
+        count++;
+    }
+    this.setDirty();
+    this.recalculateVisualRows();
+    this.mode = 'edit';
+    this.searchResults = [];
+    this.searchResultIndex = -1;
+    this.setStatusMessage(`Replaced ${count} occurrences.`);
 }
 /**
  * Moves cursor and adjusts scroll offset to make the result visible.
@@ -51,8 +159,11 @@ function jumpToResult(result) {
     this.rowOffset = Math.max(0, visualRowIndex - Math.floor(this.screenRows / 2));
 }
 export const searchMethods = {
-    enterSearchMode,
+    enterFindMode,
+    enterReplaceMode,
     executeSearch,
     findNext,
+    replaceCurrentAndFindNext,
+    replaceAll,
     jumpToResult,
 };

package/dist/types.d.ts

@@ -15,4 +15,4 @@ export interface VisualRow {
     logicalXStart: number;
     content: string;
 }
-export type EditorMode = 'edit' | 'search';
+export type EditorMode = 'edit' | 'search_find' | 'search_replace' | 'search_confirm' | 'goto_line';

package/dist/vendor/keypress.js

@@ -142,6 +142,16 @@ function emitKey(stream, s) {
         key.name = parts[1].toLowerCase();
         key.meta = true;
         key.shift = /^[A-Z]$/.test(parts[1]);
+        // ***** START BUG FIX *****
+        // The original library failed to handle any standard printable
+        // characters (numbers, symbols) that weren't a-z or A-Z.
+    }
+    else if (s.length === 1 && s >= ' ' && s <= '~') {
+        // Standard printable character (digits, symbols, etc.)
+        key.name = s;
+        // We can infer shift status for common symbols
+        key.shift = '!@#$%^&*()_+{}|:"<>?~'.includes(s);
+        // ***** END BUG FIX *****
     }
     else if ((parts = functionKeyCodeRe.exec(s))) {
         // ansi escape sequence

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cliedit",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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",
@@ -15,7 +15,8 @@
   "files": [
     "dist",
     "LICENSE",
-    "README.md"
+    "README.md",
+    "ACKNOWLEDGEMENTS.md"
   ],
   "scripts": {
     "build": "tsc",