@yeaft/webchat-agent 0.1.441 → 0.1.443

package/unify/tools/file-edit.js

@@ -0,0 +1,120 @@
+/**
+ * file-edit.js — Surgical string-replacement edits to files.
+ *
+ * Performs exact string matching and replacement within files,
+ * similar to Claude Code's Edit tool. Supports replace_all for
+ * bulk replacements across the file.
+ */
+
+import { defineTool } from './types.js';
+import { readFile, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+
+export default defineTool({
+  name: 'FileEdit',
+  description: `Make surgical text replacements in an existing file.
+
+Replaces exact occurrences of old_string with new_string.
+The old_string must be unique in the file unless replace_all is true.
+
+Guidelines:
+- old_string must match EXACTLY (including whitespace and indentation)
+- The edit fails if old_string is not found or is not unique
+- Use replace_all: true to replace ALL occurrences
+- For creating new files or full rewrites, use FileWrite instead
+- Always read the file first to understand its current content`,
+  parameters: {
+    type: 'object',
+    properties: {
+      file_path: {
+        type: 'string',
+        description: 'Path to the file to edit (absolute or relative to cwd)',
+      },
+      old_string: {
+        type: 'string',
+        description: 'The exact text to find and replace',
+      },
+      new_string: {
+        type: 'string',
+        description: 'The replacement text',
+      },
+      replace_all: {
+        type: 'boolean',
+        description: 'Replace all occurrences (default: false — fails if not unique)',
+      },
+    },
+    required: ['file_path', 'old_string', 'new_string'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  isDestructive: () => false,
+  async execute(input, ctx) {
+    const { file_path, old_string, new_string, replace_all = false } = input;
+    if (!file_path) return JSON.stringify({ error: 'file_path is required' });
+    if (old_string === undefined) return JSON.stringify({ error: 'old_string is required' });
+    if (new_string === undefined) return JSON.stringify({ error: 'new_string is required' });
+    if (old_string === new_string) return JSON.stringify({ error: 'old_string and new_string are identical' });
+
+    const cwd = ctx?.cwd || process.cwd();
+    const absPath = resolve(cwd, file_path);
+
+    if (!existsSync(absPath)) {
+      return JSON.stringify({ error: `File not found: ${absPath}` });
+    }
+
+    try {
+      const content = await readFile(absPath, 'utf-8');
+
+      // Count occurrences
+      let count = 0;
+      let idx = 0;
+      while (true) {
+        idx = content.indexOf(old_string, idx);
+        if (idx === -1) break;
+        count++;
+        idx += old_string.length;
+      }
+
+      if (count === 0) {
+        // Provide context for debugging
+        const preview = old_string.length > 100
+          ? old_string.slice(0, 100) + '...'
+          : old_string;
+        return JSON.stringify({
+          error: `old_string not found in file`,
+          hint: `The exact text "${preview}" was not found in ${absPath}. Check whitespace and indentation.`,
+        });
+      }
+
+      if (count > 1 && !replace_all) {
+        return JSON.stringify({
+          error: `old_string found ${count} times — not unique. Use replace_all: true to replace all occurrences, or provide more context to make it unique.`,
+          occurrences: count,
+        });
+      }
+
+      // Perform replacement
+      let newContent;
+      if (replace_all) {
+        newContent = content.split(old_string).join(new_string);
+      } else {
+        // Replace only the first occurrence (which is guaranteed unique)
+        const replaceIdx = content.indexOf(old_string);
+        newContent = content.slice(0, replaceIdx) + new_string + content.slice(replaceIdx + old_string.length);
+      }
+
+      await writeFile(absPath, newContent, 'utf-8');
+
+      return JSON.stringify({
+        success: true,
+        path: absPath,
+        replacements: replace_all ? count : 1,
+        message: `Replaced ${replace_all ? count : 1} occurrence(s) in ${absPath}`,
+      });
+    } catch (err) {
+      return JSON.stringify({ error: `Failed to edit file: ${err.message}` });
+    }
+  },
+});

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}` });
+    }
+  },
+});