hedgequantx 1.5.3 → 1.5.5

package/package.json

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

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

@@ -205,50 +205,45 @@ const copyTradingMenu = async () => {
 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;
-        }
+    let contracts = [];
+    
+    // Try getContracts first
+    if (typeof service.getContracts === 'function') {
+      const result = await service.getContracts();
+      log.debug('getContracts result', { success: result?.success, count: result?.contracts?.length });
+      if (result.success && result.contracts?.length > 0) {
+        contracts = result.contracts;
       }
-      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 = [];
-    const cats = {};
-    
-    for (const c of result.contracts) {
-      const cat = c.group || 'Other';
-      if (!cats[cat]) cats[cat] = [];
-      cats[cat].push(c);
+    // Fallback to searchContracts if no contracts yet
+    if (contracts.length === 0 && typeof service.searchContracts === 'function') {
+      log.debug('Trying searchContracts fallback');
+      // For Rithmic, searchContracts returns array directly
+      const searchResult = await service.searchContracts('ES');
+      log.debug('searchContracts result', { result: searchResult });
+      
+      if (Array.isArray(searchResult)) {
+        contracts = searchResult;
+      } else if (searchResult?.contracts) {
+        contracts = searchResult.contracts;
+      }
     }
     
-    for (const [cat, list] of Object.entries(cats)) {
-      choices.push(new inquirer.Separator(chalk.gray(`--- ${cat} ---`)));
-      for (const c of list.slice(0, 8)) {
-        choices.push({ name: c.name || c.symbol, value: c });
-      }
+    // If still no contracts, show error
+    if (!contracts || contracts.length === 0) {
+      log.error('No contracts available');
+      console.log(chalk.red('  No contracts available for this service'));
+      return null;
     }
+    
+    log.debug('Contracts loaded', { count: contracts.length });
+    
+    // Build choices - simple list without categories
+    const choices = contracts.map(c => ({ 
+      name: c.name || c.symbol, 
+      value: c 
+    }));
     choices.push(new inquirer.Separator());
     choices.push({ name: chalk.yellow('< Cancel'), value: null });
     

package/src/services/projectx/index.js

@@ -443,6 +443,35 @@ class ProjectXService {
 
   // ==================== CONTRACTS ====================
 
+  /**
+   * Get popular contracts for trading
+   */
+  async getContracts() {
+    try {
+      // Search for popular futures symbols
+      const symbols = ['ES', 'NQ', 'MES', 'MNQ', 'CL', 'GC', 'RTY', 'YM'];
+      const allContracts = [];
+      
+      for (const sym of symbols) {
+        const response = await this._request(
+          this.propfirm.gatewayApi, '/api/Contract/search', 'POST',
+          { searchText: sym, live: false }
+        );
+        if (response.statusCode === 200) {
+          const contracts = response.data.contracts || response.data || [];
+          // Take first contract for each symbol (front month)
+          if (contracts.length > 0) {
+            allContracts.push(contracts[0]);
+          }
+        }
+      }
+      
+      return { success: true, contracts: allContracts };
+    } catch (error) {
+      return { success: false, contracts: [], error: error.message };
+    }
+  }
+
   async searchContracts(searchText) {
     try {
       const response = await this._request(

package/src/services/rithmic/index.js

@@ -210,15 +210,32 @@ class RithmicService extends EventEmitter {
     };
   }
 
-  async searchContracts(searchText) {
-    const contracts = [
-      { symbol: 'ESH5', name: 'E-mini S&P 500 Mar 2025', exchange: 'CME' },
-      { symbol: 'NQH5', name: 'E-mini NASDAQ-100 Mar 2025', exchange: 'CME' },
-      { symbol: 'CLH5', name: 'Crude Oil Mar 2025', exchange: 'NYMEX' },
-      { symbol: 'GCG5', name: 'Gold Feb 2025', exchange: 'COMEX' },
-      { symbol: 'MESH5', name: 'Micro E-mini S&P 500 Mar 2025', exchange: 'CME' },
-      { symbol: 'MNQH5', name: 'Micro E-mini NASDAQ-100 Mar 2025', exchange: 'CME' },
+  // All available contracts for Rithmic
+  _getAvailableContracts() {
+    return [
+      { symbol: 'ESH5', name: 'E-mini S&P 500 Mar 2025', exchange: 'CME', group: 'Index' },
+      { symbol: 'NQH5', name: 'E-mini NASDAQ-100 Mar 2025', exchange: 'CME', group: 'Index' },
+      { symbol: 'MESH5', name: 'Micro E-mini S&P 500 Mar 2025', exchange: 'CME', group: 'Micro' },
+      { symbol: 'MNQH5', name: 'Micro E-mini NASDAQ-100 Mar 2025', exchange: 'CME', group: 'Micro' },
+      { symbol: 'MCLE5', name: 'Micro Crude Oil Mar 2025', exchange: 'NYMEX', group: 'Micro' },
+      { symbol: 'MGCG5', name: 'Micro Gold Feb 2025', exchange: 'COMEX', group: 'Micro' },
+      { symbol: 'CLH5', name: 'Crude Oil Mar 2025', exchange: 'NYMEX', group: 'Energy' },
+      { symbol: 'GCG5', name: 'Gold Feb 2025', exchange: 'COMEX', group: 'Metals' },
+      { symbol: 'SIH5', name: 'Silver Mar 2025', exchange: 'COMEX', group: 'Metals' },
+      { symbol: 'RTYH5', name: 'E-mini Russell 2000 Mar 2025', exchange: 'CME', group: 'Index' },
+      { symbol: 'YMH5', name: 'E-mini Dow Jones Mar 2025', exchange: 'CBOT', group: 'Index' },
+      { symbol: 'ZBH5', name: '30-Year US Treasury Bond Mar 2025', exchange: 'CBOT', group: 'Bonds' },
+      { symbol: 'ZNH5', name: '10-Year US Treasury Note Mar 2025', exchange: 'CBOT', group: 'Bonds' },
     ];
+  }
+
+  async getContracts() {
+    return { success: true, contracts: this._getAvailableContracts() };
+  }
+
+  async searchContracts(searchText) {
+    const contracts = this._getAvailableContracts();
+    if (!searchText) return contracts;
     const search = searchText.toUpperCase();
     return contracts.filter(c => c.symbol.includes(search) || c.name.toUpperCase().includes(search));
   }

package/src/utils/logger.js

@@ -31,21 +31,19 @@ const COLORS = {
 
 class Logger {
   constructor() {
-    this.enabled = process.env.HQX_DEBUG === '1';
+    this.consoleEnabled = process.env.HQX_DEBUG === '1';
     this.level = LEVELS.DEBUG;
     this.logFile = path.join(os.homedir(), '.hedgequantx', 'debug.log');
     
-    // Always write to file when debug is enabled
-    if (this.enabled) {
-      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`);
-      fs.appendFileSync(this.logFile, `Platform: ${process.platform}, Node: ${process.version}\n`);
-      fs.appendFileSync(this.logFile, `CWD: ${process.cwd()}\n\n`);
+    // Always write to file (logs are always saved)
+    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 Log Started ${new Date().toISOString()} ===\n`);
+    fs.appendFileSync(this.logFile, `Platform: ${process.platform}, Node: ${process.version}\n`);
+    fs.appendFileSync(this.logFile, `CWD: ${process.cwd()}\n\n`);
   }
 
   _format(level, module, message, data) {
@@ -55,20 +53,22 @@ class Logger {
   }
 
   _log(level, levelName, module, message, data) {
-    if (!this.enabled || level > this.level) return;
+    if (level > this.level) return;
 
     const formatted = this._format(levelName, module, message, data);
-    const color = COLORS[levelName] || COLORS.RESET;
     
-    // Always write to file first (survives crashes)
+    // Always write to file (survives crashes)
     try {
       fs.appendFileSync(this.logFile, formatted + '\n');
     } catch (e) {
       // Ignore file write errors
     }
     
-    // Console output (stderr to not interfere with CLI UI)
-    console.error(`${color}${formatted}${COLORS.RESET}`);
+    // Console output only if HQX_DEBUG=1
+    if (this.consoleEnabled) {
+      const color = COLORS[levelName] || COLORS.RESET;
+      console.error(`${color}${formatted}${COLORS.RESET}`);
+    }
   }
 
   error(module, message, data) {