hedgequantx 2.9.20 → 2.9.22

package/src/services/ai-supervision/symbols.js

@@ -0,0 +1,259 @@
+/**
+ * Symbol Data for AI Supervision
+ * 
+ * Contains detailed information about tradeable symbols
+ * including tick sizes, sessions, correlations, and characteristics.
+ */
+
+const SYMBOLS = {
+  NQ: {
+    id: 'NQ',
+    name: 'E-mini Nasdaq 100',
+    exchange: 'CME',
+    tickSize: 0.25,
+    tickValue: 5.00,
+    pointValue: 20.00,
+    margin: 15000,
+    characteristics: {
+      volatility: 'high',
+      sector: 'technology',
+      behavior: 'momentum-driven, gap-prone',
+      avgRange: '150-300 points'
+    },
+    correlations: {
+      positive: ['ES', 'YM'],
+      negative: ['VIX'],
+      related: ['QQQ', 'AAPL', 'MSFT', 'NVDA']
+    },
+    sessions: {
+      most_active: ['us_open', 'us_close'],
+      avoid: ['asia_lunch', 'low_volume']
+    }
+  },
+
+  ES: {
+    id: 'ES',
+    name: 'E-mini S&P 500',
+    exchange: 'CME',
+    tickSize: 0.25,
+    tickValue: 12.50,
+    pointValue: 50.00,
+    margin: 12000,
+    characteristics: {
+      volatility: 'medium',
+      sector: 'broad_market',
+      behavior: 'reference index, institutional flow',
+      avgRange: '30-60 points'
+    },
+    correlations: {
+      positive: ['NQ', 'YM', 'RTY'],
+      negative: ['VIX', 'ZB'],
+      related: ['SPY', 'SPX']
+    },
+    sessions: {
+      most_active: ['us_open', 'us_close', 'london_us_overlap'],
+      avoid: ['asia_session']
+    }
+  },
+
+  YM: {
+    id: 'YM',
+    name: 'E-mini Dow',
+    exchange: 'CME',
+    tickSize: 1.00,
+    tickValue: 5.00,
+    pointValue: 5.00,
+    margin: 10000,
+    characteristics: {
+      volatility: 'medium-low',
+      sector: 'value_stocks',
+      behavior: 'slower than ES/NQ, less spiky',
+      avgRange: '200-400 points'
+    },
+    correlations: {
+      positive: ['ES', 'NQ'],
+      negative: ['VIX'],
+      related: ['DIA', 'DJIA']
+    },
+    sessions: {
+      most_active: ['us_open', 'us_close'],
+      avoid: ['overnight']
+    }
+  },
+
+  RTY: {
+    id: 'RTY',
+    name: 'E-mini Russell 2000',
+    exchange: 'CME',
+    tickSize: 0.10,
+    tickValue: 5.00,
+    pointValue: 50.00,
+    margin: 8000,
+    characteristics: {
+      volatility: 'high',
+      sector: 'small_caps',
+      behavior: 'more volatile than ES, liquidity gaps',
+      avgRange: '20-40 points'
+    },
+    correlations: {
+      positive: ['ES', 'NQ'],
+      negative: ['VIX'],
+      related: ['IWM', 'RUT']
+    },
+    sessions: {
+      most_active: ['us_open'],
+      avoid: ['overnight', 'low_volume']
+    }
+  },
+
+  GC: {
+    id: 'GC',
+    name: 'Gold Futures',
+    exchange: 'COMEX',
+    tickSize: 0.10,
+    tickValue: 10.00,
+    pointValue: 100.00,
+    margin: 11000,
+    characteristics: {
+      volatility: 'medium',
+      sector: 'precious_metals',
+      behavior: 'safe haven, inverse USD, central bank sensitive',
+      avgRange: '15-30 points'
+    },
+    correlations: {
+      positive: ['SI', 'EURUSD'],
+      negative: ['DXY', 'US10Y'],
+      related: ['GLD', 'XAUUSD']
+    },
+    sessions: {
+      most_active: ['london', 'us_open', 'asia_open'],
+      avoid: ['us_afternoon']
+    }
+  },
+
+  SI: {
+    id: 'SI',
+    name: 'Silver Futures',
+    exchange: 'COMEX',
+    tickSize: 0.005,
+    tickValue: 25.00,
+    pointValue: 5000.00,
+    margin: 9000,
+    characteristics: {
+      volatility: 'high',
+      sector: 'precious_metals',
+      behavior: 'follows gold with more volatility, industrial demand',
+      avgRange: '0.30-0.60 points'
+    },
+    correlations: {
+      positive: ['GC'],
+      negative: ['DXY'],
+      related: ['SLV', 'XAGUSD']
+    },
+    sessions: {
+      most_active: ['london', 'us_open'],
+      avoid: ['asia_lunch']
+    }
+  },
+
+  CL: {
+    id: 'CL',
+    name: 'Crude Oil Futures',
+    exchange: 'NYMEX',
+    tickSize: 0.01,
+    tickValue: 10.00,
+    pointValue: 1000.00,
+    margin: 7000,
+    characteristics: {
+      volatility: 'high',
+      sector: 'energy',
+      behavior: 'news-driven, inventories, geopolitical, OPEC',
+      avgRange: '1.50-3.00 points'
+    },
+    correlations: {
+      positive: ['BZ', 'XLE'],
+      negative: [],
+      related: ['USO', 'WTI']
+    },
+    sessions: {
+      most_active: ['us_open', 'inventory_report'],
+      avoid: ['overnight_thin']
+    }
+  }
+};
+
+/**
+ * Trading sessions with times (Eastern Time)
+ */
+const SESSIONS = {
+  asia_open: { start: '18:00', end: '20:00', description: 'Asia market open' },
+  asia_session: { start: '20:00', end: '03:00', description: 'Asia main session' },
+  asia_lunch: { start: '00:00', end: '01:00', description: 'Asia lunch (low volume)' },
+  london: { start: '03:00', end: '08:00', description: 'London session' },
+  london_us_overlap: { start: '08:00', end: '11:30', description: 'London/US overlap' },
+  us_open: { start: '09:30', end: '11:30', description: 'US market open (high volume)' },
+  us_midday: { start: '11:30', end: '14:00', description: 'US midday (lower volume)' },
+  us_afternoon: { start: '14:00', end: '15:00', description: 'US afternoon' },
+  us_close: { start: '15:00', end: '16:00', description: 'US close (rebalancing)' },
+  overnight: { start: '16:00', end: '18:00', description: 'Overnight transition' }
+};
+
+/**
+ * Get symbol data by ID
+ */
+const getSymbol = (symbolId) => {
+  const key = symbolId?.toUpperCase?.()?.replace(/[0-9]/g, '') || '';
+  return SYMBOLS[key] || null;
+};
+
+/**
+ * Get current session based on time
+ */
+const getCurrentSession = (date = new Date()) => {
+  const et = new Date(date.toLocaleString('en-US', { timeZone: 'America/New_York' }));
+  const hours = et.getHours();
+  const minutes = et.getMinutes();
+  const time = hours * 60 + minutes;
+
+  for (const [name, session] of Object.entries(SESSIONS)) {
+    const [startH, startM] = session.start.split(':').map(Number);
+    const [endH, endM] = session.end.split(':').map(Number);
+    const start = startH * 60 + startM;
+    const end = endH * 60 + endM;
+
+    if (start <= end) {
+      if (time >= start && time < end) return { name, ...session };
+    } else {
+      if (time >= start || time < end) return { name, ...session };
+    }
+  }
+  return { name: 'unknown', description: 'Unknown session' };
+};
+
+/**
+ * Check if current time is good for trading a symbol
+ */
+const isGoodSessionForSymbol = (symbolId, date = new Date()) => {
+  const symbol = getSymbol(symbolId);
+  if (!symbol) return { good: true, reason: 'Unknown symbol' };
+
+  const session = getCurrentSession(date);
+  
+  if (symbol.sessions.avoid?.includes(session.name)) {
+    return { good: false, reason: `${session.description} - typically low volume for ${symbolId}` };
+  }
+  
+  if (symbol.sessions.most_active?.includes(session.name)) {
+    return { good: true, reason: `${session.description} - optimal for ${symbolId}` };
+  }
+
+  return { good: true, reason: session.description };
+};
+
+module.exports = {
+  SYMBOLS,
+  SESSIONS,
+  getSymbol,
+  getCurrentSession,
+  isGoodSessionForSymbol
+};

