@gaberoo/kalshitools 1.0.0

package/dist/commands/config/init.js

@@ -0,0 +1,89 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { getConfig } from '../../lib/config/manager.js';
+import { logger } from '../../lib/logger.js';
+export default class ConfigInit extends BaseCommand {
+    static description = 'Initialize kalshitools configuration interactively';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env production',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        env: Flags.string({
+            description: 'Environment to configure (demo or production)',
+            options: ['demo', 'production'],
+            default: 'demo',
+        }),
+        keyId: Flags.string({
+            description: 'API key ID (email)',
+        }),
+        privateKeyPath: Flags.string({
+            description: 'Path to private key file',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ConfigInit);
+        const configManager = getConfig();
+        // Interactive prompts
+        const env = flags.env || 'demo';
+        let keyId = flags.keyId;
+        let privateKeyPath = flags.privateKeyPath;
+        // If not provided via flags, prompt the user
+        if (!keyId) {
+            keyId = await this.promptForInput('API Key ID (email)');
+        }
+        if (!privateKeyPath) {
+            privateKeyPath = await this.promptForInput(`Path to private key file (default: ~/.kalshitools/${env}-private-key.pem)`, `~/.kalshitools/${env}-private-key.pem`);
+        }
+        // Save configuration
+        configManager.setApiConfig(env, {
+            keyId,
+            privateKeyPath,
+        });
+        configManager.setEnvironment(env);
+        if (flags.json) {
+            this.formatter.success({
+                environment: env,
+                keyId,
+                privateKeyPath,
+                configPath: configManager.getConfigPath(),
+            });
+        }
+        else {
+            this.log(chalk.green('✓ Configuration saved successfully!'));
+            this.log();
+            this.log(chalk.cyan('Configuration:'));
+            this.log(`  Environment: ${chalk.yellow(env)}`);
+            this.log(`  Key ID: ${chalk.yellow(keyId)}`);
+            this.log(`  Private Key Path: ${chalk.yellow(privateKeyPath)}`);
+            this.log(`  Config File: ${chalk.gray(configManager.getConfigPath())}`);
+            this.log();
+            this.log(chalk.cyan('Next steps:'));
+            this.log(`  1. Make sure your private key is at: ${privateKeyPath}`);
+            this.log(`  2. Verify configuration: ${chalk.yellow('kalshitools config show')}`);
+            this.log(`  3. Test connection: ${chalk.yellow('kalshitools portfolio balance')}`);
+        }
+        logger.info({ env, keyId }, 'Configuration initialized');
+    }
+    async promptForInput(prompt, defaultValue) {
+        // For now, if in non-interactive mode or JSON mode, use defaults or fail
+        if (this.formatter.isJSONMode() || !process.stdin.isTTY) {
+            if (defaultValue) {
+                return defaultValue;
+            }
+            throw new Error(`${prompt} is required in non-interactive mode`);
+        }
+        // Simple readline prompt (could be enhanced with inquirer or @oclif/prompts)
+        const readline = await import('node:readline/promises');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const displayPrompt = defaultValue ? `${prompt} [${defaultValue}]: ` : `${prompt}: `;
+        const answer = await rl.question(displayPrompt);
+        rl.close();
+        return answer.trim() || defaultValue || '';
+    }
+}

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

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

package/dist/commands/config/show.js

