hedgequantx 2.9.50 → 2.9.51

package/package.json

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

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,
+};