tsunami-code 3.12.6 → 3.12.7

package/index.js

@@ -27,7 +27,7 @@ import {
 import { listMemories, readMemory, saveMemory, deleteMemory, getMemdirPath } from './lib/memdir.js';
 import { execSync, spawn } from 'child_process';
 
-const VERSION = '3.12.6';
+const VERSION = '3.12.7';
 const CONFIG_DIR = join(os.homedir(), '.tsunami-code');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
 const DEFAULT_SERVER = 'https://radiometric-reita-amuck.ngrok-free.dev';

package/lib/tools.js

@@ -14,6 +14,11 @@ const execAsync = promisify(exec);
 // ── Lines Changed Tracking ────────────────────────────────────────────────────
 export const linesChanged = { added: 0, removed: 0 };
 
+// ── File Changelog Tracking (feature 5) ──────────────────────────────────────
+export const fileChangelog = new Map(); // path → { action: 'created'|'modified'|'deleted', lines: number }
+export function getFileChangelog() { return fileChangelog; }
+export function clearFileChangelog() { fileChangelog.clear(); }
+
 // ── Undo Stack (per-turn batching) ───────────────────────────────────────────
 const _undoTurns = [];
 let _currentTurnFiles = [];
@@ -613,11 +618,49 @@ export const WriteTool = {
     try {
       _pushFileSnapshot(file_path);
       const newLineCount = content.split('\n').length;
-      const oldLineCount = existsSync(file_path) ? readFileSync(file_path, 'utf8').split('\n').length : 0;
+      const fileExists = existsSync(file_path);
+      const oldContent = fileExists ? readFileSync(file_path, 'utf8') : '';
+      const oldLineCount = fileExists ? oldContent.split('\n').length : 0;
+
+      // Feature 8: Show diff and ask confirmation when overwriting an existing file
+      if (fileExists && TSUNAMI_MODE !== 'bypass' && TSUNAMI_MODE !== 'accept-edits') {
+        const oldLines = oldContent.split('\n');
+        const newLines = content.split('\n');
+        const diffLines = [];
+        const maxLen = Math.max(oldLines.length, newLines.length);
+        for (let i = 0; i < maxLen; i++) {
+          if (i >= oldLines.length) {
+            diffLines.push(`\x1b[32m+ ${newLines[i]}\x1b[0m`);
+          } else if (i >= newLines.length) {
+            diffLines.push(`\x1b[31m- ${oldLines[i]}\x1b[0m`);
+          } else if (oldLines[i] !== newLines[i]) {
+            diffLines.push(`\x1b[31m- ${oldLines[i]}\x1b[0m`);
+            diffLines.push(`\x1b[32m+ ${newLines[i]}\x1b[0m`);
+          }
+        }
+        if (diffLines.length > 0) {
+          const preview = diffLines.slice(0, 40).join('\n');
+          process.stdout.write(`\n${preview}${diffLines.length > 40 ? `\n  ... (${diffLines.length - 40} more diff lines)` : ''}\n`);
+        }
+        const confirmed = await new Promise(resolve => {
+          const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+          rl.question(`  Write to ${file_path}? [Y/n] `, answer => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() !== 'n');
+          });
+        });
+        if (!confirmed) return 'Write cancelled by user';
+      }
+
       writeFileSync(file_path, content, 'utf8');
       linesChanged.added += Math.max(0, newLineCount - oldLineCount);
       linesChanged.removed += Math.max(0, oldLineCount - newLineCount);
       recordWriteAudit(file_path, 'Write', `${newLineCount} lines`);
+
+      // Feature 5: track file changelog
+      const resolved = safeResolve(file_path);
+      fileChangelog.set(resolved, { action: fileExists ? 'modified' : 'created', lines: newLineCount });
+
       return `Written ${newLineCount} lines to ${file_path}`;
     } catch (e) {
       return `Error writing file: ${e.message}`;
@@ -1059,20 +1102,37 @@ IMPORTANT: You can call Agent multiple times in one response to run tasks truly
     if (!_currentServerUrl) return 'Error: AgentTool not initialized (no server URL)';
 
     const url = serverUrl || _currentServerUrl;
+    const taskPreview = task.slice(0, 60).replace(/\n/g, ' ');
+    process.stdout.write(`\n  ◎ Agent spawning: ${taskPreview}${task.length > 60 ? '...' : ''}\n`);
+
     const subMessages = [
       { role: 'system', content: _agentSystemPrompt || 'You are a capable software engineering sub-agent. Complete the given task fully and return a summary of what you did.' },
       { role: 'user', content: task }
     ];
 
     const outputTokens = [];
+    const frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
+    let frameIdx = 0;
+    const spinInterval = setInterval(() => {
+      process.stdout.write(`\r  ◎ Agent working ${frames[frameIdx++ % frames.length]}   `);
+    }, 500);
+
     try {
       await _agentLoopRef(url, subMessages, (token) => { outputTokens.push(token); }, () => {}, null, null, 10);
     } catch (e) {
+      clearInterval(spinInterval);
+      process.stdout.write('\r' + ' '.repeat(40) + '\r');
       return `Sub-agent error: ${e.message}`;
     }
 
+    clearInterval(spinInterval);
+    process.stdout.write('\r' + ' '.repeat(40) + '\r');
+
     const lastAssistant = [...subMessages].reverse().find(m => m.role === 'assistant');
     const result = lastAssistant?.content || outputTokens.join('');
+    const resultPreview = result.slice(0, 100).replace(/\n/g, ' ');
+    process.stdout.write(`  ◎ Agent done — ${resultPreview}${result.length > 100 ? '...' : ''}\n`);
+
     return `[Sub-agent result]\n${String(result).slice(0, 6000)}`;
   }
 };

