@gaberoo/kalshitools 1.0.1 → 1.0.3

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);

package/dist/commands/portfolio/balance.js

@@ -15,18 +15,23 @@ export default class PortfolioBalance extends BaseCommand {
             const client = createClientFromConfig();
             // Fetch balance
             const balance = await client.getBalance();
+            // Convert cents to dollars
+            const balanceDollars = balance.balance / 100;
+            const portfolioValueDollars = balance.portfolio_value / 100;
             if (this.formatter.isJSONMode()) {
-                this.formatter.success(balance);
+                // Return in dollars for readability
+                this.formatter.success({
+                    balance: balanceDollars,
+                    portfolio_value: portfolioValueDollars,
+                });
             }
             else {
                 this.log(chalk.cyan.bold('Account Balance'));
                 this.log();
-                this.log(`${chalk.cyan('Balance:')} ${chalk.green('$' + balance.balance.toFixed(2))}`);
-                this.log(`${chalk.cyan('Payout:')} ${chalk.yellow('$' + balance.payout.toFixed(2))}`);
-                this.log();
-                this.log(chalk.gray(`Total: $${(balance.balance + balance.payout).toFixed(2)}`));
+                this.log(`${chalk.cyan('Available:')} ${chalk.green('$' + balanceDollars.toFixed(2))}`);
+                this.log(`${chalk.cyan('Portfolio Value:')} ${chalk.yellow('$' + portfolioValueDollars.toFixed(2))}`);
             }
-            logger.info({ balance: balance.balance, payout: balance.payout }, 'Balance fetched successfully');
+            logger.info({ balance: balanceDollars, portfolio_value: portfolioValueDollars }, 'Balance fetched successfully');
         }
         catch (error) {
             // Error will be handled by BaseCommand.catch()

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/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/lib/base-command.d.ts

@@ -4,10 +4,10 @@ import { OutputFormatter } from './output/formatter.js';
  * Base command class that all kalshitools commands extend
  */
 export declare abstract class BaseCommand extends Command {
-    protected formatter: OutputFormatter;
     static baseFlags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    init(): Promise<void>;
+    protected formatter: OutputFormatter;
     protected catch(error: Error): Promise<unknown>;
+    init(): Promise<void>;
 }

package/dist/lib/base-command.js

@@ -6,20 +6,15 @@ import { OutputFormatter } from './output/formatter.js';
  * Base command class that all kalshitools commands extend
  */
 export class BaseCommand extends Command {
-    formatter;
     static baseFlags = {
         json: Flags.boolean({
-            description: 'Output in JSON format',
             default: false,
+            description: 'Output in JSON format',
         }),
     };
-    async init() {
-        await super.init();
-        const { flags } = await this.parse(this.constructor);
-        this.formatter = new OutputFormatter(flags.json, this.id);
-    }
+    formatter;
     async catch(error) {
-        logger.error({ error, command: this.id }, 'Command failed');
+        logger.error({ command: this.id, error }, 'Command failed');
         if (error instanceof KalshiToolsError) {
             if (this.formatter?.isJSONMode()) {
                 this.formatter.error(error.code, error.message, error.details);
@@ -35,4 +30,9 @@ export class BaseCommand extends Command {
         }
         throw error;
     }
+    async init() {
+        await super.init();
+        const { flags } = await this.parse(this.constructor);
+        this.formatter = new OutputFormatter(flags.json, this.id);
+    }
 }

package/dist/lib/config/manager.d.ts

@@ -1,45 +1,37 @@
-import { type Config, type ApiEnvConfig } from './schema.js';
+import { type ApiEnvConfig, type Config } from './schema.js';
 /**
  * Configuration manager for kalshitools
  */
 export declare class ConfigManager {
-    private store;
     private static instance;
+    private store;
     constructor();
     /**
      * Get singleton instance
      */
     static getInstance(): ConfigManager;
-    /**
-     * Get the full configuration
-     */
-    getConfig(): Config;
-    /**
-     * Get the current environment (demo or production)
-     */
-    getEnvironment(): 'demo' | 'production';
-    /**
-     * Set the environment
-     */
-    setEnvironment(env: 'demo' | 'production'): void;
     /**
      * Get API configuration for the current environment
      */
     getApiConfig(): ApiEnvConfig;
     /**
-     * Read private key from file
+     * Get the full configuration
      */
-    readPrivateKey(): string;
+    getConfig(): Config;
     /**
-     * Set API configuration for an environment
+     * Get the configuration file path
      */
-    setApiConfig(env: 'demo' | 'production', config: Partial<ApiEnvConfig>): void;
+    getConfigPath(): string;
+    /**
+     * Get the current environment (demo or production)
+     */
+    getEnvironment(): 'demo' | 'production';
     /**
      * Get output configuration
      */
     getOutputConfig(): {
-        defaultFormat: "json" | "table";
         colors: boolean;
+        defaultFormat: "json" | "table";
     };
     /**
      * Get trading configuration
@@ -49,21 +41,29 @@ export declare class ConfigManager {
         maxOrderSize: number;
     };
     /**
-     * Set a configuration value
+     * Check if configuration is initialized
      */
-    set<K extends keyof Config>(key: K, value: Config[K]): void;
+    isConfigured(): boolean;
     /**
-     * Get the configuration file path
+     * Read private key from file
      */
-    getConfigPath(): string;
+    readPrivateKey(): string;
     /**
      * Reset configuration to defaults
      */
     reset(): void;
     /**
-     * Check if configuration is initialized
+     * Set a configuration value
      */
-    isConfigured(): boolean;
+    set<K extends keyof Config>(key: K, value: Config[K]): void;
+    /**
+     * Set API configuration for an environment
+     */
+    setApiConfig(env: 'demo' | 'production', config: Partial<ApiEnvConfig>): void;
+    /**
+     * Set the environment
+     */
+    setEnvironment(env: 'demo' | 'production'): void;
 }
 /**
  * Get the global configuration manager instance

package/dist/lib/config/manager.js

@@ -1,20 +1,20 @@
 import Conf from 'conf';
+import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { readFileSync } from 'node:fs';
-import { defaultConfig } from './schema.js';
 import { ConfigError } from '../errors/base.js';
 import { logger } from '../logger.js';
+import { defaultConfig } from './schema.js';
 /**
  * Configuration manager for kalshitools
  */
 export class ConfigManager {
-    store;
     static instance = null;
+    store;
     constructor() {
         this.store = new Conf({
-            projectName: 'kalshitools',
             defaults: defaultConfig,
+            projectName: 'kalshitools',
         });
     }
     /**
@@ -26,6 +26,24 @@ export class ConfigManager {
         }
         return ConfigManager.instance;
     }
+    /**
+     * Get API configuration for the current environment
+     */
+    getApiConfig() {
+        const env = this.getEnvironment();
+        const config = this.store.get(`api.${env}`);
+        // Override with environment variables if present
+        const keyId = process.env.KALSHI_API_KEY_ID || config.keyId;
+        const privateKeyPath = process.env.KALSHI_PRIVATE_KEY_PATH || config.privateKeyPath;
+        if (!keyId || !privateKeyPath) {
+            throw new ConfigError(`API credentials not configured for ${env} environment. Run 'kalshitools config init' to set up.`, { environment: env });
+        }
+        return {
+            baseUrl: config.baseUrl,
+            keyId,
+            privateKeyPath,
+        };
+    }
     /**
      * Get the full configuration
      */
@@ -33,6 +51,12 @@ export class ConfigManager {
         const config = this.store.store;
         return config;
     }
+    /**
+     * Get the configuration file path
+     */
+    getConfigPath() {
+        return this.store.path;
+    }
     /**
      * Get the current environment (demo or production)
      */
@@ -40,28 +64,24 @@ export class ConfigManager {
         return process.env.KALSHI_ENV === 'production' ? 'production' : this.store.get('environment', 'demo');
     }
     /**
-     * Set the environment
+     * Get output configuration
      */
-    setEnvironment(env) {
-        this.store.set('environment', env);
+    getOutputConfig() {
+        return this.store.get('output');
     }
     /**
-     * Get API configuration for the current environment
+     * Get trading configuration
      */
-    getApiConfig() {
+    getTradingConfig() {
+        return this.store.get('trading');
+    }
+    /**
+     * Check if configuration is initialized
+     */
+    isConfigured() {
         const env = this.getEnvironment();
         const config = this.store.get(`api.${env}`);
-        // Override with environment variables if present
-        const keyId = process.env.KALSHI_API_KEY_ID || config.keyId;
-        const privateKeyPath = process.env.KALSHI_PRIVATE_KEY_PATH || config.privateKeyPath;
-        if (!keyId || !privateKeyPath) {
-            throw new ConfigError(`API credentials not configured for ${env} environment. Run 'kalshitools config init' to set up.`, { environment: env });
-        }
-        return {
-            baseUrl: config.baseUrl,
-            keyId,
-            privateKeyPath,
-        };
+        return Boolean(config.keyId && config.privateKeyPath);
     }
     /**
      * Read private key from file
@@ -78,29 +98,16 @@ export class ConfigManager {
         }
         catch (error) {
             throw new ConfigError(`Failed to read private key from ${expandedPath}`, {
-                path: expandedPath,
                 error: error instanceof Error ? error.message : String(error),
+                path: expandedPath,
             });
         }
     }
     /**
-     * Set API configuration for an environment
-     */
-    setApiConfig(env, config) {
-        const current = this.store.get(`api.${env}`);
-        this.store.set(`api.${env}`, { ...current, ...config });
-    }
-    /**
-     * Get output configuration
-     */
-    getOutputConfig() {
-        return this.store.get('output');
-    }
-    /**
-     * Get trading configuration
+     * Reset configuration to defaults
      */
-    getTradingConfig() {
-        return this.store.get('trading');
+    reset() {
+        this.store.clear();
     }
     /**
      * Set a configuration value
@@ -109,24 +116,17 @@ export class ConfigManager {
         this.store.set(key, value);
     }
     /**
-     * Get the configuration file path
-     */
-    getConfigPath() {
-        return this.store.path;
-    }
-    /**
-     * Reset configuration to defaults
+     * Set API configuration for an environment
      */
-    reset() {
-        this.store.clear();
+    setApiConfig(env, config) {
+        const current = this.store.get(`api.${env}`);
+        this.store.set(`api.${env}`, { ...current, ...config });
     }
     /**
-     * Check if configuration is initialized
+     * Set the environment
      */
-    isConfigured() {
-        const env = this.getEnvironment();
-        const config = this.store.get(`api.${env}`);
-        return Boolean(config.keyId && config.privateKeyPath);
+    setEnvironment(env) {
+        this.store.set('environment', env);
     }
 }
 /**