snow-flow 3.0.8 → 3.0.10

package/dist/src/utils/agent-detector.js

@@ -1,655 +0,0 @@
-"use strict";
-/**
- * Intelligent Agent Detection System
- * Dynamically determines which agents to spawn based on task analysis
- *
- * NOTE: This system now integrates with the Snow-Flow MCP task_categorize tool
- * for dynamic AI-based categorization instead of static patterns.
- */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentDetector = void 0;
-var AgentDetector = /** @class */ (function () {
-    function AgentDetector() {
-    }
-    /**
-     * Set the MCP client for dynamic categorization
-     */
-    AgentDetector.setMCPClient = function (client) {
-        this.mcpClient = client;
-    };
-    /**
-     * Analyze task using MCP dynamic categorization or fallback to static patterns
-     */
-    AgentDetector.analyzeTaskDynamic = function (objective, userMaxAgents) {
-        return __awaiter(this, void 0, void 0, function () {
-            var response, result, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.mcpClient) return [3 /*break*/, 4];
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.mcpClient.callTool({
-                                name: 'task_categorize',
-                                arguments: {
-                                    objective: objective,
-                                    context: {
-                                        language: 'auto',
-                                        maxAgents: userMaxAgents || 8,
-                                        environment: 'development',
-                                    },
-                                },
-                            })];
-                    case 2:
-                        response = _a.sent();
-                        if (response && response.content && response.content[0]) {
-                            result = JSON.parse(response.content[0].text);
-                            // Map MCP response to TaskAnalysis interface
-                            return [2 /*return*/, {
-                                    primaryAgent: result.categorization.primary_agent,
-                                    supportingAgents: result.categorization.supporting_agents,
-                                    complexity: result.categorization.complexity,
-                                    estimatedAgentCount: result.categorization.estimated_agent_count,
-                                    requiresUpdateSet: result.categorization.requires_update_set,
-                                    requiresApplication: result.categorization.requires_application,
-                                    taskType: result.categorization.task_type,
-                                    serviceNowArtifacts: result.categorization.service_now_artifacts,
-                                    confidence: result.categorization.confidence_score,
-                                    neuralConfidence: result.metadata.neural_confidence,
-                                    intentAnalysis: result.intent_analysis,
-                                    approach: {
-                                        recommendedStrategy: result.approach.recommended_strategy,
-                                        executionMode: result.approach.execution_mode,
-                                        parallelOpportunities: result.approach.parallel_opportunities,
-                                        riskFactors: result.approach.risk_factors,
-                                        optimizationHints: result.approach.optimization_hints,
-                                    },
-                                }];
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _a.sent();
-                        console.warn('MCP task_categorize failed, falling back to static patterns:', error_1);
-                        return [3 /*break*/, 4];
-                    case 4: 
-                    // Fallback to static analysis
-                    return [2 /*return*/, this.analyzeTask(objective, userMaxAgents)];
-                }
-            });
-        });
-    };
-    AgentDetector.analyzeTask = function (objective, userMaxAgents) {
-        var lowerObjective = objective.toLowerCase();
-        var words = lowerObjective.split(/\s+/);
-        // Check for data generation FIRST - before any other analysis
-        var dataGenerationPatterns = [
-            // Pattern for "create/make X incidents/changes" with flexible word order
-            /\b(create|generate|make|maak|genereer|aanmaken)\b.*\b\d+\b.*(incident|change|request|problem|task|record|item)/i,
-            // Pattern for "data set" with numbers anywhere
-            /\bdata\s*set\b.*\b\d{3,}/i, // data set with 3+ digit numbers
-            // Pattern for various test/mock/sample data keywords
-            /\b(test\s+data|mock\s+data|sample\s+data|training\s+data)\b/i,
-            // Pattern for populate/seed/fill operations
-            /\b(populate|seed|fill)\s+(with\s+)?(test|sample|random|mock)\s+(data|incident|change|record)/i,
-            // Pattern for seed database with numbers
-            /\b(seed|populate|fill)\s+(database|db|table)\s+with\s+\d+/i,
-            // Pattern for ML training data
-            /\b(ML|machine\s+learning|training)\b.*\bdata/i,
-            // Pattern for random/test with large numbers
-            /\b(random|test|mock|sample)\b.*\b\d{3,}\b.*(incident|change|request|problem)/i,
-            // Pattern for Dutch data set creation
-            /\bdata\s*set\s+(aan\s+)?van\s+\d+/i
-        ];
-        var isDataGeneration = dataGenerationPatterns.some(function (pattern) { return pattern.test(objective); });
-        if (isDataGeneration) {
-            return {
-                primaryAgent: 'script-writer',
-                supportingAgents: ['tester'], // Minimal support
-                complexity: 'simple',
-                estimatedAgentCount: 2,
-                requiresUpdateSet: false, // Usually no update set needed for data generation
-                requiresApplication: false,
-                taskType: 'data_generation',
-                serviceNowArtifacts: ['script']
-            };
-        }
-        // Check for simple operations
-        var simpleOperationPatterns = [
-            /\b(update|change|modify|delete|remove)\s+(the\s+)?(field|record|value|property)\b/i,
-            /\b(wijzig|verander|verwijder|pas\s+aan)\s+(het\s+)?(veld|record|waarde)\b/i
-        ];
-        var isSimpleOperation = simpleOperationPatterns.some(function (pattern) { return pattern.test(objective); });
-        if (isSimpleOperation) {
-            return {
-                primaryAgent: 'script-writer',
-                supportingAgents: ['tester'],
-                complexity: 'simple',
-                estimatedAgentCount: 2,
-                requiresUpdateSet: false,
-                requiresApplication: false,
-                taskType: 'simple_operation',
-                serviceNowArtifacts: ['script']
-            };
-        }
-        // Determine task type for other cases
-        var taskType = this.determineTaskType(lowerObjective, this.detectServiceNowArtifacts(lowerObjective));
-        // Detect agent capabilities
-        var agentCapabilities = this.detectAgentCapabilities(lowerObjective);
-        // Determine primary agent
-        var primaryAgent = this.determinePrimaryAgent(agentCapabilities);
-        // Determine supporting agents
-        var supportingAgents = this.determineSupportingAgents(agentCapabilities, primaryAgent, userMaxAgents);
-        // Assess complexity
-        var complexity = this.assessComplexity(objective, agentCapabilities);
-        // Determine ServiceNow artifacts
-        var serviceNowArtifacts = this.detectServiceNowArtifacts(lowerObjective);
-        // Determine if Update Set is required
-        var requiresUpdateSet = this.requiresUpdateSet(lowerObjective, serviceNowArtifacts);
-        // Determine if new Application is required
-        var requiresApplication = this.requiresApplication(lowerObjective, serviceNowArtifacts);
-        // 🚀 NEW: Accurate agent count for parallel system
-        var isDevelopmentTask = ['widget-creator', 'flow-builder', 'script-writer', 'app-architect'].includes(primaryAgent) ||
-            supportingAgents.some(function (agent) { return ['css-specialist', 'backend-specialist', 'frontend-specialist'].includes(agent); });
-        var estimatedAgentCount = isDevelopmentTask
-            ? Math.max(supportingAgents.length + 1, 6) // 6+ agents for development (1 primary + 5+ specialists)
-            : Math.min(Math.max(supportingAgents.length + 1, 2), 8); // Original logic for non-development
-        return {
-            primaryAgent: primaryAgent,
-            supportingAgents: supportingAgents,
-            complexity: complexity,
-            estimatedAgentCount: estimatedAgentCount,
-            requiresUpdateSet: requiresUpdateSet,
-            requiresApplication: requiresApplication,
-            taskType: taskType,
-            serviceNowArtifacts: serviceNowArtifacts
-        };
-    };
-    AgentDetector.detectAgentCapabilities = function (objective) {
-        var capabilities = [];
-        for (var _i = 0, _a = Object.entries(this.AGENT_PATTERNS); _i < _a.length; _i++) {
-            var _b = _a[_i], agentType = _b[0], config = _b[1];
-            var matchCount = 0;
-            var totalKeywords = config.keywords.length;
-            for (var _c = 0, _d = config.keywords; _c < _d.length; _c++) {
-                var keyword = _d[_c];
-                if (objective.includes(keyword)) {
-                    matchCount++;
-                }
-            }
-            if (matchCount > 0) {
-                var confidence = (matchCount / totalKeywords) * config.confidence;
-                capabilities.push({
-                    type: agentType,
-                    confidence: confidence,
-                    requiredFor: config.requiredFor,
-                    description: config.description
-                });
-            }
-        }
-        return capabilities.sort(function (a, b) { return b.confidence - a.confidence; });
-    };
-    AgentDetector.determinePrimaryAgent = function (capabilities) {
-        if (capabilities.length === 0)
-            return 'queen-coordinator';
-        // Map detected types to new parallel agent types
-        var convertToParallelType = function (detectedType) {
-            var mapping = {
-                'widget_builder': 'widget-creator',
-                'flow_designer': 'flow-builder',
-                'integration_specialist': 'integration-specialist',
-                'database_expert': 'app-architect',
-                'coder': 'script-writer',
-                'architect': 'app-architect',
-                'tester': 'tester',
-                'data_generator': 'script-writer' // Data generation uses script-writer
-            };
-            return mapping[detectedType] || detectedType;
-        };
-        // Convert all capability types to parallel agent types
-        var parallelCapabilities = capabilities.map(function (c) { return (__assign(__assign({}, c), { type: convertToParallelType(c.type) })); });
-        // Special logic for ServiceNow-specific tasks - use new parallel agent types
-        var serviceNowAgents = parallelCapabilities.filter(function (c) {
-            return ['flow-builder', 'widget-creator', 'integration-specialist', 'app-architect'].includes(c.type);
-        });
-        if (serviceNowAgents.length > 0) {
-            return serviceNowAgents[0].type;
-        }
-        return parallelCapabilities[0].type;
-    };
-    AgentDetector.determineSupportingAgents = function (capabilities, primaryAgent, userMaxAgents) {
-        // 🚀 NEW: Parallel Agent System - Show 6+ specialized agents for development tasks
-        var isWidgetDevelopment = primaryAgent === 'widget-creator' || capabilities.some(function (c) { return c.type === 'widget-creator'; });
-        var isFlowDevelopment = primaryAgent === 'flow-builder' || capabilities.some(function (c) { return c.type === 'flow-builder'; });
-        var isDevelopmentTask = isWidgetDevelopment || isFlowDevelopment ||
-            capabilities.some(function (c) { return ['widget-creator', 'flow-builder', 'script-writer', 'app-architect'].includes(c.type); });
-        if (isDevelopmentTask) {
-            // 🚀 Widget development gets full specialized team (6+ agents)
-            if (isWidgetDevelopment) {
-                return ['css-specialist', 'backend-specialist', 'frontend-specialist', 'integration-specialist', 'performance-specialist', 'tester'];
-            }
-            // 🚀 Flow development gets flow-specific team
-            if (isFlowDevelopment) {
-                return ['trigger-specialist', 'action-specialist', 'approval-specialist', 'integration-specialist', 'error-handler', 'tester'];
-            }
-            // 🚀 General development gets adaptive specialized team
-            return ['script-writer', 'css-specialist', 'integration-specialist', 'security-specialist', 'performance-specialist', 'tester'];
-        }
-        // 🚀 For non-development tasks, use smart agent selection based on capabilities
-        var requestedSupportingCount = userMaxAgents ? Math.max(userMaxAgents - 1, 1) : 5;
-        // Start with high-confidence agents (confidence > 0.3)
-        var supportingAgents = capabilities
-            .filter(function (c) { return c.type !== primaryAgent && c.confidence > 0.3; })
-            .slice(0, requestedSupportingCount)
-            .map(function (c) { return c.type; });
-        // If we need more agents, add specialized agents based on task context
-        if (supportingAgents.length < requestedSupportingCount) {
-            var remainingSlots = requestedSupportingCount - supportingAgents.length;
-            var specializedAgents = ['integration-specialist', 'security-specialist', 'tester', 'performance-specialist']
-                .filter(function (agent) { return !supportingAgents.includes(agent); })
-                .slice(0, remainingSlots);
-            supportingAgents = __spreadArray(__spreadArray([], supportingAgents, true), specializedAgents, true);
-        }
-        // Ensure we don't exceed the requested count
-        if (userMaxAgents && supportingAgents.length > requestedSupportingCount) {
-            supportingAgents = supportingAgents.slice(0, requestedSupportingCount);
-        }
-        return supportingAgents;
-    };
-    AgentDetector.assessComplexity = function (objective, capabilities) {
-        var wordCount = objective.split(/\s+/).length;
-        var agentCount = capabilities.length;
-        // Complex indicators
-        var complexKeywords = ['integrate', 'multiple', 'complex', 'advanced', 'system', 'architecture', 'enterprise'];
-        var hasComplexKeywords = complexKeywords.some(function (keyword) { return objective.toLowerCase().includes(keyword); });
-        if (wordCount > 20 || agentCount > 4 || hasComplexKeywords) {
-            return 'complex';
-        }
-        else if (wordCount > 10 || agentCount > 2) {
-            return 'medium';
-        }
-        else {
-            return 'simple';
-        }
-    };
-    AgentDetector.detectServiceNowArtifacts = function (objective) {
-        var artifacts = [];
-        var lowerObjective = objective.toLowerCase();
-        // Enhanced artifact detection with Dutch support and context
-        var artifactPatterns = {
-            'widget': [
-                'widget', 'widgets',
-                'service portal', 'portal component', 'dashboard component',
-                'ui component', 'interface', 'display', 'homepage'
-            ],
-            'flow': [
-                'flow', 'flows', 'workflow', 'workflows',
-                'process', 'processes', 'automation', 'automate',
-                'approval', 'approvals', 'routing', 'trigger'
-            ],
-            'application': [
-                'application', 'applications', 'app', 'apps',
-                'applicatie', 'applicaties', 'system', 'systeem',
-                'complete', 'comprehensive', 'full solution'
-            ],
-            'script': [
-                'script', 'scripts', 'code', 'function', 'functions',
-                'business rule', 'business rules', 'client script', 'server script',
-                'script include', 'javascript', 'logic', 'programmeer'
-            ],
-            'business_rule': [
-                'business rule', 'business rules', 'business_rule',
-                'rule', 'rules', 'validation', 'trigger logic',
-                'bedrijfsregel', 'regel', 'regels'
-            ],
-            'integration': [
-                'integration', 'integrations', 'api', 'apis',
-                'rest', 'soap', 'webhook', 'external', 'third party',
-                'integratie', 'koppeling', 'verbinding'
-            ],
-            'table': [
-                'table', 'tables', 'database', 'data',
-                'record', 'records', 'field', 'fields',
-                'tabel', 'tabellen', 'gegevens'
-            ],
-            'report': [
-                'report', 'reports', 'reporting', 'analytics',
-                'dashboard', 'chart', 'graph', 'metrics',
-                'rapport', 'rapporten', 'rapportage'
-            ]
-        };
-        // Check each artifact type with enhanced patterns
-        for (var _i = 0, _a = Object.entries(artifactPatterns); _i < _a.length; _i++) {
-            var _b = _a[_i], artifactType = _b[0], patterns = _b[1];
-            for (var _c = 0, patterns_1 = patterns; _c < patterns_1.length; _c++) {
-                var pattern = patterns_1[_c];
-                if (lowerObjective.includes(pattern)) {
-                    if (!artifacts.includes(artifactType)) {
-                        artifacts.push(artifactType);
-                    }
-                    break; // Found one pattern for this type, move to next type
-                }
-            }
-        }
-        // Context-based detection for common development terms
-        var developmentContext = {
-            'widget': ['voor', 'voor een', 'show', 'display', 'interface', 'homepage', 'portal'],
-            'flow': ['goedkeuring', 'approval', 'proces', 'automatiseer', 'trigger', 'wanneer'],
-            'script': ['implementeer', 'implement', 'schrijf', 'write', 'code', 'function'],
-            'table': ['opslaan', 'save', 'store', 'data', 'informatie', 'gegevens'],
-            'report': ['analyse', 'analyze', 'overview', 'overzicht', 'statistieken', 'metrics']
-        };
-        // Add context-based detection
-        for (var _d = 0, _e = Object.entries(developmentContext); _d < _e.length; _d++) {
-            var _f = _e[_d], artifactType = _f[0], contextWords = _f[1];
-            for (var _g = 0, contextWords_1 = contextWords; _g < contextWords_1.length; _g++) {
-                var contextWord = contextWords_1[_g];
-                if (lowerObjective.includes(contextWord) && !artifacts.includes(artifactType)) {
-                    // Only add if we have creation/development intent
-                    var creationWords = ['create', 'maak', 'bouw', 'build', 'develop', 'implementeer', 'schrijf', 'write'];
-                    if (creationWords.some(function (word) { return lowerObjective.includes(word); })) {
-                        artifacts.push(artifactType);
-                        break;
-                    }
-                }
-            }
-        }
-        // Remove duplicates and return
-        return Array.from(new Set(artifacts));
-    };
-    AgentDetector.requiresUpdateSet = function (objective, artifacts) {
-        var lowerObjective = objective.toLowerCase();
-        // Always require Update Set for development tasks
-        var developmentKeywords = [
-            'create', 'build', 'implement', 'develop', 'make', 'generate', 'add',
-            'bouw', 'maak', 'schrijf', 'write', 'update', 'modify', 'change',
-            'implementeer', 'ontwikkel', 'codeer', 'programmeer', 'stel', 'wijzig',
-            'business rule', 'script', 'flow', 'widget', 'workflow', 'client script',
-            'ui action', 'scheduled job', 'transform', 'integration',
-            'bedrijfsregel', 'proces', 'goedkeuring', 'automatisering'
-        ];
-        var hasDevelopmentKeywords = developmentKeywords.some(function (keyword) { return lowerObjective.includes(keyword); });
-        // Or if ServiceNow artifacts are involved
-        var hasServiceNowArtifacts = artifacts.length > 0;
-        // Or if task type indicates development
-        var developmentTaskTypes = [
-            'widget_development', 'flow_development', 'script_development',
-            'application_development', 'integration_development', 'database_development',
-            'reporting_development', 'general_development'
-        ];
-        var taskType = this.determineTaskType(objective, artifacts);
-        var isDevelopmentTask = developmentTaskTypes.includes(taskType);
-        return hasDevelopmentKeywords || hasServiceNowArtifacts || isDevelopmentTask;
-    };
-    AgentDetector.requiresApplication = function (objective, artifacts) {
-        // Require new application for comprehensive systems
-        var applicationKeywords = [
-            'application', 'app', 'system', 'complete', 'full', 'comprehensive',
-            'applicatie', 'applicaties', 'systeem', 'volledig', 'compleet',
-            'totaal', 'geheel', 'pakket', 'oplossing', 'solution'
-        ];
-        var hasApplicationKeywords = applicationKeywords.some(function (keyword) { return objective.toLowerCase().includes(keyword); });
-        // Or if multiple complex artifacts are involved
-        var hasMultipleArtifacts = artifacts.length >= 3;
-        return hasApplicationKeywords || hasMultipleArtifacts;
-    };
-    AgentDetector.determineTaskType = function (objective, artifacts) {
-        var lowerObjective = objective.toLowerCase();
-        // FIRST: Check for data generation requests
-        var dataGenerationPatterns = [
-            /\b(create|generate|make|maak)\s+\d+\s+(random\s+)?(incident|change|request|problem|task|record|item)/i,
-            /\b(genereer|aanmaken)\s+\d+\s+(willekeurige\s+)?(incident|change|request|problem|task|record|item)/i,
-            /\bdata\s*set\s*(van|of|with)\s*\d+/i,
-            /\b(test\s+data|mock\s+data|sample\s+data|training\s+data)\b/i,
-            /\b(populate|seed|fill)\s+(with\s+)?(test|sample|random)\s+data/i
-        ];
-        var isDataGeneration = dataGenerationPatterns.some(function (pattern) { return pattern.test(objective); });
-        if (isDataGeneration)
-            return 'data_generation';
-        // Check for simple operations (update, delete, modify single things)
-        var simpleOperationPatterns = [
-            /\b(update|change|modify|delete|remove)\s+(the\s+)?(field|record|value|property)\b/i,
-            /\b(wijzig|verander|verwijder|pas\s+aan)\s+(het\s+)?(veld|record|waarde)\b/i
-        ];
-        var isSimpleOperation = simpleOperationPatterns.some(function (pattern) { return pattern.test(objective); });
-        if (isSimpleOperation)
-            return 'simple_operation';
-        // Determine based on detected artifacts and keywords
-        // Check flow FIRST as it's often confused with widget when both are present
-        if (artifacts.includes('flow') || artifacts.includes('workflow'))
-            return 'flow_development';
-        if (artifacts.includes('widget'))
-            return 'widget_development';
-        if (artifacts.includes('application'))
-            return 'application_development';
-        if (artifacts.includes('script') || artifacts.includes('business_rule'))
-            return 'script_development';
-        if (artifacts.includes('integration') || artifacts.includes('api'))
-            return 'integration_development';
-        if (artifacts.includes('table') || artifacts.includes('database'))
-            return 'database_development';
-        if (artifacts.includes('report') || artifacts.includes('dashboard'))
-            return 'reporting_development';
-        // Fallback to general development
-        var developmentKeywords = [
-            'create', 'build', 'implement', 'develop', 'make', 'generate',
-            'bouw', 'maak', 'schrijf', 'implementeer', 'ontwikkel', 'codeer'
-        ];
-        var hasDevelopmentKeywords = developmentKeywords.some(function (keyword) { return lowerObjective.includes(keyword); });
-        if (hasDevelopmentKeywords)
-            return 'general_development';
-        // Research or _analysis tasks
-        var researchKeywords = [
-            'research', 'analyze', 'investigate', 'study', 'explore',
-            'onderzoek', 'analyseer', 'bestudeer', 'ontdek'
-        ];
-        var hasResearchKeywords = researchKeywords.some(function (keyword) { return lowerObjective.includes(keyword); });
-        if (hasResearchKeywords)
-            return 'research_task';
-        return 'orchestration_task';
-    };
-    AgentDetector.generateAgentPrompt = function (agentType, objective, _analysis) {
-        var agentConfig = this.AGENT_PATTERNS[agentType];
-        var basePrompt = "You are a specialized ".concat(agentType, " agent in a ServiceNow multi-agent development swarm.\n\n\uD83C\uDFAF **Your Role**: ").concat((agentConfig === null || agentConfig === void 0 ? void 0 : agentConfig.description) || 'Specialized agent', "\n\n\uD83D\uDD0D **Task Context**: ").concat(objective, "\n\n\uD83C\uDFD7\uFE0F **Project Setup**:\n").concat(_analysis.requiresUpdateSet ? '- ✅ Update Set will be automatically created' : '- ⚠️ No Update Set required', "\n").concat(_analysis.requiresApplication ? '- ✅ New Application will be automatically created' : '- ⚠️ Using existing application context', "\n\n\uD83E\uDD16 **ML Capabilities Available**:\n- \uD83E\uDDE0 Neural Networks: Incident classification, change risk prediction, anomaly detection\n- \uD83D\uDCCA Performance Analytics ML: KPI forecasting, trend analysis (when PA plugin active)\n- \uD83D\uDD2E Predictive Intelligence: Clustering, similarity matching (when PI plugin active)\n- \uD83C\uDFAF Hybrid ML: Combine ServiceNow native ML with custom TensorFlow models\n\n\uD83E\uDD16 **Team Coordination**:\n- Primary Agent: ").concat(_analysis.primaryAgent, "\n- Supporting Agents: ").concat(_analysis.supportingAgents.join(', '), "\n- Task Complexity: ").concat(_analysis.complexity, "\n- ServiceNow Artifacts: ").concat(_analysis.serviceNowArtifacts.join(', '), "\n\n\uD83D\uDCCB **Your Responsibilities**:");
-        // Add agent-specific responsibilities
-        switch (agentType) {
-            case 'architect':
-                return basePrompt + "\n- Design system architecture and data models\n- Define relationships between ServiceNow components\n- Create technical specifications\n- Ensure scalability and best practices\n- Coordinate with other agents on implementation approach";
-            case 'coder':
-                return basePrompt + "\n- Implement code based on architectural designs\n- Write ServiceNow scripts, business rules, and functions\n- Ensure code quality and maintainability\n- Follow ServiceNow development best practices\n- Collaborate with testers on code validation\n- Implement ML-powered features:\n  * mcp__servicenow-machine-learning__ml_train_incident_classifier - Train classification models\n  * mcp__servicenow-machine-learning__ml_classify_incident - Auto-classify incidents\n  * mcp__servicenow-machine-learning__ml_predictive_intelligence - Add PI capabilities";
-            case 'flow_designer':
-                return basePrompt + "\n- Design and implement ServiceNow flows and workflows\n- Configure approval processes and routing logic\n- Set up triggers and conditions\n- Ensure proper integration with other system components\n- Test flow execution and error handling";
-            case 'widget_builder':
-                return basePrompt + "\n- Design and implement Service Portal widgets\n- Create HTML templates and CSS styling\n- Develop client-side and server-side scripts\n- Ensure responsive design and accessibility\n- Integrate with ServiceNow APIs and data sources";
-            case 'tester':
-                return basePrompt + "\n- Develop and execute test plans\n- Validate functionality and performance\n- Identify and report bugs and issues\n- Ensure quality standards are met\n- Coordinate with development agents on fixes";
-            case 'researcher':
-                return basePrompt + "\n- Research ServiceNow best practices and patterns\n- Analyze requirements and gather information\n- Provide insights and recommendations\n- Study existing implementations and solutions\n- Document findings and share knowledge\n- Use ML for data-driven insights:\n  * mcp__servicenow-machine-learning__ml_forecast_incidents - Predict future trends\n  * mcp__servicenow-machine-learning__ml_detect_anomalies - Find unusual patterns\n  * mcp__servicenow-machine-learning__ml_performance_analytics - Analyze KPIs with ML";
-            case 'orchestrator':
-                return basePrompt + "\n- Coordinate activities between all agents\n- Manage task priorities and dependencies\n- Ensure project timeline and milestones\n- Facilitate communication and collaboration\n- Monitor progress and address blockers\n- Leverage ML for intelligent orchestration:\n  * mcp__servicenow-machine-learning__ml_agent_intelligence - AI work assignment\n  * mcp__servicenow-machine-learning__ml_process_optimization - Optimize workflows\n  * mcp__servicenow-machine-learning__ml_hybrid_recommendation - Combined ML insights";
-            default:
-                return basePrompt + "\n- Provide specialized expertise in your domain\n- Collaborate effectively with other agents\n- Ensure quality and best practices\n- Contribute to overall project success";
-        }
-    };
-    // MCP integration for dynamic categorization
-    AgentDetector.mcpClient = null;
-    AgentDetector.AGENT_PATTERNS = {
-        // Development agents
-        architect: {
-            keywords: ['design', 'architecture', 'structure', 'database', 'schema', 'model', 'entity', 'relationship', 'system'],
-            confidence: 0.9,
-            description: 'System architecture and design',
-            requiredFor: ['applications', 'complex_systems', 'integrations']
-        },
-        coder: {
-            keywords: ['implement', 'code', 'script', 'function', 'api', 'endpoint', 'logic', 'algorithm', 'business_rule', 'schrijf', 'write', 'develop', 'programmeer', 'implementeer', 'maak', 'bouw', 'build', 'create', 'codeer'],
-            confidence: 0.8,
-            description: 'Code implementation and development',
-            requiredFor: ['scripts', 'functions', 'business_rules', 'apis']
-        },
-        researcher: {
-            keywords: ['research', 'analyze', 'investigate', 'study', 'explore', 'understand', 'learn', 'discover', 'onderzoek', 'analyseer', 'bestudeer', 'ontdek', 'begrijp'],
-            confidence: 0.7,
-            description: 'Research and _analysis',
-            requiredFor: ['requirements', 'best_practices', 'patterns']
-        },
-        tester: {
-            keywords: ['test', 'verify', 'validate', 'check', 'ensure', 'quality', 'bug', 'debug', 'controleer', 'valideer', 'kwaliteit', 'testen'],
-            confidence: 0.8,
-            description: 'Testing and quality assurance',
-            requiredFor: ['validation', 'quality_control', 'debugging']
-        },
-        reviewer: {
-            keywords: ['review', 'audit', 'examine', 'evaluate', 'assess', 'approve', 'feedback'],
-            confidence: 0.7,
-            description: 'Code and process review',
-            requiredFor: ['code_review', 'approval_process', 'quality_gates']
-        },
-        documenter: {
-            keywords: ['document', 'documentation', 'guide', 'manual', 'readme', 'help', 'instructions'],
-            confidence: 0.6,
-            description: 'Documentation and guides',
-            requiredFor: ['documentation', 'user_guides', 'api_docs']
-        },
-        orchestrator: {
-            keywords: ['coordinate', 'manage', 'orchestrate', 'organize', 'plan', 'schedule', 'oversee'],
-            confidence: 0.9,
-            description: 'Task coordination and management',
-            requiredFor: ['complex_tasks', 'multi_agent_coordination', 'project_management']
-        },
-        // ServiceNow specific agents
-        flow_designer: {
-            keywords: ['flow', 'workflow', 'process', 'automation', 'approval', 'routing', 'trigger', 'proces', 'goedkeuring', 'automatisering', 'automatiseer', 'doorloop', 'stroom'],
-            confidence: 0.9,
-            description: 'ServiceNow Flow Designer specialist',
-            requiredFor: ['flows', 'workflows', 'approvals', 'automation']
-        },
-        widget_builder: {
-            keywords: ['widget', 'portal', 'dashboard', 'ui', 'interface', 'frontend', 'display', 'weergave', 'scherm', 'component', 'homepage'],
-            confidence: 0.9,
-            description: 'Service Portal widget development',
-            requiredFor: ['widgets', 'portals', 'dashboards', 'ui_components']
-        },
-        integration_specialist: {
-            keywords: ['integration', 'api', 'rest', 'soap', 'webhook', 'external', 'third_party'],
-            confidence: 0.8,
-            description: 'System integration and APIs',
-            requiredFor: ['integrations', 'apis', 'webhooks', 'external_systems']
-        },
-        database_expert: {
-            keywords: ['database', 'table', 'field', 'record', 'data', 'schema', 'query', 'report'],
-            confidence: 0.8,
-            description: 'Database and data management',
-            requiredFor: ['tables', 'databases', 'reports', 'data_management']
-        }
-    };
-    // 🚀 ENHANCED: Updated to use new specialized agents for parallel execution (v1.1.92)
-    AgentDetector.SERVICENOW_ARTIFACTS = {
-        'widget': [
-            'widget-creator', // HTML structure specialist
-            'css-specialist', // Styling and responsive design specialist  
-            'backend-specialist', // Server script specialist
-            'frontend-specialist', // Client script specialist
-            'integration-specialist', // API integration specialist
-            'ui-ux-specialist', // User experience specialist
-            'performance-specialist', // Performance optimization
-            'tester' // Testing specialist
-        ],
-        'flow': [
-            'flow-builder', // Flow structure specialist
-            'trigger-specialist', // Trigger configuration specialist
-            'action-specialist', // Action development specialist  
-            'integration-specialist', // External system integration
-            'approval-specialist', // Approval process specialist
-            'notification-specialist', // Notification configuration
-            'error-handler', // Error handling specialist
-            'tester' // Flow testing specialist
-        ],
-        'workflow': [
-            'flow-builder', 'trigger-specialist', 'action-specialist', 'approval-specialist', 'tester'
-        ],
-        'application': [
-            'app-architect', // Application architecture
-            'widget-creator', // UI components
-            'css-specialist', // Styling specialist
-            'flow-builder', // Business logic flows
-            'script-writer', // Script includes and business rules
-            'security-specialist', // Security implementation
-            'integration-specialist', // System integration
-            'performance-specialist', // Performance optimization
-            'documentation-specialist' // Documentation
-        ],
-        'script': ['script-writer', 'security-specialist', 'tester'],
-        'business_rule': ['script-writer', 'security-specialist', 'tester'],
-        'integration': [
-            'integration-specialist', // API integration specialist
-            'api-specialist', // API development specialist
-            'transform-specialist', // Data transformation specialist
-            'monitoring-specialist', // Integration monitoring
-            'security-specialist', // Security implementation
-            'tester' // Integration testing
-        ],
-        'api': ['api-specialist', 'integration-specialist', 'security-specialist', 'tester'],
-        'table': ['database_expert', 'architect', 'script-writer'],
-        'report': ['database_expert', 'analyst', 'performance-specialist'],
-        'dashboard': ['widget-creator', 'css-specialist', 'database_expert', 'performance-specialist']
-    };
-    return AgentDetector;
-}());
-exports.AgentDetector = AgentDetector;