coding-friend-cli 1.16.0 → 1.17.1

package/lib/cf-memory/src/daemon/process.ts

@@ -0,0 +1,271 @@
+import fs from "node:fs";
+import path from "node:path";
+import net from "node:net";
+import http from "node:http";
+import { getRequestListener } from "@hono/node-server";
+import { createDaemonApp } from "./server.js";
+import type { MemoryBackend } from "../lib/backend.js";
+
+const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+
+export interface DaemonPaths {
+  socketPath: string;
+  pidFile: string;
+  logFile: string;
+}
+
+export function getDaemonPaths(): DaemonPaths {
+  const baseDir = path.join(
+    process.env.HOME ?? process.env.USERPROFILE ?? "/tmp",
+    ".coding-friend",
+    "memory",
+  );
+  fs.mkdirSync(baseDir, { recursive: true });
+  return {
+    socketPath: path.join(baseDir, "daemon.sock"),
+    pidFile: path.join(baseDir, "daemon.pid"),
+    logFile: path.join(baseDir, "daemon.log"),
+  };
+}
+
+/**
+ * Check if the daemon is running by trying to connect to the socket.
+ */
+export async function isDaemonRunning(paths?: DaemonPaths): Promise<boolean> {
+  const { socketPath, pidFile } = paths ?? getDaemonPaths();
+
+  // Check PID file first
+  if (!fs.existsSync(pidFile)) return false;
+
+  const pid = parseInt(
+    fs.readFileSync(pidFile, "utf-8").trim().split("\n")[0],
+    10,
+  );
+  if (isNaN(pid)) return false;
+
+  // Check if process is alive
+  try {
+    process.kill(pid, 0);
+  } catch {
+    // Process not running, clean up stale files
+    cleanupDaemonFiles(paths);
+    return false;
+  }
+
+  // Try to connect to socket
+  return new Promise((resolve) => {
+    const client = net.createConnection({ path: socketPath }, () => {
+      client.end();
+      resolve(true);
+    });
+    client.on("error", () => {
+      resolve(false);
+    });
+    client.setTimeout(1000, () => {
+      client.destroy();
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Get daemon info from PID file.
+ */
+export function getDaemonInfo(
+  paths?: DaemonPaths,
+): { pid: number; startedAt: number } | null {
+  const { pidFile } = paths ?? getDaemonPaths();
+  if (!fs.existsSync(pidFile)) return null;
+
+  const content = fs.readFileSync(pidFile, "utf-8").trim();
+  const lines = content.split("\n");
+  const pid = parseInt(lines[0], 10);
+  if (isNaN(pid)) return null;
+
+  const startedAt = lines[1] ? parseInt(lines[1], 10) : Date.now();
+  return { pid, startedAt };
+}
+
+function cleanupDaemonFiles(paths?: DaemonPaths): void {
+  const { socketPath, pidFile } = paths ?? getDaemonPaths();
+  try {
+    fs.unlinkSync(socketPath);
+  } catch {
+    // Ignore
+  }
+  try {
+    fs.unlinkSync(pidFile);
+  } catch {
+    // Ignore
+  }
+}
+
+export interface DaemonHandle {
+  close: () => void;
+  server: http.Server;
+}
+
+/**
+ * Start the daemon HTTP server on a Unix Domain Socket.
+ *
+ * Signal handling is NOT registered here — the caller owns that.
+ * Use the returned `close()` to trigger graceful shutdown.
+ */
+export function startDaemonServer(
+  backend: MemoryBackend,
+  opts?: {
+    idleTimeoutMs?: number;
+    paths?: DaemonPaths;
+    onShutdown?: () => void;
+  },
+): DaemonHandle {
+  const paths = opts?.paths ?? getDaemonPaths();
+  const idleTimeoutMs = opts?.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+  const { socketPath, pidFile } = paths;
+
+  // Clean up stale socket (catch ENOENT instead of TOCTOU check-then-act)
+  try {
+    fs.unlinkSync(socketPath);
+  } catch {
+    // No stale socket — fine
+  }
+
+  const app = createDaemonApp(backend);
+  const listener = getRequestListener(app.fetch);
+
+  const server = http.createServer(listener);
+
+  let idleTimer: ReturnType<typeof setTimeout> | null = null;
+  let shuttingDown = false;
+
+  function resetIdleTimer() {
+    if (idleTimer) clearTimeout(idleTimer);
+    if (idleTimeoutMs > 0) {
+      idleTimer = setTimeout(() => {
+        shutdown();
+      }, idleTimeoutMs);
+    }
+  }
+
+  // Reset idle timer on each request
+  server.on("request", () => {
+    resetIdleTimer();
+  });
+
+  server.listen(socketPath, () => {
+    // Write PID file
+    fs.writeFileSync(pidFile, `${process.pid}\n${Date.now()}`, "utf-8");
+    resetIdleTimer();
+  });
+
+  function shutdown() {
+    if (shuttingDown) return;
+    shuttingDown = true;
+
+    if (idleTimer) clearTimeout(idleTimer);
+    opts?.onShutdown?.();
+    backend.close().catch(() => {});
+    server.close(() => {
+      cleanupDaemonFiles(paths);
+      process.exit(0);
+    });
+    // Force exit after 5 seconds
+    setTimeout(() => process.exit(1), 5000).unref();
+  }
+
+  return { close: shutdown, server };
+}
+
+/**
+ * Spawn the daemon as a detached background process (if not already running).
+ *
+ * Resolves `daemon/entry.js` relative to this file so it works from both
+ * the MCP server and the CLI without hardcoding paths.
+ */
+export async function spawnDaemon(
+  docsDir: string,
+  embeddingConfig?: {
+    provider?: string;
+    model?: string;
+    ollamaUrl?: string;
+  },
+): Promise<{ pid: number } | null> {
+  if (await isDaemonRunning()) return null;
+
+  const { spawn } = await import("node:child_process");
+  const { fileURLToPath } = await import("node:url");
+
+  const thisDir = path.dirname(fileURLToPath(import.meta.url));
+  const entryPath = path.join(thisDir, "entry.js");
+
+  if (!fs.existsSync(entryPath)) return null;
+
+  const args = [entryPath, docsDir];
+  if (embeddingConfig?.provider)
+    args.push(`--embedding-provider=${embeddingConfig.provider}`);
+  if (embeddingConfig?.model)
+    args.push(`--embedding-model=${embeddingConfig.model}`);
+  if (embeddingConfig?.ollamaUrl)
+    args.push(`--embedding-ollama-url=${embeddingConfig.ollamaUrl}`);
+
+  const child = spawn("node", args, {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env },
+  });
+  child.unref();
+
+  // Wait for daemon to be ready (max 3 seconds)
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 100));
+    if (await isDaemonRunning()) {
+      const info = getDaemonInfo();
+      return info ? { pid: info.pid } : null;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Stop the daemon by sending SIGTERM.
+ */
+export async function stopDaemon(paths?: DaemonPaths): Promise<boolean> {
+  const { pidFile } = paths ?? getDaemonPaths();
+  if (!fs.existsSync(pidFile)) return false;
+
+  const pid = parseInt(
+    fs.readFileSync(pidFile, "utf-8").trim().split("\n")[0],
+    10,
+  );
+  if (isNaN(pid)) return false;
+
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    // Already dead
+    cleanupDaemonFiles(paths);
+    return false;
+  }
+
+  // Wait for process to exit (max 5 seconds)
+  for (let i = 0; i < 50; i++) {
+    await new Promise((r) => setTimeout(r, 100));
+    try {
+      process.kill(pid, 0);
+    } catch {
+      // Process exited
+      cleanupDaemonFiles(paths);
+      return true;
+    }
+  }
+
+  // Force kill
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    // Already dead
+  }
+  cleanupDaemonFiles(paths);
+  return true;
+}

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

@@ -0,0 +1,166 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import type { MemoryBackend } from "../lib/backend.js";
+import {
+  MEMORY_TYPES,
+  type MemoryType,
+  type SearchInput,
+} from "../lib/types.js";
+
+const memoryTypeSchema = z.enum(MEMORY_TYPES);
+
+const storeSchema = z.object({
+  title: z.string().min(1),
+  description: z.string(),
+  type: memoryTypeSchema,
+  tags: z.array(z.string()),
+  content: z.string(),
+  importance: z.number().min(1).max(5).optional(),
+  source: z.string().optional(),
+});
+
+const updateSchema = z.object({
+  title: z.string().min(1).optional(),
+  description: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  content: z.string().optional(),
+  importance: z.number().min(1).max(5).optional(),
+});
+
+function parseType(raw: string | undefined): MemoryType | undefined {
+  if (!raw) return undefined;
+  const result = memoryTypeSchema.safeParse(raw);
+  return result.success ? result.data : undefined;
+}
+
+export function createDaemonApp(backend: MemoryBackend): Hono {
+  const app = new Hono();
+
+  // Global error handler
+  app.onError((err, c) => {
+    return c.json(
+      { error: err instanceof Error ? err.message : "Internal server error" },
+      500,
+    );
+  });
+
+  // Health check
+  app.get("/health", (c) => {
+    return c.json({
+      status: "ok",
+      uptime: process.uptime(),
+      pid: process.pid,
+    });
+  });
+
+  // Stats
+  app.get("/stats", async (c) => {
+    const stats = await backend.stats();
+    return c.json(stats);
+  });
+
+  // Store a new memory
+  app.post("/memory", async (c) => {
+    const raw = await c.req.json();
+    const parsed = storeSchema.safeParse(raw);
+    if (!parsed.success) {
+      return c.json(
+        { error: "Validation failed", details: parsed.error.issues },
+        400,
+      );
+    }
+    const memory = await backend.store(parsed.data);
+    return c.json(
+      { id: memory.id, title: memory.frontmatter.title, stored: true },
+      201,
+    );
+  });
+
+  // Search memories
+  app.get("/memory/search", async (c) => {
+    const query = c.req.query("query") ?? "";
+    const type = parseType(c.req.query("type"));
+    const tagsRaw = c.req.query("tags");
+    const limitRaw = c.req.query("limit");
+
+    const input: SearchInput = {
+      query,
+      type,
+      tags: tagsRaw ? tagsRaw.split(",") : undefined,
+      limit: limitRaw ? parseInt(limitRaw, 10) : undefined,
+    };
+
+    const results = await backend.search(input);
+    return c.json(results);
+  });
+
+  // Retrieve a memory by ID (category/slug)
+  app.get("/memory/:category/:slug", async (c) => {
+    const id = `${c.req.param("category")}/${c.req.param("slug")}`;
+    const memory = await backend.retrieve(id);
+    if (!memory) {
+      return c.json({ error: "Not found" }, 404);
+    }
+    return c.json(memory);
+  });
+
+  // List memories
+  app.get("/memory", async (c) => {
+    const type = parseType(c.req.query("type"));
+    const category = c.req.query("category");
+    const limitRaw = c.req.query("limit");
+
+    const metas = await backend.list({
+      type,
+      category: category || undefined,
+      limit: limitRaw ? parseInt(limitRaw, 10) : undefined,
+    });
+    return c.json(metas);
+  });
+
+  // Update a memory
+  app.patch("/memory/:category/:slug", async (c) => {
+    const id = `${c.req.param("category")}/${c.req.param("slug")}`;
+    const raw = await c.req.json();
+    const parsed = updateSchema.safeParse(raw);
+    if (!parsed.success) {
+      return c.json(
+        { error: "Validation failed", details: parsed.error.issues },
+        400,
+      );
+    }
+    const memory = await backend.update({ id, ...parsed.data });
+    if (!memory) {
+      return c.json({ error: "Not found" }, 404);
+    }
+    return c.json({
+      id: memory.id,
+      title: memory.frontmatter.title,
+      updated: true,
+    });
+  });
+
+  // Delete a memory
+  app.delete("/memory/:category/:slug", async (c) => {
+    const id = `${c.req.param("category")}/${c.req.param("slug")}`;
+    const deleted = await backend.delete(id);
+    if (!deleted) {
+      return c.json({ error: "Not found" }, 404);
+    }
+    return c.json({ id, deleted: true });
+  });
+
+  // Rebuild index (for MiniSearchBackend)
+  app.post("/rebuild", async (c) => {
+    if ("rebuild" in backend && typeof backend.rebuild === "function") {
+      await (backend as MemoryBackend & { rebuild(): Promise<void> }).rebuild();
+      return c.json({ rebuilt: true });
+    }
+    return c.json({
+      rebuilt: false,
+      reason: "Backend does not support rebuild",
+    });
+  });
+
+  return app;
+}

package/lib/cf-memory/src/daemon/watcher.ts

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { MemoryBackend } from "../lib/backend.js";
+
+export interface WatcherHandle {
+  close: () => void;
+}
+
+/**
+ * Watch docs/memory/ for changes and trigger index rebuild (debounced).
+ */
+export function setupWatcher(
+  docsDir: string,
+  backend: Required<Pick<MemoryBackend, "rebuild">>,
+  debounceMs = 500,
+): WatcherHandle {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const watchers: fs.FSWatcher[] = [];
+  const watchedDirs = new Set<string>();
+
+  function scheduleRebuild() {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      backend.rebuild().catch(() => {});
+    }, debounceMs);
+  }
+
+  function watchSubdir(dirPath: string) {
+    if (watchedDirs.has(dirPath)) return;
+    watchedDirs.add(dirPath);
+    try {
+      const w = fs.watch(dirPath, { persistent: false }, (_, filename) => {
+        if (filename && filename.endsWith(".md")) {
+          scheduleRebuild();
+        }
+      });
+      watchers.push(w);
+    } catch {
+      watchedDirs.delete(dirPath);
+    }
+  }
+
+  // Watch the root docs dir
+  if (fs.existsSync(docsDir)) {
+    try {
+      const rootWatcher = fs.watch(
+        docsDir,
+        { persistent: false },
+        (_, filename) => {
+          if (filename && !filename.startsWith(".")) {
+            scheduleRebuild();
+            // If a new directory appeared, watch it too
+            const subPath = path.join(docsDir, filename);
+            try {
+              if (fs.statSync(subPath).isDirectory()) {
+                watchSubdir(subPath);
+              }
+            } catch {
+              // File may have been deleted between event and stat
+            }
+          }
+        },
+      );
+      watchers.push(rootWatcher);
+    } catch {
+      // Ignore watch errors (e.g., directory doesn't exist)
+    }
+
+    // Watch existing subdirectories
+    try {
+      const entries = fs.readdirSync(docsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          watchSubdir(path.join(docsDir, entry.name));
+        }
+      }
+    } catch {
+      // Ignore
+    }
+  }
+
+  return {
+    close() {
+      if (timer) clearTimeout(timer);
+      for (const w of watchers) {
+        w.close();
+      }
+    },
+  };
+}

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

