tsunami-code 3.10.0 → 3.11.1

package/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import readline from 'readline';
+import { createUI } from './lib/ui.js';
 import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
 import { join } from 'path';
@@ -227,32 +227,16 @@ if (setServerIdx !== -1 && argv[setServerIdx + 1]) {
 }
 
 // ── Confirm Callback (dangerous command prompt) ─────────────────────────────
-function makeConfirmCallback(rl) {
+function makeConfirmCallback(ui) {
   const cb = async (cmd) => {
-    return new Promise((resolve) => {
-      rl.pause();
-      process.stdout.write(`\n  ${yellow('⚠  Dangerous:')} ${dim(cmd.slice(0, 120))}\n`);
-      process.stdout.write(`  ${yellow('Proceed?')} ${dim('(y/N) ')}`);
-      const handler = (data) => {
-        process.stdin.removeListener('data', handler);
-        rl.resume();
-        process.stdout.write('\n');
-        resolve(data.toString().trim().toLowerCase() === 'y');
-      };
-      process.stdin.once('data', handler);
-    });
+    process.stdout.write(`\n  ${yellow('⚠  Dangerous:')} ${dim(cmd.slice(0, 120))}\n`);
+    const ch = await ui.readChar(`  ${yellow('Proceed?')} ${dim('(y/N) ')}`);
+    return ch.toLowerCase() === 'y';
   };
 
-  cb._askUser = (question, resolve) => {
-    rl.pause();
-    process.stdout.write(`\n  ${cyan('?')} ${question}\n  ${dim('> ')}`);
-    const handler = (data) => {
-      process.stdin.removeListener('data', handler);
-      rl.resume();
-      process.stdout.write('\n');
-      resolve(data.toString().trim());
-    };
-    process.stdin.once('data', handler);
+  cb._askUser = async (question, resolve) => {
+    const answer = await ui.readLine(`\n  ${cyan('?')} ${question}\n  ${dim('> ')}`);
+    resolve(answer);
   };
 
   return cb;
@@ -351,7 +335,6 @@ async function run() {
     } catch { return []; }
   }
   const historyEntries = loadHistory();
-  let historyIdx = -1;
 
   // Preflight checks
   process.stdout.write(dim('  Checking server connection...'));
@@ -502,16 +485,6 @@ async function run() {
     return [[], line];
   }
 
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: planMode ? yellow('❯ [plan] ') : cyan('❯ '),
-    terminal: process.stdin.isTTY,
-    completer: tabCompleter,
-  });
-
-  rl.prompt();
-
   let isProcessing = false;
   let pendingClose = false;
 
