profclaw 0.0.1-beta.2 → 2.0.0

package/dist/providers/adapters/base.js

@@ -1,99 +0,0 @@
-/**
- * Base Provider Adapter
- *
- * Abstract base class for AI provider implementations.
- * Handles common functionality like configuration and model management.
- */
-import { randomUUID } from 'node:crypto';
-export class BaseProvider {
-    config;
-    models = [];
-    constructor(config) {
-        this.config = this.createDefaultConfig(config);
-    }
-    // === AIProvider Interface ===
-    configure(config) {
-        this.config = { ...this.config, ...config };
-    }
-    getConfig() {
-        return { ...this.config };
-    }
-    async listModels() {
-        if (this.models.length === 0) {
-            this.models = this.getDefaultModels();
-        }
-        return [...this.models];
-    }
-    getModel(modelId) {
-        return this.models.find((m) => m.id === modelId);
-    }
-    async complete(request) {
-        const model = request.model || this.config.defaultModel || this.models[0]?.id;
-        if (!model) {
-            throw new Error(`No model specified and no default model configured for ${this.name}`);
-        }
-        const finalRequest = {
-            ...request,
-            provider: this.type,
-            model,
-        };
-        return this.doComplete(finalRequest);
-    }
-    async completeStream(request, onChunk) {
-        const model = request.model || this.config.defaultModel || this.models[0]?.id;
-        if (!model) {
-            throw new Error(`No model specified and no default model configured for ${this.name}`);
-        }
-        const finalRequest = {
-            ...request,
-            provider: this.type,
-            model,
-            stream: true,
-        };
-        return this.doCompleteStream(finalRequest, onChunk);
-    }
-    // === Helper Methods ===
-    /**
-     * Create a chat message
-     */
-    createMessage(role, content, options) {
-        return {
-            id: randomUUID(),
-            role,
-            content,
-            timestamp: new Date().toISOString(),
-            ...options,
-        };
-    }
-    /**
-     * Convert messages to provider-specific format
-     */
-    formatMessages(messages, systemPrompt) {
-        const formatted = [];
-        // Add system prompt if provided
-        if (systemPrompt) {
-            formatted.push({ role: 'system', content: systemPrompt });
-        }
-        // Add conversation messages
-        for (const msg of messages) {
-            formatted.push({
-                role: msg.role,
-                content: msg.content,
-            });
-        }
-        return formatted;
-    }
-    /**
-     * Calculate cost from token usage
-     */
-    calculateCost(promptTokens, completionTokens, modelId) {
-        const model = modelId ? this.getModel(modelId) : this.models.find((m) => m.isDefault);
-        if (!model?.cost) {
-            return 0;
-        }
-        const inputCost = (promptTokens / 1_000_000) * model.cost.inputPerMillion;
-        const outputCost = (completionTokens / 1_000_000) * model.cost.outputPerMillion;
-        return inputCost + outputCost;
-    }
-}
-//# sourceMappingURL=base.js.map

package/dist/providers/adapters/ollama.d.ts

