@vellumai/assistant 0.7.0 → 0.7.1

package/src/memory/v2/__tests__/backfill-jobs.test.ts

@@ -5,11 +5,9 @@
  * embedding backend, Qdrant client, activation pipeline) mocked at the
  * module level so the suite never starts a real Qdrant/embedding backend.
  *
- * Coverage matrix (PR 21 acceptance criteria):
+ * Coverage matrix:
  *   - migrate: wraps `runMemoryV2Migration`; force flag propagates;
  *     `MigrationAlreadyAppliedError` is swallowed (no rethrow).
- *   - rebuild-edges: every page's `edges:` frontmatter matches `edges.json`;
- *     `ref_files` is preserved; pages without edges get `edges: []`.
  *   - reembed: enqueues `N + 4` jobs (concept-page slugs plus four reserved
  *     meta-file slugs).
  *   - activation-recompute: walks conversations with rows, runs the pipeline
@@ -206,15 +204,13 @@ const { getDb, resetDb } = await import("../../db-connection.js");
 const { initializeDb } = await import("../../db-init.js");
 const { rawExec } = await import("../../raw-query.js");
 const { conversations, memoryJobs, messages } = await import("../../schema.js");
-const { readPage, writePage } = await import("../page-store.js");
-const { writeEdges } = await import("../edges.js");
+const { writePage } = await import("../page-store.js");
 const { save: saveActivation, hydrate: hydrateActivation } =
   await import("../activation-store.js");
 const {
   META_FILE_SLUGS,
   memoryV2ActivationRecomputeJob,
   memoryV2MigrateJob,
-  memoryV2RebuildEdgesJob,
   memoryV2ReembedJob,
 } = await import("../backfill-jobs.js");
 
