archicore 0.1.0

package/dist/pr-guardian/index.d.ts

@@ -0,0 +1,143 @@
+/**
+ * PR Guardian - Pull Request Analysis System
+ *
+ * Анализ Pull Request'ов:
+ * - Оценка риска изменений
+ * - Проверка архитектурных правил
+ * - Рекомендации ревьюверам
+ * - Автоматические проверки качества
+ */
+import { DependencyGraph, Symbol } from '../types/index.js';
+export interface PRAnalysisRequest {
+    changedFiles: ChangedFile[];
+    baseBranch: string;
+    targetBranch: string;
+    author: string;
+    title: string;
+    description?: string;
+}
+export interface ChangedFile {
+    path: string;
+    status: 'added' | 'modified' | 'deleted' | 'renamed';
+    additions: number;
+    deletions: number;
+    oldContent?: string;
+    newContent?: string;
+}
+export interface PRAnalysisResult {
+    score: PRScore;
+    riskLevel: RiskLevel;
+    summary: PRSummary;
+    checks: PRCheck[];
+    suggestions: PRSuggestion[];
+    impactAnalysis: ImpactAnalysis;
+    reviewerGuidance: ReviewerGuidance;
+}
+export interface PRScore {
+    overall: number;
+    security: number;
+    architecture: number;
+    complexity: number;
+    testCoverage: number;
+    documentation: number;
+}
+export type RiskLevel = 'low' | 'medium' | 'high' | 'critical';
+export interface PRSummary {
+    totalFiles: number;
+    additions: number;
+    deletions: number;
+    affectedModules: string[];
+    criticalFilesChanged: boolean;
+    breakingChanges: boolean;
+    estimatedReviewTime: number;
+}
+export interface PRCheck {
+    name: string;
+    status: 'passed' | 'failed' | 'warning';
+    message: string;
+    details?: string;
+}
+export interface PRSuggestion {
+    type: 'improvement' | 'concern' | 'question';
+    priority: 'low' | 'medium' | 'high';
+    file?: string;
+    line?: number;
+    message: string;
+    suggestion?: string;
+}
+export interface ImpactAnalysis {
+    directlyAffected: string[];
+    transitivelyAffected: string[];
+    potentialBreaking: string[];
+    testFilesNeeded: string[];
+}
+export interface ReviewerGuidance {
+    focusAreas: FocusArea[];
+    suggestedReviewers: string[];
+    estimatedComplexity: 'simple' | 'moderate' | 'complex';
+    needsSecurityReview: boolean;
+    needsArchitectureReview: boolean;
+}
+export interface FocusArea {
+    file: string;
+    reason: string;
+    priority: 'high' | 'medium' | 'low';
+}
+export declare class PRGuardian {
+    private securityAnalyzer;
+    private duplicationDetector;
+    constructor();
+    /**
+     * Полный анализ PR
+     */
+    analyze(request: PRAnalysisRequest, graph: DependencyGraph, symbols: Map<string, Symbol>): Promise<PRAnalysisResult>;
+    /**
+     * Быстрая проверка (для CI)
+     */
+    quickCheck(request: PRAnalysisRequest): Promise<{
+        passed: boolean;
+        riskLevel: RiskLevel;
+        blockers: string[];
+    }>;
+    /**
+     * Расчёт сводки PR
+     */
+    private calculateSummary;
+    /**
+     * Детекция breaking changes
+     */
+    private detectBreakingChanges;
+    /**
+     * Анализ влияния изменений
+     */
+    private analyzeImpact;
+    /**
+     * Запуск проверок
+     */
+    private runChecks;
+    /**
+     * Анализ безопасности изменённого кода
+     */
+    private analyzeChangedSecurity;
+    /**
+     * Анализ дублирования в изменениях
+     */
+    private analyzeChangedDuplication;
+    /**
+     * Генерация предложений
+     */
+    private generateSuggestions;
+    /**
+     * Расчёт оценок
+     */
+    private calculateScore;
+    /**
+     * Определение уровня риска
+     */
+    private determineRiskLevel;
+    /**
+     * Генерация руководства для ревьюверов
+     */
+    private generateReviewerGuidance;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/pr-guardian/index.js

@@ -0,0 +1,553 @@
+/**
+ * PR Guardian - Pull Request Analysis System
+ *
+ * Анализ Pull Request'ов:
+ * - Оценка риска изменений
+ * - Проверка архитектурных правил
+ * - Рекомендации ревьюверам
+ * - Автоматические проверки качества
+ */
+import { SecurityAnalyzer } from '../analyzers/security.js';
+import { DuplicationDetector } from '../analyzers/duplication.js';
+import { Logger } from '../utils/logger.js';
+// Критические файлы, требующие особого внимания
+const CRITICAL_FILE_PATTERNS = [
+    /^(package|composer|Cargo|go\.mod|requirements).*\.(json|lock|toml|txt)$/,
+    /\.(env|config|secrets?)(\.\w+)?$/,
+    /auth|security|crypto|password|token/i,
+    /^(\.github|\.gitlab|\.circleci)/,
+    /^(Dockerfile|docker-compose|k8s|kubernetes)/i,
+    /migrations?\//i
+];
+// Файлы, которые обычно не нужно ревьювить детально
+const LOW_PRIORITY_PATTERNS = [
+    /\.(md|txt|rst)$/,
+    /\.(snap|json)$/, // Snapshots, lock files
+    /\.test\.(ts|js|tsx|jsx)$/,
+    /\.spec\.(ts|js|tsx|jsx)$/,
+    /__tests__\//,
+    /\.d\.ts$/
+];
+export class PRGuardian {
+    securityAnalyzer;
+    duplicationDetector;
+    constructor() {
+        this.securityAnalyzer = new SecurityAnalyzer();
+        this.duplicationDetector = new DuplicationDetector();
+    }
+    /**
+     * Полный анализ PR
+     */
+    async analyze(request, graph, symbols) {
+        Logger.progress('Analyzing pull request...');
+        // 1. Базовая сводка
+        const summary = this.calculateSummary(request);
+        // 2. Анализ влияния
+        const impactAnalysis = this.analyzeImpact(request, graph);
+        // 3. Запускаем проверки
+        const checks = await this.runChecks(request, graph, symbols);
+        // 4. Анализ безопасности изменённого кода
+        const securityResult = await this.analyzeChangedSecurity(request);
+        // 5. Проверка дублирования
+        const duplicationResult = await this.analyzeChangedDuplication(request);
+        // 6. Генерируем предложения
+        const suggestions = this.generateSuggestions(request, checks, securityResult, duplicationResult, impactAnalysis);
+        // 7. Рассчитываем оценки
+        const score = this.calculateScore(checks, securityResult, summary);
+        // 8. Определяем уровень риска
+        const riskLevel = this.determineRiskLevel(score, summary, impactAnalysis);
+        // 9. Руководство для ревьюверов
+        const reviewerGuidance = this.generateReviewerGuidance(request, impactAnalysis, score, riskLevel);
+        Logger.success(`PR analysis complete. Risk level: ${riskLevel}`);
+        return {
+            score,
+            riskLevel,
+            summary,
+            checks,
+            suggestions,
+            impactAnalysis,
+            reviewerGuidance
+        };
+    }
+    /**
+     * Быстрая проверка (для CI)
+     */
+    async quickCheck(request) {
+        const summary = this.calculateSummary(request);
+        const securityResult = await this.analyzeChangedSecurity(request);
+        const blockers = [];
+        // Проверяем критические проблемы безопасности
+        if (securityResult.summary.critical > 0) {
+            blockers.push(`${securityResult.summary.critical} critical security issues found`);
+        }
+        // Проверяем захардкоженные секреты
+        if (securityResult.secrets.length > 0) {
+            blockers.push(`${securityResult.secrets.length} hardcoded secrets detected`);
+        }
+        // Слишком большой PR
+        if (summary.totalFiles > 50) {
+            blockers.push('PR is too large (>50 files). Consider splitting.');
+        }
+        // Изменения в критических файлах без описания
+        if (summary.criticalFilesChanged && !request.description) {
+            blockers.push('Critical files changed but no description provided');
+        }
+        const riskLevel = blockers.length > 0 ? 'critical' :
+            summary.criticalFilesChanged ? 'high' :
+                summary.totalFiles > 20 ? 'medium' : 'low';
+        return {
+            passed: blockers.length === 0,
+            riskLevel,
+            blockers
+        };
+    }
+    /**
+     * Расчёт сводки PR
+     */
+    calculateSummary(request) {
+        const additions = request.changedFiles.reduce((sum, f) => sum + f.additions, 0);
+        const deletions = request.changedFiles.reduce((sum, f) => sum + f.deletions, 0);
+        // Определяем затронутые модули
+        const modules = new Set();
+        for (const file of request.changedFiles) {
+            const parts = file.path.split('/');
+            if (parts.length > 1) {
+                modules.add(parts[0]);
+                if (parts.length > 2) {
+                    modules.add(`${parts[0]}/${parts[1]}`);
+                }
+            }
+        }
+        // Проверяем критические файлы
+        const criticalFilesChanged = request.changedFiles.some(f => CRITICAL_FILE_PATTERNS.some(pattern => pattern.test(f.path)));
+        // Проверяем breaking changes (удаление публичных экспортов)
+        const breakingChanges = request.changedFiles.some(f => f.status === 'deleted' ||
+            (f.oldContent && f.newContent && this.detectBreakingChanges(f.oldContent, f.newContent)));
+        // Оценка времени ревью (примерно)
+        const estimatedReviewTime = Math.ceil(request.changedFiles.length * 2 +
+            (additions + deletions) / 50 +
+            (criticalFilesChanged ? 15 : 0) +
+            (breakingChanges ? 10 : 0));
+        return {
+            totalFiles: request.changedFiles.length,
+            additions,
+            deletions,
+            affectedModules: Array.from(modules),
+            criticalFilesChanged,
+            breakingChanges,
+            estimatedReviewTime
+        };
+    }
+    /**
+     * Детекция breaking changes
+     */
+    detectBreakingChanges(oldContent, newContent) {
+        // Ищем удалённые экспорты
+        const exportPattern = /export\s+(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/g;
+        const oldExports = new Set();
+        let match;
+        while ((match = exportPattern.exec(oldContent)) !== null) {
+            oldExports.add(match[1]);
+        }
+        exportPattern.lastIndex = 0;
+        const newExports = new Set();
+        while ((match = exportPattern.exec(newContent)) !== null) {
+            newExports.add(match[1]);
+        }
+        // Проверяем, удалены ли экспорты
+        for (const exp of oldExports) {
+            if (!newExports.has(exp)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Анализ влияния изменений
+     */
+    analyzeImpact(request, graph) {
+        const changedPaths = new Set(request.changedFiles.map(f => f.path));
+        const transitivelyAffected = new Set();
+        const potentialBreaking = new Set();
+        // Находим файлы, зависящие от изменённых
+        for (const [filePath, edges] of graph.edges) {
+            for (const edge of edges) {
+                // Нормализуем путь для сравнения
+                const targetPath = edge.to.replace(/^\.\//, '').replace(/\.\w+$/, '');
+                for (const changed of changedPaths) {
+                    const changedNorm = changed.replace(/\.\w+$/, '');
+                    if (targetPath.includes(changedNorm) || changedNorm.includes(targetPath)) {
+                        if (!changedPaths.has(filePath)) {
+                            transitivelyAffected.add(filePath);
+                            // Если изменённый файл удалён, это breaking
+                            const changedFile = request.changedFiles.find(f => f.path === changed);
+                            if (changedFile?.status === 'deleted') {
+                                potentialBreaking.add(filePath);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Определяем тесты для запуска
+        const testFilesNeeded = new Set();
+        const allAffected = new Set([...changedPaths, ...transitivelyAffected]);
+        for (const [nodeId, node] of graph.nodes) {
+            const isTest = /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(node.filePath);
+            if (!isTest)
+                continue;
+            // Проверяем, тестирует ли этот файл затронутые модули
+            const edges = graph.edges.get(nodeId) || [];
+            for (const edge of edges) {
+                for (const affected of allAffected) {
+                    if (edge.to.includes(affected.replace(/\.\w+$/, ''))) {
+                        testFilesNeeded.add(node.filePath);
+                        break;
+                    }
+                }
+            }
+        }
+        return {
+            directlyAffected: Array.from(changedPaths),
+            transitivelyAffected: Array.from(transitivelyAffected),
+            potentialBreaking: Array.from(potentialBreaking),
+            testFilesNeeded: Array.from(testFilesNeeded)
+        };
+    }
+    /**
+     * Запуск проверок
+     */
+    async runChecks(request, _graph, _symbols) {
+        const checks = [];
+        // 1. Размер PR
+        const totalChanges = request.changedFiles.reduce((sum, f) => sum + f.additions + f.deletions, 0);
+        if (request.changedFiles.length > 30 || totalChanges > 1000) {
+            checks.push({
+                name: 'PR Size',
+                status: 'warning',
+                message: 'Large PR detected',
+                details: `${request.changedFiles.length} files, ${totalChanges} lines changed. Consider splitting.`
+            });
+        }
+        else {
+            checks.push({
+                name: 'PR Size',
+                status: 'passed',
+                message: 'PR size is acceptable'
+            });
+        }
+        // 2. Наличие тестов
+        const hasTests = request.changedFiles.some(f => /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(f.path));
+        const hasCodeChanges = request.changedFiles.some(f => /\.(ts|js|tsx|jsx)$/.test(f.path) &&
+            !/\.(test|spec)\./.test(f.path));
+        if (hasCodeChanges && !hasTests) {
+            checks.push({
+                name: 'Test Coverage',
+                status: 'warning',
+                message: 'No test files changed',
+                details: 'Consider adding tests for the changed code'
+            });
+        }
+        else if (hasTests) {
+            checks.push({
+                name: 'Test Coverage',
+                status: 'passed',
+                message: 'Tests are included'
+            });
+        }
+        // 3. Документация для публичных API
+        const publicApiChanged = request.changedFiles.some(f => /index\.(ts|js)$/.test(f.path) ||
+            f.path.includes('api/') ||
+            f.path.includes('public/'));
+        const hasDocChanges = request.changedFiles.some(f => /\.(md|rst|txt)$/.test(f.path) ||
+            f.path.toLowerCase().includes('readme') ||
+            f.path.toLowerCase().includes('doc'));
+        if (publicApiChanged && !hasDocChanges) {
+            checks.push({
+                name: 'Documentation',
+                status: 'warning',
+                message: 'Public API changed without documentation update',
+                details: 'Consider updating relevant documentation'
+            });
+        }
+        else {
+            checks.push({
+                name: 'Documentation',
+                status: 'passed',
+                message: 'Documentation status OK'
+            });
+        }
+        // 4. Конфигурационные файлы
+        const configFiles = request.changedFiles.filter(f => CRITICAL_FILE_PATTERNS.some(p => p.test(f.path)));
+        if (configFiles.length > 0) {
+            checks.push({
+                name: 'Critical Files',
+                status: 'warning',
+                message: `${configFiles.length} critical/config files changed`,
+                details: configFiles.map(f => f.path).join(', ')
+            });
+        }
+        else {
+            checks.push({
+                name: 'Critical Files',
+                status: 'passed',
+                message: 'No critical files changed'
+            });
+        }
+        // 5. Проверка naming conventions
+        const badNaming = request.changedFiles.filter(f => {
+            const fileName = f.path.split('/').pop() || '';
+            // Проверяем snake_case vs camelCase consistency
+            return /[A-Z]/.test(fileName) && fileName.includes('_');
+        });
+        if (badNaming.length > 0) {
+            checks.push({
+                name: 'Naming Conventions',
+                status: 'warning',
+                message: 'Inconsistent file naming detected',
+                details: badNaming.map(f => f.path).join(', ')
+            });
+        }
+        else {
+            checks.push({
+                name: 'Naming Conventions',
+                status: 'passed',
+                message: 'File naming is consistent'
+            });
+        }
+        return checks;
+    }
+    /**
+     * Анализ безопасности изменённого кода
+     */
+    async analyzeChangedSecurity(request) {
+        const fileContents = new Map();
+        for (const file of request.changedFiles) {
+            if (file.newContent) {
+                fileContents.set(file.path, file.newContent);
+            }
+        }
+        return this.securityAnalyzer.analyze(fileContents);
+    }
+    /**
+     * Анализ дублирования в изменениях
+     */
+    async analyzeChangedDuplication(request) {
+        const fileContents = new Map();
+        for (const file of request.changedFiles) {
+            if (file.newContent) {
+                fileContents.set(file.path, file.newContent);
+            }
+        }
+        return this.duplicationDetector.analyze(fileContents);
+    }
+    /**
+     * Генерация предложений
+     */
+    generateSuggestions(request, checks, securityResult, duplicationResult, impactAnalysis) {
+        const suggestions = [];
+        // Предложения на основе проверок
+        for (const check of checks) {
+            if (check.status === 'failed' || check.status === 'warning') {
+                suggestions.push({
+                    type: 'concern',
+                    priority: check.status === 'failed' ? 'high' : 'medium',
+                    message: check.message,
+                    suggestion: check.details
+                });
+            }
+        }
+        // Предложения по безопасности
+        for (const vuln of securityResult.vulnerabilities.slice(0, 5)) {
+            suggestions.push({
+                type: 'concern',
+                priority: vuln.severity === 'critical' ? 'high' : 'medium',
+                file: vuln.file,
+                line: vuln.line,
+                message: `Security: ${vuln.type}`,
+                suggestion: vuln.remediation
+            });
+        }
+        // Предложения по секретам
+        for (const secret of securityResult.secrets) {
+            suggestions.push({
+                type: 'concern',
+                priority: 'high',
+                file: secret.file,
+                line: secret.line,
+                message: `Hardcoded secret detected: ${secret.type}`,
+                suggestion: 'Move to environment variables or secret manager'
+            });
+        }
+        // Предложения по дублированию
+        for (const clone of duplicationResult.clones.slice(0, 3)) {
+            suggestions.push({
+                type: 'improvement',
+                priority: 'medium',
+                file: clone.instances[0]?.file,
+                line: clone.instances[0]?.startLine,
+                message: `Code duplication detected (${clone.linesCount} lines, ${clone.instances.length} instances)`,
+                suggestion: clone.suggestion
+            });
+        }
+        // Предложения по breaking changes
+        if (impactAnalysis.potentialBreaking.length > 0) {
+            suggestions.push({
+                type: 'concern',
+                priority: 'high',
+                message: `Potential breaking changes affecting ${impactAnalysis.potentialBreaking.length} files`,
+                suggestion: 'Ensure backward compatibility or update all affected files'
+            });
+        }
+        // Вопросы для больших изменений
+        const addedFiles = request.changedFiles.filter(f => f.status === 'added');
+        if (addedFiles.length > 5) {
+            suggestions.push({
+                type: 'question',
+                priority: 'medium',
+                message: `${addedFiles.length} new files added`,
+                suggestion: 'Is this new functionality? Should it be a separate PR/module?'
+            });
+        }
+        return suggestions;
+    }
+    /**
+     * Расчёт оценок
+     */
+    calculateScore(checks, securityResult, summary) {
+        // Security score
+        const securityScore = Math.max(0, 100 -
+            securityResult.summary.critical * 30 -
+            securityResult.summary.high * 15 -
+            securityResult.summary.medium * 5 -
+            securityResult.secrets.length * 25);
+        // Architecture score (based on checks)
+        const failedChecks = checks.filter(c => c.status === 'failed').length;
+        const warningChecks = checks.filter(c => c.status === 'warning').length;
+        const architectureScore = Math.max(0, 100 - failedChecks * 20 - warningChecks * 10);
+        // Complexity score (based on size)
+        const complexityScore = Math.max(0, 100 -
+            Math.min(50, summary.totalFiles) -
+            Math.min(30, (summary.additions + summary.deletions) / 100) -
+            (summary.breakingChanges ? 20 : 0));
+        // Test coverage score
+        const testScore = checks.find(c => c.name === 'Test Coverage')?.status === 'passed' ? 100 : 50;
+        // Documentation score
+        const docScore = checks.find(c => c.name === 'Documentation')?.status === 'passed' ? 100 : 60;
+        // Overall score
+        const overall = Math.round(securityScore * 0.3 +
+            architectureScore * 0.25 +
+            complexityScore * 0.2 +
+            testScore * 0.15 +
+            docScore * 0.1);
+        return {
+            overall,
+            security: Math.round(securityScore),
+            architecture: Math.round(architectureScore),
+            complexity: Math.round(complexityScore),
+            testCoverage: Math.round(testScore),
+            documentation: Math.round(docScore)
+        };
+    }
+    /**
+     * Определение уровня риска
+     */
+    determineRiskLevel(score, summary, impactAnalysis) {
+        // Critical risk
+        if (score.security < 50 || impactAnalysis.potentialBreaking.length > 5) {
+            return 'critical';
+        }
+        // High risk
+        if (score.overall < 60 ||
+            summary.criticalFilesChanged ||
+            summary.breakingChanges ||
+            impactAnalysis.transitivelyAffected.length > 20) {
+            return 'high';
+        }
+        // Medium risk
+        if (score.overall < 80 ||
+            summary.totalFiles > 15 ||
+            impactAnalysis.transitivelyAffected.length > 10) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    /**
+     * Генерация руководства для ревьюверов
+     */
+    generateReviewerGuidance(request, impactAnalysis, score, _riskLevel) {
+        const focusAreas = [];
+        // Критические файлы - высокий приоритет
+        for (const file of request.changedFiles) {
+            if (CRITICAL_FILE_PATTERNS.some(p => p.test(file.path))) {
+                focusAreas.push({
+                    file: file.path,
+                    reason: 'Critical/configuration file',
+                    priority: 'high'
+                });
+            }
+        }
+        // Файлы с большим количеством изменений
+        const largeChanges = request.changedFiles
+            .filter(f => f.additions + f.deletions > 100)
+            .filter(f => !LOW_PRIORITY_PATTERNS.some(p => p.test(f.path)));
+        for (const file of largeChanges) {
+            focusAreas.push({
+                file: file.path,
+                reason: `Large changes (${file.additions + file.deletions} lines)`,
+                priority: 'high'
+            });
+        }
+        // Файлы, влияющие на многие другие
+        const highImpactFiles = impactAnalysis.directlyAffected.filter(filePath => {
+            const affected = impactAnalysis.transitivelyAffected.filter(t => t.includes(filePath.replace(/\.\w+$/, '')));
+            return affected.length > 5;
+        });
+        for (const file of highImpactFiles.slice(0, 5)) {
+            if (!focusAreas.some(f => f.file === file)) {
+                focusAreas.push({
+                    file,
+                    reason: 'High impact - many files depend on this',
+                    priority: 'medium'
+                });
+            }
+        }
+        // Определяем сложность
+        let estimatedComplexity;
+        if (request.changedFiles.length <= 3 && score.overall >= 80) {
+            estimatedComplexity = 'simple';
+        }
+        else if (request.changedFiles.length <= 10 && score.overall >= 60) {
+            estimatedComplexity = 'moderate';
+        }
+        else {
+            estimatedComplexity = 'complex';
+        }
+        // Нужен ли security review
+        const needsSecurityReview = score.security < 80 ||
+            request.changedFiles.some(f => /auth|security|crypto|password|token|secret/i.test(f.path));
+        // Нужен ли architecture review
+        const needsArchitectureReview = score.architecture < 80 ||
+            request.changedFiles.some(f => /index\.(ts|js)$/.test(f.path) ||
+                f.path.includes('types/') ||
+                f.path.includes('interfaces/')) ||
+            impactAnalysis.transitivelyAffected.length > 10;
+        // Рекомендуемые ревьюверы (заглушка - в реальности это из git history)
+        const suggestedReviewers = [];
+        const modules = [...new Set(request.changedFiles.map(f => f.path.split('/')[0]))];
+        if (modules.length > 0) {
+            suggestedReviewers.push(`Owner of ${modules[0]} module`);
+        }
+        if (needsSecurityReview) {
+            suggestedReviewers.push('Security team member');
+        }
+        return {
+            focusAreas: focusAreas.slice(0, 10),
+            suggestedReviewers,
+            estimatedComplexity,
+            needsSecurityReview,
+            needsArchitectureReview
+        };
+    }
+}
+//# sourceMappingURL=index.js.map