@fredrika/mcp-mochi 1.0.0 → 1.0.2

package/README.md

@@ -114,7 +114,7 @@ To use this with Claude Desktop, add the following to your `claude_desktop_confi
 ```json
 {
   "mcpServers": {
-    "github": {
+    "mochi": {
       "command": "docker",
       "args": [
         "run",
@@ -137,11 +137,11 @@ To use this with Claude Desktop, add the following to your `claude_desktop_confi
 ```json
 {
   "mcpServers": {
-    "github": {
+    "mochi": {
       "command": "npx",
       "args": [
         "-y",
-        "@modelcontextprotocol/server-github"
+        "@fredrika/mcp-mochi"
       ],
       "env": {
         "MOCHI_API_KEY": "<YOUR_TOKEN>"

package/dist/common/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "1.0.2";

package/dist/common/version.js

@@ -0,0 +1,3 @@
+// If the format of this file changes, so it doesn't simply export a VERSION constant,
+// this will break .github/workflows/version-check.yml.
+export const VERSION = "1.0.2";

package/dist/index.d.ts

@@ -4,11 +4,8 @@ declare const CreateCardRequestSchema: z.ZodObject<{
     content: z.ZodString;
     "deck-id": z.ZodString;
     "template-id": z.ZodOptional<z.ZodString>;
-    archived: z.ZodOptional<z.ZodBoolean>;
-    "review-reverse": z.ZodOptional<z.ZodBoolean>;
-    pos: z.ZodOptional<z.ZodString>;
     "manual-tags": z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         value: z.ZodString;
     }, "strip", z.ZodTypeAny, {
@@ -17,31 +14,62 @@ declare const CreateCardRequestSchema: z.ZodObject<{
     }, {
         id: string;
         value: string;
-    }>>>;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     content: string;
     "deck-id": string;
+    fields: Record<string, {
+        id: string;
+        value: string;
+    }>;
+    "template-id"?: string | undefined;
+    "manual-tags"?: string[] | undefined;
+}, {
+    content: string;
+    "deck-id": string;
+    fields: Record<string, {
+        id: string;
+        value: string;
+    }>;
     "template-id"?: string | undefined;
-    archived?: boolean | undefined;
-    "review-reverse"?: boolean | undefined;
-    pos?: string | undefined;
     "manual-tags"?: string[] | undefined;
+}>;
+declare const UpdateCardRequestSchema: z.ZodObject<{
+    content: z.ZodOptional<z.ZodString>;
+    "deck-id": z.ZodOptional<z.ZodString>;
+    "template-id": z.ZodOptional<z.ZodString>;
+    "archived?": z.ZodOptional<z.ZodBoolean>;
+    "trashed?": z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        value: string;
+    }, {
+        id: string;
+        value: string;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    content?: string | undefined;
+    "deck-id"?: string | undefined;
+    "template-id"?: string | undefined;
     fields?: Record<string, {
         id: string;
         value: string;
     }> | undefined;
+    "archived?"?: boolean | undefined;
+    "trashed?"?: string | undefined;
 }, {
-    content: string;
-    "deck-id": string;
+    content?: string | undefined;
+    "deck-id"?: string | undefined;
     "template-id"?: string | undefined;
-    archived?: boolean | undefined;
-    "review-reverse"?: boolean | undefined;
-    pos?: string | undefined;
-    "manual-tags"?: string[] | undefined;
     fields?: Record<string, {
         id: string;
         value: string;
     }> | undefined;
+    "archived?"?: boolean | undefined;
+    "trashed?"?: string | undefined;
 }>;
 declare const ListDecksParamsSchema: z.ZodObject<{
     bookmark: z.ZodOptional<z.ZodString>;
@@ -63,54 +91,134 @@ declare const ListCardsParamsSchema: z.ZodObject<{
     bookmark?: string | undefined;
     limit?: number | undefined;
 }>;
-type ListCardsParams = z.infer<typeof ListCardsParamsSchema>;
-type ListDecksParams = z.infer<typeof ListDecksParamsSchema>;
-type CreateCardRequest = z.infer<typeof CreateCardRequestSchema>;
-declare const CreateCardResponseSchema: z.ZodObject<{
-    status: z.ZodString;
-    error_message: z.ZodOptional<z.ZodString>;
+declare const ListTemplatesParamsSchema: z.ZodObject<{
+    bookmark: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    status: string;
-    error_message?: string | undefined;
+    bookmark?: string | undefined;
 }, {
-    status: string;
-    error_message?: string | undefined;
+    bookmark?: string | undefined;
 }>;
-declare const ListDecksResponseSchema: z.ZodObject<{
+declare const ListTemplatesResponseSchema: z.ZodObject<{
     bookmark: z.ZodString;
     docs: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        sort: z.ZodNumber;
         name: z.ZodString;
-        archived: z.ZodOptional<z.ZodBoolean>;
+        content: z.ZodString;
+        pos: z.ZodString;
+        fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            pos: z.ZodString;
+            options: z.ZodOptional<z.ZodObject<{
+                "multi-line?": z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                "multi-line?"?: boolean | undefined;
+            }, {
+                "multi-line?"?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
-        sort: number;
         name: string;
         id: string;
-        archived?: boolean | undefined;
+        content: string;
+        fields: Record<string, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }>;
+        pos: string;
     }, {
-        sort: number;
         name: string;
         id: string;
-        archived?: boolean | undefined;
+        content: string;
+        fields: Record<string, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }>;
+        pos: string;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     bookmark: string;
     docs: {
-        sort: number;
         name: string;
         id: string;
-        archived?: boolean | undefined;
+        content: string;
+        fields: Record<string, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }>;
+        pos: string;
     }[];
 }, {
     bookmark: string;
     docs: {
-        sort: number;
         name: string;
         id: string;
-        archived?: boolean | undefined;
+        content: string;
+        fields: Record<string, {
+            name: string;
+            id: string;
+            pos: string;
+            options?: {
+                "multi-line?"?: boolean | undefined;
+            } | undefined;
+        }>;
+        pos: string;
     }[];
 }>;
+type ListTemplatesParams = z.infer<typeof ListTemplatesParamsSchema>;
+type ListTemplatesResponse = z.infer<typeof ListTemplatesResponseSchema>;
+type ListCardsParams = z.infer<typeof ListCardsParamsSchema>;
+type ListDecksParams = z.infer<typeof ListDecksParamsSchema>;
+type CreateCardRequest = z.infer<typeof CreateCardRequestSchema>;
+type UpdateCardRequest = z.infer<typeof UpdateCardRequestSchema>;
+declare const CreateCardResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    tags: z.ZodArray<z.ZodString, "many">;
+    content: z.ZodString;
+    name: z.ZodString;
+    "deck-id": z.ZodString;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    content: string;
+    "deck-id": string;
+    tags: string[];
+    fields?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    id: string;
+    content: string;
+    "deck-id": string;
+    tags: string[];
+    fields?: Record<string, unknown> | undefined;
+}>;
 declare const ListCardsResponseSchema: z.ZodObject<{
     bookmark: z.ZodString;
     docs: z.ZodArray<z.ZodObject<{
@@ -119,43 +227,21 @@ declare const ListCardsResponseSchema: z.ZodObject<{
         content: z.ZodString;
         name: z.ZodString;
         "deck-id": z.ZodString;
-        fields: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        pos: z.ZodString;
-        references: z.ZodArray<z.ZodUnknown, "many">;
-        reviews: z.ZodArray<z.ZodUnknown, "many">;
-        "created-at": z.ZodObject<{
-            date: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            date: string;
-        }, {
-            date: string;
-        }>;
+        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         id: string;
         content: string;
         "deck-id": string;
-        pos: string;
-        fields: Record<string, unknown>;
         tags: string[];
-        references: unknown[];
-        reviews: unknown[];
-        "created-at": {
-            date: string;
-        };
+        fields?: Record<string, unknown> | undefined;
     }, {
         name: string;
         id: string;
         content: string;
         "deck-id": string;
-        pos: string;
-        fields: Record<string, unknown>;
         tags: string[];
-        references: unknown[];
-        reviews: unknown[];
-        "created-at": {
-            date: string;
-        };
+        fields?: Record<string, unknown> | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     bookmark: string;
@@ -164,14 +250,8 @@ declare const ListCardsResponseSchema: z.ZodObject<{
         id: string;
         content: string;
         "deck-id": string;
-        pos: string;
-        fields: Record<string, unknown>;
         tags: string[];
-        references: unknown[];
-        reviews: unknown[];
-        "created-at": {
-            date: string;
-        };
+        fields?: Record<string, unknown> | undefined;
     }[];
 }, {
     bookmark: string;
@@ -180,25 +260,56 @@ declare const ListCardsResponseSchema: z.ZodObject<{
         id: string;
         content: string;
         "deck-id": string;
-        pos: string;
-        fields: Record<string, unknown>;
         tags: string[];
-        references: unknown[];
-        reviews: unknown[];
-        "created-at": {
-            date: string;
-        };
+        fields?: Record<string, unknown> | undefined;
     }[];
 }>;
 type CreateCardResponse = z.infer<typeof CreateCardResponseSchema>;
-type ListDecksResponse = z.infer<typeof ListDecksResponseSchema>;
+type ListDecksResponse = z.infer<typeof ListDecksResponseSchema>["docs"];
 type ListCardsResponse = z.infer<typeof ListCardsResponseSchema>;
+declare const ListDecksResponseSchema: z.ZodObject<{
+    bookmark: z.ZodString;
+    docs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sort: z.ZodNumber;
+        name: z.ZodString;
+        archived: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        sort: number;
+        name: string;
+        id: string;
+        archived?: boolean | undefined;
+    }, {
+        sort: number;
+        name: string;
+        id: string;
+        archived?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    bookmark: string;
+    docs: {
+        sort: number;
+        name: string;
+        id: string;
+        archived?: boolean | undefined;
+    }[];
+}, {
+    bookmark: string;
+    docs: {
+        sort: number;
+        name: string;
+        id: string;
+        archived?: boolean | undefined;
+    }[];
+}>;
 export declare class MochiClient {
     private api;
     private token;
     constructor(token: string);
     createCard(request: CreateCardRequest): Promise<CreateCardResponse>;
+    updateCard(cardId: string, request: UpdateCardRequest): Promise<CreateCardResponse>;
     listDecks(params?: ListDecksParams): Promise<ListDecksResponse>;
     listCards(params?: ListCardsParams): Promise<ListCardsResponse>;
+    listTemplates(params?: ListTemplatesParams): Promise<ListTemplatesResponse>;
 }
 export {};

package/dist/index.js

@@ -5,6 +5,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import dotenv from "dotenv";
 import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
 dotenv.config();
 /**
  * Custom error class for Mochi API errors
@@ -34,10 +35,15 @@ const CreateCardRequestSchema = z.object({
     content: z.string().min(1),
     "deck-id": z.string().min(1),
     "template-id": z.string().optional(),
-    archived: z.boolean().optional(),
-    "review-reverse": z.boolean().optional(),
-    pos: z.string().optional(),
     "manual-tags": z.array(z.string()).optional(),
+    fields: z.record(z.string(), CreateCardFieldSchema),
+});
+const UpdateCardRequestSchema = z.object({
+    content: z.string().optional(),
+    "deck-id": z.string().optional(),
+    "template-id": z.string().optional(),
+    "archived?": z.boolean().optional(),
+    "trashed?": z.string().optional(),
     fields: z.record(z.string(), CreateCardFieldSchema).optional(),
 });
 const ListDecksParamsSchema = z.object({
@@ -48,27 +54,35 @@ const ListCardsParamsSchema = z.object({
     limit: z.number().min(1).max(100).optional(),
     bookmark: z.string().optional(),
 });
-// Response Zod schemas
-const CreateCardResponseSchema = z
-    .object({
-    status: z.string(),
-    error_message: z.string().optional(),
-})
-    .strip();
-const DeckSchema = z
+const ListTemplatesParamsSchema = z.object({
+    bookmark: z.string().optional(),
+});
+const TemplateFieldSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    pos: z.string(),
+    options: z
+        .object({
+        "multi-line?": z.boolean().optional(),
+    })
+        .optional(),
+});
+const TemplateSchema = z
     .object({
     id: z.string(),
-    sort: z.number(),
     name: z.string(),
-    archived: z.boolean().optional(),
+    content: z.string(),
+    pos: z.string(),
+    fields: z.record(z.string(), TemplateFieldSchema),
 })
     .strip();
-const ListDecksResponseSchema = z
+const ListTemplatesResponseSchema = z
     .object({
     bookmark: z.string(),
-    docs: z.array(DeckSchema),
+    docs: z.array(TemplateSchema),
 })
     .strip();
+// Response Zod schemas
 const CardSchema = z
     .object({
     id: z.string(),
@@ -76,21 +90,30 @@ const CardSchema = z
     content: z.string(),
     name: z.string(),
     "deck-id": z.string(),
-    fields: z.record(z.unknown()),
-    pos: z.string(),
-    references: z.array(z.unknown()),
-    reviews: z.array(z.unknown()),
-    "created-at": z.object({
-        date: z.string(),
-    }),
+    fields: z.record(z.unknown()).optional(),
 })
     .strip();
+const CreateCardResponseSchema = CardSchema.strip();
 const ListCardsResponseSchema = z
     .object({
     bookmark: z.string(),
     docs: z.array(CardSchema),
 })
     .strip();
+const DeckSchema = z
+    .object({
+    id: z.string(),
+    sort: z.number(),
+    name: z.string(),
+    archived: z.boolean().optional(),
+})
+    .strip();
+const ListDecksResponseSchema = z
+    .object({
+    bookmark: z.string(),
+    docs: z.array(DeckSchema),
+})
+    .strip();
 function getApiKey() {
     const apiKey = process.env.MOCHI_API_KEY;
     if (!apiKey) {
@@ -100,59 +123,6 @@ function getApiKey() {
     return apiKey;
 }
 const MOCHI_API_KEY = getApiKey();
-// Tool definitions
-const CREATE_CARD_TOOL = {
-    name: "mochi_create_card",
-    description: "Create a new flashcard",
-    inputSchema: {
-        type: "object",
-        properties: {
-            content: {
-                type: "string",
-                description: "The markdown content of the card. Separate front from back with `\n---\n`",
-            },
-            "deck-id": {
-                type: "string",
-                description: "The deck ID that the card belongs too.",
-            },
-        },
-        required: ["content", "deck-id"],
-    },
-};
-const LIST_CARDS_TOOL = {
-    name: "mochi_list_cards",
-    description: "List cards in pages of 10 cards per page",
-    inputSchema: {
-        type: "object",
-        properties: {
-            "deck-id": {
-                type: "string",
-                description: "Only return cards for the specified deck ID",
-            },
-            limit: {
-                type: "number",
-                description: "Number of cards to return per page (1-100, default 10)",
-            },
-            bookmark: {
-                type: "string",
-                description: "Cursor for pagination from a previous list request",
-            },
-        },
-    },
-};
-const LIST_DECKS_TOOL = {
-    name: "mochi_list_decks",
-    description: "List all decks",
-    inputSchema: {
-        type: "object",
-        properties: {},
-    },
-};
-const MOCHI_TOOLS = [
-    CREATE_CARD_TOOL,
-    LIST_CARDS_TOOL,
-    LIST_DECKS_TOOL,
-];
 export class MochiClient {
     api;
     token;
@@ -170,12 +140,16 @@ export class MochiClient {
         const response = await this.api.post("/cards", request);
         return CreateCardResponseSchema.parse(response.data);
     }
+    async updateCard(cardId, request) {
+        const response = await this.api.post(`/cards/${cardId}`, request);
+        return CreateCardResponseSchema.parse(response.data);
+    }
     async listDecks(params) {
         const validatedParams = params
             ? ListDecksParamsSchema.parse(params)
             : undefined;
         const response = await this.api.get("/decks", { params: validatedParams });
-        return ListDecksResponseSchema.parse(response.data);
+        return ListDecksResponseSchema.parse(response.data).docs.filter((deck) => !deck.archived);
     }
     async listCards(params) {
         const validatedParams = params
@@ -184,11 +158,20 @@ export class MochiClient {
         const response = await this.api.get("/cards", { params: validatedParams });
         return ListCardsResponseSchema.parse(response.data);
     }
+    async listTemplates(params) {
+        const validatedParams = params
+            ? ListTemplatesParamsSchema.parse(params)
+            : undefined;
+        const response = await this.api.get("/templates", {
+            params: validatedParams,
+        });
+        return ListTemplatesResponseSchema.parse(response.data);
+    }
 }
 // Server setup
 const server = new Server({
     name: "mcp-server/mochi",
-    version: "0.1.0",
+    version: "1.0.2",
 }, {
     capabilities: {
         tools: {},
@@ -197,59 +180,267 @@ const server = new Server({
 });
 // Set up request handlers
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: MOCHI_TOOLS,
+    tools: [
+        {
+            name: "mochi_create_card",
+            description: `Create a new flashcard in Mochi. Use this whenever I ask questions about something that is interesting to remember. E.g. if I ask "What is the capital of France?", you should create a new flashcard with the content "What is the capital of France?\n---\nParis".
+
+## Parameters
+
+### deck-id (required)
+ALWAYS look up deck-id with the mochi_list_decks tool.
+
+### content (required)
+The markdown content of the card. Separate front and back using a horizontal rule (---).
+
+### fields (optional)
+A map of field IDs (keyword) to field values. The field IDs should correspond to the fields defined on the template used by the card.
+
+## Example
+{
+  "content": "New card from API. ![](@media/foobar03.png)",
+  "deck-id": "btmZUXWM",
+  "template-id": "8BtaEAXe",
+  "fields": {
+    "name": {
+      "id": "name",
+      "value": "Hello,"
+    },
+    "JNEnw1e7": {
+      "id": "JNEnw1e7",
+      "value": "World!"
+    },
+  },
+}
+
+## Good cards:
+- **concise**: as short question and answer as possible.
+- **focused:** A question or answer involving too much detail will dull your concentration and stimulate incomplete retrievals, leaving some bulbs unlit.
+- **precise** about what they're asking for. Vague questions will elicit vague answers, which won't reliably light the bulbs you're targeting.
+- **consistent** answers, lighting the same bulbs each time you perform the task.
+- **tractable**: Write prompts which you can almost always answer correctly. This often means breaking the task down, or adding cues
+- **effortful**: You shouldn't be able to trivially infer the answer.
+`,
+            inputSchema: zodToJsonSchema(CreateCardRequestSchema),
+            annotations: {
+                title: "Create flashcard on Mochi",
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+        },
+        {
+            name: "mochi_update_card",
+            description: `Update an existing flashcard in Mochi.`,
+            inputSchema: zodToJsonSchema(z.object({
+                "card-id": z.string(),
+                ...UpdateCardRequestSchema.shape,
+            })),
+            annotations: {
+                title: "Update flashcard on Mochi",
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+        },
+        {
+            name: "mochi_list_cards",
+            description: "List cards in pages of 10 cards per page",
+            inputSchema: zodToJsonSchema(ListCardsParamsSchema),
+            annotations: {
+                title: "List flashcards on Mochi",
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+        },
+        {
+            name: "mochi_list_decks",
+            description: "List all decks",
+            inputSchema: zodToJsonSchema(ListDecksParamsSchema),
+            annotations: {
+                title: "List decks on Mochi",
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+        },
+        {
+            name: "mochi_list_templates",
+            description: `Templates can be used to create cards with pre-defined fields using the template_id field. 
+
+Example response:
+{
+  "bookmark": "g1AAAABAeJzLYWBgYMpgSmHgKy5JLCrJTq2MT8lPzkzJBYpzVBn4JgaaVZiC5Dlg8igyWQAxwRHd",
+  "docs": [
+    {
+      "id": "YDELNZSu",
+      "name": "Simple flashcard",
+      "content": "# << Front >>\n---\n<< Back >>",
+      "pos": "s",
+      "fields": {
+        "name": {
+          "id": "name",
+          "name": "Front",
+          "pos": "a"
+        },
+        "Ysrde7Lj": {
+          "id": "Ysrde7Lj",
+          "name": "Back",
+          "pos": "m",
+          "options": {
+            "multi-line?": true
+          }
+        }
+      }
+    },
+    ...
+  ]
+}`,
+            inputSchema: zodToJsonSchema(ListTemplatesParamsSchema),
+            annotations: {
+                title: "List templates on Mochi",
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+        },
+    ],
 }));
+// Create Mochi client
+const mochiClient = new MochiClient(MOCHI_API_KEY);
 // Add resource handlers
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    const decks = await mochiClient.listDecks();
-    return {
-        resources: decks.docs.map((deck) => ({
-            uri: `mochi://decks/${deck.id}`,
-            name: deck.name + ` (Deck ID: ${deck.id})`,
-            description: `Deck ID: ${deck.id}`,
-            mimeType: "application/json",
-        })),
-    };
-});
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const uri = request.params.uri;
-    const match = uri.match(/^mochi:\/\/decks\/(.+)$/);
-    if (!match) {
-        throw new Error("Invalid resource URI");
-    }
-    const deckId = match[1];
-    const deck = await mochiClient.listCards({ "deck-id": deckId });
     return {
-        contents: [
+        resources: [
             {
-                uri,
+                uri: `mochi://decks`,
+                name: "All Mochi Decks",
+                description: `List of all decks in Mochi.`,
+                mimeType: "application/json",
+            },
+            {
+                uri: `mochi://templates`,
+                name: "All Mochi Templates",
+                description: `List of all templates in Mochi.`,
                 mimeType: "application/json",
-                text: JSON.stringify(deck.docs.map((card) => ({
-                    id: card.id,
-                    name: card.name,
-                    content: card.content,
-                    fields: card.fields,
-                })), null, 2),
             },
         ],
     };
 });
-// Create Mochi client
-const mochiClient = new MochiClient(MOCHI_API_KEY);
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    switch (uri) {
+        case "mochi://decks": {
+            const decks = await mochiClient.listDecks();
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(decks.map((deck) => ({
+                            id: deck.id,
+                            name: deck.name,
+                            archived: deck.archived,
+                        })), null, 2),
+                    },
+                ],
+            };
+        }
+        case "mochi://templates": {
+            const templates = await mochiClient.listTemplates();
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(templates, null, 2),
+                    },
+                ],
+            };
+        }
+        default: {
+            throw new Error("Invalid resource URI");
+        }
+    }
+});
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         switch (request.params.name) {
             case "mochi_create_card": {
                 const validatedArgs = CreateCardRequestSchema.parse(request.params.arguments);
-                return mochiClient.createCard(validatedArgs);
+                const response = await mochiClient.createCard(validatedArgs);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(response, null, 2),
+                        },
+                    ],
+                    isError: false,
+                };
+            }
+            case "mochi_update_card": {
+                const { "card-id": cardId, ...updateArgs } = z
+                    .object({
+                    "card-id": z.string(),
+                    ...UpdateCardRequestSchema.shape,
+                })
+                    .parse(request.params.arguments);
+                const response = await mochiClient.updateCard(cardId, updateArgs);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(response, null, 2),
+                        },
+                    ],
+                    isError: false,
+                };
             }
             case "mochi_list_decks": {
                 const validatedArgs = ListDecksParamsSchema.parse(request.params.arguments);
-                return mochiClient.listDecks(validatedArgs);
+                const response = await mochiClient.listDecks(validatedArgs);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(response, null, 2),
+                        },
+                    ],
+                    isError: false,
+                };
             }
             case "mochi_list_cards": {
                 const validatedArgs = ListCardsParamsSchema.parse(request.params.arguments);
-                return mochiClient.listCards(validatedArgs);
+                const response = await mochiClient.listCards(validatedArgs);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(response, null, 2),
+                        },
+                    ],
+                    isError: false,
+                };
+            }
+            case "mochi_list_templates": {
+                const validatedArgs = ListTemplatesParamsSchema.parse(request.params.arguments);
+                const response = await mochiClient.listTemplates(validatedArgs);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(response, null, 2),
+                        },
+                    ],
+                    isError: false,
+                };
             }
             default:
                 return {
@@ -265,13 +456,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
     catch (error) {
         if (error instanceof z.ZodError) {
+            const formattedErrors = error.errors.map((err) => {
+                const path = err.path.join(".");
+                const message = err.code === "invalid_type" && err.message.includes("Required")
+                    ? `Required field '${path}' is missing`
+                    : err.message;
+                return `${path ? `${path}: ` : ""}${message}`;
+            });
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Validation error: ${error.errors
-                            .map((e) => e.message)
-                            .join(", ")}`,
+                        text: `Validation error:\n${formattedErrors.join("\n")}`,
                     },
                 ],
                 isError: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fredrika/mcp-mochi",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "MCP server for Mochi flashcard integration",
   "main": "dist/index.js",
   "type": "module",
@@ -15,7 +15,7 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "ts-node-esm src/index.ts",
-    "dev:inspect": "npx @modelcontextprotocol/inspector ts-node-esm src/mochi.ts",
+    "dev:inspect": "npx @modelcontextprotocol/inspector ts-node-esm src/index.ts",
     "test": "jest",
     "prepublishOnly": "npm run build"
   },

package/dist/mochi-client.d.ts

@@ -1,74 +0,0 @@
-export interface Flashcard {
-    id: string;
-    name: string;
-    content: string;
-    tags: string[];
-    'deck-id': string;
-    fields: Record<string, unknown>;
-    pos: string;
-    references: unknown[];
-    reviews: unknown[];
-    'created-at': {
-        date: string;
-    };
-}
-export interface FlashcardInput {
-    front: string;
-    back: string;
-    tags?: string[];
-}
-export interface ReviewResult {
-    success: boolean;
-    timeSpentMs: number;
-}
-export interface ListFlashcardsParams {
-    'deck-id'?: string;
-    limit?: number;
-    bookmark?: string;
-}
-export interface ListFlashcardsResponse {
-    bookmark: string;
-    docs: Flashcard[];
-}
-export interface TemplateField {
-    id: string;
-    name: string;
-    pos: string;
-    options?: {
-        'multi-line?'?: boolean;
-    };
-}
-export interface Template {
-    id: string;
-    name: string;
-    content: string;
-    pos: string;
-    fields: Record<string, TemplateField>;
-}
-export interface ListTemplatesResponse {
-    bookmark: string;
-    docs: Template[];
-}
-export interface ListTemplatesParams {
-    bookmark?: string;
-}
-export declare class MochiClient {
-    private api;
-    private token;
-    constructor(token: string);
-    getFlashcards(params?: ListFlashcardsParams): Promise<ListFlashcardsResponse>;
-    getFlashcard(id: string): Promise<Flashcard>;
-    createFlashcard(input: FlashcardInput): Promise<Flashcard>;
-    updateFlashcard(id: string, input: Partial<FlashcardInput>): Promise<Flashcard>;
-    deleteFlashcard(id: string): Promise<void>;
-    getDueFlashcards(): Promise<Flashcard[]>;
-    reviewFlashcard(id: string, result: ReviewResult): Promise<Flashcard>;
-    getStats(): Promise<{
-        totalCards: number;
-        dueCards: number;
-        averageSuccessRate: number;
-        cardsReviewedToday: number;
-    }>;
-    getTemplate(id: string): Promise<Template>;
-    listTemplates(params?: ListTemplatesParams): Promise<ListTemplatesResponse>;
-}

package/dist/mochi-client.js

@@ -1,67 +0,0 @@
-import axios from 'axios';
-export class MochiClient {
-    api;
-    token;
-    constructor(token) {
-        this.token = '228b69396efc60896d3033e3';
-        this.api = axios.create({
-            baseURL: 'https://app.mochi.cards/api/',
-            headers: {
-                'Authorization': `Basic ${Buffer.from(`${this.token}:`).toString('base64')}`,
-                'Content-Type': 'application/json'
-            }
-        });
-    }
-    async getFlashcards(params) {
-        try {
-            const response = await this.api.get('/cards', { params });
-            console.log(response.data);
-            return response.data;
-        }
-        catch (error) {
-            console.error('Error fetching flashcards:', error);
-            throw error;
-        }
-    }
-    async getFlashcard(id) {
-        const response = await this.api.get(`/cards/${id}`);
-        return response.data;
-    }
-    async createFlashcard(input) {
-        const response = await this.api.post('/cards', input);
-        return response.data;
-    }
-    async updateFlashcard(id, input) {
-        const response = await this.api.patch(`/cards/${id}`, input);
-        return response.data;
-    }
-    async deleteFlashcard(id) {
-        await this.api.delete(`/cards/${id}`);
-    }
-    async getDueFlashcards() {
-        const response = await this.api.get('/cards');
-        return response.data;
-    }
-    async reviewFlashcard(id, result) {
-        const response = await this.api.post(`/cards/${id}/review`, result);
-        return response.data;
-    }
-    async getStats() {
-        const response = await this.api.get('/v1/stats');
-        return response.data;
-    }
-    async getTemplate(id) {
-        const response = await this.api.get(`/templates/${id}`);
-        return response.data;
-    }
-    async listTemplates(params) {
-        try {
-            const response = await this.api.get('/templates', { params });
-            return response.data;
-        }
-        catch (error) {
-            console.error('Error fetching templates:', error);
-            throw error;
-        }
-    }
-}

package/dist/test-mochi-api.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test-mochi-api.js

@@ -1,69 +0,0 @@
-import axios from 'axios';
-import { MochiClient } from './mochi-client.js';
-import { config } from 'dotenv';
-// Load environment variables
-config();
-const MOCHI_TOKEN = process.env.MOCHI_TOKEN;
-if (!MOCHI_TOKEN) {
-    throw new Error("MOCHI_TOKEN environment variable is required");
-}
-// After the check above, TypeScript knows MOCHI_TOKEN is defined
-const token = MOCHI_TOKEN;
-async function testMochiApi() {
-    console.log("Testing Mochi API connection...");
-    console.log("Using token:", token.slice(0, 5) + "..." + token.slice(-5));
-    const client = new MochiClient(token);
-    try {
-        // Test getting stats (simplest operation)
-        console.log("\nTesting getStats...");
-        const stats = await client.getStats();
-        console.log("Stats response:", stats);
-        // Test getting flashcards
-        console.log("\nTesting getFlashcards...");
-        const cards = await client.getFlashcards();
-        console.log("Flashcards response:", cards);
-        // Test creating a flashcard
-        console.log("\nTesting createFlashcard...");
-        const newCard = await client.createFlashcard({
-            front: "Test Front",
-            back: "Test Back",
-            tags: ["test"]
-        });
-        console.log("Created card:", newCard);
-        // Test getting a specific flashcard
-        console.log("\nTesting getFlashcard...");
-        const card = await client.getFlashcard(newCard.id);
-        console.log("Retrieved card:", card);
-        // Test updating the flashcard
-        console.log("\nTesting updateFlashcard...");
-        const updatedCard = await client.updateFlashcard(newCard.id, {
-            front: "Updated Front"
-        });
-        console.log("Updated card:", updatedCard);
-        // Test deleting the flashcard
-        console.log("\nTesting deleteFlashcard...");
-        await client.deleteFlashcard(newCard.id);
-        console.log("Card deleted successfully");
-    }
-    catch (error) {
-        console.error("Error testing Mochi API:", error);
-        if (axios.isAxiosError(error)) {
-            const axiosError = error;
-            if (axiosError.response) {
-                console.error("Response status:", axiosError.response.status);
-                console.error("Response data:", axiosError.response.data);
-                console.error("Response headers:", axiosError.response.headers);
-                console.error("Request URL:", axiosError.config?.url);
-                console.error("Request method:", axiosError.config?.method);
-            }
-            else if (axiosError.request) {
-                console.error("No response received. Request details:", axiosError.request);
-            }
-            else {
-                console.error("Error setting up request:", axiosError.message);
-            }
-        }
-    }
-}
-// Run the test
-testMochiApi().catch(console.error);