@@ -0,0 +1,53 @@
+import path from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerAllTools } from "./server.js";
+import { registerAllResources } from "./resources/index.js";
+import { createBackendForTier } from "./lib/tier.js";
+import type { TierConfig } from "./lib/tier.js";
+import type { EmbeddingConfig } from "./backends/sqlite/embeddings.js";
+
+const rawDir =
+  process.argv[2] ?? process.env.MEMORY_DOCS_DIR ?? "./docs/memory";
+const docsDir = path.resolve(rawDir);
+const tierConfig = (process.env.MEMORY_TIER ?? "auto") as TierConfig;
+
+// Embedding config from environment variables
+const embeddingConfig: Partial<EmbeddingConfig> | undefined = (() => {
+  const provider = process.env.MEMORY_EMBEDDING_PROVIDER as
+    | EmbeddingConfig["provider"]
+    | undefined;
+  const model = process.env.MEMORY_EMBEDDING_MODEL;
+  const ollamaUrl = process.env.MEMORY_EMBEDDING_OLLAMA_URL;
+  if (!provider && !model && !ollamaUrl) return undefined;
+  return {
+    ...(provider && { provider }),
+    ...(model && { model }),
+    ...(ollamaUrl && { ollamaUrl }),
+  };
+})();
+
+const { backend, tier } = await createBackendForTier(
+  docsDir,
+  tierConfig,
+  embeddingConfig,
+);
+
+// Auto-start daemon for file watching (Tier 1 & 2)
+// Daemon watches docs/memory/ for external changes (git pull, manual edits)
+// and rebuilds the search index automatically.
+if (tier.name !== "markdown") {
+  const { spawnDaemon } = await import("./daemon/process.js");
+  spawnDaemon(docsDir, embeddingConfig).catch(() => {});
+}
+
+const server = new McpServer({
+  name: "coding-friend-memory",
+  version: "0.0.1",
+});
+
+registerAllTools(server, backend);
+registerAllResources(server, backend);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

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

@@ -0,0 +1,23 @@
+import type {
+  ListInput,
+  Memory,
+  MemoryMeta,
+  MemoryStats,
+  SearchInput,
+  SearchResult,
+  StoreInput,
+  UpdateInput,
+} from "./types.js";
+
+export interface MemoryBackend {
+  store(input: StoreInput): Promise<Memory>;
+  search(input: SearchInput): Promise<SearchResult[]>;
+  retrieve(id: string): Promise<Memory | null>;
+  list(input: ListInput): Promise<MemoryMeta[]>;
+  update(input: UpdateInput): Promise<Memory | null>;
+  delete(id: string): Promise<boolean>;
+  stats(): Promise<MemoryStats>;
+  close(): Promise<void>;
+  /** Rebuild the search index from source files. Optional — not all backends support it. */
+  rebuild?(): Promise<void>;
+}