@vellumai/assistant 0.8.0 → 0.8.2

package/src/heartbeat/__tests__/heartbeat-feed-event.test.ts

@@ -1,233 +0,0 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-let workspaceDir: string;
-
-// Stub the heartbeat run store so HeartbeatService doesn't hit the real DB.
-mock.module("../heartbeat-run-store.js", () => ({
-  insertPendingHeartbeatRun: () => "mock-run-id",
-  startHeartbeatRun: () => true,
-  completeHeartbeatRun: () => true,
-  skipHeartbeatRun: () => true,
-  supersedePendingRun: () => true,
-  markStaleRunsAsMissed: () => 0,
-  markStaleRunningAsError: () => 0,
-  listHeartbeatRuns: () => [],
-  countCompletedHeartbeatRuns: () => 10,
-}));
-
-// Stub the in-process SSE hub so the writer's publish path is a
-// no-op in these tests.
-const publishSpy = mock<(event: unknown) => Promise<void>>(async () => {});
-
-mock.module("../../runtime/assistant-event-hub.js", () => ({
-  assistantEventHub: {
-    publish: publishSpy,
-    subscribe: () => () => {},
-  },
-  broadcastMessage: () => {},
-}));
-
-// Stub workspace prompt reads so the heartbeat service doesn't try to
-// read real workspace files. Use a fallback for early module-load calls
-// (e.g. AuthSessionCache constructor) before beforeEach sets workspaceDir.
-const fallbackDir = join(tmpdir(), "vellum-hb-feed-fallback");
-mock.module("../../util/platform.js", () => ({
-  getWorkspaceDir: () => workspaceDir ?? fallbackDir,
-  getWorkspacePromptPath: (name: string) =>
-    join(workspaceDir ?? fallbackDir, name),
-  vellumRoot: () => workspaceDir ?? fallbackDir,
-  getDataDir: () => join(workspaceDir ?? fallbackDir, "data"),
-  getConversationsDir: () => join(workspaceDir ?? fallbackDir, "conversations"),
-  isMacOS: () => false,
-  isLinux: () => true,
-  isWindows: () => false,
-  getPlatformName: () => "linux",
-  normalizeAssistantId: (id: string) => id,
-  getEmbeddingModelsDir: () => join(workspaceDir ?? fallbackDir, "models"),
-  getSandboxRootDir: () => join(workspaceDir ?? fallbackDir, "sandbox"),
-  getSandboxWorkingDir: () => join(workspaceDir ?? fallbackDir, "sandbox/work"),
-  getInterfacesDir: () => join(workspaceDir ?? fallbackDir, "interfaces"),
-  getSoundsDir: () => join(workspaceDir ?? fallbackDir, "sounds"),
-  getAvatarDir: () => join(workspaceDir ?? fallbackDir, "avatar"),
-  AVATAR_IMAGE_FILENAME: "avatar-image.png",
-  getAvatarImagePath: () =>
-    join(workspaceDir ?? fallbackDir, "avatar/avatar-image.png"),
-
-  getXdgVellumConfigDirName: () => ".vellum",
-}));
-
-// Stub config so heartbeat is enabled. Must export every symbol from
-// the real module because Bun's mock.module replaces the entire module.
-const stubConfig = {
-  heartbeat: {
-    enabled: true,
-    intervalMs: 60_000,
-    activeHoursStart: null,
-    activeHoursEnd: null,
-  },
-};
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => stubConfig,
-  getConfigReadOnly: () => stubConfig,
-  loadConfig: () => stubConfig,
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  applyNestedDefaults: (c: unknown) => c,
-  deepMergeOverwrite: (a: unknown) => a,
-  mergeDefaultWorkspaceConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  API_KEY_PROVIDERS: [],
-  _appendQuarantineBulletin: () => {},
-}));
-
-// Stub conversation bootstrap.
-const lastConversationId = "conv-heartbeat-test";
-mock.module("../../memory/conversation-bootstrap.js", () => ({
-  bootstrapConversation: () => ({ id: lastConversationId }),
-}));
-
-// Stub prompt helpers.
-mock.module("../../prompts/persona-resolver.js", () => ({
-  GUARDIAN_PERSONA_TEMPLATE: "",
-  resolveGuardianPersona: () => null,
-  resolveGuardianPersonaPath: () => null,
-  resolveGuardianPersonaStrict: () => null,
-  isGuardianPersonaCustomized: () => false,
-  resolveUserSlug: () => null,
-  resolveUserPersona: () => null,
-  resolveChannelPersona: () => null,
-  resolvePersonaContext: () => ({}),
-  ensureGuardianPersonaFile: () => {},
-}));
-mock.module("../../prompts/system-prompt.js", () => ({
-  isTemplateContent: () => false,
-  SYSTEM_PROMPT_CACHE_BOUNDARY: "<<CACHE_BOUNDARY>>",
-  buildCoreIdentityContext: () => "",
-  buildSystemPrompt: () => "",
-  buildCliReferenceSection: () => "",
-  ensurePromptFiles: () => {},
-  stripCommentLines: (s: string) => s,
-  readPromptFile: () => null,
-}));
-
-// Mock processMessage — HeartbeatService now imports it directly.
-let _testProcessMessage:
-  | ((...args: unknown[]) => Promise<{ messageId: string }>)
-  | undefined;
-
-mock.module("../../daemon/process-message.js", () => ({
-  processMessage: async (...args: unknown[]) => {
-    if (_testProcessMessage) return _testProcessMessage(...args);
-    return { messageId: `mock-msg-${Date.now()}` };
-  },
-  processMessageInBackground: async () => ({ messageId: "mock-bg" }),
-  resolveTurnChannel: () => "vellum",
-  resolveTurnInterface: () => "vellum",
-  prepareConversationForMessage: async () => ({}),
-}));
-
-const { getHomeFeedPath } = await import("../../home/feed-writer.js");
-const { HeartbeatService } = await import("../heartbeat-service.js");
-
-interface OnDiskItem {
-  id: string;
-  type: string;
-  source?: string;
-  title: string;
-  summary: string;
-  priority: number;
-  status: string;
-  author: string;
-  urgency?: string;
-}
-
-function readFeedItems(): OnDiskItem[] {
-  if (!existsSync(getHomeFeedPath())) return [];
-  const raw = JSON.parse(readFileSync(getHomeFeedPath(), "utf-8"));
-  return raw.items as OnDiskItem[];
-}
-
-let origWorkspaceDir: string | undefined;
-
-beforeEach(() => {
-  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-hb-feed-"));
-  origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
-  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
-  publishSpy.mockClear();
-  _testProcessMessage = undefined;
-});
-
-afterEach(() => {
-  if (origWorkspaceDir === undefined) {
-    delete process.env.VELLUM_WORKSPACE_DIR;
-  } else {
-    process.env.VELLUM_WORKSPACE_DIR = origWorkspaceDir;
-  }
-  try {
-    rmSync(workspaceDir, { recursive: true, force: true });
-  } catch {
-    // best-effort
-  }
-});
-
-describe("heartbeat feed events", () => {
-  test("successful heartbeat without an alert does not emit a feed event", async () => {
-    _testProcessMessage = async () => ({ messageId: "msg-1" });
-    const service = new HeartbeatService({
-      alerter: () => {},
-    });
-
-    await service.runOnce({ force: true });
-
-    // Give any fire-and-forget surfacing work time to flush.
-    await new Promise((r) => setTimeout(r, 100));
-
-    const items = readFeedItems();
-    const heartbeatItem = items.find((i) => i.title === "Heartbeat");
-    expect(heartbeatItem).toBeUndefined();
-  });
-
-  test("failed heartbeat emits feed event with priority 55 and urgency medium", async () => {
-    _testProcessMessage = async () => {
-      throw new Error("LLM call failed");
-    };
-    const service = new HeartbeatService({
-      alerter: () => {},
-    });
-
-    await service.runOnce({ force: true });
-
-    // Give the fire-and-forget emitFeedEvent time to flush.
-    await new Promise((r) => setTimeout(r, 100));
-
-    const items = readFeedItems();
-    const heartbeatItem = items.find((i) => i.title === "Heartbeat Failed");
-    expect(heartbeatItem).toBeDefined();
-    expect(heartbeatItem!.summary).toContain("LLM call failed");
-    expect(heartbeatItem!.priority).toBe(55);
-    expect(heartbeatItem!.urgency).toBe("high");
-    expect(heartbeatItem!.source).toBe("assistant");
-  });
-
-  test("repeated successful heartbeats without alerts stay silent", async () => {
-    _testProcessMessage = async () => ({ messageId: "msg-1" });
-    const service = new HeartbeatService({
-      alerter: () => {},
-    });
-
-    // Run twice — neither should create a generic success item.
-    await service.runOnce({ force: true });
-    await new Promise((r) => setTimeout(r, 100));
-    await service.runOnce({ force: true });
-    await new Promise((r) => setTimeout(r, 100));
-
-    const items = readFeedItems();
-    const heartbeatItems = items.filter((i) => i.title === "Heartbeat");
-    expect(heartbeatItems).toHaveLength(0);
-  });
-});

