vellum 0.2.0 → 0.2.2

package/src/__tests__/recurrence-engine-rruleset.test.ts

@@ -0,0 +1,78 @@
+import { describe, test, expect } from 'bun:test';
+import { isValidScheduleExpression, computeNextRunAt } from '../schedule/recurrence-engine.js';
+
+describe('RRULE set engine support', () => {
+  test('multiple RRULE lines are unioned — next run is earliest', () => {
+    // Daily at 9am + Weekly on Mondays at 3pm, starting Jan 1 2099
+    const expr = [
+      'DTSTART:20990101T090000Z',
+      'RRULE:FREQ=DAILY;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+      'RRULE:FREQ=WEEKLY;BYDAY=MO;BYHOUR=15;BYMINUTE=0;BYSECOND=0',
+    ].join('\n');
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(true);
+    const next = computeNextRunAt({ syntax: 'rrule', expression: expr });
+    expect(next).toBeGreaterThan(Date.now());
+  });
+
+  test('RRULE + EXDATE excludes matching occurrence', () => {
+    // Daily starting Jan 1 2099, exclude Jan 2
+    const expr = [
+      'DTSTART:20990101T090000Z',
+      'RRULE:FREQ=DAILY;COUNT=5',
+      'EXDATE:20990102T090000Z',
+    ].join('\n');
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(true);
+    // First occurrence: Jan 1, second should skip Jan 2 and be Jan 3
+    const jan1 = new Date('2099-01-01T09:00:00Z').getTime();
+    const jan2 = new Date('2099-01-02T09:00:00Z').getTime();
+    const next = computeNextRunAt({ syntax: 'rrule', expression: expr }, jan1 + 1);
+    // Should not be Jan 2 (excluded)
+    expect(next).not.toBe(jan2);
+  });
+
+  test('RDATE adds ad-hoc occurrence', () => {
+    // Weekly on Mondays + an extra occurrence on Jan 15 2099 (Wednesday)
+    const expr = [
+      'DTSTART:20990106T090000Z',
+      'RRULE:FREQ=WEEKLY;BYDAY=MO',
+      'RDATE:20990115T090000Z',
+    ].join('\n');
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(true);
+  });
+
+  test('unknown line is rejected', () => {
+    const expr = [
+      'DTSTART:20990101T090000Z',
+      'RRULE:FREQ=DAILY',
+      'SUMMARY:My event',
+    ].join('\n');
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(false);
+  });
+
+  test('expression without DTSTART is rejected', () => {
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: 'RRULE:FREQ=DAILY' })).toBe(false);
+  });
+
+  test('expression without inclusion source is rejected', () => {
+    const expr = 'DTSTART:20990101T090000Z\nEXDATE:20990102T090000Z';
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(false);
+  });
+
+  test('escaped newlines are normalized', () => {
+    const expr = 'DTSTART:20990101T090000Z\\nRRULE:FREQ=DAILY';
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(true);
+    const next = computeNextRunAt({ syntax: 'rrule', expression: expr });
+    expect(next).toBeGreaterThan(Date.now());
+  });
+
+  test('existing single RRULE still works', () => {
+    const expr = 'DTSTART:20990101T090000Z\nRRULE:FREQ=DAILY';
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(true);
+  });
+
+  test('existing cron still works', () => {
+    expect(isValidScheduleExpression({ syntax: 'cron', expression: '0 9 * * 1-5' })).toBe(true);
+    const next = computeNextRunAt({ syntax: 'cron', expression: '* * * * *' });
+    expect(next).toBeGreaterThan(Date.now() - 1);
+  });
+});

package/src/__tests__/recurrence-engine.test.ts

