@yeaft/webchat-agent 0.1.442 → 0.1.443

package/unify/tools/task-tools.js

@@ -0,0 +1,358 @@
+/**
+ * Task management tools — in-memory task tracking for work mode.
+ *
+ * Tasks are organized in a simple flat list with status tracking.
+ * Persisted only in memory for the session duration.
+ */
+
+import { defineTool } from './types.js';
+import { randomUUID } from 'crypto';
+
+/** In-memory task store. */
+const tasks = new Map();
+
+/** Plan text (free-form markdown). */
+let currentPlan = '';
+
+/** Get task store for other tools. */
+export function getTaskStore() {
+  return tasks;
+}
+
+export function getPlan() {
+  return currentPlan;
+}
+
+// ─── TaskCreate ─────────────────────────────────────────
+
+export const taskCreate = defineTool({
+  name: 'TaskCreate',
+  description: `Create a new task for tracking work progress.
+
+Tasks have a title, description, priority, and status.
+Use this to break down complex work into trackable items.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      title: {
+        type: 'string',
+        description: 'Short task title',
+      },
+      description: {
+        type: 'string',
+        description: 'Detailed task description',
+      },
+      priority: {
+        type: 'string',
+        enum: ['low', 'medium', 'high', 'critical'],
+        description: 'Task priority (default: "medium")',
+      },
+      parent_id: {
+        type: 'string',
+        description: 'Parent task ID for subtasks',
+      },
+    },
+    required: ['title'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input, ctx) {
+    const { title, description, priority = 'medium', parent_id } = input;
+    if (!title) return JSON.stringify({ error: 'title is required' });
+
+    const id = `task-${randomUUID().slice(0, 8)}`;
+    const task = {
+      id,
+      title,
+      description: description || '',
+      priority,
+      status: 'pending',
+      parentId: parent_id || null,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+
+    tasks.set(id, task);
+
+    return JSON.stringify({
+      success: true,
+      task: { id, title, priority, status: 'pending' },
+      message: `Task created: ${title} (${id})`,
+    });
+  },
+});
+
+// ─── TaskUpdate ─────────────────────────────────────────
+
+export const taskUpdate = defineTool({
+  name: 'TaskUpdate',
+  description: `Update a task's status, priority, or details.
+
+Status values: pending, in_progress, completed, blocked, cancelled`,
+  parameters: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID to update',
+      },
+      status: {
+        type: 'string',
+        enum: ['pending', 'in_progress', 'completed', 'blocked', 'cancelled'],
+        description: 'New task status',
+      },
+      priority: {
+        type: 'string',
+        enum: ['low', 'medium', 'high', 'critical'],
+        description: 'New priority',
+      },
+      title: {
+        type: 'string',
+        description: 'Updated title',
+      },
+      description: {
+        type: 'string',
+        description: 'Updated description',
+      },
+      result: {
+        type: 'string',
+        description: 'Task result or completion notes',
+      },
+    },
+    required: ['task_id'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input, ctx) {
+    const { task_id, status, priority, title, description, result } = input;
+    if (!task_id) return JSON.stringify({ error: 'task_id is required' });
+
+    const task = tasks.get(task_id);
+    if (!task) return JSON.stringify({ error: `Task not found: ${task_id}` });
+
+    if (status) task.status = status;
+    if (priority) task.priority = priority;
+    if (title) task.title = title;
+    if (description !== undefined) task.description = description;
+    if (result) task.result = result;
+    task.updatedAt = Date.now();
+
+    return JSON.stringify({
+      success: true,
+      task: { id: task.id, title: task.title, status: task.status, priority: task.priority },
+      message: `Task "${task.title}" updated`,
+    });
+  },
+});
+
+// ─── TaskList ───────────────────────────────────────────
+
+export const taskList = defineTool({
+  name: 'TaskList',
+  description: `List all tracked tasks with their status.
+
+Shows task IDs, titles, status, and priority. Filter by status if needed.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      status: {
+        type: 'string',
+        enum: ['pending', 'in_progress', 'completed', 'blocked', 'cancelled'],
+        description: 'Filter by status (optional)',
+      },
+      include_completed: {
+        type: 'boolean',
+        description: 'Include completed tasks (default: true)',
+      },
+    },
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { status, include_completed = true } = input;
+
+    const taskList = [];
+    for (const [, task] of tasks) {
+      if (status && task.status !== status) continue;
+      if (!include_completed && task.status === 'completed') continue;
+      taskList.push({
+        id: task.id,
+        title: task.title,
+        status: task.status,
+        priority: task.priority,
+        parentId: task.parentId,
+        hasResult: !!task.result,
+      });
+    }
+
+    // Sort: in_progress first, then pending, then others
+    const ORDER = { in_progress: 0, pending: 1, blocked: 2, completed: 3, cancelled: 4 };
+    taskList.sort((a, b) => (ORDER[a.status] ?? 5) - (ORDER[b.status] ?? 5));
+
+    return JSON.stringify({
+      tasks: taskList,
+      totalCount: taskList.length,
+      summary: {
+        pending: taskList.filter(t => t.status === 'pending').length,
+        in_progress: taskList.filter(t => t.status === 'in_progress').length,
+        completed: taskList.filter(t => t.status === 'completed').length,
+        blocked: taskList.filter(t => t.status === 'blocked').length,
+      },
+    }, null, 2);
+  },
+});
+
+// ─── TaskGet ────────────────────────────────────────────
+
+export const taskGet = defineTool({
+  name: 'TaskGet',
+  description: `Get detailed information about a specific task.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID to retrieve',
+      },
+    },
+    required: ['task_id'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { task_id } = input;
+    if (!task_id) return JSON.stringify({ error: 'task_id is required' });
+
+    const task = tasks.get(task_id);
+    if (!task) return JSON.stringify({ error: `Task not found: ${task_id}` });
+
+    // Find subtasks
+    const subtasks = [];
+    for (const [, t] of tasks) {
+      if (t.parentId === task_id) {
+        subtasks.push({ id: t.id, title: t.title, status: t.status });
+      }
+    }
+
+    return JSON.stringify({
+      ...task,
+      subtasks,
+    }, null, 2);
+  },
+});
+
+// ─── FollowupTask ───────────────────────────────────────
+
+export const followupTask = defineTool({
+  name: 'FollowupTask',
+  description: `Create a follow-up task linked to an existing task.
+
+Use when a completed task reveals additional work needed.
+The new task is linked as a child of the original.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      parent_task_id: {
+        type: 'string',
+        description: 'ID of the original task',
+      },
+      title: {
+        type: 'string',
+        description: 'Follow-up task title',
+      },
+      description: {
+        type: 'string',
+        description: 'Why this follow-up is needed',
+      },
+      priority: {
+        type: 'string',
+        enum: ['low', 'medium', 'high', 'critical'],
+      },
+    },
+    required: ['parent_task_id', 'title'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input, ctx) {
+    const { parent_task_id, title, description, priority = 'medium' } = input;
+    if (!parent_task_id) return JSON.stringify({ error: 'parent_task_id is required' });
+    if (!title) return JSON.stringify({ error: 'title is required' });
+
+    const parent = tasks.get(parent_task_id);
+    if (!parent) return JSON.stringify({ error: `Parent task not found: ${parent_task_id}` });
+
+    const id = `task-${randomUUID().slice(0, 8)}`;
+    const task = {
+      id,
+      title,
+      description: description || `Follow-up to: ${parent.title}`,
+      priority,
+      status: 'pending',
+      parentId: parent_task_id,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+
+    tasks.set(id, task);
+
+    return JSON.stringify({
+      success: true,
+      task: { id, title, priority, status: 'pending', parentId: parent_task_id },
+      message: `Follow-up task created: ${title} (linked to ${parent.title})`,
+    });
+  },
+});
+
+// ─── UpdatePlan ─────────────────────────────────────────
+
+export const updatePlan = defineTool({
+  name: 'UpdatePlan',
+  description: `Update or view the current execution plan.
+
+The plan is a free-form markdown document that describes the overall
+approach, steps, and status of the current work.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['view', 'update', 'append'],
+        description: '"view" shows current plan, "update" replaces it, "append" adds to it',
+      },
+      content: {
+        type: 'string',
+        description: 'Plan content (for "update" and "append" actions)',
+      },
+    },
+    required: ['action'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: (input) => input?.action === 'view',
+  async execute(input, ctx) {
+    const { action, content } = input;
+
+    switch (action) {
+      case 'view':
+        return currentPlan || '(No plan set yet)';
+
+      case 'update':
+        if (!content) return JSON.stringify({ error: 'content is required for "update"' });
+        currentPlan = content;
+        return JSON.stringify({ success: true, message: 'Plan updated', length: content.length });
+
+      case 'append':
+        if (!content) return JSON.stringify({ error: 'content is required for "append"' });
+        currentPlan = currentPlan ? `${currentPlan}\n\n${content}` : content;
+        return JSON.stringify({ success: true, message: 'Plan updated (appended)', length: currentPlan.length });
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  },
+});

package/unify/tools/tool-search.js

@@ -0,0 +1,97 @@
+/**
+ * tool-search.js — Search available tools by name or description.
+ */
+
+import { defineTool } from './types.js';
+
+export default defineTool({
+  name: 'ToolSearch',
+  description: `Search available tools by name or description keyword.
+
+Use when you're unsure which tool to use for a task.
+Returns matching tools with their descriptions and parameters.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'Search keyword to match against tool names and descriptions',
+      },
+      mode: {
+        type: 'string',
+        enum: ['chat', 'work'],
+        description: 'Filter by mode (optional)',
+      },
+    },
+    required: ['query'],
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { query, mode } = input;
+    if (!query) return JSON.stringify({ error: 'query is required' });
+
+    // Access the tool registry through the engine context
+    // Since we don't have direct registry access, list what we know
+    const lowerQuery = query.toLowerCase();
+
+    // Get all tool definitions from the registry if available
+    // This is a self-referential tool — it describes the tools available to this engine
+    const toolList = [
+      { name: 'AskUser', description: 'Ask the user a question', modes: ['chat', 'work'] },
+      { name: 'MemoryRead', description: 'Read from memory system', modes: ['chat', 'work'] },
+      { name: 'MemoryWrite', description: 'Write to memory system', modes: ['chat', 'work'] },
+      { name: 'MemorySearch', description: 'Search memory entries', modes: ['chat', 'work'] },
+      { name: 'WebSearch', description: 'Search the web', modes: ['chat', 'work'] },
+      { name: 'WebFetch', description: 'Fetch web page content', modes: ['chat', 'work'] },
+      { name: 'HistorySearch', description: 'Search conversation history', modes: ['chat', 'work'] },
+      { name: 'Bash', description: 'Execute shell commands', modes: ['work'] },
+      { name: 'FileRead', description: 'Read file with line numbers', modes: ['work'] },
+      { name: 'FileWrite', description: 'Write/create files', modes: ['work'] },
+      { name: 'FileEdit', description: 'Surgical string replacement in files', modes: ['work'] },
+      { name: 'Glob', description: 'Find files by pattern', modes: ['work'] },
+      { name: 'Grep', description: 'Search file contents', modes: ['work'] },
+      { name: 'ListDir', description: 'List directory contents', modes: ['work'] },
+      { name: 'ApplyPatch', description: 'Apply unified diff patches', modes: ['work'] },
+      { name: 'Agent', description: 'Create sub-agents', modes: ['work'] },
+      { name: 'SendMessage', description: 'Send message to sub-agent', modes: ['work'] },
+      { name: 'WaitAgent', description: 'Wait for sub-agent result', modes: ['work'] },
+      { name: 'CloseAgent', description: 'Close a sub-agent', modes: ['work'] },
+      { name: 'ListAgents', description: 'List all sub-agents', modes: ['work'] },
+      { name: 'TaskCreate', description: 'Create a task', modes: ['work'] },
+      { name: 'TaskUpdate', description: 'Update task status', modes: ['work'] },
+      { name: 'TaskList', description: 'List all tasks', modes: ['work'] },
+      { name: 'TaskGet', description: 'Get task details', modes: ['work'] },
+      { name: 'FollowupTask', description: 'Create follow-up task', modes: ['work'] },
+      { name: 'UpdatePlan', description: 'View/update execution plan', modes: ['work'] },
+      { name: 'JsRepl', description: 'JavaScript REPL evaluation', modes: ['chat', 'work'] },
+      { name: 'JsReplReset', description: 'Reset REPL state', modes: ['chat', 'work'] },
+      { name: 'NotebookEdit', description: 'Edit Jupyter notebooks', modes: ['work'] },
+      { name: 'ImageGeneration', description: 'Generate images from text', modes: ['chat', 'work'] },
+      { name: 'ViewImage', description: 'View image metadata', modes: ['chat', 'work'] },
+      { name: 'RequestPermissions', description: 'Request dangerous operation permissions', modes: ['work'] },
+      { name: 'WriteStdin', description: 'Write to running process stdin', modes: ['work'] },
+      { name: 'Skill', description: 'Load skills from library', modes: ['chat', 'work'] },
+      { name: 'EnterWorktree', description: 'Create git worktree', modes: ['work'] },
+      { name: 'ExitWorktree', description: 'Exit git worktree', modes: ['work'] },
+      { name: 'mcp_list_tools', description: 'List MCP server tools', modes: ['chat', 'work'] },
+      { name: 'mcp_call_tool', description: 'Call MCP server tool', modes: ['chat', 'work'] },
+    ];
+
+    let results = toolList.filter(t =>
+      t.name.toLowerCase().includes(lowerQuery) ||
+      t.description.toLowerCase().includes(lowerQuery)
+    );
+
+    if (mode) {
+      results = results.filter(t => t.modes.includes(mode));
+    }
+
+    return JSON.stringify({
+      results,
+      totalResults: results.length,
+      query,
+    }, null, 2);
+  },
+});

