@vellumai/assistant 0.5.2 → 0.5.4

package/src/__tests__/conversation-switch-memory-reduction.test.ts

@@ -0,0 +1,474 @@
+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";
+
+// ── Test directory & platform mocks ───────────────────────────────
+
+const testDir = mkdtempSync(
+  join(tmpdir(), "conversation-switch-memory-reduction-test-"),
+);
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  getRootDir: () => testDir,
+  getWorkspaceDir: () => join(testDir, "workspace"),
+  getConversationsDir: () => join(testDir, "workspace", "conversations"),
+  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: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ── Config mock ───────────────────────────────────────────────────
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    memory: {
+      simplified: {
+        reducer: {
+          idleDelayMs: 30_000,
+          switchWaitMs: 5_000,
+        },
+      },
+    },
+  }),
+  loadConfig: () => ({
+    memory: {
+      simplified: {
+        reducer: {
+          idleDelayMs: 30_000,
+          switchWaitMs: 5_000,
+        },
+      },
+    },
+  }),
+}));
+
+// ── Suppress disk-view side effects ──────────────────────────────
+
+mock.module("../memory/conversation-disk-view.js", () => ({
+  initConversationDir: () => {},
+  removeConversationDir: () => {},
+  syncMessageToDisk: () => {},
+  updateMetaFile: () => {},
+}));
+
+// ── Suppress indexer side effects ────────────────────────────────
+
+mock.module("../memory/indexer.js", () => ({
+  indexMessageNow: async () => {},
+}));
+
+// ── Suppress attention side effects ──────────────────────────────
+
+mock.module("../memory/conversation-attention-store.js", () => ({
+  projectAssistantMessage: () => {},
+  seedForkedConversationAttention: () => {},
+}));
+
+// ── Mock the reducer ──────────────────────────────────────────────
+
+import type { ReducerPromptInput } from "../memory/reducer.js";
+import type { ReducerResult } from "../memory/reducer-types.js";
+import { EMPTY_REDUCER_RESULT } from "../memory/reducer-types.js";
+
+let mockReducerResult: ReducerResult = EMPTY_REDUCER_RESULT;
+let lastReducerInput: ReducerPromptInput | null = null;
+let reducerCallCount = 0;
+
+mock.module("../memory/reducer.js", () => ({
+  runReducer: async (input: ReducerPromptInput) => {
+    lastReducerInput = input;
+    reducerCallCount++;
+    return mockReducerResult;
+  },
+}));
+
+// ── Imports (after mocks) ─────────────────────────────────────────
+
+import { initializeDb, resetDb } from "../memory/db.js";
+import { getSqlite } from "../memory/db-connection.js";
+import { resetTestTables } from "../memory/raw-query.js";
+import {
+  findMostRecentDirtyConversation,
+  reduceBeforeSwitch,
+} from "../memory/reducer-scheduler.js";
+
+initializeDb();
+
+// ── Helpers ───────────────────────────────────────────────────────
+
+const NOW = 1_700_000_000_000;
+const SCOPE = "default";
+
+function insertConversation(
+  id: string,
+  opts?: {
+    dirtyTailMessageId?: string | null;
+    updatedAt?: number;
+    memoryScopeId?: string;
+    contextSummary?: string;
+  },
+): void {
+  const raw = getSqlite();
+  raw.run(
+    `INSERT INTO conversations (id, title, created_at, updated_at, conversation_type, source, memory_scope_id, is_auto_title,
+       memory_dirty_tail_since_message_id, context_summary)
+     VALUES (?, 'Test', ?, ?, 'standard', 'user', ?, 1, ?, ?)`,
+    [
+      id,
+      NOW,
+      opts?.updatedAt ?? NOW,
+      opts?.memoryScopeId ?? SCOPE,
+      opts?.dirtyTailMessageId ?? null,
+      opts?.contextSummary ?? null,
+    ],
+  );
+}
+
+function insertMessage(opts: {
+  id: string;
+  conversationId: string;
+  role?: string;
+  content?: string;
+  createdAt?: number;
+}): void {
+  const raw = getSqlite();
+  raw.run(
+    `INSERT INTO messages (id, conversation_id, role, content, created_at)
+     VALUES (?, ?, ?, ?, ?)`,
+    [
+      opts.id,
+      opts.conversationId,
+      opts.role ?? "user",
+      opts.content ?? "test message",
+      opts.createdAt ?? NOW,
+    ],
+  );
+}
+
+function getRawConversation(conversationId: string): Record<string, unknown> {
+  const raw = getSqlite();
+  return raw
+    .query(`SELECT * FROM conversations WHERE id = ?`)
+    .get(conversationId) as Record<string, unknown>;
+}
+
+function makeReducerResult(overrides?: Partial<ReducerResult>): ReducerResult {
+  return {
+    timeContexts: [],
+    openLoops: [],
+    archiveObservations: [],
+    archiveEpisodes: [],
+    ...overrides,
+  };
+}
+
+// ── Teardown ──────────────────────────────────────────────────────
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+beforeEach(() => {
+  resetTestTables(
+    "messages",
+    "conversations",
+    "memory_jobs",
+    "time_contexts",
+    "open_loops",
+  );
+  mockReducerResult = EMPTY_REDUCER_RESULT;
+  lastReducerInput = null;
+  reducerCallCount = 0;
+});
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+describe("findMostRecentDirtyConversation", () => {
+  test("returns the most recently updated dirty conversation", () => {
+    insertConversation("conv-old", {
+      dirtyTailMessageId: "msg-old",
+      updatedAt: NOW - 5000,
+    });
+    insertConversation("conv-recent", {
+      dirtyTailMessageId: "msg-recent",
+      updatedAt: NOW,
+    });
+    insertConversation("conv-target", { updatedAt: NOW + 1000 });
+
+    const result = findMostRecentDirtyConversation("conv-target");
+    // Should return the most recently updated dirty conversation (ordered by updatedAt DESC)
+    expect(result).toBe("conv-recent");
+  });
+
+  test("excludes the target conversation", () => {
+    insertConversation("conv-dirty", {
+      dirtyTailMessageId: "msg-1",
+      updatedAt: NOW,
+    });
+
+    const result = findMostRecentDirtyConversation("conv-dirty");
+    expect(result).toBeNull();
+  });
+
+  test("returns null when no dirty conversations exist", () => {
+    insertConversation("conv-clean", { updatedAt: NOW });
+
+    const result = findMostRecentDirtyConversation("conv-target");
+    expect(result).toBeNull();
+  });
+
+  test("returns null when only dirty conversation is the target", () => {
+    insertConversation("conv-target", {
+      dirtyTailMessageId: "msg-1",
+      updatedAt: NOW,
+    });
+    insertConversation("conv-clean", { updatedAt: NOW + 1000 });
+
+    const result = findMostRecentDirtyConversation("conv-target");
+    expect(result).toBeNull();
+  });
+});
+
+describe("reduceBeforeSwitch — conversation switch", () => {
+  test("reduces the dirty conversation before switching", async () => {
+    // Previous conversation with dirty messages
+    insertConversation("conv-prev", {
+      dirtyTailMessageId: "msg-1",
+      updatedAt: NOW,
+    });
+    insertMessage({
+      id: "msg-1",
+      conversationId: "conv-prev",
+      role: "user",
+      content: "Hello",
+      createdAt: NOW,
+    });
+    insertMessage({
+      id: "msg-2",
+      conversationId: "conv-prev",
+      role: "assistant",
+      content: "Hi there!",
+      createdAt: NOW + 1000,
+    });
+
+    // Target conversation
+    insertConversation("conv-target", { updatedAt: NOW + 5000 });
+
+    mockReducerResult = makeReducerResult({
+      openLoops: [
+        {
+          action: "create",
+          summary: "User greeted the assistant",
+          source: "conversation",
+        },
+      ],
+    });
+
+    const result = await reduceBeforeSwitch("conv-target");
+
+    // Should have reduced conv-prev
+    expect(result).toBe("conv-prev");
+    expect(reducerCallCount).toBe(1);
+
+    // Checkpoint should be advanced
+    const conv = getRawConversation("conv-prev");
+    expect(conv.memory_reduced_through_message_id).toBe("msg-2");
+    expect(conv.memory_dirty_tail_since_message_id).toBeNull();
+  });
+
+  test("skips when no eligible dirty conversation exists", async () => {
+    insertConversation("conv-clean", { updatedAt: NOW });
+    insertConversation("conv-target", { updatedAt: NOW + 1000 });
+
+    const result = await reduceBeforeSwitch("conv-target");
+
+    expect(result).toBeNull();
+    expect(reducerCallCount).toBe(0);
+  });
+
+  test("skips when the only dirty conversation is the target", async () => {
+    insertConversation("conv-target", {
+      dirtyTailMessageId: "msg-1",
+      updatedAt: NOW,
+    });
+    insertMessage({ id: "msg-1", conversationId: "conv-target" });
+
+    const result = await reduceBeforeSwitch("conv-target");
+
+    expect(result).toBeNull();
+    expect(reducerCallCount).toBe(0);
+  });
+
+  test("does not advance checkpoint when reducer returns empty result", async () => {
+    insertConversation("conv-prev", {
+      dirtyTailMessageId: "msg-1",
+      updatedAt: NOW,
+    });
+    insertMessage({
+      id: "msg-1",
+      conversationId: "conv-prev",
+      role: "user",
+      content: "Hello",
+      createdAt: NOW,
+    });
+    insertConversation("conv-target", { updatedAt: NOW + 5000 });
+
+    mockReducerResult = EMPTY_REDUCER_RESULT;
+
+    const result = await reduceBeforeSwitch("conv-target");
+
+    // Returns null because empty result means nothing was reduced
+    expect(result).toBeNull();
+
+    // Checkpoint should NOT advance
+    const conv = getRawConversation("conv-prev");
+    expect(conv.memory_reduced_through_message_id).toBeNull();
+    expect(conv.memory_dirty_tail_since_message_id).toBe("msg-1");
+  });
+});
+
+describe("reduceBeforeSwitch — new conversation", () => {
+  test("reduces the previous dirty conversation when starting a new one", async () => {
+    insertConversation("conv-prev", {
+      dirtyTailMessageId: "msg-1",
+      updatedAt: NOW,
+    });
+    insertMessage({
+      id: "msg-1",
+      conversationId: "conv-prev",
+      role: "user",
+      content: "Some prior work",
+      createdAt: NOW,
+    });
+
+    // The new conversation ID (just created)
+    const newConvId = "conv-new";
+    insertConversation(newConvId, { updatedAt: NOW + 5000 });
+
+    mockReducerResult = makeReducerResult({
+      timeContexts: [
+        {
+          action: "create",
+          summary: "Prior work in progress",
+          source: "conversation",
+          activeFrom: NOW,
+          activeUntil: NOW + 7 * 24 * 60 * 60 * 1000,
+        },
+      ],
+    });
+
+    const result = await reduceBeforeSwitch(newConvId);
+
+    expect(result).toBe("conv-prev");
+    expect(reducerCallCount).toBe(1);
+
+    // Verify the previous conversation's checkpoint was advanced
+    const conv = getRawConversation("conv-prev");
+    expect(conv.memory_reduced_through_message_id).toBe("msg-1");
+    expect(conv.memory_dirty_tail_since_message_id).toBeNull();
+  });
+});
+
+describe("reduceBeforeSwitch — most recent dirty selection", () => {
+  test("selects the most recently updated dirty conversation when multiple exist", async () => {
+    // Two dirty conversations — conv-newer is more recently updated
+    insertConversation("conv-older", {
+      dirtyTailMessageId: "msg-older",
+      updatedAt: NOW - 10_000,
+    });
+    insertMessage({
+      id: "msg-older",
+      conversationId: "conv-older",
+      role: "user",
+      content: "Older conversation",
+      createdAt: NOW - 10_000,
+    });
+
+    insertConversation("conv-newer", {
+      dirtyTailMessageId: "msg-newer",
+      updatedAt: NOW,
+    });
+    insertMessage({
+      id: "msg-newer",
+      conversationId: "conv-newer",
+      role: "user",
+      content: "Newer conversation",
+      createdAt: NOW,
+    });
+
+    insertConversation("conv-target", { updatedAt: NOW + 5000 });
+
+    mockReducerResult = makeReducerResult();
+
+    // Even though two are dirty, we only reduce one per switch.
+    // The function picks the most recently updated (by updatedAt DESC).
+    const result = await reduceBeforeSwitch("conv-target");
+
+    // Should pick the most recently updated dirty conversation
+    expect(result).toBe("conv-newer");
+    expect(reducerCallCount).toBe(1);
+    expect(lastReducerInput?.conversationId).toBe("conv-newer");
+  });
+});
+
+describe("reduceBeforeSwitch — error handling", () => {
+  test("returns null and continues when reducer throws", async () => {
+    insertConversation("conv-prev", {
+      dirtyTailMessageId: "msg-1",
+      updatedAt: NOW,
+    });
+    insertMessage({
+      id: "msg-1",
+      conversationId: "conv-prev",
+      role: "user",
+      content: "Hello",
+      createdAt: NOW,
+    });
+    insertConversation("conv-target", { updatedAt: NOW + 5000 });
+
+    // Override mock to throw
+    mock.module("../memory/reducer.js", () => ({
+      runReducer: async () => {
+        reducerCallCount++;
+        throw new Error("Provider timeout");
+      },
+    }));
+
+    const result = await reduceBeforeSwitch("conv-target");
+
+    // Should return null (graceful failure, don't block the switch)
+    expect(result).toBeNull();
+
+    // Checkpoint should NOT advance
+    const conv = getRawConversation("conv-prev");
+    expect(conv.memory_reduced_through_message_id).toBeNull();
+    expect(conv.memory_dirty_tail_since_message_id).toBe("msg-1");
+
+    // Restore normal mock for subsequent tests
+    mock.module("../memory/reducer.js", () => ({
+      runReducer: async (input: ReducerPromptInput) => {
+        lastReducerInput = input;
+        reducerCallCount++;
+        return mockReducerResult;
+      },
+    }));
+  });
+});

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

