snow-flow 2.0.2 → 2.0.4

package/src/queen/servicenow-queen.ts

@@ -1,1029 +0,0 @@
-/**
- * ServiceNow Queen Agent
- * Central coordination point for the ServiceNow hive-mind
- */
-
-import { ServiceNowTask, TaskAnalysis, Agent, AgentType } from './types';
-import { QueenMemorySystem } from './queen-memory';
-import { NeuralLearning } from './neural-learning';
-import { AgentFactory } from './agent-factory';
-import { MCPExecutionBridge, AgentRecommendation } from './mcp-execution-bridge';
-import { ServicePortalThemeManager } from '../utils/theme-manager';
-import { DependencyDetector } from '../utils/dependency-detector';
-import { GapAnalysisEngine, GapAnalysisResult } from '../intelligence/gap-analysis-engine';
-import { Logger } from '../utils/logger';
-import * as crypto from 'crypto';
-
-export interface QueenConfig {
-  memoryPath?: string;
-  maxConcurrentAgents?: number;
-  learningRate?: number;
-  debugMode?: boolean;
-  autoPermissions?: boolean;
-}
-
-export class ServiceNowQueen {
-  private memory: QueenMemorySystem;
-  private neuralLearning: NeuralLearning;
-  private agentFactory: AgentFactory;
-  private mcpBridge: MCPExecutionBridge;
-  private gapAnalysisEngine: GapAnalysisEngine;
-  private activeTasks: Map<string, ServiceNowTask>;
-  private config: Required<QueenConfig>;
-  private logger: Logger;
-
-  constructor(config: QueenConfig = {}) {
-    this.config = {
-      memoryPath: config.memoryPath,
-      maxConcurrentAgents: config.maxConcurrentAgents || 5,
-      learningRate: config.learningRate || 0.1,
-      debugMode: config.debugMode || false,
-      autoPermissions: config.autoPermissions || false
-    };
-
-    // Initialize logger
-    this.logger = new Logger('ServiceNowQueen');
-
-    // Initialize hive-mind components
-    this.memory = new QueenMemorySystem(this.config.memoryPath);
-    this.neuralLearning = new NeuralLearning(this.memory);
-    this.agentFactory = new AgentFactory(this.memory);
-    this.mcpBridge = new MCPExecutionBridge(this.memory);
-    this.gapAnalysisEngine = new GapAnalysisEngine(this.mcpBridge, this.logger, this.config.autoPermissions);
-    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');
-    }
-  }
-
-  /**
-   * Main entry point: Execute ServiceNow objective with MCP-FIRST workflow
-   */
-  async executeObjective(objective: string): Promise<any> {
-    const taskId = this.generateTaskId();
-    const startTime = Date.now();
-
-    try {
-      if (this.config.debugMode) {
-        this.logger.info(`🎯 Queen analyzing objective: ${objective}`);
-        this.logger.info(`🚨 ENFORCING MCP-FIRST WORKFLOW`);
-      }
-
-      // 🚨 PHASE 1: MANDATORY MCP PRE-FLIGHT AUTHENTICATION CHECK
-      this.logger.info('🔐 Step 1: Validating ServiceNow connection...');
-      const authCheck = await this.mcpBridge.executeAgentRecommendation(
-        { id: 'queen-agent', type: 'queen' },
-        {
-          agentId: 'queen-agent',
-          agentType: 'queen',
-          action: 'validate-connection',
-          tool: 'snow_validate_live_connection',
-          server: 'operations',
-          params: { test_level: 'permissions' },
-          reasoning: 'MANDATORY: Pre-flight authentication check before any ServiceNow operations',
-          confidence: 0.95
-        }
-      );
-
-      if (!authCheck.success) {
-        const authError = `
-🚨 ServiceNow Authentication Failed: ${authCheck.error}
-
-🔧 Fix this now:
-1. Run: snow-flow auth login
-2. Check .env: SNOW_INSTANCE, SNOW_CLIENT_ID, SNOW_CLIENT_SECRET  
-3. Test: snow_auth_diagnostics()
-
-❌ Cannot proceed with Queen Agent operations until authentication works!
-        `;
-        this.logger.error('Authentication failed:', authError);
-        throw new Error(authError);
-      }
-
-      this.logger.info('✅ ServiceNow authentication validated');
-
-      // 🚨 PHASE 2: MANDATORY SMART DISCOVERY (Prevent Duplication)
-      this.logger.info('🔍 Step 2: Discovering existing artifacts...');
-      const discovery = await this.mcpBridge.executeAgentRecommendation(
-        { id: 'queen-agent', type: 'queen' },
-        {
-          agentId: 'queen-agent',
-          agentType: 'queen',
-          action: 'discover-artifacts',
-          tool: 'snow_comprehensive_search',
-          server: 'intelligent',
-          params: { 
-            query: objective,
-            include_inactive: false 
-          },
-          reasoning: 'MANDATORY: Check for existing artifacts before creating new ones',
-          confidence: 0.90
-        }
-      );
-
-      if (discovery.success && discovery.toolResult?.found?.length > 0) {
-        this.logger.info(`🔍 Found ${discovery.toolResult.found.length} existing artifacts that might be relevant:`);
-        discovery.toolResult.found.forEach((artifact: any) => {
-          this.logger.info(`💡 Consider reusing: ${artifact.name} (${artifact.sys_id})`);
-        });
-      }
-
-      // Phase 3: Initial Neural Analysis (informed by MCP discovery)
-      const _analysis = this.neuralLearning.analyzeTask(objective);
-      
-      // Phase 4: Create and register task
-      const task: ServiceNowTask = {
-        id: taskId,
-        objective,
-        type: _analysis.type,
-        artifacts: [],
-        status: 'analyzing'
-      };
-      this.activeTasks.set(taskId, task);
-
-      // 🚨 PHASE 5: INTELLIGENT GAP ANALYSIS (Beyond MCP Tools)
-      this.logger.info('🧠 Step 4: Running Intelligent Gap Analysis...');
-      let gapAnalysisResult: GapAnalysisResult | null = null;
-      
-      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}`));
-        }
-
-        // Store gap _analysis result in task for later reference
-        (task as any).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(`✅ Queen completed objective in ${duration}ms`);
-      }
-
-      return result;
-
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      await this.handleExecutionFailure(taskId, objective, error as Error, duration);
-      throw error;
-    } finally {
-      this.cleanupTask(taskId);
-    }
-  }
-
-  private spawnOptimalSwarm(task: ServiceNowTask, _analysis: TaskAnalysis): 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;
-  }
-
-  private async coordinateExecution(task: ServiceNowTask, agents: Agent[], _analysis: TaskAnalysis): Promise<any> {
-    const results: any[] = [];
-    
-    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 as Error);
-    }
-  }
-
-  private shouldExecuteInParallel(agents: Agent[]): boolean {
-    // Parallel execution for independent agents
-    const independentAgents = ['researcher', 'tester', 'script-writer'];
-    return agents.some(agent => independentAgents.includes(agent.type));
-  }
-
-  private async executeAgentsInParallel(agents: Agent[], objective: string): Promise<any[]> {
-    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);
-  }
-
-  private async executeAgentsSequentially(agents: Agent[], objective: string): Promise<any[]> {
-    if (this.config.debugMode) {
-      this.logger.info('🔄 Executing agents sequentially');
-    }
-
-    const results: any[] = [];
-    
-    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;
-  }
-
-  private facilitateAgentCoordination(currentAgent: Agent, previousResults: any[]): void {
-    // 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 
-          }
-        );
-      }
-    }
-  }
-
-  private async executeFinalDeployment(task: ServiceNowTask, agentResults: any[], _analysis: TaskAnalysis): Promise<any> {
-    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 as any,
-          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;
-    }
-  }
-
-  private createDeploymentPlan(task: ServiceNowTask, agentResults: any[], _analysis: 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: '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
-    return {
-      type: task.type,
-      mcpTool: 'snow_deploy',
-      instruction: task.objective
-    };
-  }
-
-  private 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)
-    };
-  }
-
-  private extractScriptConfig(objective: string, agentResults: any[]): any {
-    return {
-      name: this.generateArtifactName(objective, 'script'),
-      description: `Auto-generated script for: ${objective}`,
-      script: this.generateScriptCode(objective)
-    };
-  }
-
-  // Simple artifact generation based on objective analysis
-  private 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}`;
-  }
-
-  private generateArtifactTitle(objective: string): string {
-    return objective.charAt(0).toUpperCase() + objective.slice(1);
-  }
-
-  private 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>
-  </div>
-  <div class="panel-body">
-    <canvas id="chart-{{::data.widget_id}}" width="400" height="200"></canvas>
-  </div>
-</div>`;
-    }
-    
-    if (isDashboard) {
-      return `
-<div class="row">
-  <div class="col-md-12">
-    <div class="panel panel-default">
-      <div class="panel-heading">
-        <h3 class="panel-title">{{data.title || '${this.generateArtifactTitle(objective)}'}}</h3>
-      </div>
-      <div class="panel-body">
-        <div class="row">
-          <div class="col-md-4" ng-repeat="item in data.items">
-            <div class="well text-center">
-              <h4>{{item.label}}</h4>
-              <h2 class="text-primary">{{item.value}}</h2>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </div>
-</div>`;
-    }
-
-    return `
-<div class="panel panel-default">
-  <div class="panel-heading">
-    <h3 class="panel-title">{{data.title || '${this.generateArtifactTitle(objective)}'}}</h3>
-  </div>
-  <div class="panel-body">
-    <div ng-if="data.items.length > 0">
-      <div class="list-group">
-        <div class="list-group-item" ng-repeat="item in data.items">
-          <h4 class="list-group-item-heading">{{item.title}}</h4>
-          <p class="list-group-item-text">{{item.description}}</p>
-        </div>
-      </div>
-    </div>
-    <div ng-if="data.items.length === 0" class="text-center">
-      <p>No items to display</p>
-    </div>
-  </div>
-</div>`;
-  }
-
-  private generateWidgetCss(objective: string): string {
-    return `
-.panel {
-  margin-bottom: 20px;
-  border-radius: 6px;
-}
-
-.panel-heading {
-  background-color: #f5f5f5;
-  border-bottom: 1px solid #ddd;
-}
-
-.panel-body {
-  padding: 15px;
-}
-
-.well {
-  background-color: #f9f9f9;
-  border: 1px solid #e3e3e3;
-  border-radius: 4px;
-  padding: 19px;
-  margin-bottom: 20px;
-}
-
-.text-primary {
-  color: #337ab7;
-}
-
-@media (max-width: 768px) {
-  .col-md-4 {
-    margin-bottom: 15px;
-  }
-}`;
-  }
-
-  private generateClientScript(objective: string): string {
-    const isChart = objective.toLowerCase().includes('chart') || objective.toLowerCase().includes('graph');
-    
-    if (isChart) {
-      return `
-function($scope) {
-  var c = this;
-  
-  c.$onInit = function() {
-    if (c.data.chartData) {
-      c.renderChart();
-    }
-  };
-  
-  c.renderChart = function() {
-    var ctx = document.getElementById('chart-' + c.data.widget_id);
-    if (ctx && c.data.chartData) {
-      new Chart(ctx, {
-        type: c.data.chartType || 'bar',
-        data: c.data.chartData,
-        options: {
-          responsive: true,
-          plugins: {
-            title: {
-              display: true,
-              text: c.data.title || 'Chart'
-            }
-          }
-        }
-      });
-    }
-  };
-}`;
-    }
-
-    return `
-function($scope) {
-  var c = this;
-  
-  c.$onInit = function() {
-    // Initialize widget
-    if (c.data.items) {
-      c.processItems();
-    }
-  };
-  
-  c.processItems = function() {
-    // Process and format items for display
-    c.data.items = c.data.items || [];
-  };
-  
-  c.refreshData = function() {
-    c.server.refresh();
-  };
-}`;
-  }
-
-  private 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();
-  
-  // Query incidents
-  var gr = new GlideRecord('incident');
-  gr.addActiveQuery();
-  gr.orderByDesc('sys_created_on');
-  gr.setLimit(10);
-  gr.query();
-  
-  data.items = [];
-  while (gr.next()) {
-    data.items.push({
-      title: gr.getValue('short_description'),
-      description: 'Priority: ' + gr.getDisplayValue('priority') + ' | State: ' + gr.getDisplayValue('state'),
-      sys_id: gr.getValue('sys_id'),
-      priority: gr.getValue('priority'),
-      state: gr.getValue('state')
-    });
-  }
-  
-  // Chart data for incidents by priority
-  if (data.items.length > 0) {
-    var priorityCounts = {};
-    data.items.forEach(function(item) {
-      priorityCounts[item.priority] = (priorityCounts[item.priority] || 0) + 1;
-    });
-    
-    data.chartData = {
-      labels: Object.keys(priorityCounts),
-      datasets: [{
-        label: 'Incidents by Priority',
-        data: Object.values(priorityCounts),
-        backgroundColor: ['#ff6384', '#ff9f40', '#ffcd56', '#4bc0c0']
-      }]
-    };
-    data.chartType = 'doughnut';
-  }
-})();`;
-    }
-
-    return `
-(function() {
-  data.title = options.title || '${this.generateArtifactTitle(objective)}';
-  data.widget_id = gs.generateGUID();
-  data.items = [];
-  
-  // Add your data processing logic here
-  // Example: Query relevant records and populate data.items
-  
-  // Default demo data
-  data.items = [
-    {
-      title: 'Sample Item 1',
-      description: 'This is a sample item for demonstration'
-    },
-    {
-      title: 'Sample Item 2', 
-      description: 'This is another sample item'
-    }
-  ];
-})();`;
-  }
-
-  private generateDemoData(objective: string): any {
-    return {
-      title: this.generateArtifactTitle(objective),
-      items: [
-        {
-          title: 'Demo Item 1',
-          description: 'Sample data for testing the widget'
-        }
-      ]
-    };
-  }
-
-  private generateScriptCode(objective: string): string {
-    return `
-// Auto-generated script for: ${objective}
-// Generated by ServiceNow Queen Agent
-
-(function() {
-  // Add your script logic here
-  gs.info('${objective} script executed');
-  
-  return {
-    success: true,
-    message: 'Script executed successfully'
-  };
-})();`;
-  }
-
-  private async executeDeploymentPlan(plan: any): Promise<any> {
-    // 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
-    const recommendation: AgentRecommendation = {
-      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);
-      }
-
-      return deploymentResult;
-    } else {
-      throw new Error(`MCP execution failed: ${result.error || 'Unknown error'}`);
-    }
-  }
-
-  private getServerForTool(tool: string): string {
-    // Map tools to their servers
-    const toolServerMap: Record<string, string> = {
-      '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';
-  }
-
-  private async handleWidgetDependencies(widgetConfig: any, autoPermissions?: boolean): Promise<void> {
-    try {
-      // Detect dependencies in widget code
-      const dependencies = 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: any) => {
-          const recommendation: AgentRecommendation = {
-            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: any) => {
-          const recommendation: AgentRecommendation = {
-            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: any) => {
-          const recommendation: AgentRecommendation = {
-            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: any) => {
-          const recommendation: AgentRecommendation = {
-            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 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: any) {
-      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');
-    }
-  }
-
-  private async attemptRecovery(task: ServiceNowTask, agents: Agent[], error: Error): Promise<any> {
-    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 fallbackResult;
-  }
-
-  private learnFromExecution(task: ServiceNowTask, agents: 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);
-    }
-
-    if (this.config.debugMode) {
-      this.logger.info(`📚 Queen learned from ${error ? 'failure' : 'success'}: ${task.objective}`);
-    }
-  }
-
-  private 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
-      );
-    }
-
-    if (this.config.debugMode) {
-      console.error(`❌ Task ${taskId} failed after ${duration}ms:`, error.message);
-    }
-  }
-
-  private cleanupTask(taskId: string): void {
-    this.activeTasks.delete(taskId);
-    this.agentFactory.cleanupCompletedAgents();
-  }
-
-  private generateTaskId(): string {
-    return `task_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
-  }
-
-  // Public API methods
-
-  getActiveTaskCount(): number {
-    return this.activeTasks.size;
-  }
-
-  getTaskStatus(taskId: string): ServiceNowTask | null {
-    return this.activeTasks.get(taskId) || null;
-  }
-
-  /**
-   * Get gap _analysis results for a task
-   */
-  getGapAnalysisResults(taskId: string): GapAnalysisResult | null {
-    const task = this.activeTasks.get(taskId);
-    return (task as any)?.gapAnalysis || null;
-  }
-
-  /**
-   * Get all manual guides from gap _analysis for a task
-   */
-  getManualConfigurationGuides(taskId: string): any {
-    const gapAnalysis = this.getGapAnalysisResults(taskId);
-    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);
-    if (this.config.debugMode) {
-      this.logger.info('🧠 Queen hive-mind memory imported successfully');
-    }
-  }
-
-  clearMemory(): void {
-    this.memory.clearMemory();
-    // Also reset neural learning weights
-    this.neuralLearning = new NeuralLearning(this.memory);
-    if (this.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> {
-    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();
-  }
-}