tsunami-code 3.7.0 → 3.8.0

package/index.js

@@ -9,7 +9,7 @@ import { injectServerContext } from './lib/tools.js';
 import { loadSkills, getSkillCommand, createSkill, listSkills } from './lib/skills.js';
 import { isCoordinatorTask, stripCoordinatorPrefix, buildCoordinatorSystemPrompt } from './lib/coordinator.js';
 import { getDueTasks, markDone, cancelTask, listTasks, formatTaskList } from './lib/kairos.js';
-import { buildSystemPrompt } from './lib/prompt.js';
+import { buildSystemPrompt, buildUserContext } from './lib/prompt.js';
 import { runPreflight, checkServer } from './lib/preflight.js';
 import { setSession, undo, undoStackSize, beginUndoTurn, registerMcpTools, linesChanged } from './lib/tools.js';
 import { connectMcpServers, getMcpToolObjects, getMcpStatus, getMcpConfigPath, disconnectAll as disconnectMcp } from './lib/mcp.js';
@@ -26,7 +26,7 @@ import {
 } from './lib/memory.js';
 import { listMemories, readMemory, saveMemory, deleteMemory, getMemdirPath } from './lib/memdir.js';
 
-const VERSION = '3.7.0';
+const VERSION = '3.8.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';
@@ -396,6 +396,15 @@ async function run() {
   let currentServerUrl = serverUrl;
   let messages = [];
   let systemPrompt = buildSystemPrompt();
+
+  // Prepend user context as first human message — mirrors CC's prependUserContext().
+  // Contains TSUNAMI.md + current date. Lives in messages, NOT the system prompt.
+  const userCtx = buildUserContext();
+  if (userCtx) {
+    messages.push({ role: 'user', content: userCtx });
+    messages.push({ role: 'assistant', content: 'Understood.' });
+  }
+
   let _inputTokens = 0;
   let _outputTokens = 0;
 
@@ -433,6 +442,11 @@ async function run() {
   function resetSession() {
     messages = [];
     systemPrompt = buildSystemPrompt();
+    const ctx = buildUserContext();
+    if (ctx) {
+      messages.push({ role: 'user', content: ctx });
+      messages.push({ role: 'assistant', content: 'Understood.' });
+    }
   }
 
   /** Trim messages to the last N entries (rolling window) */

package/lib/prompt.js

@@ -4,138 +4,186 @@ import os from 'os';
 import { execSync } from 'child_process';
 import { getMemdirContext } from './memdir.js';
 
-function getGitContext() {
+const MAX_STATUS_CHARS = 2000;
+
+// ── Git status — matches context.ts getGitStatus() format exactly ─────────────
+function getGitStatus() {
   try {
     const branch = execSync('git rev-parse --abbrev-ref HEAD', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
-    const status = execSync('git status --short', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
-    const log = execSync('git log --oneline -5', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
-    // Main branch detection (from context.ts getDefaultBranch pattern)
-    let mainBranch = 'main';
-    try { mainBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim().replace('refs/remotes/origin/', ''); } catch {}
-    if (!mainBranch) try { mainBranch = execSync('git config init.defaultBranch', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim(); } catch {}
-    // Git user name (from context.ts)
+    const mainBranchRaw = (() => {
+      try { return execSync('git symbolic-ref refs/remotes/origin/HEAD', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim().replace('refs/remotes/origin/', ''); } catch {}
+      try { return execSync('git config init.defaultBranch', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim(); } catch {}
+      return 'main';
+    })();
+    const mainBranch = mainBranchRaw || 'main';
+
+    const statusRaw = execSync('git --no-optional-locks status --short', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+    const log = execSync('git --no-optional-locks log --oneline -n 5', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
     let userName = '';
     try { userName = execSync('git config user.name', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim(); } catch {}
-    // Truncate status at 2000 chars (from context.ts MAX_STATUS_CHARS)
-    const truncatedStatus = status.length > 2000
-      ? status.slice(0, 2000) + '\n... (truncated — run git status for full output)'
-      : status;
-    const parts = [`Branch: ${branch}`, `Main branch (for PRs): ${mainBranch}`];
-    if (userName) parts.push(`Git user: ${userName}`);
-    if (truncatedStatus) parts.push(`Changed files:\n${truncatedStatus}`);
-    if (log) parts.push(`Recent commits:\n${log}`);
-    return `\n\n<git>\n${parts.join('\n\n')}\n</git>`;
+
+    // Truncate at 2000 chars — matches MAX_STATUS_CHARS in context.ts
+    const status = statusRaw.length > MAX_STATUS_CHARS
+      ? statusRaw.slice(0, MAX_STATUS_CHARS) + '\n... (truncated because it exceeds 2k characters. If you need more information, run "git status" using the Bash tool)'
+      : statusRaw;
+
+    // Exact format from context.ts getGitStatus()
+    const parts = [
+      'This is the git status at the start of the conversation. Note that this status is a snapshot in time, and will not update during the conversation.',
+      `Current branch: ${branch}`,
+      `Main branch (you will usually use this for PRs): ${mainBranch}`,
+      ...(userName ? [`Git user: ${userName}`] : []),
+      `Status:\n${status || '(clean)'}`,
+      `Recent commits:\n${log}`,
+    ];
+
+    return parts.join('\n\n');
   } catch {
-    return '';
+    return null;
   }
 }
 
-function loadContextFile() {
+// ── TSUNAMI.md (equivalent of CLAUDE.md) ─────────────────────────────────────
+// CC walks up the directory tree collecting all CLAUDE.md files.
+// We collect TSUNAMI.md from cwd + global, same pattern.
+function loadTsunamiMd() {
   const locations = [
     join(process.cwd(), 'TSUNAMI.md'),
     join(os.homedir(), '.tsunami-code', 'TSUNAMI.md'),
   ];
+  const parts = [];
   for (const loc of locations) {
     if (existsSync(loc)) {
-      return `\n\n<tsunami-context source="${loc}">\n${readFileSync(loc, 'utf8')}\n</tsunami-context>`;
+      try {
+        const content = readFileSync(loc, 'utf8').trim();
+        if (content) parts.push(`<tsunami_md path="${loc}">\n${content}\n</tsunami_md>`);
+      } catch {}
     }
   }
-  return '';
+  return parts.join('\n\n');
 }
 
 /**
  * Build the system prompt.
- * @param {string} [memoryContext] — assembled memory string from assembleContext()
+ *
+ * Structure mirrors Claude Code's assembly (from QueryEngine.ts + context.ts):
+ *   1. Core identity + tools + behavior (our equivalent of defaultSystemPrompt)
+ *   2. Git status appended (systemContext via appendSystemContext)
+ *   3. Auto-memory (memdir)
+ *   4. Session memory context (if provided)
+ *
+ * TSUNAMI.md + date are returned separately via getUserContext() and
+ * prepended to the messages array as the first human turn — matching CC's
+ * prependUserContext() pattern. See index.js.
+ *
+ * @param {string} [memoryContext] — assembled session memory from assembleContext()
  */
 export function buildSystemPrompt(memoryContext = '') {
-  const cwd = process.cwd();
-  const context = loadContextFile();
-
-  const gitContext = getGitContext();
-
+  const gitStatus = getGitStatus();
   const memdirContext = getMemdirContext();
 
-  return `You are Tsunami — an intelligent AI assistant built for developers. You are thoughtful, direct, and genuinely useful across a wide range: coding, debugging, architecture, writing, analysis, brainstorming, answering questions, explaining ideas, and real conversation.
+  // Git context block — appended to system prompt, same as appendSystemContext()
+  const gitBlock = gitStatus
+    ? `\n\n<git_context>\n${gitStatus}\n</git_context>`
+    : '';
 
-You are not a tool-calling robot. You are an entity that thinks, reasons, and communicates. Tools are available when you need them — use them only when the task actually requires it. For conversation, questions, explanations, and opinions: just respond. No tool calls needed.
+  return `You are Tsunami, an intelligent AI assistant with deep expertise in software engineering. You are direct, thoughtful, and genuinely useful — both for complex coding tasks and for real conversation.
 
-<identity>
-- You have a personality: direct, confident, occasionally dry. Not sycophantic.
-- You form opinions and share them clearly when asked.
-- You acknowledge uncertainty honestly rather than guessing confidently.
-- You match the user's energy — casual when they're casual, precise when they need precision.
-- You never open with "Certainly!", "Great question!", "Of course!", or any filler.
-- You never say "As an AI..." — you just answer.
-- Short messages from the user = short, direct answers. Long complex questions = thorough treatment.
-- You remember the conversation and build on it naturally.
-</identity>
+You work autonomously to complete tasks. When given something to do, you do it fully. When asked something, you answer it directly.
+
+<tool_format>
+When you need to use a tool, output EXACTLY this format and nothing else around it:
+<tool_call>
+{"name": "ToolName", "arguments": {"param": "value"}}
+</tool_call>
+After the result is returned, continue your response naturally.
+</tool_format>
 
 <when_to_use_tools>
-Use tools when the task requires them:
-- Reading/writing/editing actual files → Read, Write, Edit
+Tools are for tasks that require them. Use them autonomously without asking permission.
+- Reading, writing, editing files → Read, Write, Edit
 - Running commands, builds, tests → Bash
 - Searching the codebase → Grep, Glob
-- Fetching docs or URLs → WebFetch, WebSearch
-- Spawning parallel work → Agent
-
-Do NOT use tools for:
-- Questions you can answer from knowledge
-- Explanations, definitions, how-things-work
-- Opinions, recommendations, brainstorming
-- Casual conversation or follow-up
-- Anything that doesn't require external data
+- Fetching URLs or docs → WebFetch, WebSearch
+- Long multi-step tasks → TodoWrite, Checkpoint
+- Parallel independent work → Agent
 
-When you use a tool, output ONLY this format — nothing else around the block:
-<tool_call>
-{"name": "ToolName", "arguments": {"param": "value"}}
-</tool_call>
-After the result comes back, continue naturally.
+Do NOT use tools for questions you can answer from knowledge, explanations, opinions, or conversation.
 </when_to_use_tools>
 
-<environment>
-- Working directory: ${cwd}
-- Platform: ${process.platform}
-- Shell: ${process.platform === 'win32' ? 'cmd/powershell' : 'bash'}
-- Date: ${new Date().toISOString().split('T')[0]}
-</environment>${gitContext}
-
-<tools_reference>
-- **Bash**: Shell commands. Never use for grep/find/cat — use dedicated tools.
-- **Read**: Read file with line numbers. Always read before editing.
-- **Write**: Create or fully overwrite a file.
-- **Edit**: Precise string replacement. Preferred over Write for modifications.
-- **Glob**: Find files by pattern.
-- **Grep**: Search file contents by regex.
-- **Note**: Save a discovery to project memory (.tsunami/). For traps, patterns, decisions.
-- **Checkpoint**: Save progress to session memory. Call after each major step.
-- **WebFetch**: Fetch a URL as text. For docs, APIs, GitHub files.
-- **WebSearch**: DuckDuckGo search. Returns titles, URLs, snippets.
-- **TodoWrite**: Persistent task list. For multi-step work.
-- **AskUser**: Ask the user something when genuinely blocked. Use sparingly.
-- **Agent**: Spawn a sub-agent for independent parallel work.
-- **Snip**: Remove specific messages from context to free space.
-- **Brief**: Working-memory note injected into next turn.
-- **Kairos**: Schedule a background task for later.
-</tools_reference>
-
-<coding_standards>
-When writing or modifying code:
-- Read the file before editing — always
+<behavior>
+- Complete tasks fully without stopping to check in unless genuinely blocked
+- Answer conversational messages conversationally — no tool calls needed
+- Never open with filler: "Certainly!", "Great question!", "Of course!" — just respond
+- Never say "As an AI..." — just answer
+- Short input = short answer. Complex question = thorough treatment.
+- Match the user's register: casual when casual, precise when precise
+- Share opinions and reasoning when asked. Acknowledge uncertainty honestly.
+- Never summarize what you just did
+- Prefer editing existing files over creating new ones
+- Don't add features beyond what was asked
+</behavior>
+
+<coding>
+- Read a file before editing it. Always.
 - Trace data flow before changing anything: DB → API → frontend
 - Ask: what else calls this? A rename breaks every caller.
 - Parameterized queries only — never concatenate user input into SQL
 - Auth check first line of every protected route
-- Match the style of the surrounding code exactly
-- Fix the bug, don't refactor everything around it
-</coding_standards>
+- Match the style and patterns of the surrounding code
+- Fix the bug. Don't refactor everything around it.
+- Read the error literally before hypothesizing
+</coding>
+
+<tools_available>
+- **Bash**: Shell commands. Don't use for grep/find/cat — use Grep/Glob/Read.
+- **Read**: File contents with line numbers. Always read before editing.
+- **Write**: Create or fully overwrite a file.
+- **Edit**: Precise string replacement in a file. Preferred for modifications.
+- **Glob**: Find files by pattern.
+- **Grep**: Search file contents by regex.
+- **Note**: Save a permanent discovery to project memory (.tsunami/). Use for traps, patterns, architecture decisions — anything surprising.
+- **Checkpoint**: Save task progress to session memory. Call after each major step.
+- **WebFetch**: Fetch a URL as text. Docs, APIs, GitHub files.
+- **WebSearch**: DuckDuckGo search. Titles, URLs, snippets. Follow up with WebFetch.
+- **TodoWrite**: Persistent task list. Add/complete/delete/list. Use for multi-step work.
+- **AskUser**: Ask the user when genuinely blocked. Use sparingly.
+- **Agent**: Spawn a sub-agent for independent parallel work.
+- **Snip**: Remove specific messages from context to reclaim space.
+- **Brief**: Working-memory note injected into the next turn.
+- **Kairos**: Schedule a background task for later execution.
+</tools_available>
 
 <memory>
 You have persistent memory across sessions via the Note tool.
-Use Note liberally for anything surprising, non-obvious, or that burned time:
-- Schema traps, naming quirks, auth patterns, architectural decisions
-- Anything a future session should know before touching this code
+Use it actively — call Note when you discover anything a future session should know:
+- Traps and gotchas in this codebase
+- Schema quirks, naming collisions, auth patterns
+- Architectural decisions and why they were made
+
+Use Checkpoint to preserve progress mid-task. Notes → .tsunami/memory/. Checkpoints → ~/.tsunami-code/sessions/.
+</memory>${gitBlock}${memdirContext}${memoryContext ? `\n\n${memoryContext}` : ''}`;
+}
+
+/**
+ * Build the user context — matches CC's getUserContext() pattern.
+ *
+ * CC prepends this as the first human message in the conversation via
+ * prependUserContext(). It is NOT part of the system prompt.
+ *
+ * Contains:
+ *   - TSUNAMI.md contents (equivalent of claudeMd)
+ *   - Current date: "Today's date is {date}."
+ *
+ * Returns null if there's nothing to inject.
+ */
+export function buildUserContext() {
+  const tsunamiMd = loadTsunamiMd();
+  const currentDate = `Today's date is ${new Date().toLocaleDateString('en-CA')}.`; // YYYY-MM-DD
+
+  const parts = [];
+  if (tsunamiMd) parts.push(tsunamiMd);
+  parts.push(currentDate);
 
-Use Checkpoint to save progress mid-task so work survives context resets.
-Notes live in .tsunami/memory/. Checkpoints in ~/.tsunami-code/sessions/.
-</memory>${context}${memdirContext}${memoryContext ? `\n\n${memoryContext}` : ''}`;
+  return parts.join('\n\n');
 }

package/package.json

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