perp-cli 0.9.8 → 0.12.0

package/dist/commands/gap.js

@@ -1,305 +0,0 @@
-import chalk from "chalk";
-import { printJson, jsonOk } from "../utils.js";
-import { fetchPacificaPricesRaw, parsePacificaRaw, fetchHyperliquidAllMidsRaw, fetchLighterOrderBookDetailsRaw, } from "../shared-api.js";
-async function fetchAllPrices() {
-    const [pacRes, hlRes, ltRes] = await Promise.all([
-        fetchPacificaPricesRaw(),
-        fetchHyperliquidAllMidsRaw(),
-        fetchLighterOrderBookDetailsRaw(),
-    ]);
-    const { prices: pacPrices } = parsePacificaRaw(pacRes);
-    const hlPrices = new Map();
-    if (hlRes && typeof hlRes === "object" && !Array.isArray(hlRes)) {
-        for (const [symbol, price] of Object.entries(hlRes)) {
-            const p = Number(price);
-            if (p > 0)
-                hlPrices.set(symbol, p);
-        }
-    }
-    const ltPrices = new Map();
-    if (ltRes) {
-        const details = (ltRes.order_book_details ?? []);
-        for (const m of details) {
-            const sym = String(m.symbol ?? "").replace(/_USDC$/, "");
-            const price = Number(m.last_trade_price ?? m.mark_price ?? 0);
-            if (sym && price > 0)
-                ltPrices.set(sym, price);
-        }
-    }
-    const allSymbols = new Set([...pacPrices.keys(), ...hlPrices.keys(), ...ltPrices.keys()]);
-    const snapshots = [];
-    for (const sym of allSymbols) {
-        const pac = pacPrices.get(sym) ?? null;
-        const hl = hlPrices.get(sym) ?? null;
-        const lt = ltPrices.get(sym) ?? null;
-        // Need at least 2 exchanges
-        const available = [];
-        if (pac !== null)
-            available.push({ ex: "PAC", price: pac });
-        if (hl !== null)
-            available.push({ ex: "HL", price: hl });
-        if (lt !== null)
-            available.push({ ex: "LT", price: lt });
-        if (available.length < 2)
-            continue;
-        available.sort((a, b) => a.price - b.price);
-        const cheapest = available[0];
-        const expensive = available[available.length - 1];
-        const maxGap = expensive.price - cheapest.price;
-        const mid = (cheapest.price + expensive.price) / 2;
-        const maxGapPct = mid > 0 ? (maxGap / mid) * 100 : 0;
-        snapshots.push({
-            symbol: sym,
-            pacPrice: pac,
-            hlPrice: hl,
-            ltPrice: lt,
-            maxGap,
-            maxGapPct,
-            cheapest: cheapest.ex,
-            expensive: expensive.ex,
-        });
-    }
-    return snapshots.sort((a, b) => b.maxGapPct - a.maxGapPct);
-}
-function formatPrice(p) {
-    if (p >= 1000)
-        return p.toFixed(2);
-    if (p >= 1)
-        return p.toFixed(4);
-    return p.toFixed(6);
-}
-function printGapTable(snapshots, minGap) {
-    const filtered = snapshots.filter((s) => s.maxGapPct >= minGap);
-    if (filtered.length === 0) {
-        console.log(chalk.gray(`\n  No gaps above ${minGap}%\n`));
-        return;
-    }
-    console.log(chalk.cyan.bold("\n  Symbol      Pacifica          Hyperliquid       Lighter           Gap($)      Gap(%)    Buy/Sell\n"));
-    for (const s of filtered) {
-        const gapColor = s.maxGapPct >= 0.5
-            ? chalk.red.bold
-            : s.maxGapPct >= 0.1
-                ? chalk.yellow
-                : chalk.gray;
-        const fmtP = (p) => p !== null ? `$${formatPrice(p).padEnd(16)}` : chalk.gray("-".padEnd(17));
-        console.log(`  ${chalk.white.bold(s.symbol.padEnd(10))} ` +
-            `${fmtP(s.pacPrice)} ` +
-            `${fmtP(s.hlPrice)} ` +
-            `${fmtP(s.ltPrice)} ` +
-            `${gapColor("$" + s.maxGap.toFixed(4).padEnd(10))} ` +
-            `${gapColor(s.maxGapPct.toFixed(4).padEnd(8) + "%")} ` +
-            `${chalk.green(s.cheapest)}→${chalk.red(s.expensive)}`);
-    }
-    const avgGap = filtered.reduce((sum, s) => sum + s.maxGapPct, 0) / filtered.length;
-    const top = filtered[0];
-    console.log(chalk.gray(`\n  ${filtered.length} pairs | Avg gap: ${avgGap.toFixed(4)}% | Max: ${top.symbol} ${top.maxGapPct.toFixed(4)}%\n`));
-}
-export function registerGapCommands(program, isJson) {
-    const gap = program
-        .command("gap")
-        .description("Cross-exchange price gap monitoring (Pacifica vs Hyperliquid vs Lighter)");
-    // ── gap show (default) ──
-    gap
-        .command("show", { isDefault: true })
-        .description("Show current price gaps between exchanges")
-        .option("--min <pct>", "Minimum gap % to display", "0.01")
-        .option("--symbol <sym>", "Filter by symbol (e.g. BTC, ETH)")
-        .option("--top <n>", "Show top N gaps only")
-        .action(async (opts) => {
-        const minGap = parseFloat(opts.min);
-        if (!isJson())
-            console.log(chalk.cyan("\n  Fetching prices from Pacifica, Hyperliquid & Lighter...\n"));
-        let snapshots = await fetchAllPrices();
-        if (opts.symbol) {
-            const sym = opts.symbol.toUpperCase();
-            snapshots = snapshots.filter((s) => s.symbol.includes(sym));
-        }
-        if (opts.top) {
-            snapshots = snapshots.slice(0, parseInt(opts.top));
-        }
-        if (isJson())
-            return printJson(jsonOk(snapshots.filter((s) => s.maxGapPct >= minGap)));
-        printGapTable(snapshots, minGap);
-    });
-    // ── gap watch ── (live monitoring)
-    gap
-        .command("watch")
-        .description("Live-monitor price gaps (auto-refresh)")
-        .option("--min <pct>", "Minimum gap % to display", "0.05")
-        .option("--interval <seconds>", "Refresh interval", "5")
-        .option("--symbol <sym>", "Filter by symbol")
-        .option("--beep", "Beep on gaps above 0.5%")
-        .action(async (opts) => {
-        const minGap = parseFloat(opts.min);
-        const intervalMs = parseInt(opts.interval) * 1000;
-        const beep = !!opts.beep;
-        if (!isJson()) {
-            console.log(chalk.cyan.bold("\n  Price Gap Monitor"));
-            console.log(`  Min gap:   ${minGap}%`);
-            console.log(`  Interval:  ${opts.interval}s`);
-            if (opts.symbol)
-                console.log(`  Symbol:    ${opts.symbol.toUpperCase()}`);
-            console.log(chalk.gray("  Ctrl+C to stop\n"));
-        }
-        const cycle = async () => {
-            try {
-                let snapshots = await fetchAllPrices();
-                if (opts.symbol) {
-                    const sym = opts.symbol.toUpperCase();
-                    snapshots = snapshots.filter((s) => s.symbol.includes(sym));
-                }
-                // Clear screen for live view
-                process.stdout.write("\x1B[2J\x1B[0f");
-                const now = new Date().toLocaleTimeString();
-                console.log(chalk.cyan.bold(`  Price Gap Monitor`) +
-                    chalk.gray(`  ${now}  (refresh: ${opts.interval}s)\n`));
-                printGapTable(snapshots, minGap);
-                // Alert on large gaps
-                const bigGaps = snapshots.filter((s) => s.maxGapPct >= 0.5);
-                if (bigGaps.length > 0) {
-                    console.log(chalk.red.bold(`  !! ${bigGaps.length} large gap(s): ` +
-                        bigGaps
-                            .map((s) => `${s.symbol}(${s.maxGapPct.toFixed(3)}%)`)
-                            .join(", ")));
-                    if (beep)
-                        process.stdout.write("\x07");
-                }
-            }
-            catch (err) {
-                console.error(chalk.gray(`  Error: ${err instanceof Error ? err.message : String(err)}`));
-            }
-        };
-        await cycle();
-        setInterval(cycle, intervalMs);
-        await new Promise(() => { }); // keep alive
-    });
-    // ── gap history ── (track gap over time for a symbol)
-    gap
-        .command("track")
-        .description("Track a symbol's gap over time and print stats")
-        .requiredOption("-s, --symbol <sym>", "Symbol to track (e.g. BTC)")
-        .option("--duration <minutes>", "How long to track (minutes)", "10")
-        .option("--interval <seconds>", "Sample interval", "10")
-        .action(async (opts) => {
-        const symbol = opts.symbol.toUpperCase();
-        const durationMs = parseInt(opts.duration) * 60 * 1000;
-        const intervalMs = parseInt(opts.interval) * 1000;
-        const endTime = Date.now() + durationMs;
-        const samples = [];
-        if (!isJson()) {
-            console.log(chalk.cyan.bold(`\n  Tracking ${symbol} price gap\n`));
-            console.log(`  Duration:  ${opts.duration} min`);
-            console.log(`  Interval:  ${opts.interval}s`);
-            console.log(chalk.gray("  Collecting samples...\n"));
-        }
-        const sample = async () => {
-            const snapshots = await fetchAllPrices();
-            const s = snapshots.find((x) => x.symbol === symbol);
-            if (!s) {
-                console.log(chalk.gray(`  ${new Date().toLocaleTimeString()} — ${symbol} not found on both exchanges`));
-                return;
-            }
-            samples.push({
-                time: new Date().toLocaleTimeString(),
-                gap: s.maxGap,
-                gapPct: s.maxGapPct,
-                direction: `${s.cheapest}→${s.expensive}`,
-            });
-            const gapColor = s.maxGapPct >= 0.1 ? chalk.yellow : chalk.gray;
-            const parts = [`PAC: ${s.pacPrice !== null ? "$" + formatPrice(s.pacPrice) : "-"}`];
-            parts.push(`HL: ${s.hlPrice !== null ? "$" + formatPrice(s.hlPrice) : "-"}`);
-            parts.push(`LT: ${s.ltPrice !== null ? "$" + formatPrice(s.ltPrice) : "-"}`);
-            console.log(`  ${chalk.white(s.symbol.padEnd(6))} ` +
-                `${parts.join("  ")}  ` +
-                `${gapColor(`${s.maxGapPct.toFixed(4)}%`)}  ${s.cheapest}→${s.expensive}`);
-        };
-        await sample();
-        const timer = setInterval(async () => {
-            if (Date.now() >= endTime) {
-                clearInterval(timer);
-                printTrackSummary(symbol, samples);
-                return;
-            }
-            await sample();
-        }, intervalMs);
-        await new Promise((resolve) => {
-            setTimeout(resolve, durationMs + 1000);
-        });
-    });
-    // ── gap alert ── (one-shot: notify when gap exceeds threshold)
-    gap
-        .command("alert")
-        .description("Wait until a symbol's gap exceeds a threshold, then exit")
-        .requiredOption("-s, --symbol <sym>", "Symbol to watch")
-        .requiredOption("--above <pct>", "Gap % threshold to trigger")
-        .option("--interval <seconds>", "Check interval", "5")
-        .action(async (opts) => {
-        const symbol = opts.symbol.toUpperCase();
-        const threshold = parseFloat(opts.above);
-        const intervalMs = parseInt(opts.interval) * 1000;
-        if (!isJson())
-            console.log(chalk.cyan(`\n  Waiting for ${symbol} gap > ${threshold}%...\n`));
-        const check = async () => {
-            const snapshots = await fetchAllPrices();
-            const s = snapshots.find((x) => x.symbol === symbol);
-            if (!s)
-                return false;
-            const now = new Date().toLocaleTimeString();
-            if (!isJson())
-                console.log(chalk.gray(`  ${now} ${symbol} gap: ${s.maxGapPct.toFixed(4)}%`));
-            if (s.maxGapPct >= threshold) {
-                if (isJson()) {
-                    printJson(jsonOk(s));
-                }
-                else {
-                    console.log(chalk.green.bold(`\n  TRIGGERED! ${symbol} gap: ${s.maxGapPct.toFixed(4)}% (> ${threshold}%)`));
-                    const lines = [];
-                    if (s.pacPrice !== null)
-                        lines.push(`  Pacifica:    $${formatPrice(s.pacPrice)}`);
-                    if (s.hlPrice !== null)
-                        lines.push(`  Hyperliquid: $${formatPrice(s.hlPrice)}`);
-                    if (s.ltPrice !== null)
-                        lines.push(`  Lighter:     $${formatPrice(s.ltPrice)}`);
-                    lines.push(`  Gap:         $${s.maxGap.toFixed(4)} (${s.cheapest}→${s.expensive})`);
-                    console.log(lines.join("\n") + "\n");
-                }
-                return true;
-            }
-            return false;
-        };
-        if (await check())
-            return;
-        await new Promise((resolve) => {
-            const timer = setInterval(async () => {
-                if (await check()) {
-                    clearInterval(timer);
-                    resolve();
-                }
-            }, intervalMs);
-        });
-    });
-}
-function printTrackSummary(symbol, samples) {
-    if (samples.length === 0) {
-        console.log(chalk.gray("\n  No samples collected.\n"));
-        return;
-    }
-    const gaps = samples.map((s) => s.gapPct);
-    const avg = gaps.reduce((a, b) => a + b, 0) / gaps.length;
-    const max = Math.max(...gaps);
-    const min = Math.min(...gaps);
-    const maxSample = samples[gaps.indexOf(max)];
-    // Count direction frequencies
-    const dirCounts = new Map();
-    for (const s of samples) {
-        dirCounts.set(s.direction, (dirCounts.get(s.direction) ?? 0) + 1);
-    }
-    console.log(chalk.cyan.bold(`\n  ${symbol} Gap Summary (${samples.length} samples)\n`));
-    console.log(`  Avg gap:    ${avg.toFixed(4)}%`);
-    console.log(`  Max gap:    ${max.toFixed(4)}% at ${maxSample.time}`);
-    console.log(`  Min gap:    ${min.toFixed(4)}%`);
-    for (const [dir, count] of [...dirCounts.entries()].sort((a, b) => b[1] - a[1])) {
-        console.log(`  ${dir.padEnd(10)} ${count} times (${((count / samples.length) * 100).toFixed(0)}%)`);
-    }
-    console.log();
-}

