@yeaft/webchat-agent 0.1.442 → 0.1.443

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

package/unify/tools/send-message.js

@@ -0,0 +1,62 @@
+/**
+ * send-message.js — Send a message to a sub-agent.
+ */
+
+import { defineTool } from './types.js';
+import { getAgentRegistry } from './agent.js';
+
+export default defineTool({
+  name: 'SendMessage',
+  description: `Send a message to a sub-agent.
+
+Use this to give tasks, provide instructions, or relay information to a sub-agent.
+The message is queued for the agent to process.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      agent_id: {
+        type: 'string',
+        description: 'The sub-agent ID (returned by Agent tool)',
+      },
+      message: {
+        type: 'string',
+        description: 'The message to send to the agent',
+      },
+    },
+    required: ['agent_id', 'message'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input, ctx) {
+    const { agent_id, message } = input;
+    if (!agent_id) return JSON.stringify({ error: 'agent_id is required' });
+    if (!message) return JSON.stringify({ error: 'message is required' });
+
+    const agents = getAgentRegistry();
+    const agent = agents.get(agent_id);
+
+    if (!agent) {
+      return JSON.stringify({ error: `Agent not found: ${agent_id}` });
+    }
+
+    if (agent.status === 'closed') {
+      return JSON.stringify({ error: `Agent "${agent.name}" is closed` });
+    }
+
+    agent.messages.push({
+      role: 'user',
+      content: message,
+      timestamp: Date.now(),
+    });
+    agent.status = 'active';
+
+    return JSON.stringify({
+      success: true,
+      agentId: agent_id,
+      name: agent.name,
+      messageCount: agent.messages.length,
+      message: `Message sent to agent "${agent.name}"`,
+    });
+  },
+});