@vellumai/assistant 0.6.6 → 0.7.0

package/src/__tests__/workspace-migration-acp-sessions-ui.test.ts

@@ -0,0 +1,144 @@
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
+
+import { releaseNotesAcpSessionsUiMigration } from "../workspace/migrations/058-release-notes-acp-sessions-ui.js";
+
+const MIGRATION_ID = "058-release-notes-acp-sessions-ui";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+let testRoot: string;
+let workspaceDir: string;
+
+beforeAll(() => {
+  testRoot = mkdtempSync(join(tmpdir(), "migration-058-test-"));
+});
+
+afterAll(() => {
+  rmSync(testRoot, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(testRoot, "ws-"));
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+});
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+describe("workspace migration 058-release-notes-acp-sessions-ui", () => {
+  test("has the correct id and description", () => {
+    expect(releaseNotesAcpSessionsUiMigration.id).toBe(MIGRATION_ID);
+    expect(releaseNotesAcpSessionsUiMigration.description).toContain(
+      "Coding Agents",
+    );
+  });
+
+  test("creates UPDATES.md with marker and key copy when file is absent", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    releaseNotesAcpSessionsUiMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(MARKER)).toBe(true);
+    expect(content).toContain("Coding Agents");
+    expect(content).toContain("Codex");
+    expect(content).toContain("Claude");
+    expect(content).toContain("Acp Spawn");
+    expect(content).toContain("per-conversation filter");
+    expect(content).toContain("persist across assistant and app restarts");
+    expect(content).toContain("agent_thought_chunk");
+    expect(content).toContain("italic secondary text");
+  });
+
+  test("appends to existing UPDATES.md when marker is absent and preserves existing content", () => {
+    const prior = "## Earlier note\n\nSomething already queued.\n";
+    writeFileSync(updatesPath(), prior, "utf-8");
+
+    releaseNotesAcpSessionsUiMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(prior)).toBe(true);
+    expect(content.slice(prior.length).startsWith(`\n${MARKER}`)).toBe(true);
+    expect(content.split(MARKER).length - 1).toBe(1);
+    expect(content).not.toContain("\n\n\n");
+  });
+
+  test("is a no-op when marker is already present", () => {
+    const seeded = `## Prior\n\n${MARKER}\n## Coding Agents\n\nAlready appended.\n`;
+    writeFileSync(updatesPath(), seeded, "utf-8");
+
+    releaseNotesAcpSessionsUiMigration.run(workspaceDir);
+    const afterFirst = readFileSync(updatesPath(), "utf-8");
+    expect(afterFirst).toBe(seeded);
+
+    releaseNotesAcpSessionsUiMigration.run(workspaceDir);
+    const afterSecond = readFileSync(updatesPath(), "utf-8");
+    expect(afterSecond).toBe(seeded);
+    expect(afterSecond.split(MARKER).length - 1).toBe(1);
+  });
+
+  test("running twice on a fresh workspace appends only once (idempotent)", () => {
+    releaseNotesAcpSessionsUiMigration.run(workspaceDir);
+    const afterFirst = readFileSync(updatesPath(), "utf-8");
+
+    releaseNotesAcpSessionsUiMigration.run(workspaceDir);
+    const afterSecond = readFileSync(updatesPath(), "utf-8");
+
+    expect(afterSecond).toBe(afterFirst);
+    expect(afterSecond.split(MARKER).length - 1).toBe(1);
+  });
+
+  test("re-creates UPDATES.md when it was deleted between runs", () => {
+    releaseNotesAcpSessionsUiMigration.run(workspaceDir);
+    expect(existsSync(updatesPath())).toBe(true);
+
+    rmSync(updatesPath());
+
+    releaseNotesAcpSessionsUiMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(MARKER)).toBe(true);
+    expect(content).toContain("Coding Agents");
+  });
+
+  test("existing UPDATES.md with no trailing newline gets one blank line separator", () => {
+    const prior = "## Prior\n\nBody.";
+    writeFileSync(updatesPath(), prior, "utf-8");
+
+    releaseNotesAcpSessionsUiMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(prior)).toBe(true);
+    expect(content.slice(prior.length).startsWith(`\n\n${MARKER}`)).toBe(true);
+    expect(content).not.toContain("\n\n\n");
+  });
+
+  test("down() is a no-op", () => {
+    writeFileSync(updatesPath(), `${MARKER}\nBody.\n`, "utf-8");
+    const before = readFileSync(updatesPath(), "utf-8");
+
+    releaseNotesAcpSessionsUiMigration.down(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(before);
+  });
+});

