hedgequantx 2.5.37 → 2.5.39

package/package.json

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

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,141 @@ const showStats = async (service) => {
       }
       
       drawBoxFooter(boxWidth);
+      
+      // ========== AI BEHAVIOR DIAGRAM ==========
+      const behaviorData = StrategySupervisor.getBehaviorHistory(100);
+      const learningStats = StrategySupervisor.getLearningStats();
+      
+      console.log();
+      drawBoxHeader('AI AGENTS BEHAVIOR', boxWidth);
+      
+      const behaviorInnerWidth = boxWidth - 2;
+      
+      // Count behavior occurrences
+      const behaviorCounts = { AGGRESSIVE: 0, NORMAL: 0, CAUTIOUS: 0, PAUSE: 0 };
+      const valueToAction = { 3: 'AGGRESSIVE', 2: 'NORMAL', 1: 'CAUTIOUS', 0: 'PAUSE' };
+      
+      if (behaviorData.values.length > 0) {
+        for (const val of behaviorData.values) {
+          const action = valueToAction[Math.round(val)] || 'NORMAL';
+          behaviorCounts[action]++;
+        }
+      } else {
+        behaviorCounts.NORMAL = 1; // Default
+      }
+      
+      const total = Object.values(behaviorCounts).reduce((a, b) => a + b, 0) || 1;
+      const percentages = {
+        AGGRESSIVE: Math.round((behaviorCounts.AGGRESSIVE / total) * 100),
+        NORMAL: Math.round((behaviorCounts.NORMAL / total) * 100),
+        CAUTIOUS: Math.round((behaviorCounts.CAUTIOUS / total) * 100),
+        PAUSE: Math.round((behaviorCounts.PAUSE / total) * 100)
+      };
+      
+      // Bar chart configuration
+      const labelWidth = 12;
+      const percentWidth = 6;
+      const barMaxWidth = behaviorInnerWidth - labelWidth - percentWidth - 6;
+      
+      // Get current behavior
+      const currentValue = behaviorData.values.length > 0 ? behaviorData.values[behaviorData.values.length - 1] : 2;
+      const currentAction = valueToAction[Math.round(currentValue)] || 'NORMAL';
+      
+      // Draw vertical bar chart (bars going up)
+      const chartHeight = 8;
+      const barWidth = Math.floor((barMaxWidth - 12) / 4); // 4 bars with spacing
+      
+      // Calculate bar heights (max height = chartHeight)
+      const maxPercent = Math.max(...Object.values(percentages), 1);
+      const barHeights = {
+        AGGRESSIVE: Math.round((percentages.AGGRESSIVE / 100) * chartHeight),
+        NORMAL: Math.round((percentages.NORMAL / 100) * chartHeight),
+        CAUTIOUS: Math.round((percentages.CAUTIOUS / 100) * chartHeight),
+        PAUSE: Math.round((percentages.PAUSE / 100) * chartHeight)
+      };
+      
+      // Colors for each behavior
+      const barColors = {
+        AGGRESSIVE: chalk.green,
+        NORMAL: chalk.cyan,
+        CAUTIOUS: chalk.yellow,
+        PAUSE: chalk.red
+      };
+      
+      // Draw bars from top to bottom
+      const barLabels = ['AGGRESSIVE', 'NORMAL', 'CAUTIOUS', 'PAUSE'];
+      const shortLabels = ['AGR', 'NOR', 'CAU', 'PAU'];
+      
+      // Calculate left padding to center the chart
+      const totalBarWidth = (barWidth * 4) + 9; // 4 bars + 3 spaces of 3 chars
+      const leftPad = Math.floor((behaviorInnerWidth - totalBarWidth - 4) / 2);
+      
+      for (let row = chartHeight; row >= 1; row--) {
+        let line = ' '.repeat(leftPad);
+        
+        for (let i = 0; i < 4; i++) {
+          const label = barLabels[i];
+          const height = barHeights[label];
+          const color = barColors[label];
+          const isCurrent = label === currentAction;
+          
+          if (row <= height) {
+            // Draw filled bar
+            const block = isCurrent ? '█' : '▓';
+            line += color(block.repeat(barWidth));
+          } else {
+            // Empty space
+            line += ' '.repeat(barWidth);
+          }
+          
+          if (i < 3) line += '   '; // Space between bars
+        }
+        
+        const lineLen = line.replace(/\x1b\[[0-9;]*m/g, '').length;
+        line += ' '.repeat(Math.max(0, behaviorInnerWidth - lineLen));
+        console.log(chalk.cyan('\u2551') + line + chalk.cyan('\u2551'));
+      }
+      
+      // Draw baseline
+      let baseLine = ' '.repeat(leftPad) + '─'.repeat(totalBarWidth);
+      const baseLen = baseLine.length;
+      baseLine += ' '.repeat(Math.max(0, behaviorInnerWidth - baseLen));
+      console.log(chalk.cyan('\u2551') + chalk.white(baseLine) + chalk.cyan('\u2551'));
+      
+      // Draw labels
+      let labelLine = ' '.repeat(leftPad);
+      for (let i = 0; i < 4; i++) {
+        const lbl = shortLabels[i];
+        const pad = Math.floor((barWidth - lbl.length) / 2);
+        labelLine += ' '.repeat(pad) + barColors[barLabels[i]](lbl) + ' '.repeat(barWidth - pad - lbl.length);
+        if (i < 3) labelLine += '   ';
+      }
+      const lblLen = labelLine.replace(/\x1b\[[0-9;]*m/g, '').length;
+      labelLine += ' '.repeat(Math.max(0, behaviorInnerWidth - lblLen));
+      console.log(chalk.cyan('\u2551') + labelLine + chalk.cyan('\u2551'));
+      
+      // Draw percentages
+      let pctLine = ' '.repeat(leftPad);
+      for (let i = 0; i < 4; i++) {
+        const pct = percentages[barLabels[i]] + '%';
+        const pad = Math.floor((barWidth - pct.length) / 2);
+        pctLine += ' '.repeat(pad) + chalk.white(pct) + ' '.repeat(barWidth - pad - pct.length);
+        if (i < 3) pctLine += '   ';
+      }
+      const pctLen = pctLine.replace(/\x1b\[[0-9;]*m/g, '').length;
+      pctLine += ' '.repeat(Math.max(0, behaviorInnerWidth - pctLen));
+      console.log(chalk.cyan('\u2551') + pctLine + chalk.cyan('\u2551'));
+      
+      // Empty line
+      console.log(chalk.cyan('\u2551') + ' '.repeat(behaviorInnerWidth) + chalk.cyan('\u2551'));
+      
+      // Stats line
+      const durationMin = behaviorData.duration ? Math.floor(behaviorData.duration / 60000) : 0;
+      const statsLine = `  CURRENT: ${barColors[currentAction](currentAction)} | PATTERNS: ${learningStats.patternsLearned.total} (${learningStats.patternsLearned.winning}W/${learningStats.patternsLearned.losing}L) | OPTIMIZATIONS: ${learningStats.optimizations}`;
+      const statsLen = statsLine.replace(/\x1b\[[0-9;]*m/g, '').length;
+      console.log(chalk.cyan('\u2551') + statsLine + ' '.repeat(Math.max(0, behaviorInnerWidth - statsLen)) + chalk.cyan('\u2551'));
+      
+      drawBoxFooter(boxWidth);
     }
     
     // ========== EQUITY CURVE ==========

package/src/services/ai/strategy-supervisor.js

@@ -56,7 +56,12 @@ let supervisorState = {
     action: 'NORMAL',
     sizeMultiplier: 1.0,
     reason: 'Starting'
-  }
+  },
+  
+  // Behavior history for graph (action over time)
+  // Values: 0=PAUSE, 1=CAUTIOUS, 2=NORMAL, 3=AGGRESSIVE
+  behaviorHistory: [],
+  behaviorStartTime: null
 };
 
 // Analysis interval
@@ -66,6 +71,8 @@ let analysisInterval = null;
  * Initialize supervisor with strategy and agents
  */
 const initialize = (strategy, agents, service, accountId) => {
+  const now = Date.now();
+  
   supervisorState = {
     ...supervisorState,
     active: true,
@@ -92,13 +99,23 @@ const initialize = (strategy, agents, service, accountId) => {
       maxLossStreak: 0
     },
     optimizations: [],
-    lastOptimizationTime: Date.now()
+    lastOptimizationTime: now,
+    behaviorHistory: [{ timestamp: now, value: 2, action: 'NORMAL' }], // Start with NORMAL
+    behaviorStartTime: now,
+    currentAdvice: { action: 'NORMAL', sizeMultiplier: 1.0, reason: 'Starting' }
   };
   
   // Start continuous analysis loop
   if (analysisInterval) clearInterval(analysisInterval);
   analysisInterval = setInterval(analyzeAndOptimize, supervisorState.optimizationInterval);
   
+  // Also record behavior every 10 seconds to have smooth graph
+  setInterval(() => {
+    if (supervisorState.active) {
+      recordBehavior(supervisorState.currentAdvice.action);
+    }
+  }, 10000);
+  
   return {
     success: true,
     agents: agents.length,
@@ -410,6 +427,7 @@ const analyzeAndOptimize = async () => {
         sizeMultiplier: consensusResult.sizeMultiplier || 1.0,
         reason: consensusResult.reason || 'Consensus recommendation'
       };
+      recordBehavior(consensusResult.action);
     }
   } else {
     // INDIVIDUAL MODE: Apply single agent's suggestions
@@ -427,12 +445,40 @@ const analyzeAndOptimize = async () => {
         sizeMultiplier: suggestion.sizeMultiplier || 1.0,
         reason: suggestion.reason || 'Agent recommendation'
       };
+      recordBehavior(suggestion.action);
     }
   }
   
   supervisorState.lastOptimizationTime = Date.now();
 };
 
