@raintree-technology/perps 0.1.0

package/dist/commands/arb/track.js

@@ -0,0 +1,259 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { Box, Text, render, useApp, useInput } from "ink";
+import { getContext } from "../../cli/program.js";
+import { AppShell, MetricStrip, Panel, Table, colors, toBar, toSparkline, } from "../../cli/ink/index.js";
+import { pollFundingRates } from "../../lib/funding-tracker.js";
+import { getSpreadStats, getRecordCount, cleanupOldRecords } from "../../lib/db/funding-history.js";
+import { getAvailableExchanges } from "../../lib/exchange.js";
+import { COMMON_ASSETS, FUNDING_HISTORY_RETENTION_DAYS } from "../../lib/constants.js";
+import { parseAssetList, parsePositiveInt } from "../../lib/validate.js";
+function formatRatePct(rate) {
+    const sign = rate >= 0 ? "+" : "";
+    return `${sign}${(rate * 100).toFixed(4)}%`;
+}
+function findExchangeRecord(assetRecords, exchange) {
+    return assetRecords.find((record) => record.exchange.toLowerCase().includes(exchange.toLowerCase()));
+}
+function edgeToSignal(edgeAnnualized, avg24h) {
+    if (edgeAnnualized >= 30 && (avg24h ?? 0) >= 10)
+        return "HUNT";
+    if (edgeAnnualized >= 10)
+        return "WATCH";
+    return "IDLE";
+}
+function signalColor(signal) {
+    if (signal === "HUNT")
+        return colors.profit;
+    if (signal === "WATCH")
+        return colors.warning;
+    return colors.muted;
+}
+function edgeColor(edgeAnnualized) {
+    if (edgeAnnualized >= 30)
+        return colors.profit;
+    if (edgeAnnualized >= 10)
+        return colors.warning;
+    return colors.muted;
+}
+function buildAssetSummaryRows(assets, exchanges, records, stats) {
+    const baseRows = assets.map((asset) => {
+        const market = `${asset}-PERP`;
+        const assetRecords = records.filter((record) => record.market === market);
+        const sorted = [...assetRecords].sort((left, right) => right.rate - left.rate);
+        const high = sorted[0];
+        const low = sorted[sorted.length - 1];
+        const edge = high && low ? (high.rate - low.rate) * 100 * 24 * 365 : 0;
+        const stat = stats.get(asset);
+        const rates = exchanges
+            .map((exchange) => {
+            const record = findExchangeRecord(assetRecords, exchange);
+            return record ? `${exchange}:${formatRatePct(record.rate)}` : `${exchange}:--`;
+        })
+            .join(" ");
+        return {
+            asset,
+            rates,
+            trend: toSparkline(assetRecords.map((record) => record.rate * 100), 10),
+            edge,
+            edgeBar: "",
+            avg24h: stat?.avg ?? null,
+            signal: edgeToSignal(edge, stat?.avg ?? null),
+        };
+    });
+    const maxEdge = Math.max(1, ...baseRows.map((row) => row.edge));
+    return baseRows.map((row) => ({
+        ...row,
+        edgeBar: toBar(row.edge, maxEdge, 10, "#", "."),
+    }));
+}
+function buildOpportunityRows(assets, records) {
+    const rows = [];
+    for (const asset of assets) {
+        const market = `${asset}-PERP`;
+        const assetRecords = records.filter((record) => record.market === market);
+        if (assetRecords.length < 2)
+            continue;
+        const sorted = [...assetRecords].sort((left, right) => right.rate - left.rate);
+        const high = sorted[0];
+        const low = sorted[sorted.length - 1];
+        const edge = (high.rate - low.rate) * 100 * 24 * 365;
+        rows.push({
+            market,
+            pair: `${high.exchange} -> ${low.exchange}`,
+            edge,
+            rates: `${formatRatePct(high.rate)} / ${formatRatePct(low.rate)}`,
+        });
+    }
+    return rows.sort((left, right) => right.edge - left.edge).slice(0, 8);
+}
+function TrackerUI({ assets, exchanges, intervalMin, testnet }) {
+    const [records, setRecords] = useState([]);
+    const [pollCount, setPollCount] = useState(0);
+    const [lastUpdate, setLastUpdate] = useState(null);
+    const [errors, setErrors] = useState(new Map());
+    const [stats, setStats] = useState(new Map());
+    const [pollMs, setPollMs] = useState(0);
+    const { exit } = useApp();
+    useInput((input, key) => {
+        if (input.toLowerCase() === "q" || key.escape || (key.ctrl && input.toLowerCase() === "c")) {
+            exit();
+        }
+    });
+    useEffect(() => {
+        let cancelled = false;
+        const doPoll = async () => {
+            const start = performance.now();
+            const pollErrors = new Map();
+            try {
+                const newRecords = await pollFundingRates(assets, exchanges, (err, exchange) => {
+                    pollErrors.set(exchange, err.message);
+                }, testnet);
+                if (cancelled)
+                    return;
+                setRecords(newRecords);
+                setLastUpdate(new Date());
+                setPollCount((count) => count + 1);
+                setPollMs(Math.round(performance.now() - start));
+                setErrors(pollErrors);
+                const newStats = new Map();
+                for (const asset of assets) {
+                    const s = getSpreadStats(`${asset}-PERP`, 24);
+                    if (s.samples > 0) {
+                        newStats.set(asset, { avg: s.avgAnnualized, consistency: s.consistency });
+                    }
+                }
+                setStats(newStats);
+            }
+            catch (err) {
+                if (cancelled)
+                    return;
+                pollErrors.set("tracker", err instanceof Error ? err.message : String(err));
+                setErrors(pollErrors);
+            }
+        };
+        void doPoll();
+        const interval = setInterval(() => {
+            void doPoll();
+        }, intervalMin * 60 * 1000);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+        };
+    }, [assets, exchanges, intervalMin, testnet]);
+    const assetRows = useMemo(() => buildAssetSummaryRows(assets, exchanges, records, stats), [assets, exchanges, records, stats]);
+    const opportunityRows = useMemo(() => buildOpportunityRows(assets, records), [assets, records]);
+    const assetColumns = useMemo(() => [
+        { key: "asset", header: "Asset", width: 8 },
+        { key: "rates", header: "Rates", width: Math.max(24, exchanges.length * 14) },
+        { key: "trend", header: "Trend", width: 10 },
+        {
+            key: "edge",
+            header: "Edge",
+            align: "right",
+            width: 24,
+            render: (value, row) => {
+                const edge = value;
+                return (_jsxs(Text, { color: edgeColor(edge), children: [row.edgeBar, " ", edge.toFixed(1), "%/yr"] }));
+            },
+        },
+        {
+            key: "avg24h",
+            header: "24h Avg",
+            align: "right",
+            width: 11,
+            render: (value) => {
+                const average = value;
+                if (average === null)
+                    return _jsx(Text, { color: colors.muted, children: "--" });
+                return _jsxs(Text, { color: edgeColor(average), children: [average.toFixed(1), "%/yr"] });
+            },
+        },
+        {
+            key: "signal",
+            header: "Signal",
+            align: "right",
+            width: 6,
+            render: (value) => {
+                const signal = value;
+                return _jsx(Text, { color: signalColor(signal), children: signal });
+            },
+        },
+    ], [exchanges.length]);
+    const opportunityColumns = [
+        { key: "market", header: "Market", width: 10 },
+        { key: "pair", header: "Pair", width: 40 },
+        {
+            key: "edge",
+            header: "Edge",
+            align: "right",
+            width: 12,
+            render: (value) => {
+                const edge = value;
+                return _jsxs(Text, { color: edgeColor(edge), children: [edge.toFixed(1), "%/yr"] });
+            },
+        },
+        { key: "rates", header: "Rates", width: 24 },
+    ];
+    const totalRecords = getRecordCount();
+    const activeSignals = assetRows.filter((row) => row.signal !== "IDLE").length;
+    const metrics = [
+        { label: "Polls", value: String(pollCount), tone: "neutral" },
+        { label: "Rows", value: String(records.length), tone: "neutral" },
+        { label: "Stored", value: String(totalRecords), tone: "neutral" },
+        {
+            label: "Latency",
+            value: pollMs > 0 ? `${pollMs}ms` : "--",
+            tone: pollMs > 2_000 ? "danger" : pollMs > 1_000 ? "warning" : "success",
+        },
+        { label: "Signals", value: String(activeSignals), tone: activeSignals > 0 ? "info" : "neutral" },
+    ];
+    return (_jsxs(AppShell, { title: "Funding Rate Tracker", subtitle: `${testnet ? "testnet" : "mainnet"} • poll interval ${intervalMin}m`, status: [
+            { label: "LIVE", tone: "success" },
+            { label: `${errors.size} ERR`, tone: errors.size > 0 ? "danger" : "neutral" },
+        ], lastUpdated: lastUpdate ?? undefined, shortcuts: [
+            { key: "q", label: "quit" },
+            { key: "esc", label: "quit" },
+            { key: "ctrl+c", label: "quit" },
+        ], children: [_jsx(MetricStrip, { metrics: metrics }), _jsx(Box, { flexDirection: "column", marginBottom: 1, children: _jsx(Panel, { title: "Asset Matrix", subtitle: "Cross-exchange rates, edge bars, and 24h signal quality", tone: "info", children: assetRows.length === 0 ? (_jsx(Text, { color: colors.muted, children: "Waiting for first poll..." })) : (_jsx(Table, { data: assetRows, columns: assetColumns })) }) }), _jsx(Box, { flexDirection: "column", marginBottom: errors.size > 0 ? 1 : 0, children: _jsx(Panel, { title: "Top Opportunities", subtitle: "Best spread by asset from latest poll", children: opportunityRows.length === 0 ? (_jsx(Text, { color: colors.muted, children: "Need at least 2 exchange quotes per asset." })) : (_jsx(Table, { data: opportunityRows, columns: opportunityColumns })) }) }), errors.size > 0 && (_jsx(Panel, { title: "Errors", subtitle: "Latest polling errors by exchange", tone: "danger", children: _jsx(Box, { flexDirection: "column", children: Array.from(errors.entries()).map(([exchange, message]) => (_jsxs(Text, { color: colors.loss, children: [exchange, ": ", message] }, exchange))) }) }))] }));
+}
+export function registerArbTrackCommand(arb) {
+    arb
+        .command("track")
+        .description("Start live funding rate tracking")
+        .option("-a, --assets <assets>", "Comma-separated assets to track", COMMON_ASSETS.join(","))
+        .option("-i, --interval <minutes>", "Poll interval in minutes", "5")
+        .option("--once", "Poll once and exit (no live tracking)")
+        .option("--cleanup", `Clean up old records (>${FUNDING_HISTORY_RETENTION_DAYS} days)`)
+        .action(async function () {
+        const ctx = getContext(this);
+        const opts = this.opts();
+        const assets = parseAssetList(opts.assets, COMMON_ASSETS);
+        const intervalMin = parsePositiveInt(opts.interval, "interval", 5);
+        const exchanges = getAvailableExchanges();
+        const isTestnet = ctx.config.testnet;
+        if (opts.cleanup) {
+            const deleted = cleanupOldRecords(FUNDING_HISTORY_RETENTION_DAYS);
+            console.log(`Cleaned up ${deleted} old records`);
+            return;
+        }
+        if (opts.once) {
+            console.log(`\nPolling funding rates for ${assets.join(", ")}...\n`);
+            const records = await pollFundingRates(assets, exchanges, undefined, isTestnet);
+            console.log("Exchange".padEnd(16) + "Market".padEnd(12) + "Rate".padEnd(14) + "Annualized");
+            console.log("─".repeat(55));
+            for (const r of records.sort((a, b) => a.market.localeCompare(b.market) || b.rate - a.rate)) {
+                const sign = r.rate >= 0 ? "+" : "";
+                console.log(`${r.exchange.padEnd(14)}` +
+                    `${r.market.padEnd(12)}` +
+                    `${sign}${(r.rate * 100).toFixed(4)}%`.padEnd(14) +
+                    `${sign}${r.annualized.toFixed(2)}%`);
+            }
+            console.log(`\nStored ${records.length} records`);
+            return;
+        }
+        // Live tracking UI
+        const { waitUntilExit } = render(_jsx(TrackerUI, { assets: assets, exchanges: exchanges, intervalMin: intervalMin, testnet: isTestnet }));
+        await waitUntilExit();
+    });
+}

