@yeaft/webchat-agent 0.1.442 → 0.1.443

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

package/unify/tools/list-agents.js

@@ -0,0 +1,56 @@
+/**
+ * list-agents.js — List all active sub-agents.
+ */
+
+import { defineTool } from './types.js';
+import { getAgentRegistry } from './agent.js';
+
+export default defineTool({
+  name: 'ListAgents',
+  description: `List all sub-agents and their current status.
+
+Shows agent IDs, names, tasks, status (created/active/completed/closed),
+and message counts. Use to monitor parallel task progress.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      include_closed: {
+        type: 'boolean',
+        description: 'Include closed agents in the list (default: false)',
+      },
+    },
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { include_closed = false } = input;
+    const agents = getAgentRegistry();
+
+    const agentList = [];
+    for (const [id, agent] of agents) {
+      if (!include_closed && agent.status === 'closed') continue;
+      agentList.push({
+        id,
+        name: agent.name,
+        status: agent.status,
+        task: agent.task?.slice(0, 200),
+        messages: agent.messages.length,
+        hasResult: !!agent.result,
+        createdAt: agent.createdAt,
+      });
+    }
+
+    if (agentList.length === 0) {
+      return JSON.stringify({
+        agents: [],
+        message: 'No active sub-agents',
+      });
+    }
+
+    return JSON.stringify({
+      agents: agentList,
+      totalCount: agentList.length,
+    }, null, 2);
+  },
+});

package/unify/tools/list-dir.js

@@ -0,0 +1,106 @@
+/**
+ * list-dir.js — List directory contents.
+ *
+ * Lists files and directories with type, size, and modification time.
+ * Skips common large directories (node_modules, .git, etc.).
+ */
+
+import { defineTool } from './types.js';
+import { readdir, stat } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, join } from 'path';
+
+/** Directories to skip in listings. */
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', '__pycache__', '.next', '.nuxt', '.cache',
+]);
+
+export default defineTool({
+  name: 'ListDir',
+  description: `List the contents of a directory.
+
+Shows files and subdirectories with their types and sizes.
+Directories are listed first, then files, both sorted alphabetically.
+Common large directories (node_modules, .git) are skipped.
+
+This is better than using Bash with 'ls' because it provides structured output.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      path: {
+        type: 'string',
+        description: 'Directory path to list (default: cwd)',
+      },
+      show_hidden: {
+        type: 'boolean',
+        description: 'Include hidden files (starting with dot, default: true)',
+      },
+    },
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { path: dirPath, show_hidden = true } = input;
+
+    const cwd = ctx?.cwd || process.cwd();
+    const absPath = dirPath ? resolve(cwd, dirPath) : cwd;
+
+    if (!existsSync(absPath)) {
+      return JSON.stringify({ error: `Directory not found: ${absPath}` });
+    }
+
+    try {
+      const entries = await readdir(absPath, { withFileTypes: true });
+      const results = [];
+
+      for (const entry of entries) {
+        // Skip hidden files if not requested
+        if (!show_hidden && entry.name.startsWith('.')) continue;
+
+        // Skip large directories
+        if (entry.isDirectory() && SKIP_DIRS.has(entry.name)) continue;
+
+        try {
+          const fullPath = join(absPath, entry.name);
+          const fileStat = await stat(fullPath);
+          results.push({
+            name: entry.name,
+            type: entry.isDirectory() ? 'dir' : 'file',
+            size: fileStat.size,
+            modified: fileStat.mtime.toISOString(),
+          });
+        } catch {
+          results.push({
+            name: entry.name,
+            type: entry.isDirectory() ? 'dir' : 'file',
+            size: 0,
+          });
+        }
+      }
+
+      // Sort: directories first, then files, alphabetically
+      results.sort((a, b) => {
+        if (a.type !== b.type) return a.type === 'dir' ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
+
+      // Format as text
+      const lines = results.map(r => {
+        const typeChar = r.type === 'dir' ? '📁' : '📄';
+        const sizeStr = r.type === 'dir' ? '' : ` (${formatSize(r.size)})`;
+        return `${typeChar} ${r.name}${sizeStr}`;
+      });
+
+      return `${absPath}/\n\n${lines.join('\n')}` || `${absPath}/ (empty directory)`;
+    } catch (err) {
+      return JSON.stringify({ error: `Failed to list directory: ${err.message}` });
+    }
+  },
+});
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}

package/unify/tools/memory-read.js

