cliedit 0.1.0

package/dist/editor.history.js

@@ -0,0 +1,67 @@
+// src/editor.history.ts
+/**
+ * Methods related to Undo/Redo operations.
+ */
+/**
+ * Gets the current document state (content and cursor position).
+ */
+function getCurrentState() {
+    return {
+        // Use JSON to deep clone the lines array
+        lines: JSON.parse(JSON.stringify(this.lines)),
+        cursorX: this.cursorX,
+        cursorY: this.cursorY,
+    };
+}
+/**
+ * Saves the current state to the history manager.
+ */
+function saveState(initial = false) {
+    // Only save if content is different from the last state, 
+    // but ALWAYS save the initial state.
+    this.history.saveState(this.getCurrentState());
+}
+/**
+ * Loads a document state from the history manager.
+ */
+function loadState(state) {
+    this.lines = state.lines;
+    this.cursorX = state.cursorX;
+    this.cursorY = state.cursorY;
+    this.adjustCursorPosition();
+}
+/**
+ * Performs an undo operation.
+ */
+function undo() {
+    const state = this.history.undo(this.getCurrentState());
+    if (state) {
+        this.loadState(state);
+        this.setDirty();
+        this.setStatusMessage('Undo successful');
+    }
+    else {
+        this.setStatusMessage('Already at oldest change');
+    }
+}
+/**
+ * Performs a redo operation.
+ */
+function redo() {
+    const state = this.history.redo(this.getCurrentState());
+    if (state) {
+        this.loadState(state);
+        this.setDirty();
+        this.setStatusMessage('Redo successful');
+    }
+    else {
+        this.setStatusMessage('Already at newest change');
+    }
+}
+export const historyMethods = {
+    getCurrentState,
+    saveState,
+    loadState,
+    undo,
+    redo,
+};

package/dist/editor.io.d.ts

@@ -0,0 +1,17 @@
+import { CliEditor } from './editor.js';
+/**
+ * Methods related to File I/O and document state management (dirty flag).
+ */
+/**
+ * Sets the document state to 'dirty' (unsaved changes).
+ */
+declare function setDirty(this: CliEditor): void;
+/**
+ * Saves the current document content to the file path.
+ */
+declare function saveFile(this: CliEditor): Promise<void>;
+export declare const ioMethods: {
+    setDirty: typeof setDirty;
+    saveFile: typeof saveFile;
+};
+export {};

package/dist/editor.io.js

@@ -0,0 +1,30 @@
+// src/editor.io.ts
+import { promises as fs } from 'fs';
+/**
+ * Methods related to File I/O and document state management (dirty flag).
+ */
+/**
+ * Sets the document state to 'dirty' (unsaved changes).
+ */
+function setDirty() {
+    this.isDirty = true;
+}
+/**
+ * Saves the current document content to the file path.
+ */
+async function saveFile() {
+    const content = this.lines.join('\n');
+    try {
+        await fs.writeFile(this.filepath, content, 'utf-8');
+        this.isDirty = false; // Reset dirty flag
+        this.quitConfirm = false; // Reset quit confirmation
+        this.setStatusMessage(`Saved: ${this.filepath}`, 2000);
+    }
+    catch (err) {
+        this.setStatusMessage(`Save Error: ${err.message}`);
+    }
+}
+export const ioMethods = {
+    setDirty,
+    saveFile,
+};

package/dist/editor.js

