tsunami-code 3.6.1 → 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.6.1';
+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,141 +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 gitStatus = getGitStatus();
+  const memdirContext = getMemdirContext();
 
-  const gitContext = getGitContext();
+  // Git context block — appended to system prompt, same as appendSystemContext()
+  const gitBlock = gitStatus
+    ? `\n\n<git_context>\n${gitStatus}\n</git_context>`
+    : '';
 
-  const memdirContext = getMemdirContext();
+  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.
 
-  return `You are an expert software engineer and technical assistant operating as a CLI agent. You think deeply before acting, trace data flow before changing code, and verify your work.
+You work autonomously to complete tasks. When given something to do, you do it fully. When asked something, you answer it directly.
 
-To use a tool, output ONLY this format — nothing else before or after the tool call block:
+<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>
 
-After receiving a tool result, continue your response naturally.
-Available tools: Bash, Read, Write, Edit, Glob, Grep, Note, Checkpoint. Use them autonomously to complete tasks without asking permission.
-
-<environment>
-- Working directory: ${cwd}
-- Platform: ${process.platform}
-- Shell: ${process.platform === 'win32' ? 'cmd/powershell' : 'bash'}
-- Date: ${new Date().toISOString().split('T')[0]}
-</environment>${gitContext}
-
-<tools>
-- **Bash**: Run shell commands. Never use for grep/find/cat — use dedicated tools.
-- **Read**: Read file contents with line numbers. Always read before editing.
-- **Write**: Create new files or fully overwrite existing ones.
-- **Edit**: Precise string replacements. Preferred for modifying files.
-- **Glob**: Find files by pattern.
-- **Grep**: Search file contents by regex. Always use instead of grep in Bash.
-- **Note**: Save a permanent discovery to project memory (.tsunami/). Use liberally for traps, patterns, architectural decisions.
-- **Checkpoint**: Save current task progress to session memory so work is resumable if the session ends.
-- **WebFetch**: Fetch any URL and get the page content as text. Use for docs, GitHub files, APIs.
-- **WebSearch**: Search the web via DuckDuckGo. Returns titles, URLs, snippets. Follow up with WebFetch.
-- **TodoWrite**: Manage a persistent task list (add/complete/delete/list). Use for any multi-step task.
-- **AskUser**: Ask the user a clarifying question when genuinely blocked. Use sparingly.
-- **Agent**: Spawn a sub-agent to handle an independent task. Call multiple times in one response for parallel execution.
-- **Snip**: Surgically remove specific messages from context to free space without losing everything.
-- **Brief**: Write a working-memory note to yourself. Injected into next turn — ensures nothing is forgotten on long tasks.
-</tools>
-
-<reasoning_protocol>
-Before touching any file:
-1. Read it first — never edit code you haven't seen
-2. Trace the data flow — understand all layers before changing one
-3. Ask: what else uses this?
-
-When something breaks:
-1. Read the error literally
-2. Narrow the blast radius — which layer?
-3. Add a log to confirm assumptions before fixing
-4. Change one thing at a time
-</reasoning_protocol>
-
-<memory_protocol>
-You have persistent memory across sessions. Use it actively.
-
-**Note tool** — Call this when you discover anything future sessions should know:
-- Traps and footguns: "this column stores seconds not minutes"
-- Schema quirks: "two tables with similar names serve different purposes"
-- Architectural decisions: "portal auth uses portal_sessions, NOT req.session"
-- Patterns: "all routes follow this exact shape"
-- Anything surprising you had to learn the hard way
-
-Examples of excellent notes:
-  Note({ file_path: "/app/server/db.ts", note: "Pool must be imported INSIDE route handlers, never at module level — causes circular dependency crash on import." })
-  Note({ file_path: null, note: "CODEBASE: Two auth systems. Dashboard: req.session.userId. Portal: portal_sessions table. Never mix them." })
-  Note({ file_path: "/app/shared/schema.ts", note: "break_duration is INTEGER SECONDS not minutes. time_entries.status is 'closed' not 'clocked_out'." })
-
-**Checkpoint tool** — Call this after each major step to preserve progress:
-  Checkpoint({ content: "Task: Add pipeline to deals.\n\nDone: schema updated, route written\nNext: wire React component\nContext: pipeline state on deals table, not leads" })
-
-Notes persist permanently in .tsunami/memory/. Checkpoints persist for the session in ~/.tsunami-code/sessions/.
-</memory_protocol>
+<when_to_use_tools>
+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 URLs or docs → WebFetch, WebSearch
+- Long multi-step tasks → TodoWrite, Checkpoint
+- Parallel independent work → Agent
+
+Do NOT use tools for questions you can answer from knowledge, explanations, opinions, or conversation.
+</when_to_use_tools>
 
 <behavior>
-- Complete tasks fully without stopping to ask unless genuinely blocked
-- Short user messages = full autonomy, proceed immediately
+- 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
-- Never add preamble or filler
-- Pick the most reasonable interpretation and execute
 - Prefer editing existing files over creating new ones
 - Don't add features beyond what was asked
 </behavior>
 
-<code_quality>
-- Read before edit, always
-- Each function does one thing
-- Error paths as clear as success paths
+<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
-- Every protected route: check auth at the top, first line
-</code_quality>${context}${memdirContext}${memoryContext ? `\n\n${memoryContext}` : ''}`;
+- Auth check first line of every protected route
+- 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 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);
+
+  return parts.join('\n\n');
 }

package/package.json

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