snow-flow 2.6.0 → 2.6.2

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

@@ -0,0 +1,655 @@
+"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;