@vellumai/assistant 0.5.0 → 0.5.2

package/src/__tests__/conversation-attachments.test.ts

@@ -55,14 +55,16 @@ mock.module("../permissions/trust-store.js", () => ({
 }));
 
 mock.module("../permissions/types.js", () => ({
+  RiskLevel: {
+    Low: "low",
+    Medium: "medium",
+    High: "high",
+  },
   isAllowDecision: () => true,
 }));
 
 import type { AssistantAttachmentDraft } from "../daemon/assistant-attachments.js";
-import {
-  FILE_BACKED_THRESHOLD_BYTES,
-  getFilePathForAttachment,
-} from "../memory/attachments-store.js";
+import { getFilePathForAttachment } from "../memory/attachments-store.js";
 import { addMessage, createConversation } from "../memory/conversation-crud.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 
@@ -94,13 +96,13 @@ function makeBase64(bytes: number): string {
 }
 
 // ---------------------------------------------------------------------------
-// resolveAssistantAttachments — inline vs file-backed storage
+// resolveAssistantAttachments — all attachments are now file-backed
 // ---------------------------------------------------------------------------
 
 describe("resolveAssistantAttachments", () => {
   beforeEach(resetTables);
 
-  test("attachments under 5 MB are stored inline via uploadAttachment", async () => {
+  test("small attachments are stored on disk via uploadAttachment", async () => {
     const conv = createConversation("test-conv");
     const msg = await addMessage(conv.id, "assistant", "hello");
 
@@ -150,15 +152,17 @@ describe("resolveAssistantAttachments", () => {
     expect(result.emittedAttachments.length).toBe(1);
     const emitted = result.emittedAttachments[0];
     expect(emitted.id).toBeDefined();
-    expect(emitted.data).toBe(dataBase64); // inline — data is present
-    expect(emitted.sizeBytes).toBeUndefined(); // no sizeBytes hint for inline
 
-    // Verify the attachment is in the DB and not file-backed
+    // All attachments are file-backed and have a file on disk
     const filePath = getFilePathForAttachment(emitted.id!);
-    expect(filePath).toBeNull();
+    expect(filePath).not.toBeNull();
+    expect(existsSync(filePath!)).toBe(true);
+
+    // fileBacked flag is always true now
+    expect(emitted.fileBacked).toBe(true);
   });
 
-  test("attachments over 5 MB are stored via uploadFileBackedAttachment with file on disk", async () => {
+  test("large attachments are stored on disk with file path", async () => {
     const conv = createConversation("test-conv-large");
     const msg = await addMessage(conv.id, "assistant", "hello");
 
@@ -207,9 +211,6 @@ describe("resolveAssistantAttachments", () => {
     expect(result.emittedAttachments.length).toBe(1);
     const emitted = result.emittedAttachments[0];
     expect(emitted.id).toBeDefined();
-    // File-backed: data should be empty, sizeBytes should be set
-    expect(emitted.data).toBe("");
-    expect(emitted.sizeBytes).toBe(largeSize);
 
     // Verify the file exists on disk at the expected path
     const filePath = getFilePathForAttachment(emitted.id!);
@@ -217,11 +218,8 @@ describe("resolveAssistantAttachments", () => {
     expect(filePath!).toContain("attachments");
     expect(filePath!).toContain("big-video.mov");
     expect(existsSync(filePath!)).toBe(true);
-  });
-});
 
-describe("FILE_BACKED_THRESHOLD_BYTES", () => {
-  test("is 5 MB", () => {
-    expect(FILE_BACKED_THRESHOLD_BYTES).toBe(5 * 1024 * 1024);
+    // fileBacked flag is always true now
+    expect(emitted.fileBacked).toBe(true);
   });
 });

package/src/__tests__/conversation-disk-view-integration.test.ts

@@ -0,0 +1,277 @@
+/**
+ * Integration tests for the ConversationDiskView lifecycle hooks.
+ *
+ * Verifies that creating, messaging, updating titles, deleting, and clearing
+ * conversations correctly projects to the disk-view filesystem layout.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+} 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(), "conv-disk-view-integration-"));
+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 {
+  linkAttachmentToMessage,
+  uploadAttachment,
+} from "../memory/attachments-store.js";
+import {
+  addMessage,
+  clearAll,
+  createConversation,
+  deleteConversation,
+  updateConversationTitle,
+} from "../memory/conversation-crud.js";
+import {
+  getConversationDirPath,
+  syncMessageToDisk,
+} from "../memory/conversation-disk-view.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: 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 });
+}
+
+// ---------------------------------------------------------------------------
+// Lifecycle integration: createConversation
+// ---------------------------------------------------------------------------
+
+describe("createConversation → disk view", () => {
+  beforeEach(() => {
+    resetTables();
+    resetConversationsDir();
+  });
+
+  test("creates directory and meta.json on createConversation", () => {
+    const conv = createConversation("My Conversation");
+
+    const dirPath = getConversationDirPath(conv.id, conv.createdAt);
+    expect(existsSync(dirPath)).toBe(true);
+    expect(readdirSync(conversationsDir)).toEqual([
+      `${new Date(conv.createdAt).toISOString().replace(/:/g, "-")}_${conv.id}`,
+    ]);
+
+    const metaPath = join(dirPath, "meta.json");
+    expect(existsSync(metaPath)).toBe(true);
+
+    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    expect(meta.id).toBe(conv.id);
+    expect(meta.title).toBe("My Conversation");
+    expect(meta.type).toBe("standard");
+    expect(meta.createdAt).toBe(new Date(conv.createdAt).toISOString());
+  });
+
+  test("handles null title in createConversation", () => {
+    const conv = createConversation();
+
+    const dirPath = getConversationDirPath(conv.id, conv.createdAt);
+    const meta = JSON.parse(readFileSync(join(dirPath, "meta.json"), "utf-8"));
+    expect(meta.title).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Lifecycle integration: addMessage + syncMessageToDisk
+// ---------------------------------------------------------------------------
+
+describe("addMessage + syncMessageToDisk → disk view", () => {
+  beforeEach(() => {
+    resetTables();
+    resetConversationsDir();
+  });
+
+  test("appends JSONL line for a text message", async () => {
+    const conv = createConversation("Msg Test");
+
+    const msg = await addMessage(conv.id, "user", "Hello world", undefined, {
+      skipIndexing: true,
+    });
+
+    syncMessageToDisk(conv.id, msg.id, conv.createdAt);
+
+    const dirPath = getConversationDirPath(conv.id, conv.createdAt);
+    const jsonlPath = join(dirPath, "messages.jsonl");
+    expect(existsSync(jsonlPath)).toBe(true);
+
+    const lines = readFileSync(jsonlPath, "utf-8").trim().split("\n");
+    expect(lines).toHaveLength(1);
+
+    const record = JSON.parse(lines[0]);
+    expect(record.role).toBe("user");
+    expect(record.content).toBe("Hello world");
+    expect(record.ts).toBeDefined();
+  });
+
+  test("message with attachment copies file and includes in JSONL", async () => {
+    const conv = createConversation("Attach Test");
+
+    const msg = await addMessage(conv.id, "user", "See attached", undefined, {
+      skipIndexing: true,
+    });
+
+    const att = uploadAttachment("screenshot.png", "image/png", "iVBORw0K");
+    linkAttachmentToMessage(msg.id, att.id, 0);
+
+    syncMessageToDisk(conv.id, msg.id, conv.createdAt);
+
+    const dirPath = getConversationDirPath(conv.id, conv.createdAt);
+
+    // Attachment file exists in attachments/ subdirectory
+    const attachDir = join(dirPath, "attachments");
+    expect(existsSync(join(attachDir, "screenshot.png"))).toBe(true);
+
+    // JSONL references the attachment
+    const lines = readFileSync(join(dirPath, "messages.jsonl"), "utf-8")
+      .trim()
+      .split("\n");
+    const record = JSON.parse(lines[0]);
+    expect(record.attachments).toEqual(["screenshot.png"]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Lifecycle integration: updateConversationTitle
+// ---------------------------------------------------------------------------
+
+describe("updateConversationTitle → disk view", () => {
+  beforeEach(() => {
+    resetTables();
+    resetConversationsDir();
+  });
+
+  test("rewrites meta.json with new title", () => {
+    const conv = createConversation("Original Title");
+    const dirPath = getConversationDirPath(conv.id, conv.createdAt);
+
+    // Verify original
+    let meta = JSON.parse(readFileSync(join(dirPath, "meta.json"), "utf-8"));
+    expect(meta.title).toBe("Original Title");
+
+    // Update
+    updateConversationTitle(conv.id, "New Title");
+
+    // Verify updated
+    meta = JSON.parse(readFileSync(join(dirPath, "meta.json"), "utf-8"));
+    expect(meta.title).toBe("New Title");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Lifecycle integration: deleteConversation
+// ---------------------------------------------------------------------------
+
+describe("deleteConversation → disk view", () => {
+  beforeEach(() => {
+    resetTables();
+    resetConversationsDir();
+  });
+
+  test("removes conversation directory on delete", () => {
+    const conv = createConversation("To Delete");
+    const dirPath = getConversationDirPath(conv.id, conv.createdAt);
+    expect(existsSync(dirPath)).toBe(true);
+
+    deleteConversation(conv.id);
+
+    expect(existsSync(dirPath)).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Lifecycle integration: clearAll
+// ---------------------------------------------------------------------------
+
+describe("clearAll → disk view", () => {
+  beforeEach(() => {
+    resetTables();
+    resetConversationsDir();
+  });
+
+  test("empties the conversations directory", () => {
+    // Create two conversations
+    createConversation("Conv A");
+    createConversation("Conv B");
+
+    // Verify directories exist
+    const entries = readdirSync(conversationsDir);
+    expect(entries.length).toBe(2);
+
+    // Clear all
+    clearAll();
+
+    // Conversations directory should exist but be empty
+    expect(existsSync(conversationsDir)).toBe(true);
+    const afterEntries = readdirSync(conversationsDir);
+    expect(afterEntries.length).toBe(0);
+  });
+});