@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/daemon-credential-client.test.ts

@@ -13,8 +13,13 @@ let _ipcResponse: { ok: boolean; result?: unknown; error?: string } = {
   error: "Could not connect to assistant daemon. Is it running?",
 };
 
+let _lastIpcCall: { method: string; params: unknown } | null = null;
+
 mock.module("../ipc/cli-client.js", () => ({
-  cliIpcCall: async () => _ipcResponse,
+  cliIpcCall: async (method: string, params: unknown) => {
+    _lastIpcCall = { method, params };
+    return _ipcResponse;
+  },
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -120,4 +125,54 @@ describe("daemon credential client", () => {
       expect(result.error).toBeUndefined();
     });
   });
+
+  // Regression: the IPC server registers route handlers by `operationId`
+  // (e.g. `secrets_add`, `secrets_delete`) and unwraps params from
+  // `{ body: ... }`. Earlier versions called `secrets/write` and
+  // `secrets/delete` with un-wrapped params, which the IPC server rejected
+  // with "Unknown method". These tests pin the wire format so it cannot
+  // silently drift again.
+  describe("IPC wire format", () => {
+    test("set uses secrets_add with body-wrapped params", async () => {
+      _ipcResponse = { ok: true, result: { success: true } };
+      _lastIpcCall = null;
+
+      await setSecureKeyViaDaemon(
+        "credential",
+        "github-app:pem",
+        "secret-pem-value",
+      );
+
+      const captured = _lastIpcCall as {
+        method: string;
+        params: unknown;
+      } | null;
+      expect(captured).not.toBeNull();
+      expect(captured?.method).toBe("secrets_add");
+      expect(captured?.params).toEqual({
+        body: {
+          type: "credential",
+          name: "github-app:pem",
+          value: "secret-pem-value",
+        },
+      });
+    });
+
+    test("delete uses secrets_delete with body-wrapped params", async () => {
+      _ipcResponse = { ok: true, result: { success: true } };
+      _lastIpcCall = null;
+
+      await deleteSecureKeyViaDaemon("credential", "github-app:pem");
+
+      const captured = _lastIpcCall as {
+        method: string;
+        params: unknown;
+      } | null;
+      expect(captured).not.toBeNull();
+      expect(captured?.method).toBe("secrets_delete");
+      expect(captured?.params).toEqual({
+        body: { type: "credential", name: "github-app:pem" },
+      });
+    });
+  });
 });

package/src/__tests__/db-activation-state-fk-cascade.test.ts

@@ -0,0 +1,132 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../memory/db-connection.js";
+import { migrateActivationState } from "../memory/migrations/232-activation-state.js";
+import { migrateActivationStateFkCascade } from "../memory/migrations/241-activation-state-fk-cascade.js";
+import * as schema from "../memory/schema.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function bootstrap(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS conversations (id TEXT PRIMARY KEY)
+  `);
+}
+
+function insertActivation(
+  raw: Database,
+  conversationId: string,
+  messageId = "msg-1",
+): void {
+  raw
+    .query(
+      /*sql*/ `INSERT INTO activation_state (conversation_id, message_id, state_json, updated_at) VALUES (?, ?, ?, ?)`,
+    )
+    .run(conversationId, messageId, "{}", 1);
+}
+
+describe("activation_state FK cascade migration", () => {
+  test("rebuilds the table with ON DELETE CASCADE", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(raw);
+
+    migrateActivationState(db);
+    migrateActivationStateFkCascade(db);
+
+    const ddl = raw
+      .query(
+        `SELECT sql FROM sqlite_master WHERE type='table' AND name='activation_state'`,
+      )
+      .get() as { sql: string } | null;
+    expect(ddl?.sql).toContain("REFERENCES conversations(id)");
+    expect(ddl?.sql).toContain("ON DELETE CASCADE");
+  });
+
+  test("deleting a conversation cascades to activation_state", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(raw);
+
+    migrateActivationState(db);
+    migrateActivationStateFkCascade(db);
+
+    raw.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
+    insertActivation(raw, "conv-1");
+
+    raw.query(`DELETE FROM conversations WHERE id = ?`).run("conv-1");
+
+    const remaining = raw
+      .query(`SELECT COUNT(*) AS n FROM activation_state`)
+      .get() as { n: number };
+    expect(remaining.n).toBe(0);
+  });
+
+  test("rebuild purges existing orphan rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(raw);
+
+    migrateActivationState(db);
+
+    raw.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-live");
+    insertActivation(raw, "conv-live");
+    insertActivation(raw, "conv-orphan");
+
+    migrateActivationStateFkCascade(db);
+
+    const rows = raw
+      .query(
+        `SELECT conversation_id FROM activation_state ORDER BY conversation_id`,
+      )
+      .all() as Array<{ conversation_id: string }>;
+    expect(rows.map((r) => r.conversation_id)).toEqual(["conv-live"]);
+  });
+
+  test("is idempotent — second run is a no-op", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(raw);
+
+    migrateActivationState(db);
+    migrateActivationStateFkCascade(db);
+    expect(() => migrateActivationStateFkCascade(db)).not.toThrow();
+
+    const ddl = raw
+      .query(
+        `SELECT sql FROM sqlite_master WHERE type='table' AND name='activation_state'`,
+      )
+      .get() as { sql: string } | null;
+    expect(ddl?.sql).toContain("ON DELETE CASCADE");
+  });
+
+  test("no-ops when activation_state table is absent", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrap(raw);
+
+    expect(() => migrateActivationStateFkCascade(db)).not.toThrow();
+
+    const tableRow = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='activation_state'`,
+      )
+      .get();
+    expect(tableRow).toBeNull();
+  });
+});

