snow-flow 3.0.9 → 3.0.10

package/dist/specialists/app-specialists.js

@@ -1,1639 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerformanceSpecialist = exports.InterfaceSpecialist = exports.BusinessLogicSpecialist = exports.DatabaseSpecialist = void 0;
-const base_specialist_js_1 = require("./base-specialist.js");
-class DatabaseSpecialist extends base_specialist_js_1.BaseSpecialist {
-    constructor(options = {}) {
-        super('Database Designer', 'Database Designer', ['Table Design', 'Relationships', 'Indexing', 'Performance', 'Data Modeling'], options);
-    }
-    async execute(task, context) {
-        await this.logProgress(`Analyzing database requirements for: ${task}`);
-        const analysis = await this.analyzeTask(task);
-        const dbRequirements = {
-            tables: this.identifyTables(task),
-            relationships: this.analyzeRelationships(task),
-            fields: this.identifyFields(task),
-            indexes: this.analyzeIndexingNeeds(task),
-            constraints: this.identifyConstraints(task),
-            performance: this.analyzePerformanceRequirements(task)
-        };
-        await this.logProgress('Designing database schema');
-        const schema = await this.createDatabaseSchema(dbRequirements);
-        await this.logProgress('Creating table definitions and relationships');
-        const tableDefinitions = await this.createTableDefinitions(dbRequirements);
-        return {
-            ...analysis,
-            specialist: 'Database Designer',
-            deliverables: {
-                schema,
-                tableDefinitions,
-                requirements: dbRequirements
-            }
-        };
-    }
-    identifyTables(task) {
-        const tables = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('itsm') || lowerTask.includes('service management')) {
-            tables.push({ name: 'custom_incident', label: 'Custom Incident', extends: 'incident' }, { name: 'custom_request', label: 'Custom Request', extends: 'sc_request' }, { name: 'custom_change', label: 'Custom Change', extends: 'change_request' });
-        }
-        if (lowerTask.includes('asset') || lowerTask.includes('inventory')) {
-            tables.push({ name: 'custom_asset', label: 'Custom Asset', extends: 'alm_asset' }, { name: 'asset_location', label: 'Asset Location', extends: 'cmn_location' });
-        }
-        if (lowerTask.includes('hr') || lowerTask.includes('employee')) {
-            tables.push({ name: 'employee_profile', label: 'Employee Profile', extends: 'sys_user' }, { name: 'employee_skill', label: 'Employee Skills', extends: '' }, { name: 'skill_category', label: 'Skill Categories', extends: '' });
-        }
-        if (lowerTask.includes('project') || lowerTask.includes('task')) {
-            tables.push({ name: 'project', label: 'Projects', extends: '' }, { name: 'project_task', label: 'Project Tasks', extends: 'task' }, { name: 'project_milestone', label: 'Project Milestones', extends: '' });
-        }
-        if (lowerTask.includes('financial') || lowerTask.includes('budget')) {
-            tables.push({ name: 'budget_item', label: 'Budget Items', extends: '' }, { name: 'expense_record', label: 'Expense Records', extends: '' }, { name: 'cost_center', label: 'Cost Centers', extends: '' });
-        }
-        // If no specific domain identified, create generic tables
-        if (tables.length === 0) {
-            tables.push({ name: 'custom_record', label: 'Custom Records', extends: '' }, { name: 'custom_category', label: 'Custom Categories', extends: '' });
-        }
-        return tables;
-    }
-    analyzeRelationships(task) {
-        const relationships = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('itsm')) {
-            relationships.push({
-                from: 'custom_incident',
-                to: 'sys_user',
-                type: 'many_to_one',
-                field: 'assigned_to',
-                description: 'Incident assignment relationship'
-            }, {
-                from: 'custom_request',
-                to: 'sys_user',
-                type: 'many_to_one',
-                field: 'requested_for',
-                description: 'Request requester relationship'
-            });
-        }
-        if (lowerTask.includes('asset')) {
-            relationships.push({
-                from: 'custom_asset',
-                to: 'asset_location',
-                type: 'many_to_one',
-                field: 'location',
-                description: 'Asset location relationship'
-            }, {
-                from: 'custom_asset',
-                to: 'sys_user',
-                type: 'many_to_one',
-                field: 'assigned_to',
-                description: 'Asset ownership relationship'
-            });
-        }
-        if (lowerTask.includes('project')) {
-            relationships.push({
-                from: 'project_task',
-                to: 'project',
-                type: 'many_to_one',
-                field: 'project',
-                description: 'Task to project relationship'
-            }, {
-                from: 'project_milestone',
-                to: 'project',
-                type: 'many_to_one',
-                field: 'project',
-                description: 'Milestone to project relationship'
-            });
-        }
-        return relationships;
-    }
-    identifyFields(task) {
-        const lowerTask = task.toLowerCase();
-        const commonFields = {
-            core: [
-                { name: 'sys_id', type: 'GUID', label: 'Sys ID', mandatory: true },
-                { name: 'sys_created_on', type: 'glide_date_time', label: 'Created', mandatory: true },
-                { name: 'sys_created_by', type: 'reference', label: 'Created by', mandatory: true },
-                { name: 'sys_updated_on', type: 'glide_date_time', label: 'Updated', mandatory: true },
-                { name: 'sys_updated_by', type: 'reference', label: 'Updated by', mandatory: true }
-            ],
-            standard: [
-                { name: 'number', type: 'string', label: 'Number', mandatory: true },
-                { name: 'short_description', type: 'string', label: 'Short description', mandatory: true },
-                { name: 'description', type: 'html', label: 'Description', mandatory: false },
-                { name: 'state', type: 'integer', label: 'State', mandatory: true },
-                { name: 'priority', type: 'integer', label: 'Priority', mandatory: false }
-            ]
-        };
-        const domainSpecificFields = {};
-        if (lowerTask.includes('itsm')) {
-            domainSpecificFields.itsm = [
-                { name: 'impact', type: 'integer', label: 'Impact', mandatory: false },
-                { name: 'urgency', type: 'integer', label: 'Urgency', mandatory: false },
-                { name: 'assignment_group', type: 'reference', label: 'Assignment group', mandatory: false },
-                { name: 'assigned_to', type: 'reference', label: 'Assigned to', mandatory: false },
-                { name: 'category', type: 'string', label: 'Category', mandatory: false }
-            ];
-        }
-        if (lowerTask.includes('asset')) {
-            domainSpecificFields.asset = [
-                { name: 'asset_tag', type: 'string', label: 'Asset tag', mandatory: true },
-                { name: 'serial_number', type: 'string', label: 'Serial number', mandatory: false },
-                { name: 'model', type: 'reference', label: 'Model', mandatory: false },
-                { name: 'location', type: 'reference', label: 'Location', mandatory: false },
-                { name: 'cost', type: 'currency', label: 'Cost', mandatory: false }
-            ];
-        }
-        if (lowerTask.includes('project')) {
-            domainSpecificFields.project = [
-                { name: 'start_date', type: 'glide_date', label: 'Start date', mandatory: false },
-                { name: 'end_date', type: 'glide_date', label: 'End date', mandatory: false },
-                { name: 'percent_complete', type: 'integer', label: 'Percent complete', mandatory: false },
-                { name: 'project_manager', type: 'reference', label: 'Project manager', mandatory: false },
-                { name: 'budget', type: 'currency', label: 'Budget', mandatory: false }
-            ];
-        }
-        return { commonFields, domainSpecificFields };
-    }
-    analyzeIndexingNeeds(task) {
-        const indexes = [];
-        // Common indexes for all tables
-        indexes.push({ fields: ['sys_created_on'], type: 'btree', purpose: 'creation_date_queries' }, { fields: ['sys_updated_on'], type: 'btree', purpose: 'modification_date_queries' }, { fields: ['number'], type: 'unique', purpose: 'number_lookup' });
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('itsm')) {
-            indexes.push({ fields: ['state'], type: 'hash', purpose: 'state_filtering' }, { fields: ['priority'], type: 'btree', purpose: 'priority_sorting' }, { fields: ['assigned_to'], type: 'btree', purpose: 'assignment_queries' }, { fields: ['assignment_group'], type: 'btree', purpose: 'group_assignment_queries' });
-        }
-        if (lowerTask.includes('asset')) {
-            indexes.push({ fields: ['asset_tag'], type: 'unique', purpose: 'asset_tag_lookup' }, { fields: ['serial_number'], type: 'btree', purpose: 'serial_number_search' }, { fields: ['location'], type: 'btree', purpose: 'location_queries' });
-        }
-        if (lowerTask.includes('project')) {
-            indexes.push({ fields: ['start_date'], type: 'btree', purpose: 'date_range_queries' }, { fields: ['end_date'], type: 'btree', purpose: 'deadline_queries' }, { fields: ['project_manager'], type: 'btree', purpose: 'manager_queries' });
-        }
-        return indexes;
-    }
-    identifyConstraints(task) {
-        const constraints = [];
-        // Common constraints
-        constraints.push({ type: 'not_null', field: 'number', description: 'Number field cannot be null' }, { type: 'not_null', field: 'short_description', description: 'Short description is required' }, { type: 'unique', field: 'number', description: 'Number must be unique' });
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('asset')) {
-            constraints.push({ type: 'unique', field: 'asset_tag', description: 'Asset tag must be unique' }, { type: 'check', field: 'cost', condition: 'cost >= 0', description: 'Cost cannot be negative' });
-        }
-        if (lowerTask.includes('project')) {
-            constraints.push({ type: 'check', field: 'percent_complete', condition: 'percent_complete BETWEEN 0 AND 100', description: 'Percent complete must be between 0 and 100' }, { type: 'check', field: 'dates', condition: 'end_date >= start_date', description: 'End date must be after start date' });
-        }
-        return constraints;
-    }
-    analyzePerformanceRequirements(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            expectedVolume: this.estimateDataVolume(task),
-            queryPatterns: this.identifyQueryPatterns(task),
-            performanceTargets: {
-                insertTime: lowerTask.includes('high volume') ? '< 100ms' : '< 50ms',
-                queryTime: '< 200ms',
-                updateTime: '< 150ms'
-            },
-            partitioning: lowerTask.includes('large') || lowerTask.includes('enterprise'),
-            archiving: lowerTask.includes('historical') || lowerTask.includes('audit')
-        };
-    }
-    estimateDataVolume(task) {
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('enterprise') || lowerTask.includes('large')) {
-            return 'high'; // 1M+ records
-        }
-        else if (lowerTask.includes('medium') || lowerTask.includes('department')) {
-            return 'medium'; // 100K-1M records
-        }
-        return 'low'; // < 100K records
-    }
-    identifyQueryPatterns(task) {
-        const patterns = ['single_record_lookup', 'list_views'];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('report') || lowerTask.includes('analytics')) {
-            patterns.push('aggregation_queries', 'complex_joins');
-        }
-        if (lowerTask.includes('dashboard')) {
-            patterns.push('real_time_queries', 'count_queries');
-        }
-        if (lowerTask.includes('search')) {
-            patterns.push('full_text_search', 'fuzzy_matching');
-        }
-        return patterns;
-    }
-    async createDatabaseSchema(requirements) {
-        const schema = {
-            tables: requirements.tables,
-            relationships: requirements.relationships,
-            indexes: requirements.indexes,
-            constraints: requirements.constraints,
-            performance: requirements.performance,
-            metadata: {
-                version: '1.0',
-                created: new Date(),
-                description: 'Auto-generated database schema'
-            }
-        };
-        return schema;
-    }
-    async createTableDefinitions(requirements) {
-        const definitions = [];
-        for (const table of requirements.tables) {
-            const definition = {
-                name: table.name,
-                label: table.label,
-                extends: table.extends,
-                fields: this.generateFieldDefinitions(table, requirements.fields),
-                indexes: this.generateTableIndexes(table, requirements.indexes),
-                constraints: this.generateTableConstraints(table, requirements.constraints),
-                permissions: this.generateTablePermissions(table),
-                businessRules: this.generateBusinessRules(table)
-            };
-            definitions.push(definition);
-        }
-        return definitions;
-    }
-    generateFieldDefinitions(table, fieldsConfig) {
-        const fields = [...fieldsConfig.commonFields.core, ...fieldsConfig.commonFields.standard];
-        // Add domain-specific fields based on table type
-        if (table.name.includes('incident') || table.name.includes('request')) {
-            fields.push(...(fieldsConfig.domainSpecificFields.itsm || []));
-        }
-        else if (table.name.includes('asset')) {
-            fields.push(...(fieldsConfig.domainSpecificFields.asset || []));
-        }
-        else if (table.name.includes('project')) {
-            fields.push(...(fieldsConfig.domainSpecificFields.project || []));
-        }
-        return fields;
-    }
-    generateTableIndexes(table, indexes) {
-        return indexes.filter(index => 
-        // Include common indexes and table-specific ones
-        index.purpose.includes('common') ||
-            index.purpose.includes(table.name) ||
-            (table.name.includes('incident') && index.purpose.includes('itsm')) ||
-            (table.name.includes('asset') && index.purpose.includes('asset')));
-    }
-    generateTableConstraints(table, constraints) {
-        return constraints.filter(constraint => 
-        // Include constraints relevant to this table
-        !constraint.tableSpecific || constraint.tableSpecific.includes(table.name));
-    }
-    generateTablePermissions(table) {
-        return {
-            read: ['user', 'admin'],
-            write: ['admin'],
-            create: ['admin'],
-            delete: ['admin'],
-            acl_rules: [
-                {
-                    name: `${table.name}_read`,
-                    type: 'read',
-                    roles: 'user',
-                    condition: ''
-                },
-                {
-                    name: `${table.name}_write`,
-                    type: 'write',
-                    roles: 'admin',
-                    condition: ''
-                }
-            ]
-        };
-    }
-    generateBusinessRules(table) {
-        return [
-            {
-                name: `${table.name}_auto_number`,
-                when: 'before',
-                insert: true,
-                script: `if (current.number.nil()) { current.number = new NumberManager('${table.name}').getNextObjNumber(); }`
-            },
-            {
-                name: `${table.name}_audit_log`,
-                when: 'after',
-                insert: true,
-                update: true,
-                script: `gs.log('${table.name} record modified: ' + current.number);`
-            }
-        ];
-    }
-}
-exports.DatabaseSpecialist = DatabaseSpecialist;
-class BusinessLogicSpecialist extends base_specialist_js_1.BaseSpecialist {
-    constructor(options = {}) {
-        super('Business Logic Developer', 'Business Logic Developer', ['Business Rules', 'Script Includes', 'Workflows', 'Calculations', 'Validations'], options);
-    }
-    async execute(task, context) {
-        await this.logProgress(`Analyzing business logic requirements for: ${task}`);
-        const analysis = await this.analyzeTask(task);
-        const logicRequirements = {
-            businessRules: this.identifyBusinessRules(task),
-            scriptIncludes: this.identifyScriptIncludes(task),
-            calculations: this.identifyCalculations(task),
-            validations: this.identifyValidations(task),
-            workflows: this.identifyWorkflows(task),
-            automations: this.identifyAutomations(task)
-        };
-        await this.logProgress('Designing business logic architecture');
-        const logicArchitecture = await this.createLogicArchitecture(logicRequirements);
-        await this.logProgress('Creating business logic implementations');
-        const implementations = await this.createImplementations(logicRequirements);
-        return {
-            ...analysis,
-            specialist: 'Business Logic Developer',
-            deliverables: {
-                logicArchitecture,
-                implementations,
-                requirements: logicRequirements
-            }
-        };
-    }
-    identifyBusinessRules(task) {
-        const rules = [];
-        const lowerTask = task.toLowerCase();
-        // Auto-numbering rules
-        rules.push({
-            name: 'Auto Number Generation',
-            type: 'before_insert',
-            description: 'Automatically generate unique numbers for new records',
-            priority: 100,
-            table: 'auto_detect'
-        });
-        if (lowerTask.includes('itsm')) {
-            rules.push({
-                name: 'Priority Calculation',
-                type: 'before_insert_update',
-                description: 'Calculate priority based on impact and urgency',
-                priority: 200,
-                table: 'incident'
-            }, {
-                name: 'Assignment Group Population',
-                type: 'before_insert_update',
-                description: 'Auto-populate assignment group based on category',
-                priority: 300,
-                table: 'incident'
-            }, {
-                name: 'SLA Start Trigger',
-                type: 'after_insert',
-                description: 'Start SLA timers when incident is created',
-                priority: 400,
-                table: 'incident'
-            });
-        }
-        if (lowerTask.includes('asset')) {
-            rules.push({
-                name: 'Asset Tag Validation',
-                type: 'before_insert_update',
-                description: 'Validate asset tag format and uniqueness',
-                priority: 200,
-                table: 'asset'
-            }, {
-                name: 'Depreciation Calculation',
-                type: 'before_update',
-                description: 'Calculate asset depreciation on cost changes',
-                priority: 300,
-                table: 'asset'
-            });
-        }
-        if (lowerTask.includes('approval')) {
-            rules.push({
-                name: 'Approval Chain Trigger',
-                type: 'after_insert_update',
-                description: 'Trigger approval workflow based on request value',
-                priority: 500,
-                table: 'request'
-            });
-        }
-        return rules;
-    }
-    identifyScriptIncludes(task) {
-        const scriptIncludes = [];
-        const lowerTask = task.toLowerCase();
-        // Common utility script includes
-        scriptIncludes.push({
-            name: 'ApplicationUtils',
-            description: 'Common utility functions for the application',
-            clientCallable: false,
-            functions: ['validateData', 'formatNumber', 'calculateDate']
-        });
-        if (lowerTask.includes('itsm')) {
-            scriptIncludes.push({
-                name: 'IncidentUtils',
-                description: 'Utility functions for incident management',
-                clientCallable: true,
-                functions: ['calculatePriority', 'getAssignmentGroup', 'checkSLA']
-            }, {
-                name: 'ITSMIntegration',
-                description: 'Integration functions for ITSM processes',
-                clientCallable: false,
-                functions: ['syncWithCMDB', 'updateAssetStatus', 'createChangeRequest']
-            });
-        }
-        if (lowerTask.includes('asset')) {
-            scriptIncludes.push({
-                name: 'AssetManager',
-                description: 'Asset management utility functions',
-                clientCallable: true,
-                functions: ['calculateDepreciation', 'validateAssetTag', 'getAssetHistory']
-            });
-        }
-        if (lowerTask.includes('notification') || lowerTask.includes('email')) {
-            scriptIncludes.push({
-                name: 'NotificationUtils',
-                description: 'Notification and communication utilities',
-                clientCallable: false,
-                functions: ['sendEmail', 'formatNotification', 'getRecipients']
-            });
-        }
-        return scriptIncludes;
-    }
-    identifyCalculations(task) {
-        const calculations = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('itsm')) {
-            calculations.push({
-                name: 'Priority Calculation',
-                description: 'Calculate priority from impact and urgency',
-                formula: 'priority = Math.max(impact, urgency)',
-                triggers: ['impact_change', 'urgency_change']
-            }, {
-                name: 'SLA Duration',
-                description: 'Calculate SLA duration based on priority',
-                formula: 'sla_duration = priority_mapping[priority]',
-                triggers: ['priority_change', 'sla_start']
-            });
-        }
-        if (lowerTask.includes('asset')) {
-            calculations.push({
-                name: 'Depreciation Value',
-                description: 'Calculate current asset value with depreciation',
-                formula: 'current_value = cost - (cost * depreciation_rate * years)',
-                triggers: ['cost_change', 'date_change']
-            }, {
-                name: 'Total Cost of Ownership',
-                description: 'Calculate TCO including maintenance and operational costs',
-                formula: 'tco = purchase_cost + maintenance_cost + operational_cost',
-                triggers: ['cost_updates']
-            });
-        }
-        if (lowerTask.includes('project')) {
-            calculations.push({
-                name: 'Project Progress',
-                description: 'Calculate project completion percentage',
-                formula: 'progress = completed_tasks / total_tasks * 100',
-                triggers: ['task_completion', 'task_creation']
-            }, {
-                name: 'Budget Utilization',
-                description: 'Calculate budget utilization percentage',
-                formula: 'utilization = spent_amount / total_budget * 100',
-                triggers: ['expense_recording']
-            });
-        }
-        return calculations;
-    }
-    identifyValidations(task) {
-        const validations = [];
-        const lowerTask = task.toLowerCase();
-        // Common validations
-        validations.push({
-            name: 'Required Fields',
-            description: 'Validate that required fields are not empty',
-            type: 'client_server',
-            severity: 'error'
-        }, {
-            name: 'Field Format',
-            description: 'Validate field formats (email, phone, etc.)',
-            type: 'client',
-            severity: 'error'
-        });
-        if (lowerTask.includes('asset')) {
-            validations.push({
-                name: 'Asset Tag Format',
-                description: 'Validate asset tag follows organization format',
-                type: 'server',
-                severity: 'error',
-                pattern: '^[A-Z]{2}[0-9]{6}$'
-            }, {
-                name: 'Serial Number Uniqueness',
-                description: 'Ensure serial numbers are unique across assets',
-                type: 'server',
-                severity: 'error'
-            });
-        }
-        if (lowerTask.includes('financial') || lowerTask.includes('budget')) {
-            validations.push({
-                name: 'Positive Amount',
-                description: 'Ensure monetary amounts are positive',
-                type: 'client_server',
-                severity: 'error'
-            }, {
-                name: 'Budget Limits',
-                description: 'Validate expenses do not exceed budget limits',
-                type: 'server',
-                severity: 'warning'
-            });
-        }
-        return validations;
-    }
-    identifyWorkflows(task) {
-        const workflows = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('approval')) {
-            workflows.push({
-                name: 'Approval Process',
-                description: 'Multi-stage approval workflow',
-                trigger: 'record_insert_update',
-                stages: ['manager_approval', 'finance_approval', 'final_approval']
-            });
-        }
-        if (lowerTask.includes('itsm')) {
-            workflows.push({
-                name: 'Incident Resolution',
-                description: 'Incident lifecycle management workflow',
-                trigger: 'state_change',
-                stages: ['assignment', 'investigation', 'resolution', 'closure']
-            }, {
-                name: 'Change Management',
-                description: 'Change request approval and implementation',
-                trigger: 'change_request_creation',
-                stages: ['assessment', 'approval', 'implementation', 'review']
-            });
-        }
-        if (lowerTask.includes('asset')) {
-            workflows.push({
-                name: 'Asset Lifecycle',
-                description: 'Asset procurement to disposal workflow',
-                trigger: 'asset_state_change',
-                stages: ['procurement', 'deployment', 'maintenance', 'disposal']
-            });
-        }
-        return workflows;
-    }
-    identifyAutomations(task) {
-        const automations = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('notification') || lowerTask.includes('email')) {
-            automations.push({
-                name: 'Automatic Notifications',
-                description: 'Send notifications on record state changes',
-                trigger: 'state_change',
-                actions: ['send_email', 'update_stakeholders']
-            });
-        }
-        if (lowerTask.includes('escalation')) {
-            automations.push({
-                name: 'SLA Escalation',
-                description: 'Automatic escalation on SLA breach',
-                trigger: 'sla_breach',
-                actions: ['escalate_to_manager', 'send_alert', 'increase_priority']
-            });
-        }
-        if (lowerTask.includes('integration')) {
-            automations.push({
-                name: 'External System Sync',
-                description: 'Synchronize data with external systems',
-                trigger: 'record_update',
-                actions: ['api_call', 'data_transform', 'update_external']
-            });
-        }
-        return automations;
-    }
-    async createLogicArchitecture(requirements) {
-        return {
-            layers: {
-                presentation: 'UI policies and client scripts',
-                business: 'Business rules and script includes',
-                data: 'Database constraints and triggers',
-                integration: 'REST APIs and web services'
-            },
-            patterns: {
-                validation: 'Client-side and server-side validation',
-                calculation: 'Real-time and batch calculations',
-                workflow: 'State-based workflow automation',
-                notification: 'Event-driven notifications'
-            },
-            components: {
-                businessRules: requirements.businessRules.length,
-                scriptIncludes: requirements.scriptIncludes.length,
-                workflows: requirements.workflows.length,
-                validations: requirements.validations.length
-            },
-            performance: {
-                caching: 'Script include function caching',
-                optimization: 'Query optimization in business rules',
-                batching: 'Batch processing for bulk operations'
-            }
-        };
-    }
-    async createImplementations(requirements) {
-        return {
-            businessRules: await this.generateBusinessRulesCode(requirements.businessRules),
-            scriptIncludes: await this.generateScriptIncludesCode(requirements.scriptIncludes),
-            validations: await this.generateValidationCode(requirements.validations),
-            calculations: await this.generateCalculationCode(requirements.calculations),
-            workflows: await this.generateWorkflowDefinitions(requirements.workflows)
-        };
-    }
-    async generateBusinessRulesCode(rules) {
-        return rules.map(rule => ({
-            name: rule.name,
-            when: this.getWhenCondition(rule.type),
-            condition: this.generateRuleCondition(rule),
-            script: this.generateRuleScript(rule)
-        }));
-    }
-    getWhenCondition(type) {
-        if (type.includes('before'))
-            return 'before';
-        if (type.includes('after'))
-            return 'after';
-        return 'before';
-    }
-    generateRuleCondition(rule) {
-        if (rule.name.includes('Priority')) {
-            return 'current.impact.changes() || current.urgency.changes()';
-        }
-        if (rule.name.includes('Auto Number')) {
-            return 'current.number.nil()';
-        }
-        return '';
-    }
-    generateRuleScript(rule) {
-        if (rule.name.includes('Auto Number')) {
-            return `
-// Auto-generate number for new records
-if (current.number.nil()) {
-    current.number = new NumberManager('${rule.table || 'custom'}').getNextObjNumber();
-}
-      `.trim();
-        }
-        if (rule.name.includes('Priority')) {
-            return `
-// Calculate priority based on impact and urgency
-if (current.impact.changes() || current.urgency.changes()) {
-    var impact = parseInt(current.impact) || 3;
-    var urgency = parseInt(current.urgency) || 3;
-    current.priority = Math.max(impact, urgency);
-}
-      `.trim();
-        }
-        if (rule.name.includes('Assignment Group')) {
-            return `
-// Auto-populate assignment group based on category
-if (current.category.changes() && !current.assignment_group.nil()) {
-    var assignmentMapping = {
-        'hardware': 'Hardware Support',
-        'software': 'Software Support',
-        'network': 'Network Operations'
-    };
-    
-    var group = assignmentMapping[current.category.toString()] || 'General Support';
-    var gr = new GlideRecord('sys_user_group');
-    if (gr.get('name', group)) {
-        current.assignment_group = gr.sys_id;
-    }
-}
-      `.trim();
-        }
-        return `// ${rule.description}\n// TODO: Implement ${rule.name} logic`;
-    }
-    async generateScriptIncludesCode(scriptIncludes) {
-        return scriptIncludes.map(si => ({
-            name: si.name,
-            clientCallable: si.clientCallable,
-            description: si.description,
-            script: this.generateScriptIncludeContent(si)
-        }));
-    }
-    generateScriptIncludeContent(scriptInclude) {
-        const className = scriptInclude.name;
-        const functions = scriptInclude.functions || [];
-        let script = `var ${className} = Class.create();\n`;
-        script += `${className}.prototype = {\n`;
-        script += `    initialize: function() {\n`;
-        script += `    },\n\n`;
-        functions.forEach((func, index) => {
-            script += `    ${func}: function() {\n`;
-            script += `        // TODO: Implement ${func} logic\n`;
-            script += `        return null;\n`;
-            script += `    }${index < functions.length - 1 ? ',' : ''}\n\n`;
-        });
-        script += `    type: '${className}'\n`;
-        script += `};`;
-        return script;
-    }
-    async generateValidationCode(validations) {
-        return validations.map(validation => ({
-            name: validation.name,
-            type: validation.type,
-            severity: validation.severity,
-            clientScript: this.generateClientValidation(validation),
-            serverScript: this.generateServerValidation(validation)
-        }));
-    }
-    generateClientValidation(validation) {
-        if (validation.name.includes('Required Fields')) {
-            return `
-function onSubmit() {
-    var requiredFields = ['short_description', 'category'];
-    for (var i = 0; i < requiredFields.length; i++) {
-        var field = requiredFields[i];
-        if (g_form.getValue(field) == '') {
-            g_form.addErrorMessage(field + ' is required');
-            return false;
-        }
-    }
-    return true;
-}
-      `.trim();
-        }
-        if (validation.name.includes('Field Format')) {
-            return `
-function onChange(control, oldValue, newValue, isLoading) {
-    if (isLoading || newValue == '') return;
-    
-    // Email validation
-    if (control == 'email') {
-        var emailPattern = /^[\\w\\.-]+@[\\w\\.-]+\\.[a-zA-Z]{2,}$/;
-        if (!emailPattern.test(newValue)) {
-            g_form.addErrorMessage('Please enter a valid email address');
-            g_form.clearValue('email');
-        }
-    }
-}
-      `.trim();
-        }
-        return `// Client-side validation for ${validation.name}`;
-    }
-    generateServerValidation(validation) {
-        if (validation.name.includes('Asset Tag Format') && validation.pattern) {
-            return `
-// Validate asset tag format
-if (current.asset_tag.changes()) {
-    var pattern = /${validation.pattern}/;
-    if (!pattern.test(current.asset_tag.toString())) {
-        gs.addErrorMessage('Asset tag must follow format: ${validation.pattern}');
-        current.setAbortAction(true);
-    }
-}
-      `.trim();
-        }
-        return `// Server-side validation for ${validation.name}`;
-    }
-    async generateCalculationCode(calculations) {
-        return calculations.map(calc => ({
-            name: calc.name,
-            description: calc.description,
-            formula: calc.formula,
-            implementation: this.generateCalculationImplementation(calc)
-        }));
-    }
-    generateCalculationImplementation(calculation) {
-        if (calculation.name.includes('Priority')) {
-            return `
-// Priority calculation based on impact and urgency
-function calculatePriority(impact, urgency) {
-    var impactValue = parseInt(impact) || 3;
-    var urgencyValue = parseInt(urgency) || 3;
-    return Math.max(impactValue, urgencyValue);
-}
-      `.trim();
-        }
-        if (calculation.name.includes('Depreciation')) {
-            return `
-// Asset depreciation calculation
-function calculateDepreciation(cost, depreciationRate, years) {
-    var annualDepreciation = cost * depreciationRate;
-    var totalDepreciation = annualDepreciation * years;
-    return Math.max(0, cost - totalDepreciation);
-}
-      `.trim();
-        }
-        return `// Implementation for ${calculation.name}`;
-    }
-    async generateWorkflowDefinitions(workflows) {
-        return workflows.map(workflow => ({
-            name: workflow.name,
-            description: workflow.description,
-            trigger: workflow.trigger,
-            stages: workflow.stages,
-            definition: this.generateWorkflowDefinition(workflow)
-        }));
-    }
-    generateWorkflowDefinition(workflow) {
-        return {
-            name: workflow.name,
-            table: this.getWorkflowTable(workflow),
-            condition: this.getWorkflowCondition(workflow),
-            activities: workflow.stages.map((stage, index) => ({
-                sequence: index + 1,
-                name: stage.replace('_', ' ').replace(/\b\w/g, l => l.toUpperCase()),
-                type: 'task',
-                description: `Execute ${stage} stage`
-            }))
-        };
-    }
-    getWorkflowTable(workflow) {
-        if (workflow.name.includes('Incident'))
-            return 'incident';
-        if (workflow.name.includes('Change'))
-            return 'change_request';
-        if (workflow.name.includes('Request'))
-            return 'sc_request';
-        if (workflow.name.includes('Asset'))
-            return 'alm_asset';
-        return 'task';
-    }
-    getWorkflowCondition(workflow) {
-        if (workflow.trigger === 'record_insert_update')
-            return 'current.operation() != "delete"';
-        if (workflow.trigger === 'state_change')
-            return 'current.state.changes()';
-        return '';
-    }
-}
-exports.BusinessLogicSpecialist = BusinessLogicSpecialist;
-class InterfaceSpecialist extends base_specialist_js_1.BaseSpecialist {
-    constructor(options = {}) {
-        super('Interface Designer', 'Interface Designer', ['Forms', 'Lists', 'UI Policies', 'Client Scripts', 'User Experience'], options);
-    }
-    async execute(task, context) {
-        await this.logProgress(`Analyzing interface requirements for: ${task}`);
-        const analysis = await this.analyzeTask(task);
-        const interfaceRequirements = {
-            forms: this.identifyForms(task),
-            lists: this.identifyLists(task),
-            uiPolicies: this.identifyUIPolicies(task),
-            clientScripts: this.identifyClientScripts(task),
-            modules: this.identifyNavigationModules(task),
-            userExperience: this.analyzeUXRequirements(task)
-        };
-        await this.logProgress('Designing user interface architecture');
-        const interfaceArchitecture = await this.createInterfaceArchitecture(interfaceRequirements);
-        await this.logProgress('Creating interface implementations');
-        const implementations = await this.createInterfaceImplementations(interfaceRequirements);
-        return {
-            ...analysis,
-            specialist: 'Interface Designer',
-            deliverables: {
-                interfaceArchitecture,
-                implementations,
-                requirements: interfaceRequirements
-            }
-        };
-    }
-    identifyForms(task) {
-        const forms = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('itsm')) {
-            forms.push({
-                name: 'incident_form',
-                table: 'incident',
-                type: 'default',
-                sections: ['details', 'assignment', 'resolution', 'related']
-            }, {
-                name: 'request_form',
-                table: 'sc_request',
-                type: 'default',
-                sections: ['request_details', 'approval', 'fulfillment']
-            });
-        }
-        if (lowerTask.includes('asset')) {
-            forms.push({
-                name: 'asset_form',
-                table: 'alm_asset',
-                type: 'default',
-                sections: ['basic_info', 'financial', 'location', 'maintenance']
-            });
-        }
-        if (lowerTask.includes('project')) {
-            forms.push({
-                name: 'project_form',
-                table: 'project',
-                type: 'default',
-                sections: ['project_details', 'timeline', 'team', 'budget']
-            }, {
-                name: 'task_form',
-                table: 'project_task',
-                type: 'default',
-                sections: ['task_details', 'assignment', 'progress']
-            });
-        }
-        // Default generic form if no specific domain
-        if (forms.length === 0) {
-            forms.push({
-                name: 'default_form',
-                table: 'custom_table',
-                type: 'default',
-                sections: ['basic_information', 'details', 'system_information']
-            });
-        }
-        return forms;
-    }
-    identifyLists(task) {
-        const lists = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('itsm')) {
-            lists.push({
-                name: 'open_incidents',
-                table: 'incident',
-                filter: 'active=true',
-                columns: ['number', 'short_description', 'state', 'priority', 'assigned_to']
-            }, {
-                name: 'my_requests',
-                table: 'sc_request',
-                filter: 'requested_by=javascript:gs.getUserID()',
-                columns: ['number', 'short_description', 'state', 'requested_for']
-            });
-        }
-        if (lowerTask.includes('asset')) {
-            lists.push({
-                name: 'asset_inventory',
-                table: 'alm_asset',
-                filter: 'install_status!=7',
-                columns: ['asset_tag', 'display_name', 'model', 'assigned_to', 'location']
-            });
-        }
-        if (lowerTask.includes('project')) {
-            lists.push({
-                name: 'active_projects',
-                table: 'project',
-                filter: 'state=2',
-                columns: ['number', 'short_description', 'percent_complete', 'project_manager']
-            }, {
-                name: 'my_tasks',
-                table: 'project_task',
-                filter: 'assigned_to=javascript:gs.getUserID()',
-                columns: ['number', 'short_description', 'state', 'due_date']
-            });
-        }
-        return lists;
-    }
-    identifyUIPolicies(task) {
-        const policies = [];
-        const lowerTask = task.toLowerCase();
-        // Common UI policies
-        policies.push({
-            name: 'Hide System Fields',
-            description: 'Hide system fields from end users',
-            condition: '!gs.hasRole("admin")',
-            actions: [
-                { field: 'sys_created_by', action: 'hidden', value: true },
-                { field: 'sys_updated_by', action: 'hidden', value: true }
-            ]
-        });
-        if (lowerTask.includes('itsm')) {
-            policies.push({
-                name: 'Incident Assignment Logic',
-                description: 'Show assignment fields only when incident is assigned',
-                condition: 'current.state >= 2',
-                actions: [
-                    { field: 'assigned_to', action: 'visible', value: true },
-                    { field: 'assignment_group', action: 'visible', value: true }
-                ]
-            }, {
-                name: 'Resolution Fields',
-                description: 'Show resolution fields only when resolving',
-                condition: 'current.state == 6',
-                actions: [
-                    { field: 'close_code', action: 'mandatory', value: true },
-                    { field: 'close_notes', action: 'mandatory', value: true }
-                ]
-            });
-        }
-        if (lowerTask.includes('approval')) {
-            policies.push({
-                name: 'Approval Fields Visibility',
-                description: 'Show approval fields based on approval state',
-                condition: 'current.approval != "not requested"',
-                actions: [
-                    { field: 'approver', action: 'readonly', value: true },
-                    { field: 'approval_history', action: 'visible', value: true }
-                ]
-            });
-        }
-        return policies;
-    }
-    identifyClientScripts(task) {
-        const scripts = [];
-        const lowerTask = task.toLowerCase();
-        // Common client scripts
-        scripts.push({
-            name: 'Form Validation',
-            type: 'onSubmit',
-            description: 'Validate required fields before submission',
-            table: 'global'
-        });
-        if (lowerTask.includes('itsm')) {
-            scripts.push({
-                name: 'Priority Calculation',
-                type: 'onChange',
-                description: 'Calculate priority when impact or urgency changes',
-                table: 'incident',
-                field: 'impact,urgency'
-            }, {
-                name: 'Category Assignment Group',
-                type: 'onChange',
-                description: 'Suggest assignment group based on category',
-                table: 'incident',
-                field: 'category'
-            });
-        }
-        if (lowerTask.includes('asset')) {
-            scripts.push({
-                name: 'Asset Tag Format',
-                type: 'onChange',
-                description: 'Format and validate asset tag',
-                table: 'alm_asset',
-                field: 'asset_tag'
-            });
-        }
-        if (lowerTask.includes('financial') || lowerTask.includes('cost')) {
-            scripts.push({
-                name: 'Currency Formatting',
-                type: 'onChange',
-                description: 'Format currency fields',
-                table: 'global',
-                field: 'cost,price,amount'
-            });
-        }
-        return scripts;
-    }
-    identifyNavigationModules(task) {
-        const modules = [];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('itsm')) {
-            modules.push({
-                title: 'Incident Management',
-                application: 'ITSM Application',
-                items: [
-                    { title: 'Create New', table: 'incident', type: 'new' },
-                    { title: 'Open Incidents', table: 'incident', type: 'list', filter: 'active=true' },
-                    { title: 'My Incidents', table: 'incident', type: 'list', filter: 'assigned_to=javascript:gs.getUserID()' }
-                ]
-            }, {
-                title: 'Request Management',
-                application: 'ITSM Application',
-                items: [
-                    { title: 'Service Catalog', type: 'catalog' },
-                    { title: 'My Requests', table: 'sc_request', type: 'list', filter: 'requested_by=javascript:gs.getUserID()' }
-                ]
-            });
-        }
-        if (lowerTask.includes('asset')) {
-            modules.push({
-                title: 'Asset Management',
-                application: 'Asset Application',
-                items: [
-                    { title: 'All Assets', table: 'alm_asset', type: 'list' },
-                    { title: 'My Assets', table: 'alm_asset', type: 'list', filter: 'assigned_to=javascript:gs.getUserID()' },
-                    { title: 'Asset Reports', type: 'reports' }
-                ]
-            });
-        }
-        return modules;
-    }
-    analyzeUXRequirements(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            usability: {
-                intuitive: true,
-                consistent: true,
-                accessible: true,
-                responsive: lowerTask.includes('mobile') || lowerTask.includes('responsive')
-            },
-            performance: {
-                fastLoading: true,
-                efficientQueries: true,
-                caching: lowerTask.includes('dashboard') || lowerTask.includes('reports')
-            },
-            accessibility: {
-                wcag: 'AA',
-                screenReader: true,
-                keyboardNavigation: true,
-                colorContrast: true
-            },
-            responsive: {
-                mobile: lowerTask.includes('mobile'),
-                tablet: true,
-                desktop: true
-            }
-        };
-    }
-    async createInterfaceArchitecture(requirements) {
-        return {
-            patterns: {
-                navigation: 'Hierarchical menu structure',
-                forms: 'Section-based form layout',
-                lists: 'Filtered list views with sorting',
-                interaction: 'Real-time field validation'
-            },
-            components: {
-                forms: requirements.forms.length,
-                lists: requirements.lists.length,
-                uiPolicies: requirements.uiPolicies.length,
-                clientScripts: requirements.clientScripts.length,
-                modules: requirements.modules.length
-            },
-            userExperience: requirements.userExperience,
-            responsive: {
-                breakpoints: ['mobile', 'tablet', 'desktop'],
-                approach: 'mobile-first'
-            }
-        };
-    }
-    async createInterfaceImplementations(requirements) {
-        return {
-            forms: await this.generateFormDefinitions(requirements.forms),
-            lists: await this.generateListDefinitions(requirements.lists),
-            uiPolicies: await this.generateUIPolicyCode(requirements.uiPolicies),
-            clientScripts: await this.generateClientScriptCode(requirements.clientScripts),
-            modules: await this.generateModuleDefinitions(requirements.modules)
-        };
-    }
-    async generateFormDefinitions(forms) {
-        return forms.map(form => ({
-            name: form.name,
-            table: form.table,
-            type: form.type,
-            layout: this.generateFormLayout(form),
-            sections: this.generateFormSections(form.sections)
-        }));
-    }
-    generateFormLayout(form) {
-        return {
-            columns: 2,
-            sections: form.sections,
-            responsive: true,
-            collapsible: true
-        };
-    }
-    generateFormSections(sections) {
-        return sections.map(section => ({
-            name: section,
-            label: section.replace('_', ' ').replace(/\b\w/g, l => l.toUpperCase()),
-            collapsed: section.includes('system'),
-            columns: section === 'details' ? 1 : 2
-        }));
-    }
-    async generateListDefinitions(lists) {
-        return lists.map(list => ({
-            name: list.name,
-            table: list.table,
-            filter: list.filter,
-            columns: list.columns,
-            sortBy: list.columns[0],
-            groupBy: null,
-            aggregates: []
-        }));
-    }
-    async generateUIPolicyCode(policies) {
-        return policies.map(policy => ({
-            name: policy.name,
-            description: policy.description,
-            condition: policy.condition,
-            script: this.generateUIPolicyScript(policy)
-        }));
-    }
-    generateUIPolicyScript(policy) {
-        let script = `// ${policy.description}\n`;
-        script += `if (${policy.condition}) {\n`;
-        policy.actions.forEach(action => {
-            switch (action.action) {
-                case 'hidden':
-                    script += `    g_form.setVisible('${action.field}', ${!action.value});\n`;
-                    break;
-                case 'visible':
-                    script += `    g_form.setVisible('${action.field}', ${action.value});\n`;
-                    break;
-                case 'mandatory':
-                    script += `    g_form.setMandatory('${action.field}', ${action.value});\n`;
-                    break;
-                case 'readonly':
-                    script += `    g_form.setReadOnly('${action.field}', ${action.value});\n`;
-                    break;
-            }
-        });
-        script += `}`;
-        return script;
-    }
-    async generateClientScriptCode(scripts) {
-        return scripts.map(script => ({
-            name: script.name,
-            type: script.type,
-            table: script.table,
-            field: script.field,
-            script: this.generateClientScriptContent(script)
-        }));
-    }
-    generateClientScriptContent(script) {
-        if (script.name.includes('Form Validation')) {
-            return `
-function onSubmit() {
-    var requiredFields = ['short_description'];
-    for (var i = 0; i < requiredFields.length; i++) {
-        var field = requiredFields[i];
-        if (g_form.getValue(field) == '') {
-            g_form.addErrorMessage(field.replace('_', ' ') + ' is required');
-            return false;
-        }
-    }
-    return true;
-}
-      `.trim();
-        }
-        if (script.name.includes('Priority Calculation')) {
-            return `
-function onChange(control, oldValue, newValue, isLoading) {
-    if (isLoading || newValue == '') return;
-    
-    var impact = parseInt(g_form.getValue('impact')) || 3;
-    var urgency = parseInt(g_form.getValue('urgency')) || 3;
-    var priority = Math.max(impact, urgency);
-    
-    g_form.setValue('priority', priority);
-}
-      `.trim();
-        }
-        return `// ${script.description}\nfunction ${script.type}() {\n    // TODO: Implement logic\n}`;
-    }
-    async generateModuleDefinitions(modules) {
-        return modules.map(module => ({
-            title: module.title,
-            application: module.application,
-            order: 100,
-            items: module.items.map((item, index) => ({
-                title: item.title,
-                order: (index + 1) * 10,
-                table: item.table,
-                type: item.type,
-                filter: item.filter
-            }))
-        }));
-    }
-}
-exports.InterfaceSpecialist = InterfaceSpecialist;
-class PerformanceSpecialist extends base_specialist_js_1.BaseSpecialist {
-    constructor(options = {}) {
-        super('Performance Optimizer', 'Performance Specialist', ['Query Optimization', 'Caching', 'Indexing', 'Load Testing', 'Monitoring'], options);
-    }
-    async execute(task, context) {
-        await this.logProgress(`Analyzing performance requirements for: ${task}`);
-        const analysis = await this.analyzeTask(task);
-        const performanceRequirements = {
-            queryOptimization: this.analyzeQueryOptimization(task),
-            caching: this.analyzeCachingNeeds(task),
-            indexing: this.analyzeIndexingStrategy(task),
-            monitoring: this.analyzeMonitoringNeeds(task),
-            scalability: this.analyzeScalabilityRequirements(task),
-            loadTesting: this.analyzeLoadTestingNeeds(task)
-        };
-        await this.logProgress('Designing performance optimization strategy');
-        const optimizationStrategy = await this.createOptimizationStrategy(performanceRequirements);
-        await this.logProgress('Creating performance implementation plan');
-        const implementationPlan = await this.createImplementationPlan(performanceRequirements);
-        return {
-            ...analysis,
-            specialist: 'Performance Specialist',
-            deliverables: {
-                optimizationStrategy,
-                implementationPlan,
-                requirements: performanceRequirements
-            }
-        };
-    }
-    analyzeQueryOptimization(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            enabled: true,
-            techniques: [
-                'indexed_queries',
-                'query_caching',
-                'result_limiting',
-                'field_selection'
-            ],
-            priorities: this.identifyQueryPriorities(task),
-            monitoring: lowerTask.includes('monitor') || lowerTask.includes('analytics'),
-            automation: true
-        };
-    }
-    identifyQueryPriorities(task) {
-        const priorities = ['list_views', 'form_loads'];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('dashboard')) {
-            priorities.push('dashboard_queries', 'aggregation_queries');
-        }
-        if (lowerTask.includes('report')) {
-            priorities.push('reporting_queries', 'complex_joins');
-        }
-        if (lowerTask.includes('search')) {
-            priorities.push('search_queries', 'full_text_search');
-        }
-        return priorities;
-    }
-    analyzeCachingNeeds(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            levels: ['browser', 'application', 'database'],
-            strategies: {
-                static: lowerTask.includes('reference') || lowerTask.includes('lookup'),
-                dynamic: lowerTask.includes('dashboard') || lowerTask.includes('realtime'),
-                distributed: lowerTask.includes('enterprise') || lowerTask.includes('high volume')
-            },
-            ttl: {
-                short: '5 minutes',
-                medium: '30 minutes',
-                long: '4 hours'
-            },
-            invalidation: 'event_based'
-        };
-    }
-    analyzeIndexingStrategy(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            automatic: true,
-            types: ['btree', 'hash', 'composite'],
-            monitoring: true,
-            maintenance: 'automated',
-            priorities: this.identifyIndexPriorities(task)
-        };
-    }
-    identifyIndexPriorities(task) {
-        const priorities = ['primary_keys', 'foreign_keys', 'frequently_queried'];
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('search')) {
-            priorities.push('text_search', 'full_text_indexes');
-        }
-        if (lowerTask.includes('date') || lowerTask.includes('time')) {
-            priorities.push('temporal_indexes');
-        }
-        if (lowerTask.includes('geographic') || lowerTask.includes('location')) {
-            priorities.push('spatial_indexes');
-        }
-        return priorities;
-    }
-    analyzeMonitoringNeeds(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            realTime: lowerTask.includes('realtime') || lowerTask.includes('monitor'),
-            metrics: [
-                'response_time',
-                'throughput',
-                'error_rate',
-                'resource_utilization'
-            ],
-            alerting: {
-                thresholds: {
-                    response_time: '> 2 seconds',
-                    error_rate: '> 5%',
-                    cpu_usage: '> 80%',
-                    memory_usage: '> 90%'
-                },
-                notifications: ['email', 'dashboard']
-            },
-            dashboards: lowerTask.includes('dashboard') || lowerTask.includes('monitor')
-        };
-    }
-    analyzeScalabilityRequirements(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            horizontal: lowerTask.includes('enterprise') || lowerTask.includes('large'),
-            vertical: true,
-            autoScaling: lowerTask.includes('auto') || lowerTask.includes('dynamic'),
-            loadBalancing: lowerTask.includes('distributed') || lowerTask.includes('cluster'),
-            partitioning: lowerTask.includes('partition') || lowerTask.includes('shard')
-        };
-    }
-    analyzeLoadTestingNeeds(task) {
-        const lowerTask = task.toLowerCase();
-        return {
-            required: lowerTask.includes('performance') || lowerTask.includes('load'),
-            scenarios: [
-                'normal_load',
-                'peak_load',
-                'stress_test'
-            ],
-            metrics: [
-                'concurrent_users',
-                'transactions_per_second',
-                'response_time_percentiles'
-            ],
-            automation: true
-        };
-    }
-    async createOptimizationStrategy(requirements) {
-        return {
-            phases: [
-                {
-                    name: 'Assessment',
-                    duration: '1-2 days',
-                    activities: ['baseline_measurement', 'bottleneck_identification', 'requirements_analysis']
-                },
-                {
-                    name: 'Quick Wins',
-                    duration: '2-3 days',
-                    activities: ['query_optimization', 'index_creation', 'caching_implementation']
-                },
-                {
-                    name: 'Deep Optimization',
-                    duration: '1-2 weeks',
-                    activities: ['architecture_optimization', 'advanced_caching', 'load_balancing']
-                },
-                {
-                    name: 'Monitoring & Tuning',
-                    duration: 'ongoing',
-                    activities: ['performance_monitoring', 'continuous_optimization', 'capacity_planning']
-                }
-            ],
-            priorities: this.createOptimizationPriorities(requirements),
-            success_criteria: this.createSuccessCriteria(requirements)
-        };
-    }
-    createOptimizationPriorities(requirements) {
-        return [
-            {
-                priority: 'high',
-                area: 'Database Queries',
-                techniques: requirements.queryOptimization.techniques,
-                expectedImprovement: '50-80%'
-            },
-            {
-                priority: 'high',
-                area: 'Caching',
-                techniques: Object.keys(requirements.caching.strategies),
-                expectedImprovement: '30-60%'
-            },
-            {
-                priority: 'medium',
-                area: 'Indexing',
-                techniques: requirements.indexing.types,
-                expectedImprovement: '20-40%'
-            },
-            {
-                priority: 'medium',
-                area: 'Monitoring',
-                techniques: ['real_time_monitoring', 'alerting'],
-                expectedImprovement: 'ongoing'
-            }
-        ];
-    }
-    createSuccessCriteria(requirements) {
-        return {
-            response_time: {
-                form_loads: '< 2 seconds',
-                list_views: '< 3 seconds',
-                dashboard_loads: '< 5 seconds',
-                search_results: '< 1 second'
-            },
-            throughput: {
-                concurrent_users: '100+',
-                transactions_per_second: '50+',
-                data_processing: '1000+ records/minute'
-            },
-            availability: {
-                uptime: '99.9%',
-                error_rate: '< 1%',
-                recovery_time: '< 5 minutes'
-            },
-            scalability: {
-                user_growth: '200% capacity',
-                data_growth: '300% capacity',
-                transaction_growth: '250% capacity'
-            }
-        };
-    }
-    async createImplementationPlan(requirements) {
-        return {
-            database_optimization: this.createDatabaseOptimizationPlan(requirements),
-            caching_implementation: this.createCachingImplementationPlan(requirements),
-            monitoring_setup: this.createMonitoringSetupPlan(requirements),
-            testing_strategy: this.createTestingStrategy(requirements),
-            maintenance_plan: this.createMaintenancePlan(requirements)
-        };
-    }
-    createDatabaseOptimizationPlan(requirements) {
-        return {
-            query_optimization: {
-                techniques: requirements.queryOptimization.techniques,
-                tools: ['query_analyzer', 'execution_plan_viewer', 'performance_dashboard'],
-                automation: requirements.queryOptimization.automation
-            },
-            indexing: {
-                strategy: requirements.indexing,
-                creation_priority: requirements.indexing.priorities,
-                maintenance: 'automated'
-            },
-            partitioning: {
-                enabled: requirements.scalability.partitioning,
-                strategy: 'date_based',
-                maintenance: 'automated'
-            }
-        };
-    }
-    createCachingImplementationPlan(requirements) {
-        return {
-            levels: requirements.caching.levels,
-            strategies: requirements.caching.strategies,
-            configuration: {
-                ttl_policies: requirements.caching.ttl,
-                invalidation: requirements.caching.invalidation,
-                compression: true,
-                encryption: false
-            },
-            monitoring: {
-                hit_rate: 'target > 80%',
-                miss_rate: 'target < 20%',
-                eviction_rate: 'monitor'
-            }
-        };
-    }
-    createMonitoringSetupPlan(requirements) {
-        return {
-            metrics_collection: {
-                real_time: requirements.monitoring.realTime,
-                metrics: requirements.monitoring.metrics,
-                retention: '90 days'
-            },
-            alerting: requirements.monitoring.alerting,
-            dashboards: {
-                executive: 'high_level_kpis',
-                operational: 'detailed_metrics',
-                technical: 'system_performance'
-            },
-            reporting: {
-                frequency: 'weekly',
-                format: 'automated_reports',
-                distribution: ['technical_team', 'management']
-            }
-        };
-    }
-    createTestingStrategy(requirements) {
-        if (!requirements.loadTesting.required) {
-            return { required: false };
-        }
-        return {
-            scenarios: requirements.loadTesting.scenarios.map(scenario => ({
-                name: scenario,
-                users: this.getScenarioUsers(scenario),
-                duration: this.getScenarioDuration(scenario),
-                ramp_up: this.getScenarioRampUp(scenario)
-            })),
-            metrics: requirements.loadTesting.metrics,
-            tools: ['jmeter', 'loadrunner', 'gatling'],
-            automation: requirements.loadTesting.automation,
-            schedule: 'before_major_releases'
-        };
-    }
-    getScenarioUsers(scenario) {
-        switch (scenario) {
-            case 'normal_load': return 50;
-            case 'peak_load': return 200;
-            case 'stress_test': return 500;
-            default: return 100;
-        }
-    }
-    getScenarioDuration(scenario) {
-        switch (scenario) {
-            case 'normal_load': return '30 minutes';
-            case 'peak_load': return '15 minutes';
-            case 'stress_test': return '10 minutes';
-            default: return '20 minutes';
-        }
-    }
-    getScenarioRampUp(scenario) {
-        switch (scenario) {
-            case 'normal_load': return '5 minutes';
-            case 'peak_load': return '2 minutes';
-            case 'stress_test': return '1 minute';
-            default: return '3 minutes';
-        }
-    }
-    createMaintenancePlan(requirements) {
-        return {
-            daily: [
-                'performance_metrics_review',
-                'cache_hit_rate_monitoring',
-                'slow_query_identification'
-            ],
-            weekly: [
-                'index_usage_analysis',
-                'performance_trend_analysis',
-                'capacity_planning_review'
-            ],
-            monthly: [
-                'full_performance_audit',
-                'optimization_opportunities_assessment',
-                'scalability_planning'
-            ],
-            automation: {
-                monitoring: true,
-                alerting: true,
-                reporting: true,
-                optimization: 'semi_automated'
-            }
-        };
-    }
-}
-exports.PerformanceSpecialist = PerformanceSpecialist;
-//# sourceMappingURL=app-specialists.js.map