@vellumai/assistant 0.5.1 → 0.5.2

package/src/__tests__/workspace-migration-007-web-search-provider-rename.test.ts

@@ -0,0 +1,312 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { webSearchProviderRenameMigration } from "../workspace/migrations/007-web-search-provider-rename.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-007-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("007-web-search-provider-rename migration", () => {
+  test("renames anthropic-native to inference-provider-native", () => {
+    writeConfig({
+      services: {
+        inference: {
+          mode: "your-own",
+          provider: "anthropic",
+          model: "claude-opus-4-6",
+        },
+        "web-search": {
+          mode: "your-own",
+          provider: "anthropic-native",
+        },
+      },
+    });
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, Record<string, unknown>>;
+    expect(services["web-search"].provider).toBe("inference-provider-native");
+
+    // Other services should be unchanged
+    expect(services.inference.provider).toBe("anthropic");
+    expect(services.inference.model).toBe("claude-opus-4-6");
+  });
+
+  test("no-op when provider is already inference-provider-native", () => {
+    const original = {
+      services: {
+        "web-search": {
+          mode: "your-own",
+          provider: "inference-provider-native",
+        },
+      },
+    };
+    writeConfig(original);
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config).toEqual(original);
+  });
+
+  test("no-op when provider is a different value (e.g. brave)", () => {
+    const original = {
+      services: {
+        "web-search": {
+          mode: "your-own",
+          provider: "brave",
+        },
+      },
+    };
+    writeConfig(original);
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config).toEqual(original);
+  });
+
+  test("no-op when provider is perplexity", () => {
+    const original = {
+      services: {
+        "web-search": {
+          mode: "your-own",
+          provider: "perplexity",
+        },
+      },
+    };
+    writeConfig(original);
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config).toEqual(original);
+  });
+
+  test("no-op when config.json does not exist", () => {
+    webSearchProviderRenameMigration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
+  });
+
+  test("no-op when services key is missing", () => {
+    const original = { someOtherKey: true };
+    writeConfig(original);
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config).toEqual(original);
+  });
+
+  test("no-op when web-search section is missing", () => {
+    const original = {
+      services: {
+        inference: {
+          mode: "your-own",
+          provider: "anthropic",
+          model: "claude-opus-4-6",
+        },
+      },
+    };
+    writeConfig(original);
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config).toEqual(original);
+  });
+
+  test("idempotency: running migration twice produces same result", () => {
+    writeConfig({
+      services: {
+        "web-search": {
+          mode: "your-own",
+          provider: "anthropic-native",
+        },
+      },
+    });
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+    const afterFirst = readConfig();
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+    const afterSecond = readConfig();
+
+    expect(afterSecond).toEqual(afterFirst);
+    const services = afterSecond.services as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect(services["web-search"].provider).toBe("inference-provider-native");
+  });
+
+  test("gracefully handles invalid JSON in config file", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    // File should be unchanged
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("gracefully handles array config", () => {
+    writeFileSync(join(workspaceDir, "config.json"), JSON.stringify([1, 2, 3]));
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    // File should be unchanged
+    const raw = JSON.parse(
+      readFileSync(join(workspaceDir, "config.json"), "utf-8"),
+    );
+    expect(raw).toEqual([1, 2, 3]);
+  });
+
+  test("gracefully handles services as a non-object value", () => {
+    const original = { services: "not-an-object" };
+    writeConfig(original);
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config).toEqual(original);
+  });
+
+  test("gracefully handles web-search as a non-object value", () => {
+    const original = {
+      services: {
+        "web-search": "not-an-object",
+      },
+    };
+    writeConfig(original);
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config).toEqual(original);
+  });
+
+  test("preserves extra fields in web-search config", () => {
+    writeConfig({
+      services: {
+        "web-search": {
+          mode: "your-own",
+          provider: "anthropic-native",
+          extraField: "should-survive",
+        },
+      },
+    });
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const services = config.services as Record<string, Record<string, unknown>>;
+    expect(services["web-search"].provider).toBe("inference-provider-native");
+    expect(services["web-search"].extraField).toBe("should-survive");
+    expect(services["web-search"].mode).toBe("your-own");
+  });
+
+  test("preserves other top-level config keys", () => {
+    writeConfig({
+      someTopLevelKey: "value",
+      services: {
+        inference: {
+          mode: "your-own",
+          provider: "openai",
+          model: "gpt-4o",
+        },
+        "web-search": {
+          mode: "your-own",
+          provider: "anthropic-native",
+        },
+        "custom-service": {
+          foo: "bar",
+        },
+      },
+    });
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config.someTopLevelKey).toBe("value");
+
+    const services = config.services as Record<string, Record<string, unknown>>;
+    expect(services["web-search"].provider).toBe("inference-provider-native");
+    expect(services.inference.provider).toBe("openai");
+    expect(services["custom-service"]).toEqual({ foo: "bar" });
+  });
+
+  test("gracefully handles services as an array", () => {
+    const original = { services: [1, 2, 3] };
+    writeConfig(original);
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config).toEqual(original);
+  });
+
+  test("gracefully handles web-search as an array", () => {
+    const original = {
+      services: {
+        "web-search": [1, 2, 3],
+      },
+    };
+    writeConfig(original);
+
+    webSearchProviderRenameMigration.run(workspaceDir);
+
+    const config = readConfig();
+    expect(config).toEqual(original);
+  });
+});

