coding-friend-cli 1.16.0 → 1.17.0

package/lib/cf-memory/src/__tests__/schema.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect } from "vitest";
+import {
+  SCHEMA_V1,
+  SCHEMA_VERSION,
+  PRAGMA_SETTINGS,
+  EMBEDDING_DIMS,
+  SCHEMA_V2_METADATA,
+  getVecTableSQL,
+} from "../backends/sqlite/schema.js";
+
+describe("Schema constants", () => {
+  it("SCHEMA_VERSION is 2", () => {
+    expect(SCHEMA_VERSION).toBe(2);
+  });
+
+  it("EMBEDDING_DIMS is 384 (all-MiniLM-L6-v2)", () => {
+    expect(EMBEDDING_DIMS).toBe(384);
+  });
+
+  it("SCHEMA_V1 contains all required table creation statements", () => {
+    const combined = SCHEMA_V1.join(" ");
+
+    // Main tables
+    expect(combined).toContain("CREATE TABLE IF NOT EXISTS schema_version");
+    expect(combined).toContain("CREATE TABLE IF NOT EXISTS memories");
+    expect(combined).toContain("CREATE TABLE IF NOT EXISTS embedding_cache");
+
+    // FTS5 virtual table
+    expect(combined).toContain(
+      "CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5",
+    );
+
+    // FTS5 sync triggers
+    expect(combined).toContain("CREATE TRIGGER IF NOT EXISTS memories_ai");
+    expect(combined).toContain("CREATE TRIGGER IF NOT EXISTS memories_ad");
+    expect(combined).toContain("CREATE TRIGGER IF NOT EXISTS memories_au");
+
+    // Indexes
+    expect(combined).toContain("CREATE INDEX IF NOT EXISTS idx_memories_type");
+    expect(combined).toContain(
+      "CREATE INDEX IF NOT EXISTS idx_memories_category",
+    );
+    expect(combined).toContain(
+      "CREATE INDEX IF NOT EXISTS idx_memories_updated",
+    );
+    expect(combined).toContain(
+      "CREATE INDEX IF NOT EXISTS idx_memories_content_hash",
+    );
+  });
+
+  it("memories table has all required columns", () => {
+    const memoriesTable = SCHEMA_V1.find((s) =>
+      s.includes("CREATE TABLE IF NOT EXISTS memories"),
+    )!;
+
+    const requiredColumns = [
+      "id TEXT PRIMARY KEY",
+      "slug TEXT NOT NULL",
+      "category TEXT NOT NULL",
+      "title TEXT NOT NULL",
+      "description TEXT NOT NULL",
+      "type TEXT NOT NULL",
+      "tags TEXT NOT NULL",
+      "importance INTEGER NOT NULL",
+      "created TEXT NOT NULL",
+      "updated TEXT NOT NULL",
+      "source TEXT NOT NULL",
+      "content TEXT NOT NULL",
+      "content_hash TEXT NOT NULL",
+    ];
+
+    for (const col of requiredColumns) {
+      expect(memoriesTable).toContain(col);
+    }
+  });
+
+  it("FTS5 table uses porter tokenizer", () => {
+    const ftsTable = SCHEMA_V1.find((s) => s.includes("memories_fts"))!;
+    expect(ftsTable).toContain("tokenize='porter unicode61'");
+  });
+
+  it("embedding_cache table has required columns", () => {
+    const cacheTable = SCHEMA_V1.find((s) =>
+      s.includes("CREATE TABLE IF NOT EXISTS embedding_cache"),
+    )!;
+    expect(cacheTable).toContain("content_hash TEXT PRIMARY KEY");
+    expect(cacheTable).toContain("embedding BLOB NOT NULL");
+    expect(cacheTable).toContain("model TEXT NOT NULL");
+  });
+});
+
+describe("PRAGMA_SETTINGS", () => {
+  it("enables WAL mode", () => {
+    expect(PRAGMA_SETTINGS).toContain("PRAGMA journal_mode = WAL");
+  });
+
+  it("sets synchronous to NORMAL", () => {
+    expect(PRAGMA_SETTINGS).toContain("PRAGMA synchronous = NORMAL");
+  });
+
+  it("sets cache size", () => {
+    const cachePragma = PRAGMA_SETTINGS.find((p) => p.includes("cache_size"));
+    expect(cachePragma).toBeDefined();
+  });
+});
+
+describe("getVecTableSQL()", () => {
+  it("creates vec0 table with default dims", () => {
+    const sql = getVecTableSQL();
+    expect(sql).toContain(
+      "CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0",
+    );
+    expect(sql).toContain("float[384]");
+  });
+
+  it("supports custom dimensions", () => {
+    const sql = getVecTableSQL(768);
+    expect(sql).toContain("float[768]");
+  });
+});
+
+describe("SCHEMA_V2_METADATA", () => {
+  it("creates metadata table with key-value structure", () => {
+    expect(SCHEMA_V2_METADATA).toContain("CREATE TABLE IF NOT EXISTS metadata");
+    expect(SCHEMA_V2_METADATA).toContain("key TEXT PRIMARY KEY");
+    expect(SCHEMA_V2_METADATA).toContain("value TEXT NOT NULL");
+  });
+});