@@ -0,0 +1,77 @@
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { getConfig } from '../../lib/config/manager.js';
+export default class ConfigShow extends BaseCommand {
+    static description = 'Show current configuration (credentials redacted)';
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --json'];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(ConfigShow);
+        const configManager = getConfig();
+        const config = configManager.getConfig();
+        const env = configManager.getEnvironment();
+        // Redact sensitive information
+        const safeConfig = {
+            version: config.version,
+            environment: env,
+            configPath: configManager.getConfigPath(),
+            api: {
+                demo: {
+                    baseUrl: config.api.demo.baseUrl,
+                    keyId: config.api.demo.keyId ? this.redact(config.api.demo.keyId) : undefined,
+                    privateKeyPath: config.api.demo.privateKeyPath,
+                    configured: Boolean(config.api.demo.keyId && config.api.demo.privateKeyPath),
+                },
+                production: {
+                    baseUrl: config.api.production.baseUrl,
+                    keyId: config.api.production.keyId ? this.redact(config.api.production.keyId) : undefined,
+                    privateKeyPath: config.api.production.privateKeyPath,
+                    configured: Boolean(config.api.production.keyId && config.api.production.privateKeyPath),
+                },
+            },
+            output: config.output,
+            trading: config.trading,
+        };
+        if (this.formatter.isJSONMode()) {
+            this.formatter.success(safeConfig);
+        }
+        else {
+            this.log(chalk.cyan.bold('Kalshitools Configuration'));
+            this.log();
+            this.log(`${chalk.cyan('Version:')} ${safeConfig.version}`);
+            this.log(`${chalk.cyan('Current Environment:')} ${chalk.yellow(safeConfig.environment)}`);
+            this.log(`${chalk.cyan('Config File:')} ${chalk.gray(safeConfig.configPath)}`);
+            this.log();
+            this.log(chalk.cyan.bold('API Configuration:'));
+            for (const [envName, envConfig] of Object.entries(safeConfig.api)) {
+                const isActive = envName === safeConfig.environment;
+                const prefix = isActive ? chalk.green('● ') : chalk.gray('○ ');
+                const status = envConfig.configured ? chalk.green('✓ Configured') : chalk.red('✗ Not configured');
+                this.log(`${prefix}${chalk.yellow(envName.toUpperCase())} ${status}`);
+                this.log(`  Base URL: ${envConfig.baseUrl}`);
+                if (envConfig.keyId) {
+                    this.log(`  Key ID: ${envConfig.keyId}`);
+                }
+                if (envConfig.privateKeyPath) {
+                    this.log(`  Private Key: ${envConfig.privateKeyPath}`);
+                }
+                this.log();
+            }
+            this.log(chalk.cyan.bold('Output Settings:'));
+            this.log(`  Default Format: ${safeConfig.output.defaultFormat}`);
+            this.log(`  Colors: ${safeConfig.output.colors ? 'enabled' : 'disabled'}`);
+            this.log();
+            this.log(chalk.cyan.bold('Trading Safety:'));
+            this.log(`  Confirmations: ${safeConfig.trading.confirmations ? 'enabled' : 'disabled'}`);
+            this.log(`  Max Order Size: ${safeConfig.trading.maxOrderSize}`);
+        }
+    }
+    redact(value) {
+        if (value.length <= 8) {
+            return '***';
+        }
+        return `${value.slice(0, 4)}...${value.slice(-4)}`;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class MarketsList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        status: 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/markets/list.js

@@ -0,0 +1,64 @@
+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';
+export default class MarketsList extends BaseCommand {
+    static description = 'List prediction markets';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --status active --limit 10',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        status: Flags.string({
+            description: 'Filter by market status',
+            options: ['active', 'closed', 'settled', 'finalized'],
+        }),
+        limit: Flags.integer({
+            description: 'Maximum number of markets to return',
+            default: 20,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(MarketsList);
+        try {
+            // Create API client from configuration
+            const client = createClientFromConfig();
+            // Fetch markets
+            const result = await client.getMarkets({
+                status: flags.status,
+                limit: flags.limit,
+            });
+            const markets = result.markets;
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success({ markets, cursor: result.cursor });
+            }
+            else {
+                if (markets.length === 0) {
+                    this.log(chalk.yellow('No markets found'));
+                    return;
+                }
+                this.log(chalk.cyan.bold(`Markets (${markets.length})`));
+                this.log();
+                const rows = markets.map((market) => [
+                    market.ticker,
+                    market.title.length > 50 ? market.title.slice(0, 47) + '...' : market.title,
+                    market.status,
+                    market.last_price !== undefined ? market.last_price.toFixed(2) : 'N/A',
+                    market.volume_24h !== undefined ? market.volume_24h.toLocaleString() : 'N/A',
+                ]);
+                this.formatter.outputTable(['Ticker', 'Title', 'Status', 'Price', 'Volume 24h'], rows);
+                if (result.cursor) {
+                    this.log();
+                    this.log(chalk.gray(`More results available. Use cursor: ${result.cursor}`));
+                }
+            }
+            logger.info({ count: markets.length }, 'Markets fetched successfully');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class MarketsShow extends BaseCommand {
+    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

@@ -0,0 +1,79 @@
+import { Args } 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 MarketsShow extends BaseCommand {
+    static description = 'Show market details';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TICKER',
+        '<%= config.bin %> <%= command.id %> TICKER --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    static args = {
+        ticker: Args.string({
+            description: 'Market ticker symbol',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(MarketsShow);
+        try {
+            // Create API client from configuration
+            const client = createClientFromConfig();
+            // Fetch market details
+            const market = await client.getMarket(args.ticker);
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success(market);
+            }
+            else {
+                this.log(chalk.cyan.bold(market.title));
+                this.log(chalk.gray(market.subtitle));
+                this.log();
+                this.log(`${chalk.cyan('Ticker:')} ${market.ticker}`);
+                this.log(`${chalk.cyan('Status:')} ${this.formatStatus(market.status)}`);
+                this.log();
+                this.log(chalk.cyan.bold('Pricing:'));
+                if (market.yes_bid !== undefined && market.yes_ask !== undefined) {
+                    this.log(`  Yes: ${chalk.green(market.yes_bid.toFixed(2))} / ${chalk.green(market.yes_ask.toFixed(2))}`);
+                }
+                if (market.no_bid !== undefined && market.no_ask !== undefined) {
+                    this.log(`  No:  ${chalk.red(market.no_bid.toFixed(2))} / ${chalk.red(market.no_ask.toFixed(2))}`);
+                }
+                if (market.last_price !== undefined) {
+                    this.log(`  Last: ${chalk.yellow(market.last_price.toFixed(2))}`);
+                }
+                this.log();
+                this.log(chalk.cyan.bold('Trading:'));
+                this.log(`  Volume: ${market.volume?.toLocaleString() || 'N/A'}`);
+                this.log(`  24h Volume: ${market.volume_24h?.toLocaleString() || 'N/A'}`);
+                this.log(`  Liquidity: ${market.liquidity?.toLocaleString() || 'N/A'}`);
+                this.log();
+                this.log(chalk.cyan.bold('Timing:'));
+                this.log(`  Opens: ${new Date(market.open_time).toLocaleString()}`);
+                this.log(`  Closes: ${new Date(market.close_time).toLocaleString()}`);
+                this.log(`  Expires: ${new Date(market.expiration_time).toLocaleString()}`);
+                if (market.result) {
+                    this.log();
+                    this.log(`${chalk.cyan('Result:')} ${chalk.bold(market.result.toUpperCase())}`);
+                }
+            }
+            logger.info({ ticker: market.ticker }, 'Market details fetched successfully');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    formatStatus(status) {
+        const colors = {
+            active: chalk.green,
+            closed: chalk.yellow,
+            settled: chalk.blue,
+            finalized: chalk.gray,
+        };
+        const colorFn = colors[status] || chalk.white;
+        return colorFn(status);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class OrdersCancel extends BaseCommand {
+    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

@@ -0,0 +1,129 @@
+import { Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+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 description = 'Cancel an order';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> ORDER_ID',
+        '<%= config.bin %> <%= command.id %> ORDER_ID --yes',
+        '<%= config.bin %> <%= command.id %> ORDER_ID --json',
+    ];
+    static flags = {
+        ...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,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(OrdersCancel);
+        const configManager = getConfig();
+        const tradingConfig = configManager.getTradingConfig();
+        const environment = configManager.getEnvironment();
+        try {
+            // Create API client
+            const client = createClientFromConfig();
+            // Fetch order details first
+            const order = await client.getOrder(args.orderId);
+            // Check if order can be cancelled
+            if (order.status === 'executed') {
+                if (this.formatter.isJSONMode()) {
+                    this.formatter.error('VALIDATION_ERROR', 'Order has already been executed and cannot be cancelled', {
+                        orderId: args.orderId,
+                        status: order.status,
+                    });
+                }
+                else {
+                    this.log(chalk.red('✗ Order has already been executed and cannot be cancelled'));
+                }
+                return;
+            }
+            if (order.status === 'canceled') {
+                if (this.formatter.isJSONMode()) {
+                    this.formatter.error('VALIDATION_ERROR', 'Order has already been cancelled', {
+                        orderId: args.orderId,
+                        status: order.status,
+                    });
+                }
+                else {
+                    this.log(chalk.yellow('Order has already been cancelled'));
+                }
+                return;
+            }
+            if (order.status === 'expired') {
+                if (this.formatter.isJSONMode()) {
+                    this.formatter.error('VALIDATION_ERROR', 'Order has already expired', {
+                        orderId: args.orderId,
+                        status: order.status,
+                    });
+                }
+                else {
+                    this.log(chalk.yellow('Order has already expired'));
+                }
+                return;
+            }
+            // Display order info
+            if (!this.formatter.isJSONMode()) {
+                this.log();
+                this.log(chalk.cyan.bold('Cancel Order'));
+                this.log(chalk.gray('─'.repeat(50)));
+                this.log(`${chalk.cyan('Environment:')} ${environment === 'demo' ? chalk.yellow('DEMO') : chalk.red('PRODUCTION')}`);
+                this.log(`${chalk.cyan('Order ID:')} ${order.order_id}`);
+                this.log(`${chalk.cyan('Ticker:')} ${order.ticker}`);
+                this.log(`${chalk.cyan('Action:')} ${order.action.toUpperCase()} ${order.side.toUpperCase()}`);
+                this.log(`${chalk.cyan('Quantity:')} ${order.count}`);
+                this.log(`${chalk.cyan('Filled:')} ${order.filled_count}/${order.count}`);
+                this.log(`${chalk.cyan('Status:')} ${order.status}`);
+                this.log(chalk.gray('─'.repeat(50)));
+                this.log();
+            }
+            // Confirmation prompt (unless --yes flag or JSON mode)
+            if (tradingConfig.confirmations && !flags.yes && !this.formatter.isJSONMode()) {
+                const confirmed = await this.confirm('Cancel this order?');
+                if (!confirmed) {
+                    this.log(chalk.yellow('Cancellation aborted'));
+                    return;
+                }
+            }
+            // Cancel the order
+            const cancelledOrder = await client.cancelOrder(args.orderId);
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success(cancelledOrder);
+            }
+            else {
+                this.log(chalk.green('✓ Order cancelled successfully'));
+                this.log();
+                this.log(`${chalk.cyan('Order ID:')} ${cancelledOrder.order_id}`);
+                this.log(`${chalk.cyan('Status:')} ${chalk.gray(cancelledOrder.status)}`);
+                if (cancelledOrder.filled_count > 0) {
+                    this.log();
+                    this.log(chalk.yellow(`Note: ${cancelledOrder.filled_count} contracts were filled before cancellation`));
+                }
+            }
+            logger.info({ orderId: args.orderId }, 'Order cancelled successfully');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async confirm(message) {
+        const readline = await import('node:readline/promises');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const answer = await rl.question(`${message} (y/N): `);
+        rl.close();
+        return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+    }
+}

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

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../lib/base-command.js';
+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>;
+        quantity: import("@oclif/core/interfaces").OptionFlag<number, 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;
+}