recker 1.0.68 → 1.0.70-next.9b4eebc

package/dist/cli/commands/vector.js

@@ -1,214 +0,0 @@
-import colors from '../../utils/colors.js';
-import { MemoryVectorStore } from '../../ai/vector/store.js';
-import { promises as fs } from 'node:fs';
-async function loadStore(filePath) {
-    try {
-        const content = await fs.readFile(filePath, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        return [];
-    }
-}
-async function saveStore(filePath, docs) {
-    await fs.writeFile(filePath, JSON.stringify(docs, null, 2), 'utf-8');
-}
-async function initAI(provider, model) {
-    const { createAI } = await import('../../ai/index.js');
-    try {
-        const aiClient = createAI({
-            defaultProvider: provider,
-        });
-        return new MemoryVectorStore({
-            client: aiClient,
-            model: model
-        });
-    }
-    catch (e) {
-        console.error(colors.red(`AI Initialization Failed: ${e.message}`));
-        console.log(colors.gray('Ensure you have OPENAI_API_KEY or other provider keys set.'));
-        process.exit(1);
-    }
-}
-export function registerVectorCommand(program) {
-    const vector = program.command('vector')
-        .description('Manage a local vector store for RAG (Retrieval-Augmented Generation)')
-        .example('rek vector add "Recker is a network tool" -f data.json', 'Add document')
-        .example('rek vector search "network tool" -f data.json -l 3', 'Search')
-        .example('rek vector info -f data.json', 'Show stats');
-    vector.command('add')
-        .description('Add a document to the store')
-        .argument('<content>', {
-        type: 'string',
-        description: 'Text content to add',
-        example: 'Recker is a network tool',
-    })
-        .option('file', {
-        type: 'string',
-        short: 'f',
-        default: 'vectors.json',
-        description: 'Vector store file path',
-        example: 'data.json',
-    })
-        .option('metadata', {
-        type: 'string',
-        short: 'm',
-        description: 'Metadata JSON for the document',
-        example: '{"source":"docs"}',
-    })
-        .option('provider', {
-        type: 'string',
-        short: 'p',
-        description: 'AI Provider (openai, google, ollama)',
-        example: 'openai',
-    })
-        .option('model', {
-        type: 'string',
-        description: 'Embedding model',
-        example: 'text-embedding-3-small',
-    })
-        .example('rek vector add "Recker is a network SDK"', 'Add simple document')
-        .example('rek vector add "API docs" -f docs.json -m \'{"type":"docs"}\'', 'Add with metadata')
-        .action(async (content, args, cmdObj) => {
-        const options = cmdObj.opts ? cmdObj.opts() : {};
-        const filePath = options.file || 'vectors.json';
-        const existingDocs = await loadStore(filePath);
-        const store = await initAI(options.provider, options.model);
-        if (existingDocs.length > 0) {
-            await store.add(existingDocs);
-        }
-        let metadata = {};
-        if (options.metadata) {
-            try {
-                metadata = JSON.parse(options.metadata);
-            }
-            catch {
-                console.error(colors.red('Invalid metadata JSON'));
-                process.exit(1);
-            }
-        }
-        console.log(colors.gray(`Generating embedding for: "${content.slice(0, 50)}${content.length > 50 ? '...' : ''}"...`));
-        await store.add([{ content, metadata }]);
-        const allDocs = Array.from(store.documents.values());
-        await saveStore(filePath, allDocs);
-        console.log(colors.green(`✔ Added document. Total: ${store.count}`));
-    });
-    vector.command('search')
-        .description('Search the vector store')
-        .argument('<query>', {
-        type: 'string',
-        description: 'Search query',
-        example: 'network tool',
-    })
-        .option('file', {
-        type: 'string',
-        short: 'f',
-        default: 'vectors.json',
-        description: 'Vector store file path',
-        example: 'data.json',
-    })
-        .option('limit', {
-        type: 'number',
-        short: 'l',
-        default: 3,
-        description: 'Maximum results to return',
-        example: '5',
-    })
-        .option('threshold', {
-        type: 'number',
-        short: 't',
-        default: 0.0,
-        description: 'Similarity threshold (0-1)',
-        example: '0.5',
-    })
-        .option('provider', {
-        type: 'string',
-        short: 'p',
-        description: 'AI Provider (openai, google, ollama)',
-        example: 'openai',
-    })
-        .option('model', {
-        type: 'string',
-        description: 'Embedding model',
-        example: 'text-embedding-3-small',
-    })
-        .option('json', {
-        short: 'j',
-        description: 'Output as JSON',
-    })
-        .example('rek vector search "how to make requests"', 'Basic search')
-        .example('rek vector search "api" -f docs.json -l 5 -t 0.5', 'Search with options')
-        .action(async (query, args, cmdObj) => {
-        const options = cmdObj.opts ? cmdObj.opts() : {};
-        const filePath = options.file || 'vectors.json';
-        const limit = options.limit || 3;
-        const threshold = options.threshold || 0.0;
-        const jsonOutput = !!options.json;
-        const existingDocs = await loadStore(filePath);
-        const store = await initAI(options.provider, options.model);
-        if (existingDocs.length > 0) {
-            await store.add(existingDocs);
-        }
-        console.log(colors.gray(`Searching for: "${query}"...`));
-        const results = await store.search(query, limit, threshold);
-        if (jsonOutput) {
-            console.log(JSON.stringify(results, null, 2));
-            return;
-        }
-        console.log(`\n${colors.bold(colors.cyan('Search Results'))} (${results.length})\n`);
-        results.forEach((res, i) => {
-            const score = (res.score * 100).toFixed(1) + '%';
-            const color = res.score > 0.8 ? colors.green : res.score > 0.5 ? colors.yellow : colors.gray;
-            console.log(`${i + 1}. ${color(score)} - ${res.id}`);
-            console.log(`   ${res.content.slice(0, 100).replace(/\n/g, ' ')}${res.content.length > 100 ? '...' : ''}`);
-            if (res.metadata && Object.keys(res.metadata).length > 0) {
-                console.log(`   ${colors.gray(JSON.stringify(res.metadata))}`);
-            }
-            console.log('');
-        });
-    });
-    vector.command('info')
-        .description('Show store statistics')
-        .option('file', {
-        type: 'string',
-        short: 'f',
-        default: 'vectors.json',
-        description: 'Vector store file path',
-        example: 'data.json',
-    })
-        .option('json', {
-        short: 'j',
-        description: 'Output as JSON',
-    })
-        .example('rek vector info', 'Show default store info')
-        .example('rek vector info -f docs.json -j', 'Show as JSON')
-        .action(async (args, cmdObj) => {
-        const options = cmdObj.opts ? cmdObj.opts() : {};
-        const filePath = options.file || 'vectors.json';
-        const jsonOutput = !!options.json;
-        const existingDocs = await loadStore(filePath);
-        if (jsonOutput) {
-            console.log(JSON.stringify({ file: filePath, count: existingDocs.length, documents: existingDocs }, null, 2));
-            return;
-        }
-        console.log(colors.cyan(`Vector Store: ${filePath}`));
-        console.log(`Documents: ${existingDocs.length}`);
-    });
-    vector.command('clear')
-        .description('Clear the vector store')
-        .option('file', {
-        type: 'string',
-        short: 'f',
-        default: 'vectors.json',
-        description: 'Vector store file path',
-        example: 'data.json',
-    })
-        .example('rek vector clear', 'Clear default store')
-        .example('rek vector clear -f docs.json', 'Clear specific store')
-        .action(async (args, cmdObj) => {
-        const options = cmdObj.opts ? cmdObj.opts() : {};
-        const filePath = options.file || 'vectors.json';
-        await saveStore(filePath, []);
-        console.log(colors.green(`✔ Cleared vector store at ${filePath}`));
-    });
-}

package/dist/mcp/embeddings-loader.d.ts

@@ -1,17 +0,0 @@
-import type { EmbeddingsData } from './search/types.js';
-declare function getPackageVersion(): string;
-export declare function getEmbeddingsCachePath(version?: string): string;
-export declare function hasLocalEmbeddings(version?: string): boolean;
-export declare function loadLocalEmbeddings(version?: string): EmbeddingsData | null;
-export declare function saveLocalEmbeddings(data: EmbeddingsData, version?: string): void;
-export declare function downloadEmbeddings(version?: string): Promise<EmbeddingsData>;
-export declare function loadBundledEmbeddings(): Promise<EmbeddingsData | null>;
-export interface LoadEmbeddingsOptions {
-    forceDownload?: boolean;
-    version?: string;
-    offline?: boolean;
-    debug?: boolean;
-}
-export declare function loadEmbeddings(options?: LoadEmbeddingsOptions): Promise<EmbeddingsData | null>;
-export declare function clearEmbeddingsCache(version?: string): void;
-export { getPackageVersion };

package/dist/mcp/embeddings-loader.js

@@ -1,162 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { DownloadError } from '../core/errors.js';
-function getPackageVersionFromPkg() {
-    try {
-        const __dirname = dirname(fileURLToPath(import.meta.url));
-        const paths = [
-            join(__dirname, '..', '..', 'package.json'),
-            join(__dirname, '..', '..', '..', 'package.json'),
-            join(process.cwd(), 'package.json'),
-        ];
-        for (const pkgPath of paths) {
-            if (existsSync(pkgPath)) {
-                const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-                if (pkg.name === 'recker') {
-                    return pkg.version;
-                }
-            }
-        }
-    }
-    catch {
-    }
-    return '1.0.15';
-}
-let _packageVersion = null;
-function getPackageVersion() {
-    if (!_packageVersion) {
-        _packageVersion = getPackageVersionFromPkg();
-    }
-    return _packageVersion;
-}
-const GITHUB_RELEASE_URL = 'https://github.com/forattini-dev/recker/releases/download';
-function getCacheDir() {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-    if (homeDir) {
-        return join(homeDir, '.cache', 'recker');
-    }
-    try {
-        const __dirname = dirname(fileURLToPath(import.meta.url));
-        return join(__dirname, '..', '..', 'node_modules', '.cache', 'recker');
-    }
-    catch {
-        return join(process.cwd(), 'node_modules', '.cache', 'recker');
-    }
-}
-export function getEmbeddingsCachePath(version) {
-    const cacheDir = getCacheDir();
-    const ver = version || getPackageVersion();
-    return join(cacheDir, `embeddings-${ver}.json`);
-}
-export function hasLocalEmbeddings(version) {
-    return existsSync(getEmbeddingsCachePath(version));
-}
-export function loadLocalEmbeddings(version) {
-    const cachePath = getEmbeddingsCachePath(version);
-    if (!existsSync(cachePath)) {
-        return null;
-    }
-    try {
-        const data = readFileSync(cachePath, 'utf-8');
-        return JSON.parse(data);
-    }
-    catch {
-        return null;
-    }
-}
-export function saveLocalEmbeddings(data, version) {
-    const cachePath = getEmbeddingsCachePath(version);
-    const cacheDir = dirname(cachePath);
-    if (!existsSync(cacheDir)) {
-        mkdirSync(cacheDir, { recursive: true });
-    }
-    writeFileSync(cachePath, JSON.stringify(data));
-}
-export async function downloadEmbeddings(version) {
-    const ver = version || getPackageVersion();
-    const url = `${GITHUB_RELEASE_URL}/v${ver}/embeddings.json`;
-    try {
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new DownloadError(`Failed to download embeddings: ${response.status} ${response.statusText}`, {
-                url,
-                statusCode: response.status,
-                retriable: response.status >= 500,
-            });
-        }
-        const data = await response.json();
-        saveLocalEmbeddings(data, ver);
-        return data;
-    }
-    catch (error) {
-        if (error instanceof DownloadError)
-            throw error;
-        throw new DownloadError(`Failed to download embeddings from ${url}: ${error}`, {
-            url,
-            retriable: true,
-        });
-    }
-}
-export async function loadBundledEmbeddings() {
-    try {
-        const __dirname = dirname(fileURLToPath(import.meta.url));
-        const bundledPath = join(__dirname, 'data', 'embeddings.json');
-        if (existsSync(bundledPath)) {
-            const data = readFileSync(bundledPath, 'utf-8');
-            return JSON.parse(data);
-        }
-        const srcPath = join(__dirname, '..', 'mcp', 'data', 'embeddings.json');
-        if (existsSync(srcPath)) {
-            const data = readFileSync(srcPath, 'utf-8');
-            return JSON.parse(data);
-        }
-    }
-    catch {
-    }
-    return null;
-}
-export async function loadEmbeddings(options = {}) {
-    const { forceDownload = false, version, offline = false, debug = false } = options;
-    const log = (msg) => {
-        if (debug)
-            console.log(`[embeddings-loader] ${msg}`);
-    };
-    if (!forceDownload) {
-        const cached = loadLocalEmbeddings(version);
-        if (cached) {
-            log(`Loaded from cache: ${getEmbeddingsCachePath(version)}`);
-            return cached;
-        }
-    }
-    const bundled = await loadBundledEmbeddings();
-    if (bundled) {
-        log('Loaded bundled embeddings');
-        return bundled;
-    }
-    if (!offline) {
-        try {
-            log(`Downloading embeddings v${version || getPackageVersion()}...`);
-            const downloaded = await downloadEmbeddings(version);
-            log(`Downloaded and cached: ${downloaded.documents?.length || 0} documents`);
-            return downloaded;
-        }
-        catch (error) {
-            log(`Download failed: ${error}`);
-        }
-    }
-    log('No embeddings available');
-    return null;
-}
-export function clearEmbeddingsCache(version) {
-    const cachePath = getEmbeddingsCachePath(version);
-    try {
-        const fs = require('fs');
-        if (fs.existsSync(cachePath)) {
-            fs.unlinkSync(cachePath);
-        }
-    }
-    catch {
-    }
-}
-export { getPackageVersion };

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

@@ -1,9 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,30 +0,0 @@
-import type { IndexedDoc, SearchResult, SearchOptions, HybridSearchConfig } from './types.js';
-export declare class HybridSearch {
-    private fuse;
-    private docs;
-    private vectors;
-    private embeddingsData;
-    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[]>;
-    private fuzzySearch;
-    private semanticSearch;
-    private extractSnippet;
-    private static STOP_WORDS;
-    private cleanQuery;
-    private tokenize;
-    private averageVectors;
-    hasEmbeddings(): boolean;
-    getStats(): {
-        documents: number;
-        embeddings: number;
-        model?: string;
-        dimensions?: number;
-    };
-    private log;
-}
-export declare function createHybridSearch(config?: HybridSearchConfig): HybridSearch;