archicore 0.1.0

package/dist/orchestrator/deepseek-optimizer.js

@@ -0,0 +1,320 @@
+/**
+ * DeepSeek Optimizer
+ *
+ * Оптимизирует промпты и контекст специально для DeepSeek,
+ * чтобы минимизировать ошибки и получать точные ответы.
+ */
+import { Logger } from '../utils/logger.js';
+export class DeepSeekOptimizer {
+    config;
+    constructor(config) {
+        this.config = {
+            maxContextLength: 8000, // DeepSeek лучше работает с коротким контекстом
+            simplifyPrompts: true,
+            useEnglish: true, // DeepSeek лучше понимает английский
+            reduceExamples: true,
+            structuredOutput: true,
+            ...config
+        };
+    }
+    /**
+     * Оптимизирует промпт для DeepSeek
+     */
+    optimizePrompt(prompt) {
+        Logger.debug('Optimizing prompt for DeepSeek...');
+        let optimizedSystem = prompt.system;
+        let optimizedUser = prompt.user;
+        // 1. Упрощаем системный промпт
+        if (this.config.simplifyPrompts) {
+            optimizedSystem = this.simplifySystemPrompt(prompt.system);
+        }
+        // 2. Сокращаем контекст
+        if (prompt.context) {
+            optimizedSystem = this.reduceContext(optimizedSystem, prompt.context);
+        }
+        // 3. Упрощаем пользовательский запрос
+        if (this.config.simplifyPrompts) {
+            optimizedUser = this.simplifyUserPrompt(prompt.user);
+        }
+        // 4. Добавляем требование структурированного вывода
+        if (this.config.structuredOutput) {
+            optimizedUser = this.addStructuredOutputRequest(optimizedUser);
+        }
+        // 5. Переводим на английский (если нужно)
+        if (this.config.useEnglish) {
+            optimizedSystem = this.translateToEnglish(optimizedSystem);
+            optimizedUser = this.translateToEnglish(optimizedUser);
+        }
+        // 6. Обрезаем до максимальной длины
+        optimizedSystem = this.truncateText(optimizedSystem, this.config.maxContextLength);
+        optimizedUser = this.truncateText(optimizedUser, this.config.maxContextLength);
+        Logger.debug(`Prompt optimized: ${prompt.system.length + prompt.user.length} -> ${optimizedSystem.length + optimizedUser.length} chars`);
+        return {
+            system: optimizedSystem,
+            user: optimizedUser,
+            context: prompt.context
+        };
+    }
+    /**
+     * Упрощает системный промпт
+     */
+    simplifySystemPrompt(prompt) {
+        let simplified = prompt;
+        // Убираем избыточные формулировки
+        simplified = simplified
+            .replace(/с глубокими знаниями/g, 'with knowledge')
+            .replace(/Вы являетесь/g, 'You are')
+            .replace(/должны/g, 'should')
+            .replace(/необходимо/g, 'need to');
+        // Сокращаем длинные списки правил
+        const lines = simplified.split('\n');
+        const importantLines = lines.filter(line => {
+            // Оставляем только важные строки
+            return (line.includes('You are') ||
+                line.includes('Your role') ||
+                line.includes('Important') ||
+                line.includes('Rules') ||
+                line.includes('Bounded Context') ||
+                line.trim().startsWith('-'));
+        });
+        return importantLines.join('\n');
+    }
+    /**
+     * Упрощает пользовательский промпт
+     */
+    simplifyUserPrompt(prompt) {
+        let simplified = prompt;
+        // Убираем эмодзи (DeepSeek может путаться)
+        simplified = simplified.replace(/[\u{1F300}-\u{1F9FF}]/gu, '');
+        // Убираем markdown форматирование, которое может сбивать
+        simplified = simplified
+            .replace(/\*\*\*([^*]+)\*\*\*/g, '$1') // *** text ***
+            .replace(/\*\*([^*]+)\*\*/g, '$1'); // ** text **
+        // Упрощаем структуру
+        simplified = simplified
+            .replace(/Пожалуйста, предоставьте:/g, 'Provide:')
+            .replace(/Пожалуйста/g, 'Please')
+            .replace(/Необходимо/g, 'Need');
+        return simplified;
+    }
+    /**
+     * Сокращает контекст до самого важного
+     */
+    reduceContext(systemPrompt, context) {
+        let reduced = systemPrompt;
+        // Сокращаем semantic memory до 3 самых релевантных
+        if (context.semanticMemory && context.semanticMemory.length > 3) {
+            const topResults = context.semanticMemory.slice(0, 3);
+            reduced += '\n\n**Relevant Code (top 3):**\n';
+            for (const result of topResults) {
+                // Берем только путь к файлу и короткий контекст
+                const shortContext = result.context.substring(0, 150);
+                reduced += `- ${result.chunk.metadata.filePath}: ${shortContext}...\n`;
+            }
+        }
+        // Сокращаем информацию об архитектуре
+        if (context.architecture?.boundedContexts) {
+            reduced += '\n\n**Architecture:**\n';
+            for (const bc of context.architecture.boundedContexts.slice(0, 3)) {
+                reduced += `- ${bc.name}: ${bc.description}\n`;
+            }
+        }
+        return reduced;
+    }
+    /**
+     * Добавляет требование структурированного вывода
+     */
+    addStructuredOutputRequest(userPrompt) {
+        // Добавляем четкое требование к формату ответа
+        return userPrompt + '\n\n**Output Format:**\nProvide a clear, structured response. Use numbered lists. Be specific and concise.';
+    }
+    /**
+     * Упрощенный перевод ключевых терминов на английский
+     */
+    translateToEnglish(text) {
+        // Базовый словарь для перевода
+        const translations = {
+            'Вы': 'You',
+            'являетесь': 'are',
+            'архитектором': 'architect',
+            'системным': 'system',
+            'программного обеспечения': 'software',
+            'Ваша роль': 'Your role',
+            'Понимать': 'Understand',
+            'весь код': 'entire codebase',
+            'структуру кодовой базы': 'codebase structure',
+            'Принимать': 'Make',
+            'архитектурные решения': 'architectural decisions',
+            'на основе контекста': 'based on context',
+            'Определять': 'Identify',
+            'риски': 'risks',
+            'потенциальные проблемы': 'potential issues',
+            'Предлагать': 'Suggest',
+            'улучшения': 'improvements',
+            'сохраняя': 'maintaining',
+            'целостность системы': 'system integrity',
+            'Следовать': 'Follow',
+            'установленным': 'established',
+            'правилам': 'rules',
+            'паттернам': 'patterns',
+            'Принципы': 'Principles',
+            'Минимизировать': 'Minimize',
+            'breaking changes': 'breaking changes',
+            'Поддерживать': 'Maintain',
+            'обратную совместимость': 'backward compatibility',
+            'когда возможно': 'when possible',
+            'Предпочитать': 'Prefer',
+            'инкрементальные улучшения': 'incremental improvements',
+            'большим переписываниям': 'big rewrites',
+            'Учитывать': 'Consider',
+            'производительность': 'performance',
+            'безопасность': 'security',
+            'поддерживаемость': 'maintainability',
+            'Уважать': 'Respect',
+            'границы контекстов': 'bounded contexts',
+            'доменные границы': 'domain boundaries',
+            'Анализировать': 'Analyze',
+            'влияние изменений': 'impact of changes',
+            'Описание изменения': 'Change Description',
+            'Тип': 'Type',
+            'Файлы': 'Files',
+            'Затронутые компоненты': 'Affected Components',
+            'Критические': 'Critical',
+            'Высокие': 'High',
+            'Средние': 'Medium',
+            'Низкие': 'Low',
+            'Выявленные риски': 'Identified Risks',
+            'Текущие рекомендации': 'Current Recommendations',
+            'Предоставьте': 'Provide',
+            'Дополнительные риски или проблемы': 'Additional risks or concerns',
+            'Конкретные шаги миграции': 'Specific migration steps',
+            'при необходимости': 'if needed',
+            'Стратегия тестирования': 'Testing strategy',
+            'План отката': 'Rollback plan',
+            'Долгосрочные архитектурные последствия': 'Long-term architectural implications'
+        };
+        let translated = text;
+        // Если текст в основном на русском, переводим ключевые части
+        if (this.isMostlyRussian(text)) {
+            for (const [russian, english] of Object.entries(translations)) {
+                translated = translated.replace(new RegExp(russian, 'g'), english);
+            }
+        }
+        return translated;
+    }
+    /**
+     * Проверяет, в основном ли текст на русском
+     */
+    isMostlyRussian(text) {
+        const russianChars = text.match(/[а-яА-ЯёЁ]/g);
+        const totalChars = text.replace(/\s/g, '').length;
+        return russianChars ? (russianChars.length / totalChars) > 0.3 : false;
+    }
+    /**
+     * Обрезает текст до максимальной длины
+     */
+    truncateText(text, maxLength) {
+        if (text.length <= maxLength) {
+            return text;
+        }
+        // Обрезаем, но стараемся сохранить смысл
+        const truncated = text.substring(0, maxLength);
+        // Находим последнюю точку или перенос строки
+        const lastPeriod = truncated.lastIndexOf('.');
+        const lastNewline = truncated.lastIndexOf('\n');
+        const cutPoint = Math.max(lastPeriod, lastNewline);
+        if (cutPoint > maxLength * 0.8) {
+            return truncated.substring(0, cutPoint + 1);
+        }
+        return truncated + '...';
+    }
+    /**
+     * Разбивает сложную задачу на простые подзадачи
+     */
+    splitComplexTask(task) {
+        const subtasks = [];
+        // Определяем тип задачи
+        if (task.includes('analyze') || task.includes('анализ')) {
+            subtasks.push('Step 1: List all affected components');
+            subtasks.push('Step 2: Identify direct dependencies');
+            subtasks.push('Step 3: Assess risk level for each component');
+            subtasks.push('Step 4: Provide recommendations');
+        }
+        else if (task.includes('refactor') || task.includes('рефакторинг')) {
+            subtasks.push('Step 1: Identify code to refactor');
+            subtasks.push('Step 2: Propose refactoring approach');
+            subtasks.push('Step 3: List potential risks');
+            subtasks.push('Step 4: Define testing requirements');
+        }
+        else if (task.includes('review') || task.includes('ревью')) {
+            subtasks.push('Step 1: Check architecture compliance');
+            subtasks.push('Step 2: Find potential bugs');
+            subtasks.push('Step 3: Identify performance issues');
+            subtasks.push('Step 4: Suggest improvements');
+        }
+        else {
+            // Общий подход
+            subtasks.push('Step 1: Understand the context');
+            subtasks.push('Step 2: Analyze the requirements');
+            subtasks.push('Step 3: Provide solution');
+            subtasks.push('Step 4: List considerations');
+        }
+        return subtasks;
+    }
+    /**
+     * Валидирует и очищает ответ от DeepSeek
+     */
+    validateAndCleanResponse(response) {
+        let cleaned = response;
+        // Убираем возможный мусор в начале/конце
+        cleaned = cleaned.trim();
+        // Убираем повторяющиеся переносы строк
+        cleaned = cleaned.replace(/\n{3,}/g, '\n\n');
+        // Убираем незавершенные предложения в конце
+        const lastChar = cleaned[cleaned.length - 1];
+        if (lastChar !== '.' && lastChar !== '!' && lastChar !== '?' && lastChar !== '\n') {
+            const lastCompleteSentence = cleaned.lastIndexOf('.');
+            if (lastCompleteSentence > cleaned.length * 0.8) {
+                cleaned = cleaned.substring(0, lastCompleteSentence + 1);
+            }
+        }
+        return cleaned;
+    }
+    /**
+     * Создает retry-стратегию с упрощением
+     */
+    createRetryStrategy(originalPrompt, attemptNumber) {
+        Logger.info(`Creating retry strategy, attempt ${attemptNumber}`);
+        // С каждой попыткой упрощаем еще больше
+        const config = {
+            ...this.config,
+            maxContextLength: this.config.maxContextLength / attemptNumber,
+            simplifyPrompts: true,
+            useEnglish: true
+        };
+        const optimizer = new DeepSeekOptimizer(config);
+        return optimizer.optimizePrompt(originalPrompt);
+    }
+}
+/**
+ * Создает оптимизированный промпт для простых задач DeepSeek
+ */
+export function createSimplePrompt(task, context) {
+    const systemPrompt = `You are a helpful AI assistant for code analysis.
+
+Rules:
+- Be concise and specific
+- Use structured output
+- Focus on facts, not speculation
+- If unsure, say so
+
+${context ? `Context:\n${context.substring(0, 500)}` : ''}`;
+    const userPrompt = `Task: ${task}
+
+Provide a clear, structured response.`;
+    return {
+        system: systemPrompt,
+        user: userPrompt
+    };
+}
+//# sourceMappingURL=deepseek-optimizer.js.map