@@ -519,15 +492,24 @@ async function run() {
   function gracefulExit(code = 0) {
     try { endSession(sessionDir); } catch {}
     try { disconnectMcp(); } catch {}
+    ui.exitUI();
     console.log(dim('\n  Goodbye.\n'));
     process.exit(code);
   }
 
-  rl.on('close', () => {
-    if (isProcessing) { pendingClose = true; return; }
-    gracefulExit(0);
+  const ui = createUI({
+    planMode,
+    onLine: handleLine,
+    onTab:  tabCompleter,
+    onExit: (code) => {
+      if (isProcessing) { pendingClose = true; return; }
+      gracefulExit(code);
+    },
   });
 
+  ui.start(historyEntries);
+  ui.setModelLabel(getModel());
+
   // ── Memory commands ───────────────────────────────────────────────────────────
   async function handleMemoryCommand(args) {
     const sub = args[0]?.toLowerCase();
@@ -627,36 +609,32 @@ async function run() {
   let mlBuffer = [];
   let mlHeredoc = false;
 
-  rl.on('line', async (input) => {
+  async function handleLine(input) {
     // ── Multiline: heredoc mode (""" toggle) ──────────────────────────────────
     if (input.trimStart() === '"""' || input.trimStart() === "'''") {
       if (!mlHeredoc) {
         mlHeredoc = true;
-        rl.setPrompt(dim('··· '));
-        rl.prompt();
+        ui.setContinuation(true);
         return;
       } else {
         // Close heredoc — submit accumulated buffer
         mlHeredoc = false;
         const assembled = mlBuffer.join('\n');
         mlBuffer = [];
-        rl.setPrompt(planMode ? yellow('❯ [plan] ') : cyan('❯ '));
-        // Fall through with assembled as the input
+        ui.setContinuation(false);
         return _handleInput(assembled);
       }
     }
 
     if (mlHeredoc) {
       mlBuffer.push(input);
-      rl.prompt();
       return;
     }
 
     // ── Multiline: backslash continuation ─────────────────────────────────────
     if (input.endsWith('\\')) {
       mlBuffer.push(input.slice(0, -1));
-      rl.setPrompt(dim('··· '));
-      rl.prompt();
+      ui.setContinuation(true);
       return;
     }
 
@@ -665,21 +643,20 @@ async function run() {
       mlBuffer.push(input);
       const assembled = mlBuffer.join('\n');
       mlBuffer = [];
-      rl.setPrompt(planMode ? yellow('❯ [plan] ') : cyan('❯ '));
+      ui.setContinuation(false);
       return _handleInput(assembled);
     }
 
     return _handleInput(input);
-  });
+  }
 
   async function _handleInput(input) {
     const line = input.trim();
-    if (!line) { rl.prompt(); return; }
+    if (!line) { return; }
 
     // Append to persistent history
     if (!line.startsWith('/')) {
       appendHistory(line);
-      historyIdx = -1;
     }
 
     if (line.startsWith('/')) {
@@ -696,7 +673,7 @@ async function run() {
           : skillMatch.prompt;
         messages.push({ role: 'user', content: userContent });
         const fullMessages = [{ role: 'system', content: systemPrompt }, ...messages];
-        rl.pause(); isProcessing = true;
+        ui.pause(); isProcessing = true;
         process.stdout.write('\n' + dim(`  ◈ Running skill: ${skillMatch.skill.name}\n\n`));
         let firstToken = true;
         try {
@@ -704,10 +681,10 @@ async function run() {
             if (firstToken) { process.stdout.write('  '); firstToken = false; }
             process.stdout.write(token);
           }, (name, args) => { printToolCall(name, args); firstToken = true; },
-          { sessionDir, cwd, planMode }, makeConfirmCallback(rl));
+          { sessionDir, cwd, planMode }, makeConfirmCallback(ui));
           process.stdout.write('\n\n');
         } catch(e) { console.error(red(`  Error: ${e.message}\n`)); }
-        isProcessing = false; rl.resume(); rl.prompt();
+        isProcessing = false; ui.resume();
         return;
       }
 
@@ -758,7 +735,7 @@ async function run() {
           planMode = !planMode;
           if (planMode) console.log(yellow('  Plan mode ON — read-only, no writes or execution.\n'));
           else console.log(green('  Plan mode OFF — full capabilities restored.\n'));
-          rl.setPrompt(planMode ? yellow('❯ [plan] ') : cyan('❯ '));
+          ui.setPlanMode(planMode);
           break;
         case 'undo': {
           const restored = undo();
@@ -997,6 +974,7 @@ async function run() {
         case 'model':
           if (rest[0]) {
             setModel(rest[0]);
+            ui.setModelLabel(rest[0]);
             console.log(green(`  Model changed to: ${rest[0]}\n`));
           } else {
             console.log(dim(`  Current model: ${getModel()}\n`));
@@ -1174,7 +1152,7 @@ Output ONLY the TSUNAMI.md content, starting with "# Project: <name>"`;
         default:
           console.log(red(`  Unknown command: /${cmd}\n`));
       }
-      rl.prompt();
+      ui.resume();
       return;
     }
 
@@ -1206,7 +1184,7 @@ Output ONLY the TSUNAMI.md content, starting with "# Project: <name>"`;
     ];
     messages.push({ role: 'user', content: userContent });
 
-    rl.pause();
+    ui.pause();
     isProcessing = true;
     process.stdout.write('\n');
 
@@ -1243,7 +1221,7 @@ Output ONLY the TSUNAMI.md content, starting with "# Project: <name>"`;
           firstToken = true;
         },
         { sessionDir, cwd, planMode },
-        makeConfirmCallback(rl)
+        makeConfirmCallback(ui)
       );
       spinner.stop();
       flushHighlighter(highlight);
@@ -1286,27 +1264,13 @@ Output ONLY the TSUNAMI.md content, starting with "# Project: <name>"`;
       gracefulExit(0);
       return;
     }
-    rl.resume();
-    rl.prompt();
+    ui.resume();
   }
 
+  // SIGINT from kill -INT (keyboard Ctrl+C is handled in raw mode inside ui.js)
   process.on('SIGINT', () => {
-    if (!isProcessing) {
-      gracefulExit(0);
-    } else {
-      // Remove interrupted command from history (from history.ts removeLastFromHistory)
-      try {
-        if (existsSync(HISTORY_FILE)) {
-          const lines = readFileSync(HISTORY_FILE, 'utf8').trimEnd().split('\n').filter(Boolean);
-          if (lines.length > 0) lines.pop();
-          import('fs').then(({ writeFileSync: wfs }) => {
-            try { wfs(HISTORY_FILE, lines.join('\n') + (lines.length ? '\n' : ''), 'utf8'); } catch {}
-          });
-        }
-      } catch {}
-      pendingClose = true;
-      console.log(dim('\n  (interrupted)\n'));
-    }
+    if (!isProcessing) gracefulExit(0);
+    else pendingClose = true;
   });
 }
 

package/lib/ui.js

@@ -0,0 +1,365 @@
+// lib/ui.js — sticky-bottom terminal UI
+// Pins a 4-line area at the bottom of the terminal:
+//   ╭─ tsunami ───────────────────────────────────────────────╮
+//   │ ❯ input                                                 │
+//   ╰─────────────────────────────────────────────────────────╯
+//     model-name                                         (dim)
+// All output (replies, tool calls, spinner) scrolls above.
+// Uses ANSI scroll region so the bottom box never scrolls away.
+
+import chalk from 'chalk';
+
+const cyan   = (s) => chalk.cyan(s);
+const yellow = (s) => chalk.yellow(s);
+const dim    = (s) => chalk.dim(s);
+
+const BOX_LINES = 4; // top border + input + bottom border + model label
+
+export function createUI({ planMode: initPlanMode = false, onLine, onTab, onExit }) {
+  let planMode     = initPlanMode;
+  let continuation = false;
+  let modelLabel   = '';
+  let inputBuf     = '';
+  let cursorPos    = 0;
+  let history      = [];
+  let histIdx      = 0;
+  let histDraft    = '';
+  let processing   = false;
+  let lineHandler  = null;
+  let _interrupted = false;
+
+  const rows = () => process.stdout.rows    || 24;
+  const cols = () => process.stdout.columns || 80;
+
+  // ── Scroll region ──────────────────────────────────────────────────────────
+  // Rows 1 .. (rows-BOX_LINES) scroll. The bottom BOX_LINES rows stay fixed.
+
+  function setScrollRegion() {
+    process.stdout.write(`\x1b[1;${rows() - BOX_LINES}r`);
+  }
+
+  function resetScrollRegion() {
+    process.stdout.write('\x1b[r');
+  }
+
+  function goOutputArea() {
+    process.stdout.write(`\x1b[${rows() - BOX_LINES};1H`);
+  }
+
+  // ── Box drawing ────────────────────────────────────────────────────────────
+  // Draws using absolute row numbers from the actual terminal bottom.
+
+  function drawBox() {
+    const w  = cols();
+    const r  = rows();       // last row of terminal
+    const rT = r - 3;        // top border    ╭─────╮
+    const rI = r - 2;        // input line    │ ❯   │
+    const rB = r - 1;        // bottom border ╰─────╯
+    const rM = r;            // model label
+
+    process.stdout.write('\x1b[s');   // save cursor
+
+    // Top border ─────────────────────────────────────────────────────
+    const label     = ' tsunami ';
+    const rightFill = Math.max(0, w - 2 - 1 - label.length);
+    const topLine   = `╭─${label}${'─'.repeat(rightFill)}╮`;
+    process.stdout.write(`\x1b[${rT};1H\x1b[2K${topLine.slice(0, w)}`);
+
+    // Input line ──────────────────────────────────────────────────────
+    let prefix;
+    if (continuation)  prefix = ` ${dim('···')} `;
+    else if (planMode) prefix = ` ${yellow('❯')} ${dim('[plan]')} `;
+    else               prefix = ` ${cyan('❯')} `;
+
+    const prefixVis = prefix.replace(/\x1b\[[0-9;]*m/g, '');
+    const innerW    = w - 2;
+    const maxInput  = Math.max(0, innerW - prefixVis.length - 1);
+
+    let dispInput  = inputBuf;
+    let dispCursor = cursorPos;
+    if (dispInput.length > maxInput) {
+      const start = Math.max(0, cursorPos - maxInput + 1);
+      dispInput  = inputBuf.slice(start);
+      dispCursor = cursorPos - start;
+    }
+    const display = dispInput.slice(0, maxInput);
+    const pad     = ' '.repeat(Math.max(0, maxInput - display.length));
+    process.stdout.write(`\x1b[${rI};1H\x1b[2K│${prefix}${display}${pad} │`);
+
+    // Bottom border ───────────────────────────────────────────────────
+    const botLine = `╰${'─'.repeat(w - 2)}╯`;
+    process.stdout.write(`\x1b[${rB};1H\x1b[2K${botLine.slice(0, w)}`);
+
+    // Model label ─────────────────────────────────────────────────────
+    const ml = modelLabel ? `  ${dim(modelLabel)}` : '';
+    process.stdout.write(`\x1b[${rM};1H\x1b[2K${ml}`);
+
+    // Position cursor in input line at correct column ─────────────────
+    const curCol = 1 + prefixVis.length + 1 + Math.min(dispCursor, display.length);
+    process.stdout.write(`\x1b[${rI};${curCol}H`);
+  }
+
+  // ── Raw key handler ────────────────────────────────────────────────────────
+
+  function handleKey(chunk) {
+    const key = chunk.toString('utf8');
+
+    if (lineHandler) { lineHandler(key); return; }
+
+    // Ctrl+C
+    if (key === '\x03') {
+      if (processing) {
+        _interrupted = true;
+        process.stdout.write(dim('\n  (interrupted)\n'));
+      } else if (inputBuf !== '') {
+        inputBuf  = '';
+        cursorPos = 0;
+        drawBox();
+      } else {
+        exitUI();
+        onExit(0);
+      }
+      return;
+    }
+
+    // Ctrl+D
+    if (key === '\x04') {
+      if (!processing && inputBuf === '') { exitUI(); onExit(0); }
+      return;
+    }
+
+    if (processing) return;
+
+    // Enter
+    if (key === '\r' || key === '\n') {
+      const line = inputBuf;
+      if (line || continuation) {
+        if (line) {
+          history.push(line);
+          histIdx   = history.length;
+          histDraft = '';
+        }
+        inputBuf  = '';
+        cursorPos = 0;
+        drawBox();
+        goOutputArea();
+        process.stdout.write('\n');
+        onLine(line);
+      }
+      return;
+    }
+
+    // Backspace
+    if (key === '\x7f' || key === '\x08') {
+      if (cursorPos > 0) {
+        inputBuf = inputBuf.slice(0, cursorPos - 1) + inputBuf.slice(cursorPos);
+        cursorPos--;
+        drawBox();
+      }
+      return;
+    }
+
+    // Tab
+    if (key === '\t') {
+      if (!onTab) return;
+      const [hits] = onTab(inputBuf);
+      if (!hits.length) return;
+      if (hits.length === 1) {
+        inputBuf  = hits[0];
+        cursorPos = hits[0].length;
+        drawBox();
+        return;
+      }
+      const prefix = hits.reduce((a, b) => {
+        let i = 0;
+        while (i < a.length && i < b.length && a[i] === b[i]) i++;
+        return a.slice(0, i);
+      });
+      goOutputArea();
+      const shown = hits.slice(0, 8).join('  ') + (hits.length > 8 ? ` …+${hits.length - 8}` : '');
+      process.stdout.write('\n  ' + dim(shown) + '\n');
+      if (prefix.length > inputBuf.length) {
+        inputBuf  = prefix;
+        cursorPos = prefix.length;
+      }
+      drawBox();
+      return;
+    }
+
+    // Arrow keys / navigation
+    if (key === '\x1b[A') {
+      if (histIdx > 0) {
+        if (histIdx === history.length) histDraft = inputBuf;
+        histIdx--;
+        inputBuf  = history[histIdx] || '';
+        cursorPos = inputBuf.length;
+        drawBox();
+      }
+      return;
+    }
+    if (key === '\x1b[B') {
+      if (histIdx < history.length) {
+        histIdx++;
+        inputBuf  = histIdx === history.length ? histDraft : history[histIdx] || '';
+        cursorPos = inputBuf.length;
+        drawBox();
+      }
+      return;
+    }
+    if (key === '\x1b[D')   { cursorPos = Math.max(0, cursorPos - 1);             drawBox(); return; }
+    if (key === '\x1b[C')   { cursorPos = Math.min(inputBuf.length, cursorPos+1); drawBox(); return; }
+    if (key === '\x1b[H' || key === '\x01') { cursorPos = 0;               drawBox(); return; }
+    if (key === '\x1b[F' || key === '\x05') { cursorPos = inputBuf.length; drawBox(); return; }
+    if (key === '\x1b[3~') {
+      if (cursorPos < inputBuf.length) {
+        inputBuf = inputBuf.slice(0, cursorPos) + inputBuf.slice(cursorPos + 1);
+        drawBox();
+      }
+      return;
+    }
+
+    // Editing shortcuts
+    if (key === '\x0b') { inputBuf = inputBuf.slice(0, cursorPos); drawBox(); return; }
+    if (key === '\x15') { inputBuf = inputBuf.slice(cursorPos); cursorPos = 0; drawBox(); return; }
+    if (key === '\x17') {
+      const before    = inputBuf.slice(0, cursorPos).trimEnd();
+      const lastSpace = before.lastIndexOf(' ');
+      const newBefore = lastSpace < 0 ? '' : before.slice(0, lastSpace + 1);
+      inputBuf  = newBefore + inputBuf.slice(cursorPos);
+      cursorPos = newBefore.length;
+      drawBox();
+      return;
+    }
+    if (key === '\x0c') {
+      process.stdout.write('\x1b[2J\x1b[1;1H');
+      setScrollRegion();
+      drawBox();
+      return;
+    }
+
+    if (key.startsWith('\x1b')) return;
+
+    if (key >= ' ' || key.charCodeAt(0) > 127) {
+      inputBuf   = inputBuf.slice(0, cursorPos) + key + inputBuf.slice(cursorPos);
+      cursorPos += key.length;
+      drawBox();
+    }
+  }
+
+  // ── readLine / readChar ────────────────────────────────────────────────────
+
+  function readLine(promptText) {
+    return new Promise((resolve) => {
+      let buf = '';
+      process.stdout.write(promptText);
+      lineHandler = (key) => {
+        if (key === '\r' || key === '\n') {
+          lineHandler = null;
+          process.stdout.write('\n');
+          resolve(buf);
+        } else if (key === '\x7f' || key === '\x08') {
+          if (buf.length > 0) { buf = buf.slice(0, -1); process.stdout.write('\x08 \x08'); }
+        } else if (key === '\x03') {
+          lineHandler = null;
+          process.stdout.write('\n');
+          resolve('');
+        } else if (key >= ' ') {
+          buf += key;
+          process.stdout.write(key);
+        }
+      };
+    });
+  }
+
+  function readChar(promptText) {
+    return new Promise((resolve) => {
+      process.stdout.write(promptText);
+      lineHandler = (key) => {
+        if (key === '\x03' || key === '\r' || key === '\n' || key >= ' ') {
+          lineHandler = null;
+          const ch = (key === '\r' || key === '\n' || key === '\x03') ? '' : key;
+          process.stdout.write(ch + '\n');
+          resolve(ch);
+        }
+      };
+    });
+  }
+
+  // ── Public API ─────────────────────────────────────────────────────────────
+
+  function start(preloadHistory = []) {
+    if (!process.stdin.isTTY) return;
+
+    history = [...preloadHistory];
+    histIdx = history.length;
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', handleKey);
+
+    process.stdout.on('resize', () => {
+      setScrollRegion();
+      drawBox();
+    });
+
+    // Push existing content up to make room for the box.
+    process.stdout.write('\n'.repeat(BOX_LINES));
+    setScrollRegion();
+    goOutputArea();
+    drawBox();
+  }
+
+  function pause() {
+    processing = true;
+    goOutputArea();
+  }
+
+  function resume() {
+    processing = false;
+    drawBox();
+  }
+
+  function setPlanMode(val) {
+    planMode = val;
+    if (!processing) drawBox();
+  }
+
+  function setContinuation(val) {
+    continuation = val;
+    if (!processing) drawBox();
+  }
+
+  function setModelLabel(label) {
+    modelLabel = label;
+    if (!processing) drawBox();
+  }
+
+  function wasInterrupted() {
+    const v = _interrupted;
+    _interrupted = false;
+    return v;
+  }
+
+  function exitUI() {
+    resetScrollRegion();
+    const r = rows();
+    for (let i = 0; i < BOX_LINES; i++) {
+      process.stdout.write(`\x1b[${r - BOX_LINES + 1 + i};1H\x1b[2K`);
+    }
+    process.stdout.write(`\x1b[${r - BOX_LINES + 1};1H`);
+    try { process.stdin.setRawMode(false); } catch {}
+  }
+
+  function stop(code = 0) {
+    exitUI();
+    process.exit(code);
+  }
+
+  return {
+    start, pause, resume,
+    setPlanMode, setContinuation, setModelLabel,
+    readLine, readChar,
+    wasInterrupted, stop, exitUI,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsunami-code",
-  "version": "3.10.0",
+  "version": "3.11.1",
   "description": "Tsunami Code CLI — AI coding agent by Keystone World Management Navy Seal Unit XI3",
   "type": "module",
   "bin": {