package/src/__tests__/db-conversation-inference-profile-migration.test.ts

@@ -18,6 +18,7 @@ import { resetDb } from "../memory/db-connection.js";
 import { getSqliteFrom } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { migrateAddConversationInferenceProfile } from "../memory/migrations/227-add-conversation-inference-profile.js";
+import { migrateRenameInferenceProfileSnakeCase } from "../memory/migrations/228-rename-inference-profile-snake-case.js";
 import * as schema from "../memory/schema.js";
 import { getDbPath } from "../util/platform.js";
 
@@ -208,6 +209,42 @@ describe("conversation inference profile migration", () => {
     expect(row).toEqual({ inferenceProfile: "quality-optimized" });
   });
 
+  test("replaying 227 + 228 across multiple boots does not re-add the camelCase column", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    bootstrapPreInferenceProfileConversations(raw);
+
+    // First boot: 227 adds camelCase, 228 renames to snake_case.
+    migrateAddConversationInferenceProfile(db);
+    migrateRenameInferenceProfileSnakeCase(db);
+    expect(getColumnNames(raw)).toContain("inference_profile");
+    expect(getColumnNames(raw)).not.toContain("inferenceProfile");
+
+    // Second boot: replays must not re-add the camelCase column.
+    migrateAddConversationInferenceProfile(db);
+    migrateRenameInferenceProfileSnakeCase(db);
+    expect(getColumnNames(raw)).toContain("inference_profile");
+    expect(getColumnNames(raw)).not.toContain("inferenceProfile");
+  });
+
+  test("228 self-heals when both columns are present from the legacy bug", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    bootstrapPreInferenceProfileConversations(raw);
+    // Simulate the legacy state: both columns exist because 227 re-added the
+    // camelCase column on a boot after 228 had already renamed it.
+    raw.exec(`ALTER TABLE conversations ADD COLUMN inference_profile TEXT`);
+    raw.exec(`ALTER TABLE conversations ADD COLUMN inferenceProfile TEXT`);
+    expect(getColumnNames(raw)).toContain("inferenceProfile");
+
+    migrateRenameInferenceProfileSnakeCase(db);
+
+    expect(getColumnNames(raw)).toContain("inference_profile");
+    expect(getColumnNames(raw)).not.toContain("inferenceProfile");
+  });
+
   test("new rows default to NULL inferenceProfile after migration", () => {
     const db = createTestDb();
     const raw = getSqliteFrom(db);

package/src/__tests__/db-memory-graph-event-date-repair.test.ts

@@ -28,7 +28,8 @@ function bootstrapTables(raw: Database): void {
     CREATE TABLE memory_graph_nodes (
       id TEXT PRIMARY KEY,
       created INTEGER NOT NULL,
-      event_date INTEGER
+      event_date INTEGER,
+      content TEXT NOT NULL DEFAULT ''
     );
 
     CREATE TABLE memory_graph_triggers (
@@ -59,16 +60,35 @@ describe("repairMemoryGraphEventDate", () => {
     const created = Date.UTC(2026, 3, 26, 5, 23, 20);
     const wrongEventDate = Date.UTC(2025, 3, 19, 2, 32, 0);
 
-    expect(repairMemoryGraphEventDate(created, wrongEventDate)).toBe(
-      Date.UTC(2026, 3, 19, 2, 32, 0),
-    );
+    expect(
+      repairMemoryGraphEventDate(
+        created,
+        wrongEventDate,
+        "Talked about the trip on April 19",
+      ),
+    ).toBe(Date.UTC(2026, 3, 19, 2, 32, 0));
   });
 
   test("leaves distant historical dates alone", () => {
     const created = Date.UTC(2026, 3, 26, 5, 23, 20);
     const historicalEventDate = Date.UTC(2025, 10, 1, 12, 0, 0);
 
-    expect(repairMemoryGraphEventDate(created, historicalEventDate)).toBeNull();
+    expect(
+      repairMemoryGraphEventDate(created, historicalEventDate, ""),
+    ).toBeNull();
+  });
+
+  test("leaves dates alone when content explicitly mentions the prior year", () => {
+    const created = Date.UTC(2026, 3, 26, 5, 23, 20);
+    const explicitHistorical = Date.UTC(2025, 3, 19, 2, 32, 0);
+
+    expect(
+      repairMemoryGraphEventDate(
+        created,
+        explicitHistorical,
+        "User flew on April 19, 2025 to visit family",
+      ),
+    ).toBeNull();
   });
 });
 
@@ -84,21 +104,23 @@ describe("migrate231RepairMemoryGraphEventDates", () => {
     const distantHistoricalDate = Date.UTC(2025, 10, 1, 12, 0, 0);
     const futureDate = Date.UTC(2027, 0, 1, 12, 0, 0);
 
-    raw
-      .prepare(
-        `INSERT INTO memory_graph_nodes (id, created, event_date) VALUES (?, ?, ?)`,
-      )
-      .run("bad-node", created, wrongEventDate);
-    raw
-      .prepare(
-        `INSERT INTO memory_graph_nodes (id, created, event_date) VALUES (?, ?, ?)`,
-      )
-      .run("historical-node", created, distantHistoricalDate);
-    raw
-      .prepare(
-        `INSERT INTO memory_graph_nodes (id, created, event_date) VALUES (?, ?, ?)`,
-      )
-      .run("future-node", created, futureDate);
+    const insertNode = raw.prepare(
+      `INSERT INTO memory_graph_nodes (id, created, event_date, content) VALUES (?, ?, ?, ?)`,
+    );
+    insertNode.run("bad-node", created, wrongEventDate, "Trip on April 19");
+    insertNode.run(
+      "historical-node",
+      created,
+      distantHistoricalDate,
+      "Notes from last fall",
+    );
+    insertNode.run("future-node", created, futureDate, "New Year 2027 plans");
+    insertNode.run(
+      "explicit-year-node",
+      created,
+      wrongEventDate,
+      "User flew on April 19, 2025 to visit family",
+    );
     raw
       .prepare(
         `INSERT INTO memory_graph_triggers (id, node_id, type, event_date) VALUES (?, ?, ?, ?)`,
@@ -112,5 +134,6 @@ describe("migrate231RepairMemoryGraphEventDates", () => {
     expect(triggerEventDateFor(raw, "bad-trigger")).toBe(correctedEventDate);
     expect(eventDateFor(raw, "historical-node")).toBe(distantHistoricalDate);
     expect(eventDateFor(raw, "future-node")).toBe(futureDate);
+    expect(eventDateFor(raw, "explicit-year-node")).toBe(wrongEventDate);
   });
 });

package/src/__tests__/db-proxy-transaction.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Tests for the `db_proxy_transaction` IPC handler.
+ *
+ * Verifies all-or-nothing semantics: every step commits together, any
+ * exception or `requireChanges` violation rolls the entire batch back.
+ *
+ * Uses the real DB (via `initializeDb()`); the test preload points
+ * `VELLUM_WORKSPACE_DIR` at a per-file temp dir.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { handleDbProxyTransaction } from "../ipc/routes/db-proxy-transaction.js";
+import { getSqlite } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { RouteError } from "../runtime/routes/errors.js";
+
+initializeDb();
+
+function resetTestTable(): void {
+  const sqlite = getSqlite();
+  sqlite.exec("DROP TABLE IF EXISTS proxy_tx_test");
+  sqlite.exec(
+    "CREATE TABLE proxy_tx_test (id INTEGER PRIMARY KEY, label TEXT NOT NULL, count INTEGER NOT NULL DEFAULT 0)",
+  );
+}
+
+function rowCount(): number {
+  const result = getSqlite()
+    .prepare("SELECT COUNT(*) AS n FROM proxy_tx_test")
+    .get() as { n: number };
+  return result.n;
+}
+
+describe("db_proxy_transaction", () => {
+  beforeEach(() => {
+    resetTestTable();
+  });
+
+  test("commits multiple inserts atomically", () => {
+    const result = handleDbProxyTransaction({
+      steps: [
+        {
+          sql: "INSERT INTO proxy_tx_test (id, label) VALUES (?, ?)",
+          bind: [1, "alpha"],
+        },
+        {
+          sql: "INSERT INTO proxy_tx_test (id, label) VALUES (?, ?)",
+          bind: [2, "beta"],
+        },
+      ],
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.results).toHaveLength(2);
+      expect(result.results[0].changes).toBe(1);
+      expect(result.results[1].changes).toBe(1);
+    }
+    expect(rowCount()).toBe(2);
+  });
+
+  test("rolls back all writes when a later step throws (SQL constraint)", () => {
+    // Pre-existing row that the transaction will collide with.
+    getSqlite()
+      .prepare("INSERT INTO proxy_tx_test (id, label) VALUES (?, ?)")
+      .run(2, "preexisting");
+
+    let caught: unknown;
+    try {
+      handleDbProxyTransaction({
+        steps: [
+          {
+            sql: "INSERT INTO proxy_tx_test (id, label) VALUES (?, ?)",
+            bind: [1, "alpha"],
+          },
+          // Primary-key collision triggers a SqliteError mid-transaction.
+          {
+            sql: "INSERT INTO proxy_tx_test (id, label) VALUES (?, ?)",
+            bind: [2, "beta"],
+          },
+        ],
+      });
+    } catch (err) {
+      caught = err;
+    }
+
+    // The thrown error must be a RouteError carrying the underlying SQL
+    // message — without the wrapping, the IPC envelope would lose the
+    // statusCode and the gateway-side strict caller would misclassify
+    // this as a transport failure ("assistant may not be ready").
+    expect(caught).toBeInstanceOf(RouteError);
+    if (caught instanceof RouteError) {
+      expect(caught.code).toBe("DB_PROXY_TRANSACTION_FAILED");
+      expect(caught.statusCode).toBe(500);
+      // The original SQL constraint message must survive the wrap so
+      // operators can debug from the gateway logs.
+      expect(caught.message).toMatch(/UNIQUE|PRIMARY KEY|constraint/i);
+    }
+
+    // The first step's insert must NOT have committed.
+    expect(rowCount()).toBe(1);
+    const remaining = getSqlite()
+      .prepare("SELECT label FROM proxy_tx_test WHERE id = ?")
+      .get(2) as { label: string };
+    expect(remaining.label).toBe("preexisting");
+  });
+
+  test("requireChanges aborts the transaction when unmet", () => {
+    // Seed a row to update; condition will not match so changes = 0.
+    getSqlite()
+      .prepare("INSERT INTO proxy_tx_test (id, label, count) VALUES (?, ?, ?)")
+      .run(1, "active", 0);
+
+    const result = handleDbProxyTransaction({
+      steps: [
+        {
+          sql: "INSERT INTO proxy_tx_test (id, label) VALUES (?, ?)",
+          bind: [99, "should-rollback"],
+        },
+        {
+          // No row matches label='nonexistent', so changes = 0.
+          sql: "UPDATE proxy_tx_test SET count = count + 1 WHERE label = ?",
+          bind: ["nonexistent"],
+          requireChanges: 1,
+        },
+      ],
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.reason).toBe("require_changes_failed");
+      expect(result.failedStep).toBe(1);
+      expect(result.actualChanges).toBe(0);
+      expect(result.requiredChanges).toBe(1);
+    }
+
+    // The earlier insert must have rolled back.
+    expect(rowCount()).toBe(1);
+    const remaining = getSqlite()
+      .prepare("SELECT label FROM proxy_tx_test WHERE id = ?")
+      .get(1) as { label: string };
+    expect(remaining.label).toBe("active");
+  });
+
+  test("requireChanges allows the transaction to commit when met", () => {
+    getSqlite()
+      .prepare("INSERT INTO proxy_tx_test (id, label, count) VALUES (?, ?, ?)")
+      .run(1, "active", 0);
+
+    const result = handleDbProxyTransaction({
+      steps: [
+        {
+          sql: "INSERT INTO proxy_tx_test (id, label) VALUES (?, ?)",
+          bind: [2, "new"],
+        },
+        {
+          sql: "UPDATE proxy_tx_test SET count = count + 1 WHERE label = ?",
+          bind: ["active"],
+          requireChanges: 1,
+        },
+      ],
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.results[1].changes).toBe(1);
+    }
+    expect(rowCount()).toBe(2);
+    const updated = getSqlite()
+      .prepare("SELECT count FROM proxy_tx_test WHERE id = ?")
+      .get(1) as { count: number };
+    expect(updated.count).toBe(1);
+  });
+
+  test("rejects empty step list with a 400 RouteError", () => {
+    let caught: unknown;
+    try {
+      handleDbProxyTransaction({ steps: [] });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(RouteError);
+    if (caught instanceof RouteError) {
+      expect(caught.statusCode).toBe(400);
+      expect(caught.code).toBe("INVALID_PARAMS");
+      expect(caught.message).toMatch(/at least one step/);
+    }
+  });
+
+  test("returns lastInsertRowid for inserts", () => {
+    const result = handleDbProxyTransaction({
+      steps: [
+        {
+          sql: "INSERT INTO proxy_tx_test (label) VALUES (?)",
+          bind: ["solo"],
+        },
+      ],
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.results[0].lastInsertRowid).toBeGreaterThan(0);
+    }
+  });
+});