@vellumai/assistant 0.8.0 → 0.8.2

package/src/__tests__/workspace-migration-082-backfill-managed-profile-labels.test.ts

@@ -0,0 +1,268 @@
+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 { backfillManagedProfileLabelsMigration } from "../workspace/migrations/082-backfill-managed-profile-labels.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-082-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("082-backfill-managed-profile-labels migration", () => {
+  test("has correct migration id", () => {
+    expect(backfillManagedProfileLabelsMigration.id).toBe(
+      "082-backfill-managed-profile-labels",
+    );
+  });
+
+  test("backfills missing labels on the canonical managed triplet (Marina QA #5)", () => {
+    // The exact shape migration 052 writes — provider + model + numeric
+    // tuning fields, no label, no source, no provider_connection.
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+        profiles: {
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+            maxTokens: 16000,
+            effort: "high",
+            thinking: { enabled: true, streamThinking: true },
+          },
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+            maxTokens: 32000,
+            effort: "max",
+            thinking: { enabled: true, streamThinking: true },
+          },
+          "cost-optimized": {
+            provider: "anthropic",
+            model: "claude-haiku-4-5-20251001",
+            maxTokens: 8192,
+            effort: "low",
+            thinking: { enabled: false, streamThinking: false },
+          },
+        },
+        activeProfile: "balanced",
+      },
+    });
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const profiles = (config.llm as Record<string, unknown>).profiles as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect(profiles.balanced.label).toBe("Balanced");
+    expect(profiles["quality-optimized"].label).toBe("Quality");
+    expect(profiles["cost-optimized"].label).toBe("Speed");
+  });
+
+  test("preserves user-set string labels without rewriting", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+            label: "My Balanced",
+          },
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+            // No label — backfills.
+          },
+          "cost-optimized": {
+            provider: "anthropic",
+            model: "claude-haiku-4-5-20251001",
+            label: "Speed (Managed)",
+          },
+        },
+      },
+    });
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const profiles = (config.llm as Record<string, unknown>).profiles as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect(profiles.balanced.label).toBe("My Balanced");
+    expect(profiles["quality-optimized"].label).toBe("Quality");
+    expect(profiles["cost-optimized"].label).toBe("Speed (Managed)");
+  });
+
+  test("preserves explicit null labels (user cleared the label)", () => {
+    // `null` is a meaningful signal — the user cleared the label via the
+    // PUT route. Treat the key as present and skip backfill.
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+            label: null,
+          },
+        },
+      },
+    });
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const profiles = (config.llm as Record<string, unknown>).profiles as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect(profiles.balanced.label).toBeNull();
+  });
+
+  test("does NOT touch non-canonical profile names", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "my-custom": {
+            provider: "openai",
+            model: "gpt-5.4",
+            // No label — must NOT be backfilled.
+          },
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+            // Missing label — gets backfilled.
+          },
+        },
+      },
+    });
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const profiles = (config.llm as Record<string, unknown>).profiles as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect("label" in profiles["my-custom"]).toBe(false);
+    expect(profiles.balanced.label).toBe("Balanced");
+  });
+
+  test("is idempotent — second run produces no further changes", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+          },
+        },
+      },
+    });
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+    const afterFirst = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+    const afterSecond = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("no-op when config.json does not exist", () => {
+    // Fresh workspace, no config file. Migration must not throw or create
+    // the file.
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
+  });
+
+  test("no-op when llm.profiles is absent", () => {
+    writeConfig({ llm: { default: { provider: "anthropic" } } });
+    const before = readFileSync(join(workspaceDir, "config.json"), "utf-8");
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+    const after = readFileSync(join(workspaceDir, "config.json"), "utf-8");
+    expect(after).toBe(before);
+  });
+
+  test("ignores malformed config.json without throwing", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "{ not valid json");
+    // Should not throw.
+    expect(() =>
+      backfillManagedProfileLabelsMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+
+  test("does NOT skip when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    // Unlike the seed migrations (040/046/052/054/...), this is a forward
+    // data repair that runs regardless. Platform-supplied overlay labels
+    // already win at the profile level (the on-disk entry has a `label`
+    // key, so this migration leaves it alone). Skipping the whole
+    // migration when the env var is set would leave migration-052 holes
+    // unhealed on platform-style hatches.
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+          },
+        },
+      },
+    });
+
+    try {
+      backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+      const config = readConfig();
+      const profiles = (config.llm as Record<string, unknown>)
+        .profiles as Record<string, Record<string, unknown>>;
+      expect(profiles.balanced.label).toBe("Balanced");
+    } finally {
+      delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+    }
+  });
+});

