@vellumai/assistant 0.8.9-staging.2 → 0.8.9-staging.4

package/src/plugins/defaults/memory-v3-shadow/__tests__/health.test.ts

@@ -1,219 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { computeV3Health, renderV3Health } from "../health.js";
-import type { LeafNode, LeafPath, LeafTree, Slug } from "../types.js";
-
-/** Build an in-memory leaf node with the given members. */
-function leaf(path: LeafPath, members: Slug[]): LeafNode {
-  return {
-    path,
-    frontmatter: { path, in_core: false },
-    description: "",
-    members: [...members],
-    domain: path.split("/")[0],
-  };
-}
-
-/**
- * Build a {@link LeafTree} from `{ leafPath: members[] }`. `byPage` is the
- * inverted membership map, matching what `loadLeafTree` produces.
- */
-function tree(spec: Record<LeafPath, Slug[]>): LeafTree {
-  const leaves = new Map<LeafPath, LeafNode>();
-  const byPage = new Map<Slug, LeafPath[]>();
-  for (const [path, members] of Object.entries(spec)) {
-    leaves.set(path, leaf(path, members));
-    for (const slug of members) {
-      const existing = byPage.get(slug);
-      if (existing) existing.push(path);
-      else byPage.set(slug, [path]);
-    }
-  }
-  return { leaves, byPage };
-}
-
-describe("computeV3Health", () => {
-  test("flags unassigned slugs (in neither byPage nor a leaf)", () => {
-    const t = tree({ "domain-a/topic-x": ["page-a"] });
-    const report = computeV3Health({
-      tree: t,
-      allSlugs: ["page-a", "page-b", "page-c"],
-    });
-    expect(report.unassigned).toEqual(["page-b", "page-c"]);
-  });
-
-  test("excludes synthetic capability slugs from unassigned / novel clusters", () => {
-    const t = tree({ "domain-a/topic-x": ["page-a"] });
-    const report = computeV3Health({
-      tree: t,
-      allSlugs: ["page-a", "page-b", "cli-commands/example", "skills/example"],
-    });
-    // Capability slugs are handled by the always-on capabilities leaf (injected
-    // into the live lane tree, absent here), not the persisted tree — so they must
-    // not be reported as unassigned or grouped into novel clusters. page-b is the
-    // one real unassigned concept page.
-    expect(report.unassigned).toEqual(["page-b"]);
-    expect(report.novelClusters).toEqual([
-      { prefix: "page-b", slugs: ["page-b"], count: 1 },
-    ]);
-  });
-
-  test("flags dangling page refs pointing at missing leaves", () => {
-    const t = tree({ "domain-a/topic-x": ["page-a"] });
-    const report = computeV3Health({
-      tree: t,
-      allSlugs: ["page-a", "page-b"],
-      pageRefs: new Map([
-        ["page-a", ["domain-a/topic-x"]],
-        ["page-b", ["domain-a/topic-missing"]],
-      ]),
-    });
-    expect(report.danglingRefs).toEqual([
-      { source: "page-b", leaf: "domain-a/topic-missing" },
-    ]);
-  });
-
-  test("flags dangling core refs", () => {
-    const t = tree({ "domain-a/topic-x": ["page-a"] });
-    const report = computeV3Health({
-      tree: t,
-      allSlugs: ["page-a"],
-      core: new Set(["domain-a/topic-x", "domain-z/gone"]),
-    });
-    expect(report.danglingRefs).toEqual([
-      { source: "core", leaf: "domain-z/gone" },
-    ]);
-  });
-
-  test("groups unassigned slugs into novel clusters by 2-level prefix", () => {
-    const t = tree({ "domain-a/topic-x": ["assigned"] });
-    const report = computeV3Health({
-      tree: t,
-      allSlugs: [
-        "assigned",
-        "area-a/topic-x/one",
-        "area-a/topic-x/two",
-        "area-b/topic-y",
-      ],
-    });
-    expect(report.novelClusters).toEqual([
-      {
-        prefix: "area-a/topic-x",
-        slugs: ["area-a/topic-x/one", "area-a/topic-x/two"],
-        count: 2,
-      },
-      { prefix: "area-b/topic-y", slugs: ["area-b/topic-y"], count: 1 },
-    ]);
-  });
-
-  test("flags oversized leaves above 3x the median member count", () => {
-    // Medians: counts [1,1,1,12] -> sorted median = (1+1)/2 = 1; threshold 3.
-    const t = tree({
-      "domain-a/small-1": ["s1"],
-      "domain-a/small-2": ["s2"],
-      "domain-a/small-3": ["s3"],
-      "domain-a/big": Array.from({ length: 12 }, (_, i) => `b${i}`),
-    });
-    const report = computeV3Health({ tree: t, allSlugs: [] });
-    expect(report.oversizedLeaves).toEqual([
-      { leaf: "domain-a/big", members: 12 },
-    ]);
-  });
-
-  test("flags tiny leaves with 0-1 members", () => {
-    const t = tree({
-      "domain-a/empty": [],
-      "domain-a/single": ["s1"],
-      "domain-a/full": ["a", "b", "c"],
-    });
-    const report = computeV3Health({ tree: t, allSlugs: [] });
-    expect(report.tinyLeaves).toEqual([
-      { leaf: "domain-a/empty", members: 0 },
-      { leaf: "domain-a/single", members: 1 },
-    ]);
-  });
-
-  test("staleLabels is deferred (always empty)", () => {
-    const t = tree({ "domain-a/topic-x": ["page-a"] });
-    const report = computeV3Health({ tree: t, allSlugs: ["page-a"] });
-    expect(report.staleLabels).toEqual([]);
-  });
-
-  test("passes lastMaintain through", () => {
-    const t = tree({ "domain-a/topic-x": ["page-a"] });
-    const report = computeV3Health({
-      tree: t,
-      allSlugs: ["page-a"],
-      lastMaintain: { at: 12345, ok: true },
-    });
-    expect(report.lastMaintain).toEqual({ at: 12345, ok: true });
-  });
-
-  test("does not mutate inputs", () => {
-    const t = tree({ "domain-a/topic-x": ["page-a", "page-b"] });
-    const allSlugs = ["page-a", "page-c"];
-    computeV3Health({ tree: t, allSlugs });
-    expect(allSlugs).toEqual(["page-a", "page-c"]);
-    expect(t.leaves.get("domain-a/topic-x")?.members).toEqual([
-      "page-a",
-      "page-b",
-    ]);
-  });
-});
-
-describe("renderV3Health", () => {
-  test("returns empty string when all-green", () => {
-    // A perfectly balanced tree: every leaf has the median count, no
-    // unassigned, no dangling, no clusters, lastMaintain ok.
-    const t = tree({
-      "domain-a/topic-x": ["page-a", "page-b"],
-      "domain-a/topic-y": ["page-c", "page-d"],
-    });
-    const report = computeV3Health({
-      tree: t,
-      allSlugs: ["page-a", "page-b", "page-c", "page-d"],
-      lastMaintain: { at: 1, ok: true },
-    });
-    expect(report.unassigned).toEqual([]);
-    expect(report.danglingRefs).toEqual([]);
-    expect(report.novelClusters).toEqual([]);
-    expect(report.oversizedLeaves).toEqual([]);
-    expect(report.tinyLeaves).toEqual([]);
-    expect(renderV3Health(report)).toBe("");
-  });
-
-  test("returns empty string when report is entirely empty and no maintain", () => {
-    const report = computeV3Health({
-      tree: { leaves: new Map(), byPage: new Map() },
-      allSlugs: [],
-    });
-    expect(renderV3Health(report)).toBe("");
-  });
-
-  test("renders a non-empty block when any signal fires", () => {
-    const t = tree({ "domain-a/topic-x": ["page-a"] });
-    const report = computeV3Health({
-      tree: t,
-      allSlugs: ["page-a", "page-b"],
-    });
-    const rendered = renderV3Health(report);
-    expect(rendered).not.toBe("");
-    expect(rendered).toContain("memory-v3 health:");
-    expect(rendered).toContain("unassigned");
-    expect(rendered).toContain("page-b");
-  });
-
-  test("renders a failed last-maintenance even with no other signals", () => {
-    const t = tree({
-      "domain-a/topic-x": ["page-a", "page-b"],
-      "domain-a/topic-y": ["page-c", "page-d"],
-    });
-    const report = computeV3Health({
-      tree: t,
-      allSlugs: ["page-a", "page-b", "page-c", "page-d"],
-      lastMaintain: { at: 99, ok: false },
-    });
-    const rendered = renderV3Health(report);
-    expect(rendered).toContain("last maintenance FAILED");
-  });
-});