@@ -26,6 +26,7 @@ mock.module("../util/logger.js", () => ({
 import {
   addMessage,
   createConversation,
+  deleteConversation,
   getConversation,
   getMessages,
   wipeConversation,
@@ -436,3 +437,228 @@ describe("wipeConversation", () => {
     expect(itemBRow).not.toBeNull();
   });
 });
+
+describe("deleteConversation — private scope cleanup", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM conversation_starters`);
+    db.run(`DELETE FROM memory_item_sources`);
+    db.run(`DELETE FROM memory_segments`);
+    db.run(`DELETE FROM memory_items`);
+    db.run(`DELETE FROM memory_summaries`);
+    db.run(`DELETE FROM memory_embeddings`);
+    db.run(`DELETE FROM memory_jobs`);
+    db.run(`DELETE FROM tool_invocations`);
+    db.run(`DELETE FROM llm_request_logs`);
+    db.run(`DELETE FROM messages`);
+    db.run(`DELETE FROM conversations`);
+  });
+
+  test("sourceless items cleaned up", () => {
+    const conv = createConversation({ conversationType: "private" });
+    const scopeId = conv.memoryScopeId;
+    const now = Date.now();
+
+    const raw = (
+      getDb() as unknown as {
+        $client: import("bun:sqlite").Database;
+      }
+    ).$client;
+
+    // Insert a memory item with matching scopeId but no memory_item_sources
+    raw
+      .query(
+        `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
+         VALUES ('priv-item-1', 'active', 'fact', 'test', 'test fact', 0.8, 'fp-priv-1', ?, ?, ?)`,
+      )
+      .run(scopeId, now, now);
+
+    const result = deleteConversation(conv.id);
+
+    // Item should be gone
+    const itemRow = raw
+      .query("SELECT * FROM memory_items WHERE id = 'priv-item-1'")
+      .get();
+    expect(itemRow).toBeNull();
+
+    // Its ID should be in orphanedItemIds
+    expect(result.orphanedItemIds).toContain("priv-item-1");
+  });
+
+  test("summaries cleaned up", () => {
+    const conv = createConversation({ conversationType: "private" });
+    const scopeId = conv.memoryScopeId;
+    const now = Date.now();
+
+    const raw = (
+      getDb() as unknown as {
+        $client: import("bun:sqlite").Database;
+      }
+    ).$client;
+
+    // Insert a memory summary with matching scopeId
+    raw
+      .query(
+        `INSERT INTO memory_summaries (id, scope, scope_key, summary, token_estimate, version, scope_id, start_at, end_at, created_at, updated_at)
+         VALUES ('priv-sum-1', 'global', 'all', 'private summary', 100, 1, ?, ?, ?, ?, ?)`,
+      )
+      .run(scopeId, now, now, now, now);
+
+    const result = deleteConversation(conv.id);
+
+    // Summary should be gone
+    const summaryRow = raw
+      .query("SELECT * FROM memory_summaries WHERE id = 'priv-sum-1'")
+      .get();
+    expect(summaryRow).toBeNull();
+
+    // Its ID should be in deletedSummaryIds
+    expect(result.deletedSummaryIds).toContain("priv-sum-1");
+  });
+
+  test("standard conversations unaffected", async () => {
+    const conv = createConversation("standard test");
+    const now = Date.now();
+
+    const raw = (
+      getDb() as unknown as {
+        $client: import("bun:sqlite").Database;
+      }
+    ).$client;
+
+    // Insert items with scopeId = "default"
+    raw
+      .query(
+        `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
+         VALUES ('default-item-1', 'active', 'fact', 'test', 'test fact', 0.8, 'fp-default', 'default', ?, ?)`,
+      )
+      .run(now, now);
+
+    deleteConversation(conv.id);
+
+    // Default-scope items should still exist
+    const itemRow = raw
+      .query("SELECT * FROM memory_items WHERE id = 'default-item-1'")
+      .get();
+    expect(itemRow).not.toBeNull();
+  });
+
+  test("embeddings cleaned up", () => {
+    const conv = createConversation({ conversationType: "private" });
+    const scopeId = conv.memoryScopeId;
+    const now = Date.now();
+
+    const raw = (
+      getDb() as unknown as {
+        $client: import("bun:sqlite").Database;
+      }
+    ).$client;
+
+    // Insert a memory item with matching scopeId
+    raw
+      .query(
+        `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
+         VALUES ('priv-item-emb', 'active', 'fact', 'test', 'test fact', 0.8, 'fp-priv-emb', ?, ?, ?)`,
+      )
+      .run(scopeId, now, now);
+
+    // Insert a corresponding embedding
+    raw
+      .query(
+        `INSERT INTO memory_embeddings (id, target_type, target_id, provider, model, dimensions, created_at, updated_at)
+         VALUES ('emb-priv-item', 'item', 'priv-item-emb', 'test', 'test', 384, ?, ?)`,
+      )
+      .run(now, now);
+
+    deleteConversation(conv.id);
+
+    // Both item and embedding should be deleted
+    const itemRow = raw
+      .query("SELECT * FROM memory_items WHERE id = 'priv-item-emb'")
+      .get();
+    expect(itemRow).toBeNull();
+
+    const embeddingRow = raw
+      .query("SELECT * FROM memory_embeddings WHERE id = 'emb-priv-item'")
+      .get();
+    expect(embeddingRow).toBeNull();
+  });
+
+  test("conversationStarters cleaned up", () => {
+    const conv = createConversation({ conversationType: "private" });
+    const scopeId = conv.memoryScopeId;
+    const now = Date.now();
+
+    const raw = (
+      getDb() as unknown as {
+        $client: import("bun:sqlite").Database;
+      }
+    ).$client;
+
+    // Insert a conversation_starters row with the private scopeId
+    raw
+      .query(
+        `INSERT INTO conversation_starters (id, label, prompt, generation_batch, scope_id, card_type, created_at)
+         VALUES ('starter-1', 'Test starter', 'Tell me about tests', 1, ?, 'chip', ?)`,
+      )
+      .run(scopeId, now);
+
+    // Also insert a default-scope starter that should NOT be deleted
+    raw
+      .query(
+        `INSERT INTO conversation_starters (id, label, prompt, generation_batch, scope_id, card_type, created_at)
+         VALUES ('starter-default', 'Default starter', 'Hello', 1, 'default', 'chip', ?)`,
+      )
+      .run(now);
+
+    deleteConversation(conv.id);
+
+    // Private-scope starter should be gone
+    const starterRow = raw
+      .query("SELECT * FROM conversation_starters WHERE id = 'starter-1'")
+      .get();
+    expect(starterRow).toBeNull();
+
+    // Default-scope starter should still exist
+    const defaultStarterRow = raw
+      .query("SELECT * FROM conversation_starters WHERE id = 'starter-default'")
+      .get();
+    expect(defaultStarterRow).not.toBeNull();
+  });
+
+  test("no duplicate IDs", async () => {
+    const conv = createConversation({ conversationType: "private" });
+    const scopeId = conv.memoryScopeId;
+    const msg = await addMessage(conv.id, "user", "hello");
+    const now = Date.now();
+
+    const raw = (
+      getDb() as unknown as {
+        $client: import("bun:sqlite").Database;
+      }
+    ).$client;
+
+    // Insert a memory item with the private scopeId AND a source linking to the message
+    raw
+      .query(
+        `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
+         VALUES ('priv-item-dup', 'active', 'fact', 'test', 'test fact', 0.8, 'fp-priv-dup', ?, ?, ?)`,
+      )
+      .run(scopeId, now, now);
+
+    raw
+      .query(
+        `INSERT INTO memory_item_sources (memory_item_id, message_id, created_at) VALUES ('priv-item-dup', ?, ?)`,
+      )
+      .run(msg.id, now);
+
+    const result = deleteConversation(conv.id);
+
+    // The item ID should appear exactly once in orphanedItemIds (caught by
+    // source-based cleanup, not double-counted by scope sweep).
+    const count = result.orphanedItemIds.filter(
+      (id) => id === "priv-item-dup",
+    ).length;
+    expect(count).toBe(1);
+  });
+});