@nexstone/rift-cli 0.1.1

package/dist/commands/init.js

@@ -0,0 +1,122 @@
+import { GatedCommand } from '../lib/base-command.js';
+import { createInterface } from 'node:readline';
+import { runEngine } from '../lib/python-bridge.js';
+import { hasCredentials } from '../lib/credentials.js';
+import { hasApprovedFees, approveFees, BUILDER_FEE_DISPLAY } from '../lib/fees.js';
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${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 ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export default class Init extends GatedCommand {
+    static description = 'Set up RIFT — wallet, sample data, and first backtest in under 60 seconds';
+    static examples = [
+        '$ rift init',
+    ];
+    static flags = {};
+    async run() {
+        const { flags } = await this.parse(Init);
+        this.log('');
+        this.log(`  ${bold('Welcome to RIFT')} ${dim('— Research / Iteration / Forecast / Trade')}`);
+        this.log(`  ${dim('─'.repeat(50))}`);
+        this.log('');
+        // Step 1: Builder fee approval
+        this.log(`  ${dim('1/4')} Builder fee agreement...`);
+        if (hasApprovedFees()) {
+            this.log(`  ${green('✔')} Builder fee already approved`);
+        }
+        else {
+            this.log('');
+            this.log(`  RIFT is free and open-source. To support ongoing`);
+            this.log(`  development, a ${bold(BUILDER_FEE_DISPLAY)} builder fee is applied to live`);
+            this.log(`  trades executed through RIFT on Hyperliquid.`);
+            this.log('');
+            this.log(`  ${dim('Backtesting, simulation, and analysis are always free.')}`);
+            this.log(`  ${dim('Example: on a $10,000 perp trade, the fee is $3.')}`);
+            this.log('');
+            const answer = await ask(`  ${cyan('Do you agree?')} ${dim('(yes/no)')}: `);
+            if (answer.toLowerCase() === 'yes' || answer.toLowerCase() === 'y') {
+                approveFees();
+                this.log(`  ${green('✔')} Builder fee approved. Thank you for supporting RIFT.`);
+            }
+            else {
+                this.log('');
+                this.log(`  ${red('RIFT requires builder fee approval to operate.')}`);
+                this.log(`  ${dim('Run rift init again when you\'re ready.')}`);
+                this.log('');
+                return;
+            }
+        }
+        this.log('');
+        // Step 2: Check/generate wallet
+        this.log(`  ${dim('2/4')} Setting up wallet...`);
+        if (hasCredentials()) {
+            this.log(`  ${green('✔')} Wallet already configured`);
+        }
+        else {
+            const { generatePrivateKey, privateKeyToAccount } = await import('viem/accounts');
+            const { saveCredentials } = await import('../lib/credentials.js');
+            const privateKey = generatePrivateKey();
+            const account = privateKeyToAccount(privateKey);
+            saveCredentials({
+                private_key: privateKey.replace(/^0x/, ''),
+                address: account.address.toLowerCase(),
+                account_address: account.address.toLowerCase(),
+                type: 'generated',
+                network: 'mainnet',
+                registered_at: new Date().toISOString(),
+            });
+            this.log(`  ${green('✔')} Wallet generated: ${dim(account.address)}`);
+            this.log(`  ${yellow('!')} Save your private key: ${privateKey}`);
+        }
+        this.log('');
+        // Step 3: Fetch sample data
+        this.log(`  ${dim('3/4')} Fetching BTC 1h data from Hyperliquid...`);
+        try {
+            await runEngine('fetch', ['BTC', '--tf', '1h'], (msg) => {
+                if (msg.type === 'result') {
+                    this.log(`  ${green('✔')} Cached ${msg.candles} candles`);
+                }
+            });
+        }
+        catch {
+            this.log(`  ${yellow('!')} Could not fetch data (offline?). You can run 'rift data fetch' later.`);
+        }
+        this.log('');
+        // Step 4: Run a quick backtest
+        this.log(`  ${dim('4/4')} Running sample backtest...`);
+        try {
+            await runEngine('backtest', ['trend_follow', '--pair', 'BTC', '--tf', '4h'], (msg) => {
+                if (msg.type === 'result') {
+                    const ret = msg.total_return_pct;
+                    const trades = msg.num_trades;
+                    this.log(`  ${green('✔')} Backtest complete: ${ret > 0 ? green(`+${ret}%`) : `${ret}%`} return, ${trades} trades`);
+                }
+            });
+        }
+        catch {
+            this.log(`  ${yellow('!')} Backtest skipped. Run manually: rift backtest trend_follow --pair BTC --tf 4h`);
+        }
+        this.log('');
+        this.log(`  ${dim('─'.repeat(50))}`);
+        this.log(`  ${green('✔')} ${bold('RIFT is ready.')}`);
+        this.log('');
+        this.log(`  ${dim('Try these commands:')}`);
+        this.log(`    ${cyan('rift strategies list')}             ${dim('— see available strategies')}`);
+        this.log(`    ${cyan('rift backtest trend_follow --pair BTC --tf 4h')}  ${dim('— run a backtest')}`);
+        this.log(`    ${cyan('rift guide')}                        ${dim('— 9-step research-to-trade journey')}`);
+        this.log(`    ${cyan('rift new my-strategy')}              ${dim('— create your own')}`);
+        this.log(`    ${cyan('rift doctor')}                       ${dim('— check system health')}`);
+        this.log('');
+    }
+}

package/dist/commands/install.d.ts

@@ -0,0 +1,9 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Install extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        source: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/install.js

@@ -0,0 +1,89 @@
+import { Args } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+function findProjectRoot() {
+    let dir = path.resolve(__dirname);
+    for (let i = 0; i < 10; i++) {
+        if (fs.existsSync(path.join(dir, 'engine', 'pyproject.toml')))
+            return dir;
+        dir = path.dirname(dir);
+    }
+    throw new Error('Cannot find project root');
+}
+export default class Install extends GatedCommand {
+    static description = 'Install a community strategy from GitHub';
+    static examples = [
+        '$ rift install https://github.com/user/rift-strategy-bollinger',
+        '$ rift install user/rift-strategy-macd',
+    ];
+    static args = {
+        source: Args.string({
+            description: 'GitHub repo URL or user/repo shorthand',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(Install);
+        const source = args.source;
+        // Normalize to full URL
+        let repoUrl = source;
+        if (!source.startsWith('http')) {
+            repoUrl = `https://github.com/${source}`;
+        }
+        // Extract repo name for strategy directory name
+        const repoName = repoUrl.split('/').pop()?.replace(/\.git$/, '') || 'unknown';
+        const strategyName = repoName.replace(/^rift-strategy-/, '').replace(/^rift-/, '');
+        const projectRoot = findProjectRoot();
+        const strategiesDir = path.join(projectRoot, 'strategies');
+        const targetDir = path.join(strategiesDir, strategyName);
+        if (fs.existsSync(targetDir)) {
+            this.log(`  ${red('✘')} Strategy "${strategyName}" already exists at ${targetDir}`);
+            this.log(`  ${dim('Remove it first: rm -rf ' + targetDir)}`);
+            return;
+        }
+        this.log('');
+        this.log(`  Installing ${bold(strategyName)} from ${dim(repoUrl)}...`);
+        this.log('');
+        try {
+            // Clone into strategies dir
+            execSync(`git clone --depth 1 ${repoUrl} ${targetDir}`, { stdio: 'pipe' });
+            // Remove .git dir (it's now part of our project)
+            const gitDir = path.join(targetDir, '.git');
+            if (fs.existsSync(gitDir)) {
+                fs.rmSync(gitDir, { recursive: true });
+            }
+            // Check for strategy.py
+            const hasStrategy = fs.existsSync(path.join(targetDir, 'strategy.py'));
+            const hasPy = fs.readdirSync(targetDir).some(f => f.endsWith('.py'));
+            if (hasStrategy || hasPy) {
+                this.log(`  ${green('✔')} Strategy ${bold(strategyName)} installed`);
+                this.log('');
+                // List files
+                const files = fs.readdirSync(targetDir).filter(f => !f.startsWith('.'));
+                for (const f of files) {
+                    this.log(`    ${f}`);
+                }
+                this.log('');
+                this.log(`  ${dim('Run:')} ${cyan(`rift backtest ${strategyName} --pair BTC-PERP --tf 1h`)}`);
+            }
+            else {
+                this.log(`  ${red('✘')} No .py strategy files found in the repo`);
+                fs.rmSync(targetDir, { recursive: true });
+            }
+        }
+        catch (error) {
+            this.log(`  ${red('✘')} Failed to install: ${error.message.split('\n')[0]}`);
+        }
+        this.log('');
+    }
+}

package/dist/commands/interactive.d.ts

@@ -0,0 +1,17 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Interactive extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    /**
+     * Run a subcommand and pause briefly if it exited fast (likely a
+     * precondition failure that printed an error). Prevents the menu redraw
+     * from clobbering "Trade requires wallet setup" etc.
+     */
+    private dispatch;
+    private interactiveBacktest;
+    private interactiveCompare;
+    private interactiveFetch;
+    private interactivePortfolio;
+    private interactiveNew;
+}

package/dist/commands/interactive.js

@@ -0,0 +1,179 @@
+import { GatedCommand } from '../lib/base-command.js';
+import { createInterface } from 'node:readline';
+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 ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function menu(title, options) {
+    console.log('');
+    console.log(`  ${bold(title)}`);
+    console.log('');
+    for (const opt of options) {
+        console.log(`    ${cyan(opt.key)}  ${opt.label}  ${dim(opt.desc)}`);
+    }
+    console.log('');
+}
+export default class Interactive extends GatedCommand {
+    static description = 'Launch interactive mode';
+    static examples = [
+        '$ rift interactive',
+    ];
+    async run() {
+        // Main loop — after each action the user returns to the menu.
+        // Exit via `0`, `q`, `quit`, or Ctrl-C.
+        while (true) {
+            console.log('');
+            console.log(`  ${bold('⬡ RIFT')} ${dim('v0.1.0')}`);
+            console.log(`  ${dim('Research / Iteration / Forecast / Trade')}`);
+            menu('What would you like to do?', [
+                { key: '1', label: 'Scout the market', desc: '— scan for opportunities now' },
+                { key: '2', label: 'Quick trade', desc: '— manual trade with stop loss' },
+                { key: '3', label: 'Backtest a strategy', desc: '— test on historical data' },
+                { key: '4', label: 'Compare strategies', desc: '— head-to-head comparison' },
+                { key: '5', label: 'Fetch market data', desc: '— download candles from Hyperliquid' },
+                { key: '6', label: 'Create a new strategy', desc: '— scaffold from template' },
+                { key: '7', label: 'Portfolio manager', desc: '— multi-strategy algo trading' },
+                { key: '8', label: 'System health check', desc: '— run rift doctor' },
+                { key: '9', label: 'Quick start', desc: '— set up everything' },
+                { key: '0', label: 'Exit', desc: '' },
+            ]);
+            const action = await ask(`  ${cyan('>')} `);
+            switch (action) {
+                case '0':
+                case 'q':
+                case 'quit':
+                case 'exit':
+                    console.log('');
+                    return;
+                case '1':
+                    await this.dispatch('scout');
+                    break;
+                case '2':
+                    await this.dispatch('trade');
+                    break;
+                case '3':
+                    await this.interactiveBacktest();
+                    break;
+                case '4':
+                    await this.interactiveCompare();
+                    break;
+                case '5':
+                    await this.interactiveFetch();
+                    break;
+                case '6':
+                    await this.interactiveNew();
+                    break;
+                case '7':
+                    await this.interactivePortfolio();
+                    break;
+                case '8':
+                    await this.dispatch('doctor');
+                    break;
+                case '9':
+                    await this.dispatch('init');
+                    break;
+                default:
+                    if (action) {
+                        console.log(dim('  Invalid selection. Pick 0-9.'));
+                    }
+            }
+        }
+    }
+    /**
+     * Run a subcommand and pause briefly if it exited fast (likely a
+     * precondition failure that printed an error). Prevents the menu redraw
+     * from clobbering "Trade requires wallet setup" etc.
+     */
+    async dispatch(cmd, args = []) {
+        const start = Date.now();
+        try {
+            await this.config.runCommand(cmd, args);
+        }
+        catch (err) {
+            console.log(`\n  ${dim('Command threw:')} ${err?.message ?? err}\n`);
+        }
+        const elapsed = Date.now() - start;
+        if (elapsed < 1500) {
+            await ask(`  ${dim('Press Enter to return to menu...')} `);
+        }
+    }
+    async interactiveBacktest() {
+        const strategy = await ask(`  ${cyan('Strategy name')} ${dim('(e.g. trend_follow, or run rift strategies to see all)')}: `);
+        if (!strategy) {
+            console.log(dim('  Cancelled — no strategy name given.'));
+            return;
+        }
+        const pair = await ask(`  ${cyan('Ticker')} ${dim('(BTC)')}: `) || 'BTC';
+        const tf = await ask(`  ${cyan('Timeframe')} ${dim('(1h)')}: `) || '1h';
+        console.log('');
+        await this.config.runCommand('backtest', [strategy, '--pair', pair, '--tf', tf]);
+    }
+    async interactiveCompare() {
+        const input = await ask(`  ${cyan('Strategies')} ${dim('(comma-separated, e.g. trend_follow,my_strategy)')}: `);
+        if (!input) {
+            console.log(dim('  Cancelled — no strategies given.'));
+            return;
+        }
+        const pair = await ask(`  ${cyan('Ticker')} ${dim('(BTC)')}: `) || 'BTC';
+        const tf = await ask(`  ${cyan('Timeframe')} ${dim('(1h)')}: `) || '1h';
+        console.log('');
+        await this.config.runCommand('compare', [input, '--pair', pair, '--tf', tf]);
+    }
+    async interactiveFetch() {
+        const pair = await ask(`  ${cyan('Ticker')} ${dim('(BTC)')}: `) || 'BTC';
+        const tf = await ask(`  ${cyan('Timeframe')} ${dim('(1h)')}: `) || '1h';
+        console.log('');
+        await this.config.runCommand('data:fetch', ['--pair', pair, '--tf', tf]);
+    }
+    async interactivePortfolio() {
+        menu('Portfolio Manager', [
+            { key: '1', label: 'Create portfolio', desc: '— build a portfolio config' },
+            { key: '2', label: 'Start portfolio', desc: '— launch supervisor + strategies' },
+            { key: '3', label: 'Portfolio status', desc: '— view running portfolio' },
+            { key: '4', label: 'Stop portfolio', desc: '— stop all strategies' },
+            { key: '5', label: 'View alerts', desc: '— recent trading alerts' },
+            { key: '0', label: 'Back', desc: '' },
+        ]);
+        const choice = await ask(`  ${cyan('>')} `);
+        switch (choice) {
+            case '0':
+            case 'q':
+            case '':
+                return;
+            case '1':
+                await this.config.runCommand('portfolio:create');
+                break;
+            case '2':
+                await this.config.runCommand('portfolio:start');
+                break;
+            case '3':
+                await this.config.runCommand('portfolio:status');
+                break;
+            case '4':
+                await this.config.runCommand('portfolio:stop');
+                break;
+            case '5':
+                await this.config.runCommand('portfolio:alerts');
+                break;
+            default:
+                console.log(dim('  Invalid selection. Pick 0-5.'));
+        }
+    }
+    async interactiveNew() {
+        const name = await ask(`  ${cyan('Strategy name')}: `);
+        if (!name) {
+            console.log(dim('  Cancelled — no strategy name given.'));
+            return;
+        }
+        console.log('');
+        await this.config.runCommand('new', [name]);
+    }
+}

package/dist/commands/lessons.d.ts

@@ -0,0 +1,12 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Lessons extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        coin: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        strategy: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/lessons.js

@@ -0,0 +1,33 @@
+import { Flags } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { passthroughToEngine } from '../lib/engine-passthrough.js';
+export default class Lessons extends GatedCommand {
+    static description = 'Show captured trading lessons (post-trade learnings)';
+    static examples = [
+        '$ rift lessons',
+        '$ rift lessons --strategy trend_follow',
+    ];
+    static flags = {
+        coin: Flags.string({ description: 'Filter by coin', default: '' }),
+        strategy: Flags.string({ description: 'Filter by strategy name', default: '' }),
+        limit: Flags.string({ description: 'Number of lessons to show', default: '20' }),
+        json: Flags.boolean({ description: 'Emit raw JSON only', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(Lessons);
+        const args = [];
+        if (flags.coin)
+            args.push('--coin', flags.coin);
+        if (flags.strategy)
+            args.push('--strategy', flags.strategy);
+        args.push('--limit', flags.limit);
+        await passthroughToEngine({
+            command: 'lessons',
+            args,
+            log: (m) => this.log(m),
+            error: (m) => this.error(m),
+            exit: (c) => this.exit(c),
+            jsonOnly: flags.json,
+        });
+    }
+}

package/dist/commands/montecarlo.d.ts

@@ -0,0 +1,19 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class MonteCarlo extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        strategy: 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>;
+        runs: import("@oclif/core/interfaces").OptionFlag<number, 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 renderResult;
+    private row;
+    private rowColored;
+}

package/dist/commands/montecarlo.js

@@ -0,0 +1,168 @@
+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 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 MonteCarlo extends GatedCommand {
+    static description = 'Run Monte Carlo simulation to test how much of your backtest was luck vs edge';
+    static examples = [
+        '$ rift montecarlo trend_follow --pair BTC --tf 4h',
+        '$ rift montecarlo trend_follow --pair BTC --tf 4h --runs 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', default: '1h' }),
+        runs: Flags.integer({ description: 'Number of simulations', default: 10000 }),
+        equity: Flags.integer({ description: 'Starting equity', default: 10000 }),
+        leverage: Flags.integer({ description: 'Leverage multiplier', default: 1 }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(MonteCarlo);
+        this.log('');
+        this.log(`  ${bold('Monte Carlo Simulation')}`);
+        this.log(`  ${dim(`${args.strategy} on ${flags.pair} ${flags.tf} — ${flags.runs.toLocaleString()} simulations`)}`);
+        this.log('');
+        const engineArgs = [
+            args.strategy,
+            '--pair', flags.pair,
+            '--tf', flags.tf,
+            '--runs', String(flags.runs),
+            '--equity', String(flags.equity),
+            '--leverage', String(flags.leverage),
+        ];
+        await runEngine('montecarlo', engineArgs, (msg) => {
+            if (msg.type === 'progress' && msg.msg) {
+                process.stdout.write(`\r  ${dim(String(msg.msg))}${''.padEnd(20)}`);
+            }
+            else if (msg.type === 'result') {
+                process.stdout.write('\r' + ' '.repeat(80) + '\r');
+                this.renderResult(msg);
+            }
+            else if (msg.type === 'error') {
+                process.stdout.write('\r' + ' '.repeat(80) + '\r');
+                this.error(msg.msg);
+            }
+        });
+    }
+    renderResult(msg) {
+        const ret = msg.return_distribution;
+        const dd = msg.drawdown_distribution;
+        const histogram = msg.histogram;
+        const probProfit = msg.prob_profit;
+        const probRuin = msg.prob_ruin;
+        const originalReturn = msg.original_return_pct;
+        const numTrades = msg.num_trades;
+        const numSims = msg.num_simulations;
+        // ASCII histogram
+        this.log(dim('  ── Return Distribution ──'));
+        this.log('');
+        const maxCount = Math.max(...histogram.map(h => h.count));
+        const barWidth = 30;
+        for (const bucket of histogram) {
+            const barLen = Math.round((bucket.count / maxCount) * barWidth);
+            const bar = '█'.repeat(barLen);
+            const label = `${bucket.low.toFixed(0)}%`.padStart(8);
+            const countStr = dim(`(${bucket.pct}%)`);
+            // Color bar based on whether bucket is positive or negative
+            const midpoint = (bucket.low + bucket.high) / 2;
+            const coloredBar = midpoint >= 0 ? green(bar) : red(bar);
+            this.log(`  ${label} ${coloredBar} ${countStr}`);
+        }
+        this.log('');
+        // Summary box
+        const w = 55;
+        const hr = '─'.repeat(w - 2);
+        this.log(`  ${dim('┌' + hr + '┐')}`);
+        this.log(`  ${dim('│')} ${bold('MONTE CARLO RESULTS')}${' '.repeat(w - 22)}${dim('│')}`);
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.row('Strategy', String(msg.strategy), w));
+        this.log(this.row('Pair / Interval', `${msg.pair} ${msg.interval}`, w));
+        this.log(this.row('Trades', String(numTrades), w));
+        this.log(this.row('Simulations', numSims.toLocaleString(), w));
+        this.log(this.rowColored('Original Return', originalReturn, '%', w));
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(`  ${dim('│')} ${dim('RETURN PERCENTILES')}${' '.repeat(w - 22)}${dim('│')}`);
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.rowColored('5th (worst case)', ret.p5, '%', w));
+        this.log(this.rowColored('10th', ret.p10, '%', w));
+        this.log(this.rowColored('25th', ret.p25, '%', w));
+        this.log(this.rowColored('50th (median)', ret.p50, '%', w));
+        this.log(this.rowColored('75th', ret.p75, '%', w));
+        this.log(this.rowColored('90th', ret.p90, '%', w));
+        this.log(this.rowColored('95th (best case)', ret.p95, '%', w));
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(`  ${dim('│')} ${dim('MAX DRAWDOWN PERCENTILES')}${' '.repeat(w - 28)}${dim('│')}`);
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.rowColored('5th (worst)', dd.p5, '%', w));
+        this.log(this.rowColored('25th', dd.p25, '%', w));
+        this.log(this.rowColored('50th (median)', dd.p50, '%', w));
+        this.log(this.rowColored('75th', dd.p75, '%', w));
+        this.log(this.rowColored('95th (best)', dd.p95, '%', w));
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(`  ${dim('│')} ${bold('RISK ASSESSMENT')}${' '.repeat(w - 19)}${dim('│')}`);
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.row('Probability of Profit', `${probProfit}%`, w, probProfit >= 60 ? 'green' : probProfit >= 40 ? 'yellow' : 'red'));
+        this.log(this.row('Probability of Ruin (>50% DD)', `${probRuin}%`, w, probRuin <= 10 ? 'green' : probRuin <= 30 ? 'yellow' : 'red'));
+        this.log(this.rowColored('Median Sharpe', msg.median_sharpe, '', w));
+        this.log(`  ${dim('└' + hr + '┘')}`);
+        this.log('');
+        // Interpretation
+        this.log(dim('  ── Interpretation ──'));
+        this.log('');
+        if (ret.p5 > 0) {
+            this.log(`  ${green('Even in the worst 5% of scenarios, this strategy is profitable.')}`);
+            this.log(`  ${dim('The edge is robust — not dependent on lucky trade ordering.')}`);
+        }
+        else if (ret.p25 > 0) {
+            this.log(`  ${yellow('The strategy is profitable in most scenarios, but the bottom 25% lose money.')}`);
+            this.log(`  ${dim('Some of the backtest return may be from favorable trade sequencing.')}`);
+        }
+        else if (ret.p50 > 0) {
+            this.log(`  ${yellow('Median outcome is positive, but there is significant downside risk.')}`);
+            this.log(`  ${dim('The strategy has an edge but is sensitive to trade ordering. Consider tighter risk management.')}`);
+        }
+        else {
+            this.log(`  ${red('The median outcome is negative. The original backtest result was likely lucky.')}`);
+            this.log(`  ${dim('This strategy does not have a reliable edge. Do not trade this.')}`);
+        }
+        if (probRuin > 30) {
+            this.log(`  ${red(`Warning: ${probRuin}% chance of >50% drawdown. This is extremely risky.`)}`);
+        }
+        this.log('');
+    }
+    row(label, value, width, color) {
+        const labelStr = `  ${label}:`;
+        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('│')}`;
+    }
+}

package/dist/commands/more.d.ts

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