@pungoyal/kite-cli 0.2.1 → 0.4.0

package/dist/commands/margins.js

@@ -0,0 +1,258 @@
+import { ORDER_TYPES, PRODUCTS, VARIETIES, } from '../core/api.js';
+import { UsageError } from '../core/errors.js';
+import { formatInstrumentKey, parseInstrumentKey } from '../core/instruments.js';
+import { money, rupees } from '../output/format.js';
+import { heading, printTable, renderKeyValue } from '../output/table.js';
+/**
+ * Margin and charge calculators — read-only.
+ *
+ * These POST a hypothetical set of orders to Kite and return what they would
+ * cost: `order` gives the per-order required margin (no netting), `basket` the
+ * net margin for the set (with spread/hedge benefit), and `charges` the
+ * itemised brokerage/tax breakdown (a "virtual contract note"). Nothing is
+ * placed, so none of the trading safety layer applies.
+ */
+export const marginCommands = (program, run) => {
+    const margins = program.command('margins').description('Calculate order margins and charges (nothing is placed)');
+    const orderExample = 'Each order is EXCHANGE:SYMBOL:SIDE:QTY[:TYPE][:PRODUCT][:VARIETY][:PRICE][:trigger=<n>], ' +
+        "e.g. 'NFO:NIFTY25AUGFUT:BUY:75:MARKET:NRML'. Product defaults to CNC, variety to regular.";
+    margins
+        .command('order')
+        .description('Required margin for each order on its own')
+        .argument('<orders...>', orderExample)
+        .action(run(orderMargins));
+    margins
+        .command('basket')
+        .description('Net margin for a basket of orders, with spread/hedge benefit')
+        .argument('<orders...>', orderExample)
+        .option('--no-consider-positions', 'Ignore existing positions when netting')
+        .action(run(basketMargins));
+    margins
+        .command('charges')
+        .description('Itemised charges for a set of executed orders (virtual contract note)')
+        .argument('<orders...>', `${orderExample} A non-zero price (the execution price) is required.`)
+        .action(run(orderCharges));
+};
+/**
+ * Parse one `EXCHANGE:SYMBOL:SIDE:QTY[:attrs...]` spec.
+ *
+ * Attributes after QTY are classified by content — an order type, a product, a
+ * variety, a bare number (the price), or `trigger=<n>`. Fails closed: an
+ * unrecognised token, a duplicated field, or an empty field rejects the whole
+ * spec rather than silently defaulting, since a mis-parsed order yields a
+ * silently wrong margin or charge.
+ */
+export function parseOrderSpec(spec) {
+    const tokens = spec
+        .trim()
+        .split(':')
+        .map((t) => t.trim());
+    if (tokens.length < 4) {
+        throw new UsageError(`Malformed order "${spec}".`, "Expected at least EXCHANGE:SYMBOL:SIDE:QTY, e.g. 'NFO:NIFTY25AUGFUT:BUY:75:NRML'.");
+    }
+    const [exchangeTok, symbolTok, sideTok, qtyTok, ...rest] = tokens;
+    const { exchange, tradingsymbol } = parseInstrumentKey(`${exchangeTok}:${symbolTok}`);
+    const side = sideTok.toUpperCase();
+    if (side !== 'BUY' && side !== 'SELL') {
+        throw new UsageError(`Order side must be BUY or SELL, got "${sideTok}" in "${spec}".`);
+    }
+    const quantity = Number(qtyTok);
+    if (!Number.isInteger(quantity) || quantity <= 0) {
+        throw new UsageError(`Order quantity must be a positive integer, got "${qtyTok}" in "${spec}".`);
+    }
+    let orderType;
+    let product;
+    let variety;
+    let price;
+    let triggerPrice;
+    const setOnce = (current, next, label) => {
+        if (current !== undefined)
+            throw new UsageError(`Order "${spec}" sets ${label} more than once.`);
+        return next;
+    };
+    for (const tok of rest) {
+        if (tok === '')
+            throw new UsageError(`Order "${spec}" has an empty field. Remove the stray ":".`);
+        const eq = tok.indexOf('=');
+        if (eq !== -1) {
+            const key = tok.slice(0, eq).trim().toLowerCase();
+            const value = tok.slice(eq + 1).trim();
+            if (key === 'price')
+                price = setOnce(price, parsePositive(value, 'price', spec), 'the price');
+            else if (key === 'trigger')
+                triggerPrice = setOnce(triggerPrice, parsePositive(value, 'trigger', spec), 'the trigger price');
+            else if (key === 'type')
+                orderType = setOnce(orderType, normalise(value, ORDER_TYPES, 'order type'), 'the order type');
+            else if (key === 'product')
+                product = setOnce(product, normalise(value, PRODUCTS, 'product'), 'the product');
+            else if (key === 'variety')
+                variety = setOnce(variety, normalise(value, VARIETIES, 'variety'), 'the variety');
+            else
+                throw new UsageError(`Order "${spec}" has an unknown field "${key}".`, 'Valid keys: type, product, variety, price, trigger.');
+            continue;
+        }
+        const upper = tok.toUpperCase();
+        const lower = tok.toLowerCase();
+        if (ORDER_TYPES.includes(upper)) {
+            orderType = setOnce(orderType, upper, 'the order type');
+        }
+        else if (PRODUCTS.includes(upper)) {
+            product = setOnce(product, upper, 'the product');
+        }
+        else if (VARIETIES.includes(lower)) {
+            variety = setOnce(variety, lower, 'the variety');
+        }
+        else if (isNumeric(tok)) {
+            // A bare number is the price. A trigger must be given explicitly.
+            price = setOnce(price, parsePositive(tok, 'price', spec), 'the price');
+        }
+        else {
+            throw new UsageError(`Order "${spec}" has an unrecognised field "${tok}".`, 'Fields after QTY are an order type, product, variety, a price, or trigger=<n>.');
+        }
+    }
+    return {
+        exchange,
+        tradingsymbol,
+        transactionType: side,
+        quantity,
+        orderType: orderType ?? 'MARKET',
+        product: product ?? 'CNC',
+        variety: variety ?? 'regular',
+        price,
+        triggerPrice,
+    };
+}
+function parseSpecs(args) {
+    if (args.length === 0)
+        throw new UsageError('At least one order is required.');
+    return args.map(parseOrderSpec);
+}
+/** Serialise for /margins/orders and /margins/basket (price + trigger_price). */
+function toMarginOrder(o) {
+    return {
+        exchange: o.exchange,
+        tradingsymbol: o.tradingsymbol,
+        transaction_type: o.transactionType,
+        variety: o.variety,
+        product: o.product,
+        order_type: o.orderType,
+        quantity: o.quantity,
+        price: o.price ?? 0,
+        trigger_price: o.triggerPrice ?? 0,
+    };
+}
+/**
+ * Serialise for /charges/orders (average_price + order_id, no price/trigger).
+ * Charges are a percentage of quantity × average_price, so a zero price yields
+ * a plausible-looking ≈₹0 that is silently wrong — require a real price.
+ */
+function toChargesOrder(o, index) {
+    if (o.price === undefined || o.price <= 0) {
+        throw new UsageError(`Order "${formatInstrumentKey(o.exchange, o.tradingsymbol)}" needs a non-zero price for charges.`, 'Charges are computed from quantity × execution price; add a price, e.g. :1500 or price=1500.');
+    }
+    return {
+        // A virtual contract note needs an order_id per leg; the index is fine.
+        order_id: String(index + 1),
+        exchange: o.exchange,
+        tradingsymbol: o.tradingsymbol,
+        transaction_type: o.transactionType,
+        variety: o.variety,
+        product: o.product,
+        order_type: o.orderType,
+        quantity: o.quantity,
+        average_price: o.price,
+    };
+}
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+async function orderMargins(ctx, _opts, command) {
+    ctx.requireSession();
+    const specs = parseSpecs(command.args);
+    const margins = await ctx.api.orderMargins(specs.map(toMarginOrder), ctx.signal);
+    const columns = marginColumns();
+    printTable(ctx.io, margins, columns, margins, { compact: ctx.config.output.compact, empty: 'No margins returned.' });
+    if (ctx.io.json)
+        return;
+    const total = margins.reduce((sum, m) => sum + (m.total ?? 0), 0);
+    ctx.io.line('');
+    ctx.io.line(`  Total margin required ${rupees(total)}`);
+}
+async function basketMargins(ctx, opts, command) {
+    ctx.requireSession();
+    const specs = parseSpecs(command.args);
+    const basket = await ctx.api.basketMargins(specs.map(toMarginOrder), opts.considerPositions !== false, ctx.signal);
+    if (ctx.io.json) {
+        ctx.io.writeJson(basket);
+        return;
+    }
+    const { io } = ctx;
+    io.line(heading(io, 'Per order'));
+    printTable(io, basket.orders, marginColumns(), basket.orders, {
+        compact: ctx.config.output.compact,
+        empty: 'No orders.',
+    });
+    // `final` is the margin actually blocked after spread/hedge benefit; `initial`
+    // is the gross figure before it. The difference is the benefit itself.
+    const finalTotal = basket.final?.total ?? 0;
+    const initialTotal = basket.initial?.total ?? 0;
+    io.line('');
+    io.line(renderKeyValue(io, [
+        ['Margin before benefit', rupees(initialTotal)],
+        ['Spread/hedge benefit', rupees(Math.max(0, initialTotal - finalTotal))],
+        ['Net margin required', io.bold(rupees(finalTotal))],
+    ]));
+}
+async function orderCharges(ctx, _opts, command) {
+    ctx.requireSession();
+    const specs = parseSpecs(command.args);
+    const charges = await ctx.api.orderCharges(specs.map((o, i) => toChargesOrder(o, i)), ctx.signal);
+    const columns = [
+        { header: 'Symbol', value: (m, io) => io.bold(`${m.exchange ?? '?'}:${m.tradingsymbol ?? '?'}`) },
+        { header: 'Brokerage', value: (m) => money(m.charges?.brokerage), align: 'right' },
+        { header: 'STT/CTT', value: (m) => money(m.charges?.transaction_tax), align: 'right' },
+        { header: 'Txn', value: (m) => money(m.charges?.exchange_turnover_charge), align: 'right' },
+        { header: 'GST', value: (m) => money(m.charges?.gst?.total), align: 'right' },
+        { header: 'Stamp', value: (m) => money(m.charges?.stamp_duty), align: 'right' },
+        { header: 'SEBI', value: (m) => money(m.charges?.sebi_turnover_charge), align: 'right' },
+        { header: 'Total', value: (m, io) => io.bold(money(m.charges?.total)), align: 'right' },
+    ];
+    printTable(ctx.io, charges, columns, charges, {
+        compact: ctx.config.output.compact,
+        empty: 'No charges returned.',
+    });
+    if (ctx.io.json)
+        return;
+    const total = charges.reduce((sum, m) => sum + (m.charges?.total ?? 0), 0);
+    ctx.io.line('');
+    ctx.io.line(`  Total charges ${rupees(total)}`);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function marginColumns() {
+    return [
+        { header: 'Symbol', value: (m, io) => io.bold(`${m.exchange ?? '?'}:${m.tradingsymbol ?? '?'}`) },
+        { header: 'SPAN', value: (m) => money(m.span), align: 'right' },
+        { header: 'Exposure', value: (m) => money(m.exposure), align: 'right' },
+        { header: 'Premium', value: (m) => money(m.option_premium), align: 'right' },
+        { header: 'Var', value: (m) => money(m.var), align: 'right' },
+        { header: 'Total', value: (m, io) => io.bold(money(m.total)), align: 'right' },
+    ];
+}
+function normalise(value, allowed, label) {
+    const candidate = label === 'variety' ? value.toLowerCase() : value.toUpperCase();
+    if (allowed.includes(candidate))
+        return candidate;
+    throw new UsageError(`Unknown ${label} "${value}".`, `Valid values: ${allowed.join(', ')}.`);
+}
+function isNumeric(value) {
+    return value !== '' && Number.isFinite(Number(value));
+}
+function parsePositive(value, label, spec) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new UsageError(`Order "${spec}" has an invalid ${label} "${value}"; expected a positive number.`);
+    }
+    return n;
+}

