tsunami-code 2.5.2 → 2.6.0

package/.tsunami/README.md

@@ -0,0 +1,10 @@
+# .tsunami/ — Project Memory
+
+Auto-managed by Tsunami Code CLI. Safe to commit.
+
+## Structure
+- `memory/` — Per-file notes and change history
+- `decisions/` — Team-shared decision log by date
+- `CODEBASE.md` — High-level project understanding
+
+Do not edit manually unless you know what you're doing.

package/index.js

@@ -7,8 +7,20 @@ import os from 'os';
 import { agentLoop } from './lib/loop.js';
 import { buildSystemPrompt } from './lib/prompt.js';
 import { runPreflight } from './lib/preflight.js';
-
-const VERSION = '2.5.2';
+import { setSession } from './lib/tools.js';
+import {
+  initSession,
+  initProjectMemory,
+  getLastSessionSummary,
+  endSession,
+  getMemoryStats,
+  listFileMemories,
+  getFileMemory,
+  getRecentDecisions,
+  getSessionContext
+} from './lib/memory.js';
+
+const VERSION = '2.6.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';
@@ -27,7 +39,6 @@ function saveConfig(cfg) {
 }
 
 function getServerUrl(argv) {
-  // Priority: --server flag > KEYSTONE_SERVER env var > saved config > default
   const flagIdx = argv.indexOf('--server');
   if (flagIdx !== -1 && argv[flagIdx + 1]) return argv[flagIdx + 1];
   if (process.env.TSUNAMI_SERVER) return process.env.TSUNAMI_SERVER;
@@ -43,6 +54,7 @@ const cyan = (s) => chalk.cyan(s);
 const red = (s) => chalk.red(s);
 const green = (s) => chalk.green(s);
 const yellow = (s) => chalk.yellow(s);
+const blue = (s) => chalk.blue(s);
 
 function printBanner(serverUrl) {
   console.log(cyan(bold('\n  🌊 Tsunami Code CLI')) + dim(` v${VERSION}`));
@@ -59,6 +71,12 @@ function printToolCall(name, args) {
   process.stdout.write('\n' + dim(`  ⚙ ${name}(${preview})\n`));
 }
 
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
+}
+
 // ── CLI Parsing ───────────────────────────────────────────────────────────────
 const argv = process.argv.slice(2);
 
@@ -84,6 +102,12 @@ if (argv.includes('--help') || argv.includes('-h')) {
   ${bold('Global config:')}
     ~/.tsunami-code/TSUNAMI.md — applies to all projects.
 
+  ${bold('Memory commands:')}
+    /memory           Show memory stats
+    /memory files     List files with memory entries
+    /memory view <f>  Show memory for a specific file
+    /memory clear     Clear session memory (keep project memory)
+
   ${bold('Settings:')}
     ${CONFIG_FILE}
   `);
@@ -108,6 +132,12 @@ if (setServerIdx !== -1 && argv[setServerIdx + 1]) {
 // ── Main ──────────────────────────────────────────────────────────────────────
 async function run() {
   const serverUrl = getServerUrl(argv);
+  const cwd = process.cwd();
+
+  // Initialize memory systems
+  const { sessionId, sessionDir } = initSession(cwd);
+  initProjectMemory(cwd);
+  setSession({ sessionDir, cwd });
 
   printBanner(serverUrl);
 
@@ -127,7 +157,13 @@ async function run() {
     process.exit(1);
   }
 
-  console.log(green('  ✓ Connected') + dim(' · Type your task. /help for commands. Ctrl+C to exit.\n'));
+  console.log(
+    green('  ✓ Connected') +
+    dim(` · ${sessionId} · Type your task. /help for commands. Ctrl+C to exit.\n`)
+  );
+
+  // Load last session summary if available
+  const lastSessionSummary = getLastSessionSummary(cwd);
 
   let currentServerUrl = serverUrl;
   let messages = [];
@@ -138,6 +174,15 @@ async function run() {
     systemPrompt = buildSystemPrompt();
   }
 
+  /** Trim messages to the last N entries (rolling window) */
+  function trimMessages(msgs, maxEntries = 8) {
+    // Always keep system message (index 0)
+    if (msgs.length <= maxEntries + 1) return msgs;
+    const system = msgs[0];
+    const rest = msgs.slice(1);
+    return [system, ...rest.slice(-maxEntries)];
+  }
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -150,25 +195,108 @@ async function run() {
   let isProcessing = false;
   let pendingClose = false;
 
+  // ── Exit handler ─────────────────────────────────────────────────────────────
+  function gracefulExit(code = 0) {
+    try {
+      endSession(sessionDir);
+    } catch {}
+    console.log(dim('\n  Goodbye.\n'));
+    process.exit(code);
+  }
+
   rl.on('close', () => {
     if (isProcessing) { pendingClose = true; return; }
-    console.log(dim('\n  Goodbye.\n'));
-    process.exit(0);
+    gracefulExit(0);
   });
 
+  // ── Memory commands ───────────────────────────────────────────────────────────
+  async function handleMemoryCommand(args) {
+    const sub = args[0]?.toLowerCase();
+
+    if (!sub) {
+      // /memory — show stats
+      const stats = getMemoryStats(cwd);
+      console.log(blue('\n  Living Memory Stats'));
+      console.log(dim(`  Project memory files : ${stats.projectMemoryFiles}`));
+      console.log(dim(`  Project memory size  : ${formatBytes(stats.projectMemorySize)}`));
+      console.log(dim(`  CODEBASE.md          : ${stats.hasCODEBASE ? 'exists' : 'none'}`));
+      console.log(dim(`  Sessions this dir    : ${stats.sessionCount}`));
+      console.log(dim(`  Current session      : ${sessionId}`));
+      console.log();
+      return;
+    }
+
+    if (sub === 'files') {
+      const files = listFileMemories(cwd);
+      if (files.length === 0) {
+        console.log(dim('  No file memories yet.\n'));
+      } else {
+        console.log(blue(`\n  Files with memory (${files.length}):`));
+        for (const f of files) console.log(dim(`    ${f}`));
+        console.log();
+      }
+      return;
+    }
+
+    if (sub === 'view') {
+      const filePath = args.slice(1).join(' ');
+      if (!filePath) {
+        console.log(red('  Usage: /memory view <filepath>\n'));
+        return;
+      }
+      const mem = getFileMemory(cwd, filePath);
+      if (!mem) {
+        console.log(dim(`  No memory for: ${filePath}\n`));
+      } else {
+        console.log(blue(`\n  Memory: ${filePath}`));
+        console.log(dim('  ' + mem.replace(/\n/g, '\n  ')));
+        console.log();
+      }
+      return;
+    }
+
+    if (sub === 'clear') {
+      // Reinitialize session (clear session memory, keep project memory)
+      resetSession();
+      console.log(green('  Session memory cleared. Project memory preserved.\n'));
+      return;
+    }
+
+    if (sub === 'context') {
+      // Debug: show current session context
+      const ctx = getSessionContext(sessionDir);
+      const decisions = getRecentDecisions(sessionDir, 10);
+      console.log(blue('\n  Current Session Context:'));
+      console.log(dim('  ' + (ctx || '(empty)').replace(/\n/g, '\n  ')));
+      console.log(blue('\n  Recent Decisions:'));
+      console.log(dim('  ' + (decisions || '(none)').replace(/\n/g, '\n  ')));
+      console.log();
+      return;
+    }
+
+    console.log(red(`  Unknown memory subcommand: ${sub}\n  Try: /memory, /memory files, /memory view <file>, /memory clear\n`));
+  }
+
   rl.on('line', async (input) => {
     const line = input.trim();
     if (!line) { rl.prompt(); return; }
 
     if (line.startsWith('/')) {
-      const [cmd, ...rest] = line.slice(1).split(' ');
-      switch (cmd.toLowerCase()) {
+      const parts = line.slice(1).split(' ');
+      const cmd = parts[0].toLowerCase();
+      const rest = parts.slice(1);
+
+      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
 `));
           break;
