snow-flow 1.1.0

package/dist/agents/script-generator.agent.js

@@ -0,0 +1,772 @@
+"use strict";
+/**
+ * Script Generator Agent for Business Rules and Script Includes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptGeneratorAgent = void 0;
+const base_agent_js_1 = require("../core/base-agent.js");
+class ScriptGeneratorAgent extends base_agent_js_1.BaseServiceNowAgent {
+    constructor(config) {
+        super('script-generator', servicenow_types_js_1.AgentType.SCRIPT_GENERATOR, [
+            'generate_business_rule',
+            'generate_script_include',
+            'generate_client_script',
+            'generate_ui_script',
+            'optimize_script',
+            'convert_script_type',
+            'generate_test_script'
+        ], config);
+    }
+    async execute(task) {
+        this.logger.info(`Executing script generation task: ${task.description}`);
+        try {
+            switch (task.type) {
+                case 'generate_business_rule':
+                    return await this.generateBusinessRule(task);
+                case 'generate_script_include':
+                    return await this.generateScriptInclude(task);
+                case 'generate_client_script':
+                    return await this.generateClientScript(task);
+                case 'generate_from_requirements':
+                    return await this.generateFromRequirements(task);
+                case 'optimize_script':
+                    return await this.optimizeScript(task);
+                default:
+                    throw new Error(`Unknown task type: ${task.type}`);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Script generation failed: ${error.message}`);
+            return {
+                taskId: task.id,
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    async generateBusinessRule(task) {
+        const { name, table, when, conditions, logic, order } = task.payload;
+        const script = {
+            name,
+            type: 'business_rule',
+            table,
+            when: when || 'before',
+            conditions: conditions || '',
+            script: this.generateBusinessRuleScript(logic, when),
+            active: true
+        };
+        const metadata = {
+            order: order || 100,
+            advanced: true,
+            role_conditions: '',
+            filter_conditions: conditions
+        };
+        // Generate orchestration commands
+        const commands = [
+            this.generateCommand('Bash', 'create', {
+                command: `mkdir -p /Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/business_rules`,
+                description: 'Create business rules directory'
+            }, 'Create directory'),
+            this.generateCommand('Write', 'create', {
+                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/business_rules/${this.sanitizeName(name)}.js`,
+                content: script.script
+            }, `Create business rule script: ${name}`),
+            this.generateCommand('Write', 'create', {
+                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/business_rules/${this.sanitizeName(name)}.json`,
+                content: JSON.stringify({
+                    ...script,
+                    metadata
+                }, null, 2)
+            }, 'Create business rule metadata')
+        ];
+        // Store in memory for coordination
+        await this.storeInMemory(`scripts:business_rule:${this.sanitizeName(name)}`, script);
+        return {
+            taskId: task.id,
+            success: true,
+            output: script,
+            artifacts: [
+                this.createArtifact('business_rule', name, script, metadata)
+            ],
+            commands
+        };
+    }
+    async generateScriptInclude(task) {
+        const { name, apiName, description, methods, type } = task.payload;
+        const scriptInclude = {
+            name: name || apiName,
+            api_name: apiName || this.generateAPIName(name),
+            description: description || `Script Include: ${name}`,
+            script: this.generateScriptIncludeCode(apiName || name, methods, type),
+            active: true,
+            access: type === 'public' ? 'public' : 'package_private'
+        };
+        // Generate test script
+        const testScript = this.generateTestScript(scriptInclude.api_name, methods);
+        const commands = [
+            this.generateCommand('Bash', 'create', {
+                command: `mkdir -p /Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/script_includes/{src,test}`,
+                description: 'Create script include directories'
+            }, 'Create directories'),
+            this.generateCommand('Write', 'create', {
+                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/script_includes/src/${scriptInclude.api_name}.js`,
+                content: scriptInclude.script
+            }, `Create script include: ${scriptInclude.api_name}`),
+            this.generateCommand('Write', 'create', {
+                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/script_includes/test/${scriptInclude.api_name}.test.js`,
+                content: testScript
+            }, 'Create test script'),
+            this.generateCommand('Write', 'create', {
+                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/script_includes/${scriptInclude.api_name}.json`,
+                content: JSON.stringify(scriptInclude, null, 2)
+            }, 'Create script include metadata')
+        ];
+        await this.storeInMemory(`scripts:script_include:${scriptInclude.api_name}`, scriptInclude);
+        return {
+            taskId: task.id,
+            success: true,
+            output: {
+                scriptInclude,
+                testScript
+            },
+            artifacts: [
+                this.createArtifact('script_include', scriptInclude.api_name, scriptInclude),
+                this.createArtifact('test_script', `${scriptInclude.api_name}.test`, testScript)
+            ],
+            commands
+        };
+    }
+    async generateClientScript(task) {
+        const { name, table, type, fieldName, script: customScript } = task.payload;
+        const clientScript = {
+            name,
+            type: 'client_script',
+            table,
+            when: type || 'onLoad',
+            script: customScript || this.generateClientScriptCode(type || 'onLoad', fieldName),
+            active: true
+        };
+        const metadata = {
+            ui_type: 'Desktop',
+            isolate_script: true,
+            field: fieldName || ''
+        };
+        const commands = [
+            this.generateCommand('Bash', 'create', {
+                command: `mkdir -p /Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/client_scripts`,
+                description: 'Create client scripts directory'
+            }, 'Create directory'),
+            this.generateCommand('Write', 'create', {
+                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/client_scripts/${this.sanitizeName(name)}.js`,
+                content: clientScript.script
+            }, `Create client script: ${name}`),
+            this.generateCommand('Write', 'create', {
+                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/client_scripts/${this.sanitizeName(name)}.json`,
+                content: JSON.stringify({
+                    ...clientScript,
+                    metadata
+                }, null, 2)
+            }, 'Create client script metadata')
+        ];
+        await this.storeInMemory(`scripts:client_script:${this.sanitizeName(name)}`, clientScript);
+        return {
+            taskId: task.id,
+            success: true,
+            output: clientScript,
+            artifacts: [
+                this.createArtifact('client_script', name, clientScript, metadata)
+            ],
+            commands
+        };
+    }
+    async generateFromRequirements(task) {
+        const { requirements, scriptType, table } = task.payload;
+        // Analyze requirements to determine script structure
+        const analysis = this.analyzeScriptRequirements(requirements, scriptType);
+        // Generate appropriate script based on analysis
+        let generatedScript;
+        let scriptCategory;
+        switch (analysis.recommendedType) {
+            case 'business_rule':
+                generatedScript = {
+                    name: analysis.suggestedName,
+                    type: 'business_rule',
+                    table: table || analysis.detectedTable,
+                    when: analysis.when || 'before',
+                    conditions: analysis.conditions,
+                    script: this.generateSmartBusinessRule(analysis),
+                    active: true
+                };
+                scriptCategory = 'business_rule';
+                break;
+            case 'script_include':
+                generatedScript = {
+                    name: analysis.suggestedName,
+                    api_name: this.generateAPIName(analysis.suggestedName),
+                    script: this.generateSmartScriptInclude(analysis),
+                    active: true,
+                    access: 'package_private'
+                };
+                scriptCategory = 'script_include';
+                break;
+            case 'client_script':
+                generatedScript = {
+                    name: analysis.suggestedName,
+                    type: 'client_script',
+                    table: table || analysis.detectedTable,
+                    when: analysis.clientType || 'onChange',
+                    script: this.generateSmartClientScript(analysis),
+                    active: true
+                };
+                scriptCategory = 'client_script';
+                break;
+            default:
+                throw new Error(`Unable to determine script type from requirements`);
+        }
+        // Generate comprehensive documentation
+        const documentation = this.generateScriptDocumentation(generatedScript, analysis, requirements);
+        const commands = [
+            this.generateCommand('Bash', 'create', {
+                command: `mkdir -p /Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/${scriptCategory}s`,
+                description: `Create ${scriptCategory} directory`
+            }, 'Create directory'),
+            this.generateCommand('Write', 'create', {
+                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/${scriptCategory}s/${this.sanitizeName(generatedScript.name)}.js`,
+                content: generatedScript.script
+            }, `Create ${scriptCategory}: ${generatedScript.name}`),
+            this.generateCommand('Write', 'create', {
+                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/scripts/${scriptCategory}s/${this.sanitizeName(generatedScript.name)}.md`,
+                content: documentation
+            }, 'Create documentation')
+        ];
+        return {
+            taskId: task.id,
+            success: true,
+            output: {
+                script: generatedScript,
+                analysis,
+                documentation
+            },
+            artifacts: [
+                this.createArtifact(scriptCategory, generatedScript.name, generatedScript),
+                this.createArtifact('documentation', `${generatedScript.name}.md`, documentation)
+            ],
+            commands
+        };
+    }
+    async optimizeScript(task) {
+        const { script, scriptType, optimizationGoals } = task.payload;
+        // Perform script analysis
+        const analysis = this.analyzeScriptPerformance(script);
+        // Apply optimizations
+        const optimizedScript = this.applyScriptOptimizations(script, analysis, optimizationGoals);
+        // Generate optimization report
+        const report = {
+            originalLength: script.length,
+            optimizedLength: optimizedScript.length,
+            improvements: analysis.improvements,
+            appliedOptimizations: analysis.optimizations,
+            performanceGains: analysis.estimatedGains
+        };
+        return {
+            taskId: task.id,
+            success: true,
+            output: {
+                originalScript: script,
+                optimizedScript,
+                report
+            },
+            artifacts: [
+                this.createArtifact('optimized_script', 'optimized.js', optimizedScript),
+                this.createArtifact('optimization_report', 'optimization-report.json', report)
+            ]
+        };
+    }
+    // Helper methods
+    generateBusinessRuleScript(logic, when) {
+        const template = `(function executeRule(current, previous /*null when async*/) {
+    // Business Rule: ${logic.description || 'Custom Business Logic'}
+    
+    try {
+        ${this.generateBusinessLogic(logic, when)}
+    } catch (e) {
+        gs.error('Business rule error: ' + e.message, 'BusinessRule');
+    }
+    
+})(current, previous);`;
+        return template;
+    }
+    generateBusinessLogic(logic, when) {
+        let code = '';
+        // Add common patterns based on logic type
+        if (logic.type === 'validation') {
+            code = `// Validation logic
+        if (!current.${logic.field}) {
+            current.setAbortAction(true);
+            gs.addErrorMessage('${logic.errorMessage || 'Validation failed'}');
+            return;
+        }`;
+        }
+        else if (logic.type === 'calculation') {
+            code = `// Calculation logic
+        var result = ${logic.calculation || '0'};
+        current.${logic.targetField} = result;`;
+        }
+        else if (logic.type === 'notification') {
+            code = `// Notification logic
+        if (${logic.condition || 'true'}) {
+            gs.eventQueue('${logic.eventName || 'custom.notification'}', current, '${logic.param1 || ''}', '${logic.param2 || ''}');
+        }`;
+        }
+        else if (logic.type === 'integration') {
+            code = `// Integration logic
+        var request = new sn_ws.RESTMessageV2('${logic.integrationName || 'Custom_Integration'}', '${logic.method || 'get'}');
+        request.setStringParameter('id', current.sys_id);
+        var response = request.execute();
+        current.${logic.responseField || 'integration_response'} = response.getBody();`;
+        }
+        else {
+            // Custom logic
+            code = logic.customCode || '// Add custom business logic here';
+        }
+        return code;
+    }
+    generateScriptIncludeCode(className, methods, type) {
+        const isPrototype = type !== 'static';
+        const baseClass = type === 'ajax' ? 'AbstractAjaxProcessor' : '';
+        let code = `var ${className} = Class.create();`;
+        if (isPrototype) {
+            code = `${code}
+${className}.prototype = ${baseClass ? `Object.extendsObject(${baseClass}, ` : ''}{
+    initialize: function() {
+        ${baseClass ? 'this.logPrefix = "[' + className + '] ";' : '// Initialize instance variables'}
+    },
+    
+    ${this.generateMethods(methods || [], className)}
+    
+    type: '${className}'
+}${baseClass ? ')' : ''};`;
+        }
+        else {
+            // Static script include
+            code = `var ${className} = {
+    ${this.generateStaticMethods(methods || [], className)}
+};`;
+        }
+        return code;
+    }
+    generateMethods(methods, className) {
+        if (methods.length === 0) {
+            return `// Example method
+    exampleMethod: function(param) {
+        // Add method implementation
+        return 'Result';
+    }`;
+        }
+        return methods.map(method => {
+            return `${method.name}: function(${method.parameters?.join(', ') || ''}) {
+        ${method.description ? '// ' + method.description : ''}
+        ${method.body || '// Add implementation'}
+    }`;
+        }).join(',\n    \n    ');
+    }
+    generateStaticMethods(methods, className) {
+        if (methods.length === 0) {
+            return `// Example static method
+    exampleMethod: function(param) {
+        // Add method implementation
+        return 'Result';
+    }`;
+        }
+        return methods.map(method => {
+            return `${method.name}: function(${method.parameters?.join(', ') || ''}) {
+        ${method.description ? '// ' + method.description : ''}
+        ${method.body || '// Add implementation'}
+    }`;
+        }).join(',\n    \n    ');
+    }
+    generateClientScriptCode(type, fieldName) {
+        switch (type) {
+            case 'onLoad':
+                return `function onLoad() {
+    // Client script executed when form loads
+    
+    // Hide/show fields based on conditions
+    g_form.setDisplay('field_name', false);
+    
+    // Set default values
+    if (g_form.isNewRecord()) {
+        g_form.setValue('priority', '3');
+    }
+    
+    // Add field messages
+    g_form.showFieldMsg('short_description', 'Please provide a detailed description', 'info');
+}`;
+            case 'onChange':
+                return `function onChange(control, oldValue, newValue, isLoading, isTemplate) {
+    if (isLoading || newValue === '') {
+        return;
+    }
+    
+    // Field: ${fieldName || 'field_name'}
+    // React to field changes
+    
+    if (newValue != oldValue) {
+        // Perform client-side validation
+        if (!isValidValue(newValue)) {
+            g_form.setValue('${fieldName || 'field_name'}', oldValue);
+            alert('Invalid value entered');
+            return;
+        }
+        
+        // Update related fields
+        updateRelatedFields(newValue);
+    }
+}
+
+function isValidValue(value) {
+    // Add validation logic
+    return true;
+}
+
+function updateRelatedFields(value) {
+    // Update other fields based on the new value
+}`;
+            case 'onSubmit':
+                return `function onSubmit() {
+    // Validate form before submission
+    
+    var isValid = true;
+    var errorMessage = [];
+    
+    // Check required fields
+    if (g_form.getValue('short_description') == '') {
+        errorMessage.push('Short description is required');
+        isValid = false;
+    }
+    
+    // Validate field formats
+    var email = g_form.getValue('email');
+    if (email && !isValidEmail(email)) {
+        errorMessage.push('Invalid email format');
+        isValid = false;
+    }
+    
+    if (!isValid) {
+        g_form.addErrorMessage(errorMessage.join('\\n'));
+        return false;
+    }
+    
+    return true;
+}
+
+function isValidEmail(email) {
+    var re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return re.test(email);
+}`;
+            case 'onCellEdit':
+                return `function onCellEdit(sysIDs, table, oldValues, newValue, callback) {
+    // Handle list cell edits
+    
+    // Validate the new value
+    if (!isValidCellValue(newValue)) {
+        alert('Invalid value');
+        callback(false);
+        return;
+    }
+    
+    // Perform additional checks or updates
+    var ajax = new GlideAjax('CustomAjaxProcessor');
+    ajax.addParam('sysparm_name', 'validateBulkUpdate');
+    ajax.addParam('sysparm_ids', sysIDs.join(','));
+    ajax.addParam('sysparm_value', newValue);
+    
+    ajax.getXMLAnswer(function(answer) {
+        if (answer === 'true') {
+            callback(true);
+        } else {
+            alert('Update not allowed');
+            callback(false);
+        }
+    });
+}
+
+function isValidCellValue(value) {
+    // Add validation logic
+    return true;
+}`;
+            default:
+                return '// Custom client script\n// Add your implementation here';
+        }
+    }
+    generateTestScript(apiName, methods) {
+        return `// Test script for ${apiName}
+// Run this in Scripts - Background to test the Script Include
+
+gs.info('=== Testing ${apiName} ===');
+
+try {
+    // Test instantiation
+    var instance = new ${apiName}();
+    gs.info('✓ Script Include instantiated successfully');
+    
+    ${methods?.map(method => `
+    // Test ${method.name}
+    try {
+        var result = instance.${method.name}(${method.testParams?.join(', ') || ''});
+        gs.info('✓ ${method.name} executed successfully');
+        gs.info('  Result: ' + JSON.stringify(result));
+    } catch (e) {
+        gs.error('✗ ${method.name} failed: ' + e.message);
+    }`).join('\n') || '// Add test cases for your methods'}
+    
+    gs.info('=== Test completed ===');
+} catch (e) {
+    gs.error('Test failed: ' + e.message);
+}`;
+    }
+    generateAPIName(name) {
+        // Convert name to proper API name format
+        return name
+            .split(/[\s-_]+/)
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
+    analyzeScriptRequirements(requirements, preferredType) {
+        const analysis = {
+            recommendedType: preferredType,
+            suggestedName: '',
+            detectedTable: '',
+            when: '',
+            conditions: '',
+            clientType: '',
+            methods: [],
+            features: []
+        };
+        // Detect script type from requirements
+        const reqLower = requirements.toLowerCase();
+        if (!preferredType) {
+            if (reqLower.includes('when record') || reqLower.includes('before insert') ||
+                reqLower.includes('after update') || reqLower.includes('on insert')) {
+                analysis.recommendedType = 'business_rule';
+            }
+            else if (reqLower.includes('reusable') || reqLower.includes('utility') ||
+                reqLower.includes('ajax') || reqLower.includes('api')) {
+                analysis.recommendedType = 'script_include';
+            }
+            else if (reqLower.includes('form') || reqLower.includes('client') ||
+                reqLower.includes('ui') || reqLower.includes('user interface')) {
+                analysis.recommendedType = 'client_script';
+            }
+        }
+        // Extract table name
+        const tables = ['incident', 'change_request', 'problem', 'task', 'user', 'group'];
+        for (const table of tables) {
+            if (reqLower.includes(table)) {
+                analysis.detectedTable = table;
+                break;
+            }
+        }
+        // Detect timing for business rules
+        if (reqLower.includes('before'))
+            analysis.when = 'before';
+        else if (reqLower.includes('after'))
+            analysis.when = 'after';
+        else if (reqLower.includes('async'))
+            analysis.when = 'async';
+        // Detect client script type
+        if (reqLower.includes('load'))
+            analysis.clientType = 'onLoad';
+        else if (reqLower.includes('change'))
+            analysis.clientType = 'onChange';
+        else if (reqLower.includes('submit'))
+            analysis.clientType = 'onSubmit';
+        // Extract features
+        if (reqLower.includes('validate'))
+            analysis.features.push('validation');
+        if (reqLower.includes('calculate'))
+            analysis.features.push('calculation');
+        if (reqLower.includes('email') || reqLower.includes('notify'))
+            analysis.features.push('notification');
+        if (reqLower.includes('integrate') || reqLower.includes('api'))
+            analysis.features.push('integration');
+        // Generate suggested name
+        const words = requirements.split(/\s+/).slice(0, 5);
+        analysis.suggestedName = words.join(' ');
+        return analysis;
+    }
+    generateSmartBusinessRule(analysis) {
+        let script = '(function executeRule(current, previous /*null when async*/) {\n';
+        // Add features based on analysis
+        analysis.features.forEach((feature) => {
+            switch (feature) {
+                case 'validation':
+                    script += `\n    // Validation
+    if (!current.field_name) {
+        current.setAbortAction(true);
+        gs.addErrorMessage('Field is required');
+        return;
+    }\n`;
+                    break;
+                case 'calculation':
+                    script += `\n    // Calculation
+    var calculated = calculateValue(current);
+    current.calculated_field = calculated;\n`;
+                    break;
+                case 'notification':
+                    script += `\n    // Send notification
+    gs.eventQueue('custom.event', current, current.assigned_to, current.assignment_group);\n`;
+                    break;
+            }
+        });
+        script += '\n})(current, previous);';
+        return script;
+    }
+    generateSmartScriptInclude(analysis) {
+        const className = this.generateAPIName(analysis.suggestedName);
+        let script = `var ${className} = Class.create();\n${className}.prototype = {\n`;
+        script += '    initialize: function() {\n    },\n\n';
+        // Add methods based on features
+        analysis.features.forEach((feature) => {
+            switch (feature) {
+                case 'validation':
+                    script += `    validate: function(record) {
+        // Validation logic
+        return true;
+    },\n\n`;
+                    break;
+                case 'integration':
+                    script += `    callExternalAPI: function(endpoint, payload) {
+        var request = new sn_ws.RESTMessageV2();
+        // API call implementation
+        return response;
+    },\n\n`;
+                    break;
+            }
+        });
+        script += `    type: '${className}'\n};`;
+        return script;
+    }
+    generateSmartClientScript(analysis) {
+        const type = analysis.clientType || 'onChange';
+        switch (type) {
+            case 'onLoad':
+                return this.generateClientScriptCode('onLoad');
+            case 'onChange':
+                return this.generateClientScriptCode('onChange', 'field_name');
+            case 'onSubmit':
+                return this.generateClientScriptCode('onSubmit');
+            default:
+                return '// Custom client script';
+        }
+    }
+    generateScriptDocumentation(script, analysis, requirements) {
+        return `# ${script.name}
+
+## Overview
+${analysis.description || 'Script generated from requirements'}
+
+## Requirements
+${requirements}
+
+## Script Details
+- **Type**: ${script.type}
+- **Table**: ${script.table || 'N/A'}
+- **When**: ${script.when || 'N/A'}
+- **Active**: ${script.active}
+
+## Features
+${analysis.features.map((f) => `- ${f}`).join('\n')}
+
+## Implementation
+\`\`\`javascript
+${script.script}
+\`\`\`
+
+## Usage Notes
+- This script was automatically generated based on the provided requirements
+- Review and test thoroughly before deploying to production
+- Consider adding error handling and logging as needed
+
+## Testing
+${script.type === 'script_include' ? 'See accompanying test script for testing procedures' : 'Test in a development instance first'}
+
+Generated on: ${new Date().toISOString()}
+Generated by: ServiceNow Multi-Agent Framework - Script Generator Agent
+`;
+    }
+    analyzeScriptPerformance(script) {
+        const analysis = {
+            issues: [],
+            improvements: [],
+            optimizations: [],
+            estimatedGains: {}
+        };
+        // Check for common performance issues
+        if (script.includes('GlideRecord') && !script.includes('setLimit')) {
+            analysis.issues.push('Unbounded GlideRecord query detected');
+            analysis.improvements.push('Add setLimit() to GlideRecord queries');
+        }
+        if (script.includes('gr.next()') && script.includes('new GlideRecord')) {
+            const nestedQueries = (script.match(/new GlideRecord/g) || []).length;
+            if (nestedQueries > 1) {
+                analysis.issues.push('Nested GlideRecord queries detected');
+                analysis.improvements.push('Consider using GlideAggregate or joining queries');
+            }
+        }
+        if (script.includes('gs.info') || script.includes('gs.log')) {
+            analysis.issues.push('Excessive logging detected');
+            analysis.improvements.push('Remove or conditionalize debug logging');
+        }
+        // Suggest optimizations
+        if (script.includes('getValue()') && script.match(/getValue\(\)/g)?.length > 3) {
+            analysis.optimizations.push('Cache frequently accessed values');
+        }
+        return analysis;
+    }
+    applyScriptOptimizations(script, analysis, goals) {
+        let optimized = script;
+        // Apply optimizations based on goals
+        if (goals.includes('performance')) {
+            // Add setLimit to queries without it
+            optimized = optimized.replace(/gr\.query\(\);/g, 'gr.setLimit(1000);\n    gr.query();');
+            // Cache getValue calls
+            optimized = optimized.replace(/current\.getValue\('(\w+)'\)/g, (match, field) => `cached_${field} || (cached_${field} = current.getValue('${field}'))`);
+        }
+        if (goals.includes('readability')) {
+            // Add proper indentation
+            optimized = this.formatScript(optimized);
+        }
+        if (goals.includes('maintainability')) {
+            // Extract magic numbers to constants
+            optimized = optimized.replace(/(\d{3,})/g, (match) => {
+                return `CONST_${match}`;
+            });
+        }
+        return optimized;
+    }
+    formatScript(script) {
+        // Simple formatting - in practice, use a proper formatter
+        let formatted = script;
+        let indent = 0;
+        formatted = formatted.split('\n').map(line => {
+            const trimmed = line.trim();
+            if (trimmed.endsWith('{')) {
+                const result = '    '.repeat(indent) + trimmed;
+                indent++;
+                return result;
+            }
+            else if (trimmed.startsWith('}')) {
+                indent = Math.max(0, indent - 1);
+                return '    '.repeat(indent) + trimmed;
+            }
+            return '    '.repeat(indent) + trimmed;
+        }).join('\n');
+        return formatted;
+    }
+    sanitizeName(name) {
+        return name.toLowerCase().replace(/[^a-z0-9]/g, '_');
+    }
+}
+exports.ScriptGeneratorAgent = ScriptGeneratorAgent;
+//# sourceMappingURL=script-generator.agent.js.map