hedgequantx 2.5.38 → 2.5.40

package/package.json

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

package/src/pages/stats.js

@@ -481,84 +481,147 @@ const showStats = async (service) => {
       
       drawBoxFooter(boxWidth);
       
-      // ========== AI BEHAVIOR GRAPH ==========
-      const behaviorData = StrategySupervisor.getBehaviorHistory(boxWidth - 20);
+      // ========== AI BEHAVIOR DIAGRAM ==========
+      const behaviorData = StrategySupervisor.getBehaviorHistory(100);
       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);
+      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);
         
-        // 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);
+        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);
           }
-        };
-        
-        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'));
+          
+          if (i < 3) line += '   '; // Space between bars
         }
         
-        // 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);
+        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'));
+      
+      // Current session stats line
+      const statsLine = `  CURRENT: ${barColors[currentAction](currentAction)} | SESSION 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'));
+      
+      // Lifetime stats line (memory across sessions)
+      const lifetimeStats = StrategySupervisor.getLifetimeStats();
+      if (lifetimeStats.totalSessions > 0) {
+        const lifetimeLine = `  LIFETIME: ${lifetimeStats.totalSessions} sessions | ${lifetimeStats.totalTrades} trades | WR: ${lifetimeStats.lifetimeWinRate} | P&L: $${lifetimeStats.lifetimePnL.toFixed(2)} | ${lifetimeStats.patternsLearned.winning + lifetimeStats.patternsLearned.losing} patterns learned`;
+        const lifetimeLen = lifetimeLine.length;
+        console.log(chalk.cyan('\u2551') + chalk.magenta(lifetimeLine) + ' '.repeat(Math.max(0, behaviorInnerWidth - lifetimeLen)) + chalk.cyan('\u2551'));
+      }
+      
+      drawBoxFooter(boxWidth);
     }
     
     // ========== EQUITY CURVE ==========

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

@@ -8,12 +8,114 @@
  * 2. LEARN - Analyze winning/losing trades to identify patterns
  * 3. OPTIMIZE - Suggest and apply parameter improvements
  * 4. SUPERVISE - Monitor risk and intervene when necessary
+ * 5. PERSIST - Save learned patterns and optimizations between sessions
  * 
  * In CONSENSUS mode (2+ agents), ALL agents must agree before applying changes.
  */
 
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 const { analyzePerformance, getMarketAdvice, callAI } = require('./client');
 
+// Path for persisted learning data
+const DATA_DIR = path.join(os.homedir(), '.hqx');
+const LEARNING_FILE = path.join(DATA_DIR, 'ai-learning.json');
+
+/**
+ * Load persisted learning data from disk
+ * Called on startup to restore previous learnings
+ */
+const loadLearningData = () => {
+  try {
+    if (!fs.existsSync(DATA_DIR)) {
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+    }
+    
+    if (fs.existsSync(LEARNING_FILE)) {
+      const data = JSON.parse(fs.readFileSync(LEARNING_FILE, 'utf8'));
+      return {
+        winningPatterns: data.winningPatterns || [],
+        losingPatterns: data.losingPatterns || [],
+        optimizations: data.optimizations || [],
+        totalSessions: data.totalSessions || 0,
+        totalTrades: data.totalTrades || 0,
+        totalWins: data.totalWins || 0,
+        totalLosses: data.totalLosses || 0,
+        lifetimePnL: data.lifetimePnL || 0,
+        lastUpdated: data.lastUpdated || null
+      };
+    }
+  } catch (e) {
+    // Silent fail - start fresh
+  }
+  
+  return {
+    winningPatterns: [],
+    losingPatterns: [],
+    optimizations: [],
+    totalSessions: 0,
+    totalTrades: 0,
+    totalWins: 0,
+    totalLosses: 0,
+    lifetimePnL: 0,
+    lastUpdated: null
+  };
+};
+
+/**
+ * Save learning data to disk
+ * Called after each trade and on session end
+ */
+const saveLearningData = () => {
+  try {
+    if (!fs.existsSync(DATA_DIR)) {
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+    }
+    
+    // Load existing data first
+    const existing = loadLearningData();
+    
+    // Merge with current session data
+    const dataToSave = {
+      // Patterns - keep last 100 of each type (merge and dedupe by timestamp)
+      winningPatterns: mergePatterns(existing.winningPatterns, supervisorState.winningPatterns, 100),
+      losingPatterns: mergePatterns(existing.losingPatterns, supervisorState.losingPatterns, 100),
+      
+      // Optimizations history - keep last 50
+      optimizations: [...existing.optimizations, ...supervisorState.optimizations].slice(-50),
+      
+      // Lifetime stats
+      totalSessions: existing.totalSessions + (supervisorState.active ? 0 : 1),
+      totalTrades: existing.totalTrades + supervisorState.performance.trades,
+      totalWins: existing.totalWins + supervisorState.performance.wins,
+      totalLosses: existing.totalLosses + supervisorState.performance.losses,
+      lifetimePnL: existing.lifetimePnL + supervisorState.performance.totalPnL,
+      
+      // Metadata
+      lastUpdated: new Date().toISOString()
+    };
+    
+    fs.writeFileSync(LEARNING_FILE, JSON.stringify(dataToSave, null, 2));
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+/**
+ * Merge pattern arrays, keeping most recent unique entries
+ */
+const mergePatterns = (existing, current, maxCount) => {
+  const merged = [...existing, ...current];
+  
+  // Sort by timestamp descending (most recent first)
+  merged.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+  
+  // Keep only maxCount most recent
+  return merged.slice(0, maxCount);
+};
+
 // Singleton supervisor state
 let supervisorState = {
   active: false,
@@ -69,10 +171,14 @@ let analysisInterval = null;
 
 /**
  * Initialize supervisor with strategy and agents
+ * Loads previous learning data to continue improving
  */
 const initialize = (strategy, agents, service, accountId) => {
   const now = Date.now();
   
+  // Load previously learned patterns and optimizations
+  const previousLearning = loadLearningData();
+  
   supervisorState = {
     ...supervisorState,
     active: true,
@@ -83,8 +189,17 @@ const initialize = (strategy, agents, service, accountId) => {
     ticks: [],
     signals: [],
     trades: [],
-    winningPatterns: [],
-    losingPatterns: [],
+    // Restore previous learning
+    winningPatterns: previousLearning.winningPatterns || [],
+    losingPatterns: previousLearning.losingPatterns || [],
+    previousOptimizations: previousLearning.optimizations || [],
+    lifetimeStats: {
+      sessions: previousLearning.totalSessions || 0,
+      trades: previousLearning.totalTrades || 0,
+      wins: previousLearning.totalWins || 0,
+      losses: previousLearning.totalLosses || 0,
+      pnl: previousLearning.lifetimePnL || 0
+    },
     performance: {
       trades: 0,
       wins: 0,
@@ -124,7 +239,7 @@ const initialize = (strategy, agents, service, accountId) => {
 };
 
 /**
- * Stop supervisor
+ * Stop supervisor and save learned data
  */
 const stop = () => {
   if (analysisInterval) {
@@ -132,11 +247,16 @@ const stop = () => {
     analysisInterval = null;
   }
   
+  // Save all learned data before stopping
+  const saved = saveLearningData();
+  
   const summary = {
     ...supervisorState.performance,
     optimizationsApplied: supervisorState.optimizations.length,
     winningPatterns: supervisorState.winningPatterns.length,
-    losingPatterns: supervisorState.losingPatterns.length
+    losingPatterns: supervisorState.losingPatterns.length,
+    dataSaved: saved,
+    lifetimeStats: supervisorState.lifetimeStats
   };
   
   supervisorState.active = false;
@@ -768,6 +888,44 @@ const getLearningStats = () => {
   };
 };
 
+/**
+ * Get lifetime stats across all sessions
+ * Shows cumulative learning progress
+ */
+const getLifetimeStats = () => {
+  const saved = loadLearningData();
+  
+  return {
+    totalSessions: saved.totalSessions,
+    totalTrades: saved.totalTrades,
+    totalWins: saved.totalWins,
+    totalLosses: saved.totalLosses,
+    lifetimeWinRate: saved.totalTrades > 0 ? 
+      ((saved.totalWins / saved.totalTrades) * 100).toFixed(1) + '%' : 'N/A',
+    lifetimePnL: saved.lifetimePnL,
+    patternsLearned: {
+      winning: saved.winningPatterns?.length || 0,
+      losing: saved.losingPatterns?.length || 0
+    },
+    optimizationsApplied: saved.optimizations?.length || 0,
+    lastUpdated: saved.lastUpdated
+  };
+};
+
+/**
+ * Clear all learned data (reset AI memory)
+ */
+const clearLearningData = () => {
+  try {
+    if (fs.existsSync(LEARNING_FILE)) {
+      fs.unlinkSync(LEARNING_FILE);
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
 module.exports = {
   initialize,
   stop,
@@ -779,5 +937,8 @@ module.exports = {
   getStatus,
   analyzeAndOptimize,
   getBehaviorHistory,
-  getLearningStats
+  getLearningStats,
+  getLifetimeStats,
+  clearLearningData,
+  loadLearningData
 };