@vellumai/assistant 0.7.2 → 0.8.0

package/src/__tests__/workspace-migration-065-bump-stale-heartbeat-interval.test.ts

@@ -0,0 +1,122 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { bumpStaleHeartbeatIntervalMigration } from "../workspace/migrations/065-bump-stale-heartbeat-interval.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+
+const THIRTY_MINUTES_MS = 30 * 60 * 1000;
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-065-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(configPath(), JSON.stringify(data, null, 2) + "\n");
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath(), "utf-8"));
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("065-bump-stale-heartbeat-interval migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(bumpStaleHeartbeatIntervalMigration.id).toBe(
+      "065-bump-stale-heartbeat-interval",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "065-bump-stale-heartbeat-interval",
+    );
+  });
+
+  test("bumps stale baked 6-hour default to 30 minutes", () => {
+    writeConfig({
+      heartbeat: {
+        enabled: true,
+        intervalMs: 6 * 60 * 60 * 1000,
+        activeHoursStart: 8,
+        activeHoursEnd: 22,
+      },
+    });
+
+    bumpStaleHeartbeatIntervalMigration.run(workspaceDir);
+
+    expect(readConfig()).toEqual({
+      heartbeat: {
+        enabled: true,
+        intervalMs: THIRTY_MINUTES_MS,
+        activeHoursStart: 8,
+        activeHoursEnd: 22,
+      },
+    });
+  });
+
+  test("bumps stale baked 3-hour default to 30 minutes", () => {
+    writeConfig({
+      heartbeat: {
+        intervalMs: 3 * 60 * 60 * 1000,
+      },
+    });
+
+    bumpStaleHeartbeatIntervalMigration.run(workspaceDir);
+
+    expect((readConfig().heartbeat as Record<string, unknown>).intervalMs).toBe(
+      THIRTY_MINUTES_MS,
+    );
+  });
+
+  test("preserves custom heartbeat intervals", () => {
+    writeConfig({
+      heartbeat: {
+        intervalMs: 60 * 60 * 1000,
+      },
+    });
+
+    bumpStaleHeartbeatIntervalMigration.run(workspaceDir);
+
+    expect(readConfig()).toEqual({
+      heartbeat: {
+        intervalMs: 60 * 60 * 1000,
+      },
+    });
+  });
+
+  test("is a no-op when config or heartbeat interval is absent", () => {
+    bumpStaleHeartbeatIntervalMigration.run(workspaceDir);
+    expect(existsSync(configPath())).toBe(false);
+
+    writeConfig({ heartbeat: { enabled: true }, other: "value" });
+    bumpStaleHeartbeatIntervalMigration.run(workspaceDir);
+    expect(readConfig()).toEqual({
+      heartbeat: { enabled: true },
+      other: "value",
+    });
+  });
+});

package/src/__tests__/workspace-migration-066-seed-heartbeat-callsite-cost-default.test.ts

