recker 1.0.12-alpha.91ed191 → 1.0.12-alpha.a858d02

package/dist/cli/tui/shell-search.d.ts

@@ -0,0 +1,45 @@
+import type { SearchResult } from '../../mcp/search/types.js';
+export declare class ShellSearch {
+    private hybridSearch;
+    private docsIndex;
+    private codeExamples;
+    private typeDefinitions;
+    private initialized;
+    private idleTimer;
+    private docsPath;
+    private examplesPath;
+    private srcPath;
+    constructor();
+    private ensureInitialized;
+    private resetIdleTimer;
+    private unload;
+    search(query: string, options?: {
+        limit?: number;
+        category?: string;
+    }): Promise<SearchResult[]>;
+    suggest(useCase: string): Promise<string>;
+    getExamples(feature: string, options?: {
+        limit?: number;
+        complexity?: string;
+    }): Promise<string>;
+    getStats(): {
+        documents: number;
+        examples: number;
+        types: number;
+        loaded: boolean;
+    };
+    private findDocsPath;
+    private findExamplesPath;
+    private findSrcPath;
+    private buildIndex;
+    private indexDocs;
+    private indexExamples;
+    private indexTypes;
+    private extractKeywords;
+    private parseExampleMeta;
+    private inferFeature;
+    private extractMainCode;
+    private parseTypeDefinitions;
+}
+export declare function getShellSearch(): ShellSearch;
+//# sourceMappingURL=shell-search.d.ts.map

package/dist/cli/tui/shell-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-search.d.ts","sourceRoot":"","sources":["../../../src/cli/tui/shell-search.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAmC1E,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;;YAWV,iBAAiB;IAgB/B,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,MAAM;IAaR,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAenG,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAqGzC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAwD1G,QAAQ,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE;IAWnF,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,SAAS;IAuCjB,OAAO,CAAC,aAAa;IAoCrB,OAAO,CAAC,UAAU;IAwBlB,OAAO,CAAC,eAAe;IA8BvB,OAAO,CAAC,gBAAgB;IA8BxB,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,eAAe;IAkBvB,OAAO,CAAC,oBAAoB;CA4C7B;AAKD,wBAAgB,cAAc,IAAI,WAAW,CAK5C"}

package/dist/cli/tui/shell-search.js

