@nexstone/rift-cli 0.1.1

package/dist/commands/backtest.js

@@ -0,0 +1,283 @@
+import { Flags, Args } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import * as fs from 'node:fs';
+import { runEngine } from '../lib/python-bridge.js';
+import { analyzeBacktest } from '../lib/analyzer.js';
+// ANSI color helpers
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+function colorNum(val, suffix = '') {
+    const str = `${val}${suffix}`;
+    if (val > 0)
+        return green(str);
+    if (val < 0)
+        return red(str);
+    return yellow(str);
+}
+export default class Backtest extends GatedCommand {
+    static description = 'Run a backtest on cached candle data';
+    static examples = [
+        '$ rift backtest trend_follow --pair BTC --tf 4h',
+        '$ rift backtest my_strategy --pair BTC --tf 1h --equity 50000',
+    ];
+    static args = {
+        strategy: Args.string({ description: 'Strategy name', required: true }),
+    };
+    static flags = {
+        pair: Flags.string({ description: 'Trading pair', default: 'BTC-PERP' }),
+        tf: Flags.string({ description: 'Timeframe (auto-detected from strategy if omitted)' }),
+        equity: Flags.integer({ description: 'Starting equity in USDC', default: 10000 }),
+        leverage: Flags.integer({ description: 'Leverage multiplier', default: 1 }),
+        export: Flags.string({ description: 'Export results to file (csv or json)', options: ['csv', 'json'] }),
+        analyze: Flags.boolean({ description: 'AI-powered analysis of backtest results', default: false }),
+        'all-pairs': Flags.boolean({ description: 'Run across top pairs and rank results', default: false }),
+        top: Flags.integer({ description: 'Number of top pairs for --all-pairs', default: 10 }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Backtest);
+        const tfDisplay = flags.tf || 'auto';
+        const mode = flags['all-pairs'] ? `top ${flags.top} pairs` : flags.pair;
+        this.log('');
+        this.log(dim(`  Backtesting ${bold(args.strategy)} on ${mode} ${tfDisplay}...`));
+        this.log('');
+        const engineArgs = [
+            args.strategy,
+            '--pair', flags.pair,
+            '--equity', String(flags.equity),
+            '--leverage', String(flags.leverage),
+        ];
+        if (flags.tf)
+            engineArgs.push('--tf', flags.tf);
+        if (flags['all-pairs']) {
+            engineArgs.push('--all-pairs');
+            engineArgs.push('--top', String(flags.top));
+        }
+        let resultMsg = null;
+        await runEngine('backtest', engineArgs, (msg) => {
+            if (msg.type === 'progress') {
+                if (msg.equity != null) {
+                    const bar = this.progressBar(msg.pct);
+                    process.stdout.write(`\r  ${bar} ${String(msg.pct).padStart(3)}%  equity: $${msg.equity}`);
+                }
+                else {
+                    process.stdout.write(`\r  ${dim(String(msg.msg || ''))}${''.padEnd(20)}`);
+                }
+            }
+            else if (msg.type === 'result') {
+                process.stdout.write('\r' + ' '.repeat(80) + '\r');
+                if (msg.command === 'backtest-all-pairs') {
+                    this.renderAllPairs(msg);
+                }
+                else {
+                    resultMsg = msg;
+                    this.renderResult(msg);
+                }
+            }
+            else if (msg.type === 'error') {
+                this.error(msg.msg);
+            }
+        });
+        // Handle export
+        if (flags.export && resultMsg) {
+            this.exportResults(resultMsg, flags.export, args.strategy, flags.pair, flags.tf);
+        }
+        // Handle AI analysis
+        if (flags.analyze && resultMsg) {
+            await this.runAnalysis(resultMsg);
+        }
+    }
+    async runAnalysis(msg) {
+        this.log('');
+        this.log(dim('  ── AI Analysis ──'));
+        this.log('');
+        try {
+            this.log(dim('  Thinking...'));
+            const analysis = await analyzeBacktest(msg);
+            // Move cursor up to overwrite "Thinking..."
+            process.stdout.write('\x1b[1A\x1b[2K');
+            // Print analysis with nice formatting
+            const lines = analysis.split('\n');
+            for (const line of lines) {
+                this.log(`  ${line}`);
+            }
+            this.log('');
+        }
+        catch (error) {
+            process.stdout.write('\x1b[1A\x1b[2K');
+            const errMsg = error.message || String(error);
+            if (errMsg.includes('api_key') || errMsg.includes('API key') || errMsg.includes('authentication')) {
+                this.log(`  ${red('✘')} No API key configured.`);
+                this.log('');
+                this.log(`  ${dim('Set your Anthropic API key:')}`);
+                this.log(`    ${cyan('rift config set ai.api_key sk-ant-...')}`);
+                this.log(`  ${dim('Or set environment variable:')}`);
+                this.log(`    ${cyan('export RIFT_AI_API_KEY=sk-ant-...')}`);
+            }
+            else {
+                this.log(`  ${red('✘')} Analysis failed: ${errMsg.split('\n')[0]}`);
+            }
+            this.log('');
+        }
+    }
+    exportResults(msg, format, strategy, pair, tf) {
+        const exportData = msg.export;
+        if (!exportData) {
+            this.log(dim('  No export data available.'));
+            return;
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const baseName = `rift-${strategy}-${pair}-${tf}-${timestamp}`;
+        if (format === 'json') {
+            const filePath = `${baseName}.json`;
+            fs.writeFileSync(filePath, JSON.stringify(exportData, null, 2));
+            this.log(`  ${green('✔')} Exported to ${bold(filePath)}`);
+        }
+        else if (format === 'csv') {
+            // Metrics CSV
+            const metricsPath = `${baseName}-metrics.csv`;
+            const { trades, equity_curve, ...metrics } = exportData;
+            const metricsHeaders = Object.keys(metrics).join(',');
+            const metricsValues = Object.values(metrics).join(',');
+            fs.writeFileSync(metricsPath, `${metricsHeaders}\n${metricsValues}\n`);
+            // Trades CSV
+            const tradesPath = `${baseName}-trades.csv`;
+            if (trades && trades.length > 0) {
+                const tradeHeaders = Object.keys(trades[0]).join(',');
+                const tradeRows = trades.map((t) => Object.values(t).join(',')).join('\n');
+                fs.writeFileSync(tradesPath, `${tradeHeaders}\n${tradeRows}\n`);
+            }
+            else {
+                fs.writeFileSync(tradesPath, 'No trades\n');
+            }
+            this.log(`  ${green('✔')} Exported to:`);
+            this.log(`    ${bold(metricsPath)}`);
+            this.log(`    ${bold(tradesPath)}`);
+        }
+        this.log('');
+    }
+    renderResult(msg) {
+        const totalReturn = msg.total_return_pct;
+        const maxDD = msg.max_drawdown_pct;
+        const sharpe = msg.sharpe_ratio;
+        const pf = msg.profit_factor;
+        const winRate = msg.win_rate;
+        // Equity curve chart
+        const chart = msg.chart;
+        if (chart && chart.length > 0) {
+            this.log(dim('  ── Equity Curve ──'));
+            this.log('');
+            for (const line of chart) {
+                // Color the bars based on position relative to initial equity
+                this.log(`  ${cyan(line)}`);
+            }
+            this.log('');
+        }
+        // Results box
+        const w = 50;
+        const hr = '─'.repeat(w - 2);
+        this.log(`  ${dim('┌' + hr + '┐')}`);
+        this.log(`  ${dim('│')} ${bold('BACKTEST RESULTS')}${' '.repeat(w - 19)}${dim('│')}`);
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.row('Strategy', String(msg.strategy), w));
+        this.log(this.row('Pair', String(msg.pair), w));
+        this.log(this.row('Interval', String(msg.interval), w));
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.row('Initial', `$${Number(msg.initial_equity).toLocaleString()}`, w));
+        this.log(this.row('Final', `$${Number(msg.final_equity).toLocaleString()}`, w));
+        this.log(this.rowColored('Return', totalReturn, '%', w));
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.row('Trades', String(msg.num_trades), w));
+        this.log(this.row('Win Rate', `${winRate}%`, w, winRate >= 50 ? 'green' : winRate >= 40 ? 'yellow' : 'red'));
+        this.log(this.row('Wins / Losses', `${msg.wins} / ${msg.losses}`, w));
+        this.log(this.rowColored('Avg Win', msg.avg_win_pct, '%', w));
+        this.log(this.rowColored('Avg Loss', msg.avg_loss_pct, '%', w));
+        this.log(this.rowColored('Best Trade', msg.best_trade_pct, '%', w));
+        this.log(this.rowColored('Worst Trade', msg.worst_trade_pct, '%', w));
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.rowColored('Max Drawdown', maxDD, '%', w));
+        this.log(this.row('Sharpe Ratio', String(sharpe), w, sharpe > 1 ? 'green' : sharpe > 0 ? 'yellow' : 'red'));
+        this.log(this.row('Profit Factor', String(pf), w, pf > 1.5 ? 'green' : pf > 1 ? 'yellow' : 'red'));
+        this.log(this.row('Max Consec Wins', String(msg.max_consec_wins), w));
+        this.log(this.row('Max Consec Losses', String(msg.max_consec_losses), w));
+        // Funding info
+        const totalFunding = msg.total_funding;
+        if (totalFunding !== 0 && totalFunding != null) {
+            this.log(`  ${dim('├' + hr + '┤')}`);
+            this.log(this.rowColored('Funding P&L', totalFunding, '', w));
+        }
+        this.log(`  ${dim('└' + hr + '┘')}`);
+        this.log('');
+    }
+    row(label, value, width, color) {
+        const labelStr = `  ${label}:`;
+        // Strip ANSI for length calc
+        const cleanVal = value.replace(/\x1b\[[0-9;]*m/g, '');
+        const padding = width - labelStr.length - cleanVal.length - 3;
+        let coloredVal = value;
+        if (color === 'green')
+            coloredVal = green(value);
+        else if (color === 'red')
+            coloredVal = red(value);
+        else if (color === 'yellow')
+            coloredVal = yellow(value);
+        return `  ${dim('│')}${labelStr}${' '.repeat(Math.max(1, padding))}${coloredVal} ${dim('│')}`;
+    }
+    rowColored(label, value, suffix, width) {
+        const coloredStr = colorNum(value, suffix);
+        const cleanStr = `${value}${suffix}`;
+        const labelStr = `  ${label}:`;
+        const padding = width - labelStr.length - cleanStr.length - 3;
+        return `  ${dim('│')}${labelStr}${' '.repeat(Math.max(1, padding))}${coloredStr} ${dim('│')}`;
+    }
+    renderAllPairs(msg) {
+        const results = msg.results;
+        const strategy = msg.strategy;
+        const interval = msg.interval;
+        this.log(bold(`  ${strategy} across ${results.length} pairs (${interval})`));
+        this.log('');
+        if (!results || results.length === 0) {
+            this.log(dim('  No results.'));
+            return;
+        }
+        // Table header
+        const hdr = `  ${dim('│')} ${'#'.padEnd(3)} ${'Pair'.padEnd(10)} ${'Return'.padEnd(10)} ${'Sharpe'.padEnd(10)} ${'PF'.padEnd(8)} ${'MaxDD'.padEnd(10)} ${'Win%'.padEnd(8)} ${'Trades'.padEnd(8)} ${'Funding'.padEnd(10)} ${dim('│')}`;
+        const hrLen = hdr.replace(/\x1b\[[0-9;]*m/g, '').length;
+        const hr = `  ${dim('─'.repeat(hrLen - 2))}`;
+        this.log(hr);
+        this.log(hdr);
+        this.log(hr);
+        for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            const retStr = `${r.return_pct}%`;
+            const ddStr = `${r.max_drawdown_pct}%`;
+            let row = `  ${dim('│')} ${bold(String(i + 1).padEnd(3))} ${r.pair.padEnd(10)} `;
+            row += `${colorNum(r.return_pct, '%')}${' '.repeat(Math.max(1, 10 - retStr.length))} `;
+            row += `${colorNum(r.sharpe)}${' '.repeat(Math.max(1, 10 - String(r.sharpe).length))} `;
+            row += `${String(r.profit_factor).padEnd(8)} `;
+            row += `${colorNum(r.max_drawdown_pct, '%')}${' '.repeat(Math.max(1, 10 - ddStr.length))} `;
+            row += `${String(r.win_rate).padEnd(8)} `;
+            row += `${String(r.num_trades).padEnd(8)} `;
+            row += `${colorNum(r.total_funding)}${' '.repeat(Math.max(1, 10 - String(r.total_funding).length))} `;
+            row += dim('│');
+            this.log(row);
+        }
+        this.log(hr);
+        this.log('');
+        // Best pair
+        if (results.length > 1) {
+            const best = results[0];
+            this.log(`  ${green('★')} Best by Sharpe: ${bold(best.pair)} (${colorNum(best.return_pct, '% return')}, Sharpe ${colorNum(best.sharpe)})`);
+            this.log('');
+        }
+    }
+    progressBar(pct) {
+        const width = 25;
+        const filled = Math.round(width * pct / 100);
+        const empty = width - filled;
+        return dim('[') + green('█'.repeat(filled)) + dim('░'.repeat(empty)) + dim(']');
+    }
+}