@@ -1,30 +0,0 @@
-/**
- * Ollama Provider Adapter
- *
- * Local LLM inference via Ollama.
- * Supports model auto-discovery and streaming.
- *
- * @see https://ollama.ai/
- */
-import type { ChatCompletionRequest, ChatCompletionResponse, ModelDefinition, ProviderConfig, ProviderHealth, ProviderType } from '../types.js';
-import { BaseProvider } from './base.js';
-export declare class OllamaProvider extends BaseProvider {
-    readonly type: ProviderType;
-    readonly name = "Ollama";
-    private discoveredModels;
-    protected createDefaultConfig(partial: Partial<ProviderConfig>): ProviderConfig;
-    protected getDefaultModels(): ModelDefinition[];
-    /**
-     * Discover models from local Ollama instance
-     */
-    discoverModels(): Promise<ModelDefinition[]>;
-    listModels(): Promise<ModelDefinition[]>;
-    healthCheck(): Promise<ProviderHealth>;
-    protected doComplete(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
-    protected doCompleteStream(request: ChatCompletionRequest, onChunk: (chunk: string) => void): Promise<ChatCompletionResponse>;
-}
-/**
- * Create an Ollama provider instance
- */
-export declare function createOllamaProvider(config?: Partial<ProviderConfig>): OllamaProvider;
-//# sourceMappingURL=ollama.d.ts.map

package/dist/providers/adapters/ollama.js

@@ -1,292 +0,0 @@
-/**
- * Ollama Provider Adapter
- *
- * Local LLM inference via Ollama.
- * Supports model auto-discovery and streaming.
- *
- * @see https://ollama.ai/
- */
-import { randomUUID } from 'node:crypto';
-import { BaseProvider } from './base.js';
-import { logger } from '../../utils/logger.js';
-export class OllamaProvider extends BaseProvider {
-    type = 'ollama';
-    name = 'Ollama';
-    discoveredModels = [];
-    createDefaultConfig(partial) {
-        return {
-            id: 'ollama',
-            type: 'ollama',
-            name: 'Ollama',
-            enabled: true,
-            baseUrl: partial.baseUrl || process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
-            defaultModel: partial.defaultModel || process.env.OLLAMA_MODEL || 'llama3.2',
-            maxConcurrent: partial.maxConcurrent || 3,
-            timeout: partial.timeout || 300000,
-            models: [],
-            ...partial,
-        };
-    }
-    getDefaultModels() {
-        // Default models that are commonly available
-        return [
-            {
-                id: 'llama3.2',
-                name: 'Llama 3.2',
-                provider: 'ollama',
-                capabilities: ['text', 'code'],
-                contextWindow: 128000,
-                maxOutputTokens: 8192,
-                supportsStreaming: true,
-                supportsVision: false,
-                cost: { inputPerMillion: 0, outputPerMillion: 0 },
-                isDefault: true,
-            },
-            {
-                id: 'deepseek-r1:7b',
-                name: 'DeepSeek R1 7B',
-                provider: 'ollama',
-                capabilities: ['text', 'code', 'reasoning'],
-                contextWindow: 128000,
-                maxOutputTokens: 8192,
-                supportsStreaming: true,
-                supportsVision: false,
-                cost: { inputPerMillion: 0, outputPerMillion: 0 },
-                isDefault: false,
-            },
-            {
-                id: 'qwen2.5:14b',
-                name: 'Qwen 2.5 14B',
-                provider: 'ollama',
-                capabilities: ['text', 'code'],
-                contextWindow: 128000,
-                maxOutputTokens: 8192,
-                supportsStreaming: true,
-                supportsVision: false,
-                cost: { inputPerMillion: 0, outputPerMillion: 0 },
-                isDefault: false,
-            },
-        ];
-    }
-    /**
-     * Discover models from local Ollama instance
-     */
-    async discoverModels() {
-        try {
-            const response = await fetch(`${this.config.baseUrl}/api/tags`, {
-                signal: AbortSignal.timeout(5000),
-            });
-            if (!response.ok) {
-                logger.warn(`[Ollama] Failed to discover models: ${response.status}`);
-                return [];
-            }
-            const data = (await response.json());
-            if (!data.models || data.models.length === 0) {
-                return [];
-            }
-            this.discoveredModels = data.models.map((model) => {
-                const modelId = model.name;
-                const isReasoning = modelId.toLowerCase().includes('r1') ||
-                    modelId.toLowerCase().includes('reasoning') ||
-                    modelId.toLowerCase().includes('deepseek');
-                const isVision = modelId.toLowerCase().includes('vision') ||
-                    modelId.toLowerCase().includes('llava');
-                return {
-                    id: modelId,
-                    name: model.details?.family
-                        ? `${model.details.family} ${model.details.parameter_size || ''}`
-                        : modelId,
-                    provider: 'ollama',
-                    capabilities: isReasoning
-                        ? ['text', 'code', 'reasoning']
-                        : isVision
-                            ? ['text', 'vision']
-                            : ['text', 'code'],
-                    contextWindow: 128000,
-                    maxOutputTokens: 8192,
-                    supportsStreaming: true,
-                    supportsVision: isVision,
-                    cost: { inputPerMillion: 0, outputPerMillion: 0 }, // Free!
-                    isDefault: false,
-                };
-            });
-            logger.info(`[Ollama] Discovered ${this.discoveredModels.length} models`);
-            return this.discoveredModels;
-        }
-        catch (error) {
-            logger.warn(`[Ollama] Model discovery failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            return [];
-        }
-    }
-    async listModels() {
-        // Try to discover models first
-        const discovered = await this.discoverModels();
-        if (discovered.length > 0) {
-            this.models = discovered;
-            return this.models;
-        }
-        // Fall back to defaults
-        this.models = this.getDefaultModels();
-        return this.models;
-    }
-    async healthCheck() {
-        const startTime = Date.now();
-        try {
-            const response = await fetch(`${this.config.baseUrl}/api/tags`, {
-                signal: AbortSignal.timeout(5000),
-            });
-            const latencyMs = Date.now() - startTime;
-            if (!response.ok) {
-                return {
-                    provider: 'ollama',
-                    healthy: false,
-                    latencyMs,
-                    message: `Ollama API returned ${response.status}`,
-                    lastChecked: new Date().toISOString(),
-                };
-            }
-            const data = (await response.json());
-            const modelNames = data.models?.map((m) => m.name) || [];
-            // Check if default model is available
-            const defaultModel = this.config.defaultModel || 'llama3.2';
-            const modelAvailable = modelNames.some((name) => name === defaultModel || name.startsWith(`${defaultModel}:`));
-            return {
-                provider: 'ollama',
-                healthy: true,
-                latencyMs,
-                message: modelAvailable
-                    ? `Ollama running with ${modelNames.length} models`
-                    : `Model '${defaultModel}' not found`,
-                availableModels: modelNames,
-                lastChecked: new Date().toISOString(),
-            };
-        }
-        catch (error) {
-            return {
-                provider: 'ollama',
-                healthy: false,
-                latencyMs: Date.now() - startTime,
-                message: error instanceof Error ? error.message : 'Connection failed',
-                lastChecked: new Date().toISOString(),
-            };
-        }
-    }
-    async doComplete(request) {
-        const startTime = Date.now();
-        const model = request.model || this.config.defaultModel || 'llama3.2';
-        const messages = this.formatMessages(request.messages, request.systemPrompt);
-        const response = await fetch(`${this.config.baseUrl}/api/chat`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                model,
-                messages,
-                stream: false,
-                options: {
-                    temperature: request.temperature || 0.7,
-                    num_predict: request.maxTokens || 4096,
-                },
-            }),
-            signal: AbortSignal.timeout(this.config.timeout),
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Ollama API error: ${response.status} - ${errorText}`);
-        }
-        const result = (await response.json());
-        const duration = Date.now() - startTime;
-        const promptTokens = result.prompt_eval_count || 0;
-        const completionTokens = result.eval_count || 0;
-        return {
-            id: randomUUID(),
-            provider: 'ollama',
-            model,
-            message: this.createMessage('assistant', result.message?.content || ''),
-            finishReason: 'stop',
-            usage: {
-                promptTokens,
-                completionTokens,
-                totalTokens: promptTokens + completionTokens,
-                cost: 0, // Free!
-            },
-            duration,
-        };
-    }
-    async doCompleteStream(request, onChunk) {
-        const startTime = Date.now();
-        const model = request.model || this.config.defaultModel || 'llama3.2';
-        const messages = this.formatMessages(request.messages, request.systemPrompt);
-        const response = await fetch(`${this.config.baseUrl}/api/chat`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                model,
-                messages,
-                stream: true,
-                options: {
-                    temperature: request.temperature || 0.7,
-                    num_predict: request.maxTokens || 4096,
-                },
-            }),
-            signal: AbortSignal.timeout(this.config.timeout),
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Ollama API error: ${response.status} - ${errorText}`);
-        }
-        // Process streaming response
-        let fullContent = '';
-        let promptTokens = 0;
-        let completionTokens = 0;
-        const reader = response.body?.getReader();
-        if (!reader) {
-            throw new Error('No response body');
-        }
-        const decoder = new TextDecoder();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            const chunk = decoder.decode(value, { stream: true });
-            const lines = chunk.split('\n').filter((line) => line.trim());
-            for (const line of lines) {
-                try {
-                    const data = JSON.parse(line);
-                    if (data.message?.content) {
-                        fullContent += data.message.content;
-                        onChunk(data.message.content);
-                    }
-                    if (data.done) {
-                        promptTokens = data.prompt_eval_count || 0;
-                        completionTokens = data.eval_count || 0;
-                    }
-                }
-                catch {
-                    // Skip invalid JSON
-                }
-            }
-        }
-        const duration = Date.now() - startTime;
-        return {
-            id: randomUUID(),
-            provider: 'ollama',
-            model,
-            message: this.createMessage('assistant', fullContent),
-            finishReason: 'stop',
-            usage: {
-                promptTokens,
-                completionTokens,
-                totalTokens: promptTokens + completionTokens,
-                cost: 0,
-            },
-            duration,
-        };
-    }
-}
-/**
- * Create an Ollama provider instance
- */
-export function createOllamaProvider(config) {
-    return new OllamaProvider(config || {});
-}
-//# sourceMappingURL=ollama.js.map

package/dist/utils/ai-cache.d.ts

@@ -1,72 +0,0 @@
-/**
- * AI Inference Cache Utility
- *
- * Provides caching layer for AI inference results to avoid
- * redundant API calls for identical inputs.
- *
- * Cache key = SHA256(cacheType + model + normalized_input)
- */
-export type CacheType = 'categorize' | 'suggest' | 'summarize' | 'analyze_comment' | 'generate_response';
-export interface CacheEntry<T> {
-    id: string;
-    cacheType: CacheType;
-    inputHash: string;
-    model: string;
-    provider?: string;
-    response: T;
-    confidence?: number;
-    hitCount: number;
-    lastHitAt?: Date;
-    expiresAt?: Date;
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface CacheStats {
-    totalEntries: number;
-    hitCount: number;
-    missCount: number;
-    hitRate: number;
-    byType: Record<string, {
-        entries: number;
-        hits: number;
-    }>;
-}
-/**
- * Generate a consistent hash for cache lookup
- */
-export declare function generateCacheKey(cacheType: CacheType, model: string, ...inputs: (string | undefined)[]): string;
-/**
- * Get cached response if available and not expired
- */
-export declare function getCachedResponse<T>(db: any, // Database instance
-cacheType: CacheType, model: string, ...inputs: (string | undefined)[]): Promise<T | null>;
-/**
- * Store response in cache
- */
-export declare function setCachedResponse<T>(db: any, cacheType: CacheType, model: string, response: T, options: {
-    inputs: (string | undefined)[];
-    provider?: string;
-    confidence?: number;
-    ttlMs?: number;
-}): Promise<void>;
-/**
- * Invalidate cache entries by type or specific hash
- */
-export declare function invalidateCache(db: any, options: {
-    cacheType?: CacheType;
-    inputHash?: string;
-    olderThanMs?: number;
-}): Promise<number>;
-/**
- * Clean up expired cache entries
- */
-export declare function cleanupExpiredCache(db: any): Promise<number>;
-/**
- * Get cache statistics
- */
-export declare function getCacheStats(db: any): Promise<CacheStats>;
-/**
- * Reset in-memory stats (for testing)
- */
-export declare function resetCacheStats(): void;
-//# sourceMappingURL=ai-cache.d.ts.map

package/dist/utils/ai-cache.js

@@ -1,204 +0,0 @@
-/**
- * AI Inference Cache Utility
- *
- * Provides caching layer for AI inference results to avoid
- * redundant API calls for identical inputs.
- *
- * Cache key = SHA256(cacheType + model + normalized_input)
- */
-import { createHash } from 'crypto';
-import { logger } from './logger.js';
-// Default cache TTL: 7 days for most operations
-const DEFAULT_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-// Cache TTLs by type (in milliseconds)
-const CACHE_TTL_BY_TYPE = {
-    categorize: 30 * 24 * 60 * 60 * 1000, // 30 days - categorization is stable
-    suggest: 7 * 24 * 60 * 60 * 1000, // 7 days - suggestions can evolve
-    summarize: 14 * 24 * 60 * 60 * 1000, // 14 days - summaries are fairly stable
-    analyze_comment: 7 * 24 * 60 * 60 * 1000, // 7 days
-    generate_response: 1 * 24 * 60 * 60 * 1000, // 1 day - responses should be fresh
-};
-// In-memory stats tracking
-let cacheHits = 0;
-let cacheMisses = 0;
-/**
- * Generate a consistent hash for cache lookup
- */
-export function generateCacheKey(cacheType, model, ...inputs) {
-    // Normalize inputs: lowercase, trim, remove extra whitespace
-    const normalizedInputs = inputs
-        .filter((i) => !!i)
-        .map((i) => i.toLowerCase().trim().replace(/\s+/g, ' '))
-        .join('|');
-    const keyData = `${cacheType}:${model}:${normalizedInputs}`;
-    return createHash('sha256').update(keyData).digest('hex');
-}
-/**
- * Get cached response if available and not expired
- */
-export async function getCachedResponse(db, // Database instance
-cacheType, model, ...inputs) {
-    try {
-        const inputHash = generateCacheKey(cacheType, model, ...inputs);
-        const now = Date.now();
-        const result = await db.query(`SELECT id, response, expires_at, confidence
-       FROM ai_inference_cache
-       WHERE cache_type = ? AND input_hash = ? AND model = ?`, [cacheType, inputHash, model]);
-        if (!result || result.length === 0) {
-            cacheMisses++;
-            return null;
-        }
-        const entry = result[0];
-        // Check expiration
-        if (entry.expires_at && entry.expires_at < now) {
-            cacheMisses++;
-            // Clean up expired entry
-            await db.execute(`DELETE FROM ai_inference_cache WHERE id = ?`, [entry.id]);
-            logger.debug('[AI Cache] Entry expired', { cacheType, inputHash: inputHash.slice(0, 8) });
-            return null;
-        }
-        // Update hit stats
-        await db.execute(`UPDATE ai_inference_cache SET hit_count = hit_count + 1, last_hit_at = ? WHERE id = ?`, [now, entry.id]);
-        cacheHits++;
-        logger.debug('[AI Cache] Cache hit', { cacheType, inputHash: inputHash.slice(0, 8) });
-        // Parse and return response
-        const response = typeof entry.response === 'string'
-            ? JSON.parse(entry.response)
-            : entry.response;
-        return response;
-    }
-    catch (error) {
-        logger.warn('[AI Cache] Error reading cache', { error });
-        cacheMisses++;
-        return null;
-    }
-}
-/**
- * Store response in cache
- */
-export async function setCachedResponse(db, cacheType, model, response, options) {
-    try {
-        const inputHash = generateCacheKey(cacheType, model, ...options.inputs);
-        const id = `cache_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-        const now = Date.now();
-        const ttl = options.ttlMs ?? CACHE_TTL_BY_TYPE[cacheType] ?? DEFAULT_CACHE_TTL_MS;
-        const expiresAt = ttl > 0 ? now + ttl : null;
-        // Upsert: delete existing then insert
-        await db.execute(`DELETE FROM ai_inference_cache WHERE cache_type = ? AND input_hash = ? AND model = ?`, [cacheType, inputHash, model]);
-        await db.execute(`INSERT INTO ai_inference_cache
-       (id, cache_type, input_hash, model, provider, response, confidence, hit_count, expires_at, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?)`, [
-            id,
-            cacheType,
-            inputHash,
-            model,
-            options.provider ?? null,
-            JSON.stringify(response),
-            options.confidence ?? null,
-            expiresAt,
-            now,
-            now,
-        ]);
-        logger.debug('[AI Cache] Stored response', { cacheType, inputHash: inputHash.slice(0, 8) });
-    }
-    catch (error) {
-        logger.warn('[AI Cache] Error storing cache', { error });
-    }
-}
-/**
- * Invalidate cache entries by type or specific hash
- */
-export async function invalidateCache(db, options) {
-    try {
-        const conditions = [];
-        const params = [];
-        if (options.cacheType) {
-            conditions.push('cache_type = ?');
-            params.push(options.cacheType);
-        }
-        if (options.inputHash) {
-            conditions.push('input_hash = ?');
-            params.push(options.inputHash);
-        }
-        if (options.olderThanMs) {
-            const cutoff = Date.now() - options.olderThanMs;
-            conditions.push('created_at < ?');
-            params.push(cutoff);
-        }
-        if (conditions.length === 0) {
-            return 0;
-        }
-        const result = await db.execute(`DELETE FROM ai_inference_cache WHERE ${conditions.join(' AND ')}`, params);
-        const deleted = result?.rowsAffected ?? 0;
-        logger.info('[AI Cache] Invalidated entries', { deleted, ...options });
-        return deleted;
-    }
-    catch (error) {
-        logger.warn('[AI Cache] Error invalidating cache', { error });
-        return 0;
-    }
-}
-/**
- * Clean up expired cache entries
- */
-export async function cleanupExpiredCache(db) {
-    try {
-        const now = Date.now();
-        const result = await db.execute(`DELETE FROM ai_inference_cache WHERE expires_at IS NOT NULL AND expires_at < ?`, [now]);
-        const deleted = result?.rowsAffected ?? 0;
-        if (deleted > 0) {
-            logger.info('[AI Cache] Cleaned up expired entries', { deleted });
-        }
-        return deleted;
-    }
-    catch (error) {
-        logger.warn('[AI Cache] Error cleaning up cache', { error });
-        return 0;
-    }
-}
-/**
- * Get cache statistics
- */
-export async function getCacheStats(db) {
-    try {
-        const totalResult = await db.query(`SELECT COUNT(*) as count FROM ai_inference_cache`);
-        const totalEntries = totalResult[0]?.count ?? 0;
-        const byTypeResult = await db.query(`SELECT cache_type, COUNT(*) as entries, SUM(hit_count) as hits
-       FROM ai_inference_cache
-       GROUP BY cache_type`);
-        const byType = {};
-        for (const row of byTypeResult) {
-            byType[row.cache_type] = { entries: row.entries, hits: row.hits ?? 0 };
-        }
-        const totalHits = cacheHits;
-        const totalMisses = cacheMisses;
-        const hitRate = totalHits + totalMisses > 0
-            ? (totalHits / (totalHits + totalMisses)) * 100
-            : 0;
-        return {
-            totalEntries,
-            hitCount: totalHits,
-            missCount: totalMisses,
-            hitRate: Math.round(hitRate * 100) / 100,
-            byType,
-        };
-    }
-    catch (error) {
-        logger.warn('[AI Cache] Error getting stats', { error });
-        return {
-            totalEntries: 0,
-            hitCount: cacheHits,
-            missCount: cacheMisses,
-            hitRate: 0,
-            byType: {},
-        };
-    }
-}
-/**
- * Reset in-memory stats (for testing)
- */
-export function resetCacheStats() {
-    cacheHits = 0;
-    cacheMisses = 0;
-}
-//# sourceMappingURL=ai-cache.js.map