package/lib/cf-memory/src/__tests__/search.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from "vitest";
+import { detectSearchMode, rrfFuse } from "../backends/sqlite/search.js";
+
+describe("detectSearchMode()", () => {
+  it("returns 'keyword' for quoted strings", () => {
+    expect(detectSearchMode('"exact phrase"')).toBe("keyword");
+    expect(detectSearchMode("'single quoted'")).toBe("keyword");
+  });
+
+  it("returns 'keyword' for code-like patterns", () => {
+    expect(detectSearchMode("auth.middleware")).toBe("keyword");
+    expect(detectSearchMode("std::vector")).toBe("keyword");
+    expect(detectSearchMode("user->name")).toBe("keyword");
+    expect(detectSearchMode("src/lib/auth")).toBe("keyword");
+  });
+
+  it("returns 'semantic' for questions", () => {
+    expect(detectSearchMode("how does auth work")).toBe("semantic");
+    expect(detectSearchMode("What is the login flow")).toBe("semantic");
+    expect(detectSearchMode("why did we choose JWT")).toBe("semantic");
+    expect(detectSearchMode("where is the config stored")).toBe("semantic");
+    expect(detectSearchMode("when was this added")).toBe("semantic");
+    expect(detectSearchMode("who implemented this")).toBe("semantic");
+    expect(detectSearchMode("is this deprecated")).toBe("semantic");
+    expect(detectSearchMode("can we use OAuth")).toBe("semantic");
+    expect(detectSearchMode("does this support SSO")).toBe("semantic");
+    expect(detectSearchMode("should we migrate")).toBe("semantic");
+    expect(detectSearchMode("which database to use")).toBe("semantic");
+  });
+
+  it("returns 'hybrid' for general queries", () => {
+    expect(detectSearchMode("authentication")).toBe("hybrid");
+    expect(detectSearchMode("JWT tokens")).toBe("hybrid");
+    expect(detectSearchMode("database migration")).toBe("hybrid");
+    expect(detectSearchMode("CORS fix")).toBe("hybrid");
+  });
+
+  it("handles edge cases", () => {
+    expect(detectSearchMode("  authentication  ")).toBe("hybrid");
+    expect(detectSearchMode("How")).toBe("semantic");
+  });
+});
+
+describe("rrfFuse()", () => {
+  it("merges two ranked lists using RRF", () => {
+    const list1 = [
+      { id: "a", score: 10, matchedOn: ["title"] },
+      { id: "b", score: 5, matchedOn: ["content"] },
+    ];
+    const list2 = [
+      { id: "b", score: 0.9, matchedOn: ["semantic"] },
+      { id: "c", score: 0.5, matchedOn: ["semantic"] },
+    ];
+
+    const fused = rrfFuse(list1, list2);
+
+    // "b" appears in both lists, should have highest RRF score
+    expect(fused[0].id).toBe("b");
+    expect(fused[0].matchedOn).toContain("content");
+    expect(fused[0].matchedOn).toContain("semantic");
+
+    // All three items should be in the result
+    expect(fused.map((r) => r.id).sort()).toEqual(["a", "b", "c"]);
+  });
+
+  it("handles single list", () => {
+    const list = [
+      { id: "a", score: 10, matchedOn: ["title"] },
+      { id: "b", score: 5, matchedOn: ["content"] },
+    ];
+
+    const fused = rrfFuse(list);
+    expect(fused).toHaveLength(2);
+    expect(fused[0].id).toBe("a"); // rank 0 in first list
+  });
+
+  it("handles empty lists", () => {
+    expect(rrfFuse([], [])).toEqual([]);
+    expect(rrfFuse([])).toEqual([]);
+  });
+
+  it("handles three lists", () => {
+    const list1 = [{ id: "a", score: 10, matchedOn: ["title"] }];
+    const list2 = [{ id: "a", score: 0.9, matchedOn: ["semantic"] }];
+    const list3 = [{ id: "b", score: 5, matchedOn: ["tags"] }];
+
+    const fused = rrfFuse(list1, list2, list3);
+
+    // "a" appears in 2 lists, should rank higher than "b" in 1 list
+    expect(fused[0].id).toBe("a");
+    expect(fused[0].score).toBeGreaterThan(fused[1].score);
+  });
+
+  it("RRF scores are positive", () => {
+    const list = [
+      { id: "a", score: 10, matchedOn: ["title"] },
+      { id: "b", score: 5, matchedOn: ["content"] },
+    ];
+
+    const fused = rrfFuse(list);
+    for (const item of fused) {
+      expect(item.score).toBeGreaterThan(0);
+    }
+  });
+
+  it("merges matchedOn from multiple lists", () => {
+    const list1 = [{ id: "a", score: 10, matchedOn: ["title", "tags"] }];
+    const list2 = [{ id: "a", score: 0.9, matchedOn: ["semantic"] }];
+
+    const fused = rrfFuse(list1, list2);
+    expect(fused[0].matchedOn).toContain("title");
+    expect(fused[0].matchedOn).toContain("tags");
+    expect(fused[0].matchedOn).toContain("semantic");
+  });
+});

