@ankimcp/anki-mcp-server 0.8.0

package/dist/mcp/primitives/essential/prompts/twenty-rules.prompt/content.md

@@ -0,0 +1,195 @@
+# Description
+
+Twenty rules of formulating knowledge for effective Anki flashcard creation based on Dr. Piotr Wozniak's SuperMemo research
+
+# Content
+
+*Based on "Twenty Rules of Formulating Knowledge" by Dr. Piotr Wozniak: https://www.supermemo.com/en/blog/twenty-rules-of-formulating-knowledge*
+
+You are helping a user create effective Anki flashcards based on Dr. Piotr Wozniak's "Twenty Rules of Formulating Knowledge" from SuperMemo research. These principles dramatically improve retention and reduce study time.
+
+## Core Principles
+
+### 1. Do Not Learn If You Do Not Understand
+**Before creating any flashcard, ensure the user understands the concept.**
+- Ask clarifying questions if the topic seems unclear
+- Don't create cards from material the user hasn't comprehended
+- Suggest breaking down complex topics into understandable chunks first
+
+### 2. Learn Before You Memorize - Build the Big Picture First
+**Context before details. Overview before memorization.**
+- When user wants to learn a new topic, suggest understanding the overall structure first
+- Example: Before creating cards about React hooks, ensure they understand React's component model
+- Create foundational cards before advanced ones
+
+### 3. Build Upon the Basics
+**Never skip fundamentals. Simple before complex.**
+- Identify prerequisite knowledge
+- Suggest creating basic cards first, then build complexity
+- Example: Learn addition before multiplication, HTTP before REST APIs
+
+### 4. Stick to the Minimum Information Principle
+**CRITICAL: Each card should test ONE piece of information.**
+- ❌ BAD: "What are the three main features of React and how do they work?"
+- ✅ GOOD: Three separate cards, each testing one feature
+- Break complex cards into atomic units
+- Simpler cards = faster reviews = better retention
+
+### 5. Cloze Deletion is Easy and Effective
+**Use fill-in-the-blank format extensively.**
+- Convert statements into cloze deletions
+- Example: "The capital of {{c1::France}} is {{c2::Paris}}"
+- Particularly effective for facts, definitions, and relationships
+- Multiple clozes per card are OK if they test the same context
+
+### 6. Use Imagery - Visual Memory is Powerful
+**Add images whenever possible.**
+- "A picture is worth a thousand words"
+- Suggest adding relevant images for:
+  - Geography, anatomy, architecture
+  - Historical figures, artworks
+  - Diagrams for abstract concepts
+- Use the mediaActions tool to help users add images
+
+### 7. Use Mnemonic Techniques
+**Memory aids make retention easier.**
+- Suggest mnemonics for difficult items
+- Use acronyms (e.g., "PEMDAS" for math order of operations)
+- Create vivid, memorable associations
+- Link abstract concepts to concrete images
+
+### 8. Avoid Sets - They're Difficult to Memorize
+**Large lists are memory killers.**
+- ❌ BAD: "List all 50 US state capitals"
+- ✅ GOOD: Convert to cloze deletions or enumerated questions
+- If a set is necessary, break it into overlapping subsets
+- Use enumerations with context cues
+
+### 9. Avoid Enumerations When Possible
+**Lists are harder than single facts.**
+- Instead of "What are the 7 principles of X?", create 7 separate cards
+- If enumeration is necessary:
+  - Use cloze deletion: "The 7 principles are: {{c1::principle1}}, {{c2::principle2}}..."
+  - Add context and memory aids
+  - Keep lists short (max 5-7 items)
+
+### 10. Combat Interference - Make Items Distinct
+**Similar cards cause confusion.**
+- Avoid creating nearly identical cards
+- Make distinctions explicit
+- Add context to differentiate similar concepts
+- Example for similar countries:
+  - ❌ "Capital of Guyana?" and "Capital of Suriname?" (too similar)
+  - ✅ Add distinguishing features: "Capital of Guyana (only English-speaking country in South America)?"
+
+### 11. Optimize Wording - Keep It Simple and Clear
+**Shorter, simpler wording = faster reviews.**
+- Remove unnecessary words
+- Use active voice
+- Make questions unambiguous
+- ❌ "In the context of programming, when considering the various paradigms, what would you say is the main characteristic that defines the functional approach?"
+- ✅ "Functional programming's main characteristic?"
+
+### 12. Refer to Other Memories - Build Connections
+**Connect new knowledge to existing knowledge.**
+- Reference previously learned concepts
+- Build knowledge networks
+- Example: "Like REST but for GraphQL: {{c1::single endpoint}}"
+- Use analogies to familiar concepts
+
+### 13. Personalize and Provide Examples
+**Personal context dramatically improves retention.**
+- Link to user's experiences
+- Use examples from their projects, life, or interests
+- ❌ Generic: "TypeScript interface definition?"
+- ✅ Personal: "TypeScript interface (like the User type in your project)?"
+
+### 14. Rely on Emotional States
+**Emotion enhances memory.**
+- Use vivid, emotionally charged examples when appropriate
+- Link to memorable events or stories
+- Make boring facts interesting with context
+- Example: Instead of dry historical dates, add dramatic context
+
+### 15. Context Cues Simplify Wording
+**Categories and prefixes reduce cognitive load.**
+- Add subject prefixes: "bio:", "hist:", "prog:"
+- Use tags effectively
+- Group related cards in decks
+- Example: "js: Array method for filtering?" (context cue: "js:")
+
+### 16. Redundancy Can Be Beneficial
+**Some repetition from different angles helps.**
+- Create multiple cards for critical concepts from different angles
+- Test the same fact in different contexts
+- Balance with "don't overdo it"
+
+### 17. Provide Sources and References
+**Context helps understanding and future reference.**
+- Add source information in card metadata or extra field
+- Link to documentation, books, or articles
+- Helps when reviewing old cards
+
+### 18. Prioritize - Learn What Matters Most
+**Not everything deserves a flashcard.**
+- Focus on applicable, useful knowledge
+- Ask: "Will I actually need to recall this?"
+- Quality over quantity
+
+## Workflow for Creating Cards
+
+1. **Understand First**: Verify user understands the concept
+2. **Build Context**: Ensure foundational knowledge exists
+3. **Apply Minimum Information**: Break into atomic facts
+4. **Choose Format**: Prefer cloze deletion for facts, Q&A for concepts
+5. **Optimize Wording**: Make it clear, concise, unambiguous
+6. **Add Richness**: Images, mnemonics, personal connections
+7. **Review**: Check for interference with existing cards
+
+## When User Asks to Create Cards
+
+1. Ask about their understanding of the topic
+2. Suggest the number and type of cards (don't just create them)
+3. Show examples of proposed cards
+4. Wait for approval before creating
+5. Apply these rules to make cards effective
+6. Use addNote tool only after user confirms
+
+## Example Transformations
+
+### Example 1: Complex → Simple
+❌ **Bad Card**:
+Q: "What are the main differences between REST and GraphQL APIs and when would you use each?"
+A: [Long paragraph explaining both]
+
+✅ **Good Cards** (4 separate cards):
+1. "REST uses {{c1::multiple endpoints}}, GraphQL uses {{c2::single endpoint}}"
+2. "GraphQL advantage over REST: {{c1::client specifies exact data needed}}"
+3. "REST advantage over GraphQL: {{c1::simpler caching}} and {{c2::better tooling support}}"
+4. "Use GraphQL when: {{c1::client needs flexible queries}} and {{c2::reducing over-fetching matters}}"
+
+### Example 2: Generic → Personal
+❌ **Bad Card**:
+Q: "What is a closure in JavaScript?"
+A: "A function that has access to outer function variables"
+
+✅ **Good Card**:
+Q: "js: Closure definition (like in your React hooks code)?"
+A: "Function that remembers variables from its outer scope even after outer function returns"
+
+### Example 3: Adding Visual Memory
+❌ **Text Only**:
+Q: "Structure of the human heart?"
+A: [Text description]
+
+✅ **With Image**:
+Q: [Image of heart with blank labels]
+A: [Same image with labels visible]
+(Use mediaActions to help user add the image)
+
+## Remember
+
+**Quality > Quantity**: Five well-formed cards beat twenty poorly made ones.
+**Atomic Knowledge**: One fact per card, always.
+**User Context**: Personalize everything you can.
+**Understanding First**: Never create cards from material the user doesn't understand.

package/dist/mcp/primitives/essential/prompts/twenty-rules.prompt/index.d.ts

@@ -0,0 +1,12 @@
+export declare class TwentyRulesPrompt {
+    getTwentyRulesPrompt(): {
+        description: string;
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+}

package/dist/mcp/primitives/essential/prompts/twenty-rules.prompt/index.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwentyRulesPrompt = void 0;
+const common_1 = require("@nestjs/common");
+const mcp_nest_1 = require("@rekog/mcp-nest");
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const markdown_utils_1 = require("../../../../utils/markdown.utils");
+const PROMPT_SECTIONS = (() => {
+    const markdownPath = path.join(__dirname, "content.md");
+    const markdown = fs.readFileSync(markdownPath, "utf-8");
+    return (0, markdown_utils_1.parseMarkdownSections)(markdown);
+})();
+let TwentyRulesPrompt = class TwentyRulesPrompt {
+    getTwentyRulesPrompt() {
+        return {
+            description: PROMPT_SECTIONS.Description ||
+                "Twenty rules of formulating knowledge for effective Anki flashcard creation",
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: PROMPT_SECTIONS.Content || "",
+                    },
+                },
+            ],
+        };
+    }
+};
+exports.TwentyRulesPrompt = TwentyRulesPrompt;
+__decorate([
+    (0, mcp_nest_1.Prompt)({
+        name: "twenty_rules",
+        description: PROMPT_SECTIONS.Description ||
+            "Twenty rules of formulating knowledge for effective Anki flashcard creation",
+        parameters: zod_1.z.object({}),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TwentyRulesPrompt.prototype, "getTwentyRulesPrompt", null);
+exports.TwentyRulesPrompt = TwentyRulesPrompt = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST })
+], TwentyRulesPrompt);
+//# sourceMappingURL=index.js.map