@@ -187,8 +315,12 @@ async function run() {
             console.log(dim(`  Current server: ${currentServerUrl}\n`));
           }
           break;
+        case 'memory':
+          await handleMemoryCommand(rest);
+          break;
         case 'exit': case 'quit':
-          process.exit(0);
+          gracefulExit(0);
+          return;
         default:
           console.log(red(`  Unknown command: /${cmd}\n`));
       }
@@ -196,12 +328,18 @@ async function run() {
       return;
     }
 
+    // Build the user message, optionally injecting last session summary on first turn
+    let userContent = line;
+    if (messages.length === 0 && lastSessionSummary) {
+      userContent = `[Previous session summary]\n${lastSessionSummary}\n\n---\n\n${line}`;
+    }
+
     const fullMessages = [
       { role: 'system', content: systemPrompt },
       ...messages,
-      { role: 'user', content: line }
+      { role: 'user', content: userContent }
     ];
-    messages.push({ role: 'user', content: line });
+    messages.push({ role: 'user', content: userContent });
 
     rl.pause();
     isProcessing = true;
@@ -219,10 +357,15 @@ async function run() {
         (toolName, toolArgs) => {
           printToolCall(toolName, toolArgs);
           firstToken = true;
-        }
+        },
+        { sessionDir, cwd }
       );
 