package/dist/commands/collect/start.d.ts

@@ -0,0 +1,11 @@
+import { GatedCommand } from '../../lib/base-command.js';
+export default class CollectStart extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        symbols: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        tf: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'ob-interval': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/collect/start.js

@@ -0,0 +1,78 @@
+import { Flags } from '@oclif/core';
+import { GatedCommand } from '../../lib/base-command.js';
+import { runEngine } from '../../lib/python-bridge.js';
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+export default class CollectStart extends GatedCommand {
+    static description = 'Start the persistent data collector — builds historical data 24/7';
+    static examples = [
+        '$ rift collect start',
+        '$ rift collect start --symbols BTC,ETH,SOL,HYPE,DOGE --tf 1h,15m',
+        '$ rift collect start --ob-interval 30',
+    ];
+    static flags = {
+        symbols: Flags.string({ description: 'Comma-separated symbols to collect', default: 'BTC,ETH,SOL,HYPE' }),
+        tf: Flags.string({ description: 'Comma-separated timeframes for candles', default: '1h' }),
+        'ob-interval': Flags.integer({ description: 'Seconds between order book snapshots', default: 60 }),
+    };
+    async run() {
+        const { flags } = await this.parse(CollectStart);
+        const symbols = flags.symbols.split(',').map(s => s.trim());
+        const timeframes = flags.tf.split(',').map(t => t.trim());
+        this.log('');
+        this.log(`  ${bold('RIFT Data Collector')}`);
+        this.log(`  ${dim('─'.repeat(55))}`);
+        this.log(`  Symbols:    ${symbols.map(s => bold(s)).join(', ')}`);
+        this.log(`  Timeframes: ${timeframes.join(', ')}`);
+        this.log(`  Order book: every ${flags['ob-interval']}s`);
+        this.log(`  ${dim('─'.repeat(55))}`);
+        this.log('');
+        this.log(`  ${dim('Collecting:')}`);
+        this.log(`    ${green('•')} Candle data (OHLCV) for ${symbols.length} pairs`);
+        this.log(`    ${green('•')} Funding rates (hourly)`);
+        this.log(`    ${green('•')} L2 order book snapshots (${symbols.length} × ${Math.round(86400 / flags['ob-interval'])}/day)`);
+        this.log(`    ${green('•')} Market data (mid prices, funding)`);
+        this.log('');
+        this.log(`  ${dim('Data stored at: ~/.rift/data/ and ~/.rift/collector.db')}`);
+        this.log(`  ${dim('The longer this runs, the more valuable your data becomes.')}`);
+        this.log(`  ${dim('Press Ctrl+C to stop')}`);
+        this.log('');
+        const engineArgs = [
+            '--symbols', flags.symbols,
+            '--tf', flags.tf,
+            '--ob-interval', String(flags['ob-interval']),
+        ];
+        try {
+            await runEngine('collect', engineArgs, (msg) => {
+                if (msg.type === 'status') {
+                    this.log(`  ${green('✔')} ${msg.msg}`);
+                }
+                else if (msg.type === 'heartbeat') {
+                    const stats = msg.stats;
+                    const dbSize = msg.db_size_mb;
+                    process.stdout.write(`\r  ${dim(`Uptime: ${msg.uptime_minutes}min | OB: ${stats?.orderbook || 0} | Market: ${stats?.market || 0} | Candles: ${stats?.candles || 0} | DB: ${dbSize}MB`)}${''.padEnd(10)}`);
+                }
+                else if (msg.type === 'shutdown') {
+                    process.stdout.write('\r' + ' '.repeat(100) + '\r');
+                    this.log('');
+                    this.log(`  ${dim('Collector stopped.')}`);
+                    const stats = msg.stats;
+                    if (stats) {
+                        this.log(`  ${dim(`Total collected: ${stats.orderbook} orderbook, ${stats.market} market, ${stats.candles} candles, ${stats.funding} funding`)}`);
+                    }
+                    this.log('');
+                }
+                else if (msg.type === 'error') {
+                    this.log(`  ${dim(`Error: ${msg.msg}`)}`);
+                }
+            });
+        }
+        catch (error) {
+            if (!error.message.includes('null') && !error.message.includes('SIGTERM')) {
+                this.log(`  Error: ${error.message.split('\n')[0]}`);
+            }
+        }
+    }
+}

