@yeaft/webchat-agent 0.1.442 → 0.1.444

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

package/unify/tools/image-generation.js

@@ -0,0 +1,97 @@
+/**
+ * image-generation.js — Generate images via external API.
+ *
+ * Delegates to a configured image generation service (DALL-E, etc.).
+ */
+
+import { defineTool } from './types.js';
+
+export default defineTool({
+  name: 'ImageGeneration',
+  description: `Generate an image from a text description.
+
+Uses a configured image generation API to create images.
+Requires an image generation API endpoint in config.
+
+Guidelines:
+- Provide detailed, specific descriptions for best results
+- Specify style, composition, and mood
+- Images are saved to the working directory`,
+  parameters: {
+    type: 'object',
+    properties: {
+      prompt: {
+        type: 'string',
+        description: 'Text description of the image to generate',
+      },
+      output_path: {
+        type: 'string',
+        description: 'File path to save the generated image',
+      },
+      size: {
+        type: 'string',
+        enum: ['256x256', '512x512', '1024x1024'],
+        description: 'Image size (default: "1024x1024")',
+      },
+    },
+    required: ['prompt'],
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => false,
+  async execute(input, ctx) {
+    const { prompt, output_path, size = '1024x1024' } = input;
+    if (!prompt) return JSON.stringify({ error: 'prompt is required' });
+
+    const imageApiUrl = ctx?.config?.imageApiUrl;
+    if (!imageApiUrl) {
+      return JSON.stringify({
+        error: 'No image generation API configured.',
+        hint: 'Configure imageApiUrl in ~/.yeaft/config.json',
+      });
+    }
+
+    try {
+      const response = await fetch(imageApiUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ prompt, size }),
+        signal: ctx?.signal,
+      });
+
+      if (!response.ok) {
+        return JSON.stringify({ error: `Image API returned ${response.status}: ${response.statusText}` });
+      }
+
+      const data = await response.json();
+
+      // If output_path specified, save the image
+      if (output_path && data.url) {
+        const { resolve: resolvePath } = await import('path');
+        const { writeFile } = await import('fs/promises');
+
+        const imgResponse = await fetch(data.url);
+        const buffer = Buffer.from(await imgResponse.arrayBuffer());
+        const absPath = resolvePath(ctx?.cwd || process.cwd(), output_path);
+        await writeFile(absPath, buffer);
+
+        return JSON.stringify({
+          success: true,
+          path: absPath,
+          size,
+          prompt: prompt.slice(0, 100),
+        });
+      }
+
+      return JSON.stringify({
+        success: true,
+        url: data.url,
+        size,
+        prompt: prompt.slice(0, 100),
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') return JSON.stringify({ error: 'Generation cancelled' });
+      return JSON.stringify({ error: `Image generation failed: ${err.message}` });
+    }
+  },
+});

package/unify/tools/index.js

@@ -9,21 +9,113 @@
  */
 
 import { ToolRegistry } from './registry.js';
+
+// --- Existing tools ---
 import mcpTools from './mcp-tools.js';
 import skillTool from './skill.js';
 import enterWorktree from './enter-worktree.js';
 import exitWorktree from './exit-worktree.js';
 
