coding-friend-cli 1.37.0 → 1.38.1

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

@@ -1,388 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdirSync, rmSync, existsSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { detectTier, createBackendForTier, TIERS } from "../lib/tier.js";
-import { MarkdownBackend } from "../backends/markdown.js";
-import { DaemonClient } from "../lib/daemon-client.js";
-import type { DaemonPaths } from "../daemon/process.js";
-import { areSqliteDepsAvailable } from "../lib/lazy-install.js";
-
-let testDir: string;
-
-beforeEach(() => {
-  testDir = join(tmpdir(), `cf-memory-tier-test-${Date.now()}`);
-  mkdirSync(testDir, { recursive: true });
-});
-
-afterEach(() => {
-  rmSync(testDir, { recursive: true, force: true });
-});
-
-describe("detectTier()", () => {
-  it("returns Tier 3 (markdown) when no daemon is running and no sqlite deps", async () => {
-    const lazyInstall = await import("../lib/lazy-install.js");
-    const sqliteSpy = vi
-      .spyOn(lazyInstall, "areSqliteDepsAvailable")
-      .mockReturnValue(false);
-    const daemonProcess = await import("../daemon/process.js");
-    const daemonSpy = vi
-      .spyOn(daemonProcess, "isDaemonRunning")
-      .mockResolvedValue(false);
-    try {
-      const tier = await detectTier();
-      // Without a daemon running and no SQLite deps, should detect Tier 3
-      expect(tier.name).toBe("markdown");
-      expect(tier.number).toBe(3);
-      expect(tier.label).toContain("Tier 3");
-    } finally {
-      sqliteSpy.mockRestore();
-      daemonSpy.mockRestore();
-    }
-  });
-
-  it("respects config override to markdown", async () => {
-    const tier = await detectTier("markdown");
-    expect(tier.name).toBe("markdown");
-  });
-
-  it("respects config override to lite", async () => {
-    const tier = await detectTier("lite");
-    expect(tier.name).toBe("lite");
-    expect(tier.number).toBe(2);
-  });
-
-  it("respects config override to full", async () => {
-    const tier = await detectTier("full");
-    expect(tier.name).toBe("full");
-    expect(tier.number).toBe(1);
-  });
-
-  it("auto mode defaults to markdown when no daemon and no sqlite deps", async () => {
-    // Mock areSqliteDepsAvailable to return false
-    const lazyInstall = await import("../lib/lazy-install.js");
-    const sqliteSpy = vi
-      .spyOn(lazyInstall, "areSqliteDepsAvailable")
-      .mockReturnValue(false);
-    const daemonProcess = await import("../daemon/process.js");
-    const daemonSpy = vi
-      .spyOn(daemonProcess, "isDaemonRunning")
-      .mockResolvedValue(false);
-    try {
-      const tier = await detectTier("auto");
-      expect(tier.name).toBe("markdown");
-    } finally {
-      sqliteSpy.mockRestore();
-      daemonSpy.mockRestore();
-    }
-  });
-
-  it("auto mode returns full when SQLite deps are available", async () => {
-    const lazyInstall = await import("../lib/lazy-install.js");
-    const sqliteSpy = vi
-      .spyOn(lazyInstall, "areSqliteDepsAvailable")
-      .mockReturnValue(true);
-    try {
-      const tier = await detectTier("auto");
-      expect(tier.name).toBe("full");
-      expect(tier.number).toBe(1);
-    } finally {
-      sqliteSpy.mockRestore();
-    }
-  });
-
-  it("auto mode returns lite when daemon is running (no sqlite deps)", async () => {
-    // Mock areSqliteDepsAvailable to return false, isDaemonRunning to return true
-    const lazyInstall = await import("../lib/lazy-install.js");
-    const sqliteSpy = vi
-      .spyOn(lazyInstall, "areSqliteDepsAvailable")
-      .mockReturnValue(false);
-    const daemonProcess = await import("../daemon/process.js");
-    const spy = vi
-      .spyOn(daemonProcess, "isDaemonRunning")
-      .mockResolvedValue(true);
-    try {
-      const tier = await detectTier("auto");
-      expect(tier.name).toBe("lite");
-      expect(tier.number).toBe(2);
-    } finally {
-      spy.mockRestore();
-      sqliteSpy.mockRestore();
-    }
-  });
-});
-
-describe("createBackendForTier()", () => {
-  it("creates MarkdownBackend for markdown tier", async () => {
-    const { backend, tier } = await createBackendForTier(testDir, "markdown");
-    expect(tier.name).toBe("markdown");
-    expect(backend).toBeInstanceOf(MarkdownBackend);
-    await backend.close();
-  });
-
-  it("auto tier falls back to markdown when no daemon and no sqlite deps", async () => {
-    const lazyInstall = await import("../lib/lazy-install.js");
-    const sqliteSpy = vi
-      .spyOn(lazyInstall, "areSqliteDepsAvailable")
-      .mockReturnValue(false);
-    const daemonProcess = await import("../daemon/process.js");
-    const daemonSpy = vi
-      .spyOn(daemonProcess, "isDaemonRunning")
-      .mockResolvedValue(false);
-    try {
-      const { backend, tier } = await createBackendForTier(testDir, "auto");
-      expect(tier.name).toBe("markdown");
-      expect(backend).toBeInstanceOf(MarkdownBackend);
-      await backend.close();
-    } finally {
-      sqliteSpy.mockRestore();
-      daemonSpy.mockRestore();
-    }
-  });
-
-  it("auto tier creates SqliteBackend when sqlite deps available", async () => {
-    const lazyInstall = await import("../lib/lazy-install.js");
-    if (!lazyInstall.areSqliteDepsAvailable()) return; // skip if deps not installed
-    const dbPath = join(testDir, "db.sqlite");
-    const { backend, tier } = await createBackendForTier(
-      testDir,
-      "auto",
-      undefined,
-      { dbPath },
-    );
-    expect(tier.name).toBe("full");
-    await backend.close();
-  });
-
-  it("full tier falls back to markdown when SQLite deps not available", async () => {
-    // Without lazy-installed deps, SqliteBackend will fail to construct
-    // and createBackendForTier should fall back to markdown
-    const dbPath = join(testDir, "db.sqlite");
-    const { backend, tier } = await createBackendForTier(
-      testDir,
-      "full",
-      undefined,
-      { dbPath },
-    );
-    // Falls back because better-sqlite3 is not installed in test env
-    expect(["markdown", "full"]).toContain(tier.name);
-    await backend.close();
-  });
-
-  it("lite tier with running daemon returns DaemonClient", async () => {
-    // Start a real daemon to test the full path
-    const { MiniSearchBackend } = await import("../backends/minisearch.js");
-    const { startDaemonServer } = await import("../daemon/process.js");
-
-    const docsDir = join(testDir, "docs");
-    mkdirSync(docsDir, { recursive: true });
-    const daemonDir = join(testDir, "daemon");
-    mkdirSync(daemonDir, { recursive: true });
-
-    const paths: DaemonPaths = {
-      socketPath: join(daemonDir, "daemon.sock"),
-      pidFile: join(daemonDir, "daemon.pid"),
-      logFile: join(daemonDir, "daemon.log"),
-    };
-
-    const backend = new MiniSearchBackend(docsDir);
-    const handle = startDaemonServer(backend, {
-      paths,
-      idleTimeoutMs: 0,
-    });
-
-    await new Promise<void>((resolve) => {
-      handle.server.once("listening", resolve);
-    });
-
-    try {
-      // Mock getDaemonPaths so createBackendForTier uses our test paths
-      const daemonProcess = await import("../daemon/process.js");
-      const pathsSpy = vi
-        .spyOn(daemonProcess, "getDaemonPaths")
-        .mockReturnValue(paths);
-
-      const { backend: created, tier } = await createBackendForTier(
-        docsDir,
-        "lite",
-      );
-      expect(tier.name).toBe("lite");
-      expect(created).toBeInstanceOf(DaemonClient);
-      await created.close();
-      pathsSpy.mockRestore();
-    } finally {
-      await new Promise<void>((resolve) => {
-        handle.server.close(() => resolve());
-      });
-      rmSync(paths.socketPath, { force: true });
-      rmSync(paths.pidFile, { force: true });
-    }
-  });
-
-  it("lite tier falls back to markdown when daemon is unreachable mid-session", async () => {
-    // Simulate: tier detection says "lite" but daemon socket is gone
-    // Must also mock SQLite deps away so auto tier picks "lite" over "full"
-    const lazyInstall = await import("../lib/lazy-install.js");
-    const sqliteSpy = vi
-      .spyOn(lazyInstall, "areSqliteDepsAvailable")
-      .mockReturnValue(false);
-    const daemonProcess = await import("../daemon/process.js");
-    const spy = vi
-      .spyOn(daemonProcess, "isDaemonRunning")
-      .mockResolvedValue(true);
-    const pathsSpy = vi.spyOn(daemonProcess, "getDaemonPaths").mockReturnValue({
-      socketPath: "/tmp/nonexistent-cf-test-sock-" + Date.now(),
-      pidFile: "/tmp/nonexistent-cf-test-pid-" + Date.now(),
-      logFile: "/tmp/nonexistent-cf-test-log-" + Date.now(),
-    });
-
-    try {
-      const { backend: created, tier } = await createBackendForTier(
-        testDir,
-        "auto",
-      );
-      // DaemonClient.ping() fails → falls back to MarkdownBackend
-      expect(tier.name).toBe("markdown");
-      expect(created).toBeInstanceOf(MarkdownBackend);
-      await created.close();
-    } finally {
-      sqliteSpy.mockRestore();
-      spy.mockRestore();
-      pathsSpy.mockRestore();
-    }
-  });
-});
-
-describe("createBackendForTier() — lazy DB guarantee", () => {
-  it.skipIf(!areSqliteDepsAvailable())(
-    "full tier on a non-CF project does not create DB before any write",
-    async () => {
-      // Use an explicit tmpdir dbPath so ~/.coding-friend is never touched
-      const dbPath = join(testDir, "db.sqlite");
-      const { backend, tier } = await createBackendForTier(
-        testDir,
-        "full",
-        undefined,
-        { dbPath },
-      );
-      expect(tier.name).toBe("full");
-      // No DB file after construction
-      expect(existsSync(dbPath)).toBe(false);
-      await backend.close();
-    },
-  );
-});
-
-describe("createBackendForTier() with embeddingConfig", () => {
-  it("accepts an optional embeddingConfig parameter without error", async () => {
-    const embeddingConfig = {
-      provider: "ollama" as const,
-      model: "nomic-embed-text",
-      ollamaUrl: "http://localhost:11434",
-    };
-    // Should not throw — markdown tier ignores embedding config gracefully
-    const { backend, tier } = await createBackendForTier(
-      testDir,
-      "markdown",
-      embeddingConfig,
-    );
-    expect(tier.name).toBe("markdown");
-    expect(backend).toBeInstanceOf(MarkdownBackend);
-    await backend.close();
-  });
-
-  it("passes embeddingConfig through when full tier falls back to markdown", async () => {
-    const embeddingConfig = {
-      provider: "ollama" as const,
-      model: "nomic-embed-text",
-    };
-    const dbPath = join(testDir, "db.sqlite");
-    // Full tier will fail (no sqlite deps in test env) and fall back
-    const { backend, tier } = await createBackendForTier(
-      testDir,
-      "full",
-      embeddingConfig,
-      { dbPath },
-    );
-    // Falls back because better-sqlite3 is not installed in test env
-    expect(["markdown", "full"]).toContain(tier.name);
-    await backend.close();
-  });
-});
-
-describe("makeRespawn retry logic", () => {
-  it("retries up to 3 times before giving up", async () => {
-    const daemonProcess = await import("../daemon/process.js");
-
-    let attempts = 0;
-    const spawnSpy = vi
-      .spyOn(daemonProcess, "spawnDaemon")
-      .mockImplementation(async () => {
-        attempts++;
-        return null; // always fail
-      });
-    // Isolate from real daemon state on the host machine
-    const runningSpy = vi
-      .spyOn(daemonProcess, "isDaemonRunning")
-      .mockResolvedValue(false);
-
-    // Use createBackendForTier with "lite" to trigger respawn path
-    // The respawn callback wraps makeRespawn which calls spawnDaemon
-    // We need to get the respawn function indirectly
-    // Instead, test via the exported createRespawnWithRetry
-    const { createRespawnWithRetry } = await import("../lib/tier.js");
-    const respawn = createRespawnWithRetry(".", undefined, undefined);
-    const result = await respawn();
-
-    expect(result).toBe(false);
-    expect(attempts).toBe(3);
-
-    spawnSpy.mockRestore();
-    runningSpy.mockRestore();
-  });
-
-  it("succeeds on second attempt", async () => {
-    const daemonProcess = await import("../daemon/process.js");
-
-    let attempts = 0;
-    const spawnSpy = vi
-      .spyOn(daemonProcess, "spawnDaemon")
-      .mockImplementation(async () => {
-        attempts++;
-        if (attempts === 2) return { pid: 1234 };
-        return null;
-      });
-    // Isolate from real daemon state on the host machine
-    const runningSpy = vi
-      .spyOn(daemonProcess, "isDaemonRunning")
-      .mockResolvedValue(false);
-
-    const { createRespawnWithRetry } = await import("../lib/tier.js");
-    const respawn = createRespawnWithRetry(".", undefined, undefined);
-    const result = await respawn();
-
-    expect(result).toBe(true);
-    expect(attempts).toBe(2);
-
-    spawnSpy.mockRestore();
-    runningSpy.mockRestore();
-  });
-});
-
-describe("TIERS constant", () => {
-  it("has all 3 tier definitions", () => {
-    expect(Object.keys(TIERS)).toHaveLength(3);
-    expect(TIERS.full.number).toBe(1);
-    expect(TIERS.lite.number).toBe(2);
-    expect(TIERS.markdown.number).toBe(3);
-  });
-
-  it("each tier has name, label, and number", () => {
-    for (const tier of Object.values(TIERS)) {
-      expect(tier.name).toBeTruthy();
-      expect(tier.label).toBeTruthy();
-      expect(tier.number).toBeGreaterThanOrEqual(1);
-      expect(tier.number).toBeLessThanOrEqual(3);
-    }
-  });
-});

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