package/unify/tools/view-image.js

@@ -0,0 +1,117 @@
+/**
+ * view-image.js — Read and describe an image file.
+ *
+ * Returns image metadata (dimensions, format, size).
+ * In a full multimodal integration, would pass the image to the LLM.
+ */
+
+import { defineTool } from './types.js';
+import { stat, readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, extname } from 'path';
+
+/** Supported image formats. */
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.svg', '.ico']);
+
+/**
+ * Parse basic image dimensions from headers.
+ */
+function parseImageDimensions(buffer, ext) {
+  try {
+    if (ext === '.png') {
+      // PNG: width at offset 16, height at 20 (big-endian 32-bit)
+      if (buffer.length >= 24) {
+        return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+      }
+    }
+    if (ext === '.jpg' || ext === '.jpeg') {
+      // JPEG: scan for SOF0 marker (0xFF 0xC0)
+      for (let i = 0; i < buffer.length - 9; i++) {
+        if (buffer[i] === 0xFF && (buffer[i + 1] === 0xC0 || buffer[i + 1] === 0xC2)) {
+          return {
+            height: buffer.readUInt16BE(i + 5),
+            width: buffer.readUInt16BE(i + 7),
+          };
+        }
+      }
+    }
+    if (ext === '.gif') {
+      // GIF: width at offset 6, height at 8 (little-endian 16-bit)
+      if (buffer.length >= 10) {
+        return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) };
+      }
+    }
+  } catch {
+    // Dimension parsing is best-effort
+  }
+  return null;
+}
+
+export default defineTool({
+  name: 'ViewImage',
+  description: `View an image file and get its metadata.
+
+Returns image format, dimensions, and file size.
+Supports PNG, JPEG, GIF, BMP, WebP, SVG, and ICO.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      file_path: {
+        type: 'string',
+        description: 'Path to the image file',
+      },
+    },
+    required: ['file_path'],
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { file_path } = input;
+    if (!file_path) return JSON.stringify({ error: 'file_path is required' });
+
+    const cwd = ctx?.cwd || process.cwd();
+    const absPath = resolve(cwd, file_path);
+
+    if (!existsSync(absPath)) {
+      return JSON.stringify({ error: `Image not found: ${absPath}` });
+    }
+
+    const ext = extname(absPath).toLowerCase();
+    if (!IMAGE_EXTS.has(ext)) {
+      return JSON.stringify({ error: `Not a recognized image format: ${ext}` });
+    }
+
+    try {
+      const fileStat = await stat(absPath);
+      const buffer = await readFile(absPath);
+
+      const dimensions = parseImageDimensions(buffer, ext);
+
+      const result = {
+        path: absPath,
+        format: ext.slice(1).toUpperCase(),
+        size: fileStat.size,
+        sizeFormatted: fileStat.size < 1024 ? `${fileStat.size}B`
+          : fileStat.size < 1024 * 1024 ? `${(fileStat.size / 1024).toFixed(1)}KB`
+          : `${(fileStat.size / 1024 / 1024).toFixed(1)}MB`,
+        modified: fileStat.mtime.toISOString(),
+      };
+
+      if (dimensions) {
+        result.width = dimensions.width;
+        result.height = dimensions.height;
+      }
+
+      // For SVG, include a text preview
+      if (ext === '.svg') {
+        const svgText = buffer.toString('utf-8');
+        result.preview = svgText.slice(0, 500);
+      }
+
+      return JSON.stringify(result, null, 2);
+    } catch (err) {
+      return JSON.stringify({ error: `Failed to read image: ${err.message}` });
+    }
+  },
+});

package/unify/tools/wait-agent.js

@@ -0,0 +1,84 @@
+/**
+ * wait-agent.js — Wait for a sub-agent to complete and get its result.
+ */
+
+import { defineTool } from './types.js';
+import { getAgentRegistry } from './agent.js';
+
+export default defineTool({
+  name: 'WaitAgent',
+  description: `Wait for a sub-agent to complete its task and retrieve the result.
+
+Returns the agent's final result or current status if still running.
+Use after sending a task to an agent via SendMessage.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      agent_id: {
+        type: 'string',
+        description: 'The sub-agent ID to wait for',
+      },
+      timeout_ms: {
+        type: 'number',
+        description: 'Maximum time to wait in milliseconds (default: 30000)',
+      },
+    },
+    required: ['agent_id'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { agent_id, timeout_ms = 30000 } = input;
+    if (!agent_id) return JSON.stringify({ error: 'agent_id is required' });
+
+    const agents = getAgentRegistry();
+    const agent = agents.get(agent_id);
+
+    if (!agent) {
+      return JSON.stringify({ error: `Agent not found: ${agent_id}` });
+    }
+
+    // If already completed, return result immediately
+    if (agent.status === 'completed' || agent.status === 'closed') {
+      return JSON.stringify({
+        agentId: agent_id,
+        name: agent.name,
+        status: agent.status,
+        result: agent.result,
+        messages: agent.messages.length,
+      });
+    }
+
+    // Wait for completion with timeout
+    const deadline = Date.now() + timeout_ms;
+    while (Date.now() < deadline) {
+      if (agent.status === 'completed' || agent.status === 'closed') {
+        return JSON.stringify({
+          agentId: agent_id,
+          name: agent.name,
+          status: agent.status,
+          result: agent.result,
+          messages: agent.messages.length,
+        });
+      }
+
+      // Check abort signal
+      if (ctx?.signal?.aborted) {
+        return JSON.stringify({ error: 'Wait cancelled', agentId: agent_id });
+      }
+
+      // Poll every 500ms
+      await new Promise(r => setTimeout(r, 500));
+    }
+
+    return JSON.stringify({
+      agentId: agent_id,
+      name: agent.name,
+      status: agent.status,
+      timedOut: true,
+      message: `Agent "${agent.name}" is still running after ${timeout_ms}ms`,
+      messages: agent.messages.length,
+    });
+  },
+});