coding-friend-cli 1.16.0 → 1.17.0

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

@@ -0,0 +1,410 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import matter from "gray-matter";
+import { MarkdownBackend } from "../backends/markdown.js";
+import type { StoreInput } from "../lib/types.js";
+
+let testDir: string;
+let backend: MarkdownBackend;
+let counter = 0;
+
+beforeEach(() => {
+  testDir = join(tmpdir(), `cf-memory-test-${Date.now()}-${++counter}`);
+  mkdirSync(testDir, { recursive: true });
+  backend = new MarkdownBackend(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("MarkdownBackend", () => {
+  describe("store()", () => {
+    it("creates a markdown file with correct frontmatter", async () => {
+      const memory = await backend.store(sampleInput);
+
+      expect(memory.id).toBe("features/api-authentication-pattern");
+      expect(memory.slug).toBe("api-authentication-pattern");
+      expect(memory.category).toBe("features");
+      expect(memory.frontmatter.title).toBe("API Authentication Pattern");
+      expect(memory.frontmatter.type).toBe("fact");
+      expect(memory.frontmatter.tags).toEqual(["auth", "jwt", "api"]);
+      expect(memory.frontmatter.importance).toBe(3);
+      expect(memory.frontmatter.source).toBe("conversation");
+
+      // Verify file on disk
+      const filePath = join(
+        testDir,
+        "features",
+        "api-authentication-pattern.md",
+      );
+      expect(existsSync(filePath)).toBe(true);
+
+      const raw = matter(readFileSync(filePath, "utf-8"));
+      expect(raw.data.title).toBe("API Authentication Pattern");
+      expect(raw.data.type).toBe("fact");
+      expect(raw.content.trim()).toContain("# API Auth");
+    });
+
+    it("maps type to correct category folder", async () => {
+      const types = [
+        { type: "fact", category: "features" },
+        { type: "preference", category: "conventions" },
+        { type: "context", category: "decisions" },
+        { type: "episode", category: "bugs" },
+        { type: "procedure", category: "infrastructure" },
+      ] as const;
+
+      for (const { type, category } of types) {
+        const memory = await backend.store({
+          ...sampleInput,
+          title: `Test ${type}`,
+          type,
+        });
+        expect(memory.category).toBe(category);
+        expect(existsSync(join(testDir, category))).toBe(true);
+      }
+    });
+
+    it("handles duplicate slugs by appending timestamp", async () => {
+      const m1 = await backend.store(sampleInput);
+      const m2 = await backend.store(sampleInput);
+
+      expect(m1.slug).toBe("api-authentication-pattern");
+      expect(m2.slug).not.toBe(m1.slug);
+      expect(m2.slug).toContain("api-authentication-pattern-");
+    });
+
+    it("respects custom importance and source", async () => {
+      const memory = await backend.store({
+        ...sampleInput,
+        importance: 5,
+        source: "auto-capture",
+      });
+
+      expect(memory.frontmatter.importance).toBe(5);
+      expect(memory.frontmatter.source).toBe("auto-capture");
+    });
+  });
+
+  describe("retrieve()", () => {
+    it("retrieves a stored memory by ID", async () => {
+      await backend.store(sampleInput);
+      const memory = await backend.retrieve(
+        "features/api-authentication-pattern",
+      );
+
+      expect(memory).not.toBeNull();
+      expect(memory!.frontmatter.title).toBe("API Authentication Pattern");
+      expect(memory!.content).toContain("JWT tokens");
+    });
+
+    it("returns null for non-existent ID", async () => {
+      const memory = await backend.retrieve("features/nonexistent");
+      expect(memory).toBeNull();
+    });
+
+    it("returns null for invalid ID format", async () => {
+      expect(await backend.retrieve("invalid")).toBeNull();
+      expect(await backend.retrieve("")).toBeNull();
+    });
+  });
+
+  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");
+      expect(results[0].matchedOn).toContain("title");
+    });
+
+    it("finds by description match", async () => {
+      const results = await backend.search({ query: "JWT" });
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].matchedOn).toContain("description");
+    });
+
+    it("finds by tag match", async () => {
+      const results = await backend.search({ query: "prisma" });
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].matchedOn).toContain("tags");
+    });
+
+    it("finds by content match", async () => {
+      const results = await backend.search({ query: "allowlist" });
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].matchedOn).toContain("content");
+    });
+
+    it("filters by type", async () => {
+      const results = await backend.search({
+        query: "api",
+        type: "episode",
+      });
+      expect(results.length).toBe(1);
+      expect(results[0].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("ranks title matches higher than content matches", async () => {
+      const results = await backend.search({ query: "api" });
+      expect(results.length).toBeGreaterThan(1);
+      // Title/description matches should score higher
+      expect(results[0].score).toBeGreaterThanOrEqual(results[1].score);
+    });
+
+    it("returns empty array for no matches", async () => {
+      const results = await backend.search({ query: "zzz_nonexistent_zzz" });
+      expect(results).toEqual([]);
+    });
+  });
+
+  describe("list()", () => {
+    beforeEach(async () => {
+      await backend.store(sampleInput);
+      await backend.store({
+        title: "Code Style",
+        description: "Always use async/await",
+        type: "preference",
+        tags: ["style"],
+        content: "Use async/await.",
+      });
+    });
+
+    it("lists all memories", async () => {
+      const metas = await backend.list({});
+      expect(metas.length).toBe(2);
+    });
+
+    it("filters by type", async () => {
+      const metas = await backend.list({ type: "fact" });
+      expect(metas.length).toBe(1);
+      expect(metas[0].frontmatter.type).toBe("fact");
+    });
+
+    it("filters by category", async () => {
+      const metas = await backend.list({ category: "conventions" });
+      expect(metas.length).toBe(1);
+      expect(metas[0].category).toBe("conventions");
+    });
+
+    it("respects limit", async () => {
+      const metas = await backend.list({ limit: 1 });
+      expect(metas.length).toBe(1);
+    });
+
+    it("sorts by updated date descending", async () => {
+      const metas = await backend.list({});
+      const dates = metas.map((m) => m.frontmatter.updated);
+      expect(dates[0]).toBe(dates[1]); // same day in tests
+    });
+
+    it("returns empty for non-existent docs dir", async () => {
+      const emptyBackend = new MarkdownBackend("/tmp/nonexistent-cf-test");
+      const metas = await emptyBackend.list({});
+      expect(metas).toEqual([]);
+    });
+  });
+
+  describe("update()", () => {
+    it("updates title and tags", async () => {
+      await backend.store(sampleInput);
+      const updated = await backend.update({
+        id: "features/api-authentication-pattern",
+        title: "Updated Auth Pattern",
+        tags: ["security", "oauth"],
+      });
+
+      expect(updated).not.toBeNull();
+      expect(updated!.frontmatter.title).toBe("Updated Auth Pattern");
+      // Tags are merged
+      expect(updated!.frontmatter.tags).toContain("auth");
+      expect(updated!.frontmatter.tags).toContain("security");
+      expect(updated!.frontmatter.tags).toContain("oauth");
+    });
+
+    it("appends content", async () => {
+      await backend.store(sampleInput);
+      const updated = await backend.update({
+        id: "features/api-authentication-pattern",
+        content: "## New Section\n\nAdditional info.",
+      });
+
+      expect(updated).not.toBeNull();
+      expect(updated!.content).toContain("JWT tokens");
+      expect(updated!.content).toContain("New Section");
+    });
+
+    it("returns null for non-existent memory", async () => {
+      const result = await backend.update({
+        id: "features/nonexistent",
+        title: "Test",
+      });
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("delete()", () => {
+    it("deletes a stored memory", async () => {
+      await backend.store(sampleInput);
+      const deleted = await backend.delete(
+        "features/api-authentication-pattern",
+      );
+      expect(deleted).toBe(true);
+
+      const retrieved = await backend.retrieve(
+        "features/api-authentication-pattern",
+      );
+      expect(retrieved).toBeNull();
+    });
+
+    it("returns false for non-existent memory", async () => {
+      const deleted = await backend.delete("features/nonexistent");
+      expect(deleted).toBe(false);
+    });
+  });
+
+  describe("stats()", () => {
+    it("returns correct counts", async () => {
+      await backend.store(sampleInput);
+      await backend.store({
+        title: "Another Fact",
+        description: "Test",
+        type: "fact",
+        tags: [],
+        content: "Content",
+      });
+      await backend.store({
+        title: "A Bug",
+        description: "Test bug",
+        type: "episode",
+        tags: [],
+        content: "Bug content",
+      });
+
+      const stats = await backend.stats();
+      expect(stats.total).toBe(3);
+      expect(stats.byCategory.features).toBe(2);
+      expect(stats.byCategory.bugs).toBe(1);
+      expect(stats.byType.fact).toBe(2);
+      expect(stats.byType.episode).toBe(1);
+    });
+
+    it("returns zeros for empty dir", async () => {
+      const stats = await backend.stats();
+      expect(stats.total).toBe(0);
+    });
+  });
+
+  describe("CRUD cycle", () => {
+    it("store → retrieve → update → delete", async () => {
+      // Store with unique title to avoid any collision
+      const input = {
+        ...sampleInput,
+        title: "CRUD Test Memory " + Date.now(),
+      };
+      const stored = await backend.store(input);
+      expect(stored.id).toBeTruthy();
+
+      // Retrieve
+      const retrieved = await backend.retrieve(stored.id);
+      expect(retrieved).not.toBeNull();
+      expect(retrieved!.frontmatter.title).toBe(input.title);
+
+      // Update
+      const updated = await backend.update({
+        id: stored.id,
+        title: "Updated Title",
+        content: "Additional content.",
+      });
+      expect(updated!.frontmatter.title).toBe("Updated Title");
+
+      // Verify update persisted
+      const reread = await backend.retrieve(stored.id);
+      expect(reread!.frontmatter.title).toBe("Updated Title");
+      expect(reread!.content).toContain("Additional content");
+
+      // Delete
+      const deleted = await backend.delete(stored.id);
+      expect(deleted).toBe(true);
+
+      // Verify deleted
+      const gone = await backend.retrieve(stored.id);
+      expect(gone).toBeNull();
+    });
+  });
+
+  describe("edge cases", () => {
+    it("handles special characters in title", async () => {
+      const memory = await backend.store({
+        ...sampleInput,
+        title: "What's the API/Auth flow? (v2.0)",
+      });
+      expect(memory.slug).toBe("what-s-the-api-auth-flow-v2-0");
+    });
+
+    it("handles empty docs directory", async () => {
+      const metas = await backend.list({});
+      expect(metas).toEqual([]);
+
+      const results = await backend.search({ query: "anything" });
+      expect(results).toEqual([]);
+    });
+
+    it("close() is a no-op", async () => {
+      await expect(backend.close()).resolves.toBeUndefined();
+    });
+
+    it("rejects path traversal in retrieve/update/delete", async () => {
+      await backend.store(sampleInput);
+
+      expect(await backend.retrieve("../../etc/passwd")).toBeNull();
+      expect(await backend.retrieve("features/../../../etc/passwd")).toBeNull();
+      expect(
+        await backend.update({ id: "../../etc/passwd", title: "hack" }),
+      ).toBeNull();
+      expect(await backend.delete("../../etc/passwd")).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,255 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, writeFileSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { execFileSync } from "child_process";
+
+let testDir: string;
+let counter = 0;
+
+const scriptPath = join(
+  import.meta.dirname,
+  "../../scripts/migrate-frontmatter.ts",
+);
+
+beforeEach(() => {
+  testDir = join(tmpdir(), `cf-memory-migration-${Date.now()}-${++counter}`);
+  mkdirSync(join(testDir, "features"), { recursive: true });
+  mkdirSync(join(testDir, "conventions"), { recursive: true });
+  mkdirSync(join(testDir, "decisions"), { recursive: true });
+  mkdirSync(join(testDir, "bugs"), { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+function runMigration(): string {
+  return execFileSync("npx", ["tsx", scriptPath, testDir], {
+    encoding: "utf-8",
+    timeout: 15000,
+  });
+}
+
+describe("migrate-frontmatter script", () => {
+  it("adds type, importance, source fields to a features file", () => {
+    writeFileSync(
+      join(testDir, "features", "test.md"),
+      `---
+title: "Test Feature"
+description: "A test feature"
+tags: [test, feature]
+created: 2026-01-01
+updated: 2026-03-05
+---
+
+# Test Feature
+Content here.
+`,
+    );
+
+    const output = runMigration();
+    expect(output).toContain("Updated: features/test.md");
+
+    const content = readFileSync(join(testDir, "features", "test.md"), "utf-8");
+    expect(content).toContain("type: fact");
+    expect(content).toContain("importance: 3");
+    expect(content).toContain("source: conversation");
+  });
+
+  it("maps conventions to preference type", () => {
+    writeFileSync(
+      join(testDir, "conventions", "naming.md"),
+      `---
+title: "Naming Convention"
+description: "How we name things"
+tags: [naming]
+created: 2026-01-01
+updated: 2026-01-01
+---
+
+# Naming
+`,
+    );
+
+    runMigration();
+
+    const content = readFileSync(
+      join(testDir, "conventions", "naming.md"),
+      "utf-8",
+    );
+    expect(content).toContain("type: preference");
+  });
+
+  it("maps decisions to context type", () => {
+    writeFileSync(
+      join(testDir, "decisions", "arch.md"),
+      `---
+title: "Architecture Decision"
+description: "Why we chose X"
+tags: [architecture]
+created: 2026-01-01
+updated: 2026-01-01
+---
+
+# Decision
+`,
+    );
+
+    runMigration();
+
+    const content = readFileSync(
+      join(testDir, "decisions", "arch.md"),
+      "utf-8",
+    );
+    expect(content).toContain("type: context");
+  });
+
+  it("maps bugs to episode type", () => {
+    writeFileSync(
+      join(testDir, "bugs", "crash.md"),
+      `---
+title: "App Crash"
+description: "Fix for the crash bug"
+tags: [bug]
+created: 2026-01-01
+updated: 2026-01-01
+---
+
+# Bug
+`,
+    );
+
+    runMigration();
+
+    const content = readFileSync(join(testDir, "bugs", "crash.md"), "utf-8");
+    expect(content).toContain("type: episode");
+  });
+
+  it("preserves existing content unchanged", () => {
+    const originalContent = "# Test\n\nSome **bold** content with `code`.";
+    writeFileSync(
+      join(testDir, "features", "preserve.md"),
+      `---
+title: "Preserve Test"
+description: "Should preserve content"
+tags: [test]
+created: 2026-01-01
+updated: 2026-01-01
+---
+
+${originalContent}
+`,
+    );
+
+    runMigration();
+
+    const content = readFileSync(
+      join(testDir, "features", "preserve.md"),
+      "utf-8",
+    );
+    expect(content).toContain(originalContent);
+  });
+
+  it("is idempotent — running twice produces same result", () => {
+    writeFileSync(
+      join(testDir, "features", "idempotent.md"),
+      `---
+title: "Idempotent Test"
+description: "Should be idempotent"
+tags: [test]
+created: 2026-01-01
+updated: 2026-01-01
+---
+
+# Test
+`,
+    );
+
+    runMigration();
+    const afterFirst = readFileSync(
+      join(testDir, "features", "idempotent.md"),
+      "utf-8",
+    );
+
+    const output2 = runMigration();
+    const afterSecond = readFileSync(
+      join(testDir, "features", "idempotent.md"),
+      "utf-8",
+    );
+
+    expect(afterSecond).toBe(afterFirst);
+    expect(output2).toContain("Skipped: features/idempotent.md");
+  });
+
+  it("preserves date format (no ISO conversion)", () => {
+    writeFileSync(
+      join(testDir, "features", "dates.md"),
+      `---
+title: "Date Test"
+description: "Should preserve dates"
+tags: [test]
+created: 2026-01-01
+updated: 2026-03-05
+---
+
+# Test
+`,
+    );
+
+    runMigration();
+
+    const content = readFileSync(
+      join(testDir, "features", "dates.md"),
+      "utf-8",
+    );
+    expect(content).toContain("created: 2026-01-01");
+    expect(content).toContain("updated: 2026-03-05");
+    expect(content).not.toContain("T00:00:00");
+  });
+
+  it("skips files that already have all fields", () => {
+    writeFileSync(
+      join(testDir, "features", "complete.md"),
+      `---
+title: "Complete"
+description: "Already complete"
+type: fact
+tags: [test]
+importance: 4
+created: 2026-01-01
+updated: 2026-01-01
+source: manual
+---
+
+# Complete
+`,
+    );
+
+    const output = runMigration();
+    expect(output).toContain("Skipped: features/complete.md");
+  });
+
+  it("handles root-level markdown files", () => {
+    writeFileSync(
+      join(testDir, "root-doc.md"),
+      `---
+title: "Root Doc"
+description: "A root level doc"
+tags: [root]
+created: 2026-01-01
+updated: 2026-01-01
+---
+
+# Root
+`,
+    );
+
+    runMigration();
+
+    const content = readFileSync(join(testDir, "root-doc.md"), "utf-8");
+    expect(content).toContain("type: fact");
+    expect(content).toContain("importance: 3");
+    expect(content).toContain("source: conversation");
+  });
+});