claude-code-swarm 0.3.4 → 0.3.6

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

@@ -0,0 +1,407 @@
+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-frontmatter.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Tests for knowledge frontmatter parsing
+ * (Split from knowledge.test.ts to run under vitest — no node:sqlite dependency)
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  parseFrontmatter,
+  serializeFrontmatter,
+  type MemoryFrontmatter,
+} from "../session.js";
+
+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");
+  });
+});

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

@@ -0,0 +1,148 @@
+/**
+ * Tests for knowledge graph traversal (requires node:sqlite)
+ *
+ * Run with: npm run test:knowledge
+ * Frontmatter parsing tests are in knowledge-frontmatter.test.ts (vitest)
+ */
+
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { DatabaseSync } from "node:sqlite";
+import {
+  getLinksFrom,
+  getLinksTo,
+  getNeighbors,
+  getPathBetween,
+} from "../search/graph.js";
+
+describe("Knowledge graph", () => {
+  let db: DatabaseSync;
+
+  before(() => {
+    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);
+    `);
+  });
+
+  after(() => {
+    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);
+  }
+
+  function clearLinks() {
+    db.exec("DELETE FROM knowledge_links");
+  }
+
+  it("getLinksFrom returns outgoing edges", () => {
+    clearLinks();
+    insertLink("A", "B", "related-to", "semantic");
+    insertLink("A", "C", "depends-on", "causal");
+    insertLink("B", "C", "supports");
+
+    const links = getLinksFrom(db, "A");
+    assert.strictEqual(links.length, 2);
+    assert.deepStrictEqual(links.map((l) => l.toId).sort(), ["B", "C"]);
+  });
+
+  it("getLinksTo returns incoming edges", () => {
+    clearLinks();
+    insertLink("A", "C", "related-to");
+    insertLink("B", "C", "depends-on");
+
+    const links = getLinksTo(db, "C");
+    assert.strictEqual(links.length, 2);
+    assert.deepStrictEqual(links.map((l) => l.fromId).sort(), ["A", "B"]);
+  });
+
+  it("getLinksFrom filters by relation and layer", () => {
+    clearLinks();
+    insertLink("A", "B", "related-to", "semantic");
+    insertLink("A", "C", "depends-on", "causal");
+
+    const byRelation = getLinksFrom(db, "A", { relation: "related-to" });
+    assert.strictEqual(byRelation.length, 1);
+    assert.strictEqual(byRelation[0].toId, "B");
+
+    const byLayer = getLinksFrom(db, "A", { layer: "causal" });
+    assert.strictEqual(byLayer.length, 1);
+    assert.strictEqual(byLayer[0].toId, "C");
+  });
+
+  it("getNeighbors with depth=1 returns direct neighbors", () => {
+    clearLinks();
+    insertLink("A", "B", "related-to");
+    insertLink("B", "C", "depends-on");
+    insertLink("C", "D", "supports");
+
+    const neighbors = getNeighbors(db, "A", 1);
+    assert.strictEqual(neighbors.length, 1);
+    assert.strictEqual(neighbors[0].id, "B");
+    assert.strictEqual(neighbors[0].depth, 1);
+  });
+
+  it("getNeighbors with depth=2 returns transitive neighbors", () => {
+    clearLinks();
+    insertLink("A", "B", "related-to");
+    insertLink("B", "C", "depends-on");
+    insertLink("C", "D", "supports");
+
+    const neighbors = getNeighbors(db, "A", 2);
+    assert.strictEqual(neighbors.length, 2);
+
+    const ids = neighbors.map((n) => n.id);
+    assert.ok(ids.includes("B"));
+    assert.ok(ids.includes("C"));
+  });
+
+  it("getPathBetween finds shortest path", () => {
+    clearLinks();
+    insertLink("A", "B", "related-to");
+    insertLink("B", "C", "depends-on");
+    insertLink("C", "D", "supports");
+
+    const path = getPathBetween(db, "A", "C");
+    assert.strictEqual(path.length, 2);
+    assert.strictEqual(path[0].fromId, "A");
+    assert.strictEqual(path[0].toId, "B");
+    assert.strictEqual(path[1].fromId, "B");
+    assert.strictEqual(path[1].toId, "C");
+  });
+
+  it("getPathBetween returns empty for disconnected nodes", () => {
+    clearLinks();
+    insertLink("A", "B", "related-to");
+
+    const path = getPathBetween(db, "A", "C");
+    assert.deepStrictEqual(path, []);
+  });
+
+  it("getPathBetween handles same node", () => {
+    clearLinks();
+    const path = getPathBetween(db, "A", "A");
+    assert.deepStrictEqual(path, []);
+  });
+});