package/dist/mcp/primitives/essential/prompts/twenty-rules.prompt/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../src/mcp/primitives/essential/prompts/twenty-rules.prompt/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2CAAmD;AACnD,8CAAyC;AACzC,6BAAwB;AACxB,uCAAyB;AACzB,2CAA6B;AAC7B,qEAAmE;AAInE,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE;IAC5B,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IACxD,MAAM,QAAQ,GAAG,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;IACxD,OAAO,IAAA,sCAAqB,EAAC,QAAQ,CAAC,CAAC;AACzC,CAAC,CAAC,EAAE,CAAC;AAGE,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;IAQ5B,oBAAoB;QAClB,OAAO;YACL,WAAW,EACT,eAAe,CAAC,WAAW;gBAC3B,6EAA6E;YAC/E,QAAQ,EAAE;gBACR;oBACE,IAAI,EAAE,MAAM;oBACZ,OAAO,EAAE;wBACP,IAAI,EAAE,MAAM;wBACZ,IAAI,EAAE,eAAe,CAAC,OAAO,IAAI,EAAE;qBACpC;iBACF;aACF;SACF,CAAC;IACJ,CAAC;CACF,CAAA;AAxBY,8CAAiB;AAQ5B;IAPC,IAAA,iBAAM,EAAC;QACN,IAAI,EAAE,cAAc;QACpB,WAAW,EACT,eAAe,CAAC,WAAW;YAC3B,6EAA6E;QAC/E,UAAU,EAAE,OAAC,CAAC,MAAM,CAAC,EAAE,CAAC;KACzB,CAAC;;;;6DAgBD;4BAvBU,iBAAiB;IAD7B,IAAA,mBAAU,EAAC,EAAE,KAAK,EAAE,cAAK,CAAC,OAAO,EAAE,CAAC;GACxB,iBAAiB,CAwB7B"}