-      messages = fullMessages.slice(1);
+      // 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);
+
       process.stdout.write('\n\n');
     } catch (e) {
       process.stdout.write('\n');
@@ -231,8 +374,8 @@ async function run() {
 
     isProcessing = false;
     if (pendingClose) {
-      console.log(dim('  Goodbye.\n'));
-      process.exit(0);
+      gracefulExit(0);
+      return;
     }
     rl.resume();
     rl.prompt();
@@ -240,8 +383,11 @@ async function run() {
 
   process.on('SIGINT', () => {
     if (!isProcessing) {
-      console.log(dim('\n  Goodbye.\n'));
-      process.exit(0);
+      gracefulExit(0);
+    } else {
+      // If processing, mark pending and let the loop finish
+      pendingClose = true;
+      console.log(dim('\n  (finishing current operation...)\n'));
     }
   });
 }

package/lib/loop.js

@@ -1,5 +1,12 @@
 import fetch from 'node-fetch';
 import { ALL_TOOLS } from './tools.js';
+import {
+  assembleContext,
+  extractFilePaths,
+  logFileAccess,
+  logFileChange,
+  appendDecision
+} from './memory.js';
 
 // Parse tool calls from any format the model might produce
 function parseToolCalls(content) {
@@ -81,12 +88,60 @@ function normalizeArgs(args) {
   return out;
 }
 
-async function runTool(name, args) {
+/**
+ * Detect key patterns in Bash commands and return a decision string, or null.
+ * We log psql, npm, pm2, git, and deploy-related commands.
+ */
+function bashDecisionHint(cmd) {
+  if (!cmd) return null;
+  const c = cmd.trim();
+  if (/psql\s/.test(c)) return `DB: ${c.slice(0, 120)}`;
+  if (/npm\s+(install|run|publish|build)/.test(c)) return `NPM: ${c.slice(0, 120)}`;
+  if (/pm2\s+(restart|stop|start|delete|reload)/.test(c)) return `PM2: ${c.slice(0, 120)}`;
+  if (/git\s+(commit|push|checkout|merge|rebase|reset)/.test(c)) return `GIT: ${c.slice(0, 120)}`;
+  if (/ssh\s+/.test(c)) return `SSH: ${c.slice(0, 80)}`;
+  if (/scp\s+/.test(c)) return `SCP: ${c.slice(0, 80)}`;
+  if (/rm\s+-rf|DROP TABLE|ALTER TABLE|CREATE TABLE/.test(c)) return `DESTRUCTIVE: ${c.slice(0, 120)}`;
+  return null;
+}
+
+async function runTool(name, args, sessionInfo) {
   const tool = ALL_TOOLS.find(t => t.name === name);
   if (!tool) return `Error: Unknown tool "${name}"`;
   try {
     const parsed = typeof args === 'string' ? JSON.parse(args) : args;
-    return await tool.run(normalizeArgs(parsed));
+    const normalized = normalizeArgs(parsed);
+
+    // Auto-capture memory BEFORE running the tool (for access/change logging)
+    if (sessionInfo) {
+      const { sessionDir, cwd } = sessionInfo;
+      try {
+        if (name === 'Read' && normalized.file_path) {
+          logFileAccess(cwd, normalized.file_path);
+        }
+      } catch {}
+    }
+
+    const result = await tool.run(normalized);
+
+    // Auto-capture memory AFTER running the tool
+    if (sessionInfo) {
+      const { sessionDir, cwd } = sessionInfo;
+      try {
+        if (name === 'Write' && normalized.file_path) {
+          const lines = (normalized.content || '').split('\n').length;
+          logFileChange(cwd, normalized.file_path, `Written ${lines} lines`);
+        } else if (name === 'Edit' && normalized.file_path) {
+          const preview = (normalized.old_string || '').slice(0, 60).replace(/\n/g, '↵');
+          logFileChange(cwd, normalized.file_path, `Edited: replaced "${preview}"`);
+        } else if (name === 'Bash') {
+          const hint = bashDecisionHint(normalized.command);
+          if (hint) appendDecision(sessionDir, hint);
+        }
+      } catch {}
+    }
+
+    return result;
   } catch (e) {
     return `Error executing ${name}: ${e.message}`;
   }
@@ -104,14 +159,30 @@ async function waitForServer(serverUrl, retries = 10, delay = 2000) {
   throw new Error(`Model server not responding at ${serverUrl}`);
 }
 
-async function streamCompletion(serverUrl, messages, onToken) {
+/**
+ * Stream a completion from the model server.
+ * Injects memoryContext into the system message if provided.
+ */
+async function streamCompletion(serverUrl, messages, onToken, memoryContext = '') {
   await waitForServer(serverUrl, 5, 1000);
+
+  // Inject memory context into the system message (first message with role=system)
+  let finalMessages = messages;
+  if (memoryContext) {
+    finalMessages = messages.map((msg, idx) => {
+      if (idx === 0 && msg.role === 'system') {
+        return { ...msg, content: msg.content + memoryContext };
+      }
+      return msg;
+    });
+  }
+
   const res = await fetch(`${serverUrl}/v1/chat/completions`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({
       model: 'local',
-      messages,
+      messages: finalMessages,
       stream: true,
       temperature: 0.1,
       max_tokens: 4096,
@@ -146,20 +217,65 @@ async function streamCompletion(serverUrl, messages, onToken) {
   return fullContent;
 }
 
-export async function agentLoop(serverUrl, messages, onToken, onToolCall, maxIterations = 15) {
+/**
+ * Main agent loop.
+ *
+ * @param {string} serverUrl
+ * @param {Array} messages  — full message array including system prompt at index 0
+ * @param {Function} onToken
+ * @param {Function} onToolCall
+ * @param {{ sessionDir: string, cwd: string } | null} sessionInfo
+ * @param {number} maxIterations
+ */
+export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessionInfo = null, maxIterations = 15) {
+  // Extract the current task from the last user message for context assembly
+  const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
+  const currentTask = typeof lastUserMsg?.content === 'string' ? lastUserMsg.content : '';
+
   for (let i = 0; i < maxIterations; i++) {
-    const content = await streamCompletion(serverUrl, messages, onToken);
+    // Assemble memory context before each model call
+    let memoryContext = '';
+    if (sessionInfo) {
+      try {
+        const filesToConsider = extractFilePaths(currentTask);
+        memoryContext = assembleContext({
+          sessionDir: sessionInfo.sessionDir,
+          cwd: sessionInfo.cwd,
+          currentTask,
+          filesToConsider
+        });
+      } catch {}
+    }
+
+    const content = await streamCompletion(serverUrl, messages, onToken, memoryContext);
     const toolCalls = parseToolCalls(content);
 
     messages.push({ role: 'assistant', content });
 
-    if (toolCalls.length === 0) break;
+    if (toolCalls.length === 0) {
+      // Log final assistant response as a decision if it's substantive
+      if (sessionInfo && content.length > 50) {
+        try {
+          const summary = content.slice(0, 150).replace(/\n/g, ' ');
+          appendDecision(sessionInfo.sessionDir, `RESPONSE: ${summary}`);
+        } catch {}
+      }
+      break;
+    }
 
     const results = [];
     for (const tc of toolCalls) {
       onToolCall(tc.name, typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments));
-      const result = await runTool(tc.name, tc.arguments);
+      const result = await runTool(tc.name, tc.arguments, sessionInfo);
       results.push(`[${tc.name} result]\n${String(result).slice(0, 8000)}`);
+
+      // Log tool execution as a decision entry
+      if (sessionInfo) {
+        try {
+          const argsPreview = JSON.stringify(tc.arguments || {}).slice(0, 80);
+          appendDecision(sessionInfo.sessionDir, `TOOL ${tc.name}: ${argsPreview}`);
+        } catch {}
+      }
     }
 
     messages.push({