package/lib/cf-memory/src/__tests__/temporal-decay.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest";
+import { applyTemporalDecay } from "../lib/temporal-decay.js";
+
+describe("applyTemporalDecay()", () => {
+  it("keeps ~100% of score for today's date", () => {
+    const today = new Date().toISOString().split("T")[0];
+    const result = applyTemporalDecay(10, today);
+    // Should be very close to original score
+    expect(result).toBeGreaterThan(9.9);
+    expect(result).toBeLessThanOrEqual(10);
+  });
+
+  it("decays score for 90-day-old memories", () => {
+    const date90ago = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000)
+      .toISOString()
+      .split("T")[0];
+    const result = applyTemporalDecay(10, date90ago);
+    // 0.7 + 0.3 * exp(-1) ≈ 0.7 + 0.3 * 0.368 ≈ 0.81
+    expect(result).toBeGreaterThan(7.5);
+    expect(result).toBeLessThan(8.5);
+  });
+
+  it("keeps at least 70% of score for very old memories", () => {
+    const result = applyTemporalDecay(10, "2020-01-01");
+    // 0.7 + 0.3 * exp(-very_large) ≈ 0.7
+    expect(result).toBeGreaterThanOrEqual(6.9);
+    expect(result).toBeLessThan(7.2);
+  });
+
+  it("boosts score based on access count", () => {
+    const today = new Date().toISOString().split("T")[0];
+    const withoutAccess = applyTemporalDecay(10, today);
+    const withAccess = applyTemporalDecay(10, today, 5);
+    expect(withAccess).toBeGreaterThan(withoutAccess);
+  });
+
+  it("caps access boost at 10", () => {
+    const today = new Date().toISOString().split("T")[0];
+    const at10 = applyTemporalDecay(10, today, 10);
+    const at100 = applyTemporalDecay(10, today, 100);
+    expect(at10).toBe(at100);
+  });
+
+  it("handles zero score", () => {
+    const result = applyTemporalDecay(0, "2026-01-01");
+    expect(result).toBe(0);
+  });
+
+  it("handles negative score (BM25 negated)", () => {
+    const today = new Date().toISOString().split("T")[0];
+    const result = applyTemporalDecay(-5, today);
+    expect(result).toBeLessThan(0);
+  });
+});

package/lib/cf-memory/src/__tests__/tier.test.ts