package/dist/commands/collect/status.d.ts

@@ -0,0 +1,6 @@
+import { GatedCommand } from '../../lib/base-command.js';
+export default class CollectStatus extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/collect/status.js

@@ -0,0 +1,60 @@
+import { GatedCommand } from '../../lib/base-command.js';
+import { runEngine } from '../../lib/python-bridge.js';
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+export default class CollectStatus extends GatedCommand {
+    static description = 'Check data collector status and statistics';
+    static examples = [
+        '$ rift collect status',
+    ];
+    async run() {
+        this.log('');
+        this.log(`  ${bold('Data Collector Status')}`);
+        this.log(`  ${dim('─'.repeat(45))}`);
+        this.log('');
+        await runEngine('collect-status', [], (msg) => {
+            if (msg.type === 'result') {
+                const running = msg.running;
+                const dbExists = msg.db_exists;
+                const dbSize = msg.db_size_mb;
+                const obCount = msg.orderbook_count;
+                const marketCount = msg.market_count;
+                const oldest = msg.oldest_data;
+                const newest = msg.newest_data;
+                const symbols = msg.symbols;
+                if (running) {
+                    this.log(`  ${green('●')} Collector is ${green('running')} (PID ${msg.pid})`);
+                }
+                else {
+                    this.log(`  ${red('●')} Collector is ${red('stopped')}`);
+                    this.log(`    ${dim('Start with: rift collect start')}`);
+                }
+                this.log('');
+                if (dbExists) {
+                    this.log(`  ${bold('Database:')} ${dim(`~/.rift/collector.db (${dbSize} MB)`)}`);
+                    this.log(`  ${bold('Order book snapshots:')} ${obCount.toLocaleString()}`);
+                    this.log(`  ${bold('Market snapshots:')} ${marketCount.toLocaleString()}`);
+                    if (symbols && symbols.length > 0) {
+                        this.log(`  ${bold('Symbols:')} ${symbols.join(', ')}`);
+                    }
+                    if (oldest && newest) {
+                        this.log(`  ${bold('Data range:')} ${oldest} → ${newest}`);
+                        // Calculate days of data
+                        const oldDate = new Date(oldest);
+                        const newDate = new Date(newest);
+                        const days = Math.round((newDate.getTime() - oldDate.getTime()) / (1000 * 60 * 60 * 24));
+                        this.log(`  ${bold('Days collected:')} ${days}`);
+                    }
+                }
+                else {
+                    this.log(`  ${yellow('!')} No collector database found`);
+                    this.log(`    ${dim('Start collecting: rift collect start')}`);
+                }
+                this.log('');
+            }
+        });
+    }
+}

