hedgequantx 1.4.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Prop Futures Algo Trading CLI - Connect to Topstep, Alpha Futures, and other prop firms",
   "main": "src/app.js",
   "bin": {

package/src/app.js

@@ -9,6 +9,9 @@ const ora = require('ora');
 
 const { connections } = require('./services');
 const { getLogoWidth, centerText, prepareStdin } = require('./ui');
+const { logger } = require('./utils');
+
+const log = logger.scope('App');
 
 // Pages
 const { showStats } = require('./pages/stats');
@@ -292,19 +295,23 @@ const mainMenu = async () => {
  */
 const run = async () => {
   try {
+    log.info('Starting HQX CLI');
     await banner();
     
     // Try to restore session
+    log.debug('Attempting to restore session');
     const spinner = ora({ text: 'Restoring session...', color: 'yellow' }).start();
     const restored = await connections.restoreFromStorage();
     
     if (restored) {
       spinner.succeed('Session restored');
       currentService = connections.getAll()[0].service;
+      log.info('Session restored', { connections: connections.count() });
       // Refresh stats after session restore
       await refreshStats();
     } else {
       spinner.info('No active session');
+      log.debug('No session to restore');
     }
 
     // Main loop
@@ -318,8 +325,10 @@ const run = async () => {
         
         if (!connections.isConnected()) {
           const choice = await mainMenu();
+          log.debug('Main menu choice', { choice });
           
           if (choice === 'exit') {
+            log.info('User exit');
             console.log(chalk.gray('Goodbye!'));
             process.exit(0);
           }
@@ -349,6 +358,7 @@ const run = async () => {
           }
         } else {
           const action = await dashboardMenu(currentService);
+          log.debug('Dashboard action', { action });
           
           switch (action) {
             case 'accounts':

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

@@ -12,12 +12,17 @@ const { connections } = require('../../services');
 const { HQXServerService } = require('../../services/hqx-server');
 const { FUTURES_SYMBOLS } = require('../../config');
 const { AlgoUI } = require('./ui');
+const { logger } = require('../../utils');
+
+const log = logger.scope('CopyTrading');
 
 /**
  * Copy Trading Menu
  */
 const copyTradingMenu = async () => {
+  log.info('Copy Trading menu opened');
   const allConns = connections.getAll();
+  log.debug('Connections found', { count: allConns.length });
   
   if (allConns.length < 2) {
     console.log();
@@ -60,6 +65,7 @@ const copyTradingMenu = async () => {
   }
   
   spinner.succeed(`Found ${allAccounts.length} active accounts`);
+  log.debug('Active accounts loaded', { count: allAccounts.length, accounts: allAccounts.map(a => ({ propfirm: a.propfirm, name: a.account.accountName })) });
   
   // Step 1: Select Lead Account
   console.log(chalk.cyan('  Step 1: Select LEAD Account (source of trades)'));
@@ -76,8 +82,12 @@ const copyTradingMenu = async () => {
     choices: leadChoices
   }]);
   
-  if (leadIdx === -1) return;
+  if (leadIdx === -1) {
+    log.debug('User cancelled at lead selection');
+    return;
+  }
   const lead = allAccounts[leadIdx];
+  log.debug('Lead account selected', { propfirm: lead.propfirm, account: lead.account.accountName });
   
   // Step 2: Select Follower Account
   console.log();
@@ -98,14 +108,23 @@ const copyTradingMenu = async () => {
     choices: followerChoices
   }]);
   
-  if (followerIdx === -1) return;
+  if (followerIdx === -1) {
+    log.debug('User cancelled at follower selection');
+    return;
+  }
   const follower = allAccounts[followerIdx];
+  log.debug('Follower account selected', { propfirm: follower.propfirm, account: follower.account.accountName });
   
   // Step 3: Select Symbol for Lead
   console.log();
   console.log(chalk.cyan('  Step 3: Select Symbol for LEAD'));
+  log.debug('Selecting symbol for lead', { serviceType: lead.type });
   const leadSymbol = await selectSymbol(lead.service, 'Lead');
-  if (!leadSymbol) return;
+  if (!leadSymbol) {
+    log.debug('Lead symbol selection failed or cancelled');
+    return;
+  }
+  log.debug('Lead symbol selected', { symbol: leadSymbol.name || leadSymbol.symbol });
   
   // Step 4: Select Symbol for Follower
   console.log();
@@ -184,8 +203,35 @@ const copyTradingMenu = async () => {
  * Symbol selection helper
  */
 const selectSymbol = async (service, label) => {
+  log.debug('selectSymbol called', { label, hasGetContracts: typeof service.getContracts === 'function' });
   try {
+    // Check if service has getContracts method
+    if (typeof service.getContracts !== 'function') {
+      log.warn('Service does not have getContracts method, using searchContracts fallback');
+      // Fallback: use searchContracts or return predefined list
+      if (typeof service.searchContracts === 'function') {
+        const contracts = await service.searchContracts('');
+        log.debug('searchContracts result', { count: contracts?.length });
+        if (contracts && contracts.length > 0) {
+          const choices = contracts.map(c => ({ name: c.name || c.symbol, value: c }));
+          choices.push({ name: chalk.yellow('< Cancel'), value: null });
+          
+          const { symbol } = await inquirer.prompt([{
+            type: 'list',
+            name: 'symbol',
+            message: `${label} Symbol:`,
+            choices,
+            pageSize: 15
+          }]);
+          return symbol;
+        }
+      }
+      log.error('No contract fetching method available');
+      return null;
+    }
+    
     const result = await service.getContracts();
+    log.debug('getContracts result', { success: result?.success, count: result?.contracts?.length });
     if (!result.success) return null;
     
     const choices = [];

package/src/utils/index.js

@@ -0,0 +1,7 @@
+/**
+ * Utils module exports
+ */
+
+const { logger, LEVELS } = require('./logger');
+
+module.exports = { logger, LEVELS };

package/src/utils/logger.js

@@ -0,0 +1,110 @@
+/**
+ * HQX Logger - Centralized logging for debugging
+ * 
+ * Usage:
+ *   HQX_DEBUG=1 hedgequantx   - Enable all debug logs
+ *   HQX_LOG_FILE=1 hedgequantx - Also write to ~/.hedgequantx/debug.log
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Log levels
+const LEVELS = {
+  ERROR: 0,
+  WARN: 1,
+  INFO: 2,
+  DEBUG: 3,
+  TRACE: 4
+};
+
+// Colors for console output
+const COLORS = {
+  ERROR: '\x1b[31m',   // Red
+  WARN: '\x1b[33m',    // Yellow
+  INFO: '\x1b[36m',    // Cyan
+  DEBUG: '\x1b[90m',   // Gray
+  TRACE: '\x1b[90m',   // Gray
+  RESET: '\x1b[0m'
+};
+
+class Logger {
+  constructor() {
+    this.enabled = process.env.HQX_DEBUG === '1';
+    this.fileEnabled = process.env.HQX_LOG_FILE === '1';
+    this.level = LEVELS.DEBUG;
+    this.logFile = path.join(os.homedir(), '.hedgequantx', 'debug.log');
+    
+    // Create log directory if file logging enabled
+    if (this.fileEnabled) {
+      const dir = path.dirname(this.logFile);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      // Clear log file on start
+      fs.writeFileSync(this.logFile, `=== HQX Debug Log Started ${new Date().toISOString()} ===\n`);
+    }
+  }
+
+  _format(level, module, message, data) {
+    const timestamp = new Date().toISOString().substr(11, 12); // HH:MM:SS.mmm
+    const dataStr = data !== undefined ? ' ' + JSON.stringify(data) : '';
+    return `[${timestamp}] [${level}] [${module}]${dataStr ? ' ' + message + dataStr : ' ' + message}`;
+  }
+
+  _log(level, levelName, module, message, data) {
+    if (!this.enabled || level > this.level) return;
+
+    const formatted = this._format(levelName, module, message, data);
+    const color = COLORS[levelName] || COLORS.RESET;
+    
+    // Console output (stderr to not interfere with CLI UI)
+    console.error(`${color}${formatted}${COLORS.RESET}`);
+    
+    // File output
+    if (this.fileEnabled) {
+      try {
+        fs.appendFileSync(this.logFile, formatted + '\n');
+      } catch (e) {
+        // Ignore file write errors
+      }
+    }
+  }
+
+  error(module, message, data) {
+    this._log(LEVELS.ERROR, 'ERROR', module, message, data);
+  }
+
+  warn(module, message, data) {
+    this._log(LEVELS.WARN, 'WARN', module, message, data);
+  }
+
+  info(module, message, data) {
+    this._log(LEVELS.INFO, 'INFO', module, message, data);
+  }
+
+  debug(module, message, data) {
+    this._log(LEVELS.DEBUG, 'DEBUG', module, message, data);
+  }
+
+  trace(module, message, data) {
+    this._log(LEVELS.TRACE, 'TRACE', module, message, data);
+  }
+
+  // Create a scoped logger for a specific module
+  scope(moduleName) {
+    return {
+      error: (msg, data) => this.error(moduleName, msg, data),
+      warn: (msg, data) => this.warn(moduleName, msg, data),
+      info: (msg, data) => this.info(moduleName, msg, data),
+      debug: (msg, data) => this.debug(moduleName, msg, data),
+      trace: (msg, data) => this.trace(moduleName, msg, data),
+    };
+  }
+}
+
+// Singleton instance
+const logger = new Logger();
+
+module.exports = { logger, LEVELS };