@@ -0,0 +1,121 @@
+import keypress from 'keypress';
+import { ANSI } from './constants.js';
+import { HistoryManager } from './history.js';
+// Import all functional modules
+import { editingMethods } from './editor.editing.js';
+import { clipboardMethods } from './editor.clipboard.js';
+import { navigationMethods } from './editor.navigation.js';
+import { renderingMethods } from './editor.rendering.js';
+import { searchMethods } from './editor.search.js';
+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';
+/**
+ * Main editor class managing application state, TTY interaction, and rendering.
+ */
+export class CliEditor {
+    constructor(initialContent, filepath) {
+        this.isDirty = false;
+        this.cursorX = 0;
+        this.cursorY = 0;
+        this.selectionAnchor = null;
+        this.rowOffset = 0;
+        this.screenRows = 0;
+        this.screenCols = 0;
+        this.gutterWidth = 5;
+        this.screenStartRow = 1;
+        this.visualRows = [];
+        this.mode = 'edit';
+        this.statusMessage = DEFAULT_STATUS;
+        this.statusTimeout = null;
+        this.isMessageCustom = false;
+        this.quitConfirm = false;
+        this.DEFAULT_STATUS = DEFAULT_STATUS;
+        this.searchQuery = '';
+        this.searchResults = [];
+        this.searchResultIndex = -1;
+        this.isCleanedUp = false;
+        this.resolvePromise = null;
+        this.rejectPromise = null;
+        // State flag indicating the editor is in the process of closing (prevents input/render race)
+        this.isExiting = false;
+        this.lines = initialContent.split('\n');
+        if (this.lines.length === 0) {
+            this.lines = [''];
+        }
+        this.filepath = filepath;
+        this.history = new HistoryManager();
+        this.saveState(true);
+    }
+    // --- Lifecycle Methods ---
+    run() {
+        this.setupTerminal();
+        this.render();
+        return new Promise((resolve, reject) => {
+            const performCleanup = (callback) => {
+                if (this.isCleanedUp) {
+                    if (callback)
+                        callback();
+                    return;
+                }
+                // 1. Remove listeners immediately
+                process.stdin.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();
+                    this.isCleanedUp = true;
+                    if (callback)
+                        callback();
+                });
+            };
+            this.resolvePromise = (value) => {
+                performCleanup(() => resolve(value));
+            };
+            this.rejectPromise = (reason) => {
+                performCleanup(() => reject(reason));
+            };
+        });
+    }
+    setupTerminal() {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new Error('Editor requires a TTY environment.');
+        }
+        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');
+        // Setup keypress listener
+        keypress(process.stdin);
+        process.stdin.on('keypress', this.handleKeypressEvent.bind(this));
+        process.stdout.on('resize', this.handleResize.bind(this));
+    }
+    handleResize() {
+        this.updateScreenSize();
+        this.recalculateVisualRows();
+        this.render();
+    }
+    updateScreenSize() {
+        this.screenRows = process.stdout.rows - 2;
+        this.screenCols = process.stdout.columns;
+        this.screenStartRow = 1;
+    }
+}
+// --- "Mixin" magic: Assigning all methods to the prototype ---
+Object.assign(CliEditor.prototype, editingMethods);
+Object.assign(CliEditor.prototype, clipboardMethods);
+Object.assign(CliEditor.prototype, navigationMethods);
+Object.assign(CliEditor.prototype, renderingMethods);
+Object.assign(CliEditor.prototype, searchMethods);
+Object.assign(CliEditor.prototype, historyMethods);
+Object.assign(CliEditor.prototype, ioMethods);
+Object.assign(CliEditor.prototype, keyHandlingMethods);
+Object.assign(CliEditor.prototype, selectionMethods);

package/dist/editor.keys.d.ts

@@ -0,0 +1,21 @@
+import type { KeypressEvent } from 'keypress';
+declare module 'keypress' {
+    interface KeypressEvent {
+        name?: string;
+        ctrl: boolean;
+        meta: boolean;
+        shift: boolean;
+        sequence: string;
+    }
+}
+export type TKeyHandlingMethods = {
+    handleKeypressEvent: (ch: string, key: KeypressEvent) => void;
+    handleEditKeys: (key: string) => boolean;
+    handleSearchKeys: (key: string) => void;
+    handleCtrlQ: () => void;
+    handleCopy: () => Promise<void>;
+    handleCharacterKey: (ch: string) => void;
+    cutSelection: () => Promise<void>;
+    handleSave: () => Promise<void>;
+};
+export declare const keyHandlingMethods: TKeyHandlingMethods;

package/dist/editor.keys.js