@@ -0,0 +1,285 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+import { seedHeartbeatCallsiteCostDefaultMigration } from "../workspace/migrations/066-seed-heartbeat-callsite-cost-default.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-066-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(configPath(), JSON.stringify(data, null, 2) + "\n");
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath(), "utf-8"));
+}
+
+beforeEach(() => {
+  freshWorkspace();
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("066-seed-heartbeat-callsite-cost-default migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(seedHeartbeatCallsiteCostDefaultMigration.id).toBe(
+      "066-seed-heartbeat-callsite-cost-default",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "066-seed-heartbeat-callsite-cost-default",
+    );
+  });
+
+  test("fresh config seeds explicit Anthropic cheap defaults", () => {
+    expect(existsSync(configPath())).toBe(false);
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    expect(existsSync(configPath())).toBe(true);
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      provider: "anthropic",
+      model: "claude-haiku-4-5-20251001",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("uses matching cost-optimized profile when present", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-sonnet-4-6" },
+        profiles: {
+          "cost-optimized": {
+            provider: "anthropic",
+            model: "claude-haiku-4-5-20251001",
+          },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      profile: "cost-optimized",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("fills missing leaves on legacy heartbeat speed override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          heartbeatAgent: { speed: "fast" },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      speed: "fast",
+      provider: "anthropic",
+      model: "claude-haiku-4-5-20251001",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("preserves explicit user model selection unchanged", () => {
+    const heartbeatAgent = {
+      provider: "openai",
+      model: "gpt-5.4-mini",
+      effort: "medium",
+      thinking: { enabled: true },
+      contextWindow: { enabled: false },
+    };
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          heartbeatAgent,
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual(heartbeatAgent);
+  });
+
+  test("preserves explicit user profile selection unchanged", () => {
+    const heartbeatAgent = {
+      profile: "quality-optimized",
+    };
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: {
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+            effort: "max",
+            thinking: { enabled: true, streamThinking: true },
+          },
+        },
+        callSites: {
+          heartbeatAgent,
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual(heartbeatAgent);
+  });
+
+  test("seeds provider-specific cheap model for OpenAI workspaces", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+        profiles: {
+          "cost-optimized": {
+            provider: "anthropic",
+            model: "claude-haiku-4-5-20251001",
+          },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      provider: "openai",
+      model: "gpt-5.4-nano",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("seeds existing Gemini latency model for Gemini workspaces", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "gemini", model: "gemini-3.1-pro-preview" },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      provider: "gemini",
+      model: "gemini-3-flash",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("skips when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("resolved heartbeat config uses cheap model and bounded context", () => {
+    writeConfig({
+      llm: {
+        default: {
+          provider: "anthropic",
+          model: "claude-sonnet-4-6",
+          effort: "high",
+          thinking: { enabled: true, streamThinking: true },
+          contextWindow: { maxInputTokens: 200_000 },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const onDisk = readConfig() as { llm: unknown };
+    const parsed = LLMSchema.parse(onDisk.llm);
+    const resolved = resolveCallSiteConfig("heartbeatAgent", parsed);
+    expect(resolved.provider).toBe("anthropic");
+    expect(resolved.model).toBe("claude-haiku-4-5-20251001");
+    expect(resolved.maxTokens).toBe(2048);
+    expect(resolved.effort).toBe("low");
+    expect(resolved.temperature).toBe(0);
+    expect(resolved.thinking).toEqual({
+      enabled: false,
+      streamThinking: false,
+    });
+    expect(resolved.contextWindow.maxInputTokens).toBe(16_000);
+  });
+});

package/src/__tests__/workspace-migration-068-release-notes-local-timezone.test.ts

@@ -0,0 +1,90 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { releaseNotesLocalTimezoneMigration } from "../workspace/migrations/068-release-notes-local-timezone.js";
+
+const MIGRATION_ID = "068-release-notes-local-timezone";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-068-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+function markerCount(content: string): number {
+  return content.split(MARKER).length - 1;
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("workspace migration 068-release-notes-local-timezone", () => {
+  test("has the correct id", () => {
+    expect(releaseNotesLocalTimezoneMigration.id).toBe(MIGRATION_ID);
+  });
+
+  test("creates UPDATES.md with marker and key copy when file is absent", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content).toContain(MARKER);
+    expect(content).toContain("Local timezone grounding");
+    expect(content).toContain("device timezone");
+    expect(content).toContain("Manual timezone overrides still win");
+  });
+
+  test("is idempotent when run twice", () => {
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(markerCount(content)).toBe(1);
+    expect(content.match(/Local timezone grounding/g)?.length).toBe(1);
+  });
+
+  test("appends to existing UPDATES.md when marker is absent", () => {
+    const prior = "## Prior\n\nExisting release note.\n";
+    writeFileSync(updatesPath(), prior, "utf-8");
+
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(prior)).toBe(true);
+    expect(content).toContain(MARKER);
+  });
+
+  test("is a no-op when marker is already present", () => {
+    const seeded = `## Prior\n\n${MARKER}\nAlready announced.\n`;
+    writeFileSync(updatesPath(), seeded, "utf-8");
+
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(seeded);
+  });
+});

package/src/__tests__/workspace-migration-069-seed-onboarding-threads.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Tests for workspace migration `069-seed-onboarding-threads`.
+ *
+ * The migration writes onboarding bullet content to `memory/threads.md` only
+ * when the file exists and is empty (or whitespace-only). It must preserve
+ * any existing content and must be idempotent.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  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";
+import { seedOnboardingThreadsMigration } from "../workspace/migrations/069-seed-onboarding-threads.js";
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-069-test-"));
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function readThreads(): string {
+  return readFileSync(join(workspaceDir, "memory", "threads.md"), "utf-8");
+}
+
+describe("069-seed-onboarding-threads migration", () => {
+  test("has correct id and description", () => {
+    expect(seedOnboardingThreadsMigration.id).toBe(
+      "069-seed-onboarding-threads",
+    );
+    expect(seedOnboardingThreadsMigration.description).toContain("threads.md");
+  });
+
+  test.each([
+    ["empty file", ""],
+    ["whitespace-only file", "   \n\n"],
+  ])("seeds onboarding bullets when memory/threads.md is %s", (_, initial) => {
+    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+    writeFileSync(join(workspaceDir, "memory", "threads.md"), initial, "utf-8");
+
+    seedOnboardingThreadsMigration.run(workspaceDir);
+
+    const content = readThreads();
+    expect(content).toContain("Figure out what kind of personality");
+    expect(content).toContain("data/avatar/avatar-image.png");
+    expect(content).toContain("ChatGPT, Claude");
+    expect(content).toContain("Slack or Telegram");
+  });
+
+  test("preserves existing content when memory/threads.md is non-empty", () => {
+    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+    const existing = "Follow up with Bob about the design review.\n";
+    writeFileSync(
+      join(workspaceDir, "memory", "threads.md"),
+      existing,
+      "utf-8",
+    );
+
+    seedOnboardingThreadsMigration.run(workspaceDir);
+
+    expect(readThreads()).toBe(existing);
+  });
+
+  test("no-op when memory/threads.md does not exist", () => {
+    seedOnboardingThreadsMigration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "memory", "threads.md"))).toBe(false);
+  });
+
+  test("idempotent — second run does not duplicate or rewrite content", () => {
+    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+    writeFileSync(join(workspaceDir, "memory", "threads.md"), "", "utf-8");
+
+    seedOnboardingThreadsMigration.run(workspaceDir);
+    const afterFirst = readThreads();
+
+    seedOnboardingThreadsMigration.run(workspaceDir);
+    const afterSecond = readThreads();
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("composes with 060: fresh workspace -> 060 -> 069 produces seeded threads.md", () => {
+    memoryV2InitMigration.run(workspaceDir);
+    seedOnboardingThreadsMigration.run(workspaceDir);
+
+    expect(readThreads()).toContain("Figure out what kind of personality");
+    // The other v2 prose files are untouched (still empty).
+    for (const filename of ["essentials.md", "recent.md", "buffer.md"]) {
+      expect(
+        readFileSync(join(workspaceDir, "memory", filename), "utf-8"),
+      ).toBe("");
+    }
+  });
+
+  test("down() is a no-op — seeded content remains", () => {
+    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+    writeFileSync(join(workspaceDir, "memory", "threads.md"), "", "utf-8");
+
+    seedOnboardingThreadsMigration.run(workspaceDir);
+    const seeded = readThreads();
+
+    seedOnboardingThreadsMigration.down(workspaceDir);
+
+    expect(readThreads()).toBe(seeded);
+  });
+});