vellum 0.2.1 → 0.2.7

package/src/tools/playbooks/playbook-create.ts

@@ -1,17 +1,16 @@
 import { and, eq } from 'drizzle-orm';
 import { v4 as uuid } from 'uuid';
-import { RiskLevel } from '../../permissions/types.js';
 import type { ToolContext, ToolExecutionResult } from '../types.js';
-import { registerTool } from '../registry.js';
 import { getDb } from '../../memory/db.js';
 import { computeMemoryFingerprint } from '../../memory/fingerprint.js';
 import { memoryItems } from '../../memory/schema.js';
 import { enqueueMemoryJob } from '../../memory/jobs-store.js';
 import type { Playbook, PlaybookAutonomyLevel } from '../../playbooks/types.js';
+import { truncate } from '../../util/truncate.js';
 
 const VALID_AUTONOMY_LEVELS = new Set<string>(['auto', 'draft', 'notify']);
 
-async function execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
+export async function executePlaybookCreate(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
   const trigger = input.trigger as string;
   const action = input.action as string;
 
@@ -32,7 +31,7 @@ async function execute(input: Record<string, unknown>, context: ToolContext): Pr
 
   const playbook: Playbook = { trigger, channel, category, action, autonomyLevel, priority };
   const statement = JSON.stringify(playbook);
-  const subject = `Playbook: ${trigger}`.slice(0, 80);
+  const subject = truncate(`Playbook: ${trigger}`, 80, '');
   const scopeId = context.memoryScopeId ?? 'default';
 
   const fingerprint = computeMemoryFingerprint(scopeId, 'playbook', subject, statement);
@@ -95,46 +94,3 @@ async function execute(input: Record<string, unknown>, context: ToolContext): Pr
     return { content: `Error creating playbook: ${msg}`, isError: true };
   }
 }
-
-registerTool({
-  name: 'playbook_create',
-  description: 'Create an action playbook — a trigger→action rule that tells the assistant how to handle incoming messages matching a pattern',
-  category: 'playbook',
-  defaultRiskLevel: RiskLevel.Low,
-  getDefinition: () => ({
-    name: 'playbook_create',
-    description: 'Create an action playbook — a trigger→action rule that tells the assistant how to handle incoming messages matching a pattern',
-    input_schema: {
-      type: 'object',
-      properties: {
-        trigger: {
-          type: 'string',
-          description: 'Pattern or description that triggers this playbook (e.g. "meeting request", "from:ceo@*", "newsletter")',
-        },
-        action: {
-          type: 'string',
-          description: 'What to do when the trigger matches — natural language action description (e.g. "check calendar, propose 3 times")',
-        },
-        channel: {
-          type: 'string',
-          description: 'Channel this rule applies to (e.g. "email", "slack"), or "*" for all channels. Defaults to "*".',
-        },
-        category: {
-          type: 'string',
-          description: 'Free-form category for grouping (e.g. "scheduling", "triage"). Defaults to "general".',
-        },
-        autonomy_level: {
-          type: 'string',
-          enum: ['auto', 'draft', 'notify'],
-          description: 'How much autonomy: "auto" = execute automatically, "draft" = draft for review, "notify" = notify only. Defaults to "draft".',
-        },
-        priority: {
-          type: 'number',
-          description: 'Relative priority — higher numbers take precedence. Defaults to 0.',
-        },
-      },
-      required: ['trigger', 'action'],
-    },
-  }),
-  execute,
-});

package/src/tools/playbooks/playbook-delete.ts

@@ -1,12 +1,10 @@
 import { and, eq } from 'drizzle-orm';
-import { RiskLevel } from '../../permissions/types.js';
 import type { ToolContext, ToolExecutionResult } from '../types.js';
-import { registerTool } from '../registry.js';
 import { getDb } from '../../memory/db.js';
 import { memoryItems } from '../../memory/schema.js';
 import { parsePlaybookStatement } from '../../playbooks/types.js';
 