@@ -0,0 +1,91 @@
+/**
+ * memory-read.js — Read memory entries from the Yeaft memory store.
+ *
+ * Reads the user profile (MEMORY.md), specific sections, or individual
+ * memory entries by name.
+ */
+
+import { defineTool } from './types.js';
+
+export default defineTool({
+  name: 'MemoryRead',
+  description: `Read from Yeaft's persistent memory system.
+
+Actions:
+- "profile" — read the full MEMORY.md user profile
+- "section" — read a specific section from MEMORY.md (e.g. "Facts", "Preferences")
+- "entry" — read a specific memory entry by name
+- "list" — list all memory entries (frontmatter only, no body)
+- "scopes" — list all memory scopes and their entry counts`,
+  parameters: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['profile', 'section', 'entry', 'list', 'scopes'],
+        description: 'What to read from memory',
+      },
+      name: {
+        type: 'string',
+        description: 'Entry name slug (for "entry" action) or section name (for "section" action)',
+      },
+    },
+    required: ['action'],
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const memoryStore = ctx?.memoryStore;
+    if (!memoryStore) {
+      return JSON.stringify({ error: 'Memory system not initialized' });
+    }
+
+    try {
+      switch (input.action) {
+        case 'profile': {
+          const profile = memoryStore.readProfile();
+          return profile || '(No profile found — MEMORY.md is empty)';
+        }
+
+        case 'section': {
+          if (!input.name) return JSON.stringify({ error: 'name is required for "section" action' });
+          const section = memoryStore.readSection(input.name);
+          return section || `(Section "${input.name}" not found in MEMORY.md)`;
+        }
+
+        case 'entry': {
+          if (!input.name) return JSON.stringify({ error: 'name is required for "entry" action' });
+          const entry = memoryStore.readEntry(input.name);
+          if (!entry) return JSON.stringify({ error: `Entry "${input.name}" not found` });
+          return JSON.stringify(entry, null, 2);
+        }
+
+        case 'list': {
+          const entries = memoryStore.listEntries();
+          return JSON.stringify({
+            entries: entries.map(e => ({
+              name: e.name,
+              kind: e.kind,
+              scope: e.scope,
+              tags: e.tags,
+              importance: e.importance,
+              updated_at: e.updated_at,
+            })),
+            totalCount: entries.length,
+          }, null, 2);
+        }
+
+        case 'scopes': {
+          const scopes = memoryStore.readScopes();
+          return JSON.stringify({ scopes }, null, 2);
+        }
+
+        default:
+          return JSON.stringify({ error: `Unknown action: ${input.action}` });
+      }
+    } catch (err) {
+      return JSON.stringify({ error: `Memory read failed: ${err.message}` });
+    }
+  },
+});

package/unify/tools/memory-search.js

@@ -0,0 +1,101 @@
+/**
+ * memory-search.js — Search memory entries by scope, tags, and keywords.
+ *
+ * Uses the MemoryStore's findByFilter for structured search.
+ */
+
+import { defineTool } from './types.js';
+
+export default defineTool({
+  name: 'MemorySearch',
+  description: `Search Yeaft's persistent memory for relevant entries.
+
+Searches by scope, tags, kind, or keyword. Results are scored by relevance:
+- Exact scope match: highest score
+- Ancestor/descendant scope: medium score
+- Tag overlap: additional score per matching tag
+- Keyword in content: found via full-text scan
+
+Use this to find previously learned information before asking the user again.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      scope: {
+        type: 'string',
+        description: 'Memory scope to search in (e.g. "global", "work/my-project")',
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Tags to filter by',
+      },
+      kind: {
+        type: 'string',
+        enum: ['fact', 'preference', 'skill', 'lesson', 'context', 'relation'],
+        description: 'Filter by memory kind',
+      },
+      keyword: {
+        type: 'string',
+        description: 'Keyword to search in entry content',
+      },
+      limit: {
+        type: 'number',
+        description: 'Maximum number of results (default: 15)',
+      },
+    },
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const memoryStore = ctx?.memoryStore;
+    if (!memoryStore) {
+      return JSON.stringify({ error: 'Memory system not initialized' });
+    }
+
+    try {
+      const limit = input.limit || 15;
+
+      // Use findByFilter for scope + tag search
+      let results = memoryStore.findByFilter({
+        scope: input.scope,
+        tags: input.tags || [],
+        limit: limit * 2, // over-fetch for post-filtering
+      });
+
+      // Filter by kind if specified
+      if (input.kind) {
+        results = results.filter(e => e.kind === input.kind);
+      }
+
+      // Filter by keyword if specified
+      if (input.keyword) {
+        const kw = input.keyword.toLowerCase();
+        results = results.filter(e =>
+          (e.content && e.content.toLowerCase().includes(kw)) ||
+          (e.name && e.name.toLowerCase().includes(kw)) ||
+          (e.tags && e.tags.some(t => t.toLowerCase().includes(kw)))
+        );
+      }
+
+      // Trim to limit
+      results = results.slice(0, limit);
+
+      return JSON.stringify({
+        results: results.map(e => ({
+          name: e.name,
+          kind: e.kind,
+          scope: e.scope,
+          tags: e.tags,
+          importance: e.importance,
+          content: e.content?.slice(0, 500) + (e.content?.length > 500 ? '...' : ''),
+          updated_at: e.updated_at,
+          score: e._score,
+        })),
+        totalResults: results.length,
+      }, null, 2);
+    } catch (err) {
+      return JSON.stringify({ error: `Memory search failed: ${err.message}` });
+    }
+  },
+});