archicore 0.1.0

package/dist/server/routes/api.js

@@ -0,0 +1,362 @@
+/**
+ * ArchiCore API Routes
+ *
+ * REST API для Architecture Digital Twin
+ */
+import { Router } from 'express';
+import { ProjectService } from '../services/project-service.js';
+import { Logger } from '../../utils/logger.js';
+import { ExportManager } from '../../export/index.js';
+export const apiRouter = Router();
+// Singleton сервиса проектов
+const projectService = new ProjectService();
+/**
+ * GET /api/projects
+ * Получить список проектов
+ */
+apiRouter.get('/projects', async (_req, res) => {
+    try {
+        const projects = await projectService.listProjects();
+        res.json({ projects });
+    }
+    catch (error) {
+        Logger.error('Failed to list projects:', error);
+        res.status(500).json({ error: 'Failed to list projects' });
+    }
+});
+/**
+ * POST /api/projects
+ * Создать/подключить новый проект
+ */
+apiRouter.post('/projects', async (req, res) => {
+    try {
+        const { name, path: projectPath } = req.body;
+        if (!name || !projectPath) {
+            res.status(400).json({ error: 'Name and path are required' });
+            return;
+        }
+        const project = await projectService.createProject(name, projectPath);
+        res.json({ project });
+    }
+    catch (error) {
+        Logger.error('Failed to create project:', error);
+        res.status(500).json({ error: 'Failed to create project' });
+    }
+});
+/**
+ * GET /api/projects/:id
+ * Получить информацию о проекте
+ */
+apiRouter.get('/projects/:id', 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;
+        }
+        res.json({ project });
+    }
+    catch (error) {
+        Logger.error('Failed to get project:', error);
+        res.status(500).json({ error: 'Failed to get project' });
+    }
+});
+/**
+ * POST /api/projects/:id/index
+ * Запустить индексацию проекта
+ */
+apiRouter.post('/projects/:id/index', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const result = await projectService.indexProject(id);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Failed to index project:', error);
+        res.status(500).json({ error: 'Failed to index project' });
+    }
+});
+/**
+ * GET /api/projects/:id/architecture
+ * Получить архитектурную модель (Digital Twin)
+ */
+apiRouter.get('/projects/:id/architecture', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const architecture = await projectService.getArchitecture(id);
+        res.json(architecture);
+    }
+    catch (error) {
+        Logger.error('Failed to get architecture:', error);
+        res.status(500).json({ error: 'Failed to get architecture' });
+    }
+});
+/**
+ * GET /api/projects/:id/graph
+ * Получить граф зависимостей для визуализации
+ */
+apiRouter.get('/projects/:id/graph', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const graph = await projectService.getDependencyGraph(id);
+        res.json(graph);
+    }
+    catch (error) {
+        Logger.error('Failed to get dependency graph:', error);
+        res.status(500).json({ error: 'Failed to get dependency graph' });
+    }
+});
+/**
+ * POST /api/projects/:id/analyze
+ * Анализ влияния изменений
+ */
+apiRouter.post('/projects/:id/analyze', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const { description, files, symbols, type } = req.body;
+        if (!description) {
+            res.status(400).json({ error: 'Description is required' });
+            return;
+        }
+        const impact = await projectService.analyzeImpact(id, {
+            description,
+            files: files || [],
+            symbols: symbols || [],
+            type: type || 'modify'
+        });
+        res.json(impact);
+    }
+    catch (error) {
+        Logger.error('Failed to analyze impact:', error);
+        res.status(500).json({ error: 'Failed to analyze impact' });
+    }
+});
+/**
+ * POST /api/projects/:id/simulate
+ * Симуляция изменения (что будет если...)
+ */
+apiRouter.post('/projects/:id/simulate', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const { change } = req.body;
+        if (!change) {
+            res.status(400).json({ error: 'Change description is required' });
+            return;
+        }
+        const simulation = await projectService.simulateChange(id, change);
+        res.json(simulation);
+    }
+    catch (error) {
+        Logger.error('Failed to simulate change:', error);
+        res.status(500).json({ error: 'Failed to simulate change' });
+    }
+});
+/**
+ * POST /api/projects/:id/search
+ * Семантический поиск по коду
+ */
+apiRouter.post('/projects/:id/search', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const { query, limit = 10 } = req.body;
+        if (!query) {
+            res.status(400).json({ error: 'Query is required' });
+            return;
+        }
+        const results = await projectService.semanticSearch(id, query, limit);
+        res.json({ results });
+    }
+    catch (error) {
+        Logger.error('Failed to search:', error);
+        res.status(500).json({ error: 'Failed to search' });
+    }
+});
+/**
+ * POST /api/projects/:id/ask
+ * Задать вопрос AI-архитектору
+ */
+apiRouter.post('/projects/:id/ask', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const { question, language } = req.body;
+        if (!question) {
+            res.status(400).json({ error: 'Question is required' });
+            return;
+        }
+        const answer = await projectService.askArchitect(id, question, language || 'en');
+        res.json({ answer });
+    }
+    catch (error) {
+        Logger.error('Failed to ask architect:', error);
+        res.status(500).json({ error: 'Failed to ask architect' });
+    }
+});
+/**
+ * GET /api/projects/:id/stats
+ * Получить статистику проекта
+ */
+apiRouter.get('/projects/:id/stats', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const stats = await projectService.getStatistics(id);
+        res.json(stats);
+    }
+    catch (error) {
+        Logger.error('Failed to get stats:', error);
+        res.status(500).json({ error: 'Failed to get statistics' });
+    }
+});
+/**
+ * DELETE /api/projects/:id
+ * Удалить проект
+ */
+apiRouter.delete('/projects/:id', async (req, res) => {
+    try {
+        const { id } = req.params;
+        await projectService.deleteProject(id);
+        res.json({ success: true });
+    }
+    catch (error) {
+        Logger.error('Failed to delete project:', error);
+        res.status(500).json({ error: 'Failed to delete project' });
+    }
+});
+/**
+ * GET /api/projects/:id/metrics
+ * Получить метрики кода
+ */
+apiRouter.get('/projects/:id/metrics', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const metrics = await projectService.getMetrics(id);
+        res.json(metrics);
+    }
+    catch (error) {
+        Logger.error('Failed to get metrics:', error);
+        res.status(500).json({ error: 'Failed to get metrics' });
+    }
+});
+/**
+ * GET /api/projects/:id/rules
+ * Проверить правила архитектуры
+ */
+apiRouter.get('/projects/:id/rules', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const result = await projectService.checkRules(id);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Failed to check rules:', error);
+        res.status(500).json({ error: 'Failed to check rules' });
+    }
+});
+/**
+ * GET /api/projects/:id/dead-code
+ * Найти мёртвый код
+ */
+apiRouter.get('/projects/:id/dead-code', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const result = await projectService.findDeadCode(id);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Failed to find dead code:', error);
+        res.status(500).json({ error: 'Failed to find dead code' });
+    }
+});
+/**
+ * GET /api/projects/:id/duplication
+ * Найти дублирование кода
+ */
+apiRouter.get('/projects/:id/duplication', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const result = await projectService.findDuplication(id);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Failed to find duplication:', error);
+        res.status(500).json({ error: 'Failed to find duplication' });
+    }
+});
+/**
+ * GET /api/projects/:id/security
+ * Анализ безопасности
+ */
+apiRouter.get('/projects/:id/security', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const result = await projectService.analyzeSecurity(id);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Failed to analyze security:', error);
+        res.status(500).json({ error: 'Failed to analyze security' });
+    }
+});
+/**
+ * GET /api/projects/:id/refactoring
+ * Получить предложения по рефакторингу
+ */
+apiRouter.get('/projects/:id/refactoring', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const result = await projectService.getRefactoringSuggestions(id);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Failed to get refactoring suggestions:', error);
+        res.status(500).json({ error: 'Failed to get refactoring suggestions' });
+    }
+});
+/**
+ * POST /api/projects/:id/export
+ * Экспорт данных проекта
+ */
+apiRouter.post('/projects/:id/export', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const options = req.body;
+        if (!options.format) {
+            res.status(400).json({ error: 'Format is required' });
+            return;
+        }
+        const exportData = await projectService.getExportData(id);
+        const exportManager = new ExportManager();
+        const result = await exportManager.export(exportData, options);
+        // Устанавливаем правильный content-type
+        const contentTypes = {
+            json: 'application/json',
+            html: 'text/html',
+            markdown: 'text/markdown',
+            csv: 'text/csv',
+            graphml: 'application/xml'
+        };
+        res.setHeader('Content-Type', contentTypes[options.format] || 'text/plain');
+        res.setHeader('Content-Disposition', `attachment; filename="archicore-export.${options.format === 'markdown' ? 'md' : options.format}"`);
+        res.send(result);
+    }
+    catch (error) {
+        Logger.error('Failed to export:', error);
+        res.status(500).json({ error: 'Failed to export' });
+    }
+});
+/**
+ * POST /api/projects/:id/full-analysis
+ * Полный анализ проекта (все анализаторы)
+ */
+apiRouter.post('/projects/:id/full-analysis', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const result = await projectService.runFullAnalysis(id);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Failed to run full analysis:', error);
+        res.status(500).json({ error: 'Failed to run full analysis' });
+    }
+});
+//# sourceMappingURL=api.js.map