-async function execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
+export async function executePlaybookDelete(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
   const playbookId = input.playbook_id as string;
   if (!playbookId || typeof playbookId !== 'string') {
     return { content: 'Error: playbook_id is required and must be a string', isError: true };
@@ -52,25 +50,3 @@ async function execute(input: Record<string, unknown>, context: ToolContext): Pr
     return { content: `Error deleting playbook: ${msg}`, isError: true };
   }
 }
-
-registerTool({
-  name: 'playbook_delete',
-  description: 'Delete an action playbook rule',
-  category: 'playbook',
-  defaultRiskLevel: RiskLevel.Low,
-  getDefinition: () => ({
-    name: 'playbook_delete',
-    description: 'Delete an action playbook rule',
-    input_schema: {
-      type: 'object',
-      properties: {
-        playbook_id: {
-          type: 'string',
-          description: 'ID of the playbook to delete (from playbook_list results)',
-        },
-      },
-      required: ['playbook_id'],
-    },
-  }),
-  execute,
-});

package/src/tools/playbooks/playbook-list.ts

@@ -1,12 +1,10 @@
 import { and, desc, eq, isNull } from 'drizzle-orm';
-import { RiskLevel } from '../../permissions/types.js';
 import type { ToolContext, ToolExecutionResult } from '../types.js';
-import { registerTool } from '../registry.js';
 import { getDb } from '../../memory/db.js';
 import { memoryItems } from '../../memory/schema.js';
 import { parsePlaybookStatement } from '../../playbooks/types.js';
 
-async function execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
+export async function executePlaybookList(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
   const scopeId = context.memoryScopeId ?? 'default';
   const channelFilter = typeof input.channel === 'string' ? input.channel : null;
   const categoryFilter = typeof input.category === 'string' ? input.category : null;
@@ -74,28 +72,3 @@ async function execute(input: Record<string, unknown>, context: ToolContext): Pr
     return { content: `Error listing playbooks: ${msg}`, isError: true };
   }
 }
-
-registerTool({
-  name: 'playbook_list',
-  description: 'List action playbooks, optionally filtered by channel or category',
-  category: 'playbook',
-  defaultRiskLevel: RiskLevel.Low,
-  getDefinition: () => ({
-    name: 'playbook_list',
-    description: 'List action playbooks, optionally filtered by channel or category',
-    input_schema: {
-      type: 'object',
-      properties: {
-        channel: {
-          type: 'string',
-          description: 'Filter by channel (e.g. "email", "slack"). Omit to show all.',
-        },
-        category: {
-          type: 'string',
-          description: 'Filter by category (e.g. "scheduling", "triage"). Omit to show all.',
-        },
-      },
-    },
-  }),
-  execute,
-});

package/src/tools/playbooks/playbook-update.ts

@@ -1,17 +1,16 @@
 import { and, eq } from 'drizzle-orm';
-import { RiskLevel } from '../../permissions/types.js';
 import type { ToolContext, ToolExecutionResult } from '../types.js';
-import { registerTool } from '../registry.js';
 import { getDb } from '../../memory/db.js';
 import { computeMemoryFingerprint } from '../../memory/fingerprint.js';
 import { memoryItems } from '../../memory/schema.js';
 import { enqueueMemoryJob } from '../../memory/jobs-store.js';
 import { parsePlaybookStatement } from '../../playbooks/types.js';
 import type { Playbook, PlaybookAutonomyLevel } from '../../playbooks/types.js';
+import { truncate } from '../../util/truncate.js';
 
 const VALID_AUTONOMY_LEVELS = new Set<string>(['auto', 'draft', 'notify']);
 
-async function execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
+export async function executePlaybookUpdate(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
   const playbookId = input.playbook_id as string;
   if (!playbookId || typeof playbookId !== 'string') {
     return { content: 'Error: playbook_id is required and must be a string', isError: true };
@@ -55,7 +54,7 @@ async function execute(input: Record<string, unknown>, context: ToolContext): Pr
     };
 
     const statement = JSON.stringify(updated);
-    const subject = `Playbook: ${updated.trigger}`.slice(0, 80);
+    const subject = truncate(`Playbook: ${updated.trigger}`, 80, '');
     const now = Date.now();
 
     const fingerprint = computeMemoryFingerprint(scopeId, 'playbook', subject, statement);
@@ -110,50 +109,3 @@ async function execute(input: Record<string, unknown>, context: ToolContext): Pr
     return { content: `Error updating playbook: ${msg}`, isError: true };
   }
 }
