snow-flow 1.3.1 → 1.3.2

package/dist/mcp/shared/mcp-resource-manager.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * MCP Resource Manager
+ * Comprehensive resource management for MCP servers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPResourceManager = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const logger_js_1 = require("../../utils/logger.js");
+class MCPResourceManager {
+    constructor(serverName = 'mcp-server') {
+        this.resourceCache = new Map();
+        this.resourceIndex = new Map();
+        this.categories = [];
+        this.logger = new logger_js_1.Logger(`ResourceManager:${serverName}`);
+        this.initializeCategories();
+    }
+    /**
+     * Initialize resource categories
+     */
+    initializeCategories() {
+        const projectRoot = this.getProjectRoot();
+        this.categories = [
+            {
+                name: 'templates',
+                description: 'ServiceNow artifact templates (widgets, flows, scripts, etc.)',
+                basePath: (0, path_1.join)(projectRoot, 'src/templates'),
+                uriPrefix: 'servicenow://templates/'
+            },
+            {
+                name: 'documentation',
+                description: 'Setup guides, deployment documentation, and API references',
+                basePath: projectRoot,
+                uriPrefix: 'servicenow://docs/'
+            },
+            {
+                name: 'schemas',
+                description: 'Data validation schemas and API schemas',
+                basePath: (0, path_1.join)(projectRoot, 'src/schemas'),
+                uriPrefix: 'servicenow://schemas/'
+            },
+            {
+                name: 'examples',
+                description: 'Example implementations and sample data',
+                basePath: (0, path_1.join)(projectRoot, 'src/templates/examples'),
+                uriPrefix: 'servicenow://examples/'
+            },
+            {
+                name: 'help',
+                description: 'Help content and guidance documents',
+                basePath: (0, path_1.join)(projectRoot, 'src/sparc'),
+                uriPrefix: 'servicenow://help/'
+            }
+        ];
+    }
+    /**
+     * Get project root directory
+     */
+    getProjectRoot() {
+        // Use process.cwd() to get the current working directory
+        // This should be the project root when running the application
+        return process.cwd();
+    }
+    /**
+     * List all available resources
+     */
+    async listResources() {
+        if (this.resourceIndex.size === 0) {
+            await this.buildResourceIndex();
+        }
+        return Array.from(this.resourceIndex.values());
+    }
+    /**
+     * Read a specific resource by URI
+     */
+    async readResource(uri) {
+        this.logger.debug(`Reading resource: ${uri}`);
+        // Check cache first
+        if (this.resourceCache.has(uri)) {
+            this.logger.debug(`Resource found in cache: ${uri}`);
+            return this.resourceCache.get(uri);
+        }
+        // Parse URI and determine file path
+        const filePath = this.uriToFilePath(uri);
+        if (!filePath) {
+            throw new Error(`Invalid resource URI: ${uri}`);
+        }
+        try {
+            const content = await this.loadResourceContent(filePath, uri);
+            // Cache the content
+            this.resourceCache.set(uri, content);
+            return content;
+        }
+        catch (error) {
+            this.logger.error(`Failed to read resource ${uri}:`, error);
+            throw new Error(`Resource not found or inaccessible: ${uri}`);
+        }
+    }
+    /**
+     * Build comprehensive resource index
+     */
+    async buildResourceIndex() {
+        this.logger.info('Building resource index...');
+        for (const category of this.categories) {
+            try {
+                await this.indexCategory(category);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to index category ${category.name}:`, error);
+            }
+        }
+        this.logger.info(`Resource index built: ${this.resourceIndex.size} resources`);
+    }
+    /**
+     * Index resources in a specific category
+     */
+    async indexCategory(category) {
+        try {
+            const stats = await (0, promises_1.stat)(category.basePath);
+            if (!stats.isDirectory()) {
+                this.logger.debug(`Category path is not a directory: ${category.basePath}`);
+                return;
+            }
+        }
+        catch (error) {
+            this.logger.debug(`Category path does not exist: ${category.basePath}`);
+            return;
+        }
+        if (category.name === 'documentation') {
+            await this.indexDocumentationFiles(category);
+        }
+        else {
+            await this.indexDirectoryRecursive(category.basePath, category);
+        }
+    }
+    /**
+     * Index documentation files (special handling for .md files in root)
+     */
+    async indexDocumentationFiles(category) {
+        try {
+            const files = await (0, promises_1.readdir)(category.basePath);
+            for (const file of files) {
+                if (file.endsWith('.md') && file.toUpperCase().includes('SERVICENOW')) {
+                    const filePath = (0, path_1.join)(category.basePath, file);
+                    const uri = `${category.uriPrefix}${file}`;
+                    const resource = {
+                        uri,
+                        name: this.formatResourceName(file),
+                        description: `ServiceNow documentation: ${this.formatResourceName(file)}`,
+                        mimeType: this.getMimeType(file)
+                    };
+                    this.resourceIndex.set(uri, resource);
+                }
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to index documentation files:`, error);
+        }
+    }
+    /**
+     * Index directory recursively
+     */
+    async indexDirectoryRecursive(dirPath, category, relativePath = '') {
+        try {
+            const entries = await (0, promises_1.readdir)(dirPath);
+            for (const entry of entries) {
+                const fullPath = (0, path_1.join)(dirPath, entry);
+                const entryRelativePath = relativePath ? (0, path_1.join)(relativePath, entry) : entry;
+                try {
+                    const stats = await (0, promises_1.stat)(fullPath);
+                    if (stats.isDirectory()) {
+                        await this.indexDirectoryRecursive(fullPath, category, entryRelativePath);
+                    }
+                    else if (this.isResourceFile(entry)) {
+                        const uri = `${category.uriPrefix}${entryRelativePath.replace(/\\/g, '/')}`;
+                        const resource = {
+                            uri,
+                            name: this.formatResourceName(entry),
+                            description: this.generateResourceDescription(entry, category.name),
+                            mimeType: this.getMimeType(entry)
+                        };
+                        this.resourceIndex.set(uri, resource);
+                    }
+                }
+                catch (error) {
+                    this.logger.debug(`Failed to process ${fullPath}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to read directory ${dirPath}:`, error);
+        }
+    }
+    /**
+     * Check if file should be exposed as a resource
+     */
+    isResourceFile(filename) {
+        const resourceExtensions = ['.json', '.md', '.yaml', '.yml', '.txt', '.ts', '.js'];
+        const ext = (0, path_1.extname)(filename).toLowerCase();
+        return resourceExtensions.includes(ext);
+    }
+    /**
+     * Convert URI to file path
+     */
+    uriToFilePath(uri) {
+        for (const category of this.categories) {
+            if (uri.startsWith(category.uriPrefix)) {
+                const relativePath = uri.substring(category.uriPrefix.length);
+                if (category.name === 'documentation') {
+                    // Documentation files are in root
+                    return (0, path_1.join)(category.basePath, relativePath);
+                }
+                else {
+                    return (0, path_1.join)(category.basePath, relativePath);
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Load resource content from file
+     */
+    async loadResourceContent(filePath, uri) {
+        const content = await (0, promises_1.readFile)(filePath, 'utf-8');
+        const mimeType = this.getMimeType(filePath);
+        return {
+            uri,
+            mimeType,
+            text: content
+        };
+    }
+    /**
+     * Get MIME type for file
+     */
+    getMimeType(filePath) {
+        const ext = (0, path_1.extname)(filePath).toLowerCase();
+        const mimeTypes = {
+            '.json': 'application/json',
+            '.md': 'text/markdown',
+            '.yaml': 'application/yaml',
+            '.yml': 'application/yaml',
+            '.txt': 'text/plain',
+            '.ts': 'text/typescript',
+            '.js': 'text/javascript',
+            '.html': 'text/html',
+            '.css': 'text/css'
+        };
+        return mimeTypes[ext] || 'text/plain';
+    }
+    /**
+     * Format resource name for display
+     */
+    formatResourceName(filename) {
+        const nameWithoutExt = (0, path_1.basename)(filename, (0, path_1.extname)(filename));
+        // Convert various naming conventions to readable names
+        return nameWithoutExt
+            .replace(/[-_]/g, ' ')
+            .replace(/\b\w/g, l => l.toUpperCase())
+            .replace(/\.(template|schema|example)/i, '');
+    }
+    /**
+     * Generate resource description based on filename and category
+     */
+    generateResourceDescription(filename, categoryName) {
+        const name = this.formatResourceName(filename);
+        const descriptions = {
+            'templates': `ServiceNow ${name} template`,
+            'documentation': `Documentation: ${name}`,
+            'schemas': `Validation schema for ${name}`,
+            'examples': `Example implementation: ${name}`,
+            'help': `Help content: ${name}`
+        };
+        return descriptions[categoryName] || `Resource: ${name}`;
+    }
+    /**
+     * Clear resource cache
+     */
+    clearCache() {
+        this.resourceCache.clear();
+        this.resourceIndex.clear();
+        this.logger.debug('Resource cache cleared');
+    }
+    /**
+     * Get resource statistics
+     */
+    getResourceStats() {
+        const categories = {};
+        for (const resource of this.resourceIndex.values()) {
+            for (const category of this.categories) {
+                if (resource.uri.startsWith(category.uriPrefix)) {
+                    categories[category.name] = (categories[category.name] || 0) + 1;
+                    break;
+                }
+            }
+        }
+        return {
+            total: this.resourceIndex.size,
+            cached: this.resourceCache.size,
+            categories
+        };
+    }
+}
+exports.MCPResourceManager = MCPResourceManager;

package/dist/queen/parallel-agent-engine.js

@@ -40,10 +40,12 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParallelAgentEngine = void 0;
 const eventemitter3_1 = require("eventemitter3");
+const logger_1 = require("../utils/logger");
 const crypto = __importStar(require("crypto"));
 class ParallelAgentEngine extends eventemitter3_1.EventEmitter {
     constructor(memory) {
         super();
+        this.logger = new logger_1.Logger('ParallelAgentEngine');
         this.memory = memory;
         this.activeExecutionPlans = new Map();
         this.agentWorkloads = new Map();
@@ -55,7 +57,11 @@ class ParallelAgentEngine extends eventemitter3_1.EventEmitter {
      * Main entry point: Analyze todos and detect parallelization opportunities
      */
     async detectParallelizationOpportunities(todos, objectiveType, currentAgents) {
-        console.log('🧠 Analyzing parallelization opportunities...');
+        this.logger.info('🧠 Analyzing parallelization opportunities', {
+            todoCount: todos.length,
+            objectiveType,
+            currentAgentCount: currentAgents.length
+        });
         const opportunities = [];
         // 1. Detect independent tasks (can run simultaneously)
         const independentOpportunity = await this.detectIndependentTasks(todos);
@@ -77,7 +83,11 @@ class ParallelAgentEngine extends eventemitter3_1.EventEmitter {
         const rankedOpportunities = opportunities
             .filter(opp => opp.confidence > 0.5 && opp.estimatedSpeedup > 1.1) // Lower thresholds
             .sort((a, b) => (b.confidence * b.estimatedSpeedup) - (a.confidence * a.estimatedSpeedup));
-        console.log(`🎯 Found ${rankedOpportunities.length} high-confidence parallelization opportunities`);
+        this.logger.info(`🎯 Found ${rankedOpportunities.length} high-confidence parallelization opportunities`, {
+            totalOpportunities: opportunities.length,
+            rankedCount: rankedOpportunities.length,
+            averageConfidence: rankedOpportunities.reduce((sum, opp) => sum + opp.confidence, 0) / rankedOpportunities.length || 0
+        });
         // Store opportunities for learning
         await this.storeOpportunities(todos, rankedOpportunities);
         return rankedOpportunities;
@@ -103,18 +113,26 @@ class ParallelAgentEngine extends eventemitter3_1.EventEmitter {
             failureRecovery: 'reassign'
         };
         this.activeExecutionPlans.set(planId, plan);
-        console.log(`📋 Created execution plan ${planId}:`);
-        console.log(`  • Strategy: ${strategy}`);
-        console.log(`  • Team size: ${agentTeam.length} agents`);
-        console.log(`  • Est. completion: ${estimatedCompletion} minutes`);
-        console.log(`  • Max parallelism: ${plan.maxParallelism} concurrent agents`);
+        this.logger.info(`📋 Created execution plan ${planId}`, {
+            planId,
+            strategy,
+            teamSize: agentTeam.length,
+            estimatedCompletion,
+            maxParallelism: plan.maxParallelism,
+            opportunityCount: opportunities.length
+        });
         return plan;
     }
     /**
      * Execute parallel plan and coordinate agents
      */
     async executeParallelPlan(plan, spawnAgentCallback) {
-        console.log(`🚀 Executing parallel plan ${plan.planId}`);
+        this.logger.info(`🚀 Executing parallel plan ${plan.planId}`, {
+            planId: plan.planId,
+            strategy: plan.executionStrategy,
+            agentTeamSize: plan.agentTeam.length,
+            maxParallelism: plan.maxParallelism
+        });
         const spawnedAgents = [];
         // Spawn agents based on plan
         for (const workload of plan.agentTeam) {

package/dist/queen/servicenow-queen.js

@@ -45,6 +45,7 @@ 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");
+const logger_1 = require("../utils/logger");
 const crypto = __importStar(require("crypto"));
 class ServiceNowQueen {
     constructor(config = {}) {
@@ -55,17 +56,19 @@ class ServiceNowQueen {
             debugMode: config.debugMode || false,
             autoPermissions: config.autoPermissions || false
         };
+        // Initialize logger
+        this.logger = new logger_1.Logger('ServiceNowQueen');
         // Initialize hive-mind components
         this.memory = new queen_memory_1.QueenMemorySystem(this.config.memoryPath);
         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, console, this.config.autoPermissions);
+        this.gapAnalysisEngine = new gap_analysis_engine_1.GapAnalysisEngine(this.mcpBridge, this.logger, this.config.autoPermissions);
         this.activeTasks = new Map();
         if (this.config.debugMode) {
-            console.log('🐝 ServiceNow Queen Agent initialized with hive-mind intelligence');
-            console.log('🔌 MCP Execution Bridge connected for real ServiceNow operations');
-            console.log('🧠 Intelligent Gap Analysis Engine ready for beyond-MCP configurations');
+            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');
         }
     }
     /**
@@ -76,11 +79,11 @@ class ServiceNowQueen {
         const startTime = Date.now();
         try {
             if (this.config.debugMode) {
-                console.log(`🎯 Queen analyzing objective: ${objective}`);
-                console.log(`🚨 ENFORCING MCP-FIRST WORKFLOW`);
+                this.logger.info(`🎯 Queen analyzing objective: ${objective}`);
+                this.logger.info(`🚨 ENFORCING MCP-FIRST WORKFLOW`);
             }
             // 🚨 PHASE 1: MANDATORY MCP PRE-FLIGHT AUTHENTICATION CHECK
-            console.log('🔐 Step 1: Validating ServiceNow connection...');
+            this.logger.info('🔐 Step 1: Validating ServiceNow connection...');
             const authCheck = await this.mcpBridge.executeAgentRecommendation({
                 type: 'mcp_call',
                 tool: 'snow_validate_live_connection',
@@ -98,12 +101,12 @@ class ServiceNowQueen {
 
 ❌ Cannot proceed with Queen Agent operations until authentication works!
         `;
-                console.error(authError);
+                this.logger.error('Authentication failed:', authError);
                 throw new Error(authError);
             }
-            console.log('✅ ServiceNow authentication validated');
+            this.logger.info('✅ ServiceNow authentication validated');
             // 🚨 PHASE 2: MANDATORY SMART DISCOVERY (Prevent Duplication)
-            console.log('🔍 Step 2: Discovering existing artifacts...');
+            this.logger.info('🔍 Step 2: Discovering existing artifacts...');
             const discovery = await this.mcpBridge.executeAgentRecommendation({
                 type: 'mcp_call',
                 tool: 'snow_comprehensive_search',
@@ -114,9 +117,9 @@ class ServiceNowQueen {
                 reasoning: 'MANDATORY: Check for existing artifacts before creating new ones'
             });
             if (discovery.success && discovery.result?.found?.length > 0) {
-                console.log(`🔍 Found ${discovery.result.found.length} existing artifacts that might be relevant:`);
+                this.logger.info(`🔍 Found ${discovery.result.found.length} existing artifacts that might be relevant:`);
                 discovery.result.found.forEach((artifact) => {
-                    console.log(`💡 Consider reusing: ${artifact.name} (${artifact.sys_id})`);
+                    this.logger.info(`💡 Consider reusing: ${artifact.name} (${artifact.sys_id})`);
                 });
             }
             // Phase 3: Initial Neural Analysis (informed by MCP discovery)
@@ -131,7 +134,7 @@ class ServiceNowQueen {
             };
             this.activeTasks.set(taskId, task);
             // 🚨 PHASE 5: INTELLIGENT GAP ANALYSIS (Beyond MCP Tools)
-            console.log('🧠 Step 4: Running Intelligent Gap Analysis...');
+            this.logger.info('🧠 Step 4: Running Intelligent Gap Analysis...');
             let gapAnalysisResult = null;
             try {
                 gapAnalysisResult = await this.gapAnalysisEngine.analyzeAndResolve(objective, {
@@ -141,35 +144,35 @@ class ServiceNowQueen {
                     includeManualGuides: true,
                     riskTolerance: 'medium'
                 });
-                console.log(`📊 Gap Analysis Complete:`);
-                console.log(`  • Total Requirements: ${gapAnalysisResult.totalRequirements}`);
-                console.log(`  • MCP Coverage: ${gapAnalysisResult.mcpCoverage.coveragePercentage}%`);
-                console.log(`  • Automated: ${gapAnalysisResult.summary.successfulAutomation} configurations`);
-                console.log(`  • Manual Work: ${gapAnalysisResult.summary.requiresManualWork} items`);
+                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) {
-                    console.log('\n📋 Manual Configuration Required:');
-                    gapAnalysisResult.nextSteps.manual.forEach(step => console.log(`  • ${step}`));
+                    this.logger.info('\n📋 Manual Configuration Required:');
+                    gapAnalysisResult.nextSteps.manual.forEach(step => this.logger.info(`  • ${step}`));
                     if (gapAnalysisResult.manualGuides) {
-                        console.log('\n📚 Detailed manual guides available in gap analysis result');
+                        this.logger.info('\n📚 Detailed manual guides available in gap analysis result');
                     }
                 }
                 // Display automation successes
                 if (gapAnalysisResult.summary.successfulAutomation > 0) {
-                    console.log('\n✅ Automated Configurations:');
-                    gapAnalysisResult.nextSteps.automated.forEach(step => console.log(`  • ${step}`));
+                    this.logger.info('\n✅ Automated Configurations:');
+                    gapAnalysisResult.nextSteps.automated.forEach(step => this.logger.info(`  • ${step}`));
                 }
                 // Display recommendations
                 if (gapAnalysisResult.nextSteps.recommendations.length > 0) {
-                    console.log('\n💡 Recommendations:');
-                    gapAnalysisResult.nextSteps.recommendations.forEach(rec => console.log(`  • ${rec}`));
+                    this.logger.info('\n💡 Recommendations:');
+                    gapAnalysisResult.nextSteps.recommendations.forEach(rec => this.logger.info(`  • ${rec}`));
                 }
                 // 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'}`);
-                console.log('🔄 Continuing with standard MCP workflow...');
+                this.logger.info('🔄 Continuing with standard MCP workflow...');
             }
             // Phase 6: Spawn optimal agent swarm
             const agents = this.spawnOptimalSwarm(task, analysis);
@@ -182,7 +185,7 @@ class ServiceNowQueen {
             task.status = 'completed';
             task.result = result;
             if (this.config.debugMode) {
-                console.log(`✅ Queen completed objective in ${duration}ms`);
+                this.logger.info(`✅ Queen completed objective in ${duration}ms`);
             }
             return result;
         }
@@ -197,7 +200,7 @@ class ServiceNowQueen {
     }
     spawnOptimalSwarm(task, analysis) {
         if (this.config.debugMode) {
-            console.log(`🐛 Spawning swarm for ${task.type} task (complexity: ${analysis.estimatedComplexity})`);
+            this.logger.info(`🐛 Spawning swarm for ${task.type} task (complexity: ${analysis.estimatedComplexity})`);
         }
         // Use learned patterns or optimal sequence
         const agentTypes = analysis.suggestedPattern?.agentSequence ||
@@ -205,7 +208,7 @@ class ServiceNowQueen {
         // Spawn agent swarm
         const agents = this.agentFactory.spawnAgentSwarm(agentTypes, task.id);
         if (this.config.debugMode) {
-            console.log(`👥 Spawned ${agents.length} agents: ${agents.map(a => a.type).join(', ')}`);
+            this.logger.info(`👥 Spawned ${agents.length} agents: ${agents.map(a => a.type).join(', ')}`);
         }
         return agents;
     }
@@ -241,14 +244,14 @@ class ServiceNowQueen {
     }
     async executeAgentsInParallel(agents, objective) {
         if (this.config.debugMode) {
-            console.log('⚡ Executing agents in parallel');
+            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) {
-            console.log('🔄 Executing agents sequentially');
+            this.logger.info('🔄 Executing agents sequentially');
         }
         const results = [];
         for (const agent of agents) {
@@ -273,7 +276,7 @@ class ServiceNowQueen {
     }
     async executeFinalDeployment(task, agentResults, analysis) {
         if (this.config.debugMode) {
-            console.log('🚀 Executing final deployment with MCP tools');
+            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);
@@ -609,7 +612,7 @@ function($scope) {
     async executeDeploymentPlan(plan) {
         // Execute real MCP tools through the bridge
         if (this.config.debugMode) {
-            console.log('🚀 Executing deployment plan with MCP Bridge');
+            this.logger.info('🚀 Executing deployment plan with MCP Bridge');
         }
         // Create agent recommendation from plan
         const recommendation = {
@@ -665,9 +668,9 @@ function($scope) {
             if (dependencies.length === 0) {
                 return; // No dependencies needed
             }
-            console.log(`\n📦 Detected ${dependencies.length} external dependencies in widget:`);
+            this.logger.info(`\n📦 Detected ${dependencies.length} external dependencies in widget:`);
             dependencies.forEach(dep => {
-                console.log(`  • ${dep.name} - ${dep.description}`);
+                this.logger.info(`  • ${dep.name} - ${dep.description}`);
             });
             // Create MCP tools wrapper for theme manager
             const mcpTools = {
@@ -735,22 +738,22 @@ function($scope) {
                 useMinified: true
             });
             if (result.success) {
-                console.log(`✅ ${result.message}`);
+                this.logger.info(`✅ ${result.message}`);
             }
             else {
-                console.log(`⚠️ Dependencies not installed: ${result.message}`);
-                console.log('💡 You may need to manually add these dependencies to your Service Portal theme');
+                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
-            console.log('⚠️ Widget deployed successfully but dependencies may need manual installation');
+            this.logger.warn('⚠️ Widget deployed successfully but dependencies may need manual installation');
         }
     }
     async attemptRecovery(task, agents, error) {
         if (this.config.debugMode) {
-            console.log(`🔄 Attempting recovery for task ${task.id}`);
+            this.logger.info(`🔄 Attempting recovery for task ${task.id}`);
         }
         // Try with reduced complexity or different agent sequence
         const fallbackResult = {
@@ -775,7 +778,7 @@ function($scope) {
             this.memory.recordTaskCompletion(task.id, task.objective, task.type, agentTypes, true, duration);
         }
         if (this.config.debugMode) {
-            console.log(`📚 Queen learned from ${error ? 'failure' : 'success'}: ${task.objective}`);
+            this.logger.info(`📚 Queen learned from ${error ? 'failure' : 'success'}: ${task.objective}`);
         }
     }
     async handleExecutionFailure(taskId, objective, error, duration) {
@@ -837,7 +840,7 @@ function($scope) {
     importMemory(memoryData) {
         this.memory.importMemory(memoryData);
         if (this.config.debugMode) {
-            console.log('🧠 Queen hive-mind memory imported successfully');
+            this.logger.info('🧠 Queen hive-mind memory imported successfully');
         }
     }
     clearMemory() {
@@ -845,7 +848,7 @@ function($scope) {
         // Also reset neural learning weights
         this.neuralLearning = new neural_learning_1.NeuralLearning(this.memory);
         if (this.config.debugMode) {
-            console.log('🧠 Queen hive-mind memory cleared - starting fresh');
+            this.logger.info('🧠 Queen hive-mind memory cleared - starting fresh');
         }
     }
     getLearningInsights() {
@@ -880,7 +883,7 @@ function($scope) {
     }
     async shutdown() {
         if (this.config.debugMode) {
-            console.log('🛑 Shutting down ServiceNow Queen Agent');
+            this.logger.info('🛑 Shutting down ServiceNow Queen Agent');
         }
         // Clean up all agents
         const activeAgents = this.agentFactory.getActiveAgents();