tsunami-code 2.6.1 → 2.7.0

package/index.js

@@ -4,10 +4,10 @@ import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import os from 'os';
-import { agentLoop } from './lib/loop.js';
+import { agentLoop, quickCompletion } from './lib/loop.js';
 import { buildSystemPrompt } from './lib/prompt.js';
-import { runPreflight } from './lib/preflight.js';
-import { setSession } from './lib/tools.js';
+import { runPreflight, checkServer } from './lib/preflight.js';
+import { setSession, undo, undoStackSize } from './lib/tools.js';
 import {
   initSession,
   initProjectMemory,
@@ -20,7 +20,7 @@ import {
   getSessionContext
 } from './lib/memory.js';
 
-const VERSION = '2.6.1';
+const VERSION = '2.7.0';
 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';
@@ -129,10 +129,29 @@ if (setServerIdx !== -1 && argv[setServerIdx + 1]) {
   process.exit(0);
 }
 
+// ── Confirm Callback (dangerous command prompt) ─────────────────────────────
+function makeConfirmCallback(rl) {
+  return 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);
+    });
+  };
+}
+
 // ── Main ──────────────────────────────────────────────────────────────────────
 async function run() {
   const serverUrl = getServerUrl(argv);
   const cwd = process.cwd();
+  let planMode = argv.includes('--plan');
 
   // Initialize memory systems
   const { sessionId, sessionDir } = initSession(cwd);
@@ -168,6 +187,39 @@ async function run() {
   let currentServerUrl = serverUrl;
   let messages = [];
   let systemPrompt = buildSystemPrompt();
+  let _inputTokens = 0;
+  let _outputTokens = 0;
+
+  // --resume: inject last session summary
+  if (argv.includes('--resume')) {
+    const lastSummary = getLastSessionSummary(cwd);
+    if (lastSummary) {
+      console.log(dim('  Resuming from last session...\n'));
+      messages.push({ role: 'user', content: `[Resuming]\n\n${lastSummary}` });
+      messages.push({ role: 'assistant', content: 'Understood, I have the previous session context. Ready to continue.' });
+    }
+  }
+
+  // Compact messages helper
+  async function compactMessages(focus = '') {
+    if (messages.length < 3) { console.log(dim('  Nothing substantial to compact.\n')); return; }
+    process.stdout.write(dim('  ↯ Compacting...'));
+    const historyText = messages
+      .filter(m => !['system'].includes(m.role))
+      .map(m => {
+        const c = typeof m.content === 'string' ? m.content.slice(0, 250) : '[tool result]';
+        return `${m.role.toUpperCase()}: ${c}`;
+      }).join('\n\n');
+    const focusLine = focus ? ` Focus on: ${focus}.` : '';
+    const prompt = `Summarize this conversation in 4-6 bullet points. Preserve: goal, files changed, key decisions, current progress, next step.${focusLine}\n\n${historyText}`;
+    const summary = await quickCompletion(currentServerUrl, buildSystemPrompt(), prompt);
+    const before = messages.length;
+    messages = summary
+      ? [{ role: 'user', content: `[Compacted — ${before} messages]\n\n${summary}` }, { role: 'assistant', content: 'Understood, continuing.' }]
+      : messages.slice(-4);
+    process.stdout.write('\r' + ' '.repeat(25) + '\r');
+    console.log(green('  ✓ Compacted') + dim(` ${before} → ${messages.length} messages\n`));
+  }
 
   function resetSession() {
     messages = [];
@@ -186,7 +238,7 @@ async function run() {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: cyan('❯ '),
+    prompt: planMode ? yellow('❯ [plan] ') : cyan('❯ '),
     terminal: process.stdin.isTTY
   });
 
@@ -301,17 +353,74 @@ async function run() {
 
       switch (cmd) {
         case 'help':
-          console.log(dim(`
-  Commands:
-    /clear            Start new conversation
-    /status           Show context size
-    /server <url>     Change server URL for this session
-    /memory           Show memory stats
-    /memory files     List files with memory entries
-    /memory view <f>  Show memory for a file
-    /memory clear     Clear session memory (keep project memory)
-    /exit             Exit
-`));
+          console.log(blue('\n  Tsunami Code CLI — Commands\n'));
+          {
+            const cmds = [
+              ['/compact [focus]', 'Summarize context and continue'],
+              ['/plan',            'Toggle read-only plan mode'],
+              ['/undo',            'Undo last file change'],
+              ['/doctor',          'Run health diagnostics'],
+              ['/cost',            'Show token usage estimate'],
+              ['/memory',          'Show project memory stats'],
+              ['/memory files',    'List files with memory'],
+              ['/memory view <f>', 'Show memory for a file'],
+              ['/memory last',     'Show last session summary'],
+              ['/memory clear',    'Clear session memory'],
+              ['/clear',           'Start new conversation'],
+              ['/status',          'Show context size and server'],
+              ['/server <url>',    'Change model server URL'],
+              ['/exit',            'Exit'],
+            ];
+            for (const [c, desc] of cmds) {
+              console.log(`  ${cyan(c.padEnd(22))} ${dim(desc)}`);
+            }
+            console.log();
+          }
+          break;
+        case 'compact':
+          await compactMessages(rest.join(' '));
+          break;
+        case 'plan':
+          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('❯ '));
+          break;
+        case 'undo': {
+          const restored = undo();
+          if (restored) console.log(green(`  ✓ Restored: ${restored}\n`));
+          else console.log(dim('  Nothing to undo.\n'));
+          break;
+        }
+        case 'doctor': {
+          const { getRgPath } = await import('./lib/preflight.js');
+          const { getMemoryStats: _getMemoryStats } = await import('./lib/memory.js');
+
+          const nodeVer = process.versions.node;
+          const nodeMajor = parseInt(nodeVer.split('.')[0]);
+          const rgPath = getRgPath();
+          const stats = _getMemoryStats(cwd);
+          const hasTsunami = existsSync(join(cwd, '.tsunami'));
+          const hasTsunamiMd = existsSync(join(cwd, 'TSUNAMI.md'));
+          const serverOk = await checkServer(currentServerUrl).catch(() => false);
+
+          console.log(blue('\n  🩺 Tsunami Code Diagnostics\n'));
+          console.log((nodeMajor >= 18 ? green : red)(`  ${nodeMajor >= 18 ? '✓' : '✗'} Node.js v${nodeVer}`));
+          console.log((serverOk ? green : red)(`  ${serverOk ? '✓' : '✗'} Server: ${currentServerUrl}`));
+          console.log((rgPath ? green : yellow)(`  ${rgPath ? '✓' : '⚠'} ripgrep: ${rgPath || 'not found'}`));
+          console.log((hasTsunami ? green : dim)(`  ${hasTsunami ? '✓' : '○'} Project memory: ${hasTsunami ? `.tsunami/ (${stats.projectMemoryFiles} files, ${formatBytes(stats.projectMemorySize)})` : 'none'}`));
+          console.log((hasTsunamiMd ? green : yellow)(`  ${hasTsunamiMd ? '✓' : '⚠'} TSUNAMI.md: ${hasTsunamiMd ? 'found' : 'not found (add one for project instructions)'}`));
+          console.log(dim(`\n  Session : ${sessionId}`));
+          console.log(dim(`  Version : tsunami-code v${VERSION}`));
+          console.log(dim(`  CWD     : ${cwd}\n`));
+          break;
+        }
+        case 'cost':
+          console.log(blue('\n  Session Token Estimate'));
+          console.log(dim(`  Input  : ~${_inputTokens.toLocaleString()}`));
+          console.log(dim(`  Output : ~${_outputTokens.toLocaleString()}`));
+          console.log(dim(`  Total  : ~${(_inputTokens + _outputTokens).toLocaleString()}`));
+          console.log(dim('  (Estimates only)\n'));
           break;
         case 'clear':
           resetSession();
@@ -371,14 +480,27 @@ async function run() {
           printToolCall(toolName, toolArgs);
           firstToken = true;
         },
-        { sessionDir, cwd }
+        { sessionDir, cwd, planMode },
+        makeConfirmCallback(rl)
       );
 
+      // Token estimation
+      const inputChars = fullMessages.reduce((s, m) => s + (typeof m.content === 'string' ? m.content.length : 0), 0);
+      _inputTokens += Math.round(inputChars / 4);
+      const outputChars = fullMessages.filter(m => m.role === 'assistant').reduce((s, m) => s + (m.content?.length || 0), 0);
+      _outputTokens = Math.round(outputChars / 4);
+
       // Update messages from the loop (fullMessages was mutated by agentLoop)
       // Trim to rolling window: keep system + last 8 entries
       const loopMessages = fullMessages.slice(1); // drop system, agentLoop added to fullMessages
       messages = trimMessages([{ role: 'system', content: systemPrompt }, ...loopMessages]).slice(1);
 
+      // Auto-compact
+      if (messages.length > 24) {
+        await compactMessages();
+        console.log(dim('  ↯ Auto-compacted\n'));
+      }
+
       process.stdout.write('\n\n');
     } catch (e) {
       process.stdout.write('\n');

package/lib/loop.js

@@ -7,6 +7,25 @@ import {
   appendDecision
 } from './memory.js';
 
+// ── Dangerous command detection ──────────────────────────────────────────────
+const DANGEROUS_PATTERNS = [
+  /rm\s+-[rf]+\s+[^-]/,
+  /DROP\s+TABLE/i,
+  /DROP\s+DATABASE/i,
+  /DROP\s+SCHEMA/i,
+  /ALTER\s+TABLE.*DROP\s+COLUMN/i,
+  /git\s+push\s+.*--force/,
+  /git\s+push\s+-f\b/,
+  /git\s+reset\s+--hard/,
+  /del\s+\/[sf]/i,
+  /Remove-Item.*-Recurse.*-Force/i,
+  /truncate\s+table/i,
+  /delete\s+from\s+\w+\s*;?\s*$/i,
+];
+function isDangerous(cmd) {
+  return DANGEROUS_PATTERNS.some(p => p.test(cmd || ''));
+}
+
 // Skip waitForServer after first successful connection
 let _serverVerified = false;
 
@@ -226,7 +245,35 @@ async function streamCompletion(serverUrl, messages, onToken, memoryContext = ''
  * @param {{ sessionDir: string, cwd: string } | null} sessionInfo
  * @param {number} maxIterations
  */
-export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessionInfo = null, maxIterations = 15) {
+export async function quickCompletion(serverUrl, systemPrompt, userMessage) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 12000);
+  try {
+    const res = await fetch(`${serverUrl}/v1/chat/completions`, {
+      method: 'POST',
+      signal: controller.signal,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: 'local',
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userMessage }
+        ],
+        stream: false,
+        temperature: 0.1,
+        max_tokens: 600
+      })
+    });
+    clearTimeout(timer);
+    const json = await res.json();
+    return json.choices?.[0]?.message?.content || '';
+  } catch {
+    clearTimeout(timer);
+    return '';
+  }
+}
+
+export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessionInfo = null, confirmCallback = null, maxIterations = 15) {
   const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
   const currentTask = typeof lastUserMsg?.content === 'string' ? lastUserMsg.content : '';
 
@@ -258,6 +305,27 @@ export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessio
 
     const results = [];
     for (const tc of toolCalls) {
+      // Plan mode: block Write, Edit, Bash
+      if (sessionInfo?.planMode && ['Write', 'Edit', 'Bash'].includes(tc.name)) {
+        results.push(`[${tc.name} result]\n[PLAN MODE] ${tc.name} is disabled. Describe what you would do instead.`);
+        onToolCall(tc.name, typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments));
+        continue;
+      }
+
+      // Dangerous command confirmation
+      if (tc.name === 'Bash' && confirmCallback) {
+        const parsed = typeof tc.arguments === 'string' ? JSON.parse(tc.arguments) : tc.arguments;
+        const normalized = normalizeArgs(parsed);
+        if (isDangerous(normalized.command)) {
+          const ok = await confirmCallback(normalized.command);
+          if (!ok) {
+            onToolCall(tc.name, typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments));
+            results.push(`[${tc.name} result]\nCommand blocked by user. Find a safer approach to accomplish this.`);
+            continue;
+          }
+        }
+      }
+
       onToolCall(tc.name, typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments));
       const result = await runTool(tc.name, tc.arguments, sessionInfo, sessionFiles);
       results.push(`[${tc.name} result]\n${String(result).slice(0, 8000)}`);

