archicore 0.1.0

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

@@ -0,0 +1,533 @@
+/**
+ * Project Service
+ *
+ * Сервис для управления проектами в ArchiCore.
+ * Связывает API с основными модулями системы.
+ */
+import { v4 as uuidv4 } from 'uuid';
+import { CodeIndex } from '../../code-index/index.js';
+import { SemanticMemory } from '../../semantic-memory/index.js';
+import { ImpactEngine } from '../../impact-engine/index.js';
+import { LLMOrchestrator } from '../../orchestrator/index.js';
+import { ArchitectureKnowledge } from '../../architecture/index.js';
+import { Logger } from '../../utils/logger.js';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+// New analyzers
+import { RulesEngine } from '../../rules-engine/index.js';
+import { MetricsCalculator } from '../../metrics/index.js';
+import { DeadCodeDetector } from '../../analyzers/dead-code.js';
+import { DuplicationDetector } from '../../analyzers/duplication.js';
+import { SecurityAnalyzer } from '../../analyzers/security.js';
+import { RefactoringEngine } from '../../refactoring/index.js';
+// Singleton instance
+let instance = null;
+export class ProjectService {
+    projects = new Map();
+    projectData = new Map();
+    dataDir;
+    constructor() {
+        // Singleton pattern
+        if (instance) {
+            return instance;
+        }
+        instance = this;
+        this.dataDir = process.env.ARCHICORE_DATA_DIR || '.archicore';
+        this.loadProjects();
+    }
+    async loadProjects() {
+        try {
+            const projectsFile = path.join(this.dataDir, 'projects.json');
+            if (existsSync(projectsFile)) {
+                const content = await readFile(projectsFile, 'utf-8');
+                const data = JSON.parse(content);
+                for (const project of data.projects) {
+                    this.projects.set(project.id, project);
+                }
+                Logger.info(`Loaded ${this.projects.size} projects`);
+            }
+        }
+        catch (error) {
+            Logger.warn('Could not load projects:', error);
+        }
+    }
+    async saveProjects() {
+        try {
+            if (!existsSync(this.dataDir)) {
+                await mkdir(this.dataDir, { recursive: true });
+            }
+            const projectsFile = path.join(this.dataDir, 'projects.json');
+            const data = { projects: Array.from(this.projects.values()) };
+            await writeFile(projectsFile, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            Logger.error('Could not save projects:', error);
+        }
+    }
+    async listProjects() {
+        return Array.from(this.projects.values());
+    }
+    async createProject(name, projectPath) {
+        const id = uuidv4();
+        const project = {
+            id,
+            name,
+            path: projectPath,
+            createdAt: new Date().toISOString(),
+            status: 'pending'
+        };
+        this.projects.set(id, project);
+        await this.saveProjects();
+        // Инициализируем данные проекта
+        await this.initializeProjectData(id);
+        Logger.success(`Created project: ${name} (${id})`);
+        return project;
+    }
+    async getProject(id) {
+        return this.projects.get(id) || null;
+    }
+    async initializeProjectData(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        // Конфигурация для DeepSeek
+        const llmConfig = {
+            provider: 'deepseek',
+            model: process.env.DEEPSEEK_MODEL || 'deepseek-chat',
+            temperature: 0.1,
+            maxTokens: 4096,
+            baseURL: 'https://api.deepseek.com'
+        };
+        // SemanticMemory опционален - DeepSeek не поддерживает embeddings
+        let semanticMemory = null;
+        // Только если есть OpenAI ключ - используем embeddings
+        if (process.env.OPENAI_API_KEY) {
+            const embeddingConfig = {
+                provider: 'openai',
+                model: 'text-embedding-3-small'
+            };
+            const vectorStoreConfig = {
+                url: process.env.QDRANT_URL || 'http://localhost:6333',
+                apiKey: process.env.QDRANT_API_KEY,
+                collectionName: `archicore_${projectId.replace(/-/g, '_')}`
+            };
+            semanticMemory = new SemanticMemory(embeddingConfig, vectorStoreConfig);
+            Logger.info('SemanticMemory enabled (OpenAI embeddings)');
+        }
+        else {
+            Logger.warn('SemanticMemory disabled - no OPENAI_API_KEY. Semantic search unavailable.');
+        }
+        const data = {
+            codeIndex: new CodeIndex(project.path),
+            semanticMemory,
+            impactEngine: new ImpactEngine(),
+            orchestrator: new LLMOrchestrator(llmConfig),
+            architecture: new ArchitectureKnowledge(path.join(project.path, '.aiarhitector/architecture.json'))
+        };
+        this.projectData.set(projectId, data);
+        return data;
+    }
+    async getProjectData(projectId) {
+        let data = this.projectData.get(projectId);
+        if (!data) {
+            data = await this.initializeProjectData(projectId);
+        }
+        return data;
+    }
+    async indexProject(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        project.status = 'indexing';
+        await this.saveProjects();
+        try {
+            const data = await this.getProjectData(projectId);
+            Logger.progress(`Indexing project: ${project.name}`);
+            // 1. Парсинг AST
+            const asts = await data.codeIndex.parseProject();
+            data.asts = asts;
+            // 2. Извлечение символов
+            const symbols = data.codeIndex.extractSymbols(asts);
+            data.symbols = symbols;
+            // 3. Построение графа зависимостей
+            const graph = data.codeIndex.buildDependencyGraph(asts, symbols);
+            data.graph = graph;
+            // 4. Индексация в семантическую память (если доступна)
+            if (data.semanticMemory) {
+                await data.semanticMemory.initialize();
+                await data.semanticMemory.indexSymbols(symbols, asts);
+            }
+            // 5. Загрузка архитектурных знаний
+            await data.architecture.load();
+            // Обновляем статус и статистику
+            const stats = {
+                filesCount: asts.size,
+                symbolsCount: symbols.size,
+                nodesCount: graph.nodes.size,
+                edgesCount: Array.from(graph.edges.values()).reduce((sum, edges) => sum + edges.length, 0)
+            };
+            project.status = 'ready';
+            project.lastIndexedAt = new Date().toISOString();
+            project.stats = stats;
+            await this.saveProjects();
+            Logger.success(`Project indexed: ${stats.filesCount} files, ${stats.symbolsCount} symbols`);
+            return { success: true, stats };
+        }
+        catch (error) {
+            project.status = 'error';
+            await this.saveProjects();
+            Logger.error('Indexing failed:', error);
+            throw error;
+        }
+    }
+    async getArchitecture(projectId) {
+        const data = await this.getProjectData(projectId);
+        const model = data.architecture.getModel();
+        // Преобразуем граф в формат для визуализации
+        const graphData = this.convertGraphForVisualization(data.graph);
+        return {
+            boundedContexts: model.boundedContexts,
+            entities: model.entities,
+            rules: model.rules.map(r => ({
+                id: r.id,
+                description: r.description,
+                type: r.type,
+                severity: r.severity
+            })),
+            graph: graphData
+        };
+    }
+    async getDependencyGraph(projectId) {
+        const data = await this.getProjectData(projectId);
+        return this.convertGraphForVisualization(data.graph);
+    }
+    convertGraphForVisualization(graph) {
+        if (!graph) {
+            return { nodes: [], edges: [] };
+        }
+        const nodes = Array.from(graph.nodes.entries()).map(([id, node]) => ({
+            id,
+            label: node.name,
+            type: node.type,
+            filePath: node.filePath,
+            // Для визуализации - группировка по папкам
+            group: node.filePath.split('/').slice(-2, -1)[0] || 'root'
+        }));
+        const edges = [];
+        for (const [from, edgeList] of graph.edges) {
+            for (const edge of edgeList) {
+                edges.push({
+                    from,
+                    to: edge.to,
+                    type: edge.type,
+                    weight: edge.weight || 1
+                });
+            }
+        }
+        return { nodes, edges };
+    }
+    async analyzeImpact(projectId, change) {
+        const data = await this.getProjectData(projectId);
+        if (!data.graph || !data.symbols) {
+            throw new Error('Project not indexed. Please index first.');
+        }
+        const changeObj = {
+            type: change.type,
+            description: change.description,
+            files: change.files,
+            symbols: change.symbols
+        };
+        const impact = data.impactEngine.analyzeChange(changeObj, data.graph, data.symbols, data.architecture.getModel());
+        return impact;
+    }
+    async simulateChange(projectId, changeDescription) {
+        const data = await this.getProjectData(projectId);
+        let affectedFiles = [];
+        let affectedSymbols = [];
+        let searchResults = [];
+        // Если есть семантическая память - ищем релевантные файлы
+        if (data.semanticMemory) {
+            const results = await data.semanticMemory.searchByQuery(changeDescription, 5);
+            searchResults = results;
+            affectedFiles = results.map(r => r.chunk.metadata.filePath);
+            affectedSymbols = results.flatMap(r => r.chunk.metadata.symbols);
+        }
+        // Анализируем impact
+        const impact = await this.analyzeImpact(projectId, {
+            description: changeDescription,
+            files: affectedFiles,
+            symbols: affectedSymbols,
+            type: 'modify'
+        });
+        // Получаем AI анализ
+        const aiAnalysis = await data.orchestrator.analyzeImpact(impact, {
+            architecture: data.architecture.getModel(),
+            semanticMemory: searchResults
+        });
+        return {
+            impact,
+            aiAnalysis,
+            recommendations: impact.recommendations.map(r => r.description)
+        };
+    }
+    async semanticSearch(projectId, query, limit = 10) {
+        const data = await this.getProjectData(projectId);
+        if (!data.semanticMemory) {
+            throw new Error('Semantic search unavailable - no embedding API configured');
+        }
+        const results = await data.semanticMemory.searchByQuery(query, limit);
+        return results.map(r => ({
+            filePath: r.chunk.metadata.filePath,
+            startLine: r.chunk.metadata.startLine,
+            endLine: r.chunk.metadata.endLine,
+            type: r.chunk.metadata.type,
+            symbols: r.chunk.metadata.symbols,
+            score: r.score,
+            context: r.context
+        }));
+    }
+    async askArchitect(projectId, question, language = 'en') {
+        const data = await this.getProjectData(projectId);
+        // Ищем релевантный контекст (если есть семантическая память)
+        let searchResults = [];
+        if (data.semanticMemory) {
+            try {
+                searchResults = await data.semanticMemory.searchByQuery(question, 5);
+                Logger.debug(`Semantic search returned ${searchResults.length} results`);
+            }
+            catch (err) {
+                Logger.warn('Semantic search failed, using fallback');
+            }
+        }
+        // Fallback: если семантический поиск не работает, даём контекст из графа
+        if (searchResults.length === 0 && data.graph) {
+            Logger.info('Using graph fallback for context');
+            const files = Array.from(data.graph.nodes.values()).slice(0, 10);
+            for (const file of files) {
+                searchResults.push({
+                    chunk: {
+                        id: file.id,
+                        content: `File: ${file.filePath}\nType: ${file.type}`,
+                        embedding: [],
+                        metadata: {
+                            filePath: file.filePath,
+                            startLine: 0,
+                            endLine: 0,
+                            type: 'module',
+                            symbols: [],
+                            tags: []
+                        }
+                    },
+                    score: 1,
+                    context: `File: ${file.filePath}`
+                });
+            }
+        }
+        // Добавляем информацию о символах если есть
+        if (data.symbols && data.symbols.size > 0) {
+            const symbolsList = Array.from(data.symbols.values()).slice(0, 20);
+            for (const sym of symbolsList) {
+                const existing = searchResults.find(r => r.chunk.metadata.filePath === sym.filePath);
+                if (existing) {
+                    existing.context += `\n- ${sym.kind}: ${sym.name}`;
+                }
+            }
+        }
+        Logger.debug(`Passing ${searchResults.length} context items to AI`);
+        const answer = await data.orchestrator.answerArchitecturalQuestion(question, {
+            architecture: data.architecture.getModel(),
+            semanticMemory: searchResults,
+            language
+        });
+        return answer;
+    }
+    async getStatistics(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        let memoryStats = null;
+        try {
+            const data = await this.getProjectData(projectId);
+            if (data.semanticMemory) {
+                memoryStats = await data.semanticMemory.getStatistics();
+            }
+        }
+        catch {
+            // Игнорируем если семантическая память не инициализирована
+        }
+        return {
+            project,
+            indexStats: project.stats || null,
+            memoryStats
+        };
+    }
+    async deleteProject(projectId) {
+        this.projects.delete(projectId);
+        this.projectData.delete(projectId);
+        await this.saveProjects();
+        Logger.info(`Deleted project: ${projectId}`);
+    }
+    /**
+     * Получить метрики кода
+     */
+    async getMetrics(projectId) {
+        const data = await this.getProjectData(projectId);
+        if (!data.graph || !data.symbols || !data.asts) {
+            throw new Error('Project not indexed. Please index first.');
+        }
+        const fileContents = await this.getFileContents(projectId);
+        const calculator = new MetricsCalculator();
+        return calculator.calculateProjectMetrics(data.graph, data.symbols, fileContents, data.asts);
+    }
+    /**
+     * Проверить правила архитектуры
+     */
+    async checkRules(projectId) {
+        const data = await this.getProjectData(projectId);
+        if (!data.graph || !data.symbols) {
+            throw new Error('Project not indexed. Please index first.');
+        }
+        const fileContents = await this.getFileContents(projectId);
+        const rulesEngine = new RulesEngine();
+        return rulesEngine.check(data.graph, data.symbols, fileContents);
+    }
+    /**
+     * Найти мёртвый код
+     */
+    async findDeadCode(projectId) {
+        const data = await this.getProjectData(projectId);
+        if (!data.graph || !data.symbols) {
+            throw new Error('Project not indexed. Please index first.');
+        }
+        const fileContents = await this.getFileContents(projectId);
+        const detector = new DeadCodeDetector();
+        return detector.analyze(data.graph, data.symbols, fileContents);
+    }
+    /**
+     * Найти дублирование кода
+     */
+    async findDuplication(projectId) {
+        const fileContents = await this.getFileContents(projectId);
+        const detector = new DuplicationDetector();
+        return detector.analyze(fileContents);
+    }
+    /**
+     * Анализ безопасности
+     */
+    async analyzeSecurity(projectId) {
+        const fileContents = await this.getFileContents(projectId);
+        const analyzer = new SecurityAnalyzer();
+        return analyzer.analyze(fileContents);
+    }
+    /**
+     * Получить предложения по рефакторингу
+     */
+    async getRefactoringSuggestions(projectId) {
+        const data = await this.getProjectData(projectId);
+        if (!data.graph || !data.symbols || !data.asts) {
+            throw new Error('Project not indexed. Please index first.');
+        }
+        const fileContents = await this.getFileContents(projectId);
+        // Запускаем необходимые анализаторы
+        const metrics = await this.getMetrics(projectId);
+        const duplication = await this.findDuplication(projectId);
+        const deadCode = await this.findDeadCode(projectId);
+        const rulesResult = await this.checkRules(projectId);
+        const engine = new RefactoringEngine();
+        return engine.analyze(data.graph, data.symbols, fileContents, metrics, duplication, deadCode, rulesResult);
+    }
+    /**
+     * Получить данные для экспорта
+     */
+    async getExportData(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        const data = await this.getProjectData(projectId);
+        // Собираем все данные
+        const metrics = data.graph && data.symbols && data.asts
+            ? await this.getMetrics(projectId)
+            : undefined;
+        const rules = data.graph && data.symbols
+            ? await this.checkRules(projectId)
+            : undefined;
+        const deadCode = data.graph && data.symbols
+            ? await this.findDeadCode(projectId)
+            : undefined;
+        const duplication = await this.findDuplication(projectId);
+        const security = await this.analyzeSecurity(projectId);
+        return {
+            projectName: project.name,
+            exportDate: new Date().toISOString(),
+            version: '1.0.0',
+            graph: data.graph,
+            symbols: data.symbols,
+            metrics,
+            rules,
+            deadCode,
+            duplication,
+            security
+        };
+    }
+    /**
+     * Полный анализ проекта
+     */
+    async runFullAnalysis(projectId) {
+        Logger.progress('Running full analysis...');
+        const [metrics, rules, deadCode, duplication, security] = await Promise.all([
+            this.getMetrics(projectId),
+            this.checkRules(projectId),
+            this.findDeadCode(projectId),
+            this.findDuplication(projectId),
+            this.analyzeSecurity(projectId)
+        ]);
+        // Refactoring зависит от предыдущих результатов
+        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);
+        Logger.success('Full analysis complete');
+        return {
+            metrics,
+            rules,
+            deadCode,
+            duplication,
+            security,
+            refactoring
+        };
+    }
+    /**
+     * Получить содержимое файлов проекта
+     */
+    async getFileContents(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        const data = await this.getProjectData(projectId);
+        const fileContents = new Map();
+        if (data.asts) {
+            for (const [filePath] of data.asts) {
+                try {
+                    const fullPath = path.isAbsolute(filePath)
+                        ? filePath
+                        : path.join(project.path, filePath);
+                    if (existsSync(fullPath)) {
+                        const content = await readFile(fullPath, 'utf-8');
+                        fileContents.set(filePath, content);
+                    }
+                }
+                catch {
+                    // Игнорируем ошибки чтения
+                }
+            }
+        }
+        return fileContents;
+    }
+}
+//# sourceMappingURL=project-service.js.map

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

