coding-friend-cli 1.36.4 → 1.38.0

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__/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);
-  });
-});