cliedit 0.1.2 → 0.2.0

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,60 +13,94 @@ 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.
+- **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
 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';
 
 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. 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.
+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. 
+
+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).
+      * `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 +108,7 @@ import { CliEditor } from 'cliedit';
 ### Types
 
 Key types are also exported for convenience:
+
 ```javascript
 import type {
   DocumentState,

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;
@@ -52,14 +54,16 @@ export declare class CliEditor {
     }[];
     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;
 /**
@@ -29,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;
@@ -36,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

@@ -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.
@@ -110,6 +111,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,
@@ -117,4 +148,5 @@ export const editingMethods = {
     insertNewLine,
     deleteBackward,
     deleteForward,
+    handleAutoPair,
 };

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';
@@ -50,29 +52,38 @@ 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, () => {
                     // 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 +98,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');
+        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

@@ -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.
  */
@@ -74,6 +81,10 @@ 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';
         else
             keyName = key.sequence;
     }
@@ -118,6 +129,12 @@ 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) {
+    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.
@@ -175,10 +192,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)
@@ -202,6 +233,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:
@@ -238,11 +283,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.
@@ -429,4 +489,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.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cliedit",
-  "version": "0.1.2",
+  "version": "0.2.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",