@@ -230,7 +226,6 @@ const TEST_CONFIG = STUB_RUNTIME_CONFIG as Parameters<
 function makeJob(
   type:
     | "memory_v2_migrate"
-    | "memory_v2_rebuild_edges"
     | "memory_v2_reembed"
     | "memory_v2_activation_recompute",
   payload: Record<string, unknown> = {},
@@ -271,9 +266,6 @@ beforeEach(() => {
     force: true,
   });
   mkdirSync(join(tmpWorkspace, "memory", "concepts"), { recursive: true });
-  if (existsSync(join(tmpWorkspace, "memory", "edges.json"))) {
-    rmSync(join(tmpWorkspace, "memory", "edges.json"));
-  }
   for (const filename of [
     "essentials.md",
     "threads.md",
@@ -325,125 +317,6 @@ describe("memoryV2MigrateJob", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// memoryV2RebuildEdgesJob
-// ---------------------------------------------------------------------------
-
-describe("memoryV2RebuildEdgesJob", () => {
-  test("rewrites every page's edges: frontmatter from edges.json", async () => {
-    // Two pages with stale frontmatter — neither matches `edges.json`.
-    await writePage(tmpWorkspace, {
-      slug: "alice",
-      frontmatter: { edges: ["stale"], ref_files: ["alice.png"] },
-      body: "Alice prefers VS Code.\n",
-    });
-    await writePage(tmpWorkspace, {
-      slug: "bob",
-      frontmatter: { edges: [], ref_files: [] },
-      body: "Bob uses zsh.\n",
-    });
-    await writeEdges(tmpWorkspace, {
-      version: 1,
-      edges: [["alice", "bob"]],
-    });
-
-    await memoryV2RebuildEdgesJob(
-      makeJob("memory_v2_rebuild_edges"),
-      TEST_CONFIG,
-    );
-
-    const alice = await readPage(tmpWorkspace, "alice");
-    const bob = await readPage(tmpWorkspace, "bob");
-    expect(alice?.frontmatter.edges).toEqual(["bob"]);
-    expect(bob?.frontmatter.edges).toEqual(["alice"]);
-
-    // ref_files is preserved as-is — page is the source of truth there.
-    expect(alice?.frontmatter.ref_files).toEqual(["alice.png"]);
-    // Body is preserved.
-    expect(alice?.body).toBe("Alice prefers VS Code.\n");
-  });
-
-  test("sets edges: [] for pages without any edges in edges.json", async () => {
-    await writePage(tmpWorkspace, {
-      slug: "orphan",
-      frontmatter: { edges: ["should-be-removed"], ref_files: [] },
-      body: "Orphan content.\n",
-    });
-    await writeEdges(tmpWorkspace, { version: 1, edges: [] });
-
-    await memoryV2RebuildEdgesJob(
-      makeJob("memory_v2_rebuild_edges"),
-      TEST_CONFIG,
-    );
-
-    const orphan = await readPage(tmpWorkspace, "orphan");
-    expect(orphan?.frontmatter.edges).toEqual([]);
-  });
-
-  test("emits sorted neighbor lists (deterministic across reruns)", async () => {
-    await writePage(tmpWorkspace, {
-      slug: "alice",
-      frontmatter: { edges: [], ref_files: [] },
-      body: "Body.\n",
-    });
-    await writePage(tmpWorkspace, {
-      slug: "bob",
-      frontmatter: { edges: [], ref_files: [] },
-      body: "Body.\n",
-    });
-    await writePage(tmpWorkspace, {
-      slug: "carol",
-      frontmatter: { edges: [], ref_files: [] },
-      body: "Body.\n",
-    });
-    await writeEdges(tmpWorkspace, {
-      version: 1,
-      edges: [
-        ["alice", "carol"],
-        ["alice", "bob"],
-      ],
-    });
-
-    await memoryV2RebuildEdgesJob(
-      makeJob("memory_v2_rebuild_edges"),
-      TEST_CONFIG,
-    );
-
-    const alice = await readPage(tmpWorkspace, "alice");
-    expect(alice?.frontmatter.edges).toEqual(["bob", "carol"]);
-  });
-
-  test("is a no-op for pages whose frontmatter is already correct", async () => {
-    // Pre-write the page with the correct edges so the handler should leave
-    // it untouched. We can't easily observe "no rewrite happened" from the
-    // outside without instrumenting writePage, but the handler returning
-    // without error is enough to cover the early-exit branch.
-    await writePage(tmpWorkspace, {
-      slug: "alice",
-      frontmatter: { edges: ["bob"], ref_files: [] },
-      body: "Alice.\n",
-    });
-    await writePage(tmpWorkspace, {
-      slug: "bob",
-      frontmatter: { edges: ["alice"], ref_files: [] },
-      body: "Bob.\n",
-    });
-    await writeEdges(tmpWorkspace, {
-      version: 1,
-      edges: [["alice", "bob"]],
-    });
-
-    await memoryV2RebuildEdgesJob(
-      makeJob("memory_v2_rebuild_edges"),
-      TEST_CONFIG,
-    );
-
-    expect((await readPage(tmpWorkspace, "alice"))?.frontmatter.edges).toEqual([
-      "bob",
-    ]);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // memoryV2ReembedJob
 // ---------------------------------------------------------------------------

package/src/memory/v2/__tests__/consolidation-job.test.ts

@@ -136,10 +136,13 @@ const { CUTOFF_PLACEHOLDER, CONSOLIDATION_PROMPT } =
   await import("../prompts/consolidation.js");
 
 // `isAssistantFeatureFlagEnabled` ignores the `config` argument it receives
-// (resolution is purely from the overrides + registry caches), so we hand
-// the handler a minimal stand-in instead of materializing the full default
-// config.
-const CONFIG = {} as Parameters<typeof memoryV2ConsolidateJob>[1];
+// (resolution is purely from the overrides + registry caches), and the
+// resolver only reads `config.memory.v2.consolidation_prompt_path` — so a
+// minimal stand-in covers both call sites without materializing the full
+// default config.
+const CONFIG = {
+  memory: { v2: { consolidation_prompt_path: null } },
+} as Parameters<typeof memoryV2ConsolidateJob>[1];
 
 function makeJob(): Parameters<typeof memoryV2ConsolidateJob>[0] {
   return {
@@ -279,20 +282,34 @@ describe("memoryV2ConsolidateJob — flag on, non-empty buffer", () => {
     expect(hint).toContain(`${new Date().getFullYear()}`);
   });
 
-  test("enqueues memory_v2_rebuild_edges and memory_v2_reembed follow-up jobs on success", async () => {
+  test("honors memory.v2.consolidation_prompt_path override when set", async () => {
+    writeFileSync(
+      join(tmpWorkspace, "custom-prompt.md"),
+      "CUSTOM CONSOLIDATION at {{CUTOFF}}\n",
+    );
+    const overrideConfig = {
+      memory: { v2: { consolidation_prompt_path: "custom-prompt.md" } },
+    } as Parameters<typeof memoryV2ConsolidateJob>[1];
+
+    const result = await memoryV2ConsolidateJob(makeJob(), overrideConfig);
+
+    expect(result.kind).toBe("invoked");
+    const hint = wakeLastArgs?.hint as string;
+    expect(hint).toMatch(/^CUSTOM CONSOLIDATION at \d{4}-/);
+    expect(hint).not.toContain("You are running memory consolidation");
+    expect(hint).not.toContain(CUTOFF_PLACEHOLDER);
+  });
+
+  test("enqueues the memory_v2_reembed follow-up job on success", async () => {
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
     if (result.kind === "invoked") {
-      expect(result.followUpJobIds).toEqual(["job-1", "job-2"]);
+      expect(result.followUpJobIds).toEqual(["job-1"]);
     }
 
-    expect(enqueuedJobs).toHaveLength(2);
+    expect(enqueuedJobs).toHaveLength(1);
     expect(enqueuedJobs[0]).toEqual({
-      type: "memory_v2_rebuild_edges",
-      payload: {},
-    });
-    expect(enqueuedJobs[1]).toEqual({
       type: "memory_v2_reembed",
       payload: {},
     });

package/src/memory/v2/__tests__/edge-index.test.ts

@@ -0,0 +1,278 @@
+/**
+ * Tests for `memory/v2/edge-index.ts` — the in-memory directed edge index
+ * derived from concept-page frontmatter.
+ *
+ * Tests live in temp workspaces (mkdtemp) and never touch `~/.vellum/`.
+ */
+
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getEdgeIndex,
+  getReachable,
+  invalidateEdgeIndex,
+  totalEdgeCount,
+  validateEdgeTargets,
+} from "../edge-index.js";
+import { deletePage, writePage } from "../page-store.js";
+import type { ConceptPage } from "../types.js";
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-memory-v2-edge-index-"));
+});
+
+afterEach(() => {
+  invalidateEdgeIndex();
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function makePage(slug: string, edges: string[] = [], body = ""): ConceptPage {
+  return {
+    slug,
+    frontmatter: { edges, ref_files: [] },
+    body,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// getEdgeIndex
+// ---------------------------------------------------------------------------
+
+describe("getEdgeIndex", () => {
+  test("returns empty maps when no concept pages exist", async () => {
+    const idx = await getEdgeIndex(workspaceDir);
+    expect(idx.outgoing.size).toBe(0);
+    expect(idx.incoming.size).toBe(0);
+  });
+
+  test("derives outgoing and incoming adjacency from page frontmatter", async () => {
+    await writePage(workspaceDir, makePage("alice", ["bob"]));
+    await writePage(workspaceDir, makePage("bob", ["carol"]));
+    await writePage(workspaceDir, makePage("carol"));
+
+    const idx = await getEdgeIndex(workspaceDir);
+
+    expect(Array.from(idx.outgoing.get("alice") ?? new Set<string>())).toEqual([
+      "bob",
+    ]);
+    expect(Array.from(idx.outgoing.get("bob") ?? new Set<string>())).toEqual([
+      "carol",
+    ]);
+    expect(idx.outgoing.get("carol")).toBeUndefined();
+
+    expect(Array.from(idx.incoming.get("bob") ?? new Set<string>())).toEqual([
+      "alice",
+    ]);
+    expect(Array.from(idx.incoming.get("carol") ?? new Set<string>())).toEqual([
+      "bob",
+    ]);
+    expect(idx.incoming.get("alice")).toBeUndefined();
+  });
+
+  test("[A,B] and [B,A] coexist as distinct directed edges", async () => {
+    await writePage(workspaceDir, makePage("alice", ["bob"]));
+    await writePage(workspaceDir, makePage("bob", ["alice"]));
+
+    const idx = await getEdgeIndex(workspaceDir);
+
+    expect(Array.from(idx.outgoing.get("alice") ?? new Set<string>())).toEqual([
+      "bob",
+    ]);
+    expect(Array.from(idx.outgoing.get("bob") ?? new Set<string>())).toEqual([
+      "alice",
+    ]);
+    expect(Array.from(idx.incoming.get("alice") ?? new Set<string>())).toEqual([
+      "bob",
+    ]);
+    expect(Array.from(idx.incoming.get("bob") ?? new Set<string>())).toEqual([
+      "alice",
+    ]);
+  });
+
+  test("self-loops are dropped silently", async () => {
+    await writePage(workspaceDir, makePage("alice", ["alice", "bob"]));
+    await writePage(workspaceDir, makePage("bob"));
+
+    const idx = await getEdgeIndex(workspaceDir);
+
+    expect(Array.from(idx.outgoing.get("alice") ?? new Set<string>())).toEqual([
+      "bob",
+    ]);
+    expect(idx.incoming.get("alice")).toBeUndefined();
+  });
+
+  test("caches the result across calls within a workspace", async () => {
+    await writePage(workspaceDir, makePage("alice", ["bob"]));
+    await writePage(workspaceDir, makePage("bob"));
+
+    const first = await getEdgeIndex(workspaceDir);
+    const second = await getEdgeIndex(workspaceDir);
+
+    // Same instance — module-level cache returns the prior build.
+    expect(second).toBe(first);
+  });
+
+  test("writePage invalidates the cache so subsequent reads see fresh state", async () => {
+    await writePage(workspaceDir, makePage("alice", ["bob"]));
+    await writePage(workspaceDir, makePage("bob"));
+
+    const before = await getEdgeIndex(workspaceDir);
+    expect([...(before.outgoing.get("alice") ?? [])]).toEqual(["bob"]);
+
+    await writePage(workspaceDir, makePage("alice", ["bob", "carol"]));
+    await writePage(workspaceDir, makePage("carol"));
+
+    const after = await getEdgeIndex(workspaceDir);
+    expect(after).not.toBe(before);
+    expect(
+      Array.from(after.outgoing.get("alice") ?? new Set<string>()).sort(),
+    ).toEqual(["bob", "carol"]);
+  });
+
+  test("deletePage invalidates the cache", async () => {
+    await writePage(workspaceDir, makePage("alice", ["bob"]));
+    await writePage(workspaceDir, makePage("bob"));
+
+    const before = await getEdgeIndex(workspaceDir);
+    expect(before.outgoing.has("alice")).toBe(true);
+
+    await deletePage(workspaceDir, "alice");
+
+    const after = await getEdgeIndex(workspaceDir);
+    expect(after.outgoing.has("alice")).toBe(false);
+    expect(after.incoming.has("bob")).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getReachable
+// ---------------------------------------------------------------------------
+
+describe("getReachable", () => {
+  // Directed graph used across BFS tests:
+  //
+  //   alice → bob → carol → delta
+  //              ↘
+  //               echo
+  //
+  // (orphan: foxtrot)
+  async function setupGraph(): Promise<void> {
+    await writePage(workspaceDir, makePage("alice", ["bob"]));
+    await writePage(workspaceDir, makePage("bob", ["carol", "echo"]));
+    await writePage(workspaceDir, makePage("carol", ["delta"]));
+    await writePage(workspaceDir, makePage("delta"));
+    await writePage(workspaceDir, makePage("echo"));
+    await writePage(workspaceDir, makePage("foxtrot"));
+  }
+
+  test("direction='out' walks outgoing edges only", async () => {
+    await setupGraph();
+    const idx = await getEdgeIndex(workspaceDir);
+    expect(getReachable(idx, "alice", 3, "out")).toEqual(
+      new Set(["bob", "carol", "echo", "delta"]),
+    );
+  });
+
+  test("direction='in' walks incoming edges only", async () => {
+    await setupGraph();
+    const idx = await getEdgeIndex(workspaceDir);
+    expect(getReachable(idx, "delta", 3, "in")).toEqual(
+      new Set(["carol", "bob", "alice"]),
+    );
+    // Going outward from delta yields nothing — it's a sink.
+    expect(getReachable(idx, "delta", 5, "out")).toEqual(new Set());
+  });
+
+  test("hops=1 returns immediate neighbors only", async () => {
+    await setupGraph();
+    const idx = await getEdgeIndex(workspaceDir);
+    expect(getReachable(idx, "bob", 1, "out")).toEqual(
+      new Set(["carol", "echo"]),
+    );
+  });
+
+  test("never includes the start slug", async () => {
+    await setupGraph();
+    const idx = await getEdgeIndex(workspaceDir);
+    expect(getReachable(idx, "bob", 5, "out").has("bob")).toBe(false);
+  });
+
+  test("orphan node returns the empty set", async () => {
+    await setupGraph();
+    const idx = await getEdgeIndex(workspaceDir);
+    expect(getReachable(idx, "foxtrot", 5, "out")).toEqual(new Set());
+    expect(getReachable(idx, "foxtrot", 5, "in")).toEqual(new Set());
+  });
+
+  test("hops<=0 returns the empty set without throwing", async () => {
+    await setupGraph();
+    const idx = await getEdgeIndex(workspaceDir);
+    expect(getReachable(idx, "alice", 0, "out")).toEqual(new Set());
+    expect(getReachable(idx, "alice", -1, "out")).toEqual(new Set());
+  });
+
+  test("a directed cycle is traversed without infinite-looping", async () => {
+    // A → B → A (two distinct directed edges)
+    await writePage(workspaceDir, makePage("alice", ["bob"]));
+    await writePage(workspaceDir, makePage("bob", ["alice"]));
+    const idx = await getEdgeIndex(workspaceDir);
+    expect(getReachable(idx, "alice", 5, "out")).toEqual(new Set(["bob"]));
+    expect(getReachable(idx, "bob", 5, "out")).toEqual(new Set(["alice"]));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// validateEdgeTargets
+// ---------------------------------------------------------------------------
+
+describe("validateEdgeTargets", () => {
+  test("ok=true when every outgoing target has a known slug", async () => {
+    await writePage(workspaceDir, makePage("alice", ["bob"]));
+    await writePage(workspaceDir, makePage("bob"));
+
+    const idx = await getEdgeIndex(workspaceDir);
+    const result = validateEdgeTargets(idx, new Set(["alice", "bob"]));
+    expect(result).toEqual({ ok: true, missing: [] });
+  });
+
+  test("flags outgoing targets that don't correspond to a known slug", async () => {
+    await writePage(workspaceDir, makePage("alice", ["ghost", "bob"]));
+    await writePage(workspaceDir, makePage("bob", ["phantom"]));
+
+    const idx = await getEdgeIndex(workspaceDir);
+    const result = validateEdgeTargets(idx, new Set(["alice", "bob"]));
+
+    expect(result.ok).toBe(false);
+    expect(result.missing).toEqual([
+      { from: "alice", to: "ghost" },
+      { from: "bob", to: "phantom" },
+    ]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// totalEdgeCount
+// ---------------------------------------------------------------------------
+
+describe("totalEdgeCount", () => {
+  test("returns the sum of every page's outgoing fanout", async () => {
+    await writePage(workspaceDir, makePage("alice", ["bob", "carol"]));
+    await writePage(workspaceDir, makePage("bob", ["carol"]));
+    await writePage(workspaceDir, makePage("carol"));
+
+    const idx = await getEdgeIndex(workspaceDir);
+    expect(totalEdgeCount(idx)).toBe(3);
+  });
+
+  test("returns 0 for an empty graph", async () => {
+    const idx = await getEdgeIndex(workspaceDir);
+    expect(totalEdgeCount(idx)).toBe(0);
+  });
+});