snow-flow 2.0.5 → 2.0.7

package/dist/coordination/progress-monitor.d.ts

@@ -0,0 +1,71 @@
+import { EventEmitter } from 'eventemitter3';
+import { ProgressStatus, ProgressListener, BaseTeam } from './types';
+import { TaskDependencyGraph } from './task-dependencies';
+export declare class ProgressMonitor extends EventEmitter {
+    private listeners;
+    private monitoringActive;
+    private monitoringInterval?;
+    private agentHealthInterval?;
+    private memoryMonitorInterval?;
+    private progressHistory;
+    private agentMetrics;
+    private bottleneckDetector;
+    private performanceAnalyzer;
+    constructor();
+    startMonitoring(team: BaseTeam, taskGraph: TaskDependencyGraph): Promise<void>;
+    stopMonitoring(): Promise<void>;
+    private monitorTaskProgress;
+    private monitorAgentHealth;
+    private monitorSharedMemory;
+    private monitorPerformance;
+    private detectBottlenecks;
+    private getProgressStatus;
+    private checkAgentHealth;
+    private performAgentHealthCheck;
+    private updateAgentMetrics;
+    private estimateCompletion;
+    private determineCurrentPhase;
+    private gatherMetrics;
+    private analyzeTrends;
+    private calculateProgressRate;
+    private calculateErrorRate;
+    addListener(listener: ProgressListener): void;
+    removeListener(listener: ProgressListener): void;
+    private notifyListeners;
+    getDetailedReport(): Promise<DetailedProgressReport>;
+    private generateTrendSummary;
+    private describeTrend;
+    private generateRecommendations;
+}
+interface AgentMetrics {
+    totalChecks: number;
+    healthyChecks: number;
+    averageResponseTime: number;
+    lastSeen: Date;
+    errors: {
+        timestamp: Date;
+        error: string;
+    }[];
+}
+interface OverallPerformanceMetrics {
+    averageEfficiency: number;
+    averageThroughput: number;
+    bestEfficiency: number;
+    worstEfficiency: number;
+    trend: 'improving' | 'declining' | 'stable' | 'unknown';
+}
+interface DetailedProgressReport {
+    overview: ProgressStatus | null;
+    agentMetrics: Record<string, AgentMetrics>;
+    performanceMetrics: OverallPerformanceMetrics;
+    trends: TrendSummary;
+    recommendations: string[];
+}
+interface TrendSummary {
+    direction: 'improving' | 'declining' | 'stable' | 'unknown';
+    confidence: number;
+    description: string;
+    progressRate?: number;
+}
+export {};
+//# sourceMappingURL=progress-monitor.d.ts.map

package/dist/coordination/progress-monitor.js

