@yeaft/webchat-agent 0.1.442 → 0.1.443

package/unify/tools/file-read.js

@@ -0,0 +1,125 @@
+/**
+ * file-read.js — Read file contents with line numbers.
+ *
+ * Reads text files with `cat -n` style line numbering, supports
+ * offset/limit for large files, and handles binary file detection.
+ *
+ * Modeled after Claude Code's Read tool.
+ */
+
+import { defineTool } from './types.js';
+import { readFile, stat } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, extname } from 'path';
+
+/** Binary file extensions that shouldn't be read as text. */
+const BINARY_EXTS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg',
+  '.mp3', '.mp4', '.avi', '.mov', '.wav', '.flac',
+  '.zip', '.tar', '.gz', '.bz2', '.7z', '.rar',
+  '.exe', '.dll', '.so', '.dylib', '.o',
+  '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+  '.woff', '.woff2', '.ttf', '.otf', '.eot',
+  '.sqlite', '.db',
+]);
+
+/** Max file size to read (10 MB). */
+const MAX_FILE_SIZE = 10 * 1024 * 1024;
+
+/** Default number of lines to read. */
+const DEFAULT_LIMIT = 2000;
+
+export default defineTool({
+  name: 'FileRead',
+  description: `Read a file from the filesystem with line numbers.
+
+Returns file contents with line numbers (like \`cat -n\`).
+Supports offset and limit for reading specific portions of large files.
+
+Guidelines:
+- Use absolute paths when possible
+- For large files, use offset and limit to read specific sections
+- Binary files are detected by extension and rejected
+- Maximum file size: 10MB
+- Default limit: 2000 lines`,
+  parameters: {
+    type: 'object',
+    properties: {
+      file_path: {
+        type: 'string',
+        description: 'Path to the file to read (absolute or relative to cwd)',
+      },
+      offset: {
+        type: 'number',
+        description: 'Line number to start reading from (0-based, default: 0)',
+      },
+      limit: {
+        type: 'number',
+        description: `Maximum number of lines to read (default: ${DEFAULT_LIMIT})`,
+      },
+    },
+    required: ['file_path'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { file_path, offset = 0, limit = DEFAULT_LIMIT } = input;
+    if (!file_path) return JSON.stringify({ error: 'file_path is required' });
+
+    const cwd = ctx?.cwd || process.cwd();
+    const absPath = resolve(cwd, file_path);
+
+    // Check existence
+    if (!existsSync(absPath)) {
+      return JSON.stringify({ error: `File not found: ${absPath}` });
+    }
+
+    // Check binary
+    const ext = extname(absPath).toLowerCase();
+    if (BINARY_EXTS.has(ext)) {
+      return JSON.stringify({
+        error: `Cannot read binary file: ${absPath}`,
+        hint: 'Use a specialized tool for binary files',
+      });
+    }
+
+    try {
+      // Check file size
+      const fileStat = await stat(absPath);
+      if (fileStat.isDirectory()) {
+        return JSON.stringify({ error: `Path is a directory: ${absPath}. Use ListDir instead.` });
+      }
+      if (fileStat.size > MAX_FILE_SIZE) {
+        return JSON.stringify({
+          error: `File too large: ${(fileStat.size / 1024 / 1024).toFixed(1)}MB (max: ${MAX_FILE_SIZE / 1024 / 1024}MB)`,
+          hint: 'Use offset and limit to read specific sections',
+        });
+      }
+
+      const content = await readFile(absPath, 'utf-8');
+      const allLines = content.split('\n');
+      const totalLines = allLines.length;
+
+      // Apply offset and limit
+      const startLine = Math.max(0, Math.min(offset, totalLines));
+      const endLine = Math.min(startLine + limit, totalLines);
+      const lines = allLines.slice(startLine, endLine);
+
+      // Format with line numbers (1-based like cat -n)
+      const numbered = lines.map((line, i) => {
+        const lineNum = startLine + i + 1;
+        return `${lineNum}\t${line}`;
+      }).join('\n');
+
+      // Add metadata if partial
+      if (startLine > 0 || endLine < totalLines) {
+        return `${numbered}\n\n[Showing lines ${startLine + 1}-${endLine} of ${totalLines} total]`;
+      }
+
+      return numbered;
+    } catch (err) {
+      return JSON.stringify({ error: `Failed to read file: ${err.message}` });
+    }
+  },
+});

package/unify/tools/file-write.js

@@ -0,0 +1,73 @@
+/**
+ * file-write.js — Write or create files.
+ *
+ * Creates new files or overwrites existing ones. Creates parent
+ * directories as needed.
+ */
+
+import { defineTool } from './types.js';
+import { writeFile, mkdir } from 'fs/promises';
+import { resolve, dirname } from 'path';
+
+export default defineTool({
+  name: 'FileWrite',
+  description: `Write content to a file, creating it if it doesn't exist.
+
+Creates parent directories automatically. Overwrites existing files.
+
+Guidelines:
+- Use absolute paths when possible
+- For modifying existing files, prefer FileEdit (surgical edits) over FileWrite (full overwrite)
+- Parent directories are created automatically
+- Content should be the complete file content`,
+  parameters: {
+    type: 'object',
+    properties: {
+      file_path: {
+        type: 'string',
+        description: 'Path to the file to write (absolute or relative to cwd)',
+      },
+      content: {
+        type: 'string',
+        description: 'The complete file content to write',
+      },
+    },
+    required: ['file_path', 'content'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  isDestructive: () => false,
+  async execute(input, ctx) {
+    const { file_path, content } = input;
+    if (!file_path) return JSON.stringify({ error: 'file_path is required' });
+    if (content === undefined || content === null) {
+      return JSON.stringify({ error: 'content is required' });
+    }
+
+    const cwd = ctx?.cwd || process.cwd();
+    const absPath = resolve(cwd, file_path);
+
+    try {
+      // Ensure parent directory exists
+      const dir = dirname(absPath);
+      await mkdir(dir, { recursive: true });
+
+      // Write the file
+      await writeFile(absPath, content, 'utf-8');
+
+      const lines = content.split('\n').length;
+      const bytes = Buffer.byteLength(content, 'utf-8');
+
+      return JSON.stringify({
+        success: true,
+        path: absPath,
+        lines,
+        bytes,
+        message: `Wrote ${lines} lines (${bytes} bytes) to ${absPath}`,
+      });
+    } catch (err) {
+      return JSON.stringify({ error: `Failed to write file: ${err.message}` });
+    }
+  },
+});

package/unify/tools/glob.js

@@ -0,0 +1,143 @@
+/**
+ * glob.js — Find files by pattern matching.
+ *
+ * Uses Node.js glob patterns to find files matching a pattern.
+ * Results are sorted by modification time (newest first).
+ */
+
+import { defineTool } from './types.js';
+import { readdir, stat } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, join, relative } from 'path';
+
+/**
+ * Simple glob pattern matcher (supports * and **).
+ * @param {string} pattern
+ * @param {string} str
+ * @returns {boolean}
+ */
+function matchGlob(pattern, str) {
+  // Convert glob pattern to regex
+  // IMPORTANT: escape dots FIRST before replacing glob chars to avoid
+  // corrupting regex tokens like [^/]* and .*
+  let regex = pattern
+    .replace(/\\/g, '/')
+    .replace(/\./g, '\\.')     // Escape dots first (before glob replacements)
+    .replace(/\*\*/g, '<<<GLOBSTAR>>>')
+    .replace(/\*/g, '[^/]*')
+    .replace(/<<<GLOBSTAR>>>/g, '.*')
+    .replace(/\?/g, '[^/]');
+  regex = '^' + regex + '$';
+  return new RegExp(regex).test(str.replace(/\\/g, '/'));
+}
+
+/**
+ * Recursively walk a directory, yielding relative paths.
+ */
+async function* walkDir(dir, baseDir, maxDepth = 10, depth = 0) {
+  if (depth > maxDepth) return;
+
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  // Skip common large/irrelevant directories
+  const SKIP = new Set([
+    'node_modules', '.git', '__pycache__', '.next', '.nuxt',
+    'dist', 'build', '.cache', '.venv', 'venv', '.tox',
+    'vendor', 'target', '.gradle', '.idea', '.vscode',
+  ]);
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    const relPath = relative(baseDir, fullPath);
+
+    if (entry.isDirectory()) {
+      if (SKIP.has(entry.name)) continue;
+      yield { path: relPath, isDir: true };
+      yield* walkDir(fullPath, baseDir, maxDepth, depth + 1);
+    } else {
+      yield { path: relPath, isDir: false };
+    }
+  }
+}
+
+export default defineTool({
+  name: 'Glob',
+  description: `Find files matching a glob pattern.
+
+Supports glob patterns like "**/*.js", "src/**/*.ts", "*.md".
+Results are sorted by modification time (newest first).
+
+Guidelines:
+- Use "**/" for recursive directory matching
+- Common directories (node_modules, .git, etc.) are skipped
+- Returns file paths relative to the search directory
+- Limited to 500 results by default`,
+  parameters: {
+    type: 'object',
+    properties: {
+      pattern: {
+        type: 'string',
+        description: 'Glob pattern to match files (e.g. "**/*.js")',
+      },
+      path: {
+        type: 'string',
+        description: 'Directory to search in (default: cwd)',
+      },
+      limit: {
+        type: 'number',
+        description: 'Maximum number of results (default: 500)',
+      },
+    },
+    required: ['pattern'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { pattern, path: searchPath, limit = 500 } = input;
+    if (!pattern) return JSON.stringify({ error: 'pattern is required' });
+
+    const cwd = ctx?.cwd || process.cwd();
+    const baseDir = searchPath ? resolve(cwd, searchPath) : cwd;
+
+    if (!existsSync(baseDir)) {
+      return JSON.stringify({ error: `Directory not found: ${baseDir}` });
+    }
+
+    try {
+      const matches = [];
+
+      for await (const entry of walkDir(baseDir, baseDir)) {
+        if (matches.length >= limit * 2) break; // over-fetch for sorting
+
+        if (!entry.isDir && matchGlob(pattern, entry.path)) {
+          // Get mtime for sorting
+          try {
+            const fileStat = await stat(join(baseDir, entry.path));
+            matches.push({
+              path: entry.path,
+              mtime: fileStat.mtimeMs,
+            });
+          } catch {
+            matches.push({ path: entry.path, mtime: 0 });
+          }
+        }
+      }
+
+      // Sort by mtime (newest first)
+      matches.sort((a, b) => b.mtime - a.mtime);
+
+      // Trim to limit
+      const trimmed = matches.slice(0, limit);
+
+      return trimmed.map(m => m.path).join('\n') || '(no matches)';
+    } catch (err) {
+      return JSON.stringify({ error: `Glob search failed: ${err.message}` });
+    }
+  },
+});

package/unify/tools/grep.js

@@ -0,0 +1,268 @@
+/**
+ * grep.js — Search file contents for patterns.
+ *
+ * Searches for regex patterns in files. Tries to use ripgrep (rg) if
+ * available for performance, falls back to a Node.js implementation.
+ */
+
+import { defineTool } from './types.js';
+import { spawn } from 'child_process';
+import { readdir, readFile, stat } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, join, relative, extname } from 'path';
+
+/** Max output lines. */
+const MAX_LINES = 250;
+
+/** Binary extensions to skip. */
+const BINARY_EXTS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp',
+  '.mp3', '.mp4', '.avi', '.mov', '.wav',
+  '.zip', '.tar', '.gz', '.bz2', '.7z', '.rar',
+  '.exe', '.dll', '.so', '.dylib', '.o',
+  '.pdf', '.doc', '.docx', '.xls', '.xlsx',
+  '.woff', '.woff2', '.ttf', '.otf',
+  '.sqlite', '.db',
+]);
+
+/**
+ * Check if ripgrep is available.
+ */
+function hasRipgrep() {
+  return new Promise((resolve) => {
+    const proc = spawn('rg', ['--version'], { stdio: 'pipe' });
+    proc.on('close', (code) => resolve(code === 0));
+    proc.on('error', () => resolve(false));
+  });
+}
+
+/**
+ * Run ripgrep and return results.
+ */
+function runRipgrep(pattern, searchPath, options) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      pattern,
+      searchPath,
+      '--no-heading',
+      '--line-number',
+      '--color', 'never',
+    ];
+
+    if (options.caseInsensitive) args.push('-i');
+    if (options.glob) args.push('--glob', options.glob);
+    if (options.type) args.push('--type', options.type);
+    if (options.filesOnly) args.push('-l');
+    if (options.count) args.push('-c');
+    if (options.context) args.push('-C', String(options.context));
+    if (options.before) args.push('-B', String(options.before));
+    if (options.after) args.push('-A', String(options.after));
+    if (options.multiline) args.push('-U', '--multiline-dotall');
+    args.push('--max-count', String(options.maxResults || 500));
+
+    const proc = spawn('rg', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+      // Truncate early if way too large
+      if (stdout.length > 512 * 1024) {
+        try { proc.kill(); } catch {}
+      }
+    });
+    proc.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+    proc.on('close', (code) => {
+      if (code === 0 || code === 1) {
+        resolve(stdout);
+      } else {
+        reject(new Error(stderr || `rg exited with code ${code}`));
+      }
+    });
+    proc.on('error', reject);
+  });
+}
+
+/**
+ * Fallback: Node.js grep implementation.
+ */
+async function nodeGrep(pattern, searchPath, options) {
+  const regex = new RegExp(pattern, options.caseInsensitive ? 'gi' : 'g');
+  const results = [];
+  const SKIP = new Set(['node_modules', '.git', '__pycache__', '.next', 'dist', 'build', '.cache']);
+
+  async function searchDir(dir) {
+    if (results.length >= (options.maxResults || 500)) return;
+    let entries;
+    try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
+
+    for (const entry of entries) {
+      if (results.length >= (options.maxResults || 500)) return;
+      const fullPath = join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        if (SKIP.has(entry.name)) continue;
+        await searchDir(fullPath);
+      } else {
+        const ext = extname(entry.name).toLowerCase();
+        if (BINARY_EXTS.has(ext)) continue;
+
+        try {
+          const fileStat = await stat(fullPath);
+          if (fileStat.size > 1024 * 1024) continue; // skip files > 1MB
+
+          const content = await readFile(fullPath, 'utf-8');
+          const relPath = relative(searchPath, fullPath);
+
+          if (options.filesOnly) {
+            if (regex.test(content)) results.push(relPath);
+            regex.lastIndex = 0;
+          } else if (options.count) {
+            const matches = content.match(regex);
+            if (matches) results.push(`${relPath}:${matches.length}`);
+          } else {
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+              if (regex.test(lines[i])) {
+                results.push(`${relPath}:${i + 1}:${lines[i]}`);
+              }
+              regex.lastIndex = 0;
+            }
+          }
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    }
+  }
+
+  await searchDir(searchPath);
+  return results.join('\n');
+}
+
+export default defineTool({
+  name: 'Grep',
+  description: `Search file contents for a regex pattern.
+
+Uses ripgrep (rg) when available for fast searching, with a Node.js fallback.
+
+Output modes:
+- "content" — show matching lines with file path and line numbers
+- "files_with_matches" — show only file paths that match (default)
+- "count" — show match count per file
+
+Guidelines:
+- Uses regex syntax (escape special chars: \\., \\{, etc.)
+- Use glob or type filters to narrow the search
+- Skips binary files and common large directories (node_modules, .git)
+- Results are limited to 500 matches by default`,
+  parameters: {
+    type: 'object',
+    properties: {
+      pattern: {
+        type: 'string',
+        description: 'Regex pattern to search for',
+      },
+      path: {
+        type: 'string',
+        description: 'File or directory to search (default: cwd)',
+      },
+      output_mode: {
+        type: 'string',
+        enum: ['content', 'files_with_matches', 'count'],
+        description: 'Output format (default: "files_with_matches")',
+      },
+      glob: {
+        type: 'string',
+        description: 'Glob filter for file names (e.g. "*.js", "*.{ts,tsx}")',
+      },
+      type: {
+        type: 'string',
+        description: 'File type filter (e.g. "js", "py", "rust")',
+      },
+      case_insensitive: {
+        type: 'boolean',
+        description: 'Case-insensitive search (default: false)',
+      },
+      context: {
+        type: 'number',
+        description: 'Lines of context around matches (for "content" mode)',
+      },
+      before: {
+        type: 'number',
+        description: 'Lines before each match',
+      },
+      after: {
+        type: 'number',
+        description: 'Lines after each match',
+      },
+      multiline: {
+        type: 'boolean',
+        description: 'Enable multiline matching',
+      },
+      head_limit: {
+        type: 'number',
+        description: 'Limit output to first N results (default: 250)',
+      },
+    },
+    required: ['pattern'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const {
+      pattern, path: searchPath, output_mode = 'files_with_matches',
+      glob: globFilter, type, case_insensitive = false,
+      context, before, after, multiline = false,
+      head_limit = MAX_LINES,
+    } = input;
+
+    if (!pattern) return JSON.stringify({ error: 'pattern is required' });
+
+    const cwd = ctx?.cwd || process.cwd();
+    const absPath = searchPath ? resolve(cwd, searchPath) : cwd;
+
+    if (!existsSync(absPath)) {
+      return JSON.stringify({ error: `Path not found: ${absPath}` });
+    }
+
+    const options = {
+      caseInsensitive: case_insensitive,
+      glob: globFilter,
+      type,
+      filesOnly: output_mode === 'files_with_matches',
+      count: output_mode === 'count',
+      context,
+      before,
+      after,
+      multiline,
+      maxResults: head_limit * 2,
+    };
+
+    try {
+      let result;
+      const rgAvailable = await hasRipgrep();
+
+      if (rgAvailable) {
+        result = await runRipgrep(pattern, absPath, options);
+      } else {
+        result = await nodeGrep(pattern, absPath, options);
+      }
+
+      if (!result || !result.trim()) {
+        return '(no matches)';
+      }
+
+      // Limit output lines
+      const lines = result.trim().split('\n');
+      if (lines.length > head_limit) {
+        return lines.slice(0, head_limit).join('\n') + `\n\n... (${lines.length - head_limit} more results)`;
+      }
+
+      return result.trim();
+    } catch (err) {
+      return JSON.stringify({ error: `Grep failed: ${err.message}` });
+    }
+  },
+});

package/unify/tools/history-search.js

@@ -0,0 +1,69 @@
+/**
+ * history-search.js — Search conversation history.
+ *
+ * Searches through persisted conversation messages for keywords.
+ * Uses the ConversationStore's search functionality.
+ */
+
+import { defineTool } from './types.js';
+import { searchMessages } from '../conversation/search.js';
+
+export default defineTool({
+  name: 'HistorySearch',
+  description: `Search through past conversation history.
+
+Searches for keywords in previously persisted conversation messages.
+Useful for finding previous discussions, decisions, or code snippets.
+
+Results are returned newest-first with message role and content.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      keyword: {
+        type: 'string',
+        description: 'Search keyword (case-insensitive)',
+      },
+      limit: {
+        type: 'number',
+        description: 'Maximum number of results (default: 20)',
+      },
+    },
+    required: ['keyword'],
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { keyword, limit = 20 } = input;
+    if (!keyword) return JSON.stringify({ error: 'keyword is required' });
+
+    const yeaftDir = ctx?.yeaftDir;
+    if (!yeaftDir) {
+      return JSON.stringify({ error: 'Yeaft directory not configured — no conversation history available' });
+    }
+
+    try {
+      const results = searchMessages(yeaftDir, keyword, limit);
+
+      if (results.length === 0) {
+        return JSON.stringify({
+          results: [],
+          message: `No matches found for "${keyword}"`,
+        });
+      }
+
+      return JSON.stringify({
+        results: results.map(msg => ({
+          role: msg.role,
+          content: msg.content?.slice(0, 2000) + (msg.content?.length > 2000 ? '...' : ''),
+          mode: msg.mode,
+          timestamp: msg.timestamp,
+        })),
+        totalResults: results.length,
+        keyword,
+      }, null, 2);
+    } catch (err) {
+      return JSON.stringify({ error: `History search failed: ${err.message}` });
+    }
+  },
+});