package/src/home/__tests__/assistant-feed-authoring.test.ts

@@ -1,156 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { FeedAction, FeedItem } from "../feed-types.js";
-
-// ─── feed-writer mock ──────────────────────────────────────────────────
-// We mock `appendFeedItem` at the module level so the helper under
-// test delegates to the mock instead of hitting disk. The mock is
-// installed before the dynamic import below so the helper module
-// picks it up during resolution.
-const appendFeedItemMock = mock<(item: FeedItem) => Promise<void>>(
-  async () => {},
-);
-
-mock.module("../feed-writer.js", () => ({
-  appendFeedItem: appendFeedItemMock,
-}));
-
-// Dynamic import — must run after `mock.module` above so the helper
-// resolves against the mocked writer.
-const { writeAssistantFeedItem } =
-  await import("../assistant-feed-authoring.js");
-
-beforeEach(() => {
-  appendFeedItemMock.mockClear();
-});
-
-describe("writeAssistantFeedItem", () => {
-  test("builds an assistant-authored FeedItem and delegates to appendFeedItem", async () => {
-    const item = await writeAssistantFeedItem({
-      type: "nudge",
-      source: "gmail",
-      title: "Urgent email from Alice",
-      summary: "Alice is asking when the deck lands",
-    });
-
-    // Author is hard-coded to "assistant" — this is the whole point
-    // of the helper (wins over platform for the same (type,source)).
-    expect(item.author).toBe("assistant");
-    // Non-empty UUID id was generated.
-    expect(typeof item.id).toBe("string");
-    expect(item.id.length).toBeGreaterThan(0);
-    // Status defaults to "new".
-    expect(item.status).toBe("new");
-    // Semantic fields are passed through untouched.
-    expect(item.type).toBe("nudge");
-    expect(item.source).toBe("gmail");
-    expect(item.title).toBe("Urgent email from Alice");
-    expect(item.summary).toBe("Alice is asking when the deck lands");
-
-    // Delegated to the writer exactly once with the constructed item.
-    expect(appendFeedItemMock.mock.calls).toHaveLength(1);
-    const [appended] = appendFeedItemMock.mock.calls[0]!;
-    expect(appended).toBe(item);
-  });
-
-  test("defaults priority to 60 when not supplied", async () => {
-    const item = await writeAssistantFeedItem({
-      type: "digest",
-      source: "slack",
-      title: "Slack digest",
-      summary: "3 threads need a reply",
-    });
-
-    expect(item.priority).toBe(60);
-    expect(appendFeedItemMock.mock.calls).toHaveLength(1);
-    expect(appendFeedItemMock.mock.calls[0]![0]!.priority).toBe(60);
-  });
-
-  test("passes an explicit priority through untouched", async () => {
-    const item = await writeAssistantFeedItem({
-      type: "nudge",
-      source: "slack",
-      title: "High-priority nudge",
-      summary: "You should look at this",
-      priority: 80,
-    });
-
-    expect(item.priority).toBe(80);
-    expect(appendFeedItemMock.mock.calls[0]![0]!.priority).toBe(80);
-  });
-
-  test("populates createdAt and timestamp as ISO strings", async () => {
-    const before = Date.now();
-    const item = await writeAssistantFeedItem({
-      type: "nudge",
-      title: "Ping",
-      summary: "Ping summary",
-    });
-    const after = Date.now();
-
-    expect(typeof item.timestamp).toBe("string");
-    expect(typeof item.createdAt).toBe("string");
-
-    const timestampMs = Date.parse(item.timestamp);
-    const createdAtMs = Date.parse(item.createdAt);
-    expect(Number.isNaN(timestampMs)).toBe(false);
-    expect(Number.isNaN(createdAtMs)).toBe(false);
-
-    // Both are stamped at call time.
-    expect(timestampMs).toBeGreaterThanOrEqual(before);
-    expect(timestampMs).toBeLessThanOrEqual(after);
-    expect(createdAtMs).toBeGreaterThanOrEqual(before);
-    expect(createdAtMs).toBeLessThanOrEqual(after);
-  });
-
-  test("passes the actions array through untouched", async () => {
-    const actions: FeedAction[] = [
-      { id: "reply", label: "Reply", prompt: "Draft a reply to Alice" },
-      { id: "snooze", label: "Snooze", prompt: "Snooze this for 1 hour" },
-    ];
-
-    const item = await writeAssistantFeedItem({
-      type: "action",
-      source: "gmail",
-      title: "Alice needs a reply",
-      summary: "Reply or snooze",
-      actions,
-    });
-
-    expect(item.actions).toEqual(actions);
-    // Delegated value is the same object the caller passed in.
-    expect(appendFeedItemMock.mock.calls[0]![0]!.actions).toEqual(actions);
-  });
-
-  test("throws a Zod validation error when the constructed item violates the schema", async () => {
-    // Plan calls for a "missing required fields → throws Zod error"
-    // test. The underlying `feedItemSchema` uses `z.string()` (not
-    // `.min(1)`) so an empty title technically parses, but an
-    // out-of-range priority is a guaranteed schema violation and
-    // exercises the same guardrail path: `feedItemSchema.parse()`
-    // rejects the item, the helper rethrows, and `appendFeedItem` is
-    // NEVER called.
-    await expect(
-      writeAssistantFeedItem({
-        type: "nudge",
-        title: "bad",
-        summary: "also bad",
-        priority: 150,
-      }),
-    ).rejects.toThrow();
-
-    // And for the original "missing required field" intent from the
-    // plan: force-omit `title` through a type cast and confirm the
-    // schema still rejects (z.string() rejects `undefined`).
-    await expect(
-      writeAssistantFeedItem({
-        type: "nudge",
-        summary: "no title",
-        // biome-ignore lint/suspicious/noExplicitAny: deliberately invalid
-      } as any),
-    ).rejects.toThrow();
-
-    // The invalid calls must NOT have reached the writer.
-    expect(appendFeedItemMock.mock.calls).toHaveLength(0);
-  });
-});