package/dist/mcp/primitives/essential/resources/system-info.resource.d.ts

@@ -0,0 +1,21 @@
+export declare class SystemInfoResource {
+    getSystemInfo({ uri }: {
+        uri: string;
+    }): {
+        contents: {
+            uri: string;
+            mimeType: string;
+            text: string;
+        }[];
+    };
+    getEnvironmentVariable({ uri, name }: {
+        uri: string;
+        name: string;
+    }): {
+        contents: {
+            uri: string;
+            mimeType: string;
+            text: string;
+        }[];
+    };
+}

package/dist/mcp/primitives/essential/resources/system-info.resource.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemInfoResource = void 0;
+const common_1 = require("@nestjs/common");
+const mcp_nest_1 = require("@rekog/mcp-nest");
+const os = __importStar(require("os"));
+let SystemInfoResource = class SystemInfoResource {
+    getSystemInfo({ uri }) {
+        const systemInfo = {
+            platform: os.platform(),
+            release: os.release(),
+            type: os.type(),
+            arch: os.arch(),
+            cpus: os.cpus().length,
+            totalMemory: `${Math.round(os.totalmem() / (1024 * 1024 * 1024))} GB`,
+            freeMemory: `${Math.round(os.freemem() / (1024 * 1024 * 1024))} GB`,
+            uptime: `${Math.round(os.uptime() / 3600)} hours`,
+            hostname: os.hostname(),
+            nodeVersion: process.version,
+            env: {
+                NODE_ENV: process.env.NODE_ENV || "development",
+            },
+        };
+        return {
+            contents: [
+                {
+                    uri: uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify(systemInfo, null, 2),
+                },
+            ],
+        };
+    }
+    getEnvironmentVariable({ uri, name }) {
+        const value = process.env[name.toUpperCase()] || "undefined";
+        return {
+            contents: [
+                {
+                    uri: uri,
+                    mimeType: "text/plain",
+                    text: value,
+                },
+            ],
+        };
+    }
+};
+exports.SystemInfoResource = SystemInfoResource;
+__decorate([
+    (0, mcp_nest_1.Resource)({
+        name: "system-info",
+        description: "Current system information and environment",
+        mimeType: "application/json",
+        uri: "system://info",
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], SystemInfoResource.prototype, "getSystemInfo", null);
+__decorate([
+    (0, mcp_nest_1.ResourceTemplate)({
+        name: "environment-variable",
+        description: "Get a specific environment variable",
+        mimeType: "text/plain",
+        uriTemplate: "env://{name}",
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], SystemInfoResource.prototype, "getEnvironmentVariable", null);
+exports.SystemInfoResource = SystemInfoResource = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST })
+], SystemInfoResource);
+//# sourceMappingURL=system-info.resource.js.map

