recker 1.0.20-next.de24f7d → 1.0.20-next.e194d90

package/dist/ai/providers/ollama.js

@@ -0,0 +1,240 @@
+import { BaseAIProvider, AIError, RateLimitError, OverloadedError, } from './base.js';
+import { StreamError } from '../../core/errors.js';
+export class OllamaProvider extends BaseAIProvider {
+    ollamaConfig;
+    constructor(config = {}) {
+        super({ ...config, name: 'ollama' });
+        this.ollamaConfig = config;
+    }
+    getEnvApiKey() {
+        return undefined;
+    }
+    getBaseUrl() {
+        return this.config.baseUrl || 'http://127.0.0.1:11434/api';
+    }
+    buildHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            ...this.config.headers,
+        };
+    }
+    transformMessages(messages) {
+        return messages.map((msg) => {
+            const { content, images } = this.extractContentAndImages(msg.content);
+            return {
+                role: msg.role,
+                content,
+                images: images.length > 0 ? images : undefined,
+            };
+        });
+    }
+    extractContentAndImages(content) {
+        if (typeof content === 'string') {
+            return { content, images: [] };
+        }
+        let text = '';
+        const images = [];
+        for (const part of content) {
+            if (part.type === 'text') {
+                text += part.text;
+            }
+            else if (part.type === 'image') {
+                images.push(Buffer.from(part.data).toString('base64'));
+            }
+            else if (part.type === 'image_url') {
+                if (part.image_url.url.startsWith('data:')) {
+                    const base64 = part.image_url.url.split(',')[1];
+                    if (base64)
+                        images.push(base64);
+                }
+            }
+        }
+        return { content: text, images };
+    }
+    async chat(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const body = this.buildChatBody(options, false);
+        const response = await this.makeRequest('/chat', body, options.signal);
+        const data = await response.json();
+        return this.parseResponse(data, context);
+    }
+    async stream(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const body = this.buildChatBody(options, true);
+        const response = await this.makeRequest('/chat', body, options.signal);
+        return this.parseNDJSONStream(response, context);
+    }
+    async embed(options) {
+        const startTime = performance.now();
+        const body = {
+            model: options.model || this.config.defaultModel || 'nomic-embed-text',
+            input: options.input,
+        };
+        if (this.ollamaConfig.keepAlive) {
+            body.keep_alive = this.ollamaConfig.keepAlive;
+        }
+        const response = await this.makeRequest('/embed', body, options.signal);
+        const data = await response.json();
+        const latency = {
+            ttft: performance.now() - startTime,
+            tps: 0,
+            total: performance.now() - startTime,
+        };
+        const usage = {
+            inputTokens: data.prompt_eval_count || 0,
+            outputTokens: 0,
+            totalTokens: data.prompt_eval_count || 0,
+        };
+        return {
+            embeddings: data.embeddings,
+            usage,
+            model: data.model,
+            provider: 'ollama',
+            latency,
+        };
+    }
+    buildChatBody(options, stream) {
+        const body = {
+            model: options.model || this.config.defaultModel || 'llama3',
+            messages: this.transformMessages(options.messages),
+            stream,
+            options: {},
+        };
+        if (options.responseFormat?.type === 'json_object') {
+            body.format = 'json';
+        }
+        if (this.ollamaConfig.keepAlive) {
+            body.keep_alive = this.ollamaConfig.keepAlive;
+        }
+        if (options.temperature !== undefined)
+            body.options.temperature = options.temperature;
+        if (options.topP !== undefined)
+            body.options.top_p = options.topP;
+        if (options.maxTokens !== undefined)
+            body.options.num_predict = options.maxTokens;
+        if (options.stop)
+            body.options.stop = options.stop;
+        return body;
+    }
+    async makeRequest(endpoint, body, signal) {
+        const url = `${this.getBaseUrl()}${endpoint}`;
+        const headers = this.buildHeaders();
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!response.ok) {
+            let errorMsg = response.statusText;
+            try {
+                const err = await response.json();
+                if (err.error)
+                    errorMsg = err.error;
+            }
+            catch { }
+            if (response.status === 429)
+                throw new RateLimitError('ollama');
+            if (response.status === 503)
+                throw new OverloadedError('ollama');
+            throw new AIError(errorMsg, 'ollama', String(response.status), response.status);
+        }
+        return response;
+    }
+    parseResponse(data, context) {
+        const usage = {
+            inputTokens: data.prompt_eval_count || 0,
+            outputTokens: data.eval_count || 0,
+            totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+        };
+        context.tokenCount = usage.outputTokens;
+        return {
+            content: data.message.content,
+            usage,
+            latency: this.calculateLatency(context),
+            model: data.model,
+            provider: 'ollama',
+            cached: false,
+            finishReason: data.done ? 'stop' : undefined,
+            raw: data,
+        };
+    }
+    parseStreamEvent(_chunk, _context) {
+        return null;
+    }
+    async *parseNDJSONStream(response, context) {
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new StreamError('Response body is not readable', { streamType: 'ndjson' });
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const data = JSON.parse(line);
+                        if (data.message?.content) {
+                            if (!context.firstTokenTime)
+                                context.firstTokenTime = performance.now();
+                            context.tokenCount++;
+                            yield { type: 'text', content: data.message.content };
+                        }
+                        if (data.done) {
+                            const usage = {
+                                inputTokens: data.prompt_eval_count || 0,
+                                outputTokens: data.eval_count || 0,
+                                totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+                            };
+                            yield { type: 'done', finishReason: 'stop', usage };
+                        }
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+            if (buffer.trim()) {
+                const lines = buffer.split('\n');
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const data = JSON.parse(line);
+                        if (data.message?.content) {
+                            if (!context.firstTokenTime)
+                                context.firstTokenTime = performance.now();
+                            context.tokenCount++;
+                            yield { type: 'text', content: data.message.content };
+                        }
+                        if (data.done) {
+                            const usage = {
+                                inputTokens: data.prompt_eval_count || 0,
+                                outputTokens: data.eval_count || 0,
+                                totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+                            };
+                            yield { type: 'done', finishReason: 'stop', usage };
+                        }
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/ai/providers/openai.d.ts

@@ -62,4 +62,3 @@ export declare class OpenAIProvider extends BaseAIProvider {
     protected parseStreamEvent(chunk: string, context: ProviderRequestContext): StreamEvent | null;
 }
 export {};
-//# sourceMappingURL=openai.d.ts.map

package/dist/ai/rate-limiter.d.ts

@@ -41,4 +41,3 @@ export declare const tokenEstimators: {
     estimateMessage(content: string): number;
     estimateChatTokens(options: ChatOptions): number;
 };
-//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/ai/vector/index.d.ts

@@ -0,0 +1,2 @@
+export * from './similarity.js';
+export * from './store.js';

package/dist/ai/vector/index.js

@@ -0,0 +1,2 @@
+export * from './similarity.js';
+export * from './store.js';

package/dist/ai/vector/similarity.d.ts

@@ -0,0 +1,2 @@
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+export declare function euclideanDistance(a: number[], b: number[]): number;

package/dist/ai/vector/similarity.js

@@ -0,0 +1,27 @@
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+    }
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+export function euclideanDistance(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+    }
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        const diff = a[i] - b[i];
+        sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+}