package/dist/commands/mf.d.ts

@@ -0,0 +1,10 @@
+import type { CommandFactory } from './types.js';
+/**
+ * Mutual funds — read only.
+ *
+ * Kite Connect does not offer MF order placement or SIP management over the
+ * API (an MF purchase needs a bank debit the API can't authorise), so this is
+ * holdings, recent orders, and SIPs — the three read endpoints — and nothing
+ * that moves money. No kill switch, value cap, or confirmation applies.
+ */
+export declare const mfCommands: CommandFactory;

package/dist/commands/mf.js

@@ -0,0 +1,85 @@
+import { dateTime, money, quantity, rupees, signedRupees } from '../output/format.js';
+import { printTable } from '../output/table.js';
+/**
+ * Mutual funds — read only.
+ *
+ * Kite Connect does not offer MF order placement or SIP management over the
+ * API (an MF purchase needs a bank debit the API can't authorise), so this is
+ * holdings, recent orders, and SIPs — the three read endpoints — and nothing
+ * that moves money. No kill switch, value cap, or confirmation applies.
+ */
+export const mfCommands = (program, run) => {
+    const mf = program.command('mf').description('View mutual fund holdings, orders and SIPs');
+    mf.command('holdings', { isDefault: true }).description('Show your mutual fund holdings').action(run(mfHoldings));
+    mf.command('orders').description('Show mutual fund orders from the last 7 days').action(run(mfOrders));
+    mf.command('sips').description('Show your mutual fund SIPs').action(run(mfSips));
+};
+async function mfHoldings(ctx) {
+    ctx.requireSession();
+    const rows = await ctx.api.getMfHoldings(ctx.signal);
+    const columns = [
+        { header: 'Fund', value: (h, io) => io.bold(h.fund ?? h.tradingsymbol) },
+        { header: 'Folio', value: (h) => h.folio ?? '—' },
+        { header: 'Units', value: (h) => quantity(h.quantity), align: 'right' },
+        { header: 'Avg', value: (h) => money(h.average_price), align: 'right' },
+        { header: 'NAV', value: (h) => money(h.last_price), align: 'right' },
+        { header: 'Value', value: (h) => money(h.last_price * h.quantity), align: 'right' },
+        { header: 'P&L', value: (h, io) => io.signed(h.pnl, signedRupees(h.pnl)), align: 'right' },
+    ];
+    printTable(ctx.io, rows, columns, rows, {
+        compact: ctx.config.output.compact,
+        empty: 'No mutual fund holdings.',
+    });
+    if (ctx.io.json)
+        return;
+    const totalValue = rows.reduce((sum, h) => sum + h.last_price * h.quantity, 0);
+    const totalPnl = rows.reduce((sum, h) => sum + h.pnl, 0);
+    if (rows.length > 0) {
+        const { io } = ctx;
+        io.line('');
+        io.line(`  Current value ${rupees(totalValue)}   P&L ${io.signed(totalPnl, signedRupees(totalPnl))}`);
+    }
+}
+async function mfOrders(ctx) {
+    ctx.requireSession();
+    const rows = await ctx.api.getMfOrders(ctx.signal);
+    const columns = [
+        { header: 'Order ID', value: (o, io) => io.dim(o.order_id) },
+        { header: 'Fund', value: (o, io) => io.bold(o.fund ?? o.tradingsymbol ?? '—') },
+        {
+            header: 'Side',
+            value: (o, io) => o.transaction_type === 'BUY'
+                ? io.green('BUY')
+                : o.transaction_type === 'SELL'
+                    ? io.red('SELL')
+                    : (o.transaction_type ?? '—'),
+        },
+        { header: 'Status', value: (o) => o.status ?? '—' },
+        { header: 'Units', value: (o) => quantity(o.quantity ?? undefined), align: 'right' },
+        { header: 'Amount', value: (o) => money(o.amount ?? undefined), align: 'right' },
+        { header: 'When', value: (o) => dateTime(o.order_timestamp ?? undefined) },
+    ];
+    printTable(ctx.io, rows, columns, rows, {
+        compact: ctx.config.output.compact,
+        // An empty list can just mean nothing was placed recently, not that you have
+        // no MF history — the endpoint only reaches back 7 days.
+        empty: 'No mutual fund orders in the last 7 days.',
+    });
+}
+async function mfSips(ctx) {
+    ctx.requireSession();
+    const rows = await ctx.api.getMfSips(ctx.signal);
+    const columns = [
+        { header: 'SIP ID', value: (s, io) => io.dim(s.sip_id) },
+        { header: 'Fund', value: (s, io) => io.bold(s.fund ?? s.tradingsymbol ?? '—') },
+        { header: 'Status', value: (s) => s.status ?? '—' },
+        { header: 'Instalment', value: (s) => money(s.instalment_amount), align: 'right' },
+        { header: 'Done', value: (s) => quantity(s.instalments), align: 'right' },
+        { header: 'Frequency', value: (s) => s.frequency ?? '—' },
+        { header: 'Next', value: (s) => dateTime(s.next_instalment ?? undefined) },
+    ];
+    printTable(ctx.io, rows, columns, rows, {
+        compact: ctx.config.output.compact,
+        empty: 'No mutual fund SIPs.',
+    });
+}

