hedgequantx 2.5.36 → 2.5.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.5.36",
+  "version": "2.5.38",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/pages/algo/one-account.js

@@ -16,6 +16,10 @@ const { M1 } = require('../../../dist/lib/m/s1');
 const { MarketDataFeed } = require('../../../dist/lib/data');
 const { algoLogger } = require('./logger');
 
+// AI Strategy Supervisor - observes, learns, and optimizes the strategy
+const aiService = require('../../services/ai');
+const StrategySupervisor = require('../../services/ai/strategy-supervisor');
+
 
 
 /**
@@ -167,6 +171,7 @@ const configureAlgo = async (account, contract) => {
 /**
  * Launch algo trading - HQX Ultra Scalping Strategy
  * Real-time market data + Strategy signals + Auto order execution
+ * AI Supervision: All connected agents monitor and supervise trading
  */
 const launchAlgo = async (service, account, contract, config) => {
   const { contracts, dailyTarget, maxRisk, showName } = config;
@@ -197,7 +202,9 @@ const launchAlgo = async (service, account, contract, config) => {
     losses: 0,
     latency: 0,
     connected: false,
-    startTime: Date.now()
+    startTime: Date.now(),
+    aiSupervision: false,
+    aiMode: null
   };
   
   let running = true;
@@ -213,6 +220,14 @@ const launchAlgo = async (service, account, contract, config) => {
   const strategy = M1;
   strategy.initialize(contractId, tickSize, tickValue);
   
+  // Initialize AI Strategy Supervisor - agents observe, learn & optimize
+  const aiAgents = aiService.getAgents();
+  if (aiAgents.length > 0) {
+    const supervisorResult = StrategySupervisor.initialize(strategy, aiAgents, service, account.accountId);
+    stats.aiSupervision = supervisorResult.success;
+    stats.aiMode = supervisorResult.mode;
+  }
+  
   // Initialize Market Data Feed
   const marketFeed = new MarketDataFeed({ propfirm: account.propfirm });
   
@@ -225,17 +240,44 @@ const launchAlgo = async (service, account, contract, config) => {
   algoLogger.engineStarting(ui, connectionType, dailyTarget, maxRisk);
   algoLogger.marketOpen(ui, sessionName.toUpperCase(), etTime);
   
+  // Log AI supervision status
+  if (stats.aiSupervision) {
+    algoLogger.info(ui, 'AI SUPERVISION', `${aiAgents.length} agent(s) - ${stats.aiMode} mode - LEARNING ACTIVE`);
+  }
+  
   // Handle strategy signals
   strategy.on('signal', async (signal) => {
     if (!running || pendingOrder || currentPosition !== 0) return;
     
     const { side, direction, entry, stopLoss, takeProfit, confidence } = signal;
     
+    // Feed signal to AI supervisor (agents observe the signal)
+    if (stats.aiSupervision) {
+      StrategySupervisor.feedSignal({ direction, entry, stopLoss, takeProfit, confidence });
+      
+      // Check AI advice - agents may recommend caution based on learned patterns
+      const advice = StrategySupervisor.shouldTrade();
+      if (!advice.proceed) {
+        algoLogger.info(ui, 'AI HOLD', advice.reason);
+        return; // Skip - agents learned this pattern leads to losses
+      }
+    }
+    
     // Calculate position size with kelly
-    const kelly = Math.min(0.25, confidence);
-    const riskAmount = Math.round(maxRisk * kelly);
-    const riskPct = Math.round((riskAmount / maxRisk) * 100);
+    let kelly = Math.min(0.25, confidence);
+    let riskAmount = Math.round(maxRisk * kelly);
     
+    // AI may adjust size based on learning
+    if (stats.aiSupervision) {
+      const advice = StrategySupervisor.getCurrentAdvice();
+      if (advice.sizeMultiplier && advice.sizeMultiplier !== 1.0) {
+        kelly = kelly * advice.sizeMultiplier;
+        riskAmount = Math.round(riskAmount * advice.sizeMultiplier);
+        algoLogger.info(ui, 'AI ADJUST', `Size x${advice.sizeMultiplier.toFixed(2)} - ${advice.reason}`);
+      }
+    }
+    
+    const riskPct = Math.round((riskAmount / maxRisk) * 100);
     algoLogger.positionSized(ui, contracts, kelly, riskAmount, riskPct);
     
     // Place order via API
@@ -319,6 +361,11 @@ const launchAlgo = async (service, account, contract, config) => {
       timestamp: tick.timestamp || Date.now()
     };
     
+    // Feed tick to AI supervisor (agents observe same data as strategy)
+    if (stats.aiSupervision) {
+      StrategySupervisor.feedTick(tickData);
+    }
+    
     strategy.processTick(tickData);
     
     stats.latency = Date.now() - latencyStart;
@@ -443,6 +490,25 @@ const launchAlgo = async (service, account, contract, config) => {
                 
                 // Record in strategy for adaptation
                 strategy.recordTradeResult(pnl);
+                
+                // Feed trade result to AI supervisor - THIS IS WHERE AGENTS LEARN
+                if (stats.aiSupervision) {
+                  StrategySupervisor.feedTradeResult({
+                    side,
+                    qty: contracts,
+                    price: exitPrice,
+                    pnl,
+                    symbol: symbolName,
+                    direction: side
+                  });
+                  
+                  // Log if AI learned something
+                  const status = StrategySupervisor.getStatus();
+                  if (status.patternsLearned.winning + status.patternsLearned.losing > 0) {
+                    algoLogger.info(ui, 'AI LEARNING', 
+                      `${status.patternsLearned.winning}W/${status.patternsLearned.losing}L patterns`);
+                  }
+                }
               }
             }
           } catch (e) {
@@ -510,6 +576,15 @@ const launchAlgo = async (service, account, contract, config) => {
   clearInterval(refreshInterval);
   clearInterval(pnlInterval);
   
+  // Stop AI Supervisor and get learning summary
+  if (stats.aiSupervision) {
+    const aiSummary = StrategySupervisor.stop();
+    stats.aiLearning = {
+      optimizations: aiSummary.optimizationsApplied || 0,
+      patternsLearned: (aiSummary.winningPatterns || 0) + (aiSummary.losingPatterns || 0)
+    };
+  }
+  
   // Disconnect market feed with timeout
   try {
     await Promise.race([

package/src/pages/stats.js

@@ -16,6 +16,7 @@ const { getLogoWidth, visibleLength, drawBoxHeader, drawBoxFooter, getColWidths,
 const { prompts } = require('../utils');
 const aiService = require('../services/ai');
 const AISupervisor = require('../services/ai/supervisor');
+const StrategySupervisor = require('../services/ai/strategy-supervisor');
 
 /**
  * Show Stats Page
@@ -479,6 +480,85 @@ const showStats = async (service) => {
       }
       
       drawBoxFooter(boxWidth);
+      
+      // ========== AI BEHAVIOR GRAPH ==========
+      const behaviorData = StrategySupervisor.getBehaviorHistory(boxWidth - 20);
+      const learningStats = StrategySupervisor.getLearningStats();
+      
+      if (behaviorData.values.length > 2) {
+        console.log();
+        drawBoxHeader('AI AGENTS BEHAVIOR', boxWidth);
+        
+        const behaviorInnerWidth = boxWidth - 2;
+        const yAxisWidth = 12;
+        const chartWidth = behaviorInnerWidth - yAxisWidth - 4;
+        
+        // Scale values for better visualization (0-3 -> 0-100 with some padding)
+        let scaledValues = behaviorData.values.map(v => (v + 0.5) * 25); // 0->12.5, 1->37.5, 2->62.5, 3->87.5
+        
+        // Ensure we have enough points for a nice curve
+        if (scaledValues.length < 10) {
+          const newValues = [];
+          for (let i = 0; i < scaledValues.length - 1; i++) {
+            newValues.push(scaledValues[i]);
+            // Smooth interpolation
+            const diff = scaledValues[i + 1] - scaledValues[i];
+            newValues.push(scaledValues[i] + diff * 0.33);
+            newValues.push(scaledValues[i] + diff * 0.66);
+          }
+          newValues.push(scaledValues[scaledValues.length - 1]);
+          scaledValues = newValues;
+        }
+        
+        // Limit data points to chart width
+        if (scaledValues.length > chartWidth) {
+          const step = Math.ceil(scaledValues.length / chartWidth);
+          scaledValues = scaledValues.filter((_, i) => i % step === 0);
+        }
+        
+        // Determine color based on current behavior
+        const currentValue = behaviorData.values[behaviorData.values.length - 1];
+        let chartColor = asciichart.white;
+        if (currentValue >= 2.5) chartColor = asciichart.green; // AGGRESSIVE
+        else if (currentValue >= 1.5) chartColor = asciichart.cyan; // NORMAL
+        else if (currentValue >= 0.5) chartColor = asciichart.yellow; // CAUTIOUS
+        else chartColor = asciichart.red; // PAUSE
+        
+        const behaviorConfig = {
+          height: 6,
+          min: 0,
+          max: 100,
+          colors: [chartColor],
+          format: (x) => {
+            if (x >= 75) return 'AGGRESSIVE'.padStart(yAxisWidth);
+            if (x >= 50) return '    NORMAL'.padStart(yAxisWidth);
+            if (x >= 25) return '  CAUTIOUS'.padStart(yAxisWidth);
+            return '     PAUSE'.padStart(yAxisWidth);
+          }
+        };
+        
+        try {
+          const behaviorChart = asciichart.plot(scaledValues, behaviorConfig);
+          behaviorChart.split('\n').forEach(line => {
+            let chartLine = '  ' + line;
+            const len = chartLine.replace(/\x1b\[[0-9;]*m/g, '').length;
+            if (len < behaviorInnerWidth) chartLine += ' '.repeat(behaviorInnerWidth - len);
+            console.log(chalk.cyan('\u2551') + chartLine + chalk.cyan('\u2551'));
+          });
+        } catch (e) {
+          // Fallback if chart fails
+          const msg = '  BEHAVIOR DATA INSUFFICIENT';
+          console.log(chalk.cyan('\u2551') + chalk.white(msg) + ' '.repeat(Math.max(0, behaviorInnerWidth - msg.length)) + chalk.cyan('\u2551'));
+        }
+        
+        // Add learning stats line
+        const durationMin = Math.floor(behaviorData.duration / 60000);
+        const statsLine = `  SESSION: ${durationMin}m | PATTERNS: ${learningStats.patternsLearned.total} (${learningStats.patternsLearned.winning}W/${learningStats.patternsLearned.losing}L) | OPTIMIZATIONS: ${learningStats.optimizations} | SIGNALS: ${learningStats.signalsObserved}`;
+        const statsLen = statsLine.length;
+        console.log(chalk.cyan('\u2551') + chalk.white(statsLine) + ' '.repeat(Math.max(0, behaviorInnerWidth - statsLen)) + chalk.cyan('\u2551'));
+        
+        drawBoxFooter(boxWidth);
+      }
     }
     
     // ========== EQUITY CURVE ==========

package/src/services/ai/client.js

@@ -308,6 +308,145 @@ Analyze and provide recommendation.`;
   }
 };
 
+/**
+ * Analyze strategy performance and suggest optimizations
+ * Called periodically to help the strategy improve
+ * 
+ * @param {Object} agent - AI agent
+ * @param {Object} performanceData - Strategy performance data
+ * @returns {Promise<Object|null>} Optimization suggestions
+ */
+const analyzePerformance = async (agent, performanceData) => {
+  if (!agent || !performanceData) return null;
+  
+  const systemPrompt = `You are an AI supervisor for HQX Ultra Scalping, a professional prop firm futures trading strategy.
+
+The strategy uses advanced mathematical models:
+- Order flow analysis (delta, cumulative delta, absorption)
+- Market microstructure (bid/ask imbalance, volume profile)
+- Statistical edge detection (z-score, standard deviation bands)
+- Dynamic risk management (Kelly criterion, volatility-adjusted sizing)
+
+Your job is to analyze performance data and suggest parameter optimizations.
+Be precise and actionable. Focus on improving win rate, reducing drawdown, and optimizing risk/reward.
+
+Respond ONLY in valid JSON format:
+{
+  "assessment": "brief performance assessment",
+  "winRateAnalysis": "analysis of win/loss patterns",
+  "riskAnalysis": "analysis of risk management",
+  "optimizations": [
+    { "param": "parameter_name", "current": "current_value", "suggested": "new_value", "reason": "why" }
+  ],
+  "marketCondition": "trending|ranging|volatile|calm",
+  "confidence": 0-100
+}`;
+  
+  const prompt = `STRATEGY PERFORMANCE DATA - ANALYZE AND OPTIMIZE
+
+Session Stats:
+- Trades: ${performanceData.trades || 0}
+- Wins: ${performanceData.wins || 0}
+- Losses: ${performanceData.losses || 0}
+- Win Rate: ${performanceData.winRate ? (performanceData.winRate * 100).toFixed(1) + '%' : 'N/A'}
+- Total P&L: $${performanceData.pnl?.toFixed(2) || '0.00'}
+- Avg Win: $${performanceData.avgWin?.toFixed(2) || 'N/A'}
+- Avg Loss: $${performanceData.avgLoss?.toFixed(2) || 'N/A'}
+- Largest Win: $${performanceData.largestWin?.toFixed(2) || 'N/A'}
+- Largest Loss: $${performanceData.largestLoss?.toFixed(2) || 'N/A'}
+- Max Drawdown: $${performanceData.maxDrawdown?.toFixed(2) || 'N/A'}
+- Profit Factor: ${performanceData.profitFactor?.toFixed(2) || 'N/A'}
+
+Current Parameters:
+- Position Size: ${performanceData.positionSize || 'N/A'} contracts
+- Daily Target: $${performanceData.dailyTarget || 'N/A'}
+- Max Risk: $${performanceData.maxRisk || 'N/A'}
+- Symbol: ${performanceData.symbol || 'N/A'}
+
+Recent Trades:
+${performanceData.recentTrades?.map(t => 
+  `- ${t.side} ${t.qty}x @ ${t.price} → P&L: $${t.pnl?.toFixed(2) || 'N/A'}`
+).join('\n') || 'No recent trades'}
+
+Market Context:
+- Volatility: ${performanceData.volatility || 'N/A'}
+- Trend: ${performanceData.trend || 'N/A'}
+- Session: ${performanceData.session || 'N/A'}
+
+Analyze and suggest optimizations to improve performance.`;
+
+  try {
+    const response = await callAI(agent, prompt, systemPrompt);
+    if (!response) return null;
+    
+    // Parse JSON from response
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Get real-time trading advice based on current market conditions
+ * 
+ * @param {Object} agent - AI agent
+ * @param {Object} marketData - Current market data
+ * @returns {Promise<Object|null>} Trading advice
+ */
+const getMarketAdvice = async (agent, marketData) => {
+  if (!agent || !marketData) return null;
+  
+  const systemPrompt = `You are an AI supervisor for HQX Ultra Scalping futures strategy.
+Analyze real-time market data and provide actionable advice.
+Be concise and precise. The strategy will use your recommendations.
+
+Respond ONLY in valid JSON:
+{
+  "action": "AGGRESSIVE|NORMAL|CAUTIOUS|PAUSE",
+  "sizeMultiplier": 0.5-1.5,
+  "reason": "brief reason",
+  "confidence": 0-100
+}`;
+  
+  const prompt = `REAL-TIME MARKET ANALYSIS
+
+Current Price: ${marketData.price || 'N/A'}
+Bid: ${marketData.bid || 'N/A'} | Ask: ${marketData.ask || 'N/A'}
+Spread: ${marketData.spread || 'N/A'}
+Volume: ${marketData.volume || 'N/A'}
+Delta: ${marketData.delta || 'N/A'}
+Volatility: ${marketData.volatility || 'N/A'}
+
+Recent Price Action:
+- High: ${marketData.high || 'N/A'}
+- Low: ${marketData.low || 'N/A'}
+- Range: ${marketData.range || 'N/A'}
+
+Current Position: ${marketData.position || 'FLAT'}
+Session P&L: $${marketData.pnl?.toFixed(2) || '0.00'}
+
+What should the strategy do?`;
+
+  try {
+    const response = await callAI(agent, prompt, systemPrompt);
+    if (!response) return null;
+    
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
 /**
  * Fetch available models from Anthropic API (API Key auth)
  * @param {string} apiKey - API key
@@ -429,6 +568,8 @@ const fetchOpenAIModels = async (endpoint, apiKey) => {
 module.exports = {
   callAI,
   analyzeTrading,
+  analyzePerformance,
+  getMarketAdvice,
   callOpenAICompatible,
   callAnthropic,
   callGemini,