behemoth-cli/src/core/nlp.ts

🌍 BEHEMOTH CLIv3.760.4 - Level 50+ POST-SINGULARITY Intelligence Trading AI

/**
 * Natural Language Processing for conversational command parsing
 * Transforms natural language queries into BEHEMOTH CLI commands
 */

interface ParsedIntent {
	command: string;
	confidence: number;
	originalInput: string;
}

interface TradingPairMapping {
	[key: string]: string;
}

const TRADING_PAIRS: TradingPairMapping = {
	bitcoin: 'BTCUSDT',
	btc: 'BTCUSDT',
	ethereum: 'ETHUSDT',
	ether: 'ETHUSDT',
	eth: 'ETHUSDT',
	solana: 'SOLUSDT',
	sol: 'SOLUSDT',
	cardano: 'ADAUSDT',
	ada: 'ADAUSDT',
	polkadot: 'DOTUSDT',
	dot: 'DOTUSDT',
	chainlink: 'LINKUSDT',
	link: 'LINKUSDT',
	polygon: 'MATICUSDT',
	matic: 'MATICUSDT',
	avalanche: 'AVAXUSDT',
	avax: 'AVAXUSDT',
	dogecoin: 'DOGEUSDT',
	doge: 'DOGEUSDT',
};

const INTENT_PATTERNS = [
	// CRITICAL SAFETY FIX: Orderbook patterns - HIGHEST PRIORITY to prevent trading accidents
	{
		patterns: [
			/(?:get|show|display|fetch|retrieve).*?(?:order.*?book|orderbook|market.*?depth|liquidity)/i,
			/(?:order.*?book|orderbook)(?:.*?for|.*?data|.*?info)?/i,
			/(?:market.*?depth|bid.*?ask.*?spread|liquidity.*?depth|order.*?flow)/i,
			/(?:show.*?bids|show.*?asks|check.*?orderbook|orderbook.*?analysis)/i,
		],
		command: 'orderbook',
		confidence: 0.98, // HIGHEST priority for safety
	},

	// CRITICAL SAFETY FIX: Casual price request patterns - HIGH PRIORITY  
	{
		patterns: [
			/(?:yo|hey|sup)?.*?(?:check|tell me|what is|what's|show me|gimme|get me).*?(?:price|value|worth|cost)/i,
			/(?:quick|fast|real quick).*?(?:price|check|look)/i,
			/(?:current|latest|now).*?(?:price|value|rate)/i,
			/(?:how much|what's).*?(?:worth|cost|trading|going for)/i,
		],
		command: 'casual_price',
		confidence: 0.96, // Very high priority for casual requests
	},

	// MEMORY SYSTEM PATTERNS - HIGH PRIORITY to prevent routing conflicts
	{
		patterns: [
			/^(?:remember|store|save)(?:\s+this)?[\s:]*(.+)/i,
			/(?:store|save|remember).*?(?:insight|analysis|idea|observation|note)/i,
			/(?:memory|memories).*?(?:store|save|add|create)/i,
		],
		command: 'memory',
		confidence: 0.94, // High priority for memory storage
	},
	{
		patterns: [
			/^(?:recall|retrieve|find|search).*?(?:memory|memories|insight|analysis)/i,
			/(?:what did|show me).*?(?:remember|store|save)/i,
			/(?:find|search).*?(?:previous|past|earlier|stored)/i,
			/(?:memory|memories).*?(?:recall|retrieve|find|search|about)/i,
		],
		command: 'memory',
		confidence: 0.94, // High priority for memory recall
	},
	{
		patterns: [
			/(?:memory|memories).*?(?:stats|statistics|list|show|display)/i,
			/(?:show|list|display).*?(?:memory|memories|stored)/i,
			/(?:what.*?stored|what.*?remembered|memory.*?system)/i,
		],
		command: 'memory', 
		confidence: 0.94, // High priority for memory stats
	},

	// Support & Resistance specific patterns
	{
		patterns: [
			/(?:support.*?resistance|resistance.*?support|support.*?levels|resistance.*?levels|sr\b)/i,
			/(?:key.*?levels|price.*?levels|important.*?levels)/i,
			/(?:where.*?support|where.*?resistance|find.*?support|find.*?resistance)/i,
		],
		command: 'support_resistance',
		confidence: 0.95,
	},

	// Cosmic intelligence intents - HIGHER PRIORITY to avoid conflicts
	{
		patterns: [
			/(?:cosmic|planetary|lunar|moon|astro|quantum|sacred geometry)/i,
			/(?:cosmic.*signals|cosmic.*analysis|planetary.*analysis)/i,
			/(?:lunar.*phase|moon.*phase|astro.*trading)/i,
			/(?:quantum.*flux|quantum.*analysis|dimensional.*analysis)/i,
			/(?:cosmic.*timing|energy.*vortex|harmonic.*resonance)/i,
			/(?:sacred.*geometry|golden.*ratio|fibonacci.*cosmic)/i,
		],
		command: 'cosmic',
		confidence: 0.95,
	},

	// Analysis intents - More conversational patterns with enhanced technical analysis detection
	{
		patterns: [
			/(?:analyze|analysis|check|look at|examine|study|tell me about|what about|how is|how's).*?(?:bitcoin|btc|ethereum|eth|solana|sol|cardano|ada|polkadot|dot|chainlink|link|polygon|matic|avalanche|avax|dogecoin|doge)/i,
			/(?:what.*?look.*?like|how.*?doing|price.*?action|technical.*?analysis|chart.*?analysis)/i,
			/(?:rsi|macd|bollinger.*?band|moving.*?average|fibonacci|indicators?)/i,
			/(?:should i|is it good|worth|recommend|opinion).*?(?:bitcoin|btc|ethereum|eth|solana|sol)/i,
			/(?:market.*?analysis|technical.*?view|chart.*?reading)/i,
			/(?:ma\b|sma|ema|bb\b|fib)/i,
		],
		command: 'analyze',
		confidence: 0.9,
	},

	// Trading intents - More natural language
	{
		patterns: [
			/(?:buy|purchase|long|go.*?long|invest in|get some).*?(?:bitcoin|btc|ethereum|eth|solana|sol)/i,
			/(?:sell|short|go.*?short|dump|exit).*?(?:bitcoin|btc|ethereum|eth|solana|sol)/i,
			/(?:trade|trading|position|order|execute|place.*?order)/i,
			/(?:should i buy|should i sell|good time to|when to)/i,
			/(?:entry.*?point|exit.*?strategy|take.*?profit|stop.*?loss)/i,
		],
		command: 'trade',
		confidence: 0.8,
	},

	// Portfolio & Risk intents - More conversational
	{
		patterns: [
			/(?:portfolio|risk|position.*?size|allocation|balance|my.*?holdings)/i,
			/(?:how.*?much|what.*?size|calculate.*?risk|risk.*?management)/i,
			/(?:diversification|asset.*?allocation|portfolio.*?balance)/i,
			/(?:safe|risky|conservative|aggressive).*?(?:strategy|approach|investment)/i,
			/(?:what.*?percentage|how.*?allocate|split.*?portfolio)/i,
		],
		command: 'risk',
		confidence: 0.7,
	},

	// Market data intents - More natural queries (orderbook patterns moved to dedicated intent above)
	{
		patterns: [
			/(?:price|ticker|current.*?value|market.*?data|quote)/i,
			/(?:volume|funding.*?rate|24h.*?data)/i,
			/(?:what.*?price|how.*?much|current.*?rate|market.*?cap)/i,
			/(?:trading.*?volume|24h.*?volume|daily.*?volume)/i,
			/(?:spread|bid.*?ask)(?!.*?depth|.*?book)/i, // Only spread patterns, not depth/book
		],
		command: 'ticker',
		confidence: 0.75, // Lowered to avoid conflicts with higher priority patterns
	},

	// Sentiment intents - More emotional language
	{
		patterns: [
			/(?:sentiment|feeling|mood|social|news|fear.*?greed|market.*?emotion)/i,
			/(?:bullish|bearish|market.*?sentiment|investor.*?sentiment)/i,
			/(?:optimistic|pessimistic|confident|worried|nervous)/i,
			/(?:fomo|fud|hype|excitement|panic)/i,
			/(?:social.*?media|twitter|reddit|community.*?feeling)/i,
		],
		command: 'sentiment',
		confidence: 0.8,
	},

	// System intents - More casual language
	{
		patterns: [
			/(?:system|health|status|performance|uptime|working)/i,
			/(?:how.*?running|everything.*?working|all.*?good|system.*?ok)/i,
			/(?:connection|api.*?status|server.*?status|online)/i,
			/(?:check.*?system|diagnostic|test.*?connection)/i,
		],
		command: 'system_health',
		confidence: 0.9,
	},

	// Greeting and conversational intents
	{
		patterns: [
			/^(?:hi|hello|hey|good morning|good afternoon|good evening|what's up|sup)/i,
			/^(?:how are you|how's it going|what's happening)/i,
		],
		command: 'greeting',
		confidence: 0.95,
	},

	// Memory and learning intents
	{
		patterns: [
			/(?:remember|store|save|memory|recall|retrieve)/i,
			/(?:memory system|behemoth memory|store.*insight|remember.*that)/i,
			/(?:list.*memories|show.*memories|what.*remember)/i,
			/(?:forget|delete.*memory|clear.*memory)/i,
		],
		command: 'memory',
		confidence: 0.95,
	},

	// Help and guidance intents
	{
		patterns: [
			/(?:help|assist|guide|tutorial|how to|explain|what can you do)/i,
			/(?:commands|features|capabilities|functions)/i,
			/(?:getting started|new user|beginner)/i,
		],
		command: 'help',
		confidence: 0.9,
	},


	// Advanced trading intents
	{
		patterns: [
			/(?:arbitrage|cross.*exchange|delta.*neutral|pairs.*trading)/i,
			/(?:momentum.*breakout|mean.*reversion|volume.*profile)/i,
			/(?:order.*flow|market.*microstructure|liquidity.*hunting)/i,
			/(?:whale.*movement|institutional.*flow|dark.*pool)/i,
		],
		command: 'advanced_trading',
		confidence: 0.8,
	},

	// Adaptive learning intents - HIGH PRIORITY for machine learning operations
	{
		patterns: [
			/(?:learn|train).*?(?:pattern|patterns|data|model|behavior)/i,
			/(?:pattern|patterns).*?(?:learn|training|machine.*?learning)/i,
			/(?:reinforcement.*?learning|rl\b|sac|td3|maml)/i,
			/(?:train.*?on.*?data|learn.*?from.*?data|pattern.*?learning)/i,
			/(?:machine.*?learning.*?pattern|ml.*?pattern|pattern.*?recognition)/i,
		],
		command: 'adaptive_learning',
		confidence: 0.94,
	},
	{
		patterns: [
			/(?:analyze|analysis).*?(?:behavior|behavioral|user.*?behavior)/i,
			/(?:behavior|behavioral).*?(?:analyze|analysis|pattern|patterns)/i,
			/(?:user.*?pattern|session.*?analysis|behavioral.*?analysis)/i,
			/(?:analyze.*?my.*?behavior|my.*?trading.*?behavior|behavior.*?tracking)/i,
			/(?:behavioral.*?insights|behavior.*?detection)/i,
		],
		command: 'behavior_analysis',
		confidence: 0.93,
	},
	{
		patterns: [
			/(?:adapt|optimize|improve).*?(?:strategy|strategies|approach|method)/i,
			/(?:strategy|strategies).*?(?:adapt|adaptation|optimize|optimization)/i,
			/(?:strategy.*?tuning|parameter.*?optimization|approach.*?improvement)/i,
			/(?:optimize.*?my.*?strategy|improve.*?trading.*?strategy|adapt.*?approach)/i,
			/(?:strategy.*?evolution|dynamic.*?strategy)/i,
		],
		command: 'strategy_adaptation',
		confidence: 0.93,
	},
	{
		patterns: [
			/(?:safety|safe|safety.*?check|constitutional|constitution|ai.*?safety)/i,
			/(?:check.*?safety|verify.*?safety|safety.*?review|ethical.*?check)/i,
			/(?:constitutional.*?ai|constitutional.*?check|safety.*?assessment)/i,
			/(?:harmless|harmful|bias.*?check|fairness.*?check)/i,
			/(?:alignment.*?check|safety.*?validation)/i,
		],
		command: 'constitutional_safety',
		confidence: 0.95,
	},
	{
		patterns: [
			/(?:neural|architecture).*?(?:search|optimization|optimize)/i,
			/(?:neural.*?architecture.*?search|nas\b|architecture.*?optimization)/i,
			/(?:optimize.*?neural|optimize.*?network|network.*?optimization)/i,
			/(?:hyperparameter.*?search|hyperparameter.*?optimization|neural.*?tuning)/i,
			/(?:architecture.*?search|search.*?architecture|neural.*?design)/i,
		],
		command: 'neural_optimization',
		confidence: 0.93,
	},

	// n8n workflow automation intents
	{
		patterns: [
			/(?:n8n|workflow|deploy.*?workflow|configure.*?n8n|list.*?workflows|create.*?workflow|run.*?workflow)/i,
			/(?:build.*?automation|setup.*?alert|crypto.*?alert|smart.*?alert)/i,
			/(?:integrate.*?n8n|use.*?n8n|deploy.*?crypto.*?system)/i,
			/(?:workflow.*?generation|generate.*?workflow|build.*?workflow)/i,
			/(?:automate.*?trading|automate.*?monitoring|automate.*?alerts)/i,
			/(?:validate.*?workflow|test.*?workflow|check.*?workflow)/i,
			/(?:supercode|javascript.*?node|code.*?generation)/i,
			/(?:schedule.*?workflow|webhook.*?workflow|trigger.*?workflow)/i,
		],
		command: 'n8n',
		confidence: 0.9,
	},

	// Intelligence module intents for AI methodology routing - HIGHER PRIORITY
	{
		patterns: [
			/(?:use|apply|implement).*?(?:dspy|bmad|autoexpert|synapse).*?(?:optimization|optimize|workflow|methodology)/i,
			/(?:route.*?(?:my|this|the).*?(?:ada|cardano|eth|ethereum|btc|bitcoin|sol|solana).*?(?:analysis|request).*?(?:to|via).*?(?:best|ai|methodology|intelligence|expert))/i,
			/(?:professor.*?synapse|synapse.*?reason|expert.*?reasoning)/i,
			/(?:multi.*?expert|expert.*?collaboration|reasoning.*?chain)/i,
			/(?:bmad.*?workflow|meta.*?framework|optimization.*?workflow)/i,
			/(?:autoexpert.*?optimize|chain.*?refinement|expert.*?optimization)/i,
			/(?:dspy.*?optimize|optimization.*?pipeline|pipeline.*?optimization)/i,
			/(?:route.*?request|methodology.*?routing|ai.*?routing)/i,
			/(?:intelligence.*?system|expert.*?system|reasoning.*?system)/i,
		],
		command: 'intelligence',
		confidence: 0.97, // Much higher than analyze (0.9) to ensure precedence
	},

	// Pattern detection intents for chart patterns and formations
	{
		patterns: [
			/(?:pattern.*?detection|detect.*?pattern|find.*?pattern)/i,
			/(?:chart.*?pattern|price.*?pattern|candlestick.*?pattern)/i,
			/(?:head.*?shoulder|double.*?top|double.*?bottom|triangle)/i,
			/(?:flag.*?pattern|pennant|wedge|channel)/i,
			/(?:harmonic.*?pattern|gartley|butterfly|crab|bat)/i,
			/(?:elliott.*?wave|wave.*?pattern|impulse.*?wave)/i,
			/(?:support.*?resistance|trend.*?line|breakout)/i,
		],
		command: 'pattern_detection',
		confidence: 0.85,
	},

	// Market overview intents
	{
		patterns: [
			/(?:market.*?overview|overall.*?market|crypto.*?market|market.*?summary)/i,
			/(?:what's.*?happening|market.*?update|daily.*?summary)/i,
			/(?:top.*?coins|best.*?performers|worst.*?performers)/i,
		],
		command: 'market_overview',
		confidence: 0.85,
	},
	{
		patterns: [
			/(?:arbitrage|cross.*exchange|delta.*neutral|pairs.*trading)/i,
			/(?:momentum.*breakout|mean.*reversion|volume.*profile)/i,
			/(?:order.*flow|market.*microstructure|liquidity.*hunting)/i,
			/(?:whale.*movement|institutional.*flow|dark.*pool)/i,
			/(?:machine.*learning|lstm|neural.*network|ai.*prediction)/i,
			/(?:risk.*management|var|portfolio.*optimization)/i,
		],
		command: 'advanced_analysis',
		confidence: 0.8,
	},
	{
		patterns: [
			/(?:lstm|neural.*network|deep.*learning|ai.*prediction)/i,
			/(?:transformer|reinforcement.*learning|ensemble)/i,
			/(?:machine.*learning|ml.*prediction|artificial.*intelligence)/i,
			/(?:autoencoder|gan|attention.*mechanism)/i,
		],
		command: 'ml_analysis',
		confidence: 0.85,
	},
	{
		patterns: [
			/(?:uniswap|aave|compound|sushiswap|curve|yearn)/i,
			/(?:defi|yield.*farm|liquidity.*pool|dex)/i,
			/(?:opensea|nft|web3|smart.*contract|gas.*price)/i,
			/(?:mempool|wallet.*portfolio|ens.*domain)/i,
		],
		command: 'defi_web3_analysis',
		confidence: 0.8,
	},
	{
		patterns: [
			/(?:real.*time|streaming|low.*latency|high.*frequency)/i,
			/(?:tick.*data|microsecond|hft|instant.*alert)/i,
			/(?:live.*pnl|real.*time.*risk|streaming.*data)/i,
		],
		command: 'realtime_analysis',
		confidence: 0.85,
	},
	{
		patterns: [
			/(?:risk.*management|var|cvar|drawdown|sharpe.*ratio|kelly.*criterion)/i,
			/(?:portfolio.*optimization|correlation.*matrix|risk.*parity|black.*litterman)/i,
			/(?:monte.*carlo|stress.*test)/i,
		],
		command: 'risk_analysis',
		confidence: 0.8,
	},
	{
		patterns: [
			/(?:system.*adaptation|adaptive.*optimization|neural.*evolution|genetic.*algorithm)/i,
			/(?:performance.*auto.*analyzer|latency.*auto.*optimizer|cosmic.*strength.*enhancer)/i,
			/(?:strategy.*auto.*selector|parameter.*auto.*tuner|feedback.*loop.*optimizer)/i,
			/(?:adaptive.*learning.*engine|self.*healing.*monitor|auto.*scaling.*controller)/i,
			/(?:dynamic.*threshold.*adjuster|performance.*predictor|optimization.*scheduler)/i,
			/(?:adaptive.*risk.*manager)/i,
		],
		command: 'system_adaptation',
		confidence: 0.8,
	},
	{
		patterns: [
			/(?:market.*structure|dark.*pool.*detection|institutional.*flow|retail.*sentiment)/i,
			/(?:smart.*money.*detector|accumulation.*distribution|volume.*spread.*analysis)/i,
			/(?:market.*maker.*behavior|order.*book.*dynamics)/i,
		],
		command: 'market_structure_analysis',
		confidence: 0.8,
	},
];

/**
 * Extract trading pair(s) from natural language input
 * Returns string for single pair, array for multiple pairs
 */
function extractTradingPair(input: string): string | string[] {
	const normalizedInput = input.toLowerCase();
	const foundPairs: string[] = [];

	// Direct pair mentions (BTC-USDT, BTC/USDT, BTCUSDT)
	const pairMatches = normalizedInput.matchAll(/([a-z]{2,10})[-\/]?usdt?/gi);
	for (const match of pairMatches) {
		const pair = `${match[1].toUpperCase()}USDT`;
		if (!foundPairs.includes(pair)) {
			foundPairs.push(pair);
		}
	}

	// Coin name matches
	for (const [coinName, pair] of Object.entries(TRADING_PAIRS)) {
		if (normalizedInput.includes(coinName) && !foundPairs.includes(pair)) {
			foundPairs.push(pair);
		}
	}

	// Enhanced multi-asset detection with better comma handling
	const hasMultiAssetIndicators = /(?:and|plus|,\s*|&|\+|vs|versus|compare)/.test(normalizedInput);
	
	// Handle comma-separated lists more aggressively
	const commaMatches = normalizedInput.match(/\b([a-z]{2,10})\s*,\s*([a-z]{2,10})/gi);
	if (commaMatches && commaMatches.length > 0) {
		// Force multi-asset mode for comma patterns
		for (const match of commaMatches) {
			const parts = match.split(/\s*,\s*/);
			for (const part of parts) {
				const trimmed = part.trim().toLowerCase();
				if (TRADING_PAIRS[trimmed] && !foundPairs.includes(TRADING_PAIRS[trimmed])) {
					foundPairs.push(TRADING_PAIRS[trimmed]);
				}
			}
		}
	}
	
	if (foundPairs.length === 0) {
		// Default to BTC if no specific pair found
		return 'BTCUSDT';
	} else if (foundPairs.length === 1 || !hasMultiAssetIndicators) {
		// Single pair or no multi-asset indicators
		return foundPairs[0];
	} else {
		// Multiple pairs found with multi-asset indicators
		return foundPairs;
	}
}

/**
 * Extract multiple trading pairs from natural language input  
 * Always returns array for consistency in multi-asset handling
 */
function extractMultipleTradingPairs(input: string): string[] {
	const result = extractTradingPair(input);
	return Array.isArray(result) ? result : [result];
}

/**
 * Extract amount/quantity from trading commands
 */
function extractAmount(input: string): string | null {
	// Look for patterns like "buy 2 ETH", "$1000 worth", "100 dollars"
	const amountPatterns = [
		/(?:buy|sell|trade)\s+(\d+(?:\.\d+)?)\s/i,
		/\$(\d+(?:,\d{3})*(?:\.\d+)?)/,
		/(\d+(?:\.\d+)?)\s*(?:dollars?|usd)/i,
	];

	for (const pattern of amountPatterns) {
		const match = input.match(pattern);
		if (match) {
			return match[1].replace(',', '');
		}
	}

	return null;
}

/**
 * Extract risk level from input
 */
function extractRiskLevel(input: string): string {
	const riskPatterns = {
		low: /(?:low|conservative|safe|minimal).*?risk/i,
		medium: /(?:medium|moderate|balanced).*?risk/i,
		high: /(?:high|aggressive|maximum).*?risk/i,
	};

	for (const [level, pattern] of Object.entries(riskPatterns)) {
		if (pattern.test(input)) {
			return level;
		}
	}

	return 'medium'; // default
}

/**
 * Extract exchange names from user input
 */
function extractExchanges(input: string): string[] {
	const exchanges: string[] = [];
	const text = input.toLowerCase();

	if (text.includes('binance')) exchanges.push('binance');
	if (text.includes('bybit')) exchanges.push('bybit');
	if (text.includes('bitget')) exchanges.push('bitget');

	// If no specific exchange mentioned, default to binance
	if (exchanges.length === 0) exchanges.push('binance');

	return exchanges;
}

/**
 * Main NLP parser - converts natural language to CLI commands
 */
export async function parseNaturalLanguage(
	input: string,
): Promise<ParsedIntent> {
	const normalizedInput = input.toLowerCase().trim();

	// Skip if already a command
	if (input.startsWith('/')) {
		return {
			command: input,
			confidence: 1.0,
			originalInput: input,
		};
	}

	let bestMatch = {command: input, confidence: 0.0, originalInput: input};

	// Find best matching intent
	for (const intent of INTENT_PATTERNS) {
		for (const pattern of intent.patterns) {
			if (pattern.test(input)) {
				if (intent.confidence > bestMatch.confidence) {
					bestMatch = {
						command: intent.command,
						confidence: intent.confidence,
						originalInput: input,
					};
				}
			}
		}
	}

	// If no intent found with sufficient confidence, return original
	if (bestMatch.confidence < 0.6) {
		return bestMatch;
	}

	// Build command with extracted parameters
	const tradingPairResult = extractTradingPair(input);
	const tradingPairs = Array.isArray(tradingPairResult) ? tradingPairResult : [tradingPairResult];
	const isMultiAsset = Array.isArray(tradingPairResult);
	const tradingPair = tradingPairs[0]; // Use first pair for backward compatibility
	const amount = extractAmount(input);
	const riskLevel = extractRiskLevel(input);

	let command = '';
	let commands: string[] = []; // For multi-asset support

	switch (bestMatch.command) {
		case 'orderbook':
			// CRITICAL SAFETY FIX: Dedicated orderbook routing
			command = `trading_get_orderbook --symbol=${tradingPair} --limit=50`;
			break;

		case 'casual_price':
			// CRITICAL SAFETY FIX: Casual price requests go to ticker, not technical analysis
			// MULTI-ASSET SUPPORT: Handle multiple symbols in one request
			const exchanges = extractExchanges(input);
			let marketType = 'futures';
			if (/spot/i.test(input)) marketType = 'spot';
			
			if (isMultiAsset) {
				// Generate multiple commands for multi-asset requests
				for (const pair of tradingPairs) {
					let singleCommand = '';
					if (exchanges.includes('binance')) {
						singleCommand = `/exchange_ticker --exchange=binance --symbol=${pair} --market_type=${marketType}`;
					} else if (exchanges.includes('bitget')) {
						singleCommand = `/exchange_ticker --exchange=bitget --symbol=${pair} --market_type=${marketType}`;
					} else {
						singleCommand = `/exchange_ticker --exchange=bybit --symbol=${pair} --market_type=${marketType}`;
					}
					commands.push(singleCommand);
				}
				command = commands.join(' && '); // Execute multiple commands
			} else {
				// Single asset request
				if (exchanges.includes('binance')) {
					command = `/exchange_ticker --exchange=binance --symbol=${tradingPair} --market_type=${marketType}`;
				} else if (exchanges.includes('bitget')) {
					command = `/exchange_ticker --exchange=bitget --symbol=${tradingPair} --market_type=${marketType}`;
				} else {
					command = `/exchange_ticker --exchange=bybit --symbol=${tradingPair} --market_type=${marketType}`;
				}
			}
			break;

		case 'support_resistance':
			command = `/pattern_analysis --pattern_type=support_resistance --symbol=${tradingPair}`;
			break;

		case 'analyze':
			// MULTI-ASSET SUPPORT: Check if this is a price analysis request first
			if (/(?:price|prices).*?(?:together|compare|vs|versus)/i.test(input) && isMultiAsset) {
				// Multi-asset price analysis - generate multiple ticker commands
				for (const pair of tradingPairs) {
					const singleCommand = `/exchange_ticker --exchange=binance --symbol=${pair} --market_type=futures`;
					commands.push(singleCommand);
				}
				command = commands.join(' && ');
			} else if (/moving.*?average|ma\b|sma|ema/i.test(input)) {
				if (isMultiAsset) {
					for (const pair of tradingPairs) {
						commands.push(`/technical_indicator --indicator=moving_averages --symbol=${pair}`);
					}
					command = commands.join(' && ');
				} else {
					command = `/technical_indicator --indicator=moving_averages --symbol=${tradingPair}`;
				}
			} else if (/bollinger.*?band|bb\b/i.test(input)) {
				if (isMultiAsset) {
					for (const pair of tradingPairs) {
						commands.push(`/technical_indicator --indicator=bollinger_bands --symbol=${pair}`);
					}
					command = commands.join(' && ');
				} else {
					command = `/technical_indicator --indicator=bollinger_bands --symbol=${tradingPair}`;
				}
			} else if (/macd/i.test(input)) {
				command = `/technical_indicator --indicator=macd --symbol=${tradingPair}`;
			} else if (/trend.*?analysis|trend/i.test(input)) {
				command = `/pattern_analysis --pattern_type=trend_analysis --symbol=${tradingPair}`;
			} else if (
				/support.*?resistance|support.*?levels|resistance.*?levels|sr\b/i.test(
					input,
				)
			) {
				command = `/pattern_analysis --pattern_type=support_resistance --symbol=${tradingPair}`;
			} else if (/momentum/i.test(input)) {
				command = `/technical_indicator --indicator=momentum --symbol=${tradingPair}`;
			} else if (/volatility/i.test(input)) {
				command = `/technical_indicator --indicator=volatility --symbol=${tradingPair}`;
			} else if (/candlestick.*?pattern|candle.*?pattern/i.test(input)) {
				command = `/pattern_analysis --pattern_type=candlestick_patterns --symbol=${tradingPair}`;
			} else if (/fibonacci|fib/i.test(input)) {
				command = `/pattern_analysis --pattern_type=fibonacci --symbol=${tradingPair}`;
			} else if (/adx|average.*directional/i.test(input)) {
				command = `/technical_indicator --indicator=adx --symbol=${tradingPair}`;
			} else if (/atr|average.*true.*range/i.test(input)) {
				command = `/technical_indicator --indicator=atr --symbol=${tradingPair}`;
			} else if (/pivot.*points/i.test(input)) {
				command = `/pattern_analysis --pattern_type=pivot_points --symbol=${tradingPair}`;
			} else if (/ichimoku/i.test(input)) {
				command = `/pattern_analysis --pattern_type=ichimoku --symbol=${tradingPair}`;
			} else if (/cosmic|planetary|lunar|quantum|astro/i.test(input)) {
				command = `/cosmic_analysis --analysis_type=planetary --symbol=${tradingPair}`;
			} else if (/master.*?analysis|comprehensive|complete/i.test(input)) {
				command = `/fr3k_analysis --analysis_type=fr3k_master_analysis --symbol=${tradingPair}`;
			} else {
				// Default to RSI only if no specific pattern matches
				command = `/technical_indicator --indicator=rsi --symbol=${tradingPair}`;
			}
			break;

		case 'trade':
			// CRITICAL SAFETY FIX: Add safety confirmations and analysis-only mode for trading
			const action = /(?:buy|purchase|long)/i.test(input) ? 'buy' : 'sell';
			
			// Instead of executing trades, provide analysis and require explicit confirmation
			command = `/trading_analyze_entry_exit --action=${action} --symbol=${tradingPair} --analysis_mode=safety_check`;
			if (amount) command += ` --amount=${amount}`;
			
			// Add safety note in command to remind user this is analysis only
			command += ` --note="ANALYSIS_ONLY_NO_EXECUTION_USE_EXPLICIT_TRADE_COMMAND_TO_EXECUTE"`;
			break;

		case 'risk':
			command = `/risk --symbol=${tradingPair} --level=${riskLevel}`;
			if (amount) command += ` --portfolio=${amount}`;
			break;

		case 'ticker':
			// MULTI-ASSET SUPPORT: Handle multiple symbols in ticker requests
			const tickerExchanges = extractExchanges(input);
			let tickerMarketType = 'futures'; // Default to futures
			if (/spot/i.test(input)) {
				tickerMarketType = 'spot';
			} else if (/futures/i.test(input)) {
				tickerMarketType = 'futures';
			}
			
			if (isMultiAsset) {
				// Generate multiple commands for multi-asset requests
				for (const pair of tradingPairs) {
					let singleCommand = '';
					if (tickerExchanges.includes('binance')) {
						singleCommand = `/exchange_ticker --exchange=binance --symbol=${pair} --market_type=${tickerMarketType}`;
					} else if (tickerExchanges.includes('bitget')) {
						singleCommand = `/exchange_ticker --exchange=bitget --symbol=${pair} --market_type=${tickerMarketType}`;
					} else {
						singleCommand = `/exchange_ticker --exchange=bybit --symbol=${pair} --market_type=${tickerMarketType}`;
					}
					commands.push(singleCommand);
				}
				command = commands.join(' && '); // Execute multiple commands
			} else {
				// Single asset request
				if (tickerExchanges.includes('binance')) {
					command = `/exchange_ticker --exchange=binance --symbol=${tradingPair} --market_type=${tickerMarketType}`;
				} else if (tickerExchanges.includes('bitget')) {
					command = `/exchange_ticker --exchange=bitget --symbol=${tradingPair} --market_type=${tickerMarketType}`;
				} else {
					command = `/exchange_ticker --exchange=bybit --symbol=${tradingPair} --market_type=${tickerMarketType}`;
				}
			}
			break;

		case 'sentiment':
			// Use the actual MCP tool name for market sentiment analysis
			command = `trading_analyze_market_sentiment --symbol=${tradingPair} --exchange=bybit`;
			break;

		case 'system_health':
			command = `/system_monitoring --monitor_type=system_health`;
			break;

		case 'greeting':
			command = `/help`;
			break;

		case 'help':
			command = `/help`;
			break;

		case 'market_overview':
			command = `market_mood`;
			break;

		case 'memory':
			// Memory commands using unified MCP server memory tools
			if (/(?:remember|store|save)/.test(input)) {
				command = `memory_store_memory --content="${input}" --context={"type":"user_request","source":"nlp"} --importance=7 --tags=["nlp_generated","user_insight"]`;
			} else if (/(?:recall|retrieve|find)/.test(input)) {
				command = `memory_recall_memory --query="${input}" --limit=5 --min_relevance=0.3`;
			} else if (/(?:stats|statistics|list|show).*?(?:memory|memories)/.test(input)) {
				command = `memory_memory_stats --detailed=true`;
			} else if (/(?:reflect|insights?)/.test(input)) {
				command = `memory_reflect_on_memory --reflection_type=insight`;
			} else {
				command = `memory_store_memory --content="${input}" --context={"type":"user_request","source":"nlp"} --importance=7 --tags=["nlp_generated","user_insight"]`;
			}
			break;

		case 'cosmic':
			if (/planetary/i.test(input)) {
				command = `cosmic_planetary_analysis --symbol=${tradingPair}`;
			} else if (/lunar|moon/i.test(input)) {
				command = `cosmic_lunar_cycle_analysis --symbol=${tradingPair}`;
			} else if (/quantum/i.test(input)) {
				command = `cosmic_quantum_entanglement --symbol=${tradingPair}`;
			} else if (/sacred.*geometry/i.test(input)) {
				command = `cosmic_sacred_geometry --symbol=${tradingPair}`;
			} else {
				command = `cosmic_planetary_analysis --symbol=${tradingPair}`;
			}
			break;

		case 'advanced_trading':
			if (/arbitrage/i.test(input)) {
				command = `/trading_strategy --strategy_type=cross_exchange_arbitrage --symbol=${tradingPair}`;
			} else if (/momentum.*breakout/i.test(input)) {
				command = `/trading_strategy --strategy_type=momentum_breakout --symbol=${tradingPair}`;
			} else if (/whale/i.test(input)) {
				command = `/market_microstructure --analysis_type=whale_movement_tracker --symbol=${tradingPair}`;
			} else if (/institutional/i.test(input)) {
				command = `/market_microstructure --analysis_type=institutional_flow_detector --symbol=${tradingPair}`;
			} else {
				command = `/volume_analysis --volume_type=order_flow --symbol=${tradingPair}`;
			}
			break;

		case 'advanced_analysis':
			if (/arbitrage/i.test(input)) {
				command = `/trading_strategy --strategy_type=cross_exchange_arbitrage --symbol=${tradingPair}`;
			} else if (/whale/i.test(input)) {
				command = `/market_microstructure --analysis_type=whale_movement_tracker --symbol=${tradingPair}`;
			} else if (/dark.*pool/i.test(input)) {
				command = `/market_microstructure --analysis_type=dark_pool_analyzer --symbol=${tradingPair}`;
			} else if (/momentum.*breakout/i.test(input)) {
				command = `/trading_strategy --strategy_type=momentum_breakout --symbol=${tradingPair}`;
			} else if (/mean.*reversion/i.test(input)) {
				command = `/trading_strategy --strategy_type=mean_reversion --symbol=${tradingPair}`;
			} else if (/statistical.*arbitrage/i.test(input)) {
				command = `/trading_strategy --strategy_type=statistical_arbitrage --symbol=${tradingPair}`;
			} else if (/pairs.*trading/i.test(input)) {
				command = `/trading_strategy --strategy_type=pairs_trading --symbol=${tradingPair}`;
			} else if (/volatility.*surface/i.test(input)) {
				command = `/trading_strategy --strategy_type=volatility_surface_analyzer --symbol=${tradingPair}`;
			} else if (/gamma.*exposure/i.test(input)) {
				command = `/trading_strategy --strategy_type=gamma_exposure_tracker --symbol=${tradingPair}`;
			} else if (/delta.*hedging/i.test(input)) {
				command = `/trading_strategy --strategy_type=delta_hedging --symbol=${tradingPair}`;
			} else if (/liquidity.*hunting/i.test(input)) {
				command = `/market_microstructure --analysis_type=liquidity_hunting_algo --symbol=${tradingPair}`;
			} else if (/institutional.*flow/i.test(input)) {
				command = `/market_microstructure --analysis_type=institutional_flow_detector --symbol=${tradingPair}`;
			} else if (/options.*flow/i.test(input)) {
				command = `/market_microstructure --analysis_type=options_flow_monitor --symbol=${tradingPair}`;
			} else if (/futures.*basis/i.test(input)) {
				command = `/market_microstructure --analysis_type=futures_basis_trader --symbol=${tradingPair}`;
			} else if (/funding.*rate.*arbitrage/i.test(input)) {
				command = `/market_microstructure --analysis_type=funding_rate_arbitrage --symbol=${tradingPair}`;
			}
			break;

		case 'ml_analysis':
			if (/lstm/i.test(input)) {
				command = `/ml_prediction --model_type=lstm_price_predictor --symbol=${tradingPair}`;
			} else if (/neural.*network/i.test(input)) {
				command = `/ml_prediction --model_type=neural_network_optimizer --symbol=${tradingPair}`;
			} else if (/transformer/i.test(input)) {
				command = `/ml_prediction --model_type=transformer_pattern_recognition --symbol=${tradingPair}`;
			} else if (/reinforcement.*learning/i.test(input)) {
				command = `/ml_prediction --model_type=reinforcement_learning_trader --symbol=${tradingPair}`;
			} else if (/deep.*learning/i.test(input)) {
				command = `/ml_prediction --model_type=deep_learning_analyzer --symbol=${tradingPair}`;
			} else if (/ensemble.*model/i.test(input)) {
				command = `/ml_prediction --model_type=ensemble_model_predictor --symbol=${tradingPair}`;
			} else if (/gradient.*boosting/i.test(input)) {
				command = `/ml_prediction --model_type=gradient_boosting_signals --symbol=${tradingPair}`;
			} else if (/random.*forest/i.test(input)) {
				command = `/ml_prediction --model_type=random_forest_classifier --symbol=${tradingPair}`;
			} else if (/svm|support.*vector/i.test(input)) {
				command = `/ml_prediction --model_type=svm_trend_detector --symbol=${tradingPair}`;
			} else if (/autoencoder.*anomaly/i.test(input)) {
				command = `/ai_analysis --ai_type=autoencoder_anomaly_detector --symbol=${tradingPair}`;
			} else if (/gan|synthetic.*data/i.test(input)) {
				command = `/ai_analysis --ai_type=gan_synthetic_data --symbol=${tradingPair}`;
			} else if (/attention.*mechanism/i.test(input)) {
				command = `/ai_analysis --ai_type=attention_mechanism_analyzer --symbol=${tradingPair}`;
			} else if (/federated.*learning/i.test(input)) {
				command = `/ai_analysis --ai_type=federated_learning_coordinator --symbol=${tradingPair}`;
			} else if (/transfer.*learning/i.test(input)) {
				command = `/ai_analysis --ai_type=transfer_learning_adapter --symbol=${tradingPair}`;
			} else if (/active.*learning/i.test(input)) {
				command = `/ai_analysis --ai_type=active_learning_selector --symbol=${tradingPair}`;
			} else if (/meta.*learning/i.test(input)) {
				command = `/ai_analysis --ai_type=meta_learning_optimizer --symbol=${tradingPair}`;
			} else if (/continual.*learning/i.test(input)) {
				command = `/ai_analysis --ai_type=continual_learning_engine --symbol=${tradingPair}`;
			} else if (/multimodal.*fusion/i.test(input)) {
				command = `/ai_analysis --ai_type=multimodal_fusion_analyzer --symbol=${tradingPair}`;
			}
			break;

		case 'defi_web3_analysis':
			if (/uniswap/i.test(input)) {
				command = `/defi_analysis --protocol=uniswap_liquidity_analyzer --symbol=${tradingPair}`;
			} else if (/aave/i.test(input)) {
				command = `/defi_analysis --protocol=aave_lending_optimizer --symbol=${tradingPair}`;
			} else if (/compound/i.test(input)) {
				command = `/defi_analysis --protocol=compound_yield_farmer --symbol=${tradingPair}`;
			} else if (/sushiswap/i.test(input)) {
				command = `/defi_analysis --protocol=sushiswap_arbitrage_finder --symbol=${tradingPair}`;
			} else if (/curve/i.test(input)) {
				command = `/defi_analysis --protocol=curve_pool_analyzer --symbol=${tradingPair}`;
			} else if (/yearn/i.test(input)) {
				command = `/defi_analysis --protocol=yearn_vault_tracker --symbol=${tradingPair}`;
			} else if (/pancakeswap/i.test(input)) {
				command = `/defi_analysis --protocol=pancakeswap_sniper_bot --symbol=${tradingPair}`;
			} else if (/balancer/i.test(input)) {
				command = `/defi_analysis --protocol=balancer_pool_optimizer --symbol=${tradingPair}`;
			} else if (/dydx/i.test(input)) {
				command = `/defi_analysis --protocol=dydx_margin_trader --symbol=${tradingPair}`;
			} else if (/gmx/i.test(input)) {
				command = `/defi_analysis --protocol=gmx_perp_analyzer --symbol=${tradingPair}`;
			} else if (/opensea|nft/i.test(input)) {
				command = `/web3_tools --tool_type=opensea_floor_tracker`;
			} else if (/rarity/i.test(input)) {
				command = `/web3_tools --tool_type=nft_rarity_analyzer`;
			} else if (/gas.*price/i.test(input)) {
				command = `/web3_tools --tool_type=gas_price_optimizer`;
			} else if (/mempool/i.test(input)) {
				command = `/web3_tools --tool_type=mempool_transaction_scanner`;
			} else if (/wallet.*portfolio/i.test(input)) {
				command = `/web3_tools --tool_type=wallet_portfolio_tracker`;
			} else if (/ens.*domain/i.test(input)) {
				command = `/web3_tools --tool_type=ens_domain_monitor`;
			} else if (/smart.*contract.*audit/i.test(input)) {
				command = `/web3_tools --tool_type=smart_contract_auditor`;
			} else if (/dapp.*interaction/i.test(input)) {
				command = `/web3_tools --tool_type=dapp_interaction_logger`;
			} else if (/ipfs/i.test(input)) {
				command = `/web3_tools --tool_type=ipfs_data_fetcher`;
			} else if (/polygon.*bridge/i.test(input)) {
				command = `/web3_tools --tool_type=polygon_bridge_monitor`;
			}
			break;

		case 'realtime_analysis':
			if (/streaming/i.test(input)) {
				command = `/realtime_processing --processing_type=streaming_data_processor --symbol=${tradingPair}`;
			} else if (/low.*latency/i.test(input)) {
				command = `/realtime_processing --processing_type=low_latency_executor --symbol=${tradingPair}`;
			} else if (/real.*time.*aggregator/i.test(input)) {
				command = `/realtime_processing --processing_type=real_time_aggregator --symbol=${tradingPair}`;
			} else if (/tick.*data/i.test(input)) {
				command = `/realtime_processing --processing_type=tick_data_analyzer --symbol=${tradingPair}`;
			} else if (/microsecond.*timer/i.test(input)) {
				command = `/realtime_processing --processing_type=microsecond_timer --symbol=${tradingPair}`;
			} else if (/high.*frequency.*monitor/i.test(input)) {
				command = `/realtime_processing --processing_type=high_frequency_monitor --symbol=${tradingPair}`;
			} else if (/real.*time.*risk.*monitor/i.test(input)) {
				command = `/realtime_processing --processing_type=real_time_risk_monitor --symbol=${tradingPair}`;
			} else if (/live.*pnl/i.test(input)) {
				command = `/realtime_processing --processing_type=live_pnl_tracker --symbol=${tradingPair}`;
			} else if (/instant.*alert/i.test(input)) {
				command = `/realtime_processing --processing_type=instant_alert_system --symbol=${tradingPair}`;
			} else if (/real.*time.*cosmic.*sync/i.test(input)) {
				command = `/realtime_processing --processing_type=real_time_cosmic_sync --symbol=${tradingPair}`;
			}
			break;

		case 'risk_analysis':
			if (/var/i.test(input)) {
				command = `/risk_analysis --risk_type=var_calculator --symbol=${tradingPair}`;
			} else if (/cvar/i.test(input)) {
				command = `/risk_analysis --risk_type=cvar_analyzer --symbol=${tradingPair}`;
			} else if (/drawdown/i.test(input)) {
				command = `/risk_analysis --risk_type=maximum_drawdown_tracker --symbol=${tradingPair}`;
			} else if (/sharpe.*ratio/i.test(input)) {
				command = `/risk_analysis --risk_type=sharpe_ratio_optimizer --symbol=${tradingPair}`;
			} else if (/kelly.*criterion/i.test(input)) {
				command = `/risk_analysis --risk_type=kelly_criterion_calculator --symbol=${tradingPair}`;
			} else if (/position.*sizing/i.test(input)) {
				command = `/risk_analysis --risk_type=position_sizing_optimizer --symbol=${tradingPair}`;
			} else if (/correlation.*matrix/i.test(input)) {
				command = `/portfolio_optimization --optimization_type=correlation_matrix_analyzer --symbols=${tradingPair}`;
			} else if (/portfolio.*rebalancer/i.test(input)) {
				command = `/portfolio_optimization --optimization_type=portfolio_rebalancer --symbols=${tradingPair}`;
			} else if (/risk.*parity/i.test(input)) {
				command = `/portfolio_optimization --optimization_type=risk_parity_allocator --symbols=${tradingPair}`;
			} else if (/black.*litterman/i.test(input)) {
				command = `/portfolio_optimization --optimization_type=black_litterman_optimizer --symbols=${tradingPair}`;
			} else if (/monte.*carlo/i.test(input)) {
				command = `/portfolio_optimization --optimization_type=monte_carlo_simulator --symbols=${tradingPair}`;
			} else if (/stress.*test/i.test(input)) {
				command = `/portfolio_optimization --optimization_type=stress_testing_engine --symbols=${tradingPair}`;
			}
			break;

		case 'system_adaptation':
			if (/neural.*evolution/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=neural_evolution_optimizer`;
			} else if (/genetic.*algorithm/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=genetic_algorithm_tuner`;
			} else if (/performance.*auto.*analyzer/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=performance_auto_analyzer`;
			} else if (/latency.*auto.*optimizer/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=latency_auto_optimizer`;
			} else if (/cosmic.*strength.*enhancer/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=cosmic_strength_enhancer`;
			} else if (/strategy.*auto.*selector/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=strategy_auto_selector`;
			} else if (/parameter.*auto.*tuner/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=parameter_auto_tuner`;
			} else if (/feedback.*loop.*optimizer/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=feedback_loop_optimizer`;
			} else if (/adaptive.*learning.*engine/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=adaptive_learning_engine`;
			} else if (/self.*healing.*monitor/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=self_healing_monitor`;
			} else if (/auto.*scaling.*controller/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=auto_scaling_controller`;
			} else if (/dynamic.*threshold.*adjuster/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=dynamic_threshold_adjuster`;
			} else if (/performance.*predictor/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=performance_predictor`;
			} else if (/optimization.*scheduler/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=optimization_scheduler`;
			} else if (/adaptive.*risk.*manager/i.test(input)) {
				command = `/adaptive_optimization --optimization_type=adaptive_risk_manager`;
			}
			break;

		case 'market_structure_analysis':
			if (/dark.*pool.*detection/i.test(input)) {
				command = `/market_structure_analysis --structure_type=dark_pool_detection --symbol=${tradingPair}`;
			} else if (/institutional.*flow/i.test(input)) {
				command = `/market_structure_analysis --structure_type=institutional_flow --symbol=${tradingPair}`;
			} else if (/retail.*sentiment/i.test(input)) {
				command = `/market_structure_analysis --structure_type=retail_sentiment_tracker --symbol=${tradingPair}`;
			} else if (/smart.*money.*detector/i.test(input)) {
				command = `/market_structure_analysis --structure_type=smart_money_detector --symbol=${tradingPair}`;
			} else if (/accumulation.*distribution/i.test(input)) {
				command = `/market_structure_analysis --structure_type=accumulation_distribution --symbol=${tradingPair}`;
			} else if (/volume.*spread.*analysis/i.test(input)) {
				command = `/market_structure_analysis --structure_type=volume_spread_analysis --symbol=${tradingPair}`;
			} else if (/market.*maker.*behavior/i.test(input)) {
				command = `/market_structure_analysis --structure_type=market_maker_behavior --symbol=${tradingPair}`;
			} else if (/order.*book.*dynamics/i.test(input)) {
				command = `/market_structure_analysis --structure_type=order_book_dynamics --symbol=${tradingPair}`;
			}
			break;

		case 'intelligence':
			// CRITICAL FIX: Preserve trading pair in intelligence routing
			if (/professor.*?synapse|synapse.*?reason/i.test(input)) {
				command = `intel_synapse_reason --query="${input}" --context="crypto_analysis" --symbol=${tradingPair}`;
			} else if (/bmad.*?workflow|meta.*?framework/i.test(input)) {
				command = `intel_bmad_workflow --task="${input}" --optimization_level="high" --symbol=${tradingPair}`;
			} else if (/autoexpert.*?optimize|expert.*?optimization/i.test(input)) {
				command = `intel_autoexpert_optimize --domain="crypto_trading" --query="${input}" --symbol=${tradingPair}`;
			} else if (/dspy.*?optimize|pipeline.*?optimization/i.test(input)) {
				command = `intel_dspy_optimize --task="${input}" --optimization_type="reasoning" --symbol=${tradingPair}`;
			} else if (/route.*?request|methodology.*?routing/i.test(input)) {
				command = `intel_route_request --query="${input}" --domain="crypto_trading" --symbol=${tradingPair}`;
			} else {
				command = `intel_route_request --query="${input}" --domain="crypto_trading" --symbol=${tradingPair}`;
			}
			break;

		case 'pattern_detection':
			if (/head.*?shoulder/i.test(input)) {
				command = `trading_detect_patterns --pattern_type=head_and_shoulders --symbol=${tradingPair} --timeframe=1h`;
			} else if (/double.*?top|double.*?bottom/i.test(input)) {
				command = `trading_detect_patterns --pattern_type=double_top_bottom --symbol=${tradingPair} --timeframe=1h`;
			} else if (/triangle/i.test(input)) {
				command = `trading_detect_patterns --pattern_type=triangle --symbol=${tradingPair} --timeframe=1h`;
			} else if (/harmonic.*?pattern|gartley|butterfly/i.test(input)) {
				command = `trading_detect_patterns --pattern_type=harmonic --symbol=${tradingPair} --timeframe=1h`;
			} else if (/elliott.*?wave/i.test(input)) {
				command = `trading_detect_patterns --pattern_type=elliott_wave --symbol=${tradingPair} --timeframe=1h`;
			} else if (/candlestick/i.test(input)) {
				command = `trading_detect_patterns --pattern_type=candlestick --symbol=${tradingPair} --timeframe=1h`;
			} else {
				command = `trading_detect_patterns --pattern_type=all --symbol=${tradingPair} --timeframe=1h`;
			}
			break;

		case 'adaptive_learning':
			// Map to adaptive learning MCP tools - pattern learning and machine learning
			if (/reinforcement.*?learning|rl\b|sac|td3|maml/i.test(input)) {
				const algorithm = /sac/i.test(input) ? 'sac' : /td3/i.test(input) ? 'td3' : /maml/i.test(input) ? 'maml' : 'sac';
				command = `adaptive_learn_pattern --pattern_data=[{"input":[1,2,3],"output":[0.8]},{"input":[2,3,4],"output":[0.9]}] --algorithm=${algorithm} --learning_rate=0.1`;
			} else {
				command = `adaptive_learn_pattern --pattern_data=[{"input":[1,2,3],"output":[0.8]},{"input":[2,3,4],"output":[0.9]}] --algorithm=sac --learning_rate=0.1`;
			}
			break;

		case 'behavior_analysis':
			// Map to behavioral analysis MCP tools
			const sessionId = `session_${Date.now()}`;
			const analysisDepth = /detailed|deep/i.test(input) ? 'detailed' : /deep/i.test(input) ? 'deep' : 'basic';
			command = `adaptive_analyze_behavior --behavior_data={"actions":["analyze","trade","check"],"risk_level":0.3} --session_id=${sessionId} --analysis_depth=${analysisDepth}`;
			break;

		case 'strategy_adaptation':
			// Map to strategy adaptation MCP tools
			const adaptationStrength = /aggressive|strong/i.test(input) ? 0.8 : /gentle|light/i.test(input) ? 0.3 : 0.5;
			command = `adaptive_adapt_strategy --current_strategy={"risk_threshold":0.1,"position_size":0.02} --adaptation_strength=${adaptationStrength} --performance_data=[{"profit":0.05},{"profit":-0.02}]`;
			break;

		case 'constitutional_safety':
			// Map to constitutional AI safety checks
			const safetyLevel = /strict|high/i.test(input) ? 'strict' : /permissive|low/i.test(input) ? 'permissive' : 'moderate';
			command = `adaptive_constitutional_check --proposed_change={"parameter_adjustment":"increase_risk_threshold","new_value":0.15} --safety_level=${safetyLevel}`;
			break;

		case 'neural_optimization':
			// Map to neural architecture search and optimization
			const epochs = /quick|fast/i.test(input) ? 5 : /thorough|deep/i.test(input) ? 50 : 20;
			const taskType = /classification/i.test(input) ? 'classification' : /regression/i.test(input) ? 'regression' : 'optimization';
			command = `adaptive_neural_search --task_type=${taskType} --epochs=${epochs} --search_space={"max_layers":5,"max_neurons":128}`;
			break;

		case 'n8n':
			if (/create.*?workflow|generate.*?workflow|build.*?workflow/i.test(input)) {
				command = `n8n_create_workflow --description="${input}"`;
			} else if (/list.*?workflows|show.*?workflows/i.test(input)) {
				command = `n8n_list_workflows`;
			} else if (/validate.*?workflow|check.*?workflow/i.test(input)) {
				command = `n8n_validate_workflow --workflow_path="${input}"`;
			} else if (/deploy.*?workflow|upload.*?workflow/i.test(input)) {
				command = `n8n_deploy_workflow --workflow_path="${input}"`;
			} else if (/supercode|javascript.*?node/i.test(input)) {
				command = `n8n_generate_supercode --description="${input}"`;
			} else if (/test.*?workflow/i.test(input)) {
				command = `n8n_test_workflow --workflow_path="${input}"`;
			} else if (/status|health|check.*?n8n/i.test(input)) {
				command = `n8n_check_status`;
			} else {
				command = `n8n_create_workflow --description="${input}"`;
			}
			break;

		default:
			command = input;
	}

	return {
		command,
		confidence: bestMatch.confidence,
		originalInput: input,
	};
}

/**
 * Generate conversational response for successful command parsing
 */
export function generateParsingResponse(parsed: ParsedIntent): string {
	if (parsed.confidence < 0.6) {
		const helpResponses = [
			"I'm not quite sure what you're looking for. Could you try asking something like 'analyze Bitcoin' or 'check ETH price'?",
			"Hmm, I didn't catch that. You can ask me about crypto analysis, prices, trading, or just say 'help' to see what I can do!",
			"I'm still learning! Try asking me to analyze a coin, check market sentiment, or use a slash command like /help",
			'Not sure I understood that. Feel free to ask about crypto prices, market analysis, or trading strategies!',
		];