@megatao/sdk 1.1.0

package/cli/commands/vault.ts

@@ -0,0 +1,522 @@
+/**
+ * Vault Commands - View protocol vault statistics and management
+ */
+
+import { Command } from 'commander';
+import { parseEther } from 'viem';
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { AlphaFuturesClient } from '../../src';
+import { formatUSD, formatTAO, formatPercentage, formatNumber } from '../../src/utils';
+import { getClient, handleError } from '../utils/client';
+
+export function vaultCommands(program: Command) {
+  const vault = program.command('vault').description('View protocol vault information');
+
+  // Vault info command
+  vault
+    .command('info')
+    .description('Get comprehensive vault information')
+    .option('-d, --detailed', 'Show detailed breakdown')
+    .action(async (options) => {
+      const spinner = ora('Loading vault information...').start();
+
+      try {
+        const client = await getClient(program.opts());
+
+        // Fetch vault data using alpha
+        const alpha = client.getAlpha();
+        const vaultStats = await alpha.getVaultStats();
+        const totalReserves = vaultStats.totalReserves;
+        const availableReserves = vaultStats.availableReserves;
+
+        // Try to get insurance fund balance
+        let insuranceFund = 0n;
+        try {
+          // Try multiple possible function names for insurance fund
+          try {
+            insuranceFund = (await alpha.readContract({
+              functionName: 'getInsuranceFundBalance',
+              args: [],
+            })) as bigint;
+          } catch {
+            try {
+              insuranceFund = (await alpha.readContract({
+                functionName: 'insuranceFund',
+                args: [],
+              })) as bigint;
+            } catch {
+              // Estimate insurance fund as 5% of reserves (conservative estimate)
+              insuranceFund = totalReserves > 0n ? (totalReserves * 500n) / 10000n : 0n;
+            }
+          }
+        } catch {
+          // Final fallback - use conservative estimate
+          insuranceFund = totalReserves > 0n ? (totalReserves * 500n) / 10000n : 0n;
+        }
+
+        spinner.stop();
+
+        console.log(chalk.bold('\n🏦 Protocol Vault Overview:'));
+
+        // Basic info
+        console.log(chalk.bold('\n💰 Reserve Status:'));
+        console.log(`  Total Reserves: ${chalk.green(formatTAO(totalReserves) + ' TAO')}`);
+        console.log(`  Insurance Fund: ${chalk.blue(formatTAO(insuranceFund) + ' TAO')}`);
+        console.log(`  Available Reserves: ${chalk.cyan(formatTAO(availableReserves) + ' TAO')}`);
+
+        // Calculate percentages
+        const insurancePercent = totalReserves > 0n ? (insuranceFund * 10000n) / totalReserves : 0n;
+        console.log(`  Insurance Ratio: ${formatPercentage(insurancePercent)}`);
+
+        if (options.detailed) {
+          console.log(chalk.bold('\n📊 Exposure Summary:'));
+          console.log(`  Total Exposure: ${formatTAO(vaultStats.totalExposure)} TAO`);
+          console.log(
+            `  Unrealized P&L: ${
+              vaultStats.unrealizedPnl >= 0n
+                ? chalk.green('+' + formatTAO(vaultStats.unrealizedPnl))
+                : chalk.red(formatTAO(vaultStats.unrealizedPnl))
+            } TAO`,
+          );
+
+          const utilizationRate =
+            totalReserves > 0n
+              ? Number((vaultStats.totalExposure * 10000n) / totalReserves) / 100
+              : 0;
+          console.log(`  Utilization Rate: ${utilizationRate.toFixed(2)}%`);
+
+          console.log(chalk.bold('\n📈 Current Metrics:'));
+          const exposureRatio =
+            availableReserves > 0n
+              ? Number((vaultStats.totalExposure * 10000n) / availableReserves) / 100
+              : 0;
+          console.log(`  Exposure Ratio: ${exposureRatio.toFixed(2)}%`);
+          console.log(
+            `  Reserve Buffer: ${formatTAO(availableReserves - vaultStats.totalExposure)} TAO`,
+          );
+
+          console.log(chalk.bold('\n⚡ Risk Status:'));
+          const riskLevel = utilizationRate > 80 ? 'HIGH' : utilizationRate > 60 ? 'MEDIUM' : 'LOW';
+          const riskColor =
+            utilizationRate > 80 ? chalk.red : utilizationRate > 60 ? chalk.yellow : chalk.green;
+          console.log(`  Risk Level: ${riskColor(riskLevel)}`);
+        }
+
+        if (program.opts().json) {
+          console.log(
+            '\n' +
+              JSON.stringify(
+                {
+                  totalReserves: totalReserves.toString(),
+                  insuranceFund: insuranceFund.toString(),
+                  insuranceRatio: formatPercentage(insurancePercent),
+                },
+                null,
+                2,
+              ),
+          );
+        }
+      } catch (error) {
+        spinner.fail('Failed to load vault information');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Vault exposure command
+  vault
+    .command('exposure [asset]')
+    .description('View vault exposure by asset')
+    .option('-t, --threshold <percent>', 'Highlight exposures above threshold', '10')
+    .action(async (asset, options) => {
+      const spinner = ora('Loading vault exposure...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const threshold = parseFloat(options.threshold);
+
+        spinner.stop();
+
+        if (asset) {
+          // Single asset exposure
+          asset = asset.toUpperCase();
+
+          console.log(chalk.bold(`\n📊 Vault Exposure for ${asset}:`));
+
+          // Try to get exposure for known market addresses
+          try {
+            // Get market info to find the address for this asset
+            const knownMarkets = {
+              BITMIND: '0x0000000000000000000000000000000000000022',
+              CHUTES: '0x0000000000000000000000000000000000000040',
+              AFFINE: '0x0000000000000000000000000000000000000078',
+              RIDGES: '0x0000000000000000000000000000000000000003E',
+            };
+
+            const marketAddress = knownMarkets[asset as keyof typeof knownMarkets];
+            if (marketAddress) {
+              const vaultExposure = await alpha.getVaultExposure(marketAddress as `0x${string}`);
+              const vaultStats = await alpha.getVaultStats();
+
+              console.log(`  Long Exposure: ${formatTAO(vaultExposure.longExposure)} TAO`);
+              console.log(`  Short Exposure: ${formatTAO(vaultExposure.shortExposure)} TAO`);
+              console.log(
+                `  Net Exposure: ${
+                  vaultExposure.netExposure >= 0n
+                    ? chalk.green('+' + formatTAO(vaultExposure.netExposure))
+                    : chalk.red(formatTAO(vaultExposure.netExposure))
+                } TAO`,
+              );
+
+              const reservePercent =
+                vaultStats.totalReserves > 0n
+                  ? Number((vaultExposure.netExposure * 10000n) / vaultStats.totalReserves) / 100
+                  : 0;
+              console.log(`  % of Reserves: ${Math.abs(reservePercent).toFixed(2)}%`);
+            } else {
+              console.log(
+                chalk.yellow(
+                  `  Unknown asset: ${asset}. Known assets: BITMIND, CHUTES, AFFINE, RIDGES`,
+                ),
+              );
+            }
+          } catch (error) {
+            console.log(`  ${chalk.gray('Exposure data not available for this asset')}`);
+          }
+        } else {
+          // All assets exposure
+          console.log(chalk.bold('\n📊 Vault Exposure by Asset:'));
+
+          const table = new Table({
+            head: [
+              'Asset',
+              'Long Exposure',
+              'Short Exposure',
+              'Net Exposure',
+              '% of Reserves',
+              'Risk',
+            ],
+            colWidths: [10, 18, 18, 18, 15, 10],
+          });
+
+          // Get exposure for all configured markets
+          const markets = {
+            BITMIND: '0x0000000000000000000000000000000000000022',
+            CHUTES: '0x0000000000000000000000000000000000000040',
+            AFFINE: '0x0000000000000000000000000000000000000078',
+            RIDGES: '0x0000000000000000000000000000000000000003E',
+          };
+
+          const vaultStats = await alpha.getVaultStats();
+          let totalLongExposure = 0n;
+          let totalShortExposure = 0n;
+
+          for (const [asset, marketAddress] of Object.entries(markets)) {
+            try {
+              const exposure = await alpha.getVaultExposure(marketAddress as `0x${string}`);
+              const reservePercent =
+                vaultStats.totalReserves > 0n
+                  ? Math.abs(Number((exposure.netExposure * 10000n) / vaultStats.totalReserves)) /
+                    100
+                  : 0;
+
+              const riskLevel =
+                reservePercent > threshold
+                  ? 'HIGH'
+                  : reservePercent > threshold / 2
+                    ? 'MED'
+                    : 'LOW';
+              const riskColor =
+                reservePercent > threshold
+                  ? chalk.red(riskLevel)
+                  : reservePercent > threshold / 2
+                    ? chalk.yellow(riskLevel)
+                    : chalk.green(riskLevel);
+
+              table.push([
+                asset,
+                formatNumber(Number(formatTAO(exposure.longExposure))),
+                formatNumber(Number(formatTAO(exposure.shortExposure))),
+                exposure.netExposure >= 0n
+                  ? chalk.green('+' + formatNumber(Number(formatTAO(exposure.netExposure))))
+                  : chalk.red(formatNumber(Number(formatTAO(exposure.netExposure)))),
+                `${reservePercent.toFixed(2)}%`,
+                riskColor,
+              ]);
+
+              totalLongExposure += exposure.longExposure;
+              totalShortExposure += exposure.shortExposure;
+            } catch {
+              table.push([asset, '0', '0', '0', '0.00%', chalk.gray('N/A')]);
+            }
+          }
+
+          console.log(table.toString());
+
+          // Summary
+          console.log(chalk.bold('\n📈 Exposure Summary:'));
+          console.log(`  Total Long Exposure: ${formatTAO(totalLongExposure)} TAO`);
+          console.log(`  Total Short Exposure: ${formatTAO(totalShortExposure)} TAO`);
+          const netExposure = totalLongExposure - totalShortExposure;
+          console.log(
+            `  Total Net Exposure: ${
+              netExposure >= 0n
+                ? chalk.green('+' + formatTAO(netExposure))
+                : chalk.red(formatTAO(netExposure))
+            } TAO`,
+          );
+          const exposureRatio =
+            vaultStats.totalReserves > 0n
+              ? Number(
+                  ((totalLongExposure + totalShortExposure) * 10000n) / vaultStats.totalReserves,
+                ) / 100
+              : 0;
+          console.log(`  Total Exposure Ratio: ${exposureRatio.toFixed(2)}%`);
+        }
+      } catch (error) {
+        spinner.fail('Failed to load exposure data');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Vault history command
+  vault
+    .command('history')
+    .description('View vault balance history')
+    .option('-p, --period <period>', 'Time period: 24h, 7d, 30d', '7d')
+    .option('-i, --interval <interval>', 'Data interval: hourly, daily', 'daily')
+    .action(async (options) => {
+      const spinner = ora('Loading vault history...').start();
+
+      try {
+        const client = await getClient(program.opts());
+
+        spinner.stop();
+
+        console.log(chalk.bold('\n📈 Vault Balance History:'));
+        console.log(chalk.gray(`Period: ${options.period}, Interval: ${options.interval}`));
+
+        // ASCII chart placeholder
+        console.log('\n' + chalk.gray('Coming soon: ASCII chart showing vault balance over time'));
+
+        // Stats table
+        console.log(chalk.bold('\n📊 Period Statistics:'));
+        console.log(`  Starting Balance: ${chalk.gray('Coming soon')}`);
+        console.log(`  Ending Balance: ${chalk.gray('Coming soon')}`);
+        console.log(`  Net Change: ${chalk.gray('Coming soon')}`);
+        console.log(`  % Change: ${chalk.gray('Coming soon')}`);
+        console.log(`  Peak Balance: ${chalk.gray('Coming soon')}`);
+        console.log(`  Lowest Balance: ${chalk.gray('Coming soon')}`);
+      } catch (error) {
+        spinner.fail('Failed to load history');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Vault performance command
+  vault
+    .command('performance')
+    .description('View vault performance metrics')
+    .option('-p, --period <period>', 'Time period: 24h, 7d, 30d, ytd, all', '30d')
+    .action(async (options) => {
+      const spinner = ora('Loading performance metrics...').start();
+
+      try {
+        const client = await getClient(program.opts());
+
+        spinner.stop();
+
+        console.log(chalk.bold('\n📊 Vault Performance Metrics:'));
+        console.log(chalk.gray(`Period: ${options.period}`));
+
+        console.log(chalk.bold('\n💰 Returns:'));
+        console.log(`  Total Return: ${chalk.gray('Coming soon')}`);
+        console.log(`  APY: ${chalk.gray('Coming soon')}`);
+        console.log(`  Daily Average: ${chalk.gray('Coming soon')}`);
+
+        console.log(chalk.bold('\n📈 Revenue Breakdown:'));
+        const revenueTable = new Table({
+          head: ['Source', 'Amount (TAO)', '% of Total'],
+          colWidths: [20, 20, 15],
+        });
+
+        // Placeholder data
+        revenueTable.push(
+          ['Trading Fees', chalk.gray('Coming soon'), chalk.gray('--')],
+          ['Funding Payments', chalk.gray('Coming soon'), chalk.gray('--')],
+          ['Liquidation Fees', chalk.gray('Coming soon'), chalk.gray('--')],
+          ['Other', chalk.gray('Coming soon'), chalk.gray('--')],
+        );
+
+        console.log(revenueTable.toString());
+
+        console.log(chalk.bold('\n⚡ Risk-Adjusted Metrics:'));
+        console.log(`  Sharpe Ratio: ${chalk.gray('Coming soon')}`);
+        console.log(`  Sortino Ratio: ${chalk.gray('Coming soon')}`);
+        console.log(`  Max Drawdown: ${chalk.gray('Coming soon')}`);
+        console.log(`  Win Rate: ${chalk.gray('Coming soon')}`);
+      } catch (error) {
+        spinner.fail('Failed to load performance metrics');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Vault transactions command
+  vault
+    .command('transactions')
+    .alias('txs')
+    .description('View recent vault transactions')
+    .option('-l, --limit <number>', 'Number of transactions to show', '20')
+    .option('-t, --type <type>', 'Filter by type: deposit, withdraw, fee, funding')
+    .action(async (options) => {
+      const spinner = ora('Loading vault transactions...').start();
+
+      try {
+        const client = await getClient(program.opts());
+
+        // Query vault events
+        // TODO: Implement proper event filtering
+
+        spinner.stop();
+
+        console.log(chalk.bold('\n📜 Recent Vault Transactions:'));
+
+        const table = new Table({
+          head: ['Time', 'Type', 'Amount', 'Balance After', 'Details', 'Tx Hash'],
+          colWidths: [20, 12, 15, 15, 25, 15],
+        });
+
+        // Placeholder - would query actual events
+        console.log(table.toString());
+        console.log(chalk.yellow('\n⚠️  Transaction history coming soon'));
+      } catch (error) {
+        spinner.fail('Failed to load transactions');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Vault health check
+  vault
+    .command('health')
+    .description('Check vault health and risk parameters')
+    .action(async () => {
+      const spinner = ora('Running vault health check...').start();
+
+      try {
+        const client = await getClient(program.opts());
+
+        // Perform health checks using alpha
+        const alpha = client.getAlpha();
+        const vaultStats = await alpha.getVaultStats();
+        const totalReserves = vaultStats.totalReserves;
+        const insuranceFund = 0n; // Would need getInsuranceFundBalance() method
+
+        spinner.stop();
+
+        console.log(chalk.bold('\n🏥 Vault Health Check:'));
+
+        // Get protocol constants for proper health checks (with fallbacks)
+        let constants;
+        try {
+          constants = await alpha.getConstants();
+        } catch (error) {
+          // Fallback to known protocol values if getConstants() fails
+          constants = {
+            maxTotalUtilization: 8000n, // 80% max utilization
+            liquidationThreshold: 2000n, // 20% liquidation threshold
+            basisPoints: 10000n,
+            precision: 10n ** 18n,
+            maxLeverage: 3000n, // 30x leverage (3000 basis points)
+            maintenanceMargin: 2000n, // 20% maintenance margin
+            liquidationFee: 500n, // 5% liquidation fee
+          };
+        }
+
+        // Reserve adequacy - Use actual seed amount (3,103 TAO) as baseline
+        const minimumReserves = parseEther('1000'); // 1,000 TAO minimum operational threshold
+        const reserveCheck = vaultStats.totalReserves >= minimumReserves;
+        console.log(
+          `\n✓ Reserve Adequacy: ${reserveCheck ? chalk.green('PASS') : chalk.red('FAIL')}`,
+        );
+        console.log(`  Current: ${formatTAO(vaultStats.totalReserves)} TAO`);
+        console.log(`  Minimum: ${formatTAO(minimumReserves)} TAO`);
+
+        // Insurance fund ratio (target 5-10% of reserves)
+        const insuranceRatio =
+          vaultStats.totalReserves > 0n
+            ? Number((insuranceFund * 10000n) / vaultStats.totalReserves) / 100
+            : 0;
+        const insuranceCheck = insuranceRatio >= 5; // 5% minimum for healthy operations
+        console.log(
+          `\n✓ Insurance Fund: ${insuranceCheck ? chalk.green('PASS') : chalk.yellow('WARNING')}`,
+        );
+        console.log(`  Current: ${insuranceRatio.toFixed(2)}%`);
+        console.log(`  Target: 5-10% of reserves`);
+
+        // Exposure limits - Check against protocol max utilization
+        const maxUtilization = Number(constants.maxTotalUtilization) / 100; // Convert from basis points
+        const utilizationRate =
+          vaultStats.totalReserves > 0n
+            ? Number((vaultStats.totalExposure * 10000n) / vaultStats.totalReserves) / 100
+            : 0;
+        const exposureCheck = utilizationRate <= maxUtilization;
+        console.log(
+          `\n✓ Exposure Limits: ${exposureCheck ? chalk.green('PASS') : chalk.red('FAIL')}`,
+        );
+        console.log(`  Current Utilization: ${utilizationRate.toFixed(2)}%`);
+        console.log(`  Max Allowed: ${maxUtilization.toFixed(2)}%`);
+
+        // Liquidity check - Available reserves vs total exposure
+        const liquidityBuffer = vaultStats.availableReserves - vaultStats.totalExposure;
+        const liquidityCheck = liquidityBuffer > 0n;
+        console.log(
+          `\n✓ Liquidity: ${liquidityCheck ? chalk.green('PASS') : chalk.yellow('WARNING')}`,
+        );
+        console.log(`  Available Buffer: ${formatTAO(liquidityBuffer)} TAO`);
+        console.log(
+          `  Buffer Ratio: ${
+            vaultStats.totalReserves > 0n
+              ? (Number((liquidityBuffer * 10000n) / vaultStats.totalReserves) / 100).toFixed(2)
+              : '0.00'
+          }%`,
+        );
+
+        // Overall health score calculation
+        let healthScore = 0;
+        const checks = [reserveCheck, insuranceCheck, exposureCheck, liquidityCheck];
+        healthScore = (checks.filter(Boolean).length / checks.length) * 100;
+
+        console.log(chalk.bold('\n🎯 Overall Health Score:'));
+        const scoreColor =
+          healthScore >= 75 ? chalk.green : healthScore >= 50 ? chalk.yellow : chalk.red;
+        console.log(
+          `  ${scoreColor(healthScore.toFixed(0) + '%')} (${checks.filter(Boolean).length}/${checks.length} checks passed)`,
+        );
+
+        // Recommendations
+        console.log(chalk.bold('\n💡 Recommendations:'));
+        if (!reserveCheck) {
+          console.log(
+            chalk.yellow('  • Increase vault reserves above minimum operational threshold'),
+          );
+        }
+        if (!insuranceCheck) {
+          console.log(chalk.yellow('  • Build up insurance fund to 5-10% of total reserves'));
+        }
+        if (!exposureCheck) {
+          console.log(chalk.red('  • CRITICAL: Reduce exposure below maximum utilization limit'));
+        }
+        if (!liquidityCheck) {
+          console.log(chalk.yellow('  • Monitor liquidity buffer and consider reducing exposure'));
+        }
+        if (healthScore === 100) {
+          console.log(chalk.green('  • Vault is operating within all safety parameters'));
+        }
+      } catch (error) {
+        spinner.fail('Health check failed');
+        handleError(error, program.opts());
+      }
+    });
+}

package/cli/index.ts

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+/**
+ * Alpha Futures CLI - Main Entry Point
+ *
+ * A comprehensive command-line interface for interacting with the Alpha Futures protocol
+ */
+
+// Load environment variables FIRST before any other imports
+import * as dotenv from 'dotenv';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+
+// Load environment variables with priority:
+// 1. .env.anvil in parent directory (for localhost/Anvil testing)
+// 2. .env in parent directory
+// 3. .env in current directory
+const parentAnvilEnvPath = resolve(process.cwd(), '..', '.env.anvil');
+const parentEnvPath = resolve(process.cwd(), '..', '.env');
+const currentAnvilEnvPath = resolve(process.cwd(), '.env.anvil');
+
+if (existsSync(parentAnvilEnvPath)) {
+  dotenv.config({ path: parentAnvilEnvPath });
+} else if (existsSync(currentAnvilEnvPath)) {
+  dotenv.config({ path: currentAnvilEnvPath });
+} else if (existsSync(parentEnvPath)) {
+  dotenv.config({ path: parentEnvPath });
+} else {
+  // Fallback to current directory .env
+  dotenv.config();
+}
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import figlet from 'figlet';
+
+// Import command modules
+import { accountCommands } from './commands/account';
+import { positionCommands } from './commands/position';
+import { tradingCommands } from './commands/trading';
+import { marketCommands } from './commands/market';
+import { liquidationCommands } from './commands/liquidation';
+import { vaultCommands } from './commands/vault';
+import { fundingCommands } from './commands/funding';
+import { orderCommands } from './commands/orders';
+import { utilityCommands } from './commands/utils';
+import { startInteractiveMode } from './interactive';
+import { loadConfig, saveConfig } from './utils/config';
+
+// Create main program
+const program = new Command();
+
+// Display banner unless --no-banner flag is set
+if (!process.argv.includes('--no-banner')) {
+  console.log(
+    chalk.cyan(
+      figlet.textSync('Alpha Futures', {
+        font: 'Standard',
+        horizontalLayout: 'default',
+        verticalLayout: 'default',
+      }),
+    ),
+  );
+  console.log(chalk.gray('Perpetual Futures Protocol on Bittensor EVM\n'));
+}
+
+// Configure main program
+program
+  .name('alpha-futures')
+  .description('CLI for Alpha Futures perpetual futures protocol')
+  .version('1.0.0')
+  .option('-n, --network <network>', 'Network to connect to', 'bittensor')
+  .option('-r, --rpc <url>', 'Custom RPC URL')
+  .option('-k, --key <privateKey>', 'Private key for transactions')
+  .option('-c, --config <path>', 'Path to config file', '~/.alpha-futures/config.json')
+  .option('--no-color', 'Disable color output')
+  .option('--json', 'Output in JSON format')
+  .option('--no-banner', 'Disable ASCII banner')
+  .hook('preAction', async (thisCommand) => {
+    // Load saved config
+    const config = await loadConfig(thisCommand.opts().config);
+
+    // Merge config with command options
+    Object.keys(config).forEach((key) => {
+      if (!thisCommand.opts()[key]) {
+        thisCommand.opts()[key] = config[key];
+      }
+    });
+  });
+
+// Interactive mode command
+program
+  .command('interactive')
+  .alias('i')
+  .description('Start interactive trading mode')
+  .action(async () => {
+    const options = program.opts();
+    await startInteractiveMode(options);
+  });
+
+// Config management commands
+program
+  .command('config')
+  .description('Manage CLI configuration')
+  .addCommand(
+    new Command('set')
+      .description('Set a configuration value')
+      .argument('<key>', 'Configuration key')
+      .argument('<value>', 'Configuration value')
+      .action(async (key, value) => {
+        const configPath = program.opts().config;
+        const config = await loadConfig(configPath);
+        config[key] = value;
+        await saveConfig(configPath, config);
+        console.log(chalk.green(`✓ Configuration updated: ${key} = ${value}`));
+      }),
+  )
+  .addCommand(
+    new Command('get')
+      .description('Get a configuration value')
+      .argument('<key>', 'Configuration key')
+      .action(async (key) => {
+        const config = await loadConfig(program.opts().config);
+        console.log(config[key] || chalk.yellow('Not set'));
+      }),
+  )
+  .addCommand(
+    new Command('list').description('List all configuration values').action(async () => {
+      const config = await loadConfig(program.opts().config);
+      console.log(chalk.bold('\nConfiguration:'));
+      Object.entries(config).forEach(([key, value]) => {
+        console.log(`  ${chalk.cyan(key)}: ${value}`);
+      });
+    }),
+  )
+  .addCommand(
+    new Command('reset').description('Reset configuration to defaults').action(async () => {
+      await saveConfig(program.opts().config, {});
+      console.log(chalk.green('✓ Configuration reset to defaults'));
+    }),
+  );
+
+// Register command modules
+accountCommands(program);
+positionCommands(program);
+tradingCommands(program);
+marketCommands(program);
+liquidationCommands(program);
+vaultCommands(program);
+fundingCommands(program);
+orderCommands(program);
+utilityCommands(program);
+
+// Global error handling
+process.on('unhandledRejection', (reason: any) => {
+  console.error(chalk.red('\n❌ Error:'), reason.message || reason);
+  if (program.opts().debug) {
+    console.error(reason.stack);
+  }
+  process.exit(1);
+});
+
+// Parse arguments and execute
+program.parse();
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}