tsunami-code 2.5.0

package/index.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+import readline from 'readline';
+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 { buildSystemPrompt } from './lib/prompt.js';
+import { runPreflight } from './lib/preflight.js';
+
+const VERSION = '2.5.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';
+
+// ── Config ────────────────────────────────────────────────────────────────────
+function loadConfig() {
+  if (existsSync(CONFIG_FILE)) {
+    try { return JSON.parse(readFileSync(CONFIG_FILE, 'utf8')); } catch {}
+  }
+  return {};
+}
+
+function saveConfig(cfg) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), 'utf8');
+}
+
+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;
+  const cfg = loadConfig();
+  if (cfg.server) return cfg.server;
+  return DEFAULT_SERVER;
+}
+
+// ── Formatting ────────────────────────────────────────────────────────────────
+const dim = (s) => chalk.dim(s);
+const bold = (s) => chalk.bold(s);
+const cyan = (s) => chalk.cyan(s);
+const red = (s) => chalk.red(s);
+const green = (s) => chalk.green(s);
+const yellow = (s) => chalk.yellow(s);
+
+function printBanner(serverUrl) {
+  console.log(cyan(bold('\n  🌊 Tsunami Code CLI')) + dim(` v${VERSION}`));
+  console.log(dim('  by Keystone World Management · Navy Seal Unit XI3'));
+  console.log(dim(`  Model server: ${serverUrl}\n`));
+}
+
+function printToolCall(name, args) {
+  let parsed = {};
+  try { parsed = JSON.parse(args); } catch {}
+  const preview = Object.entries(parsed)
+    .map(([k, v]) => `${k}=${JSON.stringify(String(v).slice(0, 60))}`)
+    .join(', ');
+  process.stdout.write('\n' + dim(`  ⚙ ${name}(${preview})\n`));
+}
+
+// ── CLI Parsing ───────────────────────────────────────────────────────────────
+const argv = process.argv.slice(2);
+
+if (argv.includes('--help') || argv.includes('-h')) {
+  console.log(`
+  ${cyan(bold('tsunami'))} — Tsunami Code CLI · AI coding agent
+
+  ${bold('Usage:')}
+    keystonecli [options]
+
+  ${bold('Options:')}
+    --server <url>    Model server URL (default: env KEYSTONE_SERVER or saved config)
+    --set-server <url> Save server URL to config permanently
+    --version         Show version
+    --help            Show this help
+
+  ${bold('Environment:')}
+    TSUNAMI_SERVER    Model server URL
+
+  ${bold('Config:')}
+    ${CONFIG_FILE}
+  `);
+  process.exit(0);
+}
+
+if (argv.includes('--version') || argv.includes('-v')) {
+  console.log(`keystonecli v${VERSION}`);
+  process.exit(0);
+}
+
+const setServerIdx = argv.indexOf('--set-server');
+if (setServerIdx !== -1 && argv[setServerIdx + 1]) {
+  const url = argv[setServerIdx + 1];
+  const cfg = loadConfig();
+  cfg.server = url;
+  saveConfig(cfg);
+  console.log(green(`  Server URL saved: ${url}`));
+  process.exit(0);
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+async function run() {
+  const serverUrl = getServerUrl(argv);
+
+  printBanner(serverUrl);
+
+  // Preflight checks
+  process.stdout.write(dim('  Checking server connection...'));
+  const { errors, warnings } = await runPreflight(serverUrl);
+  process.stdout.write('\r' + ' '.repeat(40) + '\r');
+
+  if (warnings.length) {
+    for (const w of warnings) console.log(yellow(`  ⚠ ${w}`));
+    console.log();
+  }
+
+  if (errors.length) {
+    for (const e of errors) console.log(red(`  ✗ ${e}`));
+    console.log();
+    process.exit(1);
+  }
+
+  console.log(green('  ✓ Connected') + dim(' · Type your task. /help for commands. Ctrl+C to exit.\n'));
+
+  let currentServerUrl = serverUrl;
+  let messages = [];
+  let systemPrompt = buildSystemPrompt();
+
+  function resetSession() {
+    messages = [];
+    systemPrompt = buildSystemPrompt();
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: cyan('❯ '),
+    terminal: process.stdin.isTTY
+  });
+
+  rl.prompt();
+
+  let isProcessing = false;
+  let pendingClose = false;
+
+  rl.on('close', () => {
+    if (isProcessing) { pendingClose = true; return; }
+    console.log(dim('\n  Goodbye.\n'));
+    process.exit(0);
+  });
+
+  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()) {
+        case 'help':
+          console.log(dim(`
+  Commands:
+    /clear            Start new conversation
+    /status           Show context size
+    /server <url>     Change server URL for this session
+    /exit             Exit
+`));
+          break;
+        case 'clear':
+          resetSession();
+          console.log(green('  Session cleared.\n'));
+          break;
+        case 'status':
+          console.log(dim(`  Messages in context: ${messages.length} | Server: ${currentServerUrl}\n`));
+          break;
+        case 'server':
+          if (rest[0]) {
+            currentServerUrl = rest[0];
+            console.log(green(`  Server changed to: ${rest[0]}\n`));
+          } else {
+            console.log(dim(`  Current server: ${currentServerUrl}\n`));
+          }
+          break;
+        case 'exit': case 'quit':
+          process.exit(0);
+        default:
+          console.log(red(`  Unknown command: /${cmd}\n`));
+      }
+      rl.prompt();
+      return;
+    }
+
+    const fullMessages = [
+      { role: 'system', content: systemPrompt },
+      ...messages,
+      { role: 'user', content: line }
+    ];
+    messages.push({ role: 'user', content: line });
+
+    rl.pause();
+    isProcessing = true;
+    process.stdout.write('\n');
+
+    let firstToken = true;
+    try {
+      await agentLoop(
+        currentServerUrl,
+        fullMessages,
+        (token) => {
+          if (firstToken) { process.stdout.write('  '); firstToken = false; }
+          process.stdout.write(token);
+        },
+        (toolName, toolArgs) => {
+          printToolCall(toolName, toolArgs);
+          firstToken = true;
+        }
+      );
+
+      messages = fullMessages.slice(1);
+      process.stdout.write('\n\n');
+    } catch (e) {
+      process.stdout.write('\n');
+      console.error(red(`  Error: ${e.message}\n`));
+    }
+
+    isProcessing = false;
+    if (pendingClose) {
+      console.log(dim('  Goodbye.\n'));
+      process.exit(0);
+    }
+    rl.resume();
+    rl.prompt();
+  });
+
+  process.on('SIGINT', () => {
+    if (!isProcessing) {
+      console.log(dim('\n  Goodbye.\n'));
+      process.exit(0);
+    }
+  });
+}
+
+run().catch(e => {
+  console.error(chalk.red(`Fatal: ${e.message}`));
+  process.exit(1);
+});

