snow-flow 3.0.8 → 3.0.10

package/dist/specialists/flow-specialists.js

@@ -1,1787 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SecuritySpecialist = exports.IntegrationSpecialist = exports.DataSpecialist = exports.TriggerSpecialist = exports.ProcessSpecialist = void 0;
-const base_specialist_js_1 = require("./base-specialist.js");
-class ProcessSpecialist extends base_specialist_js_1.BaseSpecialist {
-    constructor(options = {}) {
-        super('Process Designer', 'Process Designer', ['Business Logic', 'Workflow Design', 'Process Optimization', 'Flow Architecture'], options);
-    }
-    async execute(task, context) {
-        await this.logProgress(`Analyzing process requirements for: ${task}`);
-        const analysis = await this.analyzeTask(task);
-        const processRequirements = {
-            flowType: this.identifyFlowType(task),
-            businessLogic: this.analyzeBusinessLogic(task),
-            processSteps: this.identifyProcessSteps(task),
-            decisionPoints: this.identifyDecisionPoints(task),
-            approvals: this.analyzeApprovalRequirements(task),
-            automation: this.analyzeAutomationOpportunities(task)
-        };
-        await this.logProgress('Designing process flow architecture');
-        const flowArchitecture = await this.designFlowArchitecture(processRequirements);
-        await this.logProgress('Creating process flow definition');
-        const flowDefinition = await this.createFlowDefinition(processRequirements);
-        return {
-            ...analysis,
-            specialist: 'Process Designer',
-            deliverables: {
-                flowArchitecture,
-                flowDefinition,
-                requirements: processRequirements
-            }
-        };
-    }
-    identifyFlowType(task) {
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('approval')) {
-            return 'approval_workflow';
-        }
-        else if (lowerTask.includes('fulfillment') || lowerTask.includes('provision')) {
-            return 'fulfillment_workflow';
-        }
-        else if (lowerTask.includes('notification') || lowerTask.includes('alert')) {
-            return 'notification_workflow';
-        }
-        else if (lowerTask.includes('integration') || lowerTask.includes('sync')) {
-            return 'integration_workflow';
-        }
-        else if (lowerTask.includes('escalation')) {
-            return 'escalation_workflow';
-        }
-        return 'utility_workflow';
-    }
-    analyzeBusinessLogic(task) {
-        const lowerTask = task.toLowerCase();
-        const businessRules = [];
-        if (lowerTask.includes('priority')) {
-            businessRules.push({
-                name: 'Priority Based Routing',
-                condition: 'priority_level',
-                action: 'route_based_on_priority'
-            });
-        }
-        if (lowerTask.includes('approval')) {
-            businessRules.push({
-                name: 'Approval Logic',
-                condition: 'approval_criteria',
-                action: 'send_for_approval'
-            });
-        }
-        if (lowerTask.includes('sla') || lowerTask.includes('deadline')) {
-            businessRules.push({
-                name: 'SLA Management',
-                condition: 'time_constraints',
-                action: 'track_sla_compliance'
-            });
-        }
-        return {
-            rules: businessRules,
-            complexity: businessRules.length > 3 ? 'complex' : businessRules.length > 1 ? 'moderate' : 'simple'
-        };
-    }
-    identifyProcessSteps(task) {
-        const steps = [];
-        const lowerTask = task.toLowerCase();
-        // Common starting step
-        steps.push({
-            id: 'start',
-            name: 'Process Start',
-            type: 'start',
-            description: 'Initialize the workflow process'
-        });
-        if (lowerTask.includes('validation') || lowerTask.includes('validate')) {
-            steps.push({
-                id: 'validation',
-                name: 'Input Validation',
-                type: 'script',
-                description: 'Validate input data and requirements'
-            });
-        }
-        if (lowerTask.includes('approval')) {
-            steps.push({
-                id: 'approval_request',
-                name: 'Send for Approval',
-                type: 'approval',
-                description: 'Request approval from designated approvers'
-            });
-        }
-        if (lowerTask.includes('notification') || lowerTask.includes('email')) {
-            steps.push({
-                id: 'notification',
-                name: 'Send Notification',
-                type: 'notification',
-                description: 'Send notification to relevant parties'
-            });
-        }
-        if (lowerTask.includes('create') || lowerTask.includes('provision')) {
-            steps.push({
-                id: 'provisioning',
-                name: 'Resource Provisioning',
-                type: 'script',
-                description: 'Create or provision requested resources'
-            });
-        }
-        if (lowerTask.includes('integration') || lowerTask.includes('api')) {
-            steps.push({
-                id: 'integration',
-                name: 'External Integration',
-                type: 'rest',
-                description: 'Integrate with external systems'
-            });
-        }
-        // Common ending step
-        steps.push({
-            id: 'end',
-            name: 'Process Complete',
-            type: 'end',
-            description: 'Mark process as completed'
-        });
-        return steps;
-    }
-    identifyDecisionPoints(task) {
-        const decisions = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('approval')) {
-            decisions.push({
-                id: 'approval_decision',
-                name: 'Approval Decision',
-                condition: 'approval_status',
-                branches: [
-                    { condition: 'approved', action: 'continue_process' },
-                    { condition: 'rejected', action: 'reject_request' },
-                    { condition: 'pending', action: 'wait_for_approval' }
-                ]
-            });
-        }
-        if (lowerTask.includes('priority') || lowerTask.includes('urgency')) {
-            decisions.push({
-                id: 'priority_routing',
-                name: 'Priority Based Routing',
-                condition: 'priority_level',
-                branches: [
-                    { condition: 'high', action: 'expedite_process' },
-                    { condition: 'medium', action: 'standard_process' },
-                    { condition: 'low', action: 'delayed_process' }
-                ]
-            });
-        }
-        if (lowerTask.includes('error') || lowerTask.includes('exception')) {
-            decisions.push({
-                id: 'error_handling',
-                name: 'Error Handling',
-                condition: 'error_status',
-                branches: [
-                    { condition: 'retry', action: 'retry_operation' },
-                    { condition: 'escalate', action: 'escalate_to_admin' },
-                    { condition: 'abort', action: 'terminate_process' }
-                ]
-            });
-        }
-        return decisions;
-    }
-    analyzeApprovalRequirements(task) {
-        const lowerTask = task.toLowerCase();
-        if (!lowerTask.includes('approval')) {
-            return { required: false };
-        }
-        return {
-            required: true,
-            type: lowerTask.includes('multi') ? 'multi_stage' : 'single_stage',
-            approvers: this.identifyApprovers(task),
-            criteria: this.identifyApprovalCriteria(task),
-            escalation: lowerTask.includes('escalation') || lowerTask.includes('deadline')
-        };
-    }
-    identifyApprovers(task) {
-        const approvers = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('manager')) {
-            approvers.push('manager');
-        }
-        if (lowerTask.includes('director')) {
-            approvers.push('director');
-        }
-        if (lowerTask.includes('admin')) {
-            approvers.push('system_administrator');
-        }
-        if (lowerTask.includes('security')) {
-            approvers.push('security_team');
-        }
-        return approvers.length > 0 ? approvers : ['default_approver'];
-    }
-    identifyApprovalCriteria(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            automaticApproval: lowerTask.includes('automatic'),
-            amountThreshold: lowerTask.includes('amount') || lowerTask.includes('cost'),
-            riskAssessment: lowerTask.includes('risk') || lowerTask.includes('security'),
-            timeConstraints: lowerTask.includes('urgent') || lowerTask.includes('deadline')
-        };
-    }
-    analyzeAutomationOpportunities(task) {
-        const opportunities = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('email') || lowerTask.includes('notification')) {
-            opportunities.push('automated_notifications');
-        }
-        if (lowerTask.includes('create') || lowerTask.includes('provision')) {
-            opportunities.push('automated_provisioning');
-        }
-        if (lowerTask.includes('update') || lowerTask.includes('modify')) {
-            opportunities.push('automated_updates');
-        }
-        if (lowerTask.includes('validation') || lowerTask.includes('check')) {
-            opportunities.push('automated_validation');
-        }
-        return {
-            level: opportunities.length > 2 ? 'high' : opportunities.length > 0 ? 'medium' : 'low',
-            opportunities
-        };
-    }
-    async designFlowArchitecture(requirements) {
-        return {
-            flowType: requirements.flowType,
-            architecture: {
-                pattern: this.selectArchitecturePattern(requirements),
-                components: this.identifyRequiredComponents(requirements),
-                integrations: this.identifyIntegrationPoints(requirements)
-            },
-            scalability: this.assessScalabilityNeeds(requirements),
-            performance: this.assessPerformanceRequirements(requirements)
-        };
-    }
-    selectArchitecturePattern(requirements) {
-        if (requirements.businessLogic.complexity === 'complex') {
-            return 'layered_architecture';
-        }
-        else if (requirements.approvals.required && requirements.approvals.type === 'multi_stage') {
-            return 'pipeline_architecture';
-        }
-        else if (requirements.automation.level === 'high') {
-            return 'event_driven_architecture';
-        }
-        return 'linear_architecture';
-    }
-    identifyRequiredComponents(requirements) {
-        const components = ['flow_logic'];
-        if (requirements.approvals.required) {
-            components.push('approval_engine');
-        }
-        if (requirements.automation.opportunities.includes('automated_notifications')) {
-            components.push('notification_service');
-        }
-        if (requirements.automation.opportunities.includes('automated_provisioning')) {
-            components.push('provisioning_engine');
-        }
-        return components;
-    }
-    identifyIntegrationPoints(requirements) {
-        const integrations = [];
-        if (requirements.approvals.required) {
-            integrations.push('approval_system');
-        }
-        if (requirements.automation.opportunities.includes('automated_notifications')) {
-            integrations.push('email_system');
-        }
-        return integrations;
-    }
-    assessScalabilityNeeds(requirements) {
-        return {
-            expectedVolume: requirements.businessLogic.complexity === 'complex' ? 'high' : 'medium',
-            concurrency: requirements.automation.level === 'high' ? 'high' : 'medium',
-            growthProjection: 'moderate'
-        };
-    }
-    assessPerformanceRequirements(requirements) {
-        return {
-            responseTime: requirements.flowType.includes('approval') ? 'fast' : 'standard',
-            throughput: requirements.automation.level === 'high' ? 'high' : 'medium',
-            reliability: 'high'
-        };
-    }
-    async createFlowDefinition(requirements) {
-        const flowDefinition = {
-            flow: {
-                name: this.generateFlowName(requirements),
-                description: this.generateFlowDescription(requirements),
-                trigger: this.createTriggerDefinition(requirements),
-                steps: this.createStepDefinitions(requirements),
-                variables: this.createVariableDefinitions(requirements)
-            }
-        };
-        return flowDefinition;
-    }
-    generateFlowName(requirements) {
-        const typeMap = {
-            'approval_workflow': 'Approval Process',
-            'fulfillment_workflow': 'Fulfillment Process',
-            'notification_workflow': 'Notification Process',
-            'integration_workflow': 'Integration Process',
-            'escalation_workflow': 'Escalation Process',
-            'utility_workflow': 'Utility Process'
-        };
-        return typeMap[requirements.flowType] || 'Custom Process';
-    }
-    generateFlowDescription(requirements) {
-        return `Automated ${requirements.flowType.replace('_', ' ')} with ${requirements.businessLogic.complexity} business logic`;
-    }
-    createTriggerDefinition(requirements) {
-        if (requirements.flowType === 'approval_workflow') {
-            return {
-                type: 'record_created',
-                table: 'sc_request',
-                condition: 'state=1'
-            };
-        }
-        else if (requirements.flowType === 'notification_workflow') {
-            return {
-                type: 'record_updated',
-                table: 'incident',
-                condition: 'priority=1'
-            };
-        }
-        return {
-            type: 'manual',
-            condition: ''
-        };
-    }
-    createStepDefinitions(requirements) {
-        return requirements.processSteps.map((step, index) => ({
-            sequence: index + 1,
-            name: step.name,
-            type: step.type,
-            description: step.description,
-            properties: this.createStepProperties(step, requirements)
-        }));
-    }
-    createStepProperties(step, requirements) {
-        const properties = {};
-        if (step.type === 'approval') {
-            properties.approvers = requirements.approvals.approvers;
-            properties.approval_criteria = requirements.approvals.criteria;
-        }
-        else if (step.type === 'notification') {
-            properties.recipients = ['${trigger.requested_for}', '${trigger.opened_by}'];
-            properties.message_template = 'Default notification message';
-        }
-        else if (step.type === 'script') {
-            properties.script_type = 'inline';
-            properties.script_content = '// Auto-generated script placeholder';
-        }
-        return properties;
-    }
-    createVariableDefinitions(requirements) {
-        const variables = [
-            {
-                name: 'process_status',
-                type: 'string',
-                default_value: 'pending'
-            },
-            {
-                name: 'created_timestamp',
-                type: 'datetime',
-                default_value: 'now'
-            }
-        ];
-        if (requirements.approvals.required) {
-            variables.push({
-                name: 'approval_status',
-                type: 'string',
-                default_value: 'pending'
-            });
-        }
-        return variables;
-    }
-}
-exports.ProcessSpecialist = ProcessSpecialist;
-class TriggerSpecialist extends base_specialist_js_1.BaseSpecialist {
-    constructor(options = {}) {
-        super('Trigger Specialist', 'Trigger Specialist', ['Event Handling', 'Conditions', 'Automation', 'Real-time Processing'], options);
-    }
-    async execute(task, context) {
-        await this.logProgress(`Analyzing trigger requirements for: ${task}`);
-        const analysis = await this.analyzeTask(task);
-        const triggerRequirements = {
-            eventTypes: this.identifyEventTypes(task),
-            conditions: this.analyzeTriggerConditions(task),
-            timing: this.analyzeTriggerTiming(task),
-            filters: this.identifyTriggerFilters(task),
-            performance: this.analyzeTriggerPerformance(task)
-        };
-        await this.logProgress('Designing trigger mechanisms');
-        const triggerDesign = await this.createTriggerDesign(triggerRequirements);
-        await this.logProgress('Creating trigger configurations');
-        const triggerConfig = await this.createTriggerConfiguration(triggerRequirements);
-        return {
-            ...analysis,
-            specialist: 'Trigger Specialist',
-            deliverables: {
-                triggerDesign,
-                triggerConfig,
-                requirements: triggerRequirements
-            }
-        };
-    }
-    identifyEventTypes(task) {
-        const events = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('create') || lowerTask.includes('new')) {
-            events.push('record_created');
-        }
-        if (lowerTask.includes('update') || lowerTask.includes('change') || lowerTask.includes('modify')) {
-            events.push('record_updated');
-        }
-        if (lowerTask.includes('delete') || lowerTask.includes('remove')) {
-            events.push('record_deleted');
-        }
-        if (lowerTask.includes('schedule') || lowerTask.includes('time') || lowerTask.includes('daily')) {
-            events.push('scheduled');
-        }
-        if (lowerTask.includes('manual') || lowerTask.includes('button') || lowerTask.includes('click')) {
-            events.push('manual');
-        }
-        if (lowerTask.includes('api') || lowerTask.includes('webhook')) {
-            events.push('webhook');
-        }
-        return events.length > 0 ? events : ['manual'];
-    }
-    analyzeTriggerConditions(task) {
-        const conditions = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('priority')) {
-            conditions.push({
-                field: 'priority',
-                operator: 'equals',
-                value: '1'
-            });
-        }
-        if (lowerTask.includes('state')) {
-            conditions.push({
-                field: 'state',
-                operator: 'equals',
-                value: 'new'
-            });
-        }
-        if (lowerTask.includes('category')) {
-            conditions.push({
-                field: 'category',
-                operator: 'equals',
-                value: 'hardware'
-            });
-        }
-        if (lowerTask.includes('user') || lowerTask.includes('assigned')) {
-            conditions.push({
-                field: 'assigned_to',
-                operator: 'is_not_empty',
-                value: ''
-            });
-        }
-        return {
-            logic: conditions.length > 1 ? 'AND' : 'SINGLE',
-            conditions: conditions
-        };
-    }
-    analyzeTriggerTiming(task) {
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('immediate') || lowerTask.includes('instant')) {
-            return {
-                timing: 'immediate',
-                delay: 0
-            };
-        }
-        else if (lowerTask.includes('delay') || lowerTask.includes('wait')) {
-            return {
-                timing: 'delayed',
-                delay: 300 // 5 minutes default
-            };
-        }
-        else if (lowerTask.includes('schedule')) {
-            return {
-                timing: 'scheduled',
-                schedule: 'daily'
-            };
-        }
-        return {
-            timing: 'immediate',
-            delay: 0
-        };
-    }
-    identifyTriggerFilters(task) {
-        const filters = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('active')) {
-            filters.push({
-                name: 'active_records_only',
-                condition: 'active=true'
-            });
-        }
-        if (lowerTask.includes('business hours')) {
-            filters.push({
-                name: 'business_hours_only',
-                condition: 'business_hours=true'
-            });
-        }
-        if (lowerTask.includes('exclude test')) {
-            filters.push({
-                name: 'exclude_test_data',
-                condition: 'name_not_contains=test'
-            });
-        }
-        return filters;
-    }
-    analyzeTriggerPerformance(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            batchProcessing: lowerTask.includes('bulk') || lowerTask.includes('batch'),
-            rateLimiting: lowerTask.includes('rate') || lowerTask.includes('throttle'),
-            errorHandling: true,
-            monitoring: true,
-            optimization: lowerTask.includes('performance') || lowerTask.includes('optimize')
-        };
-    }
-    async createTriggerDesign(requirements) {
-        return {
-            architecture: {
-                pattern: this.selectTriggerPattern(requirements),
-                components: this.identifyTriggerComponents(requirements),
-                errorHandling: this.designErrorHandling(requirements)
-            },
-            scalability: this.designScalability(requirements),
-            monitoring: this.designMonitoring(requirements)
-        };
-    }
-    selectTriggerPattern(requirements) {
-        if (requirements.eventTypes.includes('scheduled')) {
-            return 'scheduled_trigger';
-        }
-        else if (requirements.eventTypes.length > 1) {
-            return 'multi_event_trigger';
-        }
-        else if (requirements.performance.batchProcessing) {
-            return 'batch_trigger';
-        }
-        return 'simple_trigger';
-    }
-    identifyTriggerComponents(requirements) {
-        const components = ['event_listener'];
-        if (requirements.conditions.conditions.length > 0) {
-            components.push('condition_evaluator');
-        }
-        if (requirements.filters.length > 0) {
-            components.push('filter_processor');
-        }
-        if (requirements.performance.rateLimiting) {
-            components.push('rate_limiter');
-        }
-        if (requirements.performance.batchProcessing) {
-            components.push('batch_processor');
-        }
-        return components;
-    }
-    designErrorHandling(requirements) {
-        return {
-            retryPolicy: {
-                enabled: true,
-                maxRetries: 3,
-                backoffStrategy: 'exponential'
-            },
-            failureHandling: {
-                logErrors: true,
-                alertAdmins: true,
-                gracefulDegradation: true
-            },
-            deadLetterQueue: requirements.performance.batchProcessing
-        };
-    }
-    designScalability(requirements) {
-        return {
-            horizontalScaling: requirements.performance.batchProcessing,
-            loadBalancing: requirements.eventTypes.length > 1,
-            caching: requirements.performance.optimization
-        };
-    }
-    designMonitoring(requirements) {
-        return {
-            metrics: ['trigger_count', 'execution_time', 'error_rate'],
-            alerting: ['high_error_rate', 'performance_degradation'],
-            logging: ['trigger_events', 'condition_evaluation', 'error_details']
-        };
-    }
-    async createTriggerConfiguration(requirements) {
-        return {
-            triggerDefinition: {
-                name: this.generateTriggerName(requirements),
-                description: this.generateTriggerDescription(requirements),
-                active: true,
-                events: requirements.eventTypes,
-                conditions: requirements.conditions,
-                filters: requirements.filters,
-                timing: requirements.timing,
-                errorHandling: {
-                    retryCount: 3,
-                    errorNotification: true
-                }
-            },
-            performanceConfig: {
-                batchSize: requirements.performance.batchProcessing ? 100 : 1,
-                rateLimitPerMinute: requirements.performance.rateLimiting ? 60 : null,
-                timeoutSeconds: 300
-            }
-        };
-    }
-    generateTriggerName(requirements) {
-        const eventType = requirements.eventTypes[0] || 'manual';
-        return `${eventType}_trigger_${Date.now()}`;
-    }
-    generateTriggerDescription(requirements) {
-        const events = requirements.eventTypes.join(', ');
-        return `Trigger for ${events} events with ${requirements.conditions.conditions.length} conditions`;
-    }
-}
-exports.TriggerSpecialist = TriggerSpecialist;
-class DataSpecialist extends base_specialist_js_1.BaseSpecialist {
-    constructor(options = {}) {
-        super('Data Specialist', 'Data Specialist', ['Data Modeling', 'Variable Management', 'Data Transformation', 'Data Validation'], options);
-    }
-    async execute(task, context) {
-        await this.logProgress(`Analyzing data requirements for: ${task}`);
-        const analysis = await this.analyzeTask(task);
-        const dataRequirements = {
-            dataModel: this.analyzeDataModel(task),
-            variables: this.identifyVariables(task),
-            transformations: this.identifyTransformations(task),
-            validation: this.analyzeValidationNeeds(task),
-            storage: this.analyzeStorageRequirements(task)
-        };
-        await this.logProgress('Designing data architecture');
-        const dataArchitecture = await this.createDataArchitecture(dataRequirements);
-        await this.logProgress('Creating data management strategy');
-        const dataStrategy = await this.createDataStrategy(dataRequirements);
-        return {
-            ...analysis,
-            specialist: 'Data Specialist',
-            deliverables: {
-                dataArchitecture,
-                dataStrategy,
-                requirements: dataRequirements
-            }
-        };
-    }
-    analyzeDataModel(task) {
-        const lowerTask = task.toLowerCase();
-        const entities = [];
-        if (lowerTask.includes('user') || lowerTask.includes('requester')) {
-            entities.push({
-                name: 'User',
-                table: 'sys_user',
-                fields: ['name', 'email', 'department', 'manager']
-            });
-        }
-        if (lowerTask.includes('request') || lowerTask.includes('ticket')) {
-            entities.push({
-                name: 'Request',
-                table: 'sc_request',
-                fields: ['number', 'short_description', 'state', 'priority']
-            });
-        }
-        if (lowerTask.includes('approval')) {
-            entities.push({
-                name: 'Approval',
-                table: 'sysapproval_approver',
-                fields: ['state', 'approver', 'comments', 'sys_created_on']
-            });
-        }
-        return {
-            entities,
-            relationships: this.identifyRelationships(entities),
-            complexity: entities.length > 2 ? 'complex' : entities.length > 1 ? 'moderate' : 'simple'
-        };
-    }
-    identifyRelationships(entities) {
-        const relationships = [];
-        const userEntity = entities.find(e => e.name === 'User');
-        const requestEntity = entities.find(e => e.name === 'Request');
-        const approvalEntity = entities.find(e => e.name === 'Approval');
-        if (userEntity && requestEntity) {
-            relationships.push({
-                from: 'Request',
-                to: 'User',
-                type: 'many_to_one',
-                field: 'requested_for'
-            });
-        }
-        if (requestEntity && approvalEntity) {
-            relationships.push({
-                from: 'Approval',
-                to: 'Request',
-                type: 'many_to_one',
-                field: 'sysapproval'
-            });
-        }
-        return relationships;
-    }
-    identifyVariables(task) {
-        const variables = [];
-        const lowerTask = task.toLowerCase();
-        // Common flow variables
-        variables.push({
-            name: 'trigger',
-            type: 'record',
-            description: 'Triggering record data',
-            scope: 'flow'
-        });
-        if (lowerTask.includes('approval')) {
-            variables.push({
-                name: 'approval_status',
-                type: 'string',
-                description: 'Current approval status',
-                scope: 'flow',
-                defaultValue: 'pending'
-            });
-            variables.push({
-                name: 'approver',
-                type: 'reference',
-                description: 'Assigned approver',
-                scope: 'flow',
-                referenceTo: 'sys_user'
-            });
-        }
-        if (lowerTask.includes('notification') || lowerTask.includes('email')) {
-            variables.push({
-                name: 'email_recipients',
-                type: 'string',
-                description: 'Email recipient list',
-                scope: 'step'
-            });
-            variables.push({
-                name: 'email_subject',
-                type: 'string',
-                description: 'Email subject line',
-                scope: 'step'
-            });
-        }
-        if (lowerTask.includes('deadline') || lowerTask.includes('sla')) {
-            variables.push({
-                name: 'due_date',
-                type: 'datetime',
-                description: 'Process due date',
-                scope: 'flow'
-            });
-        }
-        return variables;
-    }
-    identifyTransformations(task) {
-        const transformations = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('format') || lowerTask.includes('convert')) {
-            transformations.push({
-                name: 'Data Formatting',
-                type: 'format',
-                description: 'Format data for display or processing',
-                inputType: 'string',
-                outputType: 'string'
-            });
-        }
-        if (lowerTask.includes('calculate') || lowerTask.includes('compute')) {
-            transformations.push({
-                name: 'Value Calculation',
-                type: 'calculation',
-                description: 'Perform calculations on numeric data',
-                inputType: 'number',
-                outputType: 'number'
-            });
-        }
-        if (lowerTask.includes('lookup') || lowerTask.includes('reference')) {
-            transformations.push({
-                name: 'Reference Lookup',
-                type: 'lookup',
-                description: 'Look up related record information',
-                inputType: 'reference',
-                outputType: 'record'
-            });
-        }
-        if (lowerTask.includes('aggregate') || lowerTask.includes('count') || lowerTask.includes('sum')) {
-            transformations.push({
-                name: 'Data Aggregation',
-                type: 'aggregation',
-                description: 'Aggregate data from multiple records',
-                inputType: 'recordset',
-                outputType: 'number'
-            });
-        }
-        return transformations;
-    }
-    analyzeValidationNeeds(task) {
-        const validations = [];
-        const lowerTask = task.toLowerCase();
-        validations.push({
-            name: 'Required Fields',
-            type: 'required',
-            description: 'Ensure required fields are not empty',
-            severity: 'error'
-        });
-        if (lowerTask.includes('email')) {
-            validations.push({
-                name: 'Email Format',
-                type: 'format',
-                description: 'Validate email address format',
-                pattern: '^[\\w\\.-]+@[\\w\\.-]+\\.[a-zA-Z]{2,}$',
-                severity: 'error'
-            });
-        }
-        if (lowerTask.includes('phone') || lowerTask.includes('number')) {
-            validations.push({
-                name: 'Phone Format',
-                type: 'format',
-                description: 'Validate phone number format',
-                pattern: '^[\\d\\s\\-\\+\\(\\)]+$',
-                severity: 'warning'
-            });
-        }
-        if (lowerTask.includes('date')) {
-            validations.push({
-                name: 'Date Range',
-                type: 'range',
-                description: 'Validate date is within acceptable range',
-                severity: 'error'
-            });
-        }
-        return {
-            rules: validations,
-            strategy: 'fail_fast',
-            errorHandling: 'log_and_continue'
-        };
-    }
-    analyzeStorageRequirements(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            persistence: lowerTask.includes('save') || lowerTask.includes('store'),
-            temporary: lowerTask.includes('cache') || lowerTask.includes('session'),
-            archival: lowerTask.includes('history') || lowerTask.includes('audit'),
-            encryption: lowerTask.includes('sensitive') || lowerTask.includes('secure'),
-            backup: true,
-            retention: this.determineRetentionPolicy(task)
-        };
-    }
-    determineRetentionPolicy(task) {
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('audit') || lowerTask.includes('compliance')) {
-            return { period: '7_years', reason: 'regulatory_compliance' };
-        }
-        else if (lowerTask.includes('history')) {
-            return { period: '2_years', reason: 'historical_analysis' };
-        }
-        else if (lowerTask.includes('temporary') || lowerTask.includes('cache')) {
-            return { period: '30_days', reason: 'temporary_storage' };
-        }
-        return { period: '1_year', reason: 'standard_retention' };
-    }
-    async createDataArchitecture(requirements) {
-        return {
-            model: requirements.dataModel,
-            variables: requirements.variables,
-            transformations: requirements.transformations,
-            validation: requirements.validation,
-            storage: requirements.storage,
-            performance: {
-                indexing: this.designIndexingStrategy(requirements),
-                caching: this.designCachingStrategy(requirements),
-                optimization: this.designOptimizationStrategy(requirements)
-            }
-        };
-    }
-    designIndexingStrategy(requirements) {
-        const indexes = [];
-        requirements.dataModel.entities.forEach(entity => {
-            if (entity.fields.includes('sys_created_on')) {
-                indexes.push({
-                    table: entity.table,
-                    fields: ['sys_created_on'],
-                    type: 'btree'
-                });
-            }
-            if (entity.fields.includes('state')) {
-                indexes.push({
-                    table: entity.table,
-                    fields: ['state'],
-                    type: 'hash'
-                });
-            }
-        });
-        return { recommended: indexes };
-    }
-    designCachingStrategy(requirements) {
-        return {
-            enabled: requirements.storage.temporary,
-            ttl: requirements.storage.temporary ? 1800 : null, // 30 minutes
-            strategy: 'lru',
-            levels: ['memory', 'disk']
-        };
-    }
-    designOptimizationStrategy(requirements) {
-        return {
-            batchProcessing: requirements.dataModel.complexity === 'complex',
-            lazyLoading: true,
-            compressionEnabled: requirements.storage.archival,
-            queryOptimization: true
-        };
-    }
-    async createDataStrategy(requirements) {
-        return {
-            governance: {
-                dataOwnership: 'defined',
-                accessControls: 'rbac',
-                auditTrail: requirements.storage.archival
-            },
-            integration: {
-                apiStandards: 'rest',
-                dataFormats: ['json', 'xml'],
-                synchronization: 'real_time'
-            },
-            quality: {
-                validation: requirements.validation,
-                cleansing: 'automated',
-                monitoring: 'continuous'
-            },
-            lifecycle: {
-                creation: 'automated',
-                updates: 'event_driven',
-                archival: requirements.storage.retention,
-                deletion: 'policy_based'
-            }
-        };
-    }
-}
-exports.DataSpecialist = DataSpecialist;
-class IntegrationSpecialist extends base_specialist_js_1.BaseSpecialist {
-    constructor(options = {}) {
-        super('Integration Expert', 'Integration Specialist', ['API Integration', 'External Systems', 'Data Synchronization', 'Middleware'], options);
-    }
-    async execute(task, context) {
-        await this.logProgress(`Analyzing integration requirements for: ${task}`);
-        const analysis = await this.analyzeTask(task);
-        const integrationRequirements = {
-            systems: this.identifyExternalSystems(task),
-            apis: this.analyzeApiRequirements(task),
-            protocols: this.identifyProtocols(task),
-            dataMapping: this.analyzeDataMapping(task),
-            security: this.analyzeSecurityRequirements(task),
-            errorHandling: this.analyzeErrorHandling(task)
-        };
-        await this.logProgress('Designing integration architecture');
-        const integrationArchitecture = await this.createIntegrationArchitecture(integrationRequirements);
-        await this.logProgress('Creating integration implementation plan');
-        const implementationPlan = await this.createImplementationPlan(integrationRequirements);
-        return {
-            ...analysis,
-            specialist: 'Integration Specialist',
-            deliverables: {
-                integrationArchitecture,
-                implementationPlan,
-                requirements: integrationRequirements
-            }
-        };
-    }
-    identifyExternalSystems(task) {
-        const systems = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('email') || lowerTask.includes('smtp')) {
-            systems.push({
-                name: 'Email System',
-                type: 'communication',
-                protocol: 'smtp',
-                authentication: 'basic'
-            });
-        }
-        if (lowerTask.includes('ldap') || lowerTask.includes('active directory')) {
-            systems.push({
-                name: 'LDAP/Active Directory',
-                type: 'identity',
-                protocol: 'ldap',
-                authentication: 'kerberos'
-            });
-        }
-        if (lowerTask.includes('database') || lowerTask.includes('sql')) {
-            systems.push({
-                name: 'External Database',
-                type: 'data',
-                protocol: 'jdbc',
-                authentication: 'database'
-            });
-        }
-        if (lowerTask.includes('api') || lowerTask.includes('rest') || lowerTask.includes('webhook')) {
-            systems.push({
-                name: 'External API',
-                type: 'service',
-                protocol: 'https',
-                authentication: 'oauth2'
-            });
-        }
-        return systems;
-    }
-    analyzeApiRequirements(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            type: lowerTask.includes('soap') ? 'soap' : 'rest',
-            version: 'v1',
-            authentication: this.determineAuthMethod(task),
-            rateLimiting: lowerTask.includes('rate') || lowerTask.includes('limit'),
-            versioning: 'header',
-            documentation: 'openapi',
-            testing: 'automated'
-        };
-    }
-    determineAuthMethod(task) {
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('oauth')) {
-            return 'oauth2';
-        }
-        else if (lowerTask.includes('token')) {
-            return 'bearer_token';
-        }
-        else if (lowerTask.includes('basic')) {
-            return 'basic_auth';
-        }
-        else if (lowerTask.includes('api key')) {
-            return 'api_key';
-        }
-        return 'basic_auth';
-    }
-    identifyProtocols(task) {
-        const protocols = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('http') || lowerTask.includes('rest') || lowerTask.includes('api')) {
-            protocols.push('https');
-        }
-        if (lowerTask.includes('soap')) {
-            protocols.push('soap');
-        }
-        if (lowerTask.includes('ftp') || lowerTask.includes('file')) {
-            protocols.push('sftp');
-        }
-        if (lowerTask.includes('email') || lowerTask.includes('smtp')) {
-            protocols.push('smtp');
-        }
-        if (lowerTask.includes('ldap')) {
-            protocols.push('ldaps');
-        }
-        return protocols.length > 0 ? protocols : ['https'];
-    }
-    analyzeDataMapping(task) {
-        const mappings = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('user') || lowerTask.includes('person')) {
-            mappings.push({
-                source: 'external_user',
-                target: 'sys_user',
-                fields: [
-                    { source: 'username', target: 'user_name', transformation: 'lowercase' },
-                    { source: 'email', target: 'email', transformation: 'none' },
-                    { source: 'fullName', target: 'name', transformation: 'none' }
-                ]
-            });
-        }
-        if (lowerTask.includes('ticket') || lowerTask.includes('incident')) {
-            mappings.push({
-                source: 'external_ticket',
-                target: 'incident',
-                fields: [
-                    { source: 'title', target: 'short_description', transformation: 'truncate' },
-                    { source: 'description', target: 'description', transformation: 'none' },
-                    { source: 'severity', target: 'priority', transformation: 'map_values' }
-                ]
-            });
-        }
-        return {
-            mappings,
-            transformations: this.identifyDataTransformations(mappings),
-            validation: this.identifyMappingValidation(mappings)
-        };
-    }
-    identifyDataTransformations(mappings) {
-        const transformations = [];
-        mappings.forEach(mapping => {
-            mapping.fields.forEach(field => {
-                if (field.transformation !== 'none') {
-                    transformations.push({
-                        type: field.transformation,
-                        field: field.target,
-                        description: `Apply ${field.transformation} to ${field.source}`
-                    });
-                }
-            });
-        });
-        return transformations;
-    }
-    identifyMappingValidation(mappings) {
-        const validations = [];
-        mappings.forEach(mapping => {
-            validations.push({
-                entity: mapping.target,
-                rules: [
-                    'required_fields_present',
-                    'data_types_match',
-                    'referential_integrity'
-                ]
-            });
-        });
-        return validations;
-    }
-    analyzeSecurityRequirements(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            encryption: {
-                inTransit: true,
-                atRest: lowerTask.includes('sensitive') || lowerTask.includes('secure'),
-                algorithm: 'aes256'
-            },
-            authentication: {
-                method: this.determineAuthMethod(task),
-                tokenExpiry: '1h',
-                refreshToken: true
-            },
-            authorization: {
-                rbac: true,
-                scopes: this.identifyRequiredScopes(task),
-                auditLogging: true
-            },
-            compliance: {
-                gdpr: lowerTask.includes('gdpr') || lowerTask.includes('privacy'),
-                sox: lowerTask.includes('sox') || lowerTask.includes('financial'),
-                hipaa: lowerTask.includes('hipaa') || lowerTask.includes('medical')
-            }
-        };
-    }
-    identifyRequiredScopes(task) {
-        const scopes = ['read'];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('create') || lowerTask.includes('add')) {
-            scopes.push('write');
-        }
-        if (lowerTask.includes('update') || lowerTask.includes('modify')) {
-            scopes.push('update');
-        }
-        if (lowerTask.includes('delete') || lowerTask.includes('remove')) {
-            scopes.push('delete');
-        }
-        if (lowerTask.includes('admin')) {
-            scopes.push('admin');
-        }
-        return scopes;
-    }
-    analyzeErrorHandling(task) {
-        return {
-            retryPolicy: {
-                enabled: true,
-                maxRetries: 3,
-                backoffStrategy: 'exponential',
-                retryableErrors: ['timeout', 'rate_limit', 'temporary_failure']
-            },
-            fallbackStrategy: {
-                enabled: true,
-                fallbackActions: ['cache_response', 'default_values', 'manual_intervention']
-            },
-            monitoring: {
-                healthChecks: true,
-                alerting: true,
-                metricsCollection: true
-            },
-            gracefulDegradation: {
-                enabled: true,
-                partialFailureHandling: true
-            }
-        };
-    }
-    async createIntegrationArchitecture(requirements) {
-        return {
-            pattern: this.selectIntegrationPattern(requirements),
-            components: this.identifyArchitecturalComponents(requirements),
-            dataFlow: this.designDataFlow(requirements),
-            security: this.designSecurityArchitecture(requirements),
-            scalability: this.designScalability(requirements)
-        };
-    }
-    selectIntegrationPattern(requirements) {
-        if (requirements.systems.length > 2) {
-            return 'hub_and_spoke';
-        }
-        else if (requirements.systems.some(s => s.type === 'service')) {
-            return 'api_gateway';
-        }
-        else if (requirements.apis.type === 'soap') {
-            return 'enterprise_service_bus';
-        }
-        return 'point_to_point';
-    }
-    identifyArchitecturalComponents(requirements) {
-        const components = ['integration_engine'];
-        if (requirements.apis.authentication === 'oauth2') {
-            components.push('oauth_client');
-        }
-        if (requirements.dataMapping.mappings.length > 0) {
-            components.push('data_transformer');
-        }
-        if (requirements.errorHandling.retryPolicy.enabled) {
-            components.push('retry_handler');
-        }
-        if (requirements.security.encryption.inTransit) {
-            components.push('encryption_manager');
-        }
-        return components;
-    }
-    designDataFlow(requirements) {
-        return {
-            direction: 'bidirectional',
-            frequency: 'real_time',
-            batchSize: requirements.systems.length > 1 ? 100 : 1,
-            transformation: requirements.dataMapping.mappings.length > 0,
-            validation: true,
-            errorHandling: requirements.errorHandling
-        };
-    }
-    designSecurityArchitecture(requirements) {
-        return {
-            layers: ['transport', 'application', 'data'],
-            encryption: requirements.security.encryption,
-            authentication: requirements.security.authentication,
-            authorization: requirements.security.authorization,
-            compliance: requirements.security.compliance
-        };
-    }
-    designScalability(requirements) {
-        return {
-            horizontal: requirements.systems.length > 2,
-            loadBalancing: true,
-            caching: true,
-            circuitBreaker: true,
-            rateLimiting: requirements.apis.rateLimiting
-        };
-    }
-    async createImplementationPlan(requirements) {
-        return {
-            phases: this.createImplementationPhases(requirements),
-            timeline: this.estimateTimeline(requirements),
-            resources: this.identifyRequiredResources(requirements),
-            risks: this.identifyImplementationRisks(requirements),
-            testing: this.createTestingStrategy(requirements)
-        };
-    }
-    createImplementationPhases(requirements) {
-        const phases = [
-            {
-                name: 'Setup and Configuration',
-                tasks: ['Configure authentication', 'Set up connection pools', 'Initialize security'],
-                duration: '1-2 days'
-            },
-            {
-                name: 'Core Integration',
-                tasks: ['Implement API calls', 'Set up data mapping', 'Configure error handling'],
-                duration: '3-5 days'
-            },
-            {
-                name: 'Testing and Validation',
-                tasks: ['Unit testing', 'Integration testing', 'Performance testing'],
-                duration: '2-3 days'
-            },
-            {
-                name: 'Deployment and Monitoring',
-                tasks: ['Production deployment', 'Monitoring setup', 'Documentation'],
-                duration: '1-2 days'
-            }
-        ];
-        return phases;
-    }
-    estimateTimeline(requirements) {
-        const complexity = requirements.systems.length;
-        const baseWeeks = Math.max(1, complexity);
-        return `${baseWeeks} week${baseWeeks > 1 ? 's' : ''}`;
-    }
-    identifyRequiredResources(requirements) {
-        const resources = ['Integration Developer', 'System Administrator'];
-        if (requirements.security.compliance.gdpr || requirements.security.compliance.sox) {
-            resources.push('Security Specialist');
-        }
-        if (requirements.systems.some(s => s.type === 'data')) {
-            resources.push('Database Administrator');
-        }
-        return resources;
-    }
-    identifyImplementationRisks(requirements) {
-        const risks = [
-            {
-                risk: 'External system availability',
-                impact: 'high',
-                probability: 'medium',
-                mitigation: 'Implement circuit breaker pattern'
-            },
-            {
-                risk: 'Data mapping complexity',
-                impact: 'medium',
-                probability: 'high',
-                mitigation: 'Thorough testing and validation'
-            }
-        ];
-        if (requirements.security.compliance.gdpr) {
-            risks.push({
-                risk: 'GDPR compliance violation',
-                impact: 'high',
-                probability: 'low',
-                mitigation: 'Data protection impact assessment'
-            });
-        }
-        return risks;
-    }
-    createTestingStrategy(requirements) {
-        return {
-            unit: {
-                framework: 'jasmine',
-                coverage: 90,
-                focus: 'data transformation and validation'
-            },
-            integration: {
-                environment: 'staging',
-                dataSet: 'synthetic',
-                scenarios: ['happy path', 'error conditions', 'edge cases']
-            },
-            performance: {
-                loadTesting: requirements.systems.length > 1,
-                stressTesting: true,
-                enduranceTesting: false
-            },
-            security: {
-                penetrationTesting: requirements.security.compliance.gdpr,
-                vulnerabilityScanning: true,
-                complianceValidation: Object.values(requirements.security.compliance).some(Boolean)
-            }
-        };
-    }
-}
-exports.IntegrationSpecialist = IntegrationSpecialist;
-class SecuritySpecialist extends base_specialist_js_1.BaseSpecialist {
-    constructor(options = {}) {
-        super('Security Reviewer', 'Security Specialist', ['Security Analysis', 'Access Control', 'Compliance', 'Vulnerability Assessment'], options);
-    }
-    async execute(task, context) {
-        await this.logProgress(`Analyzing security requirements for: ${task}`);
-        const analysis = await this.analyzeTask(task);
-        const securityRequirements = {
-            authentication: this.analyzeAuthenticationNeeds(task),
-            authorization: this.analyzeAuthorizationNeeds(task),
-            dataProtection: this.analyzeDataProtectionNeeds(task),
-            auditCompliance: this.analyzeComplianceNeeds(task),
-            vulnerabilities: this.identifyVulnerabilities(task),
-            monitoring: this.analyzeMonitoringNeeds(task)
-        };
-        await this.logProgress('Designing security controls');
-        const securityControls = await this.createSecurityControls(securityRequirements);
-        await this.logProgress('Creating security implementation plan');
-        const securityPlan = await this.createSecurityPlan(securityRequirements);
-        return {
-            ...analysis,
-            specialist: 'Security Specialist',
-            deliverables: {
-                securityControls,
-                securityPlan,
-                requirements: securityRequirements
-            }
-        };
-    }
-    analyzeAuthenticationNeeds(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            required: true,
-            methods: this.identifyAuthMethods(task),
-            strength: lowerTask.includes('sensitive') || lowerTask.includes('critical') ? 'strong' : 'standard',
-            mfa: lowerTask.includes('mfa') || lowerTask.includes('two factor'),
-            sessionManagement: true,
-            passwordPolicy: this.createPasswordPolicy(task)
-        };
-    }
-    identifyAuthMethods(task) {
-        const methods = ['local'];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('sso') || lowerTask.includes('saml')) {
-            methods.push('sso');
-        }
-        if (lowerTask.includes('ldap')) {
-            methods.push('ldap');
-        }
-        if (lowerTask.includes('oauth')) {
-            methods.push('oauth2');
-        }
-        return methods;
-    }
-    createPasswordPolicy(task) {
-        const lowerTask = task.toLowerCase();
-        const isHighSecurity = lowerTask.includes('sensitive') || lowerTask.includes('critical');
-        return {
-            minimumLength: isHighSecurity ? 12 : 8,
-            complexity: isHighSecurity ? 'high' : 'medium',
-            expiration: isHighSecurity ? 90 : 180,
-            history: isHighSecurity ? 12 : 6,
-            lockoutPolicy: {
-                attempts: 5,
-                duration: 15,
-                progressive: true
-            }
-        };
-    }
-    analyzeAuthorizationNeeds(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            model: 'rbac',
-            roles: this.identifyRequiredRoles(task),
-            permissions: this.identifyRequiredPermissions(task),
-            inheritance: true,
-            delegation: lowerTask.includes('delegate') || lowerTask.includes('proxy'),
-            auditTrail: true
-        };
-    }
-    identifyRequiredRoles(task) {
-        const roles = ['user'];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('admin')) {
-            roles.push('admin');
-        }
-        if (lowerTask.includes('manager') || lowerTask.includes('supervisor')) {
-            roles.push('manager');
-        }
-        if (lowerTask.includes('approval')) {
-            roles.push('approver');
-        }
-        if (lowerTask.includes('security')) {
-            roles.push('security_officer');
-        }
-        return roles;
-    }
-    identifyRequiredPermissions(task) {
-        const permissions = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('read') || lowerTask.includes('view')) {
-            permissions.push({
-                action: 'read',
-                resource: 'flow_data',
-                conditions: []
-            });
-        }
-        if (lowerTask.includes('create') || lowerTask.includes('add')) {
-            permissions.push({
-                action: 'create',
-                resource: 'flow_instances',
-                conditions: ['own_department']
-            });
-        }
-        if (lowerTask.includes('update') || lowerTask.includes('modify')) {
-            permissions.push({
-                action: 'update',
-                resource: 'flow_instances',
-                conditions: ['own_records', 'assigned_to_user']
-            });
-        }
-        if (lowerTask.includes('delete')) {
-            permissions.push({
-                action: 'delete',
-                resource: 'flow_instances',
-                conditions: ['admin_role']
-            });
-        }
-        return permissions;
-    }
-    analyzeDataProtectionNeeds(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            classification: this.classifyDataSensitivity(task),
-            encryption: {
-                inTransit: true,
-                atRest: lowerTask.includes('sensitive') || lowerTask.includes('confidential'),
-                keyManagement: 'automatic'
-            },
-            masking: lowerTask.includes('pii') || lowerTask.includes('personal'),
-            retention: this.defineRetentionPolicy(task),
-            disposal: 'secure_deletion'
-        };
-    }
-    classifyDataSensitivity(task) {
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('confidential') || lowerTask.includes('secret')) {
-            return 'confidential';
-        }
-        else if (lowerTask.includes('sensitive') || lowerTask.includes('pii')) {
-            return 'sensitive';
-        }
-        else if (lowerTask.includes('internal')) {
-            return 'internal';
-        }
-        return 'public';
-    }
-    defineRetentionPolicy(task) {
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('audit') || lowerTask.includes('compliance')) {
-            return { period: '7_years', reason: 'regulatory' };
-        }
-        else if (lowerTask.includes('financial')) {
-            return { period: '7_years', reason: 'financial_records' };
-        }
-        else if (lowerTask.includes('hr') || lowerTask.includes('employee')) {
-            return { period: '7_years', reason: 'employment_records' };
-        }
-        return { period: '3_years', reason: 'business_records' };
-    }
-    analyzeComplianceNeeds(task) {
-        const lowerTask = task.toLowerCase();
-        const frameworks = [];
-        if (lowerTask.includes('gdpr') || lowerTask.includes('privacy')) {
-            frameworks.push('gdpr');
-        }
-        if (lowerTask.includes('sox') || lowerTask.includes('financial')) {
-            frameworks.push('sox');
-        }
-        if (lowerTask.includes('hipaa') || lowerTask.includes('medical')) {
-            frameworks.push('hipaa');
-        }
-        if (lowerTask.includes('pci') || lowerTask.includes('payment')) {
-            frameworks.push('pci_dss');
-        }
-        return {
-            frameworks,
-            auditRequirements: this.defineAuditRequirements(frameworks),
-            reportingRequirements: this.defineReportingRequirements(frameworks),
-            controls: this.defineComplianceControls(frameworks)
-        };
-    }
-    defineAuditRequirements(frameworks) {
-        return {
-            frequency: frameworks.includes('sox') ? 'quarterly' : 'annually',
-            scope: 'comprehensive',
-            documentation: 'required',
-            evidenceCollection: 'automated',
-            reporting: 'executive_summary'
-        };
-    }
-    defineReportingRequirements(frameworks) {
-        const requirements = {
-            frequency: 'monthly',
-            format: 'dashboard',
-            recipients: ['security_team', 'compliance_officer'],
-            metrics: ['access_attempts', 'policy_violations', 'security_incidents']
-        };
-        if (frameworks.includes('gdpr')) {
-            requirements.metrics.push('data_subject_requests', 'breach_notifications');
-        }
-        return requirements;
-    }
-    defineComplianceControls(frameworks) {
-        const controls = [
-            {
-                id: 'AC-1',
-                name: 'Access Control Policy',
-                description: 'Implement and maintain access control policies',
-                framework: 'general'
-            }
-        ];
-        if (frameworks.includes('gdpr')) {
-            controls.push({
-                id: 'GDPR-1',
-                name: 'Data Subject Rights',
-                description: 'Implement processes for data subject requests',
-                framework: 'gdpr'
-            });
-        }
-        if (frameworks.includes('sox')) {
-            controls.push({
-                id: 'SOX-1',
-                name: 'Financial Data Controls',
-                description: 'Controls for financial data integrity',
-                framework: 'sox'
-            });
-        }
-        return controls;
-    }
-    identifyVulnerabilities(task) {
-        const vulnerabilities = [
-            {
-                category: 'injection',
-                risk: 'medium',
-                description: 'SQL injection vulnerabilities in data processing',
-                mitigation: 'parameterized_queries'
-            },
-            {
-                category: 'authentication',
-                risk: 'high',
-                description: 'Weak authentication mechanisms',
-                mitigation: 'strong_authentication'
-            },
-            {
-                category: 'authorization',
-                risk: 'medium',
-                description: 'Insufficient access controls',
-                mitigation: 'rbac_implementation'
-            }
-        ];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('api') || lowerTask.includes('integration')) {
-            vulnerabilities.push({
-                category: 'api_security',
-                risk: 'high',
-                description: 'Insecure API endpoints',
-                mitigation: 'api_security_controls'
-            });
-        }
-        return vulnerabilities;
-    }
-    analyzeMonitoringNeeds(task) {
-        return {
-            realTime: true,
-            events: [
-                'authentication_failures',
-                'authorization_violations',
-                'data_access_anomalies',
-                'privilege_escalations'
-            ],
-            alerting: {
-                immediate: ['security_breaches', 'critical_violations'],
-                periodic: ['policy_violations', 'access_reviews']
-            },
-            logging: {
-                level: 'comprehensive',
-                retention: '1_year',
-                integrity: 'tamper_proof'
-            },
-            reporting: {
-                frequency: 'daily',
-                format: 'dashboard',
-                distribution: ['security_team', 'administrators']
-            }
-        };
-    }
-    async createSecurityControls(requirements) {
-        return {
-            preventive: this.createPreventiveControls(requirements),
-            detective: this.createDetectiveControls(requirements),
-            corrective: this.createCorrectiveControls(requirements),
-            compensating: this.createCompensatingControls(requirements)
-        };
-    }
-    createPreventiveControls(requirements) {
-        const controls = [
-            {
-                name: 'Authentication Controls',
-                type: 'preventive',
-                implementation: requirements.authentication,
-                priority: 'high'
-            },
-            {
-                name: 'Authorization Controls',
-                type: 'preventive',
-                implementation: requirements.authorization,
-                priority: 'high'
-            },
-            {
-                name: 'Data Encryption',
-                type: 'preventive',
-                implementation: requirements.dataProtection.encryption,
-                priority: 'medium'
-            }
-        ];
-        return controls;
-    }
-    createDetectiveControls(requirements) {
-        return [
-            {
-                name: 'Security Monitoring',
-                type: 'detective',
-                implementation: requirements.monitoring,
-                priority: 'high'
-            },
-            {
-                name: 'Audit Logging',
-                type: 'detective',
-                implementation: requirements.auditCompliance.auditRequirements,
-                priority: 'medium'
-            }
-        ];
-    }
-    createCorrectiveControls(requirements) {
-        return [
-            {
-                name: 'Incident Response',
-                type: 'corrective',
-                implementation: {
-                    automated: true,
-                    escalation: 'progressive',
-                    containment: 'immediate'
-                },
-                priority: 'high'
-            },
-            {
-                name: 'Access Revocation',
-                type: 'corrective',
-                implementation: {
-                    automatic: true,
-                    conditions: ['policy_violation', 'suspicious_activity']
-                },
-                priority: 'medium'
-            }
-        ];
-    }
-    createCompensatingControls(requirements) {
-        return [
-            {
-                name: 'Manual Review Process',
-                type: 'compensating',
-                implementation: {
-                    frequency: 'weekly',
-                    scope: 'high_risk_transactions'
-                },
-                priority: 'low'
-            }
-        ];
-    }
-    async createSecurityPlan(requirements) {
-        return {
-            implementation: {
-                phases: this.createSecurityPhases(),
-                timeline: '2-4 weeks',
-                resources: ['Security Engineer', 'System Administrator'],
-                budget: 'moderate'
-            },
-            testing: {
-                penetrationTesting: requirements.dataProtection.classification === 'confidential',
-                vulnerabilityScanning: true,
-                complianceValidation: requirements.auditCompliance.frameworks.length > 0
-            },
-            maintenance: {
-                reviews: 'quarterly',
-                updates: 'as_needed',
-                training: 'annual'
-            },
-            compliance: requirements.auditCompliance
-        };
-    }
-    createSecurityPhases() {
-        return [
-            {
-                name: 'Security Assessment',
-                duration: '3-5 days',
-                activities: ['Risk assessment', 'Vulnerability analysis', 'Control gap analysis']
-            },
-            {
-                name: 'Control Implementation',
-                duration: '1-2 weeks',
-                activities: ['Deploy security controls', 'Configure monitoring', 'Set up alerting']
-            },
-            {
-                name: 'Testing and Validation',
-                duration: '3-5 days',
-                activities: ['Security testing', 'Compliance validation', 'Performance impact assessment']
-            },
-            {
-                name: 'Documentation and Training',
-                duration: '2-3 days',
-                activities: ['Document procedures', 'Create user guides', 'Conduct training sessions']
-            }
-        ];
-    }
-}
-exports.SecuritySpecialist = SecuritySpecialist;
-//# sourceMappingURL=flow-specialists.js.map