package/dist/commands/health.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare function registerHealthCommands(program: Command, isJson: () => boolean): void;

package/dist/commands/health.js

@@ -1,67 +0,0 @@
-import chalk from "chalk";
-import { printJson, jsonOk, makeTable } from "../utils.js";
-import { pingPacifica, pingHyperliquid, pingLighter } from "../shared-api.js";
-async function checkExchangeHealth(name, fn) {
-    const start = Date.now();
-    try {
-        await fn();
-        return { exchange: name, status: "ok", latency_ms: Date.now() - start };
-    }
-    catch (err) {
-        return {
-            exchange: name,
-            status: "down",
-            latency_ms: Date.now() - start,
-            error: err instanceof Error ? err.message : String(err),
-        };
-    }
-}
-export function registerHealthCommands(program, isJson) {
-    program
-        .command("health")
-        .description("Check exchange API connectivity and latency")
-        .action(async () => {
-        const [pacPing, hlPing, ltPing] = await Promise.all([
-            pingPacifica(),
-            pingHyperliquid(),
-            pingLighter(),
-        ]);
-        const toPingResult = (name, p) => ({
-            exchange: name,
-            status: p.ok ? "ok" : "down",
-            latency_ms: p.latencyMs,
-            error: p.ok ? undefined : `HTTP ${p.status}`,
-        });
-        const checks = [
-            toPingResult("pacifica", pacPing),
-            toPingResult("hyperliquid", hlPing),
-            toPingResult("lighter", ltPing),
-        ];
-        const allOk = checks.every(c => c.status === "ok");
-        if (isJson()) {
-            return printJson(jsonOk({ healthy: allOk, exchanges: checks }));
-        }
-        console.log(chalk.cyan.bold("\n  Exchange Health Check\n"));
-        const rows = checks.map(c => {
-            const statusIcon = c.status === "ok"
-                ? chalk.green("OK")
-                : c.status === "degraded"
-                    ? chalk.yellow("DEGRADED")
-                    : chalk.red("DOWN");
-            const latency = c.latency_ms < 500
-                ? chalk.green(`${c.latency_ms}ms`)
-                : c.latency_ms < 2000
-                    ? chalk.yellow(`${c.latency_ms}ms`)
-                    : chalk.red(`${c.latency_ms}ms`);
-            return [
-                chalk.white.bold(c.exchange),
-                statusIcon,
-                latency,
-                c.error ? chalk.red(c.error) : chalk.gray("-"),
-            ];
-        });
-        console.log(makeTable(["Exchange", "Status", "Latency", "Error"], rows));
-        const overall = allOk ? chalk.green("ALL HEALTHY") : chalk.red("ISSUES DETECTED");
-        console.log(`\n  Overall: ${overall}\n`);
-    });
-}

