@yeaft/webchat-agent 0.1.442 → 0.1.444

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

package/unify/tools/memory-write.js

@@ -0,0 +1,114 @@
+/**
+ * memory-write.js — Write memory entries to the Yeaft memory store.
+ *
+ * Creates, updates, or deletes memory entries. Also supports
+ * appending lines to MEMORY.md sections and overwriting the profile.
+ */
+
+import { defineTool } from './types.js';
+
+export default defineTool({
+  name: 'MemoryWrite',
+  description: `Write to Yeaft's persistent memory system.
+
+Actions:
+- "write_entry" — create or update a memory entry (entries/*.md)
+- "delete_entry" — delete a memory entry by name
+- "write_profile" — overwrite the full MEMORY.md profile
+- "add_to_section" — append a line to a section in MEMORY.md
+
+Memory kinds: fact, preference, skill, lesson, context, relation
+Importance levels: low, normal, high, critical`,
+  parameters: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['write_entry', 'delete_entry', 'write_profile', 'add_to_section'],
+        description: 'What memory operation to perform',
+      },
+      entry: {
+        type: 'object',
+        description: 'Memory entry data (for "write_entry")',
+        properties: {
+          name: { type: 'string', description: 'Entry name (will be slugified for filename)' },
+          kind: { type: 'string', enum: ['fact', 'preference', 'skill', 'lesson', 'context', 'relation'] },
+          scope: { type: 'string', description: 'Scope path, e.g. "global", "work/my-project"' },
+          tags: { type: 'array', items: { type: 'string' } },
+          importance: { type: 'string', enum: ['low', 'normal', 'high', 'critical'] },
+          content: { type: 'string', description: 'The memory content (markdown body)' },
+        },
+        required: ['name', 'content'],
+      },
+      name: {
+        type: 'string',
+        description: 'Entry name slug (for "delete_entry") or section name (for "add_to_section")',
+      },
+      content: {
+        type: 'string',
+        description: 'Content for "write_profile" or line to add for "add_to_section"',
+      },
+    },
+    required: ['action'],
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input, ctx) {
+    const memoryStore = ctx?.memoryStore;
+    if (!memoryStore) {
+      return JSON.stringify({ error: 'Memory system not initialized' });
+    }
+
+    try {
+      switch (input.action) {
+        case 'write_entry': {
+          if (!input.entry) return JSON.stringify({ error: 'entry is required for "write_entry"' });
+          if (!input.entry.name) return JSON.stringify({ error: 'entry.name is required' });
+          if (!input.entry.content) return JSON.stringify({ error: 'entry.content is required' });
+
+          const slug = memoryStore.writeEntry(input.entry);
+          return JSON.stringify({
+            success: true,
+            slug,
+            message: `Memory entry "${input.entry.name}" saved as ${slug}.md`,
+          });
+        }
+
+        case 'delete_entry': {
+          if (!input.name) return JSON.stringify({ error: 'name is required for "delete_entry"' });
+          const deleted = memoryStore.deleteEntry(input.name);
+          return JSON.stringify({
+            success: deleted,
+            message: deleted
+              ? `Deleted memory entry "${input.name}"`
+              : `Entry "${input.name}" not found`,
+          });
+        }
+
+        case 'write_profile': {
+          if (!input.content && input.content !== '') {
+            return JSON.stringify({ error: 'content is required for "write_profile"' });
+          }
+          memoryStore.writeProfile(input.content);
+          return JSON.stringify({ success: true, message: 'MEMORY.md updated' });
+        }
+
+        case 'add_to_section': {
+          if (!input.name) return JSON.stringify({ error: 'name (section) is required for "add_to_section"' });
+          if (!input.content) return JSON.stringify({ error: 'content (line) is required for "add_to_section"' });
+          memoryStore.addToSection(input.name, input.content);
+          return JSON.stringify({
+            success: true,
+            message: `Added to section "${input.name}" in MEMORY.md`,
+          });
+        }
+
+        default:
+          return JSON.stringify({ error: `Unknown action: ${input.action}` });
+      }
+    } catch (err) {
+      return JSON.stringify({ error: `Memory write failed: ${err.message}` });
+    }
+  },
+});

package/unify/tools/notebook-edit.js