@@ -0,0 +1,505 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressMonitor = void 0;
+const eventemitter3_1 = require("eventemitter3");
+const logger_1 = require("../utils/logger");
+class ProgressMonitor extends eventemitter3_1.EventEmitter {
+    constructor() {
+        super();
+        this.listeners = new Set();
+        this.monitoringActive = false;
+        this.progressHistory = [];
+        this.agentMetrics = new Map();
+        this.bottleneckDetector = new BottleneckDetector();
+        this.performanceAnalyzer = new PerformanceAnalyzer();
+        logger_1.logger.info('📊 Progress Monitor initialized');
+    }
+    async startMonitoring(team, taskGraph) {
+        if (this.monitoringActive) {
+            logger_1.logger.warn('⚠️ Progress monitoring already active');
+            return;
+        }
+        this.monitoringActive = true;
+        logger_1.logger.info('📊 Starting comprehensive team progress monitoring');
+        // Start different monitoring aspects
+        await Promise.all([
+            this.monitorTaskProgress(taskGraph),
+            this.monitorAgentHealth(team),
+            this.monitorSharedMemory(),
+            this.monitorPerformance(taskGraph),
+            this.detectBottlenecks(taskGraph)
+        ]);
+        this.emit('monitoring:started', {
+            teamSize: team.agents.size,
+            totalTasks: taskGraph.getTotalTasks()
+        });
+    }
+    async stopMonitoring() {
+        this.monitoringActive = false;
+        if (this.monitoringInterval) {
+            clearInterval(this.monitoringInterval);
+        }
+        if (this.agentHealthInterval) {
+            clearInterval(this.agentHealthInterval);
+        }
+        if (this.memoryMonitorInterval) {
+            clearInterval(this.memoryMonitorInterval);
+        }
+        logger_1.logger.info('🛑 Progress monitoring stopped');
+        this.emit('monitoring:stopped');
+    }
+    async monitorTaskProgress(taskGraph) {
+        this.monitoringInterval = setInterval(async () => {
+            try {
+                const status = await this.getProgressStatus(taskGraph);
+                // Store progress snapshot
+                this.progressHistory.push({
+                    timestamp: new Date(),
+                    status,
+                    metrics: await this.gatherMetrics(taskGraph)
+                });
+                // Keep only last 100 snapshots
+                if (this.progressHistory.length > 100) {
+                    this.progressHistory = this.progressHistory.slice(-100);
+                }
+                // Notify listeners
+                this.notifyListeners('task_progress', status);
+                // Check for completion
+                if (status.completed) {
+                    await this.stopMonitoring();
+                    this.emit('monitoring:completed', status);
+                }
+                // Analyze trends
+                await this.analyzeTrends();
+            }
+            catch (error) {
+                logger_1.logger.error('❌ Task progress monitoring error', { error: error.message });
+            }
+        }, 1000); // Check every second
+    }
+    async monitorAgentHealth(team) {
+        this.agentHealthInterval = setInterval(async () => {
+            try {
+                const healthReport = await this.checkAgentHealth(team);
+                // Update agent metrics
+                for (const [agentId, health] of Object.entries(healthReport.agents)) {
+                    this.updateAgentMetrics(agentId, health);
+                }
+                this.notifyListeners('agent_health', healthReport);
+                // Check for unhealthy agents
+                const unhealthyAgents = Object.entries(healthReport.agents)
+                    .filter(([, health]) => health.status === 'error' || health.responseTime > 30000);
+                if (unhealthyAgents.length > 0) {
+                    this.emit('agents:unhealthy', { agents: unhealthyAgents });
+                    logger_1.logger.warn('⚠️ Unhealthy agents detected', {
+                        count: unhealthyAgents.length,
+                        agents: unhealthyAgents.map(([id]) => id)
+                    });
+                }
+            }
+            catch (error) {
+                logger_1.logger.error('❌ Agent health monitoring error', { error: error.message });
+            }
+        }, 5000); // Check every 5 seconds
+    }
+    async monitorSharedMemory() {
+        this.memoryMonitorInterval = setInterval(async () => {
+            try {
+                // This would integrate with the SharedMemoryManager
+                // For now, we'll simulate memory monitoring
+                const memoryStats = {
+                    usage: Math.random() * 100,
+                    operations: Math.floor(Math.random() * 50),
+                    conflicts: Math.floor(Math.random() * 3)
+                };
+                this.notifyListeners('memory_stats', memoryStats);
+                // Check for memory issues
+                if (memoryStats.usage > 90) {
+                    this.emit('memory:high_usage', memoryStats);
+                    logger_1.logger.warn('⚠️ High memory usage detected', memoryStats);
+                }
+                if (memoryStats.conflicts > 5) {
+                    this.emit('memory:conflicts', memoryStats);
+                    logger_1.logger.warn('⚠️ Memory conflicts detected', memoryStats);
+                }
+            }
+            catch (error) {
+                logger_1.logger.error('❌ Memory monitoring error', { error: error.message });
+            }
+        }, 3000); // Check every 3 seconds
+    }
+    async monitorPerformance(taskGraph) {
+        const performanceCheck = async () => {
+            try {
+                const performance = await this.performanceAnalyzer.analyze(taskGraph);
+                this.notifyListeners('performance_metrics', performance);
+                // Check for performance degradation
+                if (performance.efficiency < 0.5) {
+                    this.emit('performance:degradation', performance);
+                    logger_1.logger.warn('⚠️ Performance degradation detected', performance);
+                }
+            }
+            catch (error) {
+                logger_1.logger.error('❌ Performance monitoring error', { error: error.message });
+            }
+        };
+        // Run performance check every 10 seconds
+        setInterval(performanceCheck, 10000);
+    }
+    async detectBottlenecks(taskGraph) {
+        const bottleneckCheck = async () => {
+            try {
+                const bottlenecks = await this.bottleneckDetector.detect(taskGraph);
+                if (bottlenecks.length > 0) {
+                    this.notifyListeners('bottlenecks_detected', bottlenecks);
+                    this.emit('bottlenecks:detected', { bottlenecks });
+                    logger_1.logger.warn('🚧 Bottlenecks detected', {
+                        count: bottlenecks.length,
+                        types: bottlenecks.map(b => b.type)
+                    });
+                }
+            }
+            catch (error) {
+                logger_1.logger.error('❌ Bottleneck detection error', { error: error.message });
+            }
+        };
+        // Run bottleneck detection every 15 seconds
+        setInterval(bottleneckCheck, 15000);
+    }
+    async getProgressStatus(taskGraph) {
+        const totalTasks = taskGraph.getTotalTasks();
+        const completedTasks = taskGraph.getCompletedTasks();
+        const failedTasks = taskGraph.getFailedTasks();
+        const inProgressTasks = taskGraph.getInProgressTasks();
+        const percentage = totalTasks > 0 ? Math.round((completedTasks.length / totalTasks) * 100) : 0;
+        const estimatedCompletion = this.estimateCompletion(taskGraph);
+        const currentPhase = this.determineCurrentPhase(taskGraph);
+        const bottlenecks = await this.bottleneckDetector.detect(taskGraph);
+        return {
+            total: totalTasks,
+            completed: completedTasks.length,
+            failed: failedTasks.length,
+            inProgress: inProgressTasks.length,
+            percentage,
+            estimated_completion: estimatedCompletion,
+            currentPhase,
+            bottlenecks: bottlenecks.map(b => b.description)
+        };
+    }
+    async checkAgentHealth(team) {
+        const agents = {};
+        let overallHealth = 'healthy';
+        for (const [agentId, agent] of team.agents) {
+            try {
+                const startTime = Date.now();
+                // Simulate health check (in real implementation, this would ping the agent)
+                const healthCheckResult = await this.performAgentHealthCheck(agent);
+                const responseTime = Date.now() - startTime;
+                agents[agentId] = {
+                    status: healthCheckResult.status,
+                    responseTime,
+                    lastActivity: agent.lastActivity,
+                    currentTask: healthCheckResult.currentTask,
+                    memoryUsage: healthCheckResult.memoryUsage,
+                    errorCount: healthCheckResult.errorCount
+                };
+                if (healthCheckResult.status === 'error') {
+                    overallHealth = 'degraded';
+                }
+            }
+            catch (error) {
+                agents[agentId] = {
+                    status: 'error',
+                    responseTime: 0,
+                    lastActivity: agent.lastActivity,
+                    error: error.message
+                };
+                overallHealth = 'degraded';
+            }
+        }
+        return {
+            overall: overallHealth,
+            agents,
+            timestamp: new Date()
+        };
+    }
+    async performAgentHealthCheck(agent) {
+        // Simulate agent health check
+        // In real implementation, this would communicate with the actual agent
+        const isHealthy = Math.random() > 0.1; // 90% healthy
+        return {
+            status: isHealthy ? 'idle' : 'error',
+            currentTask: isHealthy ? null : 'stuck_task',
+            memoryUsage: Math.random() * 100,
+            errorCount: isHealthy ? 0 : Math.floor(Math.random() * 5)
+        };
+    }
+    updateAgentMetrics(agentId, health) {
+        const existing = this.agentMetrics.get(agentId) || {
+            totalChecks: 0,
+            healthyChecks: 0,
+            averageResponseTime: 0,
+            lastSeen: new Date(),
+            errors: []
+        };
+        existing.totalChecks++;
+        if (health.status !== 'error') {
+            existing.healthyChecks++;
+        }
+        if (health.responseTime) {
+            existing.averageResponseTime =
+                (existing.averageResponseTime * (existing.totalChecks - 1) + health.responseTime) / existing.totalChecks;
+        }
+        existing.lastSeen = new Date();
+        if (health.error) {
+            existing.errors.push({
+                timestamp: new Date(),
+                error: health.error
+            });
+            // Keep only last 10 errors
+            if (existing.errors.length > 10) {
+                existing.errors = existing.errors.slice(-10);
+            }
+        }
+        this.agentMetrics.set(agentId, existing);
+    }
+    estimateCompletion(taskGraph) {
+        const inProgressTasks = taskGraph.getInProgressTasks();
+        const pendingTasks = taskGraph.getPendingTasks();
+        if (inProgressTasks.length === 0 && pendingTasks.length === 0) {
+            return new Date(); // Already completed
+        }
+        // Calculate average task duration from completed tasks
+        const completedTasks = taskGraph.getCompletedTasks();
+        const averageDuration = completedTasks.length > 0
+            ? completedTasks.reduce((sum, task) => {
+                const duration = task.endTime && task.startTime
+                    ? task.endTime.getTime() - task.startTime.getTime()
+                    : 60000;
+                return sum + duration;
+            }, 0) / completedTasks.length
+            : 60000; // Default 1 minute
+        // Estimate remaining time
+        const estimatedRemainingTime = (inProgressTasks.length + pendingTasks.length) * averageDuration;
+        return new Date(Date.now() + estimatedRemainingTime);
+    }
+    determineCurrentPhase(taskGraph) {
+        const totalTasks = taskGraph.getTotalTasks();
+        const completedTasks = taskGraph.getCompletedTasks().length;
+        const percentage = totalTasks > 0 ? (completedTasks / totalTasks) * 100 : 0;
+        if (percentage < 25)
+            return 'Initialization';
+        if (percentage < 50)
+            return 'Development';
+        if (percentage < 75)
+            return 'Integration';
+        if (percentage < 90)
+            return 'Testing';
+        if (percentage < 100)
+            return 'Finalization';
+        return 'Completed';
+    }
+    async gatherMetrics(taskGraph) {
+        return {
+            taskMetrics: await taskGraph.getExecutionStats(),
+            agentMetrics: Object.fromEntries(this.agentMetrics),
+            systemMetrics: {
+                timestamp: new Date(),
+                monitoringDuration: this.progressHistory.length * 1000 // milliseconds
+            }
+        };
+    }
+    async analyzeTrends() {
+        if (this.progressHistory.length < 10)
+            return; // Need enough data
+        const recent = this.progressHistory.slice(-10);
+        const progressRate = this.calculateProgressRate(recent);
+        const errorRate = this.calculateErrorRate(recent);
+        // Emit trend analysis
+        this.notifyListeners('trend_analysis', {
+            progressRate,
+            errorRate,
+            trend: progressRate > 0 ? 'improving' : progressRate < 0 ? 'declining' : 'stable'
+        });
+    }
+    calculateProgressRate(snapshots) {
+        if (snapshots.length < 2)
+            return 0;
+        const first = snapshots[0];
+        const last = snapshots[snapshots.length - 1];
+        const timeDiff = last.timestamp.getTime() - first.timestamp.getTime();
+        const progressDiff = last.status.percentage - first.status.percentage;
+        return timeDiff > 0 ? progressDiff / (timeDiff / 1000) : 0; // Progress per second
+    }
+    calculateErrorRate(snapshots) {
+        if (snapshots.length < 2)
+            return 0;
+        const errors = snapshots.reduce((sum, snapshot) => sum + snapshot.status.failed, 0);
+        return errors / snapshots.length;
+    }
+    // Public API methods
+    addListener(listener) {
+        this.listeners.add(listener);
+        logger_1.logger.debug('👂 Progress listener added', { totalListeners: this.listeners.size });
+    }
+    removeListener(listener) {
+        this.listeners.delete(listener);
+        logger_1.logger.debug('👂 Progress listener removed', { totalListeners: this.listeners.size });
+    }
+    notifyListeners(event, data) {
+        this.listeners.forEach(listener => {
+            try {
+                listener.onProgress(event, data);
+            }
+            catch (error) {
+                logger_1.logger.error('❌ Progress listener error', { event, error: error.message });
+            }
+        });
+    }
+    async getDetailedReport() {
+        return {
+            overview: this.progressHistory.length > 0
+                ? this.progressHistory[this.progressHistory.length - 1].status
+                : null,
+            agentMetrics: Object.fromEntries(this.agentMetrics),
+            performanceMetrics: await this.performanceAnalyzer.getOverallMetrics(),
+            trends: this.generateTrendSummary(),
+            recommendations: this.generateRecommendations()
+        };
+    }
+    generateTrendSummary() {
+        if (this.progressHistory.length === 0) {
+            return { direction: 'unknown', confidence: 0, description: 'Insufficient data' };
+        }
+        const recent = this.progressHistory.slice(-20);
+        const progressRate = this.calculateProgressRate(recent);
+        return {
+            direction: progressRate > 0.1 ? 'improving' : progressRate < -0.1 ? 'declining' : 'stable',
+            confidence: Math.min(recent.length / 20, 1),
+            description: this.describeTrend(progressRate),
+            progressRate
+        };
+    }
+    describeTrend(rate) {
+        if (rate > 0.5)
+            return 'Excellent progress rate';
+        if (rate > 0.1)
+            return 'Good progress rate';
+        if (rate > -0.1)
+            return 'Stable progress';
+        if (rate > -0.5)
+            return 'Slow progress';
+        return 'Progress has stalled';
+    }
+    generateRecommendations() {
+        const recommendations = [];
+        // Analyze agent health
+        const unhealthyAgents = Array.from(this.agentMetrics.entries())
+            .filter(([, metrics]) => metrics.healthyChecks / metrics.totalChecks < 0.8);
+        if (unhealthyAgents.length > 0) {
+            recommendations.push(`Review ${unhealthyAgents.length} underperforming agent(s)`);
+        }
+        // Analyze progress rate
+        if (this.progressHistory.length > 10) {
+            const rate = this.calculateProgressRate(this.progressHistory.slice(-10));
+            if (rate < 0.1) {
+                recommendations.push('Consider increasing parallelism or reviewing task dependencies');
+            }
+        }
+        return recommendations;
+    }
+}
+exports.ProgressMonitor = ProgressMonitor;
+// Supporting classes
+class BottleneckDetector {
+    async detect(taskGraph) {
+        const bottlenecks = [];
+        // Detect long-running tasks
+        const inProgressTasks = taskGraph.getInProgressTasks();
+        const longRunningTasks = inProgressTasks.filter(task => {
+            const duration = task.startTime ? Date.now() - task.startTime.getTime() : 0;
+            return duration > 300000; // 5 minutes
+        });
+        for (const task of longRunningTasks) {
+            bottlenecks.push({
+                type: 'long_running_task',
+                taskId: task.id,
+                description: `Task ${task.id} has been running for over 5 minutes`,
+                severity: 'medium',
+                suggestion: 'Consider task timeout or agent health check'
+            });
+        }
+        // Detect dependency chains
+        const pendingTasks = taskGraph.getPendingTasks();
+        if (pendingTasks.length > inProgressTasks.length * 2) {
+            bottlenecks.push({
+                type: 'dependency_bottleneck',
+                description: 'Many tasks waiting for dependencies to complete',
+                severity: 'high',
+                suggestion: 'Review task dependencies and consider parallel execution'
+            });
+        }
+        return bottlenecks;
+    }
+}
+class PerformanceAnalyzer {
+    constructor() {
+        this.metrics = [];
+    }
+    async analyze(taskGraph) {
+        const stats = await taskGraph.getExecutionStats();
+        const efficiency = stats.totalTasks > 0
+            ? stats.completedTasks / stats.totalTasks
+            : 0;
+        const throughput = stats.averageExecutionTime > 0
+            ? 1000 / stats.averageExecutionTime
+            : 0;
+        const metrics = {
+            efficiency,
+            throughput,
+            averageTaskTime: stats.averageExecutionTime,
+            retryRate: stats.totalRetries / Math.max(stats.totalTasks, 1),
+            timestamp: new Date()
+        };
+        this.metrics.push(metrics);
+        if (this.metrics.length > 100) {
+            this.metrics = this.metrics.slice(-100);
+        }
+        return metrics;
+    }
+    async getOverallMetrics() {
+        if (this.metrics.length === 0) {
+            return {
+                averageEfficiency: 0,
+                averageThroughput: 0,
+                bestEfficiency: 0,
+                worstEfficiency: 0,
+                trend: 'unknown'
+            };
+        }
+        const efficiencies = this.metrics.map(m => m.efficiency);
+        const throughputs = this.metrics.map(m => m.throughput);
+        return {
+            averageEfficiency: efficiencies.reduce((sum, e) => sum + e, 0) / efficiencies.length,
+            averageThroughput: throughputs.reduce((sum, t) => sum + t, 0) / throughputs.length,
+            bestEfficiency: Math.max(...efficiencies),
+            worstEfficiency: Math.min(...efficiencies),
+            trend: this.calculateTrend()
+        };
+    }
+    calculateTrend() {
+        if (this.metrics.length < 10)
+            return 'unknown';
+        const recent = this.metrics.slice(-5);
+        const older = this.metrics.slice(-10, -5);
+        const recentAvg = recent.reduce((sum, m) => sum + m.efficiency, 0) / recent.length;
+        const olderAvg = older.reduce((sum, m) => sum + m.efficiency, 0) / older.length;
+        const diff = recentAvg - olderAvg;
+        if (diff > 0.05)
+            return 'improving';
+        if (diff < -0.05)
+            return 'declining';
+        return 'stable';
+    }
+}
+//# sourceMappingURL=progress-monitor.js.map

