snow-flow 2.0.4 → 2.0.6

package/dist/coordination/quality-gates.js

@@ -0,0 +1,577 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BusinessLogicGate = exports.ServiceNowGate = exports.PerformanceGate = exports.SecurityGate = exports.CodeQualityGate = exports.QualityGateManager = void 0;
+const eventemitter3_1 = require("eventemitter3");
+const logger_1 = require("../utils/logger");
+class QualityGateManager extends eventemitter3_1.EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.gates = new Map();
+        this.gateResults = new Map();
+        this.config = {
+            enableBlocking: true,
+            enableScoring: true,
+            minPassingScore: 0.7,
+            enableMetrics: true,
+            timeoutMs: 30000,
+            ...config
+        };
+        logger_1.logger.info('🛡️ Quality Gate Manager initialized', { config: this.config });
+    }
+    addGate(taskId, gate) {
+        if (!this.gates.has(taskId)) {
+            this.gates.set(taskId, []);
+        }
+        this.gates.get(taskId).push(gate);
+        logger_1.logger.debug('🚪 Added quality gate', {
+            taskId,
+            gateName: gate.name,
+            blocking: gate.blocking
+        });
+    }
+    async validateTask(taskId, result) {
+        const startTime = Date.now();
+        try {
+            logger_1.logger.info('🔍 Starting quality gate validation', { taskId });
+            const gates = this.gates.get(taskId) || [];
+            if (gates.length === 0) {
+                logger_1.logger.debug('⚠️ No quality gates configured for task', { taskId });
+                return this.createPassingResult(taskId, startTime);
+            }
+            const validationResults = [];
+            let overallPassed = true;
+            let blockingFailure = false;
+            // Execute all quality gates
+            for (const gate of gates) {
+                try {
+                    logger_1.logger.debug('🔍 Executing quality gate', {
+                        taskId,
+                        gateName: gate.name
+                    });
+                    const validation = await this.executeGateWithTimeout(gate, result);
+                    validationResults.push(validation);
+                    if (!validation.passed) {
+                        if (gate.blocking) {
+                            blockingFailure = true;
+                            overallPassed = false;
+                            logger_1.logger.warn('🚫 Blocking quality gate failed', {
+                                taskId,
+                                gateName: gate.name,
+                                error: validation.error
+                            });
+                        }
+                        else {
+                            logger_1.logger.warn('⚠️ Non-blocking quality gate failed', {
+                                taskId,
+                                gateName: gate.name,
+                                error: validation.error
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.error('❌ Quality gate execution failed', {
+                        taskId,
+                        gateName: gate.name,
+                        error: error.message
+                    });
+                    const failedValidation = {
+                        passed: false,
+                        error: `Gate execution failed: ${error.message}`,
+                        suggestions: ['Check gate configuration', 'Verify input data format']
+                    };
+                    validationResults.push(failedValidation);
+                    if (gate.blocking) {
+                        blockingFailure = true;
+                        overallPassed = false;
+                    }
+                }
+            }
+            const result_obj = {
+                gateName: `quality_gates_${taskId}`,
+                passed: overallPassed,
+                blocking: blockingFailure,
+                validations: validationResults,
+                overallScore: this.calculateOverallScore(validationResults),
+                executionTime: Date.now() - startTime
+            };
+            // Store results for analytics
+            if (!this.gateResults.has(taskId)) {
+                this.gateResults.set(taskId, []);
+            }
+            this.gateResults.get(taskId).push(result_obj);
+            // Emit events
+            if (overallPassed) {
+                this.emit('gate:passed', { taskId, result: result_obj });
+                logger_1.logger.info('✅ Quality gates passed', {
+                    taskId,
+                    gatesCount: gates.length,
+                    score: result_obj.overallScore
+                });
+            }
+            else {
+                this.emit('gate:failed', { taskId, result: result_obj });
+                logger_1.logger.error('❌ Quality gates failed', {
+                    taskId,
+                    blocking: blockingFailure,
+                    failedGates: validationResults.filter(v => !v.passed).length
+                });
+            }
+            return result_obj;
+        }
+        catch (error) {
+            logger_1.logger.error('💥 Quality gate validation crashed', { taskId, error: error.message });
+            return {
+                gateName: `quality_gates_${taskId}`,
+                passed: false,
+                blocking: true,
+                validations: [{
+                        passed: false,
+                        error: `Validation system error: ${error.message}`
+                    }],
+                executionTime: Date.now() - startTime
+            };
+        }
+    }
+    async executeGateWithTimeout(gate, result) {
+        return new Promise(async (resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error(`Quality gate '${gate.name}' timed out after ${this.config.timeoutMs}ms`));
+            }, this.config.timeoutMs);
+            try {
+                const validation = await gate.validate(result);
+                clearTimeout(timeout);
+                resolve(validation);
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                reject(error);
+            }
+        });
+    }
+    calculateOverallScore(validations) {
+        if (!this.config.enableScoring || validations.length === 0) {
+            return 1.0;
+        }
+        const scores = validations
+            .filter(v => typeof v.score === 'number')
+            .map(v => v.score);
+        if (scores.length === 0) {
+            // Fall back to pass/fail scoring
+            const passed = validations.filter(v => v.passed).length;
+            return passed / validations.length;
+        }
+        return scores.reduce((sum, score) => sum + score, 0) / scores.length;
+    }
+    createPassingResult(taskId, startTime) {
+        return {
+            gateName: `quality_gates_${taskId}`,
+            passed: true,
+            blocking: false,
+            validations: [],
+            overallScore: 1.0,
+            executionTime: Date.now() - startTime
+        };
+    }
+    // Analytics and reporting
+    async getGateStatistics(taskId) {
+        const allResults = taskId
+            ? this.gateResults.get(taskId) || []
+            : Array.from(this.gateResults.values()).flat();
+        if (allResults.length === 0) {
+            return {
+                totalExecutions: 0,
+                passRate: 0,
+                averageScore: 0,
+                averageExecutionTime: 0,
+                mostCommonFailures: []
+            };
+        }
+        const passed = allResults.filter(r => r.passed).length;
+        const scores = allResults
+            .filter(r => typeof r.overallScore === 'number')
+            .map(r => r.overallScore);
+        const failures = allResults
+            .filter(r => !r.passed)
+            .flatMap(r => r.validations)
+            .filter(v => !v.passed && v.error)
+            .map(v => v.error)
+            .reduce((counts, error) => {
+            counts[error] = (counts[error] || 0) + 1;
+            return counts;
+        }, {});
+        const mostCommonFailures = Object.entries(failures)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 5)
+            .map(([error, count]) => ({ error, count }));
+        return {
+            totalExecutions: allResults.length,
+            passRate: passed / allResults.length,
+            averageScore: scores.length > 0 ? scores.reduce((sum, s) => sum + s, 0) / scores.length : 0,
+            averageExecutionTime: allResults.reduce((sum, r) => sum + r.executionTime, 0) / allResults.length,
+            mostCommonFailures
+        };
+    }
+    // Predefined Quality Gates
+    createCodeQualityGate(options = {}) {
+        return new CodeQualityGate(options);
+    }
+    createSecurityGate(options = {}) {
+        return new SecurityGate(options);
+    }
+    createPerformanceGate(options = {}) {
+        return new PerformanceGate(options);
+    }
+    createServiceNowGate(options = {}) {
+        return new ServiceNowGate(options);
+    }
+    createBusinessLogicGate(options = {}) {
+        return new BusinessLogicGate(options);
+    }
+}
+exports.QualityGateManager = QualityGateManager;
+// Predefined Quality Gate Implementations
+class CodeQualityGate {
+    constructor(options = {}) {
+        this.name = 'Code Quality';
+        this.blocking = options.blocking ?? true;
+        this.options = {
+            maxComplexity: 10,
+            minCoverage: 80,
+            maxLines: 1000,
+            requireDocumentation: true,
+            checkNaming: true,
+            blocking: true,
+            ...options
+        };
+    }
+    async validate(result) {
+        const issues = [];
+        const warnings = [];
+        let score = 1.0;
+        // Check code complexity
+        if (result.code && result.complexity > this.options.maxComplexity) {
+            issues.push(`Code complexity ${result.complexity} exceeds maximum ${this.options.maxComplexity}`);
+            score -= 0.3;
+        }
+        // Check test coverage
+        if (result.coverage && result.coverage < this.options.minCoverage) {
+            issues.push(`Test coverage ${result.coverage}% below minimum ${this.options.minCoverage}%`);
+            score -= 0.2;
+        }
+        // Check code length
+        if (result.code && result.code.split('\n').length > this.options.maxLines) {
+            warnings.push(`Code is very long (${result.code.split('\n').length} lines)`);
+            score -= 0.1;
+        }
+        // Check documentation
+        if (this.options.requireDocumentation && result.code && !this.hasDocumentation(result.code)) {
+            warnings.push('Missing documentation');
+            score -= 0.1;
+        }
+        return {
+            passed: issues.length === 0,
+            score: Math.max(score, 0),
+            error: issues.length > 0 ? issues.join('; ') : undefined,
+            warnings,
+            suggestions: this.generateCodeSuggestions(issues, warnings)
+        };
+    }
+    hasDocumentation(code) {
+        return /\/\*\*|\*\/|\/\//.test(code);
+    }
+    generateCodeSuggestions(issues, warnings) {
+        const suggestions = [];
+        if (issues.some(i => i.includes('complexity'))) {
+            suggestions.push('Consider breaking down complex functions into smaller ones');
+            suggestions.push('Use early returns to reduce nesting');
+        }
+        if (issues.some(i => i.includes('coverage'))) {
+            suggestions.push('Add more unit tests');
+            suggestions.push('Test edge cases and error conditions');
+        }
+        if (warnings.some(w => w.includes('documentation'))) {
+            suggestions.push('Add JSDoc comments to public functions');
+            suggestions.push('Document complex business logic');
+        }
+        return suggestions;
+    }
+}
+exports.CodeQualityGate = CodeQualityGate;
+class SecurityGate {
+    constructor(options = {}) {
+        this.name = 'Security Review';
+        this.blocking = true;
+        this.options = {
+            checkInjection: true,
+            checkXSS: true,
+            checkAuth: true,
+            checkSecrets: true,
+            checkPermissions: true,
+            ...options
+        };
+    }
+    async validate(result) {
+        const vulnerabilities = [];
+        let score = 1.0;
+        if (result.code) {
+            // Check for SQL injection vulnerabilities
+            if (this.options.checkInjection && this.hasSQLInjectionRisk(result.code)) {
+                vulnerabilities.push('Potential SQL injection vulnerability detected');
+                score -= 0.4;
+            }
+            // Check for XSS vulnerabilities
+            if (this.options.checkXSS && this.hasXSSRisk(result.code)) {
+                vulnerabilities.push('Potential XSS vulnerability detected');
+                score -= 0.3;
+            }
+            // Check for hardcoded secrets
+            if (this.options.checkSecrets && this.hasHardcodedSecrets(result.code)) {
+                vulnerabilities.push('Hardcoded secrets or credentials detected');
+                score -= 0.5;
+            }
+        }
+        // Check ServiceNow specific security
+        if (result.servicenow) {
+            if (this.options.checkAuth && !this.hasProperAuthentication(result.servicenow)) {
+                vulnerabilities.push('Missing or weak authentication controls');
+                score -= 0.3;
+            }
+            if (this.options.checkPermissions && !this.hasProperPermissions(result.servicenow)) {
+                vulnerabilities.push('Insufficient access controls');
+                score -= 0.2;
+            }
+        }
+        return {
+            passed: vulnerabilities.length === 0,
+            score: Math.max(score, 0),
+            error: vulnerabilities.length > 0 ? vulnerabilities.join('; ') : undefined,
+            suggestions: this.generateSecuritySuggestions(vulnerabilities)
+        };
+    }
+    hasSQLInjectionRisk(code) {
+        const patterns = [
+            /query\s*\+\s*['"`]/i,
+            /\$\{.*\}/,
+            /\.addQuery\(/i
+        ];
+        return patterns.some(pattern => pattern.test(code));
+    }
+    hasXSSRisk(code) {
+        const patterns = [
+            /innerHTML\s*=/i,
+            /document\.write\(/i,
+            /eval\(/i
+        ];
+        return patterns.some(pattern => pattern.test(code));
+    }
+    hasHardcodedSecrets(code) {
+        const patterns = [
+            /password\s*=\s*['"][^'"]+['"]/i,
+            /api[_-]?key\s*=\s*['"][^'"]+['"]/i,
+            /secret\s*=\s*['"][^'"]+['"]/i,
+            /token\s*=\s*['"][^'"]+['"]/i
+        ];
+        return patterns.some(pattern => pattern.test(code));
+    }
+    hasProperAuthentication(servicenow) {
+        return servicenow.authMethod && servicenow.authMethod !== 'none';
+    }
+    hasProperPermissions(servicenow) {
+        return servicenow.accessControls && servicenow.accessControls.length > 0;
+    }
+    generateSecuritySuggestions(vulnerabilities) {
+        const suggestions = [];
+        if (vulnerabilities.some(v => v.includes('injection'))) {
+            suggestions.push('Use parameterized queries or prepared statements');
+            suggestions.push('Validate and sanitize all user inputs');
+        }
+        if (vulnerabilities.some(v => v.includes('XSS'))) {
+            suggestions.push('Use proper output encoding');
+            suggestions.push('Implement Content Security Policy (CSP)');
+        }
+        if (vulnerabilities.some(v => v.includes('secrets'))) {
+            suggestions.push('Use environment variables for secrets');
+            suggestions.push('Implement secure credential management');
+        }
+        return suggestions;
+    }
+}
+exports.SecurityGate = SecurityGate;
+class PerformanceGate {
+    constructor(options = {}) {
+        this.name = 'Performance Validation';
+        this.blocking = false;
+        this.options = {
+            maxResponseTime: 5000,
+            maxMemoryUsage: 100,
+            minThroughput: 100,
+            blocking: false,
+            ...options
+        };
+    }
+    async validate(result) {
+        const issues = [];
+        let score = 1.0;
+        if (result.performance) {
+            const perf = result.performance;
+            if (perf.responseTime > this.options.maxResponseTime) {
+                issues.push(`Response time ${perf.responseTime}ms exceeds maximum ${this.options.maxResponseTime}ms`);
+                score -= 0.3;
+            }
+            if (perf.memoryUsage > this.options.maxMemoryUsage) {
+                issues.push(`Memory usage ${perf.memoryUsage}MB exceeds maximum ${this.options.maxMemoryUsage}MB`);
+                score -= 0.2;
+            }
+            if (perf.throughput < this.options.minThroughput) {
+                issues.push(`Throughput ${perf.throughput} below minimum ${this.options.minThroughput}`);
+                score -= 0.2;
+            }
+        }
+        return {
+            passed: issues.length === 0,
+            score: Math.max(score, 0),
+            error: issues.length > 0 ? issues.join('; ') : undefined,
+            suggestions: this.generatePerformanceSuggestions(issues)
+        };
+    }
+    generatePerformanceSuggestions(issues) {
+        const suggestions = [];
+        if (issues.some(i => i.includes('response time'))) {
+            suggestions.push('Optimize database queries');
+            suggestions.push('Implement caching strategies');
+            suggestions.push('Consider pagination for large datasets');
+        }
+        if (issues.some(i => i.includes('memory'))) {
+            suggestions.push('Review object lifecycle management');
+            suggestions.push('Implement lazy loading');
+        }
+        return suggestions;
+    }
+}
+exports.PerformanceGate = PerformanceGate;
+class ServiceNowGate {
+    constructor(options = {}) {
+        this.name = 'ServiceNow Compliance';
+        this.blocking = true;
+        this.options = {
+            checkScope: true,
+            checkUpdateSet: true,
+            checkNaming: true,
+            checkDependencies: true,
+            blocking: true,
+            ...options
+        };
+    }
+    async validate(result) {
+        const issues = [];
+        let score = 1.0;
+        // Check ServiceNow specific requirements
+        if (this.options.checkScope && !this.hasValidScope(result)) {
+            issues.push('Invalid or missing ServiceNow scope configuration');
+            score -= 0.3;
+        }
+        if (this.options.checkUpdateSet && !this.hasValidUpdateSet(result)) {
+            issues.push('Missing or invalid update set tracking');
+            score -= 0.4;
+        }
+        if (this.options.checkNaming && !this.hasValidNaming(result)) {
+            issues.push('ServiceNow naming conventions not followed');
+            score -= 0.2;
+        }
+        if (this.options.checkDependencies && !this.hasValidDependencies(result)) {
+            issues.push('Missing or invalid ServiceNow dependencies');
+            score -= 0.2;
+        }
+        return {
+            passed: issues.length === 0,
+            score: Math.max(score, 0),
+            error: issues.length > 0 ? issues.join('; ') : undefined,
+            suggestions: this.generateServiceNowSuggestions(issues)
+        };
+    }
+    hasValidScope(result) {
+        return result.servicenow?.scope && result.servicenow.scope.length > 0;
+    }
+    hasValidUpdateSet(result) {
+        return result.servicenow?.updateSet || result.updateSetId;
+    }
+    hasValidNaming(result) {
+        // Check if names follow ServiceNow conventions
+        if (result.name) {
+            return /^[a-z][a-z0-9_]*$/.test(result.name);
+        }
+        return true;
+    }
+    hasValidDependencies(result) {
+        // Check for required ServiceNow dependencies
+        return true; // Simplified - would check actual dependencies
+    }
+    generateServiceNowSuggestions(issues) {
+        const suggestions = [];
+        if (issues.some(i => i.includes('scope'))) {
+            suggestions.push('Configure proper ServiceNow application scope');
+        }
+        if (issues.some(i => i.includes('update set'))) {
+            suggestions.push('Ensure all changes are tracked in update sets');
+        }
+        if (issues.some(i => i.includes('naming'))) {
+            suggestions.push('Follow ServiceNow naming conventions (lowercase, underscores)');
+        }
+        return suggestions;
+    }
+}
+exports.ServiceNowGate = ServiceNowGate;
+class BusinessLogicGate {
+    constructor(options = {}) {
+        this.name = 'Business Logic Validation';
+        this.blocking = true;
+        this.options = {
+            checkRequirements: true,
+            checkOutputs: true,
+            checkErrorHandling: true,
+            blocking: true,
+            ...options
+        };
+    }
+    async validate(result) {
+        const issues = [];
+        let score = 1.0;
+        // Check business requirements compliance
+        if (this.options.checkRequirements && !this.meetsBusinessRequirements(result)) {
+            issues.push('Does not meet specified business requirements');
+            score -= 0.4;
+        }
+        // Check expected outputs
+        if (this.options.checkOutputs && !this.hasExpectedOutputs(result)) {
+            issues.push('Missing expected outputs or data structures');
+            score -= 0.3;
+        }
+        // Check error handling
+        if (this.options.checkErrorHandling && !this.hasProperErrorHandling(result)) {
+            issues.push('Insufficient error handling implementation');
+            score -= 0.2;
+        }
+        return {
+            passed: issues.length === 0,
+            score: Math.max(score, 0),
+            error: issues.length > 0 ? issues.join('; ') : undefined,
+            suggestions: ['Review business requirements', 'Implement comprehensive error handling']
+        };
+    }
+    meetsBusinessRequirements(result) {
+        // Simplified - would check against actual business requirements
+        return result.businessLogic && Object.keys(result.businessLogic).length > 0;
+    }
+    hasExpectedOutputs(result) {
+        return result.outputs && Array.isArray(result.outputs) && result.outputs.length > 0;
+    }
+    hasProperErrorHandling(result) {
+        if (result.code) {
+            return /try\s*\{|catch\s*\(|throw\s+|error/i.test(result.code);
+        }
+        return true;
+    }
+}
+exports.BusinessLogicGate = BusinessLogicGate;
+//# sourceMappingURL=quality-gates.js.map

package/dist/coordination/shared-memory.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from 'eventemitter3';
+import { MemoryValue } from './types';
+import { SnowAgent } from '../types/snow-flow.types';
+export declare class SharedMemoryManager extends EventEmitter {
+    private memory;
+    private subscribers;
+    private versionCounters;
+    private accessLogs;
+    private readonly ttl;
+    private cleanupInterval;
+    constructor(ttl?: number);
+    store(key: string, value: any, notifySubscribers?: boolean): Promise<void>;
+    get(key: string): Promise<any>;
+    subscribe(key: string, agent: SnowAgent, callback: (key: string, value: any, version: number) => Promise<void>): Promise<void>;
+    unsubscribe(key: string, agent: SnowAgent): Promise<void>;
+    getHistory(key: string, limit?: number): Promise<MemoryValue[]>;
+    getKeys(pattern?: string): Promise<string[]>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    getStats(): Promise<MemoryStats>;
+    compareAndSwap(key: string, expectedValue: any, newValue: any): Promise<boolean>;
+    atomicUpdate(key: string, updateFunction: (currentValue: any) => any): Promise<any>;
+    private getNextVersion;
+    private notifySubscribers;
+    private logAccess;
+    private calculateSize;
+    private isExpired;
+    private cleanupExpiredEntries;
+    destroy(): void;
+}
+interface MemoryStats {
+    totalEntries: number;
+    totalSize: number;
+    subscriberCount: number;
+    oldestEntryAge: number;
+    averageEntrySize: number;
+}
+export {};
+//# sourceMappingURL=shared-memory.d.ts.map