@@ -1,83 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, rmSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { MarkdownBackend } from "../backends/markdown.js";
-import { registerAllTools } from "../server.js";
-import { registerAllResources } from "../resources/index.js";
-
-let testDir: string;
-let server: McpServer;
-let backend: MarkdownBackend;
-
-beforeEach(() => {
-  testDir = join(tmpdir(), `cf-memory-tools-test-${Date.now()}`);
-  mkdirSync(testDir, { recursive: true });
-  backend = new MarkdownBackend(testDir);
-  server = new McpServer({
-    name: "test-memory-server",
-    version: "0.0.1",
-  });
-});
-
-afterEach(() => {
-  rmSync(testDir, { recursive: true, force: true });
-});
-
-describe("MCP Tool Registration", () => {
-  it("registers all 6 tools without error", () => {
-    expect(() => registerAllTools(server, backend)).not.toThrow();
-  });
-
-  it("registers all 2 resources without error", () => {
-    expect(() => registerAllResources(server, backend)).not.toThrow();
-  });
-
-  it("registers both tools and resources together", () => {
-    expect(() => {
-      registerAllTools(server, backend);
-      registerAllResources(server, backend);
-    }).not.toThrow();
-  });
-});
-
-describe("MemoryBackend interface compliance", () => {
-  it("has all 8 required methods", () => {
-    expect(typeof backend.store).toBe("function");
-    expect(typeof backend.search).toBe("function");
-    expect(typeof backend.retrieve).toBe("function");
-    expect(typeof backend.list).toBe("function");
-    expect(typeof backend.update).toBe("function");
-    expect(typeof backend.delete).toBe("function");
-    expect(typeof backend.stats).toBe("function");
-    expect(typeof backend.close).toBe("function");
-  });
-});
-
-describe("Type validation", () => {
-  it("MEMORY_TYPES has exactly 5 types", async () => {
-    const { MEMORY_TYPES } = await import("../lib/types.js");
-    expect(MEMORY_TYPES).toHaveLength(5);
-    expect(MEMORY_TYPES).toContain("fact");
-    expect(MEMORY_TYPES).toContain("preference");
-    expect(MEMORY_TYPES).toContain("context");
-    expect(MEMORY_TYPES).toContain("episode");
-    expect(MEMORY_TYPES).toContain("procedure");
-  });
-
-  it("MEMORY_CATEGORIES maps all types to folders", async () => {
-    const { MEMORY_CATEGORIES, MEMORY_TYPES } = await import("../lib/types.js");
-    for (const type of MEMORY_TYPES) {
-      expect(MEMORY_CATEGORIES[type]).toBeTruthy();
-    }
-  });
-
-  it("CATEGORY_TO_TYPE is inverse of MEMORY_CATEGORIES", async () => {
-    const { MEMORY_CATEGORIES, CATEGORY_TO_TYPE } =
-      await import("../lib/types.js");
-    for (const [type, category] of Object.entries(MEMORY_CATEGORIES)) {
-      expect(CATEGORY_TO_TYPE[category]).toBe(type);
-    }
-  });
-});

