@nexstone/rift-cli 0.1.1

package/dist/commands/test-trade.d.ts

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

package/dist/commands/test-trade.js

@@ -0,0 +1,97 @@
+import { GatedCommand } from '../lib/base-command.js';
+import { loadCredentials, hasFullSetup, getAccountAddress } from '../lib/credentials.js';
+import { runEngine } from '../lib/python-bridge.js';
+import { createInterface } from 'node:readline';
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${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 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 TestTrade extends GatedCommand {
+    static description = 'Place a minimum-size test trade to verify exchange connectivity';
+    static examples = [
+        '$ rift test-trade',
+    ];
+    async run() {
+        if (!hasFullSetup()) {
+            this.log('');
+            this.log(`  ${red('Not set up.')} Run ${cyan('rift auth setup')} first.`);
+            this.log('');
+            return;
+        }
+        const creds = loadCredentials();
+        this.log('');
+        this.log(`  ${bold('╔═══════════════════════════════════════════╗')}`);
+        this.log(`  ${bold('║          RIFT Exchange Test                ║')}`);
+        this.log(`  ${bold('╚═══════════════════════════════════════════╝')}`);
+        this.log('');
+        this.log(`  This will:`);
+        this.log(`    ${cyan('1.')} Connect to Hyperliquid`);
+        this.log(`    ${cyan('2.')} Place a minimum-size BTC long ($10)`);
+        this.log(`    ${cyan('3.')} Verify the stop loss is placed`);
+        this.log(`    ${cyan('4.')} Wait 10 seconds`);
+        this.log(`    ${cyan('5.')} Close the position`);
+        this.log(`    ${cyan('6.')} Report results`);
+        this.log('');
+        const mainAddr = getAccountAddress(creds);
+        this.log(`  ${dim('Wallet:')}  ${mainAddr}`);
+        this.log(`  ${dim('Cost:')}    ~$0.07 in fees (2x $0.035 per side)`);
+        this.log('');
+        const confirm = await ask(`  ${cyan('Run test?')} ${dim('(yes/no)')}: `);
+        if (confirm.toLowerCase() !== 'yes' && confirm.toLowerCase() !== 'y') {
+            this.log(dim('\n  Cancelled.\n'));
+            return;
+        }
+        this.log('');
+        const engineArgs = [
+            '--private-key', creds.private_key,
+            '--account', mainAddr,
+        ];
+        try {
+            await runEngine('test-trade', [
+                '--account', mainAddr,
+            ], (msg) => {
+                if (msg.type === 'status') {
+                    const icon = String(msg.msg).includes('✔') ? '' : '  ';
+                    this.log(`${icon}${msg.msg}`);
+                }
+                else if (msg.type === 'error') {
+                    this.log(`  ${red('✘')} ${msg.msg}`);
+                }
+                else if (msg.type === 'result') {
+                    this.log('');
+                    this.log(`  ${bold('═'.repeat(45))}`);
+                    this.log('');
+                    if (msg.success) {
+                        this.log(`  ${green('✔ TEST PASSED')} — Exchange connectivity verified`);
+                        this.log('');
+                        this.log(`  ${dim('Entry price:')}  $${msg.entry_price}`);
+                        this.log(`  ${dim('Exit price:')}   $${msg.exit_price}`);
+                        this.log(`  ${dim('P&L:')}          $${msg.pnl}`);
+                        this.log(`  ${dim('Stop loss:')}    ${msg.stop_placed ? green('✔ placed') : red('✘ failed')}`);
+                        this.log(`  ${dim('Close:')}        ${msg.close_success ? green('✔ clean') : red('✘ failed')}`);
+                    }
+                    else {
+                        this.log(`  ${red('✘ TEST FAILED')} — ${msg.error || 'Unknown error'}`);
+                    }
+                    this.log('');
+                    this.log(`  ${bold('═'.repeat(45))}`);
+                    this.log('');
+                }
+            }, { HYPERLIQUID_PRIVATE_KEY: creds.private_key });
+        }
+        catch (error) {
+            this.log(`  ${red('✘')} Test failed: ${error?.message}`);
+        }
+        finally {
+            // Clean up private key from environment
+            delete process.env.HYPERLIQUID_PRIVATE_KEY;
+        }
+    }
+}

package/dist/commands/trade.d.ts

@@ -0,0 +1,26 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Trade extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        pair: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        direction: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        size: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        stop: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        leverage: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private dashboardActive;
+    private ds;
+    private tickTimer;
+    private sessionStart;
+    private static readonly DASHBOARD_HEIGHT;
+    run(): Promise<void>;
+    private executeTrade;
+    private handleTradeEvent;
+    private renderTradeReplay;
+    private clearDashboard;
+    private renderDashboard;
+}

