@vellumai/assistant 0.8.0 → 0.8.1

package/src/home/__tests__/feed-population-integration.test.ts

@@ -1,312 +0,0 @@
-import { mkdtempSync, 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 { readHomeFeed, MAX_ACTIONS_PER_SOURCE } =
-  await import("../feed-writer.js");
-
-type FeedItemSource = "gmail" | "slack" | "calendar" | "assistant";
-
-const ALL_SOURCES: FeedItemSource[] = [
-  "gmail",
-  "slack",
-  "calendar",
-  "assistant",
-];
-
-let workspaceDir: string;
-let origWorkspaceDir: string | undefined;
-
-beforeEach(() => {
-  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-feed-integ-"));
-  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("feed population integration", () => {
-  test("items from all 4 sources coexist and are sorted by priority", async () => {
-    // Emit one item per source with distinct priorities.
-    await emitFeedEvent({
-      source: "gmail",
-      title: "Gmail action",
-      summary: "Replied to a thread.",
-      priority: 30,
-      dedupKey: "gmail-1",
-    });
-    await emitFeedEvent({
-      source: "slack",
-      title: "Slack action",
-      summary: "Sent a message in #general.",
-      priority: 70,
-      dedupKey: "slack-1",
-    });
-    await emitFeedEvent({
-      source: "calendar",
-      title: "Calendar action",
-      summary: "Meeting prep reminder.",
-      priority: 50,
-      dedupKey: "cal-1",
-    });
-    await emitFeedEvent({
-      source: "assistant",
-      title: "Assistant action",
-      summary: "Ran weekly review.",
-      priority: 90,
-      dedupKey: "asst-1",
-    });
-
-    const feed = readHomeFeed();
-    expect(feed.items).toHaveLength(4);
-
-    // Verify all four sources are present.
-    const sources = new Set(feed.items.map((i) => i.source));
-    for (const s of ALL_SOURCES) {
-      expect(sources.has(s)).toBe(true);
-    }
-
-    // Items should be sorted by priority DESC.
-    const priorities = feed.items.map((i) => i.priority);
-    for (let i = 1; i < priorities.length; i++) {
-      expect(priorities[i - 1]!).toBeGreaterThanOrEqual(priorities[i]!);
-    }
-
-    // Spot-check the ordering: assistant (90) first, gmail (30) last.
-    expect(feed.items[0]!.source).toBe("assistant");
-    expect(feed.items[feed.items.length - 1]!.source).toBe("gmail");
-  });
-
-  test("per-source cap holds across mixed sources", async () => {
-    // Emit MAX + 5 items for gmail and MAX + 5 for slack, plus a
-    // handful from calendar and assistant. Only the capped sources
-    // should be pruned.
-    const overflow = MAX_ACTIONS_PER_SOURCE + 5;
-
-    for (let i = 0; i < overflow; i++) {
-      await emitFeedEvent({
-        source: "gmail",
-        title: `Gmail item ${i}`,
-        summary: `Gmail summary ${i}`,
-        priority: 50,
-      });
-    }
-
-    for (let i = 0; i < overflow; i++) {
-      await emitFeedEvent({
-        source: "slack",
-        title: `Slack item ${i}`,
-        summary: `Slack summary ${i}`,
-        priority: 50,
-      });
-    }
-
-    // A few items from the other two sources — should be untouched.
-    for (let i = 0; i < 3; i++) {
-      await emitFeedEvent({
-        source: "calendar",
-        title: `Calendar item ${i}`,
-        summary: `Calendar summary ${i}`,
-        priority: 50,
-      });
-    }
-    for (let i = 0; i < 2; i++) {
-      await emitFeedEvent({
-        source: "assistant",
-        title: `Assistant item ${i}`,
-        summary: `Assistant summary ${i}`,
-        priority: 50,
-      });
-    }
-
-    const feed = readHomeFeed();
-
-    const gmailItems = feed.items.filter((i) => i.source === "gmail");
-    const slackItems = feed.items.filter((i) => i.source === "slack");
-    const calendarItems = feed.items.filter((i) => i.source === "calendar");
-    const assistantItems = feed.items.filter((i) => i.source === "assistant");
-
-    expect(gmailItems).toHaveLength(MAX_ACTIONS_PER_SOURCE);
-    expect(slackItems).toHaveLength(MAX_ACTIONS_PER_SOURCE);
-    expect(calendarItems).toHaveLength(3);
-    expect(assistantItems).toHaveLength(2);
-  });
-
-  test("expired items are filtered out at read time", async () => {
-    // One item that expired in the past, one that is still valid.
-    const pastDate = new Date(Date.now() - 60_000).toISOString();
-    const futureDate = new Date(Date.now() + 3_600_000).toISOString();
-
-    await emitFeedEvent({
-      source: "gmail",
-      title: "Expired item",
-      summary: "Should not appear.",
-      expiresAt: pastDate,
-      dedupKey: "expired-1",
-    });
-    await emitFeedEvent({
-      source: "slack",
-      title: "Still valid",
-      summary: "Should appear.",
-      expiresAt: futureDate,
-      dedupKey: "valid-1",
-    });
-    await emitFeedEvent({
-      source: "calendar",
-      title: "No expiry",
-      summary: "Should also appear.",
-      dedupKey: "no-expiry-1",
-    });
-
-    const feed = readHomeFeed();
-    expect(feed.items).toHaveLength(2);
-
-    const titles = feed.items.map((i) => i.title);
-    expect(titles).toContain("Still valid");
-    expect(titles).toContain("No expiry");
-    expect(titles).not.toContain("Expired item");
-  });
-
-  test("dedup: two items with the same dedupKey produce only one entry", async () => {
-    await emitFeedEvent({
-      source: "gmail",
-      title: "First version",
-      summary: "Original summary.",
-      dedupKey: "shared-key",
-    });
-    await emitFeedEvent({
-      source: "gmail",
-      title: "Second version",
-      summary: "Updated summary.",
-      dedupKey: "shared-key",
-    });
-
-    const feed = readHomeFeed();
-    const matching = feed.items.filter((i) => i.id === "emit:gmail:shared-key");
-    expect(matching).toHaveLength(1);
-    expect(matching[0]!.title).toBe("Second version");
-    expect(matching[0]!.summary).toBe("Updated summary.");
-  });
-
-  test("dedup works across reads — no phantom duplicates", async () => {
-    await emitFeedEvent({
-      source: "assistant",
-      title: "Version 1",
-      summary: "First emit.",
-      dedupKey: "cross-read",
-    });
-
-    // Read once to confirm the item is there.
-    const feed1 = readHomeFeed();
-    expect(
-      feed1.items.filter((i) => i.id === "emit:assistant:cross-read"),
-    ).toHaveLength(1);
-
-    // Emit again with the same dedupKey.
-    await emitFeedEvent({
-      source: "assistant",
-      title: "Version 2",
-      summary: "Second emit.",
-      dedupKey: "cross-read",
-    });
-
-    const feed2 = readHomeFeed();
-    const matching = feed2.items.filter(
-      (i) => i.id === "emit:assistant:cross-read",
-    );
-    expect(matching).toHaveLength(1);
-    expect(matching[0]!.title).toBe("Version 2");
-  });
-
-  test("mixed priorities and urgencies sort correctly", async () => {
-    const events: Array<{
-      source: FeedItemSource;
-      title: string;
-      priority: number;
-      dedupKey: string;
-    }> = [
-      {
-        source: "gmail",
-        title: "Low priority gmail",
-        priority: 10,
-        dedupKey: "g-low",
-      },
-      {
-        source: "slack",
-        title: "High priority slack",
-        priority: 95,
-        dedupKey: "s-high",
-      },
-      {
-        source: "calendar",
-        title: "Mid priority calendar",
-        priority: 50,
-        dedupKey: "c-mid",
-      },
-      {
-        source: "assistant",
-        title: "High priority assistant",
-        priority: 95,
-        dedupKey: "a-high",
-      },
-      {
-        source: "gmail",
-        title: "Mid priority gmail",
-        priority: 50,
-        dedupKey: "g-mid",
-      },
-      {
-        source: "slack",
-        title: "Low priority slack",
-        priority: 20,
-        dedupKey: "s-low",
-      },
-    ];
-
-    for (const e of events) {
-      await emitFeedEvent({
-        source: e.source,
-        title: e.title,
-        summary: `Summary for ${e.title}`,
-        priority: e.priority,
-        dedupKey: e.dedupKey,
-      });
-    }
-
-    const feed = readHomeFeed();
-    expect(feed.items).toHaveLength(6);
-
-    // Verify descending priority order.
-    const priorities = feed.items.map((i) => i.priority);
-    for (let i = 1; i < priorities.length; i++) {
-      expect(priorities[i - 1]!).toBeGreaterThanOrEqual(priorities[i]!);
-    }
-  });
-});

package/src/home/__tests__/feed-scheduler.test.ts

@@ -1,222 +0,0 @@
-/**
- * Unit tests for the home-feed scheduler's tick lifecycle.
- *
- * Producer implementations are injected via `FeedSchedulerOptions`
- * spies so the tests never touch `mock.module` (which leaks across
- * files in Bun's test runner). The dedicated producer tests
- * (`rollup-producer.test.ts`, `platform-gmail-digest.test.ts`) cover
- * each producer's internal behavior.
- */
-
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { startFeedScheduler } from "../feed-scheduler.js";
-import type { FeedItem } from "../feed-types.js";
-import type { RollupResult } from "../rollup-producer.js";
-
-const gmailDigestRunner = mock<
-  (now: Date, countSource: () => Promise<number>) => Promise<FeedItem | null>
->(async () => null);
-
-const rollupRunner = mock<(now: Date) => Promise<RollupResult>>(async () => ({
-  wroteCount: 0,
-  skippedReason: "empty_items",
-}));
-
-const defaultOptions = () => ({
-  gmailCountSource: async () => 0,
-  gmailDigestRunner,
-  rollupRunner,
-  runOnStart: false,
-});
-
-beforeEach(() => {
-  gmailDigestRunner.mockClear();
-  rollupRunner.mockClear();
-});
-
-describe("startFeedScheduler", () => {
-  let handle: ReturnType<typeof startFeedScheduler> | null = null;
-
-  afterEach(() => {
-    handle?.stop();
-    handle = null;
-  });
-
-  test("runOnce invokes both producers on the first tick", async () => {
-    handle = startFeedScheduler(defaultOptions());
-    const summary = await handle.runOnce(new Date("2026-04-14T12:00:00.000Z"));
-
-    expect(summary.gmailDigestRan).toBe(true);
-    expect(summary.rollupRan).toBe(true);
-    expect(gmailDigestRunner).toHaveBeenCalledTimes(1);
-    expect(rollupRunner).toHaveBeenCalledTimes(1);
-  });
-
-  test("gmail digest re-runs every tick once its interval has elapsed", async () => {
-    handle = startFeedScheduler(defaultOptions());
-
-    const t0 = new Date("2026-04-14T12:00:00.000Z");
-    await handle.runOnce(t0);
-
-    // 1 minute later — below the 5-minute gmail gate, should NOT re-run.
-    const t1 = new Date("2026-04-14T12:01:00.000Z");
-    const summary1 = await handle.runOnce(t1);
-    expect(summary1.gmailDigestRan).toBe(false);
-
-    // 6 minutes later — past the 5-minute gate, should re-run.
-    const t2 = new Date("2026-04-14T12:06:00.000Z");
-    const summary2 = await handle.runOnce(t2);
-    expect(summary2.gmailDigestRan).toBe(true);
-  });
-
-  test("rollup only re-runs every 2 hours as the safety-net cadence", async () => {
-    // The scheduler is the safety net; the primary trigger is the
-    // on-visit refresh in home-feed-routes.ts. Long cadence is
-    // intentional so the scheduler doesn't fight the route.
-    handle = startFeedScheduler(defaultOptions());
-
-    const t0 = new Date("2026-04-14T12:00:00.000Z");
-    await handle.runOnce(t0);
-
-    // 30 min later — below the 2-hour gate.
-    const t1 = new Date("2026-04-14T12:30:00.000Z");
-    const summary1 = await handle.runOnce(t1);
-    expect(summary1.rollupRan).toBe(false);
-
-    // 1h later — still below the 2-hour gate.
-    const t2 = new Date("2026-04-14T13:00:00.000Z");
-    const summary2 = await handle.runOnce(t2);
-    expect(summary2.rollupRan).toBe(false);
-
-    // 2h 1m later — past the gate, should re-run.
-    const t3 = new Date("2026-04-14T14:01:00.000Z");
-    const summary3 = await handle.runOnce(t3);
-    expect(summary3.rollupRan).toBe(true);
-  });
-
-  test("rollup cooldown is NOT advanced on no_provider so the next tick retries", async () => {
-    // Mimic the daemon startup ordering: the scheduler boots before
-    // the provider registry is ready. The first tick gets no_provider;
-    // the next tick (even one second later) must still run the rollup
-    // instead of waiting 2 hours.
-    rollupRunner.mockImplementationOnce(async () => ({
-      wroteCount: 0,
-      skippedReason: "no_provider",
-    }));
-
-    handle = startFeedScheduler(defaultOptions());
-    const t0 = new Date("2026-04-14T12:00:00.000Z");
-    await handle.runOnce(t0);
-    expect(rollupRunner).toHaveBeenCalledTimes(1);
-
-    // One second later — providers have initialized.
-    const t1 = new Date("2026-04-14T12:00:01.000Z");
-    const summary = await handle.runOnce(t1);
-
-    expect(summary.rollupRan).toBe(true);
-    expect(rollupRunner).toHaveBeenCalledTimes(2);
-  });
-
-  test("rollup cooldown is NOT advanced on in_flight so the next tick retries", async () => {
-    // in_flight means another caller (on-visit refresh, usually) is
-    // already running the producer. Advancing the gate here would
-    // force the NEXT tick to wait out the full cadence window even
-    // though nothing broken happened — the other caller's result is
-    // effectively this tick's run.
-    rollupRunner.mockImplementationOnce(async () => ({
-      wroteCount: 0,
-      skippedReason: "in_flight",
-    }));
-
-    handle = startFeedScheduler(defaultOptions());
-    await handle.runOnce(new Date("2026-04-14T12:00:00.000Z"));
-    expect(rollupRunner).toHaveBeenCalledTimes(1);
-
-    const summary = await handle.runOnce(new Date("2026-04-14T12:00:01.000Z"));
-    expect(summary.rollupRan).toBe(true);
-    expect(rollupRunner).toHaveBeenCalledTimes(2);
-  });
-
-  test("rollup cooldown is NOT advanced on no_actions so the next tick retries", async () => {
-    // no_actions means the activity log was empty — no LLM call was
-    // made. A subsequent tick should retry as soon as new actions
-    // land, not wait the full 2-hour window.
-    rollupRunner.mockImplementationOnce(async () => ({
-      wroteCount: 0,
-      skippedReason: "no_actions",
-    }));
-
-    handle = startFeedScheduler(defaultOptions());
-    await handle.runOnce(new Date("2026-04-14T12:00:00.000Z"));
-    expect(rollupRunner).toHaveBeenCalledTimes(1);
-
-    // One second later — the next tick must still invoke the rollup.
-    const summary = await handle.runOnce(new Date("2026-04-14T12:00:01.000Z"));
-    expect(summary.rollupRan).toBe(true);
-    expect(rollupRunner).toHaveBeenCalledTimes(2);
-  });
-
-  test("rollup cooldown IS advanced on other skip reasons to preserve backoff", async () => {
-    // empty_items / malformed_output / provider_error are real LLM
-    // attempts — the next tick should be gated by the full 2-hour
-    // window so a broken producer doesn't get hammered every tick.
-    rollupRunner.mockImplementationOnce(async () => ({
-      wroteCount: 0,
-      skippedReason: "malformed_output",
-    }));
-
-    handle = startFeedScheduler(defaultOptions());
-    await handle.runOnce(new Date("2026-04-14T12:00:00.000Z"));
-    expect(rollupRunner).toHaveBeenCalledTimes(1);
-
-    // Thirty minutes later — below the 2-hour gate, should NOT re-run.
-    const summary = await handle.runOnce(new Date("2026-04-14T12:30:00.000Z"));
-    expect(summary.rollupRan).toBe(false);
-    expect(rollupRunner).toHaveBeenCalledTimes(1);
-  });
-
-  test("producer exceptions do not break the tick loop", async () => {
-    gmailDigestRunner.mockImplementationOnce(async () => {
-      throw new Error("boom");
-    });
-    rollupRunner.mockImplementationOnce(async () => {
-      throw new Error("also boom");
-    });
-
-    handle = startFeedScheduler(defaultOptions());
-    const summary = await handle.runOnce(new Date("2026-04-14T12:00:00.000Z"));
-
-    // Both producers were invoked and both counted as "ran" (the
-    // gating bookkeeping advanced) even though they threw. This is
-    // the intended behavior — a broken producer shouldn't cause the
-    // scheduler to hammer it every tick via a backoff bypass.
-    expect(summary.gmailDigestRan).toBe(true);
-    expect(summary.rollupRan).toBe(true);
-  });
-
-  test("stop() makes subsequent runOnce calls no-op", async () => {
-    handle = startFeedScheduler(defaultOptions());
-    await handle.runOnce(new Date("2026-04-14T12:00:00.000Z"));
-
-    handle.stop();
-
-    const beforeCount = gmailDigestRunner.mock.calls.length;
-    // A tick well past the cadence gate should not fire after stop.
-    await handle.runOnce(new Date("2026-04-14T13:00:00.000Z"));
-    expect(gmailDigestRunner.mock.calls.length).toBe(beforeCount);
-  });
-
-  test("gmailCountSource option is threaded through to the digest runner", async () => {
-    const countSource = mock<() => Promise<number>>(async () => 7);
-    handle = startFeedScheduler({
-      ...defaultOptions(),
-      gmailCountSource: countSource,
-    });
-    await handle.runOnce(new Date("2026-04-14T12:00:00.000Z"));
-
-    expect(gmailDigestRunner).toHaveBeenCalledTimes(1);
-    const [, passedCountSource] = gmailDigestRunner.mock.calls[0]!;
-    expect(passedCountSource).toBe(countSource);
-  });
-});