@@ -0,0 +1,311 @@
+// src/editor.keys.ts
+import { KEYS } from './constants.js';
+/**
+ * Main router for standardized keypress events from the 'keypress' library.
+ */
+function handleKeypressEvent(ch, key) {
+    // CRASH FIX: If the editor is already closing, ignore all input.
+    if (this.isExiting) {
+        return;
+    }
+    // CRASH FIX: Handle case where 'key' is undefined (a normal character key)
+    if (!key) {
+        if (ch && ch >= ' ' && ch <= '~') {
+            this.handleCharacterKey(ch);
+            this.recalculateVisualRows();
+            this.render();
+        }
+        return;
+    }
+    // --- From here, 'key' object is guaranteed to exist ---
+    let keyName = undefined;
+    let edited = false;
+    // 1. Map Control sequences (Ctrl+Arrow for selection)
+    if (key.ctrl) {
+        if (key.name === 'up')
+            keyName = KEYS.CTRL_ARROW_UP;
+        else if (key.name === 'down')
+            keyName = KEYS.CTRL_ARROW_DOWN;
+        else if (key.name === 'left')
+            keyName = KEYS.CTRL_ARROW_LEFT;
+        else if (key.name === 'right')
+            keyName = KEYS.CTRL_ARROW_RIGHT;
+        else
+            keyName = key.sequence; // Use sequence for Ctrl+S, Ctrl+C, etc.
+    }
+    else {
+        // 2. (FIXED) Map standard navigation keys (Arrow, Home, End)
+        if (key.name === 'up')
+            keyName = KEYS.ARROW_UP;
+        else if (key.name === 'down')
+            keyName = KEYS.ARROW_DOWN;
+        else if (key.name === 'left')
+            keyName = KEYS.ARROW_LEFT;
+        else if (key.name === 'right')
+            keyName = KEYS.ARROW_RIGHT;
+        else if (key.name === 'home')
+            keyName = KEYS.HOME;
+        else if (key.name === 'end')
+            keyName = KEYS.END;
+        else if (key.name === 'pageup')
+            keyName = KEYS.PAGE_UP;
+        else if (key.name === 'pagedown')
+            keyName = KEYS.PAGE_DOWN;
+        else if (key.name === 'delete')
+            keyName = KEYS.DELETE;
+        else if (key.name === 'backspace')
+            keyName = KEYS.BACKSPACE;
+        else if (key.name === 'return')
+            keyName = KEYS.ENTER;
+        else if (key.name === 'tab')
+            keyName = KEYS.TAB;
+        else
+            keyName = key.sequence; // Fallback
+    }
+    // 3. (FIXED) Handle printable characters immediately
+    // This was the source of the "no typing" bug.
+    // We must check for characters *before* routing to handleEditKeys.
+    if (keyName && keyName.length === 1 && keyName >= ' ' && keyName <= '~' && !key.ctrl && !key.meta) {
+        this.handleCharacterKey(keyName);
+        this.recalculateVisualRows();
+        this.render();
+        return;
+    }
+    // 4. Mode Routing (If it's not a character, it's a command)
+    if (this.mode === 'search') {
+        this.handleSearchKeys(keyName || ch);
+    }
+    else {
+        // 5. Handle Selection Keys (Ctrl+Arrow)
+        switch (keyName) {
+            case KEYS.CTRL_ARROW_UP:
+                this.startOrUpdateSelection();
+                this.moveCursorVisually(-1);
+                this.render();
+                return;
+            case KEYS.CTRL_ARROW_DOWN:
+                this.startOrUpdateSelection();
+                this.moveCursorVisually(1);
+                this.render();
+                return;
+            case KEYS.CTRL_ARROW_LEFT:
+                this.startOrUpdateSelection();
+                this.moveCursorLogically(-1);
+                this.render();
+                return;
+            case KEYS.CTRL_ARROW_RIGHT:
+                this.startOrUpdateSelection();
+                this.moveCursorLogically(1);
+                this.render();
+                return;
+        }
+        // 6. Handle all other command keys (Editing/Commands)
+        edited = this.handleEditKeys(keyName || ch);
+    }
+    // 7. State Update and Render
+    if (edited) {
+        this.saveState();
+        this.recalculateVisualRows();
+    }
+    if (!this.isExiting) {
+        this.render();
+    }
+}
+/**
+ * Handles all command keys in 'edit' mode.
+ * Returns true if content was modified.
+ */
+function handleEditKeys(key) {
+    // (FIXED) Removed the guard clause that was blocking typing.
+    // if (key.length === 1 && key >= ' ' && key <= '~') {
+    //     return false;
+    // }
+    // Cancel selection on normal navigation
+    const isNavigation = [
+        KEYS.ARROW_UP, KEYS.ARROW_DOWN, KEYS.ARROW_LEFT, KEYS.ARROW_RIGHT,
+        KEYS.HOME, KEYS.END, KEYS.PAGE_UP, KEYS.PAGE_DOWN
+    ].includes(key);
+    if (isNavigation) {
+        this.cancelSelection();
+        if (this.isMessageCustom) {
+            this.setStatusMessage(this.DEFAULT_STATUS, 0);
+        }
+    }
+    // Commands that return Promises must be wrapped in a sync call here
+    switch (key) {
+        // --- Exit / Save ---
+        case KEYS.CTRL_Q:
+            this.handleCtrlQ();
+            return false;
+        case KEYS.CTRL_S:
+            this.handleSave();
+            return false;
+        case KEYS.CTRL_C:
+            this.handleCopy();
+            return false;
+        // --- Navigation ---
+        case KEYS.ARROW_UP:
+            this.moveCursorVisually(-1);
+            return false;
+        case KEYS.ARROW_DOWN:
+            this.moveCursorVisually(1);
+            return false;
+        case KEYS.ARROW_LEFT:
+            this.moveCursorLogically(-1);
+            return false;
+        case KEYS.ARROW_RIGHT:
+            this.moveCursorLogically(1);
+            return false;
+        case KEYS.HOME:
+            this.cursorX = this.findVisualRowStart();
+            return false;
+        case KEYS.END:
+            this.cursorX = this.findVisualRowEnd();
+            return false;
+        case KEYS.PAGE_UP:
+            this.moveCursorVisually(-this.screenRows);
+            return false;
+        case KEYS.PAGE_DOWN:
+            this.moveCursorVisually(this.screenRows);
+            return false;
+        // --- Editing ---
+        case KEYS.ENTER:
+            this.insertNewLine();
+            return true;
+        case KEYS.BACKSPACE:
+            if (this.selectionAnchor)
+                this.deleteSelectedText();
+            else
+                this.deleteBackward();
+            return true;
+        case KEYS.DELETE:
+            if (this.selectionAnchor)
+                this.deleteSelectedText();
+            else
+                this.deleteForward();
+            return true;
+        case KEYS.TAB:
+            this.insertSoftTab();
+            return true;
+        // --- Search & History ---
+        case KEYS.CTRL_W:
+            this.enterSearchMode();
+            return false;
+        case KEYS.CTRL_G:
+            this.findNext();
+            return false;
+        case KEYS.CTRL_Z:
+            this.undo();
+            return true;
+        case KEYS.CTRL_Y:
+            this.redo();
+            return true;
+        // --- Clipboard ---
+        case KEYS.CTRL_K: // Cut Line (Traditional)
+            this.cutLine();
+            return true;
+        case KEYS.CTRL_U: // Paste Line (Traditional)
+            this.pasteLine();
+            return true;
+        case KEYS.CTRL_X: // Cut Selection
+            this.cutSelection(); // Synchronous wrapper for cutSelectionAsync
+            return true;
+        case KEYS.CTRL_V: // Paste Selection
+            this.pasteSelection();
+            return true;
+        default:
+            return false;
+    }
+}
+/**
+ * Handles insertion of a character, deleting selection first if it exists.
+ */
+function handleCharacterKey(ch) {
+    if (this.selectionAnchor) {
+        this.deleteSelectedText();
+    }
+    this.insertCharacter(ch);
+    this.setDirty();
+}
+/**
+ * Handles Ctrl+Q (Quit) sequence.
+ */
+function handleCtrlQ() {
+    if (this.isDirty && !this.quitConfirm) {
+        this.quitConfirm = true;
+        this.setStatusMessage('Warning: Unsaved changes! Press Ctrl+Q again to quit.');
+        setTimeout(() => { this.quitConfirm = false; }, 3000);
+        return;
+    }
+    this.isExiting = true;
+    this.resolvePromise?.({ saved: false, content: this.lines.join('\n') });
+}
+/**
+ * Handles Ctrl+C (Copy Selection or All) sequence.
+ */
+async function handleCopy() {
+    let textToCopy = '';
+    if (this.selectionAnchor) {
+        textToCopy = this.getSelectedText();
+        this.setStatusMessage('Selection copied!', 1000);
+    }
+    else {
+        // Copy entire file content if nothing is selected (clean copy)
+        textToCopy = this.lines.join('\n');
+        this.setStatusMessage('Copied all text!', 1000);
+    }
+    await this.setClipboard(textToCopy);
+}
+/**
+ * Handles synchronous call for cutting selection (used by Ctrl+X).
+ */
+async function cutSelection() {
+    await this.cutSelectionAsync();
+}
+/**
+ * Helper function to handle the final save and exit sequence (used by Ctrl+S).
+ */
+async function handleSave() {
+    await this.saveFile(); // Save file (sets isDirty=false)
+    // Only resolve if not already exiting 
+    if (!this.isExiting) {
+        this.isExiting = true;
+        this.resolvePromise?.({ saved: true, content: this.lines.join('\n') });
+    }
+}
+/**
+ * Handles Search Mode input keys.
+ */
+function handleSearchKeys(key) {
+    switch (key) {
+        case KEYS.ENTER:
+            this.executeSearch();
+            this.mode = 'edit';
+            this.findNext();
+            break;
+        case KEYS.ESCAPE:
+        case KEYS.CTRL_C:
+        case KEYS.CTRL_Q:
+            this.mode = 'edit';
+            this.searchQuery = '';
+            this.setStatusMessage('Search cancelled');
+            break;
+        case KEYS.BACKSPACE:
+            this.searchQuery = this.searchQuery.slice(0, -1);
+            break;
+        default:
+            if (key.length === 1 && key >= ' ' && key <= '~') {
+                this.searchQuery += key;
+            }
+    }
+}
+export const keyHandlingMethods = {
+    handleKeypressEvent,
+    handleEditKeys,
+    handleSearchKeys,
+    handleCtrlQ,
+    handleCopy,
+    handleCharacterKey,
+    cutSelection,
+    handleSave,
+};

