hedgequantx 1.8.34 → 1.8.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "1.8.34",
+  "version": "1.8.35",
   "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

@@ -180,7 +180,7 @@ const getContractsFromAPI = async () => {
 };
 
 /**
- * Symbol selection helper - uses API contracts for all services
+ * Symbol selection helper - grouped by category with indices first
  */
 const selectSymbol = async (service, label) => {
   const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
@@ -193,6 +193,7 @@ const selectSymbol = async (service, label) => {
     if (!contracts && typeof service.getContracts === 'function') {
       const result = await service.getContracts();
       if (result.success && result.contracts?.length > 0) {
+        // Contracts from Rithmic are already categorized and sorted
         contracts = result.contracts;
       }
     }
@@ -203,23 +204,36 @@ const selectSymbol = async (service, label) => {
       return null;
     }
     
-    // Sort: Popular indices first (ES, NQ, YM, RTY, MES, MNQ)
-    const prioritySymbols = ['ES', 'NQ', 'YM', 'RTY', 'MES', 'MNQ', 'MYM', 'M2K', 'NKD', 'CL', 'GC'];
-    contracts.sort((a, b) => {
-      const aSymbol = (a.symbol || a.name || '').toUpperCase();
-      const bSymbol = (b.symbol || b.name || '').toUpperCase();
-      const aIdx = prioritySymbols.findIndex(p => aSymbol.startsWith(p));
-      const bIdx = prioritySymbols.findIndex(p => bSymbol.startsWith(p));
-      if (aIdx !== -1 && bIdx !== -1) return aIdx - bIdx;
-      if (aIdx !== -1) return -1;
-      if (bIdx !== -1) return 1;
-      return (a.name || '').localeCompare(b.name || '');
-    });
-    
     spinner.succeed(`Found ${contracts.length} contracts`);
     
-    const options = contracts.map(c => ({ label: c.name || c.symbol, value: c }));
-    options.push({ label: '< Cancel', value: null });
+    // Build options with category headers (if contracts have category info)
+    const options = [];
+    let currentCategory = null;
+    
+    for (const c of contracts) {
+      // Add category header when category changes (if available)
+      if (c.categoryName && c.categoryName !== currentCategory) {
+        currentCategory = c.categoryName;
+        options.push({ 
+          label: chalk.cyan.bold(`── ${currentCategory} ──`), 
+          value: null, 
+          disabled: true 
+        });
+      }
+      
+      // Format label based on available data
+      const symbolDisplay = c.symbol || c.name;
+      const nameDisplay = c.name || c.symbol;
+      const exchangeDisplay = c.exchange ? ` (${c.exchange})` : '';
+      const label = c.categoryName 
+        ? `  ${symbolDisplay} - ${nameDisplay}${exchangeDisplay}`
+        : `${nameDisplay}${exchangeDisplay}`;
+      
+      options.push({ label, value: c });
+    }
+    
+    options.push({ label: '', value: null, disabled: true }); // Spacer
+    options.push({ label: chalk.gray('< Cancel'), value: null });
     
     return await prompts.selectOption(`${label} Symbol:`, options);
   } catch (e) {

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

@@ -72,7 +72,7 @@ const oneAccountMenu = async (service) => {
 };
 
 /**
- * Symbol selection - same as copy-trading
+ * Symbol selection - grouped by category with indices first
  */
 const selectSymbol = async (service, account) => {
   const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
@@ -83,33 +83,36 @@ const selectSymbol = async (service, account) => {
     return null;
   }
   
-  // Normalize contract structure - API returns { name: "ESH6", description: "E-mini S&P 500..." }
-  const contracts = contractsResult.contracts.map(c => ({
-    ...c,
-    symbol: c.name || c.symbol,
-    name: c.description || c.name || c.symbol
-  }));
-  
-  // Sort: Popular indices first (ES, NQ, YM, RTY, MES, MNQ)
-  const prioritySymbols = ['ES', 'NQ', 'YM', 'RTY', 'MES', 'MNQ', 'MYM', 'M2K', 'NKD', 'CL', 'GC'];
-  contracts.sort((a, b) => {
-    const aSymbol = (a.symbol || '').toUpperCase();
-    const bSymbol = (b.symbol || '').toUpperCase();
-    const aIdx = prioritySymbols.findIndex(p => aSymbol.startsWith(p));
-    const bIdx = prioritySymbols.findIndex(p => bSymbol.startsWith(p));
-    if (aIdx !== -1 && bIdx !== -1) return aIdx - bIdx;
-    if (aIdx !== -1) return -1;
-    if (bIdx !== -1) return 1;
-    return (a.name || '').localeCompare(b.name || '');
-  });
+  // Contracts are already sorted by category from getContracts()
+  const contracts = contractsResult.contracts;
   
   spinner.succeed(`Found ${contracts.length} contracts`);
   
-  const options = contracts.map(c => ({ label: c.name, value: c }));
-  options.push({ label: '< Back', value: 'back' });
+  // Build options with category headers
+  const options = [];
+  let currentCategory = null;
+  
+  for (const c of contracts) {
+    // Add category header when category changes
+    if (c.categoryName !== currentCategory) {
+      currentCategory = c.categoryName;
+      options.push({ 
+        label: chalk.cyan.bold(`── ${currentCategory} ──`), 
+        value: null, 
+        disabled: true 
+      });
+    }
+    
+    // Format: "ESH6 - E-mini S&P 500 (CME)"
+    const label = `  ${c.symbol} - ${c.name} (${c.exchange})`;
+    options.push({ label, value: c });
+  }
+  
+  options.push({ label: '', value: null, disabled: true }); // Spacer
+  options.push({ label: chalk.gray('< Back'), value: 'back' });
   
   const contract = await prompts.selectOption(chalk.yellow('Select Symbol:'), options);
-  return contract === 'back' ? null : contract;
+  return contract === 'back' || contract === null ? null : contract;
 };
 
 /**

package/src/services/rithmic/constants.js

@@ -165,6 +165,155 @@ const PROTO_FILES = [
   'response_front_month_contract.proto',
 ];
 
+// Symbol Categories - Order matters for display (indices first)
+const SYMBOL_CATEGORIES = {
+  INDICES: {
+    name: 'Indices',
+    order: 1,
+    symbols: {
+      // E-mini Indices
+      'ES': { name: 'E-mini S&P 500', tickSize: 0.25, tickValue: 12.50 },
+      'NQ': { name: 'E-mini Nasdaq-100', tickSize: 0.25, tickValue: 5.00 },
+      'YM': { name: 'E-mini Dow Jones', tickSize: 1.00, tickValue: 5.00 },
+      'RTY': { name: 'E-mini Russell 2000', tickSize: 0.10, tickValue: 5.00 },
+      'EMD': { name: 'E-mini S&P MidCap 400', tickSize: 0.10, tickValue: 10.00 },
+      // Micro Indices
+      'MES': { name: 'Micro E-mini S&P 500', tickSize: 0.25, tickValue: 1.25 },
+      'MNQ': { name: 'Micro E-mini Nasdaq-100', tickSize: 0.25, tickValue: 0.50 },
+      'MYM': { name: 'Micro E-mini Dow Jones', tickSize: 1.00, tickValue: 0.50 },
+      'M2K': { name: 'Micro E-mini Russell 2000', tickSize: 0.10, tickValue: 0.50 },
+      // International Indices
+      'NKD': { name: 'Nikkei 225 (USD)', tickSize: 5.00, tickValue: 25.00 },
+    }
+  },
+  ENERGY: {
+    name: 'Energy',
+    order: 2,
+    symbols: {
+      'CL': { name: 'Crude Oil WTI', tickSize: 0.01, tickValue: 10.00 },
+      'MCL': { name: 'Micro Crude Oil WTI', tickSize: 0.01, tickValue: 1.00 },
+      'BZ': { name: 'Brent Crude Oil', tickSize: 0.01, tickValue: 10.00 },
+      'NG': { name: 'Natural Gas', tickSize: 0.001, tickValue: 10.00 },
+      'HO': { name: 'Heating Oil', tickSize: 0.0001, tickValue: 4.20 },
+      'RB': { name: 'RBOB Gasoline', tickSize: 0.0001, tickValue: 4.20 },
+    }
+  },
+  METALS: {
+    name: 'Metals',
+    order: 3,
+    symbols: {
+      'GC': { name: 'Gold', tickSize: 0.10, tickValue: 10.00 },
+      'MGC': { name: 'Micro Gold', tickSize: 0.10, tickValue: 1.00 },
+      '1OZ': { name: '1 Ounce Gold', tickSize: 0.25, tickValue: 0.25 },
+      'SI': { name: 'Silver', tickSize: 0.005, tickValue: 25.00 },
+      'SIL': { name: 'Silver 1000oz', tickSize: 0.005, tickValue: 5.00 },
+      'HG': { name: 'Copper', tickSize: 0.0005, tickValue: 12.50 },
+      'MHG': { name: 'Micro Copper', tickSize: 0.0005, tickValue: 1.25 },
+      'PL': { name: 'Platinum', tickSize: 0.10, tickValue: 5.00 },
+      'PA': { name: 'Palladium', tickSize: 0.10, tickValue: 10.00 },
+    }
+  },
+  CURRENCIES: {
+    name: 'Currencies (FX)',
+    order: 4,
+    symbols: {
+      '6E': { name: 'Euro FX', tickSize: 0.00005, tickValue: 6.25 },
+      'M6E': { name: 'Micro Euro FX', tickSize: 0.0001, tickValue: 1.25 },
+      '6B': { name: 'British Pound', tickSize: 0.0001, tickValue: 6.25 },
+      'M6B': { name: 'Micro British Pound', tickSize: 0.0001, tickValue: 0.625 },
+      '6J': { name: 'Japanese Yen', tickSize: 0.0000005, tickValue: 6.25 },
+      '6A': { name: 'Australian Dollar', tickSize: 0.0001, tickValue: 10.00 },
+      'M6A': { name: 'Micro Australian Dollar', tickSize: 0.0001, tickValue: 1.00 },
+      '6C': { name: 'Canadian Dollar', tickSize: 0.00005, tickValue: 5.00 },
+      '6S': { name: 'Swiss Franc', tickSize: 0.0001, tickValue: 12.50 },
+      '6N': { name: 'New Zealand Dollar', tickSize: 0.0001, tickValue: 10.00 },
+      '6M': { name: 'Mexican Peso', tickSize: 0.00001, tickValue: 5.00 },
+      'E7': { name: 'E-mini Euro FX', tickSize: 0.0001, tickValue: 6.25 },
+      'RF': { name: 'Euro FX/Swiss Franc', tickSize: 0.0001, tickValue: 12.50 },
+      'RP': { name: 'Euro FX/British Pound', tickSize: 0.00005, tickValue: 6.25 },
+      'RY': { name: 'Euro FX/Japanese Yen', tickSize: 0.01, tickValue: 6.25 },
+      'SEK': { name: 'Swedish Krona', tickSize: 0.00001, tickValue: 12.50 },
+    }
+  },
+  CRYPTO: {
+    name: 'Crypto',
+    order: 5,
+    symbols: {
+      'BTC': { name: 'Bitcoin', tickSize: 5.00, tickValue: 25.00 },
+      'MBT': { name: 'Micro Bitcoin', tickSize: 5.00, tickValue: 0.50 },
+      'ETH': { name: 'Ether', tickSize: 0.25, tickValue: 12.50 },
+      'MET': { name: 'Micro Ether', tickSize: 0.05, tickValue: 0.25 },
+    }
+  },
+  RATES: {
+    name: 'Interest Rates',
+    order: 6,
+    symbols: {
+      'ZB': { name: '30-Year T-Bond', tickSize: 0.03125, tickValue: 31.25 },
+      'ZN': { name: '10-Year T-Note', tickSize: 0.015625, tickValue: 15.625 },
+      'ZF': { name: '5-Year T-Note', tickSize: 0.0078125, tickValue: 7.8125 },
+      'ZT': { name: '2-Year T-Note', tickSize: 0.0078125, tickValue: 15.625 },
+      'TN': { name: 'Ultra 10-Year T-Note', tickSize: 0.015625, tickValue: 15.625 },
+      'ZQ': { name: '30-Day Fed Funds', tickSize: 0.0025, tickValue: 10.4167 },
+    }
+  },
+  AGRICULTURE: {
+    name: 'Agriculture',
+    order: 7,
+    symbols: {
+      'ZC': { name: 'Corn', tickSize: 0.25, tickValue: 12.50 },
+      'ZS': { name: 'Soybeans', tickSize: 0.25, tickValue: 12.50 },
+      'ZW': { name: 'Wheat', tickSize: 0.25, tickValue: 12.50 },
+      'ZL': { name: 'Soybean Oil', tickSize: 0.01, tickValue: 6.00 },
+      'ZM': { name: 'Soybean Meal', tickSize: 0.10, tickValue: 10.00 },
+      'ZO': { name: 'Oats', tickSize: 0.25, tickValue: 12.50 },
+    }
+  },
+  MEATS: {
+    name: 'Meats',
+    order: 8,
+    symbols: {
+      'LE': { name: 'Live Cattle', tickSize: 0.025, tickValue: 10.00 },
+      'HE': { name: 'Lean Hogs', tickSize: 0.025, tickValue: 10.00 },
+      'GF': { name: 'Feeder Cattle', tickSize: 0.025, tickValue: 12.50 },
+    }
+  },
+};
+
+/**
+ * Get symbol info (category, name, tick info)
+ */
+function getSymbolInfo(baseSymbol) {
+  for (const [catKey, category] of Object.entries(SYMBOL_CATEGORIES)) {
+    if (category.symbols[baseSymbol]) {
+      return {
+        category: catKey,
+        categoryName: category.name,
+        categoryOrder: category.order,
+        ...category.symbols[baseSymbol]
+      };
+    }
+  }
+  // Unknown symbol
+  return {
+    category: 'OTHER',
+    categoryName: 'Other',
+    categoryOrder: 99,
+    name: baseSymbol,
+    tickSize: null,
+    tickValue: null
+  };
+}
+
+/**
+ * Get all categories in display order
+ */
+function getCategoryOrder() {
+  return Object.entries(SYMBOL_CATEGORIES)
+    .sort((a, b) => a[1].order - b[1].order)
+    .map(([key, val]) => ({ key, name: val.name, order: val.order }));
+}
+
 module.exports = {
   RITHMIC_ENDPOINTS,
   RITHMIC_SYSTEMS,
@@ -173,4 +322,7 @@ module.exports = {
   RES,
   STREAM,
   PROTO_FILES,
+  SYMBOL_CATEGORIES,
+  getSymbolInfo,
+  getCategoryOrder,
 };

package/src/services/rithmic/index.js

@@ -5,7 +5,7 @@
 
 const EventEmitter = require('events');
 const { RithmicConnection } = require('./connection');
-const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS } = require('./constants');
+const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS, getSymbolInfo, getCategoryOrder } = require('./constants');
 const { createOrderHandler, createPnLHandler } = require('./handlers');
 const { fetchAccounts, getTradingAccounts, requestPnLSnapshot, subscribePnLUpdates, getPositions, hashAccountId } = require('./accounts');
 const { placeOrder, cancelOrder, getOrders, getOrderHistory, closePosition } = require('./orders');
@@ -425,19 +425,34 @@ class RithmicService extends EventEmitter {
         setTimeout(() => {
           this.tickerConn.removeListener('message', frontMonthHandler);
           
-          // Merge with product names
+          // Merge with product names and add category info
           const results = [];
           for (const [baseSymbol, contract] of contracts) {
             const productKey = `${baseSymbol}:${contract.exchange}`;
             const product = productsToCheck.get(productKey);
+            const symbolInfo = getSymbolInfo(baseSymbol);
+            
             results.push({
               symbol: contract.symbol,
               baseSymbol: baseSymbol,
-              name: product ? product.productName : baseSymbol,
+              name: symbolInfo.name || product?.productName || baseSymbol,
               exchange: contract.exchange,
+              category: symbolInfo.category,
+              categoryName: symbolInfo.categoryName,
+              categoryOrder: symbolInfo.categoryOrder,
+              tickSize: symbolInfo.tickSize,
+              tickValue: symbolInfo.tickValue,
             });
           }
 
+          // Sort by category order, then by symbol name within category
+          results.sort((a, b) => {
+            if (a.categoryOrder !== b.categoryOrder) {
+              return a.categoryOrder - b.categoryOrder;
+            }
+            return a.baseSymbol.localeCompare(b.baseSymbol);
+          });
+
           debug(`Got ${results.length} tradeable contracts from API`);
           resolve(results);
         }, 8000);

package/src/utils/prompts.js

@@ -126,6 +126,7 @@ const numberInput = async (message, defaultVal = 1, min = 1, max = 1000) => {
 
 /**
  * Select - arrow keys navigation
+ * Supports disabled options (separators) via opt.disabled
  */
 const selectOption = async (message, options) => {
   // Close shared readline before inquirer to avoid conflicts
@@ -135,10 +136,16 @@ const selectOption = async (message, options) => {
   }
   prepareStdin();
   
-  const choices = options.map(opt => ({
-    name: opt.label,
-    value: opt.value
-  }));
+  const choices = options.map(opt => {
+    if (opt.disabled) {
+      // Use inquirer Separator for disabled items (category headers)
+      return new inquirer.Separator(opt.label);
+    }
+    return {
+      name: opt.label,
+      value: opt.value
+    };
+  });
   
   const { value } = await inquirer.prompt([{
     type: 'list',
@@ -147,7 +154,7 @@ const selectOption = async (message, options) => {
     choices,
     prefix: '',
     loop: false,
-    pageSize: 15
+    pageSize: 20  // Increased to show more symbols
   }]);
   
   return value;