coding-friend-cli 1.16.0 → 1.17.0

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

@@ -0,0 +1,288 @@
+import { describe, it, expect } from "vitest";
+import {
+  getSchemaVersion,
+  migrate,
+  applyPragmas,
+  getMetadata,
+  setMetadata,
+  checkEmbeddingMismatch,
+  type DatabaseLike,
+} from "../backends/sqlite/migrations.js";
+import { SCHEMA_VERSION } from "../backends/sqlite/schema.js";
+import { DEFAULT_TRANSFORMERS_MODEL } from "../backends/sqlite/embeddings.js";
+
+/**
+ * In-memory mock database for testing schema logic without better-sqlite3.
+ *
+ * Tracks SQL statements and supports basic prepare/get/run.
+ * Note: The `exec` method here is better-sqlite3's SQL execution,
+ * NOT child_process.exec — there is no shell involvement.
+ */
+function createMockDb(): DatabaseLike & {
+  statements: string[];
+  tables: Map<string, Array<Record<string, unknown>>>;
+} {
+  const statements: string[] = [];
+  const tables = new Map<string, Array<Record<string, unknown>>>();
+
+  return {
+    statements,
+    tables,
+    // better-sqlite3 Database.exec() — runs SQL, not shell commands
+    exec(sql: string) {
+      statements.push(sql);
+
+      // Simulate table creation and data insertion
+      if (sql.includes("INSERT INTO schema_version")) {
+        const match = sql.match(/VALUES\s*\((\d+)\)/);
+        if (match) {
+          tables.set("schema_version", [{ version: parseInt(match[1], 10) }]);
+        }
+      }
+    },
+    pragma(pragma: string) {
+      statements.push(`PRAGMA ${pragma}`);
+      return undefined;
+    },
+    prepare(sql: string) {
+      return {
+        get(..._params: unknown[]) {
+          if (sql.includes("schema_version")) {
+            const rows = tables.get("schema_version");
+            return rows?.[0];
+          }
+          return undefined;
+        },
+        run(...params: unknown[]) {
+          statements.push(sql);
+          // Simulate schema_version UPDATE from migrations
+          if (sql.includes("UPDATE schema_version SET version")) {
+            const version = params[0] as number;
+            tables.set("schema_version", [{ version }]);
+          }
+          return {};
+        },
+      };
+    },
+  };
+}
+
+describe("getSchemaVersion()", () => {
+  it("returns 0 when table doesn't exist", () => {
+    const db = createMockDb();
+    // Override prepare to throw (simulating missing table)
+    db.prepare = () => ({
+      get() {
+        throw new Error("no such table: schema_version");
+      },
+      run() {
+        return {};
+      },
+    });
+
+    expect(getSchemaVersion(db)).toBe(0);
+  });
+
+  it("returns version from schema_version table", () => {
+    const db = createMockDb();
+    db.tables.set("schema_version", [{ version: 1 }]);
+    expect(getSchemaVersion(db)).toBe(1);
+  });
+});
+
+describe("applyPragmas()", () => {
+  it("runs all PRAGMA settings", () => {
+    const db = createMockDb();
+    applyPragmas(db);
+
+    expect(db.statements.some((s) => s.includes("journal_mode"))).toBe(true);
+    expect(db.statements.some((s) => s.includes("synchronous"))).toBe(true);
+    expect(db.statements.some((s) => s.includes("cache_size"))).toBe(true);
+  });
+});
+
+describe("migrate()", () => {
+  it("applies schema from version 0", () => {
+    const db = createMockDb();
+    const result = migrate(db);
+
+    expect(result.version).toBe(SCHEMA_VERSION);
+    expect(result.migrated).toBe(true);
+
+    // Should have run schema creation SQL
+    expect(db.statements.some((s) => s.includes("CREATE TABLE"))).toBe(true);
+    expect(db.statements.some((s) => s.includes("memories_fts"))).toBe(true);
+  });
+
+  it("is idempotent — running twice produces same result", () => {
+    const db = createMockDb();
+
+    const first = migrate(db);
+    expect(first.migrated).toBe(true);
+
+    // Now schema_version exists with version 1
+    const second = migrate(db);
+    expect(second.version).toBe(SCHEMA_VERSION);
+    expect(second.migrated).toBe(false);
+  });
+
+  it("skips migration when already at current version", () => {
+    const db = createMockDb();
+    db.tables.set("schema_version", [{ version: SCHEMA_VERSION }]);
+
+    const result = migrate(db);
+    expect(result.migrated).toBe(false);
+    expect(result.version).toBe(SCHEMA_VERSION);
+  });
+
+  it("migrates from v1 to v2 creating metadata table", () => {
+    const db = createMockDb();
+    // Simulate existing v1 database
+    db.tables.set("schema_version", [{ version: 1 }]);
+
+    const result = migrate(db);
+    expect(result.version).toBe(SCHEMA_VERSION);
+    expect(result.migrated).toBe(true);
+
+    // Should have created metadata table
+    expect(
+      db.statements.some((s) =>
+        s.includes("CREATE TABLE IF NOT EXISTS metadata"),
+      ),
+    ).toBe(true);
+  });
+});
+
+/**
+ * Enhanced mock database that supports metadata table operations.
+ */
+function createMetadataMockDb(): DatabaseLike & {
+  metadata: Map<string, string>;
+} {
+  const metadata = new Map<string, string>();
+
+  return {
+    metadata,
+    // better-sqlite3 Database.exec() - runs SQL, not shell commands
+    exec(_sql: string) {
+      // Handle metadata table creation (no-op in mock)
+    },
+    pragma() {
+      return undefined;
+    },
+    prepare(sql: string) {
+      return {
+        get(...params: unknown[]) {
+          if (sql.includes("SELECT value FROM metadata WHERE key = ?")) {
+            const key = params[0] as string;
+            const val = metadata.get(key);
+            return val !== undefined ? { value: val } : undefined;
+          }
+          return undefined;
+        },
+        run(...params: unknown[]) {
+          if (sql.includes("INSERT OR REPLACE INTO metadata")) {
+            const key = params[0] as string;
+            const value = params[1] as string;
+            metadata.set(key, value);
+          }
+          return {};
+        },
+      };
+    },
+  };
+}
+
+describe("getMetadata() and setMetadata()", () => {
+  it("returns null for missing key", () => {
+    const db = createMetadataMockDb();
+    expect(getMetadata(db, "nonexistent")).toBeNull();
+  });
+
+  it("stores and retrieves a value", () => {
+    const db = createMetadataMockDb();
+    setMetadata(db, "embedding_model", "nomic-embed-text");
+    expect(getMetadata(db, "embedding_model")).toBe("nomic-embed-text");
+  });
+
+  it("overwrites existing value", () => {
+    const db = createMetadataMockDb();
+    setMetadata(db, "embedding_dims", "384");
+    setMetadata(db, "embedding_dims", "768");
+    expect(getMetadata(db, "embedding_dims")).toBe("768");
+  });
+});
+
+describe("checkEmbeddingMismatch()", () => {
+  it("returns mismatched=false when model and dims match", () => {
+    const db = createMetadataMockDb();
+    setMetadata(db, "embedding_model", DEFAULT_TRANSFORMERS_MODEL);
+    setMetadata(db, "embedding_dims", "384");
+
+    const result = checkEmbeddingMismatch(db, DEFAULT_TRANSFORMERS_MODEL, 384);
+    expect(result.mismatched).toBe(false);
+    expect(result.storedModel).toBe(DEFAULT_TRANSFORMERS_MODEL);
+    expect(result.storedDims).toBe(384);
+    expect(result.currentModel).toBe(DEFAULT_TRANSFORMERS_MODEL);
+    expect(result.currentDims).toBe(384);
+  });
+
+  it("returns mismatched=true when model changed", () => {
+    const db = createMetadataMockDb();
+    setMetadata(db, "embedding_model", DEFAULT_TRANSFORMERS_MODEL);
+    setMetadata(db, "embedding_dims", "384");
+
+    const result = checkEmbeddingMismatch(db, "nomic-embed-text", 768);
+    expect(result.mismatched).toBe(true);
+    expect(result.storedModel).toBe(DEFAULT_TRANSFORMERS_MODEL);
+    expect(result.storedDims).toBe(384);
+    expect(result.currentModel).toBe("nomic-embed-text");
+    expect(result.currentDims).toBe(768);
+  });
+
+  it("returns mismatched=true when only dims changed", () => {
+    const db = createMetadataMockDb();
+    setMetadata(db, "embedding_model", "custom-model");
+    setMetadata(db, "embedding_dims", "384");
+
+    const result = checkEmbeddingMismatch(db, "custom-model", 768);
+    expect(result.mismatched).toBe(true);
+  });
+
+  it("returns mismatched=false when no metadata exists (fresh db)", () => {
+    const db = createMetadataMockDb();
+    // No metadata set -- fresh database
+    const result = checkEmbeddingMismatch(db, "all-MiniLM-L6-v2", 384);
+    expect(result.mismatched).toBe(false);
+  });
+
+  it("returns mismatched=false when only partial metadata exists", () => {
+    const db = createMetadataMockDb();
+    // Only model set, no dims -- treat as fresh
+    setMetadata(db, "embedding_model", DEFAULT_TRANSFORMERS_MODEL);
+    const result = checkEmbeddingMismatch(db, DEFAULT_TRANSFORMERS_MODEL, 384);
+    expect(result.mismatched).toBe(false);
+  });
+
+  it("v1→v2 migration default matches DEFAULT_TRANSFORMERS_MODEL (no false positive)", () => {
+    // Regression: migration used to store "all-MiniLM-L6-v2" but pipeline
+    // resolves to "Xenova/all-MiniLM-L6-v2", causing a spurious mismatch warning
+    const db = createMockDb();
+    // Simulate fresh v0 database → migrate to v2
+    migrate(db);
+
+    // The migration should have stored the full qualified model name
+    // that matches what EmbeddingPipeline.modelName returns
+    const metaDb = createMetadataMockDb();
+    // Simulate what migrateV1ToV2 stores
+    setMetadata(metaDb, "embedding_model", "Xenova/all-MiniLM-L6-v2");
+    setMetadata(metaDb, "embedding_dims", "384");
+
+    const result = checkEmbeddingMismatch(
+      metaDb,
+      DEFAULT_TRANSFORMERS_MODEL,
+      384,
+    );
+    expect(result.mismatched).toBe(false);
+  });
+});

