vellum 0.2.13 → 0.3.2

package/src/__tests__/intent-routing.test.ts

@@ -1,259 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test';
-import { mkdirSync, rmSync, existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-// ── Mock platform to isolate tests from the real workspace ────────────
-const TEST_DIR = join(tmpdir(), `vellum-routing-test-${crypto.randomUUID()}`);
-
-mock.module('../util/platform.js', () => ({
-  getRootDir: () => TEST_DIR,
-  getDataDir: () => TEST_DIR,
-  getWorkspaceDir: () => TEST_DIR,
-  getWorkspaceConfigPath: () => join(TEST_DIR, 'config.json'),
-  getWorkspaceSkillsDir: () => join(TEST_DIR, 'skills'),
-  getWorkspaceHooksDir: () => join(TEST_DIR, 'hooks'),
-  getWorkspacePromptPath: (file: string) => join(TEST_DIR, file),
-  ensureDataDir: () => {},
-  getSocketPath: () => join(TEST_DIR, 'vellum.sock'),
-  getPidPath: () => join(TEST_DIR, 'vellum.pid'),
-  getDbPath: () => join(TEST_DIR, 'data', 'assistant.db'),
-  getLogPath: () => join(TEST_DIR, 'logs', 'vellum.log'),
-  getHistoryPath: () => join(TEST_DIR, 'history'),
-  getHooksDir: () => join(TEST_DIR, 'hooks'),
-  getIpcBlobDir: () => join(TEST_DIR, 'ipc-blobs'),
-  getSandboxRootDir: () => join(TEST_DIR, 'sandbox'),
-  getSandboxWorkingDir: () => TEST_DIR,
-  getInterfacesDir: () => join(TEST_DIR, 'interfaces'),
-  isMacOS: () => process.platform === 'darwin',
-  isLinux: () => process.platform === 'linux',
-  isWindows: () => process.platform === 'win32',
-  getPlatformName: () => process.platform,
-  getClipboardCommand: () => null,
-  removeSocketFile: () => {},
-  migratePath: () => {},
-  migrateToWorkspaceLayout: () => {},
-  migrateToDataLayout: () => {},
-}));
-
-mock.module('../util/logger.js', () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module('../config/loader.js', () => ({
-  getConfig: () => ({
-    sandbox: { enabled: false, backend: 'local' },
-  }),
-}));
-
-// ── Import after mocks ───────────────────────────────────────────────
-const { buildSystemPrompt } = await import('../config/system-prompt.js');
-
-// Load task_list_add description from the bundled skill TOOLS.json
-const tasksToolsJson = JSON.parse(
-  readFileSync(join(import.meta.dirname, '../config/bundled-skills/tasks/TOOLS.json'), 'utf-8'),
-);
-const taskListAddDef = tasksToolsJson.tools.find((t: { name: string }) => t.name === 'task_list_add');
-
-// Load reminder_create description from the bundled skill TOOLS.json
-const reminderToolsJson = JSON.parse(
-  readFileSync(join(import.meta.dirname, '../config/bundled-skills/reminder/TOOLS.json'), 'utf-8'),
-);
-const reminderCreateDef = reminderToolsJson.tools.find((t: { name: string }) => t.name === 'reminder_create');
-
-// Load schedule_create description from the bundled skill TOOLS.json
-const scheduleToolsJson = JSON.parse(
-  readFileSync(join(import.meta.dirname, '../config/bundled-skills/schedule/TOOLS.json'), 'utf-8'),
-);
-const scheduleCreateDef = scheduleToolsJson.tools.find((t: { name: string }) => t.name === 'schedule_create');
-
-// =====================================================================
-// 1. System prompt: buildTaskScheduleReminderRoutingSection
-// =====================================================================
-
-describe('Task/Schedule/Reminder routing section in system prompt', () => {
-  beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    if (existsSync(TEST_DIR)) {
-      rmSync(TEST_DIR, { recursive: true, force: true });
-    }
-  });
-
-  test('system prompt includes the routing section heading', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain('## Tool Routing: Tasks vs Schedules vs Reminders');
-  });
-
-  test('routing section explains all three subsystems', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain('### Task Queue (task_list_add / task_list_show / task_list_update / task_list_remove)');
-    expect(prompt).toContain('### Schedules (schedule_create / schedule_list / schedule_update / schedule_delete)');
-    expect(prompt).toContain('### Reminders (reminder_create / reminder_list / reminder_cancel)');
-  });
-
-  test('routing section contains key routing phrases for task queue', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain('"Add to my tasks"');
-    expect(prompt).toContain('"add to my queue"');
-    expect(prompt).toContain('"put this on my task list"');
-  });
-
-  test('routing section explains ad-hoc work item creation', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain('ad-hoc work items');
-    expect(prompt).toContain('just a `title`');
-    expect(prompt).toContain('no existing task template is needed');
-  });
-
-  test('routing section clarifies schedules are for recurring automation only', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain('recurring automated jobs');
-    expect(prompt).toContain('recurrence schedule (cron or RRULE)');
-    expect(prompt).toContain('ONLY when the user explicitly wants');
-  });
-
-  test('routing section documents supported RRULE set constructs', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain('#### RRULE Set Constructs');
-    expect(prompt).toContain('**RDATE**');
-    expect(prompt).toContain('**EXDATE**');
-    expect(prompt).toContain('**EXRULE**');
-    expect(prompt).toContain('multiple RRULE lines form a union');
-  });
-
-  test('routing section documents bounded recurrence patterns', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain('Bounded recurrence');
-    expect(prompt).toContain('COUNT or UNTIL');
-  });
-
-  test('routing section states exclusion precedence', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain('Exclusions (EXDATE, EXRULE) take precedence over inclusions (RRULE, RDATE)');
-  });
-
-  test('routing section clarifies reminders are for time-triggered notifications', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain('one-time time-triggered notifications');
-    expect(prompt).toContain('"remind me at 3pm"');
-  });
-
-  test('routing section includes common mistakes to avoid', () => {
-    const prompt = buildSystemPrompt();
-    expect(prompt).toContain('### Common mistakes to avoid');
-    // The key mis-routing guard: "add this to my tasks" should go to task_list_add
-    expect(prompt).toContain('"Add this to my tasks" → task_list_add (NOT schedule_create or reminder_create)');
-  });
-
-  test('routing section distinguishes timed vs untimed "remind me"', () => {
-    const prompt = buildSystemPrompt();
-    // Without a time → task queue
-    expect(prompt).toContain('"Remind me to buy groceries" without a time → task_list_add');
-    // With a time → reminder
-    expect(prompt).toContain('"Remind me at 5pm to buy groceries" → reminder_create');
-  });
-
-  test('routing section is present in the system prompt', () => {
-    const prompt = buildSystemPrompt();
-    const taskRoutingIdx = prompt.indexOf('## Tool Routing: Tasks vs Schedules vs Reminders');
-    expect(taskRoutingIdx).toBeGreaterThanOrEqual(0);
-  });
-});
-
-// =====================================================================
-// 2. Tool description content: routing keywords
-// =====================================================================
-
-describe('task_list_add tool description', () => {
-  test('mentions "add to my tasks" routing phrase', () => {
-    const def = taskListAddDef;
-    expect(def.description).toContain('add to my tasks');
-  });
-
-  test('mentions "add to my queue" routing phrase', () => {
-    const def = taskListAddDef;
-    expect(def.description).toContain('add to my queue');
-  });
-
-  test('mentions "put this on my task list" routing phrase', () => {
-    const def = taskListAddDef;
-    expect(def.description).toContain('put this on my task list');
-  });
-
-  test('mentions ad-hoc title-only mode', () => {
-    const def = taskListAddDef;
-    expect(def.description).toContain('just a title');
-  });
-
-  test('explicitly warns NOT to use schedule_create or reminder for task requests', () => {
-    const def = taskListAddDef;
-    expect(def.description).toContain('Do NOT use schedule_create or reminder');
-  });
-});
-
-describe('schedule_create tool description', () => {
-  test('mentions recurring scheduled automation', () => {
-    expect(scheduleCreateDef).toBeDefined();
-    expect(scheduleCreateDef.description).toContain('recurring');
-  });
-
-  test('mentions cron interval', () => {
-    expect(scheduleCreateDef.description).toContain('cron');
-  });
-
-  test('warns against using for "add to my tasks" requests', () => {
-    expect(scheduleCreateDef.description).toContain('Do NOT use this for "add to my tasks"');
-  });
-
-  test('redirects to task_list_add for task queue items', () => {
-    expect(scheduleCreateDef.description).toContain('task_list_add');
-  });
-
-  test('does NOT suggest it handles task queue items', () => {
-    expect(scheduleCreateDef.description).not.toContain('task queue');
-    expect(scheduleCreateDef.description).not.toContain('one-off');
-  });
-});
-
-describe('reminder tool description', () => {
-  test('mentions time-based reminders', () => {
-    expect(reminderCreateDef.description).toContain('time-based reminder');
-  });
-
-  test('scopes to time-triggered notifications only', () => {
-    expect(reminderCreateDef.description).toContain('ONLY when the user wants a time-triggered notification');
-  });
-
-  test('warns against using for "add to my tasks" requests', () => {
-    expect(reminderCreateDef.description).toContain('Do NOT use this for "add to my tasks"');
-  });
-
-  test('redirects to task_list_add for task queue items', () => {
-    expect(reminderCreateDef.description).toContain('task_list_add');
-  });
-});
-
-// =====================================================================
-// 3. Cross-tool consistency: all three tools agree on routing boundaries
-// =====================================================================
-
-describe('cross-tool routing consistency', () => {
-  test('all three tools reference task_list_add as the task-queue tool', () => {
-    // task_list_add is the canonical name in all three descriptions
-    expect(taskListAddDef.name).toBe('task_list_add');
-    expect(scheduleCreateDef.description).toContain('task_list_add');
-    expect(reminderCreateDef.description).toContain('task_list_add');
-  });
-
-  test('schedule_create and reminder both reject "add to my queue" usage', () => {
-    // Both should redirect away from task-queue requests
-    expect(scheduleCreateDef.description).toContain('add to my queue');
-    expect(reminderCreateDef.description).toContain('add to my queue');
-  });
-});