package/src/plugins/defaults/memory-v3-shadow/__tests__/needle.test.ts

@@ -1,107 +0,0 @@
-import { expect, test } from "bun:test";
-
-import { buildNeedleIndex } from "../needle.js";
-import type { LeafNode, LeafPath, LeafTree, Slug } from "../types.js";
-
-/**
- * Builds a small synthetic LeafTree + summary stub. No real content — every
- * label, summary, and slug here is invented for the test.
- */
-function makeFixture(): {
-  tree: LeafTree;
-  summaries: Map<Slug, string>;
-} {
-  const leaves = new Map<LeafPath, LeafNode>();
-  const byPage = new Map<Slug, LeafPath[]>();
-
-  const leaf = (path: LeafPath, description: string, members: Slug[]): void => {
-    leaves.set(path, {
-      path,
-      frontmatter: { path, in_core: false },
-      description,
-      members,
-      domain: "synthetic",
-    });
-    for (const slug of members) {
-      const list = byPage.get(slug) ?? [];
-      list.push(path);
-      byPage.set(slug, list);
-    }
-  };
-
-  leaf("animals/aquatic", "creatures that swim in water", ["dolphin-notes"]);
-  leaf("animals/birds", "winged creatures that fly", ["sparrow-notes"]);
-  leaf("vehicles/land", "machines with wheels for roads", ["bicycle-notes"]);
-
-  const summaries = new Map<Slug, string>([
-    ["dolphin-notes", "observations about marine mammals and echolocation"],
-    ["sparrow-notes", "field journal of garden visitors"],
-    ["bicycle-notes", "maintenance log for chains and brakes"],
-  ]);
-
-  return { tree: { leaves, byPage }, summaries };
-}
-
-test("query matches a literal term in a page summary", async () => {
-  const { tree, summaries } = makeFixture();
-  const index = await buildNeedleIndex(
-    tree,
-    async (slug) => summaries.get(slug) ?? "",
-  );
-
-  const results = index.query("echolocation", 3);
-  expect(results[0]).toBe("dolphin-notes");
-});
-
-test("query matches a term that appears only in a leaf label", async () => {
-  const { tree, summaries } = makeFixture();
-  const index = await buildNeedleIndex(
-    tree,
-    async (slug) => summaries.get(slug) ?? "",
-  );
-
-  // "wheels" appears only in the vehicles/land leaf description, not in any
-  // summary or slug — it must still surface bicycle-notes.
-  const results = index.query("wheels", 3);
-  expect(results).toContain("bicycle-notes");
-});
-
-test("query matches a term in the slug title segment", async () => {
-  const { tree, summaries } = makeFixture();
-  const index = await buildNeedleIndex(
-    tree,
-    async (slug) => summaries.get(slug) ?? "",
-  );
-
-  const results = index.query("sparrow", 3);
-  expect(results[0]).toBe("sparrow-notes");
-});
-
-test("nonsense query returns no spurious results", async () => {
-  const { tree, summaries } = makeFixture();
-  const index = await buildNeedleIndex(
-    tree,
-    async (slug) => summaries.get(slug) ?? "",
-  );
-
-  expect(index.query("xyzzyplugh", 3)).toEqual([]);
-});
-
-test("results are capped at k and ordered by score", async () => {
-  const { tree, summaries } = makeFixture();
-  const index = await buildNeedleIndex(
-    tree,
-    async (slug) => summaries.get(slug) ?? "",
-  );
-
-  // "creatures" appears in both animal leaf labels; vehicles should be absent.
-  const results = index.query("creatures", 1);
-  expect(results.length).toBe(1);
-  expect(results[0]).not.toBe("bicycle-notes");
-});
-
-test("empty corpus yields empty results", async () => {
-  const tree: LeafTree = { leaves: new Map(), byPage: new Map() };
-  const index = await buildNeedleIndex(tree, async () => "");
-  expect(index.query("anything", 5)).toEqual([]);
-});

