macro-agent 0.1.2 → 0.1.3

package/references/minimem/src/__tests__/internal.test.ts

@@ -1,407 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-import {
-  chunkMarkdown,
-  stripPrivateContent,
-  extractChunkMetadata,
-  hashText,
-  buildFileEntry,
-  listMemoryFiles,
-  cosineSimilarity,
-  isMemoryPath,
-  normalizeRelPath,
-  truncateUtf16Safe,
-} from "../internal.js";
-
-describe("chunkMarkdown", () => {
-  it("splits overly long lines into max-sized chunks", () => {
-    const chunkTokens = 400;
-    const maxChars = chunkTokens * 4;
-    const content = "a".repeat(maxChars * 3 + 25);
-    const chunks = chunkMarkdown(content, { tokens: chunkTokens, overlap: 0 });
-    expect(chunks.length).toBeGreaterThan(1);
-    for (const chunk of chunks) {
-      expect(chunk.text.length).toBeLessThanOrEqual(maxChars);
-    }
-  });
-
-  it("creates chunks with correct line numbers", () => {
-    const content = "line1\nline2\nline3\nline4\nline5";
-    const chunks = chunkMarkdown(content, { tokens: 10, overlap: 0 });
-    expect(chunks.length).toBeGreaterThan(0);
-    expect(chunks[0].startLine).toBe(1);
-    expect(chunks[chunks.length - 1].endLine).toBe(5);
-  });
-
-  it("handles overlap between chunks", () => {
-    const lines = Array.from({ length: 20 }, (_, i) => `line ${i + 1}`);
-    const content = lines.join("\n");
-    const chunksWithOverlap = chunkMarkdown(content, { tokens: 20, overlap: 5 });
-    const chunksWithoutOverlap = chunkMarkdown(content, { tokens: 20, overlap: 0 });
-
-    // With overlap, chunks should share some content
-    expect(chunksWithOverlap.length).toBeGreaterThanOrEqual(chunksWithoutOverlap.length);
-  });
-
-  it("handles empty content gracefully", () => {
-    // Empty string splits into one line, which creates one chunk
-    const chunks = chunkMarkdown("", { tokens: 256, overlap: 32 });
-    expect(chunks.length).toBeLessThanOrEqual(1);
-    if (chunks.length > 0) {
-      expect(chunks[0].text).toBe("");
-    }
-  });
-
-  it("assigns hash to each chunk", () => {
-    const content = "Hello world\nThis is a test";
-    const chunks = chunkMarkdown(content, { tokens: 256, overlap: 0 });
-    expect(chunks.length).toBeGreaterThan(0);
-    for (const chunk of chunks) {
-      expect(chunk.hash).toBeDefined();
-      expect(chunk.hash.length).toBe(64); // SHA256 hex length
-    }
-  });
-});
-
-describe("stripPrivateContent", () => {
-  it("strips single-line private block", () => {
-    const input = "public\n<private>secret</private>\nmore public";
-    const result = stripPrivateContent(input);
-    expect(result).toBe("public\n\nmore public");
-  });
-
-  it("strips multi-line private block preserving line count", () => {
-    const input = "line1\n<private>\nsecret1\nsecret2\n</private>\nline6";
-    const result = stripPrivateContent(input);
-    const lines = result.split("\n");
-    // Original has 6 lines, result should too
-    expect(lines.length).toBe(6);
-    expect(lines[0]).toBe("line1");
-    expect(lines[5]).toBe("line6");
-    // Middle lines should be empty
-    expect(lines[1]).toBe("");
-    expect(lines[2]).toBe("");
-    expect(lines[3]).toBe("");
-    expect(lines[4]).toBe("");
-  });
-
-  it("strips multiple private blocks", () => {
-    const input = "a\n<private>x</private>\nb\n<private>y</private>\nc";
-    const result = stripPrivateContent(input);
-    expect(result).toBe("a\n\nb\n\nc");
-  });
-
-  it("is case-insensitive", () => {
-    const input = "a\n<PRIVATE>secret</PRIVATE>\nb";
-    const result = stripPrivateContent(input);
-    expect(result).toBe("a\n\nb");
-  });
-
-  it("returns content unchanged when no private tags", () => {
-    const input = "no secrets here\njust plain text";
-    expect(stripPrivateContent(input)).toBe(input);
-  });
-
-  it("handles empty content", () => {
-    expect(stripPrivateContent("")).toBe("");
-  });
-
-  it("leaves unclosed private tag unchanged", () => {
-    const input = "text\n<private>no closing tag here\nmore text";
-    expect(stripPrivateContent(input)).toBe(input);
-  });
-
-  it("leaves orphaned closing tag unchanged", () => {
-    const input = "text\n</private>\nmore text";
-    expect(stripPrivateContent(input)).toBe(input);
-  });
-
-  it("handles mixed case tags", () => {
-    expect(stripPrivateContent("a\n<Private>x</Private>\nb")).toBe("a\n\nb");
-    expect(stripPrivateContent("a\n<pRiVaTe>x</pRiVaTe>\nb")).toBe("a\n\nb");
-  });
-
-  it("handles private block with only newlines inside", () => {
-    const input = "a\n<private>\n\n\n</private>\nb";
-    const result = stripPrivateContent(input);
-    expect(result.split("\n").length).toBe(input.split("\n").length);
-    expect(result).not.toContain("<private>");
-  });
-
-  it("handles adjacent private blocks", () => {
-    const input = "<private>a</private><private>b</private>";
-    const result = stripPrivateContent(input);
-    expect(result).not.toContain("a");
-    expect(result).not.toContain("b");
-    expect(result).not.toContain("<private>");
-  });
-});
-
-describe("chunkMarkdown with private content", () => {
-  it("excludes private content from chunks", () => {
-    const content = "public info\n<private>API_KEY=sk-123</private>\nmore public";
-    const chunks = chunkMarkdown(content, { tokens: 256, overlap: 0 });
-    for (const chunk of chunks) {
-      expect(chunk.text).not.toContain("API_KEY");
-      expect(chunk.text).not.toContain("sk-123");
-      expect(chunk.text).not.toContain("<private>");
-    }
-  });
-
-  it("preserves line numbers when private content is stripped", () => {
-    const content = "line1\n<private>\nsecret\n</private>\nline5";
-    const chunks = chunkMarkdown(content, { tokens: 256, overlap: 0 });
-    // line5 is on line 5 in the original, should stay on line 5
-    const allText = chunks.map((c) => c.text).join("\n");
-    expect(allText).toContain("line1");
-    expect(allText).toContain("line5");
-    expect(allText).not.toContain("secret");
-  });
-});
-
-describe("extractChunkMetadata", () => {
-  it("extracts type from HTML comment", () => {
-    const text = "### 2026-02-13 14:30\n<!-- type: decision -->\nDecided to use BM25";
-    expect(extractChunkMetadata(text)).toEqual({ type: "decision" });
-  });
-
-  it("is case-insensitive", () => {
-    const text = "<!-- Type: BugFix -->\nFixed off-by-one error";
-    expect(extractChunkMetadata(text)).toEqual({ type: "bugfix" });
-  });
-
-  it("returns empty object when no type comment", () => {
-    const text = "Just plain text with no metadata";
-    expect(extractChunkMetadata(text)).toEqual({});
-  });
-
-  it("extracts first type when multiple present", () => {
-    const text = "<!-- type: feature -->\n<!-- type: discovery -->\nSome text";
-    expect(extractChunkMetadata(text)).toEqual({ type: "feature" });
-  });
-
-  it("handles various type values", () => {
-    expect(extractChunkMetadata("<!-- type: discovery -->")).toEqual({ type: "discovery" });
-    expect(extractChunkMetadata("<!-- type: context -->")).toEqual({ type: "context" });
-    expect(extractChunkMetadata("<!-- type: note -->")).toEqual({ type: "note" });
-  });
-
-  it("handles hyphenated type values", () => {
-    expect(extractChunkMetadata("<!-- type: bug-fix -->")).toEqual({ type: "bug-fix" });
-    expect(extractChunkMetadata("<!-- type: api-change -->")).toEqual({ type: "api-change" });
-  });
-
-  it("handles underscored type values", () => {
-    expect(extractChunkMetadata("<!-- type: feature_flag -->")).toEqual({ type: "feature_flag" });
-  });
-
-  it("handles whitespace variations in comment", () => {
-    expect(extractChunkMetadata("<!--type:decision-->")).toEqual({ type: "decision" });
-    expect(extractChunkMetadata("<!--  type:  decision  -->")).toEqual({ type: "decision" });
-    expect(extractChunkMetadata("<!-- type:decision -->")).toEqual({ type: "decision" });
-  });
-
-  it("does not match empty type value", () => {
-    expect(extractChunkMetadata("<!-- type: -->")).toEqual({});
-    expect(extractChunkMetadata("<!-- type:  -->")).toEqual({});
-  });
-
-  it("does not match unclosed comment", () => {
-    expect(extractChunkMetadata("<!-- type: decision")).toEqual({});
-  });
-
-  it("does not match partial comment syntax", () => {
-    expect(extractChunkMetadata("type: decision")).toEqual({});
-    expect(extractChunkMetadata("// type: decision")).toEqual({});
-  });
-
-  it("normalizes mixed case type to lowercase", () => {
-    expect(extractChunkMetadata("<!-- type: DeciSion -->")).toEqual({ type: "decision" });
-    expect(extractChunkMetadata("<!-- type: BUGFIX -->")).toEqual({ type: "bugfix" });
-  });
-});
-
-describe("hashText", () => {
-  it("returns consistent SHA256 hash", () => {
-    const hash1 = hashText("hello world");
-    const hash2 = hashText("hello world");
-    expect(hash1).toBe(hash2);
-    expect(hash1.length).toBe(64);
-  });
-
-  it("returns different hashes for different inputs", () => {
-    const hash1 = hashText("hello");
-    const hash2 = hashText("world");
-    expect(hash1).not.toBe(hash2);
-  });
-});
-
-describe("cosineSimilarity", () => {
-  it("returns 1 for identical vectors", () => {
-    const vec = [1, 2, 3, 4, 5];
-    expect(cosineSimilarity(vec, vec)).toBeCloseTo(1);
-  });
-
-  it("returns 0 for orthogonal vectors", () => {
-    const vec1 = [1, 0, 0];
-    const vec2 = [0, 1, 0];
-    expect(cosineSimilarity(vec1, vec2)).toBeCloseTo(0);
-  });
-
-  it("returns -1 for opposite vectors", () => {
-    const vec1 = [1, 2, 3];
-    const vec2 = [-1, -2, -3];
-    expect(cosineSimilarity(vec1, vec2)).toBeCloseTo(-1);
-  });
-
-  it("handles empty vectors", () => {
-    expect(cosineSimilarity([], [1, 2, 3])).toBe(0);
-    expect(cosineSimilarity([1, 2, 3], [])).toBe(0);
-    expect(cosineSimilarity([], [])).toBe(0);
-  });
-
-  it("handles zero vectors", () => {
-    expect(cosineSimilarity([0, 0, 0], [1, 2, 3])).toBe(0);
-  });
-});
-
-describe("isMemoryPath", () => {
-  it("accepts MEMORY.md", () => {
-    expect(isMemoryPath("MEMORY.md")).toBe(true);
-    expect(isMemoryPath("memory.md")).toBe(true);
-  });
-
-  it("accepts paths in memory directory", () => {
-    expect(isMemoryPath("memory/2024-01-01.md")).toBe(true);
-    expect(isMemoryPath("memory/topic/notes.md")).toBe(true);
-  });
-
-  it("rejects non-memory paths", () => {
-    expect(isMemoryPath("README.md")).toBe(false);
-    expect(isMemoryPath("src/index.ts")).toBe(false);
-    expect(isMemoryPath("")).toBe(false);
-  });
-
-  it("handles leading dots and slashes", () => {
-    expect(isMemoryPath("./MEMORY.md")).toBe(true);
-    expect(isMemoryPath("./memory/test.md")).toBe(true);
-  });
-});
-
-describe("normalizeRelPath", () => {
-  it("removes leading dots and slashes", () => {
-    expect(normalizeRelPath("./foo/bar")).toBe("foo/bar");
-    expect(normalizeRelPath("../foo/bar")).toBe("foo/bar");
-    expect(normalizeRelPath("///foo")).toBe("foo");
-  });
-
-  it("converts backslashes to forward slashes", () => {
-    expect(normalizeRelPath("foo\\bar\\baz")).toBe("foo/bar/baz");
-  });
-
-  it("trims whitespace", () => {
-    expect(normalizeRelPath("  foo/bar  ")).toBe("foo/bar");
-  });
-});
-
-describe("truncateUtf16Safe", () => {
-  it("returns original string if under limit", () => {
-    expect(truncateUtf16Safe("hello", 10)).toBe("hello");
-  });
-
-  it("truncates string at limit", () => {
-    expect(truncateUtf16Safe("hello world", 5)).toBe("hello");
-  });
-});
-
-describe("listMemoryFiles", () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-test-"));
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  it("finds MEMORY.md at root", async () => {
-    await fs.writeFile(path.join(tempDir, "MEMORY.md"), "# Memory");
-    const files = await listMemoryFiles(tempDir);
-    expect(files).toHaveLength(1);
-    expect(files[0]).toContain("MEMORY.md");
-  });
-
-  it("finds files in memory directory", async () => {
-    await fs.mkdir(path.join(tempDir, "memory"));
-    await fs.writeFile(path.join(tempDir, "memory", "2024-01-01.md"), "# Log");
-    await fs.writeFile(path.join(tempDir, "memory", "notes.md"), "# Notes");
-
-    const files = await listMemoryFiles(tempDir);
-    expect(files).toHaveLength(2);
-  });
-
-  it("recursively finds files in nested directories", async () => {
-    await fs.mkdir(path.join(tempDir, "memory", "topics"), { recursive: true });
-    await fs.writeFile(path.join(tempDir, "memory", "topics", "project.md"), "# Project");
-
-    const files = await listMemoryFiles(tempDir);
-    expect(files).toHaveLength(1);
-    expect(files[0]).toContain("project.md");
-  });
-
-  it("returns empty array when no memory files exist", async () => {
-    const files = await listMemoryFiles(tempDir);
-    expect(files).toHaveLength(0);
-  });
-
-  it("only includes .md files", async () => {
-    await fs.mkdir(path.join(tempDir, "memory"));
-    await fs.writeFile(path.join(tempDir, "memory", "notes.md"), "# Notes");
-    await fs.writeFile(path.join(tempDir, "memory", "notes.txt"), "text");
-    await fs.writeFile(path.join(tempDir, "memory", "data.json"), "{}");
-
-    const files = await listMemoryFiles(tempDir);
-    expect(files).toHaveLength(1);
-    expect(files[0]).toContain(".md");
-  });
-});
-
-describe("buildFileEntry", () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-test-"));
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  it("builds correct file entry", async () => {
-    const content = "# Test content";
-    const filePath = path.join(tempDir, "test.md");
-    await fs.writeFile(filePath, content);
-
-    const entry = await buildFileEntry(filePath, tempDir);
-
-    expect(entry.path).toBe("test.md");
-    expect(entry.absPath).toBe(filePath);
-    expect(entry.hash).toBe(hashText(content));
-    expect(entry.size).toBe(content.length);
-    expect(entry.mtimeMs).toBeGreaterThan(0);
-  });
-
-  it("handles nested paths", async () => {
-    await fs.mkdir(path.join(tempDir, "memory"));
-    const filePath = path.join(tempDir, "memory", "2024-01-01.md");
-    await fs.writeFile(filePath, "# Log");
-
-    const entry = await buildFileEntry(filePath, tempDir);
-
-    expect(entry.path).toBe("memory/2024-01-01.md");
-  });
-});