package/lib/cf-memory/vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "node",
-  },
-});

package/lib/learn-host/.prettierignore

@@ -1,4 +0,0 @@
-node_modules
-.next
-out
-public/_pagefind

package/lib/learn-host/.prettierrc

@@ -1,8 +0,0 @@
-{
-  "semi": true,
-  "singleQuote": false,
-  "tabWidth": 2,
-  "trailingComma": "all",
-  "printWidth": 80,
-  "plugins": ["prettier-plugin-tailwindcss"]
-}

package/lib/learn-host/README.md

@@ -1,113 +0,0 @@
-# coding-friend-learn-host
-
-Next.js app that renders your `/cf-learn` docs as a browsable website with search, categories, and dark mode.
-
-## Usage (via CLI)
-
-```bash
-cf learn host               # serves docs/learn/ on port 3333
-cf learn host ./my-docs     # serves a custom directory
-cf learn host -p 4000       # custom port
-```
-
-The CLI handles deps install, build, and serving automatically.
-
-## Local Development
-
-Run the app directly without the CLI — useful when working on the UI itself.
-
-### 1. Install dependencies
-
-```bash
-cd cli/lib/learn-host
-npm install
-```
-
-### 2. Point to a docs directory
-
-The app reads the docs directory from the `DOCS_DIR` env var, which the CLI sets by resolving (in order):
-
-1. Explicit path argument (`cf learn host <path>`)
-2. Global `~/.coding-friend/config.json` → `learn.outputDir`
-3. Default: `~/.coding-friend/learn`
-
-For local dev, set `DOCS_DIR` to any directory with the expected structure:
-
-```
-docs/
-└── learn/
-    ├── category-one/
-    │   ├── my-doc.md
-    │   └── another-doc.md
-    └── category-two/
-        └── some-doc.md
-```
-
-Each `.md` file should have frontmatter:
-
-```md
----
-title: My Doc Title
-category: category-one
-tags: [typescript, patterns]
-created: 2025-01-01
-updated: 2025-01-15
----
-
-Content here...
-```
-
-### 3. Run dev server
-
-```bash
-# Point to this repo's own learn docs (if they exist)
-DOCS_DIR=../../../docs/learn npm run dev
-
-# Or point to any other project's docs
-DOCS_DIR=/path/to/your/project/docs/learn npm run dev
-```
-
-App runs at `http://localhost:3333`.
-
-> **Note:** `npm run dev` does not rebuild the Pagefind search index. If you've previously run `npm run build`, search will still work but uses the old index — new or edited docs won't appear in search results until you build again.
-
-### 4. Full build (with search)
-
-```bash
-DOCS_DIR=/path/to/docs npm run build
-npx next start -p 3333
-```
-
-`postbuild` runs `pagefind` to index docs for full-text search.
-
-## Structure
-
-```
-src/
-├── app/
-│   ├── page.tsx                   # Homepage: recent docs, categories, tags
-│   ├── [category]/page.tsx        # Category listing
-│   ├── [category]/[slug]/page.tsx # Individual doc
-│   └── layout.tsx
-├── components/
-│   ├── MarkdownRenderer.tsx       # Renders .md with syntax highlighting
-│   ├── TableOfContents.tsx        # Auto-generated from headings
-│   ├── Sidebar.tsx                # Category navigation
-│   ├── PagefindSearch.tsx         # Full-text search (build-time index)
-│   └── ThemeToggle.tsx
-└── lib/
-    ├── docs.ts                    # getAllDocs, getDocBySlug, etc.
-    └── types.ts
-```
-
-## How It Fits Together
-
-```
-cf learn host [path]
-  └─ resolves docs dir
-  └─ npm install (one-time)
-  └─ npm run build  (with DOCS_DIR env)
-  └─ npx next start -p 3333  (with DOCS_DIR env)
-```
-
-ISR (Incremental Static Regeneration) is enabled, so new or edited docs appear on the next page refresh without a rebuild.

package/lib/learn-host/eslint.config.mjs

@@ -1,6 +0,0 @@
-import nextConfig from "eslint-config-next";
-import eslintConfigPrettier from "eslint-config-prettier";
-
-const eslintConfig = [...nextConfig, eslintConfigPrettier];
-
-export default eslintConfig;