package/src/home/__tests__/emit-feed-event.test.ts

@@ -1,169 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-// Stub the in-process SSE hub so the writer's publish path is a
-// no-op in these tests. Must be in place before the writer module is
-// imported (directly or transitively) so the dynamic import below
-// picks it up.
-const publishSpy = mock<(event: unknown) => Promise<void>>(async () => {});
-
-mock.module("../../runtime/assistant-event-hub.js", () => ({
-  assistantEventHub: {
-    publish: publishSpy,
-    subscribe: () => () => {},
-  },
-}));
-
-const { emitFeedEvent } = await import("../emit-feed-event.js");
-const { getHomeFeedPath } = await import("../feed-writer.js");
-
-interface OnDiskItem {
-  id: string;
-  type: string;
-  source?: string;
-  title: string;
-  summary: string;
-  priority: number;
-  status: string;
-  author: string;
-  createdAt: string;
-  expiresAt?: string;
-  minTimeAway?: number;
-}
-
-function readFileJson(): {
-  version: number;
-  items: OnDiskItem[];
-  updatedAt: string;
-} {
-  return JSON.parse(readFileSync(getHomeFeedPath(), "utf-8"));
-}
-
-let workspaceDir: string;
-let origWorkspaceDir: string | undefined;
-
-beforeEach(() => {
-  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-emit-"));
-  origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
-  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
-  publishSpy.mockClear();
-});
-
-afterEach(() => {
-  if (origWorkspaceDir === undefined) {
-    delete process.env.VELLUM_WORKSPACE_DIR;
-  } else {
-    process.env.VELLUM_WORKSPACE_DIR = origWorkspaceDir;
-  }
-  try {
-    rmSync(workspaceDir, { recursive: true, force: true });
-  } catch {
-    // best-effort
-  }
-});
-
-describe("emitFeedEvent", () => {
-  test("writes an assistant-authored action item with the opinionated defaults", async () => {
-    const result = await emitFeedEvent({
-      source: "gmail",
-      title: "Replied to Alice",
-      summary: "Sent a reply to Alice's question about lunch.",
-    });
-
-    expect(result.type).toBe("action");
-    expect(result.author).toBe("assistant");
-    expect(result.source).toBe("gmail");
-    expect(result.status).toBe("new");
-    expect(result.expiresAt).toBeUndefined();
-    // Default priority: above platform baseline (40), below the
-    // assistant nudge default (60).
-    expect(result.priority).toBe(50);
-
-    const decoded = readFileJson();
-    expect(decoded.items).toHaveLength(1);
-    const persisted = decoded.items[0]!;
-    expect(persisted.id).toBe(result.id);
-    expect(persisted.type).toBe("action");
-    expect(persisted.author).toBe("assistant");
-    expect(persisted.title).toBe("Replied to Alice");
-    expect(persisted.expiresAt).toBeUndefined();
-  });
-
-  test("dedupKey produces a deterministic id so repeat emits update in place", async () => {
-    await emitFeedEvent({
-      source: "gmail",
-      title: "Unread from Alice",
-      summary: "One unread thread from alice@example.com.",
-      dedupKey: "unread-msg-42",
-    });
-    await emitFeedEvent({
-      source: "gmail",
-      title: "Unread from Alice (now 2 messages)",
-      summary: "Two unread threads from alice@example.com.",
-      dedupKey: "unread-msg-42",
-    });
-
-    const decoded = readFileJson();
-    expect(decoded.items).toHaveLength(1);
-    const item = decoded.items[0]!;
-    expect(item.id).toBe("emit:gmail:unread-msg-42");
-    expect(item.title).toBe("Unread from Alice (now 2 messages)");
-  });
-
-  test("omitting dedupKey produces a fresh id on every call", async () => {
-    const a = await emitFeedEvent({
-      source: "slack",
-      title: "Sent reply in #general",
-      summary: "Posted a reply in #general.",
-    });
-    const b = await emitFeedEvent({
-      source: "slack",
-      title: "Sent reply in #alerts",
-      summary: "Posted a reply in #alerts.",
-    });
-
-    expect(a.id).not.toBe(b.id);
-    const decoded = readFileJson();
-    expect(decoded.items).toHaveLength(2);
-  });
-
-  test("explicit expiresAt is preserved and round-trips to disk", async () => {
-    const explicit = "2026-04-20T00:00:00.000Z";
-    await emitFeedEvent({
-      source: "calendar",
-      title: "Meeting prep reminder",
-      summary: "Standup in 30 minutes — agenda is empty.",
-      expiresAt: explicit,
-      dedupKey: "standup-prep",
-    });
-
-    const decoded = readFileJson();
-    expect(decoded.items[0]!.expiresAt).toBe(explicit);
-  });
-
-  test("explicit priority overrides the default", async () => {
-    await emitFeedEvent({
-      source: "assistant",
-      title: "Ran weekly review",
-      summary: "Consolidated last week's activity into a digest.",
-      priority: 75,
-      dedupKey: "weekly-review",
-    });
-
-    const decoded = readFileJson();
-    expect(decoded.items[0]!.priority).toBe(75);
-  });
-
-  test("out-of-range priority throws a ZodError at the source", async () => {
-    await expect(
-      emitFeedEvent({
-        source: "gmail",
-        title: "Valid title",
-        summary: "Valid summary",
-        priority: 150,
-      }),
-    ).rejects.toThrow();
-  });
-});