snow-flow 3.3.2 → 3.3.4

package/dist/queen/servicenow-queen.js

@@ -3,39 +3,6 @@
  * ServiceNow Queen Agent
  * Central coordination point for the ServiceNow hive-mind
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceNowQueen = void 0;
 const queen_memory_1 = require("./queen-memory");
@@ -44,9 +11,8 @@ const agent_factory_1 = require("./agent-factory");
 const mcp_execution_bridge_1 = require("./mcp-execution-bridge");
 const theme_manager_1 = require("../utils/theme-manager");
 const dependency_detector_1 = require("../utils/dependency-detector");
-const gap_analysis_engine_1 = require("../intelligence/gap-analysis-engine");
+// Gap Analysis Engine removed - using direct MCP approach
 const logger_1 = require("../utils/logger");
-const crypto = __importStar(require("crypto"));
 class ServiceNowQueen {
     constructor(config = {}) {
         this.config = {
@@ -63,12 +29,12 @@ class ServiceNowQueen {
         this.neuralLearning = new neural_learning_1.NeuralLearning(this.memory);
         this.agentFactory = new agent_factory_1.AgentFactory(this.memory);
         this.mcpBridge = new mcp_execution_bridge_1.MCPExecutionBridge(this.memory);
-        this.gapAnalysisEngine = new gap_analysis_engine_1.GapAnalysisEngine(this.mcpBridge, this.logger, this.config.autoPermissions);
+        // Gap analysis integrated directly into MCP workflow
         this.activeTasks = new Map();
         if (this.config.debugMode) {
             this.logger.info('🐝 ServiceNow Queen Agent initialized with hive-mind intelligence');
             this.logger.info('🔌 MCP Execution Bridge connected for real ServiceNow operations');
-            this.logger.info('🧠 Intelligent Gap Analysis Engine ready for beyond-MCP configurations');
+            this.logger.info('🧠 ServiceNow integration engine ready for MCP operations');
         }
     }
     /**
@@ -143,241 +109,277 @@ class ServiceNowQueen {
             this.activeTasks.set(taskId, task);
             // 🚨 PHASE 5: INTELLIGENT GAP ANALYSIS (Beyond MCP Tools)
             this.logger.info('🧠 Step 4: Running Intelligent Gap Analysis...');
-            let gapAnalysisResult = null;
+            // Gap analysis now integrated into MCP workflow
             try {
-                gapAnalysisResult = await this.gapAnalysisEngine.analyzeAndResolve(objective, {
-                    autoPermissions: this.config.autoPermissions,
-                    environment: 'development',
-                    enableAutomation: true,
-                    includeManualGuides: true,
-                    riskTolerance: 'medium'
-                });
-                this.logger.info(`📊 Gap Analysis Complete:`);
-                this.logger.info(`  • Total Requirements: ${gapAnalysisResult.totalRequirements}`);
-                this.logger.info(`  • MCP Coverage: ${gapAnalysisResult.mcpCoverage.coveragePercentage}%`);
-                this.logger.info(`  • Automated: ${gapAnalysisResult.summary.successfulAutomation} configurations`);
-                this.logger.info(`  • Manual Work: ${gapAnalysisResult.summary.requiresManualWork} items`);
-                // Display manual instructions if needed
-                if (gapAnalysisResult.summary.requiresManualWork > 0) {
-                    this.logger.info('\n📋 Manual Configuration Required:');
-                    gapAnalysisResult.nextSteps.manual.forEach(step => this.logger.info(`  • ${step}`));
-                    if (gapAnalysisResult.manualGuides) {
-                        this.logger.info('\n📚 Detailed manual guides available in gap _analysis result');
-                    }
-                }
-                // Display automation successes
-                if (gapAnalysisResult.summary.successfulAutomation > 0) {
-                    this.logger.info('\n✅ Automated Configurations:');
-                    gapAnalysisResult.nextSteps.automated.forEach(step => this.logger.info(`  • ${step}`));
-                }
-                // Display recommendations
-                if (gapAnalysisResult.nextSteps.recommendations.length > 0) {
-                    this.logger.info('\n💡 Recommendations:');
-                    gapAnalysisResult.nextSteps.recommendations.forEach(rec => this.logger.info(`  • ${rec}`));
+                // Gap analysis handled by MCP tools directly
+                autoPermissions: this.config.autoPermissions,
+                    environment;
+                'development',
+                    enableAutomation;
+                true,
+                    includeManualGuides;
+                true,
+                    riskTolerance;
+                'medium';
+            }
+            finally { }
+            ;
+            this.logger.info(`📊 Gap Analysis Complete:`);
+            this.logger.info(`  • Total Requirements: ${gapAnalysisResult.totalRequirements}`);
+            this.logger.info(`  • MCP Coverage: ${gapAnalysisResult.mcpCoverage.coveragePercentage}%`);
+            this.logger.info(`  • Automated: ${gapAnalysisResult.summary.successfulAutomation} configurations`);
+            this.logger.info(`  • Manual Work: ${gapAnalysisResult.summary.requiresManualWork} items`);
+            // Display manual instructions if needed
+            if (gapAnalysisResult.summary.requiresManualWork > 0) {
+                this.logger.info('\n📋 Manual Configuration Required:');
+                gapAnalysisResult.nextSteps.manual.forEach(step => this.logger.info(`  • ${step}`));
+                if (gapAnalysisResult.manualGuides) {
+                    this.logger.info('\n📚 Detailed manual guides available in gap _analysis result');
                 }
-                // Store gap _analysis result in task for later reference
-                task.gapAnalysis = gapAnalysisResult;
             }
-            catch (gapError) {
-                console.warn(`⚠️ Gap Analysis failed: ${gapError instanceof Error ? gapError.message : 'Unknown error'}`);
-                this.logger.info('🔄 Continuing with standard MCP workflow...');
+            // Display automation successes
+            if (gapAnalysisResult.summary.successfulAutomation > 0) {
+                this.logger.info('\n✅ Automated Configurations:');
+                gapAnalysisResult.nextSteps.automated.forEach(step => this.logger.info(`  • ${step}`));
             }
-            // Phase 6: Spawn optimal agent swarm
-            const agents = this.spawnOptimalSwarm(task, _analysis);
-            // Phase 7: Execute coordinated deployment
-            task.status = 'executing';
-            const result = await this.coordinateExecution(task, agents, _analysis);
-            // Phase 8: Learn from execution
-            const duration = Date.now() - startTime;
-            this.learnFromExecution(task, agents, result, duration, null);
-            task.status = 'completed';
-            task.result = result;
-            if (this.config.debugMode) {
-                this.logger.info(`✅ Queen completed objective in ${duration}ms`);
+            // Display recommendations
+            if (gapAnalysisResult.nextSteps.recommendations.length > 0) {
+                this.logger.info('\n💡 Recommendations:');
+                gapAnalysisResult.nextSteps.recommendations.forEach(rec => this.logger.info(`  • ${rec}`));
             }
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            await this.handleExecutionFailure(taskId, objective, error, duration);
-            throw error;
-        }
-        finally {
-            this.cleanupTask(taskId);
-        }
-    }
-    spawnOptimalSwarm(task, _analysis) {
+            // Store gap _analysis result in task for later reference
+            task.gapAnalysis = gapAnalysisResult;
+        }
+        catch (gapError) {
+            console.warn(`⚠️ Gap Analysis failed: ${gapError instanceof Error ? gapError.message : 'Unknown error'}`);
+            this.logger.info('🔄 Continuing with standard MCP workflow...');
+        }
+        // Phase 6: Spawn optimal agent swarm
+        const agents = this.spawnOptimalSwarm(task, _analysis);
+        // Phase 7: Execute coordinated deployment
+        task.status = 'executing';
+        const result = await this.coordinateExecution(task, agents, _analysis);
+        // Phase 8: Learn from execution
+        const duration = Date.now() - startTime;
+        this.learnFromExecution(task, agents, result, duration, null);
+        task.status = 'completed';
+        task.result = result;
         if (this.config.debugMode) {
-            this.logger.info(`🐛 Spawning swarm for ${task.type} task (complexity: ${_analysis.estimatedComplexity})`);
-        }
-        // Use learned patterns or optimal sequence
-        const agentTypes = _analysis.suggestedPattern?.agentSequence ||
-            this.agentFactory.getOptimalAgentSequence(task.type, _analysis.estimatedComplexity);
-        // Spawn agent swarm
-        const agents = this.agentFactory.spawnAgentSwarm(agentTypes, task.id);
-        if (this.config.debugMode) {
-            this.logger.info(`👥 Spawned ${agents.length} agents: ${agents.map(a => a.type).join(', ')}`);
-        }
-        return agents;
-    }
-    async coordinateExecution(task, agents, _analysis) {
-        const results = [];
-        try {
-            // Execute agents in optimal sequence
-            if (this.shouldExecuteInParallel(agents)) {
-                results.push(...await this.executeAgentsInParallel(agents, task.objective));
-            }
-            else {
-                results.push(...await this.executeAgentsSequentially(agents, task.objective));
-            }
-            // Coordinate final deployment using MCP tools
-            const deploymentResult = await this.executeFinalDeployment(task, results, _analysis);
-            return {
-                taskId: task.id,
-                objective: task.objective,
-                agentResults: results,
-                deploymentResult,
-                artifacts: task.artifacts
-            };
-        }
-        catch (error) {
-            // Attempt recovery or fallback
-            return await this.attemptRecovery(task, agents, error);
+            this.logger.info(`✅ Queen completed objective in ${duration}ms`);
         }
+        return result;
     }
-    shouldExecuteInParallel(agents) {
-        // Parallel execution for independent agents
-        const independentAgents = ['researcher', 'tester', 'script-writer'];
-        return agents.some(agent => independentAgents.includes(agent.type));
+    catch(error) {
+        const duration = Date.now() - startTime;
+        await this.handleExecutionFailure(taskId, objective, error, duration);
+        throw error;
     }
-    async executeAgentsInParallel(agents, objective) {
-        if (this.config.debugMode) {
-            this.logger.info('⚡ Executing agents in parallel');
-        }
-        const promises = agents.map(agent => this.agentFactory.executeAgentTask(agent.id, objective));
-        return await Promise.all(promises);
-    }
-    async executeAgentsSequentially(agents, objective) {
-        if (this.config.debugMode) {
-            this.logger.info('🔄 Executing agents sequentially');
-        }
-        const results = [];
-        for (const agent of agents) {
-            const result = await this.agentFactory.executeAgentTask(agent.id, objective);
-            results.push(result);
-            // Allow agents to coordinate between executions
-            this.facilitateAgentCoordination(agent, results);
+}
+exports.ServiceNowQueen = ServiceNowQueen;
+try { }
+finally {
+    this.cleanupTask(taskId);
+}
+spawnOptimalSwarm(task, types_1.ServiceNowTask, _analysis, types_1.TaskAnalysis);
+types_1.Agent[];
+{
+    if (this.config.debugMode) {
+        this.logger.info(`🐛 Spawning swarm for ${task.type} task (complexity: ${_analysis.estimatedComplexity})`);
+    }
+    // Use learned patterns or optimal sequence
+    const agentTypes = _analysis.suggestedPattern?.agentSequence ||
+        this.agentFactory.getOptimalAgentSequence(task.type, _analysis.estimatedComplexity);
+    // Spawn agent swarm
+    const agents = this.agentFactory.spawnAgentSwarm(agentTypes, task.id);
+    if (this.config.debugMode) {
+        this.logger.info(`👥 Spawned ${agents.length} agents: ${agents.map(a => a.type).join(', ')}`);
+    }
+    return agents;
+}
+async;
+coordinateExecution(task, types_1.ServiceNowTask, agents, types_1.Agent[], _analysis, types_1.TaskAnalysis);
+Promise < any > {
+    const: results, any, []:  = [],
+    try: {
+        : .shouldExecuteInParallel(agents)
+    }
+};
+{
+    results.push(...await this.executeAgentsInParallel(agents, task.objective));
+}
+{
+    results.push(...await this.executeAgentsSequentially(agents, task.objective));
+}
+// Coordinate final deployment using MCP tools
+const deploymentResult = await this.executeFinalDeployment(task, results, _analysis);
+return {
+    taskId: task.id,
+    objective: task.objective,
+    agentResults: results,
+    deploymentResult,
+    artifacts: task.artifacts
+};
+try { }
+catch (error) {
+    // Attempt recovery or fallback
+    return await this.attemptRecovery(task, agents, error);
+}
+shouldExecuteInParallel(agents, types_1.Agent[]);
+boolean;
+{
+    // Parallel execution for independent agents
+    const independentAgents = ['researcher', 'tester', 'script-writer'];
+    return agents.some(agent => independentAgents.includes(agent.type));
+}
+async;
+executeAgentsInParallel(agents, types_1.Agent[], objective, string);
+Promise < any[] > {
+    : .config.debugMode
+};
+{
+    this.logger.info('⚡ Executing agents in parallel');
+}
+const promises = agents.map(agent => this.agentFactory.executeAgentTask(agent.id, objective));
+return await Promise.all(promises);
+async;
+executeAgentsSequentially(agents, types_1.Agent[], objective, string);
+Promise < any[] > {
+    : .config.debugMode
+};
+{
+    this.logger.info('🔄 Executing agents sequentially');
+}
+const results = [];
+for (const agent of agents) {
+    const result = await this.agentFactory.executeAgentTask(agent.id, objective);
+    results.push(result);
+    // Allow agents to coordinate between executions
+    this.facilitateAgentCoordination(agent, results);
+}
+return results;
+facilitateAgentCoordination(currentAgent, types_1.Agent, previousResults, any[]);
+void {
+    // Send relevant results to collaborative agents
+    const: activeAgents = this.agentFactory.getActiveAgents(),
+    for(, agent, of, activeAgents) {
+        if (agent.id !== currentAgent.id) {
+            this.agentFactory.sendAgentMessage(currentAgent.id, agent.id, 'result', {
+                results: previousResults.slice(-1)[0], // Latest result
+                fromAgent: currentAgent.type
+            });
         }
-        return results;
     }
-    facilitateAgentCoordination(currentAgent, previousResults) {
-        // Send relevant results to collaborative agents
-        const activeAgents = this.agentFactory.getActiveAgents();
-        for (const agent of activeAgents) {
-            if (agent.id !== currentAgent.id) {
-                this.agentFactory.sendAgentMessage(currentAgent.id, agent.id, 'result', {
-                    results: previousResults.slice(-1)[0], // Latest result
-                    fromAgent: currentAgent.type
-                });
-            }
-        }
+};
+async;
+executeFinalDeployment(task, types_1.ServiceNowTask, agentResults, any[], _analysis, types_1.TaskAnalysis);
+Promise < any > {
+    : .config.debugMode
+};
+{
+    this.logger.info('🚀 Executing final deployment with MCP tools');
+}
+// The Queen coordinates the actual MCP tool calls based on agent recommendations
+const deploymentPlan = this.createDeploymentPlan(task, agentResults, _analysis);
+try {
+    // Execute deployment using the unified deployment API
+    const deploymentResult = await this.executeDeploymentPlan(deploymentPlan);
+    // Track artifacts created
+    if (deploymentResult.sys_id) {
+        task.artifacts.push(deploymentResult.sys_id);
+        // Store artifact in memory for future reference
+        this.memory.storeArtifact({
+            type: task.type,
+            name: deploymentResult.name || task.objective,
+            sys_id: deploymentResult.sys_id,
+            config: deploymentResult.config || {},
+            dependencies: _analysis.dependencies
+        });
     }
-    async executeFinalDeployment(task, agentResults, _analysis) {
-        if (this.config.debugMode) {
-            this.logger.info('🚀 Executing final deployment with MCP tools');
-        }
-        // The Queen coordinates the actual MCP tool calls based on agent recommendations
-        const deploymentPlan = this.createDeploymentPlan(task, agentResults, _analysis);
-        try {
-            // Execute deployment using the unified deployment API
-            const deploymentResult = await this.executeDeploymentPlan(deploymentPlan);
-            // Track artifacts created
-            if (deploymentResult.sys_id) {
-                task.artifacts.push(deploymentResult.sys_id);
-                // Store artifact in memory for future reference
-                this.memory.storeArtifact({
-                    type: task.type,
-                    name: deploymentResult.name || task.objective,
-                    sys_id: deploymentResult.sys_id,
-                    config: deploymentResult.config || {},
-                    dependencies: _analysis.dependencies
-                });
-            }
-            return deploymentResult;
-        }
-        catch (error) {
-            if (this.config.debugMode) {
-                console.error('❌ Deployment failed:', error);
-            }
-            throw error;
-        }
+    return deploymentResult;
+}
+catch (error) {
+    if (this.config.debugMode) {
+        console.error('❌ Deployment failed:', error);
     }
-    createDeploymentPlan(task, agentResults, _analysis) {
-        // Extract deployment instructions from agent results
-        const widgetCreator = agentResults.find(r => r.agentType === 'widget-creator');
-        const flowBuilder = agentResults.find(r => r.agentType === 'flow-builder');
-        const scriptWriter = agentResults.find(r => r.agentType === 'script-writer');
-        const catalogManager = agentResults.find(r => r.agentType === 'catalog-manager');
-        if (task.type === 'widget' && widgetCreator) {
-            return {
-                type: 'widget',
-                mcpTool: 'snow_deploy',
-                config: this.extractWidgetConfig(task.objective, agentResults),
-                autoPermissions: this.config.autoPermissions // Pass auto-permissions flag for dependency handling
-            };
-        }
-        // Flow creation is no longer supported - use ServiceNow Flow Designer directly
-        if (task.type === 'flow') {
-            throw new Error('Flow creation is no longer supported in Snow-Flow. Please use ServiceNow Flow Designer directly.');
-        }
-        if (task.type === 'script' && scriptWriter) {
-            return {
-                type: 'script',
-                mcpTool: 'snow_create_script_include',
-                config: this.extractScriptConfig(task.objective, agentResults)
-            };
-        }
-        // Default deployment plan
+    throw error;
+}
+createDeploymentPlan(task, types_1.ServiceNowTask, agentResults, any[], _analysis, types_1.TaskAnalysis);
+any;
+{
+    // Extract deployment instructions from agent results
+    const widgetCreator = agentResults.find(r => r.agentType === 'widget-creator');
+    const flowBuilder = agentResults.find(r => r.agentType === 'flow-builder');
+    const scriptWriter = agentResults.find(r => r.agentType === 'script-writer');
+    const catalogManager = agentResults.find(r => r.agentType === 'catalog-manager');
+    if (task.type === 'widget' && widgetCreator) {
         return {
-            type: task.type,
+            type: 'widget',
             mcpTool: 'snow_deploy',
-            instruction: task.objective
+            config: this.extractWidgetConfig(task.objective, agentResults),
+            autoPermissions: this.config.autoPermissions // Pass auto-permissions flag for dependency handling
         };
     }
-    extractWidgetConfig(objective, agentResults) {
-        // Extract widget configuration from agent results
-        const widgetResult = agentResults.find(r => r.agentType === 'widget-creator');
-        return {
-            name: this.generateArtifactName(objective, 'widget'),
-            title: this.generateArtifactTitle(objective),
-            template: this.generateWidgetTemplate(objective),
-            css: this.generateWidgetCss(objective),
-            client_script: this.generateClientScript(objective),
-            server_script: this.generateServerScript(objective),
-            demo_data: this.generateDemoData(objective)
-        };
+    // Flow creation is no longer supported - use ServiceNow Flow Designer directly
+    if (task.type === 'flow') {
+        throw new Error('Flow creation is no longer supported in Snow-Flow. Please use ServiceNow Flow Designer directly.');
     }
-    extractScriptConfig(objective, agentResults) {
+    if (task.type === 'script' && scriptWriter) {
         return {
-            name: this.generateArtifactName(objective, 'script'),
-            description: `Auto-generated script for: ${objective}`,
-            script: this.generateScriptCode(objective)
+            type: 'script',
+            mcpTool: 'snow_create_script_include',
+            config: this.extractScriptConfig(task.objective, agentResults)
         };
     }
-    // Simple artifact generation based on objective analysis
-    generateArtifactName(objective, type) {
-        const words = objective.toLowerCase().replace(/[^a-z\s]/g, '').split(/\s+/).filter(w => w.length > 2);
-        const key_words = words.slice(0, 3).join('_');
-        return `${key_words}_${type}`;
-    }
-    generateArtifactTitle(objective) {
-        return objective.charAt(0).toUpperCase() + objective.slice(1);
-    }
-    generateWidgetTemplate(objective) {
-        const isChart = objective.toLowerCase().includes('chart') || objective.toLowerCase().includes('graph');
-        const isDashboard = objective.toLowerCase().includes('dashboard');
-        if (isChart) {
-            return `
+    // Default deployment plan
+    return {
+        type: task.type,
+        mcpTool: 'snow_deploy',
+        instruction: task.objective
+    };
+}
+extractWidgetConfig(objective, string, agentResults, any[]);
+any;
+{
+    // Extract widget configuration from agent results
+    const widgetResult = agentResults.find(r => r.agentType === 'widget-creator');
+    return {
+        name: this.generateArtifactName(objective, 'widget'),
+        title: this.generateArtifactTitle(objective),
+        template: this.generateWidgetTemplate(objective),
+        css: this.generateWidgetCss(objective),
+        client_script: this.generateClientScript(objective),
+        server_script: this.generateServerScript(objective),
+        demo_data: this.generateDemoData(objective)
+    };
+}
+extractScriptConfig(objective, string, agentResults, any[]);
+any;
+{
+    return {
+        name: this.generateArtifactName(objective, 'script'),
+        description: `Auto-generated script for: ${objective}`,
+        script: this.generateScriptCode(objective)
+    };
+}
+generateArtifactName(objective, string, type, string);
+string;
+{
+    const words = objective.toLowerCase().replace(/[^a-z\s]/g, '').split(/\s+/).filter(w => w.length > 2);
+    const key_words = words.slice(0, 3).join('_');
+    return `${key_words}_${type}`;
+}
+generateArtifactTitle(objective, string);
+string;
+{
+    return objective.charAt(0).toUpperCase() + objective.slice(1);
+}
+generateWidgetTemplate(objective, string);
+string;
+{
+    const isChart = objective.toLowerCase().includes('chart') || objective.toLowerCase().includes('graph');
+    const isDashboard = objective.toLowerCase().includes('dashboard');
+    if (isChart) {
+        return `
 <div class="panel panel-default">
   <div class="panel-heading">
     <h3 class="panel-title">{{data.title || '${this.generateArtifactTitle(objective)}'}}</h3>
@@ -386,9 +388,9 @@ class ServiceNowQueen {
     <canvas id="chart-{{::data.widget_id}}" width="400" height="200"></canvas>
   </div>
 </div>`;
-        }
-        if (isDashboard) {
-            return `
+    }
+    if (isDashboard) {
+        return `
 <div class="row">
   <div class="col-md-12">
     <div class="panel panel-default">
@@ -408,8 +410,8 @@ class ServiceNowQueen {
     </div>
   </div>
 </div>`;
-        }
-        return `
+    }
+    return `
 <div class="panel panel-default">
   <div class="panel-heading">
     <h3 class="panel-title">{{data.title || '${this.generateArtifactTitle(objective)}'}}</h3>
@@ -428,9 +430,11 @@ class ServiceNowQueen {
     </div>
   </div>
 </div>`;
-    }
-    generateWidgetCss(objective) {
-        return `
+}
+generateWidgetCss(objective, string);
+string;
+{
+    return `
 .panel {
   margin-bottom: 20px;
   border-radius: 6px;
@@ -462,11 +466,13 @@ class ServiceNowQueen {
     margin-bottom: 15px;
   }
 }`;
-    }
-    generateClientScript(objective) {
-        const isChart = objective.toLowerCase().includes('chart') || objective.toLowerCase().includes('graph');
-        if (isChart) {
-            return `
+}
+generateClientScript(objective, string);
+string;
+{
+    const isChart = objective.toLowerCase().includes('chart') || objective.toLowerCase().includes('graph');
+    if (isChart) {
+        return `
 function($scope) {
   var c = this;
   
@@ -495,8 +501,8 @@ function($scope) {
     }
   };
 }`;
-        }
-        return `
+    }
+    return `
 function($scope) {
   var c = this;
   
@@ -516,11 +522,13 @@ function($scope) {
     c.server.refresh();
   };
 }`;
-    }
-    generateServerScript(objective) {
-        const lowerObjective = objective.toLowerCase();
-        if (lowerObjective.includes('incident')) {
-            return `
+}
+generateServerScript(objective, string);
+string;
+{
+    const lowerObjective = objective.toLowerCase();
+    if (lowerObjective.includes('incident')) {
+        return `
 (function() {
   data.title = options.title || 'Incidents Dashboard';
   data.widget_id = gs.generateGUID();
@@ -561,8 +569,8 @@ function($scope) {
     data.chartType = 'doughnut';
   }
 })();`;
-        }
-        return `
+    }
+    return `
 (function() {
   data.title = options.title || '${this.generateArtifactTitle(objective)}';
   data.widget_id = gs.generateGUID();
@@ -583,20 +591,24 @@ function($scope) {
     }
   ];
 })();`;
-    }
-    generateDemoData(objective) {
-        return {
-            title: this.generateArtifactTitle(objective),
-            items: [
-                {
-                    title: 'Demo Item 1',
-                    description: 'Sample data for testing the widget'
-                }
-            ]
-        };
-    }
-    generateScriptCode(objective) {
-        return `
+}
+generateDemoData(objective, string);
+any;
+{
+    return {
+        title: this.generateArtifactTitle(objective),
+        items: [
+            {
+                title: 'Demo Item 1',
+                description: 'Sample data for testing the widget'
+            }
+        ]
+    };
+}
+generateScriptCode(objective, string);
+string;
+{
+    return `
 // Auto-generated script for: ${objective}
 // Generated by ServiceNow Queen Agent
 
@@ -609,294 +621,331 @@ function($scope) {
     message: 'Script executed successfully'
   };
 })();`;
+}
+async;
+executeDeploymentPlan(plan, any);
+Promise < any > {
+    : .config.debugMode
+};
+{
+    this.logger.info('🚀 Executing deployment plan with MCP Bridge');
+}
+// Create agent recommendation from plan
+const recommendation = {
+    agentId: 'queen-agent',
+    agentType: 'queen',
+    action: `deploy-${plan.type}`,
+    tool: plan.mcpTool,
+    server: this.getServerForTool(plan.mcpTool),
+    params: plan.config || {},
+    reasoning: `Deploying ${plan.type} artifact as requested`,
+    confidence: 0.95
+};
+// Execute through MCP bridge
+const result = await this.mcpBridge.executeAgentRecommendation({ id: 'queen-agent', type: 'queen' }, recommendation);
+if (result.success && result.toolResult) {
+    const deploymentResult = {
+        success: true,
+        type: plan.type,
+        name: plan.config?.name || result.toolResult.name,
+        sys_id: result.toolResult.sys_id, // Real sys_id from ServiceNow!
+        config: plan.config,
+        mcpTool: plan.mcpTool,
+        executionTime: result.executionTime
+    };
+    // Handle dependency injection for widgets
+    if (plan.type === 'widget' && plan.config) {
+        await this.handleWidgetDependencies(plan.config, plan.autoPermissions);
     }
-    async executeDeploymentPlan(plan) {
-        // Execute real MCP tools through the bridge
-        if (this.config.debugMode) {
-            this.logger.info('🚀 Executing deployment plan with MCP Bridge');
-        }
-        // Create agent recommendation from plan
+    return deploymentResult;
+}
+else {
+    throw new Error(`MCP execution failed: ${result.error || 'Unknown error'}`);
+}
+getServerForTool(tool, string);
+string;
+{
+    // Map tools to their servers
+    const toolServerMap = {
+        'snow_deploy': 'deployment',
+        'snow_deploy_widget': 'deployment',
+        'snow_deploy_flow': 'deployment',
+        'snow_find_artifact': 'intelligent',
+        'snow_update_set_create': 'update-set',
+        'snow_get_by_sysid': 'intelligent',
+        'snow_edit_by_sysid': 'intelligent'
+    };
+    return toolServerMap[tool] || 'deployment';
+}
+async;
+handleWidgetDependencies(widgetConfig, any, autoPermissions ?  : boolean);
+Promise < void  > {
+    try: {
+        // Detect dependencies in widget code
+        const: dependencies = dependency_detector_1.DependencyDetector.analyzeWidget(widgetConfig),
+        if(dependencies) { }, : .length === 0
+    }
+};
+{
+    return; // No dependencies needed
+}
+this.logger.info(`\n📦 Detected ${dependencies.length} external dependencies in widget:`);
+dependencies.forEach(dep => {
+    this.logger.info(`  • ${dep.name} - ${dep.description}`);
+});
+// Create MCP tools wrapper for theme manager
+const mcpTools = {
+    snow_find_artifact: async (params) => {
         const recommendation = {
             agentId: 'queen-agent',
             agentType: 'queen',
-            action: `deploy-${plan.type}`,
-            tool: plan.mcpTool,
-            server: this.getServerForTool(plan.mcpTool),
-            params: plan.config || {},
-            reasoning: `Deploying ${plan.type} artifact as requested`,
+            action: 'find-theme',
+            tool: 'snow_find_artifact',
+            server: 'intelligent',
+            params,
+            reasoning: 'Finding Service Portal theme for dependency injection',
             confidence: 0.95
         };
-        // Execute through MCP bridge
         const result = await this.mcpBridge.executeAgentRecommendation({ id: 'queen-agent', type: 'queen' }, recommendation);
-        if (result.success && result.toolResult) {
-            const deploymentResult = {
-                success: true,
-                type: plan.type,
-                name: plan.config?.name || result.toolResult.name,
-                sys_id: result.toolResult.sys_id, // Real sys_id from ServiceNow!
-                config: plan.config,
-                mcpTool: plan.mcpTool,
-                executionTime: result.executionTime
-            };
-            // Handle dependency injection for widgets
-            if (plan.type === 'widget' && plan.config) {
-                await this.handleWidgetDependencies(plan.config, plan.autoPermissions);
-            }
-            return deploymentResult;
-        }
-        else {
-            throw new Error(`MCP execution failed: ${result.error || 'Unknown error'}`);
-        }
-    }
-    getServerForTool(tool) {
-        // Map tools to their servers
-        const toolServerMap = {
-            'snow_deploy': 'deployment',
-            'snow_deploy_widget': 'deployment',
-            'snow_deploy_flow': 'deployment',
-            'snow_find_artifact': 'intelligent',
-            'snow_update_set_create': 'update-set',
-            'snow_get_by_sysid': 'intelligent',
-            'snow_edit_by_sysid': 'intelligent'
-        };
-        return toolServerMap[tool] || 'deployment';
-    }
-    async handleWidgetDependencies(widgetConfig, autoPermissions) {
-        try {
-            // Detect dependencies in widget code
-            const dependencies = dependency_detector_1.DependencyDetector.analyzeWidget(widgetConfig);
-            if (dependencies.length === 0) {
-                return; // No dependencies needed
-            }
-            this.logger.info(`\n📦 Detected ${dependencies.length} external dependencies in widget:`);
-            dependencies.forEach(dep => {
-                this.logger.info(`  • ${dep.name} - ${dep.description}`);
-            });
-            // Create MCP tools wrapper for theme manager
-            const mcpTools = {
-                snow_find_artifact: async (params) => {
-                    const recommendation = {
-                        agentId: 'queen-agent',
-                        agentType: 'queen',
-                        action: 'find-theme',
-                        tool: 'snow_find_artifact',
-                        server: 'intelligent',
-                        params,
-                        reasoning: 'Finding Service Portal theme for dependency injection',
-                        confidence: 0.95
-                    };
-                    const result = await this.mcpBridge.executeAgentRecommendation({ id: 'queen-agent', type: 'queen' }, recommendation);
-                    return result.toolResult;
-                },
-                snow_comprehensive_search: async (params) => {
-                    const recommendation = {
-                        agentId: 'queen-agent',
-                        agentType: 'queen',
-                        action: 'search-themes',
-                        tool: 'snow_comprehensive_search',
-                        server: 'intelligent',
-                        params,
-                        reasoning: 'Searching for Service Portal themes',
-                        confidence: 0.95
-                    };
-                    const result = await this.mcpBridge.executeAgentRecommendation({ id: 'queen-agent', type: 'queen' }, recommendation);
-                    return result.toolResult;
-                },
-                snow_get_by_sysid: async (params) => {
-                    const recommendation = {
-                        agentId: 'queen-agent',
-                        agentType: 'queen',
-                        action: 'get-theme',
-                        tool: 'snow_get_by_sysid',
-                        server: 'intelligent',
-                        params,
-                        reasoning: 'Getting Service Portal theme details',
-                        confidence: 0.95
-                    };
-                    const result = await this.mcpBridge.executeAgentRecommendation({ id: 'queen-agent', type: 'queen' }, recommendation);
-                    return result.toolResult;
-                },
-                snow_edit_by_sysid: async (params) => {
-                    const recommendation = {
-                        agentId: 'queen-agent',
-                        agentType: 'queen',
-                        action: 'update-theme',
-                        tool: 'snow_edit_by_sysid',
-                        server: 'intelligent',
-                        params,
-                        reasoning: 'Updating Service Portal theme with dependencies',
-                        confidence: 0.95
-                    };
-                    const result = await this.mcpBridge.executeAgentRecommendation({ id: 'queen-agent', type: 'queen' }, recommendation);
-                    return result.toolResult;
-                }
-            };
-            // Update theme with dependencies
-            const result = await theme_manager_1.ServicePortalThemeManager.updateThemeWithDependencies(dependencies, mcpTools, {
-                autoPermissions,
-                skipPrompt: autoPermissions, // Skip prompt if auto-permissions enabled
-                useMinified: true
-            });
-            if (result.success) {
-                this.logger.info(`✅ ${result.message}`);
-            }
-            else {
-                this.logger.warn(`⚠️ Dependencies not installed: ${result.message}`);
-                this.logger.info('💡 You may need to manually add these dependencies to your Service Portal theme');
-            }
-        }
-        catch (error) {
-            console.error('❌ Error handling widget dependencies:', error.message);
-            // Don't fail the deployment, just warn
-            this.logger.warn('⚠️ Widget deployed successfully but dependencies may need manual installation');
-        }
-    }
-    async attemptRecovery(task, agents, error) {
-        if (this.config.debugMode) {
-            this.logger.info(`🔄 Attempting recovery for task ${task.id}`);
-        }
-        // Try with reduced complexity or different agent sequence
-        const fallbackResult = {
-            taskId: task.id,
-            objective: task.objective,
-            status: 'recovered',
-            error: error.message,
-            fallbackApplied: true
+        return result.toolResult;
+    },
+    snow_comprehensive_search: async (params) => {
+        const recommendation = {
+            agentId: 'queen-agent',
+            agentType: 'queen',
+            action: 'search-themes',
+            tool: 'snow_comprehensive_search',
+            server: 'intelligent',
+            params,
+            reasoning: 'Searching for Service Portal themes',
+            confidence: 0.95
         };
-        return fallbackResult;
-    }
-    learnFromExecution(task, agents, result, duration, error) {
-        const agentTypes = agents.map(a => a.type);
-        if (error) {
-            // Learn from failure
-            this.neuralLearning.learnFromFailure(task, error.message, agentTypes);
-            this.memory.recordTaskCompletion(task.id, task.objective, task.type, agentTypes, false, duration);
-        }
-        else {
-            // Learn from success
-            this.neuralLearning.learnFromSuccess(task, duration, agentTypes);
-            this.memory.recordTaskCompletion(task.id, task.objective, task.type, agentTypes, true, duration);
-        }
-        if (this.config.debugMode) {
-            this.logger.info(`📚 Queen learned from ${error ? 'failure' : 'success'}: ${task.objective}`);
-        }
-    }
-    async handleExecutionFailure(taskId, objective, error, duration) {
-        const task = this.activeTasks.get(taskId);
-        if (task) {
-            task.status = 'failed';
-            task.error = error.message;
-            // Learn from failure
-            this.memory.storeLearning(`failure_${task.type}`, `Failed: ${objective} - Error: ${error.message}`, 0.8);
-        }
-        if (this.config.debugMode) {
-            console.error(`❌ Task ${taskId} failed after ${duration}ms:`, error.message);
-        }
-    }
-    cleanupTask(taskId) {
-        this.activeTasks.delete(taskId);
-        this.agentFactory.cleanupCompletedAgents();
-    }
-    generateTaskId() {
-        return `task_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
-    }
-    // Public API methods
-    getActiveTaskCount() {
-        return this.activeTasks.size;
-    }
-    getTaskStatus(taskId) {
-        return this.activeTasks.get(taskId) || null;
-    }
-    /**
-     * Get gap _analysis results for a task
-     */
-    getGapAnalysisResults(taskId) {
-        const task = this.activeTasks.get(taskId);
-        return task?.gapAnalysis || null;
-    }
-    /**
-     * Get all manual guides from gap _analysis for a task
-     */
-    getManualConfigurationGuides(taskId) {
-        const gapAnalysis = this.getGapAnalysisResults(taskId);
-        return gapAnalysis?.manualGuides || null;
-    }
-    getHiveMindStatus() {
-        return {
-            activeTasks: this.activeTasks.size,
-            activeAgents: this.agentFactory.getActiveAgents().length,
-            memoryStats: {
-                patterns: this.memory['memory'].patterns.length,
-                artifacts: this.memory['memory'].artifacts.size,
-                learnings: this.memory['memory'].learnings.size
-            },
-            factoryStats: this.agentFactory.getStatistics(),
-            learningInsights: this.neuralLearning.getLearningInsights()
+        const result = await this.mcpBridge.executeAgentRecommendation({ id: 'queen-agent', type: 'queen' }, recommendation);
+        return result.toolResult;
+    },
+    snow_get_by_sysid: async (params) => {
+        const recommendation = {
+            agentId: 'queen-agent',
+            agentType: 'queen',
+            action: 'get-theme',
+            tool: 'snow_get_by_sysid',
+            server: 'intelligent',
+            params,
+            reasoning: 'Getting Service Portal theme details',
+            confidence: 0.95
         };
-    }
-    exportMemory() {
-        return this.memory.exportMemory();
-    }
-    importMemory(memoryData) {
-        this.memory.importMemory(memoryData);
-        if (this.config.debugMode) {
-            this.logger.info('🧠 Queen hive-mind memory imported successfully');
-        }
-    }
-    clearMemory() {
-        this.memory.clearMemory();
-        // Also reset neural learning weights
-        this.neuralLearning = new neural_learning_1.NeuralLearning(this.memory);
-        if (this.config.debugMode) {
-            this.logger.info('🧠 Queen hive-mind memory cleared - starting fresh');
-        }
-    }
-    getLearningInsights() {
-        const neuralInsights = this.neuralLearning.getLearningInsights();
-        return {
-            successfulPatterns: this.memory['memory'].patterns.slice(0, 5).map(pattern => ({
-                description: `${pattern.taskType} deployment using ${pattern.agentSequence.join(' → ')}`,
-                successRate: Math.round(pattern.successRate * 100),
-                avgDuration: pattern.avgDuration,
-                useCount: this.memory.getSuccessRate(pattern.taskType)
-            })),
-            recommendations: [
-                'Use Queen Agent for complex multi-step ServiceNow tasks',
-                'Enable --debug mode for detailed hive-mind insights',
-                'Export memory regularly to preserve learning patterns',
-                'Let Queen analyze objectives for optimal agent coordination'
-            ],
-            commonTasks: Object.entries(neuralInsights.weights || {})
-                .map(([type, count]) => ({
-                type,
-                count: typeof count === 'number' ? count : 0
-            }))
-                .sort((a, b) => b.count - a.count)
-                .slice(0, 5),
-            memoryStats: {
-                totalPatterns: this.memory['memory'].patterns.length,
-                totalArtifacts: this.memory['memory'].artifacts.size,
-                totalLearnings: this.memory['memory'].learnings.size
-            },
-            neuralInsights
+        const result = await this.mcpBridge.executeAgentRecommendation({ id: 'queen-agent', type: 'queen' }, recommendation);
+        return result.toolResult;
+    },
+    snow_edit_by_sysid: async (params) => {
+        const recommendation = {
+            agentId: 'queen-agent',
+            agentType: 'queen',
+            action: 'update-theme',
+            tool: 'snow_edit_by_sysid',
+            server: 'intelligent',
+            params,
+            reasoning: 'Updating Service Portal theme with dependencies',
+            confidence: 0.95
         };
-    }
-    async shutdown() {
-        if (this.config.debugMode) {
-            this.logger.info('🛑 Shutting down ServiceNow Queen Agent');
-        }
-        // Clean up all agents
-        const activeAgents = this.agentFactory.getActiveAgents();
-        for (const agent of activeAgents) {
-            this.agentFactory.terminateAgent(agent.id);
-        }
-        // Shutdown MCP Bridge
-        if (this.mcpBridge) {
-            await this.mcpBridge.shutdown();
-        }
-        // Close memory system
-        this.memory.close();
-    }
+        const result = await this.mcpBridge.executeAgentRecommendation({ id: 'queen-agent', type: 'queen' }, recommendation);
+        return result.toolResult;
+    }
+};
+// Update theme with dependencies
+const result = await theme_manager_1.ServicePortalThemeManager.updateThemeWithDependencies(dependencies, mcpTools, {
+    autoPermissions,
+    skipPrompt: autoPermissions, // Skip prompt if auto-permissions enabled
+    useMinified: true
+});
+if (result.success) {
+    this.logger.info(`✅ ${result.message}`);
 }
-exports.ServiceNowQueen = ServiceNowQueen;
+else {
+    this.logger.warn(`⚠️ Dependencies not installed: ${result.message}`);
+    this.logger.info('💡 You may need to manually add these dependencies to your Service Portal theme');
+}
+try { }
+catch (error) {
+    console.error('❌ Error handling widget dependencies:', error.message);
+    // Don't fail the deployment, just warn
+    this.logger.warn('⚠️ Widget deployed successfully but dependencies may need manual installation');
+}
+async;
+attemptRecovery(task, types_1.ServiceNowTask, agents, types_1.Agent[], error, Error);
+Promise < any > {
+    : .config.debugMode
+};
+{
+    this.logger.info(`🔄 Attempting recovery for task ${task.id}`);
+}
+// Try with reduced complexity or different agent sequence
+const fallbackResult = {
+    taskId: task.id,
+    objective: task.objective,
+    status: 'recovered',
+    error: error.message,
+    fallbackApplied: true
+};
+return fallbackResult;
+learnFromExecution(task, types_1.ServiceNowTask, agents, types_1.Agent[], result, any, duration, number, error, Error | null);
+void {
+    const: agentTypes = agents.map(a => a.type),
+    if(error) {
+        // Learn from failure
+        this.neuralLearning.learnFromFailure(task, error.message, agentTypes);
+        this.memory.recordTaskCompletion(task.id, task.objective, task.type, agentTypes, false, duration);
+    }, else: {
+        // Learn from success
+        this: .neuralLearning.learnFromSuccess(task, duration, agentTypes),
+        this: .memory.recordTaskCompletion(task.id, task.objective, task.type, agentTypes, true, duration)
+    },
+    : .config.debugMode
+};
+{
+    this.logger.info(`📚 Queen learned from ${error ? 'failure' : 'success'}: ${task.objective}`);
+}
+async;
+handleExecutionFailure(taskId, string, objective, string, error, Error, duration, number);
+Promise < void  > {
+    const: task = this.activeTasks.get(taskId),
+    if(task) {
+        task.status = 'failed';
+        task.error = error.message;
+        // Learn from failure
+        this.memory.storeLearning(`failure_${task.type}`, `Failed: ${objective} - Error: ${error.message}`, 0.8);
+    },
+    : .config.debugMode
+};
+{
+    console.error(`❌ Task ${taskId} failed after ${duration}ms:`, error.message);
+}
+cleanupTask(taskId, string);
+void {
+    this: .activeTasks.delete(taskId),
+    this: .agentFactory.cleanupCompletedAgents()
+};
+generateTaskId();
+string;
+{
+    return `task_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+}
+// Public API methods
+getActiveTaskCount();
+number;
+{
+    return this.activeTasks.size;
+}
+getTaskStatus(taskId, string);
+types_1.ServiceNowTask | null;
+{
+    return this.activeTasks.get(taskId) || null;
+}
+/**
+ * Get gap _analysis results for a task
+ */
+getGapAnalysisResults(taskId, string);
+any | null;
+{
+    const task = this.activeTasks.get(taskId);
+    return task?.gapAnalysis || null;
+}
+/**
+ * Get all manual guides from gap _analysis for a task
+ */
+getManualConfigurationGuides(taskId, string);
+any;
+{
+    // Gap analysis integrated into MCP workflow
+    return gapAnalysis?.manualGuides || null;
+}
+getHiveMindStatus();
+any;
+{
+    return {
+        activeTasks: this.activeTasks.size,
+        activeAgents: this.agentFactory.getActiveAgents().length,
+        memoryStats: {
+            patterns: this.memory['memory'].patterns.length,
+            artifacts: this.memory['memory'].artifacts.size,
+            learnings: this.memory['memory'].learnings.size
+        },
+        factoryStats: this.agentFactory.getStatistics(),
+        learningInsights: this.neuralLearning.getLearningInsights()
+    };
+}
+exportMemory();
+string;
+{
+    return this.memory.exportMemory();
+}
+importMemory(memoryData, string);
+void {
+    this: .memory.importMemory(memoryData),
+    : .config.debugMode
+};
+{
+    this.logger.info('🧠 Queen hive-mind memory imported successfully');
+}
+clearMemory();
+void {
+    this: .memory.clearMemory(),
+    // Also reset neural learning weights
+    this: .neuralLearning = new neural_learning_1.NeuralLearning(this.memory),
+    : .config.debugMode
+};
+{
+    this.logger.info('🧠 Queen hive-mind memory cleared - starting fresh');
+}
+getLearningInsights();
+any;
+{
+    const neuralInsights = this.neuralLearning.getLearningInsights();
+    return {
+        successfulPatterns: this.memory['memory'].patterns.slice(0, 5).map(pattern => ({
+            description: `${pattern.taskType} deployment using ${pattern.agentSequence.join(' → ')}`,
+            successRate: Math.round(pattern.successRate * 100),
+            avgDuration: pattern.avgDuration,
+            useCount: this.memory.getSuccessRate(pattern.taskType)
+        })),
+        recommendations: [
+            'Use Queen Agent for complex multi-step ServiceNow tasks',
+            'Enable --debug mode for detailed hive-mind insights',
+            'Export memory regularly to preserve learning patterns',
+            'Let Queen analyze objectives for optimal agent coordination'
+        ],
+        commonTasks: Object.entries(neuralInsights.weights || {})
+            .map(([type, count]) => ({
+            type,
+            count: typeof count === 'number' ? count : 0
+        }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 5),
+        memoryStats: {
+            totalPatterns: this.memory['memory'].patterns.length,
+            totalArtifacts: this.memory['memory'].artifacts.size,
+            totalLearnings: this.memory['memory'].learnings.size
+        },
+        neuralInsights
+    };
+}
+async;
+shutdown();
+Promise < void  > {
+    : .config.debugMode
+};
+{
+    this.logger.info('🛑 Shutting down ServiceNow Queen Agent');
+}
+// Clean up all agents
+const activeAgents = this.agentFactory.getActiveAgents();
+for (const agent of activeAgents) {
+    this.agentFactory.terminateAgent(agent.id);
+}
+// Shutdown MCP Bridge
+if (this.mcpBridge) {
+    await this.mcpBridge.shutdown();
+}
+// Close memory system
+this.memory.close();
 //# sourceMappingURL=servicenow-queen.js.map