hedgequantx 2.9.49 → 2.9.51

package/package.json

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

package/src/lib/data.js

@@ -113,6 +113,7 @@ class MarketDataFeed extends EventEmitter {
       });
 
       this.subscriptions.add(key);
+      this.emit('subscribed', `${symbol}:${exchange}`);
     } catch (e) {
       this.emit('error', e);
       throw e;
@@ -172,9 +173,17 @@ class MarketDataFeed extends EventEmitter {
   _handleMessage(msg) {
     const { templateId, data } = msg;
 
+    // Debug: log all message template IDs
+    if (!this._seenTemplates) this._seenTemplates = new Set();
+    if (!this._seenTemplates.has(templateId)) {
+      this._seenTemplates.add(templateId);
+      this.emit('debug', `New message type: templateId=${templateId}`);
+    }
+
     switch (templateId) {
       case RES.MARKET_DATA:
         // Subscription confirmed
+        this.emit('debug', 'Market data subscription confirmed');
         break;
 
       case STREAM.LAST_TRADE:
@@ -186,7 +195,10 @@ class MarketDataFeed extends EventEmitter {
         break;
 
       default:
-        // Ignore other messages
+        // Log unknown messages for debugging
+        if (templateId && !this._seenTemplates.has(`logged_${templateId}`)) {
+          this._seenTemplates.add(`logged_${templateId}`);
+        }
         break;
     }
   }

package/src/pages/algo/algo-executor.js

@@ -93,7 +93,20 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   
   // Handle strategy signals
   strategy.on('signal', async (signal) => {
-    if (!running || pendingOrder || currentPosition !== 0) return;
+    ui.addLog('info', `SIGNAL DETECTED: ${signal.direction?.toUpperCase()}`);
+    
+    if (!running) {
+      ui.addLog('info', 'Signal ignored: not running');
+      return;
+    }
+    if (pendingOrder) {
+      ui.addLog('info', 'Signal ignored: order pending');
+      return;
+    }
+    if (currentPosition !== 0) {
+      ui.addLog('info', `Signal ignored: position open (${currentPosition})`);
+      return;
+    }
     
     let { direction, entry, stopLoss, takeProfit, confidence } = signal;
     let orderSize = contracts;
@@ -185,25 +198,85 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   });
   
   // Handle market data ticks
+  let lastPrice = null;
+  let lastBid = null;
+  let lastAsk = null;
+  let ticksPerSecond = 0;
+  let lastTickSecond = Math.floor(Date.now() / 1000);
+  
   marketFeed.on('tick', (tick) => {
     tickCount++;
     const latencyStart = Date.now();
+    const currentSecond = Math.floor(Date.now() / 1000);
+    
+    // Count ticks per second
+    if (currentSecond === lastTickSecond) {
+      ticksPerSecond++;
+    } else {
+      ticksPerSecond = 1;
+      lastTickSecond = currentSecond;
+    }
     
     aiContext.recentTicks.push(tick);
     if (aiContext.recentTicks.length > aiContext.maxTicks) aiContext.recentTicks.shift();
     
+    // Smart logs for tick flow
+    const price = tick.price || tick.tradePrice;
+    const bid = tick.bid || tick.bidPrice;
+    const ask = tick.ask || tick.askPrice;
+    
+    // Log first tick
+    if (tickCount === 1) {
+      ui.addLog('info', `First tick received @ ${price?.toFixed(2) || 'N/A'}`);
+      ui.addLog('info', `Tick type: ${tick.type || 'unknown'}`);
+    }
+    
+    // Log price changes
+    if (price && lastPrice && price !== lastPrice) {
+      const direction = price > lastPrice ? 'UP' : 'DOWN';
+      const change = Math.abs(price - lastPrice).toFixed(2);
+      if (tickCount <= 10 || tickCount % 50 === 0) {
+        ui.addLog('info', `Price ${direction} ${change} -> ${price.toFixed(2)}`);
+      }
+    }
+    
+    // Log bid/ask spread
+    if (bid && ask && (bid !== lastBid || ask !== lastAsk)) {
+      const spread = (ask - bid).toFixed(2);
+      if (tickCount <= 5) {
+        ui.addLog('info', `Spread: ${spread} (Bid: ${bid.toFixed(2)} / Ask: ${ask.toFixed(2)})`);
+      }
+    }
+    
+    lastPrice = price;
+    lastBid = bid;
+    lastAsk = ask;
+    
     strategy.processTick({
       contractId: tick.contractId || contractId,
-      price: tick.price, bid: tick.bid, ask: tick.ask,
-      volume: tick.volume || 1, side: tick.lastTradeSide || 'unknown',
+      price: price, bid: bid, ask: ask,
+      volume: tick.volume || tick.size || 1, 
+      side: tick.side || tick.lastTradeSide || 'unknown',
       timestamp: tick.timestamp || Date.now()
     });
     
     stats.latency = Date.now() - latencyStart;
-    if (tickCount % 100 === 0) ui.addLog('info', `Tick #${tickCount} @ ${tick.price?.toFixed(2) || 'N/A'}`);
+    
+    // Periodic status logs
+    if (tickCount === 10) ui.addLog('info', `Receiving ticks... (${ticksPerSecond}/sec)`);
+    if (tickCount === 50) ui.addLog('info', `50 ticks processed, strategy analyzing...`);
+    if (tickCount % 200 === 0) {
+      ui.addLog('info', `Tick #${tickCount} @ ${price?.toFixed(2) || 'N/A'} | ${ticksPerSecond}/sec`);
+    }
   });
   
-  marketFeed.on('connected', () => { stats.connected = true; ui.addLog('connected', 'Market data connected!'); });
+  marketFeed.on('connected', () => { 
+    stats.connected = true; 
+    ui.addLog('connected', 'Market data connected!');
+    ui.addLog('info', 'Subscribing to market data...');
+  });
+  marketFeed.on('subscribed', (symbol) => ui.addLog('info', `Subscribed to ${symbol}`));
+  marketFeed.on('debug', (msg) => ui.addLog('info', msg));
   marketFeed.on('error', (err) => ui.addLog('error', `Market: ${err.message}`));
   marketFeed.on('disconnected', () => { stats.connected = false; ui.addLog('error', 'Market disconnected'); });
   

package/src/pages/algo/copy-trading.js

@@ -14,6 +14,7 @@ const { getActiveAgentCount, getSupervisionConfig, getActiveAgents } = require('
 const { launchCopyTrading } = require('./copy-executor');
 const { runPreflightCheck, formatPreflightResults, getPreflightSummary } = require('../../services/ai-supervision');
 const { getAvailableStrategies } = require('../../lib/m');
+const { getLastCopyTradingConfig, saveCopyTradingConfig } = require('../../services/algo-config');
 
 /**
  * Copy Trading Menu
@@ -54,6 +55,98 @@ const copyTradingMenu = async () => {
   
   spinner.succeed(`Found ${activeAccounts.length} active accounts`);
   
+  // Check for saved config
+  const lastConfig = getLastCopyTradingConfig();
+  
+  if (lastConfig) {
+    // Try to find matching accounts
+    const matchingLead = activeAccounts.find(acc => 
+      acc.accountId === lastConfig.leadAccountId || 
+      acc.accountName === lastConfig.leadAccountName
+    );
+    
+    if (matchingLead && lastConfig.followerAccountIds?.length > 0) {
+      const matchingFollowers = lastConfig.followerAccountIds
+        .map(id => activeAccounts.find(acc => acc.accountId === id || acc.accountName === id))
+        .filter(Boolean);
+      
+      if (matchingFollowers.length > 0) {
+        console.log();
+        console.log(chalk.cyan('  Last configuration found:'));
+        console.log(chalk.gray(`    Lead: ${lastConfig.leadAccountName} (${lastConfig.leadPropfirm})`));
+        console.log(chalk.gray(`    Followers: ${matchingFollowers.length} account(s)`));
+        console.log(chalk.gray(`    Symbol: ${lastConfig.symbol}`));
+        console.log(chalk.gray(`    Strategy: ${lastConfig.strategyName}`));
+        console.log(chalk.gray(`    Lead contracts: ${lastConfig.leadContracts} | Follower: ${lastConfig.followerContracts}`));
+        console.log(chalk.gray(`    Target: $${lastConfig.dailyTarget} | Risk: $${lastConfig.maxRisk}`));
+        console.log();
+        
+        const reuseConfig = await prompts.confirmPrompt('Use last configuration?', true);
+        
+        if (reuseConfig) {
+          // Load contracts to find symbol
+          const leadService = matchingLead.service || connections.getServiceForAccount(matchingLead.accountId);
+          const contractsResult = await leadService.getContracts();
+          const contract = contractsResult.success 
+            ? contractsResult.contracts.find(c => c.symbol === lastConfig.symbol)
+            : null;
+          
+          // Find strategy
+          const strategies = getAvailableStrategies();
+          const strategy = strategies.find(s => s.id === lastConfig.strategyId);
+          
+          if (contract && strategy) {
+            console.log(chalk.green('  ✓ Configuration loaded'));
+            
+            // Check for AI Supervision
+            const agentCount = getActiveAgentCount();
+            let supervisionConfig = null;
+            
+            if (agentCount > 0) {
+              console.log();
+              console.log(chalk.cyan(`  ${agentCount} AI Agent(s) available for supervision`));
+              const enableAI = await prompts.confirmPrompt('Enable AI Supervision?', true);
+              
+              if (enableAI) {
+                const agents = getActiveAgents();
+                const preflightResults = await runPreflightCheck(agents);
+                const lines = formatPreflightResults(preflightResults, 60);
+                for (const line of lines) console.log(line);
+                const summary = getPreflightSummary(preflightResults);
+                console.log();
+                console.log(`  ${summary.text}`);
+                
+                if (!preflightResults.success) {
+                  console.log(chalk.red('  Cannot start algo - fix agent connections first.'));
+                  await prompts.waitForEnter();
+                  return;
+                }
+                supervisionConfig = getSupervisionConfig();
+              }
+            }
+            
+            const confirm = await prompts.confirmPrompt('Start Copy Trading?', true);
+            if (!confirm) return;
+            
+            await launchCopyTrading({
+              lead: { account: matchingLead, contracts: lastConfig.leadContracts },
+              followers: matchingFollowers.map(f => ({ account: f, contracts: lastConfig.followerContracts })),
+              contract,
+              strategy,
+              dailyTarget: lastConfig.dailyTarget,
+              maxRisk: lastConfig.maxRisk,
+              showNames: lastConfig.showNames,
+              supervisionConfig
+            });
+            return;
+          } else {
+            console.log(chalk.yellow('  Symbol or strategy no longer available, please reconfigure'));
+          }
+        }
+      }
+    }
+  }
+  
   // Step 1: Select LEAD Account
   console.log();
   console.log(chalk.cyan.bold('  STEP 1: SELECT LEAD ACCOUNT'));
@@ -204,6 +297,22 @@ const copyTradingMenu = async () => {
   const confirm = await prompts.confirmPrompt('Start Copy Trading?', true);
   if (!confirm) return;
   
+  // Save config for next time
+  saveCopyTradingConfig({
+    leadAccountId: leadAccount.accountId || leadAccount.rithmicAccountId,
+    leadAccountName: leadAccount.accountName || leadAccount.rithmicAccountId || leadAccount.accountId,
+    leadPropfirm: leadAccount.propfirm || leadAccount.platform || 'Unknown',
+    followerAccountIds: followers.map(f => f.accountId || f.rithmicAccountId),
+    symbol: contract.symbol,
+    strategyId: strategy.id,
+    strategyName: strategy.name,
+    leadContracts,
+    followerContracts,
+    dailyTarget,
+    maxRisk,
+    showNames
+  });
+  
   await launchCopyTrading({
     lead: { account: leadAccount, contracts: leadContracts },
     followers: followers.map(f => ({ account: f, contracts: followerContracts })),

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

@@ -13,6 +13,7 @@ const { executeAlgo } = require('./algo-executor');
 const { getActiveAgentCount, getSupervisionConfig, getActiveAgents } = require('../ai-agents');
 const { runPreflightCheck, formatPreflightResults, getPreflightSummary } = require('../../services/ai-supervision');
 const { getAvailableStrategies } = require('../../lib/m');
+const { getLastOneAccountConfig, saveOneAccountConfig } = require('../../services/algo-config');
 
 
 
@@ -54,37 +55,112 @@ const oneAccountMenu = async (service) => {
   
   spinner.succeed(`Found ${activeAccounts.length} active account(s)`);
   
-  // Select account - display RAW API fields
-  const options = activeAccounts.map(acc => {
-    // Use what API returns: rithmicAccountId or accountName for Rithmic
-    const name = acc.accountName || acc.rithmicAccountId || acc.accountId;
-    const balance = acc.balance !== null && acc.balance !== undefined 
-      ? ` - $${acc.balance.toLocaleString()}` 
-      : '';
-    return {
-      label: `${name} (${acc.propfirm || acc.platform || 'Unknown'})${balance}`,
-      value: acc
-    };
-  });
-  options.push({ label: '< Back', value: 'back' });
-  
-  const selectedAccount = await prompts.selectOption('Select Account:', options);
-  if (!selectedAccount || selectedAccount === 'back') return;
-  
-  // Use the service attached to the account (from getAllAccounts), fallback to getServiceForAccount
-  const accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
-  
-  // Select symbol
-  const contract = await selectSymbol(accountService, selectedAccount);
-  if (!contract) return;
-  
-  // Select strategy
-  const strategy = await selectStrategy();
-  if (!strategy) return;
+  // Check for saved config
+  const lastConfig = getLastOneAccountConfig();
+  let selectedAccount = null;
+  let contract = null;
+  let strategy = null;
+  let config = null;
+  let accountService = null;
+  
+  if (lastConfig) {
+    // Try to find matching account and offer to reuse config
+    const matchingAccount = activeAccounts.find(acc => 
+      acc.accountId === lastConfig.accountId || 
+      acc.rithmicAccountId === lastConfig.accountId ||
+      acc.accountName === lastConfig.accountName
+    );
+    
+    if (matchingAccount) {
+      console.log();
+      console.log(chalk.cyan('  Last configuration found:'));
+      console.log(chalk.gray(`    Account: ${lastConfig.accountName} (${lastConfig.propfirm})`));
+      console.log(chalk.gray(`    Symbol: ${lastConfig.symbol}`));
+      console.log(chalk.gray(`    Strategy: ${lastConfig.strategyName}`));
+      console.log(chalk.gray(`    Contracts: ${lastConfig.contracts} | Target: $${lastConfig.dailyTarget} | Risk: $${lastConfig.maxRisk}`));
+      console.log();
+      
+      const reuseConfig = await prompts.confirmPrompt('Use last configuration?', true);
+      
+      if (reuseConfig) {
+        selectedAccount = matchingAccount;
+        accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
+        
+        // Load contracts to find the saved symbol
+        const contractsResult = await accountService.getContracts();
+        if (contractsResult.success) {
+          contract = contractsResult.contracts.find(c => c.symbol === lastConfig.symbol);
+        }
+        
+        // Find strategy
+        const strategies = getAvailableStrategies();
+        strategy = strategies.find(s => s.id === lastConfig.strategyId);
+        
+        // Restore config
+        if (contract && strategy) {
+          config = {
+            contracts: lastConfig.contracts,
+            dailyTarget: lastConfig.dailyTarget,
+            maxRisk: lastConfig.maxRisk,
+            showName: lastConfig.showName
+          };
+          console.log(chalk.green('  ✓ Configuration loaded'));
+        } else {
+          console.log(chalk.yellow('  Symbol or strategy no longer available, please reconfigure'));
+          selectedAccount = null;
+        }
+      }
+    }
+  }
   
-  // Configure algo
-  const config = await configureAlgo(selectedAccount, contract, strategy);
-  if (!config) return;
+  // If no saved config used, go through normal selection
+  if (!selectedAccount) {
+    // Select account - display RAW API fields
+    const options = activeAccounts.map(acc => {
+      // Use what API returns: rithmicAccountId or accountName for Rithmic
+      const name = acc.accountName || acc.rithmicAccountId || acc.accountId;
+      const balance = acc.balance !== null && acc.balance !== undefined 
+        ? ` - $${acc.balance.toLocaleString()}` 
+        : '';
+      return {
+        label: `${name} (${acc.propfirm || acc.platform || 'Unknown'})${balance}`,
+        value: acc
+      };
+    });
+    options.push({ label: '< Back', value: 'back' });
+    
+    selectedAccount = await prompts.selectOption('Select Account:', options);
+    if (!selectedAccount || selectedAccount === 'back') return;
+    
+    // Use the service attached to the account (from getAllAccounts), fallback to getServiceForAccount
+    accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
+    
+    // Select symbol
+    contract = await selectSymbol(accountService, selectedAccount);
+    if (!contract) return;
+    
+    // Select strategy
+    strategy = await selectStrategy();
+    if (!strategy) return;
+    
+    // Configure algo
+    config = await configureAlgo(selectedAccount, contract, strategy);
+    if (!config) return;
+    
+    // Save config for next time
+    saveOneAccountConfig({
+      accountId: selectedAccount.accountId || selectedAccount.rithmicAccountId,
+      accountName: selectedAccount.accountName || selectedAccount.rithmicAccountId || selectedAccount.accountId,
+      propfirm: selectedAccount.propfirm || selectedAccount.platform || 'Unknown',
+      symbol: contract.symbol,
+      strategyId: strategy.id,
+      strategyName: strategy.name,
+      contracts: config.contracts,
+      dailyTarget: config.dailyTarget,
+      maxRisk: config.maxRisk,
+      showName: config.showName
+    });
+  }
   
   // Check for AI Supervision BEFORE asking to start
   const agentCount = getActiveAgentCount();

package/src/services/algo-config.js

@@ -0,0 +1,102 @@
+/**
+ * Algo Config Storage - Persist algo configuration between sessions
+ * Saves to ~/.hqx/algo-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.hqx');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'algo-config.json');
+
+/**
+ * Ensure config directory exists
+ */
+const ensureConfigDir = () => {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+};
+
+/**
+ * Load saved config
+ * @returns {Object|null} Saved config or null
+ */
+const loadConfig = () => {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const data = fs.readFileSync(CONFIG_FILE, 'utf8');
+      return JSON.parse(data);
+    }
+  } catch (e) {
+    // Ignore errors, return null
+  }
+  return null;
+};
+
+/**
+ * Save config
+ * @param {Object} config - Config to save
+ */
+const saveConfig = (config) => {
+  try {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  } catch (e) {
+    // Ignore save errors
+  }
+};
+
+/**
+ * Get last config for one-account mode
+ * @returns {Object|null}
+ */
+const getLastOneAccountConfig = () => {
+  const config = loadConfig();
+  return config?.oneAccount || null;
+};
+
+/**
+ * Save one-account config
+ * @param {Object} data - { accountId, accountName, propfirm, symbol, strategyId, contracts, dailyTarget, maxRisk, showName }
+ */
+const saveOneAccountConfig = (data) => {
+  const config = loadConfig() || {};
+  config.oneAccount = {
+    ...data,
+    savedAt: Date.now()
+  };
+  saveConfig(config);
+};
+
+/**
+ * Get last config for copy-trading mode
+ * @returns {Object|null}
+ */
+const getLastCopyTradingConfig = () => {
+  const config = loadConfig();
+  return config?.copyTrading || null;
+};
+
+/**
+ * Save copy-trading config
+ * @param {Object} data - { masterAccountId, followerAccountIds, symbol, strategyId, contracts, dailyTarget, maxRisk }
+ */
+const saveCopyTradingConfig = (data) => {
+  const config = loadConfig() || {};
+  config.copyTrading = {
+    ...data,
+    savedAt: Date.now()
+  };
+  saveConfig(config);
+};
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  getLastOneAccountConfig,
+  saveOneAccountConfig,
+  getLastCopyTradingConfig,
+  saveCopyTradingConfig,
+};