+// --- P0 Core tools ---
+import askUser from './ask-user.js';
+import memoryRead from './memory-read.js';
+import memoryWrite from './memory-write.js';
+import memorySearch from './memory-search.js';
+import webSearch from './web-search.js';
+import webFetch from './web-fetch.js';
+import historySearch from './history-search.js';
+
+// --- P0 File tools ---
+import bash from './bash.js';
+import fileRead from './file-read.js';
+import fileWrite from './file-write.js';
+import fileEdit from './file-edit.js';
+import globTool from './glob.js';
+import grepTool from './grep.js';
+import listDir from './list-dir.js';
+import applyPatch from './apply-patch.js';
+
+// --- P1 Agent tools ---
+import agentTool from './agent.js';
+import sendMessage from './send-message.js';
+import waitAgent from './wait-agent.js';
+import closeAgent from './close-agent.js';
+import listAgents from './list-agents.js';
+
+// --- P1 Task tools ---
+import {
+  taskCreate,
+  taskUpdate,
+  taskList,
+  taskGet,
+  followupTask,
+  updatePlan,
+} from './task-tools.js';
+
+// --- P2 Auxiliary tools ---
+import { jsRepl, jsReplReset } from './js-repl.js';
+import notebookEdit from './notebook-edit.js';
+import imageGeneration from './image-generation.js';
+import viewImage from './view-image.js';
+import toolSearch from './tool-search.js';
+import requestPermissions from './request-permissions.js';
+import writeStdin from './write-stdin.js';
+
 /**
  * All built-in tools, flattened into a single array.
  * mcpTools is already an array; the rest are single ToolDef objects.
  * @type {import('./types.js').ToolDef[]}
  */
 export const allTools = [
+  // Existing tools
   ...mcpTools,
   skillTool,
   enterWorktree,
   exitWorktree,
+
+  // P0 Core
+  askUser,
+  memoryRead,
+  memoryWrite,
+  memorySearch,
+  webSearch,
+  webFetch,
+  historySearch,
+
+  // P0 File
+  bash,
+  fileRead,
+  fileWrite,
+  fileEdit,
+  globTool,
+  grepTool,
+  listDir,
+  applyPatch,
+
+  // P1 Agent
+  agentTool,
+  sendMessage,
+  waitAgent,
+  closeAgent,
+  listAgents,
+
+  // P1 Task
+  taskCreate,
+  taskUpdate,
+  taskList,
+  taskGet,
+  followupTask,
+  updatePlan,
+
+  // P2 Auxiliary
+  jsRepl,
+  jsReplReset,
+  notebookEdit,
+  imageGeneration,
+  viewImage,
+  toolSearch,
+  requestPermissions,
+  writeStdin,
 ];
 
 /**

package/unify/tools/js-repl.js

@@ -0,0 +1,122 @@
+/**
+ * js-repl.js — JavaScript REPL for evaluating expressions.
+ *
+ * Runs JavaScript code in a persistent VM context, allowing
+ * state to be maintained across calls.
+ */
+
+import { defineTool } from './types.js';
+import { createContext, runInContext } from 'vm';
+
+/** Persistent VM context per session. */
+let vmContext = null;
+
+function getContext() {
+  if (!vmContext) {
+    vmContext = createContext({
+      console: {
+        log: (...args) => { vmContext.__output.push(args.map(String).join(' ')); },
+        error: (...args) => { vmContext.__output.push('[error] ' + args.map(String).join(' ')); },
+        warn: (...args) => { vmContext.__output.push('[warn] ' + args.map(String).join(' ')); },
+      },
+      setTimeout,
+      setInterval,
+      clearTimeout,
+      clearInterval,
+      JSON,
+      Math,
+      Date,
+      RegExp,
+      Array,
+      Object,
+      String,
+      Number,
+      Boolean,
+      Map,
+      Set,
+      WeakMap,
+      WeakSet,
+      Promise,
+      Error,
+      Buffer,
+      __output: [],
+    });
+  }
+  vmContext.__output = [];
+  return vmContext;
+}
+
+export const jsRepl = defineTool({
+  name: 'JsRepl',
+  description: `Evaluate JavaScript code in a persistent REPL environment.
+
+The REPL context persists across calls — variables and functions
+defined in one call are available in subsequent calls.
+
+Guidelines:
+- Use for calculations, data transformations, and quick experiments
+- State is preserved between calls (use JsReplReset to clear)
+- console.log output is captured and returned
+- Returns the last expression's value plus any console output
+- No filesystem or network access from within the REPL`,
+  parameters: {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        description: 'JavaScript code to evaluate',
+      },
+    },
+    required: ['code'],
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { code } = input;
+    if (!code) return JSON.stringify({ error: 'code is required' });
+
+    const vmCtx = getContext();
+
+    try {
+      const result = runInContext(code, vmCtx, {
+        timeout: 10000, // 10 second timeout
+        displayErrors: true,
+      });
+
+      const output = vmCtx.__output.slice();
+      const resultStr = result === undefined ? '' : String(result);
+
+      const parts = [];
+      if (output.length > 0) parts.push(output.join('\n'));
+      if (resultStr) parts.push(`→ ${resultStr}`);
+
+      return parts.join('\n') || '(no output)';
+    } catch (err) {
+      const output = vmCtx.__output.slice();
+      const parts = [];
+      if (output.length > 0) parts.push(output.join('\n'));
+      parts.push(`Error: ${err.message}`);
+      return parts.join('\n');
+    }
+  },
+});
+
+export const jsReplReset = defineTool({
+  name: 'JsReplReset',
+  description: `Reset the JavaScript REPL environment.
+
+Clears all variables and state from previous evaluations.
+Use when you want a clean slate.`,
+  parameters: {
+    type: 'object',
+    properties: {},
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input, ctx) {
+    vmContext = null;
+    return JSON.stringify({ success: true, message: 'REPL context reset' });
+  },
+});