package/lib/cf-memory/src/__tests__/minisearch-backend.test.ts

@@ -0,0 +1,262 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { MiniSearchBackend } from "../backends/minisearch.js";
+import type { StoreInput } from "../lib/types.js";
+
+let testDir: string;
+let backend: MiniSearchBackend;
+let counter = 0;
+
+beforeEach(() => {
+  testDir = join(tmpdir(), `cf-memory-mini-test-${Date.now()}-${++counter}`);
+  mkdirSync(testDir, { recursive: true });
+  backend = new MiniSearchBackend(testDir);
+});
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+const sampleInput: StoreInput = {
+  title: "API Authentication Pattern",
+  description: "Auth module uses JWT tokens stored in httpOnly cookies",
+  type: "fact",
+  tags: ["auth", "jwt", "api"],
+  content: "# API Auth\n\nThe project uses JWT tokens with refresh rotation.",
+};
+
+describe("MiniSearchBackend", () => {
+  describe("store()", () => {
+    it("stores a memory and indexes it", async () => {
+      const memory = await backend.store(sampleInput);
+      expect(memory.id).toBe("features/api-authentication-pattern");
+      expect(memory.frontmatter.title).toBe("API Authentication Pattern");
+
+      // Verify it's searchable
+      const results = await backend.search({ query: "authentication" });
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].memory.frontmatter.title).toContain("Authentication");
+    });
+  });
+
+  describe("search()", () => {
+    beforeEach(async () => {
+      await backend.store(sampleInput);
+      await backend.store({
+        title: "Database Migration Guide",
+        description: "How to run database migrations with Prisma",
+        type: "procedure",
+        tags: ["database", "prisma", "migration"],
+        content: "# Migrations\n\nRun npx prisma migrate dev.",
+      });
+      await backend.store({
+        title: "CORS Bug Fix",
+        description: "Fixed CORS issue on /api/upload endpoint",
+        type: "episode",
+        tags: ["cors", "api", "bug"],
+        content: "# CORS Fix\n\nAdded missing Origin header to allowlist.",
+      });
+    });
+
+    it("finds by title match", async () => {
+      const results = await backend.search({ query: "authentication" });
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].memory.frontmatter.title).toContain("Authentication");
+    });
+
+    it("finds by tag match", async () => {
+      const results = await backend.search({ query: "prisma" });
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].memory.frontmatter.title).toBe(
+        "Database Migration Guide",
+      );
+    });
+
+    it("finds by content match", async () => {
+      const results = await backend.search({ query: "allowlist" });
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].memory.frontmatter.title).toContain("CORS");
+    });
+
+    it("fuzzy search finds results that substring grep misses", async () => {
+      // Typo: "autentication" (missing 'h')
+      const results = await backend.search({ query: "autentication" });
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].memory.frontmatter.title).toContain("Authentication");
+    });
+
+    it("BM25 ranking: both exact and partial find the right result", async () => {
+      const exactResults = await backend.search({ query: "authentication" });
+      const partialResults = await backend.search({ query: "auth" });
+
+      // Both should find the auth memory
+      expect(exactResults.length).toBeGreaterThan(0);
+      expect(partialResults.length).toBeGreaterThan(0);
+
+      const exactHit = exactResults.find((r) =>
+        r.memory.frontmatter.title.includes("Authentication"),
+      );
+      const partialHit = partialResults.find((r) =>
+        r.memory.frontmatter.title.includes("Authentication"),
+      );
+
+      expect(exactHit).toBeDefined();
+      expect(partialHit).toBeDefined();
+      // Both should have positive scores
+      expect(exactHit!.score).toBeGreaterThan(0);
+      expect(partialHit!.score).toBeGreaterThan(0);
+    });
+
+    it("boost: title/tags matches rank above content-only matches", async () => {
+      // "api" is in both title/tags of CORS and content of auth
+      const results = await backend.search({ query: "api" });
+      expect(results.length).toBeGreaterThanOrEqual(2);
+      // The first result should have matched on title or tags, not just content
+      expect(results[0].matchedOn.length).toBeGreaterThan(0);
+    });
+
+    it("filters by type", async () => {
+      const results = await backend.search({
+        query: "api",
+        type: "episode",
+      });
+      for (const r of results) {
+        expect(r.memory.frontmatter.type).toBe("episode");
+      }
+    });
+
+    it("filters by tags", async () => {
+      const results = await backend.search({
+        query: "api",
+        tags: ["cors"],
+      });
+      expect(results.length).toBe(1);
+      expect(results[0].memory.frontmatter.title).toContain("CORS");
+    });
+
+    it("respects limit", async () => {
+      const results = await backend.search({ query: "api", limit: 1 });
+      expect(results.length).toBe(1);
+    });
+
+    it("returns empty for no matches", async () => {
+      const results = await backend.search({
+        query: "zzz_nonexistent_zzz",
+      });
+      expect(results).toEqual([]);
+    });
+
+    it("empty query returns list results", async () => {
+      const results = await backend.search({ query: "" });
+      expect(results.length).toBe(3);
+    });
+  });
+
+  describe("index rebuild after mutations", () => {
+    it("search finds newly stored memory", async () => {
+      await backend.store(sampleInput);
+
+      const before = await backend.search({ query: "migration" });
+      expect(before.length).toBe(0);
+
+      await backend.store({
+        title: "DB Migration",
+        description: "How to migrate",
+        type: "procedure",
+        tags: ["db"],
+        content: "Migration steps.",
+      });
+
+      const after = await backend.search({ query: "migration" });
+      expect(after.length).toBeGreaterThan(0);
+    });
+
+    it("search reflects updates", async () => {
+      const memory = await backend.store(sampleInput);
+
+      await backend.update({
+        id: memory.id,
+        title: "Updated Authentication Pattern v2",
+      });
+
+      const results = await backend.search({ query: "v2" });
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].memory.frontmatter.title).toContain("v2");
+    });
+
+    it("search excludes deleted memory", async () => {
+      const memory = await backend.store(sampleInput);
+
+      const before = await backend.search({ query: "authentication" });
+      expect(before.length).toBe(1);
+
+      await backend.delete(memory.id);
+
+      const after = await backend.search({ query: "authentication" });
+      expect(after.length).toBe(0);
+    });
+
+    it("rebuild() refreshes the full index", async () => {
+      await backend.store(sampleInput);
+      await backend.store({
+        title: "Second Memory",
+        description: "Test",
+        type: "fact",
+        tags: [],
+        content: "Content",
+      });
+
+      await backend.rebuild();
+
+      const results = await backend.search({ query: "authentication" });
+      expect(results.length).toBe(1);
+    });
+  });
+
+  describe("CRUD cycle", () => {
+    it("store → retrieve → update → delete", async () => {
+      const uniqueInput = {
+        ...sampleInput,
+        title: `CRUD Test Memory ${Date.now()}`,
+      };
+      const stored = await backend.store(uniqueInput);
+      expect(stored.id).toBeTruthy();
+
+      const retrieved = await backend.retrieve(stored.id);
+      expect(retrieved).not.toBeNull();
+      expect(retrieved!.frontmatter.title).toBe(uniqueInput.title);
+
+      const updated = await backend.update({
+        id: stored.id,
+        title: "Updated Auth",
+      });
+      expect(updated!.frontmatter.title).toBe("Updated Auth");
+
+      const deleted = await backend.delete(stored.id);
+      expect(deleted).toBe(true);
+
+      const gone = await backend.retrieve(stored.id);
+      expect(gone).toBeNull();
+    });
+  });
+
+  describe("stats()", () => {
+    it("returns correct counts", async () => {
+      await backend.store(sampleInput);
+      await backend.store({
+        title: "A Bug",
+        description: "Bug fix",
+        type: "episode",
+        tags: [],
+        content: "Bug",
+      });
+
+      const stats = await backend.stats();
+      expect(stats.total).toBe(2);
+      expect(stats.byType.fact).toBe(1);
+      expect(stats.byType.episode).toBe(1);
+    });
+  });
+});

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

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import {
+  isOllamaRunning,
+  listOllamaModels,
+  hasOllamaEmbeddingModel,
+  detectEmbeddingProvider,
+} from "../lib/ollama.js";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("isOllamaRunning()", () => {
+  it("returns false when Ollama is not running", async () => {
+    // Use a port that's very unlikely to be in use
+    const result = await isOllamaRunning("http://localhost:19999");
+    expect(result).toBe(false);
+  });
+
+  it("handles network errors gracefully", async () => {
+    const result = await isOllamaRunning("http://invalid-host-xyz:11434");
+    expect(result).toBe(false);
+  });
+});
+
+describe("listOllamaModels()", () => {
+  it("returns empty array when Ollama is not running", async () => {
+    const models = await listOllamaModels("http://localhost:19999");
+    expect(models).toEqual([]);
+  });
+});
+
+describe("hasOllamaEmbeddingModel()", () => {
+  it("returns false when Ollama is not running", async () => {
+    const has = await hasOllamaEmbeddingModel(
+      "all-minilm:l6-v2",
+      "http://localhost:19999",
+    );
+    expect(has).toBe(false);
+  });
+});
+
+describe("detectEmbeddingProvider()", () => {
+  it("falls back to transformers when Ollama is not available", async () => {
+    const result = await detectEmbeddingProvider("http://localhost:19999");
+    expect(result.provider).toBe("transformers");
+  });
+});