@gaberoo/kalshitools 1.0.2 → 1.1.0

package/dist/commands/markets/orderbook.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class MarketsOrderbook extends BaseCommand {
+    static args: {
+        ticker: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        depth: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/markets/orderbook.js

@@ -0,0 +1,83 @@
+import { Args, 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';
+export default class MarketsOrderbook extends BaseCommand {
+    static args = {
+        ticker: Args.string({
+            description: 'Market ticker symbol',
+            required: true,
+        }),
+    };
+    static description = 'Show order book for a market';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TICKER',
+        '<%= config.bin %> <%= command.id %> TICKER --depth 5',
+        '<%= config.bin %> <%= command.id %> TICKER --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        depth: Flags.integer({
+            default: 10,
+            description: 'Number of price levels to show',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(MarketsOrderbook);
+        try {
+            // Create API client from configuration
+            const client = createClientFromConfig();
+            // Fetch order book
+            const orderbook = await client.getOrderBook(args.ticker, flags.depth);
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success(orderbook);
+            }
+            else {
+                // Human-readable output
+                this.log(chalk.cyan.bold(`Order Book: ${orderbook.ticker}`));
+                this.log();
+                // YES Side (Buy)
+                this.log(chalk.green.bold('YES Side (Buy)'));
+                if (orderbook.yes.length === 0) {
+                    this.log(chalk.gray('  No orders'));
+                }
+                else {
+                    const yesRows = orderbook.yes.map((level) => [
+                        level.price.toFixed(2),
+                        level.count.toString(),
+                        (level.price * level.count).toFixed(2),
+                    ]);
+                    this.formatter.outputTable(['Price', 'Quantity', 'Total'], yesRows);
+                }
+                this.log();
+                // NO Side (Sell)
+                this.log(chalk.red.bold('NO Side (Sell)'));
+                if (orderbook.no.length === 0) {
+                    this.log(chalk.gray('  No orders'));
+                }
+                else {
+                    const noRows = orderbook.no.map((level) => [
+                        level.price.toFixed(2),
+                        level.count.toString(),
+                        (level.price * level.count).toFixed(2),
+                    ]);
+                    this.formatter.outputTable(['Price', 'Quantity', 'Total'], noRows);
+                }
+                // Calculate and display spread if both sides have orders
+                if (orderbook.yes.length > 0 && orderbook.no.length > 0) {
+                    const bestYes = orderbook.yes[0].price;
+                    const bestNo = orderbook.no[0].price;
+                    const spread = Math.abs(bestYes - bestNo);
+                    const spreadPct = ((spread / ((bestYes + bestNo) / 2)) * 100).toFixed(1);
+                    this.log();
+                    this.log(`${chalk.cyan('Spread:')} ${spread.toFixed(2)} (${spreadPct}%)`);
+                }
+            }
+            logger.info({ depth: flags.depth, ticker: args.ticker }, 'Order book fetched successfully');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}

package/dist/commands/markets/scan.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class MarketsScan extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        depth: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        'event-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>;
+        'max-spread': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'min-liquidity': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'min-spread': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'min-volume': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'series-ticker': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'sort-by': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/markets/scan.js

@@ -0,0 +1,237 @@
+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 { calculateOrderbookLiquidity, calculateSpread, classifyOpportunity, filterMarketsByCriteria, generateOpportunityReason, scoreMarket, } from '../../lib/scanner.js';
+export default class MarketsScan extends BaseCommand {
+    static description = 'Scan markets for trading opportunities based on liquidity and spreads';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --min-liquidity 200 --min-spread 0.05',
+        '<%= config.bin %> <%= command.id %> --event-ticker EVENT-2024',
+        '<%= config.bin %> <%= command.id %> --sort-by liquidity --limit 20',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        'depth': Flags.integer({
+            default: 5,
+            description: 'Orderbook depth to fetch for analysis',
+        }),
+        'event-ticker': Flags.string({
+            description: 'Filter to specific event',
+        }),
+        'limit': Flags.integer({
+            default: 50,
+            description: 'Maximum markets to scan',
+        }),
+        'max-spread': Flags.string({
+            default: '0.30',
+            description: 'Maximum spread in cents (e.g., 0.30 = 30 cents)',
+        }),
+        'min-liquidity': Flags.string({
+            default: '100',
+            description: 'Minimum orderbook depth in dollars',
+        }),
+        'min-spread': Flags.string({
+            default: '0.03',
+            description: 'Minimum spread in cents (e.g., 0.03 = 3 cents)',
+        }),
+        'min-volume': Flags.string({
+            default: '500',
+            description: 'Minimum 24h volume in dollars',
+        }),
+        'series-ticker': Flags.string({
+            description: 'Filter to specific series',
+        }),
+        'sort-by': Flags.string({
+            default: 'score',
+            description: 'Ranking criteria',
+            options: ['liquidity', 'score', 'spread', 'volume'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(MarketsScan);
+        try {
+            const client = createClientFromConfig();
+            // Parse numeric flags
+            const minLiquidity = Number.parseFloat(flags['min-liquidity']);
+            const minSpread = Number.parseFloat(flags['min-spread']);
+            const maxSpread = Number.parseFloat(flags['max-spread']);
+            const minVolume = Number.parseFloat(flags['min-volume']);
+            if (!this.formatter.isJSONMode()) {
+                this.log(chalk.cyan.bold('Scanning Markets for Opportunities...'));
+                this.log();
+            }
+            // Fetch active markets
+            const marketsResult = await client.getMarkets({
+                event_ticker: flags['event-ticker'],
+                limit: flags.limit,
+                series_ticker: flags['series-ticker'],
+                status: 'active',
+            });
+            const { markets } = marketsResult;
+            if (markets.length === 0) {
+                if (this.formatter.isJSONMode()) {
+                    this.formatter.success({
+                        markets: [],
+                        opportunities: 0,
+                        scanned: 0,
+                        stats: {
+                            avg_liquidity: 0,
+                            avg_spread: 0,
+                            avg_volume_24h: 0,
+                        },
+                    });
+                }
+                else {
+                    this.log(chalk.yellow('No active markets found'));
+                }
+                return;
+            }
+            if (!this.formatter.isJSONMode()) {
+                this.log(`Found ${markets.length} active markets. Fetching orderbooks...`);
+                this.log(chalk.gray('(This may take a few seconds due to rate limiting)'));
+                this.log();
+            }
+            // Fetch orderbooks for all markets (rate limited automatically by client)
+            const marketData = [];
+            for (const market of markets) {
+                try {
+                    const orderbook = await client.getOrderBook(market.ticker, flags.depth);
+                    const liquidity = calculateOrderbookLiquidity(orderbook);
+                    const spreadData = calculateSpread(orderbook);
+                    const volume = market.volume_24h || market.volume || 0;
+                    const score = scoreMarket(market, orderbook);
+                    marketData.push({
+                        liquidity: liquidity.total,
+                        market,
+                        orderbook,
+                        score,
+                        spread: spreadData ? spreadData.spreadCents : null,
+                        volume,
+                    });
+                }
+                catch (error) {
+                    logger.debug({ error, ticker: market.ticker }, 'Failed to fetch orderbook');
+                    // Skip markets with orderbook fetch errors
+                    continue;
+                }
+            }
+            // Filter markets by criteria
+            const filtered = filterMarketsByCriteria(marketData, {
+                maxSpread,
+                minLiquidity,
+                minSpread,
+                minVolume,
+            });
+            // Sort markets
+            const sorted = [...filtered];
+            if (flags['sort-by'] === 'liquidity') {
+                sorted.sort((a, b) => b.liquidity - a.liquidity);
+            }
+            else if (flags['sort-by'] === 'spread') {
+                sorted.sort((a, b) => (b.spread || 0) - (a.spread || 0));
+            }
+            else if (flags['sort-by'] === 'volume') {
+                sorted.sort((a, b) => b.volume - a.volume);
+            }
+            else {
+                // Default to score
+                sorted.sort((a, b) => b.score - a.score);
+            }
+            // Calculate statistics
+            const avgLiquidity = filtered.length > 0
+                ? filtered.reduce((sum, m) => sum + m.liquidity, 0) / filtered.length
+                : 0;
+            const avgSpread = filtered.length > 0
+                ? filtered.filter(m => m.spread !== null).reduce((sum, m) => sum + (m.spread || 0), 0) / filtered.filter(m => m.spread !== null).length
+                : 0;
+            const avgVolume24h = filtered.length > 0
+                ? filtered.reduce((sum, m) => sum + m.volume, 0) / filtered.length
+                : 0;
+            if (this.formatter.isJSONMode()) {
+                const opportunities = sorted.map(m => {
+                    const spreadData = m.orderbook ? calculateSpread(m.orderbook) : null;
+                    const liquidityData = m.orderbook ? calculateOrderbookLiquidity(m.orderbook) : { noTotal: 0, total: 0, yesTotal: 0 };
+                    const opportunityType = classifyOpportunity(m.spread || 0, m.liquidity, m.volume);
+                    return {
+                        liquidity: {
+                            no_total: liquidityData.noTotal,
+                            total: liquidityData.total,
+                            yes_total: liquidityData.yesTotal,
+                        },
+                        opportunity_type: opportunityType,
+                        reason: generateOpportunityReason(opportunityType, m.spread || 0, m.liquidity, m.volume),
+                        score: m.score,
+                        spread: spreadData ? {
+                            spread_cents: spreadData.spreadCents,
+                            spread_pct: spreadData.spreadPct,
+                            yes_ask: spreadData.yesAsk,
+                            yes_bid: spreadData.yesBid,
+                        } : null,
+                        ticker: m.market.ticker,
+                        title: m.market.title,
+                        volume: {
+                            volume_24h: m.volume,
+                        },
+                    };
+                });
+                this.formatter.success({
+                    markets: opportunities,
+                    opportunities: filtered.length,
+                    scanned: markets.length,
+                    stats: {
+                        avg_liquidity: avgLiquidity,
+                        avg_spread: avgSpread,
+                        avg_volume_24h: avgVolume24h,
+                    },
+                });
+            }
+            else {
+                // Human-readable output
+                this.log(chalk.cyan.bold('Market Opportunities'));
+                this.log();
+                this.log(chalk.yellow('Summary:'));
+                this.log(`  Markets Scanned: ${markets.length}`);
+                this.log(`  Opportunities Found: ${filtered.length}`);
+                this.log(`  Avg Liquidity: ${chalk.cyan('$' + avgLiquidity.toFixed(2))}`);
+                this.log(`  Avg Spread: ${chalk.cyan(avgSpread.toFixed(3))} cents`);
+                this.log(`  Avg 24h Volume: ${chalk.cyan('$' + avgVolume24h.toFixed(2))}`);
+                this.log();
+                if (sorted.length > 0) {
+                    this.log(chalk.yellow('Top Opportunities:'));
+                    const rows = sorted.slice(0, 20).map(m => {
+                        const spreadData = m.orderbook ? calculateSpread(m.orderbook) : null;
+                        return [
+                            m.market.ticker,
+                            m.score.toString(),
+                            spreadData ? spreadData.spreadCents.toFixed(3) : 'N/A',
+                            '$' + m.liquidity.toFixed(0),
+                            '$' + m.volume.toFixed(0),
+                            m.market.title.length > 40 ? m.market.title.slice(0, 37) + '...' : m.market.title,
+                        ];
+                    });
+                    this.formatter.outputTable(['Ticker', 'Score', 'Spread', 'Liquidity', '24h Vol', 'Title'], rows);
+                    if (sorted.length > 20) {
+                        this.log();
+                        this.log(chalk.gray(`  ... showing top 20 of ${sorted.length} opportunities`));
+                    }
+                }
+                else {
+                    this.log(chalk.yellow('No opportunities found matching criteria'));
+                }
+                this.log();
+                this.log(chalk.gray('Tip: Use --json for full data including orderbook details'));
+            }
+            logger.info({
+                filtered: filtered.length,
+                scanned: markets.length,
+            }, 'Market scan completed');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}

package/dist/commands/markets/show.d.ts

@@ -1,13 +1,13 @@
 import { BaseCommand } from '../../lib/base-command.js';
 export default class MarketsShow extends BaseCommand {
+    static args: {
+        ticker: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    static args: {
-        ticker: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
     run(): Promise<void>;
     private formatStatus;
 }

package/dist/commands/markets/show.js

@@ -4,6 +4,12 @@ import { BaseCommand } from '../../lib/base-command.js';
 import { createClientFromConfig } from '../../lib/kalshi/index.js';
 import { logger } from '../../lib/logger.js';
 export default class MarketsShow extends BaseCommand {
+    static args = {
+        ticker: Args.string({
+            description: 'Market ticker symbol',
+            required: true,
+        }),
+    };
     static description = 'Show market details';
     static examples = [
         '<%= config.bin %> <%= command.id %> TICKER',
@@ -12,12 +18,6 @@ export default class MarketsShow extends BaseCommand {
     static flags = {
         ...BaseCommand.baseFlags,
     };
-    static args = {
-        ticker: Args.string({
-            description: 'Market ticker symbol',
-            required: true,
-        }),
-    };
     async run() {
         const { args } = await this.parse(MarketsShow);
         try {
@@ -70,8 +70,8 @@ export default class MarketsShow extends BaseCommand {
         const colors = {
             active: chalk.green,
             closed: chalk.yellow,
-            settled: chalk.blue,
             finalized: chalk.gray,
+            settled: chalk.blue,
         };
         const colorFn = colors[status] || chalk.white;
         return colorFn(status);

package/dist/commands/orders/cancel.d.ts

@@ -1,14 +1,14 @@
 import { BaseCommand } from '../../lib/base-command.js';
 export default class OrdersCancel extends BaseCommand {
+    static args: {
+        orderId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     static flags: {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    static args: {
-        orderId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
     run(): Promise<void>;
     private confirm;
 }

package/dist/commands/orders/cancel.js

@@ -5,6 +5,12 @@ import { getConfig } from '../../lib/config/manager.js';
 import { createClientFromConfig } from '../../lib/kalshi/index.js';
 import { logger } from '../../lib/logger.js';
 export default class OrdersCancel extends BaseCommand {
+    static args = {
+        orderId: Args.string({
+            description: 'Order ID to cancel',
+            required: true,
+        }),
+    };
     static description = 'Cancel an order';
     static examples = [
         '<%= config.bin %> <%= command.id %> ORDER_ID',
@@ -15,14 +21,8 @@ export default class OrdersCancel extends BaseCommand {
         ...BaseCommand.baseFlags,
         yes: Flags.boolean({
             char: 'y',
-            description: 'Skip confirmation prompt',
             default: false,
-        }),
-    };
-    static args = {
-        orderId: Args.string({
-            description: 'Order ID to cancel',
-            required: true,
+            description: 'Skip confirmation prompt',
         }),
     };
     async run() {

package/dist/commands/orders/create.d.ts

@@ -3,17 +3,17 @@ export default class OrdersCreate extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
-        ticker: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         action: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        side: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        price: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         quantity: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        side: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        ticker: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         type: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        price: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private formatStatus;
     private confirm;
+    private formatStatus;
 }

package/dist/commands/orders/create.js

@@ -16,45 +16,45 @@ export default class OrdersCreate extends BaseCommand {
     ];
     static flags = {
         ...BaseCommand.baseFlags,
-        ticker: Flags.string({
-            char: 't',
-            description: 'Market ticker symbol',
-            required: true,
-        }),
         action: Flags.string({
             char: 'a',
             description: 'Order action (buy or sell)',
             options: ['buy', 'sell'],
             required: true,
         }),
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Simulate the order without actually placing it',
+        }),
+        price: Flags.string({
+            char: 'p',
+            description: 'Limit price (required for limit orders, 0.01-0.99)',
+        }),
+        quantity: Flags.integer({
+            char: 'q',
+            description: 'Number of contracts',
+            required: true,
+        }),
         side: Flags.string({
             char: 's',
             description: 'Contract side (yes or no)',
             options: ['yes', 'no'],
             required: true,
         }),
-        quantity: Flags.integer({
-            char: 'q',
-            description: 'Number of contracts',
+        ticker: Flags.string({
+            char: 't',
+            description: 'Market ticker symbol',
             required: true,
         }),
         type: Flags.string({
+            default: 'market',
             description: 'Order type (market or limit)',
             options: ['market', 'limit'],
-            default: 'market',
-        }),
-        price: Flags.string({
-            char: 'p',
-            description: 'Limit price (required for limit orders, 0.01-0.99)',
         }),
         yes: Flags.boolean({
             char: 'y',
-            description: 'Skip confirmation prompt',
-            default: false,
-        }),
-        'dry-run': Flags.boolean({
-            description: 'Simulate the order without actually placing it',
             default: false,
+            description: 'Skip confirmation prompt',
         }),
     };
     async run() {
@@ -84,10 +84,10 @@ export default class OrdersCreate extends BaseCommand {
             const costEstimate = estimateOrderCost(side, action, flags.quantity, price);
             // Build order request
             const orderRequest = {
-                ticker: flags.ticker,
-                side,
                 action,
                 count: flags.quantity,
+                side,
+                ticker: flags.ticker,
                 type: orderType,
             };
             if (orderType === 'limit' && price) {
@@ -132,16 +132,16 @@ export default class OrdersCreate extends BaseCommand {
             if (flags['dry-run']) {
                 if (this.formatter.isJSONMode()) {
                     this.formatter.success({
+                        costEstimate,
                         dryRun: true,
                         order: orderRequest,
-                        costEstimate,
                     });
                 }
                 else {
                     this.log(chalk.yellow('DRY RUN - Order not placed'));
                     this.log(chalk.gray('Order would be submitted with the parameters above'));
                 }
-                logger.info({ orderRequest, dryRun: true }, 'Dry run order');
+                logger.info({ dryRun: true, orderRequest }, 'Dry run order');
                 return;
             }
             // Confirmation prompt (unless --yes flag or JSON mode)
@@ -187,17 +187,6 @@ export default class OrdersCreate extends BaseCommand {
             throw error;
         }
     }
-    formatStatus(status) {
-        const colors = {
-            executed: chalk.green,
-            pending: chalk.yellow,
-            resting: chalk.cyan,
-            canceled: chalk.gray,
-            expired: chalk.red,
-        };
-        const colorFn = colors[status] || chalk.white;
-        return colorFn(status);
-    }
     async confirm(message) {
         const readline = await import('node:readline/promises');
         const rl = readline.createInterface({
@@ -208,4 +197,15 @@ export default class OrdersCreate extends BaseCommand {
         rl.close();
         return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
     }
+    formatStatus(status) {
+        const colors = {
+            canceled: chalk.gray,
+            executed: chalk.green,
+            expired: chalk.red,
+            pending: chalk.yellow,
+            resting: chalk.cyan,
+        };
+        const colorFn = colors[status] || chalk.white;
+        return colorFn(status);
+    }
 }

package/dist/commands/orders/list.d.ts

@@ -3,9 +3,9 @@ export default class OrdersList extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         status: 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>;
-        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/orders/list.js

@@ -13,6 +13,10 @@ export default class OrdersList extends BaseCommand {
     ];
     static flags = {
         ...BaseCommand.baseFlags,
+        limit: Flags.integer({
+            default: 50,
+            description: 'Maximum number of orders to return',
+        }),
         status: Flags.string({
             description: 'Filter by order status',
             options: ['pending', 'resting', 'canceled', 'executed', 'expired'],
@@ -20,10 +24,6 @@ export default class OrdersList extends BaseCommand {
         ticker: Flags.string({
             description: 'Filter by ticker',
         }),
-        limit: Flags.integer({
-            description: 'Maximum number of orders to return',
-            default: 50,
-        }),
     };
     async run() {
         const { flags } = await this.parse(OrdersList);
@@ -32,13 +32,13 @@ export default class OrdersList extends BaseCommand {
             const client = createClientFromConfig();
             // Fetch orders
             const result = await client.getOrders({
+                limit: flags.limit,
                 status: flags.status,
                 ticker: flags.ticker,
-                limit: flags.limit,
             });
-            const orders = result.orders;
+            const { orders } = result;
             if (this.formatter.isJSONMode()) {
-                this.formatter.success({ orders, cursor: result.cursor });
+                this.formatter.success({ cursor: result.cursor, orders });
             }
             else {
                 if (orders.length === 0) {
@@ -80,11 +80,11 @@ export default class OrdersList extends BaseCommand {
     }
     formatStatus(status) {
         const colors = {
+            canceled: chalk.gray,
             executed: chalk.green,
+            expired: chalk.red,
             pending: chalk.yellow,
             resting: chalk.cyan,
-            canceled: chalk.gray,
-            expired: chalk.red,
         };
         const colorFn = colors[status] || chalk.white;
         return colorFn(status);