@nexstone/rift-cli 0.1.1

package/dist/commands/pairs.js

@@ -0,0 +1,147 @@
+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 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 Pairs extends GatedCommand {
+    static description = 'Backtest a pairs/spread trade between two assets (e.g. BTC/ETH)';
+    // `pairs-backtest` is the engine command name and was the previous
+    // wrapper name; alias kept so scripts and docs that referenced it
+    // continue to work.
+    static aliases = ['pairs-backtest'];
+    static examples = [
+        '$ rift pairs --a BTC --b ETH --tf 1h',
+        '$ rift pairs --a BTC --b ETH --entry-z 2.5 --lookback 336',
+        '$ rift pairs --a BTC --b ETH --json   # raw JSON for pipelines',
+    ];
+    static flags = {
+        a: Flags.string({ description: 'First asset', default: 'BTC' }),
+        b: Flags.string({ description: 'Second asset', default: 'ETH' }),
+        tf: Flags.string({ description: 'Timeframe', default: '1h' }),
+        equity: Flags.integer({ description: 'Starting equity', default: 10000 }),
+        lookback: Flags.integer({ description: 'Rolling z-score window (candles)', default: 168 }),
+        'entry-z': Flags.string({ description: 'Z-score entry threshold', default: '2.0' }),
+        'exit-z': Flags.string({ description: 'Z-score exit threshold', default: '0.5' }),
+        'stop-z': Flags.string({ description: 'Z-score stop loss', default: '4.0' }),
+        'max-hold': Flags.integer({ description: 'Max hold time (candles)', default: 72 }),
+        json: Flags.boolean({ description: 'Emit raw JSON result instead of the rendered panel', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(Pairs);
+        if (!flags.json) {
+            this.log('');
+            this.log(`  ${bold('Pairs Trading Backtest')}`);
+            this.log(`  ${dim(`${flags.a}/${flags.b} spread on ${flags.tf} — z-score entry: ${flags['entry-z']}, exit: ${flags['exit-z']}`)}`);
+            this.log('');
+        }
+        const engineArgs = [
+            '--a', flags.a,
+            '--b', flags.b,
+            '--tf', flags.tf,
+            '--equity', String(flags.equity),
+            '--lookback', String(flags.lookback),
+            '--entry-z', flags['entry-z'],
+            '--exit-z', flags['exit-z'],
+            '--stop-z', flags['stop-z'],
+            '--max-hold', String(flags['max-hold']),
+        ];
+        await runEngine('pairs-backtest', engineArgs, (msg) => {
+            if (flags.json) {
+                // JSON mode: emit the result payload only, silently consume
+                // progress/status so the output is pipe-safe.
+                if (msg.type === 'result') {
+                    const { type: _t, ...rest } = msg;
+                    this.log(JSON.stringify(rest, null, 2));
+                }
+                else if (msg.type === 'error') {
+                    this.error(msg.msg);
+                }
+                return;
+            }
+            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 w = 55;
+        const hr = '─'.repeat(w - 2);
+        this.log(`  ${dim('┌' + hr + '┐')}`);
+        this.log(`  ${dim('│')} ${bold('PAIRS TRADING RESULTS')}${' '.repeat(w - 24)}${dim('│')}`);
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.row('Spread', `${msg.asset_a}/${msg.asset_b}`, w));
+        this.log(this.row('Interval', String(msg.interval), w));
+        this.log(this.row('Avg Hold', `${msg.avg_hold_candles}h`, 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', msg.total_return_pct, '%', w));
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.row('Trades', String(msg.num_trades), w));
+        this.log(this.row('Win Rate', `${msg.win_rate}%`, w, msg.win_rate >= 50 ? 'green' : 'red'));
+        this.log(this.rowColored('Avg Win', msg.avg_win_pct, '%', w));
+        this.log(this.rowColored('Avg Loss', msg.avg_loss_pct, '%', w));
+        this.log(`  ${dim('├' + hr + '┤')}`);
+        this.log(this.rowColored('Max Drawdown', msg.max_drawdown_pct, '%', w));
+        this.log(this.row('Sharpe Ratio', String(msg.sharpe_ratio), w, msg.sharpe_ratio > 0.5 ? 'green' : msg.sharpe_ratio > 0 ? 'yellow' : 'red'));
+        this.log(this.row('Profit Factor', String(msg.profit_factor), w, msg.profit_factor > 1.5 ? 'green' : msg.profit_factor > 1 ? 'yellow' : 'red'));
+        this.log(this.rowColored('Funding P&L', msg.total_funding, '', w));
+        this.log(`  ${dim('└' + hr + '┘')}`);
+        // Interpretation
+        this.log('');
+        const sharpe = msg.sharpe_ratio;
+        const pf = msg.profit_factor;
+        const dd = msg.max_drawdown_pct;
+        if (sharpe > 0.5 && pf > 1.5 && dd > -10) {
+            this.log(`  ${green('Strong pairs trade.')} Positive Sharpe with controlled drawdown.`);
+            this.log(`  ${dim('The spread shows mean-reverting behavior — the edge is structural.')}`);
+        }
+        else if (sharpe > 0 && pf > 1) {
+            this.log(`  ${yellow('Moderate pairs trade.')} Positive but consider optimizing parameters.`);
+        }
+        else {
+            this.log(`  ${red('Weak or negative.')} The spread may not be mean-reverting in this period.`);
+        }
+        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/perp/close.d.ts

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

package/dist/commands/perp/close.js

@@ -0,0 +1,57 @@
+import { Args, Flags } from '@oclif/core';
+import { GatedCommand } from '../../lib/base-command.js';
+import { passthroughToEngine } from '../../lib/engine-passthrough.js';
+import { loadCredentials, hasFullSetup, getAccountAddress } from '../../lib/credentials.js';
+export default class PerpClose extends GatedCommand {
+    static description = 'Close an open perp position (and cancel any orders for the coin) via reduce-only IOC market order.';
+    static examples = [
+        '$ rift perp close BTC      # close BTC perp position + cancel BTC orders',
+        '$ rift perp close          # close ALL perp positions + cancel ALL orders',
+    ];
+    static args = {
+        coin: Args.string({
+            description: 'Coin to close (omit to close all open positions)',
+            required: false,
+        }),
+    };
+    static flags = {
+        json: Flags.boolean({ description: 'Emit raw JSON only', default: false }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PerpClose);
+        if (!hasFullSetup()) {
+            this.error('Perp close requires wallet setup. Run: rift auth setup');
+        }
+        const creds = loadCredentials();
+        if (!creds) {
+            this.error('No credentials. Run: rift auth setup');
+        }
+        // The engine's `close-all` command reads HYPERLIQUID_PRIVATE_KEY
+        // from env (not CLI args, for security — see comment in close-all
+        // source). The spawned engine subprocess inherits process.env, so
+        // we set it here before passthroughToEngine spawns.
+        process.env.HYPERLIQUID_PRIVATE_KEY = creds.private_key;
+        try {
+            // Delegates to the engine's `close-all` command, which is the
+            // direct close path (reduce-only IOC market order). Distinct from
+            // `close-position` which writes a command file for a running algo
+            // daemon — that's the right call when you have an algo session
+            // managing a position; `perp close` is for the manual-trade lifecycle
+            // or for emergency cleanup.
+            const engineArgs = ['--account', getAccountAddress(creds)];
+            if (args.coin)
+                engineArgs.push('--coin', args.coin);
+            await passthroughToEngine({
+                command: 'close-all',
+                args: engineArgs,
+                log: (m) => this.log(m),
+                error: (m) => this.error(m),
+                exit: (c) => this.exit(c),
+                jsonOnly: flags.json,
+            });
+        }
+        finally {
+            delete process.env.HYPERLIQUID_PRIVATE_KEY;
+        }
+    }
+}

package/dist/commands/perp/long.d.ts

@@ -0,0 +1,14 @@
+import { GatedCommand } from '../../lib/base-command.js';
+export default class PerpLong extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        coin: import("@oclif/core/interfaces").Arg<string, 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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/perp/long.js

@@ -0,0 +1,38 @@
+import { Args, Flags } from '@oclif/core';
+import { GatedCommand } from '../../lib/base-command.js';
+export default class PerpLong extends GatedCommand {
+    static description = 'Open a LONG position on Hyperliquid perps with a stop loss and live monitor.';
+    static examples = [
+        '$ rift perp long BTC --size 50 --stop 2     # $50 long, 2% stop',
+        '$ rift perp long ETH --size 25 --leverage 3 # $25 long at 3x',
+    ];
+    static args = {
+        coin: Args.string({ description: 'Coin (e.g. BTC, ETH, SOL)', required: true }),
+    };
+    static flags = {
+        size: Flags.integer({ description: 'Position size in USD', required: true }),
+        stop: Flags.string({ description: 'Stop loss % (default: 2)', default: '2' }),
+        leverage: Flags.integer({ description: 'Leverage multiplier', default: 1 }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PerpLong);
+        // Delegate to `rift trade` which already has the rich live monitor
+        // dashboard for the manual-trade lifecycle. This wrapper exists so
+        // `rift perp long BTC` reads naturally without the user having to
+        // type "long" twice or remember the `rift trade <pair> <direction>`
+        // positional-arg order.
+        // --yes skips the "Type GO" prompt that `rift trade` shows for the
+        // legacy `rift trade BTC long` form — `rift perp long BTC` already
+        // requires the user to type the direction in the verb, so a second
+        // confirmation is redundant. The position-size + stop are still on
+        // the command line and the manual-trade daemon's risk disclaimers
+        // remain in place.
+        await this.config.runCommand('trade', [
+            args.coin, 'long',
+            '--size', String(flags.size),
+            '--stop', flags.stop,
+            '--leverage', String(flags.leverage),
+            '--yes',
+        ]);
+    }
+}

package/dist/commands/perp/short.d.ts

@@ -0,0 +1,14 @@
+import { GatedCommand } from '../../lib/base-command.js';
+export default class PerpShort extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        coin: import("@oclif/core/interfaces").Arg<string, 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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/perp/short.js

@@ -0,0 +1,27 @@
+import { Args, Flags } from '@oclif/core';
+import { GatedCommand } from '../../lib/base-command.js';
+export default class PerpShort extends GatedCommand {
+    static description = 'Open a SHORT position on Hyperliquid perps with a stop loss and live monitor.';
+    static examples = [
+        '$ rift perp short BTC --size 50 --stop 2     # $50 short, 2% stop',
+        '$ rift perp short ETH --size 25 --leverage 3 # $25 short at 3x',
+    ];
+    static args = {
+        coin: Args.string({ description: 'Coin (e.g. BTC, ETH, SOL)', required: true }),
+    };
+    static flags = {
+        size: Flags.integer({ description: 'Position size in USD', required: true }),
+        stop: Flags.string({ description: 'Stop loss % (default: 2)', default: '2' }),
+        leverage: Flags.integer({ description: 'Leverage multiplier', default: 1 }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PerpShort);
+        await this.config.runCommand('trade', [
+            args.coin, 'short',
+            '--size', String(flags.size),
+            '--stop', flags.stop,
+            '--leverage', String(flags.leverage),
+            '--yes',
+        ]);
+    }
+}

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

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

package/dist/commands/perp/status.js

@@ -0,0 +1,26 @@
+import { Flags } from '@oclif/core';
+import { GatedCommand } from '../../lib/base-command.js';
+import { passthroughToEngine } from '../../lib/engine-passthrough.js';
+export default class PerpStatus extends GatedCommand {
+    static description = 'Show current perp account state — positions, margin used, unrealized PnL, open orders.';
+    static examples = [
+        '$ rift perp status',
+        '$ rift perp status --json',
+    ];
+    static flags = {
+        json: Flags.boolean({ description: 'Emit raw JSON only', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(PerpStatus);
+        // `state` is the canonical engine command for "what's my account
+        // doing right now": positions, equity, margin, algo sessions, etc.
+        await passthroughToEngine({
+            command: 'state',
+            args: [],
+            log: (m) => this.log(m),
+            error: (m) => this.error(m),
+            exit: (c) => this.exit(c),
+            jsonOnly: flags.json,
+        });
+    }
+}

package/dist/commands/portfolio/alerts.d.ts

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

package/dist/commands/portfolio/alerts.js

@@ -0,0 +1,47 @@
+import { GatedCommand } from '../../lib/base-command.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getDataDir } from '../../lib/python-bridge.js';
+import { red, yellow, cyan, bold, dim, } from '../../lib/tui.js';
+export default class PortfolioAlerts extends GatedCommand {
+    static description = 'Show recent portfolio alerts';
+    static examples = [
+        '$ rift portfolio alerts',
+    ];
+    async run() {
+        const alertsFile = path.join(getDataDir(), 'algo', 'alerts.log');
+        if (!fs.existsSync(alertsFile)) {
+            this.log(`\n  ${dim('No alerts yet.')}\n`);
+            return;
+        }
+        const lines = fs.readFileSync(alertsFile, 'utf-8').trim().split('\n').filter(l => l.trim());
+        if (lines.length === 0) {
+            this.log(`\n  ${dim('No alerts yet.')}\n`);
+            return;
+        }
+        this.log('');
+        this.log(`  ${bold('Recent Alerts')} ${dim(`(${lines.length} total)`)}`);
+        this.log(`  ${dim('─'.repeat(60))}`);
+        this.log('');
+        // Show last 20
+        const recent = lines.slice(-20);
+        for (const line of recent) {
+            try {
+                const alert = JSON.parse(line);
+                const event = (alert.event || '').padEnd(18);
+                const eventColor = event.includes('trade') ? cyan
+                    : event.includes('health') ? yellow
+                        : event.includes('drawdown') ? red
+                            : event.includes('session_died') ? red
+                                : event.includes('schedule') ? dim
+                                    : event.includes('risk') ? yellow
+                                        : dim;
+                this.log(`  ${dim(alert.time || '??:??')}  ${eventColor(event)} ${alert.message || ''}`);
+            }
+            catch {
+                // Skip unparseable lines
+            }
+        }
+        this.log('');
+    }
+}

package/dist/commands/portfolio/backtest.d.ts

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

package/dist/commands/portfolio/backtest.js

@@ -0,0 +1,178 @@
+import { Args } from '@oclif/core';
+import * as path from 'node:path';
+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 PortfolioBacktest extends GatedCommand {
+    static description = 'Backtest a portfolio of multiple strategies simultaneously';
+    static examples = [
+        '$ rift portfolio backtest strategies/configs/portfolio_btc.yaml',
+    ];
+    static args = {
+        config: Args.string({ description: 'Path to portfolio.yaml config file', required: true }),
+    };
+    async run() {
+        const { args } = await this.parse(PortfolioBacktest);
+        this.log('');
+        this.log(`  ${bold('Portfolio Backtest')}`);
+        this.log(`  ${dim(`Config: ${args.config}`)}`);
+        this.log('');
+        const configPath = path.resolve(args.config);
+        await runEngine('portfolio-backtest', [configPath], (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 strategies = msg.strategies;
+        const corrMatrix = msg.correlation_matrix;
+        // Per-strategy results table
+        this.log(dim('  ── Per-Strategy Results ──'));
+        this.log('');
+        const hdr = `  ${dim('│')} ${'Strategy'.padEnd(20)} ${'Alloc'.padEnd(8)} ${'Return'.padEnd(12)} ${'Sharpe'.padEnd(10)} ${'PF'.padEnd(8)} ${'MaxDD'.padEnd(10)} ${'Trades'.padEnd(8)} ${'Win%'.padEnd(8)} ${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 (const s of strategies) {
+            const retStr = `${s.return_pct}%`;
+            const ddStr = `${s.max_drawdown_pct}%`;
+            let row = `  ${dim('│')} ${bold(String(s.name).padEnd(20))} `;
+            row += `${String(s.allocation).padEnd(8)} `;
+            row += `${colorNum(s.return_pct, '%')}${' '.repeat(Math.max(1, 12 - retStr.length))} `;
+            row += `${colorNum(s.sharpe)}${' '.repeat(Math.max(1, 10 - String(s.sharpe).length))} `;
+            row += `${String(s.profit_factor).padEnd(8)} `;
+            row += `${colorNum(s.max_drawdown_pct, '%')}${' '.repeat(Math.max(1, 10 - ddStr.length))} `;
+            row += `${String(s.num_trades).padEnd(8)} `;
+            row += `${String(s.win_rate).padEnd(8)} `;
+            row += dim('│');
+            this.log(row);
+        }
+        this.log(hr);
+        this.log('');
+        // Portfolio summary box
+        const w = 55;
+        const boxHr = '─'.repeat(w - 2);
+        this.log(`  ${dim('┌' + boxHr + '┐')}`);
+        this.log(`  ${dim('│')} ${bold('PORTFOLIO SUMMARY')}${' '.repeat(w - 20)}${dim('│')}`);
+        this.log(`  ${dim('├' + boxHr + '┤')}`);
+        this.log(this.row('Initial Equity', `$${Number(msg.initial_equity).toLocaleString()}`, w));
+        this.log(this.row('Final Equity', `$${Number(msg.final_equity).toLocaleString()}`, w));
+        this.log(this.rowColored('Portfolio Return', msg.total_return_pct, '%', w));
+        this.log(this.rowColored('Portfolio Sharpe', msg.portfolio_sharpe, '', w));
+        this.log(this.rowColored('Portfolio Max Drawdown', msg.portfolio_max_drawdown_pct, '%', w));
+        this.log(this.row('Total Trades', String(msg.total_trades), w));
+        this.log(this.row('Strategies', String(strategies.length), w));
+        this.log(`  ${dim('└' + boxHr + '┘')}`);
+        this.log('');
+        // Correlation matrix
+        if (corrMatrix && corrMatrix.strategies.length > 1) {
+            this.log(dim('  ── Strategy Correlation ──'));
+            this.log('');
+            const names = corrMatrix.strategies;
+            const matrix = corrMatrix.matrix;
+            // Header
+            let corrHdr = `  ${''.padEnd(20)}`;
+            for (const n of names) {
+                corrHdr += `${n.slice(0, 12).padEnd(14)}`;
+            }
+            this.log(dim(corrHdr));
+            // Rows
+            for (let i = 0; i < names.length; i++) {
+                let corrRow = `  ${names[i].padEnd(20)}`;
+                for (let j = 0; j < names.length; j++) {
+                    const val = matrix[i][j];
+                    const valStr = val.toFixed(3);
+                    if (i === j) {
+                        corrRow += dim(valStr.padEnd(14));
+                    }
+                    else if (val > 0.7) {
+                        corrRow += red(valStr.padEnd(14)); // high correlation = warning
+                    }
+                    else if (val < 0.3) {
+                        corrRow += green(valStr.padEnd(14)); // low correlation = good
+                    }
+                    else {
+                        corrRow += yellow(valStr.padEnd(14));
+                    }
+                }
+                this.log(corrRow);
+            }
+            this.log('');
+            // Check for high correlations
+            for (let i = 0; i < names.length; i++) {
+                for (let j = i + 1; j < names.length; j++) {
+                    if (matrix[i][j] > 0.7) {
+                        this.log(`  ${yellow('!')} ${names[i]} and ${names[j]} are highly correlated (${matrix[i][j].toFixed(3)}) — diversification benefit is limited`);
+                    }
+                }
+            }
+            const allLow = matrix.every((row, i) => row.every((val, j) => i === j || val < 0.5));
+            if (allLow) {
+                this.log(`  ${green('✔')} Strategy correlations are low — good portfolio diversification`);
+            }
+            this.log('');
+        }
+        // Interpretation
+        const portfolioReturn = msg.total_return_pct;
+        const portfolioSharpe = msg.portfolio_sharpe;
+        const portfolioDD = msg.portfolio_max_drawdown_pct;
+        this.log(dim('  ── Interpretation ──'));
+        this.log('');
+        if (portfolioSharpe > 0.5 && portfolioDD > -10) {
+            this.log(`  ${green('Strong portfolio.')} Positive Sharpe with controlled drawdown.`);
+        }
+        else if (portfolioSharpe > 0 && portfolioDD > -20) {
+            this.log(`  ${yellow('Moderate portfolio.')} Positive returns but drawdown needs attention.`);
+        }
+        else {
+            this.log(`  ${red('Weak portfolio.')} Consider adjusting allocations or strategy selection.`);
+        }
+        // Compare portfolio to best individual strategy
+        const bestStrat = strategies.reduce((best, s) => (s.sharpe > best.sharpe ? s : best), strategies[0]);
+        if (portfolioSharpe > bestStrat.sharpe) {
+            this.log(`  ${green('Portfolio Sharpe (' + portfolioSharpe.toFixed(3) + ') exceeds best individual strategy (' + bestStrat.name + ': ' + bestStrat.sharpe.toFixed(3) + ').')}`);
+            this.log(`  ${dim('Diversification is adding value.')}`);
+        }
+        else {
+            this.log(`  ${dim(`Best individual Sharpe: ${bestStrat.name} (${bestStrat.sharpe.toFixed(3)}) vs portfolio (${portfolioSharpe.toFixed(3)})`)}`);
+        }
+        this.log('');
+    }
+    row(label, value, width) {
+        const labelStr = `  ${label}:`;
+        const cleanVal = value.replace(/\x1b\[[0-9;]*m/g, '');
+        const padding = width - labelStr.length - cleanVal.length - 3;
+        return `  ${dim('│')}${labelStr}${' '.repeat(Math.max(1, padding))}${value} ${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/portfolio/create.d.ts

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