+/**
+ * Record behavior for graph visualization
+ * Converts action to numeric value: PAUSE=0, CAUTIOUS=1, NORMAL=2, AGGRESSIVE=3
+ */
+const recordBehavior = (action) => {
+  const actionToValue = {
+    'PAUSE': 0,
+    'CAUTIOUS': 1,
+    'NORMAL': 2,
+    'AGGRESSIVE': 3
+  };
+  
+  const value = actionToValue[action] ?? 2; // Default to NORMAL
+  const now = Date.now();
+  
+  supervisorState.behaviorHistory.push({
+    timestamp: now,
+    value,
+    action
+  });
+  
+  // Keep last 200 data points
+  if (supervisorState.behaviorHistory.length > 200) {
+    supervisorState.behaviorHistory = supervisorState.behaviorHistory.slice(-200);
+  }
+};
+
 /**
  * Analyze patterns in losing trades
  */
@@ -662,6 +708,66 @@ const shouldTrade = () => {
   };
 };
 
+/**
+ * Get behavior history for graph visualization
+ * Returns array of numeric values (0-3) representing agent behavior over time
+ * 
+ * @param {number} maxPoints - Maximum data points to return
+ * @returns {Object} { values: number[], labels: string[], startTime: number }
+ */
+const getBehaviorHistory = (maxPoints = 50) => {
+  if (!supervisorState.active || supervisorState.behaviorHistory.length === 0) {
+    return { values: [], labels: [], startTime: null };
+  }
+  
+  let history = [...supervisorState.behaviorHistory];
+  
+  // Downsample if too many points
+  if (history.length > maxPoints) {
+    const step = Math.ceil(history.length / maxPoints);
+    history = history.filter((_, i) => i % step === 0);
+  }
+  
+  // If too few points, interpolate to make smooth curve
+  if (history.length < 10 && history.length > 1) {
+    const interpolated = [];
+    for (let i = 0; i < history.length - 1; i++) {
+      interpolated.push(history[i]);
+      // Add intermediate points
+      const curr = history[i].value;
+      const next = history[i + 1].value;
+      const mid = (curr + next) / 2;
+      interpolated.push({ value: mid, action: 'interpolated' });
+    }
+    interpolated.push(history[history.length - 1]);
+    history = interpolated;
+  }
+  
+  return {
+    values: history.map(h => h.value),
+    actions: history.map(h => h.action),
+    startTime: supervisorState.behaviorStartTime,
+    duration: Date.now() - supervisorState.behaviorStartTime
+  };
+};
+
+/**
+ * Get learning statistics for display
+ */
+const getLearningStats = () => {
+  return {
+    patternsLearned: {
+      winning: supervisorState.winningPatterns.length,
+      losing: supervisorState.losingPatterns.length,
+      total: supervisorState.winningPatterns.length + supervisorState.losingPatterns.length
+    },
+    optimizations: supervisorState.optimizations.length,
+    tradesAnalyzed: supervisorState.trades.length,
+    ticksProcessed: supervisorState.ticks.length,
+    signalsObserved: supervisorState.signals.length
+  };
+};
+
 module.exports = {
   initialize,
   stop,
@@ -671,5 +777,7 @@ module.exports = {
   getCurrentAdvice,
   shouldTrade,
   getStatus,
-  analyzeAndOptimize
+  analyzeAndOptimize,
+  getBehaviorHistory,
+  getLearningStats
 };