coding-friend-cli 1.26.0 → 1.27.0

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

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

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

@@ -0,0 +1,136 @@
+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/index.ts

@@ -65,7 +65,15 @@ const server = new McpServer({
   version: cliPkg.version,
 });
 
-registerAllTools(server, backend);
+// Resolve DB path for status display
+const dbPath = (() => {
+  if ("getDbPath" in backend && typeof backend.getDbPath === "function") {
+    return (backend as { getDbPath(): string }).getDbPath();
+  }
+  return null;
+})();
+
+registerAllTools(server, backend, { docsDir, dbPath });
 registerAllResources(server, backend);
 
 const transport = new StdioServerTransport();

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

@@ -0,0 +1,217 @@
+/**
+ * Sync convention memories to the project's CLAUDE.md file.
+ *
+ * When a memory of type "preference" (category "conventions") is stored,
+ * updated, or deleted, the corresponding entry in CLAUDE.md is kept in sync.
+ *
+ * Entries are tracked via HTML comments: <!-- cf:<memory-id> -->
+ * All entries live under a dedicated section header.
+ *
+ * Note: The read-modify-write cycle assumes single-threaded MCP tool
+ * execution (sequential tool calls). No file-level locking is needed
+ * under this model.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+export const SECTION_HEADER = "## CF Memory: Conventions";
+
+// Tested per-line via .split("\n"), not against the full document,
+// so the $ anchor correctly matches end-of-line without the `m` flag.
+const ENTRY_RE = /^- .+ <!-- cf:(.+?) -->$/;
+
+/**
+ * Derive project root from docsDir by stripping known suffixes.
+ *
+ * Expected docsDir formats:
+ * - `<project>/docs/memory` (standard layout, preferred)
+ * - `<project>/memory` (fallback for non-standard layouts)
+ * - Any other path is used as-is (CLAUDE.md written alongside docsDir)
+ */
+function projectRoot(docsDir: string): string {
+  let root = path.resolve(docsDir);
+  root = root.replace(/\/docs\/memory$/, "").replace(/\/memory$/, "");
+  return root;
+}
+
+/**
+ * Resolve the CLAUDE.md path for a given docsDir.
+ * Exported so tool handlers can display the path in status frames
+ * without reimplementing the projectRoot derivation.
+ */
+export function claudeMdPath(docsDir: string): string {
+  return path.join(projectRoot(docsDir), "CLAUDE.md");
+}
+
+/**
+ * Parse a CLAUDE.md file into: before the section, section entries, and after the section.
+ */
+function parseClaudeMd(content: string): {
+  before: string;
+  entries: string[];
+  after: string;
+  untrackedLines: string[];
+} {
+  const headerIdx = content.indexOf(SECTION_HEADER);
+  if (headerIdx === -1) {
+    return { before: content, entries: [], after: "", untrackedLines: [] };
+  }
+
+  const before = content.slice(0, headerIdx);
+  const rest = content.slice(headerIdx + SECTION_HEADER.length);
+
+  // Find the next section header (## ) to determine where our section ends
+  const nextSectionMatch = rest.match(/\n(## )/);
+  let sectionBody: string;
+  let after: string;
+
+  if (nextSectionMatch && nextSectionMatch.index !== undefined) {
+    sectionBody = rest.slice(0, nextSectionMatch.index);
+    after = rest.slice(nextSectionMatch.index + 1); // +1 to skip the \n
+  } else {
+    sectionBody = rest;
+    after = "";
+  }
+
+  // Extract tracked entries (lines matching "- ... <!-- cf:... -->")
+  // and preserve untracked lines within the section
+  const lines = sectionBody.split("\n");
+  const entries: string[] = [];
+  const untrackedLines: string[] = [];
+
+  for (const line of lines) {
+    if (ENTRY_RE.test(line)) {
+      entries.push(line);
+    } else if (line.trim()) {
+      untrackedLines.push(line);
+    }
+  }
+
+  return { before, entries, after, untrackedLines };
+}
+
+/**
+ * Rebuild the CLAUDE.md content from its parts.
+ */
+function buildClaudeMd(
+  before: string,
+  entries: string[],
+  after: string,
+  untrackedLines: string[] = [],
+): string {
+  // If no entries and no untracked lines, remove the section entirely
+  if (entries.length === 0 && untrackedLines.length === 0) {
+    const result = before.trimEnd() + (after ? "\n\n" + after : "\n");
+    return result;
+  }
+
+  let result = before.trimEnd() + "\n\n" + SECTION_HEADER + "\n\n";
+  if (untrackedLines.length > 0) {
+    result += untrackedLines.join("\n") + "\n";
+  }
+  if (entries.length > 0) {
+    result += entries.join("\n") + "\n";
+  }
+  if (after) {
+    result += "\n" + after;
+  }
+  return result;
+}
+
+/**
+ * Format a concise single-line entry for CLAUDE.md.
+ */
+function formatEntry(id: string, description: string): string {
+  // Take only first line and trim
+  const oneLiner = description.split("\n")[0].trim();
+  return `- ${oneLiner} <!-- cf:${id} -->`;
+}
+
+/**
+ * Add or update a convention entry in the project's CLAUDE.md.
+ */
+export function syncToClaudeMd(
+  docsDir: string,
+  id: string,
+  description: string,
+): void {
+  const filePath = claudeMdPath(docsDir);
+  const existing = fs.existsSync(filePath)
+    ? fs.readFileSync(filePath, "utf-8")
+    : "";
+
+  const { before, entries, after, untrackedLines } = parseClaudeMd(existing);
+
+  // Remove any existing entry with the same ID
+  const filtered = entries.filter((e) => {
+    const match = e.match(ENTRY_RE);
+    return !match || match[1] !== id;
+  });
+
+  // Add the new/updated entry
+  filtered.push(formatEntry(id, description));
+
+  fs.writeFileSync(
+    filePath,
+    buildClaudeMd(before, filtered, after, untrackedLines),
+    "utf-8",
+  );
+}
+
+/**
+ * Remove a convention entry from the project's CLAUDE.md.
+ */
+export function removeFromClaudeMd(docsDir: string, id: string): void {
+  const filePath = claudeMdPath(docsDir);
+  if (!fs.existsSync(filePath)) return;
+
+  const content = fs.readFileSync(filePath, "utf-8");
+  const { before, entries, after, untrackedLines } = parseClaudeMd(content);
+
+  if (entries.length === 0) return;
+
+  const filtered = entries.filter((e) => {
+    const match = e.match(ENTRY_RE);
+    return !match || match[1] !== id;
+  });
+
+  // Only write if something actually changed
+  if (filtered.length === entries.length) return;
+
+  fs.writeFileSync(
+    filePath,
+    buildClaudeMd(before, filtered, after, untrackedLines),
+    "utf-8",
+  );
+}
+
+/**
+ * Update an existing convention entry in CLAUDE.md (no upsert).
+ */
+export function updateInClaudeMd(
+  docsDir: string,
+  id: string,
+  description: string,
+): void {
+  const filePath = claudeMdPath(docsDir);
+  if (!fs.existsSync(filePath)) return;
+
+  const content = fs.readFileSync(filePath, "utf-8");
+  const { before, entries, after, untrackedLines } = parseClaudeMd(content);
+
+  // Check if entry exists
+  const idx = entries.findIndex((e) => {
+    const match = e.match(ENTRY_RE);
+    return match && match[1] === id;
+  });
+
+  if (idx === -1) return;
+
+  entries[idx] = formatEntry(id, description);
+
+  fs.writeFileSync(
+    filePath,
+    buildClaudeMd(before, entries, after, untrackedLines),
+    "utf-8",
+  );
+}

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

@@ -0,0 +1,63 @@
+/**
+ * Build status output for memory store/update operations.
+ * Shows what was saved (markdown file, database) as a simple list with icons.
+ */
+
+interface StoreStatusInput {
+  id: string;
+  title: string;
+  markdownPath: string;
+  dbPath: string | null;
+  claudeMdUpdated?: boolean;
+  warning?: string;
+}
+
+interface UpdateStatusInput {
+  id: string;
+  title: string;
+  markdownPath: string;
+  dbPath: string | null;
+  claudeMdUpdated?: boolean;
+}
+
+export function buildStoreStatus(input: StoreStatusInput): string {
+  const lines: string[] = [
+    `✅ Memory stored`,
+    `   ID:       ${input.id}`,
+    `   Title:    ${input.title}`,
+    `📄 Markdown: ${input.markdownPath}`,
+  ];
+
+  if (input.dbPath) {
+    lines.push(`🗄️  Database: ${input.dbPath}`);
+  }
+
+  if (input.claudeMdUpdated) {
+    lines.push(`📋 CLAUDE.md updated`);
+  }
+
+  if (input.warning) {
+    lines.push(`⚠ ${input.warning}`);
+  }
+
+  return lines.join("\n");
+}
+
+export function buildUpdateStatus(input: UpdateStatusInput): string {
+  const lines: string[] = [
+    `✅ Memory updated`,
+    `   ID:       ${input.id}`,
+    `   Title:    ${input.title}`,
+    `📄 Markdown: ${input.markdownPath}`,
+  ];
+
+  if (input.dbPath) {
+    lines.push(`🗄️  Database: ${input.dbPath}`);
+  }
+
+  if (input.claudeMdUpdated) {
+    lines.push(`📋 CLAUDE.md updated`);
+  }
+
+  return lines.join("\n");
+}

package/lib/cf-memory/src/server.ts

@@ -7,14 +7,20 @@ import { registerList } from "./tools/list.js";
 import { registerUpdate } from "./tools/update.js";
 import { registerDelete } from "./tools/delete.js";
 
+export interface ToolRegistrationContext {
+  docsDir: string;
+  dbPath?: string | null;
+}
+
 export function registerAllTools(
   server: McpServer,
   backend: MemoryBackend,
+  ctx?: ToolRegistrationContext,
 ): void {
-  registerStore(server, backend);
+  registerStore(server, backend, ctx);
   registerSearch(server, backend);
   registerRetrieve(server, backend);
   registerList(server, backend);
-  registerUpdate(server, backend);
-  registerDelete(server, backend);
+  registerUpdate(server, backend, ctx);
+  registerDelete(server, backend, ctx);
 }