coding-friend-cli 1.16.0 → 1.17.0

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

@@ -0,0 +1,220 @@
+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 };
+}
+
+/**
+ * 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,45 @@
+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,
+);
+
+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>;
+}

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

@@ -0,0 +1,163 @@
+import http from "node:http";
+import type { MemoryBackend } from "./backend.js";
+import type {
+  ListInput,
+  Memory,
+  MemoryMeta,
+  MemoryStats,
+  SearchInput,
+  SearchResult,
+  StoreInput,
+  UpdateInput,
+} from "./types.js";
+
+/**
+ * MemoryBackend implementation that talks to the daemon over UDS.
+ */
+export class DaemonClient implements MemoryBackend {
+  constructor(private socketPath: string) {}
+
+  private request<T>(method: string, path: string, body?: unknown): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const options: http.RequestOptions = {
+        socketPath: this.socketPath,
+        path,
+        method,
+        headers: {
+          "Content-Type": "application/json",
+        },
+      };
+
+      const req = http.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk: Buffer) => {
+          data += chunk.toString();
+        });
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(data) as T;
+            if (res.statusCode && res.statusCode >= 400) {
+              reject(
+                new Error(
+                  (parsed as Record<string, string>).error ??
+                    `HTTP ${res.statusCode}`,
+                ),
+              );
+            } else {
+              resolve(parsed);
+            }
+          } catch {
+            reject(new Error(`Invalid JSON response: ${data}`));
+          }
+        });
+      });
+
+      req.on("error", (err) => {
+        reject(err);
+      });
+
+      req.setTimeout(10000, () => {
+        req.destroy();
+        reject(new Error("Request timeout"));
+      });
+
+      if (body) {
+        req.write(JSON.stringify(body));
+      }
+      req.end();
+    });
+  }
+
+  async store(input: StoreInput): Promise<Memory> {
+    const result = await this.request<{
+      id: string;
+      title: string;
+      stored: boolean;
+    }>("POST", "/memory", input);
+    // Retrieve full memory after store
+    const memory = await this.retrieve(result.id);
+    if (!memory) throw new Error("Store succeeded but retrieve failed");
+    return memory;
+  }
+
+  async search(input: SearchInput): Promise<SearchResult[]> {
+    const params = new URLSearchParams();
+    params.set("query", input.query);
+    if (input.type) params.set("type", input.type);
+    if (input.tags) params.set("tags", input.tags.join(","));
+    if (input.limit) params.set("limit", String(input.limit));
+
+    return this.request<SearchResult[]>(
+      "GET",
+      `/memory/search?${params.toString()}`,
+    );
+  }
+
+  async retrieve(id: string): Promise<Memory | null> {
+    try {
+      return await this.request<Memory>("GET", `/memory/${id}`);
+    } catch {
+      return null;
+    }
+  }
+
+  async list(input: ListInput): Promise<MemoryMeta[]> {
+    const params = new URLSearchParams();
+    if (input.type) params.set("type", input.type);
+    if (input.category) params.set("category", input.category);
+    if (input.limit) params.set("limit", String(input.limit));
+
+    const qs = params.toString();
+    return this.request<MemoryMeta[]>("GET", qs ? `/memory?${qs}` : "/memory");
+  }
+
+  async update(input: UpdateInput): Promise<Memory | null> {
+    const { id, ...body } = input;
+    try {
+      await this.request("PATCH", `/memory/${id}`, body);
+      return this.retrieve(id);
+    } catch {
+      return null;
+    }
+  }
+
+  async delete(id: string): Promise<boolean> {
+    try {
+      await this.request("DELETE", `/memory/${id}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async stats(): Promise<MemoryStats> {
+    return this.request<MemoryStats>("GET", "/stats");
+  }
+
+  async close(): Promise<void> {
+    // No-op — daemon keeps running
+  }
+
+  /**
+   * Check if the daemon is reachable.
+   */
+  async ping(): Promise<boolean> {
+    try {
+      const result = await this.request<{ status: string }>("GET", "/health");
+      return result.status === "ok";
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Trigger index rebuild on the daemon.
+   */
+  async rebuild(): Promise<void> {
+    try {
+      await this.request<{ rebuilt: boolean }>("POST", "/rebuild");
+    } catch {
+      // Rebuild failed or not supported
+    }
+  }
+}