package/dist/ai/vector/store.d.ts

@@ -0,0 +1,27 @@
+import type { AIClient } from '../../types/ai.js';
+export interface VectorDocument {
+    id: string;
+    content: string;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+}
+export interface SearchResult extends VectorDocument {
+    score: number;
+}
+export interface VectorStoreOptions {
+    client?: AIClient;
+    model?: string;
+}
+export declare class MemoryVectorStore {
+    private documents;
+    private client?;
+    private model?;
+    constructor(options?: VectorStoreOptions);
+    add(docs: Array<Partial<VectorDocument> & {
+        content: string;
+    }>): Promise<void>;
+    search(query: string, limit?: number, threshold?: number): Promise<SearchResult[]>;
+    delete(id: string): boolean;
+    clear(): void;
+    get count(): number;
+}

package/dist/ai/vector/store.js

@@ -0,0 +1,82 @@
+import { cosineSimilarity } from './similarity.js';
+export class MemoryVectorStore {
+    documents = new Map();
+    client;
+    model;
+    constructor(options = {}) {
+        this.client = options.client;
+        this.model = options.model;
+    }
+    async add(docs) {
+        const docsToEmbed = [];
+        const readyDocs = [];
+        for (const doc of docs) {
+            const id = doc.id || Math.random().toString(36).substring(7);
+            const fullDoc = {
+                id,
+                content: doc.content,
+                metadata: doc.metadata || {},
+                embedding: doc.embedding,
+            };
+            if (!fullDoc.embedding) {
+                docsToEmbed.push(fullDoc);
+            }
+            else {
+                readyDocs.push(fullDoc);
+            }
+        }
+        if (docsToEmbed.length > 0) {
+            if (!this.client) {
+                throw new Error('AI Client required to generate embeddings. Pass "client" to constructor or provide "embedding" in document.');
+            }
+            const contents = docsToEmbed.map(d => d.content);
+            const response = await this.client.embed({
+                model: this.model,
+                input: contents,
+            });
+            docsToEmbed.forEach((doc, i) => {
+                doc.embedding = response.embeddings[i];
+                readyDocs.push(doc);
+            });
+        }
+        for (const doc of readyDocs) {
+            this.documents.set(doc.id, doc);
+        }
+    }
+    async search(query, limit = 3, threshold = 0.0) {
+        if (this.documents.size === 0)
+            return [];
+        if (!this.client) {
+            throw new Error('AI Client required to search by text query.');
+        }
+        const response = await this.client.embed({
+            model: this.model,
+            input: query,
+        });
+        const queryEmbedding = response.embeddings[0];
+        const results = [];
+        for (const doc of this.documents.values()) {
+            if (!doc.embedding)
+                continue;
+            const score = cosineSimilarity(queryEmbedding, doc.embedding);
+            if (score >= threshold) {
+                results.push({
+                    ...doc,
+                    score,
+                });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    delete(id) {
+        return this.documents.delete(id);
+    }
+    clear() {
+        this.documents.clear();
+    }
+    get count() {
+        return this.documents.size;
+    }
+}

package/dist/bench/generator.d.ts

@@ -16,4 +16,3 @@ export declare class LoadGenerator {
     start(): Promise<void[]>;
     stop(): void;
 }
-//# sourceMappingURL=generator.d.ts.map

package/dist/bench/stats.d.ts

@@ -46,4 +46,3 @@ export declare class LoadStats {
         errors: Record<string, number>;
     };
 }
-//# sourceMappingURL=stats.d.ts.map

package/dist/cache/basic-file-storage.d.ts

@@ -0,0 +1,12 @@
+import { CacheEntry, CacheStorage } from '../types/index.js';
+export declare class FileStorage implements CacheStorage {
+    private dir;
+    constructor(baseDir?: string);
+    private getHash;
+    private getPath;
+    private ensureDir;
+    get(key: string): Promise<CacheEntry | undefined>;
+    set(key: string, entry: CacheEntry, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/cache/basic-file-storage.js

@@ -0,0 +1,50 @@
+import { mkdir, readFile, writeFile, unlink, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+export class FileStorage {
+    dir;
+    constructor(baseDir = '.recker/cache') {
+        this.dir = baseDir;
+    }
+    getHash(key) {
+        return createHash('md5').update(key).digest('hex');
+    }
+    getPath(key) {
+        return join(this.dir, `${this.getHash(key)}.json`);
+    }
+    async ensureDir() {
+        if (!existsSync(this.dir)) {
+            await mkdir(this.dir, { recursive: true });
+        }
+    }
+    async get(key) {
+        try {
+            const path = this.getPath(key);
+            if (!existsSync(path))
+                return undefined;
+            const content = await readFile(path, 'utf-8');
+            const data = JSON.parse(content);
+            return data;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async set(key, entry, ttl) {
+        await this.ensureDir();
+        const path = this.getPath(key);
+        await writeFile(path, JSON.stringify(entry), 'utf-8');
+    }
+    async delete(key) {
+        const path = this.getPath(key);
+        if (existsSync(path)) {
+            await unlink(path);
+        }
+    }
+    async clear() {
+        if (existsSync(this.dir)) {
+            await rm(this.dir, { recursive: true, force: true });
+        }
+    }
+}

package/dist/cache/file-storage.d.ts

@@ -1,13 +1,27 @@
-import { CacheEntry, CacheStorage } from '../types/index.js';
-export declare class FileStorage implements CacheStorage {
-    private dir;
-    constructor(baseDir?: string);
-    private getHash;
-    private getPath;
-    private ensureDir;
-    get(key: string): Promise<CacheEntry | undefined>;
-    set(key: string, entry: CacheEntry, ttl?: number): Promise<void>;
+import type { CacheStorage, CacheEntry } from '../types/index.js';
+export interface FileSystemStorageOptions {
+    path?: string;
+    ttl?: number;
+    cleanupInterval?: number;
+    maxSize?: number;
+}
+export declare class FileSystemStorage implements CacheStorage {
+    private cacheDir;
+    private defaultTtl;
+    private cleanupInterval;
+    private maxSize;
+    private cleanupTimer;
+    constructor(options?: FileSystemStorageOptions);
+    private initCacheDir;
+    private getFilePath;
+    private isExpired;
+    get(key: string): Promise<CacheEntry | undefined | null>;
+    set(key: string, value: CacheEntry, ttl?: number): Promise<void>;
     delete(key: string): Promise<void>;
-    clear(): Promise<void>;
+    clear(prefix?: string): Promise<void>;
+    size(): Promise<number>;
+    keys(): Promise<string[]>;
+    private cleanupExpired;
+    private enforceMaxSize;
+    shutdown(): void;
 }
-//# sourceMappingURL=file-storage.d.ts.map