@@ -0,0 +1,69 @@
+import { describe, test, expect } from 'bun:test';
+import { isValidScheduleExpression, computeNextRunAt } from '../schedule/recurrence-engine.js';
+
+describe('recurrence engine — cron', () => {
+  test('validates valid cron expressions', () => {
+    expect(isValidScheduleExpression({ syntax: 'cron', expression: '0 9 * * 1-5' })).toBe(true);
+    expect(isValidScheduleExpression({ syntax: 'cron', expression: '*/5 * * * *' })).toBe(true);
+  });
+
+  test('rejects invalid cron expressions', () => {
+    expect(isValidScheduleExpression({ syntax: 'cron', expression: 'not valid' })).toBe(false);
+    expect(isValidScheduleExpression({ syntax: 'cron', expression: '' })).toBe(false);
+  });
+
+  test('computes next run for cron', () => {
+    const now = Date.now();
+    const next = computeNextRunAt({ syntax: 'cron', expression: '* * * * *' }, now);
+    expect(next).toBeGreaterThan(now - 1);
+    // Next minute should be within 60 seconds
+    expect(next - now).toBeLessThanOrEqual(60_000);
+  });
+});
+
+describe('recurrence engine — rrule', () => {
+  test('validates RRULE with DTSTART', () => {
+    const expr = 'DTSTART:20250101T090000Z\nRRULE:FREQ=DAILY;BYHOUR=9;BYMINUTE=0';
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(true);
+  });
+
+  test('rejects RRULE without DTSTART', () => {
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: 'RRULE:FREQ=DAILY' })).toBe(false);
+  });
+
+  test('accepts RRULE set constructs', () => {
+    const withExdate = 'DTSTART:20250101T090000Z\nRRULE:FREQ=DAILY\nEXDATE:20250105T090000Z';
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: withExdate })).toBe(true);
+
+    const withRdate = 'DTSTART:20250101T090000Z\nRRULE:FREQ=DAILY\nRDATE:20250115T090000Z';
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: withRdate })).toBe(true);
+
+    const multiRrule = 'DTSTART:20250101T090000Z\nRRULE:FREQ=DAILY\nRRULE:FREQ=WEEKLY';
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: multiRrule })).toBe(true);
+  });
+
+  test('computes next run for RRULE with future DTSTART', () => {
+    // Use a date far in the future to ensure the test is stable
+    const futureDate = new Date('2099-01-01T09:00:00Z');
+    const expr = 'DTSTART:20990101T090000Z\nRRULE:FREQ=DAILY';
+    const next = computeNextRunAt({ syntax: 'rrule', expression: expr });
+    expect(next).toBeGreaterThanOrEqual(futureDate.getTime());
+  });
+
+  test('throws when RRULE has no future runs (UNTIL in past)', () => {
+    const expr = 'DTSTART:20200101T090000Z\nRRULE:FREQ=DAILY;UNTIL=20200105T090000Z';
+    expect(() => computeNextRunAt({ syntax: 'rrule', expression: expr })).toThrow(/no upcoming runs/);
+  });
+
+  test('throws for RRULE missing DTSTART in computeNextRunAt', () => {
+    expect(() => computeNextRunAt({ syntax: 'rrule', expression: 'RRULE:FREQ=DAILY' })).toThrow(/DTSTART/);
+  });
+
+  test('computes next run for RRULE with EXDATE set construct', () => {
+    const expr = 'DTSTART:20990101T090000Z\nRRULE:FREQ=DAILY\nEXDATE:20990101T090000Z';
+    const next = computeNextRunAt({ syntax: 'rrule', expression: expr });
+    // Should skip the excluded date and return January 2
+    const jan2 = new Date('2099-01-02T09:00:00Z').getTime();
+    expect(next).toBe(jan2);
+  });
+});

package/src/__tests__/recurrence-types.test.ts

@@ -0,0 +1,71 @@
+import { describe, test, expect } from 'bun:test';
+import { detectScheduleSyntax, normalizeScheduleSyntax } from '../schedule/recurrence-types.js';
+
+describe('detectScheduleSyntax', () => {
+  test('detects cron for standard 5-field expressions', () => {
+    expect(detectScheduleSyntax('0 9 * * 1-5')).toBe('cron');
+    expect(detectScheduleSyntax('*/5 * * * *')).toBe('cron');
+    expect(detectScheduleSyntax('30 14 1 * *')).toBe('cron');
+    expect(detectScheduleSyntax('0 0 * * 0')).toBe('cron');
+  });
+
+  test('detects RRULE for RRULE: prefix', () => {
+    expect(detectScheduleSyntax('RRULE:FREQ=DAILY;BYHOUR=9;BYMINUTE=0')).toBe('rrule');
+  });
+
+  test('detects RRULE for DTSTART + RRULE multiline', () => {
+    expect(detectScheduleSyntax('DTSTART:20250101T090000Z\nRRULE:FREQ=DAILY')).toBe('rrule');
+  });
+
+  test('detects RRULE for expression containing FREQ=', () => {
+    expect(detectScheduleSyntax('FREQ=WEEKLY;BYDAY=MO,WE,FR')).toBe('rrule');
+  });
+
+  test('returns null for empty/invalid input', () => {
+    expect(detectScheduleSyntax('')).toBeNull();
+    expect(detectScheduleSyntax('   ')).toBeNull();
+    expect(detectScheduleSyntax('hello world')).toBeNull();
+    expect(detectScheduleSyntax('not a schedule expression at all and is long')).toBeNull();
+  });
+
+  test('returns null for ambiguous expressions', () => {
+    // Single word that is not 5 fields and not RRULE
+    expect(detectScheduleSyntax('daily')).toBeNull();
+  });
+});
+
+describe('normalizeScheduleSyntax', () => {
+  test('uses explicit syntax + expression when both provided', () => {
+    const result = normalizeScheduleSyntax({
+      syntax: 'rrule',
+      expression: 'RRULE:FREQ=DAILY',
+    });
+    expect(result).toEqual({ syntax: 'rrule', expression: 'RRULE:FREQ=DAILY' });
+  });
+
+  test('auto-detects syntax from expression', () => {
+    const cronResult = normalizeScheduleSyntax({ expression: '0 9 * * 1-5' });
+    expect(cronResult).toEqual({ syntax: 'cron', expression: '0 9 * * 1-5' });
+
+    const rruleResult = normalizeScheduleSyntax({ expression: 'RRULE:FREQ=DAILY' });
+    expect(rruleResult).toEqual({ syntax: 'rrule', expression: 'RRULE:FREQ=DAILY' });
+  });
+
+  test('falls back to legacyCronExpression', () => {
+    const result = normalizeScheduleSyntax({ legacyCronExpression: '0 9 * * *' });
+    expect(result).toEqual({ syntax: 'cron', expression: '0 9 * * *' });
+  });
+
+  test('returns null when nothing is provided', () => {
+    expect(normalizeScheduleSyntax({})).toBeNull();
+  });
+
+  test('returns null when expression is ambiguous and no syntax hint', () => {
+    expect(normalizeScheduleSyntax({ expression: 'daily' })).toBeNull();
+  });
+
+  test('trusts explicit syntax when auto-detection fails', () => {
+    const result = normalizeScheduleSyntax({ syntax: 'cron', expression: 'some-custom-expr' });
+    expect(result).toEqual({ syntax: 'cron', expression: 'some-custom-expr' });
+  });
+});

