@semalt-ai/code 1.5.0 → 1.6.0

package/lib/ui.js

@@ -111,133 +111,279 @@ function readInteractiveInput(promptText, options = {}) {
     let done = false;
     let historyIndex = Array.isArray(history) ? history.length : -1;
     let historyActive = false;
+    let pasting = false;
+    let lastLineCount = 1;
+    let lastCursorRow = 0;
+    let lastWasCR = false;
 
-    readline.emitKeypressEvents(process.stdin);
     process.stdin.setRawMode(true);
     process.stdin.resume();
+    process.stdout.write('\x1b[?2004h'); // enable bracketed paste mode
+
+    const promptWidth = stripAnsi(promptText).length;
 
     const render = () => {
+      const lines = buffer.split('\n');
+      const newLineCount = lines.length;
+
+      if (lastLineCount > 1) {
+        readline.moveCursor(process.stdout, 0, -(lastLineCount - 1));
+      }
+
       readline.cursorTo(process.stdout, 0);
       readline.clearLine(process.stdout, 0);
-      process.stdout.write(`${promptText}${buffer}`);
-      const promptWidth = stripAnsi(promptText).length;
-      readline.cursorTo(process.stdout, promptWidth + cursor);
+      process.stdout.write(`${promptText}${lines[0]}`);
+
+      for (let i = 1; i < newLineCount; i++) {
+        process.stdout.write('\n');
+        readline.cursorTo(process.stdout, 0);
+        readline.clearLine(process.stdout, 0);
+        process.stdout.write(lines[i]);
+      }
+
+      // Clear any extra lines from a previous longer render
+      for (let i = newLineCount; i < lastLineCount; i++) {
+        process.stdout.write('\n');
+        readline.cursorTo(process.stdout, 0);
+        readline.clearLine(process.stdout, 0);
+      }
+
+      lastLineCount = newLineCount;
+
+      const beforeCursor = Array.from(buffer).slice(0, cursor).join('');
+      const cursorLines = beforeCursor.split('\n');
+      lastCursorRow = cursorLines.length - 1;
+      const cursorCol = (lastCursorRow === 0 ? promptWidth : 0) + cursorLines[lastCursorRow].length;
+
+      const rowsFromBottom = newLineCount - 1 - lastCursorRow;
+      if (rowsFromBottom > 0) {
+        readline.moveCursor(process.stdout, 0, -rowsFromBottom);
+      }
+      readline.cursorTo(process.stdout, cursorCol);
     };
 
     const finish = (result, addNewline = true) => {
       if (done) return;
       done = true;
+      process.stdout.write('\x1b[?2004l'); // disable bracketed paste mode
       process.stdin.setRawMode(wasRaw);
-      process.stdin.removeListener('keypress', onKeypress);
-      if (addNewline) process.stdout.write('\n');
+      process.stdin.removeListener('data', onData);
+      if (addNewline) {
+        const rowsToBottom = lastLineCount - 1 - lastCursorRow;
+        if (rowsToBottom > 0) {
+          readline.moveCursor(process.stdout, 0, rowsToBottom);
+        }
+        process.stdout.write('\n');
+      }
       resolve(result);
     };
 
-    const onKeypress = (str, key = {}) => {
-      if (key.ctrl && key.name === 'c') {
-        if (buffer) {
-          buffer = '';
-          cursor = 0;
-          render();
-          return;
+    // Parse raw stdin data directly so we can intercept bracketed paste markers
+    // (\x1b[200~ ... \x1b[201~) before any higher-level key parser sees them.
+    const onData = (chunk) => {
+      if (done) return;
+      const data = chunk.toString('utf8');
+      let i = 0;
+
+      while (i < data.length) {
+        // --- Bracketed paste markers ---
+        if (data.startsWith('\x1b[200~', i)) {
+          pasting = true;
+          lastWasCR = false;
+          i += 6;
+          continue;
+        }
+        if (data.startsWith('\x1b[201~', i)) {
+          pasting = false;
+          lastWasCR = false;
+          i += 6;
+          continue;
         }
-        finish({ type: 'sigint' }, false);
-        return;
-      }
 
-      if (key.ctrl && key.name === 'd') {
-        if (!buffer) finish({ type: 'eof' }, false);
-        return;
-      }
+        const ch = data[i];
+
+        // --- Escape sequences ---
+        if (ch === '\x1b') {
+          lastWasCR = false;
+          const next = data[i + 1];
+
+          // CSI sequences: \x1b[...
+          if (next === '[') {
+            const seq3 = data.slice(i, i + 3);
+            const seq4 = data.slice(i, i + 4);
+
+            if (seq3 === '\x1b[A') { // up
+              if (Array.isArray(history) && history.length) {
+                if (historyActive || buffer.length === 0) {
+                  historyActive = true;
+                  historyIndex = Math.max(0, historyIndex - 1);
+                  buffer = historyIndex >= history.length ? '' : history[historyIndex];
+                  cursor = Array.from(buffer).length;
+                  render();
+                }
+              }
+              i += 3; continue;
+            }
+            if (seq3 === '\x1b[B') { // down
+              if (Array.isArray(history) && history.length) {
+                if (historyActive || buffer.length === 0) {
+                  historyActive = true;
+                  historyIndex = Math.min(history.length, historyIndex + 1);
+                  buffer = historyIndex >= history.length ? '' : history[historyIndex];
+                  cursor = Array.from(buffer).length;
+                  render();
+                }
+              }
+              i += 3; continue;
+            }
+            if (seq3 === '\x1b[C') { // right
+              if (allowCursorNavigation && cursor < Array.from(buffer).length) { cursor++; render(); }
+              i += 3; continue;
+            }
+            if (seq3 === '\x1b[D') { // left
+              if (allowCursorNavigation && cursor > 0) { cursor--; render(); }
+              i += 3; continue;
+            }
+            if (seq3 === '\x1b[H' || seq4 === '\x1b[1~') { // home
+              if (allowCursorNavigation) { cursor = 0; render(); }
+              i += (seq3 === '\x1b[H' ? 3 : 4); continue;
+            }
+            if (seq3 === '\x1b[F' || seq4 === '\x1b[4~') { // end
+              if (allowCursorNavigation) { cursor = Array.from(buffer).length; render(); }
+              i += (seq3 === '\x1b[F' ? 3 : 4); continue;
+            }
+            if (seq4 === '\x1b[3~') { // delete
+              if (cursor < Array.from(buffer).length) {
+                buffer = removeCharAt(buffer, cursor);
+                historyActive = false;
+                render();
+              }
+              i += 4; continue;
+            }
+            // Skip unknown CSI sequence (read until terminating byte)
+            let j = i + 2;
+            while (j < data.length && (data.charCodeAt(j) < 0x40 || data.charCodeAt(j) > 0x7e)) j++;
+            i = j + 1;
+            continue;
+          }
+
+          // SS3 sequences: \x1bO... (application cursor keys)
+          if (next === 'O') {
+            const c = data[i + 2];
+            if (c === 'A') { // up
+              if (Array.isArray(history) && history.length && (historyActive || buffer.length === 0)) {
+                historyActive = true;
+                historyIndex = Math.max(0, historyIndex - 1);
+                buffer = historyIndex >= history.length ? '' : history[historyIndex];
+                cursor = Array.from(buffer).length;
+                render();
+              }
+              i += 3; continue;
+            }
+            if (c === 'B') { // down
+              if (Array.isArray(history) && history.length && (historyActive || buffer.length === 0)) {
+                historyActive = true;
+                historyIndex = Math.min(history.length, historyIndex + 1);
+                buffer = historyIndex >= history.length ? '' : history[historyIndex];
+                cursor = Array.from(buffer).length;
+                render();
+              }
+              i += 3; continue;
+            }
+            if (c === 'C' && allowCursorNavigation) { if (cursor < Array.from(buffer).length) { cursor++; render(); } i += 3; continue; }
+            if (c === 'D' && allowCursorNavigation) { if (cursor > 0) { cursor--; render(); } i += 3; continue; }
+            if (c === 'H' && allowCursorNavigation) { cursor = 0; render(); i += 3; continue; }
+            if (c === 'F' && allowCursorNavigation) { cursor = Array.from(buffer).length; render(); i += 3; continue; }
+            i += 3; continue;
+          }
+
+          // Unknown escape - skip
+          i += 2;
+          continue;
+        }
 
-      if (key.name === 'return' || key.name === 'enter') {
-        finish({ type: 'submit', value: trim ? buffer.trim() : buffer });
-        return;
-      }
+        // --- Ctrl+C ---
+        if (ch === '\x03') {
+          lastWasCR = false;
+          if (buffer) { buffer = ''; cursor = 0; pasting = false; render(); }
+          else { finish({ type: 'sigint' }, false); return; }
+          i++; continue;
+        }
 
-      if (key.name === 'backspace' || key.name === 'delete') {
-        if (key.name === 'backspace' && cursor > 0) {
-          buffer = removeCharAt(buffer, cursor - 1);
-          cursor--;
-          historyActive = false;
-          render();
-        } else if (key.name === 'delete' && cursor < Array.from(buffer).length) {
-          buffer = removeCharAt(buffer, cursor);
-          historyActive = false;
-          render();
+        // --- Ctrl+D ---
+        if (ch === '\x04') {
+          lastWasCR = false;
+          if (!buffer) { finish({ type: 'eof' }, false); return; }
+          i++; continue;
         }
-        return;
-      }
 
-      if (allowCursorNavigation && key.name === 'left') {
-        if (cursor > 0) {
-          cursor--;
-          render();
+        // --- Enter / newline ---
+        if (ch === '\r' || ch === '\n') {
+          // Collapse CRLF into a single newline
+          if (ch === '\n' && lastWasCR) { lastWasCR = false; i++; continue; }
+          lastWasCR = (ch === '\r');
+
+          if (pasting) {
+            buffer = insertCharAt(buffer, cursor, '\n');
+            cursor++;
+            historyActive = false;
+            render();
+          } else {
+            finish({ type: 'submit', value: trim ? buffer.trim() : buffer });
+            return;
+          }
+          i++; continue;
+        }
+        lastWasCR = false;
+
+        // --- Backspace ---
+        if (ch === '\x7f' || ch === '\x08') {
+          if (cursor > 0) {
+            buffer = removeCharAt(buffer, cursor - 1);
+            cursor--;
+            historyActive = false;
+            render();
+          }
+          i++; continue;
         }
-        return;
-      }
 
-      if (allowCursorNavigation && key.name === 'right') {
-        if (cursor < Array.from(buffer).length) {
-          cursor++;
-          render();
+        // --- Tab ---
+        if (ch === '\t') {
+          if (pasting) {
+            buffer = insertCharAt(buffer, cursor, '\t');
+            cursor++;
+            render();
+          }
+          i++; continue;
         }
-        return;
-      }
 
-      if (allowCursorNavigation && key.name === 'home') {
-        cursor = 0;
-        render();
-        return;
-      }
+        // --- Other control characters: skip ---
+        if (ch.charCodeAt(0) < 0x20) { i++; continue; }
 
-      if (allowCursorNavigation && key.name === 'end') {
-        cursor = Array.from(buffer).length;
-        render();
-        return;
-      }
+        // --- Printable character (handles multi-byte Unicode via code points) ---
+        const cp = data.codePointAt(i);
+        const char = String.fromCodePoint(cp);
 
-      if (Array.isArray(history) && (key.name === 'up' || key.name === 'down')) {
-        const canEnterHistory = buffer.length === 0;
-        if (!history.length) return;
-        if (!historyActive && !canEnterHistory) return;
+        if (allowed && !allowed.includes(char)) { i += char.length; continue; }
 
-        historyActive = true;
-        if (key.name === 'up') {
-          historyIndex = Math.max(0, historyIndex - 1);
-        } else {
-          historyIndex = Math.min(history.length, historyIndex + 1);
+        if (immediate) {
+          buffer = char;
+          cursor = 1;
+          historyActive = false;
+          render();
+          finish({ type: 'submit', value: char });
+          return;
         }
 
-        buffer = historyIndex >= history.length ? '' : history[historyIndex];
-        cursor = Array.from(buffer).length;
-        render();
-        return;
-      }
-
-      if (key.name && ['up', 'down', 'left', 'right', 'home', 'end', 'pageup', 'pagedown', 'escape', 'tab'].includes(key.name)) {
-        return;
-      }
-
-      if (!isPrintableKey(str, key)) return;
-      if (allowed && !allowed.includes(str)) return;
-
-      if (immediate) {
-        buffer = str;
-        cursor = Array.from(buffer).length;
+        buffer = insertCharAt(buffer, cursor, char);
+        cursor++;
         historyActive = false;
         render();
-        finish({ type: 'submit', value: str });
-        return;
+        i += char.length;
       }
-
-      buffer = insertCharAt(buffer, cursor, str);
-      cursor++;
-      historyActive = false;
-      render();
     };
 
-    process.stdin.on('keypress', onKeypress);
+    process.stdin.on('data', onData);
     render();
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semalt-ai/code",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Self-hosted AI Coding Assistant CLI",
   "main": "index.js",
   "bin": {