@vellumai/assistant 0.6.0 → 0.6.1

package/src/__tests__/log-export-workspace.test.ts

@@ -5,8 +5,6 @@
  * - audit-data.json with tool invocation records
  * - daemon-logs/ with log file contents
  * - config-snapshot.json with sanitized config
- * - workspace/ with text files, SQL dumps for .db files, and proper
- *   filtering (excluded directories, binary files, symlinks).
  */
 
 import { spawnSync } from "node:child_process";
@@ -16,7 +14,6 @@ import {
   readdirSync,
   readFileSync,
   rmSync,
-  symlinkSync,
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
@@ -24,8 +21,7 @@ import { join } from "node:path";
 import { describe, expect, mock, test } from "bun:test";
 
 // Set up temp directories before mocking
-const testDir = process.env.VELLUM_WORKSPACE_DIR!;
-const testWorkspaceDir = testDir;
+const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 mkdirSync(testWorkspaceDir, { recursive: true });
 
 mock.module("../util/logger.js", () => ({
@@ -52,11 +48,13 @@ initializeDb();
 const routes = logExportRouteDefinitions();
 const exportRoute = routes.find((r) => r.endpoint === "export")!;
 
-async function callExport(): Promise<Response> {
+async function callExport(
+  body: Record<string, unknown> = {},
+): Promise<Response> {
   const req = new Request("http://localhost/v1/export", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({}),
+    body: JSON.stringify(body),
   });
   const url = new URL(req.url);
   return exportRoute.handler({
@@ -85,73 +83,37 @@ async function extractArchive(res: Response): Promise<string> {
   return extractDir;
 }
 
-/** Recursively lists all files under a directory as relative paths. */
-function listFiles(dir: string, base = dir): string[] {
-  const result: string[] = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      result.push(...listFiles(full, base));
-    } else {
-      result.push(full.slice(base.length + 1));
-    }
-  }
-  return result;
-}
-
 // ---------------------------------------------------------------------------
-// Seed workspace files
+// Seed test data
 // ---------------------------------------------------------------------------
 
-// Text files — should be included
-writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), "# My Identity\nHello");
-mkdirSync(join(testWorkspaceDir, "notes"), { recursive: true });
-writeFileSync(join(testWorkspaceDir, "notes", "daily.txt"), "Some daily notes");
-
-// SQLite DB file — should be dumped as .sql
-mkdirSync(join(testWorkspaceDir, "data", "db"), { recursive: true });
-// Create a real sqlite db with a table
-import { Database } from "bun:sqlite";
-const wsDbPath = join(testWorkspaceDir, "data", "db", "assistant.db");
-const wsDb = new Database(wsDbPath);
-wsDb.run("CREATE TABLE test_table (id INTEGER PRIMARY KEY, name TEXT)");
-wsDb.run("INSERT INTO test_table (name) VALUES ('hello')");
-wsDb.close();
-
-// Excluded directory: embedding-models/
-mkdirSync(join(testWorkspaceDir, "embedding-models"), { recursive: true });
+// config.json at workspace root — needed for config-snapshot test
 writeFileSync(
-  join(testWorkspaceDir, "embedding-models", "model.bin"),
-  "large binary model data",
+  join(testWorkspaceDir, "config.json"),
+  JSON.stringify({ provider: "anthropic" }),
 );
 
-// Excluded directory: data/qdrant/
-mkdirSync(join(testWorkspaceDir, "data", "qdrant"), { recursive: true });
+// Daemon log files — used for date filtering tests
+const logsDir = join(testWorkspaceDir, "data", "logs");
+mkdirSync(logsDir, { recursive: true });
 writeFileSync(
-  join(testWorkspaceDir, "data", "qdrant", "index.bin"),
-  "vector index data",
+  join(logsDir, "assistant-2025-01-10.log"),
+  "log entry from Jan 10\n",
 );
-
-// Binary file — should be skipped
 writeFileSync(
-  join(testWorkspaceDir, "binary-file.dat"),
-  Buffer.from([0x48, 0x65, 0x6c, 0x00, 0x6f]), // contains null byte
+  join(logsDir, "assistant-2025-01-15.log"),
+  "log entry from Jan 15\n",
 );
-
-// config.json at workspace root — should be skipped (already in configSnapshot)
 writeFileSync(
-  join(testWorkspaceDir, "config.json"),
-  JSON.stringify({ provider: "anthropic" }),
+  join(logsDir, "assistant-2025-01-20.log"),
+  "log entry from Jan 20\n",
 );
-
-// Symlink pointing outside workspace — should be skipped
-const outsideFile = join(testDir, "outside-secret.txt");
-writeFileSync(outsideFile, "sensitive data outside workspace");
-try {
-  symlinkSync(outsideFile, join(testWorkspaceDir, "sneaky-link.txt"));
-} catch {
-  // Symlink creation may fail on some platforms; tests will still pass
-}
+writeFileSync(
+  join(logsDir, "assistant-2025-01-25.log"),
+  "log entry from Jan 25\n",
+);
+// Non-dated log file — should always be included regardless of time filter
+writeFileSync(join(logsDir, "vellum.log"), "non-dated log content\n");
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -185,90 +147,95 @@ describe("POST /v1/export — tar.gz archive", () => {
     }
   });
 
-  test("archive contains workspace text files", async () => {
+  test("archive contains config-snapshot.json when config exists", async () => {
     const res = await callExport();
     const dir = await extractArchive(res);
     try {
-      const identity = readFileSync(
-        join(dir, "workspace", "IDENTITY.md"),
-        "utf-8",
-      );
-      expect(identity).toBe("# My Identity\nHello");
-
-      const daily = readFileSync(
-        join(dir, "workspace", "notes", "daily.txt"),
+      const configContent = readFileSync(
+        join(dir, "config-snapshot.json"),
         "utf-8",
       );
-      expect(daily).toBe("Some daily notes");
+      const parsed = JSON.parse(configContent);
+      expect(parsed.provider).toBe("anthropic");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
+});
 
-  test("archive contains SQLite DB dumps as .sql files", async () => {
-    const res = await callExport();
+describe("POST /v1/export — daemon log date filtering", () => {
+  test("excludes log files before startTime", async () => {
+    // startTime = Jan 14 — should exclude assistant-2025-01-10.log
+    const startTime = new Date("2025-01-14T00:00:00.000Z").getTime();
+    const res = await callExport({ startTime });
     const dir = await extractArchive(res);
     try {
-      const sqlContent = readFileSync(
-        join(dir, "workspace", "data", "db", "assistant.db.sql"),
-        "utf-8",
-      );
-      expect(sqlContent).toContain("CREATE TABLE");
-      expect(sqlContent).toContain("test_table");
+      const logFiles = readdirSync(join(dir, "daemon-logs"));
+      expect(logFiles).not.toContain("assistant-2025-01-10.log");
+      expect(logFiles).toContain("assistant-2025-01-15.log");
+      expect(logFiles).toContain("assistant-2025-01-20.log");
+      expect(logFiles).toContain("assistant-2025-01-25.log");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  test("archive excludes embedding-models/ and data/qdrant/", async () => {
-    const res = await callExport();
+  test("excludes log files after endTime", async () => {
+    // endTime = Jan 22 — should exclude assistant-2025-01-25.log
+    const endTime = new Date("2025-01-22T00:00:00.000Z").getTime();
+    const res = await callExport({ endTime });
     const dir = await extractArchive(res);
     try {
-      const files = listFiles(join(dir, "workspace"));
-      const embeddingFiles = files.filter((f) =>
-        f.startsWith("embedding-models/"),
-      );
-      const qdrantFiles = files.filter((f) => f.startsWith("data/qdrant/"));
-      expect(embeddingFiles).toHaveLength(0);
-      expect(qdrantFiles).toHaveLength(0);
+      const logFiles = readdirSync(join(dir, "daemon-logs"));
+      expect(logFiles).toContain("assistant-2025-01-10.log");
+      expect(logFiles).toContain("assistant-2025-01-15.log");
+      expect(logFiles).toContain("assistant-2025-01-20.log");
+      expect(logFiles).not.toContain("assistant-2025-01-25.log");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  test("archive excludes binary files and config.json at workspace root", async () => {
-    const res = await callExport();
+  test("filters log files by both startTime and endTime", async () => {
+    // startTime = Jan 14, endTime = Jan 22 — should only include Jan 15 and Jan 20
+    const startTime = new Date("2025-01-14T00:00:00.000Z").getTime();
+    const endTime = new Date("2025-01-22T00:00:00.000Z").getTime();
+    const res = await callExport({ startTime, endTime });
     const dir = await extractArchive(res);
     try {
-      const files = listFiles(join(dir, "workspace"));
-      expect(files).not.toContain("binary-file.dat");
-      expect(files).not.toContain("config.json");
+      const logFiles = readdirSync(join(dir, "daemon-logs"));
+      expect(logFiles).not.toContain("assistant-2025-01-10.log");
+      expect(logFiles).toContain("assistant-2025-01-15.log");
+      expect(logFiles).toContain("assistant-2025-01-20.log");
+      expect(logFiles).not.toContain("assistant-2025-01-25.log");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  test("archive excludes symlinks", async () => {
-    const res = await callExport();
+  test("always includes non-dated log files regardless of time filter", async () => {
+    const startTime = new Date("2025-01-14T00:00:00.000Z").getTime();
+    const endTime = new Date("2025-01-22T00:00:00.000Z").getTime();
+    const res = await callExport({ startTime, endTime });
     const dir = await extractArchive(res);
     try {
-      const files = listFiles(join(dir, "workspace"));
-      expect(files).not.toContain("sneaky-link.txt");
+      const logFiles = readdirSync(join(dir, "daemon-logs"));
+      expect(logFiles).toContain("vellum.log");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  test("archive contains config-snapshot.json when config exists", async () => {
+  test("includes all log files when no time filter is specified", async () => {
     const res = await callExport();
     const dir = await extractArchive(res);
     try {
-      const configContent = readFileSync(
-        join(dir, "config-snapshot.json"),
-        "utf-8",
-      );
-      const parsed = JSON.parse(configContent);
-      expect(parsed.provider).toBe("anthropic");
+      const logFiles = readdirSync(join(dir, "daemon-logs"));
+      expect(logFiles).toContain("assistant-2025-01-10.log");
+      expect(logFiles).toContain("assistant-2025-01-15.log");
+      expect(logFiles).toContain("assistant-2025-01-20.log");
+      expect(logFiles).toContain("assistant-2025-01-25.log");
+      expect(logFiles).toContain("vellum.log");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }

package/src/__tests__/mcp-abort-signal.test.ts

@@ -7,6 +7,11 @@ mock.module("../security/secure-keys.js", () => ({
   deleteSecureKeyAsync: jest.fn().mockResolvedValue("deleted"),
 }));
 
+// Mock platform-callback-registration (imported by client.ts)
+mock.module("../inbound/platform-callback-registration.js", () => ({
+  shouldUsePlatformCallbacks: jest.fn().mockReturnValue(false),
+}));
+
 const { McpClient } = await import("../mcp/client.js");
 const { McpServerManager } = await import("../mcp/manager.js");
 const { createMcpTool } = await import("../tools/mcp/mcp-tool-factory.js");

package/src/__tests__/mcp-client-auth.test.ts

@@ -7,6 +7,11 @@ mock.module("../security/secure-keys.js", () => ({
   deleteSecureKeyAsync: jest.fn().mockResolvedValue("deleted"),
 }));
 
+// Mock platform-callback-registration (imported by client.ts)
+mock.module("../inbound/platform-callback-registration.js", () => ({
+  shouldUsePlatformCallbacks: jest.fn().mockReturnValue(false),
+}));
+
 const { McpClient } = await import("../mcp/client.js");
 
 /**

package/src/__tests__/memory-recall-log-store.test.ts

@@ -22,6 +22,7 @@ import { getDb, initializeDb } from "../memory/db.js";
 import {
   backfillMemoryRecallLogMessageId,
   getMemoryRecallLogByMessageIds,
+  normalizeTopCandidates,
   recordMemoryRecallLog,
 } from "../memory/memory-recall-log-store.js";
 import { memoryRecallLogs } from "../memory/schema.js";
@@ -61,6 +62,7 @@ describe("memory-recall-log-store", () => {
       topCandidatesJson: [{ id: "c1", score: 0.9 }],
       injectedText: "some memory context",
       reason: "user query matched memories",
+      queryContext: "what is the weather like",
     });
 
     backfillMemoryRecallLogMessageId(conversationId, messageId);
@@ -84,6 +86,34 @@ describe("memory-recall-log-store", () => {
     expect(result!.topCandidates).toEqual([{ id: "c1", score: 0.9 }]);
     expect(result!.injectedText).toBe("some memory context");
     expect(result!.reason).toBe("user query matched memories");
+    expect(result!.queryContext).toBe("what is the weather like");
+  });
+
+  test("queryContext defaults to null when omitted", () => {
+    const conversationId = "conv-no-query-ctx";
+    const messageId = "msg-no-query-ctx";
+
+    recordMemoryRecallLog({
+      conversationId,
+      enabled: true,
+      degraded: false,
+      semanticHits: 1,
+      mergedCount: 1,
+      selectedCount: 1,
+      tier1Count: 1,
+      tier2Count: 0,
+      hybridSearchLatencyMs: 50,
+      sparseVectorUsed: false,
+      injectedTokens: 100,
+      latencyMs: 80,
+      topCandidatesJson: [],
+    });
+
+    backfillMemoryRecallLogMessageId(conversationId, messageId);
+
+    const result = getMemoryRecallLogByMessageIds([messageId]);
+    expect(result).not.toBeNull();
+    expect(result!.queryContext).toBeNull();
   });
 
   test("returns null when no log exists for a messageId", () => {
@@ -148,4 +178,106 @@ describe("memory-recall-log-store", () => {
     expect(secondLog).not.toBeNull();
     expect(secondLog!.degraded).toBe(true);
   });
+
+  test("normalizes SSE-event format candidates to inspector format on read", () => {
+    const conversationId = "conv-normalize-sse";
+    const messageId = "msg-normalize-sse";
+
+    // Store candidates in SSE-event format (key/finalScore/semantic/recency/kind)
+    recordMemoryRecallLog({
+      conversationId,
+      enabled: true,
+      degraded: false,
+      semanticHits: 2,
+      mergedCount: 1,
+      selectedCount: 1,
+      tier1Count: 1,
+      tier2Count: 0,
+      hybridSearchLatencyMs: 100,
+      sparseVectorUsed: false,
+      injectedTokens: 200,
+      latencyMs: 120,
+      topCandidatesJson: [
+        {
+          key: "node-abc",
+          finalScore: 0.85,
+          semantic: 0.9,
+          recency: 0.1,
+          kind: "episode",
+          type: "episodic",
+        },
+      ],
+    });
+
+    backfillMemoryRecallLogMessageId(conversationId, messageId);
+
+    const result = getMemoryRecallLogByMessageIds([messageId]);
+    expect(result).not.toBeNull();
+    const candidates = result!.topCandidates as Array<Record<string, unknown>>;
+    expect(candidates).toHaveLength(1);
+    expect(candidates[0]).toEqual({
+      nodeId: "node-abc",
+      score: 0.85,
+      semanticSimilarity: 0.9,
+      recencyBoost: 0.1,
+      type: "episodic",
+    });
+    // kind should be stripped
+    expect(candidates[0]).not.toHaveProperty("kind");
+    // Old field names should not be present
+    expect(candidates[0]).not.toHaveProperty("key");
+    expect(candidates[0]).not.toHaveProperty("finalScore");
+    expect(candidates[0]).not.toHaveProperty("semantic");
+    expect(candidates[0]).not.toHaveProperty("recency");
+  });
+
+  test("passes through candidates already in inspector format unchanged", () => {
+    const conversationId = "conv-normalize-inspector";
+    const messageId = "msg-normalize-inspector";
+
+    // Store candidates already in inspector format (nodeId/score/semanticSimilarity/recencyBoost)
+    recordMemoryRecallLog({
+      conversationId,
+      enabled: true,
+      degraded: false,
+      semanticHits: 1,
+      mergedCount: 1,
+      selectedCount: 1,
+      tier1Count: 1,
+      tier2Count: 0,
+      hybridSearchLatencyMs: 80,
+      sparseVectorUsed: false,
+      injectedTokens: 100,
+      latencyMs: 90,
+      topCandidatesJson: [
+        {
+          nodeId: "node-xyz",
+          score: 0.92,
+          semanticSimilarity: 0.88,
+          recencyBoost: 0.05,
+          type: "semantic",
+        },
+      ],
+    });
+
+    backfillMemoryRecallLogMessageId(conversationId, messageId);
+
+    const result = getMemoryRecallLogByMessageIds([messageId]);
+    expect(result).not.toBeNull();
+    const candidates = result!.topCandidates as Array<Record<string, unknown>>;
+    expect(candidates).toHaveLength(1);
+    expect(candidates[0]).toEqual({
+      nodeId: "node-xyz",
+      score: 0.92,
+      semanticSimilarity: 0.88,
+      recencyBoost: 0.05,
+      type: "semantic",
+    });
+  });
+
+  test("normalizeTopCandidates handles non-array input", () => {
+    expect(normalizeTopCandidates(null)).toBeNull();
+    expect(normalizeTopCandidates("not-an-array")).toBe("not-an-array");
+    expect(normalizeTopCandidates(42)).toBe(42);
+  });
 });