archicore 0.4.0 → 0.4.1

package/dist/code-index/ast-parser.js

@@ -162,10 +162,12 @@ export class ASTParser {
                 /^(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?(?:\w+\s+)+(\w+)\s*\(/
             ],
             php: [
-                /^(?:public|private|protected)?\s*(?:static\s+)?function\s+(\w+)/,
-                /^class\s+(\w+)/,
-                /^interface\s+(\w+)/,
-                /^trait\s+(\w+)/
+                /^\s*namespace\s+([\w\\]+)/, // namespace App\Controllers
+                /^\s*(?:final\s+|abstract\s+)?class\s+(\w+)/, // class, final class, abstract class
+                /^\s*interface\s+(\w+)/, // interface
+                /^\s*trait\s+(\w+)/, // trait
+                /^\s*(?:public|private|protected)?\s*(?:static\s+)?function\s+(\w+)/, // function
+                /^\s*const\s+(\w+)\s*=/, // const
             ],
             ruby: [
                 /^def\s+(\w+)/,
@@ -400,16 +402,29 @@ export class ASTParser {
                         continue;
                     }
                     const type = this.inferTypeFromPattern(pattern, language);
+                    // Извлекаем больше контекста - следующие строки до закрывающей скобки
+                    let codeContext = trimmedLine;
+                    let endLineIndex = index;
+                    // Для функций/классов пытаемся захватить тело (до 50 строк)
+                    if (type.includes('function') || type.includes('class') || type.includes('method')) {
+                        let braceCount = (trimmedLine.match(/\{/g) || []).length - (trimmedLine.match(/\}/g) || []).length;
+                        for (let j = index + 1; j < Math.min(index + 50, lines.length) && braceCount > 0; j++) {
+                            const nextLine = lines[j];
+                            codeContext += '\n' + nextLine;
+                            braceCount += (nextLine.match(/\{/g) || []).length - (nextLine.match(/\}/g) || []).length;
+                            endLineIndex = j;
+                        }
+                    }
                     children.push({
                         id: `${filePath}:${name}:${index}`,
                         type,
                         name,
                         filePath,
                         startLine: index,
-                        endLine: index,
+                        endLine: endLineIndex,
                         children: [],
                         metadata: {
-                            text: trimmedLine.substring(0, 200),
+                            text: codeContext.substring(0, 2000), // Увеличено с 200 до 2000
                             hasErrors: false,
                             regexParsed: true
                         }

package/dist/code-index/file-chunker.d.ts

@@ -0,0 +1,61 @@
+/**
+ * File Chunker
+ *
+ * Умное разбиение больших файлов на логические части:
+ * - По классам/функциям/namespace
+ * - С сохранением контекста (импорты, namespace)
+ * - Для эффективного семантического поиска
+ */
+export interface FileChunk {
+    id: string;
+    filePath: string;
+    chunkIndex: number;
+    totalChunks: number;
+    startLine: number;
+    endLine: number;
+    type: 'header' | 'namespace' | 'class' | 'function' | 'trait' | 'interface' | 'code';
+    name: string;
+    content: string;
+    context: string;
+}
+export interface ChunkingOptions {
+    maxChunkSize: number;
+    minChunkSize: number;
+    includeContext: boolean;
+    language: string;
+}
+export declare class FileChunker {
+    /**
+     * Разбить файл на логические чанки
+     */
+    chunkFile(content: string, filePath: string, options?: Partial<ChunkingOptions>): FileChunk[];
+    /**
+     * Извлечь контекст файла (импорты, namespace)
+     */
+    private extractContext;
+    /**
+     * Найти логические границы в файле
+     */
+    private findLogicalBoundaries;
+    /**
+     * Найти конец блока кода
+     */
+    private findBlockEnd;
+    /**
+     * Получить уровень отступа строки
+     */
+    private getIndent;
+    /**
+     * Создать чанки из найденных границ
+     */
+    private createChunks;
+    /**
+     * Разбить большой блок на подчанки
+     */
+    private splitLargeBlock;
+    /**
+     * Разбить файл по размеру (fallback)
+     */
+    private chunkBySize;
+}
+//# sourceMappingURL=file-chunker.d.ts.map

package/dist/code-index/file-chunker.js

@@ -0,0 +1,431 @@
+/**
+ * File Chunker
+ *
+ * Умное разбиение больших файлов на логические части:
+ * - По классам/функциям/namespace
+ * - С сохранением контекста (импорты, namespace)
+ * - Для эффективного семантического поиска
+ */
+import { Logger } from '../utils/logger.js';
+const DEFAULT_OPTIONS = {
+    maxChunkSize: 4000,
+    minChunkSize: 500,
+    includeContext: true,
+    language: 'unknown'
+};
+export class FileChunker {
+    /**
+     * Разбить файл на логические чанки
+     */
+    chunkFile(content, filePath, options = {}) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        const lines = content.split('\n');
+        // Если файл маленький - возвращаем как есть
+        if (content.length <= opts.maxChunkSize) {
+            return [{
+                    id: `${filePath}:chunk:0`,
+                    filePath,
+                    chunkIndex: 0,
+                    totalChunks: 1,
+                    startLine: 0,
+                    endLine: lines.length - 1,
+                    type: 'code',
+                    name: filePath.split(/[/\\]/).pop() || 'file',
+                    content,
+                    context: ''
+                }];
+        }
+        // Извлекаем контекст (импорты, namespace, use statements)
+        const contextInfo = this.extractContext(lines, opts.language);
+        // Находим логические границы (классы, функции и т.д.)
+        const boundaries = this.findLogicalBoundaries(lines, opts.language);
+        // Создаём чанки
+        const chunks = this.createChunks(lines, boundaries, contextInfo, filePath, opts);
+        Logger.debug(`Chunked ${filePath}: ${content.length} chars -> ${chunks.length} chunks`);
+        return chunks;
+    }
+    /**
+     * Извлечь контекст файла (импорты, namespace)
+     */
+    extractContext(lines, language) {
+        const contextLines = [];
+        let endLine = 0;
+        const contextPatterns = {
+            php: [
+                /^\s*<\?php/,
+                /^\s*namespace\s+/,
+                /^\s*use\s+/,
+                /^\s*require(_once)?\s+/,
+                /^\s*include(_once)?\s+/,
+            ],
+            typescript: [
+                /^\s*import\s+/,
+                /^\s*export\s+\{[^}]*\}\s+from/,
+                /^\s*\/\/\s*@ts-/,
+            ],
+            javascript: [
+                /^\s*import\s+/,
+                /^\s*const\s+\{[^}]*\}\s*=\s*require/,
+                /^\s*require\s*\(/,
+            ],
+            python: [
+                /^\s*import\s+/,
+                /^\s*from\s+\w+\s+import/,
+                /^\s*#.*coding[:=]/,
+            ],
+            java: [
+                /^\s*package\s+/,
+                /^\s*import\s+/,
+            ],
+            csharp: [
+                /^\s*using\s+/,
+                /^\s*namespace\s+/,
+            ],
+            go: [
+                /^\s*package\s+/,
+                /^\s*import\s+/,
+            ],
+            rust: [
+                /^\s*use\s+/,
+                /^\s*mod\s+/,
+                /^\s*extern\s+crate/,
+            ],
+            ruby: [
+                /^\s*require\s+/,
+                /^\s*require_relative\s+/,
+                /^\s*include\s+/,
+            ]
+        };
+        const patterns = contextPatterns[language] || [];
+        // Собираем все строки импортов/namespace в начале файла
+        for (let i = 0; i < Math.min(lines.length, 100); i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            // Пустые строки и комментарии в начале - пропускаем но добавляем
+            if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('#') || trimmed.startsWith('/*') || trimmed.startsWith('*')) {
+                if (contextLines.length > 0 || patterns.some(p => p.test(trimmed))) {
+                    contextLines.push(line);
+                    endLine = i;
+                }
+                continue;
+            }
+            // Проверяем паттерны
+            const isContext = patterns.some(p => p.test(trimmed));
+            if (isContext) {
+                contextLines.push(line);
+                endLine = i;
+            }
+            else if (contextLines.length > 0) {
+                // Достигли конца контекста
+                break;
+            }
+        }
+        return {
+            context: contextLines.join('\n'),
+            endLine
+        };
+    }
+    /**
+     * Найти логические границы в файле
+     */
+    findLogicalBoundaries(lines, language) {
+        const boundaries = [];
+        // Паттерны для начала блоков
+        const blockPatterns = {
+            php: [
+                { pattern: /^\s*namespace\s+([\w\\]+)/, type: 'namespace' },
+                { pattern: /^\s*(?:final\s+|abstract\s+)?class\s+(\w+)/, type: 'class' },
+                { pattern: /^\s*interface\s+(\w+)/, type: 'interface' },
+                { pattern: /^\s*trait\s+(\w+)/, type: 'trait' },
+                { pattern: /^\s*(?:public|private|protected)?\s*(?:static\s+)?function\s+(\w+)/, type: 'function' },
+            ],
+            typescript: [
+                { pattern: /^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/, type: 'class' },
+                { pattern: /^\s*(?:export\s+)?interface\s+(\w+)/, type: 'interface' },
+                { pattern: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/, type: 'function' },
+                { pattern: /^\s*(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/, type: 'function' },
+            ],
+            javascript: [
+                { pattern: /^\s*(?:export\s+)?class\s+(\w+)/, type: 'class' },
+                { pattern: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/, type: 'function' },
+                { pattern: /^\s*(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/, type: 'function' },
+            ],
+            python: [
+                { pattern: /^class\s+(\w+)/, type: 'class' },
+                { pattern: /^(?:async\s+)?def\s+(\w+)/, type: 'function' },
+            ],
+            java: [
+                { pattern: /^\s*(?:public|private|protected)?\s*(?:abstract\s+)?class\s+(\w+)/, type: 'class' },
+                { pattern: /^\s*(?:public|private|protected)?\s*interface\s+(\w+)/, type: 'interface' },
+                { pattern: /^\s*(?:public|private|protected)?\s*(?:static\s+)?(?:\w+\s+)+(\w+)\s*\(/, type: 'function' },
+            ],
+            csharp: [
+                { pattern: /^\s*(?:public|private|protected|internal)?\s*(?:partial\s+)?class\s+(\w+)/, type: 'class' },
+                { pattern: /^\s*(?:public|private|protected|internal)?\s*interface\s+(\w+)/, type: 'interface' },
+            ],
+            go: [
+                { pattern: /^func\s+(?:\([^)]+\)\s+)?(\w+)/, type: 'function' },
+                { pattern: /^type\s+(\w+)\s+struct/, type: 'class' },
+                { pattern: /^type\s+(\w+)\s+interface/, type: 'interface' },
+            ],
+            rust: [
+                { pattern: /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/, type: 'function' },
+                { pattern: /^(?:pub\s+)?struct\s+(\w+)/, type: 'class' },
+                { pattern: /^(?:pub\s+)?trait\s+(\w+)/, type: 'interface' },
+                { pattern: /^impl(?:<[^>]+>)?\s+(\w+)/, type: 'class' },
+            ],
+            ruby: [
+                { pattern: /^\s*class\s+(\w+)/, type: 'class' },
+                { pattern: /^\s*module\s+(\w+)/, type: 'namespace' },
+                { pattern: /^\s*def\s+(\w+)/, type: 'function' },
+            ]
+        };
+        const patterns = blockPatterns[language] || blockPatterns.javascript || [];
+        // Находим все блоки
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            for (const { pattern, type } of patterns) {
+                const match = line.match(pattern);
+                if (match) {
+                    const name = match[1] || 'anonymous';
+                    // Находим конец блока (по скобкам или отступам)
+                    const endLine = this.findBlockEnd(lines, i, language);
+                    boundaries.push({
+                        startLine: i,
+                        endLine,
+                        type,
+                        name
+                    });
+                    // Пропускаем вложенные определения для классов
+                    if (type === 'class' || type === 'interface' || type === 'trait') {
+                        i = endLine;
+                    }
+                    break;
+                }
+            }
+        }
+        return boundaries;
+    }
+    /**
+     * Найти конец блока кода
+     */
+    findBlockEnd(lines, startLine, language) {
+        // Для языков с фигурными скобками
+        const braceLanguages = ['php', 'typescript', 'javascript', 'java', 'csharp', 'go', 'rust', 'c', 'cpp'];
+        if (braceLanguages.includes(language)) {
+            let braceCount = 0;
+            let foundFirstBrace = false;
+            for (let i = startLine; i < lines.length; i++) {
+                const line = lines[i];
+                // Подсчитываем скобки (упрощённо, не учитываем строки/комментарии)
+                for (const char of line) {
+                    if (char === '{') {
+                        braceCount++;
+                        foundFirstBrace = true;
+                    }
+                    else if (char === '}') {
+                        braceCount--;
+                    }
+                }
+                // Блок закрыт
+                if (foundFirstBrace && braceCount === 0) {
+                    return i;
+                }
+            }
+        }
+        // Для Python - по отступам
+        if (language === 'python') {
+            const startIndent = this.getIndent(lines[startLine]);
+            for (let i = startLine + 1; i < lines.length; i++) {
+                const line = lines[i];
+                if (line.trim() === '')
+                    continue;
+                const indent = this.getIndent(line);
+                if (indent <= startIndent && line.trim() !== '') {
+                    return i - 1;
+                }
+            }
+        }
+        // Fallback: ищем следующее определение того же уровня или конец файла
+        return Math.min(startLine + 100, lines.length - 1);
+    }
+    /**
+     * Получить уровень отступа строки
+     */
+    getIndent(line) {
+        const match = line.match(/^(\s*)/);
+        return match ? match[1].length : 0;
+    }
+    /**
+     * Создать чанки из найденных границ
+     */
+    createChunks(lines, boundaries, contextInfo, filePath, opts) {
+        const chunks = [];
+        const fileName = filePath.split(/[/\\]/).pop() || 'file';
+        // Если нет логических границ - разбиваем по размеру
+        if (boundaries.length === 0) {
+            return this.chunkBySize(lines, filePath, contextInfo, opts);
+        }
+        // Добавляем header chunk если есть контекст
+        if (contextInfo.context && contextInfo.context.length > opts.minChunkSize) {
+            chunks.push({
+                id: `${filePath}:chunk:header`,
+                filePath,
+                chunkIndex: 0,
+                totalChunks: 0, // Будет обновлено позже
+                startLine: 0,
+                endLine: contextInfo.endLine,
+                type: 'header',
+                name: `${fileName} imports`,
+                content: contextInfo.context,
+                context: ''
+            });
+        }
+        // Создаём чанки для каждой логической границы
+        for (const boundary of boundaries) {
+            const chunkLines = lines.slice(boundary.startLine, boundary.endLine + 1);
+            let content = chunkLines.join('\n');
+            // Если чанк слишком большой - разбиваем дальше
+            if (content.length > opts.maxChunkSize) {
+                const subChunks = this.splitLargeBlock(chunkLines, boundary, filePath, contextInfo, opts);
+                chunks.push(...subChunks);
+            }
+            else {
+                // Добавляем контекст если нужно
+                const contextPrefix = opts.includeContext && contextInfo.context
+                    ? `// Context from ${fileName}:\n${contextInfo.context}\n\n// ${boundary.type}: ${boundary.name}\n`
+                    : '';
+                chunks.push({
+                    id: `${filePath}:chunk:${boundary.type}:${boundary.name}:${boundary.startLine}`,
+                    filePath,
+                    chunkIndex: chunks.length,
+                    totalChunks: 0,
+                    startLine: boundary.startLine,
+                    endLine: boundary.endLine,
+                    type: boundary.type,
+                    name: boundary.name,
+                    content,
+                    context: contextPrefix
+                });
+            }
+        }
+        // Обновляем totalChunks
+        const total = chunks.length;
+        chunks.forEach((chunk, i) => {
+            chunk.totalChunks = total;
+            chunk.chunkIndex = i;
+        });
+        return chunks;
+    }
+    /**
+     * Разбить большой блок на подчанки
+     */
+    splitLargeBlock(lines, boundary, filePath, contextInfo, opts) {
+        const chunks = [];
+        let currentChunk = [];
+        let currentSize = 0;
+        let chunkStartLine = boundary.startLine;
+        let partNum = 1;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineSize = line.length + 1; // +1 for newline
+            if (currentSize + lineSize > opts.maxChunkSize && currentChunk.length > 0) {
+                // Сохраняем текущий чанк
+                const contextPrefix = opts.includeContext && contextInfo.context
+                    ? `// Context: ${boundary.type} ${boundary.name} (part ${partNum})\n`
+                    : '';
+                chunks.push({
+                    id: `${filePath}:chunk:${boundary.type}:${boundary.name}:${chunkStartLine}:part${partNum}`,
+                    filePath,
+                    chunkIndex: chunks.length,
+                    totalChunks: 0,
+                    startLine: chunkStartLine,
+                    endLine: boundary.startLine + i - 1,
+                    type: boundary.type,
+                    name: `${boundary.name} (part ${partNum})`,
+                    content: currentChunk.join('\n'),
+                    context: contextPrefix
+                });
+                currentChunk = [];
+                currentSize = 0;
+                chunkStartLine = boundary.startLine + i;
+                partNum++;
+            }
+            currentChunk.push(line);
+            currentSize += lineSize;
+        }
+        // Последний чанк
+        if (currentChunk.length > 0) {
+            chunks.push({
+                id: `${filePath}:chunk:${boundary.type}:${boundary.name}:${chunkStartLine}:part${partNum}`,
+                filePath,
+                chunkIndex: chunks.length,
+                totalChunks: 0,
+                startLine: chunkStartLine,
+                endLine: boundary.endLine,
+                type: boundary.type,
+                name: `${boundary.name} (part ${partNum})`,
+                content: currentChunk.join('\n'),
+                context: opts.includeContext ? `// Context: ${boundary.type} ${boundary.name} (part ${partNum})\n` : ''
+            });
+        }
+        return chunks;
+    }
+    /**
+     * Разбить файл по размеру (fallback)
+     */
+    chunkBySize(lines, filePath, contextInfo, opts) {
+        const chunks = [];
+        const fileName = filePath.split(/[/\\]/).pop() || 'file';
+        let currentChunk = [];
+        let currentSize = 0;
+        let chunkStartLine = 0;
+        let partNum = 1;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineSize = line.length + 1;
+            if (currentSize + lineSize > opts.maxChunkSize && currentChunk.length > 0) {
+                chunks.push({
+                    id: `${filePath}:chunk:${chunkStartLine}:part${partNum}`,
+                    filePath,
+                    chunkIndex: chunks.length,
+                    totalChunks: 0,
+                    startLine: chunkStartLine,
+                    endLine: i - 1,
+                    type: 'code',
+                    name: `${fileName} (part ${partNum})`,
+                    content: currentChunk.join('\n'),
+                    context: opts.includeContext && partNum === 1 ? contextInfo.context : ''
+                });
+                currentChunk = [];
+                currentSize = 0;
+                chunkStartLine = i;
+                partNum++;
+            }
+            currentChunk.push(line);
+            currentSize += lineSize;
+        }
+        if (currentChunk.length > 0) {
+            chunks.push({
+                id: `${filePath}:chunk:${chunkStartLine}:part${partNum}`,
+                filePath,
+                chunkIndex: chunks.length,
+                totalChunks: 0,
+                startLine: chunkStartLine,
+                endLine: lines.length - 1,
+                type: 'code',
+                name: `${fileName} (part ${partNum})`,
+                content: currentChunk.join('\n'),
+                context: ''
+            });
+        }
+        // Обновляем totalChunks
+        const total = chunks.length;
+        chunks.forEach((chunk, i) => {
+            chunk.totalChunks = total;
+            chunk.chunkIndex = i;
+        });
+        return chunks;
+    }
+}
+//# sourceMappingURL=file-chunker.js.map

package/dist/code-index/index.d.ts

@@ -60,5 +60,7 @@ export declare class CodeIndex {
     private getSymbolsByKind;
 }
 export { ASTParser, SymbolExtractor, DependencyGraphBuilder, SourceMapExtractor };
+export { FileChunker } from './file-chunker.js';
 export type { VirtualFile, ExtractionResult } from './source-map-extractor.js';
+export type { FileChunk, ChunkingOptions } from './file-chunker.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/code-index/index.js

@@ -165,4 +165,5 @@ export class CodeIndex {
     }
 }
 export { ASTParser, SymbolExtractor, DependencyGraphBuilder, SourceMapExtractor };