package/dist/mcp/primitives/essential/resources/system-info.resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-info.resource.js","sourceRoot":"","sources":["../../../../../src/mcp/primitives/essential/resources/system-info.resource.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2CAAmD;AACnD,8CAA6D;AAC7D,uCAAyB;AAGlB,IAAM,kBAAkB,GAAxB,MAAM,kBAAkB;IAO7B,aAAa,CAAC,EAAE,GAAG,EAAmB;QACpC,MAAM,UAAU,GAAG;YACjB,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE;YACvB,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE;YACrB,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE;YACf,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE;YACf,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,MAAM;YACtB,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,KAAK;YACrE,UAAU,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,KAAK;YACnE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,QAAQ;YACjD,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE;YACvB,WAAW,EAAE,OAAO,CAAC,OAAO;YAC5B,GAAG,EAAE;gBACH,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,aAAa;aAChD;SACF,CAAC;QAEF,OAAO;YACL,QAAQ,EAAE;gBACR;oBACE,GAAG,EAAE,GAAG;oBACR,QAAQ,EAAE,kBAAkB;oBAC5B,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;iBAC1C;aACF;SACF,CAAC;IACJ,CAAC;IAQD,sBAAsB,CAAC,EAAE,GAAG,EAAE,IAAI,EAAiC;QACjE,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,WAAW,CAAC;QAE7D,OAAO;YACL,QAAQ,EAAE;gBACR;oBACE,GAAG,EAAE,GAAG;oBACR,QAAQ,EAAE,YAAY;oBACtB,IAAI,EAAE,KAAK;iBACZ;aACF;SACF,CAAC;IACJ,CAAC;CACF,CAAA;AAtDY,gDAAkB;AAO7B;IANC,IAAA,mBAAQ,EAAC;QACR,IAAI,EAAE,aAAa;QACnB,WAAW,EAAE,4CAA4C;QACzD,QAAQ,EAAE,kBAAkB;QAC5B,GAAG,EAAE,eAAe;KACrB,CAAC;;;;uDA2BD;AAQD;IANC,IAAA,2BAAgB,EAAC;QAChB,IAAI,EAAE,sBAAsB;QAC5B,WAAW,EAAE,qCAAqC;QAClD,QAAQ,EAAE,YAAY;QACtB,WAAW,EAAE,cAAc;KAC5B,CAAC;;;;gEAaD;6BArDU,kBAAkB;IAD9B,IAAA,mBAAU,EAAC,EAAE,KAAK,EAAE,cAAK,CAAC,OAAO,EAAE,CAAC;GACxB,kBAAkB,CAsD9B"}

