minercon 3.0.0

package/out/historyStore.js

@@ -0,0 +1,126 @@
+"use strict";
+// src/historyStore.ts
+//
+// Command history: on-disk persistence (server-scoped, like
+// commandTreeCache.ts) — loaded once at session start to seed LineEditor's
+// in-memory history and rewritten each time a command is run — plus the pure
+// state/matching logic for Ctrl+R reverse history search, which operates on
+// that same in-memory list.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryStore = void 0;
+exports.searchHistory = searchHistory;
+exports.startHistorySearch = startHistorySearch;
+exports.setHistorySearchQuery = setHistorySearchQuery;
+exports.cycleHistorySearch = cycleHistorySearch;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class HistoryStore {
+    logger;
+    maxEntries;
+    file;
+    /** `maxEntries` mirrors LineEditor's in-memory cap — no point persisting more than it'll ever hold. */
+    constructor(cacheDir, serverHost, serverPort, logger, maxEntries = 100) {
+        this.logger = logger;
+        this.maxEntries = maxEntries;
+        this.file = path.join(cacheDir, `${serverHost}_${serverPort}_history.txt`);
+    }
+    /** Returns persisted entries (oldest-first), or `[]` if there's nothing usable to load. */
+    load() {
+        try {
+            if (!fs.existsSync(this.file)) {
+                return [];
+            }
+            const lines = fs.readFileSync(this.file, 'utf-8').split('\n');
+            if (lines.length > 0 && lines[lines.length - 1] === '') {
+                lines.pop();
+            }
+            return lines.slice(-this.maxEntries);
+        }
+        catch (error) {
+            this.logger.error(`Error loading command history: ${error}`);
+            return [];
+        }
+    }
+    /** Persists `entries` (oldest-first, one per line), overwriting whatever was there before. Newlines within an entry are stripped. */
+    save(entries) {
+        try {
+            const dir = path.dirname(this.file);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            const lines = entries.slice(-this.maxEntries).map((entry) => entry.replace(/[\r\n]/g, ''));
+            fs.writeFileSync(this.file, lines.map((line) => `${line}\n`).join(''));
+        }
+        catch (error) {
+            this.logger.error(`Error saving command history: ${error}`);
+        }
+    }
+}
+exports.HistoryStore = HistoryStore;
+/** Entries from `history` (oldest-first) containing `query` (case-insensitive), most-recently-used first, deduplicated. An empty query matches everything, so the list starts as "recent history, newest first". */
+function searchHistory(history, query) {
+    const lowerQuery = query.toLowerCase();
+    const seen = new Set();
+    const results = [];
+    for (let i = history.length - 1; i >= 0; i--) {
+        const entry = history[i];
+        if (seen.has(entry)) {
+            continue;
+        }
+        seen.add(entry);
+        if (entry.toLowerCase().includes(lowerQuery)) {
+            results.push(entry);
+        }
+    }
+    return results;
+}
+/** Enters search mode: empty query, recent history shown newest-first. */
+function startHistorySearch(history, originalLine) {
+    return { query: '', items: searchHistory(history, ''), selectedIndex: 0, originalLine };
+}
+/** Re-filters as the query changes (typing or backspacing), resetting to the best (first) match. */
+function setHistorySearchQuery(history, state, query) {
+    return { ...state, query, items: searchHistory(history, query), selectedIndex: 0 };
+}
+/** Moves the selection by `delta`, wrapping; a no-op when there's nothing to select. */
+function cycleHistorySearch(state, delta) {
+    if (state.items.length === 0) {
+        return state;
+    }
+    const selectedIndex = ((state.selectedIndex + delta) % state.items.length + state.items.length) % state.items.length;
+    return { ...state, selectedIndex };
+}
+//# sourceMappingURL=historyStore.js.map

package/out/lineEditor.js