+export { FileChunker } from './file-chunker.js';
 //# sourceMappingURL=index.js.map

package/dist/code-index/symbol-extractor.js

@@ -59,7 +59,31 @@ export class SymbolExtractor {
             'impl_item': SymbolKind.Class,
             'struct_item': SymbolKind.Class,
             'enum_item': SymbolKind.Type,
-            'trait_item': SymbolKind.Interface
+            'trait_item': SymbolKind.Interface,
+            // PHP and general
+            'namespace_definition': SymbolKind.Namespace,
+            'namespace_use_declaration': SymbolKind.Variable,
+            'trait_declaration': SymbolKind.Interface,
+            'property_declaration': SymbolKind.Variable,
+            'enum_declaration': SymbolKind.Type,
+            'enum_declaration_list': SymbolKind.Type,
+            'module_declaration': SymbolKind.Namespace, // For regex-parsed namespaces
+            'struct_declaration': SymbolKind.Class, // For regex-parsed structs
+            'impl_declaration': SymbolKind.Class, // For regex-parsed impl blocks
+            // Java
+            'constructor_declaration': SymbolKind.Function,
+            'field_declaration': SymbolKind.Variable,
+            'annotation_type_declaration': SymbolKind.Interface,
+            // C/C++
+            'struct_specifier': SymbolKind.Class,
+            'union_specifier': SymbolKind.Class,
+            'enum_specifier': SymbolKind.Type,
+            'preproc_function_def': SymbolKind.Function,
+            // Ruby
+            'method': SymbolKind.Function,
+            'singleton_method': SymbolKind.Function,
+            'module': SymbolKind.Namespace,
+            'class': SymbolKind.Class
         };
         return mapping[nodeType] || null;
     }

