recker 1.0.11-alpha.0f357e4 → 1.0.11-alpha.d342d95

package/dist/cli/index.js

@@ -326,6 +326,60 @@ ${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('-p, --port <number>', 'Server port', '3100')
+        .option('-d, --docs <path>', 'Path to documentation folder')
+        .option('--debug', 'Enable debug logging')
+        .addHelpText('after', `
+${pc.bold(pc.yellow('Usage:'))}
+  ${pc.green('$ rek mcp')}                    ${pc.gray('Start server on port 3100')}
+  ${pc.green('$ rek mcp -p 8080')}            ${pc.gray('Start 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 server = new MCPServer({
+            port: parseInt(options.port),
+            docsPath: options.docs,
+            debug: options.debug,
+        });
+        await server.start();
+        console.log(pc.green(`
+┌─────────────────────────────────────────────┐
+│  ${pc.bold('Recker MCP Server')}                         │
+├─────────────────────────────────────────────┤
+│  Endpoint: ${pc.cyan(`http://localhost:${options.port}`)}         │
+│  Docs indexed: ${pc.yellow(String(server.getDocsCount()).padEnd(28))}│
+│                                             │
+│  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,30 @@
+export interface MCPServerOptions {
+    name?: string;
+    version?: string;
+    docsPath?: string;
+    port?: number;
+    debug?: boolean;
+}
+export declare class MCPServer {
+    private options;
+    private server?;
+    private docsIndex;
+    constructor(options?: MCPServerOptions);
+    private findDocsPath;
+    private buildIndex;
+    private walkDir;
+    private extractTitle;
+    private extractKeywords;
+    private getTools;
+    private handleToolCall;
+    private searchDocs;
+    private extractSnippet;
+    private getDoc;
+    private handleRequest;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getPort(): number;
+    getDocsCount(): number;
+}
+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":"AAcA,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,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAiBD,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,MAAM,CAAC,CAAkC;IACjD,OAAO,CAAC,SAAS,CAAkB;gBAEvB,OAAO,GAAE,gBAAqB;IAY1C,OAAO,CAAC,YAAY;IAkBpB,OAAO,CAAC,UAAU;IAuClB,OAAO,CAAC,OAAO;IAyBf,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,eAAe;IAyBvB,OAAO,CAAC,QAAQ;IAyChB,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,UAAU;IA4DlB,OAAO,CAAC,cAAc;IAoBtB,OAAO,CAAC,MAAM;IAmCd,OAAO,CAAC,aAAa;IAiDf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA4DtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAU3B,OAAO,IAAI,MAAM;IAIjB,YAAY,IAAI,MAAM;CAGvB;AAKD,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAErE"}

package/dist/mcp/server.js

@@ -0,0 +1,370 @@
+import { createServer } from 'http';
+import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
+import { join, relative } from 'path';
+export class MCPServer {
+    options;
+    server;
+    docsIndex = [];
+    constructor(options = {}) {
+        this.options = {
+            name: options.name || 'recker-docs',
+            version: options.version || '1.0.0',
+            docsPath: options.docsPath || this.findDocsPath(),
+            port: options.port || 3100,
+            debug: options.debug || false,
+        };
+        this.buildIndex();
+    }
+    findDocsPath() {
+        const possiblePaths = [
+            join(process.cwd(), 'docs'),
+            join(process.cwd(), '..', 'docs'),
+            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)) {
+            if (this.options.debug) {
+                console.log(`[MCP] 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) {
+                if (this.options.debug) {
+                    console.log(`[MCP] Failed to index ${file}:`, err);
+                }
+            }
+        }
+        if (this.options.debug) {
+            console.log(`[MCP] 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;
+        try {
+            switch (method) {
+                case 'initialize': {
+                    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 '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 };
+                }
+                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) },
+            };
+        }
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server = createServer((req, res) => {
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.setHeader('Access-Control-Allow-Methods', 'POST, 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);
+                        if (this.options.debug) {
+                            console.log('[MCP] Request:', JSON.stringify(request, null, 2));
+                        }
+                        const response = this.handleRequest(request);
+                        if (this.options.debug) {
+                            console.log('[MCP] Response:', JSON.stringify(response, null, 2));
+                        }
+                        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, () => {
+                if (this.options.debug) {
+                    console.log(`[MCP] Server listening on http://localhost:${this.options.port}`);
+                    console.log(`[MCP] Docs path: ${this.options.docsPath}`);
+                    console.log(`[MCP] Indexed ${this.docsIndex.length} files`);
+                }
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    getPort() {
+        return this.options.port;
+    }
+    getDocsCount() {
+        return this.docsIndex.length;
+    }
+}
+export function createMCPServer(options) {
+    return new MCPServer(options);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.11-alpha.0f357e4",
+  "version": "1.0.11-alpha.d342d95",
   "description": "AI & DevX focused HTTP client for Node.js 18+",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",