@vellumai/assistant 0.7.0 → 0.7.1

package/src/memory/v2/edges.ts

@@ -1,217 +0,0 @@
-/**
- * Memory v2 — `memory/edges.json` read/write and neighbor resolution.
- *
- * This module is the sole owner of the `memory/edges.json` file. The edges
- * index is the source of truth for v2 graph topology — concept-page
- * frontmatter only mirrors a derived view of it.
- *
- * Edges are unweighted, undirected, and stored as canonicalized 2-tuples
- * (alphabetically-first slug first). Self-loops are rejected at write time.
- *
- * Writes are atomic (write to `<file>.tmp-<uuid>`, then `rename(2)` onto the
- * destination) so a crashed writer never leaves a torn JSON file behind —
- * readers always see either the previous or the new index.
- */
-import { randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-import type { EdgesIndex } from "./types.js";
-import { EdgesIndexSchema } from "./types.js";
-
-const EDGES_FILENAME = "edges.json";
-
-/** Path to `memory/edges.json` inside `workspaceDir`. */
-function edgesPath(workspaceDir: string): string {
-  return join(workspaceDir, "memory", EDGES_FILENAME);
-}
-
-/**
- * Canonicalize a single tuple so `[a, b]` and `[b, a]` collapse to the same
- * representation. Keeps writes deterministic regardless of caller order.
- */
-function canonicalTuple(a: string, b: string): [string, string] {
-  return a <= b ? [a, b] : [b, a];
-}
-
-/** Stable string key for a canonical tuple, used for de-duplication. */
-function tupleKey(t: readonly [string, string]): string {
-  return `${t[0]}\u0000${t[1]}`;
-}
-
-/**
- * Read `memory/edges.json` and validate it against `EdgesIndexSchema`.
- * Returns the canonical empty index when the file is missing.
- *
- * Any JSON parse error or schema-validation failure throws — the file should
- * never be silently quarantined, since a broken edges.json signals a bug in
- * a writer or external tampering.
- */
-export async function readEdges(workspaceDir: string): Promise<EdgesIndex> {
-  let raw: string;
-  try {
-    raw = await readFile(edgesPath(workspaceDir), "utf-8");
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
-      return { version: 1, edges: [] };
-    }
-    throw err;
-  }
-  const parsed = JSON.parse(raw);
-  return EdgesIndexSchema.parse(parsed);
-}
-
-/**
- * Write `memory/edges.json` atomically. The on-disk tuples are canonicalized
- * and de-duplicated before serialization, so the output is independent of
- * insertion order and free of redundant pairs.
- *
- * Atomicity: bytes are written to a sibling temp file then renamed onto the
- * destination. `rename(2)` on the same filesystem is atomic, so a reader
- * concurrent with the writer sees either the prior file or the new one in
- * full — never a partial write.
- */
-export async function writeEdges(
-  workspaceDir: string,
-  idx: EdgesIndex,
-): Promise<void> {
-  const canonical = canonicalizeIndex(idx);
-  const finalPath = edgesPath(workspaceDir);
-  await mkdir(dirname(finalPath), { recursive: true });
-  const tmpPath = `${finalPath}.tmp-${randomUUID()}`;
-  const body = `${JSON.stringify(canonical, null, 2)}\n`;
-  await writeFile(tmpPath, body, "utf-8");
-  await rename(tmpPath, finalPath);
-}
-
-/**
- * Pure helper: return a new index with `(a, b)` added (canonicalized). If the
- * edge already exists the index is returned unchanged. Self-loops are
- * rejected — concept-page graphs are simple graphs.
- */
-export function addEdge(idx: EdgesIndex, a: string, b: string): EdgesIndex {
-  if (a === b) {
-    throw new Error(`addEdge: refusing to add self-loop on slug "${a}"`);
-  }
-  const tuple = canonicalTuple(a, b);
-  const key = tupleKey(tuple);
-  for (const existing of idx.edges) {
-    if (tupleKey(canonicalTuple(existing[0], existing[1])) === key) {
-      return idx;
-    }
-  }
-  return { version: idx.version, edges: [...idx.edges, tuple] };
-}
-
-/**
- * Pure helper: return a new index with `(a, b)` removed (matched on its
- * canonical form). No-op if the edge is not present.
- */
-export function removeEdge(idx: EdgesIndex, a: string, b: string): EdgesIndex {
-  const target = tupleKey(canonicalTuple(a, b));
-  const filtered = idx.edges.filter(
-    ([x, y]) => tupleKey(canonicalTuple(x, y)) !== target,
-  );
-  if (filtered.length === idx.edges.length) return idx;
-  return { version: idx.version, edges: filtered };
-}
-
-/**
- * Iterative BFS over the undirected edge graph starting at `slug`. Returns
- * every slug reachable within `hops` edges, *excluding* the start slug. An
- * orphan node (or unknown slug) yields the empty set.
- *
- * `hops` is clamped at 0 — a non-positive value collapses to an immediate
- * empty result so callers never need to special-case it.
- */
-export function getNeighbors(
-  idx: EdgesIndex,
-  slug: string,
-  hops: number,
-): Set<string> {
-  const result = new Set<string>();
-  if (hops <= 0) return result;
-
-  const adjacency = buildAdjacency(idx);
-  const visited = new Set<string>([slug]);
-  let frontier: string[] = [slug];
-
-  for (let depth = 0; depth < hops && frontier.length > 0; depth++) {
-    const next: string[] = [];
-    for (const node of frontier) {
-      const neighbors = adjacency.get(node);
-      if (!neighbors) continue;
-      for (const neighbor of neighbors) {
-        if (visited.has(neighbor)) continue;
-        visited.add(neighbor);
-        result.add(neighbor);
-        next.push(neighbor);
-      }
-    }
-    frontier = next;
-  }
-
-  return result;
-}
-
-/**
- * Validate an edges index against a known set of concept-page slugs. Returns
- * the unique list of endpoints that are referenced by an edge but missing
- * from `knownSlugs`. `ok` mirrors `missing.length === 0` for caller
- * convenience.
- */
-export function validateEdges(
-  idx: EdgesIndex,
-  knownSlugs: Set<string>,
-): { ok: boolean; missing: string[] } {
-  const missing = new Set<string>();
-  for (const [a, b] of idx.edges) {
-    if (!knownSlugs.has(a)) missing.add(a);
-    if (!knownSlugs.has(b)) missing.add(b);
-  }
-  const list = [...missing].sort();
-  return { ok: list.length === 0, missing: list };
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Canonicalize tuples + dedup, returning a deterministically-sorted index.
- * Self-loops are dropped silently here (writer-side) so a malformed in-memory
- * value can still be persisted as a clean file.
- */
-function canonicalizeIndex(idx: EdgesIndex): EdgesIndex {
-  const seen = new Map<string, [string, string]>();
-  for (const [a, b] of idx.edges) {
-    if (a === b) continue;
-    const tuple = canonicalTuple(a, b);
-    seen.set(tupleKey(tuple), tuple);
-  }
-  // Sort by canonical key (NUL-separated) — gives a lexicographic order on
-  // the (left, right) pair without a multi-clause comparator.
-  const tuples = [...seen.entries()]
-    .sort(([keyX], [keyY]) => (keyX < keyY ? -1 : keyX > keyY ? 1 : 0))
-    .map(([, tuple]) => tuple);
-  return { version: idx.version, edges: tuples };
-}
-
-/** Build slug → neighbors map from canonicalized tuples (undirected). */
-function buildAdjacency(idx: EdgesIndex): Map<string, Set<string>> {
-  const adjacency = new Map<string, Set<string>>();
-  const ensure = (slug: string): Set<string> => {
-    let set = adjacency.get(slug);
-    if (!set) {
-      set = new Set<string>();
-      adjacency.set(slug, set);
-    }
-    return set;
-  };
-  for (const [a, b] of idx.edges) {
-    if (a === b) continue;
-    ensure(a).add(b);
-    ensure(b).add(a);
-  }
-  return adjacency;
-}

package/src/prompts/__tests__/system-prompt-memory-v2.test.ts

@@ -1,197 +0,0 @@
-/**
- * Tests for the memory-v2 autoload block in buildSystemPrompt.
- *
- * Verifies that when the `memory-v2-enabled` feature flag is on, the four
- * top-level memory files (essentials/threads/recent/buffer) are appended to
- * the dynamic suffix in order, each wrapped in a Markdown header. With the
- * flag off, none of these files leak into the prompt — even if present.
- */
-
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
-
-const noopLogger: Record<string, unknown> = new Proxy(
-  {} as Record<string, unknown>,
-  {
-    get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
-  },
-);
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realLogger = require("../../util/logger.js");
-mock.module("../../util/logger.js", () => ({
-  ...realLogger,
-  getLogger: () => noopLogger,
-  getCliLogger: () => noopLogger,
-  truncateForLog: (v: string) => v,
-  initLogger: () => {},
-  pruneOldLogFiles: () => 0,
-}));
-
-const mockLoadedConfig: Record<string, unknown> = {};
-
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    services: {
-      inference: {
-        mode: "your-own",
-        provider: "anthropic",
-        model: "claude-opus-4-6",
-      },
-      "image-generation": {
-        mode: "your-own",
-        provider: "gemini",
-        model: "gemini-3.1-flash-image-preview",
-      },
-      "web-search": { mode: "your-own", provider: "inference-provider-native" },
-    },
-  }),
-  loadConfig: () => mockLoadedConfig,
-  loadRawConfig: () => ({}),
-  saveConfig: () => {},
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-}));
-
-const { _setOverridesForTesting } =
-  await import("../../config/assistant-feature-flags.js");
-const { buildSystemPrompt, SYSTEM_PROMPT_CACHE_BOUNDARY } =
-  await import("../system-prompt.js");
-
-const MEMORY_FILES = [
-  "essentials.md",
-  "threads.md",
-  "recent.md",
-  "buffer.md",
-] as const;
-
-const ALL_HEADINGS = ["## Essentials", "## Threads", "## Recent", "## Buffer"];
-
-function writeMemoryFile(name: string, body: string): void {
-  const memoryDir = join(TEST_DIR, "memory");
-  mkdirSync(memoryDir, { recursive: true });
-  writeFileSync(join(memoryDir, name), body);
-}
-
-function cleanupMemoryDir(): void {
-  const memoryDir = join(TEST_DIR, "memory");
-  if (existsSync(memoryDir))
-    rmSync(memoryDir, { recursive: true, force: true });
-}
-
-function expectNoHeadings(result: string): void {
-  for (const heading of ALL_HEADINGS) {
-    expect(result).not.toContain(heading);
-  }
-}
-
-describe("buildSystemPrompt — memory v2 autoload", () => {
-  beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true });
-    _setOverridesForTesting({});
-  });
-
-  afterEach(() => {
-    cleanupMemoryDir();
-    _setOverridesForTesting({});
-  });
-
-  test("flag off: no memory headings appear even when files are populated", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    for (const file of MEMORY_FILES) {
-      writeMemoryFile(file, `Content for ${file}`);
-    }
-    const result = buildSystemPrompt();
-    expectNoHeadings(result);
-    for (const file of MEMORY_FILES) {
-      expect(result).not.toContain(`Content for ${file}`);
-    }
-  });
-
-  test("flag on, all files populated: all four blocks appear in canonical order", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
-    writeMemoryFile("essentials.md", "Alice prefers dark mode.");
-    writeMemoryFile("threads.md", "Open thread: ship PR-123 review.");
-    writeMemoryFile(
-      "recent.md",
-      "Yesterday Alice asked about Postgres tuning.",
-    );
-    writeMemoryFile(
-      "buffer.md",
-      "Bob mentioned a pager rotation conflict on Friday.",
-    );
-
-    const result = buildSystemPrompt();
-
-    expect(result).toContain("## Essentials");
-    expect(result).toContain("## Threads");
-    expect(result).toContain("## Recent");
-    expect(result).toContain("## Buffer");
-
-    expect(result).toContain("Alice prefers dark mode.");
-    expect(result).toContain("Open thread: ship PR-123 review.");
-    expect(result).toContain("Yesterday Alice asked about Postgres tuning.");
-    expect(result).toContain(
-      "Bob mentioned a pager rotation conflict on Friday.",
-    );
-
-    const essentialsIdx = result.indexOf("## Essentials");
-    const threadsIdx = result.indexOf("## Threads");
-    const recentIdx = result.indexOf("## Recent");
-    const bufferIdx = result.indexOf("## Buffer");
-    expect(essentialsIdx).toBeLessThan(threadsIdx);
-    expect(threadsIdx).toBeLessThan(recentIdx);
-    expect(recentIdx).toBeLessThan(bufferIdx);
-  });
-
-  test("flag on, files empty: blocks are omitted", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
-    for (const file of MEMORY_FILES) {
-      writeMemoryFile(file, "");
-    }
-    expectNoHeadings(buildSystemPrompt());
-  });
-
-  test("flag on, only some files have content: only populated blocks appear", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
-    writeMemoryFile("essentials.md", "Alice prefers VS Code.");
-    writeMemoryFile("threads.md", "");
-    writeMemoryFile("recent.md", "Recent topic: GraphQL pagination.");
-    writeMemoryFile("buffer.md", "");
-
-    const result = buildSystemPrompt();
-    expect(result).toContain("## Essentials");
-    expect(result).toContain("Alice prefers VS Code.");
-    expect(result).toContain("## Recent");
-    expect(result).toContain("Recent topic: GraphQL pagination.");
-    expect(result).not.toContain("## Threads");
-    expect(result).not.toContain("## Buffer");
-  });
-
-  test("flag on, files missing entirely: section is silently skipped", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
-    cleanupMemoryDir();
-    expectNoHeadings(buildSystemPrompt());
-  });
-
-  test("memory blocks live in the dynamic-suffix cache region", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
-    writeMemoryFile("essentials.md", "Alice prefers dark mode.");
-    const result = buildSystemPrompt();
-    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-    expect(boundaryIdx).toBeGreaterThan(-1);
-    const staticBlock = result.slice(0, boundaryIdx);
-    const dynamicBlock = result.slice(
-      boundaryIdx + SYSTEM_PROMPT_CACHE_BOUNDARY.length,
-    );
-    expect(staticBlock).not.toContain("## Essentials");
-    expect(dynamicBlock).toContain("## Essentials");
-    expect(dynamicBlock).toContain("Alice prefers dark mode.");
-  });
-});