coding-friend-cli 1.37.0 → 1.38.1

package/lib/cf-memory/src/__tests__/claude-md.test.ts

@@ -1,343 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import {
-  syncToClaudeMd,
-  removeFromClaudeMd,
-  updateInClaudeMd,
-  claudeMdPath,
-  SECTION_HEADER,
-} from "../lib/claude-md.js";
-
-let testDir: string;
-let claudeMdFile: string;
-let counter = 0;
-
-beforeEach(() => {
-  testDir = join(tmpdir(), `cf-claude-md-test-${Date.now()}-${++counter}`);
-  mkdirSync(testDir, { recursive: true });
-  claudeMdFile = join(testDir, "CLAUDE.md");
-});
-
-afterEach(() => {
-  rmSync(testDir, { recursive: true, force: true });
-});
-
-describe("syncToClaudeMd", () => {
-  it("creates CLAUDE.md with section if it does not exist", () => {
-    syncToClaudeMd(
-      testDir,
-      "conventions/code-style",
-      "Use 2-space indentation",
-    );
-
-    expect(existsSync(claudeMdFile)).toBe(true);
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain(SECTION_HEADER);
-    expect(content).toContain("Use 2-space indentation");
-  });
-
-  it("appends section to existing CLAUDE.md that has no memory section", () => {
-    writeFileSync(claudeMdFile, "# My Project\n\nSome existing content.\n");
-
-    syncToClaudeMd(
-      testDir,
-      "conventions/code-style",
-      "Use 2-space indentation",
-    );
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain("# My Project");
-    expect(content).toContain("Some existing content.");
-    expect(content).toContain(SECTION_HEADER);
-    expect(content).toContain("Use 2-space indentation");
-  });
-
-  it("adds entry to existing memory section", () => {
-    writeFileSync(
-      claudeMdFile,
-      `# My Project\n\n${SECTION_HEADER}\n\n- Use 2-space indentation\n`,
-    );
-
-    syncToClaudeMd(
-      testDir,
-      "conventions/naming",
-      "Use camelCase for variables",
-    );
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain("Use 2-space indentation");
-    expect(content).toContain("Use camelCase for variables");
-  });
-
-  it("does not duplicate entries with same ID", () => {
-    syncToClaudeMd(
-      testDir,
-      "conventions/code-style",
-      "Use 2-space indentation",
-    );
-    syncToClaudeMd(
-      testDir,
-      "conventions/code-style",
-      "Use 4-space indentation",
-    );
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    // Should have the updated version, not both
-    expect(content).toContain("Use 4-space indentation");
-    expect(content).not.toContain("Use 2-space indentation");
-  });
-
-  it("stores entry with ID as HTML comment for tracking", () => {
-    syncToClaudeMd(
-      testDir,
-      "conventions/code-style",
-      "Use 2-space indentation",
-    );
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain("<!-- cf:conventions/code-style -->");
-  });
-
-  it("handles multi-line description by taking first line only", () => {
-    syncToClaudeMd(
-      testDir,
-      "conventions/style",
-      "Line one\nLine two\nLine three",
-    );
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain("Line one");
-    // Multi-line content should be joined into a single bullet
-    expect(content.split(SECTION_HEADER)[1]).not.toContain("\nLine two");
-  });
-
-  it("preserves content after the memory section", () => {
-    writeFileSync(
-      claudeMdFile,
-      `# My Project\n\n${SECTION_HEADER}\n\n- Old entry <!-- cf:conventions/old -->\n\n## Other Section\n\nMore content.\n`,
-    );
-
-    syncToClaudeMd(testDir, "conventions/new-rule", "New convention");
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain("## Other Section");
-    expect(content).toContain("More content.");
-    expect(content).toContain("New convention");
-  });
-});
-
-describe("removeFromClaudeMd", () => {
-  it("removes an entry by ID", () => {
-    syncToClaudeMd(
-      testDir,
-      "conventions/code-style",
-      "Use 2-space indentation",
-    );
-    syncToClaudeMd(testDir, "conventions/naming", "Use camelCase");
-
-    removeFromClaudeMd(testDir, "conventions/code-style");
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).not.toContain("Use 2-space indentation");
-    expect(content).not.toContain("conventions/code-style");
-    expect(content).toContain("Use camelCase");
-  });
-
-  it("does nothing if CLAUDE.md does not exist", () => {
-    // Should not throw
-    removeFromClaudeMd(testDir, "conventions/code-style");
-    expect(existsSync(claudeMdFile)).toBe(false);
-  });
-
-  it("does nothing if ID is not found", () => {
-    writeFileSync(
-      claudeMdFile,
-      `# Project\n\n${SECTION_HEADER}\n\n- Some entry <!-- cf:conventions/other -->\n`,
-    );
-
-    removeFromClaudeMd(testDir, "conventions/nonexistent");
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain("Some entry");
-  });
-
-  it("removes section header when last entry is removed", () => {
-    syncToClaudeMd(testDir, "conventions/only-one", "The only convention");
-
-    removeFromClaudeMd(testDir, "conventions/only-one");
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).not.toContain(SECTION_HEADER);
-  });
-});
-
-describe("updateInClaudeMd", () => {
-  it("updates the description of an existing entry", () => {
-    syncToClaudeMd(testDir, "conventions/style", "Old style guide");
-
-    updateInClaudeMd(testDir, "conventions/style", "New style guide");
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain("New style guide");
-    expect(content).not.toContain("Old style guide");
-  });
-
-  it("does nothing if ID is not found (no upsert)", () => {
-    writeFileSync(claudeMdFile, "# Project\n");
-
-    updateInClaudeMd(testDir, "conventions/nonexistent", "Something");
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).not.toContain("Something");
-  });
-
-  it("does nothing if CLAUDE.md does not exist", () => {
-    updateInClaudeMd(testDir, "conventions/style", "Something");
-    expect(existsSync(claudeMdFile)).toBe(false);
-  });
-});
-
-describe("claudeMdPath", () => {
-  it("strips /docs/memory suffix to derive project root", () => {
-    const docsDir = join(testDir, "docs", "memory");
-    mkdirSync(docsDir, { recursive: true });
-
-    const result = claudeMdPath(docsDir);
-    expect(result).toBe(join(testDir, "CLAUDE.md"));
-  });
-
-  it("strips /memory suffix as fallback", () => {
-    const docsDir = join(testDir, "memory");
-    mkdirSync(docsDir, { recursive: true });
-
-    const result = claudeMdPath(docsDir);
-    expect(result).toBe(join(testDir, "CLAUDE.md"));
-  });
-
-  it("uses docsDir as-is when no known suffix matches", () => {
-    const result = claudeMdPath(testDir);
-    expect(result).toBe(join(testDir, "CLAUDE.md"));
-  });
-});
-
-describe("syncToClaudeMd with realistic docsDir", () => {
-  it("writes CLAUDE.md to project root when docsDir is docs/memory", () => {
-    const docsDir = join(testDir, "docs", "memory");
-    mkdirSync(docsDir, { recursive: true });
-
-    syncToClaudeMd(docsDir, "conventions/style", "Use tabs");
-
-    const expectedPath = join(testDir, "CLAUDE.md");
-    expect(existsSync(expectedPath)).toBe(true);
-    const content = readFileSync(expectedPath, "utf-8");
-    expect(content).toContain("Use tabs");
-    expect(content).toContain(SECTION_HEADER);
-  });
-});
-
-describe("migration from old header", () => {
-  const OLD_HEADER = "## CF Memory: Conventions";
-
-  it("reads entries from old header and rewrites with new header on sync", () => {
-    writeFileSync(
-      claudeMdFile,
-      `# My Project\n\n${OLD_HEADER}\n\n- Old rule <!-- cf:conventions/old-rule -->\n`,
-    );
-
-    syncToClaudeMd(testDir, "conventions/new-rule", "New rule");
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    // Should have new header
-    expect(content).toContain(SECTION_HEADER);
-    // Should NOT have old header (unless they're the same)
-    if (SECTION_HEADER !== OLD_HEADER) {
-      expect(content).not.toContain(OLD_HEADER);
-    }
-    // Both entries should be preserved
-    expect(content).toContain("Old rule");
-    expect(content).toContain("New rule");
-  });
-
-  it("removes entries from old header format", () => {
-    writeFileSync(
-      claudeMdFile,
-      `# My Project\n\n${OLD_HEADER}\n\n- Old rule <!-- cf:conventions/old-rule -->\n- Keep this <!-- cf:conventions/keep -->\n`,
-    );
-
-    removeFromClaudeMd(testDir, "conventions/old-rule");
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).not.toContain("Old rule");
-    expect(content).toContain("Keep this");
-  });
-});
-
-describe("syncToClaudeMd with non-convention categories", () => {
-  it("syncs decisions entries to CLAUDE.md", () => {
-    syncToClaudeMd(
-      testDir,
-      "decisions/api-versioning",
-      "Always use URL-based API versioning (v1, v2)",
-    );
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain(SECTION_HEADER);
-    expect(content).toContain("Always use URL-based API versioning");
-    expect(content).toContain("<!-- cf:decisions/api-versioning -->");
-  });
-
-  it("syncs infrastructure entries to CLAUDE.md", () => {
-    syncToClaudeMd(
-      testDir,
-      "infrastructure/deploy-checklist",
-      "Always run migrations before deploying",
-    );
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain("Always run migrations before deploying");
-    expect(content).toContain("<!-- cf:infrastructure/deploy-checklist -->");
-  });
-
-  it("mixes convention and non-convention entries in same section", () => {
-    syncToClaudeMd(testDir, "conventions/naming", "Use camelCase");
-    syncToClaudeMd(
-      testDir,
-      "decisions/db-choice",
-      "Use PostgreSQL for all new services",
-    );
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain("Use camelCase");
-    expect(content).toContain("Use PostgreSQL for all new services");
-    // Only one section header
-    const headerCount = content.split(SECTION_HEADER).length - 1;
-    expect(headerCount).toBe(1);
-  });
-
-  it("removes non-convention entries by ID", () => {
-    syncToClaudeMd(testDir, "decisions/api-versioning", "URL-based versioning");
-    syncToClaudeMd(testDir, "conventions/naming", "Use camelCase");
-
-    removeFromClaudeMd(testDir, "decisions/api-versioning");
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).not.toContain("URL-based versioning");
-    expect(content).toContain("Use camelCase");
-  });
-
-  it("updates non-convention entries", () => {
-    syncToClaudeMd(testDir, "infrastructure/ci-rule", "Run lint before tests");
-
-    updateInClaudeMd(
-      testDir,
-      "infrastructure/ci-rule",
-      "Run lint and type-check before tests",
-    );
-
-    const content = readFileSync(claudeMdFile, "utf-8");
-    expect(content).toContain("Run lint and type-check before tests");
-    expect(content).not.toContain("Run lint before tests\n");
-  });
-});

