@ayoxx/kundex 0.1.7 → 0.1.9

package/README.md

@@ -1,12 +1,12 @@
 # Kundex CLI & SDK
 
 The Kundex terminal AI coding agent — usable as a global CLI (`kundex`) or as
-an SDK (`import { ... } from "kundex"`).
+an SDK (`import { ... } from "@ayoxx/kundex"`).
 
 ## Install
 
 ```bash
-npm install -g kundex
+npm install -g @ayoxx/kundex
 ```
 
 ## Usage
@@ -20,15 +20,15 @@ kundex                # start an interactive agent session
 
 This export ships a GitHub Actions workflow at
 `.github/workflows/publish-cli.yml` that publishes to npm whenever you push a
-git tag matching `cli-v*` (e.g. `v0.2.0`):
+git tag matching `cli-v*` (e.g. `cli-v0.2.0`):
 
 1. Push this directory to a GitHub repo.
 2. In the repo's Settings > Secrets and variables > Actions, add an
    `NPM_TOKEN` secret (an npm automation token with publish rights).
 3. Bump `version` in `package.json`, commit, then:
    ```bash
-   git tag v0.2.0
-   git push origin v0.2.0
+   git tag cli-v0.2.0
+   git push origin cli-v0.2.0
    ```
 4. The workflow installs dependencies, type-checks, and runs `npm publish`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ayoxx/kundex",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Kundex — a terminal-based AI coding agent CLI and SDK, powered by Groq.",
   "type": "module",
   "bin": {

package/src/repl.ts

@@ -5,12 +5,177 @@ import { Kundex, type AgentTurn } from "./sdk";
 import { executeToolCall } from "./tools";
 import type { KundexConfig } from "./config";
 
-const HELP = `Commands:
-  /help    Show this help
-  /model   Show the model this session is using
-  /clear   Start a new agent session
-  /exit    Quit
-Anything else is sent to the agent as a message.`;
+// ─── ANSI colour helpers ──────────────────────────────────────────────────────
+const c = {
+  reset:   "\x1b[0m",
+  bold:    "\x1b[1m",
+  dim:     "\x1b[2m",
+  italic:  "\x1b[3m",
+  cyan:    "\x1b[36m",
+  green:   "\x1b[32m",
+  yellow:  "\x1b[33m",
+  red:     "\x1b[31m",
+  blue:    "\x1b[34m",
+  magenta: "\x1b[35m",
+  white:   "\x1b[37m",
+  // Syntax-highlight colours (256-colour palette)
+  kw:      "\x1b[38;5;204m",  // keywords     – salmon/red
+  str:     "\x1b[38;5;150m",  // strings      – light green
+  num:     "\x1b[38;5;141m",  // numbers      – light purple
+  comment: "\x1b[38;5;244m",  // comments     – grey
+  fn:      "\x1b[38;5;117m",  // functions    – light blue
+  type_:   "\x1b[38;5;215m",  // types/decorators – orange
+  punct:   "\x1b[38;5;250m",  // punctuation  – light grey
+};
+
+// ─── Per-language syntax highlighter (ANSI, no deps) ─────────────────────────
+interface LangRule {
+  pattern: RegExp;
+  color: string;
+}
+
+const KEYWORDS: Record<string, string[]> = {
+  python: ["def","class","return","import","from","if","elif","else","for","while",
+           "try","except","with","as","in","not","and","or","is","None","True","False","pass","raise","yield","async","await","lambda"],
+  javascript: ["const","let","var","function","return","if","else","for","while",
+               "class","extends","import","export","from","default","new","this",
+               "try","catch","finally","throw","async","await","typeof","instanceof","of","in","null","undefined","true","false"],
+  typescript: ["const","let","var","function","return","if","else","for","while",
+               "class","extends","implements","interface","type","import","export",
+               "from","default","new","this","try","catch","finally","throw","async",
+               "await","typeof","instanceof","of","in","null","undefined","true","false",
+               "string","number","boolean","any","void","never","unknown","enum","as","namespace"],
+  bash: ["if","then","else","elif","fi","for","while","do","done","case","esac",
+         "function","return","echo","exit","local","export","source","cd","ls","grep","awk","sed"],
+  go: ["func","package","import","var","const","type","struct","interface","return",
+       "if","else","for","range","switch","case","default","go","chan","defer","select","nil","true","false","map","make","new"],
+  rust: ["fn","let","mut","pub","use","mod","struct","enum","impl","trait","return",
+         "if","else","for","while","loop","match","Some","None","Ok","Err","true","false","self","Self","super","as","in","where","async","await"],
+};
+
+function buildRules(lang: string): LangRule[] {
+  const kws = KEYWORDS[lang] || KEYWORDS["javascript"];
+  return [
+    // Comments
+    { pattern: /(#.*$|\/\/.*$|\/\*[\s\S]*?\*\/|"""[\s\S]*?"""|'''[\s\S]*?''')/gm, color: c.comment },
+    // Strings
+    { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g, color: c.str },
+    // Numbers
+    { pattern: /\b(\d+\.?\d*(?:e[+-]?\d+)?)\b/g, color: c.num },
+    // Keywords (built from per-language list)
+    { pattern: new RegExp(`\\b(${kws.join("|")})\\b`, "g"), color: c.kw },
+    // Function calls
+    { pattern: /\b([a-zA-Z_]\w*)\s*(?=\()/g, color: c.fn },
+    // Type annotations (CamelCase identifiers)
+    { pattern: /\b([A-Z][a-zA-Z0-9_]*)\b/g, color: c.type_ },
+  ];
+}
+
+/** Apply regex-based ANSI syntax highlighting to a code string. */
+function syntaxHighlight(code: string, lang: string): string {
+  const l = lang.toLowerCase().replace(/^(tsx?|jsx?)$/, lang.includes("ts") || lang.includes("tsx") ? "typescript" : "javascript");
+  const normalised = ["python","py"].includes(l) ? "python"
+    : ["sh","shell","zsh"].includes(l) ? "bash"
+    : ["rs"].includes(l) ? "rust"
+    : l;
+
+  const rules = buildRules(normalised in KEYWORDS ? normalised : "javascript");
+
+  // We work character-by-character with a simple placeholder approach:
+  // collect all matches with their positions, sort them, then reconstruct.
+  type Span = { start: number; end: number; color: string };
+  const spans: Span[] = [];
+
+  for (const rule of rules) {
+    rule.pattern.lastIndex = 0;
+    let m: RegExpExecArray | null;
+    while ((m = rule.pattern.exec(code)) !== null) {
+      spans.push({ start: m.index, end: m.index + m[0].length, color: rule.color });
+      if (rule.pattern.lastIndex === m.index) rule.pattern.lastIndex++;
+    }
+  }
+
+  if (spans.length === 0) return code;
+
+  // Sort by start; discard overlapping spans (first wins)
+  spans.sort((a, b) => a.start - b.start);
+  const merged: Span[] = [];
+  let cursor = 0;
+  for (const span of spans) {
+    if (span.start < cursor) continue;
+    merged.push(span);
+    cursor = span.end;
+  }
+
+  let out = "";
+  cursor = 0;
+  for (const span of merged) {
+    out += code.slice(cursor, span.start);
+    out += span.color + code.slice(span.start, span.end) + c.reset;
+    cursor = span.end;
+  }
+  out += code.slice(cursor);
+  return out;
+}
+
+// ─── Code-block printer ───────────────────────────────────────────────────────
+function printCodeBlock(lang: string, code: string) {
+  const border = "─".repeat(52);
+  const label = lang || "code";
+  const labelPad = "─".repeat(Math.max(0, 52 - label.length - 3));
+
+  process.stdout.write(`${c.dim}┌─ ${c.reset}${c.bold}${label}${c.reset}${c.dim} ${labelPad}${c.reset}\n`);
+
+  const highlighted = syntaxHighlight(code, lang);
+  highlighted.split("\n").forEach(line => {
+    process.stdout.write(`${c.dim}│${c.reset} ${line}\n`);
+  });
+
+  process.stdout.write(`${c.dim}└${border}${c.reset}\n`);
+}
+
+// ─── Reply printer (handles mixed text + code blocks) ────────────────────────
+function printReply(text: string) {
+  process.stdout.write("\n");
+  const codeBlockRe = /```(\w*)\n?([\s\S]*?)```/g;
+  let last = 0;
+  let match: RegExpExecArray | null;
+
+  while ((match = codeBlockRe.exec(text)) !== null) {
+    const before = text.slice(last, match.index);
+    if (before.trim()) {
+      // Wrap plain text at ~100 chars
+      before.split("\n").forEach(line => {
+        process.stdout.write(`  ${line}\n`);
+      });
+    }
+    printCodeBlock(match[1], match[2].trimEnd());
+    last = match.index + match[0].length;
+  }
+
+  const tail = text.slice(last);
+  if (tail.trim()) {
+    tail.split("\n").forEach(line => {
+      process.stdout.write(`  ${line}\n`);
+    });
+  }
+
+  process.stdout.write(`\n${c.dim}${"─".repeat(60)}${c.reset}\n\n`);
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const HELP = `
+${c.bold}Commands:${c.reset}
+  /help         Show this help
+  /model        Show the model for this session
+  /clear        Start a fresh agent session
+  /exit         Quit kundex
+
+${c.bold}Tips:${c.reset}
+  • The agent can read, edit and search files, run commands, and use git.
+  • You will be asked to confirm any writes or shell commands before they run.
+  • Code blocks are syntax-highlighted in the terminal.
+`;
 
 function safeGitStatus(cwd: string): string | undefined {
   try {
@@ -20,6 +185,17 @@ function safeGitStatus(cwd: string): string | undefined {
   }
 }
 
+function safeFileTree(cwd: string): string | undefined {
+  try {
+    return execSync(
+      `find . -maxdepth 3 ! -path '*/node_modules/*' ! -path '*/.git/*' ! -path '*/dist/*' ! -path '*/build/*' -print`,
+      { cwd, timeout: 5000 }
+    ).toString().trim().split("\n").slice(0, 200).join("\n");
+  } catch {
+    return undefined;
+  }
+}
+
 async function handleTurn(
   kundex: Kundex,
   cwd: string,
@@ -30,10 +206,10 @@ async function handleTurn(
 
   while (!current.done && current.toolCalls && current.toolCalls.length > 0) {
     for (const call of current.toolCalls) {
-      console.log(`\n\u2192 ${call.name}(${call.arguments})`);
       const { result, isError } = await executeToolCall(cwd, call);
-      console.log(isError ? `  error: ${result}` : `  ${result.slice(0, 2000)}`);
-
+      if (isError) {
+        process.stdout.write(`${c.red}  ✗ ${call.name}: ${result}${c.reset}\n`);
+      }
       current = await kundex.agent.submitToolResult({
         sessionId,
         toolCallId: call.id,
@@ -44,51 +220,74 @@ async function handleTurn(
   }
 
   if (current.reply) {
-    console.log(`\nkundex: ${current.reply}\n`);
+    printReply(current.reply);
   }
 }
 
+function printBanner(cwd: string, model: string) {
+  const shortCwd = cwd.replace(process.env.HOME ?? "", "~");
+  console.log(`
+${c.bold}${c.cyan}  ██╗  ██╗██╗   ██╗███╗   ██╗██████╗ ███████╗██╗  ██╗${c.reset}
+${c.bold}${c.cyan}  ██║ ██╔╝██║   ██║████╗  ██║██╔══██╗██╔════╝╚██╗██╔╝${c.reset}
+${c.bold}${c.cyan}  █████╔╝ ██║   ██║██╔██╗ ██║██║  ██║█████╗   ╚███╔╝ ${c.reset}
+${c.bold}${c.cyan}  ██╔═██╗ ██║   ██║██║╚██╗██║██║  ██║██╔══╝   ██╔██╗ ${c.reset}
+${c.bold}${c.cyan}  ██║  ██╗╚██████╔╝██║ ╚████║██████╔╝███████╗██╔╝ ██╗${c.reset}
+${c.bold}${c.cyan}  ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝╚═════╝ ╚══════╝╚═╝  ╚═╝${c.reset}
+
+  ${c.dim}AI coding agent — terminal edition${c.reset}
+  ${c.dim}cwd:${c.reset}   ${c.bold}${shortCwd}${c.reset}
+  ${c.dim}model:${c.reset} ${c.bold}${model}${c.reset}
+
+  Type ${c.cyan}/help${c.reset} for commands.
+`);
+}
+
+// ─── REPL ─────────────────────────────────────────────────────────────────────
 export async function runRepl(config: KundexConfig, apiKey: string, baseUrl: string): Promise<void> {
   const cwd = process.cwd();
   const kundex = new Kundex({ apiKey, baseUrl });
   const model = config.defaultModel ?? "openai/gpt-oss-120b";
 
-  console.log(`Kundex agent — cwd: ${cwd}, model: ${model}`);
-  console.log("Type /help for commands.\n");
+  printBanner(cwd, model);
 
   let session = await kundex.agent.createSession({ cwd, model });
-
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
   try {
     for (;;) {
-      const input = (await rl.question("> ")).trim();
+      const raw = await rl.question(`${c.bold}${c.cyan}kundex${c.reset} ${c.dim}▸${c.reset} `);
+      const input = raw.trim();
       if (!input) continue;
 
-      if (input === "/exit") break;
-      if (input === "/help") {
-        console.log(HELP);
-        continue;
+      if (input === "/exit") {
+        console.log(`\n${c.dim}Goodbye!${c.reset}\n`);
+        break;
       }
+      if (input === "/help") { console.log(HELP); continue; }
       if (input === "/model") {
-        console.log(`Model: ${session.model}`);
+        console.log(`  ${c.dim}model:${c.reset} ${c.bold}${session.model}${c.reset}`);
         continue;
       }
       if (input === "/clear") {
         session = await kundex.agent.createSession({ cwd, model });
-        console.log("Started a new session.");
+        console.log(`\n${c.green}  ✓ Started a new session.${c.reset}\n`);
         continue;
       }
 
       try {
+        process.stdout.write(`\n${c.dim}  thinking...${c.reset}\n`);
         const turn = await kundex.agent.sendMessage({
           sessionId: session.id,
           message: input,
-          context: { gitStatus: safeGitStatus(cwd), openFiles: [] },
+          context: {
+            gitStatus: safeGitStatus(cwd),
+            fileTree: safeFileTree(cwd),
+            openFiles: [],
+          },
         });
         await handleTurn(kundex, cwd, session.id, turn);
       } catch (err) {
-        console.error(`Error: ${(err as Error).message}`);
+        console.error(`\n${c.red}  error: ${(err as Error).message}${c.reset}\n`);
       }
     }
   } finally {

package/src/tools.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { exec } from "node:child_process";
+import { exec, execFile } from "node:child_process";
 import readline from "node:readline/promises";
 
 export interface ToolCall {
@@ -14,10 +14,58 @@ export interface ToolResult {
   isError: boolean;
 }
 
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  white: "\x1b[37m",
+  bgDark: "\x1b[48;5;235m",
+};
+
+function header(label: string, value: string) {
+  process.stdout.write(
+    `${c.bold}${c.cyan}  ◆ ${label}${c.reset} ${c.dim}${value}${c.reset}\n`
+  );
+}
+
+function printDiff(oldContent: string | null, newContent: string, filePath: string) {
+  const oldLines = oldContent ? oldContent.split("\n") : [];
+  const newLines = newContent.split("\n");
+  const maxLines = Math.max(oldLines.length, newLines.length);
+  const LIMIT = 60;
+  const shown = Math.min(maxLines, LIMIT);
+
+  console.log(`\n${c.bold}${c.white}  ┌─ ${filePath} ─────────────────────────${c.reset}`);
+  for (let i = 0; i < shown; i++) {
+    const o = oldLines[i];
+    const n = newLines[i];
+    if (o === undefined) {
+      process.stdout.write(`${c.green}  + ${(i + 1).toString().padStart(4)}  ${n ?? ""}${c.reset}\n`);
+    } else if (n === undefined) {
+      process.stdout.write(`${c.red}  - ${(i + 1).toString().padStart(4)}  ${o ?? ""}${c.reset}\n`);
+    } else if (o !== n) {
+      process.stdout.write(`${c.red}  - ${(i + 1).toString().padStart(4)}  ${o}${c.reset}\n`);
+      process.stdout.write(`${c.green}  + ${(i + 1).toString().padStart(4)}  ${n}${c.reset}\n`);
+    } else {
+      process.stdout.write(`${c.dim}    ${(i + 1).toString().padStart(4)}  ${o}${c.reset}\n`);
+    }
+  }
+  if (maxLines > LIMIT) {
+    console.log(`${c.dim}  ... ${maxLines - LIMIT} more lines omitted${c.reset}`);
+  }
+  console.log(`${c.bold}${c.white}  └──────────────────────────────────────${c.reset}\n`);
+}
+
 async function confirm(prompt: string): Promise<boolean> {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   try {
-    const answer = await rl.question(`${prompt} [y/N] `);
+    const answer = await rl.question(`${c.yellow}${c.bold}  ? ${c.reset}${prompt} ${c.dim}[y/N]${c.reset} `);
     return answer.trim().toLowerCase().startsWith("y");
   } finally {
     rl.close();
@@ -34,40 +82,84 @@ function resolveInCwd(cwd: string, relPath: string): string {
 
 async function readFileTool(cwd: string, args: { path: string }): Promise<string> {
   const full = resolveInCwd(cwd, args.path);
+  header("read_file", args.path);
   return fs.readFile(full, "utf-8");
 }
 
 async function writeFileTool(cwd: string, args: { path: string; content: string }): Promise<string> {
-  const approved = await confirm(`Write ${args.content.length} bytes to "${args.path}"?`);
-  if (!approved) return "User declined to write this file.";
   const full = resolveInCwd(cwd, args.path);
+  const lines = args.content.split("\n").length;
+  const bytes = Buffer.byteLength(args.content, "utf-8");
+
+  console.log(`\n${c.bold}${c.magenta}  ◆ write_file${c.reset} ${c.dim}${args.path}${c.reset}`);
+  console.log(`${c.dim}     ${lines} lines  ·  ${bytes} bytes${c.reset}`);
+
+  // Show diff vs existing file
+  let oldContent: string | null = null;
+  try {
+    oldContent = await fs.readFile(full, "utf-8");
+    console.log(`${c.dim}     (modifying existing file)${c.reset}`);
+  } catch {
+    console.log(`${c.dim}     (creating new file)${c.reset}`);
+  }
+
+  printDiff(oldContent, args.content, args.path);
+
+  const approved = await confirm(`Write ${bytes} bytes to "${args.path}"?`);
+  if (!approved) return "User declined to write this file.";
+
   await fs.mkdir(path.dirname(full), { recursive: true });
   await fs.writeFile(full, args.content, "utf-8");
-  return `Wrote ${args.content.length} bytes to ${args.path}`;
+
+  console.log(`${c.green}${c.bold}  ✓ Wrote ${args.path}${c.reset} ${c.dim}(${bytes} bytes)${c.reset}\n`);
+  return `Wrote ${bytes} bytes to ${args.path}`;
 }
 
 async function runCommandTool(cwd: string, args: { command: string }): Promise<string> {
-  const approved = await confirm(`Run shell command: "${args.command}"?`);
+  console.log(`\n${c.bold}${c.yellow}  ◆ run_command${c.reset} ${c.dim}${args.command}${c.reset}`);
+  const approved = await confirm(`Run: ${c.bold}${args.command}${c.reset}?`);
   if (!approved) return "User declined to run this command.";
+
   return new Promise((resolve) => {
-    exec(args.command, { cwd, timeout: 60_000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
-      if (err) {
-        resolve(`Command failed (${err.message}):\n${stdout}\n${stderr}`);
+    const child = exec(args.command, { cwd, timeout: 60_000, maxBuffer: 4 * 1024 * 1024 });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout?.on("data", (chunk: string) => {
+      process.stdout.write(`${c.dim}  │ ${chunk}${c.reset}`);
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk: string) => {
+      process.stderr.write(`${c.red}  │ ${chunk}${c.reset}`);
+      stderr += chunk;
+    });
+
+    child.on("close", (code) => {
+      const combined = (stdout + (stderr ? `\nstderr:\n${stderr}` : "")).trim();
+      if (code !== 0) {
+        console.log(`${c.red}  ✗ exited with code ${code}${c.reset}\n`);
+        resolve(`Command failed (exit ${code}):\n${combined || "(no output)"}`);
       } else {
-        resolve(stdout || stderr || "(no output)");
+        console.log(`${c.green}  ✓ done${c.reset}\n`);
+        resolve(combined || "(no output)");
       }
     });
   });
 }
 
 async function gitTool(cwd: string, args: { args: string[] }): Promise<string> {
+  const cmd = `git ${args.args.join(" ")}`;
   const isMutating = !["status", "diff", "log", "show", "branch"].includes(args.args[0]);
+
+  header("git", cmd);
   if (isMutating) {
-    const approved = await confirm(`Run: git ${args.args.join(" ")}?`);
+    const approved = await confirm(`Run: ${c.bold}${cmd}${c.reset}?`);
     if (!approved) return "User declined to run this git command.";
   }
+
   return new Promise((resolve) => {
-    exec(`git ${args.args.join(" ")}`, { cwd, timeout: 30_000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+    exec(cmd, { cwd, timeout: 30_000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
       if (err) {
         resolve(`git command failed (${err.message}):\n${stdout}\n${stderr}`);
       } else {
@@ -77,7 +169,69 @@ async function gitTool(cwd: string, args: { args: string[] }): Promise<string> {
   });
 }
 
-/** Executes a single tool call locally, matching the server's AGENT_TOOLS contract. */
+async function listDirectoryTool(cwd: string, args: { path: string }): Promise<string> {
+  const full = resolveInCwd(cwd, args.path);
+  header("list_directory", args.path);
+  const entries = await fs.readdir(full, { withFileTypes: true });
+  const lines = entries.map(e => {
+    if (e.isDirectory()) return `  ${c.blue}${c.bold}${e.name}/${c.reset}`;
+    if (e.isSymbolicLink()) return `  ${c.cyan}${e.name}@${c.reset}`;
+    return `  ${e.name}`;
+  });
+  // Print inline preview
+  lines.forEach(l => process.stdout.write(l + "\n"));
+  return entries
+    .map(e => (e.isDirectory() ? `${e.name}/` : e.name))
+    .join("\n");
+}
+
+async function searchFilesTool(
+  cwd: string,
+  args: { pattern: string; glob?: string }
+): Promise<string> {
+  // Validate inputs: pattern must be a non-empty string; glob (if provided)
+  // must only contain safe filename characters to prevent shell expansion.
+  if (!args.pattern || typeof args.pattern !== "string") {
+    return "Search failed: pattern must be a non-empty string.";
+  }
+  if (args.glob !== undefined) {
+    if (typeof args.glob !== "string" || /[;&|`$(){}[\]<>!]/.test(args.glob)) {
+      return "Search failed: glob contains disallowed characters.";
+    }
+  }
+
+  header("search_files", `"${args.pattern}"${args.glob ? ` in ${args.glob}` : ""}`);
+
+  // Build the argument array passed directly to execFile — no shell involved.
+  const grepArgs: string[] = [
+    "-rn",
+    "--color=never",
+    "-m", "5",
+  ];
+  if (args.glob) {
+    grepArgs.push(`--include=${args.glob}`);
+  }
+  // Pattern and path as positional args (not shell-interpolated)
+  grepArgs.push(args.pattern, ".");
+
+  return new Promise((resolve) => {
+    execFile("grep", grepArgs, { cwd, timeout: 15_000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err && (err as NodeJS.ErrnoException & { code: number }).code === 1) {
+        // grep exits 1 when no matches are found — not an error
+        resolve("No matches found.");
+        return;
+      }
+      if (err) {
+        resolve(`Search failed: ${err.message}`);
+        return;
+      }
+      const lines = stdout.trim().split("\n").slice(0, 80);
+      lines.forEach(l => console.log(`  ${c.dim}${l}${c.reset}`));
+      resolve(stdout.trim() || "No matches found.");
+    });
+  });
+}
+
 export async function executeToolCall(cwd: string, call: ToolCall): Promise<ToolResult> {
   let args: any;
   try {
@@ -96,6 +250,10 @@ export async function executeToolCall(cwd: string, call: ToolCall): Promise<Tool
         return { result: await runCommandTool(cwd, args), isError: false };
       case "git":
         return { result: await gitTool(cwd, args), isError: false };
+      case "list_directory":
+        return { result: await listDirectoryTool(cwd, args), isError: false };
+      case "search_files":
+        return { result: await searchFilesTool(cwd, args), isError: false };
       default:
         return { result: `Unknown tool: ${call.name}`, isError: true };
     }