package/lib/loop.js

@@ -0,0 +1,172 @@
+import fetch from 'node-fetch';
+import { ALL_TOOLS } from './tools.js';
+
+// Parse tool calls from any format the model might produce
+function parseToolCalls(content) {
+  const calls = [];
+  const seen = new Set();
+
+  function add(name, args) {
+    const tool = ALL_TOOLS.find(t => t.name === name);
+    if (!tool) return;
+    const key = name + JSON.stringify(args);
+    if (seen.has(key)) return;
+    seen.add(key);
+    calls.push({ name, arguments: typeof args === 'string' ? args : args });
+  }
+
+  // Format 1: <tool_call>{"name":..., "arguments":...}</tool_call>
+  const tc1 = /<tool_call>([\s\S]*?)<\/tool_call>/g;
+  let m;
+  while ((m = tc1.exec(content)) !== null) {
+    try {
+      const p = JSON.parse(m[1].trim());
+      if (p.name) add(p.name, p.arguments || p.params || {});
+    } catch {}
+  }
+
+  // Format 2: ```json or ```bash code block with {"name":..., "arguments":...}
+  const tc2 = /```(?:\w+)?\s*(\{[\s\S]*?"name"[\s\S]*?\})\s*```/g;
+  while ((m = tc2.exec(content)) !== null) {
+    try {
+      const p = JSON.parse(m[1].trim());
+      if (p.name) add(p.name, p.arguments || p.params || {});
+    } catch {}
+  }
+
+  // Format 3: <function_call><name>X</name><arguments>JSON</arguments></function_call>
+  const tc3 = /<function_call[\s\S]*?<name>([\s\S]*?)<\/name>[\s\S]*?<arguments>([\s\S]*?)<\/arguments>[\s\S]*?<\/function_call>/g;
+  while ((m = tc3.exec(content)) !== null) {
+    const name = m[1].trim();
+    const argsRaw = m[2].trim();
+    try {
+      add(name, JSON.parse(argsRaw));
+    } catch {
+      const args = {};
+      const kv = /<(\w+)>([\s\S]*?)<\/\1>/g;
+      let a;
+      while ((a = kv.exec(argsRaw)) !== null) args[a[1]] = a[2];
+      if (Object.keys(args).length) add(name, args);
+    }
+  }
+
+  // Format 4: bare JSON with "name" field (last resort)
+  if (calls.length === 0) {
+    const tc4 = /\{[\s\S]*?"name"\s*:\s*"(\w+)"[\s\S]*?"arguments"\s*:\s*(\{[\s\S]*?\})[\s\S]*?\}/g;
+    while ((m = tc4.exec(content)) !== null) {
+      try { add(m[1], JSON.parse(m[2])); } catch {}
+    }
+  }
+
+  return calls;
+}
+
+// Normalize argument keys — model sometimes uses aliases
+function normalizeArgs(args) {
+  if (typeof args !== 'object' || !args) return args;
+  const out = { ...args };
+  const aliases = {
+    path: 'file_path', file: 'file_path', filepath: 'file_path', filename: 'file_path',
+    cmd: 'command', shell_command: 'command',
+    regex: 'pattern', search: 'pattern', query: 'pattern',
+    text: 'content', body: 'content',
+    old: 'old_string', new: 'new_string', replacement: 'new_string'
+  };
+  for (const [alias, canonical] of Object.entries(aliases)) {
+    if (out[alias] !== undefined && out[canonical] === undefined) {
+      out[canonical] = out[alias];
+      delete out[alias];
+    }
+  }
+  return out;
+}
+
+async function runTool(name, args) {
+  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));
+  } catch (e) {
+    return `Error executing ${name}: ${e.message}`;
+  }
+}
+
+async function waitForServer(serverUrl, retries = 10, delay = 2000) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      const r = await fetch(`${serverUrl}/health`);
+      const j = await r.json();
+      if (j.status === 'ok') return;
+    } catch {}
+    await new Promise(r => setTimeout(r, delay));
+  }
+  throw new Error(`Model server not responding at ${serverUrl}`);
+}
+
+async function streamCompletion(serverUrl, messages, onToken) {
+  await waitForServer(serverUrl, 5, 1000);
+  const res = await fetch(`${serverUrl}/v1/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model: 'local',
+      messages,
+      stream: true,
+      temperature: 0.1,
+      max_tokens: 4096,
+      stop: ['</tool_call>\n\nContinue']
+    })
+  });
+
+  if (!res.ok) throw new Error(`Model server: ${res.status} ${await res.text()}`);
+
+  let fullContent = '';
+  let buffer = '';
+
+  for await (const chunk of res.body) {
+    buffer += chunk.toString();
+    const lines = buffer.split('\n');
+    buffer = lines.pop();
+
+    for (const line of lines) {
+      if (!line.startsWith('data: ')) continue;
+      const data = line.slice(6).trim();
+      if (data === '[DONE]') continue;
+      let parsed;
+      try { parsed = JSON.parse(data); } catch { continue; }
+      const token = parsed.choices?.[0]?.delta?.content;
+      if (token) {
+        fullContent += token;
+        onToken(token);
+      }
+    }
+  }
+
+  return fullContent;
+}
+
+export async function agentLoop(serverUrl, messages, onToken, onToolCall, maxIterations = 15) {
+  for (let i = 0; i < maxIterations; i++) {
+    const content = await streamCompletion(serverUrl, messages, onToken);
+    const toolCalls = parseToolCalls(content);
+
+    messages.push({ role: 'assistant', content });
+
+    if (toolCalls.length === 0) 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);
+      results.push(`[${tc.name} result]\n${String(result).slice(0, 8000)}`);
+    }
+
+    messages.push({
+      role: 'user',
+      content: results.join('\n\n---\n\n') + '\n\nContinue with the task.'
+    });
+
+    onToken('\n');
+  }
+}

package/lib/preflight.js

@@ -0,0 +1,51 @@
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import fetch from 'node-fetch';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const VENDOR = join(__dirname, '..', 'vendor');
+
+export function getRgPath() {
+  const vendored = join(VENDOR, process.platform === 'win32' ? 'rg.exe' : 'rg');
+  if (existsSync(vendored)) return vendored;
+  // Fall back to system rg
+  try {
+    const which = execSync(process.platform === 'win32' ? 'where rg' : 'which rg', { stdio: 'pipe' }).toString().trim().split('\n')[0];
+    if (which) return which;
+  } catch {}
+  return null;
+}
+
+export async function checkServer(serverUrl, timeoutMs = 5000) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(`${serverUrl}/health`, { signal: controller.signal });
+    clearTimeout(timer);
+    const json = await res.json();
+    return json.status === 'ok';
+  } catch {
+    return false;
+  }
+}
+
+export async function runPreflight(serverUrl) {
+  const errors = [];
+  const warnings = [];
+
+  // Node version
+  const [major] = process.versions.node.split('.').map(Number);
+  if (major < 18) errors.push(`Node.js 18+ required (found ${process.versions.node})`);
+
+  // ripgrep
+  const rgPath = getRgPath();
+  if (!rgPath) warnings.push('ripgrep not found — Grep tool disabled (run: npm install -g ripgrep or brew install ripgrep)');
+
+  // Server connectivity
+  const serverOk = await checkServer(serverUrl);
+  if (!serverOk) errors.push(`Cannot reach model server at ${serverUrl}\n  → Check your KEYSTONE_SERVER env var or set it with: keystonecli --server <url>`);
+
+  return { errors, warnings, rgPath };
+}

package/lib/prompt.js

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+
+function loadContextFile() {
+  const locations = [
+    join(process.cwd(), 'CLAUDE.md'),
+    join(process.cwd(), 'AGENTS.md'),
+    join(os.homedir(), '.claude', 'CLAUDE.md'),
+    join(os.homedir(), 'AGENTS.md'),
+  ];
+  for (const loc of locations) {
+    if (existsSync(loc)) {
+      return `\n\n<project-context source="${loc}">\n${readFileSync(loc, 'utf8')}\n</project-context>`;
+    }
+  }
+  return '';
+}
+
+export function buildSystemPrompt() {
+  const cwd = process.cwd();
+  const context = loadContextFile();
+
+  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.
+
+To use a tool, output ONLY this format — nothing else before or after the tool call block:
+<tool_call>
+{"name": "ToolName", "arguments": {"param": "value"}}
+</tool_call>
+
+After receiving a tool result, continue your response naturally.
+Available tools: Bash, Read, Write, Edit, Glob, Grep. 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>
+
+<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.
+</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>
+
+<behavior>
+- Complete tasks fully without stopping to ask unless genuinely blocked
+- Short user messages = full autonomy, proceed immediately
+- 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
+- Parameterized queries only — never concatenate user input into SQL
+- Every protected route: check auth at the top, first line
+</code_quality>${context}`;
+}

package/lib/tools.js

@@ -0,0 +1,206 @@
+import { execSync, exec } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { glob } from 'glob';
+import { promisify } from 'util';
+import { getRgPath } from './preflight.js';
+
+const execAsync = promisify(exec);
+
+// ── BASH ──────────────────────────────────────────────────────────────────────
+export const BashTool = {
+  name: 'Bash',
+  description: `Executes a bash command and returns its output. The working directory persists between commands.
+
+IMPORTANT: Never use for grep/find/cat/head/tail/sed/awk — use Read, Grep, Glob tools instead.
+
+- Always quote file paths with spaces
+- Chain dependent commands with && not newlines
+- Max timeout: 120000ms`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      command: { type: 'string', description: 'The bash command to execute' },
+      timeout: { type: 'number', description: 'Timeout ms (max 120000)', default: 120000 },
+      description: { type: 'string', description: 'Short description of what this command does' }
+    },
+    required: ['command']
+  },
+  async run({ command, timeout = 120000 }) {
+    try {
+      const shell = process.platform === 'win32' ? undefined : '/bin/bash';
+      const { stdout, stderr } = await execAsync(command, {
+        timeout: Math.min(timeout, 120000),
+        maxBuffer: 10 * 1024 * 1024,
+        shell
+      });
+      const out = stdout || '';
+      const err = stderr ? `\nSTDERR: ${stderr}` : '';
+      return (out + err).trim() || '(no output)';
+    } catch (e) {
+      if (e.killed) return `Error: Command timed out after ${timeout}ms`;
+      return `Error (exit ${e.code}): ${e.message}\n${e.stderr || ''}`.trim();
+    }
+  }
+};
+
+// ── READ ──────────────────────────────────────────────────────────────────────
+export const ReadTool = {
+  name: 'Read',
+  description: `Reads a file from the local filesystem. Returns content with line numbers (cat -n format).
+
+- file_path must be absolute
+- Reads up to 2000 lines by default
+- Use offset and limit for large files`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      file_path: { type: 'string', description: 'Absolute path to the file' },
+      offset: { type: 'number', description: 'Line to start from (0-indexed)' },
+      limit: { type: 'number', description: 'Lines to read (default 2000)' }
+    },
+    required: ['file_path']
+  },
+  async run({ file_path, offset = 0, limit = 2000 }) {
+    if (!existsSync(file_path)) return `Error: File not found: ${file_path}`;
+    try {
+      const content = readFileSync(file_path, 'utf8');
+      const lines = content.split('\n');
+      const slice = lines.slice(offset, offset + limit);
+      return slice.map((l, i) => `${offset + i + 1}\t${l}`).join('\n');
+    } catch (e) {
+      return `Error reading file: ${e.message}`;
+    }
+  }
+};
+
+// ── WRITE ─────────────────────────────────────────────────────────────────────
+export const WriteTool = {
+  name: 'Write',
+  description: `Writes content to a file (creates or overwrites). Prefer Edit for modifying existing files.`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      file_path: { type: 'string', description: 'Absolute path to write to' },
+      content: { type: 'string', description: 'Content to write' }
+    },
+    required: ['file_path', 'content']
+  },
+  async run({ file_path, content }) {
+    try {
+      writeFileSync(file_path, content, 'utf8');
+      return `Written ${content.split('\n').length} lines to ${file_path}`;
+    } catch (e) {
+      return `Error writing file: ${e.message}`;
+    }
+  }
+};
+
+// ── EDIT ──────────────────────────────────────────────────────────────────────
+export const EditTool = {
+  name: 'Edit',
+  description: `Exact string replacement in a file. Fails if old_string not found or not unique.
+
+- Read the file first before editing
+- old_string must match exactly including whitespace
+- Use replace_all to replace every occurrence`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      file_path: { type: 'string', description: 'Absolute path to the file' },
+      old_string: { type: 'string', description: 'Exact text to replace' },
+      new_string: { type: 'string', description: 'Replacement text' },
+      replace_all: { type: 'boolean', description: 'Replace all occurrences', default: false }
+    },
+    required: ['file_path', 'old_string', 'new_string']
+  },
+  async run({ file_path, old_string, new_string, replace_all = false }) {
+    if (!existsSync(file_path)) return `Error: File not found: ${file_path}`;
+    try {
+      let content = readFileSync(file_path, 'utf8');
+      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;
+        if (count > 1) return `Error: old_string appears ${count} times — use replace_all or add more context to make it unique`;
+      }
+      const updated = replace_all
+        ? content.split(old_string).join(new_string)
+        : content.replace(old_string, new_string);
+      writeFileSync(file_path, updated, 'utf8');
+      return `Edited ${file_path}`;
+    } catch (e) {
+      return `Error editing file: ${e.message}`;
+    }
+  }
+};
+
+// ── GLOB ──────────────────────────────────────────────────────────────────────
+export const GlobTool = {
+  name: 'Glob',
+  description: `File pattern matching. Returns matching paths sorted by modification time.
+
+- Supports patterns like "**/*.js" or "src/**/*.ts"
+- Use for file discovery; use Grep for content search`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      pattern: { type: 'string', description: 'Glob pattern' },
+      path: { type: 'string', description: 'Directory to search in (defaults to cwd)' }
+    },
+    required: ['pattern']
+  },
+  async run({ pattern, path: searchPath }) {
+    try {
+      const cwd = searchPath || process.cwd();
+      const matches = await glob(pattern, { cwd, absolute: true });
+      if (matches.length === 0) return 'No files matched';
+      return matches.join('\n');
+    } catch (e) {
+      return `Error: ${e.message}`;
+    }
+  }
+};
+
+// ── GREP ──────────────────────────────────────────────────────────────────────
+export const GrepTool = {
+  name: 'Grep',
+  description: `Search file contents using regex (ripgrep). Always use this instead of running grep in Bash.
+
+- output_mode: "content" shows lines, "files_with_matches" shows paths, "count" shows counts
+- Supports glob filter, type filter, -i for case insensitive, -C for context lines`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      pattern: { type: 'string', description: 'Regex pattern' },
+      path: { type: 'string', description: 'File or directory to search' },
+      glob: { type: 'string', description: 'Glob filter (e.g. "*.js")' },
+      output_mode: { type: 'string', enum: ['content', 'files_with_matches', 'count'], default: 'files_with_matches' },
+      '-i': { type: 'boolean', description: 'Case insensitive' },
+      '-C': { type: 'number', description: 'Context lines around each match' },
+      head_limit: { type: 'number', description: 'Limit output to first N results', default: 250 }
+    },
+    required: ['pattern']
+  },
+  async run({ pattern, path: searchPath = '.', glob: globFilter, output_mode = 'files_with_matches', '-i': caseInsensitive, '-C': context, head_limit = 250 }) {
+    const rgPath = getRgPath();
+    if (!rgPath) return 'Error: ripgrep not available — install with: brew install ripgrep or apt install ripgrep';
+    try {
+      const rgBin = JSON.stringify(rgPath);
+      let cmd = rgBin;
+      if (caseInsensitive) cmd += ' -i';
+      if (context) cmd += ` -C ${context}`;
+      if (globFilter) cmd += ` --glob ${JSON.stringify(globFilter)}`;
+      if (output_mode === 'files_with_matches') cmd += ' -l';
+      else if (output_mode === 'count') cmd += ' --count';
+      else cmd += ' -n';
+      cmd += ` ${JSON.stringify(pattern)} ${JSON.stringify(searchPath)}`;
+      const { stdout } = await execAsync(cmd, { maxBuffer: 10 * 1024 * 1024 });
+      const lines = stdout.trim().split('\n').filter(Boolean);
+      return lines.slice(0, head_limit).join('\n') || 'No matches found';
+    } catch (e) {
+      if (e.code === 1) return 'No matches found';
+      return `Error: ${e.message}`;
+    }
+  }
+};
+
+export const ALL_TOOLS = [BashTool, ReadTool, WriteTool, EditTool, GlobTool, GrepTool];

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "tsunami-code",
+  "version": "2.5.0",
+  "description": "Tsunami Code CLI — AI coding agent powered by open-source models",
+  "type": "module",
+  "bin": {
+    "tsunami": "index.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/setup.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "glob": "^13.0.6",
+    "node-fetch": "^3.3.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "agent",
+    "coding",
+    "llm",
+    "tsunami"
+  ],
+  "author": "Keystone World Management Navy Seal Unit XI3",
+  "license": "MIT"
+}

