@vellumai/assistant 0.5.1 → 0.5.3

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"]);
+  });
+});

package/src/__tests__/workspace-migration-010-app-dir-rename.test.ts

@@ -0,0 +1,275 @@
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  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 { appDirRenameMigration } from "../workspace/migrations/010-app-dir-rename.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let workspaceDir: string;
+let appsDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-010-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  appsDir = join(workspaceDir, "data", "apps");
+  mkdirSync(appsDir, { recursive: true });
+}
+
+function writeAppJson(filename: string, data: Record<string, unknown>): void {
+  writeFileSync(join(appsDir, filename), JSON.stringify(data, null, 2));
+}
+
+function readAppJson(filename: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(appsDir, filename), "utf-8"));
+}
+
+function createUuidApp(
+  id: string,
+  name: string,
+  opts?: { preview?: string; indexHtml?: string },
+): void {
+  // JSON file at {id}.json
+  writeAppJson(`${id}.json`, { id, name, schemaJson: "{}" });
+
+  // App directory at {id}/
+  const appDir = join(appsDir, id);
+  mkdirSync(appDir, { recursive: true });
+  writeFileSync(
+    join(appDir, "index.html"),
+    opts?.indexHtml ?? `<h1>${name}</h1>`,
+    "utf-8",
+  );
+
+  // Preview file at {id}.preview
+  if (opts?.preview) {
+    writeFileSync(join(appsDir, `${id}.preview`), opts.preview, "utf-8");
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("010-app-dir-rename migration", () => {
+  test("renames UUID-named app files/dirs to slugified names with dirName in JSON", () => {
+    const id = "aaaaaaaa-1111-2222-3333-444444444444";
+    createUuidApp(id, "My Cool App", { preview: "preview-data" });
+
+    appDirRenameMigration.run(workspaceDir);
+
+    // Old files should be gone
+    expect(existsSync(join(appsDir, `${id}.json`))).toBe(false);
+    expect(existsSync(join(appsDir, id))).toBe(false);
+    expect(existsSync(join(appsDir, `${id}.preview`))).toBe(false);
+
+    // New files should exist
+    expect(existsSync(join(appsDir, "my-cool-app.json"))).toBe(true);
+    expect(existsSync(join(appsDir, "my-cool-app"))).toBe(true);
+    expect(existsSync(join(appsDir, "my-cool-app.preview"))).toBe(true);
+
+    // JSON should have dirName set
+    const json = readAppJson("my-cool-app.json");
+    expect(json.dirName).toBe("my-cool-app");
+    expect(json.id).toBe(id);
+
+    // index.html should be in the new directory
+    expect(
+      readFileSync(join(appsDir, "my-cool-app", "index.html"), "utf-8"),
+    ).toBe("<h1>My Cool App</h1>");
+
+    // Preview content preserved
+    expect(readFileSync(join(appsDir, "my-cool-app.preview"), "utf-8")).toBe(
+      "preview-data",
+    );
+  });
+
+  test("idempotency: running migration again produces no errors or changes", () => {
+    const id = "bbbbbbbb-1111-2222-3333-444444444444";
+    createUuidApp(id, "Idempotent App");
+
+    // Run twice
+    appDirRenameMigration.run(workspaceDir);
+    const jsonAfterFirst = readAppJson("idempotent-app.json");
+
+    appDirRenameMigration.run(workspaceDir);
+    const jsonAfterSecond = readAppJson("idempotent-app.json");
+
+    expect(jsonAfterSecond).toEqual(jsonAfterFirst);
+    expect(existsSync(join(appsDir, "idempotent-app"))).toBe(true);
+  });
+
+  test("partial-rename recovery: JSON has dirName but files still at UUID", () => {
+    const id = "cccccccc-1111-2222-3333-444444444444";
+    const dirName = "partial-app";
+
+    // Simulate crash: JSON was updated with dirName but files weren't renamed
+    writeAppJson(`${id}.json`, {
+      id,
+      name: "Partial App",
+      dirName,
+      schemaJson: "{}",
+    });
+    // Files still at UUID locations
+    mkdirSync(join(appsDir, id), { recursive: true });
+    writeFileSync(join(appsDir, id, "index.html"), "<h1>Partial</h1>", "utf-8");
+    writeFileSync(join(appsDir, `${id}.preview`), "partial-preview", "utf-8");
+
+    appDirRenameMigration.run(workspaceDir);
+
+    // UUID files should be gone, dirName files should exist
+    expect(existsSync(join(appsDir, `${id}.json`))).toBe(false);
+    expect(existsSync(join(appsDir, id))).toBe(false);
+    expect(existsSync(join(appsDir, `${id}.preview`))).toBe(false);
+
+    expect(existsSync(join(appsDir, `${dirName}.json`))).toBe(true);
+    expect(existsSync(join(appsDir, dirName))).toBe(true);
+    expect(existsSync(join(appsDir, `${dirName}.preview`))).toBe(true);
+
+    const json = readAppJson(`${dirName}.json`);
+    expect(json.dirName).toBe(dirName);
+  });
+
+  test("missing directories: JSON exists but no app dir — still sets dirName and renames JSON", () => {
+    const id = "dddddddd-1111-2222-3333-444444444444";
+    // JSON exists but no corresponding directory
+    writeAppJson(`${id}.json`, { id, name: "No Dir App", schemaJson: "{}" });
+
+    appDirRenameMigration.run(workspaceDir);
+
+    // Old JSON gone
+    expect(existsSync(join(appsDir, `${id}.json`))).toBe(false);
+
+    // New JSON and directory created
+    expect(existsSync(join(appsDir, "no-dir-app.json"))).toBe(true);
+    expect(existsSync(join(appsDir, "no-dir-app"))).toBe(true);
+
+    const json = readAppJson("no-dir-app.json");
+    expect(json.dirName).toBe("no-dir-app");
+  });
+
+  test("missing preview files produce no error, JSON and dir still renamed", () => {
+    const id = "eeeeeeee-1111-2222-3333-444444444444";
+    // Create app without preview
+    writeAppJson(`${id}.json`, {
+      id,
+      name: "No Preview",
+      schemaJson: "{}",
+    });
+    mkdirSync(join(appsDir, id), { recursive: true });
+    writeFileSync(
+      join(appsDir, id, "index.html"),
+      "<h1>No Preview</h1>",
+      "utf-8",
+    );
+
+    appDirRenameMigration.run(workspaceDir);
+
+    expect(existsSync(join(appsDir, "no-preview.json"))).toBe(true);
+    expect(existsSync(join(appsDir, "no-preview"))).toBe(true);
+    expect(existsSync(join(appsDir, "no-preview.preview"))).toBe(false);
+  });
+
+  test("duplicate names after slugification get numeric suffixes", () => {
+    const id1 = "ffffffff-1111-2222-3333-444444444444";
+    const id2 = "gggggggg-1111-2222-3333-444444444444";
+    createUuidApp(id1, "Same Name");
+    createUuidApp(id2, "Same Name");
+
+    appDirRenameMigration.run(workspaceDir);
+
+    // Both should exist with deduped names
+    const jsonFiles = readdirSync(appsDir)
+      .filter((f) => f.endsWith(".json"))
+      .sort();
+
+    // One should be "same-name.json", the other "same-name-2.json"
+    expect(jsonFiles).toContain("same-name.json");
+    expect(jsonFiles).toContain("same-name-2.json");
+
+    // Both should have dirName set
+    const json1 = readAppJson("same-name.json");
+    const json2 = readAppJson("same-name-2.json");
+    expect(json1.dirName).toBe("same-name");
+    expect(json2.dirName).toBe("same-name-2");
+
+    // Both directories should exist
+    expect(existsSync(join(appsDir, "same-name"))).toBe(true);
+    expect(existsSync(join(appsDir, "same-name-2"))).toBe(true);
+  });
+
+  test("emoji-only app names get fallback slug", () => {
+    const id = "hhhhhhhh-1111-2222-3333-444444444444";
+    writeAppJson(`${id}.json`, { id, name: "🚀🎉", schemaJson: "{}" });
+    mkdirSync(join(appsDir, id), { recursive: true });
+    writeFileSync(join(appsDir, id, "index.html"), "<h1>Emoji</h1>", "utf-8");
+
+    appDirRenameMigration.run(workspaceDir);
+
+    // Old files should be gone
+    expect(existsSync(join(appsDir, `${id}.json`))).toBe(false);
+
+    // Find the new JSON file (has app- prefix fallback)
+    const jsonFiles = readdirSync(appsDir).filter(
+      (f) => f.endsWith(".json") && f !== `${id}.json`,
+    );
+    expect(jsonFiles.length).toBe(1);
+    expect(jsonFiles[0]).toMatch(/^app-[a-f0-9]{8}\.json$/);
+
+    const json = readAppJson(jsonFiles[0]);
+    expect(json.dirName).toMatch(/^app-[a-f0-9]{8}$/);
+    expect(json.id).toBe(id);
+  });
+
+  test("empty app name falls back to 'untitled' slug", () => {
+    const id = "iiiiiiii-1111-2222-3333-444444444444";
+    // name is absent — migration defaults to "untitled"
+    writeAppJson(`${id}.json`, { id, schemaJson: "{}" });
+    mkdirSync(join(appsDir, id), { recursive: true });
+    writeFileSync(join(appsDir, id, "index.html"), "<h1>No Name</h1>", "utf-8");
+
+    appDirRenameMigration.run(workspaceDir);
+
+    expect(existsSync(join(appsDir, "untitled.json"))).toBe(true);
+    const json = readAppJson("untitled.json");
+    expect(json.dirName).toBe("untitled");
+  });
+
+  test("no-op when apps directory does not exist", () => {
+    // Remove the apps directory
+    rmSync(appsDir, { recursive: true, force: true });
+
+    // Should not throw
+    expect(() => appDirRenameMigration.run(workspaceDir)).not.toThrow();
+  });
+
+  test("no-op when apps directory is empty", () => {
+    expect(() => appDirRenameMigration.run(workspaceDir)).not.toThrow();
+  });
+});

package/src/__tests__/workspace-migration-012-rename-conversation-disk-view-dirs.test.ts

@@ -0,0 +1,77 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { renameConversationDiskViewDirsMigration } from "../workspace/migrations/012-rename-conversation-disk-view-dirs.js";
+
+function freshWorkspace(): { workspaceDir: string; conversationsDir: string } {
+  const workspaceDir = mkdtempSync(
+    join(tmpdir(), `vellum-migration-012-test-${Date.now()}-`),
+  );
+  const conversationsDir = join(workspaceDir, "conversations");
+  mkdirSync(conversationsDir, { recursive: true });
+  return { workspaceDir, conversationsDir };
+}
+
+function legacyConversationDirName(
+  conversationId: string,
+  createdAtMs: number,
+): string {
+  return `${conversationId}_${new Date(createdAtMs).toISOString().replace(/:/g, "-")}`;
+}
+
+describe("012-rename-conversation-disk-view-dirs migration", () => {
+  test("renames legacy conversation directories to timestamp-first names", () => {
+    const { workspaceDir, conversationsDir } = freshWorkspace();
+    try {
+      const createdAt = Date.parse("2026-03-18T14:23:00.000Z");
+      const legacyName = legacyConversationDirName("conv-123", createdAt);
+      const legacyDir = join(conversationsDir, legacyName);
+      mkdirSync(legacyDir, { recursive: true });
+      writeFileSync(join(legacyDir, "meta.json"), "{\"ok\":true}\n", "utf-8");
+
+      renameConversationDiskViewDirsMigration.run(workspaceDir);
+
+      const newName = `2026-03-18T14-23-00.000Z_conv-123`;
+      const newDir = join(conversationsDir, newName);
+      expect(existsSync(legacyDir)).toBe(false);
+      expect(existsSync(newDir)).toBe(true);
+      expect(readFileSync(join(newDir, "meta.json"), "utf-8")).toContain(
+        "\"ok\":true",
+      );
+    } finally {
+      rmSync(workspaceDir, { recursive: true, force: true });
+    }
+  });
+
+  test("is idempotent and ignores non-matching entries", () => {
+    const { workspaceDir, conversationsDir } = freshWorkspace();
+    try {
+      const createdAt = Date.parse("2026-03-18T15:00:00.000Z");
+      const legacyName = legacyConversationDirName("conv-456", createdAt);
+      mkdirSync(join(conversationsDir, legacyName), { recursive: true });
+      mkdirSync(join(conversationsDir, "already-new"), { recursive: true });
+      mkdirSync(join(conversationsDir, "random-folder"), { recursive: true });
+
+      renameConversationDiskViewDirsMigration.run(workspaceDir);
+      renameConversationDiskViewDirsMigration.run(workspaceDir);
+
+      const names = readdirSync(conversationsDir).sort();
+      expect(names).toContain("2026-03-18T15-00-00.000Z_conv-456");
+      expect(names).toContain("already-new");
+      expect(names).toContain("random-folder");
+      expect(names).not.toContain(legacyName);
+    } finally {
+      rmSync(workspaceDir, { recursive: true, force: true });
+    }
+  });
+});