package/dist/commands/compare.d.ts

@@ -0,0 +1,16 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Compare extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        strategies: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        pair: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        tf: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        equity: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        leverage: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private renderComparison;
+}

package/dist/commands/compare.js

@@ -0,0 +1,130 @@
+import { Flags, Args } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { runEngine } from '../lib/python-bridge.js';
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+function colorNum(val, suffix = '') {
+    const str = `${val}${suffix}`;
+    if (val > 0)
+        return green(str);
+    if (val < 0)
+        return red(str);
+    return yellow(str);
+}
+function bestOf(results, key, higher = true) {
+    const values = results.map(r => r[key]);
+    return higher ? Math.max(...values) : Math.min(...values);
+}
+export default class Compare extends GatedCommand {
+    static description = 'Compare multiple strategies head-to-head';
+    static examples = [
+        '$ rift compare trend_follow,my_strategy --pair BTC --tf 4h',
+    ];
+    static args = {
+        strategies: Args.string({ description: 'Comma-separated strategy names', required: true }),
+    };
+    static flags = {
+        pair: Flags.string({ description: 'Trading pair', default: 'BTC-PERP' }),
+        tf: Flags.string({ description: 'Timeframe', default: '15m' }),
+        equity: Flags.integer({ description: 'Starting equity in USDC', default: 10000 }),
+        leverage: Flags.integer({ description: 'Leverage multiplier', default: 1 }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Compare);
+        this.log('');
+        this.log(dim(`  Comparing strategies on ${flags.pair} ${flags.tf}...`));
+        this.log('');
+        const engineArgs = [
+            args.strategies,
+            '--pair', flags.pair,
+            '--tf', flags.tf,
+            '--equity', String(flags.equity),
+            '--leverage', String(flags.leverage),
+        ];
+        await runEngine('compare', engineArgs, (msg) => {
+            if (msg.type === 'progress' && msg.msg) {
+                process.stdout.write(`\r  ${dim(String(msg.msg))}${''.padEnd(40)}`);
+            }
+            else if (msg.type === 'result') {
+                process.stdout.write('\r' + ' '.repeat(80) + '\r');
+                this.renderComparison(msg.results);
+            }
+            else if (msg.type === 'error') {
+                this.error(msg.msg);
+            }
+        });
+    }
+    renderComparison(results) {
+        if (!results || results.length === 0) {
+            this.log('  No results.');
+            return;
+        }
+        // Column widths
+        const labelW = 18;
+        const colW = 18;
+        // Header
+        const hr = '─'.repeat(labelW + colW * results.length + 3);
+        this.log(`  ${dim(hr)}`);
+        let header = `  ${dim('│')} ${'Metric'.padEnd(labelW)}`;
+        for (const r of results) {
+            header += `${dim('│')} ${bold(cyan(String(r.strategy).padEnd(colW - 2)))} `;
+        }
+        header += dim('│');
+        this.log(header);
+        this.log(`  ${dim(hr)}`);
+        // Metrics rows
+        const metrics = [
+            { label: 'Return', key: 'total_return_pct', suffix: '%', higher: true },
+            { label: 'Final Equity', key: 'final_equity', suffix: '', higher: true, format: v => `$${Number(v).toLocaleString()}` },
+            { label: 'Trades', key: 'num_trades', suffix: '', higher: false },
+            { label: 'Win Rate', key: 'win_rate', suffix: '%', higher: true },
+            { label: 'Avg Win', key: 'avg_win_pct', suffix: '%', higher: true },
+            { label: 'Avg Loss', key: 'avg_loss_pct', suffix: '%', higher: false },
+            { label: 'Max Drawdown', key: 'max_drawdown_pct', suffix: '%', higher: false },
+            { label: 'Sharpe Ratio', key: 'sharpe_ratio', suffix: '', higher: true },
+            { label: 'Profit Factor', key: 'profit_factor', suffix: '', higher: true },
+        ];
+        for (const m of metrics) {
+            const best = bestOf(results, m.key, m.higher);
+            let row = `  ${dim('│')} ${m.label.padEnd(labelW)}`;
+            for (const r of results) {
+                const val = r[m.key];
+                let display;
+                if (m.format) {
+                    display = m.format(val);
+                }
+                else {
+                    display = `${val}${m.suffix}`;
+                }
+                // Highlight best
+                const isBest = val === best && results.length > 1;
+                const cleanLen = display.replace(/\x1b\[[0-9;]*m/g, '').length;
+                if (m.key === 'total_return_pct' || m.key === 'max_drawdown_pct' || m.key === 'avg_win_pct' || m.key === 'avg_loss_pct' || m.key === 'sharpe_ratio') {
+                    display = colorNum(val, m.suffix);
+                }
+                if (isBest) {
+                    display = bold(display) + ' ★';
+                    row += `${dim('│')} ${display}${' '.repeat(Math.max(0, colW - cleanLen - 4))} `;
+                }
+                else {
+                    row += `${dim('│')} ${display}${' '.repeat(Math.max(0, colW - cleanLen - 2))} `;
+                }
+            }
+            row += dim('│');
+            this.log(row);
+        }
+        this.log(`  ${dim(hr)}`);
+        // Winner
+        const bestReturn = bestOf(results, 'total_return_pct', true);
+        const winner = results.find(r => r.total_return_pct === bestReturn);
+        if (winner && results.length > 1) {
+            this.log('');
+            this.log(`  ${green('★')} Winner by return: ${bold(cyan(winner.strategy))} ${green(`(${winner.total_return_pct}%)`)}`);
+        }
+        this.log('');
+    }
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,16 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Config extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static args: {
+        action: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        key: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private listConfig;
+    private printObject;
+    private getConfig;
+    private setConfig;
+}