archicore 0.1.8 → 0.2.0

package/dist/semantic-memory/index.js

@@ -24,19 +24,66 @@ export class SemanticMemory {
         await this.vectorStore.initialize(dimension);
         Logger.success(`Semantic Memory initialized (dimension: ${dimension})`);
     }
-    async indexSymbols(symbols, asts) {
+    async indexSymbols(symbols, asts, progressCallback) {
         Logger.progress('Indexing symbols into semantic memory...');
-        const chunks = [];
-        for (const symbol of symbols.values()) {
+        const symbolArray = Array.from(symbols.values());
+        const totalSymbols = symbolArray.length;
+        if (totalSymbols === 0) {
+            Logger.warn('No symbols to index');
+            return;
+        }
+        // Step 1: Prepare all texts and metadata for batch embedding
+        Logger.progress('Preparing texts for embedding...');
+        const textsToEmbed = [];
+        const symbolData = [];
+        for (const symbol of symbolArray) {
             const ast = asts.get(symbol.filePath);
             if (!ast)
                 continue;
             const code = this.extractSymbolCode(symbol, ast);
-            const chunk = await this.createChunkFromSymbol(symbol, code);
-            chunks.push(chunk);
+            if (!code)
+                continue;
+            // Prepare text with context (same format as generateCodeEmbedding)
+            let context = `File: ${symbol.filePath}\n`;
+            context += `Symbol: ${symbol.kind} ${symbol.name}\n`;
+            const text = this.embeddingService.prepareCodeForEmbedding(code, context);
+            textsToEmbed.push(text);
+            symbolData.push({ symbol, code });
         }
-        await this.vectorStore.upsertChunks(chunks);
-        Logger.success(`Indexed ${chunks.length} symbols`);
+        Logger.progress(`Generating embeddings for ${textsToEmbed.length} symbols (batch mode)...`);
+        // Step 2: Generate all embeddings in batch (MUCH faster!)
+        const embeddings = await this.embeddingService.generateBatchEmbeddings(textsToEmbed, progressCallback);
+        // Step 3: Create chunks with embeddings
+        Logger.progress('Creating chunks and storing in vector DB...');
+        const chunks = [];
+        for (let i = 0; i < symbolData.length; i++) {
+            const { symbol, code } = symbolData[i];
+            const embedding = embeddings[i];
+            const metadata = {
+                filePath: symbol.filePath,
+                startLine: symbol.location.startLine,
+                endLine: symbol.location.endLine,
+                type: this.mapSymbolKindToChunkType(symbol.kind),
+                symbols: [symbol.name],
+                tags: [symbol.kind, this.extractDomain(symbol.filePath)]
+            };
+            chunks.push({
+                id: symbol.id,
+                content: code,
+                embedding,
+                metadata
+            });
+            // Batch upsert every 500 chunks to avoid memory issues
+            if (chunks.length >= 500) {
+                await this.vectorStore.upsertChunks(chunks);
+                chunks.length = 0;
+            }
+        }
+        // Upsert remaining chunks
+        if (chunks.length > 0) {
+            await this.vectorStore.upsertChunks(chunks);
+        }
+        Logger.success(`Indexed ${symbolData.length} symbols (batch mode)`);
     }
     async indexModules(asts) {
         Logger.progress('Indexing modules into semantic memory...');

package/dist/server/config.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Server Configuration
+ * Centralized configuration for security, CORS, rate limiting
+ */
+export interface ServerSecurityConfig {
+    cors: {
+        allowedOrigins: string[];
+        allowedMethods: string[];
+        allowedHeaders: string[];
+        credentials: boolean;
+    };
+    rateLimit: {
+        windowMs: number;
+        max: number;
+        message: string;
+        standardHeaders: boolean;
+        legacyHeaders: boolean;
+    };
+    compression: {
+        level: number;
+        threshold: number;
+    };
+}
+export declare const securityConfig: ServerSecurityConfig;
+export declare const apiRateLimits: {
+    analysis: {
+        windowMs: number;
+        max: number;
+    };
+    auth: {
+        windowMs: number;
+        max: number;
+    };
+    search: {
+        windowMs: number;
+        max: number;
+    };
+    webhook: {
+        windowMs: number;
+        max: number;
+    };
+};
+export declare const isDevelopment: boolean;
+export declare const isProduction: boolean;
+export declare const cookieConfig: {
+    name: string;
+    maxAge: number;
+    secure: boolean;
+    httpOnly: boolean;
+    sameSite: "lax";
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/server/config.js

@@ -0,0 +1,88 @@
+/**
+ * Server Configuration
+ * Centralized configuration for security, CORS, rate limiting
+ */
+// Get allowed origins from environment or defaults
+function getAllowedOrigins() {
+    const envOrigins = process.env.CORS_ORIGINS;
+    if (envOrigins) {
+        return envOrigins.split(',').map(o => o.trim());
+    }
+    // Default origins for development and production
+    const defaults = [
+        'http://localhost:3000',
+        'http://localhost:5173',
+        'http://127.0.0.1:3000',
+        'http://127.0.0.1:5173',
+    ];
+    // Add production domains if configured
+    if (process.env.PRODUCTION_DOMAIN) {
+        defaults.push(`https://${process.env.PRODUCTION_DOMAIN}`);
+        defaults.push(`https://www.${process.env.PRODUCTION_DOMAIN}`);
+    }
+    // ArchiCore production domains
+    defaults.push('https://archicore.io');
+    defaults.push('https://www.archicore.io');
+    defaults.push('https://app.archicore.io');
+    return defaults;
+}
+export const securityConfig = {
+    cors: {
+        allowedOrigins: getAllowedOrigins(),
+        allowedMethods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+        allowedHeaders: [
+            'Content-Type',
+            'Authorization',
+            'X-API-Key',
+            'X-Request-ID',
+            'X-Requested-With',
+        ],
+        credentials: true,
+    },
+    rateLimit: {
+        windowMs: 15 * 60 * 1000, // 15 minutes
+        max: parseInt(process.env.RATE_LIMIT_MAX || '100', 10), // 100 requests per window
+        message: 'Too many requests, please try again later.',
+        standardHeaders: true, // Return rate limit info in headers
+        legacyHeaders: false,
+    },
+    compression: {
+        level: 6, // Default compression level (1-9)
+        threshold: 1024, // Only compress responses > 1KB
+    },
+};
+// API-specific rate limits
+export const apiRateLimits = {
+    // Stricter limits for expensive operations
+    analysis: {
+        windowMs: 60 * 60 * 1000, // 1 hour
+        max: 50, // 50 analysis requests per hour
+    },
+    // Auth endpoints (prevent brute force)
+    auth: {
+        windowMs: 15 * 60 * 1000, // 15 minutes
+        max: 10, // 10 auth attempts per window
+    },
+    // Search/query endpoints
+    search: {
+        windowMs: 60 * 1000, // 1 minute
+        max: 30, // 30 searches per minute
+    },
+    // Webhook endpoints (GitHub, etc)
+    webhook: {
+        windowMs: 60 * 1000, // 1 minute
+        max: 100, // 100 webhooks per minute
+    },
+};
+// Environment detection
+export const isDevelopment = process.env.NODE_ENV !== 'production';
+export const isProduction = process.env.NODE_ENV === 'production';
+// Cookie consent config
+export const cookieConfig = {
+    name: 'archicore_consent',
+    maxAge: 365 * 24 * 60 * 60 * 1000, // 1 year
+    secure: isProduction,
+    httpOnly: false, // Needs to be accessible by JS
+    sameSite: 'lax',
+};
+//# sourceMappingURL=config.js.map

package/dist/server/index.d.ts

@@ -12,6 +12,9 @@ import express from 'express';
 export interface ServerConfig {
     port: number;
     host?: string;
+    corsOrigins?: string[];
+    rateLimitWindowMs?: number;
+    rateLimitMax?: number;
 }
 export declare class ArchiCoreServer {
     private app;

package/dist/server/index.js

@@ -10,6 +10,10 @@
 import 'dotenv/config';
 import express from 'express';
 import cors from 'cors';
+import compression from 'compression';
+import helmet from 'helmet';
+import morgan from 'morgan';
+import rateLimit from 'express-rate-limit';
 import { createServer } from 'http';
 import path from 'path';
 import { fileURLToPath } from 'url';
@@ -23,6 +27,32 @@ import { githubRouter } from './routes/github.js';
 import deviceAuthRouter from './routes/device-auth.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+// CORS whitelist - настройте под свои домены
+const DEFAULT_CORS_ORIGINS = [
+    'http://localhost:3000',
+    'http://localhost:5173',
+    'http://127.0.0.1:3000',
+    'http://127.0.0.1:5173',
+    // Production domains (добавьте свои)
+    // 'https://archicore.io',
+    // 'https://app.archicore.io',
+];
+// Rate limiting конфигурация
+const createRateLimiter = (windowMs, max, message) => rateLimit({
+    windowMs,
+    max,
+    message: { error: message, retryAfter: Math.ceil(windowMs / 1000) },
+    standardHeaders: true, // Return rate limit info in headers
+    legacyHeaders: false, // Disable X-RateLimit-* headers
+    handler: (_req, res) => {
+        res.status(429).json({
+            error: message,
+            retryAfter: Math.ceil(windowMs / 1000),
+            limit: max,
+            windowMs,
+        });
+    },
+});
 export class ArchiCoreServer {
     app;
     server = null;
@@ -35,23 +65,98 @@ export class ArchiCoreServer {
         this.setupErrorHandling();
     }
     setupMiddleware() {
-        // CORS для фронтенда
+        // Security headers (helmet) - disabled in development for easier testing
+        // Set HELMET_ENABLED=true in production
+        const helmetEnabled = process.env.HELMET_ENABLED === 'true';
+        if (helmetEnabled) {
+            this.app.use(helmet({
+                contentSecurityPolicy: {
+                    directives: {
+                        defaultSrc: ["'self'"],
+                        styleSrc: ["'self'", "'unsafe-inline'"],
+                        scriptSrc: ["'self'", "'unsafe-inline'"],
+                        imgSrc: ["'self'", "data:", "https:"],
+                        connectSrc: ["'self'", "https://api.jina.ai", "https://api.openai.com", "https://api.anthropic.com"],
+                    },
+                },
+                crossOriginResourcePolicy: { policy: 'cross-origin' },
+                crossOriginOpenerPolicy: { policy: 'same-origin-allow-popups' },
+                crossOriginEmbedderPolicy: false,
+            }));
+        }
+        // Gzip compression
+        this.app.use(compression({
+            level: 6, // Баланс между скоростью и сжатием
+            threshold: 1024, // Сжимать только > 1KB
+            filter: (req, res) => {
+                if (req.headers['x-no-compression'])
+                    return false;
+                return compression.filter(req, res);
+            },
+        }));
+        // HTTP request logging
+        const morganFormat = process.env.NODE_ENV === 'production'
+            ? 'combined'
+            : 'dev';
+        this.app.use(morgan(morganFormat, {
+            stream: {
+                write: (message) => Logger.info(message.trim()),
+            },
+            skip: (req) => req.path === '/health', // Skip health checks
+        }));
+        // Global rate limiting (100 requests per minute)
+        const globalLimiter = createRateLimiter(this.config.rateLimitWindowMs || 60 * 1000, this.config.rateLimitMax || 100, 'Too many requests, please try again later');
+        this.app.use(globalLimiter);
+        // CORS configuration
+        // Set CORS_RESTRICT=true in .env to enable whitelist mode
+        const restrictCors = process.env.CORS_RESTRICT === 'true';
+        const allowedOrigins = this.config.corsOrigins || DEFAULT_CORS_ORIGINS;
         this.app.use(cors({
-            origin: '*',
-            methods: ['GET', 'POST', 'PUT', 'DELETE'],
-            allowedHeaders: ['Content-Type', 'Authorization']
+            origin: restrictCors
+                ? (origin, callback) => {
+                    // Allow requests with no origin (mobile apps, curl, etc.)
+                    if (!origin)
+                        return callback(null, true);
+                    // Check whitelist
+                    if (allowedOrigins.includes(origin) || process.env.NODE_ENV === 'development') {
+                        return callback(null, true);
+                    }
+                    // Check wildcard patterns (e.g., *.archicore.io)
+                    const isAllowed = allowedOrigins.some(allowed => {
+                        if (allowed.startsWith('*.')) {
+                            const domain = allowed.slice(2);
+                            return origin.endsWith(domain);
+                        }
+                        return false;
+                    });
+                    if (isAllowed)
+                        return callback(null, true);
+                    Logger.warn(`CORS blocked origin: ${origin}`);
+                    callback(new Error('Not allowed by CORS'));
+                }
+                : true, // Allow all origins when CORS_RESTRICT is not set
+            methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+            allowedHeaders: ['Content-Type', 'Authorization', 'X-API-Key', 'X-Request-ID'],
+            credentials: true,
+            maxAge: 86400, // Cache preflight for 24 hours
         }));
         // JSON парсинг
         this.app.use(express.json({ limit: '50mb' }));
         this.app.use(express.urlencoded({ extended: true }));
-        // Статические файлы (фронтенд)
-        const publicPath = path.join(__dirname, '../../public');
-        this.app.use(express.static(publicPath));
-        // Логирование запросов
-        this.app.use((req, _res, next) => {
-            Logger.debug(`${req.method} ${req.path}`);
+        // Request ID для трейсинга
+        this.app.use((req, res, next) => {
+            const requestId = req.headers['x-request-id'] ||
+                `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            req.headers['x-request-id'] = requestId;
+            res.setHeader('X-Request-ID', requestId);
             next();
         });
+        // Статические файлы (фронтенд)
+        const publicPath = path.join(__dirname, '../../public');
+        this.app.use(express.static(publicPath, {
+            maxAge: process.env.NODE_ENV === 'production' ? '1d' : 0,
+            etag: true,
+        }));
     }
     setupRoutes() {
         // Auth routes

package/dist/server/routes/admin.js

@@ -6,7 +6,7 @@ import { AuthService } from '../services/auth-service.js';
 import { authMiddleware, adminMiddleware } from './auth.js';
 import { Logger } from '../../utils/logger.js';
 export const adminRouter = Router();
-const authService = new AuthService();
+const authService = AuthService.getInstance();
 // All admin routes require authentication and admin role
 adminRouter.use(authMiddleware);
 adminRouter.use(adminMiddleware);
@@ -52,9 +52,9 @@ adminRouter.put('/users/:id/tier', async (req, res) => {
     try {
         const { id } = req.params;
         const { tier } = req.body;
-        const validTiers = ['free', 'mid', 'pro', 'admin'];
+        const validTiers = ['free', 'mid', 'pro', 'enterprise', 'admin'];
         if (!tier || !validTiers.includes(tier)) {
-            res.status(400).json({ error: 'Invalid tier' });
+            res.status(400).json({ error: 'Invalid tier. Valid tiers: ' + validTiers.join(', ') });
             return;
         }
         const updated = await authService.updateUserTier(id, tier);

package/dist/server/routes/api.js

@@ -4,13 +4,16 @@
  * REST API для Architecture Digital Twin
  */
 import { Router } from 'express';
-import { ProjectService } from '../services/project-service.js';
+import { ProjectService, subscribeToProgress } from '../services/project-service.js';
+import { AuthService } from '../services/auth-service.js';
 import { Logger } from '../../utils/logger.js';
 import { ExportManager } from '../../export/index.js';
 import { authMiddleware } from './auth.js';
+import { FileUtils } from '../../utils/file-utils.js';
 export const apiRouter = Router();
 // Singleton сервиса проектов
 const projectService = new ProjectService();
+const authService = AuthService.getInstance();
 // Helper to get user ID from request
 const getUserId = (req) => {
     return req.user?.id;
@@ -46,8 +49,21 @@ apiRouter.post('/projects', authMiddleware, async (req, res) => {
             res.status(401).json({ error: 'Authentication required' });
             return;
         }
+        // Check project creation limit
+        const usageResult = await authService.checkAndUpdateUsage(userId, 'project');
+        if (!usageResult.allowed) {
+            res.status(429).json({
+                error: 'Project limit reached',
+                message: `You have reached your daily project limit (${usageResult.limit})`,
+                usage: { used: usageResult.limit, limit: usageResult.limit, remaining: 0 }
+            });
+            return;
+        }
         const project = await projectService.createProject(name, projectPath, userId);
-        res.json({ project });
+        res.json({
+            project,
+            usage: { used: usageResult.limit - usageResult.remaining, limit: usageResult.limit, remaining: usageResult.remaining }
+        });
     }
     catch (error) {
         Logger.error('Failed to create project:', error);
@@ -215,10 +231,23 @@ apiRouter.post('/projects/:id/simulate', authMiddleware, checkProjectAccess, asy
     try {
         const { id } = req.params;
         const { change } = req.body;
+        const userId = getUserId(req);
         if (!change) {
             res.status(400).json({ error: 'Change description is required' });
             return;
         }
+        // Check request limit
+        if (userId) {
+            const usageResult = await authService.checkAndUpdateUsage(userId, 'request');
+            if (!usageResult.allowed) {
+                res.status(429).json({
+                    error: 'Request limit reached',
+                    message: `You have reached your daily request limit (${usageResult.limit})`,
+                    usage: { used: usageResult.limit, limit: usageResult.limit, remaining: 0 }
+                });
+                return;
+            }
+        }
         const simulation = await projectService.simulateChange(id, change);
         res.json(simulation);
     }
@@ -235,10 +264,23 @@ apiRouter.post('/projects/:id/search', authMiddleware, checkProjectAccess, async
     try {
         const { id } = req.params;
         const { query, limit = 10 } = req.body;
+        const userId = getUserId(req);
         if (!query) {
             res.status(400).json({ error: 'Query is required' });
             return;
         }
+        // Check request limit
+        if (userId) {
+            const usageResult = await authService.checkAndUpdateUsage(userId, 'request');
+            if (!usageResult.allowed) {
+                res.status(429).json({
+                    error: 'Request limit reached',
+                    message: `You have reached your daily request limit (${usageResult.limit})`,
+                    usage: { used: usageResult.limit, limit: usageResult.limit, remaining: 0 }
+                });
+                return;
+            }
+        }
         const results = await projectService.semanticSearch(id, query, limit);
         res.json({ results });
     }
@@ -255,10 +297,23 @@ apiRouter.post('/projects/:id/ask', authMiddleware, checkProjectAccess, async (r
     try {
         const { id } = req.params;
         const { question, language } = req.body;
+        const userId = getUserId(req);
         if (!question) {
             res.status(400).json({ error: 'Question is required' });
             return;
         }
+        // Check request limit
+        if (userId) {
+            const usageResult = await authService.checkAndUpdateUsage(userId, 'request');
+            if (!usageResult.allowed) {
+                res.status(429).json({
+                    error: 'Request limit reached',
+                    message: `You have reached your daily request limit (${usageResult.limit})`,
+                    usage: { used: usageResult.limit, limit: usageResult.limit, remaining: 0 }
+                });
+                return;
+            }
+        }
         const answer = await projectService.askArchitect(id, question, language || 'en');
         res.json({ answer });
     }
@@ -426,6 +481,19 @@ apiRouter.post('/projects/:id/export', authMiddleware, checkProjectAccess, async
 apiRouter.post('/projects/:id/full-analysis', authMiddleware, checkProjectAccess, async (req, res) => {
     try {
         const { id } = req.params;
+        const userId = getUserId(req);
+        // Check full analysis limit
+        if (userId) {
+            const usageResult = await authService.checkAndUpdateUsage(userId, 'analysis');
+            if (!usageResult.allowed) {
+                res.status(429).json({
+                    error: 'Analysis limit reached',
+                    message: `You have reached your daily full analysis limit (${usageResult.limit})`,
+                    usage: { used: usageResult.limit, limit: usageResult.limit, remaining: 0 }
+                });
+                return;
+            }
+        }
         const result = await projectService.runFullAnalysis(id);
         res.json(result);
     }
@@ -442,6 +510,19 @@ apiRouter.post('/projects/:id/documentation', authMiddleware, checkProjectAccess
     try {
         const { id } = req.params;
         const { format = 'markdown', language = 'en' } = req.body;
+        const userId = getUserId(req);
+        // Check request limit (documentation uses AI)
+        if (userId) {
+            const usageResult = await authService.checkAndUpdateUsage(userId, 'request');
+            if (!usageResult.allowed) {
+                res.status(429).json({
+                    error: 'Request limit reached',
+                    message: `You have reached your daily request limit (${usageResult.limit})`,
+                    usage: { used: usageResult.limit, limit: usageResult.limit, remaining: 0 }
+                });
+                return;
+            }
+        }
         const result = await projectService.generateDocumentation(id, { format, language });
         res.json(result);
     }
@@ -450,4 +531,120 @@ apiRouter.post('/projects/:id/documentation', authMiddleware, checkProjectAccess
         res.status(500).json({ error: 'Failed to generate documentation' });
     }
 });
+/**
+ * GET /api/projects/:id/index-progress
+ * Server-Sent Events endpoint for real-time indexing progress
+ * Note: Accepts token via query param since EventSource doesn't support headers
+ */
+apiRouter.get('/projects/:id/index-progress', async (req, res) => {
+    const { id } = 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;
+    }
+    // Verify token manually (use singleton instance)
+    const user = await authService.validateToken(token);
+    if (!user) {
+        res.status(401).json({ error: 'Invalid token' });
+        return;
+    }
+    // Check project access
+    const isOwner = await projectService.isProjectOwner(id, user.id);
+    if (!isOwner) {
+        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'); // Disable nginx buffering
+    res.flushHeaders();
+    // Send initial connection message
+    res.write(`data: ${JSON.stringify({ type: 'connected', projectId: id })}\n\n`);
+    // Subscribe to progress updates
+    const unsubscribe = subscribeToProgress(id, (progress) => {
+        try {
+            res.write(`data: ${JSON.stringify({ type: 'progress', ...progress })}\n\n`);
+            // If complete or error, close connection
+            if (progress.step === 'complete' || progress.step === 'error') {
+                setTimeout(() => {
+                    res.write(`data: ${JSON.stringify({ type: 'done' })}\n\n`);
+                    res.end();
+                }, 500);
+            }
+        }
+        catch (err) {
+            // Client disconnected
+        }
+    });
+    // Handle client disconnect
+    req.on('close', () => {
+        unsubscribe();
+    });
+});
+/**
+ * GET /api/projects/:id/scan
+ * Scan project directory and get file statistics before indexing
+ */
+apiRouter.get('/projects/:id/scan', authMiddleware, checkProjectAccess, async (req, res) => {
+    try {
+        const { id } = req.params;
+        const project = await projectService.getProject(id);
+        if (!project) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        // Get project structure (files, sizes, etc.)
+        const structure = await FileUtils.getProjectStructure(project.path);
+        // Calculate statistics
+        let totalSize = 0;
+        const languageCounts = {};
+        for (const file of structure.files) {
+            totalSize += file.size;
+            languageCounts[file.language] = (languageCounts[file.language] || 0) + 1;
+        }
+        // Estimate symbol count (rough: ~20-50 symbols per file on average)
+        const estimatedSymbols = structure.files.length * 30;
+        // Estimate indexing time with batch embeddings
+        // - Parsing: ~0.05s per file
+        // - Batch embedding: ~2s per 500 symbols (Jina batch API)
+        // - Vector store: ~0.5s per 500 chunks
+        const parsingTime = structure.files.length * 0.05;
+        const embeddingBatches = Math.ceil(estimatedSymbols / 500);
+        const embeddingTime = embeddingBatches * 2;
+        const storageTime = embeddingBatches * 0.5;
+        const estimatedTimeSeconds = Math.ceil(parsingTime + embeddingTime + storageTime);
+        res.json({
+            projectId: id,
+            projectName: project.name,
+            totalFiles: structure.files.length,
+            totalSizeMB: Math.round(totalSize / (1024 * 1024) * 100) / 100,
+            totalSizeBytes: totalSize,
+            languageCounts,
+            estimatedSymbols,
+            estimatedTimeSeconds,
+            estimatedTimeFormatted: formatTime(estimatedTimeSeconds),
+            directories: structure.directories.size
+        });
+    }
+    catch (error) {
+        Logger.error('Failed to scan project:', error);
+        res.status(500).json({ error: 'Failed to scan project' });
+    }
+});
+// Helper function to format time
+function formatTime(seconds) {
+    if (seconds < 60) {
+        return `~${seconds} sec`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (remainingSeconds === 0) {
+        return `~${minutes} min`;
+    }
+    return `~${minutes} min ${remainingSeconds} sec`;
+}
 //# sourceMappingURL=api.js.map