package/dist/commands/register.d.ts

@@ -0,0 +1,25 @@
+import type { Command } from 'commander';
+import type { Runner } from './types.js';
+/**
+ * Command wiring, factored out of run.ts so there is a single source of truth
+ * for the command tree.
+ *
+ * run() consumes this to build the live program; `kite completion` consumes it
+ * with a no-op runner to introspect command and flag names for shell
+ * completions. Keeping both on the same registration path means a new command
+ * or flag is completable the moment it is added, with nothing to keep in sync.
+ */
+/**
+ * Attach the global options every command inherits. Split from the name /
+ * version / output wiring in run.ts, which is invocation-specific, so an
+ * introspection-only program can still enumerate the same global flags.
+ */
+export declare function applyGlobalOptions(program: Command): Command;
+/**
+ * Register every command group on `program`, grouped for a readable `--help`.
+ *
+ * The `run` runner wraps each handler with context construction and error
+ * reporting in the real CLI; completion passes a no-op that only needs the
+ * command definitions, not their behaviour.
+ */
+export declare function registerCommands(program: Command, run: Runner): Promise<void>;

package/dist/commands/register.js

@@ -0,0 +1,75 @@
+/**
+ * Command wiring, factored out of run.ts so there is a single source of truth
+ * for the command tree.
+ *
+ * run() consumes this to build the live program; `kite completion` consumes it
+ * with a no-op runner to introspect command and flag names for shell
+ * completions. Keeping both on the same registration path means a new command
+ * or flag is completable the moment it is added, with nothing to keep in sync.
+ */
+/**
+ * Attach the global options every command inherits. Split from the name /
+ * version / output wiring in run.ts, which is invocation-specific, so an
+ * introspection-only program can still enumerate the same global flags.
+ */
+export function applyGlobalOptions(program) {
+    return (program
+        .option('--json', 'Emit JSON instead of formatted tables')
+        .option('--color <when>', 'Colour output: auto, always, or never')
+        // Deliberately no `-q` short form: it would shadow `-q, --quantity` on the
+        // order and GTT subcommands, which is typed far more often than --quiet.
+        .option('--quiet', 'Suppress informational messages')
+        .option('--debug', 'Print redacted request diagnostics to stderr')
+        .option('--env <env>', 'Environment: production or sandbox')
+        .option('--profile <name>', 'Account profile to use (see `kite profiles`)')
+        .option('-y, --yes', 'Skip confirmation prompts (use with care)')
+        .option('--dry-run', 'Show what would happen without sending anything to Kite'));
+}
+/**
+ * Register every command group on `program`, grouped for a readable `--help`.
+ *
+ * The `run` runner wraps each handler with context construction and error
+ * reporting in the real CLI; completion passes a no-op that only needs the
+ * command definitions, not their behaviour.
+ */
+export async function registerCommands(program, run) {
+    // Imported here rather than at module top so a single invocation only pays for
+    // parsing the command modules once run() (or completion) actually asks for
+    // them, not on every `import` of this file.
+    const { authCommands } = await import('./auth.js');
+    const { profileCommands } = await import('./profiles.js');
+    const { portfolioCommands } = await import('./portfolio.js');
+    const { marketCommands } = await import('./market.js');
+    const { orderCommands } = await import('./orders.js');
+    const { gttCommands } = await import('./gtt.js');
+    const { alertCommands } = await import('./alerts.js');
+    const { marginCommands } = await import('./margins.js');
+    const { mfCommands } = await import('./mf.js');
+    const { watchCommands } = await import('./watch.js');
+    const { configCommands } = await import('./config.js');
+    const { doctorCommands } = await import('./doctor.js');
+    const { completionCommands } = await import('./completion.js');
+    // commandsGroup applies to every command registered after it, so the group
+    // is set immediately before each block. With ~25 commands this is the
+    // difference between a readable --help and a wall of text.
+    program.commandsGroup('Account:');
+    authCommands(program, run);
+    profileCommands(program, run);
+    program.commandsGroup('Portfolio:');
+    portfolioCommands(program, run);
+    program.commandsGroup('Mutual funds:');
+    mfCommands(program, run);
+    program.commandsGroup('Market data:');
+    marketCommands(program, run);
+    program.commandsGroup('Trading:');
+    orderCommands(program, run);
+    gttCommands(program, run);
+    alertCommands(program, run);
+    marginCommands(program, run);
+    program.commandsGroup('Streaming:');
+    watchCommands(program, run);
+    program.commandsGroup('Settings:');
+    configCommands(program, run);
+    doctorCommands(program, run);
+    completionCommands(program, run);
+}

