@vellumai/assistant 0.8.1 → 0.8.2

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);
+  });
+});

package/src/__tests__/workspace-migration-086-revert-stale-gemini-mis-rewrites.test.ts

@@ -0,0 +1,269 @@
+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 { revertStaleGeminiMisRewritesMigration } from "../workspace/migrations/086-revert-stale-gemini-mis-rewrites.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-086-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"));
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("086-revert-stale-gemini-mis-rewrites migration", () => {
+  test("registered in WORKSPACE_MIGRATIONS", () => {
+    expect(WORKSPACE_MIGRATIONS).toContain(
+      revertStaleGeminiMisRewritesMigration,
+    );
+  });
+
+  test("reverts call-site model when 057 rewrote on non-Gemini default", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "ollama", model: "llama3.2" },
+        callSites: {
+          recall: { model: "gemini-3-flash-preview" },
+        },
+      },
+    });
+
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: { recall: { model: string } } };
+    };
+    expect(config.llm.callSites.recall.model).toBe("gemini-3-flash");
+  });
+
+  test("reverts latency call-site model when default is openrouter", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openrouter", model: "x-ai/grok-4" },
+        callSites: {
+          memoryRetrieval: { model: "gemini-3.1-flash-lite-preview" },
+        },
+      },
+    });
+
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: { memoryRetrieval: { model: string } } };
+    };
+    expect(config.llm.callSites.memoryRetrieval.model).toBe("gemini-3-flash");
+  });
+
+  test("does not revert when default provider is Gemini", () => {
+    const before = {
+      llm: {
+        default: { provider: "gemini", model: "gemini-3-flash-preview" },
+        callSites: {
+          recall: { model: "gemini-3-flash-preview" },
+        },
+      },
+    };
+    writeConfig(before);
+    const beforeRaw = readFileSync(configPath(), "utf-8");
+
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath(), "utf-8")).toBe(beforeRaw);
+  });
+
+  test("does not revert when fragment has an explicit provider", () => {
+    const before = {
+      llm: {
+        default: { provider: "ollama", model: "llama3.2" },
+        callSites: {
+          recall: { provider: "gemini", model: "gemini-3-flash-preview" },
+        },
+      },
+    };
+    writeConfig(before);
+    const beforeRaw = readFileSync(configPath(), "utf-8");
+
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath(), "utf-8")).toBe(beforeRaw);
+  });
+
+  test("does not revert when site profile carries Gemini context via catalog", () => {
+    const before = {
+      llm: {
+        default: { provider: "ollama", model: "llama3.2" },
+        profiles: {
+          custom: { model: "gemini-2.5-pro" },
+        },
+        callSites: {
+          recall: { profile: "custom", model: "gemini-3-flash-preview" },
+        },
+      },
+    };
+    writeConfig(before);
+    const beforeRaw = readFileSync(configPath(), "utf-8");
+
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath(), "utf-8")).toBe(beforeRaw);
+  });
+
+  test("reverts profile fragment when default provider is non-Gemini", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openrouter", model: "x-ai/grok-4" },
+        profiles: {
+          custom: { model: "gemini-3-flash-preview" },
+        },
+      },
+    });
+
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { profiles: { custom: { model: string } } };
+    };
+    expect(config.llm.profiles.custom.model).toBe("gemini-3-flash");
+  });
+
+  test("reverts both profile and call-site when call-site references a candidate profile", () => {
+    // Regression for ordering bug: if profile reversion ran after call-site
+    // evaluation, the call-site would see the profile's pre-revert rewritten
+    // model and infer a Gemini context, masking its own need to revert.
+    writeConfig({
+      llm: {
+        default: { provider: "ollama", model: "llama3.2" },
+        profiles: {
+          custom: { model: "gemini-3-flash-preview" },
+        },
+        callSites: {
+          recall: { profile: "custom", model: "gemini-3-flash-preview" },
+        },
+      },
+    });
+
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: {
+        profiles: { custom: { model: string } };
+        callSites: { recall: { model: string; profile: string } };
+      };
+    };
+    expect(config.llm.profiles.custom.model).toBe("gemini-3-flash");
+    expect(config.llm.callSites.recall.model).toBe("gemini-3-flash");
+  });
+
+  test("mainAgent revert uses activeProfile over call-site for context", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "gemini", model: "gemini-3-flash-preview" },
+        activeProfile: "ollamaActive",
+        profiles: {
+          ollamaActive: { provider: "ollama", model: "llama3.2" },
+        },
+        callSites: {
+          mainAgent: { model: "gemini-3-flash-preview" },
+        },
+      },
+    });
+
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: { mainAgent: { model: string } } };
+    };
+    // For mainAgent the active profile sits above the call-site, so an
+    // Ollama active profile dominates the Gemini default and the rewrite
+    // must be reverted.
+    expect(config.llm.callSites.mainAgent.model).toBe("gemini-3-flash");
+  });
+
+  test("non-mainAgent ignores activeProfile when site.profile is Gemini", () => {
+    const before = {
+      llm: {
+        default: { provider: "ollama", model: "llama3.2" },
+        activeProfile: "alsoOllama",
+        profiles: {
+          alsoOllama: { provider: "ollama", model: "llama3.2" },
+          geminiProfile: {
+            provider: "gemini",
+            model: "gemini-3-flash-preview",
+          },
+        },
+        callSites: {
+          recall: { profile: "geminiProfile", model: "gemini-3-flash-preview" },
+        },
+      },
+    };
+    writeConfig(before);
+    const beforeRaw = readFileSync(configPath(), "utf-8");
+
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath(), "utf-8")).toBe(beforeRaw);
+  });
+
+  test("no-op when config.json is missing", () => {
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+    expect(existsSync(configPath())).toBe(false);
+  });
+
+  test("no-op on malformed config", () => {
+    writeFileSync(configPath(), "{not json");
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+    expect(readFileSync(configPath(), "utf-8")).toBe("{not json");
+  });
+
+  test("idempotent: re-running after revert is a no-op", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "ollama", model: "llama3.2" },
+        callSites: {
+          recall: { model: "gemini-3-flash-preview" },
+        },
+      },
+    });
+
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+    const afterFirst = readFileSync(configPath(), "utf-8");
+    revertStaleGeminiMisRewritesMigration.run(workspaceDir);
+    expect(readFileSync(configPath(), "utf-8")).toBe(afterFirst);
+  });
+});