package/lib/cf-memory/src/__tests__/daemon-client.test.ts

@@ -1,146 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdirSync, rmSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { DaemonClient } from "../lib/daemon-client.js";
-import { startDaemonServer, type DaemonPaths } from "../daemon/process.js";
-import { MiniSearchBackend } from "../backends/minisearch.js";
-
-let testDir: string;
-let testPaths: DaemonPaths;
-let counter = 0;
-
-beforeEach(() => {
-  testDir = join(tmpdir(), `cf-daemon-client-test-${Date.now()}-${++counter}`);
-  mkdirSync(testDir, { recursive: true });
-
-  const daemonDir = join(testDir, "daemon");
-  mkdirSync(daemonDir, { recursive: true });
-
-  testPaths = {
-    socketPath: join(daemonDir, "daemon.sock"),
-    pidFile: join(daemonDir, "daemon.pid"),
-    logFile: join(daemonDir, "daemon.log"),
-  };
-});
-
-afterEach(() => {
-  rmSync(testDir, { recursive: true, force: true });
-});
-
-describe("DaemonClient auto-reconnect", () => {
-  it("calls respawn and retries on connection error", async () => {
-    const docsDir = join(testDir, "docs");
-    mkdirSync(docsDir, { recursive: true });
-
-    // Start daemon
-    const backend = new MiniSearchBackend(docsDir);
-    let handle = startDaemonServer(backend, {
-      paths: testPaths,
-      idleTimeoutMs: 0,
-    });
-    await new Promise<void>((resolve) => {
-      handle.server.once("listening", resolve);
-    });
-
-    const respawn = vi.fn(async () => {
-      // Re-create a fresh backend and server on same paths
-      const newBackend = new MiniSearchBackend(docsDir);
-      handle = startDaemonServer(newBackend, {
-        paths: testPaths,
-        idleTimeoutMs: 0,
-      });
-      await new Promise<void>((resolve) => {
-        handle.server.once("listening", resolve);
-      });
-      return true;
-    });
-
-    const client = new DaemonClient(testPaths.socketPath, { respawn });
-
-    // Verify initial connection works
-    const alive = await client.ping();
-    expect(alive).toBe(true);
-
-    // Kill daemon and wait for socket cleanup
-    await new Promise<void>((resolve) => {
-      handle.server.close(() => resolve());
-    });
-    rmSync(testPaths.socketPath, { force: true });
-    rmSync(testPaths.pidFile, { force: true });
-    // Small delay to ensure OS fully releases the socket
-    await new Promise((r) => setTimeout(r, 50));
-
-    // Next request should trigger respawn and succeed
-    const stats = await client.stats();
-    expect(stats.total).toBe(0);
-    expect(respawn).toHaveBeenCalledOnce();
-
-    // Cleanup
-    await new Promise<void>((resolve) => {
-      handle.server.close(() => resolve());
-    });
-    rmSync(testPaths.socketPath, { force: true });
-    rmSync(testPaths.pidFile, { force: true });
-  });
-
-  it("throws original error when respawn fails", async () => {
-    const respawn = vi.fn(async () => false);
-    const client = new DaemonClient(
-      "/tmp/nonexistent-cf-test-sock-" + Date.now(),
-      { respawn },
-    );
-
-    await expect(client.stats()).rejects.toThrow();
-    expect(respawn).toHaveBeenCalledOnce();
-  });
-
-  it("throws directly without respawn callback", async () => {
-    const client = new DaemonClient(
-      "/tmp/nonexistent-cf-test-sock-" + Date.now(),
-    );
-
-    await expect(client.stats()).rejects.toThrow();
-  });
-
-  it("ping does not trigger respawn", async () => {
-    const respawn = vi.fn(async () => true);
-    const client = new DaemonClient(
-      "/tmp/nonexistent-cf-test-sock-" + Date.now(),
-      { respawn },
-    );
-
-    // ping() should return false without attempting respawn
-    const alive = await client.ping();
-    expect(alive).toBe(false);
-    expect(respawn).not.toHaveBeenCalled();
-  });
-
-  it("does not call respawn for HTTP 4xx errors", async () => {
-    const docsDir = join(testDir, "docs");
-    mkdirSync(docsDir, { recursive: true });
-
-    const backend = new MiniSearchBackend(docsDir);
-    const handle = startDaemonServer(backend, {
-      paths: testPaths,
-      idleTimeoutMs: 0,
-    });
-    await new Promise<void>((resolve) => {
-      handle.server.once("listening", resolve);
-    });
-
-    const respawn = vi.fn(async () => true);
-    const client = new DaemonClient(testPaths.socketPath, { respawn });
-
-    // 404 is not a connection error — should not trigger respawn
-    const result = await client.retrieve("nonexistent/id");
-    expect(result).toBeNull();
-    expect(respawn).not.toHaveBeenCalled();
-
-    await new Promise<void>((resolve) => {
-      handle.server.close(() => resolve());
-    });
-    rmSync(testPaths.socketPath, { force: true });
-    rmSync(testPaths.pidFile, { force: true });
-  });
-});