archicore 0.1.0

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

@@ -0,0 +1,315 @@
+/**
+ * Authentication Service for ArchiCore
+ */
+import { randomUUID } from 'crypto';
+import { createHash } from 'crypto';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { TIER_LIMITS } from '../../types/user.js';
+const DATA_DIR = '.archicore';
+const USERS_FILE = 'users.json';
+const SESSIONS_FILE = 'sessions.json';
+export class AuthService {
+    dataDir;
+    users = [];
+    sessions = [];
+    initialized = false;
+    constructor(dataDir = DATA_DIR) {
+        this.dataDir = dataDir;
+    }
+    async ensureInitialized() {
+        if (this.initialized)
+            return;
+        try {
+            await mkdir(this.dataDir, { recursive: true });
+        }
+        catch { }
+        // Load users
+        try {
+            const usersPath = join(this.dataDir, USERS_FILE);
+            const data = await readFile(usersPath, 'utf-8');
+            const parsed = JSON.parse(data);
+            this.users = parsed.users || [];
+        }
+        catch {
+            this.users = [];
+            // Create default admin user
+            await this.createDefaultAdmin();
+        }
+        // Load sessions
+        try {
+            const sessionsPath = join(this.dataDir, SESSIONS_FILE);
+            const data = await readFile(sessionsPath, 'utf-8');
+            const parsed = JSON.parse(data);
+            this.sessions = parsed.sessions || [];
+        }
+        catch {
+            this.sessions = [];
+        }
+        this.initialized = true;
+    }
+    async createDefaultAdmin() {
+        const admin = {
+            id: 'admin-' + randomUUID(),
+            email: 'admin@archicore.io',
+            username: 'Administrator',
+            passwordHash: this.hashPassword('admin123'),
+            tier: 'admin',
+            provider: 'email',
+            createdAt: new Date(),
+            lastLoginAt: new Date(),
+            usage: this.createEmptyUsage()
+        };
+        this.users.push(admin);
+        await this.saveUsers();
+    }
+    async saveUsers() {
+        const usersPath = join(this.dataDir, USERS_FILE);
+        await writeFile(usersPath, JSON.stringify({ users: this.users }, null, 2));
+    }
+    async saveSessions() {
+        const sessionsPath = join(this.dataDir, SESSIONS_FILE);
+        await writeFile(sessionsPath, JSON.stringify({ sessions: this.sessions }, null, 2));
+    }
+    hashPassword(password) {
+        return createHash('sha256').update(password + 'archicore-salt-2024').digest('hex');
+    }
+    createEmptyUsage() {
+        return {
+            requestsToday: 0,
+            fullAnalysisToday: 0,
+            projectsToday: 0,
+            lastResetDate: new Date().toISOString().split('T')[0]
+        };
+    }
+    generateToken() {
+        return randomUUID() + '-' + randomUUID();
+    }
+    sanitizeUser(user) {
+        const { passwordHash, ...sanitized } = user;
+        return sanitized;
+    }
+    async register(email, username, password) {
+        await this.ensureInitialized();
+        // Check if email already exists
+        if (this.users.find(u => u.email.toLowerCase() === email.toLowerCase())) {
+            return { success: false, error: 'Email already registered' };
+        }
+        // Check if username already exists
+        if (this.users.find(u => u.username.toLowerCase() === username.toLowerCase())) {
+            return { success: false, error: 'Username already taken' };
+        }
+        const user = {
+            id: 'user-' + randomUUID(),
+            email: email.toLowerCase(),
+            username,
+            passwordHash: this.hashPassword(password),
+            tier: 'free',
+            provider: 'email',
+            createdAt: new Date(),
+            lastLoginAt: new Date(),
+            usage: this.createEmptyUsage()
+        };
+        this.users.push(user);
+        await this.saveUsers();
+        // Create session
+        const token = this.generateToken();
+        const session = {
+            token,
+            userId: user.id,
+            expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000) // 7 days
+        };
+        this.sessions.push(session);
+        await this.saveSessions();
+        return {
+            success: true,
+            token,
+            user: this.sanitizeUser(user)
+        };
+    }
+    async login(email, password) {
+        await this.ensureInitialized();
+        const user = this.users.find(u => u.email.toLowerCase() === email.toLowerCase());
+        if (!user) {
+            return { success: false, error: 'Invalid email or password' };
+        }
+        if (user.passwordHash !== this.hashPassword(password)) {
+            return { success: false, error: 'Invalid email or password' };
+        }
+        // Update last login
+        user.lastLoginAt = new Date();
+        await this.saveUsers();
+        // Create session
+        const token = this.generateToken();
+        const session = {
+            token,
+            userId: user.id,
+            expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
+        };
+        this.sessions.push(session);
+        await this.saveSessions();
+        return {
+            success: true,
+            token,
+            user: this.sanitizeUser(user)
+        };
+    }
+    async oauthLogin(provider, profile) {
+        await this.ensureInitialized();
+        // Find existing user by provider ID or email
+        let user = this.users.find(u => (u.provider === provider && u.providerId === profile.id) ||
+            u.email.toLowerCase() === profile.email.toLowerCase());
+        if (!user) {
+            // Create new user
+            user = {
+                id: 'user-' + randomUUID(),
+                email: profile.email.toLowerCase(),
+                username: profile.name || profile.email.split('@')[0],
+                avatar: profile.avatar,
+                tier: 'free',
+                provider,
+                providerId: profile.id,
+                createdAt: new Date(),
+                lastLoginAt: new Date(),
+                usage: this.createEmptyUsage()
+            };
+            this.users.push(user);
+        }
+        else {
+            // Update existing user
+            user.lastLoginAt = new Date();
+            if (profile.avatar)
+                user.avatar = profile.avatar;
+            if (!user.providerId) {
+                user.provider = provider;
+                user.providerId = profile.id;
+            }
+        }
+        await this.saveUsers();
+        // Create session
+        const token = this.generateToken();
+        const session = {
+            token,
+            userId: user.id,
+            expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
+        };
+        this.sessions.push(session);
+        await this.saveSessions();
+        return {
+            success: true,
+            token,
+            user: this.sanitizeUser(user)
+        };
+    }
+    async validateToken(token) {
+        await this.ensureInitialized();
+        const session = this.sessions.find(s => s.token === token);
+        if (!session)
+            return null;
+        if (new Date(session.expiresAt) < new Date()) {
+            // Session expired, remove it
+            this.sessions = this.sessions.filter(s => s.token !== token);
+            await this.saveSessions();
+            return null;
+        }
+        const user = this.users.find(u => u.id === session.userId);
+        return user || null;
+    }
+    async logout(token) {
+        await this.ensureInitialized();
+        this.sessions = this.sessions.filter(s => s.token !== token);
+        await this.saveSessions();
+    }
+    async getUser(userId) {
+        await this.ensureInitialized();
+        return this.users.find(u => u.id === userId) || null;
+    }
+    async updateUserTier(userId, tier) {
+        await this.ensureInitialized();
+        const user = this.users.find(u => u.id === userId);
+        if (!user)
+            return false;
+        user.tier = tier;
+        await this.saveUsers();
+        return true;
+    }
+    async checkAndUpdateUsage(userId, type) {
+        await this.ensureInitialized();
+        const user = this.users.find(u => u.id === userId);
+        if (!user)
+            return { allowed: false, remaining: 0, limit: 0 };
+        const today = new Date().toISOString().split('T')[0];
+        // Reset usage if new day
+        if (user.usage.lastResetDate !== today) {
+            user.usage = this.createEmptyUsage();
+        }
+        const limits = TIER_LIMITS[user.tier];
+        let current;
+        let limit;
+        switch (type) {
+            case 'request':
+                current = user.usage.requestsToday;
+                limit = limits.requestsPerDay;
+                break;
+            case 'analysis':
+                current = user.usage.fullAnalysisToday;
+                limit = limits.fullAnalysisPerDay;
+                break;
+            case 'project':
+                current = user.usage.projectsToday;
+                limit = limits.projectsPerDay;
+                break;
+        }
+        if (current >= limit && limit !== Infinity) {
+            return { allowed: false, remaining: 0, limit };
+        }
+        // Increment usage
+        switch (type) {
+            case 'request':
+                user.usage.requestsToday++;
+                break;
+            case 'analysis':
+                user.usage.fullAnalysisToday++;
+                break;
+            case 'project':
+                user.usage.projectsToday++;
+                break;
+        }
+        await this.saveUsers();
+        const remaining = limit === Infinity ? Infinity : limit - current - 1;
+        return { allowed: true, remaining, limit };
+    }
+    async getAllUsers() {
+        await this.ensureInitialized();
+        return this.users.map(u => this.sanitizeUser(u));
+    }
+    async deleteUser(userId) {
+        await this.ensureInitialized();
+        const index = this.users.findIndex(u => u.id === userId);
+        if (index === -1)
+            return false;
+        // Don't delete admin
+        if (this.users[index].tier === 'admin')
+            return false;
+        this.users.splice(index, 1);
+        this.sessions = this.sessions.filter(s => s.userId !== userId);
+        await this.saveUsers();
+        await this.saveSessions();
+        return true;
+    }
+    async updateUser(userId, updates) {
+        await this.ensureInitialized();
+        const user = this.users.find(u => u.id === userId);
+        if (!user)
+            return false;
+        if (updates.username)
+            user.username = updates.username;
+        if (updates.email)
+            user.email = updates.email;
+        if (updates.avatar)
+            user.avatar = updates.avatar;
+        await this.saveUsers();
+        return true;
+    }
+}
+//# sourceMappingURL=auth-service.js.map

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