package/src/__tests__/registry.test.ts

@@ -19,7 +19,7 @@ import {
   __resetRegistryForTesting,
   __clearRegistryForTesting,
 } from '../tools/registry.js';
-import { eagerModules, explicitTools, lazyTools } from '../tools/tool-manifest.js';
+import { eagerModuleToolNames, explicitTools, lazyTools } from '../tools/tool-manifest.js';
 
 // Clean up global registry after this file completes to prevent
 // contamination of subsequent test files in combined runs.
@@ -175,24 +175,26 @@ describe('tool manifest', () => {
     expect(lazyNames.has('swarm_delegate')).toBe(true);
   });
 
-  test('eager module list contains expected count', () => {
-    expect(eagerModules.length).toBe(28);
+  test('eager module tool names list contains expected count', () => {
+    expect(eagerModuleToolNames.length).toBe(15);
   });
 
-  test('explicit tools list includes memory, credential, and timer tools', () => {
+  test('explicit tools list includes memory, credential, watch, catalog, and discover tools', () => {
     const names = explicitTools.map((t) => t.name);
     expect(names).toContain('memory_search');
     expect(names).toContain('memory_save');
     expect(names).toContain('memory_update');
     expect(names).toContain('credential_store');
     expect(names).toContain('account_manage');
-    expect(names).toContain('reminder');
+    expect(names).toContain('start_screen_watch');
+    expect(names).toContain('vellum_skills_catalog');
+    expect(names).toContain('cli_discover');
   });
 
   test('registered tool count is at least eager + lazy + host', async () => {
     await initializeTools();
     const tools = getAllTools();
-    expect(tools.length).toBeGreaterThanOrEqual(eagerModules.length + lazyTools.length);
+    expect(tools.length).toBeGreaterThanOrEqual(eagerModuleToolNames.length + lazyTools.length);
   });
 });
 
@@ -210,8 +212,13 @@ describe('baseline characterization: hardcoded tool loading', () => {
     }
   });
 
-  test('gmail eager module is NOT in eagerModules manifest', () => {
-    expect(eagerModules).not.toContain('./gmail/executors.js');
+  test('gmail tool names are NOT in eagerModuleToolNames manifest', () => {
+    const gmailTools = ['gmail_search', 'gmail_list_messages', 'gmail_get_message', 'gmail_mark_read',
+      'gmail_draft', 'gmail_archive', 'gmail_batch_archive', 'gmail_label', 'gmail_batch_label',
+      'gmail_trash', 'gmail_send', 'gmail_unsubscribe'];
+    for (const name of gmailTools) {
+      expect(eagerModuleToolNames).not.toContain(name);
+    }
   });
 
   test('weather tool is NOT in global registry after initializeTools()', async () => {
@@ -220,8 +227,8 @@ describe('baseline characterization: hardcoded tool loading', () => {
     expect(tool).toBeUndefined();
   });
 
-  test('weather eager module is NOT in eagerModules manifest', () => {
-    expect(eagerModules).not.toContain('./weather/get-weather.js');
+  test('weather tool name is NOT in eagerModuleToolNames manifest', () => {
+    expect(eagerModuleToolNames).not.toContain('get_weather');
   });
 
   test('claude_code is NOT in global registry after initializeTools()', async () => {