@@ -0,0 +1,525 @@
+"use strict";
+// src/lineEditor.ts
+//
+// Owns the input line itself: the text, cursor position, selection range,
+// and command history, plus every operation that mutates them — character
+// insertion/deletion, cursor and selection movement, kill/yank-style word and
+// line edits, and history navigation. It also owns redrawing the line (with
+// or without selection highlighting) to the terminal.
+//
+// This is the "what does typing do to the buffer, and how does that get
+// painted" layer — it knows nothing about RCON, tab completion, or connection
+// state. Where it needs the host terminal to do something on its behalf (emit
+// ANSI, know the current prompt text, react to the line changing), it goes
+// through the small `LineEditorHost` interface below, so it stays testable
+// and reusable independent of `vscode.Pseudoterminal` plumbing.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineEditor = void 0;
+const ansi = __importStar(require("./ansi"));
+class LineEditor {
+    host;
+    maxHistorySize;
+    currentLine = '';
+    cursorPosition = 0;
+    // The active selection, or null when there's none. `anchor` is the fixed end
+    // (where the gesture started); `head` is the moving end, kept in step with the
+    // cursor. A collapsed selection (anchor === head) counts as none — see
+    // hasSelection.
+    selection = null;
+    history = [];
+    // Non-null while the user is navigating history; null when at the live line.
+    // Bundles the navigation index and the line saved on first Up-arrow so they
+    // stay in sync and can be reset atomically.
+    historyCursor = null;
+    constructor(host, maxHistorySize = 100) {
+        this.host = host;
+        this.maxHistorySize = maxHistorySize;
+    }
+    get line() {
+        return this.currentLine;
+    }
+    get cursor() {
+        return this.cursorPosition;
+    }
+    // ── selection ──
+    hasSelection() {
+        return this.selection !== null && this.selection.anchor !== this.selection.head;
+    }
+    clearSelection() {
+        this.selection = null;
+    }
+    /** The selection's bounds as `[start, end)`, low-to-high — only valid when `hasSelection()`. */
+    selectionRange() {
+        const { anchor, head } = this.selection;
+        return { start: Math.min(anchor, head), end: Math.max(anchor, head) };
+    }
+    getSelectedText() {
+        if (!this.hasSelection()) {
+            return '';
+        }
+        const { start, end } = this.selectionRange();
+        return this.currentLine.slice(start, end);
+    }
+    deleteSelection() {
+        if (!this.hasSelection()) {
+            return;
+        }
+        this.deleteSelectionInternal();
+        this.host.onLineChanged(this.currentLine);
+    }
+    /** `deleteSelection` without the host notification — for compound edits (insertText) that notify once themselves, with the final line. */
+    deleteSelectionInternal() {
+        if (!this.hasSelection()) {
+            return;
+        }
+        const { start, end } = this.selectionRange();
+        this.currentLine = this.currentLine.slice(0, start) + this.currentLine.slice(end);
+        this.cursorPosition = start;
+        this.clearSelection();
+    }
+    /**
+     * Extend (or begin) the selection so its moving end lands at `newPos`: anchor
+     * at the current cursor if there isn't a selection yet, then move both the
+     * cursor and the selection's moving end to `newPos` and repaint. Every
+     * select* operation is this — they differ only in how they pick `newPos`.
+     */
+    extendSelectionTo(newPos) {
+        if (!this.hasSelection()) {
+            this.selection = { anchor: this.cursorPosition, head: this.cursorPosition };
+        }
+        this.cursorPosition = newPos;
+        this.selection.head = newPos;
+        this.redraw();
+    }
+    selectLeft() {
+        if (this.cursorPosition > 0) {
+            this.extendSelectionTo(this.cursorPosition - 1);
+        }
+    }
+    selectRight() {
+        if (this.cursorPosition < this.currentLine.length) {
+            this.extendSelectionTo(this.cursorPosition + 1);
+        }
+    }
+    selectWordLeft() {
+        this.extendSelectionTo(this.findWordLeft());
+    }
+    selectWordRight() {
+        this.extendSelectionTo(this.findWordRight());
+    }
+    selectToStart() {
+        if (this.cursorPosition > 0) {
+            this.extendSelectionTo(0);
+        }
+    }
+    selectToEnd() {
+        if (this.cursorPosition < this.currentLine.length) {
+            this.extendSelectionTo(this.currentLine.length);
+        }
+    }
+    // ── cursor movement ──
+    moveLeft() {
+        const hadSelection = this.hasSelection();
+        if (hadSelection) {
+            this.clearSelection();
+        }
+        if (this.cursorPosition > 0) {
+            this.cursorPosition--;
+            if (hadSelection) {
+                this.redraw();
+            }
+            else {
+                this.host.write('\x1b[D');
+            }
+        }
+        else if (hadSelection) {
+            this.redraw();
+        }
+    }
+    moveRight() {
+        const hadSelection = this.hasSelection();
+        if (hadSelection) {
+            this.clearSelection();
+        }
+        if (this.cursorPosition < this.currentLine.length) {
+            this.cursorPosition++;
+            if (hadSelection) {
+                this.redraw();
+            }
+            else {
+                this.host.write('\x1b[C');
+            }
+        }
+        else if (hadSelection) {
+            this.redraw();
+        }
+    }
+    moveWordLeft() {
+        const newPos = this.findWordLeft();
+        if (newPos !== this.cursorPosition) {
+            this.clearSelection();
+            this.cursorPosition = newPos;
+            this.redraw();
+        }
+    }
+    moveWordRight() {
+        const newPos = this.findWordRight();
+        if (newPos !== this.cursorPosition) {
+            this.clearSelection();
+            this.cursorPosition = newPos;
+            this.redraw();
+        }
+    }
+    moveToStart() {
+        const hadSelection = this.hasSelection();
+        this.clearSelection();
+        if (this.cursorPosition > 0) {
+            this.cursorPosition = 0;
+            if (hadSelection) {
+                this.redraw();
+            }
+            else {
+                this.host.write('\r');
+                this.host.write(this.host.promptText());
+                this.host.write(this.currentLine);
+                const moveBack = this.currentLine.length;
+                if (moveBack > 0) {
+                    this.host.write('\x1b[' + moveBack + 'D');
+                }
+            }
+        }
+        else if (hadSelection) {
+            this.redraw();
+        }
+    }
+    moveToEnd() {
+        const hadSelection = this.hasSelection();
+        this.clearSelection();
+        const moveForward = this.currentLine.length - this.cursorPosition;
+        if (moveForward > 0) {
+            this.cursorPosition = this.currentLine.length;
+            if (hadSelection) {
+                this.redraw();
+            }
+            else {
+                this.host.write('\x1b[' + moveForward + 'C');
+            }
+        }
+        else if (hadSelection) {
+            this.redraw();
+        }
+    }
+    // ── editing ──
+    insertText(text) {
+        if (this.host.consumeOutputArtifacts()) {
+            this.host.write('\x1b[2K');
+            this.host.write('\r');
+            this.host.write(this.host.promptText());
+            this.host.write(this.currentLine.substring(0, this.cursorPosition));
+        }
+        if (this.hasSelection()) {
+            this.deleteSelectionInternal();
+        }
+        const filteredText = text.replace(/[\x00-\x08\x0a-\x1f\x7f]/g, '');
+        if (filteredText.length === 0) {
+            return;
+        }
+        this.currentLine = this.currentLine.slice(0, this.cursorPosition) +
+            filteredText +
+            this.currentLine.slice(this.cursorPosition);
+        const restOfLine = this.currentLine.slice(this.cursorPosition + filteredText.length);
+        this.host.write(filteredText + restOfLine);
+        this.cursorPosition += filteredText.length;
+        if (restOfLine.length > 0) {
+            this.host.write('\x1b[' + restOfLine.length + 'D');
+        }
+        this.clearSelection();
+        this.host.onLineChanged(this.currentLine);
+    }
+    handleBackspace() {
+        if (this.hasSelection()) {
+            this.deleteSelection();
+            this.redraw();
+        }
+        else if (this.cursorPosition > 0) {
+            this.currentLine = this.currentLine.slice(0, this.cursorPosition - 1) +
+                this.currentLine.slice(this.cursorPosition);
+            this.cursorPosition--;
+            this.host.write('\b');
+            const restOfLine = this.currentLine.slice(this.cursorPosition);
+            this.host.write(restOfLine + ' ');
+            this.host.write('\x1b[' + (restOfLine.length + 1) + 'D');
+            this.host.onLineChanged(this.currentLine);
+        }
+    }
+    deleteForward() {
+        if (this.hasSelection()) {
+            this.deleteSelection();
+            this.redraw();
+        }
+        else if (this.cursorPosition < this.currentLine.length) {
+            this.currentLine = this.currentLine.slice(0, this.cursorPosition) +
+                this.currentLine.slice(this.cursorPosition + 1);
+            const restOfLine = this.currentLine.slice(this.cursorPosition);
+            this.host.write(restOfLine + ' ');
+            this.host.write('\x1b[' + (restOfLine.length + 1) + 'D');
+            this.host.onLineChanged(this.currentLine);
+        }
+    }
+    /**
+     * Repaint the line after a kill: step the cursor `cursorShiftLeft` columns
+     * left to the new insertion point (for backward kills), clear to end of line,
+     * then write the surviving `tail` and step back onto its start. Shared by all
+     * four kill operations — they differ only in `tail` and the shift.
+     */
+    repaintAfterKill(tail, cursorShiftLeft = 0) {
+        if (cursorShiftLeft > 0) {
+            this.host.write('\x1b[' + cursorShiftLeft + 'D');
+        }
+        this.host.write('\x1b[K');
+        this.host.write(tail);
+        if (tail.length > 0) {
+            this.host.write('\x1b[' + tail.length + 'D');
+        }
+    }
+    // emacs: unix-line-discard — kill from cursor to start of line
+    killToStart() {
+        if (this.cursorPosition > 0) {
+            const killed = this.currentLine.slice(0, this.cursorPosition);
+            const afterCursor = this.currentLine.slice(this.cursorPosition);
+            this.currentLine = afterCursor;
+            this.cursorPosition = 0;
+            this.clearSelection();
+            this.repaintAfterKill(afterCursor, killed.length);
+            this.host.onLineChanged(this.currentLine);
+            return killed;
+        }
+        return '';
+    }
+    // emacs: kill-line — kill from cursor to end of line
+    killToEnd() {
+        if (this.cursorPosition < this.currentLine.length) {
+            const killed = this.currentLine.slice(this.cursorPosition);
+            this.currentLine = this.currentLine.slice(0, this.cursorPosition);
+            this.clearSelection();
+            this.repaintAfterKill('');
+            this.host.onLineChanged(this.currentLine);
+            return killed;
+        }
+        return '';
+    }
+    // emacs: backward-kill-word (Ctrl+W / Alt+Backspace)
+    killWordBack() {
+        if (this.cursorPosition > 0) {
+            const beforeCursor = this.currentLine.slice(0, this.cursorPosition);
+            const afterCursor = this.currentLine.slice(this.cursorPosition);
+            const newPos = this.findWordLeft();
+            const killed = beforeCursor.slice(newPos);
+            this.currentLine = beforeCursor.slice(0, newPos) + afterCursor;
+            this.cursorPosition = newPos;
+            this.clearSelection();
+            this.repaintAfterKill(afterCursor, killed.length);
+            this.host.onLineChanged(this.currentLine);
+            return killed;
+        }
+        return '';
+    }
+    // emacs: kill-word (Alt+D) — delete from cursor to end of the word forward
+    killWordForward() {
+        const newPos = this.findWordRight();
+        if (newPos > this.cursorPosition) {
+            const beforeCursor = this.currentLine.slice(0, this.cursorPosition);
+            const killed = this.currentLine.slice(this.cursorPosition, newPos);
+            const afterDeleted = this.currentLine.slice(newPos);
+            this.currentLine = beforeCursor + afterDeleted;
+            this.clearSelection();
+            this.repaintAfterKill(afterDeleted);
+            this.host.onLineChanged(this.currentLine);
+            return killed;
+        }
+        return '';
+    }
+    // emacs: transpose-chars — swap the two characters around the cursor
+    transposeChars() {
+        if (this.currentLine.length >= 2 && this.cursorPosition > 0) {
+            // At end of line, transpose the last two characters; otherwise transpose
+            // the character before the cursor with the one at the cursor.
+            const pos = Math.min(this.cursorPosition, this.currentLine.length - 1);
+            const chars = [...this.currentLine];
+            [chars[pos - 1], chars[pos]] = [chars[pos], chars[pos - 1]];
+            this.currentLine = chars.join('');
+            this.cursorPosition = Math.min(pos + 1, this.currentLine.length);
+            this.clearSelection();
+            this.redraw();
+            this.host.onLineChanged(this.currentLine);
+        }
+    }
+    // ── whole-line operations ──
+    redraw() {
+        // Move cursor to start of line, clear it, redraw the prompt
+        this.host.write('\r');
+        this.host.write('\x1b[K');
+        this.host.write(this.host.promptText());
+        if (!this.hasSelection()) {
+            this.host.write(this.currentLine);
+        }
+        else {
+            const { start, end } = this.selectionRange();
+            if (start > 0) {
+                this.host.write(this.currentLine.slice(0, start));
+            }
+            this.host.write(ansi.REVERSE + this.currentLine.slice(start, end) + ansi.REVERSE_OFF);
+            if (end < this.currentLine.length) {
+                this.host.write(this.currentLine.slice(end));
+            }
+        }
+        if (this.currentLine.length > this.cursorPosition) {
+            const moveBack = this.currentLine.length - this.cursorPosition;
+            this.host.write('\x1b[' + moveBack + 'D');
+        }
+    }
+    /** Resets the line/cursor/selection to empty without writing anything — for callers (like Enter) that print their own newline and redraw the prompt themselves. */
+    resetLine() {
+        this.currentLine = '';
+        this.cursorPosition = 0;
+        this.clearSelection();
+    }
+    clearAndReset() {
+        this.host.beforeLineCleared();
+        this.host.write('\r');
+        this.host.write('\x1b[K');
+        this.currentLine = '';
+        this.cursorPosition = 0;
+        this.clearSelection();
+        this.host.onLineChanged('');
+    }
+    /** Replaces the line wholesale (tab-completion splices, history recall, restore-on-escape) — sets the cursor to the end and redraws from scratch. */
+    replaceLine(newLine) {
+        this.host.write('\r');
+        this.host.write('\x1b[K');
+        this.host.write(this.host.promptText());
+        this.host.write(newLine);
+        this.currentLine = newLine;
+        this.cursorPosition = newLine.length;
+        this.clearSelection();
+    }
+    // ── history ──
+    /** Command history, oldest-first — e.g. for Ctrl+R search or persisting to disk. */
+    get historyEntries() {
+        return this.history;
+    }
+    /** Seeds history (oldest-first) from persisted entries, e.g. loaded from disk at session start. Replaces any existing in-memory history. */
+    loadHistory(entries) {
+        this.history = entries.slice(-this.maxHistorySize);
+    }
+    pushHistory(command) {
+        if (this.history.length === 0 || this.history[this.history.length - 1] !== command) {
+            this.history.push(command);
+            if (this.history.length > this.maxHistorySize) {
+                this.history.shift();
+            }
+        }
+    }
+    navigateHistory(direction) {
+        if (this.history.length === 0) {
+            return;
+        }
+        if (direction === 'up') {
+            if (this.historyCursor === null) {
+                this.historyCursor = { index: 0, savedLine: this.currentLine };
+                this.replaceLine(this.history[this.history.length - 1]);
+            }
+            else if (this.historyCursor.index < this.history.length - 1) {
+                this.historyCursor.index++;
+                this.replaceLine(this.history[this.history.length - 1 - this.historyCursor.index]);
+            }
+        }
+        else {
+            if (this.historyCursor === null) {
+                return;
+            }
+            if (this.historyCursor.index > 0) {
+                this.historyCursor.index--;
+                this.replaceLine(this.history[this.history.length - 1 - this.historyCursor.index]);
+            }
+            else {
+                const { savedLine } = this.historyCursor;
+                this.historyCursor = null;
+                this.replaceLine(savedLine);
+            }
+        }
+    }
+    resetHistoryCursor() {
+        this.historyCursor = null;
+    }
+    // ── word-boundary helpers ──
+    findWordLeft() {
+        if (this.cursorPosition === 0) {
+            return 0;
+        }
+        let pos = this.cursorPosition - 1;
+        // Skip whitespace
+        while (pos > 0 && this.currentLine[pos] === ' ') {
+            pos--;
+        }
+        // Skip word characters
+        while (pos > 0 && this.currentLine[pos - 1] !== ' ') {
+            pos--;
+        }
+        return pos;
+    }
+    findWordRight() {
+        if (this.cursorPosition >= this.currentLine.length) {
+            return this.currentLine.length;
+        }
+        let pos = this.cursorPosition;
+        // If we're in whitespace, skip to next word
+        if (this.currentLine[pos] === ' ') {
+            while (pos < this.currentLine.length && this.currentLine[pos] === ' ') {
+                pos++;
+            }
+        }
+        else {
+            // Skip current word
+            while (pos < this.currentLine.length && this.currentLine[pos] !== ' ') {
+                pos++;
+            }
+        }
+        return pos;
+    }
+}
+exports.LineEditor = LineEditor;
+//# sourceMappingURL=lineEditor.js.map