package/dist/commands/asset/book-simple.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple order book command using the adapter interface
+ */
+import { Command } from "commander";
+export declare function registerBookSimpleCommand(asset: Command): void;

package/dist/commands/asset/book-simple.js

@@ -0,0 +1,77 @@
+/**
+ * Simple order book command using the adapter interface
+ */
+import { getContext, getOutputOptions } from "../../cli/program.js";
+import { output, outputError } from "../../cli/output.js";
+import { getExchangeAdapter } from "../../lib/exchange.js";
+export function registerBookSimpleCommand(asset) {
+    asset
+        .command("book <symbol>")
+        .description("Show order book for an asset")
+        .option("-d, --depth <number>", "Order book depth", "10")
+        .action(async function (symbol) {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const depth = parseInt(opts.depth, 10);
+        const adapter = getExchangeAdapter();
+        let connected = false;
+        try {
+            await adapter.connect({ testnet: ctx.config.testnet });
+            connected = true;
+            // Normalize symbol (accept BTC, BTC-PERP, btc, etc.)
+            let market = symbol.toUpperCase();
+            if (!market.includes("-")) {
+                market = `${market}-PERP`;
+            }
+            const book = await adapter.getOrderBook(market, depth);
+            if (outputOpts.json) {
+                output(book, outputOpts);
+            }
+            else {
+                console.log(`\n${adapter.info.name} Order Book: ${book.market}\n`);
+                // Calculate max sizes for formatting
+                const maxBidSize = Math.max(...book.bids.map(b => parseFloat(b.size)));
+                const maxAskSize = Math.max(...book.asks.map(a => parseFloat(a.size)));
+                const maxSize = Math.max(maxBidSize, maxAskSize);
+                // Header
+                console.log("  " + "Price".padEnd(14) + "Size".padEnd(14) + "│".padEnd(3) + "Price".padEnd(14) + "Size");
+                console.log("  " + "─".repeat(14) + "─".repeat(14) + "│" + "─".repeat(14) + "─".repeat(14));
+                // Asks (reversed so lowest ask is at bottom)
+                const asks = [...book.asks].reverse();
+                for (const ask of asks) {
+                    const bar = "█".repeat(Math.ceil((parseFloat(ask.size) / maxSize) * 10));
+                    console.log("  " + " ".repeat(28) + "│ " +
+                        `\x1b[31m${parseFloat(ask.price).toFixed(2).padEnd(13)}\x1b[0m` +
+                        parseFloat(ask.size).toFixed(4).padEnd(10) +
+                        `\x1b[31m${bar}\x1b[0m`);
+                }
+                // Spread
+                const bestBid = book.bids[0] ? parseFloat(book.bids[0].price) : 0;
+                const bestAsk = book.asks[0] ? parseFloat(book.asks[0].price) : 0;
+                const spread = bestAsk - bestBid;
+                const spreadPct = bestBid > 0 ? ((spread / bestBid) * 100).toFixed(4) : "0";
+                console.log("  " + " ".repeat(28) + "│ " + `Spread: $${spread.toFixed(2)} (${spreadPct}%)`);
+                // Bids
+                for (const bid of book.bids) {
+                    const bar = "█".repeat(Math.ceil((parseFloat(bid.size) / maxSize) * 10));
+                    console.log("  " +
+                        `\x1b[32m${parseFloat(bid.price).toFixed(2).padEnd(13)}\x1b[0m` +
+                        parseFloat(bid.size).toFixed(4).padEnd(10) +
+                        `\x1b[32m${bar}\x1b[0m` +
+                        " ".repeat(5) + "│");
+                }
+                console.log("");
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+        finally {
+            if (connected) {
+                await adapter.disconnect().catch(() => undefined);
+            }
+        }
+    });
+}

package/dist/commands/asset/index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerAssetCommands(program: Command): void;

package/dist/commands/asset/index.js

@@ -0,0 +1,5 @@
+import { registerBookSimpleCommand } from "./book-simple.js";
+export function registerAssetCommands(program) {
+    const asset = program.command("asset").description("Asset-specific information");
+    registerBookSimpleCommand(asset);
+}

package/dist/commands/completion.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerCompletionCommand(program: Command): void;

package/dist/commands/completion.js

@@ -0,0 +1,161 @@
+import { getAvailableExchanges } from "../lib/exchange.js";
+/**
+ * Walk the Commander command tree to collect all command paths
+ */
+function collectCommandPaths(cmd, prefix = []) {
+    const paths = [];
+    for (const sub of cmd.commands) {
+        const current = [...prefix, sub.name()];
+        paths.push(current);
+        paths.push(...collectCommandPaths(sub, current));
+    }
+    return paths;
+}
+function generateBashCompletion(program) {
+    const paths = collectCommandPaths(program);
+    const exchanges = getAvailableExchanges();
+    // Build subcommand map: "perps" -> ["account", "markets", ...], "perps account" -> ["ls", "add", ...]
+    const subcommandMap = new Map();
+    subcommandMap.set("perps", new Set(program.commands.map((c) => c.name())));
+    for (const path of paths) {
+        const key = ["perps", ...path.slice(0, -1)].join(" ");
+        const child = path[path.length - 1];
+        if (!subcommandMap.has(key))
+            subcommandMap.set(key, new Set());
+        subcommandMap.get(key).add(child);
+    }
+    const cases = Array.from(subcommandMap.entries())
+        .map(([key, children]) => {
+        const words = Array.from(children).sort().join(" ");
+        return `    "${key}") COMPREPLY=( $(compgen -W "${words}" -- "\${cur}") ) ;;`;
+    })
+        .join("\n");
+    return `# bash completion for perps
+# Add to ~/.bashrc:  eval "$(perps completion bash)"
+_perps_completions() {
+  local cur prev words
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  # Global flags
+  if [[ "\${cur}" == -* ]]; then
+    COMPREPLY=( $(compgen -W "--json --human --no-banner --testnet --mainnet --exchange --help --version" -- "\${cur}") )
+    return
+  fi
+
+  # Exchange names for --exchange / -e
+  if [[ "\${prev}" == "--exchange" || "\${prev}" == "-e" ]]; then
+    COMPREPLY=( $(compgen -W "${exchanges.join(" ")}" -- "\${cur}") )
+    return
+  fi
+
+  # Subcommands
+  local cmd_path="\${COMP_WORDS[*]:0:COMP_CWORD}"
+  case "\${cmd_path}" in
+${cases}
+  esac
+}
+complete -F _perps_completions perps
+`;
+}
+function generateZshCompletion(program) {
+    const paths = collectCommandPaths(program);
+    const exchanges = getAvailableExchanges();
+    const subcommandMap = new Map();
+    subcommandMap.set("perps", new Set(program.commands.map((c) => c.name())));
+    for (const path of paths) {
+        const key = ["perps", ...path.slice(0, -1)].join(" ");
+        const child = path[path.length - 1];
+        if (!subcommandMap.has(key))
+            subcommandMap.set(key, new Set());
+        subcommandMap.get(key).add(child);
+    }
+    const cases = Array.from(subcommandMap.entries())
+        .map(([key, children]) => {
+        const words = Array.from(children).sort().join(" ");
+        return `    ${key}) compadd ${words} ;;`;
+    })
+        .join("\n");
+    return `# zsh completion for perps
+# Add to ~/.zshrc:  eval "$(perps completion zsh)"
+_perps() {
+  local -a exchanges=(${exchanges.join(" ")})
+
+  # Global flags
+  if [[ "\${words[\${CURRENT}]}" == -* ]]; then
+    compadd -- --json --human --no-banner --testnet --mainnet --exchange --help --version
+    return
+  fi
+
+  # Exchange names for --exchange / -e
+  if [[ "\${words[\${CURRENT}-1]}" == "--exchange" || "\${words[\${CURRENT}-1]}" == "-e" ]]; then
+    compadd -- \${exchanges[@]}
+    return
+  fi
+
+  # Subcommands
+  local cmd_path="\${words[1,\${CURRENT}-1]}"
+  case "\${cmd_path}" in
+${cases}
+  esac
+}
+compdef _perps perps
+`;
+}
+function generateFishCompletion(program) {
+    const paths = collectCommandPaths(program);
+    const exchanges = getAvailableExchanges();
+    const lines = [
+        "# fish completion for perps",
+        '# Save to ~/.config/fish/completions/perps.fish  or run:  perps completion fish | source',
+        "",
+        "# Global flags",
+        "complete -c perps -l json -d 'Output in JSON format'",
+        "complete -c perps -l human -d 'Enable human-first output UX'",
+        "complete -c perps -l no-banner -d 'Disable session header'",
+        "complete -c perps -l testnet -d 'Force testnet network'",
+        "complete -c perps -l mainnet -d 'Force mainnet network'",
+        `complete -c perps -s e -l exchange -xa '${exchanges.join(" ")}' -d 'Exchange to use'`,
+        "",
+    ];
+    // Top-level subcommands
+    for (const cmd of program.commands) {
+        const desc = cmd.description() || cmd.name();
+        lines.push(`complete -c perps -n '__fish_use_subcommand' -a '${cmd.name()}' -d '${desc.replace(/'/g, "\\'")}'`);
+    }
+    // Nested subcommands
+    for (const path of paths) {
+        if (path.length < 2)
+            continue;
+        const parent = path.slice(0, -1);
+        const child = path[path.length - 1];
+        const condition = parent
+            .map((p, _i) => `__fish_seen_subcommand_from ${p}`)
+            .join("; and ");
+        lines.push(`complete -c perps -n '${condition}' -a '${child}'`);
+    }
+    return lines.join("\n") + "\n";
+}
+export function registerCompletionCommand(program) {
+    program
+        .command("completion")
+        .description("Generate shell completion scripts")
+        .argument("[shell]", "Shell type: bash, zsh, or fish", "bash")
+        .action((shell) => {
+        switch (shell.toLowerCase()) {
+            case "bash":
+                console.log(generateBashCompletion(program));
+                break;
+            case "zsh":
+                console.log(generateZshCompletion(program));
+                break;
+            case "fish":
+                console.log(generateFishCompletion(program));
+                break;
+            default:
+                console.error(`Unknown shell: ${shell}. Supported: bash, zsh, fish`);
+                process.exit(1);
+        }
+    });
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Config commands for managing settings
+ */
+import { Command } from "commander";
+export declare function registerConfigCommands(program: Command): void;

package/dist/commands/config/index.js

@@ -0,0 +1,109 @@
+/**
+ * Config commands for managing settings
+ */
+import { getOutputOptions } from "../../cli/program.js";
+import { output, outputSuccess, outputError } from "../../cli/output.js";
+import { getSetting, setSetting, getAllSettings, resetSettings } from "../../lib/settings.js";
+import { getAvailableExchanges, isExchangeSupported } from "../../lib/exchange.js";
+const VALID_SETTING_KEYS = ["defaultExchange", "testnetByDefault"];
+function isConfigKey(key) {
+    return VALID_SETTING_KEYS.includes(key);
+}
+export function registerConfigCommands(program) {
+    const config = program
+        .command("config")
+        .description("Manage CLI configuration");
+    // Show all settings
+    config
+        .command("show")
+        .description("Show current configuration")
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        const settings = getAllSettings();
+        if (outputOpts.json) {
+            output(settings, outputOpts);
+        }
+        else {
+            console.log("\nCurrent Configuration:\n");
+            console.log(`  Default Exchange: ${settings.defaultExchange}`);
+            console.log(`  Testnet Fallback: ${settings.testnetByDefault}`);
+            console.log("  Network Rules:    data=mainnet, execution=testnet (unless overridden)");
+            console.log(`\nAvailable Exchanges: ${getAvailableExchanges().join(", ")}`);
+            console.log("");
+        }
+    });
+    // Get a specific setting
+    config
+        .command("get <key>")
+        .description("Get a configuration value")
+        .action(function (key) {
+        const outputOpts = getOutputOptions(this);
+        if (!isConfigKey(key)) {
+            outputError(`Unknown setting: ${key}`);
+            console.error(`Valid settings: ${VALID_SETTING_KEYS.join(", ")}`);
+            process.exit(1);
+        }
+        const value = getSetting(key);
+        if (outputOpts.json) {
+            output({ [key]: value }, outputOpts);
+        }
+        else {
+            console.log(value);
+        }
+    });
+    // Set a specific setting
+    config
+        .command("set <key> <value>")
+        .description("Set a configuration value")
+        .action(function (key, value) {
+        const outputOpts = getOutputOptions(this);
+        // Validate key
+        if (!isConfigKey(key)) {
+            outputError(`Unknown setting: ${key}`);
+            console.error(`Valid settings: ${VALID_SETTING_KEYS.join(", ")}`);
+            process.exit(1);
+        }
+        if (key === "defaultExchange") {
+            if (!isExchangeSupported(value)) {
+                outputError(`Unknown exchange: ${value}`);
+                console.error(`Available exchanges: ${getAvailableExchanges().join(", ")}`);
+                process.exit(1);
+            }
+            const finalValue = value.toLowerCase();
+            setSetting(key, finalValue);
+            if (outputOpts.json) {
+                output({ [key]: finalValue, success: true }, outputOpts);
+            }
+            else {
+                outputSuccess(`Set ${key} = ${finalValue}`);
+            }
+            return;
+        }
+        if (!["true", "false"].includes(value.toLowerCase())) {
+            outputError("Value must be 'true' or 'false'");
+            process.exit(1);
+        }
+        const finalValue = value.toLowerCase() === "true";
+        setSetting(key, finalValue);
+        if (outputOpts.json) {
+            output({ [key]: finalValue, success: true }, outputOpts);
+        }
+        else {
+            outputSuccess(`Set ${key} = ${finalValue}`);
+        }
+    });
+    // Reset all settings
+    config
+        .command("reset")
+        .description("Reset all settings to defaults")
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        resetSettings();
+        if (outputOpts.json) {
+            output({ success: true, message: "Settings reset to defaults" }, outputOpts);
+        }
+        else {
+            outputSuccess("Settings reset to defaults");
+        }
+    });
+}

package/dist/commands/data/index.d.ts

@@ -0,0 +1,31 @@
+import type { Command } from "commander";
+export type JsonObject = Record<string, unknown>;
+type DynamicClient = Record<string, unknown> & {
+    close?: () => Promise<unknown> | unknown;
+    setSandboxMode?: (enabled: boolean) => void;
+};
+interface CcxtFuturesOperationOptions {
+    symbol?: string;
+    symbols?: string[];
+    id?: string;
+    side?: string;
+    orderType?: string;
+    amount?: number;
+    price?: number;
+    since?: number;
+    limit?: number;
+    leverage?: number;
+    marginMode?: string;
+    positionMode?: string;
+    code?: string;
+    from?: string;
+    to?: string;
+    params: JsonObject;
+    rawMethod?: string;
+    rawArgs: unknown[];
+}
+export declare function parseJsonArray(raw: string): unknown[];
+export declare function parseJsonObject(raw: string, label?: string): JsonObject;
+export declare function executeCcxtFuturesOperation(instance: DynamicClient, operationRaw: string, input: CcxtFuturesOperationOptions): Promise<unknown>;
+export declare function registerDataCommands(program: Command): void;
+export {};