package/dist/orchestrator/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * LLM Orchestrator
+ *
+ * Оркестрация взаимодействия с LLM:
+ * - Управление контекстом
+ * - Генерация промптов с архитектурными знаниями
+ * - Интеграция с Claude/GPT
+ * - Принятие архитектурных решений
+ */
+import { LLMConfig, LLMPrompt, LLMContext, LLMResponse, ChangeImpact } from '../types/index.js';
+export declare class LLMOrchestrator {
+    private anthropic?;
+    private openai?;
+    private config;
+    private deepseekOptimizer?;
+    private initialized;
+    private _isAvailable;
+    constructor(config: LLMConfig);
+    private ensureInitialized;
+    isAvailable(): boolean;
+    query(prompt: LLMPrompt, retryCount?: number): Promise<LLMResponse>;
+    analyzeImpact(impact: ChangeImpact, context?: LLMContext): Promise<string>;
+    suggestRefactoring(code: string, goal: string, context?: LLMContext): Promise<string>;
+    answerArchitecturalQuestion(question: string, context: LLMContext): Promise<string>;
+    generateDocumentation(codebase: string, context: LLMContext): Promise<string>;
+    reviewCode(code: string, changedFiles: string[], context: LLMContext): Promise<string>;
+    private queryAnthropic;
+    private queryOpenAI;
+    private buildImpactAnalysisPrompt;
+    private buildRefactoringPrompt;
+    private buildArchitecturalPrompt;
+    private buildSystemPrompt;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/orchestrator/index.js

@@ -0,0 +1,305 @@
+/**
+ * LLM Orchestrator
+ *
+ * Оркестрация взаимодействия с LLM:
+ * - Управление контекстом
+ * - Генерация промптов с архитектурными знаниями
+ * - Интеграция с Claude/GPT
+ * - Принятие архитектурных решений
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
+import { Logger } from '../utils/logger.js';
+import { DeepSeekOptimizer } from './deepseek-optimizer.js';
+export class LLMOrchestrator {
+    anthropic;
+    openai;
+    config;
+    deepseekOptimizer;
+    initialized = false;
+    _isAvailable = false;
+    constructor(config) {
+        this.config = config;
+        // Lazy initialization
+    }
+    ensureInitialized() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        try {
+            if (this.config.provider === 'anthropic') {
+                const apiKey = process.env.ANTHROPIC_API_KEY;
+                if (!apiKey) {
+                    Logger.warn('ANTHROPIC_API_KEY not set - LLM disabled');
+                    return;
+                }
+                this.anthropic = new Anthropic({ apiKey });
+                this._isAvailable = true;
+            }
+            else if (this.config.provider === 'deepseek') {
+                const apiKey = process.env.DEEPSEEK_API_KEY;
+                if (!apiKey) {
+                    Logger.warn('DEEPSEEK_API_KEY not set - LLM disabled');
+                    return;
+                }
+                this.openai = new OpenAI({
+                    apiKey,
+                    baseURL: this.config.baseURL || 'https://api.deepseek.com'
+                });
+                this.deepseekOptimizer = new DeepSeekOptimizer({
+                    maxContextLength: 8000,
+                    simplifyPrompts: true,
+                    useEnglish: true,
+                    reduceExamples: true,
+                    structuredOutput: true
+                });
+                Logger.info('DeepSeek optimizer enabled');
+                this._isAvailable = true;
+            }
+            else {
+                const apiKey = process.env.OPENAI_API_KEY;
+                if (!apiKey) {
+                    Logger.warn('OPENAI_API_KEY not set - LLM disabled');
+                    return;
+                }
+                this.openai = new OpenAI({ apiKey });
+                this._isAvailable = true;
+            }
+        }
+        catch (error) {
+            Logger.warn('LLM init failed: ' + error);
+        }
+    }
+    isAvailable() {
+        this.ensureInitialized();
+        return this._isAvailable;
+    }
+    async query(prompt, retryCount = 0) {
+        this.ensureInitialized();
+        if (!this._isAvailable) {
+            return {
+                content: 'LLM not available - API key not configured',
+                metadata: { tokensUsed: 0, model: this.config.model, timestamp: Date.now() }
+            };
+        }
+        Logger.progress('Querying LLM...');
+        try {
+            // Оптимизируем промпт для DeepSeek
+            let optimizedPrompt = prompt;
+            if (this.config.provider === 'deepseek' && this.deepseekOptimizer) {
+                if (retryCount > 0) {
+                    // При повторных попытках упрощаем еще больше
+                    optimizedPrompt = this.deepseekOptimizer.createRetryStrategy(prompt, retryCount + 1);
+                    Logger.info(`Using retry strategy ${retryCount + 1} for DeepSeek`);
+                }
+                else {
+                    optimizedPrompt = this.deepseekOptimizer.optimizePrompt(prompt);
+                    Logger.info('Prompt optimized for DeepSeek');
+                }
+            }
+            // Выполняем запрос
+            if (this.config.provider === 'anthropic' && this.anthropic) {
+                return await this.queryAnthropic(optimizedPrompt);
+            }
+            else if ((this.config.provider === 'openai' || this.config.provider === 'deepseek') &&
+                this.openai) {
+                const response = await this.queryOpenAI(optimizedPrompt);
+                // Для DeepSeek валидируем и очищаем ответ
+                if (this.config.provider === 'deepseek' && this.deepseekOptimizer) {
+                    response.content = this.deepseekOptimizer.validateAndCleanResponse(response.content);
+                }
+                return response;
+            }
+            throw new Error('No LLM provider configured');
+        }
+        catch (error) {
+            // Retry логика для DeepSeek
+            if (this.config.provider === 'deepseek' && retryCount < 2) {
+                Logger.warn(`DeepSeek query failed, retrying (${retryCount + 1}/2)...`);
+                await new Promise(resolve => setTimeout(resolve, 1000 * (retryCount + 1)));
+                return this.query(prompt, retryCount + 1);
+            }
+            Logger.error('LLM query failed', error);
+            throw error;
+        }
+    }
+    async analyzeImpact(impact, context) {
+        const prompt = this.buildImpactAnalysisPrompt(impact, context);
+        const response = await this.query(prompt);
+        return response.content;
+    }
+    async suggestRefactoring(code, goal, context) {
+        const prompt = this.buildRefactoringPrompt(code, goal, context);
+        const response = await this.query(prompt);
+        return response.content;
+    }
+    async answerArchitecturalQuestion(question, context) {
+        const prompt = this.buildArchitecturalPrompt(question, context);
+        const response = await this.query(prompt);
+        return response.content;
+    }
+    async generateDocumentation(codebase, context) {
+        const prompt = {
+            system: this.buildSystemPrompt(context),
+            user: `Generate comprehensive documentation for this codebase:\n\n${codebase}\n\nInclude:\n- Architecture overview\n- Key components\n- Data flows\n- Design decisions\n- Usage examples`
+        };
+        const response = await this.query(prompt);
+        return response.content;
+    }
+    async reviewCode(code, changedFiles, context) {
+        const prompt = {
+            system: this.buildSystemPrompt(context),
+            user: `Review this code change:\n\nChanged files: ${changedFiles.join(', ')}\n\n${code}\n\nProvide:\n- Architecture compliance check\n- Potential bugs\n- Performance issues\n- Security concerns\n- Improvement suggestions`
+        };
+        const response = await this.query(prompt);
+        return response.content;
+    }
+    async queryAnthropic(prompt) {
+        if (!this.anthropic) {
+            throw new Error('Anthropic client not initialized');
+        }
+        const response = await this.anthropic.messages.create({
+            model: this.config.model,
+            max_tokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+            system: prompt.system,
+            messages: [
+                {
+                    role: 'user',
+                    content: prompt.user
+                }
+            ]
+        });
+        const content = response.content[0];
+        const text = content.type === 'text' ? content.text : '';
+        return {
+            content: text,
+            metadata: {
+                tokensUsed: response.usage.input_tokens + response.usage.output_tokens,
+                model: this.config.model,
+                timestamp: Date.now()
+            }
+        };
+    }
+    async queryOpenAI(prompt) {
+        if (!this.openai) {
+            throw new Error('OpenAI client not initialized');
+        }
+        const response = await this.openai.chat.completions.create({
+            model: this.config.model,
+            temperature: this.config.temperature,
+            max_tokens: this.config.maxTokens,
+            messages: [
+                {
+                    role: 'system',
+                    content: prompt.system
+                },
+                {
+                    role: 'user',
+                    content: prompt.user
+                }
+            ]
+        });
+        const message = response.choices[0]?.message;
+        return {
+            content: message?.content || '',
+            metadata: {
+                tokensUsed: response.usage?.total_tokens || 0,
+                model: this.config.model,
+                timestamp: Date.now()
+            }
+        };
+    }
+    buildImpactAnalysisPrompt(impact, context) {
+        const systemPrompt = this.buildSystemPrompt(context);
+        const userPrompt = `Analyze the impact of this change:
+
+**Change Description:** ${impact.change.description}
+**Type:** ${impact.change.type}
+**Files:** ${impact.change.files.join(', ')}
+
+**Affected Components:** ${impact.affectedNodes.length}
+- Critical: ${impact.affectedNodes.filter(n => n.impactLevel === 'critical').length}
+- High: ${impact.affectedNodes.filter(n => n.impactLevel === 'high').length}
+- Medium: ${impact.affectedNodes.filter(n => n.impactLevel === 'medium').length}
+
+**Risks Identified:** ${impact.risks.length}
+${impact.risks.map(r => `- [${r.severity}] ${r.description}`).join('\n')}
+
+**Current Recommendations:**
+${impact.recommendations.map(r => `- [${r.priority}] ${r.description}`).join('\n')}
+
+Please provide:
+1. Additional risks or concerns
+2. Specific migration steps if needed
+3. Testing strategy
+4. Rollback plan
+5. Long-term architectural implications`;
+        return {
+            system: systemPrompt,
+            user: userPrompt,
+            context
+        };
+    }
+    buildRefactoringPrompt(code, goal, context) {
+        const systemPrompt = this.buildSystemPrompt(context);
+        const userPrompt = `Suggest refactoring for this code to achieve: ${goal}
+
+Code:
+\`\`\`
+${code}
+\`\`\`
+
+Please provide:
+1. Proposed refactoring approach
+2. Step-by-step implementation plan
+3. Potential risks
+4. Testing requirements
+5. Before/after comparison`;
+        return {
+            system: systemPrompt,
+            user: userPrompt,
+            context
+        };
+    }
+    buildArchitecturalPrompt(question, context) {
+        return {
+            system: this.buildSystemPrompt(context),
+            user: question,
+            context
+        };
+    }
+    buildSystemPrompt(context) {
+        let prompt = `###CRITICAL INSTRUCTION - LANGUAGE###
+If the user's question contains Cyrillic characters (Russian), you MUST respond ENTIRELY in Russian.
+Если вопрос на русском - отвечай ТОЛЬКО на русском языке. Ни одного слова на английском!
+###END LANGUAGE INSTRUCTION###
+
+You are an AI assistant analyzing a specific codebase.
+
+ABSOLUTE RULES:
+1. ONLY USE PROVIDED DATA: You may ONLY mention files that appear in "PROJECT FILES" section below.
+2. NO INVENTION: NEVER invent file paths, class names, or code. If not shown - it doesn't exist.
+3. WHEN NO DATA: Say "Нет данных в индексе" (Russian) or "No indexed data" (English).
+4. BE HONEST: If you don't know - say so. Don't guess.`;
+        if (context?.architecture?.boundedContexts && context.architecture.boundedContexts.length > 0) {
+            prompt += '\n\n**Defined Architecture:**\n';
+            for (const bc of context.architecture.boundedContexts) {
+                prompt += `- ${bc.name}: ${bc.description}\n`;
+            }
+        }
+        if (context?.semanticMemory && context.semanticMemory.length > 0) {
+            prompt += '\n\n###PROJECT FILES (ONLY reference these - nothing else exists)###\n';
+            for (const result of context.semanticMemory.slice(0, 10)) {
+                prompt += `\nФайл: ${result.chunk.metadata.filePath}\n`;
+                prompt += `${result.context}\n`;
+            }
+            prompt += '\n###END PROJECT FILES###';
+        }
+        else {
+            prompt += '\n\n###PROJECT FILES: EMPTY###\nNo code indexed. Respond: "Проект не проиндексирован. Запустите индексацию."';
+        }
+        return prompt;
+    }
+}
+//# sourceMappingURL=index.js.map