package/dist/orchestrator/index.js

@@ -403,8 +403,19 @@ A: "✅ Компонент Comments найден в 3 файлах:
             prompt += '\n';
             for (const result of context.semanticMemory.slice(0, maxResults)) {
                 const cleanPath = sanitizePath(result.chunk.metadata.filePath);
-                prompt += `\nФайл: ${cleanPath}\n`;
-                prompt += `${result.context}\n`;
+                const lineInfo = result.chunk.metadata.startLine > 0
+                    ? `:${result.chunk.metadata.startLine}-${result.chunk.metadata.endLine}`
+                    : '';
+                prompt += `\n### Файл: ${cleanPath}${lineInfo}\n`;
+                prompt += `Символы: ${result.chunk.metadata.symbols.join(', ') || 'N/A'}\n`;
+                prompt += `Тип: ${result.chunk.metadata.type}\n`;
+                // Используем полный контент из chunk.content, не обрезанный context
+                const codeContent = result.chunk.content || result.context;
+                // Ограничиваем до 3000 символов на файл чтобы не переполнить контекст
+                const truncatedCode = codeContent.length > 3000
+                    ? codeContent.substring(0, 3000) + '\n... (truncated)'
+                    : codeContent;
+                prompt += `\`\`\`\n${truncatedCode}\n\`\`\`\n`;
             }
             prompt += '\n###END PROJECT FILES###';
         }