-
-registerTool({
-  name: 'playbook_update',
-  description: 'Update an existing action playbook rule',
-  category: 'playbook',
-  defaultRiskLevel: RiskLevel.Low,
-  getDefinition: () => ({
-    name: 'playbook_update',
-    description: 'Update an existing action playbook rule',
-    input_schema: {
-      type: 'object',
-      properties: {
-        playbook_id: {
-          type: 'string',
-          description: 'ID of the playbook to update (from playbook_list results)',
-        },
-        trigger: {
-          type: 'string',
-          description: 'Updated trigger pattern',
-        },
-        action: {
-          type: 'string',
-          description: 'Updated action description',
-        },
-        channel: {
-          type: 'string',
-          description: 'Updated channel ("*" for all)',
-        },
-        category: {
-          type: 'string',
-          description: 'Updated category',
-        },
-        autonomy_level: {
-          type: 'string',
-          enum: ['auto', 'draft', 'notify'],
-          description: 'Updated autonomy level',
-        },
-        priority: {
-          type: 'number',
-          description: 'Updated priority',
-        },
-      },
-      required: ['playbook_id'],
-    },
-  }),
-  execute,
-});

package/src/tools/reminder/reminder.ts

@@ -1,6 +1,4 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
+import type { ToolExecutionResult } from '../types.js';
 import { formatLocalDate } from '../../schedule/schedule-store.js';
 import {
   insertReminder,
@@ -8,28 +6,9 @@ import {
   cancelReminder,
 } from './reminder-store.js';
 
-function executeReminder(input: Record<string, unknown>): ToolExecutionResult {
-  const action = input.action as string | undefined;
-  if (!action) {
-    return { content: 'Error: action is required', isError: true };
-  }
-
-  switch (action) {
-    case 'create':
-      return createAction(input);
-    case 'list':
-      return listAction();
-    case 'cancel':
-      return cancelAction(input);
-    default:
-      return {
-        content: `Error: Unknown action "${action}". Valid actions: create, list, cancel`,
-        isError: true,
-      };
-  }
-}
+// ── Exported execute functions ──────────────────────────────────────
 
-function createAction(input: Record<string, unknown>): ToolExecutionResult {
+export function executeReminderCreate(input: Record<string, unknown>): ToolExecutionResult {
   const fireAtStr = input.fire_at as string | undefined;
   const label = input.label as string | undefined;
   const message = input.message as string | undefined;
@@ -68,7 +47,7 @@ function createAction(input: Record<string, unknown>): ToolExecutionResult {
   };
 }
 
-function listAction(): ToolExecutionResult {
+export function executeReminderList(): ToolExecutionResult {
   const all = listReminders();
   if (all.length === 0) {
     return { content: 'No reminders found.', isError: false };
@@ -86,7 +65,7 @@ function listAction(): ToolExecutionResult {
   return { content: `Reminders:\n${lines.join('\n')}`, isError: false };
 }
 
-function cancelAction(input: Record<string, unknown>): ToolExecutionResult {
+export function executeReminderCancel(input: Record<string, unknown>): ToolExecutionResult {
   const reminderId = input.reminder_id as string | undefined;
   if (!reminderId) {
     return { content: 'Error: reminder_id is required for cancel', isError: true };
@@ -99,55 +78,3 @@ function cancelAction(input: Record<string, unknown>): ToolExecutionResult {
 
   return { content: `Reminder "${reminderId}" cancelled.`, isError: false };
 }
-
-class ReminderTool implements Tool {
-  name = 'reminder';
-  description = 'Create, list, or cancel one-time time-based reminders. Reminders fire at a specific future time and either notify the user or execute a message through the assistant. Use this ONLY when the user wants a time-triggered notification (e.g. "remind me at 3pm", "remind me in 2 hours"). Do NOT use this for "add to my tasks" or "add to my queue" — use task_list_add for those requests.';
-  category = 'reminder';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          action: {
-            type: 'string',
-            enum: ['create', 'list', 'cancel'],
-            description: 'Reminder action',
-          },
-          fire_at: {
-            type: 'string',
-            description: 'ISO 8601 timestamp for when the reminder should fire (required for create)',
-          },
-          label: {
-            type: 'string',
-            description: 'Human-readable label (required for create)',
-          },
-          message: {
-            type: 'string',
-            description: 'Content shown in notification (notify) or sent to agent (execute). Required for create.',
-          },
-          mode: {
-            type: 'string',
-            enum: ['notify', 'execute'],
-            description: 'How the reminder fires. Defaults to notify.',
-          },
-          reminder_id: {
-            type: 'string',
-            description: 'Reminder ID (required for cancel)',
-          },
-        },
-        required: ['action'],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    return executeReminder(input);
-  }
-}
-
-export const reminderTool = new ReminderTool();

package/src/tools/schedule/create.ts

@@ -1,86 +1,81 @@
-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 { createSchedule, isValidCronExpression, formatLocalDate, describeCronExpression } from '../../schedule/schedule-store.js';
+import { normalizeScheduleSyntax } from '../../schedule/recurrence-types.js';
+import { validateRruleSetLines } from '../../schedule/recurrence-engine.js';
 
-class ScheduleCreateTool implements Tool {
-  name = 'schedule_create';
-  description = 'Create a recurring scheduled automation that sends a message at a cron interval. ONLY use this when the user explicitly wants something to run on a schedule (e.g. "every day at 9am", "weekly on Mondays", "every hour"). Do NOT use this for "add to my tasks" or "add to my queue" — use task_list_add for those requests instead.';
-  category = 'schedule';
-  defaultRiskLevel = RiskLevel.Medium;
+export async function executeScheduleCreate(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const name = input.name as string;
+  const timezone = (input.timezone as string) ?? null;
+  const message = input.message as string;
+  const enabled = (input.enabled as boolean) ?? true;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-            description: 'A human-readable name for the scheduled task',
-          },
-          cron_expression: {
-            type: 'string',
-            description: 'A cron expression (e.g. "0 9 * * 1-5" for weekdays at 9am). Supports standard 5-field cron syntax.',
-          },
-          timezone: {
-            type: 'string',
-            description: 'IANA timezone (e.g. "America/Los_Angeles"). Defaults to system timezone if omitted.',
-          },
-          message: {
-            type: 'string',
-            description: 'The message to send to the assistant when the schedule triggers',
-          },
-          enabled: {
-            type: 'boolean',
-            description: 'Whether the job is enabled immediately. Defaults to true.',
-          },
-        },
-        required: ['name', 'cron_expression', 'message'],
-      },
-    };
+  if (!name || typeof name !== 'string') {
+    return { content: 'Error: name is required and must be a string', isError: true };
+  }
+  if (!message || typeof message !== 'string') {
+    return { content: 'Error: message is required and must be a string', isError: true };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const name = input.name as string;
-    const cronExpression = input.cron_expression as string;
-    const timezone = (input.timezone as string) ?? null;
-    const message = input.message as string;
-    const enabled = (input.enabled as boolean) ?? true;
+  // Resolve syntax and expression from new or legacy fields
+  const resolved = normalizeScheduleSyntax({
+    syntax: input.syntax as 'cron' | 'rrule' | undefined,
+    expression: input.expression as string | undefined,
+    legacyCronExpression: input.cron_expression as string | undefined,
+  });
 
-    if (!name || typeof name !== 'string') {
-      return { content: 'Error: name is required and must be a string', isError: true };
-    }
-    if (!cronExpression || typeof cronExpression !== 'string') {
-      return { content: 'Error: cron_expression is required and must be a string', isError: true };
-    }
-    if (!message || typeof message !== 'string') {
-      return { content: 'Error: message is required and must be a string', isError: true };
-    }
-    if (!isValidCronExpression(cronExpression)) {
-      return { content: `Error: Invalid cron expression: "${cronExpression}"`, isError: true };
-    }
+  if (!resolved) {
+    return { content: 'Error: expression (or cron_expression) is required', isError: true };
+  }
 
-    try {
-      const job = createSchedule({ name, cronExpression, timezone, message, enabled });
-      const nextRunDate = formatLocalDate(job.nextRunAt);
+  // Syntax-specific pre-validation for actionable error messages
+  if (resolved.syntax === 'cron' && !isValidCronExpression(resolved.expression)) {
+    return { content: `Error: Invalid cron expression: "${resolved.expression}"`, isError: true };
+  }
+  if (resolved.syntax === 'rrule') {
+    if (typeof resolved.expression !== 'string') {
+      return { content: 'Error: expression must be a string', isError: true };
+    }
+    const setError = validateRruleSetLines(resolved.expression);
+    if (setError) {
       return {
-        content: [
-          `Schedule created successfully.`,
-          `  Name: ${job.name}`,
-          `  Schedule: ${describeCronExpression(job.cronExpression)}${job.timezone ? ` (${job.timezone})` : ''}`,
-          `  Enabled: ${job.enabled}`,
-          `  Next run: ${nextRunDate}`,
-        ].join('\n'),
-        isError: false,
+        content: `Error: ${setError}. Supported line types: DTSTART, RRULE, RDATE, EXDATE, EXRULE.`,
+        isError: true,
       };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Error creating schedule: ${msg}`, isError: true };
     }
   }
-}
 
-registerTool(new ScheduleCreateTool());
+  try {
+    const job = createSchedule({
+      name,
+      cronExpression: resolved.expression,
+      timezone,
+      message,
+      enabled,
+      syntax: resolved.syntax,
+      expression: resolved.expression,
+    });
+
+    const scheduleDescription = job.syntax === 'rrule'
+      ? job.expression
+      : describeCronExpression(job.cronExpression);
+
+    const nextRunDate = formatLocalDate(job.nextRunAt);
+    return {
+      content: [
+        `Schedule created successfully.`,
+        `  Name: ${job.name}`,
+        `  Syntax: ${job.syntax}`,
+        `  Schedule: ${scheduleDescription}${job.timezone ? ` (${job.timezone})` : ''}`,
+        `  Enabled: ${job.enabled}`,
+        `  Next run: ${nextRunDate}`,
+      ].join('\n'),
+      isError: false,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error creating schedule: ${msg}`, isError: true };
+  }
+}

package/src/tools/schedule/delete.ts

@@ -1,54 +1,28 @@
-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 { deleteSchedule, getSchedule } from '../../schedule/schedule-store.js';
 
-class ScheduleDeleteTool implements Tool {
-  name = 'schedule_delete';
-  description = 'Delete a recurring scheduled automation and all its run history';
-  category = 'schedule';
-  defaultRiskLevel = RiskLevel.High;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          job_id: {
-            type: 'string',
-            description: 'The ID of the schedule to delete',
-          },
-        },
-        required: ['job_id'],
-      },
-    };
+export async function executeScheduleDelete(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const jobId = input.job_id as string;
+  if (!jobId || typeof jobId !== 'string') {
+    return { content: 'Error: job_id is required', isError: true };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const jobId = input.job_id as string;
-    if (!jobId || typeof jobId !== 'string') {
-      return { content: 'Error: job_id is required', isError: true };
-    }
-
-    // Fetch the job first for the confirmation message
-    const job = getSchedule(jobId);
-    if (!job) {
-      return { content: `Error: Schedule not found: ${jobId}`, isError: true };
-    }
-
-    const deleted = deleteSchedule(jobId);
-    if (!deleted) {
-      return { content: `Error: Failed to delete schedule: ${jobId}`, isError: true };
-    }
+  // Fetch the job first for the confirmation message
+  const job = getSchedule(jobId);
+  if (!job) {
+    return { content: `Error: Schedule not found: ${jobId}`, isError: true };
+  }
 
-    return {
-      content: `Schedule deleted: "${job.name}"`,
-      isError: false,
-    };
+  const deleted = deleteSchedule(jobId);
+  if (!deleted) {
+    return { content: `Error: Failed to delete schedule: ${jobId}`, isError: true };
   }
-}
 
-registerTool(new ScheduleDeleteTool());
+  return {
+    content: `Schedule deleted: "${job.name}"`,
+    isError: false,
+  };
+}