anki-mcp-http 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anatoly Tarnavsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,591 @@
+# Anki MCP Desktop
+
+**Beta** - This project is in active development. APIs and features may change.
+
+A Model Context Protocol (MCP) server that enables AI assistants to interact with Anki, the spaced repetition flashcard application.
+
+Transform your Anki experience with natural language interaction - like having a private tutor. The AI assistant doesn't just present questions and answers; it can explain concepts, make the learning process more engaging and human-like, provide context, and adapt to your learning style. It can create and edit notes on the fly, turning your study sessions into dynamic conversations. More features coming soon!
+
+## Examples and Tutorials
+
+For comprehensive guides, real-world examples, and step-by-step tutorials on using this MCP server with Claude Desktop, visit:
+
+**[ankimcp.ai](https://ankimcp.ai)** - Complete documentation with practical examples and use cases
+
+## Available Tools
+
+### Review & Study
+- `sync` - Sync with AnkiWeb
+- `get_due_cards` - Get cards for review
+- `present_card` - Show card for review
+- `rate_card` - Rate card performance
+
+### Deck Management
+- `list_decks` - Show available decks
+- `createDeck` - Create new decks
+
+### Note Management
+- `addNote` - Create new notes
+- `findNotes` - Search for notes using Anki query syntax
+- `notesInfo` - Get detailed information about notes (fields, tags, CSS)
+- `updateNoteFields` - Update existing note fields (CSS-aware, supports HTML)
+- `deleteNotes` - Delete notes and their cards
+
+### Model/Template Management
+- `modelNames` - List note types
+- `modelFieldNames` - Get fields for a note type
+- `modelStyling` - Get CSS styling for a note type
+
+## Prerequisites
+
+- [Anki](https://apps.ankiweb.net/) with [AnkiConnect](https://github.com/FooSoft/anki-connect) plugin installed
+- Node.js 20+
+
+## Installation
+
+This server works in two modes:
+
+- **Local mode (STDIO)** - For Claude Desktop on your computer (recommended for most users)
+- **Remote mode (HTTP)** - For web-based AI assistants like ChatGPT or Claude.ai
+
+### Option 1: MCPB Bundle (Recommended - Local Mode)
+
+The easiest way to install this MCP server for Claude Desktop:
+
+1. Download the latest `.mcpb` bundle from the [Releases](https://github.com/anki-mcp-organization/anki-mcp-desktop/releases) page
+2. In Claude Desktop, install the extension:
+   - **Method 1**: Go to Settings → Extensions, then drag and drop the `.mcpb` file
+   - **Method 2**: Go to Settings → Developer → Extensions → Install Extension, then select the `.mcpb` file
+3. Configure AnkiConnect URL if needed (defaults to `http://localhost:8765`)
+4. Restart Claude Desktop
+
+That's it! The bundle includes everything needed to run the server locally.
+
+### Option 2: HTTP Mode (For Remote AI Assistants)
+
+Want to use Anki with ChatGPT or Claude.ai in your browser? This mode lets you connect web-based AI tools to your local Anki.
+
+**How it works (simple explanation):**
+1. You run a small server on your computer (where Anki is installed)
+2. You use [ngrok](https://ngrok.com) to create a public URL that forwards to your local server
+3. You share that URL with ChatGPT or Claude.ai
+4. Now the AI can talk to your Anki through the internet!
+
+**Setup:**
+
+```bash
+# Quick start (using npx - no installation needed)
+npx anki-mcp-http
+
+# With custom options
+npx anki-mcp-http --port 8080 --host 0.0.0.0
+npx anki-mcp-http --anki-connect http://localhost:8765
+
+# Or install from source
+npm install
+npm run build
+npm run start:prod:http
+```
+
+**CLI Options:**
+
+```bash
+ankimcp [options]
+
+Options:
+  -p, --port <port>              Port to listen on (default: 3000)
+  -h, --host <host>              Host to bind to (default: 127.0.0.1)
+  -a, --anki-connect <url>       AnkiConnect URL (default: http://localhost:8765)
+  --help                         Show help message
+
+Examples:
+  ankimcp                        # Use all defaults
+  ankimcp --port 8080            # Custom port
+  ankimcp --host 0.0.0.0         # Listen on all network interfaces
+```
+
+**Using with ngrok:**
+
+```bash
+# 1. Start ankimcp
+npx anki-mcp-http
+
+# 2. In another terminal, create a tunnel
+ngrok http 3000
+
+# 3. Copy the ngrok URL (looks like: https://abc123.ngrok.io)
+# 4. Share this URL with your AI assistant
+```
+
+**Security note:** Anyone with your ngrok URL can access your Anki, so keep that URL private!
+
+### Option 3: Manual Installation from Source (Local Mode)
+
+For development or advanced usage:
+
+```bash
+npm install
+npm run build
+```
+
+## Connect to Claude Desktop (Local Mode)
+
+You can configure the server in Claude Desktop by either:
+- Going to: Settings → Developer → Edit Config
+- Or manually editing the config file
+
+### Configuration
+
+Add the following to your Claude Desktop config:
+
+```json
+{
+  "mcpServers": {
+    "anki-mcp": {
+      "command": "node",
+      "args": ["/path/to/anki-mcp-desktop/dist/main-stdio.js"],
+      "env": {
+        "ANKI_CONNECT_URL": "http://localhost:8765"
+      }
+    }
+  }
+}
+```
+
+Replace `/path/to/anki-mcp-desktop` with your actual project path.
+
+### Config File Locations
+
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+For more details, see the [official MCP documentation](https://modelcontextprotocol.io/docs/develop/connect-local-servers).
+
+## Environment Variables (Optional)
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `ANKI_CONNECT_URL` | AnkiConnect URL | `http://localhost:8765` |
+| `ANKI_CONNECT_API_VERSION` | API version | `6` |
+| `ANKI_CONNECT_API_KEY` | API key if configured in AnkiConnect | - |
+| `ANKI_CONNECT_TIMEOUT` | Request timeout in ms | `5000` |
+
+## Usage Examples
+
+### Searching and Updating Notes
+
+```
+# Search for notes in a specific deck
+findNotes(query: "deck:Spanish")
+
+# Get detailed information about notes
+notesInfo(notes: [1234567890, 1234567891])
+
+# Update a note's fields (HTML content supported)
+updateNoteFields(note: {
+  id: 1234567890,
+  fields: {
+    "Front": "<b>¿Cómo estás?</b>",
+    "Back": "How are you?"
+  }
+})
+
+# Delete notes (requires confirmation)
+deleteNotes(notes: [1234567890], confirmDeletion: true)
+```
+
+### Anki Query Syntax Examples
+
+The `findNotes` tool supports Anki's powerful query syntax:
+
+- `"deck:DeckName"` - All notes in a specific deck
+- `"tag:important"` - Notes with the "important" tag
+- `"is:due"` - Cards that are due for review
+- `"is:new"` - New cards that haven't been studied
+- `"added:7"` - Notes added in the last 7 days
+- `"front:hello"` - Notes with "hello" in the front field
+- `"flag:1"` - Notes with red flag
+- `"prop:due<=2"` - Cards due within 2 days
+- `"deck:Spanish tag:verb"` - Spanish deck notes with verb tag (AND)
+- `"deck:Spanish OR deck:French"` - Notes from either deck
+
+### Important Notes
+
+#### CSS and HTML Handling
+- The `notesInfo` tool returns CSS styling information for proper rendering awareness
+- The `updateNoteFields` tool supports HTML content in fields and preserves CSS styling
+- Each note model has its own CSS styling - use `modelStyling` to get model-specific CSS
+
+#### Update Warning
+⚠️ **IMPORTANT**: When using `updateNoteFields`, do NOT view the note in Anki's browser while updating, or the fields will not update properly. Close the browser or switch to a different note before updating.
+
+#### Deletion Safety
+The `deleteNotes` tool requires explicit confirmation (`confirmDeletion: true`) to prevent accidental deletions. Deleting a note removes ALL associated cards permanently.
+
+## Development
+
+### Transport Modes
+
+This server supports two MCP transport modes via **separate entry points**:
+
+#### STDIO Mode (Default)
+- For local MCP clients like Claude Desktop
+- Uses standard input/output for communication
+- **Entry point**: `dist/main-stdio.js`
+- **Run**: `npm run start:prod:stdio` or `node dist/main-stdio.js`
+- **MCPB bundle**: Uses STDIO mode
+
+#### HTTP Mode (Streamable HTTP)
+- For remote MCP clients and web-based integrations
+- Uses MCP Streamable HTTP protocol
+- **Entry point**: `dist/main-http.js`
+- **Run**: `npm run start:prod:http` or `node dist/main-http.js`
+- **Default port**: 3000 (configurable via `PORT` env var)
+- **Default host**: `127.0.0.1` (configurable via `HOST` env var)
+- **MCP endpoint**: `http://127.0.0.1:3000/` (root path)
+
+#### Building
+
+```bash
+npm run build  # Builds once, creates dist/ with both entry points
+```
+
+Both `main-stdio.js` and `main-http.js` are in the same `dist/` directory. Choose which to run based on your needs.
+
+#### HTTP Mode Configuration
+
+**Environment Variables:**
+- `PORT` - HTTP server port (default: 3000)
+- `HOST` - Bind address (default: 127.0.0.1 for localhost-only)
+- `ALLOWED_ORIGINS` - Comma-separated list of allowed origins for CORS (default: localhost)
+- `LOG_LEVEL` - Logging level (default: info)
+
+**Security:**
+- Origin header validation (prevents DNS rebinding attacks)
+- Binds to localhost (127.0.0.1) by default
+- No authentication in current version (OAuth support planned)
+
+**Example: Running Modes**
+```bash
+# Development - STDIO mode (watch mode with auto-rebuild)
+npm run start:dev:stdio
+
+# Development - HTTP mode (watch mode with auto-rebuild)
+npm run start:dev:http
+
+# Production - STDIO mode
+npm run start:prod:stdio
+# or
+node dist/main-stdio.js
+
+# Production - HTTP mode
+npm run start:prod:http
+# or
+PORT=8080 HOST=0.0.0.0 node dist/main-http.js
+```
+
+### Building an MCPB Bundle
+
+To create a distributable MCPB bundle:
+
+```bash
+npm run mcpb:bundle
+```
+
+This command will:
+1. Sync version from `package.json` to `manifest.json`
+2. Remove old `.mcpb` files
+3. Build the TypeScript project
+4. Package `dist/` and `node_modules/` into an `.mcpb` file
+
+The output file will be named `anki-mcp-desktop-0.3.0.mcpb` (or current version) and can be distributed for one-click installation.
+
+#### What Gets Bundled
+
+The MCPB package includes:
+- Compiled JavaScript (`dist/` directory - includes both entry points)
+- All dependencies (`node_modules/`)
+- Package metadata (`package.json`)
+- Manifest configuration (`manifest.json` - configured to use `main-stdio.js`)
+- Icon (`icon.png`)
+
+Source files, tests, and development configs are automatically excluded via `.mcpbignore`.
+
+### Logging in Claude Desktop
+
+When running as an MCPB extension in Claude Desktop, logs are written to:
+
+**Log Location**: `~/Library/Logs/Claude/` (macOS)
+
+The logs are split across multiple files:
+- **main.log** - General Claude Desktop application logs
+- **mcp-server-Anki MCP Server.log** - MCP protocol messages for this extension
+- **mcp.log** - Combined MCP logs from all servers
+
+**Note**: The pino logger output (INFO, ERROR, WARN messages from the server code) goes to stderr and appears in the MCP-specific log files. Claude Desktop determines which log file receives which messages, but generally:
+- Application startup and MCP protocol communication → MCP-specific log
+- Server internal logging (pino) → Both MCP-specific log and sometimes main.log
+
+To view logs in real-time:
+```bash
+tail -f ~/Library/Logs/Claude/mcp-server-Anki\ MCP\ Server.log
+```
+
+### Debugging the MCP Server
+
+You can debug the MCP server using the MCP Inspector and attaching a debugger from your IDE (WebStorm, VS Code, etc.).
+
+#### Step 1: Configure Debug Server in MCP Inspector
+
+The `mcp-inspector-config.json` already includes a debug server configuration:
+
+```json
+{
+  "mcpServers": {
+    "stdio-server-debug": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["--inspect-brk=9229", "dist/main-stdio.js"],
+      "env": {
+        "MCP_SERVER_NAME": "anki-mcp-stdio-debug",
+        "MCP_SERVER_VERSION": "1.0.0",
+        "LOG_LEVEL": "debug"
+      },
+      "note": "Anki MCP server with debugging enabled on port 9229"
+    }
+  }
+}
+```
+
+#### Step 2: Start the Debug Server
+
+Run the MCP Inspector with the debug server:
+
+```bash
+npm run inspector:debug
+```
+
+This will start the server with Node.js debugging enabled on port 9229 and pause execution at the first line.
+
+#### Step 3: Attach Debugger from Your IDE
+
+##### WebStorm
+1. Go to **Run → Edit Configurations**
+2. Add a new **Attach to Node.js/Chrome** configuration
+3. Set the port to `9229`
+4. Click **Debug** to attach
+
+##### VS Code
+1. Open the Debug panel (Ctrl+Shift+D / Cmd+Shift+D)
+2. Select **Debug MCP Server (Attach)** configuration
+3. Press F5 to attach
+
+#### Step 4: Set Breakpoints and Debug
+
+Once attached, you can:
+- Set breakpoints in your TypeScript source files
+- Step through code execution
+- Inspect variables and call stack
+- Use the debug console for evaluating expressions
+
+The debugger will work with source maps, allowing you to debug the original TypeScript code rather than the compiled JavaScript.
+
+### Debugging with Claude Desktop
+
+You can also debug the MCP server while it runs inside Claude Desktop by enabling the Node.js debugger and attaching your IDE.
+
+#### Step 1: Configure Claude Desktop for Debugging
+
+Update your Claude Desktop config to enable debugging:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+**Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "anki-mcp": {
+      "command": "node",
+      "args": [
+        "--inspect=9229",
+        "/Users/anatoly/Developer/git/anki-mcp-organization/anki-mcp-desktop/dist/main-stdio.js"
+      ],
+      "env": {
+        "ANKI_CONNECT_URL": "http://localhost:8765"
+      }
+    }
+  }
+}
+```
+
+**Key change**: Add `--inspect=9229` before the path to `dist/main-stdio.js`
+
+**Debug options**:
+- `--inspect=9229` - Start debugger immediately, doesn't block (recommended)
+- `--inspect-brk=9229` - Pause execution until debugger attaches (for debugging startup issues)
+
+#### Step 2: Restart Claude Desktop
+
+After saving the config, restart Claude Desktop. The MCP server will now run with debugging enabled on port 9229.
+
+#### Step 3: Attach Debugger from Your IDE
+
+##### WebStorm
+
+1. Go to **Run → Edit Configurations**
+2. Click the **+** button and select **Attach to Node.js/Chrome**
+3. Configure:
+   - **Name**: `Attach to Anki MCP (Claude Desktop)`
+   - **Host**: `localhost`
+   - **Port**: `9229`
+   - **Attach to**: `Node.js < 8` or `Chrome or Node.js > 6.3` (depending on WebStorm version)
+4. Click **OK**
+5. Click **Debug** (Shift+F9) to attach
+
+##### VS Code
+
+1. Add to `.vscode/launch.json`:
+
+```json
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "attach",
+      "name": "Attach to Anki MCP (Claude Desktop)",
+      "port": 9229,
+      "skipFiles": ["<node_internals>/**"],
+      "sourceMaps": true,
+      "outFiles": ["${workspaceFolder}/dist/**/*.js"]
+    }
+  ]
+}
+```
+
+2. Open the Debug panel (Ctrl+Shift+D / Cmd+Shift+D)
+3. Select **Attach to Anki MCP (Claude Desktop)**
+4. Press F5 to attach
+
+#### Step 4: Debug in Real-Time
+
+Once attached, you can:
+- Set breakpoints in your TypeScript source files (e.g., `src/mcp/primitives/essential/tools/create-model.tool.ts`)
+- Use Claude Desktop normally - breakpoints will hit when tools are invoked
+- Step through code execution
+- Inspect variables and call stack
+- Use the debug console
+
+**Example**: Set a breakpoint in `create-model.tool.ts` at line 119, then ask Claude to create a new model. The debugger will pause at your breakpoint!
+
+**Note**: The debugger stays attached as long as Claude Desktop is running. You can detach/reattach anytime without restarting Claude Desktop.
+
+### Build Commands
+
+```bash
+npm run build              # Build the project (compile TypeScript to JavaScript)
+npm run start:dev:stdio    # STDIO mode with watch (auto-rebuild)
+npm run start:dev:http     # HTTP mode with watch (auto-rebuild)
+npm run type-check         # Run TypeScript type checking
+npm run lint               # Run ESLint
+npm run mcpb:bundle        # Sync version, clean, build, and create MCPB bundle
+```
+
+### NPM Package Testing (Local)
+
+Test the npm package locally before publishing:
+
+```bash
+# 1. Create local package
+npm run pack:local         # Builds and creates anki-mcp-http-*.tgz
+
+# 2. Install globally from local package
+npm run install:local      # Installs from ./anki-mcp-http-*.tgz
+
+# 3. Test the command
+ankimcp                    # Runs HTTP server on port 3000
+
+# 4. Uninstall when done testing
+npm run uninstall:local    # Removes global installation
+```
+
+**How it works:**
+- `npm pack` creates a `.tgz` file identical to what npm publish would create
+- Installing from `.tgz` simulates what users get from `npm install -g ankimcp`
+- This lets you test the full user experience before publishing to npm
+
+### Testing Commands
+
+```bash
+npm test              # Run all tests
+npm run test:unit     # Run unit tests only
+npm run test:tools    # Run tool-specific tests
+npm run test:workflows # Run workflow integration tests
+npm run test:e2e      # Run end-to-end tests
+npm run test:cov      # Run tests with coverage report
+npm run test:watch    # Run tests in watch mode
+npm run test:debug    # Run tests with debugger
+npm run test:ci       # Run tests for CI (silent, with coverage)
+```
+
+### Test Coverage
+
+The project maintains 70% minimum coverage thresholds for:
+- Branches
+- Functions
+- Lines
+- Statements
+
+Coverage reports are generated in the `coverage/` directory.
+
+## Versioning
+
+This project follows [Semantic Versioning](https://semver.org/) with a pre-1.0 development approach:
+
+- **0.x.x** - Beta/Development versions (current phase)
+  - **0.1.x** - Bug fixes and patches
+  - **0.2.0+** - New features or minor improvements
+  - **Breaking changes** are acceptable in 0.x versions
+
+- **1.0.0** - First stable release
+  - Will be released when the API is stable and tested
+  - Breaking changes will require major version bumps (2.0.0, etc.)
+
+**Current Status**: `0.1.0` - Initial beta release. The project is functional but APIs may change based on feedback and testing.
+
+## Similar Projects
+
+If you're exploring Anki MCP integrations, here are other projects in this space:
+
+### [scorzeth/anki-mcp-server](https://github.com/scorzeth/anki-mcp-server)
+- **Status**: Appears to be abandoned (no recent updates)
+- Early implementation of Anki MCP integration
+
+### [nailuoGG/anki-mcp-server](https://github.com/nailuoGG/anki-mcp-server)
+- **Approach**: Lightweight, single-file implementation
+- **Architecture**: Procedural code structure with all tools in one file
+- **Good for**: Simple use cases, minimal dependencies
+
+**Why this project (anki-mcp-desktop) differs:**
+- **Enterprise-grade architecture**: Built on NestJS with dependency injection
+- **Modular design**: Each tool is a separate class with clear separation of concerns
+- **Maintainability**: Easy to extend with new features without touching existing code
+- **Testing**: Comprehensive test suite with 70% coverage requirement
+- **Type safety**: Strict TypeScript with Zod validation
+- **Error handling**: Robust error handling with helpful user feedback
+- **Production-ready**: Proper logging, progress reporting, and MCPB bundle support
+- **Scalability**: Can easily grow from basic tools to complex workflows
+
+**Use case**: If you need a solid foundation for building advanced Anki integrations or plan to extend functionality significantly, this project's architectural approach makes it easier to maintain and scale over time.
+
+## Useful Links
+
+- [Model Context Protocol Documentation](https://modelcontextprotocol.io/docs)
+- [AnkiConnect API Documentation](https://git.sr.ht/~foosoft/anki-connect)
+- [Claude Desktop Download](https://claude.ai/download)
+- [Building Desktop Extensions (Anthropic Blog)](https://www.anthropic.com/engineering/desktop-extensions)
+- [MCP Servers Repository](https://github.com/modelcontextprotocol/servers)
+- [NestJS Documentation](https://docs.nestjs.com)
+- [Anki Official Website](https://apps.ankiweb.net/)

package/bin/ankimcp.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/main-http.js');

package/dist/anki-config.service.d.ts

@@ -0,0 +1,10 @@
+import { ConfigService } from '@nestjs/config';
+import { IAnkiConfig } from './mcp/config/anki-config.interface';
+export declare class AnkiConfigService implements IAnkiConfig {
+    private configService;
+    constructor(configService: ConfigService);
+    get ankiConnectUrl(): string;
+    get ankiConnectApiVersion(): number;
+    get ankiConnectApiKey(): string | undefined;
+    get ankiConnectTimeout(): number;
+}

package/dist/anki-config.service.js

@@ -0,0 +1,42 @@
+"use strict";
+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 __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.AnkiConfigService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const mcpb_workarounds_1 = require("./mcp/utils/mcpb-workarounds");
+let AnkiConfigService = class AnkiConfigService {
+    configService;
+    constructor(configService) {
+        this.configService = configService;
+    }
+    get ankiConnectUrl() {
+        return this.configService.get('ANKI_CONNECT_URL', 'http://localhost:8765');
+    }
+    get ankiConnectApiVersion() {
+        const version = this.configService.get('ANKI_CONNECT_API_VERSION', '6');
+        return parseInt(version, 10);
+    }
+    get ankiConnectApiKey() {
+        const apiKey = this.configService.get('ANKI_CONNECT_API_KEY');
+        return (0, mcpb_workarounds_1.sanitizeMcpbConfigValue)(apiKey);
+    }
+    get ankiConnectTimeout() {
+        const timeout = this.configService.get('ANKI_CONNECT_TIMEOUT', '5000');
+        return parseInt(timeout, 10);
+    }
+};
+exports.AnkiConfigService = AnkiConfigService;
+exports.AnkiConfigService = AnkiConfigService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], AnkiConfigService);
+//# sourceMappingURL=anki-config.service.js.map

package/dist/anki-config.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anki-config.service.js","sourceRoot":"","sources":["../src/anki-config.service.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAA4C;AAC5C,2CAA+C;AAE/C,mEAAuE;AAMhE,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;IACR;IAApB,YAAoB,aAA4B;QAA5B,kBAAa,GAAb,aAAa,CAAe;IAAG,CAAC;IAEpD,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAC3B,kBAAkB,EAClB,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAED,IAAI,qBAAqB;QACvB,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CACpC,0BAA0B,EAC1B,GAAG,CACJ,CAAC;QACF,OAAO,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED,IAAI,iBAAiB;QACnB,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAS,sBAAsB,CAAC,CAAC;QACtE,OAAO,IAAA,0CAAuB,EAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IAED,IAAI,kBAAkB;QACpB,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CACpC,sBAAsB,EACtB,MAAM,CACP,CAAC;QACF,OAAO,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC/B,CAAC;CACF,CAAA;AA9BY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,mBAAU,GAAE;qCAEwB,sBAAa;GADrC,iBAAiB,CA8B7B"}

package/dist/app.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+export declare class AppModule {
+    static forStdio(): DynamicModule;
+    static forHttp(): DynamicModule;
+}