package/dist/semantic-memory/index.d.ts

@@ -16,6 +16,14 @@ export declare class SemanticMemory {
     constructor(embeddingConfig: EmbeddingConfig, vectorStoreConfig: VectorStoreConfig);
     initialize(): Promise<void>;
     indexSymbols(symbols: Map<string, Symbol>, asts: Map<string, ASTNode>, progressCallback?: (current: number, total: number) => void): Promise<void>;
+    /**
+     * Индексировать файлы с умным chunking
+     * Для больших файлов создаёт несколько чанков по логическим границам
+     */
+    indexFileChunks(fileContents: Map<string, string>, progressCallback?: (current: number, total: number) => void): Promise<{
+        indexed: number;
+        chunks: number;
+    }>;
     indexModules(asts: Map<string, ASTNode>): Promise<void>;
     searchByQuery(query: string, limit?: number): Promise<SemanticSearchResult[]>;
     searchSimilarCode(code: string, metadata?: {

package/dist/semantic-memory/index.js

@@ -10,6 +10,8 @@
 import { EmbeddingService } from './embedding-service.js';
 import { VectorStore } from './vector-store.js';
 import { Logger } from '../utils/logger.js';
+import { FileChunker } from '../code-index/file-chunker.js';
+import { FileUtils } from '../utils/file-utils.js';
 export class SemanticMemory {
     embeddingService;
     vectorStore;
@@ -85,6 +87,77 @@ export class SemanticMemory {
         }
         Logger.success(`Indexed ${symbolData.length} symbols (batch mode)`);
     }
+    /**
+     * Индексировать файлы с умным chunking
+     * Для больших файлов создаёт несколько чанков по логическим границам
+     */
+    async indexFileChunks(fileContents, progressCallback) {
+        Logger.progress('Indexing file chunks into semantic memory...');
+        const chunker = new FileChunker();
+        const allChunks = [];
+        const files = Array.from(fileContents.entries());
+        // Шаг 1: Разбиваем все файлы на чанки
+        for (const [filePath, content] of files) {
+            const language = FileUtils.getLanguageFromExtension(filePath);
+            const chunks = chunker.chunkFile(content, filePath, {
+                language,
+                maxChunkSize: 4000,
+                minChunkSize: 200,
+                includeContext: true
+            });
+            allChunks.push(...chunks);
+        }
+        if (allChunks.length === 0) {
+            Logger.warn('No chunks to index');
+            return { indexed: 0, chunks: 0 };
+        }
+        Logger.progress(`Prepared ${allChunks.length} chunks from ${files.length} files`);
+        // Шаг 2: Генерируем embeddings батчами
+        const textsToEmbed = [];
+        for (const chunk of allChunks) {
+            // Добавляем контекст для лучшего понимания
+            const textWithContext = chunk.context
+                ? `${chunk.context}\n${chunk.content}`
+                : chunk.content;
+            textsToEmbed.push(this.embeddingService.prepareCodeForEmbedding(textWithContext, `File: ${chunk.filePath}\nType: ${chunk.type}\nName: ${chunk.name}`));
+        }
+        Logger.progress(`Generating embeddings for ${textsToEmbed.length} chunks...`);
+        const embeddings = await this.embeddingService.generateBatchEmbeddings(textsToEmbed, progressCallback);
+        // Шаг 3: Создаём SemanticChunks и сохраняем в vector store
+        Logger.progress('Storing chunks in vector DB...');
+        const semanticChunks = [];
+        for (let i = 0; i < allChunks.length; i++) {
+            const chunk = allChunks[i];
+            const embedding = embeddings[i];
+            const metadata = {
+                filePath: chunk.filePath,
+                startLine: chunk.startLine,
+                endLine: chunk.endLine,
+                type: chunk.type === 'class' ? 'class' :
+                    chunk.type === 'function' ? 'function' :
+                        'module',
+                symbols: [chunk.name],
+                tags: [chunk.type, chunk.name, this.extractDomain(chunk.filePath)]
+            };
+            semanticChunks.push({
+                id: chunk.id,
+                content: chunk.content,
+                embedding,
+                metadata
+            });
+            // Batch upsert
+            if (semanticChunks.length >= 500) {
+                await this.vectorStore.upsertChunks(semanticChunks);
+                semanticChunks.length = 0;
+            }
+        }
+        // Оставшиеся чанки
+        if (semanticChunks.length > 0) {
+            await this.vectorStore.upsertChunks(semanticChunks);
+        }
+        Logger.success(`Indexed ${allChunks.length} chunks from ${files.length} files`);
+        return { indexed: files.length, chunks: allChunks.length };
+    }
     async indexModules(asts) {
         Logger.progress('Indexing modules into semantic memory...');
         const chunks = [];

package/dist/semantic-memory/vector-store.js

@@ -168,7 +168,7 @@ export class VectorStore {
             return null;
         }
     }
-    extractContext(content, contextLength = 200) {
+    extractContext(content, contextLength = 2000) {
         if (content.length <= contextLength) {
             return content;
         }

package/dist/server/services/project-service.js

@@ -428,6 +428,8 @@ export class ProjectService {
         // Анализируем стек технологий проекта
         const { analyzeProjectStack } = await import('../../utils/project-analyzer.js');
         const projectMetadata = analyzeProjectStack(project.path);
+        // Загружаем содержимое файлов для полного контекста
+        const fileContents = await this.getFileContents(projectId);
         // Ищем релевантный контекст (если есть семантическая память)
         let searchResults = [];
         if (data.semanticMemory) {
@@ -435,20 +437,34 @@ export class ProjectService {
                 // Увеличиваем лимит результатов поиска с 5 до 30
                 searchResults = await data.semanticMemory.searchByQuery(question, 30);
                 Logger.debug(`Semantic search returned ${searchResults.length} results`);
+                // Обогащаем результаты полным содержимым файлов
+                for (const result of searchResults) {
+                    const fullContent = fileContents.get(result.chunk.metadata.filePath);
+                    if (fullContent && fullContent.length > result.chunk.content.length) {
+                        // Заменяем короткий фрагмент на полное содержимое (до 5000 символов)
+                        result.chunk.content = fullContent.length > 5000
+                            ? fullContent.substring(0, 5000) + '\n... (file truncated)'
+                            : fullContent;
+                    }
+                }
             }
             catch (err) {
                 Logger.warn('Semantic search failed, using fallback');
             }
         }
-        // Fallback: если семантический поиск не работает, даём контекст из графа
+        // Fallback: если семантический поиск не работает, даём контекст из графа + содержимое файлов
         if (searchResults.length === 0 && data.graph) {
             Logger.info('Using graph fallback for context');
-            const files = Array.from(data.graph.nodes.values()).slice(0, 30); // Увеличено с 10 до 30
+            const files = Array.from(data.graph.nodes.values()).slice(0, 30);
             for (const file of files) {
+                const fullContent = fileContents.get(file.filePath) || `File: ${file.filePath}\nType: ${file.type}`;
+                const truncatedContent = fullContent.length > 5000
+                    ? fullContent.substring(0, 5000) + '\n... (file truncated)'
+                    : fullContent;
                 searchResults.push({
                     chunk: {
                         id: file.id,
-                        content: `File: ${file.filePath}\nType: ${file.type}`,
+                        content: truncatedContent,
                         embedding: [],
                         metadata: {
                             filePath: file.filePath,
@@ -460,13 +476,13 @@ export class ProjectService {
                         }
                     },
                     score: 1,
-                    context: `File: ${file.filePath}`
+                    context: truncatedContent
                 });
             }
         }
         // Добавляем информацию о символах если есть
         if (data.symbols && data.symbols.size > 0) {
-            const symbolsList = Array.from(data.symbols.values()).slice(0, 50); // Увеличено с 20 до 50
+            const symbolsList = Array.from(data.symbols.values()).slice(0, 50);
             for (const sym of symbolsList) {
                 const existing = searchResults.find(r => r.chunk.metadata.filePath === sym.filePath);
                 if (existing) {
@@ -580,7 +596,15 @@ export class ProjectService {
             // Индексация в семантическую память (если доступна)
             if (data.semanticMemory) {
                 await data.semanticMemory.initialize();
+                // Индексируем символы (функции, классы)
                 await data.semanticMemory.indexSymbols(symbols, asts);
+                // Также индексируем файлы с умным chunking для больших файлов
+                if (indexedData.fileContents && indexedData.fileContents.length > 0) {
+                    const fileContentsMap = new Map(indexedData.fileContents);
+                    Logger.progress(`Indexing ${fileContentsMap.size} files with smart chunking...`);
+                    const chunkResult = await data.semanticMemory.indexFileChunks(fileContentsMap);
+                    Logger.success(`Indexed ${chunkResult.chunks} chunks from ${chunkResult.indexed} files`);
+                }
             }
             // Сохраняем индексные данные на диск
             const projectDataDir = path.join(this.dataDir, projectId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archicore",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "AI Software Architect - code analysis, impact prediction, semantic search",
   "main": "dist/index.js",
   "type": "module",