coding-friend-cli 1.37.0 → 1.38.1

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

@@ -1,223 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, rmSync, existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import http from "node:http";
-import matter from "gray-matter";
-import { MiniSearchBackend } from "../backends/minisearch.js";
-import { startDaemonServer, type DaemonPaths } from "../daemon/process.js";
-import { DaemonClient } from "../lib/daemon-client.js";
-
-let testDir: string;
-let docsDir: string;
-let testPaths: DaemonPaths;
-let handle: ReturnType<typeof startDaemonServer> | null = null;
-let client: DaemonClient;
-let counter = 0;
-
-beforeEach(async () => {
-  testDir = join(tmpdir(), `cf-memory-e2e-${Date.now()}-${++counter}`);
-  docsDir = join(testDir, "docs");
-  mkdirSync(docsDir, { 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"),
-  };
-
-  const backend = new MiniSearchBackend(docsDir);
-  handle = startDaemonServer(backend, {
-    paths: testPaths,
-    idleTimeoutMs: 0,
-  });
-
-  client = new DaemonClient(testPaths.socketPath);
-
-  // Wait for server to be listening
-  await new Promise<void>((resolve) => {
-    handle!.server.once("listening", resolve);
-  });
-});
-
-afterEach(async () => {
-  if (handle) {
-    await new Promise<void>((resolve) => {
-      handle!.server.close(() => resolve());
-    });
-    try {
-      rmSync(testPaths.socketPath, { force: true });
-      rmSync(testPaths.pidFile, { force: true });
-    } catch {
-      // ignore
-    }
-    handle = null;
-  }
-  rmSync(testDir, { recursive: true, force: true });
-});
-
-describe("Daemon E2E: DaemonClient → Daemon → MiniSearch → Markdown", () => {
-  it("full pipeline: store → search → retrieve → update → delete", async () => {
-    // Store
-    const memory = await client.store({
-      title: "E2E Auth Pattern",
-      description: "JWT auth for API endpoints",
-      type: "fact",
-      tags: ["auth", "jwt"],
-      content: "# Auth\n\nUses RS256 signed JWT tokens.",
-    });
-    expect(memory.id).toBe("features/e2e-auth-pattern");
-
-    // Verify file on disk
-    const filePath = join(docsDir, "features", "e2e-auth-pattern.md");
-    expect(existsSync(filePath)).toBe(true);
-    const raw = matter(readFileSync(filePath, "utf-8"));
-    expect(raw.data.title).toBe("E2E Auth Pattern");
-    expect(raw.data.type).toBe("fact");
-
-    // Search via daemon
-    const searchResults = await client.search({ query: "auth" });
-    expect(searchResults.length).toBeGreaterThan(0);
-
-    // Retrieve
-    const retrieved = await client.retrieve("features/e2e-auth-pattern");
-    expect(retrieved).not.toBeNull();
-    expect(retrieved!.frontmatter.title).toBe("E2E Auth Pattern");
-    expect(retrieved!.content).toContain("RS256");
-
-    // Update
-    const updated = await client.update({
-      id: "features/e2e-auth-pattern",
-      title: "Updated E2E Auth Pattern",
-      tags: ["security"],
-    });
-    expect(updated).not.toBeNull();
-    expect(updated!.frontmatter.title).toBe("Updated E2E Auth Pattern");
-    expect(updated!.frontmatter.tags).toContain("security");
-    expect(updated!.frontmatter.tags).toContain("auth");
-
-    // Verify update on disk
-    const updatedRaw = matter(readFileSync(filePath, "utf-8"));
-    expect(updatedRaw.data.title).toBe("Updated E2E Auth Pattern");
-
-    // Delete
-    const deleted = await client.delete("features/e2e-auth-pattern");
-    expect(deleted).toBe(true);
-
-    // Verify deleted from disk
-    expect(existsSync(filePath)).toBe(false);
-
-    // Verify search no longer finds it
-    const afterDelete = await client.search({ query: "e2e auth" });
-    expect(afterDelete.length).toBe(0);
-  });
-
-  it("list returns all stored memories", async () => {
-    await client.store({
-      title: "Memory One",
-      description: "First memory",
-      type: "fact",
-      tags: ["one"],
-      content: "Content one.",
-    });
-    await client.store({
-      title: "Memory Two",
-      description: "Second memory",
-      type: "episode",
-      tags: ["two"],
-      content: "Content two.",
-    });
-
-    const list = await client.list({});
-    expect(list.length).toBe(2);
-  });
-
-  it("stats reflects stored memories", async () => {
-    await client.store({
-      title: "A Fact",
-      description: "Fact desc",
-      type: "fact",
-      tags: [],
-      content: "Fact content.",
-    });
-    await client.store({
-      title: "A Bug",
-      description: "Bug desc",
-      type: "episode",
-      tags: [],
-      content: "Bug content.",
-    });
-
-    const stats = await client.stats();
-    expect(stats.total).toBe(2);
-    expect(stats.byType.fact).toBe(1);
-    expect(stats.byType.episode).toBe(1);
-  });
-
-  it("rebuild rebuilds the search index", async () => {
-    await client.store({
-      title: "Before Rebuild",
-      description: "Test rebuild",
-      type: "fact",
-      tags: ["rebuild"],
-      content: "Before rebuild content.",
-    });
-
-    await client.rebuild();
-
-    // Search still works after rebuild
-    const results = await client.search({ query: "rebuild" });
-    expect(results.length).toBeGreaterThan(0);
-  });
-
-  it("ping returns true when daemon is running", async () => {
-    const alive = await client.ping();
-    expect(alive).toBe(true);
-  });
-
-  it("retrieve returns null for non-existent memory", async () => {
-    const result = await client.retrieve("features/nonexistent");
-    expect(result).toBeNull();
-  });
-
-  it("delete returns false for non-existent memory", async () => {
-    const result = await client.delete("features/nonexistent");
-    expect(result).toBe(false);
-  });
-
-  it("update returns null for non-existent memory", async () => {
-    const result = await client.update({
-      id: "features/nonexistent",
-      title: "Test",
-    });
-    expect(result).toBeNull();
-  });
-});
-
-describe("DaemonClient fallback", () => {
-  it("ping returns false when daemon not reachable", async () => {
-    const deadClient = new DaemonClient(
-      "/tmp/nonexistent-socket-" + Date.now(),
-    );
-    const alive = await deadClient.ping();
-    expect(alive).toBe(false);
-  });
-
-  it("store throws when daemon not reachable", async () => {
-    const deadClient = new DaemonClient(
-      "/tmp/nonexistent-socket-" + Date.now(),
-    );
-    await expect(
-      deadClient.store({
-        title: "Test",
-        description: "Test",
-        type: "fact",
-        tags: [],
-        content: "Test",
-      }),
-    ).rejects.toThrow();
-  });
-});

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

@@ -1,407 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, rmSync, existsSync, writeFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import http from "node:http";
-import {
-  getDaemonPaths,
-  isDaemonRunning,
-  getDaemonInfo,
-  startDaemonServer,
-  type DaemonPaths,
-} from "../daemon/process.js";
-import { MiniSearchBackend } from "../backends/minisearch.js";
-import type { StoreInput } from "../lib/types.js";
-
-let testDir: string;
-let testPaths: DaemonPaths;
-let counter = 0;
-
-function requestJson<T>(
-  socketPath: string,
-  method: string,
-  path: string,
-  body?: unknown,
-): Promise<{ status: number; data: T }> {
-  return new Promise((resolve, reject) => {
-    const options: http.RequestOptions = {
-      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 {
-          resolve({ status: res.statusCode ?? 0, data: JSON.parse(data) as T });
-        } catch {
-          reject(new Error(`Invalid JSON: ${data}`));
-        }
-      });
-    });
-    req.on("error", reject);
-    if (body) req.write(JSON.stringify(body));
-    req.end();
-  });
-}
-
-beforeEach(() => {
-  testDir = join(tmpdir(), `cf-memory-daemon-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("Daemon process helpers", () => {
-  it("isDaemonRunning returns false when no PID file", async () => {
-    const running = await isDaemonRunning(testPaths);
-    expect(running).toBe(false);
-  });
-
-  it("isDaemonRunning returns false for stale PID file", async () => {
-    writeFileSync(testPaths.pidFile, "99999999\n1234567890", "utf-8");
-    const running = await isDaemonRunning(testPaths);
-    expect(running).toBe(false);
-    // Should clean up stale PID file
-    expect(existsSync(testPaths.pidFile)).toBe(false);
-  });
-
-  it("getDaemonInfo returns null when no PID file", () => {
-    const info = getDaemonInfo(testPaths);
-    expect(info).toBeNull();
-  });
-
-  it("getDaemonInfo reads PID and startedAt", () => {
-    const now = Date.now();
-    writeFileSync(testPaths.pidFile, `12345\n${now}`, "utf-8");
-    const info = getDaemonInfo(testPaths);
-    expect(info).not.toBeNull();
-    expect(info!.pid).toBe(12345);
-    expect(info!.startedAt).toBe(now);
-  });
-
-  it("getDaemonPaths returns expected structure", () => {
-    const paths = getDaemonPaths();
-    expect(paths.socketPath).toContain("daemon.sock");
-    expect(paths.pidFile).toContain("daemon.pid");
-    expect(paths.logFile).toContain("daemon.log");
-  });
-});
-
-describe("Daemon server", () => {
-  let docsDir: string;
-  let handle: ReturnType<typeof startDaemonServer> | null = null;
-
-  beforeEach(() => {
-    docsDir = join(testDir, "docs");
-    mkdirSync(docsDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    if (handle) {
-      // Clean up server without exiting process
-      await new Promise<void>((resolve) => {
-        handle!.server.close(() => resolve());
-      });
-      try {
-        rmSync(testPaths.socketPath, { force: true });
-        rmSync(testPaths.pidFile, { force: true });
-      } catch {
-        // ignore
-      }
-      handle = null;
-    }
-  });
-
-  function startTestDaemon() {
-    const backend = new MiniSearchBackend(docsDir);
-    handle = startDaemonServer(backend, {
-      paths: testPaths,
-      idleTimeoutMs: 0, // Disable idle timeout for tests
-    });
-    return new Promise<void>((resolve) => {
-      // Wait for server to be listening
-      handle!.server.once("listening", resolve);
-    });
-  }
-
-  it("health endpoint responds with status ok", async () => {
-    await startTestDaemon();
-    const { status, data } = await requestJson<{ status: string }>(
-      testPaths.socketPath,
-      "GET",
-      "/health",
-    );
-    expect(status).toBe(200);
-    expect(data.status).toBe("ok");
-  });
-
-  it("stats endpoint returns memory stats", async () => {
-    await startTestDaemon();
-    const { status, data } = await requestJson<{ total: number }>(
-      testPaths.socketPath,
-      "GET",
-      "/stats",
-    );
-    expect(status).toBe(200);
-    expect(data.total).toBe(0);
-  });
-
-  it("store and retrieve a memory via HTTP", async () => {
-    await startTestDaemon();
-
-    const input: StoreInput = {
-      title: "Test Memory",
-      description: "A test memory",
-      type: "fact",
-      tags: ["test"],
-      content: "Test content.",
-    };
-
-    // Store
-    const storeResult = await requestJson<{
-      id: string;
-      stored: boolean;
-    }>(testPaths.socketPath, "POST", "/memory", input);
-    expect(storeResult.status).toBe(201);
-    expect(storeResult.data.stored).toBe(true);
-    expect(storeResult.data.id).toBe("features/test-memory");
-
-    // Retrieve
-    const { status, data } = await requestJson<{
-      id: string;
-      frontmatter: { title: string };
-    }>(testPaths.socketPath, "GET", "/memory/features/test-memory");
-    expect(status).toBe(200);
-    expect(data.frontmatter.title).toBe("Test Memory");
-  });
-
-  it("search returns results", async () => {
-    await startTestDaemon();
-
-    await requestJson(testPaths.socketPath, "POST", "/memory", {
-      title: "JWT Authentication",
-      description: "Auth pattern",
-      type: "fact",
-      tags: ["auth"],
-      content: "JWT tokens.",
-    });
-
-    const { status, data } = await requestJson<
-      Array<{ memory: { frontmatter: { title: string } } }>
-    >(testPaths.socketPath, "GET", "/memory/search?query=JWT");
-    expect(status).toBe(200);
-    expect(data.length).toBeGreaterThan(0);
-    expect(data[0].memory.frontmatter.title).toContain("JWT");
-  });
-
-  it("list returns all memories", async () => {
-    await startTestDaemon();
-
-    await requestJson(testPaths.socketPath, "POST", "/memory", {
-      title: "Memory One",
-      description: "First",
-      type: "fact",
-      tags: [],
-      content: "One.",
-    });
-    await requestJson(testPaths.socketPath, "POST", "/memory", {
-      title: "Memory Two",
-      description: "Second",
-      type: "episode",
-      tags: [],
-      content: "Two.",
-    });
-
-    const { status, data } = await requestJson<Array<{ id: string }>>(
-      testPaths.socketPath,
-      "GET",
-      "/memory",
-    );
-    expect(status).toBe(200);
-    expect(data.length).toBe(2);
-  });
-
-  it("update modifies a memory", async () => {
-    await startTestDaemon();
-
-    await requestJson(testPaths.socketPath, "POST", "/memory", {
-      title: "Original Title",
-      description: "Description",
-      type: "fact",
-      tags: [],
-      content: "Content.",
-    });
-
-    const { status, data } = await requestJson<{
-      updated: boolean;
-      title: string;
-    }>(testPaths.socketPath, "PATCH", "/memory/features/original-title", {
-      title: "New Title",
-    });
-    expect(status).toBe(200);
-    expect(data.updated).toBe(true);
-  });
-
-  it("delete removes a memory", async () => {
-    await startTestDaemon();
-
-    await requestJson(testPaths.socketPath, "POST", "/memory", {
-      title: "Delete Me",
-      description: "To be deleted",
-      type: "fact",
-      tags: [],
-      content: "Content.",
-    });
-
-    const { status, data } = await requestJson<{ deleted: boolean }>(
-      testPaths.socketPath,
-      "DELETE",
-      "/memory/features/delete-me",
-    );
-    expect(status).toBe(200);
-    expect(data.deleted).toBe(true);
-
-    // Verify gone
-    const { status: getStatus } = await requestJson(
-      testPaths.socketPath,
-      "GET",
-      "/memory/features/delete-me",
-    );
-    expect(getStatus).toBe(404);
-  });
-
-  it("rebuild endpoint works", async () => {
-    await startTestDaemon();
-
-    const { status, data } = await requestJson<{ rebuilt: boolean }>(
-      testPaths.socketPath,
-      "POST",
-      "/rebuild",
-    );
-    expect(status).toBe(200);
-    expect(data.rebuilt).toBe(true);
-  });
-
-  it("returns 404 for non-existent memory", async () => {
-    await startTestDaemon();
-
-    const { status } = await requestJson(
-      testPaths.socketPath,
-      "GET",
-      "/memory/features/nonexistent",
-    );
-    expect(status).toBe(404);
-  });
-
-  it("writes PID file on start", async () => {
-    await startTestDaemon();
-    expect(existsSync(testPaths.pidFile)).toBe(true);
-  });
-
-  it("rejects store with invalid body (missing required fields)", async () => {
-    await startTestDaemon();
-
-    const { status, data } = await requestJson<{ error: string }>(
-      testPaths.socketPath,
-      "POST",
-      "/memory",
-      { title: "Test" }, // missing type, description, tags, content
-    );
-    expect(status).toBe(400);
-    expect(data.error).toContain("Validation failed");
-  });
-
-  it("rejects store with invalid type", async () => {
-    await startTestDaemon();
-
-    const { status, data } = await requestJson<{ error: string }>(
-      testPaths.socketPath,
-      "POST",
-      "/memory",
-      {
-        title: "Test",
-        description: "desc",
-        type: "invalid_type",
-        tags: [],
-        content: "content",
-      },
-    );
-    expect(status).toBe(400);
-    expect(data.error).toContain("Validation failed");
-  });
-
-  it("rejects update with invalid importance", async () => {
-    await startTestDaemon();
-
-    // First store a valid memory
-    await requestJson(testPaths.socketPath, "POST", "/memory", {
-      title: "Test Memory",
-      description: "desc",
-      type: "fact",
-      tags: [],
-      content: "content",
-    });
-
-    const { status, data } = await requestJson<{ error: string }>(
-      testPaths.socketPath,
-      "PATCH",
-      "/memory/features/test-memory",
-      { importance: 99 }, // out of range
-    );
-    expect(status).toBe(400);
-    expect(data.error).toContain("Validation failed");
-  });
-
-  it("ignores invalid type query param on search (returns results)", async () => {
-    await startTestDaemon();
-
-    await requestJson(testPaths.socketPath, "POST", "/memory", {
-      title: "Searchable",
-      description: "A searchable memory",
-      type: "fact",
-      tags: ["test"],
-      content: "content",
-    });
-
-    // Invalid type is ignored (parsed as undefined)
-    const { status, data } = await requestJson<Array<unknown>>(
-      testPaths.socketPath,
-      "GET",
-      "/memory/search?query=searchable&type=bogus",
-    );
-    expect(status).toBe(200);
-    // No type filter applied → results returned
-    expect(data.length).toBeGreaterThan(0);
-  });
-
-  it("global error handler returns JSON 500 on unhandled errors", async () => {
-    await startTestDaemon();
-
-    // Send malformed JSON to trigger parse error
-    const { status, data } = await requestJson<{ error: string }>(
-      testPaths.socketPath,
-      "POST",
-      "/memory",
-      "not valid json body -- this gets stringified so let's test empty object parse",
-    );
-    // The body is valid JSON (string gets stringified), but Zod rejects it
-    expect(status).toBe(400);
-    expect(data.error).toBeDefined();
-  });
-});