@gaberoo/kalshitools 1.0.2 → 1.1.0

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class PortfolioAnalytics extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        '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>;
+        period: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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/fills.d.ts

@@ -3,8 +3,8 @@ export default class PortfolioFills extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
-        ticker: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         limit: import("@oclif/core/interfaces").OptionFlag<number, 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/fills.js

@@ -13,12 +13,12 @@ export default class PortfolioFills extends BaseCommand {
     ];
     static flags = {
         ...BaseCommand.baseFlags,
-        ticker: Flags.string({
-            description: 'Filter by ticker',
-        }),
         limit: Flags.integer({
-            description: 'Maximum number of fills to return',
             default: 50,
+            description: 'Maximum number of fills to return',
+        }),
+        ticker: Flags.string({
+            description: 'Filter by ticker',
         }),
     };
     async run() {
@@ -28,12 +28,12 @@ export default class PortfolioFills extends BaseCommand {
             const client = createClientFromConfig();
             // Fetch fills
             const result = await client.getFills({
-                ticker: flags.ticker,
                 limit: flags.limit,
+                ticker: flags.ticker,
             });
-            const fills = result.fills;
+            const { fills } = result;
             if (this.formatter.isJSONMode()) {
-                this.formatter.success({ fills, cursor: result.cursor });
+                this.formatter.success({ cursor: result.cursor, fills });
             }
             else {
                 if (fills.length === 0) {

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/positions.d.ts

@@ -3,6 +3,7 @@ export default class PortfolioPositions extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        'settlement-status': 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/positions.js

@@ -1,3 +1,4 @@
+import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 import { BaseCommand } from '../../lib/base-command.js';
 import { createClientFromConfig } from '../../lib/kalshi/index.js';
@@ -6,18 +7,26 @@ export default class PortfolioPositions extends BaseCommand {
     static description = 'View current positions with P&L';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --settlement-status open',
+        '<%= config.bin %> <%= command.id %> --settlement-status settled',
         '<%= config.bin %> <%= command.id %> --json',
     ];
     static flags = {
         ...BaseCommand.baseFlags,
+        'settlement-status': Flags.string({
+            description: 'Filter by settlement status',
+            options: ['open', 'pending', 'settled'],
+        }),
     };
     async run() {
-        await this.parse(PortfolioPositions);
+        const { flags } = await this.parse(PortfolioPositions);
         try {
             // Create API client from configuration
             const client = createClientFromConfig();
             // Fetch positions
-            const positions = await client.getPositions();
+            const positions = await client.getPositions({
+                settlement_status: flags['settlement-status'],
+            });
             if (this.formatter.isJSONMode()) {
                 this.formatter.success(positions);
             }

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>;
+}