package/dist/core/auth.d.ts

@@ -59,6 +59,15 @@ export declare function waitForCallback(opts: CallbackServerOptions): {
     close: () => void;
 };
 export declare function redirectUrlFor(port: number, path: string): string;
+/**
+ * Copy text to the OS clipboard, returning whether it succeeded.
+ *
+ * Like {@link openBrowser}, the text is piped to a fixed binary's stdin — never
+ * through a shell and never as an argv element — so a URL's `&`/`=` cannot
+ * become word-splitting or command injection. On Linux there is no single
+ * clipboard tool, so we try the common ones in turn (Wayland first, then X11).
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;
 /**
  * Open a URL in the user's default browser.
  *

package/dist/core/auth.js

@@ -175,6 +175,45 @@ function escapeHtml(value) {
 export function redirectUrlFor(port, path) {
     return `http://127.0.0.1:${port}${path}`;
 }
+/**
+ * Copy text to the OS clipboard, returning whether it succeeded.
+ *
+ * Like {@link openBrowser}, the text is piped to a fixed binary's stdin — never
+ * through a shell and never as an argv element — so a URL's `&`/`=` cannot
+ * become word-splitting or command injection. On Linux there is no single
+ * clipboard tool, so we try the common ones in turn (Wayland first, then X11).
+ */
+export async function copyToClipboard(text) {
+    const candidates = process.platform === 'darwin'
+        ? [['pbcopy', []]]
+        : process.platform === 'win32'
+            ? [['clip', []]]
+            : [
+                ['wl-copy', []],
+                ['xclip', ['-selection', 'clipboard']],
+                ['xsel', ['--clipboard', '--input']],
+            ];
+    for (const [command, args] of candidates) {
+        if (await pipeToCommand(command, args, text))
+            return true;
+    }
+    return false;
+}
+/** Spawn `command`, write `text` to its stdin, resolve true on a clean exit. */
+function pipeToCommand(command, args, text) {
+    return import('node:child_process').then(({ spawn }) => new Promise((resolve) => {
+        try {
+            const child = spawn(command, args, { stdio: ['pipe', 'ignore', 'ignore'], shell: false });
+            child.on('error', () => resolve(false));
+            child.on('close', (code) => resolve(code === 0));
+            child.stdin.on('error', () => resolve(false));
+            child.stdin.end(text);
+        }
+        catch {
+            resolve(false);
+        }
+    }));
+}
 /**
  * Open a URL in the user's default browser.
  *

package/dist/core/client.js

@@ -177,7 +177,14 @@ export class KiteClient {
             return new KiteCliError('Cancelled.', ExitCode.Aborted);
         }
         const message = err instanceof Error ? err.message : String(err);
-        return new NetworkError(`Could not reach Kite: ${redactString(message)}`, 'Check your network connection.');
+        // undici's fetch wraps the actual failure (ECONNRESET, ENOTFOUND, a TLS
+        // error, ...) in `cause` and sets `message` to the unhelpful constant
+        // "fetch failed" — surface the cause too, or every transient network
+        // problem looks identical and undebuggable.
+        const cause = err instanceof Error ? err.cause : undefined;
+        const causeMessage = cause instanceof Error ? cause.message : cause !== undefined ? String(cause) : undefined;
+        const detail = causeMessage && causeMessage !== message ? `${message}: ${causeMessage}` : message;
+        return new NetworkError(`Could not reach Kite: ${redactString(detail)}`, 'Check your network connection.');
     }
     handleResponse(response, text, schema, url) {
         let payload;

package/dist/core/schemas.d.ts

@@ -683,6 +683,7 @@ export declare const BasketMarginSchema: z.ZodObject<{
     }, z.core.$loose>>>;
     charges: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$loose>;
+export type BasketMargin = z.infer<typeof BasketMarginSchema>;
 export declare const MfHoldingSchema: z.ZodObject<{
     folio: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     fund: z.ZodOptional<z.ZodString>;
@@ -707,6 +708,7 @@ export declare const MfOrderSchema: z.ZodObject<{
     amount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     average_price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$loose>;
+export type MfOrder = z.infer<typeof MfOrderSchema>;
 export declare const MfSipSchema: z.ZodObject<{
     sip_id: z.ZodString;
     tradingsymbol: z.ZodOptional<z.ZodString>;
@@ -717,6 +719,7 @@ export declare const MfSipSchema: z.ZodObject<{
     frequency: z.ZodOptional<z.ZodString>;
     next_instalment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$loose>;
+export type MfSip = z.infer<typeof MfSipSchema>;
 export declare const InstrumentSchema: z.ZodObject<{
     instrument_token: z.ZodNumber;
     exchange_token: z.ZodOptional<z.ZodNumber>;

package/dist/run.js

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { Command, CommanderError } from 'commander';
+import { applyGlobalOptions, registerCommands } from './commands/register.js';
 import { createContext } from './context.js';
 import { AbortedError, ExitCode, KiteCliError } from './core/errors.js';
 import { redactString } from './core/redact.js';
@@ -36,16 +37,6 @@ export async function run(opts = {}) {
         .name('kite')
         .description('Unofficial command-line interface for the Zerodha Kite Connect API (not affiliated with Zerodha)')
         .version(VERSION, '-v, --version')
-        .option('--json', 'Emit JSON instead of formatted tables')
-        .option('--color <when>', 'Colour output: auto, always, or never')
-        // Deliberately no `-q` short form: it would shadow `-q, --quantity` on the
-        // order and GTT subcommands, which is typed far more often than --quiet.
-        .option('--quiet', 'Suppress informational messages')
-        .option('--debug', 'Print redacted request diagnostics to stderr')
-        .option('--env <env>', 'Environment: production or sandbox')
-        .option('--profile <name>', 'Account profile to use (see `kite profiles`)')
-        .option('-y, --yes', 'Skip confirmation prompts (use with care)')
-        .option('--dry-run', 'Show what would happen without sending anything to Kite')
         .showHelpAfterError('(run `kite --help` for usage)')
         .configureOutput({
         writeOut: (str) => (opts.streams?.stdout ?? process.stdout).write(str),
@@ -54,6 +45,7 @@ export async function run(opts = {}) {
         // Throw instead of calling process.exit, so `run()` stays testable and
         // always returns its exit code.
         .exitOverride();
+    applyGlobalOptions(program);
     /** Wraps a handler with context construction and error reporting. */
     const withContext = (handler) => async (...args) => {
         // Commander passes (…arguments, options, command).
@@ -68,35 +60,11 @@ export async function run(opts = {}) {
             exitCode = reportError(err, ctx.io);
         }
     };
