@vellumai/assistant 0.7.0 → 0.7.1

package/src/ipc/routes/__tests__/memory-v2-validate.test.ts

@@ -1,219 +0,0 @@
-/**
- * Tests for the `memory_v2/validate` IPC route.
- *
- * The route is read-only — it walks `memory/concepts/<slug>.md` and
- * `memory/edges.json`, returning per-page parse failures, oversized pages,
- * and broken edge endpoints. We exercise three scenarios:
- *   1. clean workspace: zero violations across all categories.
- *   2. broken edges: an edge whose endpoint has no concept page surfaces under
- *      `missingEdgeEndpoints`.
- *   3. oversized page: a body exceeding `memory.v2.max_page_chars` surfaces
- *      under `oversizedPages` (we override the cap via a config.json fixture
- *      so the test stays small).
- *   4. parse failure: a concept page with malformed YAML frontmatter surfaces
- *      under `parseFailures` without aborting the rest of the report.
- *
- * Tests run against the per-file temp workspace set up by
- * `assistant/src/__tests__/test-preload.ts` (VELLUM_WORKSPACE_DIR points at a
- * mkdtemp dir). They never touch `~/.vellum/`.
- */
-
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { invalidateConfigCache } from "../../../config/loader.js";
-import { writeEdges } from "../../../memory/v2/edges.js";
-import { writePage } from "../../../memory/v2/page-store.js";
-import { ROUTES as memoryV2Routes } from "../../../runtime/routes/memory-v2-routes.js";
-import { getWorkspaceDir } from "../../../util/platform.js";
-
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-
-/** Cast the route result to the documented shape for ergonomic assertions. */
-type ValidateResult = {
-  pageCount: number;
-  edgeCount: number;
-  missingEdgeEndpoints: { from: string; to: string }[];
-  oversizedPages: { slug: string; chars: number }[];
-  parseFailures: { slug: string; error: string }[];
-};
-
-const validateRoute = memoryV2Routes.find(r => r.operationId === "memory_v2_validate")!;
-
-async function runRoute(
-  params: Record<string, unknown> = {},
-): Promise<ValidateResult> {
-  return (await validateRoute.handler({ body: params })) as ValidateResult;
-}
-
-function workspace(): string {
-  return getWorkspaceDir();
-}
-
-function memoryDir(): string {
-  return join(workspace(), "memory");
-}
-
-/**
- * Write a `config.json` that overrides a specific config path. Mirrors what
- * the user's `~/.vellum/workspace/config.json` looks like in production. We
- * invalidate the loader cache after each write so the test sees fresh values.
- */
-function writeWorkspaceConfig(json: Record<string, unknown>): void {
-  mkdirSync(workspace(), { recursive: true });
-  writeFileSync(
-    join(workspace(), "config.json"),
-    JSON.stringify(json, null, 2),
-    "utf-8",
-  );
-  invalidateConfigCache();
-}
-
-// ---------------------------------------------------------------------------
-// Test isolation — each test starts with a fresh memory/ tree under the
-// per-file temp workspace, plus a clean config cache so loadConfig() picks up
-// any fixture written below.
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  rmSync(memoryDir(), { recursive: true, force: true });
-  rmSync(join(workspace(), "config.json"), { force: true });
-  invalidateConfigCache();
-  mkdirSync(join(memoryDir(), "concepts"), { recursive: true });
-});
-
-afterEach(() => {
-  rmSync(memoryDir(), { recursive: true, force: true });
-  rmSync(join(workspace(), "config.json"), { force: true });
-  invalidateConfigCache();
-});
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("memory_v2_validate route", () => {
-  test("operationId is 'memory_v2_validate'", () => {
-    expect(validateRoute.operationId).toBe("memory_v2_validate");
-  });
-
-  test("rejects unknown params", async () => {
-    await expect(runRoute({ extra: 1 })).rejects.toThrow();
-  });
-
-  test("clean workspace returns zero violations", async () => {
-    await writePage(workspace(), {
-      slug: "alice",
-      frontmatter: { edges: ["bob"], ref_files: [] },
-      body: "Alice prefers VS Code.",
-    });
-    await writePage(workspace(), {
-      slug: "bob",
-      frontmatter: { edges: ["alice"], ref_files: [] },
-      body: "Bob prefers vim.",
-    });
-    await writeEdges(workspace(), {
-      version: 1,
-      edges: [["alice", "bob"]],
-    });
-
-    const result = await runRoute();
-
-    expect(result.pageCount).toBe(2);
-    expect(result.edgeCount).toBe(1);
-    expect(result.missingEdgeEndpoints).toEqual([]);
-    expect(result.oversizedPages).toEqual([]);
-    expect(result.parseFailures).toEqual([]);
-  });
-
-  test("clean empty workspace reports zero of everything", async () => {
-    const result = await runRoute();
-
-    expect(result).toEqual({
-      pageCount: 0,
-      edgeCount: 0,
-      missingEdgeEndpoints: [],
-      oversizedPages: [],
-      parseFailures: [],
-    });
-  });
-
-  test("missing edge endpoint surfaces with both slugs", async () => {
-    await writePage(workspace(), {
-      slug: "alice",
-      frontmatter: { edges: [], ref_files: [] },
-      body: "Alice page only.",
-    });
-    // `bob` is referenced by the edge but no concept page exists for it.
-    await writeEdges(workspace(), {
-      version: 1,
-      edges: [["alice", "bob"]],
-    });
-
-    const result = await runRoute();
-
-    expect(result.pageCount).toBe(1);
-    expect(result.edgeCount).toBe(1);
-    expect(result.missingEdgeEndpoints).toEqual([{ from: "alice", to: "bob" }]);
-    expect(result.oversizedPages).toEqual([]);
-    expect(result.parseFailures).toEqual([]);
-  });
-
-  test("oversized page surfaces under oversizedPages", async () => {
-    // Override max_page_chars to a tiny value so we can exceed it cheaply
-    // without writing a 5KB body. Weights are unchanged from defaults.
-    writeWorkspaceConfig({
-      memory: { v2: { max_page_chars: 32 } },
-    });
-
-    await writePage(workspace(), {
-      slug: "tiny",
-      frontmatter: { edges: [], ref_files: [] },
-      body: "x".repeat(50),
-    });
-    await writePage(workspace(), {
-      slug: "fits",
-      frontmatter: { edges: [], ref_files: [] },
-      body: "ok",
-    });
-
-    const result = await runRoute();
-
-    expect(result.pageCount).toBe(2);
-    expect(result.oversizedPages).toEqual([{ slug: "tiny", chars: 50 }]);
-    expect(result.parseFailures).toEqual([]);
-  });
-
-  test("parse failure surfaces without aborting other categories", async () => {
-    // Hand-write a page with malformed YAML in the frontmatter — readPage
-    // will throw. The route must capture that and continue.
-    writeFileSync(
-      join(memoryDir(), "concepts", "broken.md"),
-      "---\nedges: [unterminated\n---\nbody",
-      "utf-8",
-    );
-    await writePage(workspace(), {
-      slug: "ok",
-      frontmatter: { edges: [], ref_files: [] },
-      body: "Healthy page.",
-    });
-    // Edge points at the broken page so we also exercise the missing-endpoint
-    // path: the broken page is not in `knownSlugs`, so the edge is reported.
-    await writeEdges(workspace(), {
-      version: 1,
-      edges: [["broken", "ok"]],
-    });
-
-    const result = await runRoute();
-
-    expect(result.pageCount).toBe(1);
-    expect(result.edgeCount).toBe(1);
-    expect(result.parseFailures).toHaveLength(1);
-    expect(result.parseFailures[0]?.slug).toBe("broken");
-    expect(result.parseFailures[0]?.error).toBeTruthy();
-    expect(result.missingEdgeEndpoints).toEqual([{ from: "broken", to: "ok" }]);
-  });
-});

