vellum 0.2.0 → 0.2.2

package/src/tools/watcher/list.ts

@@ -1,90 +1,60 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { listWatchers, getWatcher, listWatcherEvents } from '../../watcher/watcher-store.js';
 
-class WatcherListTool implements Tool {
-  name = 'watcher_list';
-  description = 'List all watchers with their status, or show details for a specific watcher';
-  category = 'watcher';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          watcher_id: {
-            type: 'string',
-            description: 'If provided, show detailed info for this specific watcher including recent events.',
-          },
-          enabled_only: {
-            type: 'boolean',
-            description: 'When true, only show enabled watchers. Defaults to false.',
-          },
-        },
-        required: [],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const watcherId = input.watcher_id as string | undefined;
-    const enabledOnly = (input.enabled_only as boolean) ?? false;
-
-    if (watcherId) {
-      const watcher = getWatcher(watcherId);
-      if (!watcher) {
-        return { content: `Error: Watcher not found: ${watcherId}`, isError: true };
-      }
-
-      const events = listWatcherEvents({ watcherId, limit: 10 });
-      const lines = [
-        `Watcher: ${watcher.name}`,
-        `  ID: ${watcher.id}`,
-        `  Provider: ${watcher.providerId}`,
-        `  Status: ${watcher.status}`,
-        `  Enabled: ${watcher.enabled}`,
-        `  Poll interval: ${Math.round(watcher.pollIntervalMs / 1000)}s`,
-        `  Credential: ${watcher.credentialService}`,
-        `  Last poll: ${watcher.lastPollAt ? new Date(watcher.lastPollAt).toLocaleString() : 'never'}`,
-        `  Next poll: ${watcher.nextPollAt ? new Date(watcher.nextPollAt).toLocaleString() : 'n/a'}`,
-        `  Errors: ${watcher.consecutiveErrors}`,
-      ];
-
-      if (watcher.lastError) {
-        lines.push(`  Last error: ${watcher.lastError}`);
-      }
-
-      if (events.length > 0) {
-        lines.push('', `Recent events (${events.length}):`);
-        for (const event of events) {
-          lines.push(`  - [${event.disposition}] ${event.summary} (${new Date(event.createdAt).toLocaleString()})`);
-        }
-      } else {
-        lines.push('', 'No events detected yet.');
-      }
-
-      return { content: lines.join('\n'), isError: false };
+export async function executeWatcherList(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const watcherId = input.watcher_id as string | undefined;
+  const enabledOnly = (input.enabled_only as boolean) ?? false;
+
+  if (watcherId) {
+    const watcher = getWatcher(watcherId);
+    if (!watcher) {
+      return { content: `Error: Watcher not found: ${watcherId}`, isError: true };
     }
 
-    const allWatchers = listWatchers({ enabledOnly });
-    if (allWatchers.length === 0) {
-      return { content: 'No watchers found.', isError: false };
+    const events = listWatcherEvents({ watcherId, limit: 10 });
+    const lines = [
+      `Watcher: ${watcher.name}`,
+      `  ID: ${watcher.id}`,
+      `  Provider: ${watcher.providerId}`,
+      `  Status: ${watcher.status}`,
+      `  Enabled: ${watcher.enabled}`,
+      `  Poll interval: ${Math.round(watcher.pollIntervalMs / 1000)}s`,
+      `  Credential: ${watcher.credentialService}`,
+      `  Last poll: ${watcher.lastPollAt ? new Date(watcher.lastPollAt).toLocaleString() : 'never'}`,
+      `  Next poll: ${watcher.nextPollAt ? new Date(watcher.nextPollAt).toLocaleString() : 'n/a'}`,
+      `  Errors: ${watcher.consecutiveErrors}`,
+    ];
+
+    if (watcher.lastError) {
+      lines.push(`  Last error: ${watcher.lastError}`);
     }
 
-    const lines = [`Watchers (${allWatchers.length}):`];
-    for (const w of allWatchers) {
-      const status = w.enabled ? w.status : 'disabled';
-      const lastPoll = w.lastPollAt ? new Date(w.lastPollAt).toLocaleString() : 'never';
-      lines.push(`  - [${status}] ${w.name} (${w.providerId}) — last: ${lastPoll}`);
+    if (events.length > 0) {
+      lines.push('', `Recent events (${events.length}):`);
+      for (const event of events) {
+        lines.push(`  - [${event.disposition}] ${event.summary} (${new Date(event.createdAt).toLocaleString()})`);
+      }
+    } else {
+      lines.push('', 'No events detected yet.');
     }
 
     return { content: lines.join('\n'), isError: false };
   }
-}
 
-registerTool(new WatcherListTool());
+  const allWatchers = listWatchers({ enabledOnly });
+  if (allWatchers.length === 0) {
+    return { content: 'No watchers found.', isError: false };
+  }
+
+  const lines = [`Watchers (${allWatchers.length}):`];
+  for (const w of allWatchers) {
+    const status = w.enabled ? w.status : 'disabled';
+    const lastPoll = w.lastPollAt ? new Date(w.lastPollAt).toLocaleString() : 'never';
+    lines.push(`  - [${status}] ${w.name} (${w.providerId}) — last: ${lastPoll}`);
+  }
+
+  return { content: lines.join('\n'), isError: false };
+}

package/src/tools/watcher/update.ts

@@ -1,102 +1,56 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { updateWatcher } from '../../watcher/watcher-store.js';
 
-class WatcherUpdateTool implements Tool {
-  name = 'watcher_update';
-  description = 'Update a watcher\'s configuration (name, action prompt, interval, enabled state)';
-  category = 'watcher';
-  defaultRiskLevel = RiskLevel.Medium;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          watcher_id: {
-            type: 'string',
-            description: 'The ID of the watcher to update',
-          },
-          name: {
-            type: 'string',
-            description: 'New name for the watcher',
-          },
-          action_prompt: {
-            type: 'string',
-            description: 'New action prompt for event processing',
-          },
-          poll_interval_ms: {
-            type: 'number',
-            description: 'New poll interval in milliseconds (minimum 15000)',
-          },
-          enabled: {
-            type: 'boolean',
-            description: 'Enable or disable the watcher',
-          },
-          config: {
-            type: 'object',
-            description: 'New provider-specific configuration',
-          },
-        },
-        required: ['watcher_id'],
-      },
-    };
+export async function executeWatcherUpdate(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const watcherId = input.watcher_id as string;
+  if (!watcherId || typeof watcherId !== 'string') {
+    return { content: 'Error: watcher_id is required', isError: true };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const watcherId = input.watcher_id as string;
-    if (!watcherId || typeof watcherId !== 'string') {
-      return { content: 'Error: watcher_id is required', isError: true };
+  const updates: Record<string, unknown> = {};
+  if (input.name !== undefined) updates.name = input.name;
+  if (input.action_prompt !== undefined) updates.actionPrompt = input.action_prompt;
+  if (input.poll_interval_ms !== undefined) {
+    if ((input.poll_interval_ms as number) < 15000) {
+      return { content: 'Error: poll_interval_ms must be at least 15000 (15 seconds)', isError: true };
     }
+    updates.pollIntervalMs = input.poll_interval_ms;
+  }
+  if (input.enabled !== undefined) updates.enabled = input.enabled;
+  if (input.config !== undefined) updates.configJson = JSON.stringify(input.config);
 
-    const updates: Record<string, unknown> = {};
-    if (input.name !== undefined) updates.name = input.name;
-    if (input.action_prompt !== undefined) updates.actionPrompt = input.action_prompt;
-    if (input.poll_interval_ms !== undefined) {
-      if ((input.poll_interval_ms as number) < 15000) {
-        return { content: 'Error: poll_interval_ms must be at least 15000 (15 seconds)', isError: true };
-      }
-      updates.pollIntervalMs = input.poll_interval_ms;
-    }
-    if (input.enabled !== undefined) updates.enabled = input.enabled;
-    if (input.config !== undefined) updates.configJson = JSON.stringify(input.config);
+  if (Object.keys(updates).length === 0) {
+    return { content: 'Error: No updates provided. Specify at least one field to update.', isError: true };
+  }
 
-    if (Object.keys(updates).length === 0) {
-      return { content: 'Error: No updates provided. Specify at least one field to update.', isError: true };
+  try {
+    const watcher = updateWatcher(watcherId, updates as {
+      name?: string;
+      actionPrompt?: string;
+      pollIntervalMs?: number;
+      enabled?: boolean;
+      configJson?: string | null;
+    });
+
+    if (!watcher) {
+      return { content: `Error: Watcher not found: ${watcherId}`, isError: true };
     }
 
-    try {
-      const watcher = updateWatcher(watcherId, updates as {
-        name?: string;
-        actionPrompt?: string;
-        pollIntervalMs?: number;
-        enabled?: boolean;
-        configJson?: string | null;
-      });
-
-      if (!watcher) {
-        return { content: `Error: Watcher not found: ${watcherId}`, isError: true };
-      }
-
-      return {
-        content: [
-          'Watcher updated successfully.',
-          `  Name: ${watcher.name}`,
-          `  Enabled: ${watcher.enabled}`,
-          `  Status: ${watcher.status}`,
-          `  Poll interval: ${Math.round(watcher.pollIntervalMs / 1000)}s`,
-        ].join('\n'),
-        isError: false,
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Error updating watcher: ${msg}`, isError: true };
-    }
+    return {
+      content: [
+        'Watcher updated successfully.',
+        `  Name: ${watcher.name}`,
+        `  Enabled: ${watcher.enabled}`,
+        `  Status: ${watcher.status}`,
+        `  Poll interval: ${Math.round(watcher.pollIntervalMs / 1000)}s`,
+      ].join('\n'),
+      isError: false,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error updating watcher: ${msg}`, isError: true };
   }
 }
-
-registerTool(new WatcherUpdateTool());