-    // Registered lazily so a bare `kite quote` never pays to import the
-    // dashboard renderer, the ticker, or the prompt library.
-    const { authCommands } = await import('./commands/auth.js');
-    const { profileCommands } = await import('./commands/profiles.js');
-    const { portfolioCommands } = await import('./commands/portfolio.js');
-    const { marketCommands } = await import('./commands/market.js');
-    const { orderCommands } = await import('./commands/orders.js');
-    const { gttCommands } = await import('./commands/gtt.js');
-    const { alertCommands } = await import('./commands/alerts.js');
-    const { watchCommands } = await import('./commands/watch.js');
-    const { configCommands } = await import('./commands/config.js');
-    // commandsGroup applies to every command registered after it, so the group
-    // is set immediately before each block. With ~25 commands this is the
-    // difference between a readable --help and a wall of text.
-    program.commandsGroup('Account:');
-    authCommands(program, withContext);
-    profileCommands(program, withContext);
-    program.commandsGroup('Portfolio:');
-    portfolioCommands(program, withContext);
-    program.commandsGroup('Market data:');
-    marketCommands(program, withContext);
-    program.commandsGroup('Trading:');
-    orderCommands(program, withContext);
-    gttCommands(program, withContext);
-    alertCommands(program, withContext);
-    program.commandsGroup('Streaming:');
-    watchCommands(program, withContext);
-    program.commandsGroup('Settings:');
-    configCommands(program, withContext);
+    // Registered through the shared registration path (see commands/register.ts)
+    // so run() and `kite completion` build the exact same command tree. Modules
+    // are still imported lazily inside registerCommands, so a bare `kite quote`
+    // never pays to parse the dashboard renderer or the ticker up front.
+    await registerCommands(program, withContext);
     program.addHelpText('after', `
 Examples:
   $ kite login                                  Authenticate and store a session

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pungoyal/kite-cli",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Unofficial command-line interface for the Zerodha Kite Connect API — not affiliated with or endorsed by Zerodha",
   "keywords": [
     "zerodha",
@@ -18,7 +18,7 @@
     "type": "git",
     "url": "git+https://github.com/pungoyal/kite-cli.git"
   },
-  "homepage": "https://github.com/pungoyal/kite-cli#readme",
+  "homepage": "https://pungoyal.github.io/kite-cli",
   "bugs": {
     "url": "https://github.com/pungoyal/kite-cli/issues"
   },