coding-friend-cli 1.37.0 → 1.38.1

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

@@ -1,128 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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__/sqlite-lazy-db.test.ts

@@ -1,213 +0,0 @@
-/**
- * Regression tests for lazy DB creation in SqliteBackend.
- *
- * Verifies that constructing a SqliteBackend (or performing read operations)
- * on a project with no existing memories does NOT create the DB file or dir,
- * and that the first write (store) creates the DB and the item is findable.
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, rmSync, existsSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { areSqliteDepsAvailable } from "../lib/lazy-install.js";
-import { SqliteBackend } from "../backends/sqlite/index.js";
-import { createBackendForTier } from "../lib/tier.js";
-import type { StoreInput } from "../lib/types.js";
-
-let testDir: string;
-let dbPath: string;
-let docsDir: string;
-let counter = 0;
-
-beforeEach(() => {
-  testDir = join(
-    tmpdir(),
-    `cf-memory-lazy-db-test-${Date.now()}-${++counter}`,
-  );
-  mkdirSync(testDir, { recursive: true });
-  docsDir = join(testDir, "docs", "memory");
-  dbPath = join(testDir, "db.sqlite");
-});
-
-afterEach(() => {
-  rmSync(testDir, { recursive: true, force: true });
-});
-
-const sampleInput: StoreInput = {
-  title: "Lazy DB Test Memory",
-  description: "Created to test lazy DB init",
-  type: "fact",
-  tags: ["test"],
-  content: "# Lazy DB\n\nThis memory tests deferred DB creation.",
-};
-
-const depsAvailable = areSqliteDepsAvailable();
-
-describe("SqliteBackend — lazy DB creation", () => {
-  it.skipIf(!depsAvailable)(
-    "(a) constructing the backend does NOT create the DB file",
-    () => {
-      new SqliteBackend(docsDir, { dbPath, skipVec: true });
-
-      expect(existsSync(dbPath)).toBe(false);
-    },
-  );
-
-  it.skipIf(!depsAvailable)(
-    "(b) search() on empty backend returns [] without creating the DB",
-    async () => {
-      const backend = new SqliteBackend(docsDir, { dbPath, skipVec: true });
-
-      const results = await backend.search({ query: "anything" });
-
-      expect(results).toEqual([]);
-      expect(existsSync(dbPath)).toBe(false);
-
-      await backend.close();
-    },
-  );
-
-  it.skipIf(!depsAvailable)(
-    "(b) list() on empty backend returns [] without creating the DB",
-    async () => {
-      const backend = new SqliteBackend(docsDir, { dbPath, skipVec: true });
-
-      const metas = await backend.list({});
-
-      expect(metas).toEqual([]);
-      expect(existsSync(dbPath)).toBe(false);
-
-      await backend.close();
-    },
-  );
-
-  it.skipIf(!depsAvailable)(
-    "(b) stats() on empty backend returns zeroed stats without creating the DB",
-    async () => {
-      const backend = new SqliteBackend(docsDir, { dbPath, skipVec: true });
-
-      const stats = await backend.stats();
-
-      expect(stats).toEqual({ total: 0, byCategory: {}, byType: {} });
-      expect(existsSync(dbPath)).toBe(false);
-
-      await backend.close();
-    },
-  );
-
-  it.skipIf(!depsAvailable)(
-    "(c) after store(), DB file exists and search() finds the item",
-    async () => {
-      const backend = new SqliteBackend(docsDir, { dbPath, skipVec: true });
-
-      // DB should not exist before write
-      expect(existsSync(dbPath)).toBe(false);
-
-      await backend.store(sampleInput);
-
-      // DB should now exist
-      expect(existsSync(dbPath)).toBe(true);
-
-      // Item should be findable via empty-query search (routes through list)
-      const results = await backend.search({ query: "" });
-      expect(results.length).toBe(1);
-      expect(results[0].memory.frontmatter.title).toBe("Lazy DB Test Memory");
-
-      await backend.close();
-    },
-  );
-
-  it.skipIf(!depsAvailable)(
-    "close() on a never-opened backend does not throw",
-    async () => {
-      const backend = new SqliteBackend(docsDir, { dbPath, skipVec: true });
-
-      await expect(backend.close()).resolves.toBeUndefined();
-      expect(existsSync(dbPath)).toBe(false);
-    },
-  );
-
-  it.skipIf(!depsAvailable)(
-    "getDbPath() returns the computed path without touching the filesystem",
-    () => {
-      const backend = new SqliteBackend(docsDir, { dbPath, skipVec: true });
-
-      expect(backend.getDbPath()).toBe(dbPath);
-      expect(existsSync(dbPath)).toBe(false);
-    },
-  );
-
-  it.skipIf(!depsAvailable)(
-    "delete(nonexistentId) returns false and does not create the DB",
-    async () => {
-      const backend = new SqliteBackend(docsDir, { dbPath, skipVec: true });
-
-      const result = await backend.delete("nonexistent/id");
-
-      expect(result).toBe(false);
-      expect(existsSync(dbPath)).toBe(false);
-
-      await backend.close();
-    },
-  );
-
-  it.skipIf(!depsAvailable)(
-    "update(nonexistentId) returns null and does not create the DB",
-    async () => {
-      const backend = new SqliteBackend(docsDir, { dbPath, skipVec: true });
-
-      const result = await backend.update({ id: "nonexistent/id", title: "New Title" });
-
-      expect(result).toBeNull();
-      expect(existsSync(dbPath)).toBe(false);
-
-      await backend.close();
-    },
-  );
-
-  it.skipIf(!depsAvailable)(
-    "rebuild() on empty docs/memory does not create the DB file",
-    async () => {
-      // docsDir does not exist (no memories)
-      const backend = new SqliteBackend(docsDir, { dbPath, skipVec: true });
-
-      await backend.rebuild();
-
-      expect(existsSync(dbPath)).toBe(false);
-
-      await backend.close();
-    },
-  );
-});
-
-describe("SqliteBackend — lazy DB via createBackendForTier (integration)", () => {
-  it.skipIf(!depsAvailable)(
-    "createBackendForTier 'full' on empty project does not create DB file before or after read ops",
-    async () => {
-      // Use explicit dbPath so we do not pollute ~/.coding-friend
-      const { backend, tier } = await createBackendForTier(
-        docsDir,
-        "full",
-        undefined,
-        { dbPath },
-      );
-
-      expect(tier.name).toBe("full");
-
-      // (1) No DB file after construction
-      expect(existsSync(dbPath)).toBe(false);
-
-      // (2) Read ops must not create the DB file
-      await backend.list({});
-      expect(existsSync(dbPath)).toBe(false);
-
-      await backend.search({ query: "anything" });
-      expect(existsSync(dbPath)).toBe(false);
-
-      await backend.stats();
-      expect(existsSync(dbPath)).toBe(false);
-
-      await backend.close();
-    },
-  );
-});

package/lib/cf-memory/src/__tests__/status-frame.test.ts

@@ -1,136 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildStoreStatus, buildUpdateStatus } from "../lib/status-frame.js";
-
-describe("buildStoreStatus", () => {
-  it("returns a list with markdown and database info", () => {
-    const result = buildStoreStatus({
-      id: "features/auth-pattern",
-      title: "Auth Pattern",
-      markdownPath: "/docs/memory/features/auth-pattern.md",
-      dbPath: "/home/.coding-friend/memory/projects/-foo/db.sqlite",
-    });
-
-    expect(result).toContain("features/auth-pattern");
-    expect(result).toContain("Auth Pattern");
-    expect(result).toContain("/docs/memory/features/auth-pattern.md");
-    expect(result).toContain("db.sqlite");
-    // No box-drawing characters
-    expect(result).not.toContain("╭");
-    expect(result).not.toContain("╰");
-    expect(result).not.toContain("│");
-  });
-
-  it("shows markdown-only when dbPath is null", () => {
-    const result = buildStoreStatus({
-      id: "features/auth-pattern",
-      title: "Auth Pattern",
-      markdownPath: "/docs/memory/features/auth-pattern.md",
-      dbPath: null,
-    });
-
-    expect(result).toContain("/docs/memory/features/auth-pattern.md");
-    expect(result).not.toContain("db.sqlite");
-  });
-
-  it("shows CLAUDE.md updated message when claudeMdUpdated is true", () => {
-    const result = buildStoreStatus({
-      id: "conventions/code-style",
-      title: "Code Style",
-      markdownPath: "/docs/memory/conventions/code-style.md",
-      dbPath: null,
-      claudeMdUpdated: true,
-    });
-
-    expect(result).toContain("CLAUDE.md updated");
-  });
-
-  it("omits CLAUDE.md line when claudeMdUpdated is false", () => {
-    const result = buildStoreStatus({
-      id: "features/auth-pattern",
-      title: "Auth Pattern",
-      markdownPath: "/docs/memory/features/auth-pattern.md",
-      dbPath: null,
-      claudeMdUpdated: false,
-    });
-
-    expect(result).not.toContain("CLAUDE.md");
-  });
-
-  it("omits CLAUDE.md line when claudeMdUpdated is not provided", () => {
-    const result = buildStoreStatus({
-      id: "features/auth-pattern",
-      title: "Auth Pattern",
-      markdownPath: "/docs/memory/features/auth-pattern.md",
-      dbPath: null,
-    });
-
-    expect(result).not.toContain("CLAUDE.md");
-  });
-
-  it("includes duplicate warning when provided", () => {
-    const result = buildStoreStatus({
-      id: "features/auth-pattern",
-      title: "Auth Pattern",
-      markdownPath: "/docs/memory/features/auth-pattern.md",
-      dbPath: null,
-      warning: "Near-duplicate found: features/old-auth (similarity: 0.82)",
-    });
-
-    expect(result).toContain("Near-duplicate");
-    expect(result).toContain("⚠");
-  });
-});
-
-describe("buildUpdateStatus", () => {
-  it("returns a list with markdown and database info", () => {
-    const result = buildUpdateStatus({
-      id: "features/auth-pattern",
-      title: "Auth Pattern",
-      markdownPath: "/docs/memory/features/auth-pattern.md",
-      dbPath: "/home/.coding-friend/memory/projects/-foo/db.sqlite",
-    });
-
-    expect(result).toContain("features/auth-pattern");
-    expect(result).toContain("Auth Pattern");
-    expect(result).toContain("/docs/memory/features/auth-pattern.md");
-    expect(result).toContain("db.sqlite");
-    expect(result).not.toContain("╭");
-    expect(result).not.toContain("╰");
-  });
-
-  it("shows markdown-only when dbPath is null", () => {
-    const result = buildUpdateStatus({
-      id: "features/auth-pattern",
-      title: "Auth Pattern",
-      markdownPath: "/docs/memory/features/auth-pattern.md",
-      dbPath: null,
-    });
-
-    expect(result).toContain("/docs/memory/features/auth-pattern.md");
-    expect(result).not.toContain("db.sqlite");
-  });
-
-  it("shows CLAUDE.md updated message when claudeMdUpdated is true", () => {
-    const result = buildUpdateStatus({
-      id: "conventions/code-style",
-      title: "Code Style",
-      markdownPath: "/docs/memory/conventions/code-style.md",
-      dbPath: null,
-      claudeMdUpdated: true,
-    });
-
-    expect(result).toContain("CLAUDE.md updated");
-  });
-
-  it("omits CLAUDE.md line when claudeMdUpdated is false", () => {
-    const result = buildUpdateStatus({
-      id: "conventions/code-style",
-      title: "Code Style",
-      markdownPath: "/docs/memory/conventions/code-style.md",
-      dbPath: null,
-      claudeMdUpdated: false,
-    });
-
-    expect(result).not.toContain("CLAUDE.md");
-  });
-});

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

@@ -1,54 +0,0 @@
-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);
-  });
-});