@vellumai/assistant 0.7.1 → 0.7.3

package/src/cli/commands/__tests__/backup.test.ts

@@ -9,7 +9,6 @@
  * or via a commander program (for end-to-end arg parsing).
  */
 
-import { Readable } from "node:stream";
 import {
   afterEach,
   beforeEach,
@@ -130,8 +129,8 @@ let mockDaemonRunning = false;
 const recoveryCallOrder: string[] = [];
 
 /** Number of times each recovery helper was invoked. */
-let mockResetDbCalls = 0;
-let mockInvalidateConfigCacheCalls = 0;
+let _mockResetDbCalls = 0;
+let _mockInvalidateConfigCacheCalls = 0;
 
 /** Log calls captured by the mocked logger. */
 let mockLogInfo: string[] = [];
@@ -167,7 +166,7 @@ mock.module("../../../config/loader.js", () => ({
     backup: getComputedBackupConfig(),
   }),
   invalidateConfigCache: () => {
-    mockInvalidateConfigCacheCalls += 1;
+    _mockInvalidateConfigCacheCalls += 1;
     recoveryCallOrder.push("invalidateConfigCache");
   },
 }));
@@ -178,7 +177,7 @@ mock.module("../../../daemon/daemon-control.js", () => ({
 
 mock.module("../../../memory/db-connection.js", () => ({
   resetDb: () => {
-    mockResetDbCalls += 1;
+    _mockResetDbCalls += 1;
     recoveryCallOrder.push("resetDb");
   },
 }));
@@ -323,9 +322,6 @@ const {
   handleDestinationsList,
   handleStatus,
   handleList,
-  handleCreate,
-  handleVerify,
-  handleRestore,
   registerBackupCommand,
 } = backupMod;
 
@@ -342,8 +338,8 @@ beforeEach(() => {
   mockLogError = [];
   mockCreateShouldThrow = null;
   mockDaemonRunning = false;
-  mockResetDbCalls = 0;
-  mockInvalidateConfigCacheCalls = 0;
+  _mockResetDbCalls = 0;
+  _mockInvalidateConfigCacheCalls = 0;
   recoveryCallOrder.length = 0;
   process.exitCode = 0;
   mockVerifyResult = { valid: true };
@@ -768,273 +764,6 @@ describe("handleList", () => {
 // create
 // ---------------------------------------------------------------------------
 
-describe("handleCreate", () => {
-  test("renders successful snapshot result with empty offsite", async () => {
-    await handleCreate();
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("Created snapshot:");
-    expect(out).toContain("backup-20260411-093000.vbundle");
-    expect(out).toContain("offsite: (none)");
-  });
-
-  test("renders per-destination outcome mix (ok, skipped, error)", async () => {
-    mockCreateSnapshotResult = {
-      ...mockCreateSnapshotResult,
-      offsite: [
-        {
-          destination: { path: "/ok", encrypt: true },
-          entry: {
-            path: "/ok/f.vbundle.enc",
-            filename: "f.vbundle.enc",
-            createdAt: new Date(),
-            sizeBytes: 100,
-            encrypted: true,
-          },
-        },
-        {
-          destination: { path: "/skipped", encrypt: true },
-          entry: null,
-          skipped: "parent-missing",
-        },
-        {
-          destination: { path: "/broken", encrypt: false },
-          entry: null,
-          error: "disk full",
-        },
-      ],
-    };
-    await handleCreate();
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("ok       /ok");
-    expect(out).toContain("skipped  /skipped");
-    expect(out).toContain("error    /broken");
-    expect(out).toContain("disk full");
-  });
-
-  test("concurrency error prints clear message", async () => {
-    mockCreateShouldThrow = new Error("snapshot in progress");
-    await handleCreate();
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) =>
-        m.toLowerCase().includes("already running"),
-      ),
-    ).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// verify
-// ---------------------------------------------------------------------------
-
-describe("handleVerify", () => {
-  test("returns valid result from verifySnapshot", async () => {
-    mockVerifyResult = {
-      valid: true,
-      manifest: {
-        schema_version: "1.0.0",
-        created_at: "2026-04-11T09:30:00Z",
-        source: "backup-worker",
-        files: [],
-        manifest_sha256: "abc",
-      },
-    };
-    await handleVerify("/tmp/local/backup.vbundle");
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("OK:");
-    expect(out).toContain("1.0.0");
-    expect(process.exitCode).toBe(0);
-  });
-
-  test("propagates invalid result with error details", async () => {
-    mockVerifyResult = { valid: false, error: "bad checksum" };
-    await handleVerify("/tmp/local/backup.vbundle");
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("Invalid:")),
-    ).toBe(true);
-    expect(
-      mockLogError.some((m) => m.includes("bad checksum")),
-    ).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// restore
-// ---------------------------------------------------------------------------
-
-/**
- * Replace `process.stdin` with a readable stream that emits the given line.
- * `readline.createInterface` consumes this as a single line so prompt-based
- * confirmation tests stay deterministic.
- */
-function stubStdin(input: string): () => void {
-  const original = process.stdin;
-  const stream = Readable.from([input + "\n"]) as NodeJS.ReadableStream;
-  Object.defineProperty(process, "stdin", {
-    value: stream,
-    writable: true,
-    configurable: true,
-  });
-  return () => {
-    Object.defineProperty(process, "stdin", {
-      value: original,
-      writable: true,
-      configurable: true,
-    });
-  };
-}
-
-describe("handleRestore", () => {
-  test("--yes flag bypasses confirmation and calls restoreFromSnapshot", async () => {
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-    });
-    expect(process.exitCode).toBe(0);
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("Restored from");
-    expect(out).toContain("files restored: 42");
-  });
-
-  test("without --yes and 'n' answer aborts", async () => {
-    const restore = stubStdin("n");
-    try {
-      await handleRestore({
-        path: "/tmp/local/backup-20260411-093000.vbundle",
-      });
-    } finally {
-      restore();
-    }
-    expect(process.exitCode).toBe(0);
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("Restore cancelled");
-  });
-
-  test("without --path and without --latest errors", async () => {
-    await handleRestore({});
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("--path")),
-    ).toBe(true);
-  });
-
-  test("both --path and --latest errors", async () => {
-    await handleRestore({
-      path: "/tmp/x.vbundle",
-      latest: true,
-      yes: true,
-    });
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("Cannot combine")),
-    ).toBe(true);
-  });
-
-  test("--latest with no local snapshots errors", async () => {
-    mockSnapshots["/tmp/local"] = [];
-    await handleRestore({ latest: true, yes: true });
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("No local snapshots")),
-    ).toBe(true);
-  });
-
-  test("--latest picks newest local snapshot", async () => {
-    mockSnapshots["/tmp/local"] = [
-      {
-        path: "/tmp/local/newest.vbundle",
-        filename: "newest.vbundle",
-        createdAt: new Date("2026-04-11T12:00:00Z"),
-        sizeBytes: 1024,
-        encrypted: false,
-      },
-      {
-        path: "/tmp/local/older.vbundle",
-        filename: "older.vbundle",
-        createdAt: new Date("2026-04-10T12:00:00Z"),
-        sizeBytes: 1024,
-        encrypted: false,
-      },
-    ];
-    await handleRestore({ latest: true, yes: true });
-    expect(process.exitCode).toBe(0);
-    expect(mockLogInfo.some((m) => m.includes("newest.vbundle"))).toBe(
-      true,
-    );
-  });
-
-  test("refuses to run while the assistant is running (no --force)", async () => {
-    // Safety gate: the CLI must refuse to restore against a live assistant
-    // unless --force is passed. Restoring under a running assistant is
-    // dangerous — the open SQLite handle, cached config, and cached trust
-    // rules all contradict the on-disk state after the bundle is written.
-    mockDaemonRunning = true;
-
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-    });
-
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) =>
-        m.toLowerCase().includes("assistant is running"),
-      ),
-    ).toBe(true);
-    // restoreFromSnapshot must not have been called — the safety gate
-    // bails before reaching the recovery sequence.
-    expect(mockResetDbCalls).toBe(0);
-    expect(recoveryCallOrder).toEqual([]);
-  });
-
-  test("--force overrides the daemon-running refusal and still runs recovery sequence", async () => {
-    mockDaemonRunning = true;
-
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-      force: true,
-    });
-
-    expect(process.exitCode).toBe(0);
-    // Recovery sequence must still run even with --force — the flag only
-    // overrides the running-assistant refusal, not the DB reset or cache
-    // invalidation.
-    expect(mockResetDbCalls).toBe(1);
-    expect(mockInvalidateConfigCacheCalls).toBe(1);
-    expect(recoveryCallOrder).toEqual([
-      "resetDb",
-      "restoreFromSnapshot",
-      "invalidateConfigCache",    ]);
-  });
-
-  test("successful restore runs resetDb, restore, then cache invalidation in order", async () => {
-    // Regression test for the restore-corrupts-daemon-state gap. The CLI
-    // handler must mirror the HTTP handler's recovery sequence so an
-    // in-process CLI invocation leaves the shared runtime in a consistent
-    // state.
-    mockDaemonRunning = false;
-
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-    });
-
-    expect(process.exitCode).toBe(0);
-    expect(mockResetDbCalls).toBe(1);
-    expect(mockInvalidateConfigCacheCalls).toBe(1);
-    expect(recoveryCallOrder).toEqual([
-      "resetDb",
-      "restoreFromSnapshot",
-      "invalidateConfigCache",    ]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// End-to-end: via Commander program
-// ---------------------------------------------------------------------------
-
 async function runProgram(
   args: string[],
 ): Promise<{ exitCode: number }> {

package/src/cli/commands/__tests__/gateway.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Tests for the `assistant gateway logs tail` CLI command.
+ *
+ * Validates:
+ *   - Default invocation calls IPC with { n: 10 } (no level or module)
+ *   - -n flag changes the line count
+ *   - --level flag forwards the level param
+ *   - --module flag forwards the module param
+ *   - Pretty-print output includes TIME/LEVEL/MODULE/MESSAGE header and entry data
+ *   - -q flag suppresses the header row
+ *   - --raw outputs one JSON object per line, no header
+ *   - Zero results shows "No log entries found."
+ *   - truncated: true shows the footer line
+ *   - IPC failure sets process.exitCode = 1
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+/** All `cliIpcCall` invocations captured for assertions. */
+let ipcCalls: Array<{ method: string; params?: any }> = [];
+
+/**
+ * Queue of responses for cliIpcCall. Each call pops from the front.
+ * When the queue is empty, defaults to { ok: true, result: null }.
+ */
+let mockResponses: Array<{
+  ok: boolean;
+  result?: unknown;
+  error?: string;
+}> = [];
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+mock.module("../../../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    ipcCalls.push({ method, params });
+    return mockResponses.shift() ?? { ok: true, result: null };
+  },
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+  getCliLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+}));
+
+// ---------------------------------------------------------------------------
+// Import module under test (after mocks)
+// ---------------------------------------------------------------------------
+
+const { registerGatewayCommand } = await import("../gateway.js");
+
+// ---------------------------------------------------------------------------
+// Test helper
+// ---------------------------------------------------------------------------
+
+async function runCommand(
+  args: string[],
+): Promise<{ stdout: string; exitCode: number }> {
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const stdoutChunks: string[] = [];
+
+  process.stdout.write = ((chunk: unknown) => {
+    stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+
+  process.exitCode = 0;
+
+  try {
+    const program = new Command();
+    program.exitOverride();
+    program.configureOutput({
+      writeErr: () => {},
+      writeOut: (str: string) => stdoutChunks.push(str),
+    });
+    registerGatewayCommand(program);
+    await program.parseAsync(["node", "assistant", ...args]);
+  } catch {
+    if (process.exitCode === 0) process.exitCode = 1;
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+  }
+
+  const exitCode = process.exitCode ?? 0;
+  process.exitCode = 0;
+
+  return {
+    exitCode,
+    stdout: stdoutChunks.join(""),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makePinoEntry(
+  overrides: Partial<{
+    time: number;
+    level: number;
+    module: string;
+    msg: string;
+  }> = {},
+) {
+  return {
+    time: 1700000000000,
+    level: 30,
+    module: "gateway",
+    msg: "Request handled",
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  ipcCalls = [];
+  mockResponses = [];
+  process.exitCode = 0;
+});
+
+// ---------------------------------------------------------------------------
+// IPC params
+// ---------------------------------------------------------------------------
+
+describe("gateway logs tail — IPC params", () => {
+  test("default (no flags): IPC called with { n: 10 } only — no level or module key", async () => {
+    mockResponses.push({ ok: true, result: { lines: [], truncated: false } });
+
+    await runCommand(["gateway", "logs", "tail"]);
+
+    expect(ipcCalls).toHaveLength(1);
+    expect(ipcCalls[0].method).toBe("gateway_logs_tail");
+    expect(ipcCalls[0].params?.body).toEqual({ n: 10 });
+  });
+
+  test("-n 25: IPC called with { n: 25 }", async () => {
+    mockResponses.push({ ok: true, result: { lines: [], truncated: false } });
+
+    await runCommand(["gateway", "logs", "tail", "-n", "25"]);
+
+    expect(ipcCalls[0].params?.body).toEqual({ n: 25 });
+  });
+
+  test("--level error: IPC called with { n: 10, level: 'error' }", async () => {
+    mockResponses.push({ ok: true, result: { lines: [], truncated: false } });
+
+    await runCommand(["gateway", "logs", "tail", "--level", "error"]);
+
+    expect(ipcCalls[0].params?.body).toEqual({ n: 10, level: "error" });
+  });
+
+  test("--module mcp: IPC called with { n: 10, module: 'mcp' }", async () => {
+    mockResponses.push({ ok: true, result: { lines: [], truncated: false } });
+
+    await runCommand(["gateway", "logs", "tail", "--module", "mcp"]);
+
+    expect(ipcCalls[0].params?.body).toEqual({ n: 10, module: "mcp" });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Pretty-print output
+// ---------------------------------------------------------------------------
+
+describe("gateway logs tail — pretty-print", () => {
+  test("output contains TIME/LEVEL/MODULE/MESSAGE header and entry data", async () => {
+    const entry = makePinoEntry({ msg: "hello world", module: "router" });
+    mockResponses.push({
+      ok: true,
+      result: { lines: [entry], truncated: false },
+    });
+
+    const { stdout } = await runCommand(["gateway", "logs", "tail"]);
+
+    expect(stdout).toContain("TIME");
+    expect(stdout).toContain("LEVEL");
+    expect(stdout).toContain("MODULE");
+    expect(stdout).toContain("MESSAGE");
+    expect(stdout).toContain("hello world");
+    expect(stdout).toContain("router");
+  });
+
+  test("-q flag: stdout does NOT contain header row (TIME absent)", async () => {
+    const entry = makePinoEntry({ msg: "silent entry" });
+    mockResponses.push({
+      ok: true,
+      result: { lines: [entry], truncated: false },
+    });
+
+    const { stdout } = await runCommand(["gateway", "logs", "tail", "-q"]);
+
+    expect(stdout).not.toContain("TIME");
+    expect(stdout).not.toContain("LEVEL");
+    expect(stdout).not.toContain("MODULE");
+    expect(stdout).not.toContain("MESSAGE");
+    expect(stdout).toContain("silent entry");
+  });
+
+  test("zero results: stdout contains 'No log entries found.'", async () => {
+    mockResponses.push({
+      ok: true,
+      result: { lines: [], truncated: false },
+    });
+
+    const { stdout, exitCode } = await runCommand(["gateway", "logs", "tail"]);
+
+    expect(stdout).toContain("No log entries found.");
+    expect(exitCode).toBe(0);
+  });
+
+  test("truncated: true — stdout contains 'earlier entries exist' footer", async () => {
+    const entry = makePinoEntry();
+    mockResponses.push({
+      ok: true,
+      result: { lines: [entry], truncated: true },
+    });
+
+    const { stdout } = await runCommand(["gateway", "logs", "tail"]);
+
+    expect(stdout).toContain("earlier entries exist");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Raw output
+// ---------------------------------------------------------------------------
+
+describe("gateway logs tail — --raw", () => {
+  test("--raw: stdout is valid JSON per line; no header", async () => {
+    const entry = makePinoEntry({ msg: "raw entry" });
+    mockResponses.push({
+      ok: true,
+      result: { lines: [entry], truncated: false },
+    });
+
+    const { stdout } = await runCommand(["gateway", "logs", "tail", "--raw"]);
+
+    // No table header
+    expect(stdout).not.toContain("TIME");
+
+    // Each non-empty line is valid JSON
+    const lines = stdout.split("\n").filter((l) => l.trim() !== "");
+    expect(lines.length).toBeGreaterThan(0);
+    for (const line of lines) {
+      const parsed = JSON.parse(line);
+      expect(parsed).toBeDefined();
+    }
+
+    // The entry data is present
+    const parsed = JSON.parse(lines[0]);
+    expect(parsed.msg).toBe("raw entry");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+
+describe("gateway logs tail — error handling", () => {
+  test("IPC failure sets process.exitCode = 1", async () => {
+    mockResponses.push({ ok: false, error: "daemon not running" });
+
+    const { exitCode } = await runCommand(["gateway", "logs", "tail"]);
+
+    expect(exitCode).toBe(1);
+  });
+});

package/src/cli/commands/__tests__/memory-v2.test.ts

@@ -146,7 +146,10 @@ describe("subcommand registration", () => {
     const subcommandNames = v2!.commands.map((c) => c.name()).sort();
     expect(subcommandNames).toEqual([
       "activation",
+      "explain",
+      "fit-anisotropy",
       "migrate",
+      "rebuild-corpus-stats",
       "reembed",
       "reembed-skills",
       "validate",
@@ -171,6 +174,7 @@ describe("subcommand registration", () => {
     expect(help).toContain("reembed-skills");
     expect(help).toContain("activation");
     expect(help).toContain("validate");
+    expect(help).toContain("explain");
     // rebuild-edges was retired alongside the directed-edges work.
     expect(help).not.toContain("rebuild-edges");
   });

package/src/cli/commands/__tests__/webhooks.test.ts

@@ -14,7 +14,6 @@ let mockPlatformContext: Record<string, unknown> = {
   isPlatform: false,
   platformBaseUrl: "",
   assistantId: "",
-  hasInternalApiKey: false,
   hasAssistantApiKey: false,
   authHeader: null,
   enabled: false,
@@ -80,7 +79,6 @@ mock.module("../../../config/loader.js", () => ({
   }),
   loadConfig: () => ({}),
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
 }));
@@ -129,7 +127,6 @@ function connectedContext(
     isPlatform: false,
     platformBaseUrl: "https://test-platform.vellum.ai",
     assistantId: "019d6d4f-6dbd-779f-91d3-cb273b9429a5",
-    hasInternalApiKey: false,
     hasAssistantApiKey: true,
     authHeader: "Api-Key vak_test123",
     enabled: true,
@@ -146,7 +143,6 @@ describe("assistant webhooks register", () => {
       isPlatform: false,
       platformBaseUrl: "",
       assistantId: "",
-      hasInternalApiKey: false,
       hasAssistantApiKey: false,
       authHeader: null,
       enabled: false,
@@ -467,7 +463,6 @@ describe("assistant webhooks list", () => {
       isPlatform: false,
       platformBaseUrl: "",
       assistantId: "",
-      hasInternalApiKey: false,
       hasAssistantApiKey: false,
       authHeader: null,
       enabled: false,