codehere 0.2.2 → 0.3.0-rc.10

package/dist/infrastructure/providers/openrouter-provider.js

@@ -1,399 +0,0 @@
-/**
- * Provider Layer: OpenRouterProvider
- * Implements IModelProvider for OpenRouter API
- *
- * Phase 4D: OpenRouter Provider Implementation
- *
- * OpenRouter provides unified access to 400+ AI models through a single API.
- * Supports GPT-4, Claude, Llama, Mistral, and many more models.
- *
- * Uses OpenRouter REST API directly (no SDK dependency) to keep dependencies minimal.
- */
-import { config } from 'dotenv';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { encoding_for_model } from 'tiktoken';
-import { retryWithBackoff } from '../../error-handler.js';
-// Load .env (same pattern as other providers)
-try {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '../../../..');
-    config({ path: join(agentDir, '.env') });
-}
-catch { }
-config();
-// Token counting (using tiktoken - OpenAI's tokenizer, works for most models)
-let tokenEncoder = null;
-function getTokenEncoder() {
-    if (!tokenEncoder) {
-        try {
-            tokenEncoder = encoding_for_model('gpt-3.5-turbo');
-        }
-        catch {
-            tokenEncoder = encoding_for_model('gpt-4');
-        }
-    }
-    return tokenEncoder;
-}
-function countTokens(text) {
-    try {
-        const encoder = getTokenEncoder();
-        return encoder.encode(text).length;
-    }
-    catch (error) {
-        console.warn('Warning: tiktoken failed, using character-based estimate (less accurate)');
-        return Math.ceil(text.length / 4);
-    }
-}
-/**
- * OpenRouter Provider
- * Implements IModelProvider using OpenRouter REST API
- */
-export class OpenRouterProvider {
-    id = 'openrouter';
-    name = 'OpenRouter';
-    capabilities = {
-        chat: true,
-        streaming: true,
-        embedding: false, // OpenRouter routes to model-specific endpoints (TBD)
-        embeddingQuery: false,
-        rerank: false, // OpenRouter doesn't have unified rerank API
-        toolCalling: true, // Many models support tool calling
-    };
-    apiKey;
-    baseUrl;
-    defaultChatModel;
-    constructor(apiKey) {
-        const key = apiKey || process.env.OPENROUTER_API_KEY;
-        if (!key) {
-            throw new Error('OPENROUTER_API_KEY not found in environment');
-        }
-        this.apiKey = key;
-        this.baseUrl = process.env.OPENROUTER_BASE_URL || 'https://openrouter.ai/api/v1';
-        this.defaultChatModel = process.env.CODEHERE_OPENROUTER_CHAT_MODEL || 'openai/gpt-4o-mini';
-    }
-    async getModels() {
-        // Fetch models from OpenRouter API
-        try {
-            const response = await fetch(`${this.baseUrl}/models`, {
-                method: 'GET',
-                headers: {
-                    'Authorization': `Bearer ${this.apiKey}`,
-                    'HTTP-Referer': 'https://github.com/muhammadegaa/codehere', // Optional: for analytics
-                },
-            });
-            if (!response.ok) {
-                // Fallback to known models if API call fails
-                return this.getDefaultModels();
-            }
-            const data = await response.json();
-            const models = data.data || [];
-            // Transform OpenRouter model format to ModelInfo
-            return models
-                .filter((model) => model.id && model.name)
-                .map((model) => ({
-                id: model.id,
-                name: model.name || model.id,
-                providerId: 'openrouter',
-                providerModelId: model.id,
-                contextWindow: model.context_length || 8192,
-                capabilities: {
-                    chat: model.top_provider?.supports_chat !== false,
-                    streaming: true,
-                    embedding: false, // OpenRouter embeddings TBD
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: model.top_provider?.supports_function_calling === true,
-                },
-            }))
-                .slice(0, 100); // Limit to top 100 models
-        }
-        catch (error) {
-            // Fallback to known models on error
-            console.warn('[OpenRouterProvider] Failed to fetch models, using defaults:', error instanceof Error ? error.message : String(error));
-            return this.getDefaultModels();
-        }
-    }
-    /**
-     * Get default models (fallback if API call fails)
-     */
-    getDefaultModels() {
-        return [
-            {
-                id: 'openai/gpt-4o',
-                name: 'GPT-4o (via OpenRouter)',
-                providerId: 'openrouter',
-                providerModelId: 'openai/gpt-4o',
-                contextWindow: 128000,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'openai/gpt-4o-mini',
-                name: 'GPT-4o Mini (via OpenRouter)',
-                providerId: 'openrouter',
-                providerModelId: 'openai/gpt-4o-mini',
-                contextWindow: 128000,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'anthropic/claude-3.5-sonnet',
-                name: 'Claude 3.5 Sonnet (via OpenRouter)',
-                providerId: 'openrouter',
-                providerModelId: 'anthropic/claude-3.5-sonnet',
-                contextWindow: 200000,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'meta-llama/llama-3.1-70b-instruct',
-                name: 'Llama 3.1 70B (via OpenRouter)',
-                providerId: 'openrouter',
-                providerModelId: 'meta-llama/llama-3.1-70b-instruct',
-                contextWindow: 131072,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: false,
-                },
-            },
-        ];
-    }
-    getDefaultModel() {
-        return this.defaultChatModel;
-    }
-    async chat(prompt, options) {
-        const model = options?.model || this.defaultChatModel;
-        return await retryWithBackoff(async () => {
-            const response = await fetch(`${this.baseUrl}/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`,
-                    'HTTP-Referer': 'https://github.com/muhammadegaa/codehere', // Optional: for analytics
-                    'X-Title': 'Codehere CLI', // Optional: for analytics
-                },
-                body: JSON.stringify({
-                    model,
-                    messages: [
-                        {
-                            role: 'user',
-                            content: prompt,
-                        },
-                    ],
-                    temperature: options?.temperature ?? 0.7,
-                    max_tokens: options?.maxTokens,
-                }),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                let errorMessage = `OpenRouter API error: ${response.status} ${response.statusText}`;
-                try {
-                    const errorJson = JSON.parse(errorText);
-                    errorMessage = errorJson.error?.message || errorMessage;
-                }
-                catch {
-                    errorMessage = errorText || errorMessage;
-                }
-                throw new Error(errorMessage);
-            }
-            const data = await response.json();
-            const text = data.choices?.[0]?.message?.content || 'No response generated';
-            const usage = data.usage || {};
-            return {
-                text,
-                model: data.model || model,
-                usage: {
-                    inputTokens: usage.prompt_tokens || countTokens(prompt),
-                    outputTokens: usage.completion_tokens || countTokens(text),
-                },
-                finishReason: data.choices?.[0]?.finish_reason,
-            };
-        }, {
-            maxRetries: 5,
-            baseDelay: 2000,
-            maxDelay: 60000,
-            operationName: 'openrouter-provider-chat',
-        });
-    }
-    async chatStream(prompt, options, onEvent) {
-        const model = options?.model || this.defaultChatModel;
-        let fullText = '';
-        try {
-            if (onEvent) {
-                onEvent({ type: 'start' });
-            }
-            const response = await fetch(`${this.baseUrl}/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`,
-                    'HTTP-Referer': 'https://github.com/muhammadegaa/codehere',
-                    'X-Title': 'Codehere CLI',
-                },
-                body: JSON.stringify({
-                    model,
-                    messages: [
-                        {
-                            role: 'user',
-                            content: prompt,
-                        },
-                    ],
-                    temperature: options?.temperature ?? 0.7,
-                    max_tokens: options?.maxTokens,
-                    stream: true,
-                }),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`OpenRouter API error: ${response.status} ${errorText}`);
-            }
-            if (!response.body) {
-                throw new Error('No response body for streaming');
-            }
-            const reader = response.body.getReader();
-            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) {
-                    if (line.startsWith('data: ')) {
-                        const data = line.slice(6);
-                        if (data === '[DONE]') {
-                            if (onEvent) {
-                                onEvent({ type: 'complete', text: fullText });
-                            }
-                            break;
-                        }
-                        try {
-                            const json = JSON.parse(data);
-                            const delta = json.choices?.[0]?.delta?.content;
-                            if (delta) {
-                                fullText += delta;
-                                if (onEvent) {
-                                    onEvent({ type: 'delta', text: delta });
-                                }
-                            }
-                        }
-                        catch (e) {
-                            // Skip invalid JSON chunks
-                        }
-                    }
-                }
-            }
-            if (onEvent && !fullText) {
-                onEvent({ type: 'complete', text: fullText });
-            }
-            const inputTokens = countTokens(prompt);
-            const outputTokens = countTokens(fullText);
-            return {
-                text: fullText,
-                model: model || 'default',
-                usage: {
-                    inputTokens,
-                    outputTokens,
-                },
-            };
-        }
-        catch (error) {
-            if (onEvent) {
-                onEvent({
-                    type: 'error',
-                    error: error instanceof Error ? error : new Error(String(error)),
-                });
-            }
-            throw error;
-        }
-    }
-    async embed(_text) {
-        // OpenRouter embeddings support TBD - will route to model-specific endpoints
-        throw new Error('Embeddings not yet supported via OpenRouter. Use direct provider (Cohere/OpenAI) for embeddings.');
-    }
-    async countTokens(text, _model) {
-        return Promise.resolve(countTokens(text));
-    }
-    async isAvailable() {
-        try {
-            // Simple availability check - try a minimal API call
-            const response = await fetch(`${this.baseUrl}/models`, {
-                method: 'GET',
-                headers: {
-                    'Authorization': `Bearer ${this.apiKey}`,
-                },
-            });
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    handleError(error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const lowerMessage = errorMessage.toLowerCase();
-        // Rate limiting (429)
-        if (errorMessage.includes('429') || lowerMessage.includes('rate limit') || lowerMessage.includes('rate_limit')) {
-            return {
-                type: 'rate_limit',
-                retryable: true, // OpenRouter may have retry logic
-                message: 'Rate limit exceeded',
-            };
-        }
-        // Authentication errors (401)
-        if (errorMessage.includes('401') || errorMessage.includes('Unauthorized') || lowerMessage.includes('no api key')) {
-            return {
-                type: 'auth_error',
-                retryable: false,
-                message: 'Authentication failed - check OPENROUTER_API_KEY',
-            };
-        }
-        // Quota exceeded
-        if (errorMessage.includes('quota') || errorMessage.includes('insufficient_quota') || lowerMessage.includes('insufficient credits')) {
-            return {
-                type: 'quota_exceeded',
-                retryable: false,
-                message: 'OpenRouter credits insufficient',
-            };
-        }
-        // Network errors
-        if (errorMessage.includes('network') || errorMessage.includes('timeout') || errorMessage.includes('ECONNREFUSED')) {
-            return {
-                type: 'network_error',
-                retryable: true,
-                message: errorMessage,
-            };
-        }
-        // Default to retryable
-        return {
-            type: 'unknown',
-            retryable: true,
-            message: errorMessage,
-        };
-    }
-}
-//# sourceMappingURL=openrouter-provider.js.map

package/dist/infrastructure/providers/operation-provider-resolver.js

@@ -1,105 +0,0 @@
-/**
- * Provider Layer: Operation Provider Resolver
- * Resolves which provider to use for a given operation
- *
- * Phase 4F: Per-Operation Provider Selection
- * Internal-only routing logic (no user-facing config yet)
- */
-/**
- * Operation Provider Resolver
- * Resolves which provider to use for a given operation based on precedence rules
- *
- * Precedence (highest to lowest):
- * 1. CODEHERE_FAKE_AI=1 → FakeProvider always wins
- * 2. Config file:
- *    - Operation-level override from config (if present)
- *    - Config default provider (if set)
- * 3. Global provider env choice (CODEHERE_AI_PROVIDER)
- * 4. Registry default provider
- */
-export class OperationProviderResolver {
-    operationConfig = null;
-    configDefault = null;
-    registry;
-    constructor(registry, operationConfig, configDefaultProvider) {
-        this.registry = registry;
-        this.operationConfig = operationConfig || null;
-        this.configDefault = configDefaultProvider || null;
-    }
-    /**
-     * Resolve provider for a given operation
-     *
-     * @param operation - The operation type (chat, embedding, rerank)
-     * @returns The IModelProvider to use for this operation
-     */
-    resolveProvider(operation) {
-        // Precedence 1: FakeProvider always wins if CODEHERE_FAKE_AI=1
-        if (process.env.CODEHERE_FAKE_AI === '1') {
-            const fakeProvider = this.registry.get('fake');
-            if (fakeProvider) {
-                return fakeProvider;
-            }
-        }
-        // Precedence 2: Operation-level override (if configured)
-        if (this.operationConfig) {
-            let providerId;
-            switch (operation) {
-                case 'chat':
-                    providerId = this.operationConfig.chat;
-                    break;
-                case 'embedding':
-                    providerId = this.operationConfig.embedding;
-                    break;
-                case 'rerank':
-                    providerId = this.operationConfig.rerank;
-                    break;
-            }
-            // If operation-specific provider is set, use it
-            if (providerId) {
-                const provider = this.registry.get(providerId);
-                if (provider) {
-                    return provider;
-                }
-                // If operation provider is misconfigured, fall through to next precedence
-                console.warn(`[OperationProviderResolver] Provider '${providerId}' not found for operation '${operation}', falling back to default`);
-            }
-            // Check for default in operation config
-            if (this.operationConfig.default) {
-                const provider = this.registry.get(this.operationConfig.default);
-                if (provider) {
-                    return provider;
-                }
-            }
-        }
-        // Precedence 2b: Config default provider (if no operation override)
-        if (this.configDefault) {
-            const provider = this.registry.get(this.configDefault);
-            if (provider) {
-                return provider;
-            }
-        }
-        // Precedence 3: Global provider env choice (CODEHERE_AI_PROVIDER)
-        const requestedProvider = process.env.CODEHERE_AI_PROVIDER?.toLowerCase();
-        if (requestedProvider) {
-            const provider = this.registry.get(requestedProvider);
-            if (provider) {
-                return provider;
-            }
-        }
-        // Precedence 4: Registry default provider (fallback)
-        return this.registry.getDefault();
-    }
-    /**
-     * Set operation-level configuration (for testing or future config file support)
-     */
-    setOperationConfig(config) {
-        this.operationConfig = config;
-    }
-    /**
-     * Get current operation configuration
-     */
-    getOperationConfig() {
-        return this.operationConfig;
-    }
-}
-//# sourceMappingURL=operation-provider-resolver.js.map

package/dist/infrastructure/providers/provider-config-loader.js

@@ -1,120 +0,0 @@
-/**
- * Provider Layer: Provider Config Loader
- * Loads user-facing provider configuration from JSON files
- *
- * Phase 4G: User-facing provider config files
- */
-import { existsSync, readFileSync } from 'fs';
-import { join, resolve } from 'path';
-import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
-/**
- * Load provider configuration from file
- *
- * @param options - Optional configuration
- * @param options.cwd - Working directory (defaults to process.cwd())
- * @returns ProviderConfig if file exists and is valid, undefined otherwise
- */
-export function loadProviderConfig(options) {
-    const cwd = options?.cwd || process.cwd();
-    // Determine config file path
-    let configPath;
-    // Check for explicit path override
-    if (process.env.CODEHERE_PROVIDER_CONFIG_PATH) {
-        configPath = resolve(process.env.CODEHERE_PROVIDER_CONFIG_PATH);
-    }
-    else {
-        // Find codebase root
-        const codebaseInfo = findCodebaseRoot(cwd);
-        if (codebaseInfo) {
-            // Default path: .codehere/providers.json
-            configPath = join(codebaseInfo.rootPath, '.codehere', 'providers.json');
-        }
-        else {
-            // Fallback to cwd if codebase root not found
-            configPath = join(cwd, '.codehere', 'providers.json');
-        }
-    }
-    // If file doesn't exist, return undefined (not an error)
-    if (!configPath || !existsSync(configPath)) {
-        return undefined;
-    }
-    try {
-        // Read and parse JSON
-        const fileContent = readFileSync(configPath, 'utf-8');
-        const rawConfig = JSON.parse(fileContent);
-        // Validate and normalize config
-        return validateAndNormalizeConfig(rawConfig);
-    }
-    catch (error) {
-        // Log warning but don't throw (non-fatal)
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.warn(`[ProviderConfigLoader] Failed to load config from ${configPath}: ${errorMessage}`);
-        return undefined;
-    }
-}
-/**
- * Validate and normalize raw config object
- * Ignores unknown fields and invalid values gracefully
- */
-function validateAndNormalizeConfig(raw) {
-    if (!raw || typeof raw !== 'object') {
-        return undefined;
-    }
-    const config = {};
-    const obj = raw;
-    // Extract default provider
-    if (obj.default !== undefined) {
-        if (typeof obj.default === 'string' && obj.default.trim()) {
-            config.default = obj.default.trim();
-        }
-    }
-    // Extract operations
-    if (obj.operations !== undefined && typeof obj.operations === 'object' && obj.operations !== null) {
-        const operations = obj.operations;
-        const normalizedOps = {};
-        // Known operation types
-        const validOperations = ['chat', 'embedding', 'rerank'];
-        for (const op of validOperations) {
-            if (operations[op] !== undefined) {
-                const providerId = operations[op];
-                if (typeof providerId === 'string' && providerId.trim()) {
-                    normalizedOps[op] = providerId.trim();
-                }
-            }
-        }
-        // Only set operations if at least one is valid
-        if (Object.keys(normalizedOps).length > 0) {
-            config.operations = normalizedOps;
-        }
-    }
-    // Return config only if it has at least one meaningful field
-    if (config.default || config.operations) {
-        return config;
-    }
-    return undefined;
-}
-/**
- * Convert ProviderConfig to OperationProviderConfig
- * Used to pass config to OperationProviderResolver
- */
-export function configToOperationConfig(config) {
-    const operationConfig = {};
-    // Set default if present
-    if (config.default) {
-        operationConfig.default = config.default;
-    }
-    // Map operations
-    if (config.operations) {
-        if (config.operations.chat) {
-            operationConfig.chat = config.operations.chat;
-        }
-        if (config.operations.embedding) {
-            operationConfig.embedding = config.operations.embedding;
-        }
-        if (config.operations.rerank) {
-            operationConfig.rerank = config.operations.rerank;
-        }
-    }
-    return operationConfig;
-}
-//# sourceMappingURL=provider-config-loader.js.map