@@ -0,0 +1,123 @@
+/**
+ * Project Service
+ *
+ * Сервис для управления проектами в ArchiCore.
+ * Связывает API с основными модулями системы.
+ */
+import { ChangeImpact } from '../../types/index.js';
+import { RulesCheckResult } from '../../rules-engine/index.js';
+import { ProjectMetrics } from '../../metrics/index.js';
+import { DeadCodeResult } from '../../analyzers/dead-code.js';
+import { DuplicationResult } from '../../analyzers/duplication.js';
+import { SecurityResult } from '../../analyzers/security.js';
+import { RefactoringResult } from '../../refactoring/index.js';
+import { ExportData } from '../../export/index.js';
+export interface Project {
+    id: string;
+    name: string;
+    path: string;
+    createdAt: string;
+    lastIndexedAt?: string;
+    status: 'pending' | 'indexing' | 'ready' | 'error';
+    stats?: ProjectStats;
+}
+export interface ProjectStats {
+    filesCount: number;
+    symbolsCount: number;
+    nodesCount: number;
+    edgesCount: number;
+}
+export declare class ProjectService {
+    private projects;
+    private projectData;
+    private dataDir;
+    constructor();
+    private loadProjects;
+    private saveProjects;
+    listProjects(): Promise<Project[]>;
+    createProject(name: string, projectPath: string): Promise<Project>;
+    getProject(id: string): Promise<Project | null>;
+    private initializeProjectData;
+    private getProjectData;
+    indexProject(projectId: string): Promise<{
+        success: boolean;
+        stats: ProjectStats;
+    }>;
+    getArchitecture(projectId: string): Promise<{
+        boundedContexts: unknown[];
+        entities: unknown[];
+        rules: unknown[];
+        graph: {
+            nodes: unknown[];
+            edges: unknown[];
+        };
+    }>;
+    getDependencyGraph(projectId: string): Promise<{
+        nodes: unknown[];
+        edges: unknown[];
+    }>;
+    private convertGraphForVisualization;
+    analyzeImpact(projectId: string, change: {
+        description: string;
+        files: string[];
+        symbols: string[];
+        type: 'add' | 'modify' | 'delete' | 'refactor';
+    }): Promise<ChangeImpact>;
+    simulateChange(projectId: string, changeDescription: string): Promise<{
+        impact: ChangeImpact;
+        aiAnalysis: string;
+        recommendations: string[];
+    }>;
+    semanticSearch(projectId: string, query: string, limit?: number): Promise<unknown[]>;
+    askArchitect(projectId: string, question: string, language?: 'en' | 'ru'): Promise<string>;
+    getStatistics(projectId: string): Promise<{
+        project: Project;
+        indexStats: ProjectStats | null;
+        memoryStats: unknown;
+    }>;
+    deleteProject(projectId: string): Promise<void>;
+    /**
+     * Получить метрики кода
+     */
+    getMetrics(projectId: string): Promise<ProjectMetrics>;
+    /**
+     * Проверить правила архитектуры
+     */
+    checkRules(projectId: string): Promise<RulesCheckResult>;
+    /**
+     * Найти мёртвый код
+     */
+    findDeadCode(projectId: string): Promise<DeadCodeResult>;
+    /**
+     * Найти дублирование кода
+     */
+    findDuplication(projectId: string): Promise<DuplicationResult>;
+    /**
+     * Анализ безопасности
+     */
+    analyzeSecurity(projectId: string): Promise<SecurityResult>;
+    /**
+     * Получить предложения по рефакторингу
+     */
+    getRefactoringSuggestions(projectId: string): Promise<RefactoringResult>;
+    /**
+     * Получить данные для экспорта
+     */
+    getExportData(projectId: string): Promise<ExportData>;
+    /**
+     * Полный анализ проекта
+     */
+    runFullAnalysis(projectId: string): Promise<{
+        metrics: ProjectMetrics;
+        rules: RulesCheckResult;
+        deadCode: DeadCodeResult;
+        duplication: DuplicationResult;
+        security: SecurityResult;
+        refactoring: RefactoringResult;
+    }>;
+    /**
+     * Получить содержимое файлов проекта
+     */
+    private getFileContents;
+}
+//# sourceMappingURL=project-service.d.ts.map