@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/memory/v3/__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/memory/v3/__tests__/maintain-job.test.ts

@@ -1,288 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { setOverridesForTesting } from "../../../__tests__/feature-flag-test-helpers.js";
-import type { AssistantConfig } from "../../../config/types.js";
-import type { MemoryJob } from "../../jobs-store.js";
-import { readPage, writePage } from "../../v2/page-store.js";
-import type { ConceptPage } from "../../v2/types.js";
-import type { AssignPageResult, AssignPagesOptions } from "../assign.js";
-import {
-  type ClassifyCandidate,
-  computeClassifyTargets,
-  maintainJob,
-  type MaintainJobDeps,
-} from "../maintain-job.js";
-import type { LeafNode, LeafPath, LeafTree, Slug } from "../types.js";
-
-const FLAG_SHADOW = "memory-v3-shadow";
-const FLAG_LIVE = "memory-v3-live";
-
-// The flag resolver ignores the passed config and reads the override cache; the
-// config arg only satisfies the signature. Flags are driven via
-// `setOverridesForTesting` below.
-const CONFIG = {} as AssistantConfig;
-
-function makeLeaf(path: LeafPath): LeafNode {
-  return {
-    path,
-    frontmatter: { path, in_core: false },
-    description: `${path} description`,
-    members: [],
-    domain: path.split("/")[0],
-  };
-}
-
-function makeTree(paths: LeafPath[]): LeafTree {
-  const leaves = new Map<LeafPath, LeafNode>();
-  for (const path of paths) leaves.set(path, makeLeaf(path));
-  return { leaves, byPage: new Map<Slug, LeafPath[]>() };
-}
-
-function makePage(slug: string, leaves?: string[]): ConceptPage {
-  return {
-    slug,
-    frontmatter: {
-      summary: `Summary for ${slug}`,
-      edges: [],
-      ref_files: [],
-      ref_urls: [],
-      leaves,
-    },
-    body: `Body content for ${slug}`,
-  };
-}
-
-const JOB = { id: "job-1", type: "memory_v3_maintain" } as unknown as MemoryJob;
-
-describe("maintainJob", () => {
-  let workspaceDir: string;
-
-  beforeEach(async () => {
-    workspaceDir = await mkdtemp(join(tmpdir(), "v3-maintain-"));
-  });
-
-  afterEach(async () => {
-    setOverridesForTesting({});
-    await rm(workspaceDir, { recursive: true, force: true });
-  });
-
-  function deps(overrides: Partial<MaintainJobDeps> = {}): {
-    deps: MaintainJobDeps;
-    calls: { assign: number; invalidate: number; commit: number };
-  } {
-    const calls = { assign: 0, invalidate: 0, commit: 0 };
-    const base: MaintainJobDeps = {
-      workspaceDir,
-      loadTree: async () => makeTree(["domain/topic-a", "domain/topic-b"]),
-      assignPages: async (
-        _opts: AssignPagesOptions,
-      ): Promise<AssignPageResult[]> => {
-        calls.assign += 1;
-        return [];
-      },
-      selectClassifyTargets: async () => [],
-      commitClassifyHighWater: () => {
-        calls.commit += 1;
-      },
-      invalidateLanes: () => {
-        calls.invalidate += 1;
-      },
-    };
-    return { deps: { ...base, ...overrides }, calls };
-  }
-
-  test("no-op when both v3 flags are off", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: false, [FLAG_LIVE]: false });
-    const { deps: d, calls } = deps();
-    const outcome = await maintainJob(JOB, CONFIG, d);
-    expect(outcome.disabled).toBe(true);
-    expect(calls.assign).toBe(0);
-    expect(calls.invalidate).toBe(0);
-  });
-
-  test("runs assign + invalidate when shadow flag is on", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
-    const { deps: d, calls } = deps();
-    const outcome = await maintainJob(JOB, CONFIG, d);
-    expect(outcome.disabled).toBe(false);
-    expect(calls.assign).toBe(1);
-    expect(calls.invalidate).toBe(1);
-    expect(outcome.invalidated).toBe(true);
-  });
-
-  test("runs when only the live flag is on", async () => {
-    setOverridesForTesting({ [FLAG_LIVE]: true });
-    const { deps: d, calls } = deps();
-    await maintainJob(JOB, CONFIG, d);
-    expect(calls.assign).toBe(1);
-    expect(calls.invalidate).toBe(1);
-  });
-
-  test("counts pages newly assigned by the classify-union stage", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
-    const { deps: d } = deps({
-      assignPages: async () => [
-        { slug: "p1", before: [], after: ["domain/topic-a"], failed: false },
-        { slug: "p2", before: [], after: [], failed: true },
-        {
-          slug: "p3",
-          before: ["domain/topic-a"],
-          after: ["domain/topic-a"],
-          failed: false,
-        },
-      ],
-    });
-    const outcome = await maintainJob(JOB, CONFIG, d);
-    expect(outcome.assigned).toBe(1);
-  });
-
-  test("prune drops dangling leaf refs and rewrites the page", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
-    await writePage(
-      workspaceDir,
-      makePage("dangling", ["domain/topic-a", "domain/gone"]),
-    );
-    await writePage(workspaceDir, makePage("clean", ["domain/topic-b"]));
-    await writePage(workspaceDir, makePage("empty", []));
-
-    const { deps: d } = deps();
-    const outcome = await maintainJob(JOB, CONFIG, d);
-
-    expect(outcome.pruned).toBe(1);
-    expect(outcome.prunedRefs).toBe(1);
-
-    const dangling = await readPage(workspaceDir, "dangling");
-    expect(dangling?.frontmatter.leaves).toEqual(["domain/topic-a"]);
-
-    const clean = await readPage(workspaceDir, "clean");
-    expect(clean?.frontmatter.leaves).toEqual(["domain/topic-b"]);
-  });
-
-  test("contains an assign failure without aborting prune or invalidate", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
-    await writePage(
-      workspaceDir,
-      makePage("dangling", ["domain/topic-a", "domain/gone"]),
-    );
-    const { deps: d, calls } = deps({
-      assignPages: async () => {
-        throw new Error("assign boom");
-      },
-    });
-    const outcome = await maintainJob(JOB, CONFIG, d);
-    expect(outcome.failures).toContain("assign");
-    expect(outcome.pruned).toBe(1);
-    expect(calls.invalidate).toBe(1);
-    expect(outcome.invalidated).toBe(true);
-  });
-
-  test("contains a tree-load failure but still invalidates lanes", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
-    const { deps: d, calls } = deps({
-      loadTree: async () => {
-        throw new Error("load boom");
-      },
-    });
-    const outcome = await maintainJob(JOB, CONFIG, d);
-    expect(outcome.failures).toContain("load_tree");
-    expect(calls.assign).toBe(0);
-    expect(calls.invalidate).toBe(1);
-  });
-
-  test("classifies the selected delta targets (passes them to assignPages)", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
-    let seenSlugs: Slug[] | undefined;
-    const { deps: d } = deps({
-      selectClassifyTargets: async () => ["p-new", "p-edited"],
-      assignPages: async (opts: AssignPagesOptions) => {
-        seenSlugs = opts.slugs;
-        return [];
-      },
-    });
-    await maintainJob(JOB, CONFIG, d);
-    expect(seenSlugs).toEqual(["p-new", "p-edited"]);
-  });
-
-  test("advances the high-water mark after a successful classify pass", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
-    const { deps: d, calls } = deps();
-    await maintainJob(JOB, CONFIG, d);
-    expect(calls.commit).toBe(1);
-  });
-
-  test("does not advance the high-water mark when classify throws", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
-    const { deps: d, calls } = deps({
-      assignPages: async () => {
-        throw new Error("assign boom");
-      },
-    });
-    const outcome = await maintainJob(JOB, CONFIG, d);
-    expect(outcome.failures).toContain("assign");
-    expect(calls.commit).toBe(0);
-  });
-});
-
-describe("computeClassifyTargets", () => {
-  const page = (
-    slug: string,
-    modifiedAt: number,
-    leaves: string[] = [],
-  ): ClassifyCandidate => ({ slug, modifiedAt, leaves });
-
-  test("first run (null high-water) classifies only unassigned pages", () => {
-    const targets = computeClassifyTargets(
-      [page("unassigned", 100, []), page("assigned-recent", 200, ["domain/a"])],
-      null,
-    );
-    expect(targets).toEqual(["unassigned"]);
-  });
-
-  test("re-classifies an already-assigned page edited since the high-water", () => {
-    const targets = computeClassifyTargets(
-      [page("assigned-edited", 300, ["domain/a"])],
-      200,
-    );
-    expect(targets).toEqual(["assigned-edited"]);
-  });
-
-  test("skips an assigned page untouched since the high-water (no self-trigger / drift)", () => {
-    const targets = computeClassifyTargets(
-      [page("assigned-stale", 150, ["domain/a"])],
-      200,
-    );
-    expect(targets).toEqual([]);
-  });
-
-  test("still classifies unassigned pages regardless of mtime", () => {
-    const targets = computeClassifyTargets(
-      [page("unassigned-old", 10, [])],
-      200,
-    );
-    expect(targets).toEqual(["unassigned-old"]);
-  });
-
-  test("excludes synthetic skill/CLI rows (modifiedAt 0) despite empty leaves", () => {
-    const targets = computeClassifyTargets(
-      [page("skills/meet-join", 0, []), page("real", 300, [])],
-      200,
-    );
-    expect(targets).toEqual(["real"]);
-  });
-
-  test("targets = unassigned ∪ recently-edited, excluding assigned-and-stale", () => {
-    const targets = computeClassifyTargets(
-      [
-        page("unassigned-old", 10, []),
-        page("assigned-stale", 150, ["domain/a"]),
-        page("assigned-fresh", 300, ["domain/a"]),
-        page("skills/x", 0, []),
-      ],
-      200,
-    );
-    expect(targets).toEqual(["unassigned-old", "assigned-fresh"]);
-  });
-});

package/src/memory/v3/__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([]);
-});