package/dist/editor.navigation.d.ts

@@ -0,0 +1,42 @@
+import { CliEditor } from './editor.js';
+/**
+ * Methods related to cursor movement and viewport scrolling.
+ */
+/**
+ * Finds the index of the visual row that currently contains the cursor.
+ */
+declare function findCurrentVisualRowIndex(this: CliEditor): number;
+/**
+ * Moves the cursor one position left or right (logically, wrapping lines).
+ */
+declare function moveCursorLogically(this: CliEditor, dx: number): void;
+/**
+ * Moves the cursor up or down by visual rows (dy).
+ */
+declare function moveCursorVisually(this: CliEditor, dy: number): void;
+/**
+ * Finds the start of the current visual line (Home key behavior).
+ */
+declare function findVisualRowStart(this: CliEditor): number;
+/**
+ * Finds the end of the current visual line (End key behavior).
+ */
+declare function findVisualRowEnd(this: CliEditor): number;
+/**
+ * Clamps the cursor position to valid coordinates and ensures it stays within line bounds.
+ */
+declare function adjustCursorPosition(this: CliEditor): void;
+/**
+ * Scrolls the viewport to keep the cursor visible.
+ */
+declare function scroll(this: CliEditor): void;
+export declare const navigationMethods: {
+    findCurrentVisualRowIndex: typeof findCurrentVisualRowIndex;
+    moveCursorLogically: typeof moveCursorLogically;
+    moveCursorVisually: typeof moveCursorVisually;
+    findVisualRowStart: typeof findVisualRowStart;
+    findVisualRowEnd: typeof findVisualRowEnd;
+    adjustCursorPosition: typeof adjustCursorPosition;
+    scroll: typeof scroll;
+};
+export {};