recker 1.0.22 → 1.0.25-next.566f437

package/dist/cli/handler.js

@@ -1,9 +1,8 @@
 import { createClient } from '../core/client.js';
 import { requireOptional } from '../utils/optional-require.js';
 import colors from '../utils/colors.js';
-import oraImport from 'ora';
+import { createSpinner } from './tui/spinner.js';
 let highlight;
-const ora = oraImport;
 async function initDependencies() {
     if (!highlight) {
         try {
@@ -24,10 +23,9 @@ export async function handleRequest(options) {
             }
         });
     }
-    const spinner = options.quiet ? null : ora({
+    const spinner = options.quiet ? null : createSpinner({
         text: `${colors.bold(options.method)} ${colors.cyan(options.url)}`,
-        color: 'cyan',
-        spinner: 'dots'
+        color: 'cyan'
     }).start();
     const start = performance.now();
     try {

package/dist/cli/index.js

@@ -993,6 +993,60 @@ ${colors.bold(colors.yellow('Examples:'))}
             process.exit(0);
         });
     });
+    serve
+        .command('webhook')
+        .alias('wh')
+        .description('Start a webhook receiver server')
+        .option('-p, --port <number>', 'Port to listen on', '3000')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('-s, --status <code>', 'Response status code (200 or 204)', '204')
+        .option('-q, --quiet', 'Disable logging', false)
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek serve webhook')}                 ${colors.gray('Start on port 3000')}
+  ${colors.green('$ rek serve wh -p 8080')}              ${colors.gray('Start on port 8080')}
+  ${colors.green('$ rek serve webhook --status 200')}    ${colors.gray('Return 200 instead of 204')}
+
+${colors.bold(colors.yellow('Endpoints:'))}
+  * /              ${colors.gray('Receive webhook without ID')}
+  * /:id           ${colors.gray('Receive webhook with custom ID')}
+
+${colors.bold(colors.yellow('Methods:'))}
+  ${colors.gray('GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS')}
+`)
+        .action(async (options) => {
+        const { createWebhookServer } = await import('../testing/mock-http-server.js');
+        const status = parseInt(options.status);
+        if (status !== 200 && status !== 204) {
+            console.error(colors.red('Status must be 200 or 204'));
+            process.exit(1);
+        }
+        const server = await createWebhookServer({
+            port: parseInt(options.port),
+            host: options.host,
+            status,
+            log: !options.quiet,
+        });
+        console.log(colors.green(`
+┌─────────────────────────────────────────────┐
+│  ${colors.bold('Recker Webhook Receiver')}                   │
+├─────────────────────────────────────────────┤
+│  URL: ${colors.cyan(server.url.padEnd(37))}│
+│  Status: ${colors.yellow(String(status).padEnd(34))}│
+├─────────────────────────────────────────────┤
+│  ${colors.cyan('*')} ${colors.cyan('/')}            ${colors.gray('Webhook without ID')}        │
+│  ${colors.cyan('*')} ${colors.cyan('/:id')}         ${colors.gray('Webhook with custom ID')}    │
+├─────────────────────────────────────────────┤
+│  Press ${colors.bold('Ctrl+C')} to stop                       │
+└─────────────────────────────────────────────┘
+`));
+        process.on('SIGINT', async () => {
+            console.log(colors.yellow('\nShutting down...'));
+            console.log(colors.gray(`Total webhooks received: ${server.webhooks.length}`));
+            await server.stop();
+            process.exit(0);
+        });
+    });
     serve
         .command('websocket')
         .alias('ws')

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

@@ -13,6 +13,8 @@ export declare class SearchPanel {
     private rightPanelWidth;
     private contentHeight;
     private previewContent;
+    private keyHandler;
+    private resizeHandler;
     constructor(options?: SearchPanelOptions);
     private findDocsPath;
     open(): Promise<void>;

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

@@ -34,6 +34,8 @@ export class SearchPanel {
     rightPanelWidth = 0;
     contentHeight = 0;
     previewContent = [];
+    keyHandler = null;
+    resizeHandler = null;
     constructor(options = {}) {
         this.state = {
             query: options.initialQuery || '',
@@ -69,11 +71,13 @@ export class SearchPanel {
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(true);
         }
-        process.stdout.on('resize', () => {
+        this.resizeHandler = () => {
             this.updateDimensions();
             this.render();
-        });
-        process.stdin.on('data', this.handleKeyInput.bind(this));
+        };
+        process.stdout.on('resize', this.resizeHandler);
+        this.keyHandler = this.handleKeyInput.bind(this);
+        process.stdin.on('data', this.keyHandler);
         if (this.state.query) {
             await this.performSearch();
         }
@@ -99,8 +103,14 @@ export class SearchPanel {
             this.rl.close();
             this.rl = null;
         }
-        process.stdin.removeAllListeners('data');
-        process.stdout.removeAllListeners('resize');
+        if (this.keyHandler) {
+            process.stdin.removeListener('data', this.keyHandler);
+            this.keyHandler = null;
+        }
+        if (this.resizeHandler) {
+            process.stdout.removeListener('resize', this.resizeHandler);
+            this.resizeHandler = null;
+        }
     }
     updateDimensions() {
         this.termWidth = process.stdout.columns || 80;

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

@@ -1,21 +1,27 @@
 import type { SearchResult } from '../../mcp/search/types.js';
+export type ProgressCallback = (stage: string, percent?: number) => void;
 export declare class ShellSearch {
     private hybridSearch;
     private docsIndex;
     private codeExamples;
     private typeDefinitions;
     private initialized;
+    private initializing;
     private idleTimer;
     private docsPath;
     private examplesPath;
     private srcPath;
+    private spinner;
+    private hasSemanticSearch;
     constructor();
+    private updateSpinner;
     private ensureInitialized;
     private resetIdleTimer;
     private unload;
     search(query: string, options?: {
         limit?: number;
         category?: string;
+        silent?: boolean;
     }): Promise<SearchResult[]>;
     suggest(useCase: string): Promise<string>;
     getExamples(feature: string, options?: {

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

@@ -1,7 +1,8 @@
-import { createHybridSearch } from '../../mcp/search/index.js';
+import { createHybridSearch, createEmbedder, isFastembedAvailable } from '../../mcp/search/index.js';
 import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
 import { join, relative, extname, basename, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { createSpinner } from './spinner.js';
 const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
 export class ShellSearch {
     hybridSearch = null;
@@ -9,24 +10,61 @@ export class ShellSearch {
     codeExamples = [];
     typeDefinitions = [];
     initialized = false;
+    initializing = false;
     idleTimer = null;
     docsPath;
     examplesPath;
     srcPath;
+    spinner = null;
+    hasSemanticSearch = false;
     constructor() {
         this.docsPath = this.findDocsPath();
         this.examplesPath = this.findExamplesPath();
         this.srcPath = this.findSrcPath();
     }
+    updateSpinner(text) {
+        if (this.spinner) {
+            this.spinner.text = text;
+        }
+    }
     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;
+        if (this.initializing) {
+            while (this.initializing) {
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            return;
+        }
+        this.initializing = true;
+        this.spinner = createSpinner({ text: 'Initializing search...' }).start();
+        try {
+            this.updateSpinner('Creating search index...');
+            this.hybridSearch = createHybridSearch({ debug: false });
+            this.updateSpinner('Checking semantic search availability...');
+            const fastembedAvailable = await isFastembedAvailable();
+            if (fastembedAvailable) {
+                this.updateSpinner('Loading AI embedding model (first time may take a while)...');
+                this.hybridSearch.setEmbedder(createEmbedder());
+                this.hasSemanticSearch = true;
+            }
+            this.updateSpinner('Indexing documentation...');
+            this.buildIndex();
+            this.updateSpinner('Finalizing search index...');
+            await this.hybridSearch.initialize(this.docsIndex);
+            this.initialized = true;
+            this.spinner.succeed(`Search ready (${this.docsIndex.length} docs${this.hasSemanticSearch ? ', semantic enabled' : ''})`);
+        }
+        catch (error) {
+            this.spinner.fail(`Search initialization failed: ${error}`);
+            throw error;
+        }
+        finally {
+            this.initializing = false;
+            this.spinner = null;
+        }
     }
     resetIdleTimer() {
         if (this.idleTimer) {
@@ -45,22 +83,46 @@ export class ShellSearch {
     }
     async search(query, options = {}) {
         await this.ensureInitialized();
-        const { limit = 5, category } = options;
+        const { limit = 5, category, silent = false } = options;
         if (!this.hybridSearch) {
             return [];
         }
-        return this.hybridSearch.search(query, { limit, category, mode: 'hybrid' });
+        let searchSpinner = null;
+        if (!silent && this.hasSemanticSearch) {
+            searchSpinner = createSpinner({ text: 'Generating query embedding...' }).start();
+        }
+        try {
+            if (searchSpinner) {
+                searchSpinner.text = 'Searching documentation...';
+            }
+            const results = await this.hybridSearch.search(query, { limit, category, mode: 'hybrid' });
+            if (searchSpinner) {
+                searchSpinner.succeed(`Found ${results.length} result${results.length !== 1 ? 's' : ''}`);
+            }
+            return results;
+        }
+        catch (error) {
+            if (searchSpinner) {
+                searchSpinner.fail(`Search failed: ${error}`);
+            }
+            throw error;
+        }
     }
     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:**
+        const spinner = createSpinner({ text: 'Generating suggestions...' }).start();
+        try {
+            await this.ensureInitialized();
+            spinner.text = 'Finding relevant documentation...';
+            const results = await this.search(useCase, { limit: 3, silent: true });
+            if (results.length === 0) {
+                spinner.info('No suggestions found');
+                return `No suggestions found for: "${useCase}"\n\nTry searching for specific features like:\n  - retry\n  - cache\n  - streaming\n  - websocket\n  - pagination`;
+            }
+            spinner.text = 'Building suggestions...';
+            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';
 
@@ -74,9 +136,9 @@ const client = createClient({
   }
 });
 \`\`\``);
