archicore 0.3.9 → 0.4.1

package/dist/cli/commands/interactive.js

@@ -710,7 +710,9 @@ async function handleIndexCommand() {
             // Детальная обработка ошибок
             indexSpinner.fail('Indexing failed');
             // Debug output to see what's in the result
-            console.log(colors.dim(`  [DEBUG] uploadResult: ${JSON.stringify(uploadResult, null, 2)}`));
+            if (process.env.DEBUG) {
+                console.log(colors.dim(`  [DEBUG] uploadResult: ${JSON.stringify(uploadResult, null, 2)}`));
+            }
             if (uploadResult.errorDetails) {
                 const { code, message, suggestion, technicalDetails } = uploadResult.errorDetails;
                 console.log();

package/dist/cli/utils/upload-utils.js

@@ -7,6 +7,13 @@
  * - Детальная обработка ошибок
  */
 import { loadConfig } from './config.js';
+// Debug logging (only when DEBUG env var is set)
+const DEBUG = process.env.DEBUG === 'true' || process.env.DEBUG === '1';
+function debugLog(message) {
+    if (DEBUG) {
+        debugLog(` ${message}`);
+    }
+}
 // Лимиты для chunked upload (оптимизировано для очень больших проектов и нестабильных соединений)
 const MAX_PAYLOAD_SIZE = 3 * 1024 * 1024; // 3MB per chunk (уменьшено для надёжности на медленных соединениях)
 const MAX_SYMBOLS_PER_CHUNK = 1500; // Меньше символов на chunk для стабильности
@@ -190,7 +197,7 @@ async function fetchWithRetry(url, options, timeout = UPLOAD_TIMEOUT, maxRetries
             if (attempt < maxRetries) {
                 // 2s, 4s, 8s, 16s, 32s, до 60s max
                 const delay = Math.min(2000 * Math.pow(2, attempt - 1), 60000);
-                console.log(`[DEBUG] fetchWithRetry: waiting ${delay / 1000}s before attempt ${attempt + 1}...`);
+                debugLog(` fetchWithRetry: waiting ${delay / 1000}s before attempt ${attempt + 1}...`);
                 await new Promise(resolve => setTimeout(resolve, delay));
             }
         }
@@ -215,11 +222,11 @@ export async function uploadIndexData(projectId, data, onProgress) {
     });
     // Для небольших проектов - обычная загрузка
     if (!isLargeProject) {
-        console.log(`[DEBUG] Using single request upload for ${data.symbols.length} symbols`);
+        debugLog(` Using single request upload for ${data.symbols.length} symbols`);
         return uploadSingleRequest(url, projectId, data, config.accessToken || '', onProgress);
     }
     // Для больших проектов - chunked upload
-    console.log(`[DEBUG] Using chunked upload for large project (${data.symbols.length} symbols)`);
+    debugLog(` Using chunked upload for large project (${data.symbols.length} symbols)`);
     return uploadChunked(url, projectId, data, config.accessToken || '', onProgress);
 }
 /**
@@ -243,11 +250,11 @@ async function uploadSingleRequest(url, projectId, data, accessToken, onProgress
         });
         if (!response.ok) {
             const errorBody = await response.json().catch(() => ({}));
-            console.log(`[DEBUG] HTTP error ${response.status}: ${JSON.stringify(errorBody)}`);
+            debugLog(` HTTP error ${response.status}: ${JSON.stringify(errorBody)}`);
             const errorDetails = analyzeHttpError(response.status, errorBody);
             // Если payload слишком большой - пробуем chunked
             if (response.status === 413) {
-                console.log(`[DEBUG] Payload too large, trying chunked upload`);
+                debugLog(` Payload too large, trying chunked upload`);
                 return uploadChunked(url, projectId, data, accessToken, onProgress);
             }
             return {
@@ -269,13 +276,13 @@ async function uploadSingleRequest(url, projectId, data, accessToken, onProgress
         };
     }
     catch (error) {
-        console.log(`[DEBUG] uploadSingleRequest caught error: ${error}`);
+        debugLog(` uploadSingleRequest caught error: ${error}`);
         const errorDetails = analyzeNetworkError(error);
-        console.log(`[DEBUG] Analyzed error: ${JSON.stringify(errorDetails)}`);
+        debugLog(` Analyzed error: ${JSON.stringify(errorDetails)}`);
         // Если ошибка связана с размером - пробуем chunked
         if (errorDetails.code === 'CONNECTION_RESET' ||
             errorDetails.code === 'PAYLOAD_TOO_LARGE') {
-            console.log(`[DEBUG] Trying chunked upload due to ${errorDetails.code}`);
+            debugLog(` Trying chunked upload due to ${errorDetails.code}`);
             return uploadChunked(url, projectId, data, accessToken, onProgress);
         }
         return {
@@ -293,7 +300,7 @@ async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress)
     // Для очень больших проектов пропускаем fileContents (экономим трафик и время)
     const isVeryLargeProject = data.symbols.length > VERY_LARGE_PROJECT_SYMBOLS;
     if (isVeryLargeProject) {
-        console.log(`[DEBUG] Very large project (${data.symbols.length} symbols), skipping fileContents upload`);
+        debugLog(` Very large project (${data.symbols.length} symbols), skipping fileContents upload`);
     }
     // Разбиваем данные на chunks
     const symbolChunks = chunkArray(data.symbols, MAX_SYMBOLS_PER_CHUNK);
@@ -301,7 +308,7 @@ async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress)
     const fileChunks = isVeryLargeProject ? [] : chunkArray(data.fileContents, MAX_FILES_PER_CHUNK);
     const totalChunks = symbolChunks.length + astChunks.length + fileChunks.length + 1; // +1 for graph
     let completedChunks = 0;
-    console.log(`[DEBUG] Chunked upload: ${symbolChunks.length} symbol chunks, ${astChunks.length} AST chunks, ${fileChunks.length} file chunks`);
+    debugLog(` Chunked upload: ${symbolChunks.length} symbol chunks, ${astChunks.length} AST chunks, ${fileChunks.length} file chunks`);
     onProgress?.({
         phase: 'uploading',
         current: 0,
@@ -328,13 +335,13 @@ async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress)
         }
         catch (initError) {
             // Сервер не поддерживает chunked upload или недоступен
-            console.log(`[DEBUG] Chunked upload not supported, falling back to minimal data`);
+            debugLog(` Chunked upload not supported, falling back to minimal data`);
             return uploadMinimalData(baseUrl, projectId, data, accessToken, onProgress);
         }
         if (!initResponse.ok) {
             // Fallback: если сервер не поддерживает chunked upload,
             // отправляем только минимальные данные
-            console.log(`[DEBUG] Init returned ${initResponse.status}, falling back to minimal data`);
+            debugLog(` Init returned ${initResponse.status}, falling back to minimal data`);
             return uploadMinimalData(baseUrl, projectId, data, accessToken, onProgress);
         }
         const initResult = await initResponse.json();
@@ -343,13 +350,13 @@ async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress)
         const PARALLEL_UPLOADS = 3;
         // Helper для параллельной загрузки с retry для отдельных chunks
         async function uploadChunksParallel(chunks, chunkType, label) {
-            console.log(`[DEBUG] Starting parallel upload of ${chunks.length} ${chunkType} chunks`);
+            debugLog(` Starting parallel upload of ${chunks.length} ${chunkType} chunks`);
             const failedChunks = [];
             const MAX_CHUNK_RETRIES = 5; // Увеличено для нестабильных соединений (Debian и т.д.)
             for (let batch = 0; batch < chunks.length; batch += PARALLEL_UPLOADS) {
                 const batchChunks = chunks.slice(batch, batch + PARALLEL_UPLOADS);
                 const batchNum = Math.floor(batch / PARALLEL_UPLOADS) + 1;
-                console.log(`[DEBUG] Uploading batch ${batchNum} (${batchChunks.length} chunks)`);
+                debugLog(` Uploading batch ${batchNum} (${batchChunks.length} chunks)`);
                 // Upload each chunk with individual retry logic
                 const results = await Promise.allSettled(batchChunks.map(async (chunk, idx) => {
                     const chunkIndex = batch + idx;
@@ -357,17 +364,17 @@ async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress)
                     for (let retry = 0; retry < MAX_CHUNK_RETRIES; retry++) {
                         try {
                             await uploadChunk(config.serverUrl, projectId, uploadId, chunkType, chunkIndex, chunk, accessToken);
-                            console.log(`[DEBUG] Chunk ${chunkType}[${chunkIndex}] uploaded`);
+                            debugLog(` Chunk ${chunkType}[${chunkIndex}] uploaded`);
                             return { success: true, chunkIndex };
                         }
                         catch (error) {
                             lastError = error instanceof Error ? error : new Error(String(error));
-                            console.log(`[DEBUG] Chunk ${chunkType}[${chunkIndex}] failed (attempt ${retry + 1}/${MAX_CHUNK_RETRIES}): ${lastError.message}`);
+                            debugLog(` Chunk ${chunkType}[${chunkIndex}] failed (attempt ${retry + 1}/${MAX_CHUNK_RETRIES}): ${lastError.message}`);
                             // Exponential backoff before retry (увеличено для нестабильных соединений)
                             if (retry < MAX_CHUNK_RETRIES - 1) {
                                 // Более агрессивный backoff: 2s, 4s, 8s, 16s, до 30s max
                                 const delay = Math.min(2000 * Math.pow(2, retry), 30000);
-                                console.log(`[DEBUG] Waiting ${delay / 1000}s before retry ${retry + 2}...`);
+                                debugLog(` Waiting ${delay / 1000}s before retry ${retry + 2}...`);
                                 await new Promise(resolve => setTimeout(resolve, delay));
                             }
                         }
@@ -385,7 +392,7 @@ async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress)
                     else {
                         const chunkIndex = batch + i;
                         failedChunks.push(chunkIndex);
-                        console.log(`[DEBUG] Chunk ${chunkType}[${chunkIndex}] failed permanently: ${result.reason}`);
+                        debugLog(` Chunk ${chunkType}[${chunkIndex}] failed permanently: ${result.reason}`);
                     }
                 }
                 completedChunks += batchSuccesses;
@@ -400,10 +407,10 @@ async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress)
                     throw new Error(`Too many chunks failed (${failedChunks.length}/${chunks.length}). Network may be unstable. Try again or check your connection.`);
                 }
             }
-            console.log(`[DEBUG] Finished uploading ${chunks.length} ${chunkType} chunks (${failedChunks.length} failed)`);
+            debugLog(` Finished uploading ${chunks.length} ${chunkType} chunks (${failedChunks.length} failed)`);
             // If any chunks failed, warn but continue if under threshold
             if (failedChunks.length > 0) {
-                console.log(`[DEBUG] Warning: ${failedChunks.length} ${chunkType} chunks failed to upload`);
+                debugLog(` Warning: ${failedChunks.length} ${chunkType} chunks failed to upload`);
             }
         }
         // 2. Загружаем ASTs параллельно
@@ -475,7 +482,7 @@ async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress)
 async function uploadMinimalData(url, _projectId, data, accessToken, onProgress) {
     const symbolCount = data.symbols.length;
     const fileCount = data.asts.length;
-    console.log(`[DEBUG] uploadMinimalData: ${symbolCount} symbols, ${fileCount} files`);
+    debugLog(` uploadMinimalData: ${symbolCount} symbols, ${fileCount} files`);
     onProgress?.({
         phase: 'uploading',
         current: 50,
@@ -491,9 +498,9 @@ async function uploadMinimalData(url, _projectId, data, accessToken, onProgress)
         statistics: data.statistics,
         // Без fileContents - это самая большая часть
     };
-    console.log(`[DEBUG] Minimal payload: ${minimalData.asts.length} ASTs, ${minimalData.symbols.length} symbols`);
+    debugLog(` Minimal payload: ${minimalData.asts.length} ASTs, ${minimalData.symbols.length} symbols`);
     try {
-        console.log(`[DEBUG] Sending minimal data to ${url}`);
+        debugLog(` Sending minimal data to ${url}`);
         const response = await fetchWithRetry(url, {
             method: 'POST',
             headers: {
@@ -502,10 +509,10 @@ async function uploadMinimalData(url, _projectId, data, accessToken, onProgress)
             },
             body: JSON.stringify(minimalData),
         }, 180000, 2); // 3 минуты, 2 попытки
-        console.log(`[DEBUG] Response status: ${response.status}`);
+        debugLog(` Response status: ${response.status}`);
         if (!response.ok) {
             const errorBody = await response.json().catch(() => ({}));
-            console.log(`[DEBUG] Error body: ${JSON.stringify(errorBody)}`);
+            debugLog(` Error body: ${JSON.stringify(errorBody)}`);
             const errorDetails = analyzeHttpError(response.status, errorBody);
             return {
                 success: false,
@@ -529,7 +536,7 @@ async function uploadMinimalData(url, _projectId, data, accessToken, onProgress)
         };
     }
     catch (error) {
-        console.log(`[DEBUG] uploadMinimalData error: ${error}`);
+        debugLog(` uploadMinimalData error: ${error}`);
         const errorDetails = analyzeNetworkError(error);
         return {
             success: false,

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/dist/utils/file-utils.js

@@ -80,7 +80,10 @@ export class FileUtils {
         const resolvedPath = resolve(rootDir);
         // Normalize for glob (use forward slashes on all platforms)
         const absoluteRootDir = resolvedPath.replace(/\\/g, '/');
-        Logger.info(`getAllFiles: rootDir=${rootDir}, resolvedPath=${resolvedPath}, absoluteRootDir=${absoluteRootDir}`);
+        // Logger.debug for verbose output (only in DEBUG mode)
+        if (process.env.DEBUG) {
+            Logger.info(`getAllFiles: rootDir=${rootDir}, resolvedPath=${resolvedPath}`);
+        }
         // Check if directory exists and is accessible
         try {
             const dirStats = await stat(resolvedPath);
@@ -88,7 +91,7 @@ export class FileUtils {
                 Logger.error(`getAllFiles: ${resolvedPath} is not a directory`);
                 return [];
             }
-            Logger.info(`getAllFiles: Directory exists and is accessible`);
+            // Directory exists - no need to log in production
         }
         catch (err) {
             Logger.error(`getAllFiles: Cannot access directory ${resolvedPath}: ${err}`);
@@ -107,6 +110,9 @@ export class FileUtils {
                     'bower_components/**',
                     '**/bower_components/**',
                     'jspm_packages/**',
+                    // PHP Composer dependencies
+                    'vendor/**',
+                    '**/vendor/**',
                     // Build/Generated output
                     'dist/**',
                     '**/dist/**',
@@ -168,7 +174,10 @@ export class FileUtils {
             });
             files.push(...matches);
         }
-        Logger.info(`getAllFiles: glob found ${files.length} raw matches`);
+        // Verbose logging only in DEBUG mode
+        if (process.env.DEBUG) {
+            Logger.info(`getAllFiles: found ${files.length} files`);
+        }
         // If no files found, list directory contents for debugging
         if (files.length === 0) {
             try {
@@ -207,12 +216,9 @@ export class FileUtils {
                 // Skip files we can't stat
             }
         }
-        Logger.info(`getAllFiles: returning ${filteredFiles.length} files after filtering`);
-        if (filteredFiles.length > 0 && filteredFiles.length <= 20) {
-            Logger.info(`Files found: ${filteredFiles.join(', ')}`);
-        }
-        else if (filteredFiles.length > 20) {
-            Logger.info(`First 20 files: ${filteredFiles.slice(0, 20).join(', ')}`);
+        // Only log file list in DEBUG mode
+        if (process.env.DEBUG && filteredFiles.length > 0) {
+            Logger.info(`getAllFiles: returning ${filteredFiles.length} files`);
         }
         return filteredFiles;
     }

package/dist/utils/logger.js

@@ -7,7 +7,8 @@ export var LogLevel;
     LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
 })(LogLevel || (LogLevel = {}));
 export class Logger {
-    static level = LogLevel.INFO;
+    // Default to WARN in production, INFO/DEBUG only when DEBUG env var is set
+    static level = process.env.DEBUG ? LogLevel.DEBUG : LogLevel.WARN;
     static setLevel(level) {
         this.level = level;
     }

package/package.json

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