archicore 0.2.8 → 0.3.0

package/dist/cli/commands/analyzers.js

@@ -13,7 +13,11 @@ async function getProjectId() {
 async function fetchAnalysis(endpoint, projectId) {
     const config = await loadConfig();
     const id = projectId || await getProjectId();
-    const response = await fetch(`${config.serverUrl}/api/projects/${id}/${endpoint}`);
+    const response = await fetch(`${config.serverUrl}/api/projects/${id}/${endpoint}`, {
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`
+        }
+    });
     if (!response.ok) {
         const error = await response.json();
         throw new Error(error.error || `Failed to run ${endpoint}`);
@@ -376,6 +380,9 @@ export function registerAnalyzerCommands(program) {
             }
             const response = await fetch(`${config.serverUrl}/api/projects/${projectId}/full-analysis`, {
                 method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${config.accessToken}`
+                }
             });
             if (!response.ok) {
                 const error = await response.json();

package/dist/cli/commands/projects.js

@@ -59,9 +59,17 @@ export function registerProjectsCommand(program) {
         const spinner = createSpinner('Creating project...').start();
         try {
             const config = await loadConfig();
+            if (!config.accessToken) {
+                spinner.fail('Not logged in');
+                console.log('  Please run: archicore login');
+                process.exit(1);
+            }
             const response = await fetch(`${config.serverUrl}/api/projects`, {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.accessToken}`
+                },
                 body: JSON.stringify({
                     name: options.name || path.split('/').pop() || path.split('\\').pop(),
                     path: path,
@@ -112,8 +120,16 @@ export function registerProjectsCommand(program) {
         const spinner = createSpinner('Deleting project...').start();
         try {
             const config = await loadConfig();
+            if (!config.accessToken) {
+                spinner.fail('Not logged in');
+                console.log('  Please run: archicore login');
+                process.exit(1);
+            }
             const response = await fetch(`${config.serverUrl}/api/projects/${id}`, {
                 method: 'DELETE',
+                headers: {
+                    'Authorization': `Bearer ${config.accessToken}`
+                }
             });
             if (!response.ok) {
                 const error = await response.json();
@@ -225,8 +241,16 @@ export function registerProjectsCommand(program) {
                 printError('Use "archicore projects select <id>" or specify project ID');
                 process.exit(1);
             }
+            if (!config.accessToken) {
+                spinner.fail('Not logged in');
+                console.log('  Please run: archicore login');
+                process.exit(1);
+            }
             const response = await fetch(`${config.serverUrl}/api/projects/${projectId}/index`, {
                 method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${config.accessToken}`
+                }
             });
             if (!response.ok) {
                 const error = await response.json();

package/dist/cli/utils/session.js

@@ -30,9 +30,13 @@ export function getSession() {
 }
 export async function selectProject(projectId) {
     const project = await fetchProject(projectId);
-    if (project && sessionState) {
-        sessionState.project = project;
+    if (project) {
+        // Always save to config, regardless of session state
         await setActiveProject(project.id, project.path);
+        // Update session state if initialized
+        if (sessionState) {
+            sessionState.project = project;
+        }
     }
     return project;
 }
@@ -43,20 +47,27 @@ export async function clearProject() {
 }
 async function fetchProject(projectId) {
     const config = await loadConfig();
+    if (!config.accessToken)
+        return null;
     try {
-        const response = await fetch(`${config.serverUrl}/api/projects/${projectId}`);
+        const response = await fetch(`${config.serverUrl}/api/projects/${projectId}`, {
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`
+            }
+        });
         if (!response.ok)
             return null;
         const data = await response.json();
+        const p = data.project || data; // Handle both { project: {...} } and direct object
         return {
-            id: data.id,
-            name: data.name,
-            path: data.path,
-            status: data.status || 'unknown',
-            files: data.statistics?.codeIndex?.totalFiles,
-            symbols: data.statistics?.codeIndex?.totalSymbols,
-            indexed: data.status === 'indexed',
-            lastIndexed: data.lastIndexed ? new Date(data.lastIndexed) : undefined,
+            id: p.id,
+            name: p.name,
+            path: p.path,
+            status: p.status || 'unknown',
+            files: p.statistics?.codeIndex?.totalFiles || p.stats?.filesCount,
+            symbols: p.statistics?.codeIndex?.totalSymbols || p.stats?.symbolsCount,
+            indexed: p.status === 'indexed' || p.status === 'ready',
+            lastIndexed: p.lastIndexed ? new Date(p.lastIndexed) : undefined,
         };
     }
     catch {
@@ -65,8 +76,14 @@ async function fetchProject(projectId) {
 }
 export async function fetchProjects() {
     const config = await loadConfig();
+    if (!config.accessToken)
+        return [];
     try {
-        const response = await fetch(`${config.serverUrl}/api/projects`);
+        const response = await fetch(`${config.serverUrl}/api/projects`, {
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`
+            }
+        });
         if (!response.ok)
             return [];
         const data = await response.json();

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

@@ -7,15 +7,17 @@
  * - Детальная обработка ошибок
  */
 import { loadConfig } from './config.js';
-// Лимиты для chunked upload
-const MAX_PAYLOAD_SIZE = 10 * 1024 * 1024; // 10MB per chunk
-const MAX_SYMBOLS_PER_CHUNK = 5000;
-const MAX_FILES_PER_CHUNK = 100;
-const UPLOAD_TIMEOUT = 120000; // 120 секунд на chunk (увеличено для больших проектов)
-const MAX_RETRIES = 3;
+// Лимиты для chunked upload (оптимизировано для очень больших проектов)
+const MAX_PAYLOAD_SIZE = 5 * 1024 * 1024; // 5MB per chunk (уменьшено для надёжности)
+const MAX_SYMBOLS_PER_CHUNK = 2000; // Меньше символов на chunk
+const MAX_FILES_PER_CHUNK = 50; // Меньше файлов на chunk
+const UPLOAD_TIMEOUT = 180000; // 3 минуты на chunk
+const MAX_RETRIES = 5; // Больше попыток
 // Лимиты для минимальной загрузки
 const MINIMAL_MAX_SYMBOLS = 10000;
 const MINIMAL_MAX_FILES = 500;
+// Порог для "очень большого" проекта (пропускаем fileContents)
+const VERY_LARGE_PROJECT_SYMBOLS = 30000;
 /**
  * Определение размера JSON в байтах
  */
@@ -178,10 +180,9 @@ async function fetchWithRetry(url, options, timeout = UPLOAD_TIMEOUT, maxRetries
         }
         catch (error) {
             lastError = error instanceof Error ? error : new Error(String(error));
-            // Не повторяем для определённых ошибок
+            // Не повторяем для определённых ошибок (кроме AbortError - таймаут можно повторить)
             const errorStr = String(error);
-            if (errorStr.includes('AbortError') ||
-                errorStr.includes('ENOTFOUND') ||
+            if (errorStr.includes('ENOTFOUND') ||
                 errorStr.includes('CERT')) {
                 throw error;
             }
@@ -287,12 +288,18 @@ async function uploadSingleRequest(url, projectId, data, accessToken, onProgress
  */
 async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress) {
     const config = await loadConfig();
+    // Для очень больших проектов пропускаем 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`);
+    }
     // Разбиваем данные на chunks
     const symbolChunks = chunkArray(data.symbols, MAX_SYMBOLS_PER_CHUNK);
     const astChunks = chunkArray(data.asts, MAX_FILES_PER_CHUNK);
-    const fileChunks = chunkArray(data.fileContents, MAX_FILES_PER_CHUNK);
+    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`);
     onProgress?.({
         phase: 'uploading',
         current: 0,
@@ -330,28 +337,32 @@ async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress)
         }
         const initResult = await initResponse.json();
         const uploadId = initResult.uploadId;
-        // 2. Загружаем ASTs по частям
-        for (let i = 0; i < astChunks.length; i++) {
-            await uploadChunk(config.serverUrl, projectId, uploadId, 'asts', i, astChunks[i], accessToken);
-            completedChunks++;
-            onProgress?.({
-                phase: 'uploading',
-                current: completedChunks,
-                total: totalChunks,
-                message: `Uploading ASTs (${i + 1}/${astChunks.length})...`,
-            });
-        }
-        // 3. Загружаем символы по частям
-        for (let i = 0; i < symbolChunks.length; i++) {
-            await uploadChunk(config.serverUrl, projectId, uploadId, 'symbols', i, symbolChunks[i], accessToken);
-            completedChunks++;
-            onProgress?.({
-                phase: 'uploading',
-                current: completedChunks,
-                total: totalChunks,
-                message: `Uploading symbols (${i + 1}/${symbolChunks.length})...`,
-            });
+        // Параллельная загрузка chunks (по 3 одновременно)
+        const PARALLEL_UPLOADS = 3;
+        // Helper для параллельной загрузки
+        async function uploadChunksParallel(chunks, chunkType, label) {
+            console.log(`[DEBUG] Starting parallel upload of ${chunks.length} ${chunkType} chunks`);
+            for (let batch = 0; batch < chunks.length; batch += PARALLEL_UPLOADS) {
+                const batchChunks = chunks.slice(batch, batch + PARALLEL_UPLOADS);
+                console.log(`[DEBUG] Uploading batch ${batch / PARALLEL_UPLOADS + 1} (${batchChunks.length} chunks)`);
+                const promises = batchChunks.map((chunk, idx) => uploadChunk(config.serverUrl, projectId, uploadId, chunkType, batch + idx, chunk, accessToken).then(() => {
+                    console.log(`[DEBUG] Chunk ${chunkType}[${batch + idx}] uploaded`);
+                }));
+                await Promise.all(promises);
+                completedChunks += batchChunks.length;
+                onProgress?.({
+                    phase: 'uploading',
+                    current: completedChunks,
+                    total: totalChunks,
+                    message: `${label} (${Math.min(batch + PARALLEL_UPLOADS, chunks.length)}/${chunks.length})...`,
+                });
+            }
+            console.log(`[DEBUG] Finished uploading ${chunks.length} ${chunkType} chunks`);
         }
+        // 2. Загружаем ASTs параллельно
+        await uploadChunksParallel(astChunks, 'asts', 'Uploading ASTs');
+        // 3. Загружаем символы параллельно
+        await uploadChunksParallel(symbolChunks, 'symbols', 'Uploading symbols');
         // 4. Загружаем граф
         await uploadChunk(config.serverUrl, projectId, uploadId, 'graph', 0, data.graph, accessToken);
         completedChunks++;
@@ -361,16 +372,9 @@ async function uploadChunked(baseUrl, projectId, data, accessToken, onProgress)
             total: totalChunks,
             message: 'Uploading dependency graph...',
         });
-        // 5. Загружаем содержимое файлов (опционально)
-        for (let i = 0; i < fileChunks.length; i++) {
-            await uploadChunk(config.serverUrl, projectId, uploadId, 'fileContents', i, fileChunks[i], accessToken);
-            completedChunks++;
-            onProgress?.({
-                phase: 'uploading',
-                current: completedChunks,
-                total: totalChunks,
-                message: `Uploading file contents (${i + 1}/${fileChunks.length})...`,
-            });
+        // 5. Загружаем содержимое файлов параллельно (опционально)
+        if (fileChunks.length > 0) {
+            await uploadChunksParallel(fileChunks, 'fileContents', 'Uploading files');
         }
         // 6. Финализируем upload
         onProgress?.({

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

@@ -176,7 +176,175 @@ export class ASTParser {
                 /^(\w+)\s*\(\)\s*\{/, // Function definitions
                 /^function\s+(\w+)/ // Function keyword
             ],
-            markdown: [] // Markdown doesn't have functions/classes
+            markdown: [], // Markdown doesn't have functions/classes
+            // Additional languages
+            kotlin: [
+                /^(?:public|private|internal|protected)?\s*(?:suspend\s+)?fun\s+(\w+)/,
+                /^(?:public|private|internal|protected)?\s*(?:data\s+|sealed\s+|open\s+)?class\s+(\w+)/,
+                /^(?:public|private|internal|protected)?\s*interface\s+(\w+)/,
+                /^(?:public|private|internal|protected)?\s*object\s+(\w+)/,
+                /^(?:public|private|internal|protected)?\s*enum\s+class\s+(\w+)/
+            ],
+            swift: [
+                /^(?:public|private|internal|fileprivate|open)?\s*func\s+(\w+)/,
+                /^(?:public|private|internal|fileprivate|open)?\s*class\s+(\w+)/,
+                /^(?:public|private|internal|fileprivate|open)?\s*struct\s+(\w+)/,
+                /^(?:public|private|internal|fileprivate|open)?\s*enum\s+(\w+)/,
+                /^(?:public|private|internal|fileprivate|open)?\s*protocol\s+(\w+)/,
+                /^extension\s+(\w+)/
+            ],
+            scala: [
+                /^(?:def|override\s+def)\s+(\w+)/,
+                /^(?:class|case\s+class|abstract\s+class)\s+(\w+)/,
+                /^(?:object|case\s+object)\s+(\w+)/,
+                /^trait\s+(\w+)/
+            ],
+            dart: [
+                /^(?:Future<[^>]+>|void|int|String|bool|dynamic|\w+)\s+(\w+)\s*\(/,
+                /^class\s+(\w+)/,
+                /^(?:abstract\s+)?class\s+(\w+)/,
+                /^mixin\s+(\w+)/,
+                /^extension\s+(\w+)/,
+                /^enum\s+(\w+)/
+            ],
+            lua: [
+                /^(?:local\s+)?function\s+(\w+)/,
+                /^(\w+)\s*=\s*function\s*\(/
+            ],
+            perl: [
+                /^sub\s+(\w+)/,
+                /^package\s+(\w+)/
+            ],
+            r: [
+                /^(\w+)\s*<-\s*function/,
+                /^(\w+)\s*=\s*function/
+            ],
+            julia: [
+                /^function\s+(\w+)/,
+                /^(?:mutable\s+)?struct\s+(\w+)/,
+                /^abstract\s+type\s+(\w+)/,
+                /^(\w+)\(.*\)\s*=/ // Short function syntax
+            ],
+            elixir: [
+                /^def\s+(\w+)/,
+                /^defp\s+(\w+)/,
+                /^defmodule\s+(\w+)/,
+                /^defmacro\s+(\w+)/
+            ],
+            clojure: [
+                /^\(defn\s+(\w+)/,
+                /^\(defn-\s+(\w+)/,
+                /^\(def\s+(\w+)/,
+                /^\(defmacro\s+(\w+)/
+            ],
+            haskell: [
+                /^(\w+)\s*::/, // Type signature
+                /^data\s+(\w+)/,
+                /^type\s+(\w+)/,
+                /^newtype\s+(\w+)/,
+                /^class\s+(\w+)/,
+                /^instance\s+(\w+)/
+            ],
+            erlang: [
+                /^(\w+)\s*\([^)]*\)\s*->/,
+                /^-module\((\w+)\)/,
+                /^-record\((\w+)/
+            ],
+            fsharp: [
+                /^let\s+(\w+)/,
+                /^type\s+(\w+)/,
+                /^module\s+(\w+)/,
+                /^member\s+(?:this|_)\.(\w+)/
+            ],
+            ocaml: [
+                /^let\s+(\w+)/,
+                /^type\s+(\w+)/,
+                /^module\s+(\w+)/,
+                /^class\s+(\w+)/
+            ],
+            zig: [
+                /^(?:pub\s+)?fn\s+(\w+)/,
+                /^(?:pub\s+)?const\s+(\w+)\s*=/,
+                /^(?:pub\s+)?var\s+(\w+)\s*=/
+            ],
+            nim: [
+                /^proc\s+(\w+)/,
+                /^func\s+(\w+)/,
+                /^method\s+(\w+)/,
+                /^template\s+(\w+)/,
+                /^macro\s+(\w+)/,
+                /^type\s+(\w+)/
+            ],
+            crystal: [
+                /^def\s+(\w+)/,
+                /^class\s+(\w+)/,
+                /^struct\s+(\w+)/,
+                /^module\s+(\w+)/,
+                /^macro\s+(\w+)/
+            ],
+            groovy: [
+                /^def\s+(\w+)/,
+                /^(?:public|private|protected)?\s*(?:static\s+)?(?:\w+\s+)?(\w+)\s*\(/,
+                /^class\s+(\w+)/,
+                /^interface\s+(\w+)/
+            ],
+            powershell: [
+                /^function\s+(\w+[\w-]*)/,
+                /^filter\s+(\w+[\w-]*)/,
+                /^class\s+(\w+)/
+            ],
+            dockerfile: [
+                /^FROM\s+(\S+)/i,
+                /^(?:RUN|CMD|ENTRYPOINT|COPY|ADD|ENV|ARG|EXPOSE|WORKDIR|LABEL)\s/i
+            ],
+            terraform: [
+                /^resource\s+"(\w+)"\s+"(\w+)"/,
+                /^data\s+"(\w+)"\s+"(\w+)"/,
+                /^module\s+"(\w+)"/,
+                /^variable\s+"(\w+)"/,
+                /^output\s+"(\w+)"/
+            ],
+            graphql: [
+                /^type\s+(\w+)/,
+                /^input\s+(\w+)/,
+                /^interface\s+(\w+)/,
+                /^enum\s+(\w+)/,
+                /^scalar\s+(\w+)/,
+                /^query\s+(\w+)/,
+                /^mutation\s+(\w+)/,
+                /^subscription\s+(\w+)/
+            ],
+            protobuf: [
+                /^message\s+(\w+)/,
+                /^service\s+(\w+)/,
+                /^enum\s+(\w+)/,
+                /^rpc\s+(\w+)/
+            ],
+            toml: [
+                /^\[(\w+)\]/, // Section
+                /^\[\[(\w+)\]\]/ // Array of tables
+            ],
+            ini: [
+                /^\[(\w+)\]/ // Section
+            ],
+            make: [
+                /^(\w[\w-]*)\s*:/, // Target
+                /^\.PHONY:\s*(\w+)/ // Phony target
+            ],
+            cmake: [
+                /^function\s*\(\s*(\w+)/i,
+                /^macro\s*\(\s*(\w+)/i,
+                /^(?:add_executable|add_library)\s*\(\s*(\w+)/i
+            ],
+            svelte: [
+                /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
+                /^(?:export\s+)?const\s+(\w+)\s*=/,
+                /^(?:export\s+)?let\s+(\w+)\s*=/
+            ],
+            astro: [
+                /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
+                /^(?:export\s+)?const\s+(\w+)\s*=/
+            ]
         };
         const langPatterns = patterns[language] || [];
         lines.forEach((line, index) => {

package/dist/server/index.js

@@ -228,9 +228,10 @@ export class ArchiCoreServer {
             credentials: true,
             maxAge: 86400, // Cache preflight for 24 hours
         }));
-        // JSON парсинг
-        this.app.use(express.json({ limit: '50mb' }));
-        this.app.use(express.urlencoded({ extended: true }));
+        // JSON парсинг - лимит должен покрывать максимальный тариф (admin = 1GB)
+        // Проверка по тарифу пользователя происходит в бизнес-логике после парсинга
+        this.app.use(express.json({ limit: '1gb' }));
+        this.app.use(express.urlencoded({ extended: true, limit: '1gb' }));
         // Request ID для трейсинга
         this.app.use((req, res, next) => {
             const requestId = req.headers['x-request-id'] ||