archicore 0.1.0

package/dist/github/github-service.js

@@ -0,0 +1,609 @@
+/**
+ * GitHub Service for ArchiCore
+ *
+ * Handles OAuth, API calls, webhooks, and repository management
+ */
+import { randomBytes, createHash, createHmac, createCipheriv, createDecipheriv } from 'crypto';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { Logger } from '../utils/logger.js';
+const DATA_DIR = '.archicore';
+const CONNECTIONS_FILE = 'github-connections.json';
+const REPOSITORIES_FILE = 'github-repositories.json';
+// Encryption key (in production, use env variable)
+const ENCRYPTION_KEY = process.env.GITHUB_ENCRYPTION_KEY || 'archicore-github-key-32bytes!!';
+export class GitHubService {
+    dataDir;
+    connections = [];
+    repositories = [];
+    initialized = false;
+    clientId;
+    clientSecret;
+    redirectUri;
+    webhookBaseUrl;
+    constructor(dataDir = DATA_DIR) {
+        this.dataDir = dataDir;
+        this.clientId = process.env.GITHUB_CLIENT_ID || '';
+        this.clientSecret = process.env.GITHUB_CLIENT_SECRET || '';
+        this.redirectUri = process.env.GITHUB_REDIRECT_URI || 'http://localhost:3000/api/github/callback';
+        this.webhookBaseUrl = process.env.ARCHICORE_WEBHOOK_URL || 'http://localhost:3000/api/github/webhook';
+    }
+    async ensureInitialized() {
+        if (this.initialized)
+            return;
+        try {
+            await mkdir(this.dataDir, { recursive: true });
+        }
+        catch { }
+        // Load connections
+        try {
+            const path = join(this.dataDir, CONNECTIONS_FILE);
+            const data = await readFile(path, 'utf-8');
+            const parsed = JSON.parse(data);
+            this.connections = parsed.connections || [];
+        }
+        catch {
+            this.connections = [];
+        }
+        // Load repositories
+        try {
+            const path = join(this.dataDir, REPOSITORIES_FILE);
+            const data = await readFile(path, 'utf-8');
+            const parsed = JSON.parse(data);
+            this.repositories = parsed.repositories || [];
+        }
+        catch {
+            this.repositories = [];
+        }
+        this.initialized = true;
+    }
+    async saveConnections() {
+        const path = join(this.dataDir, CONNECTIONS_FILE);
+        await writeFile(path, JSON.stringify({ connections: this.connections }, null, 2));
+    }
+    async saveRepositories() {
+        const path = join(this.dataDir, REPOSITORIES_FILE);
+        await writeFile(path, JSON.stringify({ repositories: this.repositories }, null, 2));
+    }
+    // ===== ENCRYPTION =====
+    encrypt(text) {
+        const iv = randomBytes(16);
+        const key = createHash('sha256').update(ENCRYPTION_KEY).digest();
+        const cipher = createCipheriv('aes-256-cbc', key, iv);
+        let encrypted = cipher.update(text, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return iv.toString('hex') + ':' + encrypted;
+    }
+    decrypt(encrypted) {
+        const parts = encrypted.split(':');
+        const iv = Buffer.from(parts[0], 'hex');
+        const key = createHash('sha256').update(ENCRYPTION_KEY).digest();
+        const decipher = createDecipheriv('aes-256-cbc', key, iv);
+        let decrypted = decipher.update(parts[1], 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+    // ===== OAUTH =====
+    /**
+     * Generate OAuth authorization URL
+     */
+    getAuthorizationUrl(state) {
+        const scopes = ['repo', 'read:user', 'user:email', 'write:repo_hook'];
+        const params = new URLSearchParams({
+            client_id: this.clientId,
+            redirect_uri: this.redirectUri,
+            scope: scopes.join(' '),
+            state,
+            allow_signup: 'true'
+        });
+        return `https://github.com/login/oauth/authorize?${params.toString()}`;
+    }
+    /**
+     * Exchange authorization code for access token
+     */
+    async exchangeCodeForToken(code) {
+        const response = await fetch('https://github.com/login/oauth/access_token', {
+            method: 'POST',
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                client_id: this.clientId,
+                client_secret: this.clientSecret,
+                code,
+                redirect_uri: this.redirectUri
+            })
+        });
+        if (!response.ok) {
+            throw new Error('Failed to exchange code for token');
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(data.error_description || data.error);
+        }
+        return data;
+    }
+    /**
+     * Get authenticated GitHub user
+     */
+    async getGitHubUser(accessToken) {
+        const response = await fetch('https://api.github.com/user', {
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore'
+            }
+        });
+        if (!response.ok) {
+            throw new Error('Failed to get GitHub user');
+        }
+        return response.json();
+    }
+    /**
+     * Save GitHub connection for user
+     */
+    async saveConnection(userId, tokenResponse, githubUser) {
+        await this.ensureInitialized();
+        // Remove existing connection for this user
+        this.connections = this.connections.filter(c => c.userId !== userId);
+        const connection = {
+            id: 'ghc_' + randomBytes(12).toString('hex'),
+            userId,
+            githubUserId: githubUser.id,
+            githubUsername: githubUser.login,
+            accessToken: this.encrypt(tokenResponse.access_token),
+            refreshToken: tokenResponse.refresh_token ? this.encrypt(tokenResponse.refresh_token) : undefined,
+            tokenExpiresAt: tokenResponse.expires_in
+                ? new Date(Date.now() + tokenResponse.expires_in * 1000)
+                : undefined,
+            scope: tokenResponse.scope.split(','),
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+        this.connections.push(connection);
+        await this.saveConnections();
+        Logger.info(`GitHub connected for user ${userId}: ${githubUser.login}`);
+        return connection;
+    }
+    /**
+     * Get connection for user
+     */
+    async getConnection(userId) {
+        await this.ensureInitialized();
+        return this.connections.find(c => c.userId === userId) || null;
+    }
+    /**
+     * Get decrypted access token
+     */
+    async getAccessToken(userId) {
+        const connection = await this.getConnection(userId);
+        if (!connection)
+            return null;
+        return this.decrypt(connection.accessToken);
+    }
+    /**
+     * Disconnect GitHub
+     */
+    async disconnect(userId) {
+        await this.ensureInitialized();
+        const connection = this.connections.find(c => c.userId === userId);
+        if (!connection)
+            return false;
+        // Remove all connected repositories
+        const userRepos = this.repositories.filter(r => r.userId === userId);
+        for (const repo of userRepos) {
+            if (repo.webhookId) {
+                try {
+                    await this.deleteWebhook(userId, repo.fullName, repo.webhookId);
+                }
+                catch (e) {
+                    Logger.warn(`Failed to delete webhook for ${repo.fullName}`);
+                }
+            }
+        }
+        this.repositories = this.repositories.filter(r => r.userId !== userId);
+        this.connections = this.connections.filter(c => c.userId !== userId);
+        await this.saveConnections();
+        await this.saveRepositories();
+        Logger.info(`GitHub disconnected for user ${userId}`);
+        return true;
+    }
+    // ===== REPOSITORIES =====
+    /**
+     * List user's GitHub repositories
+     */
+    async listUserRepositories(userId) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        const repos = [];
+        let page = 1;
+        const perPage = 100;
+        while (true) {
+            const response = await fetch(`https://api.github.com/user/repos?per_page=${perPage}&page=${page}&sort=updated`, {
+                headers: {
+                    'Authorization': `Bearer ${accessToken}`,
+                    'Accept': 'application/vnd.github.v3+json',
+                    'User-Agent': 'ArchiCore'
+                }
+            });
+            if (!response.ok) {
+                throw new Error('Failed to list repositories');
+            }
+            const data = await response.json();
+            repos.push(...data);
+            if (data.length < perPage)
+                break;
+            page++;
+        }
+        return repos;
+    }
+    /**
+     * Get repository details
+     */
+    async getRepository(userId, fullName) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        const response = await fetch(`https://api.github.com/repos/${fullName}`, {
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore'
+            }
+        });
+        if (!response.ok) {
+            throw new Error('Failed to get repository');
+        }
+        return response.json();
+    }
+    /**
+     * List repository branches
+     */
+    async listBranches(userId, fullName) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        const response = await fetch(`https://api.github.com/repos/${fullName}/branches`, {
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore'
+            }
+        });
+        if (!response.ok) {
+            throw new Error('Failed to list branches');
+        }
+        return response.json();
+    }
+    /**
+     * Connect repository to ArchiCore
+     */
+    async connectRepository(userId, githubRepoId, options = {}) {
+        await this.ensureInitialized();
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        // Get repository details
+        const repos = await this.listUserRepositories(userId);
+        const githubRepo = repos.find(r => r.id === githubRepoId);
+        if (!githubRepo) {
+            throw new Error('Repository not found or access denied');
+        }
+        // Check if already connected
+        const existing = this.repositories.find(r => r.userId === userId && r.githubRepoId === githubRepoId);
+        if (existing) {
+            throw new Error('Repository already connected');
+        }
+        // Generate webhook secret
+        const webhookSecret = randomBytes(32).toString('hex');
+        // Create webhook
+        let webhookId;
+        try {
+            const webhook = await this.createWebhook(userId, githubRepo.full_name, webhookSecret, ['push', 'pull_request']);
+            webhookId = webhook.id;
+        }
+        catch (e) {
+            Logger.warn(`Failed to create webhook for ${githubRepo.full_name}: ${e}`);
+        }
+        const connection = await this.getConnection(userId);
+        const connectedRepo = {
+            id: 'repo_' + randomBytes(12).toString('hex'),
+            connectionId: connection.id,
+            userId,
+            projectId: options.projectId,
+            githubRepoId,
+            fullName: githubRepo.full_name,
+            name: githubRepo.name,
+            owner: githubRepo.owner.login,
+            private: githubRepo.private,
+            defaultBranch: githubRepo.default_branch,
+            cloneUrl: githubRepo.clone_url,
+            webhookId,
+            webhookSecret: webhookId ? this.encrypt(webhookSecret) : undefined,
+            autoAnalyze: options.autoAnalyze ?? true,
+            analyzePRs: options.analyzePRs ?? true,
+            status: 'active',
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+        this.repositories.push(connectedRepo);
+        await this.saveRepositories();
+        Logger.info(`Repository connected: ${githubRepo.full_name}`);
+        return connectedRepo;
+    }
+    /**
+     * Disconnect repository
+     */
+    async disconnectRepository(userId, repoId) {
+        await this.ensureInitialized();
+        const repo = this.repositories.find(r => r.id === repoId && r.userId === userId);
+        if (!repo)
+            return false;
+        // Delete webhook
+        if (repo.webhookId) {
+            try {
+                await this.deleteWebhook(userId, repo.fullName, repo.webhookId);
+            }
+            catch (e) {
+                Logger.warn(`Failed to delete webhook: ${e}`);
+            }
+        }
+        this.repositories = this.repositories.filter(r => r.id !== repoId);
+        await this.saveRepositories();
+        Logger.info(`Repository disconnected: ${repo.fullName}`);
+        return true;
+    }
+    /**
+     * Get connected repositories for user
+     */
+    async getConnectedRepositories(userId) {
+        await this.ensureInitialized();
+        return this.repositories.filter(r => r.userId === userId);
+    }
+    /**
+     * Get connected repository by ID
+     */
+    async getConnectedRepository(repoId) {
+        await this.ensureInitialized();
+        return this.repositories.find(r => r.id === repoId) || null;
+    }
+    // ===== WEBHOOKS =====
+    /**
+     * Create webhook on repository
+     */
+    async createWebhook(userId, fullName, secret, events) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        const response = await fetch(`https://api.github.com/repos/${fullName}/hooks`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                name: 'web',
+                active: true,
+                events,
+                config: {
+                    url: this.webhookBaseUrl,
+                    content_type: 'json',
+                    secret,
+                    insecure_ssl: '0'
+                }
+            })
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.message || 'Failed to create webhook');
+        }
+        return response.json();
+    }
+    /**
+     * Delete webhook from repository
+     */
+    async deleteWebhook(userId, fullName, webhookId) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken)
+            return;
+        await fetch(`https://api.github.com/repos/${fullName}/hooks/${webhookId}`, {
+            method: 'DELETE',
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore'
+            }
+        });
+    }
+    /**
+     * Verify webhook signature
+     */
+    verifyWebhookSignature(payload, signature, secret) {
+        const hmac = createHmac('sha256', secret);
+        const digest = 'sha256=' + hmac.update(payload).digest('hex');
+        return signature === digest;
+    }
+    /**
+     * Find repository by webhook payload
+     */
+    async findRepositoryByWebhook(fullName) {
+        await this.ensureInitialized();
+        return this.repositories.find(r => r.fullName === fullName) || null;
+    }
+    // ===== PULL REQUESTS =====
+    /**
+     * Get pull request details
+     */
+    async getPullRequest(userId, fullName, prNumber) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        const response = await fetch(`https://api.github.com/repos/${fullName}/pulls/${prNumber}`, {
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore'
+            }
+        });
+        if (!response.ok) {
+            throw new Error('Failed to get pull request');
+        }
+        return response.json();
+    }
+    /**
+     * Get pull request files
+     */
+    async getPullRequestFiles(userId, fullName, prNumber) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        const response = await fetch(`https://api.github.com/repos/${fullName}/pulls/${prNumber}/files`, {
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore'
+            }
+        });
+        if (!response.ok) {
+            throw new Error('Failed to get pull request files');
+        }
+        return response.json();
+    }
+    /**
+     * Post comment on pull request
+     */
+    async postPRComment(userId, fullName, prNumber, body) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        const response = await fetch(`https://api.github.com/repos/${fullName}/issues/${prNumber}/comments`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ body })
+        });
+        if (!response.ok) {
+            throw new Error('Failed to post comment');
+        }
+        return response.json();
+    }
+    /**
+     * Create PR review
+     */
+    async createPRReview(userId, fullName, prNumber, body, event) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        const response = await fetch(`https://api.github.com/repos/${fullName}/pulls/${prNumber}/reviews`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ body, event })
+        });
+        if (!response.ok) {
+            throw new Error('Failed to create review');
+        }
+        return response.json();
+    }
+    // ===== FILE CONTENT =====
+    /**
+     * Get file content from repository
+     */
+    async getFileContent(userId, fullName, path, ref) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        const url = new URL(`https://api.github.com/repos/${fullName}/contents/${path}`);
+        if (ref)
+            url.searchParams.set('ref', ref);
+        const response = await fetch(url.toString(), {
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore'
+            }
+        });
+        if (!response.ok) {
+            throw new Error('Failed to get file content');
+        }
+        const data = await response.json();
+        return Buffer.from(data.content, 'base64').toString('utf-8');
+    }
+    /**
+     * Download repository as zip
+     */
+    async downloadRepository(userId, fullName, ref) {
+        const accessToken = await this.getAccessToken(userId);
+        if (!accessToken) {
+            throw new Error('GitHub not connected');
+        }
+        const url = `https://api.github.com/repos/${fullName}/zipball/${ref || 'HEAD'}`;
+        const response = await fetch(url, {
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'ArchiCore'
+            }
+        });
+        if (!response.ok) {
+            throw new Error('Failed to download repository');
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    // ===== UTILITY =====
+    /**
+     * Check if GitHub is configured
+     */
+    isConfigured() {
+        return !!(this.clientId && this.clientSecret);
+    }
+    /**
+     * Update repository status
+     */
+    async updateRepositoryStatus(repoId, status, error) {
+        await this.ensureInitialized();
+        const repo = this.repositories.find(r => r.id === repoId);
+        if (repo) {
+            repo.status = status;
+            repo.error = error;
+            repo.updatedAt = new Date();
+            await this.saveRepositories();
+        }
+    }
+    /**
+     * Update last analyzed timestamp
+     */
+    async updateLastAnalyzed(repoId) {
+        await this.ensureInitialized();
+        const repo = this.repositories.find(r => r.id === repoId);
+        if (repo) {
+            repo.lastAnalyzedAt = new Date();
+            repo.updatedAt = new Date();
+            await this.saveRepositories();
+        }
+    }
+}
+//# sourceMappingURL=github-service.js.map

package/dist/impact-engine/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Change Impact Engine
+ *
+ * Анализ влияния изменений на кодовую базу:
+ * - Определение затронутых компонентов
+ * - Оценка рисков
+ * - Генерация рекомендаций
+ * - Построение графа влияния
+ */
+import { ChangeImpact, Change, DependencyGraph, Symbol, ArchitectureModel } from '../types/index.js';
+export declare class ImpactEngine {
+    analyzeChange(change: Change, graph: DependencyGraph, symbols: Map<string, Symbol>, architecture?: ArchitectureModel): ChangeImpact;
+    private findAffectedNodes;
+    private getChangedNodes;
+    private traverseDependents;
+    private findDependents;
+    private calculateImpactLevel;
+    private generateImpactReason;
+    private assessRisks;
+    private generateRecommendations;
+    private buildImpactGraph;
+    generateReport(impact: ChangeImpact): string;
+    private groupByImpactLevel;
+}
+//# sourceMappingURL=index.d.ts.map