package/dist/server/routes/auth.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Authentication API Routes for ArchiCore
+ */
+import { Request, Response, NextFunction } from 'express';
+import { User } from '../../types/user.js';
+export declare const authRouter: import("express-serve-static-core").Router;
+declare global {
+    namespace Express {
+        interface Request {
+            user?: User;
+        }
+    }
+}
+export declare function authMiddleware(req: Request, res: Response, next: NextFunction): Promise<void>;
+export declare function adminMiddleware(req: Request, res: Response, next: NextFunction): Promise<void>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/server/routes/auth.js

@@ -0,0 +1,191 @@
+/**
+ * Authentication API Routes for ArchiCore
+ */
+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();
+// Middleware to check authentication
+export async function authMiddleware(req, res, next) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        res.status(401).json({ error: 'No token provided' });
+        return;
+    }
+    const token = authHeader.substring(7);
+    const user = await authService.validateToken(token);
+    if (!user) {
+        res.status(401).json({ error: 'Invalid or expired token' });
+        return;
+    }
+    req.user = user;
+    next();
+}
+// Middleware to check admin role
+export async function adminMiddleware(req, res, next) {
+    if (!req.user || req.user.tier !== 'admin') {
+        res.status(403).json({ error: 'Admin access required' });
+        return;
+    }
+    next();
+}
+/**
+ * POST /api/auth/register
+ * Register new user
+ */
+authRouter.post('/register', async (req, res) => {
+    try {
+        const { email, username, password } = req.body;
+        if (!email || !username || !password) {
+            res.status(400).json({ success: false, error: 'Email, username, and password are required' });
+            return;
+        }
+        if (password.length < 8) {
+            res.status(400).json({ success: false, error: 'Password must be at least 8 characters' });
+            return;
+        }
+        const result = await authService.register(email, username, password);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Registration error:', error);
+        res.status(500).json({ success: false, error: 'Registration failed' });
+    }
+});
+/**
+ * POST /api/auth/login
+ * Login with email/password
+ */
+authRouter.post('/login', async (req, res) => {
+    try {
+        const { email, password } = req.body;
+        if (!email || !password) {
+            res.status(400).json({ success: false, error: 'Email and password are required' });
+            return;
+        }
+        const result = await authService.login(email, password);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Login error:', error);
+        res.status(500).json({ success: false, error: 'Login failed' });
+    }
+});
+/**
+ * POST /api/auth/logout
+ * Logout current user
+ */
+authRouter.post('/logout', authMiddleware, async (req, res) => {
+    try {
+        const token = req.headers.authorization?.substring(7);
+        if (token) {
+            await authService.logout(token);
+        }
+        res.json({ success: true });
+    }
+    catch (error) {
+        Logger.error('Logout error:', error);
+        res.status(500).json({ success: false, error: 'Logout failed' });
+    }
+});
+/**
+ * GET /api/auth/me
+ * Get current user info
+ */
+authRouter.get('/me', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        // Remove sensitive data
+        const { passwordHash, ...user } = req.user;
+        res.json({ user });
+    }
+    catch (error) {
+        Logger.error('Get user error:', error);
+        res.status(500).json({ error: 'Failed to get user info' });
+    }
+});
+/**
+ * PUT /api/auth/me
+ * Update current user profile
+ */
+authRouter.put('/me', authMiddleware, async (req, res) => {
+    try {
+        const { username, email, avatar } = req.body;
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const updated = await authService.updateUser(req.user.id, { username, email, avatar });
+        if (!updated) {
+            res.status(400).json({ error: 'Failed to update profile' });
+            return;
+        }
+        const user = await authService.getUser(req.user.id);
+        if (user) {
+            const { passwordHash, ...sanitized } = user;
+            res.json({ success: true, user: sanitized });
+        }
+        else {
+            res.status(404).json({ error: 'User not found' });
+        }
+    }
+    catch (error) {
+        Logger.error('Update user error:', error);
+        res.status(500).json({ error: 'Failed to update profile' });
+    }
+});
+/**
+ * POST /api/auth/oauth/:provider
+ * OAuth login (GitHub, Google)
+ */
+authRouter.post('/oauth/:provider', async (req, res) => {
+    try {
+        const { provider } = req.params;
+        const { profile } = req.body;
+        if (provider !== 'github' && provider !== 'google') {
+            res.status(400).json({ success: false, error: 'Invalid provider' });
+            return;
+        }
+        if (!profile || !profile.id || !profile.email) {
+            res.status(400).json({ success: false, error: 'Invalid profile data' });
+            return;
+        }
+        const result = await authService.oauthLogin(provider, profile);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('OAuth error:', error);
+        res.status(500).json({ success: false, error: 'OAuth login failed' });
+    }
+});
+/**
+ * GET /api/auth/usage
+ * Get current user's usage stats
+ */
+authRouter.get('/usage', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const user = await authService.getUser(req.user.id);
+        if (!user) {
+            res.status(404).json({ error: 'User not found' });
+            return;
+        }
+        res.json({
+            tier: user.tier,
+            usage: user.usage,
+            subscription: user.subscription
+        });
+    }
+    catch (error) {
+        Logger.error('Get usage error:', error);
+        res.status(500).json({ error: 'Failed to get usage' });
+    }
+});
+//# sourceMappingURL=auth.js.map

package/dist/server/routes/developer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Developer API Routes for ArchiCore
+ *
+ * REST API для разработчиков с токенизированной тарификацией
+ * Формат ответов совместим с OpenAI/Anthropic API
+ */
+export declare const developerRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=developer.d.ts.map