package/src/__tests__/workspace-migration-drop-user-md.test.ts

@@ -80,7 +80,7 @@ mock.module("../contacts/contact-store.js", () => ({
 //   db.update(contacts).set({ userFile: slug }).where(eq(contacts.id, guardian.id)).run();
 // The stub captures the payload into `updatedUserFiles` and also mutates
 // the active mock guardian in place so downstream reads observe the new slug.
-mock.module("../memory/db.js", () => ({
+mock.module("../memory/db-connection.js", () => ({
   getDb: () => ({
     update: () => ({
       set: (values: { userFile: string }) => ({

package/src/__tests__/workspace-migration-memory-v2-init.test.ts

@@ -0,0 +1,274 @@
+/**
+ * Tests for workspace migration `060-memory-v2-init`.
+ *
+ * The migration seeds the `memory/` directory tree used by the v2 memory
+ * subsystem: `memory/`, `memory/concepts/`, `memory/archive/`,
+ * `memory/.v2-state/`, plus an empty `edges.json` and the four prose files
+ * (`essentials.md`, `threads.md`, `recent.md`, `buffer.md`). It must be
+ * idempotent and must not touch existing files.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { memoryV2InitMigration } from "../workspace/migrations/060-memory-v2-init.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-060-test-"));
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+/**
+ * Snapshot the (relative path -> mtimeMs, content) for every file inside a
+ * directory so we can assert the migration did not touch existing files.
+ */
+function snapshotTree(
+  root: string,
+): Record<string, { mtimeMs: number; content: string }> {
+  const out: Record<string, { mtimeMs: number; content: string }> = {};
+  function walk(dir: string): void {
+    if (!existsSync(dir)) return;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const abs = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(abs);
+      } else if (entry.isFile()) {
+        const rel = abs.slice(root.length + 1);
+        out[rel] = {
+          mtimeMs: statSync(abs).mtimeMs,
+          content: readFileSync(abs, "utf-8"),
+        };
+      }
+    }
+  }
+  walk(root);
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("060-memory-v2-init migration", () => {
+  test("has correct id and description", () => {
+    expect(memoryV2InitMigration.id).toBe("060-memory-v2-init");
+    expect(memoryV2InitMigration.description).toContain("memory/");
+  });
+
+  // ─── run() ──────────────────────────────────────────────────────────────
+
+  test("seeds the full memory/ tree on a fresh workspace", () => {
+    memoryV2InitMigration.run(workspaceDir);
+
+    const memoryDir = join(workspaceDir, "memory");
+    expect(existsSync(memoryDir)).toBe(true);
+    expect(statSync(memoryDir).isDirectory()).toBe(true);
+
+    expect(statSync(join(memoryDir, "concepts")).isDirectory()).toBe(true);
+    expect(statSync(join(memoryDir, "archive")).isDirectory()).toBe(true);
+    expect(statSync(join(memoryDir, ".v2-state")).isDirectory()).toBe(true);
+
+    // edges.json is seeded with the canonical empty index.
+    const edgesPath = join(memoryDir, "edges.json");
+    expect(existsSync(edgesPath)).toBe(true);
+    const edges = JSON.parse(readFileSync(edgesPath, "utf-8"));
+    expect(edges).toEqual({ version: 1, edges: [] });
+
+    // Each prose file is created and empty.
+    for (const filename of [
+      "essentials.md",
+      "threads.md",
+      "recent.md",
+      "buffer.md",
+    ]) {
+      const filePath = join(memoryDir, filename);
+      expect(existsSync(filePath)).toBe(true);
+      expect(readFileSync(filePath, "utf-8")).toBe("");
+    }
+  });
+
+  test("is idempotent — second run leaves seeded files untouched", () => {
+    memoryV2InitMigration.run(workspaceDir);
+
+    const before = snapshotTree(workspaceDir);
+
+    // Run again and verify nothing was rewritten.
+    memoryV2InitMigration.run(workspaceDir);
+
+    const after = snapshotTree(workspaceDir);
+
+    expect(Object.keys(after).sort()).toEqual(Object.keys(before).sort());
+    for (const [rel, prev] of Object.entries(before)) {
+      expect(after[rel].content).toBe(prev.content);
+      expect(after[rel].mtimeMs).toBe(prev.mtimeMs);
+    }
+  });
+
+  test("preserves an existing edges.json with prior content", () => {
+    const memoryDir = join(workspaceDir, "memory");
+    mkdirSync(memoryDir, { recursive: true });
+
+    const customEdges = {
+      version: 1,
+      edges: [
+        ["alice-preferences", "bob-handoff"],
+        ["bob-handoff", "team-rituals"],
+      ],
+    };
+    const edgesPath = join(memoryDir, "edges.json");
+    writeFileSync(edgesPath, JSON.stringify(customEdges, null, 2), "utf-8");
+
+    memoryV2InitMigration.run(workspaceDir);
+
+    const reread = JSON.parse(readFileSync(edgesPath, "utf-8"));
+    expect(reread).toEqual(customEdges);
+  });
+
+  test("preserves existing prose files with content", () => {
+    const memoryDir = join(workspaceDir, "memory");
+    mkdirSync(memoryDir, { recursive: true });
+
+    const essentials = "Alice's preferred IDE is VS Code.\n";
+    const threads = "Follow up with Bob about the design review.\n";
+    writeFileSync(join(memoryDir, "essentials.md"), essentials, "utf-8");
+    writeFileSync(join(memoryDir, "threads.md"), threads, "utf-8");
+
+    memoryV2InitMigration.run(workspaceDir);
+
+    expect(readFileSync(join(memoryDir, "essentials.md"), "utf-8")).toBe(
+      essentials,
+    );
+    expect(readFileSync(join(memoryDir, "threads.md"), "utf-8")).toBe(threads);
+    // The other two prose files are still seeded as empty.
+    expect(readFileSync(join(memoryDir, "recent.md"), "utf-8")).toBe("");
+    expect(readFileSync(join(memoryDir, "buffer.md"), "utf-8")).toBe("");
+  });
+
+  test("preserves existing concept pages and archive content", () => {
+    const memoryDir = join(workspaceDir, "memory");
+    mkdirSync(join(memoryDir, "concepts"), { recursive: true });
+    mkdirSync(join(memoryDir, "archive"), { recursive: true });
+
+    const conceptPage = "---\nedges: []\nref_files: []\n---\n\n# Alice\n";
+    writeFileSync(
+      join(memoryDir, "concepts", "alice.md"),
+      conceptPage,
+      "utf-8",
+    );
+    const archiveEntry = "Bob mentioned the Q3 roadmap.\n";
+    writeFileSync(
+      join(memoryDir, "archive", "2026-04-01.md"),
+      archiveEntry,
+      "utf-8",
+    );
+
+    memoryV2InitMigration.run(workspaceDir);
+
+    expect(readFileSync(join(memoryDir, "concepts", "alice.md"), "utf-8")).toBe(
+      conceptPage,
+    );
+    expect(
+      readFileSync(join(memoryDir, "archive", "2026-04-01.md"), "utf-8"),
+    ).toBe(archiveEntry);
+  });
+
+  test("does not touch unrelated workspace files", () => {
+    // Pre-populate unrelated workspace files.
+    writeFileSync(
+      join(workspaceDir, "config.json"),
+      JSON.stringify({ hello: "world" }, null, 2),
+      "utf-8",
+    );
+    mkdirSync(join(workspaceDir, "pkb"), { recursive: true });
+    writeFileSync(
+      join(workspaceDir, "pkb", "INDEX.md"),
+      "# Knowledge Base\n",
+      "utf-8",
+    );
+
+    const before = snapshotTree(workspaceDir);
+
+    memoryV2InitMigration.run(workspaceDir);
+
+    const after = snapshotTree(workspaceDir);
+
+    // Everything that existed before should still be there byte-for-byte.
+    for (const [rel, prev] of Object.entries(before)) {
+      expect(after[rel]).toBeDefined();
+      expect(after[rel].content).toBe(prev.content);
+      expect(after[rel].mtimeMs).toBe(prev.mtimeMs);
+    }
+
+    // Only memory/* files should be new.
+    const added = Object.keys(after).filter((rel) => !(rel in before));
+    for (const rel of added) {
+      expect(rel.startsWith("memory/")).toBe(true);
+    }
+  });
+
+  // ─── down() ─────────────────────────────────────────────────────────────
+
+  describe("down()", () => {
+    test("removes memory/.v2-state/ but preserves prose files", () => {
+      memoryV2InitMigration.run(workspaceDir);
+
+      const memoryDir = join(workspaceDir, "memory");
+      // Add a fixture file inside .v2-state to verify recursive removal.
+      writeFileSync(
+        join(memoryDir, ".v2-state", "scratch.json"),
+        "{}",
+        "utf-8",
+      );
+
+      memoryV2InitMigration.down(workspaceDir);
+
+      // .v2-state/ is gone.
+      expect(existsSync(join(memoryDir, ".v2-state"))).toBe(false);
+
+      // Prose files and edges.json remain.
+      expect(existsSync(join(memoryDir, "edges.json"))).toBe(true);
+      expect(existsSync(join(memoryDir, "essentials.md"))).toBe(true);
+      expect(existsSync(join(memoryDir, "threads.md"))).toBe(true);
+      expect(existsSync(join(memoryDir, "recent.md"))).toBe(true);
+      expect(existsSync(join(memoryDir, "buffer.md"))).toBe(true);
+      // concepts/ and archive/ remain.
+      expect(existsSync(join(memoryDir, "concepts"))).toBe(true);
+      expect(existsSync(join(memoryDir, "archive"))).toBe(true);
+    });
+
+    test("idempotent — down() twice does not throw", () => {
+      memoryV2InitMigration.run(workspaceDir);
+      memoryV2InitMigration.down(workspaceDir);
+      memoryV2InitMigration.down(workspaceDir);
+      expect(existsSync(join(workspaceDir, "memory", ".v2-state"))).toBe(false);
+    });
+
+    test("no-op when memory/.v2-state/ does not exist", () => {
+      expect(existsSync(join(workspaceDir, "memory", ".v2-state"))).toBe(false);
+      memoryV2InitMigration.down(workspaceDir);
+      expect(existsSync(join(workspaceDir, "memory", ".v2-state"))).toBe(false);
+    });
+  });
+});

package/src/acp/__tests__/client-handler.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test";
+
+import type { SessionNotification } from "@agentclientprotocol/sdk";
+
+import type { ServerMessage } from "../../daemon/message-protocol.js";
+import { VellumAcpClientHandler } from "../client-handler.js";
+
+const ACP_SESSION_ID = "acp-session-abc";
+const PARENT_CONVERSATION_ID = "conv-xyz";
+
+function makeHandler(): {
+  handler: VellumAcpClientHandler;
+  sent: ServerMessage[];
+} {
+  const sent: ServerMessage[] = [];
+  const handler = new VellumAcpClientHandler(
+    ACP_SESSION_ID,
+    (msg) => {
+      sent.push(msg);
+    },
+    PARENT_CONVERSATION_ID,
+  );
+  return { handler, sent };
+}
+
+describe("VellumAcpClientHandler.sessionUpdate", () => {
+  test("forwards agent_thought_chunk as an acp_session_update", async () => {
+    const { handler, sent } = makeHandler();
+
+    const notification: SessionNotification = {
+      sessionId: ACP_SESSION_ID,
+      update: {
+        sessionUpdate: "agent_thought_chunk",
+        content: { type: "text", text: "internal reasoning here" },
+      },
+    };
+
+    await handler.sessionUpdate(notification);
+
+    expect(sent).toHaveLength(1);
+    expect(sent[0]).toEqual({
+      type: "acp_session_update",
+      acpSessionId: ACP_SESSION_ID,
+      updateType: "agent_thought_chunk",
+      content: "internal reasoning here",
+    });
+  });
+
+  test("agent_thought_chunk does not contribute to accumulated response text", async () => {
+    const { handler } = makeHandler();
+
+    await handler.sessionUpdate({
+      sessionId: ACP_SESSION_ID,
+      update: {
+        sessionUpdate: "agent_thought_chunk",
+        content: { type: "text", text: "thinking..." },
+      },
+    });
+
+    // Thoughts are forwarded for UI display but should not be treated as the
+    // agent's final response text.
+    expect(handler.responseText).toBe("");
+  });
+});

package/src/acp/__tests__/helpers/acp-config-stub.ts

@@ -0,0 +1,62 @@
+/**
+ * Shared test helper: stub `getConfig` from `../config/loader.js` for ACP tests.
+ *
+ * Bun's `mock.module` is process-global and only intercepts the literal keys
+ * the factory returns. ACP test files have all been duplicating the same
+ * mutable `mockAcpConfig` + `mock.module(..., () => ({ getConfig: ... }))`
+ * boilerplate; this helper consolidates it. The real loader's other named
+ * exports are spread into the mock so tests whose code path transitively
+ * imports `loadConfig`, `invalidateConfigCache`, etc. don't fail at parse
+ * time on "Export named 'X' not found".
+ *
+ * Like `which-stub.ts`, this is a process-global hook by design — Bun's
+ * `mock.module` is process-global, so tests can't isolate it per-file.
+ * Each test file should `await installAcpConfigStub()` once at the top
+ * level and drive it via `setConfig(partial)` per test.
+ */
+
+import { mock } from "bun:test";
+
+import type { AcpAgentConfig } from "../../../config/acp-schema.js";
+
+export interface MockAcpConfig {
+  enabled: boolean;
+  maxConcurrentSessions: number;
+  agents: Record<string, AcpAgentConfig>;
+}
+
+const DEFAULT_CONFIG: MockAcpConfig = {
+  enabled: true,
+  maxConcurrentSessions: 4,
+  agents: {},
+};
+
+export interface AcpConfigStubHandle {
+  setConfig(partial: Partial<MockAcpConfig>): void;
+  getCurrent(): MockAcpConfig;
+}
+
+/**
+ * Installs a process-global mock of `getConfig`. The real loader's named
+ * exports are resolved *before* the mock registers so downstream dynamic
+ * imports see the spread version — that's why this returns a Promise the
+ * caller must `await`.
+ */
+export async function installAcpConfigStub(): Promise<AcpConfigStubHandle> {
+  let mockAcpConfig: MockAcpConfig = { ...DEFAULT_CONFIG };
+  const handle: AcpConfigStubHandle = {
+    setConfig(partial) {
+      mockAcpConfig = { ...DEFAULT_CONFIG, ...partial };
+    },
+    getCurrent() {
+      return mockAcpConfig;
+    },
+  };
+
+  const realLoader = await import("../../../config/loader.js");
+  mock.module("../../../config/loader.js", () => ({
+    ...realLoader,
+    getConfig: () => ({ acp: mockAcpConfig }),
+  }));
+  return handle;
+}

package/src/acp/__tests__/helpers/which-stub.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared test helper: stub `Bun.which` for ACP tests.
+ *
+ * `Bun.which` is a process-global. `mock.module` only intercepts ESM module
+ * exports, so it can't touch globals — every ACP test that exercises the
+ * resolver's PATH preflight ends up writing the same boilerplate to swap
+ * `Bun.which` and restore it in `afterAll`. This helper consolidates that
+ * setup. Because the swap is process-global the helper itself is also
+ * process-global: each test file should call `installWhichStub()` once at
+ * the top level, drive it via `setWhich(map)` per test, and call `restore()`
+ * in `afterAll` so the swap doesn't leak into other files.
+ */
+
+type WhichStub = (command: string) => string | null;
+
+/**
+ * Installs a process-global stub for Bun.which. Returns helpers to drive and
+ * restore it.
+ *
+ * `setWhich(map)` updates the stub so each `Bun.which(cmd)` call returns
+ * `map[cmd] ?? null`. The function form lets callers express "every command
+ * resolves" (the default ACP test setup) without enumerating every binary
+ * the resolver might probe.
+ */
+export function installWhichStub(): {
+  setWhich(map: Record<string, string | null>): void;
+  setWhich(fn: WhichStub): void;
+  restore(): void;
+} {
+  const originalWhich = Bun.which;
+  let whichStub: WhichStub = () => null;
+
+  (Bun as unknown as { which: WhichStub }).which = (cmd) => whichStub(cmd);
+
+  function setWhich(arg: Record<string, string | null> | WhichStub): void {
+    whichStub = typeof arg === "function" ? arg : (cmd) => arg[cmd] ?? null;
+  }
+
+  return {
+    setWhich,
+    restore(): void {
+      (Bun as unknown as { which: typeof originalWhich }).which = originalWhich;
+    },
+  };
+}