package/src/__tests__/ipc-blob-store.test.ts

@@ -1,315 +0,0 @@
-import { describe, test, expect, beforeEach, mock } from 'bun:test';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, utimesSync } from 'node:fs';
-import { existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
-
-const testDir = mkdtempSync(join(tmpdir(), 'ipc-blob-store-test-'));
-const blobDir = join(testDir, 'ipc-blobs');
-
-// Mock platform module so blob store writes to temp dir
-mock.module('../util/platform.js', () => ({
-  getRootDir: () => testDir,
-  getDataDir: () => testDir,
-  getIpcBlobDir: () => blobDir,
-  isMacOS: () => process.platform === 'darwin',
-  isLinux: () => process.platform === 'linux',
-  isWindows: () => process.platform === 'win32',
-  getSocketPath: () => join(testDir, 'test.sock'),
-  getPidPath: () => join(testDir, 'test.pid'),
-  getDbPath: () => join(testDir, 'test.db'),
-  getLogPath: () => join(testDir, 'test.log'),
-  ensureDataDir: () => {},
-}));
-
-// Mock logger to suppress output during tests
-mock.module('../util/logger.js', () => ({
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-    trace: () => {},
-    fatal: () => {},
-    child: () => ({
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-      debug: () => {},
-    }),
-  }),
-}));
-
-import {
-  ensureBlobDir,
-  isValidBlobId,
-  resolveBlobPath,
-  readBlob,
-  deleteBlob,
-  sweepStaleBlobs,
-} from '../daemon/ipc-blob-store.js';
-import type { IpcBlobRef } from '../daemon/ipc-contract.js';
-
-/** Write a blob file to the test blob directory and return its path. */
-function writeBlobFile(id: string, content: Buffer): string {
-  const filePath = join(blobDir, `${id}.blob`);
-  writeFileSync(filePath, content);
-  return filePath;
-}
-
-describe('ipc-blob-store', () => {
-  beforeEach(() => {
-    // Reset blob dir before each test
-    if (existsSync(blobDir)) {
-      rmSync(blobDir, { recursive: true });
-    }
-    mkdirSync(blobDir, { recursive: true });
-  });
-
-  // -- ensureBlobDir --
-
-  describe('ensureBlobDir', () => {
-    test('creates blob directory if missing', () => {
-      rmSync(blobDir, { recursive: true });
-      expect(existsSync(blobDir)).toBe(false);
-      ensureBlobDir();
-      expect(existsSync(blobDir)).toBe(true);
-    });
-
-    test('succeeds if blob directory already exists', () => {
-      ensureBlobDir();
-      expect(existsSync(blobDir)).toBe(true);
-    });
-  });
-
-  // -- isValidBlobId --
-
-  describe('isValidBlobId', () => {
-    test('accepts valid UUID v4', () => {
-      expect(isValidBlobId('550e8400-e29b-41d4-a716-446655440000')).toBe(true);
-      expect(isValidBlobId(randomUUID())).toBe(true);
-    });
-
-    test('accepts uppercase hex', () => {
-      expect(isValidBlobId('550E8400-E29B-41D4-A716-446655440000')).toBe(true);
-    });
-
-    test('rejects empty string', () => {
-      expect(isValidBlobId('')).toBe(false);
-    });
-
-    test('rejects too-short string', () => {
-      expect(isValidBlobId('550e8400')).toBe(false);
-    });
-
-    test('rejects path traversal characters', () => {
-      expect(isValidBlobId('../../etc/passwd/aaaaaaaaaaaaaaaa')).toBe(false);
-    });
-
-    test('rejects strings with non-hex characters', () => {
-      expect(isValidBlobId('zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz')).toBe(false);
-    });
-  });
-
-  // -- resolveBlobPath --
-
-  describe('resolveBlobPath', () => {
-    test('returns correct path for valid ID', () => {
-      const id = '550e8400-e29b-41d4-a716-446655440000';
-      const result = resolveBlobPath(id);
-      expect(result).toBe(join(blobDir, `${id}.blob`));
-    });
-
-    test('throws for invalid ID', () => {
-      expect(() => resolveBlobPath('not-a-valid-uuid')).toThrow('Invalid blob ID');
-    });
-
-    test('throws for path traversal attempt', () => {
-      // This should fail at the regex check before even reaching the path check
-      expect(() => resolveBlobPath('../../etc/passwd/aaaaaaaaaaaaaaaa')).toThrow('Invalid blob ID');
-    });
-  });
-
-  // -- readBlob --
-
-  describe('readBlob', () => {
-    test('reads a valid blob successfully', async () => {
-      const id = randomUUID();
-      const content = Buffer.from('hello world');
-      const sha256 = createHash('sha256').update(content).digest('hex');
-
-      writeBlobFile(id, content);
-
-      const ref: IpcBlobRef = {
-        id,
-        kind: 'ax_tree',
-        encoding: 'utf8',
-        byteLength: content.byteLength,
-        sha256,
-      };
-
-      const result = await readBlob(ref);
-      expect(result.toString()).toBe('hello world');
-    });
-
-    test('reads blob without sha256 check', async () => {
-      const id = randomUUID();
-      const content = Buffer.from('some data');
-
-      writeBlobFile(id, content);
-
-      const ref: IpcBlobRef = {
-        id,
-        kind: 'ax_tree',
-        encoding: 'utf8',
-        byteLength: content.byteLength,
-      };
-
-      const result = await readBlob(ref);
-      expect(result.byteLength).toBe(content.byteLength);
-    });
-
-    test('rejects when byteLength does not match', async () => {
-      const id = randomUUID();
-      const content = Buffer.from('hello');
-
-      writeBlobFile(id, content);
-
-      const ref: IpcBlobRef = {
-        id,
-        kind: 'ax_tree',
-        encoding: 'utf8',
-        byteLength: 999,
-      };
-
-      await expect(readBlob(ref)).rejects.toThrow('Blob size mismatch');
-    });
-
-    test('rejects when sha256 does not match', async () => {
-      const id = randomUUID();
-      const content = Buffer.from('hello');
-
-      writeBlobFile(id, content);
-
-      // Compute a definitely-wrong hash by hashing different content
-      const wrongHash = createHash('sha256').update('not-hello').digest('hex');
-
-      const ref: IpcBlobRef = {
-        id,
-        kind: 'ax_tree',
-        encoding: 'utf8',
-        byteLength: content.byteLength,
-        sha256: wrongHash,
-      };
-
-      await expect(readBlob(ref)).rejects.toThrow('Blob SHA-256 mismatch');
-    });
-
-    test('rejects oversized ax_tree blob before reading file', async () => {
-      const id = randomUUID();
-      // Declare a size over 2 MB limit — file doesn't even need to exist
-      const ref: IpcBlobRef = {
-        id,
-        kind: 'ax_tree',
-        encoding: 'utf8',
-        byteLength: 2 * 1024 * 1024 + 1,
-      };
-
-      await expect(readBlob(ref)).rejects.toThrow('declared size exceeds limit');
-    });
-
-    test('rejects oversized screenshot_jpeg blob before reading file', async () => {
-      const id = randomUUID();
-      // Declare a size over 10 MB limit — file doesn't even need to exist
-      const ref: IpcBlobRef = {
-        id,
-        kind: 'screenshot_jpeg',
-        encoding: 'binary',
-        byteLength: 10 * 1024 * 1024 + 1,
-      };
-
-      await expect(readBlob(ref)).rejects.toThrow('declared size exceeds limit');
-    });
-
-    test('accepts screenshot_jpeg blob at exactly 10 MB', async () => {
-      const id = randomUUID();
-      const content = Buffer.alloc(10 * 1024 * 1024);
-
-      writeBlobFile(id, content);
-
-      const ref: IpcBlobRef = {
-        id,
-        kind: 'screenshot_jpeg',
-        encoding: 'binary',
-        byteLength: content.byteLength,
-      };
-
-      const result = await readBlob(ref);
-      expect(result.byteLength).toBe(10 * 1024 * 1024);
-    });
-  });
-
-  // -- deleteBlob --
-
-  describe('deleteBlob', () => {
-    test('removes existing file', () => {
-      const id = randomUUID();
-      const filePath = writeBlobFile(id, Buffer.from('data'));
-      expect(existsSync(filePath)).toBe(true);
-
-      deleteBlob(id);
-      expect(existsSync(filePath)).toBe(false);
-    });
-
-    test('does not throw for missing file', () => {
-      const id = randomUUID();
-      expect(() => deleteBlob(id)).not.toThrow();
-    });
-  });
-
-  // -- sweepStaleBlobs --
-
-  describe('sweepStaleBlobs', () => {
-    test('removes old files and keeps recent ones', async () => {
-      const oldId = randomUUID();
-      const recentId = randomUUID();
-
-      const oldPath = writeBlobFile(oldId, Buffer.from('old'));
-      const recentPath = writeBlobFile(recentId, Buffer.from('recent'));
-
-      // Set old file's mtime to 1 hour ago
-      const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);
-      utimesSync(oldPath, oneHourAgo, oneHourAgo);
-
-      // Sweep files older than 30 minutes
-      const deleted = await sweepStaleBlobs(30 * 60 * 1000);
-
-      expect(deleted).toBe(1);
-      expect(existsSync(oldPath)).toBe(false);
-      expect(existsSync(recentPath)).toBe(true);
-    });
-
-    test('returns 0 when no files to sweep', async () => {
-      const deleted = await sweepStaleBlobs(30 * 60 * 1000);
-      expect(deleted).toBe(0);
-    });
-
-    test('returns 0 when blob directory does not exist', async () => {
-      rmSync(blobDir, { recursive: true });
-      const deleted = await sweepStaleBlobs(30 * 60 * 1000);
-      expect(deleted).toBe(0);
-    });
-
-    test('ignores non-blob files', async () => {
-      const nonBlobPath = join(blobDir, 'readme.txt');
-      writeFileSync(nonBlobPath, 'not a blob');
-      const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);
-      utimesSync(nonBlobPath, oneHourAgo, oneHourAgo);
-
-      const deleted = await sweepStaleBlobs(30 * 60 * 1000);
-      expect(deleted).toBe(0);
-      expect(existsSync(nonBlobPath)).toBe(true);
-    });
-  });
-});

