@vellumai/assistant 0.4.17 → 0.4.19

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -1,15 +1,16 @@
-import { Database } from 'bun:sqlite';
-import { describe, expect,test } from 'bun:test';
-import { eq } from 'drizzle-orm';
-import { drizzle } from 'drizzle-orm/bun-sqlite';
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
 
-import * as schema from '../memory/schema.js';
-import { scheduleJobs } from '../memory/schema.js';
+import { eq } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../memory/schema.js";
+import { scheduleJobs } from "../memory/schema.js";
 
 function createTestDb() {
-  const sqlite = new Database(':memory:');
-  sqlite.exec('PRAGMA journal_mode=WAL');
-  sqlite.exec('PRAGMA foreign_keys = ON');
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
   return drizzle(sqlite, { schema });
 }
 
@@ -17,8 +18,8 @@ function getRawSqlite(db: ReturnType<typeof drizzle<typeof schema>>): Database {
   return (db as unknown as { $client: Database }).$client;
 }
 
-describe('schedule_syntax column migration', () => {
-  test('fresh DB includes schedule_syntax with default cron', () => {
+describe("schedule_syntax column migration", () => {
+  test("fresh DB includes schedule_syntax with default cron", () => {
     const db = createTestDb();
     const raw = getRawSqlite(db);
 
@@ -42,28 +43,34 @@ describe('schedule_syntax column migration', () => {
     `);
 
     const now = Date.now();
-    db.insert(scheduleJobs).values({
-      id: 'test-1',
-      name: 'Test Job',
-      enabled: true,
-      cronExpression: '0 9 * * *',
-      timezone: null,
-      message: 'hello',
-      nextRunAt: now + 60000,
-      lastRunAt: null,
-      lastStatus: null,
-      retryCount: 0,
-      createdBy: 'agent',
-      createdAt: now,
-      updatedAt: now,
-    }).run();
-
-    const row = db.select().from(scheduleJobs).where(eq(scheduleJobs.id, 'test-1')).get();
+    db.insert(scheduleJobs)
+      .values({
+        id: "test-1",
+        name: "Test Job",
+        enabled: true,
+        cronExpression: "0 9 * * *",
+        timezone: null,
+        message: "hello",
+        nextRunAt: now + 60000,
+        lastRunAt: null,
+        lastStatus: null,
+        retryCount: 0,
+        createdBy: "agent",
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    const row = db
+      .select()
+      .from(scheduleJobs)
+      .where(eq(scheduleJobs.id, "test-1"))
+      .get();
     expect(row).toBeTruthy();
-    expect(row!.scheduleSyntax).toBe('cron');
+    expect(row!.scheduleSyntax).toBe("cron");
   });
 
-  test('upgraded DB gains schedule_syntax column via ALTER TABLE', () => {
+  test("upgraded DB gains schedule_syntax column via ALTER TABLE", () => {
     const db = createTestDb();
     const raw = getRawSqlite(db);
 
@@ -87,17 +94,29 @@ describe('schedule_syntax column migration', () => {
     `);
 
     const now = Date.now();
-    raw.exec(`INSERT INTO cron_jobs (id, name, enabled, cron_expression, timezone, message, next_run_at, last_run_at, last_status, retry_count, created_by, created_at, updated_at) VALUES ('old-1', 'Old Job', 1, '0 9 * * *', NULL, 'hello', ${now + 60000}, NULL, NULL, 0, 'agent', ${now}, ${now})`);
+    raw.exec(
+      `INSERT INTO cron_jobs (id, name, enabled, cron_expression, timezone, message, next_run_at, last_run_at, last_status, retry_count, created_by, created_at, updated_at) VALUES ('old-1', 'Old Job', 1, '0 9 * * *', NULL, 'hello', ${now + 60000}, NULL, NULL, 0, 'agent', ${now}, ${now})`,
+    );
 
     // Run the migration
-    try { raw.exec(`ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`); } catch { /* already exists */ }
-
-    const row = db.select().from(scheduleJobs).where(eq(scheduleJobs.id, 'old-1')).get();
+    try {
+      raw.exec(
+        `ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`,
+      );
+    } catch {
+      /* already exists */
+    }
+
+    const row = db
+      .select()
+      .from(scheduleJobs)
+      .where(eq(scheduleJobs.id, "old-1"))
+      .get();
     expect(row).toBeTruthy();
-    expect(row!.scheduleSyntax).toBe('cron');
+    expect(row!.scheduleSyntax).toBe("cron");
   });
 
-  test('migration is idempotent', () => {
+  test("migration is idempotent", () => {
     const db = createTestDb();
     const raw = getRawSqlite(db);
 
@@ -119,12 +138,30 @@ describe('schedule_syntax column migration', () => {
       )
     `);
 
-    try { raw.exec(`ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`); } catch { /* ok */ }
-    try { raw.exec(`ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`); } catch { /* ok */ }
+    try {
+      raw.exec(
+        `ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`,
+      );
+    } catch {
+      /* ok */
+    }
+    try {
+      raw.exec(
+        `ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`,
+      );
+    } catch {
+      /* ok */
+    }
 
     const now = Date.now();
-    raw.exec(`INSERT INTO cron_jobs (id, name, enabled, cron_expression, timezone, message, next_run_at, retry_count, created_by, created_at, updated_at) VALUES ('idem-1', 'Test', 1, '0 9 * * *', NULL, 'hi', ${now + 60000}, 0, 'agent', ${now}, ${now})`);
-    const row = db.select().from(scheduleJobs).where(eq(scheduleJobs.id, 'idem-1')).get();
-    expect(row!.scheduleSyntax).toBe('cron');
+    raw.exec(
+      `INSERT INTO cron_jobs (id, name, enabled, cron_expression, timezone, message, next_run_at, retry_count, created_by, created_at, updated_at) VALUES ('idem-1', 'Test', 1, '0 9 * * *', NULL, 'hi', ${now + 60000}, 0, 'agent', ${now}, ${now})`,
+    );
+    const row = db
+      .select()
+      .from(scheduleJobs)
+      .where(eq(scheduleJobs.id, "idem-1"))
+      .get();
+    expect(row!.scheduleSyntax).toBe("cron");
   });
 });

package/src/__tests__/delete-managed-skill-tool.test.ts

@@ -1,99 +1,123 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
-
-let TEST_DIR = '';
-
-mock.module('../util/platform.js', () => ({
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+let TEST_DIR = "";
+
+mock.module("../util/platform.js", () => ({
   getRootDir: () => TEST_DIR,
-  getWorkspaceSkillsDir: () => join(TEST_DIR, 'skills'),
+  getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
 }));
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
-import { DeleteManagedSkillTool } from '../tools/skills/delete-managed.js';
-import type { ToolContext } from '../tools/types.js';
+import { DeleteManagedSkillTool } from "../tools/skills/delete-managed.js";
+import type { ToolContext } from "../tools/types.js";
 
- 
-const tool = new (DeleteManagedSkillTool as any)() as InstanceType<typeof DeleteManagedSkillTool>;
+const tool = new (DeleteManagedSkillTool as any)() as InstanceType<
+  typeof DeleteManagedSkillTool
+>;
 
 function makeContext(): ToolContext {
   return {
-    workingDir: '/tmp',
-    sessionId: 'test-session',
-    conversationId: 'test-conversation',
-    guardianTrustClass: 'guardian',
+    workingDir: "/tmp",
+    sessionId: "test-session",
+    conversationId: "test-conversation",
+    guardianTrustClass: "guardian",
   };
 }
 
 function createSkill(id: string): void {
-  const skillDir = join(TEST_DIR, 'skills', id);
+  const skillDir = join(TEST_DIR, "skills", id);
   mkdirSync(skillDir, { recursive: true });
-  writeFileSync(join(skillDir, 'SKILL.md'), '---\nname: "Test"\ndescription: "Test"\n---\n\nBody.\n');
+  writeFileSync(
+    join(skillDir, "SKILL.md"),
+    '---\nname: "Test"\ndescription: "Test"\n---\n\nBody.\n',
+  );
   // Update SKILLS.md
-  const indexPath = join(TEST_DIR, 'skills', 'SKILLS.md');
-  const existing = existsSync(indexPath) ? readFileSync(indexPath, 'utf-8') : '';
+  const indexPath = join(TEST_DIR, "skills", "SKILLS.md");
+  const existing = existsSync(indexPath)
+    ? readFileSync(indexPath, "utf-8")
+    : "";
   writeFileSync(indexPath, existing + `- ${id}\n`);
 }
 
 beforeEach(() => {
-  TEST_DIR = mkdtempSync(join(tmpdir(), 'delete-tool-test-'));
-  mkdirSync(join(TEST_DIR, 'skills'), { recursive: true });
+  TEST_DIR = mkdtempSync(join(tmpdir(), "delete-tool-test-"));
+  mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
 });
 
 afterEach(() => {
   rmSync(TEST_DIR, { recursive: true, force: true });
 });
 
-describe('delete_managed_skill tool', () => {
-  test('deletes existing skill and updates index', async () => {
-    createSkill('doomed');
-    createSkill('survivor');
+describe("delete_managed_skill tool", () => {
+  test("deletes existing skill and updates index", async () => {
+    createSkill("doomed");
+    createSkill("survivor");
 
-    const result = await tool.execute({
-      skill_id: 'doomed',
-    }, makeContext());
+    const result = await tool.execute(
+      {
+        skill_id: "doomed",
+      },
+      makeContext(),
+    );
 
     expect(result.isError).toBe(false);
     const parsed = JSON.parse(result.content);
     expect(parsed.deleted).toBe(true);
-    expect(parsed.skill_id).toBe('doomed');
+    expect(parsed.skill_id).toBe("doomed");
     expect(parsed.index_updated).toBe(true);
 
-    expect(existsSync(join(TEST_DIR, 'skills', 'doomed'))).toBe(false);
+    expect(existsSync(join(TEST_DIR, "skills", "doomed"))).toBe(false);
 
-    const indexContent = readFileSync(join(TEST_DIR, 'skills', 'SKILLS.md'), 'utf-8');
-    expect(indexContent).not.toContain('doomed');
-    expect(indexContent).toContain('survivor');
+    const indexContent = readFileSync(
+      join(TEST_DIR, "skills", "SKILLS.md"),
+      "utf-8",
+    );
+    expect(indexContent).not.toContain("doomed");
+    expect(indexContent).toContain("survivor");
   });
 
-  test('returns error for non-existent skill', async () => {
-    const result = await tool.execute({
-      skill_id: 'ghost',
-    }, makeContext());
+  test("returns error for non-existent skill", async () => {
+    const result = await tool.execute(
+      {
+        skill_id: "ghost",
+      },
+      makeContext(),
+    );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain('not found');
+    expect(result.content).toContain("not found");
   });
 
-  test('rejects missing skill_id', async () => {
+  test("rejects missing skill_id", async () => {
     const result = await tool.execute({}, makeContext());
     expect(result.isError).toBe(true);
-    expect(result.content).toContain('skill_id is required');
+    expect(result.content).toContain("skill_id is required");
   });
 
-  test('rejects invalid skill_id', async () => {
-    const result = await tool.execute({
-      skill_id: '../escape',
-    }, makeContext());
+  test("rejects invalid skill_id", async () => {
+    const result = await tool.execute(
+      {
+        skill_id: "../escape",
+      },
+      makeContext(),
+    );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain('traversal');
+    expect(result.content).toContain("traversal");
   });
 });

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -12,7 +12,6 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------

package/src/__tests__/dictation-mode-detection.test.ts

@@ -1,20 +1,22 @@
-import { describe, expect, test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import { detectDictationModeHeuristic as detectDictationMode } from '../daemon/handlers/dictation.js';
-import type { DictationRequest } from '../daemon/ipc-protocol.js';
+import { detectDictationModeHeuristic as detectDictationMode } from "../daemon/handlers/dictation.js";
+import type { DictationRequest } from "../daemon/ipc-protocol.js";
 
-type DictationRequestOverrides = Omit<Partial<DictationRequest>, 'context'> & {
-  context?: Partial<DictationRequest['context']>;
+type DictationRequestOverrides = Omit<Partial<DictationRequest>, "context"> & {
+  context?: Partial<DictationRequest["context"]>;
 };
 
-function makeRequest(overrides: DictationRequestOverrides = {}): DictationRequest {
+function makeRequest(
+  overrides: DictationRequestOverrides = {},
+): DictationRequest {
   const base: DictationRequest = {
-    type: 'dictation_request',
-    transcription: 'hello there',
+    type: "dictation_request",
+    transcription: "hello there",
     context: {
-      bundleIdentifier: 'com.google.Chrome',
-      appName: 'Google Chrome',
-      windowTitle: 'Inbox - Gmail',
+      bundleIdentifier: "com.google.Chrome",
+      appName: "Google Chrome",
+      windowTitle: "Inbox - Gmail",
       selectedText: undefined,
       cursorInTextField: false,
     },
@@ -29,59 +31,79 @@ function makeRequest(overrides: DictationRequestOverrides = {}): DictationReques
   };
 }
 
-describe('detectDictationMode', () => {
-  test('uses command mode when selected text exists', () => {
-    const mode = detectDictationMode(makeRequest({
-      transcription: 'make this friendlier',
-      context: { selectedText: 'Please send me the files.', cursorInTextField: true },
-    }));
-    expect(mode).toBe('command');
+describe("detectDictationMode", () => {
+  test("uses command mode when selected text exists", () => {
+    const mode = detectDictationMode(
+      makeRequest({
+        transcription: "make this friendlier",
+        context: {
+          selectedText: "Please send me the files.",
+          cursorInTextField: true,
+        },
+      }),
+    );
+    expect(mode).toBe("command");
   });
 
-  test('uses action mode for action-verb utterances', () => {
-    const mode = detectDictationMode(makeRequest({
-      transcription: 'send Alex a follow up',
-      context: { selectedText: undefined, cursorInTextField: false },
-    }));
-    expect(mode).toBe('action');
+  test("uses action mode for action-verb utterances", () => {
+    const mode = detectDictationMode(
+      makeRequest({
+        transcription: "send Alex a follow up",
+        context: { selectedText: undefined, cursorInTextField: false },
+      }),
+    );
+    expect(mode).toBe("action");
   });
 
-  test('uses dictation mode when cursor is in a text field', () => {
-    const mode = detectDictationMode(makeRequest({
-      transcription: 'quick update on status',
-      context: { cursorInTextField: true },
-    }));
-    expect(mode).toBe('dictation');
+  test("uses dictation mode when cursor is in a text field", () => {
+    const mode = detectDictationMode(
+      makeRequest({
+        transcription: "quick update on status",
+        context: { cursorInTextField: true },
+      }),
+    );
+    expect(mode).toBe("dictation");
   });
 
-  test('defaults to dictation when context is ambiguous', () => {
-    const mode = detectDictationMode(makeRequest({
-      transcription: 'just checking in about tomorrow',
-      context: { selectedText: undefined, cursorInTextField: false },
-    }));
-    expect(mode).toBe('dictation');
+  test("defaults to dictation when context is ambiguous", () => {
+    const mode = detectDictationMode(
+      makeRequest({
+        transcription: "just checking in about tomorrow",
+        context: { selectedText: undefined, cursorInTextField: false },
+      }),
+    );
+    expect(mode).toBe("dictation");
   });
 
-  test('profileId does not affect mode detection', () => {
-    const dictation = detectDictationMode(makeRequest({
-      profileId: 'work',
-      transcription: 'hello there',
-      context: { cursorInTextField: true },
-    }));
-    expect(dictation).toBe('dictation');
+  test("profileId does not affect mode detection", () => {
+    const dictation = detectDictationMode(
+      makeRequest({
+        profileId: "work",
+        transcription: "hello there",
+        context: { cursorInTextField: true },
+      }),
+    );
+    expect(dictation).toBe("dictation");
 
-    const command = detectDictationMode(makeRequest({
-      profileId: 'casual',
-      transcription: 'make this shorter',
-      context: { selectedText: 'some long text here', cursorInTextField: true },
-    }));
-    expect(command).toBe('command');
+    const command = detectDictationMode(
+      makeRequest({
+        profileId: "casual",
+        transcription: "make this shorter",
+        context: {
+          selectedText: "some long text here",
+          cursorInTextField: true,
+        },
+      }),
+    );
+    expect(command).toBe("command");
 
-    const action = detectDictationMode(makeRequest({
-      profileId: 'work',
-      transcription: 'send Alex a follow up',
-      context: { selectedText: undefined, cursorInTextField: false },
-    }));
-    expect(action).toBe('action');
+    const action = detectDictationMode(
+      makeRequest({
+        profileId: "work",
+        transcription: "send Alex a follow up",
+        context: { selectedText: undefined, cursorInTextField: false },
+      }),
+    );
+    expect(action).toBe("action");
   });
 });