@@ -0,0 +1,421 @@
+import { createHybridSearch } from '../../mcp/search/index.js';
+import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
+import { join, relative, extname, basename, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+export class ShellSearch {
+    hybridSearch = null;
+    docsIndex = [];
+    codeExamples = [];
+    typeDefinitions = [];
+    initialized = false;
+    idleTimer = null;
+    docsPath;
+    examplesPath;
+    srcPath;
+    constructor() {
+        this.docsPath = this.findDocsPath();
+        this.examplesPath = this.findExamplesPath();
+        this.srcPath = this.findSrcPath();
+    }
+    async ensureInitialized() {
+        this.resetIdleTimer();
+        if (this.initialized && this.hybridSearch) {
+            return;
+        }
+        this.hybridSearch = createHybridSearch({ debug: false });
+        this.buildIndex();
+        await this.hybridSearch.initialize(this.docsIndex);
+        this.initialized = true;
+    }
+    resetIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+        }
+        this.idleTimer = setTimeout(() => this.unload(), IDLE_TIMEOUT_MS);
+    }
+    unload() {
+        if (this.initialized) {
+            this.hybridSearch = null;
+            this.docsIndex = [];
+            this.codeExamples = [];
+            this.typeDefinitions = [];
+            this.initialized = false;
+        }
+    }
+    async search(query, options = {}) {
+        await this.ensureInitialized();
+        const { limit = 5, category } = options;
+        if (!this.hybridSearch) {
+            return [];
+        }
+        return this.hybridSearch.search(query, { limit, category, mode: 'hybrid' });
+    }
+    async suggest(useCase) {
+        await this.ensureInitialized();
+        const results = await this.search(useCase, { limit: 3 });
+        if (results.length === 0) {
+            return `No suggestions found for: "${useCase}"\n\nTry searching for specific features like:\n  - retry\n  - cache\n  - streaming\n  - websocket\n  - pagination`;
+        }
+        const useCaseLower = useCase.toLowerCase();
+        const suggestions = [];
+        if (useCaseLower.includes('retry') || useCaseLower.includes('fail') || useCaseLower.includes('error')) {
+            suggestions.push(`\n**Retry Configuration:**
+\`\`\`typescript
+import { createClient } from 'recker';
+
+const client = createClient({
+  baseUrl: 'https://api.example.com',
+  retry: {
+    attempts: 3,
+    backoff: 'exponential',
+    jitter: true,
+    retryOn: [429, 500, 502, 503, 504]
+  }
+});
+\`\`\``);
+        }
+        if (useCaseLower.includes('cache') || useCaseLower.includes('storage')) {
+            suggestions.push(`\n**Cache Configuration:**
+\`\`\`typescript
+import { createClient } from 'recker';
+
+const client = createClient({
+  baseUrl: 'https://api.example.com',
+  cache: {
+    storage: 'memory', // or 'file'
+    ttl: 300000, // 5 minutes
+    strategy: 'stale-while-revalidate'
+  }
+});
+\`\`\``);
+        }
+        if (useCaseLower.includes('stream') || useCaseLower.includes('sse') || useCaseLower.includes('ai') || useCaseLower.includes('openai')) {
+            suggestions.push(`\n**Streaming Configuration:**
+\`\`\`typescript
+import { createClient } from 'recker';
+
+const client = createClient({ baseUrl: 'https://api.openai.com' });
+
+// SSE streaming
+for await (const event of client.post('/v1/chat/completions', { body, stream: true }).sse()) {
+  console.log(event.data);
+}
+\`\`\``);
+        }
+        if (useCaseLower.includes('parallel') || useCaseLower.includes('batch') || useCaseLower.includes('concurrent')) {
+            suggestions.push(`\n**Batch/Parallel Requests:**
+\`\`\`typescript
+import { createClient } from 'recker';
+
+const client = createClient({
+  baseUrl: 'https://api.example.com',
+  concurrency: { max: 10 }
+});
+
+const { results, stats } = await client.batch([
+  { path: '/users/1' },
+  { path: '/users/2' },
+  { path: '/users/3' }
+], { mapResponse: r => r.json() });
+\`\`\``);
+        }
+        let output = `**Suggestion for: "${useCase}"**\n`;
+        if (suggestions.length > 0) {
+            output += suggestions.join('\n');
+        }
+        output += `\n\n**Related Documentation:**\n`;
+        for (const result of results) {
+            output += `  - ${result.title} (${result.path})\n`;
+            if (result.snippet) {
+                output += `    ${result.snippet.slice(0, 100)}...\n`;
+            }
+        }
+        return output;
+    }
+    async getExamples(feature, options = {}) {
+        await this.ensureInitialized();
+        const { limit = 3, complexity } = options;
+        const featureLower = feature.toLowerCase();
+        let examples = this.codeExamples.filter(ex => {
+            const matchesFeature = ex.feature.toLowerCase().includes(featureLower) ||
+                ex.keywords.some(k => k.toLowerCase().includes(featureLower)) ||
+                ex.title.toLowerCase().includes(featureLower);
+            const matchesComplexity = !complexity || ex.complexity === complexity;
+            return matchesFeature && matchesComplexity;
+        });
+        if (examples.length === 0) {
+            const searchResults = await this.search(`${feature} example`, { limit: 3 });
+            if (searchResults.length === 0) {
+                return `No examples found for: "${feature}"\n\nAvailable features:\n  - retry, cache, streaming, websocket\n  - pagination, middleware, batch\n  - scraping, load-testing, whois`;
+            }
+            let output = `**Examples for "${feature}" (from docs):**\n\n`;
+            for (const result of searchResults) {
+                output += `### ${result.title}\n`;
+                const codeBlocks = result.content.match(/```[\s\S]*?```/g) || [];
+                if (codeBlocks.length > 0) {
+                    output += codeBlocks.slice(0, 2).join('\n\n') + '\n\n';
+                }
+                else if (result.snippet) {
+                    output += result.snippet + '\n\n';
+                }
+            }
+            return output;
+        }
+        examples = examples.slice(0, limit);
+        let output = `**Code Examples for "${feature}":**\n\n`;
+        for (const ex of examples) {
+            output += `### ${ex.title} (${ex.complexity})\n`;
+            output += `${ex.description}\n\n`;
+            output += `\`\`\`typescript\n${ex.code}\n\`\`\`\n\n`;
+        }
+        return output;
+    }
+    getStats() {
+        return {
+            documents: this.docsIndex.length,
+            examples: this.codeExamples.length,
+            types: this.typeDefinitions.length,
+            loaded: this.initialized,
+        };
+    }
+    findDocsPath() {
+        const candidates = [
+            join(process.cwd(), 'docs'),
+            join(dirname(fileURLToPath(import.meta.url)), '../../../docs'),
+            join(dirname(fileURLToPath(import.meta.url)), '../../../../docs'),
+        ];
+        for (const p of candidates) {
+            if (existsSync(p))
+                return p;
+        }
+        return candidates[0];
+    }
+    findExamplesPath() {
+        const candidates = [
+            join(process.cwd(), 'examples'),
+            join(dirname(fileURLToPath(import.meta.url)), '../../../examples'),
+        ];
+        for (const p of candidates) {
+            if (existsSync(p))
+                return p;
+        }
+        return candidates[0];
+    }
+    findSrcPath() {
+        const candidates = [
+            join(process.cwd(), 'src'),
+            join(dirname(fileURLToPath(import.meta.url)), '../../'),
+        ];
+        for (const p of candidates) {
+            if (existsSync(p))
+                return p;
+        }
+        return candidates[0];
+    }
+    buildIndex() {
+        this.indexDocs();
+        this.indexExamples();
+        this.indexTypes();
+    }
+    indexDocs() {
+        if (!existsSync(this.docsPath))
+            return;
+        const walkDir = (dir) => {
+            const entries = readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = join(dir, entry);
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    walkDir(fullPath);
+                }
+                else if (extname(entry) === '.md') {
+                    const content = readFileSync(fullPath, 'utf-8');
+                    const relPath = relative(this.docsPath, fullPath);
+                    const parts = relPath.split('/');
+                    const category = parts.length > 1 ? parts[0] : 'general';
+                    const titleMatch = content.match(/^#\s+(.+)$/m);
+                    const title = titleMatch ? titleMatch[1] : basename(entry, '.md');
+                    const keywords = this.extractKeywords(content);
+                    this.docsIndex.push({
+                        id: relPath,
+                        path: relPath,
+                        title,
+                        content,
+                        category,
+                        keywords,
+                    });
+                }
+            }
+        };
+        walkDir(this.docsPath);
+    }
+    indexExamples() {
+        if (!existsSync(this.examplesPath))
+            return;
+        const walkDir = (dir) => {
+            const entries = readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = join(dir, entry);
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    walkDir(fullPath);
+                }
+                else if (['.ts', '.js', '.mjs'].includes(extname(entry))) {
+                    const code = readFileSync(fullPath, 'utf-8');
+                    const relPath = relative(this.examplesPath, fullPath);
+                    const meta = this.parseExampleMeta(code);
+                    const filename = basename(entry, extname(entry));
+                    this.codeExamples.push({
+                        id: relPath,
+                        path: relPath,
+                        title: meta.title || filename,
+                        feature: meta.feature || this.inferFeature(filename, code),
+                        complexity: meta.complexity || 'basic',
+                        code: this.extractMainCode(code),
+                        description: meta.description || '',
+                        keywords: meta.keywords || this.extractKeywords(code),
+                    });
+                }
+            }
+        };
+        walkDir(this.examplesPath);
+    }
+    indexTypes() {
+        if (!existsSync(this.srcPath))
+            return;
+        const typeFiles = ['types.ts', 'types/index.ts', 'core/types.ts'];
+        for (const tf of typeFiles) {
+            const fullPath = join(this.srcPath, tf);
+            if (!existsSync(fullPath))
+                continue;
+            const content = readFileSync(fullPath, 'utf-8');
+            this.parseTypeDefinitions(content, tf);
+        }
+        const mainFiles = ['index.ts', 'core/client.ts', 'mcp/server.ts'];
+        for (const mf of mainFiles) {
+            const fullPath = join(this.srcPath, mf);
+            if (!existsSync(fullPath))
+                continue;
+            const content = readFileSync(fullPath, 'utf-8');
+            this.parseTypeDefinitions(content, mf);
+        }
+    }
+    extractKeywords(content) {
+        const keywords = new Set();
+        const headings = content.match(/^#+\s+(.+)$/gm) || [];
+        for (const h of headings) {
+            const text = h.replace(/^#+\s+/, '');
+            text.split(/\s+/).forEach(w => {
+                if (w.length > 3)
+                    keywords.add(w.toLowerCase());
+            });
+        }
+        const identifiers = content.match(/`([a-zA-Z_][a-zA-Z0-9_]*)`/g) || [];
+        for (const id of identifiers) {
+            keywords.add(id.replace(/`/g, '').toLowerCase());
+        }
+        const terms = ['retry', 'cache', 'timeout', 'streaming', 'sse', 'websocket',
+            'middleware', 'plugin', 'hook', 'batch', 'pagination', 'http'];
+        for (const term of terms) {
+            if (content.toLowerCase().includes(term)) {
+                keywords.add(term);
+            }
+        }
+        return Array.from(keywords);
+    }
+    parseExampleMeta(code) {
+        const meta = {};
+        const docMatch = code.match(/\/\*\*[\s\S]*?\*\//);
+        if (docMatch) {
+            const doc = docMatch[0];
+            const titleMatch = doc.match(/@title\s+(.+)/);
+            if (titleMatch)
+                meta.title = titleMatch[1].trim();
+            const featureMatch = doc.match(/@feature\s+(.+)/);
+            if (featureMatch)
+                meta.feature = featureMatch[1].trim();
+            const complexityMatch = doc.match(/@complexity\s+(basic|intermediate|advanced)/);
+            if (complexityMatch)
+                meta.complexity = complexityMatch[1];
+            const descMatch = doc.match(/\*\s+([^@*\n].+)/);
+            if (descMatch)
+                meta.description = descMatch[1].trim();
+        }
+        return meta;
+    }
+    inferFeature(filename, code) {
+        const nameLower = filename.toLowerCase();
+        const codeLower = code.toLowerCase();
+        if (nameLower.includes('retry') || codeLower.includes('retry:'))
+            return 'retry';
+        if (nameLower.includes('cache') || codeLower.includes('cache:'))
+            return 'cache';
+        if (nameLower.includes('stream') || codeLower.includes('.sse('))
+            return 'streaming';
+        if (nameLower.includes('ws') || codeLower.includes('websocket'))
+            return 'websocket';
+        if (nameLower.includes('batch') || codeLower.includes('.batch('))
+            return 'batch';
+        if (nameLower.includes('pagin') || codeLower.includes('.paginate('))
+            return 'pagination';
+        return 'general';
+    }
+    extractMainCode(code) {
+        const lines = code.split('\n');
+        let startIndex = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (line.startsWith('//') || line.startsWith('/*') || line.startsWith('*') ||
+                line.startsWith('import') || line.startsWith('export') || line === '') {
+                startIndex = i + 1;
+            }
+            else {
+                break;
+            }
+        }
+        return lines.slice(startIndex).join('\n').trim() || code;
+    }
+    parseTypeDefinitions(content, path) {
+        const interfaceRegex = /(?:\/\*\*[\s\S]*?\*\/\s*)?(export\s+)?interface\s+(\w+)(?:<[^>]+>)?\s*(?:extends\s+[^{]+)?\{[\s\S]*?\n\}/g;
+        let match;
+        while ((match = interfaceRegex.exec(content)) !== null) {
+            const name = match[2];
+            const definition = match[0];
+            const docMatch = definition.match(/\/\*\*\s*([\s\S]*?)\s*\*\//);
+            const description = docMatch
+                ? docMatch[1].replace(/\s*\*\s*/g, ' ').trim()
+                : '';
+            this.typeDefinitions.push({
+                name,
+                kind: 'interface',
+                path,
+                definition: definition.replace(/\/\*\*[\s\S]*?\*\/\s*/, '').trim(),
+                description,
+            });
+        }
+        const typeRegex = /(?:\/\*\*[\s\S]*?\*\/\s*)?(export\s+)?type\s+(\w+)(?:<[^>]+>)?\s*=\s*[^;]+;/g;
+        while ((match = typeRegex.exec(content)) !== null) {
+            const name = match[2];
+            const definition = match[0];
+            const docMatch = definition.match(/\/\*\*\s*([\s\S]*?)\s*\*\//);
+            const description = docMatch
+                ? docMatch[1].replace(/\s*\*\s*/g, ' ').trim()
+                : '';
+            this.typeDefinitions.push({
+                name,
+                kind: 'type',
+                path,
+                definition: definition.replace(/\/\*\*[\s\S]*?\*\/\s*/, '').trim(),
+                description,
+            });
+        }
+    }
+}
+let shellSearchInstance = null;
+export function getShellSearch() {
+    if (!shellSearchInstance) {
+        shellSearchInstance = new ShellSearch();
+    }
+    return shellSearchInstance;
+}

package/dist/cli/tui/shell.d.ts

@@ -53,6 +53,10 @@ export declare class RekShell {
     private beautifyCSS;
     private runBeautifySave;
     private runSelectTable;
+    private runSearch;
+    private runSuggest;
+    private runExample;
+    private printMarkdown;
     private printHelp;
 }
 //# sourceMappingURL=shell.d.ts.map

package/dist/cli/tui/shell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../../src/cli/tui/shell.ts"],"names":[],"mappings":"AAmCA,qBAAa,QAAQ;IACnB,OAAO,CAAC,EAAE,CAAsB;IAChC,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,OAAO,CAA8B;IAC7C,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,aAAa,CAAc;;YAWrB,iBAAiB;IAe/B,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,SAAS;IAaJ,KAAK;IA8BlB,OAAO,CAAC,MAAM;YAKA,aAAa;YAmKb,kBAAkB;YAkBlB,SAAS;YAkBT,WAAW;IA0DzB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,QAAQ;IAoCV,WAAW,CAAC,QAAQ,CAAC,EAAE,MAAM;IA6CnC,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,UAAU;YAeJ,cAAc;YAyEd,QAAQ;YA8GR,MAAM;YA2DN,MAAM;YA2EN,OAAO;YA+DP,OAAO;YA0CP,QAAQ;YAoER,SAAS;YAsCT,aAAa;YA8Bb,aAAa;YA+Bb,aAAa;YA6Bb,cAAc;YAkCd,eAAe;YA+Ef,gBAAgB;YAmEhB,YAAY;YAiEZ,mBAAmB;YAsFnB,QAAQ;YA0FR,YAAY;YAoCZ,YAAY;YA6CZ,WAAW;IA6CzB,OAAO,CAAC,UAAU;IA4GlB,OAAO,CAAC,WAAW;YAgFL,eAAe;YAkBf,cAAc;IA8C5B,OAAO,CAAC,SAAS;CAkElB"}
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../../src/cli/tui/shell.ts"],"names":[],"mappings":"AAoCA,qBAAa,QAAQ;IACnB,OAAO,CAAC,EAAE,CAAsB;IAChC,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,OAAO,CAA8B;IAC7C,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,aAAa,CAAc;;YAWrB,iBAAiB;IAe/B,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,SAAS;IAcJ,KAAK;IA8BlB,OAAO,CAAC,MAAM;YAKA,aAAa;YAwLb,kBAAkB;YAkBlB,SAAS;YAkBT,WAAW;IA0DzB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,QAAQ;IAoCV,WAAW,CAAC,QAAQ,CAAC,EAAE,MAAM;IA6CnC,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,UAAU;YAeJ,cAAc;YAyEd,QAAQ;YA8GR,MAAM;YA2DN,MAAM;YA2EN,OAAO;YA+DP,OAAO;YA0CP,QAAQ;YAoER,SAAS;YAsCT,aAAa;YA8Bb,aAAa;YA+Bb,aAAa;YA6Bb,cAAc;YAkCd,eAAe;YA+Ef,gBAAgB;YAmEhB,YAAY;YAiEZ,mBAAmB;YAsFnB,QAAQ;YA0FR,YAAY;YAoCZ,YAAY;YA6CZ,WAAW;IA6CzB,OAAO,CAAC,UAAU;IA4GlB,OAAO,CAAC,WAAW;YAgFL,eAAe;YAkBf,cAAc;YAgDd,SAAS;YA2CT,UAAU;YAuBV,UAAU;IAwBxB,OAAO,CAAC,aAAa;IAuCrB,OAAO,CAAC,SAAS;CAwElB"}

package/dist/cli/tui/shell.js

@@ -11,6 +11,7 @@ import { getSecurityRecords } from '../../utils/dns-toolkit.js';
 import { rdap } from '../../utils/rdap.js';
 import { ScrapeDocument } from '../../scrape/document.js';
 import colors from '../../utils/colors.js';
+import { getShellSearch } from './shell-search.js';
 let highlight;
 async function initDependencies() {
     if (!highlight) {
@@ -86,6 +87,7 @@ export class RekShell {
             'ws', 'udp', 'load', 'chat', 'ai',
             'whois', 'tls', 'ssl', 'dns', 'rdap', 'ping',
             'scrap', '$', '$text', '$attr', '$html', '$links', '$images', '$scripts', '$css', '$sourcemaps', '$unmap', '$unmap:view', '$unmap:save', '$beautify', '$beautify:save', '$table',
+            '?', 'search', 'suggest', 'example',
             'help', 'clear', 'exit', 'set', 'url', 'vars', 'env'
         ];
         const hits = commands.filter((c) => c.startsWith(line));
@@ -217,6 +219,23 @@ export class RekShell {
             case '$table':
                 await this.runSelectTable(parts.slice(1).join(' '));
                 return;
+            case '?':
+            case 'search':
+                await this.runSearch(parts.slice(1).join(' '));
+                return;
+            case 'suggest':
+                await this.runSuggest(parts.slice(1).join(' '));
+                return;
+            case 'example':
+                await this.runExample(parts.slice(1).join(' '));
+                return;
+        }
+        if (input.endsWith('?') && !input.startsWith('http')) {
+            const query = input.slice(0, -1).trim();
+            if (query) {
+                await this.runSearch(query);
+                return;
+            }
         }
         const methods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
         let method = 'GET';
@@ -1640,6 +1659,117 @@ export class RekShell {
         }
         console.log('');
     }
+    async runSearch(query) {
+        if (!query.trim()) {
+            console.log(colors.yellow('Usage: ? <query> or search <query>'));
+            console.log(colors.gray('  Examples:'));
+            console.log(colors.gray('    ? retry exponential backoff'));
+            console.log(colors.gray('    search cache configuration'));
+            return;
+        }
+        console.log(colors.gray('Searching documentation...'));
+        try {
+            const search = getShellSearch();
+            const results = await search.search(query, { limit: 5 });
+            if (results.length === 0) {
+                console.log(colors.yellow(`No results for: "${query}"`));
+                console.log(colors.gray('Try different keywords like: retry, cache, streaming, websocket, pagination'));
+                return;
+            }
+            console.log(colors.bold(colors.cyan(`\nFound ${results.length} results for "${query}":\n`)));
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                const score = Math.round(result.score * 100);
+                console.log(`  ${colors.green(`${i + 1}.`)} ${colors.bold(result.title)} ${colors.gray(`(${score}%)`)}`);
+                console.log(`     ${colors.gray(result.path)}`);
+                if (result.snippet) {
+                    const snippet = result.snippet.slice(0, 120).replace(/\n/g, ' ');
+                    console.log(`     ${colors.gray(snippet)}${result.snippet.length > 120 ? '...' : ''}`);
+                }
+                console.log('');
+            }
+            console.log(colors.gray('  Tip: Use "get_doc <path>" to read full documentation'));
+        }
+        catch (error) {
+            console.error(colors.red(`Search failed: ${error.message}`));
+        }
+    }
+    async runSuggest(useCase) {
+        if (!useCase.trim()) {
+            console.log(colors.yellow('Usage: suggest <use-case>'));
+            console.log(colors.gray('  Examples:'));
+            console.log(colors.gray('    suggest implement retry with exponential backoff'));
+            console.log(colors.gray('    suggest cache API responses'));
+            console.log(colors.gray('    suggest stream AI responses from OpenAI'));
+            return;
+        }
+        console.log(colors.gray('Getting suggestions...'));
+        try {
+            const search = getShellSearch();
+            const suggestion = await search.suggest(useCase);
+            console.log('');
+            this.printMarkdown(suggestion);
+        }
+        catch (error) {
+            console.error(colors.red(`Suggest failed: ${error.message}`));
+        }
+    }
+    async runExample(feature) {
+        if (!feature.trim()) {
+            console.log(colors.yellow('Usage: example <feature>'));
+            console.log(colors.gray('  Examples:'));
+            console.log(colors.gray('    example retry'));
+            console.log(colors.gray('    example streaming'));
+            console.log(colors.gray('    example cache'));
+            console.log(colors.gray('    example websocket'));
+            return;
+        }
+        console.log(colors.gray('Finding examples...'));
+        try {
+            const search = getShellSearch();
+            const examples = await search.getExamples(feature, { limit: 3 });
+            console.log('');
+            this.printMarkdown(examples);
+        }
+        catch (error) {
+            console.error(colors.red(`Example lookup failed: ${error.message}`));
+        }
+    }
+    printMarkdown(text) {
+        const lines = text.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('**') && line.endsWith('**')) {
+                console.log(colors.bold(line.replace(/\*\*/g, '')));
+            }
+            else if (line.startsWith('### ')) {
+                console.log(colors.bold(colors.cyan(line.slice(4))));
+            }
+            else if (line.startsWith('## ')) {
+                console.log(colors.bold(colors.cyan(line.slice(3))));
+            }
+            else if (line.startsWith('# ')) {
+                console.log(colors.bold(colors.cyan(line.slice(2))));
+            }
+            else if (line.startsWith('```')) {
+                if (line.length > 3) {
+                    console.log(colors.gray('─'.repeat(40)));
+                }
+                else {
+                    console.log(colors.gray('─'.repeat(40)));
+                }
+            }
+            else if (line.startsWith('  - ') || line.startsWith('- ')) {
+                const content = line.replace(/^\s*-\s*/, '');
+                console.log(`  ${colors.green('•')} ${content}`);
+            }
+            else if (line.match(/^\s+/)) {
+                console.log(colors.yellow(line));
+            }
+            else {
+                console.log(line);
+            }
+        }
+    }
     printHelp() {
         console.log(`
   ${colors.bold(colors.cyan('Rek Console Help'))}
@@ -1698,6 +1828,12 @@ export class RekShell {
     ${colors.green('$beautify:save [f]')}  Save beautified code to file.
     ${colors.green('$table <selector>')}   Extract table as data.
 
+  ${colors.bold('Documentation:')}
+    ${colors.green('? <query>')}           Search Recker documentation.
+    ${colors.green('search <query>')}      Alias for ? (hybrid fuzzy+semantic search).
+    ${colors.green('suggest <use-case>')}  Get implementation suggestions.
+    ${colors.green('example <feature>')}   Get code examples for a feature.
+
   ${colors.bold('Examples:')}
     › url httpbin.org
     › get /json

package/package.json

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