package/src/__tests__/ipc-contract-inventory.test.ts

@@ -1,54 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import * as fs from 'fs';
-import * as path from 'path';
-import { extractInventory, type ContractInventory } from '../daemon/ipc-contract-inventory.js';
-
-const CONTRACT_PATH = path.resolve(import.meta.dirname, '../daemon/ipc-contract.ts');
-const SNAPSHOT_PATH = path.resolve(import.meta.dirname, '../daemon/ipc-contract-inventory.json');
-
-describe('IPC contract inventory', () => {
-  test('snapshot file exists', () => {
-    expect(fs.existsSync(SNAPSHOT_PATH)).toBe(true);
-  });
-
-  test('snapshot matches current contract', () => {
-    const snapshot: ContractInventory = JSON.parse(
-      fs.readFileSync(SNAPSHOT_PATH, 'utf-8'),
-    );
-    const current = extractInventory(CONTRACT_PATH);
-
-    expect(current.clientMessageTypes).toEqual(snapshot.clientMessageTypes);
-    expect(current.serverMessageTypes).toEqual(snapshot.serverMessageTypes);
-  });
-
-  test('extracted types are sorted alphabetically', () => {
-    const inventory = extractInventory(CONTRACT_PATH);
-
-    const sortedClient = [...inventory.clientMessageTypes].sort();
-    const sortedServer = [...inventory.serverMessageTypes].sort();
-
-    expect(inventory.clientMessageTypes).toEqual(sortedClient);
-    expect(inventory.serverMessageTypes).toEqual(sortedServer);
-  });
-
-  test('ClientMessage and ServerMessage have no overlap', () => {
-    const inventory = extractInventory(CONTRACT_PATH);
-    const clientSet = new Set(inventory.clientMessageTypes);
-    const overlap = inventory.serverMessageTypes.filter((t) => clientSet.has(t));
-
-    expect(overlap).toEqual([]);
-  });
-
-  test('all extracted types are non-empty strings', () => {
-    const inventory = extractInventory(CONTRACT_PATH);
-    const allTypes = [
-      ...inventory.clientMessageTypes,
-      ...inventory.serverMessageTypes,
-    ];
-
-    for (const t of allTypes) {
-      expect(typeof t).toBe('string');
-      expect(t.length).toBeGreaterThan(0);
-    }
-  });
-});