@semalt-ai/code 1.7.0 → 1.8.0

package/lib/ui/input-field.js

@@ -0,0 +1,1176 @@
+'use strict';
+
+const EventEmitter = require('events');
+const readline = require('readline');
+
+const { RST, DIM, FG_CYAN, FG_GREEN, FG_YELLOW } = require('./ansi');
+
+const SLASH_CMDS = [
+  '/help','/file','/new','/model','/models','/shell','/compact',
+  '/clear','/approve','/config','/history','/login','/whoami','/logout','/chats',
+];
+
+// ─── Key sequence parser ──────────────────────────────────────────────────────
+
+function parseKeySequence(buf) {
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+  if (!b.length) return null;
+  const b0 = b[0];
+
+  const SINGLE = {
+    0x7f:'backspace', 0x08:'backspace', 0x0d:'enter', 0x0a:'enter',
+    0x09:'tab', 0x01:'ctrl+a', 0x02:'ctrl+b', 0x05:'ctrl+e',
+    0x06:'ctrl+f', 0x07:'ctrl+g', 0x0b:'ctrl+k', 0x0e:'ctrl+n',
+    0x10:'ctrl+p', 0x12:'ctrl+r', 0x14:'ctrl+t', 0x15:'ctrl+u',
+    0x17:'ctrl+w', 0x0c:'ctrl+l', 0x03:'ctrl+c', 0x04:'ctrl+d', 0x0f:'ctrl+o',
+  };
+  if (SINGLE[b0]) return { key: SINGLE[b0], len: 1 };
+
+  if (b0 !== 0x1b) return null; // printable — caller handles
+
+  const INCOMPLETE = { key: null, len: 0, incomplete: true };
+  if (b.length === 1) return { key: 'escape', len: 1, incomplete: true };
+
+  const b1 = b[1];
+  if (b1 === 0x62) return { key: 'alt+b', len: 2 };
+  if (b1 === 0x66) return { key: 'alt+f', len: 2 };
+  if (b1 === 0x0d) return { key: 'shift+enter', len: 2 }; // ESC+CR (\x1b\r)
+
+  if (b1 === 0x5b) { // CSI '['
+    if (b.length < 3) return INCOMPLETE;
+    const b2 = b[2];
+    if (b2 === 0x41) return { key: 'up',    len: 3 };
+    if (b2 === 0x42) return { key: 'down',  len: 3 };
+    if (b2 === 0x43) return { key: 'right', len: 3 };
+    if (b2 === 0x44) return { key: 'left',  len: 3 };
+    if (b2 === 0x48) return { key: 'home',  len: 3 };
+    if (b2 === 0x46) return { key: 'end',   len: 3 };
+
+    if (b2 === 0x33 || b2 === 0x35 || b2 === 0x36) {
+      if (b.length < 4) return INCOMPLETE;
+      if (b[3] === 0x7e) {
+        if (b2 === 0x33) return { key: 'delete',   len: 4 };
+        if (b2 === 0x35) return { key: 'pageup',   len: 4 };
+        if (b2 === 0x36) return { key: 'pagedown', len: 4 };
+      }
+    }
+
+    if (b2 === 0x31) { // [1...
+      if (b.length < 4) return INCOMPLETE;
+      if (b[3] === 0x3b) { // [1;...
+        if (b.length < 6) return INCOMPLETE;
+        const mod = b[4], fin = b[5];
+        if (mod === 0x35 && fin === 0x43) return { key: 'ctrl+right',  len: 6 };
+        if (mod === 0x35 && fin === 0x44) return { key: 'ctrl+left',   len: 6 };
+        if (mod === 0x32 && fin === 0x41) return { key: 'shift+up',    len: 6 };
+        if (mod === 0x32 && fin === 0x42) return { key: 'shift+down',  len: 6 };
+      }
+      // [13;2u — kitty Shift+Enter
+      if (b[3] === 0x33 && b.length >= 7 &&
+          b[4] === 0x3b && b[5] === 0x32 && b[6] === 0x75)
+        return { key: 'shift+enter', len: 7 };
+    }
+
+    // [200~ / [201~ — bracketed paste start/end
+    if (b2 === 0x32 && b.length >= 6 && b[3] === 0x30 && b[5] === 0x7e) {
+      if (b[4] === 0x30) return { key: 'paste-start', len: 6 };
+      if (b[4] === 0x31) return { key: 'paste-end',   len: 6 };
+    }
+
+    // [27;2;13~ — xterm modifyOtherKeys Shift+Enter
+    if (b2 === 0x32 && b.length >= 10 &&
+        b[3]===0x37 && b[4]===0x3b && b[5]===0x32 && b[6]===0x3b &&
+        b[7]===0x31 && b[8]===0x33 && b[9]===0x7e)
+      return { key: 'shift+enter', len: 10 };
+
+    let j = 3;
+    while (j < b.length && (b[j] < 0x40 || b[j] > 0x7e)) j++;
+    if (j >= b.length) return INCOMPLETE;
+    return { key: 'unknown', len: j + 1 };
+  }
+
+  if (b1 === 0x4f) { // SS3 'O'
+    if (b.length < 3) return INCOMPLETE;
+    const b2 = b[2];
+    if (b2 === 0x41) return { key: 'up',    len: 3 };
+    if (b2 === 0x42) return { key: 'down',  len: 3 };
+    if (b2 === 0x43) return { key: 'right', len: 3 };
+    if (b2 === 0x44) return { key: 'left',  len: 3 };
+    if (b2 === 0x48) return { key: 'home',  len: 3 };
+    if (b2 === 0x46) return { key: 'end',   len: 3 };
+    return { key: 'unknown', len: 3 };
+  }
+
+  return { key: 'unknown', len: 2 };
+}
+
+// ─── InputField ───────────────────────────────────────────────────────────────
+
+class InputField extends EventEmitter {
+  constructor(layout, chatHistory) {
+    super();
+    this._layout = layout;
+    this._chatHistory = chatHistory;
+    this._chars = [];
+    this._cursor = 0;
+    this._disabled = false;
+    this._inputHeight = 1;
+    this._hint = '';
+    this._tabCycleIdx = 0;
+    this._tabMatches = [];
+    this._history = [];
+    this._historyIdx = -1;
+    this._draft = '';
+    this._selectCapture = null;
+    this._blink = true;
+    this._idle = false;
+    this._idleTimer = null;
+    this._cursorHidden = false;
+    this._blinkTimer = setInterval(() => {
+      if (this._idle || this._disabled) return;
+      this._blink = !this._blink;
+      if (!this._pasteMode) this._render();
+    }, 500);
+    this._escBuf = null;
+    this._escTimer = null;
+    this._utf8Buf = null;
+    this._pasteMode = false;
+    this._pasteStartIdx = null;
+    this._abbreviatedRanges = [];
+    this._pasteCounter = 0;
+    this._syntheticPaste = false;
+    this._navCapture = null;
+    this._navSearchMode = false;
+    this._navSearchQuery = '';
+
+    // History search state
+    this._searchMode = false;
+    this._searchQuery = '';
+    this._searchMatchIdx = -1;
+    this._searchMatchType = null;
+    this._searchExtraItems = [];
+    this._savedChars = null;
+    this._savedCursor = 0;
+
+    this._onData = (chunk) => this._handleData(chunk);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdout.write('\x1b[?2004h');  // bracketed paste
+      process.stdout.write('\x1b[>4;2m');   // xterm modifyOtherKeys level 2
+      process.stdout.write('\x1b[>1u');     // kitty keyboard protocol
+      process.stdin.on('data', this._onData);
+      this._idleTimer = setTimeout(() => this._goIdle(), 0);
+    }
+  }
+
+  // ── Public API ───────────────────────────────────────────────────────────────
+
+  setDisabled(val) {
+    this._disabled = !!val;
+    if (this._disabled) {
+      this._goIdle();
+    } else {
+      this._goActive();
+    }
+    this._renderHints();
+    this._render();
+  }
+  getValue() { return this._chars.join(''); }
+  onSubmit(cb) { this.on('submit', cb); }
+
+  captureSelect(menu) {
+    return new Promise((resolve) => {
+      this._selectCapture = { menu, resolve };
+    });
+  }
+
+  hideCursor() {
+    if (!this._cursorHidden) {
+      this._cursorHidden = true;
+      process.stdout.write('\x1b[?25l');
+    }
+  }
+
+  showCursor() {
+    if (this._cursorHidden) {
+      this._cursorHidden = false;
+      process.stdout.write('\x1b[?25h');
+    }
+  }
+
+  captureNavigation(handler) {
+    this._navCapture = handler;
+    this._navSearchMode = false;
+    this._navSearchQuery = '';
+    this._deleteLine();
+    this._renderHints();
+    this._render();
+    this.hideCursor();
+  }
+
+  releaseNavigation() {
+    this._navCapture = null;
+    this._navSearchMode = false;
+    this._navSearchQuery = '';
+    this.showCursor();
+    this._renderHints();
+    this._render();
+  }
+
+  // Stop all periodic stdout writes so the terminal viewport can scroll freely.
+  _goIdle() {
+    this._idle = true;
+    clearTimeout(this._idleTimer);
+    this._idleTimer = null;
+    this.hideCursor();
+    this.emit('idle');
+  }
+
+  // Resume periodic writes and restart the idle countdown.
+  _goActive() {
+    const wasIdle = this._idle;
+    this._idle = false;
+    clearTimeout(this._idleTimer);
+    this._idleTimer = setTimeout(() => this._goIdle(), 0);
+    if (wasIdle) {
+      this.showCursor();
+      this.emit('active');
+    }
+  }
+
+  setSearchItems(items) {
+    this._searchExtraItems = Array.isArray(items) ? items : [];
+  }
+
+  suspend() {
+    if (process.stdin.isTTY) process.stdin.removeListener('data', this._onData);
+  }
+  resume() {
+    if (process.stdin.isTTY) {
+      process.stdin.resume();
+      process.stdin.removeListener('data', this._onData);
+      process.stdin.on('data', this._onData);
+    }
+    this._renderHints();
+    this._render();
+  }
+
+  // ── Line buffer operations ───────────────────────────────────────────────────
+
+  _insertChar(ch) {
+    if (!this._pasteMode) this._rangeShiftInsert(this._cursor);
+    this._chars.splice(this._cursor, 0, ch);
+    this._cursor++;
+  }
+
+  _backspace() {
+    if (this._cursor <= 0) return;
+    const ri = this._abbreviatedRanges.findIndex(r => r.end === this._cursor);
+    if (ri >= 0) {
+      const r = this._abbreviatedRanges[ri];
+      const len = r.end - r.start;
+      this._chars.splice(r.start, len);
+      this._cursor = r.start;
+      this._abbreviatedRanges.splice(ri, 1);
+      for (const o of this._abbreviatedRanges) {
+        if (o.start >= r.end) { o.start -= len; o.end -= len; }
+      }
+      return;
+    }
+    this._rangeShiftDelete(this._cursor - 1, 1);
+    this._chars.splice(this._cursor - 1, 1);
+    this._cursor--;
+  }
+
+  _deleteForward() {
+    if (this._cursor >= this._chars.length) return;
+    const ri = this._abbreviatedRanges.findIndex(r => r.start === this._cursor);
+    if (ri >= 0) {
+      const r = this._abbreviatedRanges[ri];
+      const len = r.end - r.start;
+      this._chars.splice(r.start, len);
+      this._abbreviatedRanges.splice(ri, 1);
+      for (const o of this._abbreviatedRanges) {
+        if (o.start >= r.end) { o.start -= len; o.end -= len; }
+      }
+      return;
+    }
+    this._rangeShiftDelete(this._cursor, 1);
+    this._chars.splice(this._cursor, 1);
+  }
+
+  _deleteWordBefore() {
+    let pos = this._cursor;
+    while (pos > 0 && this._chars[pos - 1] === ' ') pos--;
+    while (pos > 0 && this._chars[pos - 1] !== ' ') pos--;
+    const len = this._cursor - pos;
+    if (!len) return;
+    this._rangeShiftDelete(pos, len);
+    this._chars.splice(pos, len);
+    this._cursor = pos;
+  }
+
+  _deleteWordForward() {
+    let pos = this._cursor;
+    while (pos < this._chars.length && this._chars[pos] !== ' ') pos++;
+    while (pos < this._chars.length && this._chars[pos] === ' ') pos++;
+    const len = pos - this._cursor;
+    if (!len) return;
+    this._rangeShiftDelete(this._cursor, len);
+    this._chars.splice(this._cursor, len);
+  }
+
+  _deleteToEnd() {
+    const len = this._chars.length - this._cursor;
+    if (len > 0) this._rangeShiftDelete(this._cursor, len);
+    this._chars = this._chars.slice(0, this._cursor);
+  }
+
+  _deleteLine() {
+    this._abbreviatedRanges = [];
+    this._pasteCounter = 0;
+    this._chars = [];
+    this._cursor = 0;
+  }
+
+  _moveCursorLeft() {
+    if (this._cursor <= 0) return;
+    const newPos = this._cursor - 1;
+    for (const r of this._abbreviatedRanges) {
+      if (newPos > r.start && newPos < r.end) { this._cursor = r.start; return; }
+    }
+    this._cursor = newPos;
+  }
+
+  _moveCursorRight() {
+    if (this._cursor >= this._chars.length) return;
+    const newPos = this._cursor + 1;
+    for (const r of this._abbreviatedRanges) {
+      if (newPos > r.start && newPos < r.end) { this._cursor = r.end; return; }
+    }
+    this._cursor = newPos;
+  }
+
+  _moveToStart() { this._cursor = 0; }
+  _moveToEnd()   { this._cursor = this._chars.length; }
+
+  _jumpWordForward() {
+    let pos = this._cursor;
+    while (pos < this._chars.length && this._chars[pos] === ' ') pos++;
+    while (pos < this._chars.length && this._chars[pos] !== ' ') pos++;
+    this._cursor = pos;
+    this._normalizeCursor();
+  }
+
+  _jumpWordBackward() {
+    let pos = this._cursor;
+    while (pos > 0 && this._chars[pos - 1] === ' ') pos--;
+    while (pos > 0 && this._chars[pos - 1] !== ' ') pos--;
+    this._cursor = pos;
+    this._normalizeCursor();
+  }
+
+  _transposeChars() {
+    if (this._cursor <= 0 || this._chars.length < 2) return;
+    const pos = this._cursor >= this._chars.length ? this._chars.length - 1 : this._cursor;
+    const tmp = this._chars[pos - 1];
+    this._chars[pos - 1] = this._chars[pos];
+    this._chars[pos] = tmp;
+    if (this._cursor < this._chars.length) this._cursor++;
+  }
+
+  _setValue(str) {
+    this._abbreviatedRanges = [];
+    this._chars = Array.from(str);
+    this._cursor = this._chars.length;
+  }
+
+  // ── Abbreviated-range helpers ────────────────────────────────────────────────
+
+  _rangeShiftInsert(idx) {
+    const newRanges = [];
+    for (const r of this._abbreviatedRanges) {
+      if (idx > r.start && idx < r.end) { /* insert inside range — invalidate */ }
+      else if (idx <= r.start) newRanges.push({ start: r.start + 1, end: r.end + 1, label: r.label });
+      else newRanges.push(r);
+    }
+    this._abbreviatedRanges = newRanges;
+  }
+
+  _rangeShiftDelete(delStart, delLen) {
+    const delEnd = delStart + delLen;
+    const newRanges = [];
+    for (const r of this._abbreviatedRanges) {
+      if (r.end <= delStart) newRanges.push(r);
+      else if (r.start >= delEnd) newRanges.push({ start: r.start - delLen, end: r.end - delLen, label: r.label });
+      // else overlaps deletion — invalidate
+    }
+    this._abbreviatedRanges = newRanges;
+  }
+
+  _normalizeCursor() {
+    for (const r of this._abbreviatedRanges) {
+      if (this._cursor > r.start && this._cursor < r.end) {
+        const toStart = this._cursor - r.start;
+        const toEnd = r.end - this._cursor;
+        this._cursor = toStart <= toEnd ? r.start : r.end;
+        break;
+      }
+    }
+  }
+
+  _checkAndAbbreviatePaste() {
+    if (this._pasteStartIdx == null) return;
+    const start = this._pasteStartIdx;
+    const end = this._cursor;
+    this._pasteStartIdx = null;
+    const pasteLen = end - start;
+    if (pasteLen <= 0) return;
+
+    const newRanges = [];
+    for (const r of this._abbreviatedRanges) {
+      if (r.end <= start) newRanges.push(r);
+      else if (r.start >= start) newRanges.push({ start: r.start + pasteLen, end: r.end + pasteLen, label: r.label });
+    }
+    this._abbreviatedRanges = newRanges;
+
+    const pastedChars = this._chars.slice(start, end);
+    const pastedStr = pastedChars.join('');
+    const lineCount = (pastedStr.match(/\n/g) || []).length + 1;
+    const isLarge = lineCount >= 2 || pastedStr.length >= 80;
+    if (!isLarge) return;
+
+    this._pasteCounter++;
+    const label = `[Pasted text #${this._pasteCounter}]`;
+    this._abbreviatedRanges.push({ start, end, label });
+  }
+
+  _abbreviateIfLarge() {
+    const str = this._chars.join('');
+    const lineCount = (str.match(/\n/g) || []).length + 1;
+    if (lineCount < 2 && str.length < 80) return;
+    this._pasteCounter++;
+    const label = `[Pasted text #${this._pasteCounter}]`;
+    this._abbreviatedRanges = [{ start: 0, end: this._chars.length, label }];
+  }
+
+  _getDisplayContent() {
+    if (!this._abbreviatedRanges.length) {
+      return { chars: this._chars, cursor: this._cursor };
+    }
+    const sorted = [...this._abbreviatedRanges].sort((a, b) => a.start - b.start);
+    const displayChars = [];
+    let displayCursor = -1;
+    let i = 0;
+    let ri = 0;
+
+    while (i < this._chars.length) {
+      const r = sorted[ri];
+      if (r && i === r.start) {
+        if (this._cursor >= r.start && this._cursor < r.end && displayCursor === -1) {
+          displayCursor = displayChars.length;
+        }
+        for (const ch of r.label) displayChars.push(ch);
+        if (this._cursor === r.end && displayCursor === -1) {
+          displayCursor = displayChars.length;
+        }
+        i = r.end;
+        ri++;
+      } else {
+        if (i === this._cursor && displayCursor === -1) displayCursor = displayChars.length;
+        displayChars.push(this._chars[i]);
+        i++;
+      }
+    }
+    if (displayCursor === -1) displayCursor = displayChars.length;
+    return { chars: displayChars, cursor: displayCursor };
+  }
+
+  // ── Autocomplete hint ────────────────────────────────────────────────────────
+
+  _clearHint() { this._hint = ''; this._tabMatches = []; this._tabCycleIdx = 0; }
+
+  _getFileMatches(partial) {
+    const path = require('path');
+    const fs = require('fs');
+    let dir, prefix;
+    if (partial.includes('/')) {
+      if (partial.endsWith('/')) { dir = partial; prefix = ''; }
+      else { dir = path.dirname(partial); prefix = path.basename(partial); }
+    } else {
+      dir = '.'; prefix = partial;
+    }
+    let entries;
+    try { entries = fs.readdirSync(dir || '.').sort(); } catch { return []; }
+    const matches = [];
+    for (const entry of entries) {
+      if (prefix && !entry.startsWith(prefix)) continue;
+      if (entry.startsWith('.') && !prefix.startsWith('.')) continue;
+      const full = dir === '.' ? entry : path.join(dir, entry).replace(/\\/g, '/');
+      let isDir = false;
+      try { isDir = fs.statSync(full).isDirectory(); } catch {}
+      matches.push(isDir ? full + '/' : full);
+    }
+    return matches;
+  }
+
+  // ── History ──────────────────────────────────────────────────────────────────
+
+  _histPrev() {
+    if (!this._history.length) return;
+    if (this._historyIdx === -1) this._draft = this.getValue();
+    this._historyIdx = Math.min(this._historyIdx + 1, this._history.length - 1);
+    this._setValue(this._history[this._historyIdx]);
+    this._abbreviateIfLarge();
+    this._render();
+  }
+
+  _histNext() {
+    if (this._historyIdx === -1) return;
+    this._historyIdx--;
+    if (this._historyIdx === -1) this._setValue(this._draft);
+    else this._setValue(this._history[this._historyIdx]);
+    this._abbreviateIfLarge();
+    this._render();
+  }
+
+  // ── History search (ctrl+r) ──────────────────────────────────────────────────
+
+  _enterSearchMode() {
+    this._savedChars = this._chars.slice();
+    this._savedCursor = this._cursor;
+    this._searchMode = true;
+    this._searchQuery = '';
+    this._searchMatchIdx = -1;
+    this._abbreviatedRanges = [];
+    this._chars = [];
+    this._cursor = 0;
+    this._renderHints();
+    this._render();
+  }
+
+  _exitSearchMode(accept) {
+    this._searchMode = false;
+    if (!accept) {
+      this._chars = this._savedChars || [];
+      this._cursor = this._savedCursor;
+      this._abbreviatedRanges = [];
+    }
+    this._savedChars = null;
+    this._renderHints();
+    this._render();
+  }
+
+  _getSearchSources() {
+    const sources = [];
+    for (const text of this._history)
+      sources.push({ type: 'history', text });
+    for (const item of this._searchExtraItems)
+      sources.push(item);
+    for (const cmd of SLASH_CMDS)
+      sources.push({ type: 'command', text: cmd });
+    return sources;
+  }
+
+  _doSearch(fromIdx) {
+    const q = this._searchQuery;
+    if (!q) {
+      this._searchMatchIdx = -1;
+      this._searchMatchType = null;
+      this._chars = [];
+      this._cursor = 0;
+      return;
+    }
+    const qLow = q.toLowerCase();
+    const sources = this._getSearchSources();
+    const start = fromIdx !== undefined ? fromIdx : 0;
+    for (let i = start; i < sources.length; i++) {
+      if (sources[i].text.toLowerCase().includes(qLow)) {
+        this._searchMatchIdx = i;
+        this._searchMatchType = sources[i].type;
+        this._abbreviatedRanges = [];
+        this._chars = Array.from(sources[i].text);
+        this._cursor = this._chars.length;
+        return;
+      }
+    }
+    // no match — keep query visible
+    this._searchMatchIdx = -1;
+    this._searchMatchType = null;
+    this._chars = Array.from(q);
+    this._cursor = this._chars.length;
+  }
+
+  _searchNext() {
+    const nextIdx = this._searchMatchIdx >= 0 ? this._searchMatchIdx + 1 : 0;
+    this._doSearch(nextIdx);
+    this._render();
+  }
+
+  // ── Tab autocomplete ─────────────────────────────────────────────────────────
+
+  _handleTab() {
+    const val = this.getValue();
+
+    if (val.startsWith('/file ')) {
+      const partial = val.slice(6);
+      if (!this._tabMatches.length) {
+        this._tabMatches = this._getFileMatches(partial);
+        this._tabCycleIdx = 0;
+      } else {
+        this._tabCycleIdx = (this._tabCycleIdx + 1) % this._tabMatches.length;
+      }
+      if (!this._tabMatches.length) { this._render(); return; }
+      const match = this._tabMatches[this._tabCycleIdx];
+      this._setValue('/file ' + match);
+      this._hint = this._tabMatches.length > 1
+        ? ` [${this._tabCycleIdx + 1}/${this._tabMatches.length}]`
+        : '';
+      this._render();
+      return;
+    }
+
+    if (!val.startsWith('/')) return;
+    const matches = SLASH_CMDS.filter(c => c.startsWith(val));
+    if (!matches.length) return;
+    if (matches.length === 1) {
+      this._setValue(matches[0] + ' ');
+      this._clearHint();
+    } else {
+      if (!this._tabMatches.length) { this._tabMatches = matches; this._tabCycleIdx = 0; }
+      else { this._tabCycleIdx = (this._tabCycleIdx + 1) % this._tabMatches.length; }
+      this._hint = this._tabMatches[this._tabCycleIdx].slice(val.length);
+    }
+    this._render();
+  }
+
+  // ── Key dispatch ─────────────────────────────────────────────────────────────
+
+  _handleKey(key) {
+    if (this._navCapture) {
+      if (this._navSearchMode) {
+        if (key === 'escape' || key === 'ctrl+g') {
+          this._navSearchMode = false;
+          this._navSearchQuery = '';
+          this._navCapture('search:');
+          this._renderHints();
+        } else if (key === 'backspace') {
+          this._navSearchQuery = this._navSearchQuery.slice(0, -1);
+          this._navCapture('search:' + this._navSearchQuery);
+          this._renderHints();
+        } else if (key === 'ctrl+u') {
+          this._navSearchQuery = '';
+          this._navCapture('search:');
+          this._renderHints();
+        } else if (key === 'enter') {
+          this._navSearchMode = false;
+          this._navCapture('select');
+          this._renderHints();
+        } else if (key === 'up' || key === 'ctrl+p') {
+          this._navCapture('prev');
+        } else if (key === 'down' || key === 'ctrl+n') {
+          this._navCapture('next');
+        } else if (key === 'ctrl+c' || key === 'ctrl+d') {
+          this._navSearchMode = false;
+          this._navSearchQuery = '';
+          this._navCapture('cancel');
+        }
+      } else {
+        if (key === 'up' || key === 'ctrl+p')               this._navCapture('prev');
+        else if (key === 'down' || key === 'ctrl+n')        this._navCapture('next');
+        else if (key === 'enter')                           this._navCapture('select');
+        else if (key === 'escape' || key === 'ctrl+c' || key === 'ctrl+d') this._navCapture('cancel');
+        else if (key === 'ctrl+r') {
+          this._navSearchMode = true;
+          this._navSearchQuery = '';
+          this._navCapture('search:');
+          this._renderHints();
+        }
+      }
+      return;
+    }
+
+    if (this._selectCapture) {
+      const { menu, resolve } = this._selectCapture;
+      if (key === 'up' || key === 'ctrl+p')    { menu.moveUp();   this._chatHistory.invalidateCache(); }
+      else if (key === 'down' || key === 'ctrl+n')  { menu.moveDown(); this._chatHistory.invalidateCache(); }
+      else if (key === 'enter') { this._selectCapture = null; resolve(menu.current()); }
+      else if (key === 'ctrl+c' || key === 'ctrl+d' || key === 'escape') {
+        this._selectCapture = null;
+        resolve(null);
+      }
+      return;
+    }
+
+    // ── History search mode ──────────────────────────────────────────────────
+    if (this._searchMode) {
+      switch (key) {
+        case 'ctrl+r':
+          this._searchNext();
+          return;
+        case 'escape':
+        case 'ctrl+g':
+          this._exitSearchMode(false);
+          return;
+        case 'enter': {
+          const accepted = this.getValue();
+          this._exitSearchMode(true);
+          if (accepted) {
+            this._historyIdx = -1;
+            this._draft = '';
+            this._render();
+            this._history.unshift(accepted);
+            if (this._history.length > 100) this._history.pop();
+            this.emit('submit', accepted);
+          }
+          return;
+        }
+        case 'tab': {
+          this._exitSearchMode(true);
+          return;
+        }
+        case 'backspace':
+          if (this._searchQuery.length > 0) {
+            this._searchQuery = this._searchQuery.slice(0, -1);
+            this._searchMatchIdx = -1;
+            this._doSearch(0);
+            this._render();
+          }
+          return;
+        case 'ctrl+u':
+          this._searchQuery = '';
+          this._searchMatchIdx = -1;
+          this._chars = [];
+          this._cursor = 0;
+          this._render();
+          return;
+        default:
+          return;
+      }
+    }
+
+    if (key !== 'tab') this._clearHint();
+
+    switch (key) {
+      case 'shift+enter':  this._insertChar('\n'); this._render(); break;
+      case 'enter': {
+        const val = this.getValue().trim();
+        this._chars = []; this._cursor = 0;
+        this._abbreviatedRanges = [];
+        this._pasteCounter = 0;
+        this._historyIdx = -1; this._draft = '';
+        this._clearHint();
+        this._render();
+        if (val) {
+          this._history.unshift(val);
+          if (this._history.length > 100) this._history.pop();
+          this.emit('submit', val);
+        }
+        break;
+      }
+      case 'backspace':    this._backspace(); this._render(); break;
+      case 'delete':       this._deleteForward(); this._render(); break;
+      case 'tab':          this._handleTab(); break;
+      case 'up':
+      case 'ctrl+p':       this._histPrev(); break;
+      case 'down':
+      case 'ctrl+n':       this._histNext(); break;
+      case 'left':
+      case 'ctrl+b':       this._moveCursorLeft(); this._render(); break;
+      case 'right':
+      case 'ctrl+f':       this._moveCursorRight(); this._render(); break;
+      case 'home':
+      case 'ctrl+a':       this._moveToStart(); this._render(); break;
+      case 'end':
+      case 'ctrl+e':       this._moveToEnd(); this._render(); break;
+      case 'ctrl+k':       this._deleteToEnd(); this._render(); break;
+      case 'ctrl+u':       this._deleteLine(); this._render(); break;
+      case 'ctrl+w':       this._deleteWordBefore(); this._render(); break;
+      case 'ctrl+t':       this._transposeChars(); this._render(); break;
+      case 'ctrl+l':       this._chatHistory.clearMessages(); break;
+      case 'ctrl+r':       this._enterSearchMode(); break;
+      case 'ctrl+o':       if (this._navCapture) this._navCapture('expand'); else this.emit('expand'); break;
+      case 'ctrl+g':
+      case 'ctrl+c':
+      case 'ctrl+d':       this.emit('interrupt'); break;
+      case 'ctrl+right':
+      case 'alt+f':        this._jumpWordForward(); this._render(); break;
+      case 'ctrl+left':
+      case 'alt+b':        this._jumpWordBackward(); this._render(); break;
+      case 'pageup':
+      case 'shift+up':     this._chatHistory.scrollUp(Math.max(1, this._layout.historyRows - 2)); break;
+      case 'pagedown':
+      case 'shift+down':   this._chatHistory.scrollDown(Math.max(1, this._layout.historyRows - 2)); break;
+      case 'paste-start':
+        this._pasteMode = true;
+        this._pasteStartIdx = this._cursor;
+        break;
+      case 'paste-end':
+        this._syntheticPaste = false;
+        this._pasteMode = false;
+        this._checkAndAbbreviatePaste();
+        this._render();
+        break;
+      case 'escape':       this._render(); break;
+    }
+  }
+
+  // ── Raw stdin byte handler ───────────────────────────────────────────────────
+
+  _handleData(chunk) {
+    let buf;
+    const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    if (this._escBuf) {
+      buf = Buffer.concat([this._escBuf, incoming]);
+      this._escBuf = null;
+      if (this._escTimer) { clearTimeout(this._escTimer); this._escTimer = null; }
+    } else {
+      buf = incoming;
+    }
+    if (this._utf8Buf) {
+      buf = Buffer.concat([this._utf8Buf, buf]);
+      this._utf8Buf = null;
+    }
+
+    if (this._selectCapture) { this._processBuf(buf, false); return; }
+    if (this._navCapture) { this._processBuf(buf, false); return; }
+    if (this._disabled) {
+      if (buf[0] === 0x03 || buf[0] === 0x04) {
+        this.emit('interrupt');
+      } else if (buf[0] === 0x0f) {
+        this.emit('expand');
+      } else if (buf[0] === 0x1b && buf.length === 1) {
+        // Bare ESC while agent is running: buffer and confirm after 20ms so that
+        // escape sequences (arrow keys, etc.) arriving as separate bytes are ignored.
+        this._escBuf = buf;
+        this._escTimer = setTimeout(() => {
+          const pending = this._escBuf;
+          this._escBuf = null; this._escTimer = null;
+          if (pending && pending.length === 1 && this._disabled) this.emit('abort');
+        }, 20);
+      }
+      return;
+    }
+    this._goActive();
+    this._processBuf(buf, false);
+  }
+
+  _processBuf(buf, force) {
+    // Detect unbracketed paste: buffer has a newline with content on both sides.
+    // Terminals that don't send \x1b[200~/\x1b[201~ would otherwise fire Enter on
+    // each newline inside pasted text, submitting only the first line.
+    if (!this._pasteMode && !force && !this._syntheticPaste &&
+        !this._selectCapture && !this._navCapture && !this._searchMode &&
+        buf[0] !== 0x1b) {
+      const crIdx = buf.indexOf(0x0d);
+      const nlIdx = buf.indexOf(0x0a);
+      const nlPos = crIdx === -1 ? nlIdx : (nlIdx === -1 ? crIdx : Math.min(crIdx, nlIdx));
+      if (nlPos > 0 && nlPos < buf.length - 1) {
+        this._pasteMode = true;
+        this._pasteStartIdx = this._cursor;
+        this._syntheticPaste = true;
+      }
+    }
+
+    let i = 0;
+    while (i < buf.length) {
+      const b = buf[i];
+
+      if (b === 0x1b) {
+        const result = parseKeySequence(buf.slice(i));
+        if (result && result.incomplete && !force) {
+          this._escBuf = buf.slice(i);
+          this._escTimer = setTimeout(() => {
+            const pending = this._escBuf;
+            this._escBuf = null; this._escTimer = null;
+            if (!pending) return;
+            if (pending.length === 1) { this._handleKey('escape'); this._render(); }
+            else this._processBuf(pending, true);
+          }, 20);
+          return;
+        }
+        if (result && result.key && result.key !== 'unknown') this._handleKey(result.key);
+        i += (result && result.len > 0) ? result.len : 1;
+        continue;
+      }
+
+      if (b < 0x20 || b === 0x7f) {
+        if (this._pasteMode && (b === 0x0d || b === 0x0a)) {
+          if (!(b === 0x0a && i > 0 && buf[i - 1] === 0x0d)) {
+            this._insertChar('\n');
+            this._clearHint();
+            // render deferred to paste-end
+          }
+        } else {
+          const result = parseKeySequence(buf.slice(i, i + 1));
+          if (result && result.key) this._handleKey(result.key);
+        }
+        i++;
+        continue;
+      }
+
+      // Printable char — in nav capture mode, dispatch n/p/s/c or append to search query
+      if (this._navCapture) {
+        const _b0nc = buf[i];
+        if (_b0nc >= 0xC0 && _b0nc < 0xFE) {
+          const _el = _b0nc >= 0xF0 ? 4 : _b0nc >= 0xE0 ? 3 : 2;
+          if (buf.length - i < _el) { this._utf8Buf = buf.slice(i); return; }
+        }
+        try {
+          const str = buf.slice(i).toString('utf8');
+          const cp = str.codePointAt(0);
+          if (cp !== undefined && cp >= 0x20) {
+            const ch = String.fromCodePoint(cp);
+            const byteLen = Buffer.byteLength(ch, 'utf8');
+            if (this._navSearchMode) {
+              this._navSearchQuery += ch;
+              this._navCapture('search:' + this._navSearchQuery);
+              this._renderHints();
+            } else {
+              const chLower = ch.toLowerCase();
+              if (chLower === 'n') this._navCapture('next');
+              else if (chLower === 'p') this._navCapture('prev');
+              else if (chLower === 's' || chLower === 'y') this._navCapture('select');
+              else if (chLower === 'c') this._navCapture('cancel');
+            }
+            i += byteLen;
+          } else { i++; }
+        } catch { i++; }
+        continue;
+      }
+
+      // Printable char — in search mode, append to query
+      if (this._searchMode) {
+        const _b0sm = buf[i];
+        if (_b0sm >= 0xC0 && _b0sm < 0xFE) {
+          const _el = _b0sm >= 0xF0 ? 4 : _b0sm >= 0xE0 ? 3 : 2;
+          if (buf.length - i < _el) { this._utf8Buf = buf.slice(i); return; }
+        }
+        try {
+          const str = buf.slice(i).toString('utf8');
+          const cp = str.codePointAt(0);
+          if (cp !== undefined && cp >= 0x20) {
+            const ch = String.fromCodePoint(cp);
+            this._searchQuery += ch;
+            this._searchMatchIdx = -1;
+            this._doSearch(0);
+            this._render();
+            i += Buffer.byteLength(ch, 'utf8');
+          } else { i++; }
+        } catch { i++; }
+        continue;
+      }
+
+      {
+        const _b0 = buf[i];
+        if (_b0 >= 0xC0 && _b0 < 0xFE) {
+          const _el = _b0 >= 0xF0 ? 4 : _b0 >= 0xE0 ? 3 : 2;
+          if (buf.length - i < _el) { this._utf8Buf = buf.slice(i); return; }
+        }
+        try {
+          const str = buf.slice(i).toString('utf8');
+          const cp = str.codePointAt(0);
+          if (cp !== undefined && cp >= 0x20) {
+            const ch = String.fromCodePoint(cp);
+            this._insertChar(ch);
+            if (!this._pasteMode) {
+              this._clearHint();
+              this._render();
+            }
+            i += Buffer.byteLength(ch, 'utf8');
+          } else { i++; }
+        } catch { i++; }
+      }
+    }
+
+    if (this._syntheticPaste) {
+      this._syntheticPaste = false;
+      if (this._pasteMode) {
+        this._pasteMode = false;
+        this._checkAndAbbreviatePaste();
+        this._render();
+      }
+    }
+  }
+
+  // ── Hints row ────────────────────────────────────────────────────────────────
+
+  _renderHints() {
+    const layout = this._layout;
+    if (!layout || !layout.hintsRow) return;
+    const row = layout.hintsRow;
+    const cols = layout.cols;
+
+    let text;
+    if (this._searchMode) {
+      text = `${FG_YELLOW}ctrl+r${RST}${DIM} next match  ${RST}${FG_YELLOW}esc${RST}${DIM} cancel search${RST}`;
+    } else if (this._disabled) {
+      text = `${FG_YELLOW}esc${RST}${DIM} interrupt${RST}`;
+    } else if (this._navCapture) {
+      if (this._navSearchMode) {
+        text = `${FG_YELLOW}search:${RST} ${FG_CYAN}'${this._navSearchQuery}'${RST}  ${DIM}↑↓ navigate  enter select  esc clear${RST}`;
+      } else {
+        text = `${FG_CYAN}↑↓${RST}${DIM}/${RST}${FG_CYAN}n/p${RST}${DIM} navigate  ${RST}${FG_CYAN}s${RST}${DIM}/${RST}${FG_CYAN}enter${RST}${DIM} select  ${RST}${FG_CYAN}ctrl+r${RST}${DIM} search  ${RST}${FG_CYAN}c${RST}${DIM}/${RST}${FG_CYAN}esc${RST}${DIM} cancel${RST}`;
+      }
+    } else {
+      text = `${DIM}↑↓ history  ${RST}${FG_CYAN}ctrl+r${RST}${DIM} search  ${RST}${FG_CYAN}ctrl+c${RST}${DIM} cancel${RST}`;
+    }
+
+    // Use DECSC/DECRC so the cursor is restored after drawing (keeps streaming
+    // tokens anchored at historyRows when the blink timer calls this).
+    process.stdout.write(`\x1b7\x1b[${row};1H\x1b[2K${text}`);
+    const visLen = text.replace(/\x1b\[[^m]*m/g, '').length;
+    if (visLen < cols) process.stdout.write(' '.repeat(cols - visLen));
+    process.stdout.write('\x1b8');
+  }
+
+  // ── Render ───────────────────────────────────────────────────────────────────
+
+  _render() {
+    const layout = this._layout;
+    const cols = layout.cols;
+
+    if (this._disabled) {
+      if (this._inputHeight !== 1) {
+        this._inputHeight = 1;
+        layout.setInputHeight(1);
+      }
+      const baseRow = layout.inputRow;
+      // DECSC/DECRC keeps the cursor in the history scroll region so streaming
+      // tokens written after this blink-timer redraw land at the right row.
+      process.stdout.write(`\x1b7\x1b[${baseRow};1H\x1b[2K${DIM}›${RST}`);
+      process.stdout.write(' '.repeat(Math.max(0, cols - 1)));
+      process.stdout.write('\x1b8');
+      return;
+    }
+
+    if (this._navCapture) {
+      if (this._inputHeight !== 1) {
+        this._inputHeight = 1;
+        layout.setInputHeight(1);
+      }
+      const baseRow = layout.inputRow;
+      process.stdout.write(`\x1b[${baseRow};1H\x1b[2K${DIM}›${RST}`);
+      process.stdout.write(' '.repeat(Math.max(0, cols - 1)));
+      return;
+    }
+
+    // ── Search mode rendering ────────────────────────────────────────────────
+    if (this._searchMode) {
+      if (this._inputHeight !== 1) {
+        this._inputHeight = 1;
+        layout.setInputHeight(1);
+      }
+      const baseRow = layout.inputRow;
+      const noMatch = this._searchQuery && this._searchMatchIdx === -1;
+      const queryColor = noMatch ? '\x1b[38;5;203m' : FG_CYAN;
+      const prefix = `${DIM}(search)${RST} ${queryColor}'${this._searchQuery}'${RST}${DIM}:${RST} `;
+      const matched = this._chars.join('');
+
+      // Type label
+      const typeLabel = this._searchMatchType
+        ? `${DIM}[${this._searchMatchType}]${RST} `
+        : '';
+
+      // Highlight the matching part (case-insensitive)
+      let displayMatch;
+      const matchedLow = matched.toLowerCase();
+      const qLow = this._searchQuery.toLowerCase();
+      if (this._searchQuery && matchedLow.includes(qLow)) {
+        const idx = matchedLow.indexOf(qLow);
+        const before = matched.slice(0, idx);
+        const hit    = matched.slice(idx, idx + this._searchQuery.length);
+        const after  = matched.slice(idx + this._searchQuery.length);
+        displayMatch = `${before}${FG_GREEN}${hit}${RST}${after}`;
+      } else {
+        displayMatch = matched;
+      }
+
+      const line = prefix + typeLabel + displayMatch;
+      process.stdout.write(`\x1b[${baseRow};1H\x1b[2K${line}`);
+      const visLen = line.replace(/\x1b\[[^m]*m/g, '').length;
+      if (visLen < cols) process.stdout.write(' '.repeat(cols - visLen));
+      return;
+    }
+
+    // ── Normal rendering ─────────────────────────────────────────────────────
+    const { chars: displayChars, cursor: displayCursor } = this._getDisplayContent();
+
+    const newlineCount = displayChars.filter(c => c === '\n').length;
+    const needed = Math.min(5, newlineCount + 1);
+    if (needed !== this._inputHeight) {
+      this._inputHeight = needed;
+      layout.setInputHeight(needed);
+    }
+
+    const baseRow = layout.inputRow;
+
+    for (let r = baseRow; r < baseRow + this._inputHeight; r++) {
+      process.stdout.write(`\x1b[${r};1H\x1b[2K`);
+    }
+
+    const PREFIX     = '\x1b[36m › \x1b[0m';
+    const PREFIX_LEN = 3;
+
+    const lines = [[]];
+    for (const ch of displayChars) {
+      if (ch === '\n') lines.push([]);
+      else lines[lines.length - 1].push(ch);
+    }
+
+    let cursorLine = 0, cursorCol = 0, pos = 0;
+    for (let li = 0; li < lines.length; li++) {
+      if (displayCursor <= pos + lines[li].length) {
+        cursorLine = li;
+        cursorCol  = displayCursor - pos;
+        break;
+      }
+      pos += lines[li].length + 1;
+    }
+
+    const renderCount = Math.min(lines.length, this._inputHeight);
+    for (let li = 0; li < renderCount; li++) {
+      const r         = baseRow + li;
+      const lineChars = lines[li];
+
+      let lineStr;
+      if (li === cursorLine) {
+        const leftStr  = lineChars.slice(0, cursorCol).join('');
+        const cursorCh = cursorCol < lineChars.length ? lineChars[cursorCol] : ' ';
+        const afterStr = lineChars.slice(cursorCol + (cursorCol < lineChars.length ? 1 : 0)).join('');
+        const cursorEsc = this._blink
+          ? `\x1b[7m${cursorCh}\x1b[27m`
+          : `\x1b[4m${cursorCh}\x1b[24m`;
+        lineStr = leftStr + cursorEsc + afterStr;
+      } else {
+        lineStr = lineChars.join('');
+      }
+
+      const leadIn  = li === 0 ? PREFIX : ' '.repeat(PREFIX_LEN);
+      const hintStr = (li === 0 && this._hint) ? `${DIM}${this._hint}${RST}` : '';
+      const visLen  = PREFIX_LEN + lineChars.length + (li === 0 ? this._hint.length : 0);
+      const pad     = visLen < cols ? ' '.repeat(cols - visLen) : '';
+
+      process.stdout.write(`\x1b[${r};1H` + leadIn + lineStr + hintStr + pad);
+    }
+  }
+
+  // ── Destroy ──────────────────────────────────────────────────────────────────
+
+  destroy() {
+    if (this._blinkTimer) { clearInterval(this._blinkTimer); this._blinkTimer = null; }
+    if (this._escTimer)   { clearTimeout(this._escTimer);    this._escTimer = null; }
+    if (this._idleTimer)  { clearTimeout(this._idleTimer);   this._idleTimer = null; }
+    if (process.stdin.isTTY) {
+      process.stdin.removeListener('data', this._onData);
+      this._cursorHidden = true; this.showCursor();   // restore cursor visibility
+      process.stdout.write('\x1b[<u');     // pop kitty keyboard protocol
+      process.stdout.write('\x1b[>4;0m'); // reset modifyOtherKeys
+      process.stdout.write('\x1b[?2004l'); // disable bracketed paste
+      process.stdin.setRawMode(false);    // restore cooked mode so mouse works again
+    }
+  }
+}
+
+module.exports = { InputField, parseKeySequence, SLASH_CMDS };