archicore 0.1.8 → 0.2.0

package/dist/server/routes/auth.js

@@ -5,7 +5,7 @@ import { Router } from 'express';
 import { AuthService } from '../services/auth-service.js';
 import { Logger } from '../../utils/logger.js';
 export const authRouter = Router();
-const authService = new AuthService();
+const authService = AuthService.getInstance();
 // Middleware to check authentication
 export async function authMiddleware(req, res, next) {
     const authHeader = req.headers.authorization;
@@ -91,7 +91,7 @@ authRouter.post('/logout', authMiddleware, async (req, res) => {
 });
 /**
  * GET /api/auth/me
- * Get current user info
+ * Get current user info with usage and limits
  */
 authRouter.get('/me', authMiddleware, async (req, res) => {
     try {
@@ -99,9 +99,27 @@ authRouter.get('/me', authMiddleware, async (req, res) => {
             res.status(401).json({ error: 'Not authenticated' });
             return;
         }
+        // Get fresh user data with usage
+        const freshUser = await authService.getUser(req.user.id);
+        if (!freshUser) {
+            res.status(404).json({ error: 'User not found' });
+            return;
+        }
         // Remove sensitive data
-        const { passwordHash, ...user } = req.user;
-        res.json({ user });
+        const { passwordHash, ...user } = freshUser;
+        // Get tier limits
+        const { TIER_LIMITS } = await import('../../types/user.js');
+        const limits = TIER_LIMITS[user.tier];
+        res.json({
+            user,
+            limits: {
+                requestsPerDay: limits.requestsPerDay,
+                fullAnalysisPerDay: limits.fullAnalysisPerDay,
+                projectsPerDay: limits.projectsPerDay,
+                maxProjectSizeMB: limits.maxProjectSizeMB
+            },
+            usage: user.usage
+        });
     }
     catch (error) {
         Logger.error('Get user error:', error);
@@ -138,6 +156,53 @@ authRouter.put('/me', authMiddleware, async (req, res) => {
         res.status(500).json({ error: 'Failed to update profile' });
     }
 });
+/**
+ * POST /api/auth/avatar
+ * Upload user avatar (base64 image)
+ */
+authRouter.post('/avatar', authMiddleware, async (req, res) => {
+    try {
+        const { avatar } = req.body;
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        // Validate avatar - must be a valid base64 image data URL
+        if (!avatar || typeof avatar !== 'string') {
+            res.status(400).json({ error: 'Avatar is required' });
+            return;
+        }
+        // Security: Only allow specific image formats
+        const validImagePattern = /^data:image\/(png|jpeg|jpg|gif|webp);base64,/;
+        if (!validImagePattern.test(avatar)) {
+            res.status(400).json({ error: 'Invalid image format. Only PNG, JPEG, GIF, and WebP are allowed.' });
+            return;
+        }
+        // Limit avatar size (max 500KB base64 = ~375KB actual image)
+        const maxBase64Size = 500 * 1024;
+        if (avatar.length > maxBase64Size) {
+            res.status(400).json({ error: 'Avatar image is too large. Maximum size is 500KB.' });
+            return;
+        }
+        // Additional security: Check for script injection in base64
+        const base64Data = avatar.split(',')[1];
+        if (!base64Data || /<script|javascript:|onerror|onload/i.test(base64Data)) {
+            res.status(400).json({ error: 'Invalid image data' });
+            return;
+        }
+        // Update user avatar
+        const updated = await authService.updateUser(req.user.id, { avatar });
+        if (!updated) {
+            res.status(400).json({ error: 'Failed to update avatar' });
+            return;
+        }
+        res.json({ success: true, avatar });
+    }
+    catch (error) {
+        Logger.error('Avatar upload error:', error);
+        res.status(500).json({ error: 'Failed to upload avatar' });
+    }
+});
 /**
  * POST /api/auth/oauth/:provider
  * OAuth login (GitHub, Google)
@@ -164,7 +229,7 @@ authRouter.post('/oauth/:provider', async (req, res) => {
 });
 /**
  * GET /api/auth/usage
- * Get current user's usage stats
+ * Get current user's usage stats with limits
  */
 authRouter.get('/usage', authMiddleware, async (req, res) => {
     try {
@@ -177,9 +242,18 @@ authRouter.get('/usage', authMiddleware, async (req, res) => {
             res.status(404).json({ error: 'User not found' });
             return;
         }
+        // Get tier limits
+        const { TIER_LIMITS } = await import('../../types/user.js');
+        const limits = TIER_LIMITS[user.tier];
         res.json({
             tier: user.tier,
             usage: user.usage,
+            limits: {
+                requestsPerDay: limits.requestsPerDay,
+                fullAnalysisPerDay: limits.fullAnalysisPerDay,
+                projectsPerDay: limits.projectsPerDay,
+                maxProjectSizeMB: limits.maxProjectSizeMB
+            },
             subscription: user.subscription
         });
     }

package/dist/server/routes/device-auth.js

@@ -7,7 +7,7 @@ import { Router } from 'express';
 import { randomBytes } from 'crypto';
 import { AuthService } from '../services/auth-service.js';
 const router = Router();
-const authService = new AuthService();
+const authService = AuthService.getInstance();
 const pendingAuths = new Map();
 // Generate random codes
 function generateDeviceCode() {

package/dist/server/routes/github.js

@@ -10,12 +10,15 @@ import { join } from 'path';
 import AdmZip from 'adm-zip';
 import { GitHubService } from '../../github/github-service.js';
 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();
 const projectService = new ProjectService();
+const authService = AuthService.getInstance();
 // Store OAuth states (in production, use Redis)
 const oauthStates = new Map();
 // ===== OAUTH FLOW =====
@@ -76,8 +79,12 @@ githubRouter.get('/callback', async (req, res) => {
         oauthStates.delete(state);
         // Exchange code for token
         const tokenResponse = await githubService.exchangeCodeForToken(code);
+        // Log granted scopes for debugging
+        Logger.info(`GitHub OAuth scopes granted: ${tokenResponse.scope}`);
+        Logger.info(`GitHub token type: ${tokenResponse.token_type}`);
         // Get GitHub user info
         const githubUser = await githubService.getGitHubUser(tokenResponse.access_token);
+        Logger.info(`GitHub user connected: ${githubUser.login}`);
         // Save connection
         await githubService.saveConnection(stateData.userId, tokenResponse, githubUser);
         // Redirect to app with success
@@ -268,6 +275,22 @@ 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 });
@@ -322,6 +345,16 @@ githubRouter.post('/repositories/connect', authMiddleware, async (req, res) => {
                     }
                 }
                 Logger.success(`Downloaded and extracted to: ${actualPath}`);
+                // Check project creation limit
+                const usageResult = await authService.checkAndUpdateUsage(req.user.id, '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(projectName || connectedRepo.name, actualPath, req.user.id);
                 projectId = project.id;
                 // Update connected repo with project ID and save to file

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

@@ -3,11 +3,16 @@
  */
 import { User, SubscriptionTier, AuthResponse } from '../../types/user.js';
 export declare class AuthService {
+    private static instance;
     private dataDir;
     private users;
     private sessions;
     private initialized;
     constructor(dataDir?: string);
+    /**
+     * Get singleton instance of AuthService
+     */
+    static getInstance(): AuthService;
     private ensureInitialized;
     private createDefaultAdmin;
     private saveUsers;

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

@@ -10,6 +10,7 @@ const DATA_DIR = '.archicore';
 const USERS_FILE = 'users.json';
 const SESSIONS_FILE = 'sessions.json';
 export class AuthService {
+    static instance = null;
     dataDir;
     users = [];
     sessions = [];
@@ -17,6 +18,15 @@ export class AuthService {
     constructor(dataDir = DATA_DIR) {
         this.dataDir = dataDir;
     }
+    /**
+     * Get singleton instance of AuthService
+     */
+    static getInstance() {
+        if (!AuthService.instance) {
+            AuthService.instance = new AuthService();
+        }
+        return AuthService.instance;
+    }
     async ensureInitialized() {
         if (this.initialized)
             return;

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

@@ -28,6 +28,20 @@ export interface ProjectStats {
     nodesCount: number;
     edgesCount: number;
 }
+/**
+ * Progress callback type for indexing
+ */
+export interface IndexingProgress {
+    step: 'scanning' | 'parsing' | 'symbols' | 'graph' | 'embeddings' | 'complete' | 'error';
+    stepNumber: number;
+    totalSteps: number;
+    current: number;
+    total: number;
+    message: string;
+    percentage: number;
+}
+export type ProgressCallback = (progress: IndexingProgress) => void;
+export declare function subscribeToProgress(projectId: string, callback: ProgressCallback): () => void;
 export declare class ProjectService {
     private projects;
     private projectData;
@@ -159,7 +173,7 @@ export declare class ProjectService {
      */
     private getFileContents;
     /**
-     * Генерация документации по коду проекта
+     * Генерация документации по коду проекта с использованием AI
      */
     generateDocumentation(projectId: string, options?: {
         format?: string;

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

@@ -22,6 +22,66 @@ import { DuplicationDetector } from '../../analyzers/duplication.js';
 import { SecurityAnalyzer } from '../../analyzers/security.js';
 import { RefactoringEngine } from '../../refactoring/index.js';
 import { GitHubService } from '../../github/github-service.js';
+/**
+ * Sanitize file paths to hide server directories
+ * Converts absolute paths to relative project paths
+ */
+function sanitizePath(filePath) {
+    if (!filePath)
+        return filePath;
+    // Common server path patterns to strip
+    const serverPatterns = [
+        /^\/scripts\/archicore\/.archicore\/projects\/[^/]+\/[^/]+\//,
+        /^\/scripts\/archicore\/.archicore\/projects\/[^/]+\//,
+        /^\/home\/[^/]+\/[^/]+\/.archicore\/projects\/[^/]+\//,
+        /^C:\\[^\\]+\\[^\\]+\\.archicore\\projects\\[^\\]+\\/i,
+        /^\/var\/[^/]+\/.archicore\/projects\/[^/]+\//,
+        /^.*\.archicore[\/\\]projects[\/\\][^\/\\]+[\/\\][^\/\\]+[\/\\]/,
+        /^.*\.archicore[\/\\]projects[\/\\][^\/\\]+[\/\\]/
+    ];
+    for (const pattern of serverPatterns) {
+        if (pattern.test(filePath)) {
+            return filePath.replace(pattern, '');
+        }
+    }
+    // If path contains .archicore/projects, strip everything before the actual project path
+    const archiMatch = filePath.match(/\.archicore[\/\\]projects[\/\\][^\/\\]+[\/\\](?:[^\/\\]+[\/\\])?(.+)/);
+    if (archiMatch) {
+        return archiMatch[1];
+    }
+    return filePath;
+}
+// Store active progress callbacks for SSE
+const progressCallbacks = new Map();
+export function subscribeToProgress(projectId, callback) {
+    if (!progressCallbacks.has(projectId)) {
+        progressCallbacks.set(projectId, []);
+    }
+    progressCallbacks.get(projectId).push(callback);
+    // Return unsubscribe function
+    return () => {
+        const callbacks = progressCallbacks.get(projectId);
+        if (callbacks) {
+            const index = callbacks.indexOf(callback);
+            if (index > -1) {
+                callbacks.splice(index, 1);
+            }
+        }
+    };
+}
+function emitProgress(projectId, progress) {
+    const callbacks = progressCallbacks.get(projectId);
+    if (callbacks) {
+        for (const cb of callbacks) {
+            try {
+                cb(progress);
+            }
+            catch (err) {
+                // Ignore callback errors
+            }
+        }
+    }
+}
 // Singleton instance
 let instance = null;
 export class ProjectService {
@@ -173,24 +233,54 @@ export class ProjectService {
         }
         project.status = 'indexing';
         await this.saveProjects();
+        const totalSteps = 5;
+        const sendProgress = (step, stepNumber, current, total, message) => {
+            const basePercentage = ((stepNumber - 1) / totalSteps) * 100;
+            const stepPercentage = total > 0 ? (current / total) * (100 / totalSteps) : 0;
+            const percentage = Math.min(100, Math.round(basePercentage + stepPercentage));
+            emitProgress(projectId, {
+                step,
+                stepNumber,
+                totalSteps,
+                current,
+                total,
+                message,
+                percentage
+            });
+        };
         try {
             const data = await this.getProjectData(projectId);
             Logger.progress(`Indexing project: ${project.name}`);
+            sendProgress('scanning', 1, 0, 1, 'Scanning project files...');
             // 1. Парсинг AST
-            const asts = await data.codeIndex.parseProject();
+            sendProgress('parsing', 1, 0, 1, 'Parsing source files...');
+            const asts = await data.codeIndex.parseProject((current, total, file) => {
+                sendProgress('parsing', 1, current, total, `Parsing: ${file.split(/[/\\]/).pop()}`);
+            });
             data.asts = asts;
             // 2. Извлечение символов
+            sendProgress('symbols', 2, 0, 1, 'Extracting symbols...');
             const symbols = data.codeIndex.extractSymbols(asts);
             data.symbols = symbols;
+            sendProgress('symbols', 2, 1, 1, `Extracted ${symbols.size} symbols`);
             // 3. Построение графа зависимостей
+            sendProgress('graph', 3, 0, 1, 'Building dependency graph...');
             const graph = data.codeIndex.buildDependencyGraph(asts, symbols);
             data.graph = graph;
+            sendProgress('graph', 3, 1, 1, `Built graph: ${graph.nodes.size} nodes`);
             // 4. Индексация в семантическую память (если доступна)
             if (data.semanticMemory) {
+                sendProgress('embeddings', 4, 0, symbols.size, 'Initializing vector store...');
                 await data.semanticMemory.initialize();
-                await data.semanticMemory.indexSymbols(symbols, asts);
+                await data.semanticMemory.indexSymbols(symbols, asts, (current, total) => {
+                    sendProgress('embeddings', 4, current, total, `Generating embeddings: ${current}/${total}`);
+                });
+            }
+            else {
+                sendProgress('embeddings', 4, 1, 1, 'Skipping embeddings (no API key)');
             }
             // 5. Загрузка архитектурных знаний
+            sendProgress('complete', 5, 0, 1, 'Loading architecture...');
             await data.architecture.load();
             // Обновляем статус и статистику
             const stats = {
@@ -203,12 +293,22 @@ export class ProjectService {
             project.lastIndexedAt = new Date().toISOString();
             project.stats = stats;
             await this.saveProjects();
+            sendProgress('complete', 5, 1, 1, 'Indexing complete!');
             Logger.success(`Project indexed: ${stats.filesCount} files, ${stats.symbolsCount} symbols`);
             return { success: true, stats };
         }
         catch (error) {
             project.status = 'error';
             await this.saveProjects();
+            emitProgress(projectId, {
+                step: 'error',
+                stepNumber: 0,
+                totalSteps,
+                current: 0,
+                total: 0,
+                message: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                percentage: 0
+            });
             Logger.error('Indexing failed:', error);
             throw error;
         }
@@ -758,7 +858,7 @@ export class ProjectService {
         return fileContents;
     }
     /**
-     * Генерация документации по коду проекта
+     * Генерация документации по коду проекта с использованием AI
      */
     async generateDocumentation(projectId, options = {}) {
         const project = this.projects.get(projectId);
@@ -773,24 +873,91 @@ export class ProjectService {
         // Собираем информацию о проекте
         const stats = project.stats;
         const symbols = data.symbols ? Array.from(data.symbols.values()) : [];
-        // graph is available via data.graph if needed for more detailed docs
         // Группируем символы по типу (kind)
         const classes = symbols.filter(s => s.kind === 'class');
         const functions = symbols.filter(s => s.kind === 'function');
         const interfaces = symbols.filter(s => s.kind === 'interface');
-        // Формируем структуру файлов
-        const files = fileContents ? Array.from(fileContents.keys()) : [];
+        // Формируем структуру файлов (с очисткой путей)
+        const files = fileContents ? Array.from(fileContents.keys()).map(sanitizePath) : [];
         const fileStructure = this.buildFileStructure(files);
+        // Собираем код для анализа AI (первые 10 важных файлов)
+        const codeSnippets = [];
+        if (fileContents) {
+            const importantFiles = Array.from(fileContents.entries())
+                .filter(([path]) => !path.includes('node_modules') && !path.includes('.git'))
+                .slice(0, 10);
+            for (const [filePath, content] of importantFiles) {
+                const cleanPath = sanitizePath(filePath);
+                const truncatedContent = content.substring(0, 2000);
+                codeSnippets.push(`### ${cleanPath}\n\`\`\`\n${truncatedContent}\n\`\`\``);
+            }
+        }
+        // Используем AI для генерации подробной документации
+        const orchestrator = data.orchestrator;
+        let aiDocumentation = '';
+        if (orchestrator.isAvailable()) {
+            const langInstruction = language === 'ru'
+                ? 'ВАЖНО: Отвечай ТОЛЬКО на русском языке!'
+                : 'Respond in English.';
+            const prompt = {
+                system: `You are a technical documentation writer. Generate comprehensive project documentation.
+${langInstruction}
+
+The documentation should include:
+1. Project Overview - what the project does, its purpose
+2. Architecture Description - how components are organized
+3. Key Components - main classes and their responsibilities
+4. Main Functions - important functions and what they do
+5. Data Flow - how data moves through the system
+6. Usage Examples - how to use the main features
+
+Be specific and detailed. Analyze the actual code provided to understand the project's purpose.`,
+                user: `Generate detailed documentation for project "${project.name}".
+
+Project Statistics:
+- Files: ${stats?.filesCount || files.length}
+- Symbols: ${stats?.symbolsCount || symbols.length}
+- Classes: ${classes.length}
+- Functions: ${functions.length}
+- Interfaces: ${interfaces.length}
+
+File Structure:
+${fileStructure}
+
+Classes: ${classes.slice(0, 15).map(c => `${c.name} (${sanitizePath(c.filePath)})`).join(', ') || 'None'}
+
+Key Functions: ${functions.slice(0, 20).map(f => f.name).join(', ') || 'None'}
+
+Interfaces: ${interfaces.slice(0, 10).map(i => i.name).join(', ') || 'None'}
+
+Code Samples:
+${codeSnippets.slice(0, 5).join('\n\n')}
+
+Generate comprehensive markdown documentation based on this analysis.`
+            };
+            try {
+                const response = await orchestrator.query(prompt);
+                aiDocumentation = response.content;
+            }
+            catch (err) {
+                Logger.warn('AI documentation generation failed, using basic template');
+            }
+        }
         // Генерируем документацию
         let documentation = '';
         if (format === 'markdown') {
             const title = language === 'ru' ? 'Документация проекта' : 'Project Documentation';
-            const overview = language === 'ru' ? 'Обзор' : 'Overview';
-            const structure = language === 'ru' ? 'Структура проекта' : 'Project Structure';
-            const classesTitle = language === 'ru' ? 'Классы' : 'Classes';
-            const functionsTitle = language === 'ru' ? 'Функции' : 'Functions';
-            const interfacesTitle = language === 'ru' ? 'Интерфейсы' : 'Interfaces';
-            documentation = `# ${title}: ${project.name}
+            if (aiDocumentation) {
+                // Используем AI-сгенерированную документацию
+                documentation = `# ${title}: ${project.name}\n\n${aiDocumentation}\n\n---\n*Generated by ArchiCore AI*`;
+            }
+            else {
+                // Fallback на базовый шаблон
+                const overview = language === 'ru' ? 'Обзор' : 'Overview';
+                const structure = language === 'ru' ? 'Структура проекта' : 'Project Structure';
+                const classesTitle = language === 'ru' ? 'Классы' : 'Classes';
+                const functionsTitle = language === 'ru' ? 'Функции' : 'Functions';
+                documentation = `# ${title}: ${project.name}
 
 ## ${overview}
 
@@ -810,37 +977,29 @@ ${classes.length > 0 ? `## ${classesTitle}
 
 ${classes.slice(0, 20).map(c => `### ${c.name}
 
-- **File:** \`${c.filePath}\`
+- **File:** \`${sanitizePath(c.filePath)}\`
 - **Line:** ${c.location?.startLine || 'N/A'}
 `).join('\n')}
 ` : ''}
 
-${interfaces.length > 0 ? `## ${interfacesTitle}
-
-${interfaces.slice(0, 20).map(i => `### ${i.name}
-
-- **File:** \`${i.filePath}\`
-- **Line:** ${i.location?.startLine || 'N/A'}
-`).join('\n')}
-` : ''}
-
 ${functions.length > 0 ? `## ${functionsTitle}
 
-${functions.slice(0, 30).map(f => `- \`${f.name}\` - ${f.filePath}:${f.location?.startLine || 'N/A'}`).join('\n')}
+${functions.slice(0, 30).map(f => `- \`${f.name}\` - ${sanitizePath(f.filePath)}:${f.location?.startLine || 'N/A'}`).join('\n')}
 ` : ''}
 
 ---
 *Generated by ArchiCore*
 `;
+            }
         }
         else {
             // JSON format
             documentation = JSON.stringify({
                 project: project.name,
                 stats,
-                classes: classes.map(c => ({ name: c.name, file: c.filePath, line: c.location?.startLine })),
-                functions: functions.map(f => ({ name: f.name, file: f.filePath, line: f.location?.startLine })),
-                interfaces: interfaces.map(i => ({ name: i.name, file: i.filePath, line: i.location?.startLine })),
+                classes: classes.map(c => ({ name: c.name, file: sanitizePath(c.filePath), line: c.location?.startLine })),
+                functions: functions.map(f => ({ name: f.name, file: sanitizePath(f.filePath), line: f.location?.startLine })),
+                interfaces: interfaces.map(i => ({ name: i.name, file: sanitizePath(i.filePath), line: i.location?.startLine })),
                 files
             }, null, 2);
         }

package/dist/types/user.d.ts

@@ -1,12 +1,12 @@
 /**
  * User and Subscription Types for ArchiCore
  */
-export type SubscriptionTier = 'free' | 'mid' | 'pro' | 'admin';
+export type SubscriptionTier = 'free' | 'mid' | 'pro' | 'enterprise' | 'admin';
 export interface TierLimits {
     requestsPerDay: number;
     fullAnalysisPerDay: number;
     projectsPerDay: number;
-    maxFileSizeMB: number;
+    maxProjectSizeMB: number;
     retentionDays: number;
     price: number;
     priceYearly: number;

package/dist/types/user.js

@@ -6,7 +6,7 @@ export const TIER_LIMITS = {
         requestsPerDay: 10,
         fullAnalysisPerDay: 1,
         projectsPerDay: 3,
-        maxFileSizeMB: 10,
+        maxProjectSizeMB: 30,
         retentionDays: 7,
         price: 0,
         priceYearly: 0
@@ -15,7 +15,7 @@ export const TIER_LIMITS = {
         requestsPerDay: 50,
         fullAnalysisPerDay: 5,
         projectsPerDay: 10,
-        maxFileSizeMB: 30,
+        maxProjectSizeMB: 50,
         retentionDays: 14,
         price: 39,
         priceYearly: 390 // ~2 months free
@@ -24,16 +24,25 @@ export const TIER_LIMITS = {
         requestsPerDay: 150,
         fullAnalysisPerDay: 15,
         projectsPerDay: 20,
-        maxFileSizeMB: 60,
+        maxProjectSizeMB: 80,
         retentionDays: 30,
         price: 99,
         priceYearly: 990 // ~2 months free
     },
+    enterprise: {
+        requestsPerDay: Infinity,
+        fullAnalysisPerDay: Infinity,
+        projectsPerDay: Infinity,
+        maxProjectSizeMB: 500,
+        retentionDays: 365,
+        price: -1, // Custom pricing
+        priceYearly: -1
+    },
     admin: {
         requestsPerDay: Infinity,
         fullAnalysisPerDay: Infinity,
         projectsPerDay: Infinity,
-        maxFileSizeMB: 500,
+        maxProjectSizeMB: 1000,
         retentionDays: 365,
         price: 0,
         priceYearly: 0