hedgequantx 2.5.37 → 2.5.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.5.37",
+  "version": "2.5.38",
   "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,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/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
 };