snow-flow 1.1.76 → 1.1.77

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

@@ -0,0 +1,695 @@
+"use strict";
+/**
+ * Script Writer Agent
+ * Specializes in creating ServiceNow scripts (Business Rules, Script Includes, Client Scripts)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptWriterAgent = void 0;
+const base_agent_1 = require("./base-agent");
+class ScriptWriterAgent extends base_agent_1.BaseAgent {
+    constructor(config) {
+        super({
+            type: 'script-writer',
+            capabilities: [
+                'Business rule creation',
+                'Script include development',
+                'Client script implementation',
+                'Data transformation scripts',
+                'Performance optimization',
+                'GlideRecord operations',
+                'GlideSystem methods',
+                'REST API scripting',
+                'Scheduled job scripts'
+            ],
+            mcpTools: [
+                'snow_create_script_include',
+                'snow_create_business_rule',
+                'snow_create_client_script',
+                'snow_create_ui_action',
+                'snow_create_scheduled_job',
+                'snow_discover_table_fields',
+                'snow_table_schema_discovery'
+            ],
+            ...config
+        });
+    }
+    async execute(instruction, context) {
+        try {
+            this.setStatus('working');
+            await this.reportProgress('Starting script creation', 0);
+            // Analyze script requirements
+            const requirements = await this.analyzeScriptRequirements(instruction);
+            await this.reportProgress('Analyzed script requirements', 20);
+            // Discover table schema if needed
+            if (requirements.targetTable) {
+                const schema = await this.discoverTableSchema(requirements.targetTable);
+                requirements.tableFields = schema.fields;
+                await this.reportProgress('Discovered table schema', 30);
+            }
+            // Generate script based on type
+            let script;
+            let scriptConfig;
+            switch (requirements.scriptType) {
+                case 'business_rule':
+                    script = await this.createBusinessRuleScript(requirements);
+                    scriptConfig = this.createBusinessRuleConfig(requirements, script);
+                    break;
+                case 'script_include':
+                    script = await this.createScriptIncludeScript(requirements);
+                    scriptConfig = this.createScriptIncludeConfig(requirements, script);
+                    break;
+                case 'client_script':
+                    script = await this.createClientScript(requirements);
+                    scriptConfig = this.createClientScriptConfig(requirements, script);
+                    break;
+                case 'scheduled_job':
+                    script = await this.createScheduledJobScript(requirements);
+                    scriptConfig = this.createScheduledJobConfig(requirements, script);
+                    break;
+                default:
+                    throw new Error(`Unknown script type: ${requirements.scriptType}`);
+            }
+            await this.reportProgress(`Created ${requirements.scriptType} script`, 60);
+            // Add performance optimizations
+            if (requirements.needsOptimization) {
+                script = await this.optimizeScript(script, requirements);
+                scriptConfig.script = script;
+                await this.reportProgress('Optimized script performance', 70);
+            }
+            // Create script artifact
+            const artifact = {
+                type: 'script',
+                name: requirements.name,
+                config: scriptConfig,
+                dependencies: requirements.dependencies
+            };
+            // Store artifact for other agents
+            await this.storeArtifact(artifact);
+            await this.reportProgress('Script artifact created and stored', 85);
+            // Generate documentation
+            const documentation = this.generateDocumentation(requirements, script);
+            await this.reportProgress('Generated script documentation', 95);
+            await this.reportProgress('Script creation completed', 100);
+            this.setStatus('completed');
+            await this.logActivity('script_creation', true, {
+                scriptName: requirements.name,
+                scriptType: requirements.scriptType,
+                targetTable: requirements.targetTable
+            });
+            return {
+                success: true,
+                artifacts: [artifact],
+                message: `${requirements.scriptType} "${requirements.name}" created successfully`,
+                metadata: {
+                    scriptType: requirements.scriptType,
+                    targetTable: requirements.targetTable,
+                    when: requirements.when,
+                    documentation,
+                    performanceOptimized: requirements.needsOptimization
+                }
+            };
+        }
+        catch (error) {
+            this.setStatus('failed');
+            await this.logActivity('script_creation', false, { error: error.message });
+            return {
+                success: false,
+                error: error,
+                message: `Failed to create script: ${error.message}`
+            };
+        }
+    }
+    async analyzeScriptRequirements(instruction) {
+        const requirements = {
+            name: '',
+            scriptType: '',
+            targetTable: '',
+            when: '',
+            async: false,
+            needsOptimization: false,
+            operations: [],
+            dependencies: [],
+            tableFields: [],
+            conditions: [],
+            features: []
+        };
+        // Determine script type
+        if (/business\s*rule/i.test(instruction)) {
+            requirements.scriptType = 'business_rule';
+        }
+        else if (/script\s*include/i.test(instruction)) {
+            requirements.scriptType = 'script_include';
+        }
+        else if (/client\s*script/i.test(instruction)) {
+            requirements.scriptType = 'client_script';
+        }
+        else if (/scheduled\s*job|scheduled\s*script/i.test(instruction)) {
+            requirements.scriptType = 'scheduled_job';
+        }
+        else {
+            // Default to business rule if table is mentioned
+            requirements.scriptType = /table|record/i.test(instruction) ? 'business_rule' : 'script_include';
+        }
+        // Extract script name
+        const nameMatch = instruction.match(/(?:create|write|build)\s+(?:a\s+)?([a-zA-Z0-9_\s]+?)(?:\s+(?:business\s*rule|script\s*include|client\s*script|for))/i);
+        if (nameMatch) {
+            requirements.name = nameMatch[1].trim().toLowerCase().replace(/\s+/g, '_');
+        }
+        else {
+            requirements.name = `custom_${requirements.scriptType}_${Date.now()}`;
+        }
+        // Detect target table
+        const tableMatch = instruction.match(/(?:for|on|table)\s+([a-zA-Z0-9_]+)/i);
+        if (tableMatch) {
+            requirements.targetTable = tableMatch[1];
+        }
+        else if (/incident/i.test(instruction)) {
+            requirements.targetTable = 'incident';
+        }
+        else if (/request/i.test(instruction)) {
+            requirements.targetTable = 'sc_request';
+        }
+        else if (/task/i.test(instruction)) {
+            requirements.targetTable = 'task';
+        }
+        // Determine when to execute (for business rules)
+        if (/before/i.test(instruction)) {
+            requirements.when = 'before';
+        }
+        else if (/after/i.test(instruction)) {
+            requirements.when = 'after';
+        }
+        else if (/async/i.test(instruction)) {
+            requirements.when = 'async';
+            requirements.async = true;
+        }
+        else if (/display/i.test(instruction)) {
+            requirements.when = 'display';
+        }
+        // Detect operations
+        if (/create|insert/i.test(instruction)) {
+            requirements.operations.push('insert');
+        }
+        if (/update|modify/i.test(instruction)) {
+            requirements.operations.push('update');
+        }
+        if (/delete|remove/i.test(instruction)) {
+            requirements.operations.push('delete');
+        }
+        if (!requirements.operations.length && requirements.scriptType === 'business_rule') {
+            requirements.operations = ['insert', 'update']; // Default
+        }
+        // Feature detection
+        if (/validat/i.test(instruction)) {
+            requirements.features.push('validation');
+        }
+        if (/calculat|compute/i.test(instruction)) {
+            requirements.features.push('calculation');
+        }
+        if (/notification|email/i.test(instruction)) {
+            requirements.features.push('notification');
+            requirements.dependencies.push('sys_email');
+        }
+        if (/api|rest|integration/i.test(instruction)) {
+            requirements.features.push('api_call');
+            requirements.dependencies.push('sys_rest_message');
+        }
+        if (/transform|convert/i.test(instruction)) {
+            requirements.features.push('data_transformation');
+        }
+        if (/performance|optimi/i.test(instruction)) {
+            requirements.needsOptimization = true;
+        }
+        return requirements;
+    }
+    async discoverTableSchema(tableName) {
+        // This would use snow_table_schema_discovery MCP tool
+        // For now, return common fields
+        return {
+            fields: [
+                { name: 'sys_id', type: 'GUID', mandatory: true },
+                { name: 'number', type: 'string', mandatory: true },
+                { name: 'short_description', type: 'string', mandatory: false },
+                { name: 'description', type: 'text', mandatory: false },
+                { name: 'state', type: 'integer', mandatory: false },
+                { name: 'priority', type: 'integer', mandatory: false },
+                { name: 'assigned_to', type: 'reference', reference: 'sys_user' },
+                { name: 'assignment_group', type: 'reference', reference: 'sys_user_group' },
+                { name: 'sys_created_on', type: 'glide_date_time', mandatory: true },
+                { name: 'sys_updated_on', type: 'glide_date_time', mandatory: true }
+            ]
+        };
+    }
+    async createBusinessRuleScript(requirements) {
+        let script = '(function executeRule(current, previous /*null when async*/) {\n\n';
+        // Add header comment
+        script += `  // Business Rule: ${requirements.name}\n`;
+        script += `  // Table: ${requirements.targetTable}\n`;
+        script += `  // When: ${requirements.when}\n`;
+        script += `  // Operations: ${requirements.operations.join(', ')}\n\n`;
+        // Add validation if needed
+        if (requirements.features.includes('validation')) {
+            script += '  // Validation logic\n';
+            script += '  if (!current.short_description || current.short_description.toString().trim() === "") {\n';
+            script += '    gs.addErrorMessage("Short description is required");\n';
+            script += '    current.setAbortAction(true);\n';
+            script += '    return;\n';
+            script += '  }\n\n';
+        }
+        // Add calculation if needed
+        if (requirements.features.includes('calculation')) {
+            script += '  // Calculation logic\n';
+            script += '  if (current.priority == 1 && current.impact == 1) {\n';
+            script += '    current.urgency = 1; // High urgency for P1 high impact\n';
+            script += '  }\n\n';
+        }
+        // Add main business logic based on when
+        switch (requirements.when) {
+            case 'before':
+                script += '  // Before business logic\n';
+                script += '  // Set field values before the record is saved\n';
+                script += '  if (current.isNewRecord()) {\n';
+                script += '    current.active = true;\n';
+                script += `    current.created_by_rule = "${requirements.name}";\n`;
+                script += '  }\n\n';
+                script += '  // Track changes\n';
+                script += '  if (!current.isNewRecord() && current.state.changes()) {\n';
+                script += '    current.work_notes = "State changed from " + previous.getDisplayValue("state") + " to " + current.getDisplayValue("state");\n';
+                script += '  }\n';
+                break;
+            case 'after':
+                script += '  // After business logic\n';
+                script += '  // Perform actions after the record is saved\n';
+                if (requirements.features.includes('notification')) {
+                    script += '  \n  // Send notification\n';
+                    script += '  if (current.isNewRecord() || current.state.changes()) {\n';
+                    script += '    gs.eventQueue("record.updated", current, current.assigned_to, current.assignment_group);\n';
+                    script += '  }\n';
+                }
+                script += '  \n  // Create related records if needed\n';
+                script += '  if (current.isNewRecord() && current.priority == 1) {\n';
+                script += '    // Example: Create a task for high priority items\n';
+                script += '    var task = new GlideRecord("task");\n';
+                script += '    task.initialize();\n';
+                script += '    task.parent = current.sys_id;\n';
+                script += '    task.short_description = "Review high priority " + current.getDisplayValue();\n';
+                script += '    task.insert();\n';
+                script += '  }\n';
+                break;
+            case 'async':
+                script += '  // Async business logic\n';
+                script += '  // This runs in the background after the record is saved\n';
+                if (requirements.features.includes('api_call')) {
+                    script += '  \n  // Make API call\n';
+                    script += '  try {\n';
+                    script += '    var r = new sn_ws.RESTMessageV2();\n';
+                    script += '    r.setEndpoint("https://api.example.com/webhook");\n';
+                    script += '    r.setHttpMethod("POST");\n';
+                    script += '    r.setRequestBody(JSON.stringify({\n';
+                    script += '      record_number: current.number.toString(),\n';
+                    script += '      record_type: current.getTableName(),\n';
+                    script += '      action: "created"\n';
+                    script += '    }));\n';
+                    script += '    var response = r.execute();\n';
+                    script += '    gs.info("API Response: " + response.getStatusCode());\n';
+                    script += '  } catch (ex) {\n';
+                    script += '    gs.error("API call failed: " + ex.getMessage());\n';
+                    script += '  }\n';
+                }
+                break;
+        }
+        // Add error handling
+        script += '\n  // Error handling\n';
+        script += '  try {\n';
+        script += '    // Additional processing can go here\n';
+        script += '  } catch (e) {\n';
+        script += `    gs.error("Error in business rule ${requirements.name}: " + e.getMessage());\n`;
+        script += '  }\n';
+        script += '\n})(current, previous);';
+        return script;
+    }
+    async createScriptIncludeScript(requirements) {
+        let script = `var ${requirements.name} = Class.create();\n`;
+        script += `${requirements.name}.prototype = {\n`;
+        script += '  initialize: function() {\n';
+        script += '    // Initialize the script include\n';
+        script += '    this.log_source = "' + requirements.name + '";\n';
+        script += '  },\n\n';
+        // Add main methods based on features
+        if (requirements.features.includes('data_transformation')) {
+            script += '  /**\n';
+            script += '   * Transform data from one format to another\n';
+            script += '   * @param {Object} sourceData - The data to transform\n';
+            script += '   * @return {Object} Transformed data\n';
+            script += '   */\n';
+            script += '  transformData: function(sourceData) {\n';
+            script += '    var transformedData = {};\n';
+            script += '    \n';
+            script += '    try {\n';
+            script += '      // Transformation logic\n';
+            script += '      for (var key in sourceData) {\n';
+            script += '        if (sourceData.hasOwnProperty(key)) {\n';
+            script += '          transformedData[this._normalizeKey(key)] = sourceData[key];\n';
+            script += '        }\n';
+            script += '      }\n';
+            script += '    } catch (e) {\n';
+            script += '      gs.error(this.log_source + ": Error transforming data - " + e.getMessage());\n';
+            script += '    }\n';
+            script += '    \n';
+            script += '    return transformedData;\n';
+            script += '  },\n\n';
+            script += '  _normalizeKey: function(key) {\n';
+            script += '    return key.toLowerCase().replace(/[^a-z0-9]/g, "_");\n';
+            script += '  },\n\n';
+        }
+        if (requirements.features.includes('api_call')) {
+            script += '  /**\n';
+            script += '   * Make an API call to external service\n';
+            script += '   * @param {String} endpoint - API endpoint\n';
+            script += '   * @param {Object} payload - Request payload\n';
+            script += '   * @return {Object} API response\n';
+            script += '   */\n';
+            script += '  callAPI: function(endpoint, payload) {\n';
+            script += '    var response = {\n';
+            script += '      success: false,\n';
+            script += '      data: null,\n';
+            script += '      error: null\n';
+            script += '    };\n';
+            script += '    \n';
+            script += '    try {\n';
+            script += '      var r = new sn_ws.RESTMessageV2();\n';
+            script += '      r.setEndpoint(endpoint);\n';
+            script += '      r.setHttpMethod("POST");\n';
+            script += '      r.setRequestHeader("Content-Type", "application/json");\n';
+            script += '      r.setRequestBody(JSON.stringify(payload));\n';
+            script += '      \n';
+            script += '      var httpResponse = r.execute();\n';
+            script += '      response.success = httpResponse.getStatusCode() == 200;\n';
+            script += '      response.data = JSON.parse(httpResponse.getBody());\n';
+            script += '    } catch (e) {\n';
+            script += '      response.error = e.getMessage();\n';
+            script += '      gs.error(this.log_source + ": API call failed - " + e.getMessage());\n';
+            script += '    }\n';
+            script += '    \n';
+            script += '    return response;\n';
+            script += '  },\n\n';
+        }
+        // Add utility methods
+        script += '  /**\n';
+        script += '   * Process records from a table\n';
+        script += '   * @param {String} tableName - Table to process\n';
+        script += '   * @param {String} query - Encoded query\n';
+        script += '   * @param {Function} callback - Function to call for each record\n';
+        script += '   */\n';
+        script += '  processRecords: function(tableName, query, callback) {\n';
+        script += '    var count = 0;\n';
+        script += '    var gr = new GlideRecord(tableName);\n';
+        script += '    \n';
+        script += '    if (query) {\n';
+        script += '      gr.addEncodedQuery(query);\n';
+        script += '    }\n';
+        script += '    \n';
+        script += '    gr.query();\n';
+        script += '    \n';
+        script += '    while (gr.next()) {\n';
+        script += '      try {\n';
+        script += '        callback(gr);\n';
+        script += '        count++;\n';
+        script += '      } catch (e) {\n';
+        script += '        gs.error(this.log_source + ": Error processing record " + gr.getUniqueValue() + " - " + e.getMessage());\n';
+        script += '      }\n';
+        script += '    }\n';
+        script += '    \n';
+        script += '    gs.info(this.log_source + ": Processed " + count + " records from " + tableName);\n';
+        script += '    return count;\n';
+        script += '  },\n\n';
+        // Add type checking
+        script += '  type: "' + requirements.name + '"\n';
+        script += '};';
+        return script;
+    }
+    async createClientScript(requirements) {
+        let script = 'function ';
+        // Determine function name based on type
+        let functionName = 'onLoad';
+        if (requirements.when === 'onChange') {
+            functionName = 'onChange';
+        }
+        else if (requirements.when === 'onSubmit') {
+            functionName = 'onSubmit';
+        }
+        // Add appropriate function signature
+        switch (functionName) {
+            case 'onLoad':
+                script += 'onLoad() {\n';
+                break;
+            case 'onChange':
+                script += 'onChange(control, oldValue, newValue, isLoading, isTemplate) {\n';
+                script += '  if (isLoading || newValue === "") {\n';
+                script += '    return;\n';
+                script += '  }\n\n';
+                break;
+            case 'onSubmit':
+                script += 'onSubmit() {\n';
+                break;
+        }
+        // Add script logic based on features
+        if (requirements.features.includes('validation')) {
+            script += '  // Client-side validation\n';
+            script += '  var shortDesc = g_form.getValue("short_description");\n';
+            script += '  if (!shortDesc || shortDesc.trim() === "") {\n';
+            script += '    g_form.showFieldMsg("short_description", "Short description is required", "error");\n';
+            script += '    g_form.setMandatory("short_description", true);\n';
+            if (functionName === 'onSubmit') {
+                script += '    return false; // Prevent form submission\n';
+            }
+            script += '  }\n\n';
+        }
+        if (requirements.features.includes('calculation')) {
+            script += '  // Field calculations\n';
+            script += '  var priority = g_form.getValue("priority");\n';
+            script += '  var impact = g_form.getValue("impact");\n';
+            script += '  \n';
+            script += '  if (priority == "1" && impact == "1") {\n';
+            script += '    g_form.setValue("urgency", "1");\n';
+            script += '    g_form.showFieldMsg("urgency", "Urgency set to High due to P1/High Impact", "info");\n';
+            script += '  }\n\n';
+        }
+        // Add UI behavior logic
+        script += '  // UI behavior\n';
+        script += '  var state = g_form.getValue("state");\n';
+        script += '  \n';
+        script += '  // Show/hide fields based on state\n';
+        script += '  if (state == "1") { // New\n';
+        script += '    g_form.setDisplay("resolution_notes", false);\n';
+        script += '    g_form.setDisplay("resolved_at", false);\n';
+        script += '  } else if (state == "6") { // Resolved\n';
+        script += '    g_form.setDisplay("resolution_notes", true);\n';
+        script += '    g_form.setMandatory("resolution_notes", true);\n';
+        script += '  }\n\n';
+        // Add AJAX example if needed
+        if (requirements.features.includes('api_call')) {
+            script += '  // AJAX call example\n';
+            script += '  var ga = new GlideAjax("' + requirements.name + '_Ajax");\n';
+            script += '  ga.addParam("sysparm_name", "getData");\n';
+            script += '  ga.addParam("sysparm_value", g_form.getValue("number"));\n';
+            script += '  ga.getXMLAnswer(function(response) {\n';
+            script += '    if (response) {\n';
+            script += '      g_form.addInfoMessage("Data retrieved: " + response);\n';
+            script += '    }\n';
+            script += '  });\n\n';
+        }
+        // Close function
+        if (functionName === 'onSubmit') {
+            script += '  return true; // Allow form submission\n';
+        }
+        script += '}';
+        return script;
+    }
+    async createScheduledJobScript(requirements) {
+        let script = '// Scheduled Job: ' + requirements.name + '\n';
+        script += '// Schedule: Daily at midnight (adjust as needed)\n\n';
+        script += '(function executeScheduledJob() {\n';
+        script += '  var startTime = new GlideDateTime();\n';
+        script += '  gs.info("' + requirements.name + ' - Started at " + startTime.getDisplayValue());\n\n';
+        script += '  try {\n';
+        script += '    var recordCount = 0;\n';
+        script += '    var errorCount = 0;\n\n';
+        if (requirements.targetTable) {
+            script += '    // Process records from ' + requirements.targetTable + '\n';
+            script += '    var gr = new GlideRecord("' + requirements.targetTable + '");\n';
+            script += '    gr.addQuery("active", true);\n';
+            // Add date filter for scheduled cleanup jobs
+            if (requirements.features.includes('cleanup')) {
+                script += '    // Process records older than 30 days\n';
+                script += '    gr.addQuery("sys_updated_on", "<", gs.daysAgoStart(30));\n';
+            }
+            script += '    gr.query();\n\n';
+            script += '    while (gr.next()) {\n';
+            script += '      try {\n';
+            script += '        // Process each record\n';
+            script += '        recordCount++;\n';
+            if (requirements.features.includes('data_transformation')) {
+                script += '        \n        // Transform data\n';
+                script += '        var transformedData = transformRecord(gr);\n';
+                script += '        if (transformedData) {\n';
+                script += '          gr.work_notes = "Processed by scheduled job: " + transformedData.summary;\n';
+                script += '          gr.update();\n';
+                script += '        }\n';
+            }
+            script += '      } catch (e) {\n';
+            script += '        errorCount++;\n';
+            script += '        gs.error("' + requirements.name + ' - Error processing record " + gr.getDisplayValue() + ": " + e.getMessage());\n';
+            script += '      }\n';
+            script += '    }\n';
+        }
+        // Add summary reporting
+        script += '\n    // Summary report\n';
+        script += '    var endTime = new GlideDateTime();\n';
+        script += '    var duration = GlideDateTime.subtract(startTime, endTime);\n';
+        script += '    \n';
+        script += '    var summary = {\n';
+        script += '      job_name: "' + requirements.name + '",\n';
+        script += '      start_time: startTime.getDisplayValue(),\n';
+        script += '      end_time: endTime.getDisplayValue(),\n';
+        script += '      duration: duration.getDisplayValue(),\n';
+        script += '      records_processed: recordCount,\n';
+        script += '      errors: errorCount,\n';
+        script += '      status: errorCount === 0 ? "Success" : "Completed with errors"\n';
+        script += '    };\n';
+        script += '    \n';
+        script += '    gs.info("' + requirements.name + ' - Summary: " + JSON.stringify(summary));\n';
+        // Send notification if configured
+        if (requirements.features.includes('notification')) {
+            script += '    \n    // Send completion notification\n';
+            script += '    if (errorCount > 0) {\n';
+            script += '      gs.eventQueue("scheduled_job.error", null, JSON.stringify(summary));\n';
+            script += '    }\n';
+        }
+        script += '  } catch (e) {\n';
+        script += '    gs.error("' + requirements.name + ' - Fatal error: " + e.getMessage());\n';
+        script += '  }\n';
+        // Add helper function if needed
+        if (requirements.features.includes('data_transformation')) {
+            script += '\n  function transformRecord(record) {\n';
+            script += '    // Transform record data\n';
+            script += '    return {\n';
+            script += '      summary: record.short_description + " - Processed",\n';
+            script += '      processed_date: new GlideDateTime().getDisplayValue()\n';
+            script += '    };\n';
+            script += '  }\n';
+        }
+        script += '})();';
+        return script;
+    }
+    async optimizeScript(script, requirements) {
+        let optimizedScript = script;
+        // Add caching for repeated queries
+        if (script.includes('new GlideRecord') && script.includes('while')) {
+            optimizedScript = '// Performance optimization: Use setLimit for large queries\n' + optimizedScript;
+            optimizedScript = optimizedScript.replace(/gr\.query\(\);/g, 'gr.setLimit(1000); // Prevent memory issues\n    gr.query();');
+        }
+        // Use GlideAggregate for counting
+        if (script.includes('count') || script.includes('COUNT')) {
+            const aggregateExample = '\n// Performance tip: Use GlideAggregate for counting:\n' +
+                '// var ga = new GlideAggregate("table_name");\n' +
+                '// ga.addAggregate("COUNT");\n' +
+                '// ga.query();\n' +
+                '// var count = ga.next() ? ga.getAggregate("COUNT") : 0;\n\n';
+            optimizedScript = aggregateExample + optimizedScript;
+        }
+        // Add bulk operations tip
+        if (script.includes('.update()') && script.includes('while')) {
+            const bulkTip = '\n// Performance tip: Consider using updateMultiple() for bulk updates\n' +
+                '// gr.setValue("field", "value");\n' +
+                '// gr.updateMultiple();\n\n';
+            optimizedScript = bulkTip + optimizedScript;
+        }
+        return optimizedScript;
+    }
+    createBusinessRuleConfig(requirements, script) {
+        return {
+            name: requirements.name,
+            table: requirements.targetTable,
+            active: true,
+            when: requirements.when,
+            order: 100,
+            script: script,
+            condition: requirements.conditions.join(' AND ') || '',
+            description: `Auto-generated business rule: ${requirements.name}`,
+            advanced: true,
+            actions: {
+                insert: requirements.operations.includes('insert'),
+                update: requirements.operations.includes('update'),
+                delete: requirements.operations.includes('delete'),
+                query: requirements.operations.includes('query')
+            }
+        };
+    }
+    createScriptIncludeConfig(requirements, script) {
+        return {
+            name: requirements.name,
+            api_name: requirements.name,
+            client_callable: false,
+            active: true,
+            script: script,
+            description: `Auto-generated script include: ${requirements.name}`,
+            access: 'package_private'
+        };
+    }
+    createClientScriptConfig(requirements, script) {
+        return {
+            name: requirements.name,
+            table: requirements.targetTable,
+            type: requirements.when || 'onLoad',
+            field: '', // Set if onChange script
+            script: script,
+            active: true,
+            description: `Auto-generated client script: ${requirements.name}`,
+            messages: [],
+            global: false,
+            isolate_script: true,
+            ui_type: 10 // Desktop
+        };
+    }
+    createScheduledJobConfig(requirements, script) {
+        return {
+            name: requirements.name,
+            script: script,
+            active: true,
+            run_type: 'periodically',
+            run_period: '1 day',
+            run_time: '00:00:00',
+            run_dayofweek: 'all',
+            conditional: false,
+            condition: ''
+        };
+    }
+    generateDocumentation(requirements, script) {
+        let doc = `# ${requirements.name}\n\n`;
+        doc += `## Type\n${requirements.scriptType}\n\n`;
+        if (requirements.targetTable) {
+            doc += `## Target Table\n${requirements.targetTable}\n\n`;
+        }
+        if (requirements.when) {
+            doc += `## When\n${requirements.when}\n\n`;
+        }
+        doc += `## Features\n`;
+        requirements.features.forEach(feature => {
+            doc += `- ${feature}\n`;
+        });
+        doc += `\n## Dependencies\n`;
+        if (requirements.dependencies.length > 0) {
+            requirements.dependencies.forEach(dep => {
+                doc += `- ${dep}\n`;
+            });
+        }
+        else {
+            doc += 'None\n';
+        }
+        doc += `\n## Performance Optimized\n${requirements.needsOptimization ? 'Yes' : 'No'}\n`;
+        return doc;
+    }
+}
+exports.ScriptWriterAgent = ScriptWriterAgent;
+//# sourceMappingURL=script-writer-agent.js.map