snow-flow 3.0.9 → 3.0.10

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

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