@@ -0,0 +1,293 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { detectTier, createBackendForTier, TIERS } from "../lib/tier.js";
+import { MarkdownBackend } from "../backends/markdown.js";
+import { DaemonClient } from "../lib/daemon-client.js";
+import type { DaemonPaths } from "../daemon/process.js";
+
+let testDir: string;
+
+beforeEach(() => {
+  testDir = join(tmpdir(), `cf-memory-tier-test-${Date.now()}`);
+  mkdirSync(testDir, { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+describe("detectTier()", () => {
+  it("returns Tier 3 (markdown) when no daemon is running and no sqlite deps", async () => {
+    const lazyInstall = await import("../lib/lazy-install.js");
+    const sqliteSpy = vi
+      .spyOn(lazyInstall, "areSqliteDepsAvailable")
+      .mockReturnValue(false);
+    try {
+      const tier = await detectTier();
+      // Without a daemon running and no SQLite deps, should detect Tier 3
+      expect(tier.name).toBe("markdown");
+      expect(tier.number).toBe(3);
+      expect(tier.label).toContain("Tier 3");
+    } finally {
+      sqliteSpy.mockRestore();
+    }
+  });
+
+  it("respects config override to markdown", async () => {
+    const tier = await detectTier("markdown");
+    expect(tier.name).toBe("markdown");
+  });
+
+  it("respects config override to lite", async () => {
+    const tier = await detectTier("lite");
+    expect(tier.name).toBe("lite");
+    expect(tier.number).toBe(2);
+  });
+
+  it("respects config override to full", async () => {
+    const tier = await detectTier("full");
+    expect(tier.name).toBe("full");
+    expect(tier.number).toBe(1);
+  });
+
+  it("auto mode defaults to markdown when no daemon and no sqlite deps", async () => {
+    // Mock areSqliteDepsAvailable to return false
+    const lazyInstall = await import("../lib/lazy-install.js");
+    const sqliteSpy = vi
+      .spyOn(lazyInstall, "areSqliteDepsAvailable")
+      .mockReturnValue(false);
+    try {
+      const tier = await detectTier("auto");
+      expect(tier.name).toBe("markdown");
+    } finally {
+      sqliteSpy.mockRestore();
+    }
+  });
+
+  it("auto mode returns full when SQLite deps are available", async () => {
+    const lazyInstall = await import("../lib/lazy-install.js");
+    const sqliteSpy = vi
+      .spyOn(lazyInstall, "areSqliteDepsAvailable")
+      .mockReturnValue(true);
+    try {
+      const tier = await detectTier("auto");
+      expect(tier.name).toBe("full");
+      expect(tier.number).toBe(1);
+    } finally {
+      sqliteSpy.mockRestore();
+    }
+  });
+
+  it("auto mode returns lite when daemon is running (no sqlite deps)", async () => {
+    // Mock areSqliteDepsAvailable to return false, isDaemonRunning to return true
+    const lazyInstall = await import("../lib/lazy-install.js");
+    const sqliteSpy = vi
+      .spyOn(lazyInstall, "areSqliteDepsAvailable")
+      .mockReturnValue(false);
+    const daemonProcess = await import("../daemon/process.js");
+    const spy = vi
+      .spyOn(daemonProcess, "isDaemonRunning")
+      .mockResolvedValue(true);
+    try {
+      const tier = await detectTier("auto");
+      expect(tier.name).toBe("lite");
+      expect(tier.number).toBe(2);
+    } finally {
+      spy.mockRestore();
+      sqliteSpy.mockRestore();
+    }
+  });
+});
+
+describe("createBackendForTier()", () => {
+  it("creates MarkdownBackend for markdown tier", async () => {
+    const { backend, tier } = await createBackendForTier(testDir, "markdown");
+    expect(tier.name).toBe("markdown");
+    expect(backend).toBeInstanceOf(MarkdownBackend);
+    await backend.close();
+  });
+
+  it("auto tier falls back to markdown when no daemon and no sqlite deps", async () => {
+    const lazyInstall = await import("../lib/lazy-install.js");
+    const sqliteSpy = vi
+      .spyOn(lazyInstall, "areSqliteDepsAvailable")
+      .mockReturnValue(false);
+    try {
+      const { backend, tier } = await createBackendForTier(testDir, "auto");
+      expect(tier.name).toBe("markdown");
+      expect(backend).toBeInstanceOf(MarkdownBackend);
+      await backend.close();
+    } finally {
+      sqliteSpy.mockRestore();
+    }
+  });
+
+  it("auto tier creates SqliteBackend when sqlite deps available", async () => {
+    const lazyInstall = await import("../lib/lazy-install.js");
+    if (!lazyInstall.areSqliteDepsAvailable()) return; // skip if deps not installed
+    const dbPath = join(testDir, "db.sqlite");
+    const { backend, tier } = await createBackendForTier(
+      testDir,
+      "auto",
+      undefined,
+      { dbPath },
+    );
+    expect(tier.name).toBe("full");
+    await backend.close();
+  });
+
+  it("full tier falls back to markdown when SQLite deps not available", async () => {
+    // Without lazy-installed deps, SqliteBackend will fail to construct
+    // and createBackendForTier should fall back to markdown
+    const dbPath = join(testDir, "db.sqlite");
+    const { backend, tier } = await createBackendForTier(
+      testDir,
+      "full",
+      undefined,
+      { dbPath },
+    );
+    // Falls back because better-sqlite3 is not installed in test env
+    expect(["markdown", "full"]).toContain(tier.name);
+    await backend.close();
+  });
+
+  it("lite tier with running daemon returns DaemonClient", async () => {
+    // Start a real daemon to test the full path
+    const { MiniSearchBackend } = await import("../backends/minisearch.js");
+    const { startDaemonServer } = await import("../daemon/process.js");
+
+    const docsDir = join(testDir, "docs");
+    mkdirSync(docsDir, { recursive: true });
+    const daemonDir = join(testDir, "daemon");
+    mkdirSync(daemonDir, { recursive: true });
+
+    const paths: DaemonPaths = {
+      socketPath: join(daemonDir, "daemon.sock"),
+      pidFile: join(daemonDir, "daemon.pid"),
+      logFile: join(daemonDir, "daemon.log"),
+    };
+
+    const backend = new MiniSearchBackend(docsDir);
+    const handle = startDaemonServer(backend, {
+      paths,
+      idleTimeoutMs: 0,
+    });
+
+    await new Promise<void>((resolve) => {
+      handle.server.once("listening", resolve);
+    });
+
+    try {
+      // Mock getDaemonPaths so createBackendForTier uses our test paths
+      const daemonProcess = await import("../daemon/process.js");
+      const pathsSpy = vi
+        .spyOn(daemonProcess, "getDaemonPaths")
+        .mockReturnValue(paths);
+
+      const { backend: created, tier } = await createBackendForTier(
+        docsDir,
+        "lite",
+      );
+      expect(tier.name).toBe("lite");
+      expect(created).toBeInstanceOf(DaemonClient);
+      await created.close();
+      pathsSpy.mockRestore();
+    } finally {
+      await new Promise<void>((resolve) => {
+        handle.server.close(() => resolve());
+      });
+      rmSync(paths.socketPath, { force: true });
+      rmSync(paths.pidFile, { force: true });
+    }
+  });
+
+  it("lite tier falls back to markdown when daemon is unreachable mid-session", async () => {
+    // Simulate: tier detection says "lite" but daemon socket is gone
+    // Must also mock SQLite deps away so auto tier picks "lite" over "full"
+    const lazyInstall = await import("../lib/lazy-install.js");
+    const sqliteSpy = vi
+      .spyOn(lazyInstall, "areSqliteDepsAvailable")
+      .mockReturnValue(false);
+    const daemonProcess = await import("../daemon/process.js");
+    const spy = vi
+      .spyOn(daemonProcess, "isDaemonRunning")
+      .mockResolvedValue(true);
+    const pathsSpy = vi.spyOn(daemonProcess, "getDaemonPaths").mockReturnValue({
+      socketPath: "/tmp/nonexistent-cf-test-sock-" + Date.now(),
+      pidFile: "/tmp/nonexistent-cf-test-pid-" + Date.now(),
+      logFile: "/tmp/nonexistent-cf-test-log-" + Date.now(),
+    });
+
+    try {
+      const { backend: created, tier } = await createBackendForTier(
+        testDir,
+        "auto",
+      );
+      // DaemonClient.ping() fails → falls back to MarkdownBackend
+      expect(tier.name).toBe("markdown");
+      expect(created).toBeInstanceOf(MarkdownBackend);
+      await created.close();
+    } finally {
+      sqliteSpy.mockRestore();
+      spy.mockRestore();
+      pathsSpy.mockRestore();
+    }
+  });
+});
+
+describe("createBackendForTier() with embeddingConfig", () => {
+  it("accepts an optional embeddingConfig parameter without error", async () => {
+    const embeddingConfig = {
+      provider: "ollama" as const,
+      model: "nomic-embed-text",
+      ollamaUrl: "http://localhost:11434",
+    };
+    // Should not throw — markdown tier ignores embedding config gracefully
+    const { backend, tier } = await createBackendForTier(
+      testDir,
+      "markdown",
+      embeddingConfig,
+    );
+    expect(tier.name).toBe("markdown");
+    expect(backend).toBeInstanceOf(MarkdownBackend);
+    await backend.close();
+  });
+
+  it("passes embeddingConfig through when full tier falls back to markdown", async () => {
+    const embeddingConfig = {
+      provider: "ollama" as const,
+      model: "nomic-embed-text",
+    };
+    const dbPath = join(testDir, "db.sqlite");
+    // Full tier will fail (no sqlite deps in test env) and fall back
+    const { backend, tier } = await createBackendForTier(
+      testDir,
+      "full",
+      embeddingConfig,
+      { dbPath },
+    );
+    // Falls back because better-sqlite3 is not installed in test env
+    expect(["markdown", "full"]).toContain(tier.name);
+    await backend.close();
+  });
+});
+
+describe("TIERS constant", () => {
+  it("has all 3 tier definitions", () => {
+    expect(Object.keys(TIERS)).toHaveLength(3);
+    expect(TIERS.full.number).toBe(1);
+    expect(TIERS.lite.number).toBe(2);
+    expect(TIERS.markdown.number).toBe(3);
+  });
+
+  it("each tier has name, label, and number", () => {
+    for (const tier of Object.values(TIERS)) {
+      expect(tier.name).toBeTruthy();
+      expect(tier.label).toBeTruthy();
+      expect(tier.number).toBeGreaterThanOrEqual(1);
+      expect(tier.number).toBeLessThanOrEqual(3);
+    }
+  });
+});

package/lib/cf-memory/src/__tests__/tools.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { MarkdownBackend } from "../backends/markdown.js";
+import { registerAllTools } from "../server.js";
+import { registerAllResources } from "../resources/index.js";
+
+let testDir: string;
+let server: McpServer;
+let backend: MarkdownBackend;
+
+beforeEach(() => {
+  testDir = join(tmpdir(), `cf-memory-tools-test-${Date.now()}`);
+  mkdirSync(testDir, { recursive: true });
+  backend = new MarkdownBackend(testDir);
+  server = new McpServer({
+    name: "test-memory-server",
+    version: "0.0.1",
+  });
+});
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+describe("MCP Tool Registration", () => {
+  it("registers all 6 tools without error", () => {
+    expect(() => registerAllTools(server, backend)).not.toThrow();
+  });
+
+  it("registers all 2 resources without error", () => {
+    expect(() => registerAllResources(server, backend)).not.toThrow();
+  });
+
+  it("registers both tools and resources together", () => {
+    expect(() => {
+      registerAllTools(server, backend);
+      registerAllResources(server, backend);
+    }).not.toThrow();
+  });
+});
+
+describe("MemoryBackend interface compliance", () => {
+  it("has all 8 required methods", () => {
+    expect(typeof backend.store).toBe("function");
+    expect(typeof backend.search).toBe("function");
+    expect(typeof backend.retrieve).toBe("function");
+    expect(typeof backend.list).toBe("function");
+    expect(typeof backend.update).toBe("function");
+    expect(typeof backend.delete).toBe("function");
+    expect(typeof backend.stats).toBe("function");
+    expect(typeof backend.close).toBe("function");
+  });
+});
+
+describe("Type validation", () => {
+  it("MEMORY_TYPES has exactly 5 types", async () => {
+    const { MEMORY_TYPES } = await import("../lib/types.js");
+    expect(MEMORY_TYPES).toHaveLength(5);
+    expect(MEMORY_TYPES).toContain("fact");
+    expect(MEMORY_TYPES).toContain("preference");
+    expect(MEMORY_TYPES).toContain("context");
+    expect(MEMORY_TYPES).toContain("episode");
+    expect(MEMORY_TYPES).toContain("procedure");
+  });
+
+  it("MEMORY_CATEGORIES maps all types to folders", async () => {
+    const { MEMORY_CATEGORIES, MEMORY_TYPES } = await import("../lib/types.js");
+    for (const type of MEMORY_TYPES) {
+      expect(MEMORY_CATEGORIES[type]).toBeTruthy();
+    }
+  });
+
+  it("CATEGORY_TO_TYPE is inverse of MEMORY_CATEGORIES", async () => {
+    const { MEMORY_CATEGORIES, CATEGORY_TO_TYPE } =
+      await import("../lib/types.js");
+    for (const [type, category] of Object.entries(MEMORY_CATEGORIES)) {
+      expect(CATEGORY_TO_TYPE[category]).toBe(type);
+    }
+  });
+});