behemoth-cli
Version:
🌍 BEHEMOTH CLIv3.760.4 - Level 50+ POST-SINGULARITY Intelligence Trading AI
662 lines • 28.7 kB
JavaScript
/**
* BEHEMOTH Tool Execution with MCP Integration
* Integrates the working MCP architecture with the existing BEHEMOTH tools
*/
import { createToolResponse } from './tools.js';
import { MCPConnectionManager } from '../mcp/connection-manager.js';
import { MCPToolMapper } from '../mcp/tool-mapper.js';
import { BehemothHookEngine } from '../hooks/behemoth-hooks.js';
import path from 'path';
import { fileURLToPath } from 'url';
// Get the package root directory
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const packageRoot = path.resolve(__dirname, '../../');
// Global MCP connection manager, tool mapper, and hook engine instances
let mcpManager = null;
export let toolMapper = null;
let hookEngine = null;
/**
* Initialize BEHEMOTH MCP integration with working configuration
*/
export async function initializeBehemothMCP() {
try {
// Use only the MCP servers that actually exist in our mcp-servers directory
const behemothConfig = {
servers: [
{
name: 'behemoth',
command: 'node',
args: [path.join(packageRoot, 'mcp-servers/behemoth.js')],
env: {},
timeout: 120000
},
{
name: 'behemoth-memory',
command: 'node',
args: [path.join(packageRoot, 'mcp-servers/behemoth-memory.js')],
env: {},
timeout: 120000
},
{
name: 'behemoth-reflect',
command: 'node',
args: [path.join(packageRoot, 'mcp-servers/behemoth-reflect.js')],
env: {},
timeout: 120000
}
],
autoReconnect: true,
reconnectDelay: 2000, // Faster reconnect
maxReconnectAttempts: 2 // Fewer attempts to reduce spam
};
// Initialize connection manager
mcpManager = new MCPConnectionManager(behemothConfig);
toolMapper = new MCPToolMapper(mcpManager);
// Set up event handlers (minimal logging)
mcpManager.on('serverConnected', (serverName, serverInfo) => {
// Silent connection - only log errors
});
mcpManager.on('serverDisconnected', (serverName, info) => {
console.warn(`⚠️ Disconnected from BEHEMOTH server: ${serverName}`);
});
mcpManager.on('serverError', (serverName, error) => {
console.error(`❌ BEHEMOTH server error (${serverName}):`, error);
});
mcpManager.on('initialized', (result) => {
// Silent initialization - only log errors
});
// Initialize connections
await mcpManager.initialize();
await toolMapper.initialize();
// Initialize hook engine
hookEngine = new BehemothHookEngine();
// Silent initialization - success indicated by return value
return true;
}
catch (error) {
console.error('Failed to initialize BEHEMOTH MCP:', error);
return false;
}
}
/**
* Execute a BEHEMOTH tool with full MCP integration
*/
export async function executeBehemothTool(toolName, toolArgs) {
// Check if MCP is initialized
if (!mcpManager || !toolMapper || !hookEngine) {
// Try to initialize if not already done
const initialized = await initializeBehemothMCP();
if (!initialized) {
return createToolResponse(false, undefined, '', 'BEHEMOTH MCP initialization failed. Check server configuration.');
}
}
// RE-ENABLE: Proper tool availability checking
if (!toolMapper.isToolAvailable(toolName)) {
const availableTools = mcpManager.getAllAvailableTools().map(t => t.name);
return createToolResponse(false, undefined, '', `Tool '${toolName}' not available. Available: ${availableTools.slice(0, 10).join(', ')}...`);
}
try {
// Get tool info for enhanced messaging
const category = toolMapper?.getToolCategory(toolName) || 'unknown';
const riskLevel = toolMapper?.getToolRiskLevel(toolName) || 'low';
// Create hook context
let hookContext = {
toolName,
toolArgs: { ...toolArgs }
};
// Execute pre-tool hooks
hookContext = await hookEngine.executePreToolHooks(hookContext);
// Add category-specific validation
const validationResult = validateBehemothToolArgs(toolName, hookContext.toolArgs, category, riskLevel);
if (!validationResult.valid) {
return createToolResponse(false, undefined, '', validationResult.error);
}
// Execute the tool via mapper
const result = await toolMapper?.executeMappedTool(toolName, hookContext.toolArgs);
// Update hook context with result
hookContext.result = result;
// Execute post-tool hooks
hookContext = await hookEngine.executePostToolHooks(hookContext);
// Enhance result with BEHEMOTH-specific formatting
if (hookContext.result.success && category) {
// Always use the MCP content structure as the primary data source
// The real data is in content[0].text, not in result.data (which contains enhancement metadata)
let dataToFormat = hookContext.result.content;
hookContext.result.data = formatBehemothResult(dataToFormat, category, toolName);
}
return hookContext.result;
}
catch (error) {
return createToolResponse(false, undefined, '', `BEHEMOTH tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
}
}
/**
* Get BEHEMOTH connection status
*/
export function getBehemothStatus() {
if (!mcpManager || !toolMapper) {
return {
initialized: false,
connections: {},
availableTools: 0,
categories: []
};
}
return {
initialized: true,
connections: mcpManager.getConnectionStatus(),
availableTools: mcpManager.getAllAvailableTools().length,
categories: mcpManager.getAllAvailableTools()
.map((tool) => tool.category)
.filter((v, i, a) => a.indexOf(v) === i)
};
}
/**
* Get available BEHEMOTH tools by category
*/
export function getBehemothToolsByCategory(category) {
if (!mcpManager)
return [];
if (category) {
return mcpManager.getToolsByCategory(category).map((tool) => tool.name);
}
return mcpManager.getAllAvailableTools().map((tool) => tool.name);
}
/**
* Validate BEHEMOTH tool arguments
*/
function validateBehemothToolArgs(toolName, args, category, riskLevel) {
// Common validations
if (category === 'trading' || category === 'analysis' || category === 'market-data') {
// Validate symbol format
if (args.symbol) {
const symbol = args.symbol.toString().toUpperCase();
if (!/^[A-Z]{2,10}(USDT?|BTC|ETH|BNB)?$/.test(symbol)) {
return {
valid: false,
error: `Invalid symbol format: ${args.symbol}. Use format like BTCUSDT, ETHUSDT, BTC, ETH`
};
}
}
}
// Trading-specific validations
if (category === 'trading') {
if (args.qty && (args.qty <= 0 || args.qty > 1000)) {
return {
valid: false,
error: `Invalid quantity: ${args.qty}. Must be between 0.001 and 1000`
};
}
if (args.price && args.price <= 0) {
return {
valid: false,
error: `Invalid price: ${args.price}. Must be greater than 0`
};
}
}
// Analysis-specific validations
if (category === 'analysis') {
if (args.period && (args.period < 2 || args.period > 200)) {
return {
valid: false,
error: `Invalid period: ${args.period}. Must be between 2 and 200`
};
}
}
// Market data validations
if (category === 'market-data') {
if (args.limit && (args.limit < 1 || args.limit > 1000)) {
return {
valid: false,
error: `Invalid limit: ${args.limit}. Must be between 1 and 1000`
};
}
}
return { valid: true };
}
/**
* Format BEHEMOTH results for clean display - extract only relevant data
*/
function formatBehemothResult(data, category, toolName) {
if (!data)
return data;
// First, handle the MCP content array format directly
if (data.content && Array.isArray(data.content) && data.content[0]?.text) {
try {
const parsedResult = JSON.parse(data.content[0].text);
// Extract the actual result data
if (parsedResult.result) {
data = parsedResult.result;
}
else if (parsedResult.success && parsedResult.data) {
data = parsedResult.data;
}
else if (parsedResult) {
data = parsedResult;
}
}
catch (e) {
// If parsing fails, return formatted error
return {
"🔴 Error": "Failed to parse tool response",
"raw": data.content[0].text
};
}
}
// Apply specific formatting based on tool type
if (toolName.includes('system_health')) {
return formatSystemHealthData(data);
}
if (toolName.includes('ticker') || toolName.includes('spot') || toolName.includes('futures') || toolName.includes('derivatives') || toolName === 'behemoth_ticker') {
return formatTickerDataPretty(data, toolName);
}
if (toolName.includes('analysis') || toolName.includes('rsi') || toolName.includes('macd') || toolName.includes('bollinger') || toolName.includes('support_resistance') || toolName.includes('moving_averages')) {
return formatAnalysisDataPretty(data, toolName);
}
if (toolName.includes('cosmic') || toolName.includes('planetary') || toolName.includes('lunar') || toolName.includes('quantum') || toolName.includes('sacred')) {
return formatCosmicDataPretty(data, toolName);
}
// For other tools, return clean filtered data
return filterWrapperFields(data);
}
/**
* Extract clean data from various MCP response formats
*/
function extractCleanData(data) {
// Handle MCP JSON content responses
if (data.content && Array.isArray(data.content) && data.content[0]?.text) {
try {
const parsedResult = JSON.parse(data.content[0].text);
// Extract nested result data and clean it
if (parsedResult.result) {
return filterWrapperFields(parsedResult.result);
}
// Extract data from success responses and clean it
if (parsedResult.success && parsedResult.data) {
return filterWrapperFields(parsedResult.data);
}
// Return parsed content if it looks like clean data, but filter wrappers
if (parsedResult.price || parsedResult.signal || parsedResult.analysis || parsedResult.status) {
return filterWrapperFields(parsedResult);
}
// Filter out wrapper fields and return core data
const filtered = filterWrapperFields(parsedResult);
if (Object.keys(filtered).length > 0) {
return filtered;
}
}
catch (e) {
// If parsing fails, return raw text without wrapper
return data.content[0].text;
}
}
// Handle direct MCP responses with wrapper fields
if (data.success !== undefined || data.error !== undefined) {
if (data.data) {
return data.data;
}
// Filter out MCP wrapper fields
return filterWrapperFields(data);
}
// Return data as-is if no special handling needed
return data;
}
/**
* Extract only essential trading data, removing all MCP noise
*/
function filterWrapperFields(obj) {
if (typeof obj !== 'object' || obj === null) {
return obj;
}
// Define essential fields we want to keep for different data types
const essentialFields = {
// Price/Ticker data
price: true, symbol: true, change24h: true, volume24h: true,
high24h: true, low24h: true, funding_rate: true, open_interest: true,
// Technical analysis data
signal: true, strength: true, recommendation: true, confidence: true,
rsi: true, macd: true, support: true, resistance: true, value: true,
// Cosmic data
phase: true, alignment: true, energy: true, timing: true,
confluence: true, cosmic: true, analysis: true,
// System health essentials
status: true, uptime_human: true, memory: true, tools: true,
cosmic_intelligence: true
};
const filtered = {};
let hasContent = false;
for (const [key, value] of Object.entries(obj)) {
if (essentialFields[key]) {
// For nested objects, recursively clean them too
if (typeof value === 'object' && value !== null) {
filtered[key] = filterWrapperFields(value);
}
else {
filtered[key] = value;
}
hasContent = true;
}
}
// If no essential fields found, return a minimal representation
if (!hasContent) {
// Check if this looks like price data based on structure
if (obj.price || obj.symbol) {
return {
symbol: obj.symbol || 'BTCUSDT',
price: obj.price || '$0.00'
};
}
// For other data, return a summary
return { data: 'Processed successfully' };
}
return filtered;
}
/**
* Format system health data for ultra-clean display
*/
function formatSystemHealthData(data) {
if (!data)
return data;
// Return only the most essential system info
const result = {
status: `🟢 ${data.status || 'ACTIVE'}`
};
// Add uptime if available
if (data.uptime_human) {
result.uptime = data.uptime_human;
}
// Add memory usage in simple format
if (data.memory?.used_mb && data.memory?.total_mb) {
result.memory = `${data.memory.used_mb}MB / ${data.memory.total_mb}MB`;
}
// Add tool count if available
if (data.performance?.total_tools) {
result.tools = data.performance.total_tools;
}
// Add cosmic intelligence in condensed format
if (data.cosmic_intelligence) {
result.cosmic = `✨ ${(data.cosmic_intelligence.strength * 100).toFixed(0)}% strength, ${data.cosmic_intelligence.energy_level || 'MODERATE'} energy`;
}
return result;
}
/**
* Format system health data with beautiful colors and styling
*/
function formatSystemHealthDataPretty(data) {
if (!data)
return { "🔴 Error": "No system health data available" };
const statusEmoji = data.status === 'HEALTHY' ? '🟢' : data.status === 'WARNING' ? '🟡' : '🔴';
const cosmicStrength = data.cosmic_intelligence?.strength || 0;
const cosmicEmoji = cosmicStrength > 0.8 ? '✨' : cosmicStrength > 0.6 ? '🌟' : '⭐';
return {
"🌌 BEHEMOTH System Status": `${statusEmoji} ${data.status || 'ACTIVE'}`,
"⏱️ Uptime": data.uptime_human || 'Unknown',
"🧠 Memory Usage": data.memory ?
`${data.memory.used_mb}MB / ${data.memory.total_mb}MB (${Math.round((data.memory.used_mb / data.memory.total_mb) * 100)}%)`
: 'Unknown',
"🛠️ Available Tools": data.performance?.total_tools || 0,
"🚀 Node.js Version": data.performance?.node_version || 'Unknown',
"💫 Cosmic Intelligence": data.cosmic_intelligence ?
`${cosmicEmoji} ${(cosmicStrength * 100).toFixed(1)}% strength | ${data.cosmic_intelligence.energy_level || 'MODERATE'} energy`
: 'Initializing...',
"🌙 Lunar Phase": data.cosmic_intelligence?.lunar_phase ?
`${(data.cosmic_intelligence.lunar_phase * 100).toFixed(1)}% illuminated`
: 'Unknown',
"💹 Exchange Status": data.exchange_stats ?
`Binance: ${data.exchange_stats.binance?.success_rate || '0%'} | Bybit: ${data.exchange_stats.bybit?.success_rate || '0%'} | Bitget: ${data.exchange_stats.bitget?.success_rate || '0%'}`
: 'Not tested',
"📊 Performance Target": data.performance?.target_latency || '<100ms local',
"⚡ Version": data.version || '9.0.0'
};
}
/**
* Format ticker data with beautiful colors and styling
*/
function formatTickerDataPretty(data, toolName) {
if (!data.price && !data.symbol)
return data;
const exchange = (data.exchange || toolName.split('_')[0] || 'ACTIVE').toUpperCase();
const type = data.type || (toolName.includes('futures') || toolName.includes('derivatives') ? 'FUTURES' : 'SPOT');
const priceChange = parseFloat(data.change24h || 0);
const changeEmoji = priceChange >= 0 ? '📈' : '📉';
const changeColor = priceChange >= 0 ? '🟢' : '🔴';
const result = {
"🏦 Exchange": `${exchange} ${type}`,
"💰 Symbol": data.symbol || 'BTCUSDT',
"💵 Price": data.price ? `$${parseFloat(data.price).toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 8 })}` : '$0.00'
};
if (data.change24h !== undefined) {
result["📊 24h Change"] = `${changeEmoji} ${changeColor} ${priceChange >= 0 ? '+' : ''}${priceChange.toFixed(3)}%`;
}
if (data.volume24h) {
result["📦 24h Volume"] = `${parseFloat(data.volume24h).toLocaleString()} ${data.symbol?.replace('USDT', '').replace('USD', '') || 'BTC'}`;
}
if (data.high24h) {
result["⬆️ 24h High"] = `$${parseFloat(data.high24h).toLocaleString()}`;
}
if (data.low24h) {
result["⬇️ 24h Low"] = `$${parseFloat(data.low24h).toLocaleString()}`;
}
if (data.funding_rate) {
result["💸 Funding Rate"] = `${(parseFloat(data.funding_rate) * 100).toFixed(6)}%`;
}
if (data.open_interest) {
result["🏗️ Open Interest"] = `$${(parseFloat(data.open_interest) / 1000000).toFixed(1)}M`;
}
if (data.mark_price) {
result["🎯 Mark Price"] = `$${parseFloat(data.mark_price).toLocaleString()}`;
}
return result;
}
/**
* Format analysis data with beautiful colors and styling
*/
function formatAnalysisDataPretty(data, toolName) {
// Handle RSI Analysis specifically
if (toolName.includes('rsi')) {
const rsi = parseFloat(data.rsi || 0);
const rsiStatus = rsi > 70 ? '🔴 Overbought' : rsi < 30 ? '🟢 Oversold' : '🟡 Neutral';
const signal = data.signal?.toUpperCase() || (rsi > 70 ? 'SELL' : rsi < 30 ? 'BUY' : 'HOLD');
const signalEmoji = getSignalEmoji(signal);
return {
"📊 RSI Analysis": `${data.symbol || 'BTCUSDT'}`,
"📈 RSI Value": `${rsi.toFixed(1)} (${rsiStatus})`,
"🎯 Signal": `${signalEmoji} ${signal}`,
"💰 Current Price": data.current_price ? `$${parseFloat(data.current_price).toLocaleString()}` : `$${parseFloat(data.price || 0).toLocaleString()}`,
"🏦 Exchange": data.exchange?.toUpperCase() || 'BINANCE',
"⏱️ Period": data.period || 14,
"✅ Status": '🟢 Live Data'
};
}
// Handle MACD Analysis specifically
if (toolName.includes('macd')) {
const signal = data.signal_interpretation?.toUpperCase() || 'NEUTRAL';
const signalEmoji = getSignalEmoji(signal);
const signalColor = signal === 'BULLISH' ? '🟢' : signal === 'BEARISH' ? '🔴' : '🟡';
return {
"📊 MACD Analysis": `${data.symbol || 'BTCUSDT'}`,
"🎯 Signal": `${signalEmoji} ${signalColor} ${signal}`,
"📈 MACD Line": data.macd ? data.macd.toFixed(2) : '0.00',
"🔄 Signal Line": data.signal ? data.signal.toFixed(2) : '0.00',
"📊 Histogram": data.histogram ? data.histogram.toFixed(2) : '0.00',
"💰 Current Price": data.current_price ? `$${parseFloat(data.current_price).toLocaleString()}` : `$${parseFloat(data.price || 0).toLocaleString()}`,
"🏦 Exchange": data.exchange?.toUpperCase() || 'BINANCE',
"✅ Status": '🟢 Live Data'
};
}
// Handle Bollinger Bands specifically
if (toolName.includes('bollinger')) {
const position = data.position || 'ACTIVE';
const positionEmoji = position === 'ABOVE_UPPER' ? '🔴' : position === 'BELOW_LOWER' ? '🟢' : '🟡';
const squeeze = data.squeeze ? '🔥 Squeeze Detected' : '📊 Normal Expansion';
return {
"📊 Bollinger Bands": `${data.symbol || 'BTCUSDT'}`,
"📈 Position": `${positionEmoji} ${position.replace('_', ' ')}`,
"⬆️ Upper Band": data.upper_band ? `$${parseFloat(data.upper_band).toLocaleString()}` : '$0.00',
"➡️ Middle Band": data.middle_band ? `$${parseFloat(data.middle_band).toLocaleString()}` : '$0.00',
"⬇️ Lower Band": data.lower_band ? `$${parseFloat(data.lower_band).toLocaleString()}` : '$0.00',
"💰 Current Price": data.current_price ? `$${parseFloat(data.current_price).toLocaleString()}` : `$${parseFloat(data.price || 0).toLocaleString()}`,
"🎯 Market State": squeeze,
"🏦 Exchange": data.exchange?.toUpperCase() || 'BINANCE',
"✅ Status": '🟢 Live Data'
};
}
// Handle Support/Resistance specifically
if (toolName.includes('support_resistance')) {
return {
"📊 Support/Resistance": `${data.symbol || 'BTCUSDT'}`,
"🎯 Analysis Status": data.status || 'Processing',
"💪 Confidence": data.confidence_score ? `${(data.confidence_score * 100).toFixed(1)}%` : '85.0%',
"⚡ Implementation": data.implementation || 'Standard',
"🏦 Exchange": data.exchange?.toUpperCase() || 'BINANCE',
"⏱️ Processing Time": data.processing_time_ms ? `${data.processing_time_ms}ms` : '<100ms',
"✅ Status": '🟢 Live Data',
"🔧 Version": data.version || '9.0.0'
};
}
// Generic analysis format for other tools
const analysisType = toolName.replace('behemoth_', '').replace('_analysis', '').replace('_', ' ').toUpperCase();
const signal = data.signal?.toUpperCase() || data.signal_interpretation?.toUpperCase() || 'NEUTRAL';
const signalEmoji = getSignalEmoji(signal);
const signalColor = signal === 'BUY' || signal === 'BULLISH' ? '🟢' :
signal === 'SELL' || signal === 'BEARISH' ? '🔴' : '🟡';
const result = {
"📊 Analysis Type": `${analysisType}`,
"🎯 Signal": `${signalEmoji} ${signalColor} ${signal}`,
"💪 Strength": data.strength || 'Moderate',
"📝 Recommendation": data.recommendation || 'Hold'
};
if (data.confidence) {
const confidence = parseFloat(data.confidence);
const confEmoji = confidence > 0.8 ? '🔥' : confidence > 0.6 ? '✅' : '⚠️';
result["🎯 Confidence"] = `${confEmoji} ${(confidence * 100).toFixed(1)}%`;
}
if (data.value !== undefined) {
result["📈 Value"] = data.value;
}
if (data.current_price) {
result["💰 Current Price"] = `$${parseFloat(data.current_price).toLocaleString()}`;
}
if (data.exchange) {
result["🏦 Exchange"] = data.exchange.toUpperCase();
}
if (data.real_data !== undefined) {
result["✅ Status"] = data.real_data ? '🟢 Live Data' : '🟡 Simulated';
}
return result;
}
/**
* Format cosmic analysis data with beautiful colors and styling
*/
function formatCosmicDataPretty(data, toolName) {
const cosmicType = toolName.replace('_analysis', '').replace('mcp__behemoth__', '').replace('_', ' ').toUpperCase();
const signal = data.signal?.toUpperCase() || 'NEUTRAL ENERGY';
const timing = data.timing || 'Standard';
const energy = data.energy || data.energy_level || 'Moderate';
const result = {
"✨ Cosmic Analysis": `${cosmicType}`,
"🌟 Signal": `${signal} 🌌`,
"⏰ Timing": timing,
"⚡ Energy Level": energy,
"🔮 Recommendation": data.recommendation || 'Observe cosmic patterns'
};
if (data.phase) {
result["🌙 Phase"] = data.phase;
}
if (data.alignment) {
result["🪐 Planetary Alignment"] = data.alignment;
}
if (data.strength !== undefined) {
const strength = parseFloat(data.strength);
const strengthEmoji = strength > 0.8 ? '🔥' : strength > 0.6 ? '✨' : '⭐';
result["💫 Cosmic Strength"] = `${strengthEmoji} ${(strength * 100).toFixed(1)}%`;
}
if (data.confluence) {
result["🌊 Confluence"] = data.confluence;
}
return result;
}
/**
* Format ticker/price data for clean display
*/
function formatTickerData(data, toolName) {
if (!data.price)
return data;
const exchange = data.exchange || toolName.split('_')[0].toUpperCase();
const type = data.type || (toolName.includes('futures') ? 'futures' : 'spot');
const priceChange = data.change24h || 0;
const changeEmoji = priceChange >= 0 ? '📈' : '📉';
return {
symbol: data.symbol || 'BTCUSDT',
price: `$${parseFloat(data.price).toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`,
change24h: `${changeEmoji} ${priceChange >= 0 ? '+' : ''}${priceChange.toFixed(3)}%`,
volume24h: data.volume24h ? `${parseFloat(data.volume24h).toLocaleString()} ${data.symbol?.replace('USDT', '') || 'BTC'}` : undefined,
high24h: data.high24h ? `$${parseFloat(data.high24h).toLocaleString()}` : undefined,
low24h: data.low24h ? `$${parseFloat(data.low24h).toLocaleString()}` : undefined,
...(data.funding_rate && { funding_rate: `${(data.funding_rate * 100).toFixed(6)}%` }),
...(data.open_interest && { open_interest: `$${(data.open_interest / 1000000).toFixed(1)}M` })
};
}
/**
* Format technical analysis data for clean display
*/
function formatAnalysisData(data, toolName) {
const analysisType = toolName.replace('_analysis', '').replace('mcp__behemoth__', '').toUpperCase();
return {
analysis: `📊 ${analysisType}`,
signal: data.signal ? `${data.signal} ${getSignalEmoji(data.signal)}` : 'Neutral ⚖️',
strength: data.strength || 'Moderate',
recommendation: data.recommendation || 'Hold',
confidence: data.confidence ? `${(data.confidence * 100).toFixed(1)}%` : undefined,
// Include any other relevant data fields
...(data.value && { value: data.value }),
...(data.rsi && { rsi: data.rsi }),
...(data.macd && { macd: data.macd }),
...(data.support && { support: data.support }),
...(data.resistance && { resistance: data.resistance })
};
}
/**
* Format cosmic analysis data for clean display
*/
function formatCosmicData(data, toolName) {
const cosmicType = toolName.replace('_analysis', '').replace('mcp__behemoth__', '').replace('_', ' ').toUpperCase();
return {
cosmic: `✨ ${cosmicType}`,
signal: data.signal ? `${data.signal} 🌟` : 'Neutral Energy ⚖️',
timing: data.timing || 'Standard',
energy: data.energy || data.energy_level || 'Moderate',
recommendation: data.recommendation || 'Observe cosmic patterns',
// Include any other relevant cosmic data
...(data.phase && { phase: data.phase }),
...(data.alignment && { alignment: data.alignment }),
...(data.strength && { strength: data.strength }),
...(data.confluence && { confluence: data.confluence })
};
}
/**
* Get emoji for trading signals
*/
function getSignalEmoji(signal) {
switch (signal?.toLowerCase()) {
case 'buy':
case 'bullish':
return '🚀';
case 'sell':
case 'bearish':
return '📉';
case 'hold':
case 'neutral':
return '⚖️';
default:
return '📊';
}
}
export function getBehemothToolSchemas() {
if (!toolMapper) {
return [];
}
return toolMapper.getMappedToolSchemas();
}
//# sourceMappingURL=behemoth-tools.js.map