@@ -0,0 +1,107 @@
+/**
+ * Token Service for ArchiCore Developer API
+ *
+ * Подсчёт токенов, биллинг и rate limiting
+ */
+import { TokenUsage, ApiOperation, BillingAccount, RateLimitState, RateLimitResult, UsageStats } from '../../types/api.js';
+export declare class TokenService {
+    private dataDir;
+    private usageRecords;
+    private billingAccounts;
+    private rateLimitStates;
+    private initialized;
+    constructor(dataDir?: string);
+    private ensureInitialized;
+    private saveUsage;
+    private saveBilling;
+    private saveRateLimits;
+    /**
+     * Подсчёт токенов для операции
+     */
+    calculateTokens(operation: ApiOperation, params: {
+        fileCount?: number;
+        contentSizeKb?: number;
+        inputText?: string;
+        outputText?: string;
+    }): {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    /**
+     * Расчёт стоимости в центах
+     */
+    calculateCost(totalTokens: number, pricingTier: string): number;
+    /**
+     * Запись использования токенов
+     */
+    recordUsage(apiKeyId: string, userId: string, operation: ApiOperation, tokens: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }, projectId?: string, metadata?: Record<string, unknown>): Promise<TokenUsage>;
+    /**
+     * Получение истории использования
+     */
+    getUsageHistory(userId: string, options: {
+        limit?: number;
+        offset?: number;
+        apiKeyId?: string;
+        operation?: ApiOperation;
+    }): Promise<TokenUsage[]>;
+    /**
+     * Получение статистики использования
+     */
+    getUsageStats(userId: string, period: 'hour' | 'day' | 'week' | 'month'): Promise<UsageStats>;
+    /**
+     * Получение или создание billing account
+     */
+    getBillingAccount(userId: string): Promise<BillingAccount>;
+    /**
+     * Обновление использования в billing account
+     */
+    private updateBillingUsage;
+    /**
+     * Пополнение баланса
+     */
+    addCredits(userId: string, amount: number): Promise<BillingAccount>;
+    /**
+     * Изменение pricing tier
+     */
+    updatePricingTier(userId: string, tier: string): Promise<BillingAccount>;
+    /**
+     * Проверка достаточности баланса
+     */
+    checkBalance(userId: string, estimatedTokens: number): Promise<{
+        allowed: boolean;
+        balance: number;
+        estimatedCost: number;
+        tokensRemaining: number;
+    }>;
+    /**
+     * Проверка rate limit
+     */
+    checkRateLimit(apiKeyId: string, limits: {
+        requestsPerMinute: number;
+        requestsPerDay: number;
+        tokensPerMinute: number;
+        tokensPerDay: number;
+    }): Promise<RateLimitResult>;
+    /**
+     * Инкремент rate limit счётчиков
+     */
+    incrementRateLimit(apiKeyId: string, tokens: number): Promise<void>;
+    /**
+     * Получение текущего состояния rate limit
+     */
+    getRateLimitState(apiKeyId: string): Promise<RateLimitState | null>;
+    /**
+     * Очистка старых записей usage (старше 90 дней)
+     */
+    cleanupOldUsageRecords(): Promise<number>;
+    /**
+     * Сброс месячных лимитов (вызывается в начале месяца)
+     */
+    resetMonthlyLimits(): Promise<void>;
+}
+//# sourceMappingURL=token-service.d.ts.map