package/dist/commands/trade.js

@@ -0,0 +1,274 @@
+import { Args, Flags } from '@oclif/core';
+import { createInterface } from 'node:readline';
+import { GatedCommand } from '../lib/base-command.js';
+import { runEngine } from '../lib/python-bridge.js';
+import { loadCredentials, hasFullSetup, getAccountAddress } from '../lib/credentials.js';
+import { BUILDER_FEE_DISPLAY } from '../lib/fees.js';
+import { green, red, yellow, cyan, bold, dim, greenBg, colorPnl, sparkline, proximityBar, fundingCountdown, createDashboardState, updateDashboardState, } from '../lib/tui.js';
+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 Trade extends GatedCommand {
+    static description = 'Place a manual trade with stop loss and live monitoring';
+    static examples = [
+        '$ rift trade ETH long --size 500',
+        '$ rift trade SOL short --size 1000 --stop 3',
+        '$ rift trade',
+    ];
+    static args = {
+        pair: Args.string({ description: 'Coin (e.g. BTC, ETH, SOL)', required: false }),
+        direction: Args.string({ description: 'long or short', required: false }),
+    };
+    static flags = {
+        size: Flags.integer({ description: 'Position size in USD', default: 0 }),
+        stop: Flags.string({ description: 'Stop loss % (default: 2)', default: '2' }),
+        leverage: Flags.integer({ description: 'Leverage', default: 1 }),
+        // Internal: skip the "Type GO to execute" confirmation prompt. Used
+        // by `rift perp long/short` which already require the user to type
+        // the direction explicitly in the verb (e.g. `rift perp long BTC
+        // --size 10`), so the second confirmation is redundant. The flag is
+        // intentionally undocumented in the user-facing description — it
+        // exists for internal delegation, not for users to type directly.
+        yes: Flags.boolean({ description: 'Skip the GO confirmation prompt (for internal delegation)', default: false, hidden: true }),
+    };
+    dashboardActive = false;
+    ds = createDashboardState();
+    tickTimer = null;
+    sessionStart = 0;
+    static DASHBOARD_HEIGHT = 14;
+    async run() {
+        const { args, flags } = await this.parse(Trade);
+        if (!hasFullSetup()) {
+            this.log(`\n  ${red('✘')} Trade requires wallet setup. Run: ${cyan('rift auth setup')}\n`);
+            return;
+        }
+        const creds = loadCredentials();
+        if (!creds) {
+            this.log(`\n  ${red('✘')} No credentials.\n`);
+            return;
+        }
+        // Interactive mode if no args
+        let pair = args.pair || '';
+        let direction = args.direction || '';
+        let sizeUsd = flags.size || 0;
+        const stopPct = parseFloat(flags.stop) / 100;
+        if (!pair) {
+            this.log('');
+            this.log(`  ${bold('Quick Trade')}`);
+            this.log(`  ${dim('─'.repeat(40))}`);
+            this.log('');
+            pair = (await ask(`  ${cyan('Coin')} ${dim('(BTC)')}: `)) || 'BTC';
+        }
+        if (!direction) {
+            direction = await ask(`  ${cyan('Direction')} ${dim('(long/short)')}: `);
+            if (!direction || !['long', 'short'].includes(direction.toLowerCase())) {
+                this.log(`  ${dim('Cancelled.')}`);
+                return;
+            }
+        }
+        if (!sizeUsd) {
+            const sizeStr = await ask(`  ${cyan('Size in USD')} ${dim('(500)')}: `);
+            sizeUsd = parseInt(sizeStr) || 500;
+        }
+        pair = pair.toUpperCase();
+        direction = direction.toLowerCase();
+        const dirColor = direction === 'long' ? green : red;
+        // Confirmation
+        this.log('');
+        this.log(`  ${bold('╔════════════════════════════════════════╗')}`);
+        this.log(`  ${bold('║')}  ${dirColor(direction.toUpperCase())} ${bold(pair)}  $${sizeUsd.toLocaleString()}${' '.repeat(Math.max(1, 22 - pair.length - String(sizeUsd).length))}${bold('║')}`);
+        this.log(`  ${bold('║')}  Stop: ${(stopPct * 100).toFixed(1)}%   Fee: ${BUILDER_FEE_DISPLAY}${' '.repeat(17)}${bold('║')}`);
+        this.log(`  ${bold('║')}  Leverage: ${flags.leverage}x${' '.repeat(27)}${bold('║')}`);
+        this.log(`  ${bold('╚════════════════════════════════════════╝')}`);
+        this.log('');
+        if (!flags.yes) {
+            const confirm = await ask(`  ${cyan('Type "GO" to execute')}: `);
+            if (confirm !== 'GO') {
+                this.log(dim('\n  Cancelled.\n'));
+                return;
+            }
+        }
+        this.log('');
+        await this.executeTrade(pair, direction, sizeUsd, stopPct, flags.leverage, creds);
+    }
+    async executeTrade(pair, direction, sizeUsd, stopPct, leverage, creds) {
+        this.sessionStart = Date.now();
+        this.dashboardActive = false;
+        this.ds = createDashboardState();
+        this.ds.isLive = true;
+        process.env.HYPERLIQUID_PRIVATE_KEY = creds.private_key;
+        const engineArgs = [
+            pair, direction,
+            '--size', String(sizeUsd),
+            '--stop', String(stopPct),
+            '--leverage', String(leverage),
+            '--account', getAccountAddress(creds),
+        ];
+        // Dashboard tick
+        this.tickTimer = setInterval(() => {
+            if (this.dashboardActive)
+                this.renderDashboard();
+        }, 200);
+        // Ctrl+C closes position (not detach — this is manual trading)
+        const { getEngineProcess } = await import('../lib/python-bridge.js');
+        let enginePromise = null;
+        const sigintHandler = () => {
+            if (enginePromise) {
+                const proc = getEngineProcess(enginePromise);
+                if (proc && !proc.killed)
+                    proc.kill('SIGTERM');
+            }
+        };
+        process.on('SIGINT', sigintHandler);
+        try {
+            enginePromise = runEngine('manual-trade', engineArgs, (msg) => {
+                const state = msg.state;
+                if (msg.type === 'status') {
+                    if (!this.dashboardActive) {
+                        this.log(`  ${dim(String(msg.msg))}`);
+                    }
+                }
+                else if (msg.type === 'trade') {
+                    this.handleTradeEvent(msg);
+                }
+                else if (msg.type === 'heartbeat') {
+                    if (state) {
+                        updateDashboardState(this.ds, state, msg, 'heartbeat');
+                        this.renderDashboard();
+                    }
+                }
+                else if (msg.type === 'shutdown') {
+                    if (this.tickTimer) {
+                        clearInterval(this.tickTimer);
+                        this.tickTimer = null;
+                    }
+                    if (this.dashboardActive)
+                        this.clearDashboard();
+                    if (msg.trade_replay) {
+                        this.renderTradeReplay(msg.trade_replay);
+                    }
+                    // Shareable card
+                    const card = msg.shareable_card;
+                    if (card) {
+                        this.log('');
+                        this.log(dim('  Shareable:'));
+                        this.log('');
+                        for (const line of card.split('\n')) {
+                            this.log(`  ${line}`);
+                        }
+                    }
+                    this.log('');
+                }
+                else if (msg.type === 'error') {
+                    this.log(`  ${red('✘')} ${msg.msg}`);
+                }
+            });
+            await enginePromise;
+        }
+        catch (error) {
+            const errMsg = String(error?.message ?? '');
+            if (!errMsg.includes('SIGTERM') && !errMsg.includes('SIGINT') && !errMsg.includes('null')) {
+                this.log(`  ${red('✘')} ${errMsg.split('\n')[0] || 'Unknown error'}`);
+            }
+        }
+        finally {
+            if (this.tickTimer) {
+                clearInterval(this.tickTimer);
+                this.tickTimer = null;
+            }
+            process.removeListener('SIGINT', sigintHandler);
+            delete process.env.HYPERLIQUID_PRIVATE_KEY;
+        }
+    }
+    handleTradeEvent(msg) {
+        const action = msg.action;
+        if (this.dashboardActive)
+            this.clearDashboard();
+        if (action === 'open') {
+            const side = msg.side ?? '';
+            const price = msg.price ?? 0;
+            const size = msg.size ?? 0;
+            const sl = msg.stop_loss ?? 0;
+            const sideColor = side === 'long' ? green : red;
+            this.log(`  ${greenBg(' TRADE ')} ${sideColor('▶')} ${bold(side.toUpperCase())} ${size.toFixed(4)} @ $${price.toLocaleString()}`);
+            this.log(`    ${dim('Stop:')} $${sl.toLocaleString()} ${dim('(on Hyperliquid)')}`);
+            this.log(`    ${dim('Press Ctrl+C to close position')}`);
+            this.log('');
+        }
+        else if (action === 'stop_loss') {
+            this.log(`  ${red('✘')} Stop loss triggered ${dim('(Hyperliquid server-side)')}`);
+        }
+    }
+    renderTradeReplay(replay) {
+        const isWin = replay.result === 'WIN';
+        const resultColor = isWin ? green : red;
+        const side = replay.side.toUpperCase();
+        this.log('');
+        this.log(`  ${greenBg(' RESULT ')} ${resultColor(side)} — ${resultColor(replay.result)}`);
+        this.log(`    Entry: $${replay.entry_price}  Exit: $${replay.exit_price}`);
+        this.log(`    ${bold('P&L:')} ${colorPnl(replay.total_pnl)} (${colorPnl(replay.pnl_pct, '%')})`);
+        if (replay.funding_pnl)
+            this.log(`    Funding: ${colorPnl(replay.funding_pnl)}`);
+        this.log(`    Duration: ${replay.duration}`);
+    }
+    clearDashboard() {
+        if (this.dashboardActive) {
+            const h = Trade.DASHBOARD_HEIGHT;
+            process.stdout.write(`\x1b[${h}A`);
+            for (let i = 0; i < h; i++)
+                process.stdout.write('\x1b[2K\n');
+            process.stdout.write(`\x1b[${h}A`);
+            this.dashboardActive = false;
+        }
+    }
+    renderDashboard() {
+        const ds = this.ds;
+        const pos = ds.position;
+        const elapsed = Math.floor((Date.now() - this.sessionStart) / 1000);
+        const mins = Math.floor(elapsed / 60);
+        const secs = elapsed % 60;
+        const duration = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+        const lines = [];
+        // Header
+        lines.push(`  ${greenBg(' TRADE ')} ${dim(ds.pair || '')} ${dim('│')} ${dim(duration)} ${dim('│ Ctrl+C to close')}`);
+        // Price
+        const priceStr = ds.price > 0 ? `$${ds.price.toFixed(2)}` : '$...';
+        const deltaRaw = ds.priceDelta > 0 ? green(`+$${ds.priceDelta.toFixed(0)}`)
+            : ds.priceDelta < 0 ? red(`-$${Math.abs(ds.priceDelta).toFixed(0)}`)
+                : dim('$0');
+        const chart = sparkline(ds.priceHistory, 28);
+        lines.push(`  ${bold(priceStr)}  ${deltaRaw}  ${chart}`);
+        lines.push('');
+        // Position
+        if (pos) {
+            const sideColor = pos.side === 'long' ? green : red;
+            lines.push(`  ${sideColor('●')} ${sideColor(String(pos.side).toUpperCase())} ${pos.size?.toFixed(4)} @ $${pos.entry_price?.toLocaleString()}`);
+            lines.push(`  ${dim('Unrealized:')} ${colorPnl(ds.unrealizedPnl)}  ${dim('Funding:')} ${colorPnl(ds.totalFunding)}`);
+            if (ds.stopProximity > 0.1) {
+                const proxLabel = ds.stopProximity > 0.8 ? red('DANGER') : ds.stopProximity > 0.5 ? yellow('CAUTION') : dim('safe');
+                lines.push(`  ${dim('SL')} ${proximityBar(ds.stopProximity)} ${proxLabel}`);
+            }
+            if (ds.fundingCountdownMin > 0) {
+                lines.push(`  ${fundingCountdown(ds.fundingCountdownMin, ds.predictedFunding)}`);
+            }
+        }
+        lines.push('');
+        lines.push(`  ${dim('EQUITY')} ${bold('$' + ds.totalEquity.toLocaleString())} ${colorPnl(ds.totalPnlPct, '%')}`);
+        // Fixed height
+        const H = Trade.DASHBOARD_HEIGHT;
+        while (lines.length < H)
+            lines.push('');
+        if (lines.length > H)
+            lines.length = H;
+        if (this.dashboardActive) {
+            process.stdout.write(`\x1b[${H}A`);
+        }
+        for (const line of lines) {
+            process.stdout.write(`\x1b[2K${line}\n`);
+        }
+        this.dashboardActive = true;
+    }
+}