package/lib/tools.js

@@ -7,6 +7,16 @@ import { addFileNote, updateContext, appendDecision } from './memory.js';
 
 const execAsync = promisify(exec);
 
+// ── Undo Stack ───────────────────────────────────────────────────────────────
+const _undoStack = [];
+const MAX_UNDO = 20;
+export function undo() {
+  if (_undoStack.length === 0) return null;
+  const { filePath, content } = _undoStack.pop();
+  try { writeFileSync(filePath, content, 'utf8'); return filePath; } catch { return null; }
+}
+export function undoStackSize() { return _undoStack.length; }
+
 // ── Session Context (set by index.js at startup) ──────────────────────────────
 let _sessionDir = null;
 let _cwd = null;
@@ -97,6 +107,13 @@ export const WriteTool = {
   },
   async run({ file_path, content }) {
     try {
+      // Undo stack: save previous content before overwriting
+      try {
+        if (existsSync(file_path)) {
+          _undoStack.push({ filePath: file_path, content: readFileSync(file_path, 'utf8') });
+          if (_undoStack.length > MAX_UNDO) _undoStack.shift();
+        }
+      } catch {}
       writeFileSync(file_path, content, 'utf8');
       return `Written ${content.split('\n').length} lines to ${file_path}`;
     } catch (e) {
@@ -127,6 +144,11 @@ export const EditTool = {
     if (!existsSync(file_path)) return `Error: File not found: ${file_path}`;
     try {
       let content = readFileSync(file_path, 'utf8');
+      // Undo stack: save current content before editing
+      try {
+        _undoStack.push({ filePath: file_path, content });
+        if (_undoStack.length > MAX_UNDO) _undoStack.shift();
+      } catch {}
       if (!content.includes(old_string)) return `Error: old_string not found in ${file_path}`;
       if (!replace_all) {
         const count = content.split(old_string).length - 1;

package/package.json

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