package/dist/mcp/primitives/essential/tools/add-note.tool.d.ts

@@ -0,0 +1,93 @@
+import type { Context } from "@rekog/mcp-nest";
+import { AnkiConnectClient } from "@/mcp/clients/anki-connect.client";
+export declare class AddNoteTool {
+    private readonly ankiClient;
+    private readonly logger;
+    constructor(ankiClient: AnkiConnectClient);
+    addNote({ deckName, modelName, fields, tags, allowDuplicate, duplicateScope, duplicateScopeOptions, }: {
+        deckName: string;
+        modelName: string;
+        fields: Record<string, string>;
+        tags?: string[];
+        allowDuplicate?: boolean;
+        duplicateScope?: "deck" | "collection";
+        duplicateScopeOptions?: {
+            deckName?: string;
+            checkChildren?: boolean;
+            checkAllModels?: boolean;
+        };
+    }, context: Context): Promise<{
+        [x: string]: unknown;
+        content: ({
+            [x: string]: unknown;
+            type: "text";
+            text: string;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            [x: string]: unknown;
+            type: "image";
+            data: string;
+            mimeType: string;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            [x: string]: unknown;
+            type: "audio";
+            data: string;
+            mimeType: string;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            [x: string]: unknown;
+            type: "resource_link";
+            name: string;
+            uri: string;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            mimeType?: string | undefined;
+            title?: string | undefined;
+            description?: string | undefined;
+            icons?: {
+                [x: string]: unknown;
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+            }[] | undefined;
+        } | {
+            [x: string]: unknown;
+            type: "resource";
+            resource: {
+                [x: string]: unknown;
+                text: string;
+                uri: string;
+                _meta?: {
+                    [x: string]: unknown;
+                } | undefined;
+                mimeType?: string | undefined;
+            } | {
+                [x: string]: unknown;
+                uri: string;
+                blob: string;
+                _meta?: {
+                    [x: string]: unknown;
+                } | undefined;
+                mimeType?: string | undefined;
+            };
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        structuredContent?: {
+            [x: string]: unknown;
+        } | undefined;
+        isError?: boolean | undefined;
+    }>;
+}