package/dist/commands/transfer.d.ts

@@ -0,0 +1,13 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Transfer extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        amount: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        'to-perps': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'to-spot': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/transfer.js

@@ -0,0 +1,65 @@
+import { Args, Flags } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { requestTransfer, postToHyperliquid, getExistingSession } from '../lib/walletconnect.js';
+import { loadCredentials } from '../lib/credentials.js';
+import { green, red, cyan, dim } from '../lib/tui.js';
+export default class Transfer extends GatedCommand {
+    static description = 'Transfer USDC between spot and perps on Hyperliquid';
+    static examples = [
+        '$ rift transfer 100 --to-perps',
+        '$ rift transfer 50 --to-spot',
+    ];
+    static args = {
+        amount: Args.string({ description: 'USDC amount to transfer', required: true }),
+    };
+    static flags = {
+        'to-perps': Flags.boolean({ description: 'Transfer from Spot → Perps', default: false }),
+        'to-spot': Flags.boolean({ description: 'Transfer from Perps → Spot', default: false }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Transfer);
+        const amount = args.amount;
+        const isMainnet = true;
+        // Determine direction
+        let toPerp = true;
+        if (flags['to-spot']) {
+            toPerp = false;
+        }
+        else if (!flags['to-perps'] && !flags['to-spot']) {
+            // Default to to-perps if neither specified
+            toPerp = true;
+        }
+        const direction = toPerp ? 'Spot → Perps' : 'Perps → Spot';
+        const creds = loadCredentials();
+        if (!creds) {
+            this.log(`  ${red('✘')} No wallet configured. Run: ${cyan('rift auth setup')}`);
+            return;
+        }
+        // Check for existing WalletConnect session
+        const session = await getExistingSession();
+        if (!session) {
+            this.log(`  ${red('✘')} No wallet session. Run: ${cyan('rift auth setup')} to reconnect.`);
+            return;
+        }
+        this.log('');
+        this.log(`  Transferring $${amount} (${direction})...`);
+        this.log(`  ${dim('→ Approve in your wallet (check your phone)')}`);
+        this.log('');
+        const result = await requestTransfer(amount, toPerp, isMainnet);
+        if (!result.success) {
+            this.log(`  ${red('✘')} Transfer failed: ${result.error}`);
+            return;
+        }
+        // Post to Hyperliquid
+        try {
+            const response = await postToHyperliquid(result.action, result.signature, result.nonce, isMainnet);
+            this.log(`  ${green('✔')} Transfer complete`);
+            this.log(`  ${dim(`$${amount} moved ${direction}`)}`);
+            this.log(`  ${dim('Run: rift balance to verify')}`);
+            this.log('');
+        }
+        catch (error) {
+            this.log(`  ${red('✘')} Failed to submit transfer: ${error.message}`);
+        }
+    }
+}