package/lib/ui.js

@@ -28,6 +28,9 @@ export function createUI({ planMode: initPlanMode = false, onLine, onTab, onExit
   let processing   = false;
   let lineHandler  = null;
   let _interrupted = false;
+  let _abortController = null;
+  let vimMode      = false;
+  let vimInsert    = true; // starts in insert mode
 
   const rows = () => process.stdout.rows    || 24;
   const cols = () => process.stdout.columns || 80;
@@ -138,8 +141,83 @@ export function createUI({ planMode: initPlanMode = false, onLine, onTab, onExit
       return;
     }
 
+    // Escape — pure ESC (not followed by [ which would be an arrow/function key)
+    if (key === '\x1b') {
+      if (processing) {
+        _interrupted = true;
+        if (_abortController) _abortController.abort();
+        process.stdout.write(dim('\n  ✗ Interrupted\n'));
+      } else if (vimMode) {
+        // Enter vim normal mode
+        vimInsert = false;
+        drawBox();
+      }
+      return;
+    }
+
     if (processing) return;
 
+    // Vim normal mode key handling
+    if (vimMode && !vimInsert) {
+      switch (key) {
+        case 'i':
+          vimInsert = true;
+          drawBox();
+          return;
+        case 'a':
+          vimInsert = true;
+          cursorPos = Math.min(inputBuf.length, cursorPos + 1);
+          drawBox();
+          return;
+        case 'h':
+          cursorPos = Math.max(0, cursorPos - 1);
+          drawBox();
+          return;
+        case 'l':
+          cursorPos = Math.min(inputBuf.length, cursorPos + 1);
+          drawBox();
+          return;
+        case 'w': {
+          // jump to start of next word
+          let i = cursorPos;
+          // skip current word chars
+          while (i < inputBuf.length && inputBuf[i] !== ' ') i++;
+          // skip spaces
+          while (i < inputBuf.length && inputBuf[i] === ' ') i++;
+          cursorPos = i;
+          drawBox();
+          return;
+        }
+        case 'b': {
+          // jump to start of previous word
+          let i = cursorPos - 1;
+          // skip spaces before cursor
+          while (i > 0 && inputBuf[i - 1] === ' ') i--;
+          // skip word chars
+          while (i > 0 && inputBuf[i - 1] !== ' ') i--;
+          cursorPos = Math.max(0, i);
+          drawBox();
+          return;
+        }
+        case '0':
+          cursorPos = 0;
+          drawBox();
+          return;
+        case '$':
+          cursorPos = inputBuf.length;
+          drawBox();
+          return;
+        case 'x':
+          if (cursorPos < inputBuf.length) {
+            inputBuf = inputBuf.slice(0, cursorPos) + inputBuf.slice(cursorPos + 1);
+            drawBox();
+          }
+          return;
+        default:
+          return; // ignore unmapped keys in normal mode
+      }
+    }
+
     // Enter
     if (key === '\r' || key === '\n') {
       const line = inputBuf;
@@ -417,6 +495,16 @@ export function createUI({ planMode: initPlanMode = false, onLine, onTab, onExit
     return v;
   }
 
+  function setAbortController(ac) {
+    _abortController = ac;
+  }
+
+  function setVimMode(val) {
+    vimMode = val;
+    vimInsert = true; // always start in insert mode when toggling
+    if (!processing) drawBox();
+  }
+
   function exitUI() {
     resetScrollRegion();
     const r = rows();
@@ -436,6 +524,6 @@ export function createUI({ planMode: initPlanMode = false, onLine, onTab, onExit
     start, pause, resume,
     setPlanMode, setContinuation, setModelLabel, setModeLabel,
     readLine, readChar, selectFromList,
-    wasInterrupted, stop, exitUI,
+    wasInterrupted, setAbortController, setVimMode, stop, exitUI,
   };
 }

package/package.json

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