package/src/__tests__/workspace-migration-085-memory-v2-bm25-b-reembed-disabled-v2-pages.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Tests for workspace migration
+ * `085-memory-v2-bm25-b-reembed-disabled-v2-pages`.
+ *
+ * Re-enqueues `memory_v2_reembed` for workspaces with v2 concept pages,
+ * gated on (a) concept pages existing on disk and (b) v2 not being
+ * explicitly disabled in config.json. Migration 075 already shipped
+ * un-gated, so this follow-up runs with the gating we want now.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { memoryV2Bm25BDefaultReembedMigration } from "../workspace/migrations/075-memory-v2-bm25-b-default-reembed.js";
+import { memoryV2Bm25BReembedDisabledV2PagesMigration } from "../workspace/migrations/085-memory-v2-bm25-b-reembed-disabled-v2-pages.js";
+
+let workspaceDir: string;
+let dbPath: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-085-test-"));
+  const dbDir = join(workspaceDir, "data", "db");
+  mkdirSync(dbDir, { recursive: true });
+  dbPath = join(dbDir, "assistant.db");
+
+  const db = new Database(dbPath);
+  db.run(`
+    CREATE TABLE memory_jobs (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      status TEXT NOT NULL,
+      attempts INTEGER NOT NULL,
+      deferrals INTEGER NOT NULL,
+      run_after INTEGER NOT NULL,
+      last_error TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  db.close();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function seedConceptPage(relativePath: string): void {
+  const fullPath = join(workspaceDir, "memory", "concepts", relativePath);
+  mkdirSync(dirname(fullPath), { recursive: true });
+  writeFileSync(fullPath, "---\nedges: []\n---\nbody\n", "utf-8");
+}
+
+function writeConfig(content: object): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(content),
+    "utf-8",
+  );
+}
+
+function countReembedJobs(): number {
+  const db = new Database(dbPath);
+  try {
+    const row = db
+      .query(
+        `SELECT COUNT(*) AS n FROM memory_jobs WHERE type='memory_v2_reembed'`,
+      )
+      .get() as { n: number };
+    return row.n;
+  } finally {
+    db.close();
+  }
+}
+
+function insertReembedJob(id: string, status: string): void {
+  const db = new Database(dbPath);
+  try {
+    db.run(
+      `INSERT INTO memory_jobs
+         (id, type, payload, status, attempts, deferrals, run_after, last_error, created_at, updated_at)
+       VALUES (?, 'memory_v2_reembed', '{}', ?, 0, 0, 0, NULL, 0, 0)`,
+      [id, status],
+    );
+  } finally {
+    db.close();
+  }
+}
+
+function jobIdsByStatus(status: string): string[] {
+  const db = new Database(dbPath);
+  try {
+    const rows = db
+      .query(
+        `SELECT id FROM memory_jobs WHERE type='memory_v2_reembed' AND status=? ORDER BY id`,
+      )
+      .all(status) as { id: string }[];
+    return rows.map((r) => r.id);
+  } finally {
+    db.close();
+  }
+}
+
+describe("085-memory-v2-bm25-b-reembed-disabled-v2-pages migration", () => {
+  test("skips enqueue when memory/concepts/ does not exist", () => {
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(0);
+  });
+
+  test("skips enqueue when memory/concepts/ is empty", () => {
+    mkdirSync(join(workspaceDir, "memory", "concepts"), { recursive: true });
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(0);
+  });
+
+  test("enqueues when a top-level concept page exists", () => {
+    seedConceptPage("alice.md");
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(1);
+  });
+
+  test("enqueues when only a nested concept page exists", () => {
+    seedConceptPage("people/alice.md");
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(1);
+  });
+
+  test("skips enqueue when memory.v2.enabled is explicitly false", () => {
+    seedConceptPage("alice.md");
+    writeConfig({ memory: { v2: { enabled: false } } });
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(0);
+  });
+
+  test("enqueues when config.json exists but memory.v2.enabled is not set", () => {
+    seedConceptPage("alice.md");
+    writeConfig({ memory: {} });
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(1);
+  });
+
+  test("enqueues when memory.v2.enabled is explicitly true", () => {
+    seedConceptPage("alice.md");
+    writeConfig({ memory: { v2: { enabled: true } } });
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(1);
+  });
+
+  test("does not duplicate when a pending reembed job already exists", () => {
+    seedConceptPage("alice.md");
+    insertReembedJob("pre-existing", "pending");
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(1);
+  });
+
+  test("cancels pending reembed job when memory.v2.enabled is false", () => {
+    seedConceptPage("alice.md");
+    writeConfig({ memory: { v2: { enabled: false } } });
+    insertReembedJob("from-075", "pending");
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(0);
+  });
+
+  test("cancels pending reembed job when no concept pages exist", () => {
+    insertReembedJob("from-075", "pending");
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(0);
+  });
+
+  test("leaves running reembed job alone when v2 is disabled", () => {
+    seedConceptPage("alice.md");
+    writeConfig({ memory: { v2: { enabled: false } } });
+    insertReembedJob("in-flight", "running");
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(jobIdsByStatus("running")).toEqual(["in-flight"]);
+    expect(jobIdsByStatus("pending")).toEqual([]);
+  });
+
+  test("is idempotent when re-run with v2 disabled and no pending jobs", () => {
+    seedConceptPage("alice.md");
+    writeConfig({ memory: { v2: { enabled: false } } });
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(0);
+  });
+
+  test("end-to-end: 075 enqueues, 085 cancels when v2 disabled with concept pages", () => {
+    seedConceptPage("alice.md");
+    writeConfig({ memory: { v2: { enabled: false } } });
+    memoryV2Bm25BDefaultReembedMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(1);
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(0);
+  });
+
+  test("end-to-end: 075 enqueues, 085 cancels when no concept pages exist", () => {
+    memoryV2Bm25BDefaultReembedMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(1);
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(0);
+  });
+
+  test("end-to-end: 075 enqueues, 085 keeps single job when gates pass", () => {
+    seedConceptPage("alice.md");
+    memoryV2Bm25BDefaultReembedMigration.run(workspaceDir);
+    memoryV2Bm25BReembedDisabledV2PagesMigration.run(workspaceDir);
+    expect(countReembedJobs()).toBe(1);
+  });
+});