package/src/__tests__/workspace-migration-009-backfill-conversation-disk-view.test.ts

@@ -0,0 +1,278 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must come before any imports that depend on them
+// ---------------------------------------------------------------------------
+
+const testDir = mkdtempSync(join(tmpdir(), "workspace-migration-009-test-"));
+const workspaceDir = join(testDir, "workspace");
+const conversationsDir = join(workspaceDir, "conversations");
+mkdirSync(conversationsDir, { recursive: true });
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => join(workspaceDir, "data"),
+  getWorkspaceDir: () => workspaceDir,
+  getConversationsDir: () => conversationsDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+  getRootDir: () => testDir,
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
+
+// ---------------------------------------------------------------------------
+// Imports — after mocks
+// ---------------------------------------------------------------------------
+
+import { getConversationDirPath } from "../memory/conversation-disk-view.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import {
+  attachments,
+  conversations,
+  messageAttachments,
+  messages,
+} from "../memory/schema.js";
+import { backfillConversationDiskViewMigration } from "../workspace/migrations/009-backfill-conversation-disk-view.js";
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: true, force: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+function resetConversationsDir() {
+  rmSync(conversationsDir, { recursive: true, force: true });
+  mkdirSync(conversationsDir, { recursive: true });
+}
+
+function seedConversationRows(): {
+  conversationId: string;
+  conversationCreatedAt: number;
+  conversationUpdatedAt: number;
+} {
+  const db = getDb();
+  const conversationId = "conv-009-backfill";
+  const messageId = "msg-009-backfill";
+  const attachmentId = "att-009-backfill";
+  const conversationCreatedAt = Date.parse("2026-03-18T14:23:00.000Z");
+  const messageCreatedAt = Date.parse("2026-03-18T14:24:00.000Z");
+  const conversationUpdatedAt = Date.parse("2026-03-18T14:25:00.000Z");
+
+  db.insert(conversations)
+    .values({
+      id: conversationId,
+      title: "Backfill Test",
+      createdAt: conversationCreatedAt,
+      updatedAt: conversationUpdatedAt,
+      conversationType: "standard",
+      source: "user",
+      memoryScopeId: "default",
+      originChannel: "desktop",
+    })
+    .run();
+
+  db.insert(messages)
+    .values({
+      id: messageId,
+      conversationId,
+      role: "user",
+      content: "Hello from sqlite row",
+      createdAt: messageCreatedAt,
+      metadata: null,
+    })
+    .run();
+
+  db.insert(attachments)
+    .values({
+      id: attachmentId,
+      originalFilename: "note.txt",
+      mimeType: "text/plain",
+      sizeBytes: 11,
+      kind: "document",
+      dataBase64: Buffer.from("hello world").toString("base64"),
+      contentHash: null,
+      thumbnailBase64: null,
+      filePath: null,
+      createdAt: messageCreatedAt,
+    })
+    .run();
+
+  db.insert(messageAttachments)
+    .values({
+      id: "link-009-backfill",
+      messageId,
+      attachmentId,
+      position: 0,
+      createdAt: messageCreatedAt,
+    })
+    .run();
+
+  return { conversationId, conversationCreatedAt, conversationUpdatedAt };
+}
+
+function toConversationTimestamp(createdAtMs: number): string {
+  return new Date(createdAtMs).toISOString().replace(/:/g, "-");
+}
+
+describe("009-backfill-conversation-disk-view migration", () => {
+  beforeEach(() => {
+    resetTables();
+    resetConversationsDir();
+  });
+
+  test("materializes disk view from sqlite-only rows and stays idempotent on rerun", () => {
+    const { conversationId, conversationCreatedAt, conversationUpdatedAt } =
+      seedConversationRows();
+    const conversationDir = getConversationDirPath(
+      conversationId,
+      conversationCreatedAt,
+    );
+    const metaPath = join(conversationDir, "meta.json");
+    const messagesPath = join(conversationDir, "messages.jsonl");
+    const attachmentsDir = join(conversationDir, "attachments");
+
+    // Precondition: only SQLite rows exist, disk view has not been created yet.
+    expect(existsSync(conversationDir)).toBe(false);
+
+    backfillConversationDiskViewMigration.run(workspaceDir);
+
+    expect(existsSync(conversationDir)).toBe(true);
+    expect(existsSync(metaPath)).toBe(true);
+    expect(existsSync(messagesPath)).toBe(true);
+    expect(existsSync(join(attachmentsDir, "note.txt"))).toBe(true);
+
+    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    expect(meta.id).toBe(conversationId);
+    expect(meta.updatedAt).toBe(new Date(conversationUpdatedAt).toISOString());
+
+    const firstRunLines = readFileSync(messagesPath, "utf-8")
+      .trim()
+      .split("\n");
+    expect(firstRunLines).toHaveLength(1);
+    expect(JSON.parse(firstRunLines[0])).toEqual({
+      role: "user",
+      ts: "2026-03-18T14:24:00.000Z",
+      content: "Hello from sqlite row",
+      attachments: ["note.txt"],
+    });
+
+    backfillConversationDiskViewMigration.run(workspaceDir);
+
+    const secondRunLines = readFileSync(messagesPath, "utf-8")
+      .trim()
+      .split("\n");
+    expect(secondRunLines).toHaveLength(1);
+    expect(JSON.parse(secondRunLines[0])).toEqual(JSON.parse(firstRunLines[0]));
+
+    const attachmentFiles = readdirSync(attachmentsDir).sort();
+    expect(attachmentFiles).toEqual(["note.txt"]);
+    expect(readFileSync(join(attachmentsDir, "note.txt"), "utf-8")).toBe(
+      "hello world",
+    );
+  });
+
+  test("rebuilds stale legacy-named disk views in-place and stays idempotent", () => {
+    const { conversationId, conversationCreatedAt, conversationUpdatedAt } =
+      seedConversationRows();
+    const timestamp = toConversationTimestamp(conversationCreatedAt);
+    const expectedNewDirName = `${timestamp}_${conversationId}`;
+    const expectedNewDirPath = join(conversationsDir, expectedNewDirName);
+    const legacyDirPath = join(
+      conversationsDir,
+      `${conversationId}_${timestamp}`,
+    );
+    const metaPath = join(legacyDirPath, "meta.json");
+    const messagesPath = join(legacyDirPath, "messages.jsonl");
+    const attachmentsDir = join(legacyDirPath, "attachments");
+
+    mkdirSync(attachmentsDir, { recursive: true });
+    writeFileSync(
+      metaPath,
+      JSON.stringify(
+        {
+          id: conversationId,
+          title: "Backfill Test",
+          type: "standard",
+          channel: "desktop",
+          createdAt: new Date(conversationCreatedAt).toISOString(),
+          updatedAt: new Date(conversationUpdatedAt - 1000).toISOString(),
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    writeFileSync(messagesPath, '{"role":"user","content":"stale line"}\n');
+    writeFileSync(join(attachmentsDir, "stale.txt"), "stale");
+
+    backfillConversationDiskViewMigration.run(workspaceDir);
+
+    expect(existsSync(expectedNewDirPath)).toBe(false);
+    expect(existsSync(legacyDirPath)).toBe(true);
+    expect(
+      JSON.parse(readFileSync(metaPath, "utf-8")).updatedAt,
+    ).toBe(new Date(conversationUpdatedAt).toISOString());
+    expect(readFileSync(messagesPath, "utf-8").trim().split("\n")).toHaveLength(
+      1,
+    );
+    expect(JSON.parse(readFileSync(messagesPath, "utf-8").trim())).toEqual({
+      role: "user",
+      ts: "2026-03-18T14:24:00.000Z",
+      content: "Hello from sqlite row",
+      attachments: ["note.txt"],
+    });
+    expect(readdirSync(attachmentsDir).sort()).toEqual(["note.txt"]);
+    expect(readFileSync(join(attachmentsDir, "note.txt"), "utf-8")).toBe(
+      "hello world",
+    );
+
+    const firstRunMessages = readFileSync(messagesPath, "utf-8");
+    backfillConversationDiskViewMigration.run(workspaceDir);
+
+    expect(readFileSync(messagesPath, "utf-8")).toBe(firstRunMessages);
+    expect(readdirSync(attachmentsDir).sort()).toEqual(["note.txt"]);
+  });
+});