@@ -0,0 +1,132 @@
+/**
+ * notebook-edit.js — Edit Jupyter notebook cells.
+ *
+ * Reads and modifies .ipynb notebook files by cell index.
+ */
+
+import { defineTool } from './types.js';
+import { readFile, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+
+export default defineTool({
+  name: 'NotebookEdit',
+  description: `Edit a Jupyter notebook (.ipynb file) cell.
+
+Actions:
+- "replace" — replace the source of a cell at the given index
+- "insert" — insert a new cell after the given index
+- "delete" — delete the cell at the given index
+- "read" — read the notebook content (all cells)
+
+Cell types: "code" or "markdown"`,
+  parameters: {
+    type: 'object',
+    properties: {
+      notebook_path: {
+        type: 'string',
+        description: 'Path to the .ipynb file',
+      },
+      action: {
+        type: 'string',
+        enum: ['replace', 'insert', 'delete', 'read'],
+        description: 'Operation to perform (default: "replace")',
+      },
+      cell_index: {
+        type: 'number',
+        description: 'Cell index (0-based)',
+      },
+      cell_type: {
+        type: 'string',
+        enum: ['code', 'markdown'],
+        description: 'Cell type for insert/replace',
+      },
+      source: {
+        type: 'string',
+        description: 'New cell source content',
+      },
+    },
+    required: ['notebook_path'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: (input) => input?.action === 'read',
+  async execute(input, ctx) {
+    const { notebook_path, action = 'replace', cell_index, cell_type, source } = input;
+    if (!notebook_path) return JSON.stringify({ error: 'notebook_path is required' });
+
+    const cwd = ctx?.cwd || process.cwd();
+    const absPath = resolve(cwd, notebook_path);
+
+    if (!existsSync(absPath)) {
+      if (action === 'read') return JSON.stringify({ error: `Notebook not found: ${absPath}` });
+      // For write actions on new file, create an empty notebook
+    }
+
+    try {
+      let notebook;
+      if (existsSync(absPath)) {
+        const raw = await readFile(absPath, 'utf-8');
+        notebook = JSON.parse(raw);
+      } else {
+        notebook = {
+          cells: [],
+          metadata: { kernelspec: { display_name: 'Python 3', language: 'python', name: 'python3' } },
+          nbformat: 4,
+          nbformat_minor: 5,
+        };
+      }
+
+      if (action === 'read') {
+        return JSON.stringify({
+          cells: notebook.cells.map((cell, i) => ({
+            index: i,
+            cell_type: cell.cell_type,
+            source: Array.isArray(cell.source) ? cell.source.join('') : cell.source,
+            outputs: cell.outputs ? cell.outputs.length : 0,
+          })),
+          totalCells: notebook.cells.length,
+        }, null, 2);
+      }
+
+      if (action === 'replace') {
+        if (cell_index === undefined) return JSON.stringify({ error: 'cell_index is required for replace' });
+        if (source === undefined) return JSON.stringify({ error: 'source is required for replace' });
+        if (cell_index < 0 || cell_index >= notebook.cells.length) {
+          return JSON.stringify({ error: `Cell index ${cell_index} out of range (0-${notebook.cells.length - 1})` });
+        }
+
+        notebook.cells[cell_index].source = source.split('\n').map((l, i, arr) => i < arr.length - 1 ? l + '\n' : l);
+        if (cell_type) notebook.cells[cell_index].cell_type = cell_type;
+      } else if (action === 'insert') {
+        if (source === undefined) return JSON.stringify({ error: 'source is required for insert' });
+        const type = cell_type || 'code';
+        const newCell = {
+          cell_type: type,
+          source: source.split('\n').map((l, i, arr) => i < arr.length - 1 ? l + '\n' : l),
+          metadata: {},
+          ...(type === 'code' ? { outputs: [], execution_count: null } : {}),
+        };
+        const insertIdx = cell_index !== undefined ? cell_index + 1 : notebook.cells.length;
+        notebook.cells.splice(insertIdx, 0, newCell);
+      } else if (action === 'delete') {
+        if (cell_index === undefined) return JSON.stringify({ error: 'cell_index is required for delete' });
+        if (cell_index < 0 || cell_index >= notebook.cells.length) {
+          return JSON.stringify({ error: `Cell index ${cell_index} out of range` });
+        }
+        notebook.cells.splice(cell_index, 1);
+      }
+
+      await writeFile(absPath, JSON.stringify(notebook, null, 1), 'utf-8');
+
+      return JSON.stringify({
+        success: true,
+        action,
+        totalCells: notebook.cells.length,
+        message: `Notebook ${action}d successfully`,
+      });
+    } catch (err) {
+      return JSON.stringify({ error: `Notebook edit failed: ${err.message}` });
+    }
+  },
+});

package/unify/tools/request-permissions.js

@@ -0,0 +1,60 @@
+/**
+ * request-permissions.js — Request permission for dangerous operations.
+ *
+ * When an operation is flagged as destructive, this tool requests
+ * explicit user permission before proceeding.
+ */
+
+import { defineTool } from './types.js';
+
+export default defineTool({
+  name: 'RequestPermissions',
+  description: `Request permission from the user for a potentially dangerous operation.
+
+Use this before executing destructive operations like:
+- Deleting files or directories
+- Running commands that modify system state
+- Force-pushing to git
+- Resetting databases
+
+The user must explicitly approve before you proceed.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      operation: {
+        type: 'string',
+        description: 'Description of the operation that needs permission',
+      },
+      reason: {
+        type: 'string',
+        description: 'Why this operation is necessary',
+      },
+      risk_level: {
+        type: 'string',
+        enum: ['low', 'medium', 'high', 'critical'],
+        description: 'Risk level of the operation',
+      },
+    },
+    required: ['operation'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { operation, reason, risk_level = 'medium' } = input;
+    if (!operation) return JSON.stringify({ error: 'operation is required' });
+
+    // In a full integration, this would use the ask_user mechanism
+    // to get explicit permission. For now, return a structured request.
+    return JSON.stringify({
+      type: 'permission_request',
+      operation,
+      reason: reason || 'Operation requires explicit permission',
+      riskLevel: risk_level,
+      message: `⚠️ Permission required for: ${operation}` +
+               (reason ? `\nReason: ${reason}` : '') +
+               `\nRisk level: ${risk_level}`,
+      hint: 'User must explicitly approve this operation before proceeding.',
+    });
+  },
+});