package/src/plugins/defaults/memory-v3-shadow/__tests__/provider-blocks.test.ts

@@ -1,13 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { cachedTextBlock } from "../provider-blocks.js";
-
-describe("cachedTextBlock", () => {
-  test("stamps an ephemeral cache_control with a 1h TTL", () => {
-    const block = cachedTextBlock("stable leaf block");
-    expect(block).toMatchObject({ type: "text", text: "stable leaf block" });
-    expect(
-      (block as unknown as { cache_control?: unknown }).cache_control,
-    ).toEqual({ type: "ephemeral", ttl: "1h" });
-  });
-});

package/src/plugins/defaults/memory-v3-shadow/__tests__/reconcile.test.ts

@@ -1,274 +0,0 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { readPage, writePage } from "../../../../memory/v2/page-store.js";
-import type { Provider } from "../../../../providers/types.js";
-import { type LeafRef, reconcileTree } from "../reconcile.js";
-
-/**
- * A canned provider whose `assign_leaves` tool-use response is computed from
- * the user message (the page content) via `idsForMessage`. This lets a test
- * deterministically re-home each page onto specific surviving leaves without a
- * real LLM. The leaf index in the system prompt is sorted by path; tests pass
- * the 1-based id of the target leaf in that sorted order.
- */
-function stubProvider(
-  idsForMessage: (message: string, systemPrompt: string) => number[],
-): Provider {
-  return {
-    name: "stub",
-    async sendMessage(messages: unknown, opts: unknown) {
-      const msg = messages as Array<{
-        content: Array<{ type: string; text?: string }>;
-      }>;
-      const text = msg[0]?.content?.map((c) => c.text ?? "").join("") ?? "";
-      const systemPrompt =
-        (opts as { systemPrompt?: string }).systemPrompt ?? "";
-      const ids = idsForMessage(text, systemPrompt);
-      return {
-        id: "msg_stub",
-        role: "assistant",
-        model: "stub-model",
-        stopReason: "tool_use",
-        content: [
-          {
-            type: "tool_use",
-            id: "tool_1",
-            name: "assign_leaves",
-            input: { ids },
-          },
-        ],
-      };
-    },
-  } as unknown as Provider;
-}
-
-let workspaceDir: string;
-let dataDir: string;
-
-beforeEach(async () => {
-  workspaceDir = await mkdtemp(join(tmpdir(), "reconcile-ws-"));
-  dataDir = await mkdtemp(join(tmpdir(), "reconcile-data-"));
-});
-
-afterEach(async () => {
-  await rm(workspaceDir, { recursive: true, force: true });
-  await rm(dataDir, { recursive: true, force: true });
-  await rm(join(dataDir, "..", "v3-snapshots"), {
-    recursive: true,
-    force: true,
-  }).catch(() => {});
-});
-
-/** Write a leaf `.md` with `{path, in_core, id}` frontmatter. */
-async function writeLeaf(
-  path: string,
-  opts: { id?: string; inCore?: boolean; body?: string } = {},
-): Promise<void> {
-  const full = join(dataDir, "leaves", `${path}.md`);
-  await mkdir(join(full, ".."), { recursive: true });
-  const lines = [`path: ${path}`, `in_core: ${opts.inCore ?? false}`];
-  if (opts.id) lines.push(`id: ${opts.id}`);
-  await writeFile(
-    full,
-    `---\n${lines.join("\n")}\n---\n${opts.body ?? `Leaf ${path}.`}\n`,
-  );
-}
-
-async function writeCore(alwaysOn: string[]): Promise<void> {
-  await writeFile(join(dataDir, "core.json"), JSON.stringify({ alwaysOn }));
-}
-
-/**
- * `loadLeafTree` (used by the re-homing path) reads `assignments.json`
- * unconditionally, so seed an empty one. Page→leaf membership comes from page
- * frontmatter, not this file.
- */
-async function seedAssignments(): Promise<void> {
-  await writeFile(join(dataDir, "assignments.json"), "{}");
-}
-
-async function writePageWithLeaves(
-  slug: string,
-  leaves: string[],
-): Promise<void> {
-  await writePage(workspaceDir, {
-    slug,
-    frontmatter: { edges: [], ref_files: [], ref_urls: [], leaves },
-    body: `Body of ${slug}.`,
-  });
-}
-
-async function pageLeaves(slug: string): Promise<string[]> {
-  const page = await readPage(workspaceDir, slug);
-  return page?.frontmatter.leaves ?? [];
-}
-
-async function coreOf(): Promise<string[]> {
-  const raw = await readFile(join(dataDir, "core.json"), "utf8");
-  return (JSON.parse(raw) as { alwaysOn: string[] }).alwaysOn;
-}
-
-describe("reconcileTree", () => {
-  test("rename preserves assignments (refs rewritten old → new)", async () => {
-    // Current tree: the leaf moved from domain-a/topic-x → domain-b/topic-x,
-    // keeping its stable id.
-    await writeLeaf("domain-b/topic-x", { id: "leaf-x" });
-    await writeCore(["domain-a/topic-x"]);
-    await writePageWithLeaves("page-a", ["domain-a/topic-x"]);
-
-    const prev: LeafRef[] = [{ id: "leaf-x", path: "domain-a/topic-x" }];
-    const result = await reconcileTree({
-      prevLeaves: prev,
-      dataDir,
-      workspaceDir,
-    });
-
-    expect(await pageLeaves("page-a")).toEqual(["domain-b/topic-x"]);
-    expect(await coreOf()).toEqual(["domain-b/topic-x"]);
-    expect(result.renames).toEqual([
-      {
-        id: "leaf-x",
-        oldPath: "domain-a/topic-x",
-        newPath: "domain-b/topic-x",
-      },
-    ]);
-    expect(result.idToNewPath.get("leaf-x")).toBe("domain-b/topic-x");
-  });
-
-  test("delete re-homes members with no orphan", async () => {
-    // leaf-x is deleted; leaf-y survives. page-a was only on leaf-x.
-    await writeLeaf("domain-a/topic-y", { id: "leaf-y" });
-    await writeCore([]);
-    await seedAssignments();
-    await writePageWithLeaves("page-a", ["domain-a/topic-x"]);
-
-    // Surviving leaf is sorted index 1 (only leaf in tree).
-    const provider = stubProvider(() => [1]);
-
-    const prev: LeafRef[] = [
-      { id: "leaf-x", path: "domain-a/topic-x" },
-      { id: "leaf-y", path: "domain-a/topic-y" },
-    ];
-    const result = await reconcileTree({
-      prevLeaves: prev,
-      dataDir,
-      workspaceDir,
-      provider,
-    });
-
-    const after = await pageLeaves("page-a");
-    // No orphan: at least one surviving leaf, and the dead path is gone.
-    expect(after.length).toBeGreaterThanOrEqual(1);
-    expect(after).not.toContain("domain-a/topic-x");
-    expect(after).toContain("domain-a/topic-y");
-    expect(result.deleted).toEqual(["domain-a/topic-x"]);
-  });
-
-  test("split distributes members across toPaths", async () => {
-    // leaf-x splits into leaf-x1 (domain-a/x1) and leaf-x2 (domain-a/x2).
-    await writeLeaf("domain-a/x1", { id: "leaf-x1" });
-    await writeLeaf("domain-a/x2", { id: "leaf-x2" });
-    // A third surviving leaf NOT in the split target set — members must not
-    // land here.
-    await writeLeaf("domain-b/other", { id: "leaf-other" });
-    await writeCore([]);
-    await seedAssignments();
-    await writePageWithLeaves("page-a", ["domain-a/topic-x"]);
-    await writePageWithLeaves("page-b", ["domain-a/topic-x"]);
-
-    // Restricted tree (split.toPaths) sorts as [domain-a/x1, domain-a/x2].
-    // page-a → x1 (id 1), page-b → x2 (id 2).
-    const provider = stubProvider((message) =>
-      message.includes("page-a") ? [1] : [2],
-    );
-
-    const prev: LeafRef[] = [{ id: "leaf-x", path: "domain-a/topic-x" }];
-    await reconcileTree({
-      prevLeaves: prev,
-      dataDir,
-      workspaceDir,
-      provider,
-      splits: [{ fromId: "leaf-x", toPaths: ["domain-a/x1", "domain-a/x2"] }],
-    });
-
-    expect(await pageLeaves("page-a")).toEqual(["domain-a/x1"]);
-    expect(await pageLeaves("page-b")).toEqual(["domain-a/x2"]);
-    // Neither page landed on the off-target leaf.
-    expect(await pageLeaves("page-a")).not.toContain("domain-b/other");
-    expect(await pageLeaves("page-b")).not.toContain("domain-b/other");
-  });
-
-  test("dangling core entry is pruned", async () => {
-    await writeLeaf("domain-a/topic-x", { id: "leaf-x" });
-    // core.json points at a leaf that no longer exists in the tree.
-    await writeCore(["domain-a/topic-x", "domain-a/gone"]);
-    await writePageWithLeaves("page-a", ["domain-a/topic-x"]);
-
-    // No prev entry for the gone leaf and no page references it, so reconcile
-    // succeeds and prunes the stale core entry.
-    const prev: LeafRef[] = [{ id: "leaf-x", path: "domain-a/topic-x" }];
-    const result = await reconcileTree({
-      prevLeaves: prev,
-      dataDir,
-      workspaceDir,
-    });
-
-    expect(await coreOf()).toEqual(["domain-a/topic-x"]);
-    expect(result.prunedCore).toEqual(["domain-a/gone"]);
-  });
-
-  test("out-of-band dangling page ref converges (prune pass)", async () => {
-    // The current tree has only leaf-x. page-a references leaf-x (fine) PLUS a
-    // residual leaf path that exists in NEITHER prev nor current — an out-of-band
-    // ref a maintainer left when deleting a leaf file without a `prevLeaves`
-    // entry. v1 reconcile is a convergence/prune pass: it drops the dangling ref
-    // (the page keeps its surviving leaf, so no re-home is needed) instead of
-    // failing closed.
-    await writeLeaf("domain-a/topic-x", { id: "leaf-x" });
-    await writeCore(["domain-a/topic-x"]);
-    await seedAssignments();
-    await writePageWithLeaves("page-a", [
-      "domain-a/topic-x",
-      "domain-a/residual",
-    ]);
-
-    const prev: LeafRef[] = [{ id: "leaf-x", path: "domain-a/topic-x" }];
-    const result = await reconcileTree({
-      prevLeaves: prev,
-      dataDir,
-      workspaceDir,
-    });
-
-    // Converged: the dangling residual ref is gone; the surviving leaf remains.
-    expect(await pageLeaves("page-a")).toEqual(["domain-a/topic-x"]);
-    expect(await coreOf()).toEqual(["domain-a/topic-x"]);
-    // The out-of-band drop is not a reconciler-tracked delete (no prev entry),
-    // so it is not reported in `deleted`.
-    expect(result.deleted).toEqual([]);
-  });
-
-  test("page whose ONLY leaf dangles out-of-band is re-homed, not orphaned", async () => {
-    // page-a's sole leaf was deleted on disk with no `prevLeaves` entry. The
-    // convergence pass must re-home it onto a surviving leaf before dropping the
-    // dead ref, so the page is never left with zero leaves.
-    await writeLeaf("domain-a/topic-x", { id: "leaf-x" });
-    await writeCore([]);
-    await seedAssignments();
-    // page-a points only at a leaf absent from the tree (out-of-band delete).
-    await writePageWithLeaves("page-a", ["domain-a/gone"]);
-
-    // Only surviving leaf is sorted index 1 → re-home target.
-    const provider = stubProvider(() => [1]);
-
-    const prev: LeafRef[] = [{ id: "leaf-x", path: "domain-a/topic-x" }];
-    await reconcileTree({ prevLeaves: prev, dataDir, workspaceDir, provider });
-
-    const after = await pageLeaves("page-a");
-    expect(after).not.toContain("domain-a/gone"); // dangling ref dropped
-    expect(after).toEqual(["domain-a/topic-x"]); // re-homed onto the survivor
-    expect(after.length).toBeGreaterThanOrEqual(1); // never orphaned
-  });
-});