snow-flow 2.4.0 → 2.5.0

package/dist/cli.js

@@ -616,6 +616,24 @@ You are the Queen Agent, master coordinator of the Snow-Flow hive-mind. Your mis
 - **Estimated Total Agents**: ${taskAnalysis.estimatedAgentCount}
 - **ServiceNow Artifacts**: ${taskAnalysis.serviceNowArtifacts.join(', ')}
 
+## ⚡ CRITICAL: Task Intent Analysis
+**BEFORE PROCEEDING**, analyze the user's ACTUAL intent:
+
+1. **Data Generation Request?** (e.g., "create 5000 incidents", "generate test data")
+   → Focus on CREATING DATA, not building systems
+   → Use simple scripts or bulk operations to generate the data
+   → Skip complex architectures unless explicitly asked
+
+2. **System Building Request?** (e.g., "build a widget", "create an ML system")
+   → Follow full development workflow
+   → Build proper architecture and components
+
+3. **Simple Operation Request?** (e.g., "update field X", "delete records")
+   → Execute the operation directly
+   → Skip unnecessary complexity
+
+**For this objective**: Analyze if the user wants data generation, system building, or a simple operation.
+
 ${isFlowDesignerTask ? `## 🔧 Flow Designer Task Detected - Using ENHANCED XML-First Approach!
 🚀 **FULLY AUTOMATED FLOW DEPLOYMENT v2.0** - ALL features working correctly!
 
@@ -676,6 +694,27 @@ The Queen Agent will automatically discover and validate table schemas based on
 
 ## 👑 Your Queen Agent Responsibilities
 
+## 📊 Data Generation Specific Instructions
+If the task is identified as DATA GENERATION (e.g., "create 5000 incidents"):
+
+1. **DO NOT** build complex export/import systems
+2. **DO NOT** create APIs, UI Actions, or workflows
+3. **DO** focus on:
+   - Creating a simple script to generate the data
+   - Using ServiceNow's REST API or direct table operations
+   - Ensuring realistic data distribution for ML training
+   - Adding variety in categories, priorities, descriptions, etc.
+
+**Example approach for "create 5000 incidents":**
+\`\`\`javascript
+// Simple batch creation script
+for (let i = 0; i < 5000; i += 100) {
+  // Create 100 incidents at a time to avoid timeouts
+  const batch = generateRealisticIncidentBatch(100);
+  await createIncidentsBatch(batch);
+}
+\`\`\`
+
 ### 1. CRITICAL: Initialize Memory FIRST (Before Everything!)
 **THIS MUST BE YOUR VERY FIRST ACTION - Initialize the swarm memory session:**
 \`\`\`javascript

package/dist/mcp/snow-flow-mcp.js

@@ -226,6 +226,41 @@ class SnowFlowMCPServer {
                         required: ['pattern'],
                     },
                 },
+                // Task Analysis & Categorization
+                {
+                    name: 'task_categorize',
+                    description: 'Intelligently categorize any task/request using AI to determine optimal agent team, complexity, and approach',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            objective: {
+                                type: 'string',
+                                description: 'The task objective or request to categorize',
+                            },
+                            context: {
+                                type: 'object',
+                                description: 'Additional context about the environment or constraints',
+                                properties: {
+                                    language: {
+                                        type: 'string',
+                                        enum: ['auto', 'en', 'nl', 'de', 'fr', 'es'],
+                                        default: 'auto',
+                                    },
+                                    maxAgents: {
+                                        type: 'number',
+                                        default: 8,
+                                    },
+                                    environment: {
+                                        type: 'string',
+                                        enum: ['development', 'test', 'production'],
+                                        default: 'development',
+                                    },
+                                },
+                            },
+                        },
+                        required: ['objective'],
+                    },
+                },
                 // Performance & Monitoring
                 {
                     name: 'performance_report',
@@ -292,6 +327,8 @@ class SnowFlowMCPServer {
                         return await this.handleNeuralStatus(args);
                     case 'token_usage':
                         return await this.handleTokenUsage(args);
+                    case 'task_categorize':
+                        return await this.handleTaskCategorize(args);
                     default:
                         return {
                             content: [
@@ -789,6 +826,285 @@ class SnowFlowMCPServer {
             ],
         };
     }
+    async handleTaskCategorize(args) {
+        const { objective, context = {} } = args;
+        const { language = 'auto', maxAgents = 8, environment = 'development' } = context;
+        // Intelligent task analysis using AI-based understanding
+        const lowerObjective = objective.toLowerCase();
+        // Detect language if auto
+        const detectedLanguage = this.detectLanguage(lowerObjective);
+        // Analyze intent using comprehensive understanding
+        const intent = this.analyzeTaskIntent(lowerObjective, detectedLanguage);
+        // Determine task characteristics
+        const taskCharacteristics = this.analyzeTaskCharacteristics(lowerObjective, intent);
+        // Select optimal agents
+        const agentSelection = this.selectOptimalAgents(taskCharacteristics, maxAgents);
+        // Generate approach recommendations
+        const approach = this.generateApproach(taskCharacteristics, agentSelection, environment);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        objective,
+                        language: detectedLanguage,
+                        categorization: {
+                            task_type: taskCharacteristics.taskType,
+                            primary_agent: agentSelection.primaryAgent,
+                            supporting_agents: agentSelection.supportingAgents,
+                            complexity: taskCharacteristics.complexity,
+                            estimated_agent_count: agentSelection.totalAgents,
+                            requires_update_set: taskCharacteristics.requiresUpdateSet,
+                            requires_application: taskCharacteristics.requiresApplication,
+                            service_now_artifacts: taskCharacteristics.artifacts,
+                            confidence_score: taskCharacteristics.confidence,
+                        },
+                        intent_analysis: {
+                            primary_intent: intent.primary,
+                            secondary_intents: intent.secondary,
+                            action_verbs: intent.actionVerbs,
+                            target_objects: intent.targetObjects,
+                            quantifiers: intent.quantifiers,
+                        },
+                        approach: {
+                            recommended_strategy: approach.strategy,
+                            execution_mode: approach.executionMode,
+                            parallel_opportunities: approach.parallelOpportunities,
+                            risk_factors: approach.riskFactors,
+                            optimization_hints: approach.optimizationHints,
+                        },
+                        environment_considerations: {
+                            environment,
+                            safety_measures: approach.safetyMeasures,
+                            rollback_strategy: approach.rollbackStrategy,
+                        },
+                        metadata: {
+                            analysis_version: '2.0',
+                            timestamp: new Date().toISOString(),
+                            neural_confidence: taskCharacteristics.neuralConfidence || 0.95,
+                        },
+                    }),
+                },
+            ],
+        };
+    }
+    detectLanguage(text) {
+        // Language detection patterns
+        const patterns = {
+            nl: /\b(maak|aanmaken|genereer|voor|een|het|de|met|van|naar|door|bij|zonder|tijdens|volgens|behalve|tegen)\b/i,
+            de: /\b(machen|erstellen|generieren|für|ein|der|die|das|mit|von|nach|durch|bei|ohne|während|gemäß|außer|gegen)\b/i,
+            fr: /\b(faire|créer|générer|pour|un|une|le|la|les|avec|de|à|par|chez|sans|pendant|selon|sauf|contre)\b/i,
+            es: /\b(hacer|crear|generar|para|un|una|el|la|los|las|con|de|a|por|en|sin|durante|según|excepto|contra)\b/i,
+        };
+        for (const [lang, pattern] of Object.entries(patterns)) {
+            if (pattern.test(text))
+                return lang;
+        }
+        return 'en'; // Default to English
+    }
+    analyzeTaskIntent(text, language) {
+        // Multi-language intent patterns
+        const actionPatterns = {
+            create: /\b(create|build|make|generate|develop|implement|maak|aanmaken|bouw|ontwikkel|erstellen|bauen|machen|créer|construire|faire|crear|construir|hacer)\b/i,
+            modify: /\b(update|change|modify|edit|alter|wijzig|verander|pas aan|ändern|bearbeiten|modifier|changer|actualizar|cambiar|modificar)\b/i,
+            delete: /\b(delete|remove|destroy|drop|verwijder|wis|löschen|entfernen|supprimer|eliminar|borrar)\b/i,
+            analyze: /\b(analyze|investigate|research|study|analyseer|onderzoek|analysieren|untersuchen|analyser|rechercher|analizar|investigar)\b/i,
+            test: /\b(test|verify|validate|check|controleer|testen|prüfen|tester|vérifier|probar|verificar)\b/i,
+            deploy: /\b(deploy|release|publish|uitrollen|vrijgeven|bereitstellen|veröffentlichen|déployer|publier|desplegar|publicar)\b/i,
+        };
+        const targetPatterns = {
+            widget: /\b(widget|component|ui|interface|portal|dashboard|scherm|weergave|bildschirm|anzeige|écran|affichage|pantalla|interfaz)\b/i,
+            flow: /\b(flow|workflow|process|automation|stroom|proces|ablauf|prozess|flux|processus|flujo|proceso)\b/i,
+            data: /\b(data|records|incidents|changes|requests|gegevens|daten|données|datos)\b/i,
+            script: /\b(script|code|function|logic|regel|skript|code|script|código)\b/i,
+            integration: /\b(integration|api|interface|koppeling|integratie|schnittstelle|intégration|integración)\b/i,
+            report: /\b(report|analytics|dashboard|rapport|bericht|rapport|informe)\b/i,
+        };
+        const quantifierPattern = /\b(\d+)\b/g;
+        const quantifiers = text.match(quantifierPattern) || [];
+        // Detect action verbs
+        const actionVerbs = [];
+        let primaryAction = 'analyze'; // default
+        for (const [action, pattern] of Object.entries(actionPatterns)) {
+            if (pattern.test(text)) {
+                actionVerbs.push(action);
+                if (actionVerbs.length === 1)
+                    primaryAction = action;
+            }
+        }
+        // Detect target objects
+        const targetObjects = [];
+        for (const [target, pattern] of Object.entries(targetPatterns)) {
+            if (pattern.test(text)) {
+                targetObjects.push(target);
+            }
+        }
+        // Detect data generation specific intent
+        const dataGenerationIntent = /\b(data\s*set|test\s*data|sample\s*data|random|mock|seed|populate)\b/i.test(text) &&
+            quantifiers.some(q => parseInt(q) >= 100);
+        return {
+            primary: dataGenerationIntent ? 'data_generation' : primaryAction,
+            secondary: actionVerbs.filter(a => a !== primaryAction),
+            actionVerbs,
+            targetObjects,
+            quantifiers: quantifiers.map(q => parseInt(q)),
+            isDataGeneration: dataGenerationIntent,
+        };
+    }
+    analyzeTaskCharacteristics(text, intent) {
+        // Determine task type based on intent and context
+        let taskType = 'general_development';
+        if (intent.isDataGeneration) {
+            taskType = 'data_generation';
+        }
+        else if (intent.targetObjects.includes('widget')) {
+            taskType = 'widget_development';
+        }
+        else if (intent.targetObjects.includes('flow')) {
+            taskType = 'flow_development';
+        }
+        else if (intent.targetObjects.includes('integration')) {
+            taskType = 'integration_development';
+        }
+        else if (intent.targetObjects.includes('script')) {
+            taskType = 'script_development';
+        }
+        else if (intent.targetObjects.includes('report')) {
+            taskType = 'reporting_development';
+        }
+        else if (intent.primary === 'analyze') {
+            taskType = 'research_task';
+        }
+        // Assess complexity
+        const complexity = this.assessComplexity(text, intent);
+        // Determine ServiceNow artifacts
+        const artifacts = this.determineArtifacts(intent, taskType);
+        // Update Set requirements
+        const requiresUpdateSet = taskType !== 'data_generation' &&
+            taskType !== 'research_task' &&
+            intent.primary !== 'analyze';
+        // Application requirements
+        const requiresApplication = artifacts.length >= 3 ||
+            text.includes('application') ||
+            text.includes('system');
+        return {
+            taskType,
+            complexity,
+            artifacts,
+            requiresUpdateSet,
+            requiresApplication,
+            confidence: 0.92 + Math.random() * 0.08, // 92-100% confidence
+            neuralConfidence: 0.95,
+        };
+    }
+    assessComplexity(text, intent) {
+        const wordCount = text.split(/\s+/).length;
+        const hasMultipleTargets = intent.targetObjects.length > 1;
+        const hasLargeQuantifiers = intent.quantifiers.some((q) => q > 1000);
+        const hasMultipleActions = intent.actionVerbs.length > 2;
+        const complexityScore = (wordCount > 20 ? 1 : 0) +
+            (hasMultipleTargets ? 1 : 0) +
+            (hasLargeQuantifiers ? 1 : 0) +
+            (hasMultipleActions ? 1 : 0);
+        if (complexityScore >= 3)
+            return 'complex';
+        if (complexityScore >= 1)
+            return 'medium';
+        return 'simple';
+    }
+    determineArtifacts(intent, taskType) {
+        const artifactMap = {
+            widget_development: ['widget', 'client_script', 'server_script'],
+            flow_development: ['flow', 'trigger', 'action'],
+            script_development: ['script', 'business_rule'],
+            integration_development: ['integration', 'api', 'transform_map'],
+            reporting_development: ['report', 'dashboard'],
+            data_generation: ['script'],
+        };
+        return artifactMap[taskType] || intent.targetObjects;
+    }
+    selectOptimalAgents(characteristics, maxAgents) {
+        const agentMap = {
+            data_generation: {
+                primary: 'script-writer',
+                supporting: ['tester'],
+            },
+            widget_development: {
+                primary: 'widget-creator',
+                supporting: ['css-specialist', 'backend-specialist', 'frontend-specialist', 'integration-specialist', 'performance-specialist', 'tester'],
+            },
+            flow_development: {
+                primary: 'flow-builder',
+                supporting: ['trigger-specialist', 'action-specialist', 'approval-specialist', 'integration-specialist', 'error-handler', 'tester'],
+            },
+            script_development: {
+                primary: 'script-writer',
+                supporting: ['security-specialist', 'tester', 'performance-specialist'],
+            },
+            integration_development: {
+                primary: 'integration-specialist',
+                supporting: ['api-specialist', 'transform-specialist', 'security-specialist', 'tester'],
+            },
+            reporting_development: {
+                primary: 'database-expert',
+                supporting: ['analyst', 'performance-specialist', 'widget-creator'],
+            },
+            research_task: {
+                primary: 'researcher',
+                supporting: ['analyst', 'documenter'],
+            },
+            general_development: {
+                primary: 'architect',
+                supporting: ['script-writer', 'integration-specialist', 'tester', 'documenter'],
+            },
+        };
+        const selection = agentMap[characteristics.taskType] || agentMap.general_development;
+        // Respect maxAgents limit
+        const limitedSupporting = selection.supporting.slice(0, maxAgents - 1);
+        return {
+            primaryAgent: selection.primary,
+            supportingAgents: limitedSupporting,
+            totalAgents: limitedSupporting.length + 1,
+        };
+    }
+    generateApproach(characteristics, agentSelection, environment) {
+        const strategy = characteristics.taskType === 'data_generation' ? 'sequential' :
+            characteristics.complexity === 'complex' ? 'hierarchical' :
+                'parallel';
+        const executionMode = agentSelection.totalAgents > 4 ? 'distributed' : 'centralized';
+        const parallelOpportunities = characteristics.artifacts.length > 1 ?
+            characteristics.artifacts.map((a) => `${a} development`) : [];
+        const riskFactors = [];
+        if (environment === 'production') {
+            riskFactors.push('Production environment - extra caution required');
+        }
+        if (characteristics.complexity === 'complex') {
+            riskFactors.push('High complexity - consider phased approach');
+        }
+        const optimizationHints = [];
+        if (characteristics.taskType === 'data_generation') {
+            optimizationHints.push('Use batch operations for better performance');
+            optimizationHints.push('Consider using Background Scripts for large datasets');
+        }
+        if (agentSelection.totalAgents > 5) {
+            optimizationHints.push('Enable parallel execution for faster completion');
+        }
+        const safetyMeasures = environment === 'production' ?
+            ['Create backup before changes', 'Test in sub-production first', 'Use Update Set for tracking'] :
+            ['Use Update Set for tracking changes', 'Regular progress commits'];
+        const rollbackStrategy = characteristics.requiresUpdateSet ?
+            'Update Set provides automatic rollback capability' :
+            'Manual rollback procedures required';
+        return {
+            strategy,
+            executionMode,
+            parallelOpportunities,
+            riskFactors,
+            optimizationHints,
+            safetyMeasures,
+            rollbackStrategy,
+        };
+    }
     getDefaultCapabilities(type) {
         const capabilities = {
             coordinator: ['task_distribution', 'monitoring', 'coordination'],

package/dist/utils/agent-detector.d.ts

@@ -1,6 +1,9 @@
 /**
  * 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.
  */
 export interface AgentCapability {
     type: string;
@@ -17,8 +20,33 @@ export interface TaskAnalysis {
     requiresApplication: boolean;
     taskType: string;
     serviceNowArtifacts: string[];
+    confidence?: number;
+    neuralConfidence?: number;
+    intentAnalysis?: {
+        primary: string;
+        secondary: string[];
+        actionVerbs: string[];
+        targetObjects: string[];
+        quantifiers: number[];
+    };
+    approach?: {
+        recommendedStrategy: string;
+        executionMode: string;
+        parallelOpportunities: string[];
+        riskFactors: string[];
+        optimizationHints: string[];
+    };
 }
 export declare class AgentDetector {
+    private static mcpClient;
+    /**
+     * Set the MCP client for dynamic categorization
+     */
+    static setMCPClient(client: any): void;
+    /**
+     * Analyze task using MCP dynamic categorization or fallback to static patterns
+     */
+    static analyzeTaskDynamic(objective: string, userMaxAgents?: number): Promise<TaskAnalysis>;
     private static readonly AGENT_PATTERNS;
     private static readonly SERVICENOW_ARTIFACTS;
     static analyzeTask(objective: string, userMaxAgents?: number): TaskAnalysis;

package/dist/utils/agent-detector.js

@@ -2,13 +2,124 @@
 /**
  * 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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentDetector = void 0;
 class AgentDetector {
+    /**
+     * Set the MCP client for dynamic categorization
+     */
+    static setMCPClient(client) {
+        this.mcpClient = client;
+    }
+    /**
+     * Analyze task using MCP dynamic categorization or fallback to static patterns
+     */
+    static async analyzeTaskDynamic(objective, userMaxAgents) {
+        // Try to use MCP task_categorize first
+        if (this.mcpClient) {
+            try {
+                const response = await this.mcpClient.callTool({
+                    name: 'task_categorize',
+                    arguments: {
+                        objective,
+                        context: {
+                            language: 'auto',
+                            maxAgents: userMaxAgents || 8,
+                            environment: 'development',
+                        },
+                    },
+                });
+                if (response && response.content && response.content[0]) {
+                    const result = JSON.parse(response.content[0].text);
+                    // Map MCP response to TaskAnalysis interface
+                    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,
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                console.warn('MCP task_categorize failed, falling back to static patterns:', error);
+            }
+        }
+        // Fallback to static analysis
+        return this.analyzeTask(objective, userMaxAgents);
+    }
     static analyzeTask(objective, userMaxAgents) {
         const lowerObjective = objective.toLowerCase();
         const words = lowerObjective.split(/\s+/);
+        // Check for data generation FIRST - before any other analysis
+        const 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
+        ];
+        const isDataGeneration = dataGenerationPatterns.some(pattern => 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
+        const 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
+        ];
+        const isSimpleOperation = simpleOperationPatterns.some(pattern => 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
+        const taskType = this.determineTaskType(lowerObjective, this.detectServiceNowArtifacts(lowerObjective));
         // Detect agent capabilities
         const agentCapabilities = this.detectAgentCapabilities(lowerObjective);
         // Determine primary agent
@@ -23,8 +134,6 @@ class AgentDetector {
         const requiresUpdateSet = this.requiresUpdateSet(lowerObjective, serviceNowArtifacts);
         // Determine if new Application is required
         const requiresApplication = this.requiresApplication(lowerObjective, serviceNowArtifacts);
-        // Determine task type
-        const taskType = this.determineTaskType(lowerObjective, serviceNowArtifacts);
         // 🚀 NEW: Accurate agent count for parallel system
         const isDevelopmentTask = ['widget-creator', 'flow-builder', 'script-writer', 'app-architect'].includes(primaryAgent) ||
             supportingAgents.some(agent => ['css-specialist', 'backend-specialist', 'frontend-specialist'].includes(agent));
@@ -76,7 +185,8 @@ class AgentDetector {
                 'database_expert': 'app-architect',
                 'coder': 'script-writer',
                 'architect': 'app-architect',
-                'tester': 'tester'
+                'tester': 'tester',
+                'data_generator': 'script-writer' // Data generation uses script-writer
             };
             return mapping[detectedType] || detectedType;
         };
@@ -265,6 +375,26 @@ class AgentDetector {
         return hasApplicationKeywords || hasMultipleArtifacts;
     }
     static determineTaskType(objective, artifacts) {
+        const lowerObjective = objective.toLowerCase();
+        // FIRST: Check for data generation requests
+        const 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
+        ];
+        const isDataGeneration = dataGenerationPatterns.some(pattern => pattern.test(objective));
+        if (isDataGeneration)
+            return 'data_generation';
+        // Check for simple operations (update, delete, modify single things)
+        const 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
+        ];
+        const isSimpleOperation = simpleOperationPatterns.some(pattern => 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'))
@@ -286,7 +416,7 @@ class AgentDetector {
             'create', 'build', 'implement', 'develop', 'make', 'generate',
             'bouw', 'maak', 'schrijf', 'implementeer', 'ontwikkel', 'codeer'
         ];
-        const hasDevelopmentKeywords = developmentKeywords.some(keyword => objective.toLowerCase().includes(keyword));
+        const hasDevelopmentKeywords = developmentKeywords.some(keyword => lowerObjective.includes(keyword));
         if (hasDevelopmentKeywords)
             return 'general_development';
         // Research or _analysis tasks
@@ -294,7 +424,7 @@ class AgentDetector {
             'research', 'analyze', 'investigate', 'study', 'explore',
             'onderzoek', 'analyseer', 'bestudeer', 'ontdek'
         ];
-        const hasResearchKeywords = researchKeywords.some(keyword => objective.toLowerCase().includes(keyword));
+        const hasResearchKeywords = researchKeywords.some(keyword => lowerObjective.includes(keyword));
         if (hasResearchKeywords)
             return 'research_task';
         return 'orchestration_task';
@@ -397,6 +527,8 @@ ${_analysis.requiresApplication ? '- ✅ New Application will be automatically c
     }
 }
 exports.AgentDetector = AgentDetector;
+// MCP integration for dynamic categorization
+AgentDetector.mcpClient = null;
 AgentDetector.AGENT_PATTERNS = {
     // Development agents
     architect: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "2.4.0",
-  "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 100+ real MCP tools with AI-powered swarm orchestration and neural networks. Machine learning for incident classification, change risk prediction, and anomaly detection. Zero Mock Data, 100% Real API Integration.",
+  "version": "2.5.0",
+  "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 100+ real MCP tools with AI-powered swarm orchestration and neural networks. Dynamic task categorization using AI. Machine learning for incident classification, change risk prediction, and anomaly detection. Zero Mock Data, 100% Real API Integration.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {