archicore 0.1.0

package/dist/server/routes/developer.js

@@ -0,0 +1,439 @@
+/**
+ * Developer API Routes for ArchiCore
+ *
+ * REST API для разработчиков с токенизированной тарификацией
+ * Формат ответов совместим с OpenAI/Anthropic API
+ */
+import { Router } from 'express';
+import { ApiKeyService } from '../services/api-key-service.js';
+import { TokenService } from '../services/token-service.js';
+import { ProjectService } from '../services/project-service.js';
+import { authMiddleware } from './auth.js';
+import { apiKeyAuth, requirePermission, trackUsage, apiErrorHandler } from '../middleware/api-auth.js';
+import { Logger } from '../../utils/logger.js';
+export const developerRouter = Router();
+// Services
+const apiKeyService = new ApiKeyService();
+const tokenService = new TokenService();
+const projectService = new ProjectService();
+// ========================================
+// API KEY MANAGEMENT (requires user auth)
+// ========================================
+/**
+ * POST /api/developer/keys
+ * Создание нового API ключа
+ */
+developerRouter.post('/keys', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: { message: 'Not authenticated' } });
+            return;
+        }
+        const request = {
+            name: req.body.name || 'Default Key',
+            permissions: req.body.permissions,
+            expiresIn: req.body.expiresIn,
+            rateLimit: req.body.rateLimit
+        };
+        const result = await apiKeyService.createKey(req.user.id, request);
+        if (!result.success) {
+            res.status(400).json({ error: { message: result.error } });
+            return;
+        }
+        res.status(201).json({
+            success: true,
+            data: result.apiKey,
+            message: 'API key created successfully. Save the key now - it will not be shown again!'
+        });
+    }
+    catch (error) {
+        Logger.error('Create API key error:', error);
+        res.status(500).json({ error: { message: 'Failed to create API key' } });
+    }
+});
+/**
+ * GET /api/developer/keys
+ * Получение списка API ключей
+ */
+developerRouter.get('/keys', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: { message: 'Not authenticated' } });
+            return;
+        }
+        const result = await apiKeyService.listKeys(req.user.id);
+        res.json({ success: true, data: result.keys });
+    }
+    catch (error) {
+        Logger.error('List API keys error:', error);
+        res.status(500).json({ error: { message: 'Failed to list API keys' } });
+    }
+});
+/**
+ * DELETE /api/developer/keys/:keyId
+ * Удаление API ключа
+ */
+developerRouter.delete('/keys/:keyId', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: { message: 'Not authenticated' } });
+            return;
+        }
+        const deleted = await apiKeyService.deleteKey(req.params.keyId, req.user.id);
+        if (!deleted) {
+            res.status(404).json({ error: { message: 'API key not found' } });
+            return;
+        }
+        res.json({ success: true, message: 'API key deleted' });
+    }
+    catch (error) {
+        Logger.error('Delete API key error:', error);
+        res.status(500).json({ error: { message: 'Failed to delete API key' } });
+    }
+});
+/**
+ * POST /api/developer/keys/:keyId/revoke
+ * Отзыв API ключа (деактивация без удаления)
+ */
+developerRouter.post('/keys/:keyId/revoke', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: { message: 'Not authenticated' } });
+            return;
+        }
+        const revoked = await apiKeyService.revokeKey(req.params.keyId, req.user.id);
+        if (!revoked) {
+            res.status(404).json({ error: { message: 'API key not found' } });
+            return;
+        }
+        res.json({ success: true, message: 'API key revoked' });
+    }
+    catch (error) {
+        Logger.error('Revoke API key error:', error);
+        res.status(500).json({ error: { message: 'Failed to revoke API key' } });
+    }
+});
+// ========================================
+// USAGE & BILLING (requires user auth)
+// ========================================
+/**
+ * GET /api/developer/usage
+ * Получение статистики использования
+ */
+developerRouter.get('/usage', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: { message: 'Not authenticated' } });
+            return;
+        }
+        const period = req.query.period || 'month';
+        const stats = await tokenService.getUsageStats(req.user.id, period);
+        const billing = await tokenService.getBillingAccount(req.user.id);
+        res.json({
+            success: true,
+            data: {
+                stats,
+                billing: {
+                    tier: billing.pricingTier,
+                    balance: billing.balance / 100, // в долларах
+                    tokensUsed: billing.tokensUsedThisMonth,
+                    tokensIncluded: billing.tokensIncludedThisMonth,
+                    tokensRemaining: Math.max(0, billing.tokensIncludedThisMonth - billing.tokensUsedThisMonth),
+                    billingCycleEnd: billing.billingCycleEnd
+                }
+            }
+        });
+    }
+    catch (error) {
+        Logger.error('Get usage error:', error);
+        res.status(500).json({ error: { message: 'Failed to get usage stats' } });
+    }
+});
+/**
+ * GET /api/developer/usage/history
+ * История использования
+ */
+developerRouter.get('/usage/history', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: { message: 'Not authenticated' } });
+            return;
+        }
+        const history = await tokenService.getUsageHistory(req.user.id, {
+            limit: parseInt(req.query.limit) || 100,
+            offset: parseInt(req.query.offset) || 0,
+            apiKeyId: req.query.keyId,
+            operation: req.query.operation
+        });
+        res.json({ success: true, data: history });
+    }
+    catch (error) {
+        Logger.error('Get usage history error:', error);
+        res.status(500).json({ error: { message: 'Failed to get usage history' } });
+    }
+});
+/**
+ * POST /api/developer/billing/credits
+ * Пополнение баланса (интеграция с платёжной системой)
+ */
+developerRouter.post('/billing/credits', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: { message: 'Not authenticated' } });
+            return;
+        }
+        const { amount } = req.body; // в центах
+        if (!amount || amount < 500) { // минимум $5
+            res.status(400).json({ error: { message: 'Minimum amount is $5 (500 cents)' } });
+            return;
+        }
+        // TODO: Интеграция с Stripe/PayPal
+        // Сейчас просто добавляем кредиты
+        const billing = await tokenService.addCredits(req.user.id, amount);
+        res.json({
+            success: true,
+            data: {
+                newBalance: billing.balance / 100,
+                message: 'Credits added successfully'
+            }
+        });
+    }
+    catch (error) {
+        Logger.error('Add credits error:', error);
+        res.status(500).json({ error: { message: 'Failed to add credits' } });
+    }
+});
+// ========================================
+// PUBLIC API (requires API key)
+// ========================================
+/**
+ * POST /api/v1/projects
+ * Создание проекта через API
+ */
+developerRouter.post('/v1/projects', apiKeyAuth, requirePermission('write:projects'), trackUsage('index'), async (req, res) => {
+    try {
+        const { name, repositoryUrl, localPath } = req.body;
+        if (!name) {
+            res.status(400).json({ error: { message: 'Project name is required' } });
+            return;
+        }
+        // Для API создаём проект по URL или пути
+        const project = await projectService.createProject(name, localPath || repositoryUrl);
+        res.status(201).json({
+            success: true,
+            data: { project }
+        });
+    }
+    catch (error) {
+        Logger.error('Create project error:', error);
+        res.status(500).json({ error: { message: 'Failed to create project' } });
+    }
+});
+/**
+ * GET /api/v1/projects
+ * Список проектов
+ */
+developerRouter.get('/v1/projects', apiKeyAuth, requirePermission('read:projects'), async (_req, res) => {
+    try {
+        const projects = await projectService.listProjects();
+        res.json({ success: true, data: { projects } });
+    }
+    catch (error) {
+        Logger.error('List projects error:', error);
+        res.status(500).json({ error: { message: 'Failed to list projects' } });
+    }
+});
+/**
+ * POST /api/v1/projects/:id/index
+ * Индексация проекта
+ */
+developerRouter.post('/v1/projects/:id/index', apiKeyAuth, requirePermission('write:projects'), trackUsage('index'), async (req, res) => {
+    try {
+        const result = await projectService.indexProject(req.params.id);
+        res.json({ success: true, data: result });
+    }
+    catch (error) {
+        Logger.error('Index project error:', error);
+        res.status(500).json({ error: { message: 'Failed to index project' } });
+    }
+});
+/**
+ * POST /api/v1/analyze/impact
+ * Анализ влияния изменений
+ */
+developerRouter.post('/v1/analyze/impact', apiKeyAuth, requirePermission('analyze:impact'), trackUsage('analyze'), async (req, res) => {
+    try {
+        const { projectId, description, files, symbols, type } = req.body;
+        if (!projectId || !description) {
+            res.status(400).json({
+                error: { message: 'projectId and description are required' }
+            });
+            return;
+        }
+        const impact = await projectService.analyzeImpact(projectId, {
+            description,
+            files: files || [],
+            symbols: symbols || [],
+            type: type || 'modify'
+        });
+        res.json({ success: true, data: impact });
+    }
+    catch (error) {
+        Logger.error('Analyze impact error:', error);
+        res.status(500).json({ error: { message: 'Failed to analyze impact' } });
+    }
+});
+/**
+ * POST /api/v1/analyze/security
+ * Анализ безопасности
+ */
+developerRouter.post('/v1/analyze/security', apiKeyAuth, requirePermission('analyze:security'), trackUsage('analyze'), async (req, res) => {
+    try {
+        const { projectId } = req.body;
+        if (!projectId) {
+            res.status(400).json({ error: { message: 'projectId is required' } });
+            return;
+        }
+        const result = await projectService.analyzeSecurity(projectId);
+        res.json({ success: true, data: result });
+    }
+    catch (error) {
+        Logger.error('Analyze security error:', error);
+        res.status(500).json({ error: { message: 'Failed to analyze security' } });
+    }
+});
+/**
+ * POST /api/v1/analyze/full
+ * Полный анализ проекта
+ */
+developerRouter.post('/v1/analyze/full', apiKeyAuth, requirePermission('analyze:full'), trackUsage('analyze'), async (req, res) => {
+    try {
+        const { projectId } = req.body;
+        if (!projectId) {
+            res.status(400).json({ error: { message: 'projectId is required' } });
+            return;
+        }
+        const result = await projectService.runFullAnalysis(projectId);
+        res.json({ success: true, data: result });
+    }
+    catch (error) {
+        Logger.error('Full analysis error:', error);
+        res.status(500).json({ error: { message: 'Failed to run full analysis' } });
+    }
+});
+/**
+ * POST /api/v1/search
+ * Семантический поиск
+ */
+developerRouter.post('/v1/search', apiKeyAuth, requirePermission('search:semantic'), trackUsage('search'), async (req, res) => {
+    try {
+        const { projectId, query, limit } = req.body;
+        if (!projectId || !query) {
+            res.status(400).json({
+                error: { message: 'projectId and query are required' }
+            });
+            return;
+        }
+        const results = await projectService.semanticSearch(projectId, query, limit || 10);
+        res.json({ success: true, data: { results } });
+    }
+    catch (error) {
+        Logger.error('Semantic search error:', error);
+        res.status(500).json({ error: { message: 'Failed to search' } });
+    }
+});
+/**
+ * POST /api/v1/ask
+ * Вопрос архитектору
+ */
+developerRouter.post('/v1/ask', apiKeyAuth, requirePermission('ask:architect'), trackUsage('ask'), async (req, res) => {
+    try {
+        const { projectId, question, language } = req.body;
+        if (!projectId || !question) {
+            res.status(400).json({
+                error: { message: 'projectId and question are required' }
+            });
+            return;
+        }
+        const answer = await projectService.askArchitect(projectId, question, language || 'en');
+        res.json({
+            success: true,
+            data: {
+                question,
+                answer,
+                model: 'archicore-v1'
+            }
+        });
+    }
+    catch (error) {
+        Logger.error('Ask architect error:', error);
+        res.status(500).json({ error: { message: 'Failed to process question' } });
+    }
+});
+/**
+ * GET /api/v1/projects/:id/architecture
+ * Получение архитектурной модели
+ */
+developerRouter.get('/v1/projects/:id/architecture', apiKeyAuth, requirePermission('read:projects'), async (req, res) => {
+    try {
+        const architecture = await projectService.getArchitecture(req.params.id);
+        res.json({ success: true, data: architecture });
+    }
+    catch (error) {
+        Logger.error('Get architecture error:', error);
+        res.status(500).json({ error: { message: 'Failed to get architecture' } });
+    }
+});
+/**
+ * GET /api/v1/projects/:id/graph
+ * Получение графа зависимостей
+ */
+developerRouter.get('/v1/projects/:id/graph', apiKeyAuth, requirePermission('read:projects'), async (req, res) => {
+    try {
+        const graph = await projectService.getDependencyGraph(req.params.id);
+        res.json({ success: true, data: graph });
+    }
+    catch (error) {
+        Logger.error('Get graph error:', error);
+        res.status(500).json({ error: { message: 'Failed to get dependency graph' } });
+    }
+});
+/**
+ * GET /api/v1/projects/:id/metrics
+ * Получение метрик
+ */
+developerRouter.get('/v1/projects/:id/metrics', apiKeyAuth, requirePermission('read:projects'), async (req, res) => {
+    try {
+        const metrics = await projectService.getMetrics(req.params.id);
+        res.json({ success: true, data: metrics });
+    }
+    catch (error) {
+        Logger.error('Get metrics error:', error);
+        res.status(500).json({ error: { message: 'Failed to get metrics' } });
+    }
+});
+/**
+ * POST /api/v1/export
+ * Экспорт данных
+ */
+developerRouter.post('/v1/export', apiKeyAuth, requirePermission('export:data'), trackUsage('export'), async (req, res) => {
+    try {
+        const { projectId, format } = req.body;
+        if (!projectId || !format) {
+            res.status(400).json({
+                error: { message: 'projectId and format are required' }
+            });
+            return;
+        }
+        const exportData = await projectService.getExportData(projectId);
+        // Здесь можно добавить разные форматы экспорта
+        res.json({ success: true, data: exportData });
+    }
+    catch (error) {
+        Logger.error('Export error:', error);
+        res.status(500).json({ error: { message: 'Failed to export data' } });
+    }
+});
+// Error handler
+developerRouter.use(apiErrorHandler);
+//# sourceMappingURL=developer.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * GitHub Integration Routes for ArchiCore
+ *
+ * OAuth flow, repository management, webhooks
+ */
+export declare const githubRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=github.d.ts.map