codeep 1.0.0

package/dist/api/index.js

@@ -0,0 +1,421 @@
+import { config, getApiKey } from '../config/index';
+import { withRetry, isNetworkError, isTimeoutError } from '../utils/retry';
+import { getProvider, getProviderBaseUrl, getProviderAuthHeader } from '../config/providers';
+import { logApiRequest, logApiResponse } from '../utils/logger';
+// Error messages by language
+const ERROR_MESSAGES = {
+    en: {
+        noInternet: 'No internet connection. Please check your network.',
+        timeout: 'Request timed out. Please try again.',
+        retrying: 'Connection failed, retrying...',
+        apiError: 'API error',
+    },
+    hr: {
+        noInternet: 'Nema internet konekcije. Provjerite mrežu.',
+        timeout: 'Zahtjev je istekao. Pokušajte ponovo.',
+        retrying: 'Konekcija nije uspjela, pokušavam ponovo...',
+        apiError: 'API greška',
+    },
+};
+function getErrorMessage(key) {
+    const lang = config.get('language');
+    const messages = ERROR_MESSAGES[lang] || ERROR_MESSAGES['en'];
+    return messages[key] || ERROR_MESSAGES['en'][key];
+}
+// Store project context for use in system prompt
+let currentProjectContext = null;
+export function setProjectContext(ctx) {
+    currentProjectContext = ctx;
+}
+export async function chat(message, history = [], onChunk, onRetry, projectContext, abortSignal) {
+    // Update project context if provided
+    if (projectContext !== undefined) {
+        currentProjectContext = projectContext;
+    }
+    const protocol = config.get('protocol');
+    const model = config.get('model');
+    const apiKey = getApiKey();
+    const providerId = config.get('provider');
+    if (!apiKey) {
+        throw new Error('API key not configured');
+    }
+    // Log API request
+    logApiRequest(providerId, model, history.length + 1);
+    const chatFn = protocol === 'anthropic'
+        ? () => chatAnthropic(message, history, model, apiKey, onChunk, abortSignal)
+        : () => chatOpenAI(message, history, model, apiKey, onChunk, abortSignal);
+    try {
+        const response = await withRetry(chatFn, {
+            maxAttempts: 3,
+            baseDelay: 1000,
+            onRetry: (attempt, error) => {
+                if (onRetry) {
+                    onRetry(attempt);
+                }
+            },
+            shouldRetry: (error) => {
+                // Don't retry on user abort
+                if (error.name === 'AbortError')
+                    return false;
+                // Don't retry on 4xx client errors (except 429 rate limit)
+                if (error.status >= 400 && error.status < 500 && error.status !== 429)
+                    return false;
+                // Retry on network errors, timeouts, 5xx, and rate limits
+                return true;
+            },
+        });
+        // Log successful response
+        logApiResponse(providerId, true, response.length);
+        return response;
+    }
+    catch (error) {
+        const err = error;
+        // Don't log or throw if request was aborted by user
+        if (err.name === 'AbortError' || err.message?.includes('aborted')) {
+            throw error; // Re-throw abort errors silently
+        }
+        // Log error
+        logApiResponse(providerId, false, undefined, err.message);
+        // Translate errors to user-friendly messages
+        if (isNetworkError(error)) {
+            throw new Error(getErrorMessage('noInternet'));
+        }
+        if (isTimeoutError(error)) {
+            throw new Error(getErrorMessage('timeout'));
+        }
+        throw error;
+    }
+}
+const LANGUAGE_NAMES = {
+    'en': 'English',
+    'zh': 'Chinese (中文)',
+    'es': 'Spanish (Español)',
+    'hi': 'Hindi (हिन्दी)',
+    'ar': 'Arabic (العربية)',
+    'pt': 'Portuguese (Português)',
+    'fr': 'French (Français)',
+    'de': 'German (Deutsch)',
+    'ja': 'Japanese (日本語)',
+    'ru': 'Russian (Русский)',
+    'hr': 'Croatian (Hrvatski)',
+};
+function getSystemPrompt() {
+    const language = config.get('language');
+    let basePrompt;
+    if (language === 'auto') {
+        basePrompt = `You are a helpful AI coding assistant. Always respond in the same language as the user's message. Detect the language of the user's input and reply in that same language.`;
+    }
+    else {
+        const langName = LANGUAGE_NAMES[language] || 'English';
+        basePrompt = `You are a helpful AI coding assistant. Always respond in ${langName}, regardless of what language the user writes in.`;
+    }
+    // Important: This is CHAT mode, not agent mode
+    // The model should NOT pretend to execute tools or create files
+    basePrompt += `
+
+IMPORTANT: You are in CHAT mode, NOT agent mode. You do NOT have the ability to:
+- Create, edit, or delete files directly
+- Execute shell commands
+- Use tools or tool_calls
+
+If the conversation history contains messages about file creation or tool execution, those were from a previous agent session. In chat mode, you can only provide advice, explanations, and code suggestions that the user must manually apply.`;
+    // Add project context if available
+    if (currentProjectContext) {
+        const writeInfo = currentProjectContext.hasWriteAccess
+            ? `
+
+**Write Access:** ENABLED - You can suggest file modifications. Format them as:
+\`\`\`filepath:path/to/file.ts
+// modified code here
+\`\`\`
+The user will review and approve changes before they are applied.`
+            : `
+
+**Write Access:** READ-ONLY - You can analyze code but cannot suggest file modifications.`;
+        const projectInfo = `
+
+## Project Context
+You are working with a ${currentProjectContext.type} project called "${currentProjectContext.name}".
+
+**Project Structure:**
+\`\`\`
+${currentProjectContext.structure}
+\`\`\`
+
+**Key Files:** ${currentProjectContext.keyFiles.join(', ')}${writeInfo}
+
+When the user mentions a file path, the file content will be automatically attached to their message.
+You can analyze, explain, or suggest improvements to the code.`;
+        return basePrompt + projectInfo;
+    }
+    return basePrompt;
+}
+async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal) {
+    const messages = [
+        { role: 'system', content: getSystemPrompt() },
+        ...history,
+        { role: 'user', content: message },
+    ];
+    const stream = Boolean(onChunk);
+    const timeout = config.get('apiTimeout');
+    const temperature = config.get('temperature');
+    const maxTokens = config.get('maxTokens');
+    // Get provider-specific URL and auth
+    const providerId = config.get('provider');
+    const baseUrl = getProviderBaseUrl(providerId, 'openai');
+    const authHeader = getProviderAuthHeader(providerId, 'openai');
+    if (!baseUrl) {
+        throw new Error(`Provider ${providerId} does not support OpenAI protocol`);
+    }
+    // Create abort controller for timeout or use provided one
+    const controller = abortSignal ? new AbortController() : new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    // Listen to external abort signal if provided
+    if (abortSignal) {
+        abortSignal.addEventListener('abort', () => controller.abort());
+    }
+    // Build headers based on auth type
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (authHeader === 'Bearer') {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    else {
+        headers['x-api-key'] = apiKey;
+    }
+    try {
+        const response = await fetch(`${baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                model,
+                messages,
+                stream,
+                temperature,
+                max_tokens: maxTokens,
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            const err = new Error(`${getErrorMessage('apiError')}: ${response.status} - ${error}`);
+            err.status = response.status;
+            throw err;
+        }
+        if (stream && response.body) {
+            return handleOpenAIStream(response.body, onChunk);
+        }
+        else {
+            const data = await response.json();
+            const content = data.choices[0]?.message?.content || '';
+            return stripThinkTags(content);
+        }
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+async function handleOpenAIStream(body, onChunk) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const chunks = [];
+    let buffer = '';
+    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.startsWith('data: ')) {
+                const data = line.slice(6);
+                if (data === '[DONE]')
+                    continue;
+                try {
+                    const parsed = JSON.parse(data);
+                    const content = parsed.choices?.[0]?.delta?.content;
+                    if (content) {
+                        chunks.push(content);
+                        onChunk(content);
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+        }
+    }
+    // Strip <think> tags from MiniMax and other providers
+    return stripThinkTags(chunks.join(''));
+}
+async function chatAnthropic(message, history, model, apiKey, onChunk, abortSignal) {
+    const systemPrompt = getSystemPrompt();
+    const messages = [
+        { role: 'user', content: systemPrompt },
+        { role: 'assistant', content: 'Understood. I will follow your language instructions.' },
+        ...history,
+        { role: 'user', content: message },
+    ];
+    const stream = Boolean(onChunk);
+    const timeout = config.get('apiTimeout');
+    const temperature = config.get('temperature');
+    const maxTokens = config.get('maxTokens');
+    // Get provider-specific URL and auth
+    const providerId = config.get('provider');
+    const baseUrl = getProviderBaseUrl(providerId, 'anthropic');
+    const authHeader = getProviderAuthHeader(providerId, 'anthropic');
+    if (!baseUrl) {
+        throw new Error(`Provider ${providerId} does not support Anthropic protocol`);
+    }
+    // Create abort controller for timeout or use provided one
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    // Listen to external abort signal if provided
+    if (abortSignal) {
+        abortSignal.addEventListener('abort', () => controller.abort());
+    }
+    // Build headers based on auth type
+    const headers = {
+        'Content-Type': 'application/json',
+        'anthropic-version': '2023-06-01',
+    };
+    if (authHeader === 'Bearer') {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    else {
+        headers['x-api-key'] = apiKey;
+    }
+    try {
+        const response = await fetch(`${baseUrl}/v1/messages`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                model,
+                messages,
+                max_tokens: maxTokens,
+                temperature,
+                stream,
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            const err = new Error(`${getErrorMessage('apiError')}: ${response.status} - ${error}`);
+            err.status = response.status;
+            throw err;
+        }
+        if (stream && response.body) {
+            return handleAnthropicStream(response.body, onChunk);
+        }
+        else {
+            const data = await response.json();
+            const content = data.content[0]?.text || '';
+            return stripThinkTags(content);
+        }
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Remove <think>...</think> tags from response
+ * Some providers (MiniMax, DeepSeek) include internal reasoning in these tags
+ * which should not be shown to users
+ */
+function stripThinkTags(text) {
+    return text.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+}
+async function handleAnthropicStream(body, onChunk) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const chunks = [];
+    let buffer = '';
+    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.startsWith('data: ')) {
+                const data = line.slice(6);
+                try {
+                    const parsed = JSON.parse(data);
+                    if (parsed.type === 'content_block_delta') {
+                        const text = parsed.delta?.text;
+                        if (text) {
+                            chunks.push(text);
+                            onChunk(text);
+                        }
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+        }
+    }
+    // Strip <think> tags from MiniMax responses
+    return stripThinkTags(chunks.join(''));
+}
+export async function validateApiKey(apiKey, providerId) {
+    const provider = providerId || config.get('provider');
+    const providerConfig = getProvider(provider);
+    if (!providerConfig) {
+        return { valid: false, error: `Unknown provider: ${provider}` };
+    }
+    // Determine which protocol to use for validation
+    const protocol = providerConfig.defaultProtocol;
+    const baseUrl = getProviderBaseUrl(provider, protocol);
+    const authHeader = getProviderAuthHeader(provider, protocol);
+    const model = providerConfig.defaultModel;
+    if (!baseUrl) {
+        return { valid: false, error: `No endpoint configured for ${provider}` };
+    }
+    // Build headers
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (authHeader === 'Bearer') {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    else {
+        headers['x-api-key'] = apiKey;
+    }
+    if (protocol === 'anthropic') {
+        headers['anthropic-version'] = '2023-06-01';
+    }
+    // Build request based on protocol
+    const endpoint = protocol === 'openai' ? '/chat/completions' : '/v1/messages';
+    const body = protocol === 'openai'
+        ? {
+            model,
+            messages: [{ role: 'user', content: 'hi' }],
+            max_tokens: 5,
+        }
+        : {
+            model,
+            messages: [{ role: 'user', content: 'hi' }],
+            max_tokens: 5,
+        };
+    try {
+        const response = await fetch(`${baseUrl}${endpoint}`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (response.ok) {
+            return { valid: true };
+        }
+        else {
+            const errorText = await response.text();
+            return { valid: false, error: `${response.status}: ${errorText}` };
+        }
+    }
+    catch (err) {
+        return { valid: false, error: err.message };
+    }
+}

package/dist/app.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const App: React.FC;