package/dist/commands/verify.d.ts

@@ -0,0 +1,16 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Verify 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>;
+        from: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        to: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/verify.js

@@ -0,0 +1,38 @@
+import { Args, Flags } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { passthroughToEngine } from '../lib/engine-passthrough.js';
+export default class Verify extends GatedCommand {
+    static description = 'Verify a strategy beats buy-and-hold over a date range — sanity check before going live';
+    static examples = [
+        '$ rift verify trend_follow',
+        '$ rift verify trend_follow --pair BTC --tf 4h --from 2024-01-01 --to 2024-12-31',
+    ];
+    static args = {
+        strategy: Args.string({ description: 'Strategy name', required: true }),
+    };
+    static flags = {
+        pair: Flags.string({ description: 'Trading pair', default: 'BTC' }),
+        tf: Flags.string({ description: 'Timeframe', default: '' }),
+        from: Flags.string({ description: 'Start date YYYY-MM-DD', default: '' }),
+        to: Flags.string({ description: 'End date YYYY-MM-DD', default: '' }),
+        json: Flags.boolean({ description: 'Emit raw JSON only', default: false }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Verify);
+        const engineArgs = [args.strategy, '--pair', flags.pair];
+        if (flags.tf)
+            engineArgs.push('--tf', flags.tf);
+        if (flags.from)
+            engineArgs.push('--from', flags.from);
+        if (flags.to)
+            engineArgs.push('--to', flags.to);
+        await passthroughToEngine({
+            command: 'verify',
+            args: engineArgs,
+            log: (m) => this.log(m),
+            error: (m) => this.error(m),
+            exit: (c) => this.exit(c),
+            jsonOnly: flags.json,
+        });
+    }
+}

package/dist/commands/walkforward.d.ts

@@ -0,0 +1,20 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class WalkForward extends GatedCommand {
+    static description: string;
+    static aliases: 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>;
+        wf: 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 renderResult;
+    private row;
+    private rowColored;
+}