-        }
-        if (useCaseLower.includes('cache') || useCaseLower.includes('storage')) {
-            suggestions.push(`\n**Cache Configuration:**
+            }
+            if (useCaseLower.includes('cache') || useCaseLower.includes('storage')) {
+                suggestions.push(`\n**Cache Configuration:**
 \`\`\`typescript
 import { createClient } from 'recker';
 
@@ -89,9 +151,9 @@ const client = createClient({
   }
 });
 \`\`\``);
-        }
-        if (useCaseLower.includes('stream') || useCaseLower.includes('sse') || useCaseLower.includes('ai') || useCaseLower.includes('openai')) {
-            suggestions.push(`\n**Streaming Configuration:**
+            }
+            if (useCaseLower.includes('stream') || useCaseLower.includes('sse') || useCaseLower.includes('ai') || useCaseLower.includes('openai')) {
+                suggestions.push(`\n**Streaming Configuration:**
 \`\`\`typescript
 import { createClient } from 'recker';
 
@@ -102,9 +164,9 @@ for await (const event of client.post('/v1/chat/completions', { body, stream: tr
   console.log(event.data);
 }
 \`\`\``);
-        }
-        if (useCaseLower.includes('parallel') || useCaseLower.includes('batch') || useCaseLower.includes('concurrent')) {
-            suggestions.push(`\n**Batch/Parallel Requests:**
+            }
+            if (useCaseLower.includes('parallel') || useCaseLower.includes('batch') || useCaseLower.includes('concurrent')) {
+                suggestions.push(`\n**Batch/Parallel Requests:**
 \`\`\`typescript
 import { createClient } from 'recker';
 
@@ -119,19 +181,25 @@ const { results, stats } = await client.batch([
   { 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`;
             }
+            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`;
+                }
+            }
+            spinner.succeed('Suggestions ready');
+            return output;
+        }
+        catch (error) {
+            spinner.fail(`Failed to generate suggestions: ${error}`);
+            throw error;
         }
-        return output;
     }
     async getExamples(feature, options = {}) {
         await this.ensureInitialized();

package/dist/cli/tui/shell.js

@@ -13,7 +13,7 @@ import { ScrapeDocument } from '../../scrape/document.js';
 import colors from '../../utils/colors.js';
 import { getShellSearch } from './shell-search.js';
 import { openSearchPanel } from './search-panel.js';
-import { ScrollBuffer, parseScrollKey, parseMouseScroll, enableMouseReporting, disableMouseReporting } from './scroll-buffer.js';
+import { ScrollBuffer, parseScrollKey, parseMouseScroll, disableMouseReporting } from './scroll-buffer.js';
 let highlight;
 async function initDependencies() {
     if (!highlight) {
@@ -106,7 +106,7 @@ export class RekShell {
         console.clear();
         console.log(colors.bold(colors.cyan('Rek Console')));
         console.log(colors.gray('Chat with your APIs. Type "help" for magic.'));
-        console.log(colors.gray('Page Up/Down or mouse scroll to view history.'));
+        console.log(colors.gray('Use Page Up/Down to view history.'));
         console.log(colors.gray('--------------------------------------------\n'));
         this.prompt();
         this.rl.on('line', async (line) => {
@@ -150,7 +150,6 @@ export class RekShell {
         disableMouseReporting();
     }
     setupScrollKeyHandler() {
-        enableMouseReporting();
         if (process.stdin.isTTY) {
             const originalEmit = process.stdin.emit.bind(process.stdin);
             const self = this;
@@ -2060,10 +2059,12 @@ ${colors.bold('Network:')}
             this.rl.pause();
             await openSearchPanel(query.trim() || undefined);
             this.rl.resume();
+            this.prompt();
         }
         catch (error) {
             console.error(colors.red(`Search failed: ${error.message}`));
             this.rl.resume();
+            this.prompt();
         }
     }
     async runSuggest(useCase) {
@@ -2209,7 +2210,6 @@ ${colors.bold('Network:')}
   ${colors.bold('Navigation:')}
     ${colors.green('Page Up/Down')}        Scroll through command history.
     ${colors.green('Home/End')}            Jump to top/bottom of history.
-    ${colors.green('Mouse Scroll')}        Scroll with mouse wheel.
     ${colors.green('Escape')}              Exit scroll mode.
 
   ${colors.bold('Examples:')}

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

@@ -0,0 +1,16 @@
+export interface SpinnerOptions {
+    text?: string;
+    color?: 'cyan' | 'green' | 'yellow' | 'red' | 'blue' | 'magenta' | 'white' | 'gray';
+}
+export interface Spinner {
+    text: string;
+    start(): Spinner;
+    stop(): Spinner;
+    succeed(text?: string): Spinner;
+    fail(text?: string): Spinner;
+    info(text?: string): Spinner;
+    warn(text?: string): Spinner;
+    isSpinning: boolean;
+}
+export declare function createSpinner(options?: SpinnerOptions | string): Spinner;
+export default createSpinner;

package/dist/cli/tui/spinner.js

@@ -0,0 +1,97 @@
+import colors from '../../utils/colors.js';
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const FRAME_INTERVAL = 80;
+class TerminalSpinner {
+    _text;
+    color;
+    frameIndex = 0;
+    intervalId = null;
+    stream = process.stderr;
+    isSpinning = false;
+    constructor(options = {}) {
+        this._text = options.text || '';
+        this.color = this.getColorFn(options.color || 'cyan');
+    }
+    getColorFn(color) {
+        switch (color) {
+            case 'green': return colors.green;
+            case 'yellow': return colors.yellow;
+            case 'red': return colors.red;
+            case 'blue': return colors.blue;
+            case 'magenta': return colors.magenta;
+            case 'gray': return colors.gray;
+            case 'white': return (s) => s;
+            case 'cyan':
+            default: return colors.cyan;
+        }
+    }
+    get text() {
+        return this._text;
+    }
+    set text(value) {
+        this._text = value;
+    }
+    start() {
+        if (this.isSpinning)
+            return this;
+        this.isSpinning = true;
+        this.frameIndex = 0;
+        this.stream.write('\x1b[?25l');
+        this.intervalId = setInterval(() => {
+            this.render();
+            this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+        }, FRAME_INTERVAL);
+        return this;
+    }
+    render() {
+        const frame = SPINNER_FRAMES[this.frameIndex];
+        const line = `${this.color(frame)} ${this._text}`;
+        this.stream.write(`\r\x1b[K${line}`);
+    }
+    clearLine() {
+        this.stream.write('\r\x1b[K');
+    }
+    stop() {
+        if (!this.isSpinning)
+            return this;
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        this.isSpinning = false;
+        this.clearLine();
+        this.stream.write('\x1b[?25h');
+        return this;
+    }
+    succeed(text) {
+        this.stop();
+        const finalText = text ?? this._text;
+        console.log(`${colors.green('✔')} ${finalText}`);
+        return this;
+    }
+    fail(text) {
+        this.stop();
+        const finalText = text ?? this._text;
+        console.log(`${colors.red('✖')} ${finalText}`);
+        return this;
+    }
+    info(text) {
+        this.stop();
+        const finalText = text ?? this._text;
+        console.log(`${colors.blue('ℹ')} ${finalText}`);
+        return this;
+    }
+    warn(text) {
+        this.stop();
+        const finalText = text ?? this._text;
+        console.log(`${colors.yellow('⚠')} ${finalText}`);
+        return this;
+    }
+}
+export function createSpinner(options) {
+    if (typeof options === 'string') {
+        return new TerminalSpinner({ text: options });
+    }
+    return new TerminalSpinner(options);
+}
+export default createSpinner;

package/dist/mcp/search/embedder.d.ts

@@ -0,0 +1,9 @@
+export declare function unloadEmbedder(): void;
+export declare function embed(text: string): Promise<number[]>;
+export declare function embedBatch(texts: string[]): Promise<number[][]>;
+export declare function createEmbedder(): (text: string, model?: string) => Promise<number[]>;
+export declare function isFastembedAvailable(): Promise<boolean>;
+export declare function getModelInfo(): {
+    name: string;
+    dimensions: number;
+};

package/dist/mcp/search/embedder.js

@@ -0,0 +1,83 @@
+const MODEL_NAME = 'BGESmallENV15';
+const MODEL_DIMENSIONS = 384;
+let embedderInstance = null;
+let embedderPromise = null;
+let idleTimer = null;
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+function resetIdleTimer() {
+    if (idleTimer) {
+        clearTimeout(idleTimer);
+    }
+    idleTimer = setTimeout(() => {
+        unloadEmbedder();
+    }, IDLE_TIMEOUT_MS);
+}
+export function unloadEmbedder() {
+    if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+    }
+    embedderInstance = null;
+    embedderPromise = null;
+}
+async function getEmbedder() {
+    if (embedderInstance) {
+        resetIdleTimer();
+        return embedderInstance;
+    }
+    if (embedderPromise) {
+        return embedderPromise;
+    }
+    embedderPromise = (async () => {
+        try {
+            const { EmbeddingModel, FlagEmbedding } = await import('fastembed');
+            embedderInstance = await FlagEmbedding.init({
+                model: EmbeddingModel[MODEL_NAME],
+            });
+            resetIdleTimer();
+            return embedderInstance;
+        }
+        catch (error) {
+            embedderPromise = null;
+            throw new Error(`Failed to initialize embedder: ${error}`);
+        }
+    })();
+    return embedderPromise;
+}
+export async function embed(text) {
+    const embedder = await getEmbedder();
+    const embeddings = await embedder.embed([text]);
+    for await (const embedding of embeddings) {
+        const vec = Array.isArray(embedding) ? embedding[0] : embedding;
+        return Array.from(vec);
+    }
+    throw new Error('No embedding generated');
+}
+export async function embedBatch(texts) {
+    const embedder = await getEmbedder();
+    const embeddings = await embedder.embed(texts);
+    const results = [];
+    for await (const embedding of embeddings) {
+        const vec = Array.isArray(embedding) ? embedding[0] : embedding;
+        results.push(Array.from(vec));
+    }
+    return results;
+}
+export function createEmbedder() {
+    return (text, _model) => embed(text);
+}
+export async function isFastembedAvailable() {
+    try {
+        await import('fastembed');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getModelInfo() {
+    return {
+        name: MODEL_NAME,
+        dimensions: MODEL_DIMENSIONS,
+    };
+}

package/dist/mcp/search/hybrid-search.d.ts

@@ -7,6 +7,7 @@ export declare class HybridSearch {
     private initialized;
     private config;
     constructor(config?: HybridSearchConfig);
+    setEmbedder(embedder: (text: string, model?: string) => Promise<number[]>): void;
     initialize(docs: IndexedDoc[]): Promise<void>;
     private loadPrecomputedEmbeddings;
     search(query: string, options?: SearchOptions): Promise<SearchResult[]>;

package/dist/mcp/search/hybrid-search.js

@@ -16,8 +16,12 @@ export class HybridSearch {
             fuzzyWeight: config.fuzzyWeight ?? 0.5,
             semanticWeight: config.semanticWeight ?? 0.5,
             debug: config.debug ?? false,
+            embedder: config.embedder,
         };
     }
+    setEmbedder(embedder) {
+        this.config.embedder = embedder;
+    }
     async initialize(docs) {
         this.docs = docs;
         this.fuse = new Fuse(docs, {
@@ -55,8 +59,13 @@ export class HybridSearch {
             }
             if (this.embeddingsData) {
                 for (const entry of this.embeddingsData.documents) {
-                    if (entry.vector && entry.vector.length > 0) {
-                        this.vectors.set(entry.id, entry.vector);
+                    if (entry.vector) {
+                        const vec = Array.isArray(entry.vector)
+                            ? entry.vector
+                            : Object.values(entry.vector);
+                        if (vec.length > 0) {
+                            this.vectors.set(entry.id, vec);
+                        }
                     }
                 }
                 this.log(`Loaded ${this.vectors.size} pre-computed embeddings (model: ${this.embeddingsData.model})`);
@@ -86,7 +95,7 @@ export class HybridSearch {
             this.log(`Fuzzy search found ${fuzzyResults.length} results`);
         }
         if ((mode === 'hybrid' || mode === 'semantic') && this.vectors.size > 0) {
-            const semanticResults = this.semanticSearch(searchQuery, limit * 2, category);
+            const semanticResults = await this.semanticSearch(searchQuery, limit * 2, category);
             for (const result of semanticResults) {
                 const existing = results.get(result.id);
                 if (existing) {
@@ -152,10 +161,53 @@ export class HybridSearch {
             source: 'fuzzy',
         }));
     }
-    semanticSearch(query, limit, category) {
+    async semanticSearch(query, limit, category) {
         if (!this.embeddingsData || this.vectors.size === 0) {
             return [];
         }
+        if (this.config.embedder) {
+            try {
+                const model = this.embeddingsData.model;
+                const queryVector = await this.config.embedder(query, model);
+                this.log(`Generated query vector using provided embedder (model: ${model})`);
+                const scores = [];
+                for (const [id, vector] of this.vectors) {
+                    if (category) {
+                        const entry = this.embeddingsData.documents.find((e) => e.id === id);
+                        if (!entry || !entry.category.toLowerCase().includes(category.toLowerCase())) {
+                            continue;
+                        }
+                    }
+                    if (vector.length !== queryVector.length)
+                        continue;
+                    const score = cosineSimilarity(queryVector, vector);
+                    if (score > 0.05) {
+                        scores.push({ id, score });
+                    }
+                }
+                const results = [];
+                for (const s of scores.sort((a, b) => b.score - a.score).slice(0, limit)) {
+                    const doc = this.docs.find((d) => d.id === s.id);
+                    const entry = this.embeddingsData.documents.find((e) => e.id === s.id);
+                    if (!doc && !entry)
+                        continue;
+                    const content = doc?.content || '';
+                    results.push({
+                        id: s.id,
+                        path: doc?.path || entry?.path || '',
+                        title: doc?.title || entry?.title || 'Unknown',
+                        content,
+                        snippet: this.extractSnippet(content, query),
+                        score: s.score,
+                        source: 'semantic',
+                    });
+                }
+                return results;
+            }
+            catch (error) {
+                this.log(`Embedder failed: ${error}. Falling back to synthetic vectors.`);
+            }
+        }
         const queryTerms = this.tokenize(query);
         const scores = [];
         for (const entry of this.embeddingsData.documents) {

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

@@ -1,3 +1,4 @@
 export { HybridSearch, createHybridSearch } from './hybrid-search.js';
 export { cosineSimilarity, levenshtein, stringSimilarity, reciprocalRankFusion, combineScores, } from './math.js';
+export { embed, embedBatch, createEmbedder, isFastembedAvailable, getModelInfo, unloadEmbedder, } from './embedder.js';
 export type { IndexedDoc, SearchResult, SearchOptions, HybridSearchConfig, EmbeddingsData, EmbeddingEntry, } from './types.js';

package/dist/mcp/search/index.js

@@ -1,2 +1,3 @@
 export { HybridSearch, createHybridSearch } from './hybrid-search.js';
 export { cosineSimilarity, levenshtein, stringSimilarity, reciprocalRankFusion, combineScores, } from './math.js';
+export { embed, embedBatch, createEmbedder, isFastembedAvailable, getModelInfo, unloadEmbedder, } from './embedder.js';

package/dist/mcp/search/types.d.ts

@@ -45,4 +45,5 @@ export interface HybridSearchConfig {
     fuzzyWeight?: number;
     semanticWeight?: number;
     debug?: boolean;
+    embedder?: (text: string, model?: string) => Promise<number[]>;
 }

package/dist/mcp/server.d.ts

@@ -22,9 +22,13 @@ export declare class MCPServer {
     private sseClients;
     private initialized;
     private toolRegistry;
+    private aiClient?;
     constructor(options?: MCPServerOptions);
     private indexReady;
     private ensureIndexReady;
+    private initAI;
+    private fastEmbedModel;
+    private generateEmbedding;
     private log;
     private findDocsPath;
     private findExamplesPath;

package/dist/mcp/server.js

@@ -3,6 +3,7 @@ import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
 import { join, relative, extname, basename, dirname } from 'path';
 import { createInterface } from 'readline';
 import { fileURLToPath } from 'url';
+import { createAI } from '../ai/index.js';
 import { createHybridSearch } from './search/index.js';
 import { UnsupportedError } from '../core/errors.js';
 import { getIpInfo, isValidIP, isGeoIPAvailable, isBogon, isIPv6 } from './ip-intel.js';
@@ -19,6 +20,7 @@ export class MCPServer {
     sseClients = new Set();
     initialized = false;
     toolRegistry;
+    aiClient;
     constructor(options = {}) {
         this.options = {
             name: options.name || 'recker-docs',
@@ -32,7 +34,11 @@ export class MCPServer {
             toolsFilter: options.toolsFilter || [],
             toolPaths: options.toolPaths || [],
         };
-        this.hybridSearch = createHybridSearch({ debug: this.options.debug });
+        this.aiClient = this.initAI();
+        this.hybridSearch = createHybridSearch({
+            debug: this.options.debug,
+            embedder: (text, model) => this.generateEmbedding(text, model || 'BGESmallENV15'),
+        });
         this.toolRegistry = new ToolRegistry();
         this.registerInternalTools();
         this.toolRegistry.registerModule({
@@ -47,6 +53,56 @@ export class MCPServer {
         }
         await this.indexReady;
     }
+    initAI() {
+        const hasKeys = process.env.OPENAI_API_KEY || process.env.GOOGLE_API_KEY;
+        const hasLocal = process.env.OLLAMA_HOST || true;
+        if (!hasKeys) {
+            return undefined;
+        }
+        try {
+            return createAI({ debug: this.options.debug });
+        }
+        catch (e) {
+            this.log('Failed to initialize AI client:', e);
+            return undefined;
+        }
+    }
+    fastEmbedModel = null;
+    async generateEmbedding(text, model) {
+        if (model.toLowerCase().includes('bge')) {
+            if (!this.fastEmbedModel) {
+                try {
+                    const fastembed = await import('fastembed');
+                    const { FlagEmbedding } = fastembed;
+                    this.fastEmbedModel = await FlagEmbedding.init({
+                        model: model,
+                        showDownloadProgress: false
+                    });
+                }
+                catch (e) {
+                    throw new Error(`FastEmbed required for model ${model}. Install with: pnpm add fastembed`);
+                }
+            }
+            const vectors = this.fastEmbedModel.embed([text]);
+            for await (const v of vectors)
+                return Array.from(v);
+            throw new Error('No vector generated');
+        }
+        if (!this.aiClient) {
+            throw new Error('No AI client available for external embeddings');
+        }
+        let provider = 'openai';
+        if (model.includes('google') || model.includes('gecko'))
+            provider = 'google';
+        else if (model.includes('nomic') || model.includes('llama'))
+            provider = 'ollama';
+        const res = await this.aiClient.embed({
+            input: text,
+            provider,
+            model
+        });
+        return res.embeddings[0];
+    }
     log(message, data) {
         if (this.options.debug) {
             if (this.options.transport === 'stdio') {

package/dist/mini.d.ts

@@ -16,6 +16,12 @@ export interface MiniClient {
     put<T = unknown>(path: string, body?: unknown): Promise<MiniResponse<T>>;
     patch<T = unknown>(path: string, body?: unknown): Promise<MiniResponse<T>>;
     delete<T = unknown>(path: string): Promise<MiniResponse<T>>;
+    head<T = unknown>(path: string): Promise<MiniResponse<T>>;
+    options<T = unknown>(path: string): Promise<MiniResponse<T>>;
+    trace<T = unknown>(path: string): Promise<MiniResponse<T>>;
+    purge<T = unknown>(path: string): Promise<MiniResponse<T>>;
+    request<T = unknown>(method: string, path: string, body?: unknown): Promise<MiniResponse<T>>;
+    close(): Promise<void>;
 }
 export declare function createMiniClient(options: MiniClientOptions): MiniClient;
 export declare function miniGet<T = unknown>(url: string, headers?: Record<string, string>): Promise<MiniResponse<T>>;

package/dist/mini.js

@@ -1,8 +1,9 @@
-import { request as undiciRequest } from 'undici';
+import { Client, request as undiciRequest } from 'undici';
 export function createMiniClient(options) {
     const base = options.baseUrl.endsWith('/')
         ? options.baseUrl.slice(0, -1)
         : options.baseUrl;
+    const undiciClient = new Client(base);
     const defaultHeaders = options.headers || {};
     const jsonHeaders = {
         ...defaultHeaders,
@@ -16,44 +17,48 @@ export function createMiniClient(options) {
         arrayBuffer: () => body.arrayBuffer(),
         blob: async () => new Blob([await body.arrayBuffer()])
     });
+    const doRequest = async (method, path, body, useJsonHeaders = false) => {
+        const { statusCode, headers, body: resBody } = await undiciClient.request({
+            path,
+            method,
+            headers: useJsonHeaders ? jsonHeaders : defaultHeaders,
+            body: body !== undefined ? JSON.stringify(body) : undefined
+        });
+        return wrapResponse(statusCode, headers, resBody);
+    };
     return {
         async get(path) {
-            const { statusCode, headers, body } = await undiciRequest(base + path, {
-                method: 'GET',
-                headers: defaultHeaders
-            });
-            return wrapResponse(statusCode, headers, body);
+            return doRequest('GET', path);
         },
         async post(path, data) {
-            const { statusCode, headers, body } = await undiciRequest(base + path, {
-                method: 'POST',
-                headers: jsonHeaders,
-                body: data !== undefined ? JSON.stringify(data) : undefined
-            });
-            return wrapResponse(statusCode, headers, body);
+            return doRequest('POST', path, data, true);
         },
         async put(path, data) {
-            const { statusCode, headers, body } = await undiciRequest(base + path, {
-                method: 'PUT',
-                headers: jsonHeaders,
-                body: data !== undefined ? JSON.stringify(data) : undefined
-            });
-            return wrapResponse(statusCode, headers, body);
+            return doRequest('PUT', path, data, true);
         },
         async patch(path, data) {
-            const { statusCode, headers, body } = await undiciRequest(base + path, {
-                method: 'PATCH',
-                headers: jsonHeaders,
-                body: data !== undefined ? JSON.stringify(data) : undefined
-            });
-            return wrapResponse(statusCode, headers, body);
+            return doRequest('PATCH', path, data, true);
         },
         async delete(path) {
-            const { statusCode, headers, body } = await undiciRequest(base + path, {
-                method: 'DELETE',
-                headers: defaultHeaders
-            });
-            return wrapResponse(statusCode, headers, body);
+            return doRequest('DELETE', path);
+        },
+        async head(path) {
+            return doRequest('HEAD', path);
+        },
+        async options(path) {
+            return doRequest('OPTIONS', path);
+        },
+        async trace(path) {
+            return doRequest('TRACE', path);
+        },
+        async purge(path) {
+            return doRequest('PURGE', path);
+        },
+        async request(method, path, body) {
+            return doRequest(method.toUpperCase(), path, body, body !== undefined);
+        },
+        async close() {
+            await undiciClient.close();
         }
     };
 }

package/dist/testing/index.d.ts

@@ -8,8 +8,8 @@ export { MockWebSocketServer, createMockWebSocketServer, } from './mock-websocke
 export type { MockWebSocketServerOptions, MockWebSocketClient, MockWebSocketMessage, MockWebSocketStats, } from './mock-websocket-server.js';
 export { MockSSEServer, createMockSSEServer, } from './mock-sse-server.js';
 export type { MockSSEServerOptions, SSEEvent, MockSSEClient, MockSSEStats, } from './mock-sse-server.js';
-export { MockHttpServer, createMockHttpServer, } from './mock-http-server.js';
-export type { MockHttpServerOptions, MockHttpResponse, MockHttpRequest, MockHttpHandler, MockHttpStats, } from './mock-http-server.js';
+export { MockHttpServer, createMockHttpServer, createWebhookServer, } from './mock-http-server.js';
+export type { MockHttpServerOptions, MockHttpResponse, MockHttpRequest, MockHttpHandler, MockHttpStats, WebhookServerOptions, WebhookPayload, } from './mock-http-server.js';
 export { MockDnsServer, } from './mock-dns-server.js';
 export type { MockDnsServerOptions, DnsRecordType, DnsRecord, DnsMxRecord, DnsSoaRecord, DnsSrvRecord, MockDnsStats, } from './mock-dns-server.js';
 export { MockWhoisServer, } from './mock-whois-server.js';

package/dist/testing/index.js

@@ -3,7 +3,7 @@ export { MockUDPServer, createMockUDPServer, } from './mock-udp-server.js';
 export { MockHlsServer, createMockHlsVod, createMockHlsLive, createMockHlsMultiQuality, } from './mock-hls-server.js';
 export { MockWebSocketServer, createMockWebSocketServer, } from './mock-websocket-server.js';
 export { MockSSEServer, createMockSSEServer, } from './mock-sse-server.js';
-export { MockHttpServer, createMockHttpServer, } from './mock-http-server.js';
+export { MockHttpServer, createMockHttpServer, createWebhookServer, } from './mock-http-server.js';
 export { MockDnsServer, } from './mock-dns-server.js';
 export { MockWhoisServer, } from './mock-whois-server.js';
 export { MockTelnetServer, } from './mock-telnet-server.js';

package/dist/testing/mock-http-server.d.ts

@@ -81,6 +81,15 @@ export declare class MockHttpServer extends EventEmitter {
     optionsRoute(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
         times?: number;
     }): this;
+    trace(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    connect(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    purge(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
     any(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
         times?: number;
     }): this;
@@ -97,3 +106,19 @@ export declare class MockHttpServer extends EventEmitter {
     static create(options?: MockHttpServerOptions): Promise<MockHttpServer>;
 }
 export declare function createMockHttpServer(routes?: Record<string, MockHttpResponse>, options?: MockHttpServerOptions): Promise<MockHttpServer>;
+export interface WebhookServerOptions extends MockHttpServerOptions {
+    log?: boolean;
+    logger?: (webhook: WebhookPayload) => void;
+    status?: 200 | 204;
+}
+export interface WebhookPayload {
+    id: string | null;
+    timestamp: Date;
+    method: string;
+    path: string;
+    headers: Record<string, string | string[] | undefined>;
+    body: any;
+}
+export declare function createWebhookServer(options?: WebhookServerOptions): Promise<MockHttpServer & {
+    webhooks: WebhookPayload[];
+}>;

package/dist/testing/mock-http-server.js

@@ -113,6 +113,15 @@ export class MockHttpServer extends EventEmitter {
     optionsRoute(path, handler, options) {
         return this.route('OPTIONS', path, handler, options);
     }
+    trace(path, handler, options) {
+        return this.route('TRACE', path, handler, options);
+    }
+    connect(path, handler, options) {
+        return this.route('CONNECT', path, handler, options);
+    }
+    purge(path, handler, options) {
+        return this.route('PURGE', path, handler, options);
+    }
     any(path, handler, options) {
         return this.route('*', path, handler, options);
     }
@@ -296,3 +305,39 @@ export async function createMockHttpServer(routes, options) {
     await server.start();
     return server;
 }
+export async function createWebhookServer(options = {}) {
+    const { log = true, logger, status = 204, ...serverOptions } = options;
+    const server = new MockHttpServer(serverOptions);
+    const webhooks = [];
+    const handleWebhook = (req, id) => {
+        const payload = {
+            id,
+            timestamp: new Date(),
+            method: req.method,
+            path: req.path,
+            headers: req.headers,
+            body: req.body,
+        };
+        webhooks.push(payload);
+        if (logger) {
+            logger(payload);
+        }
+        else if (log) {
+            const idStr = id ? ` [${id}]` : '';
+            console.log(`\n📥 Webhook received${idStr} at ${payload.timestamp.toISOString()}`);
+            console.log(`   Path: ${req.path}`);
+            if (req.body !== undefined) {
+                console.log(`   Body:`, typeof req.body === 'object' ? JSON.stringify(req.body, null, 2) : req.body);
+            }
+        }
+        return { status };
+    };
+    server.any('/', (req) => handleWebhook(req, null));
+    server.any('/:id', (req) => {
+        const match = req.path.match(/^\/([^/]+)$/);
+        const id = match ? match[1] : null;
+        return handleWebhook(req, id);
+    });
+    await server.start();
+    return Object.assign(server, { webhooks });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.22",
+  "version": "1.0.25-next.566f437",
   "description": "AI & DevX focused HTTP client for Node.js 18+",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -131,7 +131,6 @@
     "cheerio": "^1.0.0",
     "commander": "^14.0.2",
     "fuse.js": "^7.1.0",
-    "ora": "^9.0.0",
     "undici": "^7.16.0",
     "zod": "^4.1.13"
   },
@@ -174,7 +173,6 @@
     "mitata": "^1.0.34",
     "needle": "^3.3.1",
     "node-fetch": "^3.3.2",
-    "ora": "^9.0.0",
     "picocolors": "^1.1.1",
     "popsicle": "^12.1.2",
     "serve": "^14.2.5",