package/dist/coordination/quality-gates.d.ts

@@ -0,0 +1,124 @@
+import { EventEmitter } from 'eventemitter3';
+import { QualityGate, ValidationResult, QualityGateResult } from './types';
+export declare class QualityGateManager extends EventEmitter {
+    private gates;
+    private gateResults;
+    private config;
+    constructor(config?: Partial<QualityGateConfig>);
+    addGate(taskId: string, gate: QualityGate): void;
+    validateTask(taskId: string, result: any): Promise<QualityGateResult>;
+    private executeGateWithTimeout;
+    private calculateOverallScore;
+    private createPassingResult;
+    getGateStatistics(taskId?: string): Promise<GateStatistics>;
+    createCodeQualityGate(options?: CodeQualityOptions): QualityGate;
+    createSecurityGate(options?: SecurityGateOptions): QualityGate;
+    createPerformanceGate(options?: PerformanceGateOptions): QualityGate;
+    createServiceNowGate(options?: ServiceNowGateOptions): QualityGate;
+    createBusinessLogicGate(options?: BusinessLogicGateOptions): QualityGate;
+}
+export declare class CodeQualityGate implements QualityGate {
+    name: string;
+    blocking: boolean;
+    private options;
+    constructor(options?: CodeQualityOptions);
+    validate(result: any): Promise<ValidationResult>;
+    private hasDocumentation;
+    private generateCodeSuggestions;
+}
+export declare class SecurityGate implements QualityGate {
+    name: string;
+    blocking: boolean;
+    private options;
+    constructor(options?: SecurityGateOptions);
+    validate(result: any): Promise<ValidationResult>;
+    private hasSQLInjectionRisk;
+    private hasXSSRisk;
+    private hasHardcodedSecrets;
+    private hasProperAuthentication;
+    private hasProperPermissions;
+    private generateSecuritySuggestions;
+}
+export declare class PerformanceGate implements QualityGate {
+    name: string;
+    blocking: boolean;
+    private options;
+    constructor(options?: PerformanceGateOptions);
+    validate(result: any): Promise<ValidationResult>;
+    private generatePerformanceSuggestions;
+}
+export declare class ServiceNowGate implements QualityGate {
+    name: string;
+    blocking: boolean;
+    private options;
+    constructor(options?: ServiceNowGateOptions);
+    validate(result: any): Promise<ValidationResult>;
+    private hasValidScope;
+    private hasValidUpdateSet;
+    private hasValidNaming;
+    private hasValidDependencies;
+    private generateServiceNowSuggestions;
+}
+export declare class BusinessLogicGate implements QualityGate {
+    name: string;
+    blocking: boolean;
+    private options;
+    constructor(options?: BusinessLogicGateOptions);
+    validate(result: any): Promise<ValidationResult>;
+    private meetsBusinessRequirements;
+    private hasExpectedOutputs;
+    private hasProperErrorHandling;
+}
+interface QualityGateConfig {
+    enableBlocking: boolean;
+    enableScoring: boolean;
+    minPassingScore: number;
+    enableMetrics: boolean;
+    timeoutMs: number;
+}
+interface CodeQualityOptions {
+    maxComplexity?: number;
+    minCoverage?: number;
+    maxLines?: number;
+    requireDocumentation?: boolean;
+    checkNaming?: boolean;
+    blocking?: boolean;
+}
+interface SecurityGateOptions {
+    checkInjection?: boolean;
+    checkXSS?: boolean;
+    checkAuth?: boolean;
+    checkSecrets?: boolean;
+    checkPermissions?: boolean;
+}
+interface PerformanceGateOptions {
+    maxResponseTime?: number;
+    maxMemoryUsage?: number;
+    minThroughput?: number;
+    blocking?: boolean;
+}
+interface ServiceNowGateOptions {
+    checkScope?: boolean;
+    checkUpdateSet?: boolean;
+    checkNaming?: boolean;
+    checkDependencies?: boolean;
+    blocking?: boolean;
+}
+interface BusinessLogicGateOptions {
+    checkRequirements?: boolean;
+    checkOutputs?: boolean;
+    checkErrorHandling?: boolean;
+    blocking?: boolean;
+}
+interface GateStatistics {
+    totalExecutions: number;
+    passRate: number;
+    averageScore: number;
+    averageExecutionTime: number;
+    mostCommonFailures: {
+        error: string;
+        count: number;
+    }[];
+}
+export {};
+//# sourceMappingURL=quality-gates.d.ts.map