package/src/memory/v2/__tests__/edges.test.ts

@@ -1,435 +0,0 @@
-/**
- * Tests for `memory/v2/edges.ts` — the read/write/neighbor primitives over
- * `memory/edges.json`.
- *
- * Tests live in temp workspaces (mkdtemp) and never touch `~/.vellum/`.
- * Slug names use generic placeholders (`alice`, `bob`, `topic-x`, ...).
- */
-
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readdirSync,
-  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 {
-  addEdge,
-  getNeighbors,
-  readEdges,
-  removeEdge,
-  validateEdges,
-  writeEdges,
-} from "../edges.js";
-import type { EdgesIndex } from "../types.js";
-
-let workspaceDir: string;
-
-beforeEach(() => {
-  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-memory-v2-edges-test-"));
-});
-
-afterEach(() => {
-  if (existsSync(workspaceDir)) {
-    rmSync(workspaceDir, { recursive: true, force: true });
-  }
-});
-
-function edgesFile(): string {
-  return join(workspaceDir, "memory", "edges.json");
-}
-
-function readEdgesFileRaw(): unknown {
-  return JSON.parse(readFileSync(edgesFile(), "utf-8"));
-}
-
-// ---------------------------------------------------------------------------
-// readEdges
-// ---------------------------------------------------------------------------
-
-describe("readEdges", () => {
-  test("returns empty index when memory/edges.json is missing", async () => {
-    const idx = await readEdges(workspaceDir);
-    expect(idx).toEqual({ version: 1, edges: [] });
-  });
-
-  test("reads and validates an existing edges.json", async () => {
-    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
-    const fixture: EdgesIndex = {
-      version: 1,
-      edges: [
-        ["alice", "bob"],
-        ["bob", "carol"],
-      ],
-    };
-    writeFileSync(edgesFile(), JSON.stringify(fixture), "utf-8");
-    const idx = await readEdges(workspaceDir);
-    expect(idx).toEqual(fixture);
-  });
-
-  test("throws on schema violation (e.g. wrong version)", async () => {
-    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
-    writeFileSync(
-      edgesFile(),
-      JSON.stringify({ version: 2, edges: [] }),
-      "utf-8",
-    );
-    await expect(readEdges(workspaceDir)).rejects.toThrow();
-  });
-
-  test("throws on malformed JSON", async () => {
-    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
-    writeFileSync(edgesFile(), "not-json", "utf-8");
-    await expect(readEdges(workspaceDir)).rejects.toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// writeEdges
-// ---------------------------------------------------------------------------
-
-describe("writeEdges", () => {
-  test("creates memory/ if missing and writes the canonical empty index", async () => {
-    await writeEdges(workspaceDir, { version: 1, edges: [] });
-    expect(readEdgesFileRaw()).toEqual({ version: 1, edges: [] });
-  });
-
-  test("canonicalizes each tuple to [min, max] alphabetical-first ordering", async () => {
-    await writeEdges(workspaceDir, {
-      version: 1,
-      edges: [
-        ["bob", "alice"],
-        ["delta", "carol"],
-      ],
-    });
-    expect(readEdgesFileRaw()).toEqual({
-      version: 1,
-      edges: [
-        ["alice", "bob"],
-        ["carol", "delta"],
-      ],
-    });
-  });
-
-  test("dedupes tuples that collapse to the same canonical form", async () => {
-    await writeEdges(workspaceDir, {
-      version: 1,
-      edges: [
-        ["alice", "bob"],
-        ["bob", "alice"],
-        ["alice", "bob"],
-      ],
-    });
-    expect(readEdgesFileRaw()).toEqual({
-      version: 1,
-      edges: [["alice", "bob"]],
-    });
-  });
-
-  test("drops self-loops on write", async () => {
-    await writeEdges(workspaceDir, {
-      version: 1,
-      edges: [
-        ["alice", "alice"],
-        ["alice", "bob"],
-      ],
-    });
-    expect(readEdgesFileRaw()).toEqual({
-      version: 1,
-      edges: [["alice", "bob"]],
-    });
-  });
-
-  test("emits deterministically-sorted output regardless of input order", async () => {
-    await writeEdges(workspaceDir, {
-      version: 1,
-      edges: [
-        ["zeta", "yankee"],
-        ["alice", "bob"],
-        ["mike", "lima"],
-      ],
-    });
-    const reread = readEdgesFileRaw() as EdgesIndex;
-    expect(reread.edges).toEqual([
-      ["alice", "bob"],
-      ["lima", "mike"],
-      ["yankee", "zeta"],
-    ]);
-  });
-
-  test("write-then-read round-trip preserves a non-trivial graph", async () => {
-    const original: EdgesIndex = {
-      version: 1,
-      edges: [
-        ["alice", "bob"],
-        ["bob", "carol"],
-        ["carol", "delta"],
-        ["alice", "delta"],
-      ],
-    };
-    await writeEdges(workspaceDir, original);
-    const reread = await readEdges(workspaceDir);
-    // Edges may be reordered by canonicalization, but content is identical.
-    expect(new Set(reread.edges.map((e) => e.join("\u0000")))).toEqual(
-      new Set(original.edges.map((e) => e.join("\u0000"))),
-    );
-  });
-
-  test("atomic: leaves no .tmp file behind on success", async () => {
-    await writeEdges(workspaceDir, {
-      version: 1,
-      edges: [["alice", "bob"]],
-    });
-    const stragglers = readdirSync(join(workspaceDir, "memory")).filter((n) =>
-      n.startsWith("edges.json.tmp-"),
-    );
-    expect(stragglers).toEqual([]);
-  });
-
-  test("atomic: a concurrent reader observes the prior file until rename completes", async () => {
-    // Seed with a known-good prior file.
-    const prior: EdgesIndex = {
-      version: 1,
-      edges: [["alice", "bob"]],
-    };
-    await writeEdges(workspaceDir, prior);
-
-    // Race a write against many reads. Each read must observe a fully-formed
-    // index — never a partial JSON document.
-    const next: EdgesIndex = {
-      version: 1,
-      edges: [
-        ["alice", "bob"],
-        ["carol", "delta"],
-      ],
-    };
-    const writePromise = writeEdges(workspaceDir, next);
-    const reads = Array.from({ length: 20 }, () => readEdges(workspaceDir));
-    const results = await Promise.all([writePromise, ...reads]);
-
-    // Skip the write result (undefined); every read returns one of the two
-    // valid indices.
-    const possibilities = [
-      JSON.stringify(prior),
-      JSON.stringify({
-        version: 1,
-        edges: [
-          ["alice", "bob"],
-          ["carol", "delta"],
-        ],
-      }),
-    ];
-    for (const r of results.slice(1) as EdgesIndex[]) {
-      expect(possibilities).toContain(JSON.stringify(r));
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// addEdge / removeEdge
-// ---------------------------------------------------------------------------
-
-describe("addEdge", () => {
-  const empty: EdgesIndex = { version: 1, edges: [] };
-
-  test("adds a new edge in canonical form", () => {
-    const next = addEdge(empty, "bob", "alice");
-    expect(next.edges).toEqual([["alice", "bob"]]);
-  });
-
-  test("does not duplicate an existing edge regardless of argument order", () => {
-    const once = addEdge(empty, "alice", "bob");
-    const twice = addEdge(once, "bob", "alice");
-    expect(twice).toBe(once);
-  });
-
-  test("rejects self-loops", () => {
-    expect(() => addEdge(empty, "alice", "alice")).toThrow();
-  });
-
-  test("does not mutate the input index", () => {
-    const idx: EdgesIndex = { version: 1, edges: [["alice", "bob"]] };
-    const next = addEdge(idx, "carol", "delta");
-    expect(idx.edges).toEqual([["alice", "bob"]]);
-    expect(next.edges).toEqual([
-      ["alice", "bob"],
-      ["carol", "delta"],
-    ]);
-  });
-});
-
-describe("removeEdge", () => {
-  test("removes an edge regardless of argument order", () => {
-    const idx: EdgesIndex = {
-      version: 1,
-      edges: [
-        ["alice", "bob"],
-        ["bob", "carol"],
-      ],
-    };
-    const next = removeEdge(idx, "bob", "alice");
-    expect(next.edges).toEqual([["bob", "carol"]]);
-  });
-
-  test("returns the same index when the edge is not present", () => {
-    const idx: EdgesIndex = { version: 1, edges: [["alice", "bob"]] };
-    const next = removeEdge(idx, "carol", "delta");
-    expect(next).toBe(idx);
-  });
-
-  test("does not mutate the input index", () => {
-    const idx: EdgesIndex = {
-      version: 1,
-      edges: [
-        ["alice", "bob"],
-        ["bob", "carol"],
-      ],
-    };
-    removeEdge(idx, "alice", "bob");
-    expect(idx.edges).toEqual([
-      ["alice", "bob"],
-      ["bob", "carol"],
-    ]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getNeighbors
-// ---------------------------------------------------------------------------
-
-describe("getNeighbors", () => {
-  // Graph used across BFS tests:
-  //
-  //   alice -- bob -- carol -- delta
-  //              \
-  //               echo
-  //
-  // (orphan: foxtrot)
-  const graph: EdgesIndex = {
-    version: 1,
-    edges: [
-      ["alice", "bob"],
-      ["bob", "carol"],
-      ["bob", "echo"],
-      ["carol", "delta"],
-    ],
-  };
-
-  test("hops=1 returns immediate neighbors only", () => {
-    expect(getNeighbors(graph, "bob", 1)).toEqual(
-      new Set(["alice", "carol", "echo"]),
-    );
-  });
-
-  test("hops=2 includes second-degree neighbors", () => {
-    // From alice: bob (1), then carol+echo (2).
-    expect(getNeighbors(graph, "alice", 2)).toEqual(
-      new Set(["bob", "carol", "echo"]),
-    );
-  });
-
-  test("hops=3 reaches the third-degree node", () => {
-    // From alice: bob (1), carol+echo (2), delta (3).
-    expect(getNeighbors(graph, "alice", 3)).toEqual(
-      new Set(["bob", "carol", "echo", "delta"]),
-    );
-  });
-
-  test("never includes the start slug", () => {
-    expect(getNeighbors(graph, "bob", 5).has("bob")).toBe(false);
-  });
-
-  test("orphan node returns the empty set", () => {
-    expect(getNeighbors(graph, "foxtrot", 5)).toEqual(new Set());
-  });
-
-  test("unknown slug returns the empty set", () => {
-    expect(getNeighbors(graph, "ghost", 3)).toEqual(new Set());
-  });
-
-  test("hops=0 returns the empty set", () => {
-    expect(getNeighbors(graph, "alice", 0)).toEqual(new Set());
-  });
-
-  test("negative hops returns the empty set without throwing", () => {
-    expect(getNeighbors(graph, "alice", -1)).toEqual(new Set());
-  });
-
-  test("a cycle is traversed without infinite-looping", () => {
-    // Triangle: alice--bob, bob--carol, carol--alice.
-    const triangle: EdgesIndex = {
-      version: 1,
-      edges: [
-        ["alice", "bob"],
-        ["bob", "carol"],
-        ["alice", "carol"],
-      ],
-    };
-    expect(getNeighbors(triangle, "alice", 5)).toEqual(
-      new Set(["bob", "carol"]),
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// validateEdges
-// ---------------------------------------------------------------------------
-
-describe("validateEdges", () => {
-  test("ok=true with empty missing list when every endpoint is known", () => {
-    const idx: EdgesIndex = {
-      version: 1,
-      edges: [
-        ["alice", "bob"],
-        ["bob", "carol"],
-      ],
-    };
-    expect(validateEdges(idx, new Set(["alice", "bob", "carol"]))).toEqual({
-      ok: true,
-      missing: [],
-    });
-  });
-
-  test("reports endpoints that are not in knownSlugs", () => {
-    const idx: EdgesIndex = {
-      version: 1,
-      edges: [
-        ["alice", "bob"],
-        ["carol", "delta"],
-      ],
-    };
-    const result = validateEdges(idx, new Set(["alice", "bob"]));
-    expect(result.ok).toBe(false);
-    expect(result.missing).toEqual(["carol", "delta"]);
-  });
-
-  test("dedupes a missing slug that appears in multiple edges", () => {
-    const idx: EdgesIndex = {
-      version: 1,
-      edges: [
-        ["alice", "ghost"],
-        ["bob", "ghost"],
-      ],
-    };
-    const result = validateEdges(idx, new Set(["alice", "bob"]));
-    expect(result.missing).toEqual(["ghost"]);
-  });
-
-  test("returns a sorted missing list for stable output", () => {
-    const idx: EdgesIndex = {
-      version: 1,
-      edges: [
-        ["zeta", "alpha"],
-        ["mike", "kilo"],
-      ],
-    };
-    const result = validateEdges(idx, new Set());
-    expect(result.missing).toEqual(["alpha", "kilo", "mike", "zeta"]);
-  });
-});