snow-flow 3.0.9 → 3.0.10

package/dist/coordination/quality-gates.js

@@ -1,577 +0,0 @@
-"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

@@ -1,39 +0,0 @@
-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