coding-friend-cli 1.21.1 → 1.23.0

package/dist/{uninstall-RJ6SBB76.js → uninstall-OXWRPWYF.js}

@@ -5,10 +5,10 @@ import {
 import {
   hasShellCompletion,
   removeShellCompletion
-} from "./chunk-PYTEAC6K.js";
+} from "./chunk-DMJCO6LJ.js";
 import {
   resolveScope
-} from "./chunk-BIX7AJU3.js";
+} from "./chunk-O4CNZB5H.js";
 import {
   commandExists,
   run
@@ -25,8 +25,9 @@ import {
   marketplaceClonePath
 } from "./chunk-DO6FV6BL.js";
 import {
-  log
-} from "./chunk-W5CD7WTX.js";
+  log,
+  printBanner
+} from "./chunk-NREZK463.js";
 
 // src/commands/uninstall.ts
 import { existsSync, rmSync } from "fs";
@@ -118,8 +119,8 @@ async function uninstallScoped(scope) {
   log.dim("Restart Claude Code to complete the uninstall.");
 }
 async function uninstallCommand(opts = {}) {
-  console.log(`
-=== \u{1F44B} ${chalk.red("Coding Friend Uninstall")} \u{1F44B} ===`);
+  console.log();
+  printBanner("\u{1F44B} Coding Friend Uninstall \u{1F44B}", { color: chalk.red });
   if (!commandExists("claude")) {
     log.error("Claude CLI not found. Cannot uninstall plugin without it.");
     log.dim(

package/dist/{update-536C3YG7.js → update-6N7EASFT.js}

@@ -4,15 +4,15 @@ import {
   getLatestVersion,
   semverCompare,
   updateCommand
-} from "./chunk-PDVSGGH6.js";
+} from "./chunk-2ETE7NEL.js";
 import "./chunk-TRIALFOQ.js";
 import "./chunk-PRIH34UB.js";
-import "./chunk-PYTEAC6K.js";
-import "./chunk-BIX7AJU3.js";
+import "./chunk-DMJCO6LJ.js";
+import "./chunk-O4CNZB5H.js";
 import "./chunk-EVGXUDX4.js";
 import "./chunk-5UVDWG5L.js";
 import "./chunk-DO6FV6BL.js";
-import "./chunk-W5CD7WTX.js";
+import "./chunk-NREZK463.js";
 export {
   getCliVersion,
   getLatestCliVersion,

package/dist/{update-check-L5TNWT2J.js → update-check-XSETLRVR.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-DO6FV6BL.js";
 import {
   log
-} from "./chunk-W5CD7WTX.js";
+} from "./chunk-NREZK463.js";
 
 // src/lib/update-check.ts
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";

package/lib/cf-memory/README.md

@@ -229,6 +229,8 @@ node dist/daemon/entry.js ./docs/memory 1800000 --tier=lite
 
 The daemon runs a Hono HTTP server on a Unix Domain Socket at `~/.coding-friend/memory/daemon.sock`, with PID tracking at `~/.coding-friend/memory/daemon.pid`.
 
+**Auto-reconnect:** If the daemon dies (e.g., idle timeout expires), the `DaemonClient` automatically respawns it on the next request. This means mid-session daemon restarts are transparent — no manual intervention needed.
+
 ### Lazy dependencies (Tier 1)
 
 Heavy dependencies for Tier 1 (SQLite + embeddings) are installed on-demand into `~/.coding-friend/memory/node_modules/`, not in this package's `node_modules/`. These include:
@@ -302,6 +304,7 @@ If these are missing, `cf memory init` will fail at the "Installing SQLite depen
 | ----------------------------- | ------------------------ | ------------------------------------------------- |
 | `MEMORY_DOCS_DIR`             | `./docs/memory`          | Path to memory storage directory                  |
 | `MEMORY_TIER`                 | `auto`                   | Force a tier: `auto`, `full`, `lite`, `markdown`  |
+| `MEMORY_DAEMON_IDLE_TIMEOUT`  | `1800000` (30 min)       | Daemon idle timeout in ms (`0` = never auto-stop) |
 | `MEMORY_EMBEDDING_PROVIDER`   | `transformers`           | Embedding provider: `transformers` or `ollama`    |
 | `MEMORY_EMBEDDING_MODEL`      | (provider default)       | Embedding model name (e.g., `nomic-embed-text`)   |
 | `MEMORY_EMBEDDING_OLLAMA_URL` | `http://localhost:11434` | Ollama server URL                                 |
@@ -309,4 +312,4 @@ If these are missing, `cf memory init` will fail at the "Installing SQLite depen
 
 ## Versioning
 
-Part of the [coding-friend](https://github.com/dinhanhthi/coding-friend) monorepo. Tagged independently as `cf-memory-v*`. Changelog: [CHANGELOG.md](./CHANGELOG.md).
+Part of the [coding-friend](https://github.com/dinhanhthi/coding-friend) monorepo. Versioned and released as part of the CLI package. Changelog: [`cli/CHANGELOG.md`](../../CHANGELOG.md).

package/lib/cf-memory/package.json

@@ -1,6 +1,5 @@
 {
   "name": "coding-friend-cf-memory",
-  "version": "0.2.1",
   "private": true,
   "type": "module",
   "bin": {

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

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { DaemonClient } from "../lib/daemon-client.js";
+import { startDaemonServer, type DaemonPaths } from "../daemon/process.js";
+import { MiniSearchBackend } from "../backends/minisearch.js";
+
+let testDir: string;
+let testPaths: DaemonPaths;
+let counter = 0;
+
+beforeEach(() => {
+  testDir = join(tmpdir(), `cf-daemon-client-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("DaemonClient auto-reconnect", () => {
+  it("calls respawn and retries on connection error", async () => {
+    const docsDir = join(testDir, "docs");
+    mkdirSync(docsDir, { recursive: true });
+
+    // Start daemon
+    const backend = new MiniSearchBackend(docsDir);
+    let handle = startDaemonServer(backend, {
+      paths: testPaths,
+      idleTimeoutMs: 0,
+    });
+    await new Promise<void>((resolve) => {
+      handle.server.once("listening", resolve);
+    });
+
+    const respawn = vi.fn(async () => {
+      // Re-create a fresh backend and server on same paths
+      const newBackend = new MiniSearchBackend(docsDir);
+      handle = startDaemonServer(newBackend, {
+        paths: testPaths,
+        idleTimeoutMs: 0,
+      });
+      await new Promise<void>((resolve) => {
+        handle.server.once("listening", resolve);
+      });
+      return true;
+    });
+
+    const client = new DaemonClient(testPaths.socketPath, { respawn });
+
+    // Verify initial connection works
+    const alive = await client.ping();
+    expect(alive).toBe(true);
+
+    // Kill daemon and wait for socket cleanup
+    await new Promise<void>((resolve) => {
+      handle.server.close(() => resolve());
+    });
+    rmSync(testPaths.socketPath, { force: true });
+    rmSync(testPaths.pidFile, { force: true });
+    // Small delay to ensure OS fully releases the socket
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Next request should trigger respawn and succeed
+    const stats = await client.stats();
+    expect(stats.total).toBe(0);
+    expect(respawn).toHaveBeenCalledOnce();
+
+    // Cleanup
+    await new Promise<void>((resolve) => {
+      handle.server.close(() => resolve());
+    });
+    rmSync(testPaths.socketPath, { force: true });
+    rmSync(testPaths.pidFile, { force: true });
+  });
+
+  it("throws original error when respawn fails", async () => {
+    const respawn = vi.fn(async () => false);
+    const client = new DaemonClient(
+      "/tmp/nonexistent-cf-test-sock-" + Date.now(),
+      { respawn },
+    );
+
+    await expect(client.stats()).rejects.toThrow();
+    expect(respawn).toHaveBeenCalledOnce();
+  });
+
+  it("throws directly without respawn callback", async () => {
+    const client = new DaemonClient(
+      "/tmp/nonexistent-cf-test-sock-" + Date.now(),
+    );
+
+    await expect(client.stats()).rejects.toThrow();
+  });
+
+  it("ping does not trigger respawn", async () => {
+    const respawn = vi.fn(async () => true);
+    const client = new DaemonClient(
+      "/tmp/nonexistent-cf-test-sock-" + Date.now(),
+      { respawn },
+    );
+
+    // ping() should return false without attempting respawn
+    const alive = await client.ping();
+    expect(alive).toBe(false);
+    expect(respawn).not.toHaveBeenCalled();
+  });
+
+  it("does not call respawn for HTTP 4xx errors", async () => {
+    const docsDir = join(testDir, "docs");
+    mkdirSync(docsDir, { recursive: true });
+
+    const backend = new MiniSearchBackend(docsDir);
+    const handle = startDaemonServer(backend, {
+      paths: testPaths,
+      idleTimeoutMs: 0,
+    });
+    await new Promise<void>((resolve) => {
+      handle.server.once("listening", resolve);
+    });
+
+    const respawn = vi.fn(async () => true);
+    const client = new DaemonClient(testPaths.socketPath, { respawn });
+
+    // 404 is not a connection error — should not trigger respawn
+    const result = await client.retrieve("nonexistent/id");
+    expect(result).toBeNull();
+    expect(respawn).not.toHaveBeenCalled();
+
+    await new Promise<void>((resolve) => {
+      handle.server.close(() => resolve());
+    });
+    rmSync(testPaths.socketPath, { force: true });
+    rmSync(testPaths.pidFile, { force: true });
+  });
+});

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

@@ -189,6 +189,9 @@ export async function spawnDaemon(
     model?: string;
     ollamaUrl?: string;
   },
+  opts?: {
+    idleTimeoutMs?: number;
+  },
 ): Promise<{ pid: number } | null> {
   if (await isDaemonRunning()) return null;
 
@@ -201,6 +204,10 @@ export async function spawnDaemon(
   if (!fs.existsSync(entryPath)) return null;
 
   const args = [entryPath, docsDir];
+  // Pass idle timeout as positional arg (entry.js expects it as argv[3])
+  if (opts?.idleTimeoutMs !== undefined) {
+    args.push(String(opts.idleTimeoutMs));
+  }
   if (embeddingConfig?.provider)
     args.push(`--embedding-provider=${embeddingConfig.provider}`);
   if (embeddingConfig?.model)

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

@@ -1,4 +1,6 @@
 import path from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { registerAllTools } from "./server.js";
@@ -7,11 +9,23 @@ import { createBackendForTier } from "./lib/tier.js";
 import type { TierConfig } from "./lib/tier.js";
 import type { EmbeddingConfig } from "./backends/sqlite/embeddings.js";
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const cliPkg = JSON.parse(
+  readFileSync(path.resolve(__dirname, "../../../package.json"), "utf-8"),
+);
+
 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;
 
+// Daemon idle timeout from env (in milliseconds, 0 = disable)
+const idleTimeoutMs = (() => {
+  if (!process.env.MEMORY_DAEMON_IDLE_TIMEOUT) return undefined;
+  const parsed = parseInt(process.env.MEMORY_DAEMON_IDLE_TIMEOUT, 10);
+  return isNaN(parsed) ? undefined : parsed;
+})();
+
 // Embedding config from environment variables
 const embeddingConfig: Partial<EmbeddingConfig> | undefined = (() => {
   const provider = process.env.MEMORY_EMBEDDING_PROVIDER as
@@ -27,10 +41,15 @@ const embeddingConfig: Partial<EmbeddingConfig> | undefined = (() => {
   };
 })();
 
+const daemonOptions =
+  idleTimeoutMs !== undefined ? { idleTimeoutMs } : undefined;
+
 const { backend, tier } = await createBackendForTier(
   docsDir,
   tierConfig,
   embeddingConfig,
+  undefined,
+  daemonOptions,
 );
 
 // Auto-start daemon for file watching (Tier 1 & 2)
@@ -38,12 +57,12 @@ const { backend, tier } = await createBackendForTier(
 // and rebuilds the search index automatically.
 if (tier.name !== "markdown") {
   const { spawnDaemon } = await import("./daemon/process.js");
-  spawnDaemon(docsDir, embeddingConfig).catch(() => {});
+  spawnDaemon(docsDir, embeddingConfig, daemonOptions).catch(() => {});
 }
 
 const server = new McpServer({
   name: "coding-friend-memory",
-  version: "0.0.1",
+  version: cliPkg.version,
 });
 
 registerAllTools(server, backend);

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

@@ -11,13 +11,32 @@ import type {
   UpdateInput,
 } from "./types.js";
 
+export interface DaemonClientOptions {
+  /** Called to respawn the daemon when a connection fails. */
+  respawn?: () => Promise<boolean>;
+}
+
 /**
  * MemoryBackend implementation that talks to the daemon over UDS.
+ *
+ * When a `respawn` callback is provided, connection errors automatically
+ * trigger a single respawn attempt followed by a retry of the original request.
  */
 export class DaemonClient implements MemoryBackend {
-  constructor(private socketPath: string) {}
+  private respawn?: () => Promise<boolean>;
+
+  constructor(
+    private socketPath: string,
+    opts?: DaemonClientOptions,
+  ) {
+    this.respawn = opts?.respawn;
+  }
 
-  private request<T>(method: string, path: string, body?: unknown): Promise<T> {
+  private rawRequest<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+  ): Promise<T> {
     return new Promise((resolve, reject) => {
       const options: http.RequestOptions = {
         socketPath: this.socketPath,
@@ -68,6 +87,27 @@ export class DaemonClient implements MemoryBackend {
     });
   }
 
+  /**
+   * Send a request to the daemon. On connection error (ECONNREFUSED, ENOENT),
+   * attempt to respawn the daemon once and retry.
+   */
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+  ): Promise<T> {
+    try {
+      return await this.rawRequest<T>(method, path, body);
+    } catch (err) {
+      if (!this.respawn || !isConnectionError(err)) throw err;
+
+      const ok = await this.respawn();
+      if (!ok) throw err;
+
+      return this.rawRequest<T>(method, path, body);
+    }
+  }
+
   async store(input: StoreInput): Promise<Memory> {
     const result = await this.request<{
       id: string;
@@ -143,7 +183,11 @@ export class DaemonClient implements MemoryBackend {
    */
   async ping(): Promise<boolean> {
     try {
-      const result = await this.request<{ status: string }>("GET", "/health");
+      // Use rawRequest — ping checks liveness, must not trigger respawn
+      const result = await this.rawRequest<{ status: string }>(
+        "GET",
+        "/health",
+      );
       return result.status === "ok";
     } catch {
       return false;
@@ -161,3 +205,10 @@ export class DaemonClient implements MemoryBackend {
     }
   }
 }
+
+/** Connection-level errors that indicate the daemon process is gone. */
+function isConnectionError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  const code = (err as NodeJS.ErrnoException).code;
+  return code === "ECONNREFUSED" || code === "ENOENT" || code === "ECONNRESET";
+}

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

@@ -1,7 +1,11 @@
 import type { MemoryBackend } from "./backend.js";
 import { DaemonClient } from "./daemon-client.js";
 import { MarkdownBackend } from "../backends/markdown.js";
-import { getDaemonPaths, isDaemonRunning } from "../daemon/process.js";
+import {
+  getDaemonPaths,
+  isDaemonRunning,
+  spawnDaemon,
+} from "../daemon/process.js";
 import { areSqliteDepsAvailable } from "./lazy-install.js";
 import type { EmbeddingConfig } from "../backends/sqlite/embeddings.js";
 import type { SqliteBackendOptions } from "../backends/sqlite/index.js";
@@ -46,6 +50,20 @@ export async function detectTier(configTier?: TierConfig): Promise<TierInfo> {
   return TIERS.markdown;
 }
 
+/** Build a respawn callback that DaemonClient can call when the daemon is gone. */
+function makeRespawn(
+  docsDir: string,
+  embeddingConfig?: Partial<EmbeddingConfig>,
+  idleTimeoutMs?: number,
+): () => Promise<boolean> {
+  return async () => {
+    const result = await spawnDaemon(docsDir, embeddingConfig, {
+      idleTimeoutMs,
+    });
+    return result !== null;
+  };
+}
+
 /**
  * Create the appropriate backend for the detected tier.
  */
@@ -54,8 +72,14 @@ export async function createBackendForTier(
   configTier?: TierConfig,
   embeddingConfig?: Partial<EmbeddingConfig>,
   sqliteOptions?: Pick<SqliteBackendOptions, "dbPath">,
+  daemonOptions?: { idleTimeoutMs?: number },
 ): Promise<{ backend: MemoryBackend; tier: TierInfo }> {
   const tier = await detectTier(configTier);
+  const respawn = makeRespawn(
+    docsDir,
+    embeddingConfig,
+    daemonOptions?.idleTimeoutMs,
+  );
 
   switch (tier.name) {
     case "full": {
@@ -71,7 +95,7 @@ export async function createBackendForTier(
         // SQLite backend failed — fall through to daemon or markdown
         if (await isDaemonRunning()) {
           const paths = getDaemonPaths();
-          const client = new DaemonClient(paths.socketPath);
+          const client = new DaemonClient(paths.socketPath, { respawn });
           const alive = await client.ping();
           if (alive) {
             return { backend: client, tier: TIERS.lite };
@@ -86,7 +110,7 @@ export async function createBackendForTier(
     case "lite": {
       // Use daemon client
       const paths = getDaemonPaths();
-      const client = new DaemonClient(paths.socketPath);
+      const client = new DaemonClient(paths.socketPath, { respawn });
       const alive = await client.ping();
       if (alive) {
         return { backend: client, tier };

package/lib/learn-host/package.json

@@ -1,6 +1,5 @@
 {
   "name": "coding-friend-learn-host",
-  "version": "0.3.0",
   "private": true,
   "scripts": {
     "dev": "next dev -p 3333",

package/lib/learn-mcp/package.json

@@ -1,6 +1,5 @@
 {
   "name": "coding-friend-learn-mcp",
-  "version": "0.0.3",
   "private": true,
   "type": "module",
   "bin": {

package/lib/learn-mcp/src/index.ts

@@ -1,4 +1,6 @@
 import path from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { registerAllTools } from "./server.js";
@@ -6,9 +8,14 @@ import { registerAllTools } from "./server.js";
 const rawDir = process.argv[2] ?? process.env.LEARN_DOCS_DIR ?? "./docs/learn";
 const docsDir = path.resolve(rawDir);
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const cliPkg = JSON.parse(
+  readFileSync(path.resolve(__dirname, "../../../package.json"), "utf-8"),
+);
+
 const server = new McpServer({
   name: "coding-friend-learn",
-  version: "0.0.3",
+  version: cliPkg.version,
 });
 
 registerAllTools(server, docsDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coding-friend-cli",
-  "version": "1.21.1",
+  "version": "1.23.0",
   "description": "CLI for coding-friend — host learning docs, setup MCP server, initialize projects",
   "type": "module",
   "bin": {

package/dist/chunk-W5CD7WTX.js

@@ -1,15 +0,0 @@
-// src/lib/log.ts
-import chalk from "chalk";
-var log = {
-  info: (msg) => console.log(chalk.blue("\u2139"), msg),
-  success: (msg) => console.log(chalk.green("\u2714"), msg),
-  congrats: (msg) => console.log(chalk.green("\u{1F389}"), msg),
-  warn: (msg) => console.log(chalk.yellow("\u26A0"), msg),
-  error: (msg) => console.log(chalk.red("\u2716"), msg),
-  step: (msg) => console.log(chalk.cyan("\u2192"), msg),
-  dim: (msg) => console.log(chalk.dim(msg))
-};
-
-export {
-  log
-};

package/dist/mcp-U34LFD34.js

@@ -1,106 +0,0 @@
-import {
-  resolveDocsDir
-} from "./chunk-SIQJPT47.js";
-import {
-  getLibPath
-} from "./chunk-RZRT7NGT.js";
-import "./chunk-PRIH34UB.js";
-import {
-  run
-} from "./chunk-EVGXUDX4.js";
-import "./chunk-5UVDWG5L.js";
-import "./chunk-DO6FV6BL.js";
-import {
-  log
-} from "./chunk-W5CD7WTX.js";
-
-// src/commands/mcp.ts
-import { existsSync, readdirSync } from "fs";
-import { join } from "path";
-import chalk from "chalk";
-function countMdFiles(dir) {
-  let count = 0;
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (entry.isDirectory()) {
-      count += countMdFiles(join(dir, entry.name));
-    } else if (entry.name.endsWith(".md") && entry.name !== "README.md") {
-      count++;
-    }
-  }
-  return count;
-}
-async function mcpCommand(path) {
-  const docsDir = resolveDocsDir(path);
-  const mcpDir = getLibPath("learn-mcp");
-  if (!existsSync(docsDir)) {
-    log.error(`Docs folder not found: ${docsDir}`);
-    log.dim("Run /cf-learn first to generate some docs.");
-    process.exit(1);
-  }
-  const docCount = countMdFiles(docsDir);
-  if (docCount === 0) {
-    log.error(`No .md files found in ${docsDir}`);
-    log.dim("Run /cf-learn first to generate some docs.");
-    process.exit(1);
-  }
-  console.log("=== \u{1F33F} Coding Friend MCP \u{1F33F} ===");
-  log.info(`Docs folder: ${chalk.cyan(docsDir)}`);
-  log.info(`Found: ${chalk.green(docCount)} docs`);
-  console.log();
-  if (!existsSync(join(mcpDir, "node_modules"))) {
-    log.step("Installing MCP server dependencies (one-time setup)...");
-    const result = run("npm", ["install", "--silent"], { cwd: mcpDir });
-    if (result === null) {
-      log.error("Failed to install dependencies");
-      process.exit(1);
-    }
-    log.success("Done.");
-  }
-  if (!existsSync(join(mcpDir, "dist"))) {
-    log.step("Building MCP server...");
-    const result = run("npm", ["run", "build", "--silent"], { cwd: mcpDir });
-    if (result === null) {
-      log.error("Failed to build MCP server");
-      process.exit(1);
-    }
-    log.success("Done.");
-  }
-  console.log();
-  const serverPath = join(mcpDir, "dist", "index.js");
-  console.log(`Add this to your MCP client config:
-
---- Claude Desktop / Claude Chat (claude_desktop_config.json) ---
-
-{
-  "mcpServers": {
-    "coding-friend-learn": {
-      "command": "node",
-      "args": ["${serverPath}", "${docsDir}"]
-    }
-  }
-}
-
---- Generic MCP client ---
-
-Server command: node ${serverPath} ${docsDir}
-Transport: stdio
-
---- Available tools ---
-
-Read:
-  list-categories    List all categories with doc counts
-  list-docs          List docs, filter by category/tag
-  read-doc           Read full content of a doc
-  search-docs        Full-text search across all docs
-  get-review-list    Docs that need review
-
-Write:
-  create-doc         Create new learning doc
-  update-doc         Append content or update tags
-  improve-doc        Get improvement suggestions
-  track-knowledge    Record understanding level (remembered/needs-review/new)
-`);
-}
-export {
-  mcpCommand
-};