coding-friend-cli 1.16.0 → 1.17.0

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

@@ -0,0 +1,62 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { MemoryBackend } from "../lib/backend.js";
+
+export function registerAllResources(
+  server: McpServer,
+  backend: MemoryBackend,
+): void {
+  // memory://index — browse all memories
+  server.registerResource(
+    "memory-index",
+    "memory://index",
+    {
+      title: "Memory Index",
+      description: "Browse all stored memories with titles, types, and tags",
+      mimeType: "application/json",
+    },
+    async (uri) => {
+      const metas = await backend.list({});
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            text: JSON.stringify(
+              metas.map((m) => ({
+                id: m.id,
+                title: m.frontmatter.title,
+                description: m.frontmatter.description,
+                type: m.frontmatter.type,
+                tags: m.frontmatter.tags,
+                updated: m.frontmatter.updated,
+              })),
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    },
+  );
+
+  // memory://stats — storage statistics
+  server.registerResource(
+    "memory-stats",
+    "memory://stats",
+    {
+      title: "Memory Stats",
+      description: "Storage statistics: total count, by category, by type",
+      mimeType: "application/json",
+    },
+    async (uri) => {
+      const stats = await backend.stats();
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            text: JSON.stringify(stats, null, 2),
+          },
+        ],
+      };
+    },
+  );
+}

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

@@ -0,0 +1,20 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { MemoryBackend } from "./lib/backend.js";
+import { registerStore } from "./tools/store.js";
+import { registerSearch } from "./tools/search.js";
+import { registerRetrieve } from "./tools/retrieve.js";
+import { registerList } from "./tools/list.js";
+import { registerUpdate } from "./tools/update.js";
+import { registerDelete } from "./tools/delete.js";
+
+export function registerAllTools(
+  server: McpServer,
+  backend: MemoryBackend,
+): void {
+  registerStore(server, backend);
+  registerSearch(server, backend);
+  registerRetrieve(server, backend);
+  registerList(server, backend);
+  registerUpdate(server, backend);
+  registerDelete(server, backend);
+}

package/lib/cf-memory/src/tools/delete.ts

@@ -0,0 +1,38 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { MemoryBackend } from "../lib/backend.js";
+
+export function registerDelete(
+  server: McpServer,
+  backend: MemoryBackend,
+): void {
+  server.tool(
+    "memory_delete",
+    "Delete a memory by ID.",
+    {
+      id: z.string().describe("Memory ID (e.g. features/auth-pattern)"),
+    },
+    async ({ id }) => {
+      const deleted = await backend.delete(id);
+      if (!deleted) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify({ error: "Memory not found", id }),
+            },
+          ],
+          isError: true,
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: JSON.stringify({ id, deleted: true }, null, 2),
+          },
+        ],
+      };
+    },
+  );
+}

package/lib/cf-memory/src/tools/list.ts

