recker 1.0.11 → 1.0.12

package/dist/cli/index.js

@@ -326,6 +326,82 @@ ${pc.bold(pc.yellow('Examples:'))}
         const { startLoadDashboard } = await import('./tui/load-dashboard.js');
         await startLoadDashboard({ url, users, duration, mode, http2, rampUp });
     });
+    program
+        .command('mcp')
+        .description('Start MCP server for AI agents to access Recker documentation')
+        .option('-t, --transport <mode>', 'Transport mode: stdio, http, sse', 'stdio')
+        .option('-p, --port <number>', 'Server port (for http/sse modes)', '3100')
+        .option('-d, --docs <path>', 'Path to documentation folder')
+        .option('--debug', 'Enable debug logging')
+        .addHelpText('after', `
+${pc.bold(pc.yellow('Transport Modes:'))}
+  ${pc.cyan('stdio')}  ${pc.gray('(default)')} For Claude Code and other CLI tools
+  ${pc.cyan('http')}   Simple HTTP POST endpoint
+  ${pc.cyan('sse')}    HTTP + Server-Sent Events for real-time notifications
+
+${pc.bold(pc.yellow('Usage:'))}
+  ${pc.green('$ rek mcp')}                    ${pc.gray('Start in stdio mode (for Claude Code)')}
+  ${pc.green('$ rek mcp -t http')}            ${pc.gray('Start HTTP server on port 3100')}
+  ${pc.green('$ rek mcp -t sse -p 8080')}     ${pc.gray('Start SSE server on custom port')}
+  ${pc.green('$ rek mcp --debug')}            ${pc.gray('Enable debug logging')}
+
+${pc.bold(pc.yellow('Tools provided:'))}
+  ${pc.cyan('search_docs')}  Search documentation by keyword
+  ${pc.cyan('get_doc')}      Get full content of a doc file
+
+${pc.bold(pc.yellow('Claude Code config (~/.claude.json):'))}
+  ${pc.gray(`{
+    "mcpServers": {
+      "recker-docs": {
+        "command": "npx",
+        "args": ["recker", "mcp"]
+      }
+    }
+  }`)}
+`)
+        .action(async (options) => {
+        const { MCPServer } = await import('../mcp/server.js');
+        const transport = options.transport;
+        const server = new MCPServer({
+            transport,
+            port: parseInt(options.port),
+            docsPath: options.docs,
+            debug: options.debug,
+        });
+        if (transport === 'stdio') {
+            await server.start();
+            return;
+        }
+        await server.start();
+        const endpoints = transport === 'sse'
+            ? `
+│  POST /        - JSON-RPC endpoint          │
+│  GET  /sse     - Server-Sent Events         │
+│  GET  /health  - Health check               │`
+            : `
+│  POST /        - JSON-RPC endpoint          │`;
+        console.log(pc.green(`
+┌─────────────────────────────────────────────┐
+│  ${pc.bold('Recker MCP Server')}                         │
+├─────────────────────────────────────────────┤
+│  Transport: ${pc.cyan(transport.padEnd(31))}│
+│  Endpoint: ${pc.cyan(`http://localhost:${options.port}`.padEnd(32))}│
+│  Docs indexed: ${pc.yellow(String(server.getDocsCount()).padEnd(28))}│
+├─────────────────────────────────────────────┤${endpoints}
+├─────────────────────────────────────────────┤
+│  Tools:                                     │
+│    • ${pc.cyan('search_docs')} - Search documentation     │
+│    • ${pc.cyan('get_doc')}     - Get full doc content     │
+│                                             │
+│  Press ${pc.bold('Ctrl+C')} to stop                       │
+└─────────────────────────────────────────────┘
+`));
+        process.on('SIGINT', async () => {
+            console.log(pc.yellow('\nShutting down MCP server...'));
+            await server.stop();
+            process.exit(0);
+        });
+    });
     program.parse();
 }
 main().catch((error) => {

package/dist/mcp/index.d.ts

@@ -1,3 +1,4 @@
 export * from './types.js';
 export * from './client.js';
+export * from './server.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"AAKA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"AAKA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/dist/mcp/index.js

@@ -1,2 +1,3 @@
 export * from './types.js';
 export * from './client.js';
+export * from './server.js';

package/dist/mcp/server.d.ts

@@ -0,0 +1,41 @@
+import type { JsonRpcRequest, JsonRpcResponse } from './types.js';
+export type MCPTransportMode = 'stdio' | 'http' | 'sse';
+export interface MCPServerOptions {
+    name?: string;
+    version?: string;
+    docsPath?: string;
+    port?: number;
+    transport?: MCPTransportMode;
+    debug?: boolean;
+}
+export declare class MCPServer {
+    private options;
+    private server?;
+    private docsIndex;
+    private sseClients;
+    private initialized;
+    constructor(options?: MCPServerOptions);
+    private log;
+    private findDocsPath;
+    private buildIndex;
+    private walkDir;
+    private extractTitle;
+    private extractKeywords;
+    private getTools;
+    private handleToolCall;
+    private searchDocs;
+    private extractSnippet;
+    private getDoc;
+    handleRequest(req: JsonRpcRequest): JsonRpcResponse;
+    private sendNotification;
+    private startStdio;
+    private startHttp;
+    private startSSE;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getPort(): number;
+    getDocsCount(): number;
+    getTransport(): MCPTransportMode;
+}
+export declare function createMCPServer(options?: MCPServerOptions): MCPServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EAMhB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;AAExD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAsBD,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,MAAM,CAAC,CAAkC;IACjD,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,UAAU,CAAkC;IACpD,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,gBAAqB;IAa1C,OAAO,CAAC,GAAG;IAWX,OAAO,CAAC,YAAY;IAuBpB,OAAO,CAAC,UAAU;IAiClB,OAAO,CAAC,OAAO;IAyBf,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,eAAe;IAqBvB,OAAO,CAAC,QAAQ;IAyChB,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,UAAU;IA2DlB,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,MAAM;IAmCd,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,eAAe;IAkEnD,OAAO,CAAC,gBAAgB;YAUV,UAAU;YAqCV,SAAS;YAkDT,QAAQ;IA2FhB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAatB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB3B,OAAO,IAAI,MAAM;IAIjB,YAAY,IAAI,MAAM;IAItB,YAAY,IAAI,gBAAgB;CAGjC;AAoBD,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAErE"}

package/dist/mcp/server.js

@@ -0,0 +1,503 @@
+import { createServer } from 'http';
+import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
+import { join, relative } from 'path';
+import { createInterface } from 'readline';
+export class MCPServer {
+    options;
+    server;
+    docsIndex = [];
+    sseClients = new Set();
+    initialized = false;
+    constructor(options = {}) {
+        this.options = {
+            name: options.name || 'recker-docs',
+            version: options.version || '1.0.0',
+            docsPath: options.docsPath || this.findDocsPath(),
+            port: options.port || 3100,
+            transport: options.transport || 'stdio',
+            debug: options.debug || false,
+        };
+        this.buildIndex();
+    }
+    log(message, data) {
+        if (this.options.debug) {
+            if (this.options.transport === 'stdio') {
+                console.error(`[MCP] ${message}`, data ? JSON.stringify(data) : '');
+            }
+            else {
+                console.log(`[MCP] ${message}`, data ? JSON.stringify(data) : '');
+            }
+        }
+    }
+    findDocsPath() {
+        const possiblePaths = [
+            join(process.cwd(), 'docs'),
+            join(process.cwd(), '..', 'docs'),
+        ];
+        if (typeof __dirname !== 'undefined') {
+            possiblePaths.push(join(__dirname, '..', '..', 'docs'), join(__dirname, '..', '..', '..', 'docs'));
+        }
+        for (const p of possiblePaths) {
+            if (existsSync(p)) {
+                return p;
+            }
+        }
+        return join(process.cwd(), 'docs');
+    }
+    buildIndex() {
+        if (!existsSync(this.options.docsPath)) {
+            this.log(`Docs path not found: ${this.options.docsPath}`);
+            return;
+        }
+        const files = this.walkDir(this.options.docsPath);
+        for (const file of files) {
+            if (!file.endsWith('.md'))
+                continue;
+            try {
+                const content = readFileSync(file, 'utf-8');
+                const relativePath = relative(this.options.docsPath, file);
+                const category = relativePath.split('/')[0] || 'root';
+                const title = this.extractTitle(content) || relativePath;
+                const keywords = this.extractKeywords(content);
+                this.docsIndex.push({
+                    path: relativePath,
+                    title,
+                    category,
+                    content,
+                    keywords,
+                });
+            }
+            catch (err) {
+                this.log(`Failed to index ${file}:`, err);
+            }
+        }
+        this.log(`Indexed ${this.docsIndex.length} documentation files`);
+    }
+    walkDir(dir) {
+        const files = [];
+        try {
+            const entries = readdirSync(dir);
+            for (const entry of entries) {
+                if (entry.startsWith('_') || entry.startsWith('.'))
+                    continue;
+                const fullPath = join(dir, entry);
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    files.push(...this.walkDir(fullPath));
+                }
+                else if (stat.isFile()) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+        }
+        return files;
+    }
+    extractTitle(content) {
+        const match = content.match(/^#\s+(.+)$/m);
+        return match ? match[1].trim() : '';
+    }
+    extractKeywords(content) {
+        const keywords = new Set();
+        const headings = content.match(/^#{1,3}\s+(.+)$/gm) || [];
+        for (const h of headings) {
+            keywords.add(h.replace(/^#+\s+/, '').toLowerCase());
+        }
+        const codePatterns = content.match(/`([a-zA-Z_][a-zA-Z0-9_]*(?:\(\))?)`/g) || [];
+        for (const c of codePatterns) {
+            keywords.add(c.replace(/`/g, '').toLowerCase());
+        }
+        const terms = content.match(/\b[A-Z][a-zA-Z]+(?:Client|Server|Error|Response|Request|Plugin|Transport)\b/g) || [];
+        for (const t of terms) {
+            keywords.add(t.toLowerCase());
+        }
+        return Array.from(keywords).slice(0, 50);
+    }
+    getTools() {
+        return [
+            {
+                name: 'search_docs',
+                description: 'Search Recker documentation by keyword. Returns matching doc files with titles and snippets. Use this first to find relevant documentation.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Search query (e.g., "retry", "cache", "streaming", "websocket")',
+                        },
+                        category: {
+                            type: 'string',
+                            description: 'Optional: filter by category (http, cli, ai, protocols, reference, guides)',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Max results to return (default: 5)',
+                        },
+                    },
+                    required: ['query'],
+                },
+            },
+            {
+                name: 'get_doc',
+                description: 'Get the full content of a specific documentation file. Use the path from search_docs results.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Documentation file path (e.g., "http/07-resilience.md", "cli/01-overview.md")',
+                        },
+                    },
+                    required: ['path'],
+                },
+            },
+        ];
+    }
+    handleToolCall(name, args) {
+        switch (name) {
+            case 'search_docs':
+                return this.searchDocs(args);
+            case 'get_doc':
+                return this.getDoc(args);
+            default:
+                return {
+                    content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    }
+    searchDocs(args) {
+        const query = String(args.query || '').toLowerCase();
+        const category = args.category ? String(args.category).toLowerCase() : null;
+        const limit = Math.min(Number(args.limit) || 5, 10);
+        if (!query) {
+            return {
+                content: [{ type: 'text', text: 'Error: query is required' }],
+                isError: true,
+            };
+        }
+        const results = [];
+        for (const doc of this.docsIndex) {
+            if (category && !doc.category.toLowerCase().includes(category)) {
+                continue;
+            }
+            let score = 0;
+            const queryTerms = query.split(/\s+/);
+            for (const term of queryTerms) {
+                if (doc.title.toLowerCase().includes(term))
+                    score += 10;
+                if (doc.path.toLowerCase().includes(term))
+                    score += 5;
+                if (doc.keywords.some(k => k.includes(term)))
+                    score += 3;
+                if (doc.content.toLowerCase().includes(term))
+                    score += 1;
+            }
+            if (score > 0) {
+                const snippet = this.extractSnippet(doc.content, query);
+                results.push({ doc, score, snippet });
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        const topResults = results.slice(0, limit);
+        if (topResults.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `No documentation found for "${query}". Try different keywords like: http, cache, retry, streaming, websocket, ai, cli, plugins`,
+                    }],
+            };
+        }
+        const output = topResults.map((r, i) => `${i + 1}. **${r.doc.title}**\n   Path: \`${r.doc.path}\`\n   Category: ${r.doc.category}\n   ${r.snippet}`).join('\n\n');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Found ${topResults.length} result(s) for "${query}":\n\n${output}\n\nUse get_doc with the path to read full content.`,
+                }],
+        };
+    }
+    extractSnippet(content, query) {
+        const lowerContent = content.toLowerCase();
+        const index = lowerContent.indexOf(query.split(/\s+/)[0]);
+        if (index === -1) {
+            const firstPara = content.split('\n\n')[1] || content.substring(0, 200);
+            return firstPara.substring(0, 150).trim() + '...';
+        }
+        const start = Math.max(0, index - 50);
+        const end = Math.min(content.length, index + 150);
+        let snippet = content.substring(start, end).trim();
+        if (start > 0)
+            snippet = '...' + snippet;
+        if (end < content.length)
+            snippet = snippet + '...';
+        return snippet.replace(/\n/g, ' ');
+    }
+    getDoc(args) {
+        const path = String(args.path || '');
+        if (!path) {
+            return {
+                content: [{ type: 'text', text: 'Error: path is required' }],
+                isError: true,
+            };
+        }
+        const doc = this.docsIndex.find(d => d.path === path || d.path.endsWith(path));
+        if (!doc) {
+            const suggestions = this.docsIndex
+                .filter(d => d.path.includes(path.split('/').pop() || ''))
+                .slice(0, 3)
+                .map(d => d.path);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Documentation not found: ${path}${suggestions.length ? `\n\nDid you mean:\n${suggestions.map(s => `- ${s}`).join('\n')}` : ''}`,
+                    }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `# ${doc.title}\n\nPath: ${doc.path}\nCategory: ${doc.category}\n\n---\n\n${doc.content}`,
+                }],
+        };
+    }
+    handleRequest(req) {
+        const { method, params, id } = req;
+        this.log(`Request: ${method}`, params);
+        try {
+            switch (method) {
+                case 'initialize': {
+                    this.initialized = true;
+                    const response = {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {
+                            tools: { listChanged: false },
+                        },
+                        serverInfo: {
+                            name: this.options.name,
+                            version: this.options.version,
+                        },
+                    };
+                    return { jsonrpc: '2.0', id: id, result: response };
+                }
+                case 'notifications/initialized': {
+                    return { jsonrpc: '2.0', id: id, result: {} };
+                }
+                case 'ping':
+                    return { jsonrpc: '2.0', id: id, result: {} };
+                case 'tools/list': {
+                    const response = { tools: this.getTools() };
+                    return { jsonrpc: '2.0', id: id, result: response };
+                }
+                case 'tools/call': {
+                    const { name, arguments: args } = params;
+                    const result = this.handleToolCall(name, args || {});
+                    return { jsonrpc: '2.0', id: id, result };
+                }
+                case 'resources/list':
+                    return { jsonrpc: '2.0', id: id, result: { resources: [] } };
+                case 'prompts/list':
+                    return { jsonrpc: '2.0', id: id, result: { prompts: [] } };
+                default:
+                    return {
+                        jsonrpc: '2.0',
+                        id: id,
+                        error: { code: -32601, message: `Method not found: ${method}` },
+                    };
+            }
+        }
+        catch (err) {
+            return {
+                jsonrpc: '2.0',
+                id: id,
+                error: { code: -32603, message: String(err) },
+            };
+        }
+    }
+    sendNotification(notification) {
+        const data = JSON.stringify(notification);
+        for (const client of this.sseClients) {
+            client.write(`data: ${data}\n\n`);
+        }
+    }
+    async startStdio() {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false,
+        });
+        this.log('Starting in stdio mode');
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            try {
+                const request = JSON.parse(line);
+                const response = this.handleRequest(request);
+                process.stdout.write(JSON.stringify(response) + '\n');
+            }
+            catch (err) {
+                const errorResponse = {
+                    jsonrpc: '2.0',
+                    id: 0,
+                    error: { code: -32700, message: 'Parse error' },
+                };
+                process.stdout.write(JSON.stringify(errorResponse) + '\n');
+            }
+        });
+        rl.on('close', () => {
+            this.log('stdin closed, exiting');
+            process.exit(0);
+        });
+    }
+    async startHttp() {
+        return new Promise((resolve) => {
+            this.server = createServer((req, res) => {
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
+                res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+                if (req.method !== 'POST') {
+                    res.writeHead(405);
+                    res.end('Method not allowed');
+                    return;
+                }
+                let body = '';
+                req.on('data', chunk => body += chunk);
+                req.on('end', () => {
+                    try {
+                        const request = JSON.parse(body);
+                        const response = this.handleRequest(request);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(response));
+                    }
+                    catch (err) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            jsonrpc: '2.0',
+                            id: null,
+                            error: { code: -32700, message: 'Parse error' },
+                        }));
+                    }
+                });
+            });
+            this.server.listen(this.options.port, () => {
+                this.log(`HTTP server listening on http://localhost:${this.options.port}`);
+                resolve();
+            });
+        });
+    }
+    async startSSE() {
+        return new Promise((resolve) => {
+            this.server = createServer((req, res) => {
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
+                res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+                const url = req.url || '/';
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+                if (req.method === 'GET' && url === '/sse') {
+                    res.writeHead(200, {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        'Connection': 'keep-alive',
+                    });
+                    res.write(`data: ${JSON.stringify({ type: 'connected' })}\n\n`);
+                    this.sseClients.add(res);
+                    this.log(`SSE client connected (${this.sseClients.size} total)`);
+                    req.on('close', () => {
+                        this.sseClients.delete(res);
+                        this.log(`SSE client disconnected (${this.sseClients.size} total)`);
+                    });
+                    return;
+                }
+                if (req.method === 'POST') {
+                    let body = '';
+                    req.on('data', chunk => body += chunk);
+                    req.on('end', () => {
+                        try {
+                            const request = JSON.parse(body);
+                            const response = this.handleRequest(request);
+                            res.writeHead(200, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify(response));
+                        }
+                        catch (err) {
+                            res.writeHead(400, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({
+                                jsonrpc: '2.0',
+                                id: null,
+                                error: { code: -32700, message: 'Parse error' },
+                            }));
+                        }
+                    });
+                    return;
+                }
+                if (req.method === 'GET' && url === '/health') {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        status: 'ok',
+                        name: this.options.name,
+                        version: this.options.version,
+                        docsCount: this.docsIndex.length,
+                        sseClients: this.sseClients.size,
+                    }));
+                    return;
+                }
+                res.writeHead(404);
+                res.end('Not found');
+            });
+            this.server.listen(this.options.port, () => {
+                this.log(`SSE server listening on http://localhost:${this.options.port}`);
+                this.log(`  POST /        - JSON-RPC endpoint`);
+                this.log(`  GET  /sse     - Server-Sent Events`);
+                this.log(`  GET  /health  - Health check`);
+                resolve();
+            });
+        });
+    }
+    async start() {
+        switch (this.options.transport) {
+            case 'stdio':
+                return this.startStdio();
+            case 'http':
+                return this.startHttp();
+            case 'sse':
+                return this.startSSE();
+            default:
+                throw new Error(`Unknown transport: ${this.options.transport}`);
+        }
+    }
+    async stop() {
+        for (const client of this.sseClients) {
+            client.end();
+        }
+        this.sseClients.clear();
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    getPort() {
+        return this.options.port;
+    }
+    getDocsCount() {
+        return this.docsIndex.length;
+    }
+    getTransport() {
+        return this.options.transport;
+    }
+}
+export function createMCPServer(options) {
+    return new MCPServer(options);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "AI & DevX focused HTTP client for Node.js 18+",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -105,7 +105,8 @@
     "./package.json": "./package.json"
   },
   "bin": {
-    "rek": "./dist/cli/index.js"
+    "rek": "./dist/cli/index.js",
+    "recker": "./dist/cli/index.js"
   },
   "engines": {
     "node": ">=18"
@@ -168,7 +169,7 @@
     "test:coverage": "vitest run --coverage",
     "bench": "tsx benchmark/index.ts",
     "bench:all": "tsx benchmark/run-all.ts",
-    "docs": "serve docs -p 3000 -o",
+    "docs": "npx docsify-cli serve docs -p 3000 -o",
     "lint": "echo \"No linting configured for this project.\" && exit 0",
     "cli": "tsx src/cli/index.ts"
   }