package/scripts/setup.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+// Runs at npm install time — downloads the ripgrep binary for this platform
+import { createWriteStream, existsSync, mkdirSync, chmodSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { pipeline } from 'stream/promises';
+import https from 'https';
+import { createGunzip } from 'zlib';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+const VENDOR = join(ROOT, 'vendor');
+
+const RG_VERSION = '14.1.1';
+const PLATFORMS = {
+  'linux-x64':   { url: `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/ripgrep-${RG_VERSION}-x86_64-unknown-linux-musl.tar.gz`, bin: 'rg' },
+  'linux-arm64': { url: `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/ripgrep-${RG_VERSION}-aarch64-unknown-linux-gnu.tar.gz`, bin: 'rg' },
+  'darwin-x64':  { url: `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/ripgrep-${RG_VERSION}-x86_64-apple-darwin.tar.gz`, bin: 'rg' },
+  'darwin-arm64':{ url: `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/ripgrep-${RG_VERSION}-aarch64-apple-darwin.tar.gz`, bin: 'rg' },
+  'win32-x64':   { url: `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/ripgrep-${RG_VERSION}-x86_64-pc-windows-msvc.zip`, bin: 'rg.exe' },
+};
+
+const key = `${process.platform}-${process.arch}`;
+const platform = PLATFORMS[key];
+
+if (!platform) {
+  console.warn(`[tsunami-code] No prebuilt ripgrep for ${key} — Grep tool will fall back to system rg`);
+  process.exit(0);
+}
+
+const binPath = join(VENDOR, platform.bin);
+if (existsSync(binPath)) {
+  process.exit(0); // already installed
+}
+
+if (!existsSync(VENDOR)) mkdirSync(VENDOR, { recursive: true });
+
+console.log(`[tsunami-code] Downloading ripgrep for ${key}...`);
+
+function httpsGet(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers: { 'User-Agent': 'keystonewm-setup' } }, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        httpsGet(res.headers.location).then(resolve).catch(reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        return;
+      }
+      resolve(res);
+    }).on('error', reject);
+  });
+}
+
+async function extractTarGz(stream, destDir, binName) {
+  // Extract using system tar (available on all platforms with Node 18+)
+  const tarPath = join(destDir, '_rg.tar.gz');
+  await pipeline(stream, createWriteStream(tarPath));
+  await execAsync(`tar -xzf "${tarPath}" -C "${destDir}" --strip-components=1 --wildcards "*/${binName}" 2>/dev/null || tar -xzf "${tarPath}" -C "${destDir}" --strip-components=1`);
+  try { await execAsync(`rm "${tarPath}"`); } catch {}
+}
+
+async function extractZip(stream, destDir, binName) {
+  const zipPath = join(destDir, '_rg.zip');
+  await pipeline(stream, createWriteStream(zipPath));
+  // Use PowerShell on Windows
+  await execAsync(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`);
+  // Find and move the exe to vendor root
+  try {
+    await execAsync(`powershell -Command "Get-ChildItem -Path '${destDir}' -Recurse -Filter '${binName}' | Select-Object -First 1 | Copy-Item -Destination '${join(destDir, binName)}'"`);
+    await execAsync(`powershell -Command "Remove-Item '${zipPath}' -Force"`);
+  } catch {}
+}
+
+try {
+  const res = await httpsGet(platform.url);
+  if (platform.url.endsWith('.zip')) {
+    await extractZip(res, VENDOR, platform.bin);
+  } else {
+    await extractTarGz(res, VENDOR, platform.bin);
+  }
+
+  if (existsSync(binPath)) {
+    if (process.platform !== 'win32') chmodSync(binPath, 0o755);
+    console.log(`[tsunami-code] ripgrep installed at ${binPath}`);
+  } else {
+    console.warn(`[tsunami-code] ripgrep extraction completed but binary not found at expected path — Grep tool will fall back to system rg`);
+  }
+} catch (e) {
+  console.warn(`[tsunami-code] Could not install ripgrep: ${e.message} — Grep tool will fall back to system rg`);
+}