package/references/minimem/src/__tests__/knowledge.test.ts

@@ -1,287 +0,0 @@
-/**
- * Tests for knowledge-aware features:
- * - Frontmatter parsing of knowledge fields
- * - Knowledge link types
- * - Graph traversal functions
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { DatabaseSync } from "node:sqlite";
-import {
-  parseFrontmatter,
-  serializeFrontmatter,
-  type MemoryFrontmatter,
-} from "../session.js";
-import {
-  getLinksFrom,
-  getLinksTo,
-  getNeighbors,
-  getPathBetween,
-  type GraphLink,
-} from "../search/graph.js";
-
-// =========================================================================
-// Frontmatter parsing
-// =========================================================================
-
-describe("Knowledge frontmatter", () => {
-  it("parses full knowledge frontmatter with all fields", () => {
-    const content = `---
-id: k-abc123
-type: observation
-domain: [database, devops]
-entities: [prisma, postgres]
-confidence: 0.85
-source:
-  origin: extracted
-  trajectories: [t-001, t-002]
-  agentId: agent-v1
-links:
-  - target: k-other
-    relation: related-to
-    layer: semantic
-created: 2025-01-15T10:00:00Z
-updated: 2025-01-15T12:00:00Z
-supersedes: k-old
----
-# Observation
-
-Body content here.`;
-
-    const { frontmatter, body } = parseFrontmatter(content);
-
-    expect(frontmatter).toBeDefined();
-    expect(frontmatter!.id).toBe("k-abc123");
-    expect(frontmatter!.type).toBe("observation");
-    expect(frontmatter!.domain).toEqual(["database", "devops"]);
-    expect(frontmatter!.entities).toEqual(["prisma", "postgres"]);
-    expect(frontmatter!.confidence).toBe(0.85);
-    expect(frontmatter!.source?.origin).toBe("extracted");
-    expect(frontmatter!.source?.trajectories).toEqual(["t-001", "t-002"]);
-    expect(frontmatter!.source?.agentId).toBe("agent-v1");
-    expect(frontmatter!.links).toHaveLength(1);
-    expect(frontmatter!.links![0].target).toBe("k-other");
-    expect(frontmatter!.links![0].relation).toBe("related-to");
-    expect(frontmatter!.links![0].layer).toBe("semantic");
-    expect(frontmatter!.created).toBe("2025-01-15T10:00:00Z");
-    expect(frontmatter!.supersedes).toBe("k-old");
-    expect(body).toContain("Body content here.");
-  });
-
-  it("parses note with no knowledge fields as standard frontmatter", () => {
-    const content = `---
-created: 2025-01-15T10:00:00Z
-tags: [daily, meeting]
----
-Regular memory content.`;
-
-    const { frontmatter } = parseFrontmatter(content);
-
-    expect(frontmatter).toBeDefined();
-    expect(frontmatter!.created).toBe("2025-01-15T10:00:00Z");
-    expect(frontmatter!.tags).toEqual(["daily", "meeting"]);
-    // Knowledge fields should be absent
-    expect(frontmatter!.id).toBeUndefined();
-    expect(frontmatter!.type).toBeUndefined();
-    expect(frontmatter!.domain).toBeUndefined();
-  });
-
-  it("parses note with links array", () => {
-    const content = `---
-id: k-linked
-type: entity
-links:
-  - target: k-dep1
-    relation: depends-on
-  - target: k-dep2
-    relation: supports
-    layer: causal
----
-Entity note.`;
-
-    const { frontmatter } = parseFrontmatter(content);
-
-    expect(frontmatter!.links).toHaveLength(2);
-    expect(frontmatter!.links![0].target).toBe("k-dep1");
-    expect(frontmatter!.links![0].relation).toBe("depends-on");
-    expect(frontmatter!.links![0].layer).toBeUndefined();
-    expect(frontmatter!.links![1].target).toBe("k-dep2");
-    expect(frontmatter!.links![1].relation).toBe("supports");
-    expect(frontmatter!.links![1].layer).toBe("causal");
-  });
-
-  it("parses note with source object", () => {
-    const content = `---
-id: k-sourced
-type: observation
-confidence: 0.7
-source:
-  origin: agent-authored
-  trajectories: [t-100]
-  agentId: claude-v3
----
-Source test.`;
-
-    const { frontmatter } = parseFrontmatter(content);
-
-    expect(frontmatter!.source).toBeDefined();
-    expect(frontmatter!.source!.origin).toBe("agent-authored");
-    expect(frontmatter!.source!.trajectories).toEqual(["t-100"]);
-    expect(frontmatter!.source!.agentId).toBe("claude-v3");
-  });
-
-  it("round-trips via serialize then parse", () => {
-    const original: MemoryFrontmatter = {
-      id: "k-round-trip",
-      type: "domain-summary",
-      domain: ["testing"],
-      entities: ["vitest"],
-      confidence: 0.9,
-      created: "2025-02-01T00:00:00Z",
-      updated: "2025-02-01T12:00:00Z",
-      source: {
-        origin: "extracted",
-        trajectories: ["t-42"],
-      },
-      links: [
-        { target: "k-other", relation: "related-to", layer: "semantic" },
-      ],
-    };
-
-    const serialized = serializeFrontmatter(original);
-    const { frontmatter } = parseFrontmatter(serialized + "\nBody");
-
-    expect(frontmatter!.id).toBe("k-round-trip");
-    expect(frontmatter!.type).toBe("domain-summary");
-    expect(frontmatter!.domain).toEqual(["testing"]);
-    expect(frontmatter!.confidence).toBe(0.9);
-    expect(frontmatter!.source?.origin).toBe("extracted");
-    expect(frontmatter!.links).toHaveLength(1);
-    expect(frontmatter!.links![0].target).toBe("k-other");
-  });
-});
-
-// =========================================================================
-// Graph traversal
-// =========================================================================
-
-describe("Knowledge graph", () => {
-  let db: DatabaseSync;
-
-  beforeEach(() => {
-    db = new DatabaseSync(":memory:");
-    db.exec(`
-      CREATE TABLE knowledge_links (
-        from_id TEXT NOT NULL,
-        to_id TEXT NOT NULL,
-        relation TEXT NOT NULL,
-        layer TEXT,
-        weight REAL DEFAULT 0.5,
-        source_path TEXT,
-        created_at INTEGER DEFAULT (unixepoch()),
-        PRIMARY KEY (from_id, to_id, relation)
-      );
-      CREATE INDEX idx_links_from ON knowledge_links(from_id);
-      CREATE INDEX idx_links_to ON knowledge_links(to_id);
-      CREATE INDEX idx_links_layer ON knowledge_links(layer);
-    `);
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  function insertLink(
-    fromId: string,
-    toId: string,
-    relation: string,
-    layer?: string,
-    weight = 0.5,
-  ) {
-    db.prepare(
-      `INSERT INTO knowledge_links (from_id, to_id, relation, layer, weight) VALUES (?, ?, ?, ?, ?)`,
-    ).run(fromId, toId, relation, layer ?? null, weight);
-  }
-
-  it("getLinksFrom returns outgoing edges", () => {
-    insertLink("A", "B", "related-to", "semantic");
-    insertLink("A", "C", "depends-on", "causal");
-    insertLink("B", "C", "supports");
-
-    const links = getLinksFrom(db, "A");
-    expect(links).toHaveLength(2);
-    expect(links.map((l) => l.toId).sort()).toEqual(["B", "C"]);
-  });
-
-  it("getLinksTo returns incoming edges", () => {
-    insertLink("A", "C", "related-to");
-    insertLink("B", "C", "depends-on");
-
-    const links = getLinksTo(db, "C");
-    expect(links).toHaveLength(2);
-    expect(links.map((l) => l.fromId).sort()).toEqual(["A", "B"]);
-  });
-
-  it("getLinksFrom filters by relation and layer", () => {
-    insertLink("A", "B", "related-to", "semantic");
-    insertLink("A", "C", "depends-on", "causal");
-
-    const byRelation = getLinksFrom(db, "A", { relation: "related-to" });
-    expect(byRelation).toHaveLength(1);
-    expect(byRelation[0].toId).toBe("B");
-
-    const byLayer = getLinksFrom(db, "A", { layer: "causal" });
-    expect(byLayer).toHaveLength(1);
-    expect(byLayer[0].toId).toBe("C");
-  });
-
-  it("getNeighbors with depth=1 returns direct neighbors", () => {
-    insertLink("A", "B", "related-to");
-    insertLink("B", "C", "depends-on");
-    insertLink("C", "D", "supports");
-
-    const neighbors = getNeighbors(db, "A", 1);
-    expect(neighbors).toHaveLength(1);
-    expect(neighbors[0].id).toBe("B");
-    expect(neighbors[0].depth).toBe(1);
-  });
-
-  it("getNeighbors with depth=2 returns transitive neighbors", () => {
-    insertLink("A", "B", "related-to");
-    insertLink("B", "C", "depends-on");
-    insertLink("C", "D", "supports");
-
-    const neighbors = getNeighbors(db, "A", 2);
-    expect(neighbors).toHaveLength(2);
-
-    const ids = neighbors.map((n) => n.id);
-    expect(ids).toContain("B");
-    expect(ids).toContain("C");
-  });
-
-  it("getPathBetween finds shortest path", () => {
-    insertLink("A", "B", "related-to");
-    insertLink("B", "C", "depends-on");
-    insertLink("C", "D", "supports");
-
-    const path = getPathBetween(db, "A", "C");
-    expect(path).toHaveLength(2);
-    expect(path[0].fromId).toBe("A");
-    expect(path[0].toId).toBe("B");
-    expect(path[1].fromId).toBe("B");
-    expect(path[1].toId).toBe("C");
-  });
-
-  it("getPathBetween returns empty for disconnected nodes", () => {
-    insertLink("A", "B", "related-to");
-    // C is disconnected
-
-    const path = getPathBetween(db, "A", "C");
-    expect(path).toEqual([]);
-  });
-
-  it("getPathBetween handles same node", () => {
-    const path = getPathBetween(db, "A", "A");
-    expect(path).toEqual([]);
-  });
-});