@gaberoo/kalshitools 1.0.3 → 1.1.0

package/dist/commands/portfolio/analytics.js

@@ -0,0 +1,192 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { calculateAveragePnL, calculateExposureRatio, calculatePortfolioConcentration, calculateTotalFees, calculateWinRate, } from '../../lib/analytics.js';
+import { BaseCommand } from '../../lib/base-command.js';
+import { createClientFromConfig } from '../../lib/kalshi/index.js';
+import { logger } from '../../lib/logger.js';
+export default class PortfolioAnalytics extends BaseCommand {
+    static description = 'Comprehensive portfolio performance analytics';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --period 7',
+        '<%= config.bin %> <%= command.id %> --min-ts 2026-01-01T00:00:00Z',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        'max-ts': Flags.string({
+            description: 'End date for analysis (ISO-8601 format)',
+        }),
+        'min-ts': Flags.string({
+            description: 'Start date for analysis (ISO-8601 format)',
+        }),
+        'period': Flags.integer({
+            description: 'Analysis period in days (overridden by min-ts/max-ts)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PortfolioAnalytics);
+        try {
+            const client = createClientFromConfig();
+            // Calculate time range
+            const now = new Date();
+            let minTs;
+            let maxTs;
+            let periodDays = flags.period || 30;
+            if (flags['min-ts']) {
+                minTs = Math.floor(new Date(flags['min-ts']).getTime() / 1000);
+            }
+            else if (flags.period) {
+                minTs = Math.floor((now.getTime() - flags.period * 24 * 60 * 60 * 1000) / 1000);
+            }
+            else {
+                // Default to 30 days
+                minTs = Math.floor((now.getTime() - 30 * 24 * 60 * 60 * 1000) / 1000);
+            }
+            if (flags['max-ts']) {
+                maxTs = Math.floor(new Date(flags['max-ts']).getTime() / 1000);
+            }
+            // Calculate actual period if we have both timestamps
+            if (minTs && maxTs) {
+                periodDays = Math.floor((maxTs - minTs) / (24 * 60 * 60));
+            }
+            else if (minTs) {
+                periodDays = Math.floor((now.getTime() / 1000 - minTs) / (24 * 60 * 60));
+            }
+            // Fetch data from API
+            const [balance, positions, fillsResult] = await Promise.all([
+                client.getBalance(),
+                client.getPositions({ settlement_status: 'open' }),
+                client.getFills({ limit: 500, max_ts: maxTs, min_ts: minTs }),
+            ]);
+            const { fills } = fillsResult;
+            // Calculate metrics
+            const winRate = calculateWinRate(fills);
+            const { avgLoss, avgWin } = calculateAveragePnL(fills);
+            const totalFees = calculateTotalFees(fills);
+            // Portfolio metrics
+            const portfolioValue = balance.portfolio_value / 100; // Convert from cents
+            const cashBalance = balance.balance / 100;
+            const totalCost = positions.reduce((sum, pos) => sum + pos.total_cost, 0);
+            const totalExposure = positions.reduce((sum, pos) => sum + pos.market_exposure, 0);
+            const realizedPnL = positions.reduce((sum, pos) => sum + pos.realized_pnl, 0);
+            const unrealizedPnL = totalExposure - totalCost;
+            const exposureRatio = calculateExposureRatio(positions, portfolioValue);
+            const concentration = calculatePortfolioConcentration(positions, portfolioValue);
+            // Calculate total return
+            const initialCapital = portfolioValue - realizedPnL - unrealizedPnL;
+            const totalReturnPct = initialCapital > 0 ? ((portfolioValue - initialCapital) / initialCapital) * 100 : 0;
+            // Trade statistics
+            const totalTrades = fills.length;
+            const winningTrades = Math.round(totalTrades * winRate);
+            const losingTrades = totalTrades - winningTrades;
+            // Concentration by ticker
+            const concentrationByTicker = {};
+            for (const [ticker, pct] of concentration) {
+                concentrationByTicker[ticker] = Math.round(pct * 100) / 100;
+            }
+            // Find largest position
+            const largestPositionPct = concentration.size > 0
+                ? Math.max(...concentration.values())
+                : 0;
+            // Fee impact
+            const feeImpactPct = portfolioValue > 0 ? (totalFees / portfolioValue) * 100 : 0;
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success({
+                    fees: {
+                        fee_impact_pct: -Math.abs(feeImpactPct),
+                        total_fees: totalFees,
+                    },
+                    period: {
+                        days: periodDays,
+                        end: maxTs ? new Date(maxTs * 1000).toISOString() : now.toISOString(),
+                        start: new Date(minTs * 1000).toISOString(),
+                    },
+                    pnl: {
+                        avg_loss: avgLoss,
+                        avg_win: avgWin,
+                        realized_pnl: realizedPnL,
+                        total_pnl: realizedPnL + unrealizedPnL,
+                        total_return_pct: totalReturnPct,
+                        unrealized_pnl: unrealizedPnL,
+                    },
+                    portfolio: {
+                        cash_balance: cashBalance,
+                        current_value: portfolioValue,
+                        exposure: totalExposure,
+                        exposure_ratio: exposureRatio,
+                        total_cost: totalCost,
+                    },
+                    risk: {
+                        concentration_by_ticker: concentrationByTicker,
+                        largest_position_pct: largestPositionPct,
+                    },
+                    trades: {
+                        losing: losingTrades,
+                        total: totalTrades,
+                        win_rate: winRate,
+                        winning: winningTrades,
+                    },
+                });
+            }
+            else {
+                // Human-readable output
+                this.log(chalk.cyan.bold('Portfolio Analytics'));
+                this.log();
+                // Period
+                this.log(chalk.yellow('Period:'));
+                this.log(`  ${periodDays} days (${new Date(minTs * 1000).toLocaleDateString()} - ${maxTs ? new Date(maxTs * 1000).toLocaleDateString() : 'now'})`);
+                this.log();
+                // Trading Performance
+                this.log(chalk.yellow('Trading Performance:'));
+                this.log(`  Total Trades: ${totalTrades}`);
+                this.log(`  Win Rate: ${chalk.green((winRate * 100).toFixed(1) + '%')} (${winningTrades}W / ${losingTrades}L)`);
+                this.log(`  Avg Win: ${chalk.green('+$' + avgWin.toFixed(2))}`);
+                this.log(`  Avg Loss: ${chalk.red('$' + avgLoss.toFixed(2))}`);
+                this.log();
+                // P&L
+                this.log(chalk.yellow('Profit & Loss:'));
+                const totalPnL = realizedPnL + unrealizedPnL;
+                this.log(`  Total P&L: ${totalPnL >= 0 ? chalk.green('+$' + totalPnL.toFixed(2)) : chalk.red('-$' + Math.abs(totalPnL).toFixed(2))}`);
+                this.log(`  Realized: ${realizedPnL >= 0 ? chalk.green('+$' + realizedPnL.toFixed(2)) : chalk.red('-$' + Math.abs(realizedPnL).toFixed(2))}`);
+                this.log(`  Unrealized: ${unrealizedPnL >= 0 ? chalk.green('+$' + unrealizedPnL.toFixed(2)) : chalk.red('-$' + Math.abs(unrealizedPnL).toFixed(2))}`);
+                this.log(`  Total Return: ${totalReturnPct >= 0 ? chalk.green('+' + totalReturnPct.toFixed(2) + '%') : chalk.red(totalReturnPct.toFixed(2) + '%')}`);
+                this.log();
+                // Portfolio
+                this.log(chalk.yellow('Portfolio:'));
+                this.log(`  Current Value: ${chalk.cyan('$' + portfolioValue.toFixed(2))}`);
+                this.log(`  Cash Balance: ${chalk.cyan('$' + cashBalance.toFixed(2))}`);
+                this.log(`  Total Exposure: ${chalk.cyan('$' + totalExposure.toFixed(2))}`);
+                this.log(`  Exposure Ratio: ${chalk.cyan((exposureRatio * 100).toFixed(1) + '%')}`);
+                this.log();
+                // Risk
+                this.log(chalk.yellow('Risk:'));
+                this.log(`  Largest Position: ${largestPositionPct >= 20 ? chalk.red(largestPositionPct.toFixed(1) + '%') : chalk.green(largestPositionPct.toFixed(1) + '%')}`);
+                if (concentration.size > 0) {
+                    this.log(`  Top Concentrations:`);
+                    const sorted = [...concentration.entries()]
+                        .sort((a, b) => b[1] - a[1])
+                        .slice(0, 5);
+                    for (const [ticker, pct] of sorted) {
+                        this.log(`    ${ticker}: ${pct >= 20 ? chalk.red(pct.toFixed(1) + '%') : chalk.cyan(pct.toFixed(1) + '%')}`);
+                    }
+                }
+                this.log();
+                // Fees
+                this.log(chalk.yellow('Fees:'));
+                this.log(`  Total Fees: ${chalk.red('$' + totalFees.toFixed(2))}`);
+                this.log(`  Fee Impact: ${chalk.red(feeImpactPct.toFixed(2) + '%')}`);
+            }
+            logger.info({
+                exposure_ratio: exposureRatio,
+                period_days: periodDays,
+                total_pnl: realizedPnL + unrealizedPnL,
+                total_trades: totalTrades,
+                win_rate: winRate,
+            }, 'Portfolio analytics generated');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class PortfolioHistory extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'group-by': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        'max-ts': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'min-ts': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        ticker: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/portfolio/history.js

@@ -0,0 +1,245 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { calculateMakerTakerStats, groupFillsByPeriod, groupFillsByTicker, } from '../../lib/analytics.js';
+import { BaseCommand } from '../../lib/base-command.js';
+import { createClientFromConfig } from '../../lib/kalshi/index.js';
+import { logger } from '../../lib/logger.js';
+export default class PortfolioHistory extends BaseCommand {
+    static description = 'Historical performance analysis with time-series data';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --ticker MARKET-A',
+        '<%= config.bin %> <%= command.id %> --group-by week',
+        '<%= config.bin %> <%= command.id %> --min-ts 2026-01-01T00:00:00Z --max-ts 2026-02-01T00:00:00Z',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        'group-by': Flags.string({
+            default: 'day',
+            description: 'Time aggregation level',
+            options: ['day', 'week', 'month'],
+        }),
+        'limit': Flags.integer({
+            default: 500,
+            description: 'Maximum fills to fetch (handles pagination)',
+        }),
+        'max-ts': Flags.string({
+            description: 'End date (ISO-8601 format)',
+        }),
+        'min-ts': Flags.string({
+            description: 'Start date (ISO-8601 format)',
+        }),
+        'ticker': Flags.string({
+            description: 'Filter by specific market ticker',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PortfolioHistory);
+        try {
+            const client = createClientFromConfig();
+            // Convert timestamps
+            const minTs = flags['min-ts'] ? Math.floor(new Date(flags['min-ts']).getTime() / 1000) : undefined;
+            const maxTs = flags['max-ts'] ? Math.floor(new Date(flags['max-ts']).getTime() / 1000) : undefined;
+            // Fetch fills with pagination
+            const allFills = [];
+            let cursor;
+            let remaining = flags.limit;
+            while (remaining > 0) {
+                const batchSize = Math.min(remaining, 100); // API limit per request
+                const result = await client.getFills({
+                    cursor,
+                    limit: batchSize,
+                    max_ts: maxTs,
+                    min_ts: minTs,
+                    ticker: flags.ticker,
+                });
+                allFills.push(...result.fills);
+                remaining -= result.fills.length;
+                if (!result.cursor || result.fills.length === 0) {
+                    break;
+                }
+                cursor = result.cursor;
+            }
+            if (allFills.length === 0) {
+                if (this.formatter.isJSONMode()) {
+                    this.formatter.success({
+                        by_ticker: {},
+                        maker_taker: {
+                            maker: { fills: 0, volume: 0 },
+                            taker: { fills: 0, volume: 0 },
+                        },
+                        period: {
+                            days: 0,
+                            end: maxTs ? new Date(maxTs * 1000).toISOString() : new Date().toISOString(),
+                            start: minTs ? new Date(minTs * 1000).toISOString() : new Date().toISOString(),
+                        },
+                        summary: {
+                            buy_volume: 0,
+                            maker_fills: 0,
+                            net_volume: 0,
+                            sell_volume: 0,
+                            taker_fills: 0,
+                            total_fees: 0,
+                            total_fills: 0,
+                            total_volume: 0,
+                        },
+                        time_series: {},
+                        top_trades: {},
+                    });
+                }
+                else {
+                    this.log(chalk.yellow('No fills found for the specified period'));
+                }
+                return;
+            }
+            // Calculate period
+            const oldestFill = allFills[allFills.length - 1];
+            const startDate = minTs ? new Date(minTs * 1000) : new Date(oldestFill.created_time);
+            const endDate = maxTs ? new Date(maxTs * 1000) : new Date(allFills[0].created_time);
+            const periodDays = Math.ceil((endDate.getTime() - startDate.getTime()) / (24 * 60 * 60 * 1000));
+            // Calculate summary statistics
+            const totalVolume = allFills.reduce((sum, f) => sum + f.count * f.price, 0);
+            const buyVolume = allFills.filter(f => f.action === 'buy').reduce((sum, f) => sum + f.count * f.price, 0);
+            const sellVolume = allFills.filter(f => f.action === 'sell').reduce((sum, f) => sum + f.count * f.price, 0);
+            const makerFills = allFills.filter(f => !f.is_taker).length;
+            const takerFills = allFills.filter(f => f.is_taker).length;
+            // Estimate fees
+            const MAKER_FEE = 0.005;
+            const TAKER_FEE = 0.015;
+            const totalFees = allFills.reduce((sum, f) => {
+                const notional = f.count * f.price;
+                return sum + notional * (f.is_taker ? TAKER_FEE : MAKER_FEE);
+            }, 0);
+            // Group by ticker
+            const byTicker = groupFillsByTicker(allFills);
+            const byTickerArray = [...byTicker.entries()].map(([ticker, stats]) => ({
+                fills: stats.count,
+                pnl: stats.estimatedPnL,
+                ticker,
+                volume: stats.volume,
+                win_rate: 0, // TODO: Calculate from individual trades
+            }));
+            // Group by time period
+            const timeSeries = groupFillsByPeriod(allFills, flags['group-by']);
+            const timeSeriesArray = [...timeSeries.entries()]
+                .map(([date, fills]) => ({
+                date,
+                fills: fills.length,
+                pnl: 0, // TODO: Calculate P&L for period
+                volume: fills.reduce((sum, f) => sum + f.count * f.price, 0),
+            }))
+                .sort((a, b) => a.date.localeCompare(b.date));
+            // Maker vs taker analysis
+            const makerTakerStats = calculateMakerTakerStats(allFills);
+            // Find top trades (by volume)
+            const sortedByVolume = [...allFills].sort((a, b) => b.count * b.price - a.count * a.price);
+            const largestTrade = sortedByVolume[0];
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success({
+                    by_ticker: Object.fromEntries(byTickerArray.map(t => [t.ticker, {
+                            fills: t.fills,
+                            pnl: t.pnl,
+                            volume: t.volume,
+                            win_rate: t.win_rate,
+                        }])),
+                    maker_taker: makerTakerStats,
+                    period: {
+                        days: periodDays,
+                        end: endDate.toISOString(),
+                        start: startDate.toISOString(),
+                    },
+                    summary: {
+                        buy_volume: buyVolume,
+                        maker_fills: makerFills,
+                        net_volume: sellVolume - buyVolume,
+                        sell_volume: sellVolume,
+                        taker_fills: takerFills,
+                        total_fees: totalFees,
+                        total_fills: allFills.length,
+                        total_volume: totalVolume,
+                    },
+                    time_series: {
+                        [flags['group-by']]: timeSeriesArray,
+                    },
+                    top_trades: {
+                        largest_by_volume: largestTrade ? {
+                            date: largestTrade.created_time,
+                            ticker: largestTrade.ticker,
+                            volume: largestTrade.count * largestTrade.price,
+                        } : null,
+                    },
+                });
+            }
+            else {
+                // Human-readable output
+                this.log(chalk.cyan.bold('Historical Performance Analysis'));
+                this.log();
+                // Period
+                this.log(chalk.yellow('Period:'));
+                this.log(`  ${startDate.toLocaleDateString()} - ${endDate.toLocaleDateString()} (${periodDays} days)`);
+                this.log();
+                // Summary
+                this.log(chalk.yellow('Summary:'));
+                this.log(`  Total Fills: ${allFills.length}`);
+                this.log(`  Total Volume: ${chalk.cyan('$' + totalVolume.toFixed(2))}`);
+                this.log(`  Buy Volume: ${chalk.green('$' + buyVolume.toFixed(2))}`);
+                this.log(`  Sell Volume: ${chalk.red('$' + sellVolume.toFixed(2))}`);
+                this.log(`  Net Volume: ${sellVolume - buyVolume >= 0 ? chalk.green('+$' + (sellVolume - buyVolume).toFixed(2)) : chalk.red('-$' + Math.abs(sellVolume - buyVolume).toFixed(2))}`);
+                this.log(`  Total Fees: ${chalk.red('$' + totalFees.toFixed(2))}`);
+                this.log();
+                // Maker vs Taker
+                this.log(chalk.yellow('Maker vs Taker:'));
+                this.log(`  Maker Fills: ${makerFills} (${((makerFills / allFills.length) * 100).toFixed(1)}%)`);
+                this.log(`  Maker Volume: ${chalk.cyan('$' + makerTakerStats.maker.volume.toFixed(2))}`);
+                this.log(`  Taker Fills: ${takerFills} (${((takerFills / allFills.length) * 100).toFixed(1)}%)`);
+                this.log(`  Taker Volume: ${chalk.cyan('$' + makerTakerStats.taker.volume.toFixed(2))}`);
+                this.log();
+                // By Ticker
+                if (byTickerArray.length > 0) {
+                    this.log(chalk.yellow('Performance by Ticker:'));
+                    const topTickers = byTickerArray
+                        .sort((a, b) => b.volume - a.volume)
+                        .slice(0, 10);
+                    const tickerRows = topTickers.map(t => [
+                        t.ticker,
+                        t.fills.toString(),
+                        '$' + t.volume.toFixed(2),
+                        t.pnl >= 0 ? chalk.green('+$' + t.pnl.toFixed(2)) : chalk.red('$' + t.pnl.toFixed(2)),
+                    ]);
+                    this.formatter.outputTable(['Ticker', 'Fills', 'Volume', 'Est. P&L'], tickerRows);
+                    this.log();
+                }
+                // Time Series
+                this.log(chalk.yellow(`Time Series (${flags['group-by']}ly):`));
+                if (timeSeriesArray.length > 0) {
+                    const recent = timeSeriesArray.slice(-10); // Show last 10 periods
+                    const timeRows = recent.map(t => [
+                        t.date,
+                        t.fills.toString(),
+                        '$' + t.volume.toFixed(2),
+                    ]);
+                    this.formatter.outputTable(['Period', 'Fills', 'Volume'], timeRows);
+                    if (timeSeriesArray.length > 10) {
+                        this.log();
+                        this.log(chalk.gray(`  ... showing last 10 of ${timeSeriesArray.length} periods`));
+                    }
+                }
+                this.log();
+                // Top Trades
+                if (largestTrade) {
+                    this.log(chalk.yellow('Top Trades:'));
+                    this.log(`  Largest by Volume: ${chalk.cyan(largestTrade.ticker)} - $${(largestTrade.count * largestTrade.price).toFixed(2)} (${new Date(largestTrade.created_time).toLocaleDateString()})`);
+                }
+            }
+            logger.info({
+                fills: allFills.length,
+                period_days: periodDays,
+                total_volume: totalVolume,
+            }, 'Historical analysis completed');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class PortfolioRisk extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'group-by': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        threshold: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/portfolio/risk.js

@@ -0,0 +1,206 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { createClientFromConfig } from '../../lib/kalshi/index.js';
+import { logger } from '../../lib/logger.js';
+import { calculateConcentrationByGroup, calculatePortfolioRiskScore, detectCorrelatedPositions, identifyHighRiskPositions, suggestMaxPositionSize, } from '../../lib/risk.js';
+export default class PortfolioRisk extends BaseCommand {
+    static description = 'Real-time portfolio risk analysis and warnings';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --threshold 15',
+        '<%= config.bin %> <%= command.id %> --group-by event',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        'group-by': Flags.string({
+            default: 'ticker',
+            description: 'Grouping for concentration analysis',
+            options: ['event', 'series', 'ticker'],
+        }),
+        'threshold': Flags.integer({
+            default: 20,
+            description: 'Alert threshold for position concentration (%)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PortfolioRisk);
+        try {
+            const client = createClientFromConfig();
+            // Fetch data
+            const [balance, positions] = await Promise.all([
+                client.getBalance(),
+                client.getPositions({ settlement_status: 'open' }),
+            ]);
+            if (positions.length === 0) {
+                if (this.formatter.isJSONMode()) {
+                    this.formatter.success({
+                        alerts: [],
+                        concentrations: { by_event: [], by_ticker: [] },
+                        correlations: [],
+                        exposure_ratio: 0,
+                        position_count: 0,
+                        recommendations: {
+                            max_new_position_size: balance.balance / 100,
+                            max_single_position_pct: flags.threshold,
+                        },
+                        risk_level: 'LOW',
+                        risk_score: 0,
+                        total_exposure: 0,
+                    });
+                }
+                else {
+                    this.log(chalk.yellow('No open positions'));
+                }
+                return;
+            }
+            const portfolioValue = balance.portfolio_value / 100;
+            // Fetch market details for all positions to enable grouping
+            const tickers = positions.map(p => p.ticker).join(',');
+            const marketsResult = await client.getMarkets({ limit: positions.length, tickers });
+            const { markets } = marketsResult;
+            // Calculate risk metrics
+            const totalExposure = positions.reduce((sum, pos) => sum + pos.market_exposure, 0);
+            const exposureRatio = portfolioValue > 0 ? totalExposure / portfolioValue : 0;
+            const riskScore = calculatePortfolioRiskScore(positions, portfolioValue);
+            const highRiskPositions = identifyHighRiskPositions(positions, portfolioValue, flags.threshold);
+            // Concentration analysis
+            const concentrationByTicker = calculateConcentrationByGroup(positions, markets, portfolioValue, 'ticker', flags.threshold);
+            const concentrationByEvent = calculateConcentrationByGroup(positions, markets, portfolioValue, 'event', flags.threshold);
+            // Detect correlations
+            const correlations = detectCorrelatedPositions(positions, markets);
+            const correlationWarnings = [...correlations.entries()].map(([event, data]) => ({
+                event,
+                markets: data.markets,
+                total_exposure: data.exposure,
+                warning: 'Multiple positions in same event',
+            }));
+            // Identify alerts
+            const alerts = [];
+            if (riskScore.level === 'HIGH') {
+                alerts.push({
+                    message: `High portfolio risk score: ${riskScore.score}/100`,
+                    severity: 'high',
+                });
+            }
+            for (const pos of highRiskPositions) {
+                const pct = (pos.market_exposure / portfolioValue) * 100;
+                alerts.push({
+                    message: `${pos.ticker} exceeds threshold: ${pct.toFixed(1)}% of portfolio`,
+                    severity: pct > flags.threshold * 1.5 ? 'high' : 'medium',
+                });
+            }
+            if (exposureRatio > 0.8) {
+                alerts.push({
+                    message: `High exposure ratio: ${(exposureRatio * 100).toFixed(1)}%`,
+                    severity: exposureRatio > 1 ? 'high' : 'medium',
+                });
+            }
+            // Recommendations
+            const maxNewPositionSize = suggestMaxPositionSize(balance.balance / 100, portfolioValue, flags.threshold);
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success({
+                    alerts,
+                    concentrations: {
+                        by_event: concentrationByEvent,
+                        by_ticker: concentrationByTicker,
+                    },
+                    correlations: correlationWarnings,
+                    exposure_ratio: exposureRatio,
+                    position_count: positions.length,
+                    recommendations: {
+                        max_new_position_size: maxNewPositionSize,
+                        max_single_position_pct: flags.threshold,
+                    },
+                    risk_level: riskScore.level,
+                    risk_score: riskScore.score,
+                    total_exposure: totalExposure,
+                });
+            }
+            else {
+                // Human-readable output
+                this.log(chalk.cyan.bold('Portfolio Risk Analysis'));
+                this.log();
+                // Overall Risk
+                const riskLevelColor = riskScore.level === 'HIGH' ? chalk.red : riskScore.level === 'MEDIUM' ? chalk.yellow : chalk.green;
+                this.log(chalk.yellow('Overall Risk:'));
+                this.log(`  Risk Score: ${riskLevelColor(riskScore.score + '/100')}`);
+                this.log(`  Risk Level: ${riskLevelColor(riskScore.level)}`);
+                this.log(`  Total Exposure: ${chalk.cyan('$' + totalExposure.toFixed(2))}`);
+                this.log(`  Exposure Ratio: ${exposureRatio > 0.8 ? chalk.red((exposureRatio * 100).toFixed(1) + '%') : chalk.cyan((exposureRatio * 100).toFixed(1) + '%')}`);
+                this.log(`  Positions: ${positions.length}`);
+                this.log();
+                // Alerts
+                if (alerts.length > 0) {
+                    this.log(chalk.yellow('⚠️  Alerts:'));
+                    for (const alert of alerts) {
+                        const color = alert.severity === 'high' ? chalk.red : alert.severity === 'medium' ? chalk.yellow : chalk.blue;
+                        this.log(`  ${color('•')} ${alert.message}`);
+                    }
+                    this.log();
+                }
+                // Concentration
+                this.log(chalk.yellow('Concentration by Ticker:'));
+                const topConcentrations = concentrationByTicker.slice(0, 10);
+                if (topConcentrations.length > 0) {
+                    const rows = topConcentrations.map(c => [
+                        c.name,
+                        '$' + c.exposure.toFixed(2),
+                        c.pct_of_portfolio.toFixed(1) + '%',
+                        c.alert ? chalk.red('⚠️  ALERT') : chalk.green('OK'),
+                    ]);
+                    this.formatter.outputTable(['Ticker', 'Exposure', '% of Portfolio', 'Status'], rows);
+                }
+                else {
+                    this.log('  No positions');
+                }
+                this.log();
+                // Event concentration
+                if (concentrationByEvent.length > 0) {
+                    this.log(chalk.yellow('Concentration by Event:'));
+                    const topEvents = concentrationByEvent.slice(0, 5);
+                    const eventRows = topEvents.map(c => [
+                        c.name,
+                        (c.markets || []).length.toString() + ' markets',
+                        '$' + c.exposure.toFixed(2),
+                        c.pct_of_portfolio.toFixed(1) + '%',
+                        c.alert ? chalk.red('⚠️  ALERT') : chalk.green('OK'),
+                    ]);
+                    this.formatter.outputTable(['Event', 'Markets', 'Exposure', '% of Portfolio', 'Status'], eventRows);
+                    this.log();
+                }
+                // Correlations
+                if (correlationWarnings.length > 0) {
+                    this.log(chalk.yellow('⚠️  Correlation Warnings:'));
+                    for (const corr of correlationWarnings) {
+                        this.log(`  ${chalk.cyan(corr.event)}: ${corr.markets.length} positions, $${corr.total_exposure.toFixed(2)} total exposure`);
+                        this.log(`    Markets: ${corr.markets.join(', ')}`);
+                    }
+                    this.log();
+                }
+                // Recommendations
+                this.log(chalk.yellow('Recommendations:'));
+                this.log(`  Max New Position Size: ${chalk.cyan('$' + maxNewPositionSize.toFixed(2))} (${flags.threshold}% of portfolio)`);
+                this.log(`  Position Size Threshold: ${chalk.cyan(flags.threshold + '%')}`);
+                if (riskScore.level === 'HIGH') {
+                    this.log();
+                    this.log(chalk.red('⚠️  Consider reducing exposure or diversifying positions'));
+                }
+                else if (riskScore.level === 'MEDIUM') {
+                    this.log();
+                    this.log(chalk.yellow('ℹ️  Monitor positions and avoid over-concentration'));
+                }
+            }
+            logger.info({
+                alerts: alerts.length,
+                correlations: correlationWarnings.length,
+                risk_level: riskScore.level,
+                risk_score: riskScore.score,
+            }, 'Risk analysis completed');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}