@@ -0,0 +1,38 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { MemoryBackend } from "../lib/backend.js";
+import { MEMORY_TYPES } from "../lib/types.js";
+
+export function registerList(server: McpServer, backend: MemoryBackend): void {
+  server.tool(
+    "memory_list",
+    "List memories with optional filtering by type or category.",
+    {
+      type: z.enum(MEMORY_TYPES).optional().describe("Filter by memory type"),
+      category: z.string().optional().describe("Filter by category folder"),
+      limit: z.number().optional().describe("Max results, default 50"),
+    },
+    async ({ type, category, limit }) => {
+      const metas = await backend.list({ type, category, limit });
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: JSON.stringify(
+              metas.map((m) => ({
+                id: m.id,
+                title: m.frontmatter.title,
+                description: m.frontmatter.description,
+                type: m.frontmatter.type,
+                tags: m.frontmatter.tags,
+                updated: m.frontmatter.updated,
+              })),
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    },
+  );
+}

package/lib/cf-memory/src/tools/retrieve.ts

@@ -0,0 +1,52 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { MemoryBackend } from "../lib/backend.js";
+
+export function registerRetrieve(
+  server: McpServer,
+  backend: MemoryBackend,
+): void {
+  server.tool(
+    "memory_retrieve",
+    "Retrieve a specific memory by ID (format: category/slug).",
+    {
+      id: z.string().describe("Memory ID (e.g. features/auth-pattern)"),
+    },
+    async ({ id }) => {
+      const memory = await backend.retrieve(id);
+      if (!memory) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify({ error: "Memory not found", id }),
+            },
+          ],
+          isError: true,
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: JSON.stringify(
+              {
+                id: memory.id,
+                title: memory.frontmatter.title,
+                description: memory.frontmatter.description,
+                type: memory.frontmatter.type,
+                tags: memory.frontmatter.tags,
+                importance: memory.frontmatter.importance,
+                created: memory.frontmatter.created,
+                updated: memory.frontmatter.updated,
+                content: memory.content,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    },
+  );
+}

package/lib/cf-memory/src/tools/search.ts

@@ -0,0 +1,47 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { MemoryBackend } from "../lib/backend.js";
+import { MEMORY_TYPES } from "../lib/types.js";
+
+export function registerSearch(
+  server: McpServer,
+  backend: MemoryBackend,
+): void {
+  server.tool(
+    "memory_search",
+    "Search memories by query. Returns ranked results matching title, description, tags, or content.",
+    {
+      query: z.string().describe("Search query"),
+      type: z.enum(MEMORY_TYPES).optional().describe("Filter by memory type"),
+      tags: z
+        .array(z.string())
+        .optional()
+        .describe("Filter by tags (OR match)"),
+      limit: z.number().optional().describe("Max results, default 10"),
+    },
+    async ({ query, type, tags, limit }) => {
+      const results = await backend.search({ query, type, tags, limit });
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: JSON.stringify(
+              results.map((r) => ({
+                id: r.memory.id,
+                title: r.memory.frontmatter.title,
+                description: r.memory.frontmatter.description,
+                type: r.memory.frontmatter.type,
+                tags: r.memory.frontmatter.tags,
+                score: r.score,
+                matchedOn: r.matchedOn,
+                excerpt: r.memory.excerpt,
+              })),
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    },
+  );
+}

package/lib/cf-memory/src/tools/store.ts

@@ -0,0 +1,70 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { MemoryBackend } from "../lib/backend.js";
+import { MEMORY_TYPES } from "../lib/types.js";
+import { checkDuplicate } from "../lib/dedup.js";
+
+export function registerStore(server: McpServer, backend: MemoryBackend): void {
+  server.tool(
+    "memory_store",
+    "Store a new memory. Provide title, description, type, tags, and content.",
+    {
+      title: z.string().describe("Memory title"),
+      description: z
+        .string()
+        .describe("One-line searchable summary, under 100 chars"),
+      type: z.enum(MEMORY_TYPES).describe("Memory type"),
+      tags: z.array(z.string()).describe("3-5 keyword tags"),
+      content: z.string().describe("Markdown content (without frontmatter)"),
+      importance: z
+        .number()
+        .min(1)
+        .max(5)
+        .optional()
+        .describe("Importance 1-5, default 3"),
+      source: z
+        .string()
+        .optional()
+        .describe("Source: conversation, auto-capture, manual"),
+    },
+    async ({ title, description, type, tags, content, importance, source }) => {
+      const input = {
+        title,
+        description,
+        type,
+        tags,
+        content,
+        importance,
+        source,
+      };
+
+      let dedup: Awaited<ReturnType<typeof checkDuplicate>> | null = null;
+      try {
+        dedup = await checkDuplicate(backend, input);
+      } catch {
+        // Dedup is best-effort — don't block store on search errors
+      }
+
+      const memory = await backend.store(input);
+
+      const response: Record<string, unknown> = {
+        id: memory.id,
+        title: memory.frontmatter.title,
+        stored: true,
+      };
+
+      if (dedup?.isDuplicate) {
+        response.warning = `Near-duplicate found: ${dedup.similarId} (similarity: ${dedup.similarity.toFixed(2)}). Memory stored anyway.`;
+      }
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: JSON.stringify(response, null, 2),
+          },
+        ],
+      };
+    },
+  );
+}

package/lib/cf-memory/src/tools/update.ts

@@ -0,0 +1,62 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { MemoryBackend } from "../lib/backend.js";
+
+export function registerUpdate(
+  server: McpServer,
+  backend: MemoryBackend,
+): void {
+  server.tool(
+    "memory_update",
+    "Update an existing memory. Provide the ID and fields to update. Content is appended.",
+    {
+      id: z.string().describe("Memory ID (e.g. features/auth-pattern)"),
+      title: z.string().optional().describe("New title"),
+      description: z.string().optional().describe("New description"),
+      tags: z
+        .array(z.string())
+        .optional()
+        .describe("Tags to add (merged with existing)"),
+      content: z.string().optional().describe("Content to append to existing"),
+      importance: z
+        .number()
+        .min(1)
+        .max(5)
+        .optional()
+        .describe("New importance"),
+    },
+    async ({ id, title, description, tags, content, importance }) => {
+      const memory = await backend.update({
+        id,
+        title,
+        description,
+        tags,
+        content,
+        importance,
+      });
+      if (!memory) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify({ error: "Memory not found", id }),
+            },
+          ],
+          isError: true,
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: JSON.stringify(
+              { id: memory.id, title: memory.frontmatter.title, updated: true },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    },
+  );
+}

package/lib/cf-memory/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

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

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

package/lib/learn-host/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog (Learn Host)
 
+## v0.2.2 (2026-03-16)
+
+- Improve `cf init` to be more interactive with step-by-step guided setup ([#d5bbc9c](https://github.com/dinhanhthi/coding-friend/commit/d5bbc9c))
+
 ## v0.2.1 (2026-03-05)
 
 - Fix TOC heading text stripping markdown links from slug generation ([#9a8fb5c](https://github.com/dinhanhthi/coding-friend/commit/9a8fb5c))

package/lib/learn-host/package.json

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

package/package.json

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