package/src/services/cliproxy/index.js

@@ -0,0 +1,256 @@
+/**
+ * CLIProxy Service
+ * 
+ * Provides OAuth connections to paid AI plans (Claude Pro, ChatGPT Plus, etc.)
+ * via the embedded CLIProxyAPI binary.
+ */
+
+const http = require('http');
+const manager = require('./manager');
+
+// Re-export manager functions
+const {
+  CLIPROXY_VERSION,
+  INSTALL_DIR,
+  AUTH_DIR,
+  DEFAULT_PORT,
+  CALLBACK_PORTS,
+  CALLBACK_PATHS,
+  isInstalled,
+  isHeadless,
+  install,
+  isRunning,
+  start,
+  stop,
+  ensureRunning,
+  getLoginUrl,
+  getCallbackPort,
+  processCallback
+} = manager;
+
+// Internal API key (must match config.yaml)
+const API_KEY = 'hqx-internal-key';
+
+/**
+ * Make HTTP request to local CLIProxyAPI
+ * @param {string} path - API path
+ * @param {string} method - HTTP method
+ * @param {Object} body - Request body (optional)
+ * @param {number} timeout - Timeout in ms (default 60000 per RULES.md #15)
+ * @returns {Promise<Object>} { success, data, error }
+ */
+const fetchLocal = (path, method = 'GET', body = null, timeout = 60000) => {
+  return new Promise((resolve) => {
+    const options = {
+      hostname: '127.0.0.1',
+      port: DEFAULT_PORT,
+      path,
+      method,
+      headers: { 
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${API_KEY}`
+      },
+      timeout
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            const parsed = data ? JSON.parse(data) : {};
+            resolve({ success: true, data: parsed, error: null });
+          } else {
+            resolve({ success: false, error: `HTTP ${res.statusCode}`, data: null });
+          }
+        } catch (error) {
+          resolve({ success: false, error: 'Invalid JSON response', data: null });
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      if (error.code === 'ECONNREFUSED') {
+        resolve({ success: false, error: 'CLIProxyAPI not running', data: null });
+      } else {
+        resolve({ success: false, error: error.message, data: null });
+      }
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ success: false, error: 'Request timeout', data: null });
+    });
+
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+    
+    req.end();
+  });
+};
+
+/**
+ * Fetch available models from CLIProxyAPI
+ * @returns {Promise<Object>} { success, models, error }
+ */
+const fetchModels = async () => {
+  const result = await fetchLocal('/v1/models');
+  
+  if (!result.success) {
+    return { success: false, models: [], error: result.error };
+  }
+  
+  const data = result.data;
+  if (!data || !data.data || !Array.isArray(data.data)) {
+    return { success: false, models: [], error: 'Invalid response format' };
+  }
+  
+  const models = data.data
+    .filter(m => m.id)
+    .map(m => ({ id: m.id, name: m.id }));
+  
+  if (models.length === 0) {
+    return { success: false, models: [], error: 'No models available' };
+  }
+  
+  return { success: true, models, error: null };
+};
+
+/**
+ * Get provider-specific models
+ * @param {string} providerId - Provider ID
+ * @returns {Promise<Object>} { success, models, error }
+ */
+const fetchProviderModels = async (providerId) => {
+  const result = await fetchModels();
+  if (!result.success) return result;
+  
+  // Filter by provider prefix
+  const prefixMap = {
+    anthropic: 'claude',
+    openai: 'gpt',
+    google: 'gemini',
+    qwen: 'qwen'
+  };
+  
+  const prefix = prefixMap[providerId];
+  if (!prefix) return result;
+  
+  const filtered = result.models.filter(m => 
+    m.id.toLowerCase().includes(prefix)
+  );
+  
+  // Return only filtered models for this provider (empty if none found)
+  return { 
+    success: filtered.length > 0, 
+    models: filtered, 
+    error: filtered.length === 0 ? `No ${providerId} models available` : null 
+  };
+};
+
+/**
+ * Check which providers have auth files (are connected)
+ * @returns {Object} { anthropic: true/false, google: true/false, openai: true/false, qwen: true/false }
+ */
+const getConnectedProviders = () => {
+  const fs = require('fs');
+  const connected = { anthropic: false, google: false, openai: false, qwen: false };
+  
+  try {
+    if (!fs.existsSync(AUTH_DIR)) return connected;
+    
+    const files = fs.readdirSync(AUTH_DIR);
+    for (const file of files) {
+      if (file.startsWith('claude-') && file.endsWith('.json')) connected.anthropic = true;
+      if (file.startsWith('gemini-') && file.endsWith('.json')) connected.google = true;
+      if (file.startsWith('codex-') && file.endsWith('.json')) connected.openai = true;
+      if (file.startsWith('qwen-') && file.endsWith('.json')) connected.qwen = true;
+    }
+  } catch (e) { /* ignore */ }
+  
+  return connected;
+};
+
+/**
+ * Chat completion request
+ * @param {string} model - Model ID
+ * @param {Array} messages - Chat messages
+ * @param {Object} options - Additional options
+ * @returns {Promise<Object>} { success, response, error }
+ */
+const chatCompletion = async (model, messages, options = {}) => {
+  const body = {
+    model,
+    messages,
+    stream: false,
+    ...options
+  };
+  
+  const result = await fetchLocal('/v1/chat/completions', 'POST', body);
+  
+  if (!result.success) {
+    return { success: false, response: null, error: result.error };
+  }
+  
+  return { success: true, response: result.data, error: null };
+};
+
+/**
+ * Simple chat function for AI supervision
+ * @param {string} providerId - Provider ID (anthropic, openai, google, etc.)
+ * @param {string} modelId - Model ID
+ * @param {string} prompt - User prompt
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<Object>} { success, content, error }
+ */
+const chat = async (providerId, modelId, prompt, timeout = 30000) => {
+  const messages = [{ role: 'user', content: prompt }];
+  
+  const result = await fetchLocal('/v1/chat/completions', 'POST', {
+    model: modelId,
+    messages,
+    stream: false
+  }, timeout);
+  
+  if (!result.success) {
+    return { success: false, content: null, error: result.error };
+  }
+  
+  // Extract content from response
+  const data = result.data;
+  if (data?.choices?.[0]?.message?.content) {
+    return { success: true, content: data.choices[0].message.content, error: null };
+  }
+  
+  return { success: false, content: null, error: 'No content in response' };
+};
+
+module.exports = {
+  // Manager
+  CLIPROXY_VERSION,
+  INSTALL_DIR,
+  AUTH_DIR,
+  DEFAULT_PORT,
+  CALLBACK_PORTS,
+  CALLBACK_PATHS,
+  isInstalled,
+  isHeadless,
+  install,
+  isRunning,
+  start,
+  stop,
+  ensureRunning,
+  getLoginUrl,
+  getCallbackPort,
+  processCallback,
+  
+  // API
+  fetchLocal,
+  fetchModels,
+  fetchProviderModels,
+  getConnectedProviders,
+  chatCompletion,
+  chat
+};

package/src/services/cliproxy/installer.js

@@ -0,0 +1,111 @@
+/**
+ * CLIProxyAPI Installer
+ * 
+ * Handles downloading and extracting CLIProxyAPI binary
+ */
+
+const fs = require('fs');
+const https = require('https');
+const http = require('http');
+const { createGunzip } = require('zlib');
+const tar = require('tar');
+
+/**
+ * Download file from URL with redirect support
+ * @param {string} url - URL to download
+ * @param {string} destPath - Destination path
+ * @param {Function} onProgress - Progress callback (percent)
+ * @returns {Promise<boolean>}
+ */
+const downloadFile = (url, destPath, onProgress = null) => {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+    
+    const request = (url.startsWith('https') ? https : http).get(url, (response) => {
+      // Handle redirects
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        file.close();
+        fs.unlinkSync(destPath);
+        return downloadFile(response.headers.location, destPath, onProgress)
+          .then(resolve)
+          .catch(reject);
+      }
+      
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.unlinkSync(destPath);
+        return reject(new Error(`HTTP ${response.statusCode}`));
+      }
+      
+      const totalSize = parseInt(response.headers['content-length'], 10);
+      let downloadedSize = 0;
+      
+      response.on('data', (chunk) => {
+        downloadedSize += chunk.length;
+        if (onProgress && totalSize) {
+          onProgress(Math.round((downloadedSize / totalSize) * 100));
+        }
+      });
+      
+      response.pipe(file);
+      
+      file.on('finish', () => {
+        file.close();
+        resolve(true);
+      });
+    });
+    
+    request.on('error', (err) => {
+      file.close();
+      if (fs.existsSync(destPath)) fs.unlinkSync(destPath);
+      reject(err);
+    });
+    
+    request.setTimeout(120000, () => {
+      request.destroy();
+      reject(new Error('Download timeout'));
+    });
+  });
+};
+
+/**
+ * Extract tar.gz file
+ * @param {string} archivePath - Path to archive
+ * @param {string} destDir - Destination directory
+ * @returns {Promise<boolean>}
+ */
+const extractTarGz = (archivePath, destDir) => {
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(archivePath)
+      .pipe(createGunzip())
+      .pipe(tar.extract({ cwd: destDir }))
+      .on('finish', () => resolve(true))
+      .on('error', reject);
+  });
+};
+
+/**
+ * Extract zip file (Windows)
+ * @param {string} archivePath - Path to archive
+ * @param {string} destDir - Destination directory
+ * @returns {Promise<boolean>}
+ */
+const extractZip = async (archivePath, destDir) => {
+  const { execSync } = require('child_process');
+  
+  if (process.platform === 'win32') {
+    execSync(`powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force"`, {
+      stdio: 'ignore'
+    });
+  } else {
+    execSync(`unzip -o "${archivePath}" -d "${destDir}"`, { stdio: 'ignore' });
+  }
+  
+  return true;
+};
+
+module.exports = {
+  downloadFile,
+  extractTarGz,
+  extractZip
+};