archicore 0.2.8 → 0.2.9

package/dist/server/routes/api.js

@@ -10,10 +10,61 @@ import { Logger } from '../../utils/logger.js';
 import { ExportManager } from '../../export/index.js';
 import { authMiddleware } from './auth.js';
 import { FileUtils } from '../../utils/file-utils.js';
+import { taskQueue } from '../services/task-queue.js';
 export const apiRouter = Router();
 // Singleton сервиса проектов
 const projectService = new ProjectService();
 const authService = AuthService.getInstance();
+// Регистрация исполнителей задач
+taskQueue.registerExecutor('full-analysis', async (task, updateProgress) => {
+    try {
+        updateProgress({ phase: 'analyzing', current: 10, message: 'Starting full analysis...' });
+        const result = await projectService.runFullAnalysis(task.projectId, (phase, progress) => {
+            updateProgress({
+                phase,
+                current: Math.min(10 + progress * 0.9, 99),
+                message: `Analyzing: ${phase}...`,
+            });
+        });
+        return { success: true, data: result };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+});
+taskQueue.registerExecutor('dead-code', async (task, updateProgress) => {
+    try {
+        updateProgress({ phase: 'analyzing', current: 20, message: 'Analyzing dead code...' });
+        const result = await projectService.findDeadCode(task.projectId);
+        return { success: true, data: result };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+});
+taskQueue.registerExecutor('security', async (task, updateProgress) => {
+    try {
+        updateProgress({ phase: 'analyzing', current: 20, message: 'Analyzing security...' });
+        const result = await projectService.analyzeSecurity(task.projectId);
+        return { success: true, data: result };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+});
+taskQueue.registerExecutor('metrics', async (task, updateProgress) => {
+    try {
+        updateProgress({ phase: 'analyzing', current: 20, message: 'Calculating metrics...' });
+        const result = await projectService.getMetrics(task.projectId);
+        return { success: true, data: result };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+});
 // Helper to get user ID from request
 const getUserId = (req) => {
     return req.user?.id;
@@ -631,11 +682,17 @@ apiRouter.post('/projects/:id/export', authMiddleware, checkProjectAccess, async
 /**
  * POST /api/projects/:id/full-analysis
  * Полный анализ проекта (все анализаторы)
+ * Запускает асинхронную задачу и возвращает task ID
+ *
+ * Query params:
+ * - async=true: вернуть task ID для отслеживания (по умолчанию)
+ * - async=false: синхронное выполнение (для обратной совместимости)
  */
 apiRouter.post('/projects/:id/full-analysis', authMiddleware, checkProjectAccess, async (req, res) => {
     try {
         const { id } = req.params;
         const userId = getUserId(req);
+        const asyncMode = req.query.async !== 'false'; // По умолчанию async=true
         // Check full analysis limit
         if (userId) {
             const usageResult = await authService.checkAndUpdateUsage(userId, 'analysis');
@@ -648,8 +705,20 @@ apiRouter.post('/projects/:id/full-analysis', authMiddleware, checkProjectAccess
                 return;
             }
         }
-        const result = await projectService.runFullAnalysis(id);
-        res.json(result);
+        if (asyncMode) {
+            // Асинхронный режим - создаём задачу и возвращаем ID
+            const task = taskQueue.createTask('full-analysis', id, userId || 'anonymous');
+            res.json({
+                taskId: task.id,
+                status: task.status,
+                message: 'Analysis task queued. Poll /api/tasks/:taskId for status.',
+            });
+        }
+        else {
+            // Синхронный режим - ждём завершения (для обратной совместимости)
+            const result = await projectService.runFullAnalysis(id);
+            res.json(result);
+        }
     }
     catch (error) {
         Logger.error('Failed to run full analysis:', error);
@@ -789,6 +858,183 @@ apiRouter.get('/projects/:id/scan', authMiddleware, checkProjectAccess, async (r
         res.status(500).json({ error: 'Failed to scan project' });
     }
 });
+// ==================== TASK QUEUE ENDPOINTS ====================
+/**
+ * GET /api/tasks/:taskId
+ * Получить статус и результат задачи
+ */
+apiRouter.get('/tasks/:taskId', authMiddleware, async (req, res) => {
+    try {
+        const { taskId } = req.params;
+        const userId = getUserId(req);
+        const task = taskQueue.getTask(taskId);
+        if (!task) {
+            res.status(404).json({ error: 'Task not found' });
+            return;
+        }
+        // Проверяем, что задача принадлежит пользователю (или админ)
+        if (task.userId !== userId && !(req.user?.tier === 'enterprise' || req.user?.id?.startsWith('admin-'))) {
+            res.status(403).json({ error: 'Access denied' });
+            return;
+        }
+        res.json({
+            id: task.id,
+            type: task.type,
+            projectId: task.projectId,
+            status: task.status,
+            progress: task.progress,
+            result: task.result,
+            error: task.error,
+            createdAt: task.createdAt,
+            startedAt: task.startedAt,
+            completedAt: task.completedAt,
+        });
+    }
+    catch (error) {
+        Logger.error('Failed to get task:', error);
+        res.status(500).json({ error: 'Failed to get task' });
+    }
+});
+/**
+ * GET /api/tasks
+ * Получить список задач пользователя
+ */
+apiRouter.get('/tasks', authMiddleware, async (req, res) => {
+    try {
+        const userId = getUserId(req);
+        const limit = parseInt(req.query.limit) || 10;
+        if (!userId) {
+            res.status(401).json({ error: 'Authentication required' });
+            return;
+        }
+        const tasks = taskQueue.getUserTasks(userId, limit);
+        res.json({ tasks });
+    }
+    catch (error) {
+        Logger.error('Failed to get tasks:', error);
+        res.status(500).json({ error: 'Failed to get tasks' });
+    }
+});
+/**
+ * GET /api/projects/:id/tasks
+ * Получить список задач проекта
+ */
+apiRouter.get('/projects/:id/tasks', authMiddleware, checkProjectAccess, async (req, res) => {
+    try {
+        const { id } = req.params;
+        const limit = parseInt(req.query.limit) || 10;
+        const tasks = taskQueue.getProjectTasks(id, limit);
+        res.json({ tasks });
+    }
+    catch (error) {
+        Logger.error('Failed to get project tasks:', error);
+        res.status(500).json({ error: 'Failed to get project tasks' });
+    }
+});
+/**
+ * GET /api/tasks/:taskId/progress
+ * SSE endpoint для real-time прогресса задачи
+ */
+apiRouter.get('/tasks/:taskId/progress', async (req, res) => {
+    const { taskId } = req.params;
+    // Handle auth via query param (EventSource doesn't support headers)
+    const token = req.query.token || req.headers.authorization?.substring(7);
+    if (!token) {
+        res.status(401).json({ error: 'Authentication required' });
+        return;
+    }
+    const user = await authService.validateToken(token);
+    if (!user) {
+        res.status(401).json({ error: 'Invalid token' });
+        return;
+    }
+    const task = taskQueue.getTask(taskId);
+    if (!task) {
+        res.status(404).json({ error: 'Task not found' });
+        return;
+    }
+    if (task.userId !== user.id && !(user.tier === 'enterprise' || user.id?.startsWith('admin-'))) {
+        res.status(403).json({ error: 'Access denied' });
+        return;
+    }
+    // Set SSE headers
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders();
+    // Send current status
+    res.write(`data: ${JSON.stringify({ type: 'status', task: { id: task.id, status: task.status, progress: task.progress } })}\n\n`);
+    // If already completed, close connection
+    if (task.status === 'completed' || task.status === 'failed') {
+        res.write(`data: ${JSON.stringify({ type: 'done', result: task.result, error: task.error })}\n\n`);
+        res.end();
+        return;
+    }
+    // Subscribe to task events
+    const onProgress = (updatedTask) => {
+        if (updatedTask.id === taskId) {
+            try {
+                res.write(`data: ${JSON.stringify({ type: 'progress', progress: updatedTask.progress })}\n\n`);
+            }
+            catch {
+                // Client disconnected
+            }
+        }
+    };
+    const onComplete = (updatedTask) => {
+        if (updatedTask.id === taskId) {
+            try {
+                res.write(`data: ${JSON.stringify({ type: 'done', result: updatedTask.result })}\n\n`);
+                res.end();
+            }
+            catch {
+                // Client disconnected
+            }
+            cleanup();
+        }
+    };
+    const onFailed = (updatedTask) => {
+        if (updatedTask.id === taskId) {
+            try {
+                res.write(`data: ${JSON.stringify({ type: 'error', error: updatedTask.error })}\n\n`);
+                res.end();
+            }
+            catch {
+                // Client disconnected
+            }
+            cleanup();
+        }
+    };
+    const cleanup = () => {
+        taskQueue.off('taskProgress', onProgress);
+        taskQueue.off('taskCompleted', onComplete);
+        taskQueue.off('taskFailed', onFailed);
+    };
+    taskQueue.on('taskProgress', onProgress);
+    taskQueue.on('taskCompleted', onComplete);
+    taskQueue.on('taskFailed', onFailed);
+    // Handle client disconnect
+    req.on('close', cleanup);
+});
+/**
+ * GET /api/queue/stats
+ * Статистика очереди задач (для админов)
+ */
+apiRouter.get('/queue/stats', authMiddleware, async (req, res) => {
+    try {
+        if (!(req.user?.tier === 'enterprise' || req.user?.id?.startsWith('admin-'))) {
+            res.status(403).json({ error: 'Admin access required' });
+            return;
+        }
+        const stats = taskQueue.getStats();
+        res.json(stats);
+    }
+    catch (error) {
+        Logger.error('Failed to get queue stats:', error);
+        res.status(500).json({ error: 'Failed to get queue stats' });
+    }
+});
 // Helper function to format time
 function formatTime(seconds) {
     if (seconds < 60) {

package/dist/server/routes/auth.js

@@ -161,8 +161,7 @@ authRouter.get('/me', authMiddleware, async (req, res) => {
             limits: {
                 requestsPerDay: limits.requestsPerDay,
                 fullAnalysisPerDay: limits.fullAnalysisPerDay,
-                projectsPerDay: limits.projectsPerDay,
-                maxProjectSizeMB: limits.maxProjectSizeMB
+                projectsPerDay: limits.projectsPerDay
             },
             usage: user.usage
         });
@@ -297,8 +296,7 @@ authRouter.get('/usage', authMiddleware, async (req, res) => {
             limits: {
                 requestsPerDay: limits.requestsPerDay,
                 fullAnalysisPerDay: limits.fullAnalysisPerDay,
-                projectsPerDay: limits.projectsPerDay,
-                maxProjectSizeMB: limits.maxProjectSizeMB
+                projectsPerDay: limits.projectsPerDay
             },
             subscription: user.subscription
         });

package/dist/server/routes/github.js

@@ -13,7 +13,6 @@ import { ProjectService } from '../services/project-service.js';
 import { AuthService } from '../services/auth-service.js';
 import { authMiddleware } from './auth.js';
 import { Logger } from '../../utils/logger.js';
-import { TIER_LIMITS } from '../../types/user.js';
 export const githubRouter = Router();
 // Services
 const githubService = new GitHubService();
@@ -275,22 +274,6 @@ githubRouter.post('/repositories/connect', authMiddleware, async (req, res) => {
                 Logger.progress(`Downloading repository: ${connectedRepo.fullName} (branch: ${targetBranch})`);
                 const zipBuffer = await githubService.downloadRepository(req.user.id, connectedRepo.fullName, targetBranch);
                 Logger.info(`Downloaded ZIP: ${zipBuffer.length} bytes`);
-                // Check project size limit
-                const user = await authService.getUser(req.user.id);
-                if (user) {
-                    const limits = TIER_LIMITS[user.tier];
-                    const projectSizeMB = zipBuffer.length / (1024 * 1024);
-                    if (projectSizeMB > limits.maxProjectSizeMB) {
-                        res.status(413).json({
-                            error: 'Project size limit exceeded',
-                            message: `Project size (${projectSizeMB.toFixed(1)}MB) exceeds your plan limit (${limits.maxProjectSizeMB}MB). Upgrade to a higher tier for larger projects.`,
-                            size: projectSizeMB,
-                            limit: limits.maxProjectSizeMB,
-                            tier: user.tier
-                        });
-                        return;
-                    }
-                }
                 // Create projects directory
                 const projectsDir = process.env.PROJECTS_DIR || join('.archicore', 'projects');
                 await mkdir(projectsDir, { recursive: true });

package/dist/server/services/project-service.d.ts

@@ -157,8 +157,10 @@ export declare class ProjectService {
     getExportData(projectId: string): Promise<ExportData>;
     /**
      * Полный анализ проекта
+     * @param projectId - ID проекта
+     * @param onProgress - опциональный callback для отслеживания прогресса (phase, progress 0-100)
      */
-    runFullAnalysis(projectId: string): Promise<{
+    runFullAnalysis(projectId: string, onProgress?: (phase: string, progress: number) => void): Promise<{
         metrics: ProjectMetrics;
         rules: RulesCheckResult;
         deadCode: DeadCodeResult;

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

@@ -788,21 +788,32 @@ export class ProjectService {
     }
     /**
      * Полный анализ проекта
+     * @param projectId - ID проекта
+     * @param onProgress - опциональный callback для отслеживания прогресса (phase, progress 0-100)
      */
-    async runFullAnalysis(projectId) {
+    async runFullAnalysis(projectId, onProgress) {
         Logger.progress('Running full analysis...');
+        onProgress?.('starting', 0);
+        // Запускаем все анализы параллельно с отслеживанием прогресса
+        const metricsPromise = this.getMetrics(projectId).then(r => { onProgress?.('metrics', 20); return r; });
+        const rulesPromise = this.checkRules(projectId).then(r => { onProgress?.('rules', 35); return r; });
+        const deadCodePromise = this.findDeadCode(projectId).then(r => { onProgress?.('dead-code', 50); return r; });
+        const duplicationPromise = this.findDuplication(projectId).then(r => { onProgress?.('duplication', 60); return r; });
+        const securityPromise = this.analyzeSecurity(projectId).then(r => { onProgress?.('security', 70); return r; });
         const [metrics, rules, deadCode, duplication, security] = await Promise.all([
-            this.getMetrics(projectId),
-            this.checkRules(projectId),
-            this.findDeadCode(projectId),
-            this.findDuplication(projectId),
-            this.analyzeSecurity(projectId)
+            metricsPromise,
+            rulesPromise,
+            deadCodePromise,
+            duplicationPromise,
+            securityPromise,
         ]);
         // Refactoring зависит от предыдущих результатов
+        onProgress?.('refactoring', 75);
         const data = await this.getProjectData(projectId);
         const fileContents = await this.getFileContents(projectId);
         const engine = new RefactoringEngine();
         const refactoring = await engine.analyze(data.graph, data.symbols, fileContents, metrics, duplication, deadCode, rules);
+        onProgress?.('complete', 100);
         Logger.success('Full analysis complete');
         return {
             metrics,

package/dist/server/services/task-queue.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Task Queue Service
+ *
+ * Асинхронная очередь задач для параллельного выполнения анализа
+ * Позволяет множеству пользователей запускать анализ одновременно
+ */
+import { EventEmitter } from 'events';
+export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed';
+export interface TaskProgress {
+    phase: string;
+    current: number;
+    total: number;
+    message: string;
+}
+export interface Task<T = unknown> {
+    id: string;
+    type: string;
+    projectId: string;
+    userId: string;
+    status: TaskStatus;
+    progress: TaskProgress;
+    result?: T;
+    error?: string;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+}
+export interface TaskResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+type TaskExecutor = (task: Task, updateProgress: (progress: Partial<TaskProgress>) => void) => Promise<TaskResult>;
+declare class TaskQueueService extends EventEmitter {
+    private tasks;
+    private executors;
+    private runningTasks;
+    private maxConcurrentTasks;
+    private taskTimeout;
+    constructor();
+    /**
+     * Регистрация исполнителя задач
+     */
+    registerExecutor(taskType: string, executor: TaskExecutor): void;
+    /**
+     * Создание новой задачи
+     */
+    createTask(type: string, projectId: string, userId: string): Task;
+    /**
+     * Получение задачи по ID
+     */
+    getTask(taskId: string): Task | undefined;
+    /**
+     * Получение задач пользователя
+     */
+    getUserTasks(userId: string, limit?: number): Task[];
+    /**
+     * Получение задач проекта
+     */
+    getProjectTasks(projectId: string, limit?: number): Task[];
+    /**
+     * Обработка очереди задач
+     */
+    private processQueue;
+    /**
+     * Выполнение задачи
+     */
+    private executeTask;
+    /**
+     * Обновление прогресса задачи
+     */
+    private updateTaskProgress;
+    /**
+     * Завершение задачи успешно
+     */
+    private completeTask;
+    /**
+     * Завершение задачи с ошибкой
+     */
+    private failTask;
+    /**
+     * Очистка старых задач (старше 1 часа)
+     */
+    private cleanupOldTasks;
+    /**
+     * Статистика очереди
+     */
+    getStats(): {
+        total: number;
+        pending: number;
+        running: number;
+        completed: number;
+        failed: number;
+    };
+}
+export declare const taskQueue: TaskQueueService;
+export {};
+//# sourceMappingURL=task-queue.d.ts.map