package/dist/commands/multileg.d.ts

@@ -1,16 +0,0 @@
-/**
- * Multi-leg order command.
- *
- * Executes multiple orders across exchanges simultaneously using Promise.allSettled.
- * Supports automatic rollback if one leg fails.
- *
- * Usage:
- *   perp multi "hl:ETH:buy:0.01" "pac:ETH:sell:0.01"
- *   perp multi "hl:BTC:buy:0.001" "lighter:BTC:sell:0.001" --smart
- *   perp multi "hl:ETH:buy:0.01" "pac:SOL:buy:1" "lighter:BTC:sell:0.0001"
- *
- * Leg format: exchange:symbol:side:size
- */
-import { Command } from "commander";
-import type { ExchangeAdapter } from "../exchanges/interface.js";
-export declare function registerMultilegCommands(program: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean): void;

package/dist/commands/multileg.js

@@ -1,174 +0,0 @@
-/**
- * Multi-leg order command.
- *
- * Executes multiple orders across exchanges simultaneously using Promise.allSettled.
- * Supports automatic rollback if one leg fails.
- *
- * Usage:
- *   perp multi "hl:ETH:buy:0.01" "pac:ETH:sell:0.01"
- *   perp multi "hl:BTC:buy:0.001" "lighter:BTC:sell:0.001" --smart
- *   perp multi "hl:ETH:buy:0.01" "pac:SOL:buy:1" "lighter:BTC:sell:0.0001"
- *
- * Leg format: exchange:symbol:side:size
- */
-import chalk from "chalk";
-import { printJson, jsonOk, jsonError, withJsonErrors } from "../utils.js";
-import { logExecution } from "../execution-log.js";
-import { smartOrder } from "../smart-order.js";
-function parseLeg(spec) {
-    const parts = spec.split(":");
-    if (parts.length !== 4) {
-        throw new Error(`Invalid leg format "${spec}" — expected exchange:symbol:side:size`);
-    }
-    const [exchange, symbol, side, size] = parts;
-    // Normalize exchange aliases
-    const exMap = {
-        hl: "hyperliquid", pac: "pacifica", lit: "lighter",
-        hyperliquid: "hyperliquid", pacifica: "pacifica", lighter: "lighter",
-    };
-    const normalizedExchange = exMap[exchange.toLowerCase()];
-    if (!normalizedExchange) {
-        throw new Error(`Unknown exchange "${exchange}" in leg spec`);
-    }
-    if (side !== "buy" && side !== "sell") {
-        throw new Error(`Invalid side "${side}" — must be "buy" or "sell"`);
-    }
-    if (isNaN(Number(size)) || Number(size) <= 0) {
-        throw new Error(`Invalid size "${size}" — must be a positive number`);
-    }
-    return { exchange: normalizedExchange, symbol: symbol.toUpperCase(), side, size };
-}
-export function registerMultilegCommands(program, getAdapterForExchange, isJson) {
-    program
-        .command("multi <legs...>")
-        .description("Execute multi-leg orders simultaneously (exchange:symbol:side:size)")
-        .option("--smart", "Use smart order (IOC limit + fallback) for each leg")
-        .option("--rollback", "Auto-rollback filled legs if any leg fails", true)
-        .option("--no-rollback", "Disable auto-rollback")
-        .option("--timeout <ms>", "Per-leg timeout in milliseconds", "30000")
-        .action(async (legSpecs, opts) => {
-        await withJsonErrors(isJson(), async () => {
-            // Parse legs
-            const legs = legSpecs.map(parseLeg);
-            if (legs.length < 2) {
-                const err = "Multi-leg requires at least 2 legs";
-                if (isJson()) {
-                    printJson(jsonError("INVALID_ARGS", err));
-                    return;
-                }
-                throw new Error(err);
-            }
-            if (!isJson()) {
-                console.log(chalk.cyan.bold("Multi-Leg Order\n"));
-                for (const l of legs) {
-                    const color = l.side === "buy" ? chalk.green : chalk.red;
-                    console.log(`  ${l.exchange.padEnd(14)} ${color(l.side.toUpperCase())} ${l.symbol} x ${l.size}`);
-                }
-                console.log();
-            }
-            // Get adapters (deduplicated)
-            const adapters = new Map();
-            for (const l of legs) {
-                if (!adapters.has(l.exchange)) {
-                    adapters.set(l.exchange, await getAdapterForExchange(l.exchange));
-                }
-            }
-            // Execute all legs simultaneously
-            const timeoutMs = parseInt(opts.timeout);
-            const results = await Promise.allSettled(legs.map(async (leg) => {
-                const adapter = adapters.get(leg.exchange);
-                const orderPromise = opts.smart
-                    ? smartOrder(adapter, leg.symbol, leg.side, leg.size).then(r => r.result)
-                    : adapter.marketOrder(leg.symbol, leg.side, leg.size);
-                // Apply timeout
-                const result = await Promise.race([
-                    orderPromise,
-                    new Promise((_, reject) => setTimeout(() => reject(new Error("Leg timeout")), timeoutMs)),
-                ]);
-                // Log execution
-                logExecution({
-                    type: "multi_leg",
-                    exchange: leg.exchange,
-                    symbol: leg.symbol,
-                    side: leg.side,
-                    size: leg.size,
-                    status: "success",
-                    dryRun: false,
-                    meta: { result, smart: opts.smart },
-                });
-                return { leg, status: "filled", result };
-            }));
-            // Process results
-            const legResults = results.map((r, i) => {
-                if (r.status === "fulfilled")
-                    return r.value;
-                return {
-                    leg: legs[i],
-                    status: "failed",
-                    error: r.reason instanceof Error ? r.reason.message : String(r.reason),
-                };
-            });
-            const filled = legResults.filter(r => r.status === "filled");
-            const failed = legResults.filter(r => r.status === "failed");
-            // Rollback if partial fill and rollback enabled
-            if (failed.length > 0 && filled.length > 0 && opts.rollback) {
-                if (!isJson()) {
-                    console.log(chalk.yellow(`\n  ${failed.length} leg(s) failed — rolling back ${filled.length} filled leg(s)...\n`));
-                }
-                for (const fr of filled) {
-                    const adapter = adapters.get(fr.leg.exchange);
-                    const reverseSide = fr.leg.side === "buy" ? "sell" : "buy";
-                    try {
-                        await adapter.marketOrder(fr.leg.symbol, reverseSide, fr.leg.size);
-                        fr.status = "rolled_back";
-                        logExecution({
-                            type: "multi_leg_rollback",
-                            exchange: fr.leg.exchange,
-                            symbol: fr.leg.symbol,
-                            side: reverseSide,
-                            size: fr.leg.size,
-                            status: "success",
-                            dryRun: false,
-                        });
-                        if (!isJson()) {
-                            console.log(chalk.gray(`  Rolled back: ${fr.leg.exchange} ${reverseSide} ${fr.leg.symbol} x ${fr.leg.size}`));
-                        }
-                    }
-                    catch (err) {
-                        if (!isJson()) {
-                            console.log(chalk.red(`  Rollback failed: ${fr.leg.exchange} ${fr.leg.symbol} — ${err instanceof Error ? err.message : err}`));
-                        }
-                    }
-                }
-            }
-            if (isJson()) {
-                printJson(jsonOk({
-                    legs: legResults.map(r => ({
-                        exchange: r.leg.exchange,
-                        symbol: r.leg.symbol,
-                        side: r.leg.side,
-                        size: r.leg.size,
-                        status: r.status,
-                        error: r.error,
-                    })),
-                    summary: {
-                        total: legs.length,
-                        filled: legResults.filter(r => r.status === "filled").length,
-                        failed: failed.length,
-                        rolledBack: legResults.filter(r => r.status === "rolled_back").length,
-                    },
-                }));
-            }
-            else {
-                console.log(chalk.cyan.bold("\nResults:\n"));
-                for (const r of legResults) {
-                    const icon = r.status === "filled" ? chalk.green("OK") :
-                        r.status === "rolled_back" ? chalk.yellow("ROLLBACK") :
-                            chalk.red("FAIL");
-                    console.log(`  ${icon} ${r.leg.exchange.padEnd(14)} ${r.leg.side} ${r.leg.symbol} x ${r.leg.size}${r.error ? ` — ${r.error}` : ""}`);
-                }
-                console.log(`\n  Total: ${legs.length}  Filled: ${filled.length}  Failed: ${failed.length}  Rolled back: ${legResults.filter(r => r.status === "rolled_back").length}`);
-            }
-        });
-    });
-}

package/dist/commands/pnl.d.ts

@@ -1,12 +0,0 @@
-/**
- * PnL Tracker CLI commands.
- *
- * perp pnl snapshot  — take one-time equity snapshots across exchanges
- * perp pnl track     — continuous equity tracking (foreground)
- * perp pnl daily     — daily PnL breakdown table
- * perp pnl weekly    — weekly PnL breakdown table
- * perp pnl summary   — performance summary (Sharpe, drawdown, win rate)
- */
-import { Command } from "commander";
-import type { ExchangeAdapter } from "../exchanges/interface.js";
-export declare function registerPnlCommands(program: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean): void;