perp-cli 0.4.2 → 0.4.9

package/dist/commands/history.d.ts

@@ -1,2 +1,3 @@
 import { Command } from "commander";
-export declare function registerHistoryCommands(program: Command, isJson: () => boolean): void;
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export declare function registerHistoryCommands(program: Command, isJson: () => boolean, getAdapterForExchange?: (exchange: string) => Promise<ExchangeAdapter>): void;

package/dist/commands/history.js

@@ -1,8 +1,21 @@
 import chalk from "chalk";
-import { printJson, jsonOk, makeTable, formatUsd, formatPnl, withJsonErrors } from "../utils.js";
+import { printJson, jsonOk, jsonError, makeTable, formatUsd, formatPnl, withJsonErrors } from "../utils.js";
 import { readExecutionLog, getExecutionStats, pruneExecutionLog } from "../execution-log.js";
 import { readPositionHistory, getPositionStats } from "../position-history.js";
-export function registerHistoryCommands(program, isJson) {
+import { saveEquitySnapshot, readEquityHistory, computePnlMetrics, computeDailyPnl, aggregateWeekly, } from "../equity-tracker.js";
+const EXCHANGES = ["pacifica", "hyperliquid", "lighter"];
+function parseSince(since) {
+    if (!since)
+        return undefined;
+    const match = since.match(/^(\d+)(h|d|w)$/);
+    if (match) {
+        const [, num, unit] = match;
+        const ms = { h: 3600000, d: 86400000, w: 604800000 }[unit] ?? 86400000;
+        return new Date(Date.now() - parseInt(num) * ms).toISOString();
+    }
+    return since;
+}
+export function registerHistoryCommands(program, isJson, getAdapterForExchange) {
     const history = program.command("history").description("Execution log & audit trail");
     // ── history list ──
     history
@@ -66,10 +79,10 @@ export function registerHistoryCommands(program, isJson) {
             console.log(makeTable(["Time", "Exchange", "Type", "Symbol", "Side", "Size", "Notional", "Status", ""], rows));
         });
     });
-    // ── history stats ──
-    history
+    // ── history stats (hidden alias for 'history summary') ──
+    const statsCmd = history
         .command("stats")
-        .description("Execution statistics summary")
+        .description("Use 'history summary'")
         .option("--since <date>", "Stats since date (ISO or relative: 24h, 7d, 30d)")
         .action(async (opts) => {
         await withJsonErrors(isJson(), async () => {
@@ -110,6 +123,7 @@ export function registerHistoryCommands(program, isJson) {
             console.log();
         });
     });
+    statsCmd._hidden = true;
     // ── history positions ──
     history
         .command("positions")
@@ -232,4 +246,493 @@ export function registerHistoryCommands(program, isJson) {
         }
         console.log(chalk.green(`\n  Pruned ${pruned} old records (keeping last ${opts.keepDays} days).\n`));
     });
+    // ── Analytics subcommands (merged from analytics.ts) ──
+    if (getAdapterForExchange) {
+        registerAnalyticsSubcommands(history, getAdapterForExchange, isJson);
+        // Keep deprecated top-level 'analytics' alias (hidden from help)
+        const analytics = program.command("analytics").description("Use 'perp history'");
+        analytics._hidden = true;
+        registerAnalyticsSubcommands(analytics, getAdapterForExchange, isJson);
+    }
+    // ── PnL subcommands (merged from pnl.ts) ──
+    if (getAdapterForExchange) {
+        registerPnlSubcommands(history, getAdapterForExchange, isJson);
+        // Deprecated top-level pnl alias
+        const pnlAlias = program.command("pnl").description("Use 'perp history perf --period daily|weekly|summary'");
+        pnlAlias._hidden = true;
+        if (getAdapterForExchange)
+            registerPnlSubcommands(pnlAlias, getAdapterForExchange, isJson);
+    }
+}
+function registerAnalyticsSubcommands(parent, getAdapterForExchange, isJson) {
+    // ── analytics summary ──
+    parent
+        .command("summary")
+        .description("Execution log summary statistics")
+        .option("--since <period>", "Period: 24h, 7d, 30d, or ISO date")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const since = parseSince(opts.since);
+            const stats = getExecutionStats(since);
+            const records = readExecutionLog({ since });
+            // Calculate volume
+            let totalVolume = 0;
+            for (const r of records) {
+                if (r.notional)
+                    totalVolume += r.notional;
+                else if (r.price && r.size)
+                    totalVolume += Number(r.price) * Number(r.size);
+            }
+            const result = { ...stats, totalVolume, period: opts.since ?? "all time" };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.cyan.bold(`\n  Trading Summary ${opts.since ? `(${opts.since})` : "(all time)"}\n`));
+            console.log(`  Total Trades:     ${stats.totalTrades}`);
+            console.log(`  Success Rate:     ${stats.successRate.toFixed(1)}%`);
+            console.log(`  Total Volume:     $${formatUsd(totalVolume)}`);
+            if (Object.keys(stats.byExchange).length > 0) {
+                console.log(chalk.white.bold("\n  By Exchange:"));
+                for (const [ex, count] of Object.entries(stats.byExchange)) {
+                    console.log(`    ${ex.padEnd(14)} ${count} trades`);
+                }
+            }
+            if (Object.keys(stats.byType).length > 0) {
+                console.log(chalk.white.bold("\n  By Type:"));
+                for (const [type, count] of Object.entries(stats.byType)) {
+                    console.log(`    ${type.replace(/_/g, " ").padEnd(14)} ${count}`);
+                }
+            }
+            if (stats.recentErrors.length > 0) {
+                console.log(chalk.red.bold("\n  Recent Errors:"));
+                for (const err of stats.recentErrors) {
+                    console.log(`    ${chalk.red(err)}`);
+                }
+            }
+            console.log();
+        });
+    });
+    // ── analytics pnl ──
+    parent
+        .command("pnl")
+        .description("Realized P&L from exchange trade history (volume & fees by symbol/exchange)")
+        .option("-e, --exchange <exchanges>", "Comma-separated exchanges")
+        .option("--since <period>", "Period: 24h, 7d, 30d")
+        .option("-n, --limit <n>", "Trade history limit per exchange", "100")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const exchanges = opts.exchange
+                ? opts.exchange.split(",").map(e => e.trim())
+                : [...EXCHANGES];
+            const limit = parseInt(opts.limit);
+            const sinceMs = opts.since ? new Date(parseSince(opts.since)).getTime() : 0;
+            const allTrades = [];
+            await Promise.allSettled(exchanges.map(async (ex) => {
+                try {
+                    const adapter = await getAdapterForExchange(ex);
+                    const trades = await adapter.getTradeHistory(limit);
+                    for (const t of trades) {
+                        if (sinceMs && t.time < sinceMs)
+                            continue;
+                        allTrades.push({
+                            exchange: ex,
+                            symbol: t.symbol,
+                            side: t.side,
+                            price: Number(t.price),
+                            size: Number(t.size),
+                            fee: Number(t.fee),
+                            time: t.time,
+                        });
+                    }
+                }
+                catch { /* skip unavailable exchanges */ }
+            }));
+            // Aggregate by symbol
+            const bySymbol = new Map();
+            const byExchange = new Map();
+            let totalVolume = 0;
+            let totalFees = 0;
+            for (const t of allTrades) {
+                const notional = t.price * t.size;
+                totalVolume += notional;
+                totalFees += t.fee;
+                const sym = bySymbol.get(t.symbol) ?? { volume: 0, fees: 0, trades: 0 };
+                sym.volume += notional;
+                sym.fees += t.fee;
+                sym.trades++;
+                bySymbol.set(t.symbol, sym);
+                const ex = byExchange.get(t.exchange) ?? { volume: 0, fees: 0, trades: 0 };
+                ex.volume += notional;
+                ex.fees += t.fee;
+                ex.trades++;
+                byExchange.set(t.exchange, ex);
+            }
+            const result = {
+                totalTrades: allTrades.length,
+                totalVolume,
+                totalFees,
+                netAfterFees: -totalFees, // realized PnL would need entry/exit matching; fees are definite cost
+                bySymbol: Object.fromEntries(bySymbol),
+                byExchange: Object.fromEntries(byExchange),
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.cyan.bold(`\n  Realized Trading P&L ${opts.since ? `(${opts.since})` : ""}\n`));
+            console.log(`  Total Trades:    ${allTrades.length}`);
+            console.log(`  Total Volume:    $${formatUsd(totalVolume)}`);
+            console.log(`  Total Fees:      ${chalk.red(`-$${formatUsd(totalFees)}`)}`);
+            if (bySymbol.size > 0) {
+                console.log(chalk.white.bold("\n  By Symbol:"));
+                const symRows = [...bySymbol.entries()]
+                    .sort((a, b) => b[1].volume - a[1].volume)
+                    .map(([sym, d]) => [
+                    chalk.white.bold(sym),
+                    String(d.trades),
+                    `$${formatUsd(d.volume)}`,
+                    chalk.red(`-$${formatUsd(d.fees)}`),
+                ]);
+                console.log(makeTable(["Symbol", "Trades", "Volume", "Fees"], symRows));
+            }
+            if (byExchange.size > 0) {
+                console.log(chalk.white.bold("  By Exchange:"));
+                const exRows = [...byExchange.entries()].map(([ex, d]) => [
+                    chalk.white.bold(ex),
+                    String(d.trades),
+                    `$${formatUsd(d.volume)}`,
+                    chalk.red(`-$${formatUsd(d.fees)}`),
+                ]);
+                console.log(makeTable(["Exchange", "Trades", "Volume", "Fees"], exRows));
+            }
+        });
+    });
+    // ── analytics funding ──
+    parent
+        .command("funding")
+        .description("Funding payment aggregation across exchanges (net by symbol/exchange)")
+        .option("-e, --exchange <exchanges>", "Comma-separated exchanges")
+        .option("-s, --symbol <symbol>", "Filter by symbol")
+        .option("-n, --limit <n>", "Funding history limit per exchange", "50")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const exchanges = opts.exchange
+                ? opts.exchange.split(",").map(e => e.trim())
+                : [...EXCHANGES];
+            const allFunding = [];
+            await Promise.allSettled(exchanges.map(async (ex) => {
+                try {
+                    const adapter = await getAdapterForExchange(ex);
+                    const payments = await adapter.getFundingPayments(parseInt(opts.limit));
+                    for (const p of payments) {
+                        if (opts.symbol && !p.symbol.toUpperCase().includes(opts.symbol.toUpperCase()))
+                            continue;
+                        allFunding.push({
+                            exchange: ex,
+                            symbol: p.symbol,
+                            payment: Number(p.payment),
+                            time: p.time,
+                        });
+                    }
+                }
+                catch { /* skip */ }
+            }));
+            // Aggregate
+            const bySymbol = new Map();
+            const byExchange = new Map();
+            let totalFunding = 0;
+            for (const f of allFunding) {
+                totalFunding += f.payment;
+                bySymbol.set(f.symbol, (bySymbol.get(f.symbol) ?? 0) + f.payment);
+                byExchange.set(f.exchange, (byExchange.get(f.exchange) ?? 0) + f.payment);
+            }
+            const result = {
+                totalPayments: allFunding.length,
+                totalFunding,
+                bySymbol: Object.fromEntries(bySymbol),
+                byExchange: Object.fromEntries(byExchange),
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.cyan.bold("\n  Funding Payment Summary\n"));
+            console.log(`  Total Payments:  ${allFunding.length}`);
+            console.log(`  Net Funding:     ${formatPnl(totalFunding)}`);
+            if (bySymbol.size > 0) {
+                console.log(chalk.white.bold("\n  By Symbol:"));
+                const rows = [...bySymbol.entries()]
+                    .sort((a, b) => b[1] - a[1])
+                    .map(([sym, amt]) => [chalk.white.bold(sym), formatPnl(amt)]);
+                console.log(makeTable(["Symbol", "Net Funding"], rows));
+            }
+            if (byExchange.size > 0) {
+                console.log(chalk.white.bold("  By Exchange:"));
+                const rows = [...byExchange.entries()]
+                    .map(([ex, amt]) => [chalk.white.bold(ex), formatPnl(amt)]);
+                console.log(makeTable(["Exchange", "Net Funding"], rows));
+            }
+        });
+    });
+    // ── analytics report ──
+    parent
+        .command("report")
+        .description("Full performance report (summary + pnl + funding)")
+        .option("-e, --exchange <exchanges>", "Comma-separated exchanges")
+        .option("--since <period>", "Period: 24h, 7d, 30d")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const since = parseSince(opts.since);
+            const stats = getExecutionStats(since);
+            const records = readExecutionLog({ since });
+            const exchanges = opts.exchange
+                ? opts.exchange.split(",").map(e => e.trim())
+                : [...EXCHANGES];
+            // Volume from log
+            let logVolume = 0;
+            for (const r of records) {
+                if (r.notional)
+                    logVolume += r.notional;
+            }
+            // Fetch live data from exchanges
+            let totalFunding = 0;
+            let totalFees = 0;
+            let totalEquity = 0;
+            let totalUPnl = 0;
+            const symbolSet = new Set();
+            await Promise.allSettled(exchanges.map(async (ex) => {
+                try {
+                    const adapter = await getAdapterForExchange(ex);
+                    const [balance, trades, funding] = await Promise.all([
+                        adapter.getBalance(),
+                        adapter.getTradeHistory(50).catch(() => []),
+                        adapter.getFundingPayments(50).catch(() => []),
+                    ]);
+                    totalEquity += Number(balance.equity);
+                    totalUPnl += Number(balance.unrealizedPnl);
+                    for (const t of trades) {
+                        totalFees += Number(t.fee);
+                        symbolSet.add(t.symbol);
+                    }
+                    for (const f of funding)
+                        totalFunding += Number(f.payment);
+                }
+                catch { /* skip */ }
+            }));
+            const report = {
+                period: opts.since ?? "all time",
+                execution: {
+                    totalTrades: stats.totalTrades,
+                    successRate: stats.successRate,
+                    volume: logVolume,
+                    byExchange: stats.byExchange,
+                    byType: stats.byType,
+                },
+                portfolio: {
+                    totalEquity,
+                    unrealizedPnl: totalUPnl,
+                },
+                costs: {
+                    totalFees,
+                    totalFunding,
+                    netFunding: totalFunding,
+                },
+                insights: {
+                    uniqueSymbols: symbolSet.size,
+                    mostActiveExchange: Object.entries(stats.byExchange).sort((a, b) => b[1] - a[1])[0]?.[0] ?? "none",
+                    avgTradesPerDay: stats.totalTrades > 0
+                        ? (stats.totalTrades / Math.max(1, (Date.now() - new Date(records[records.length - 1]?.timestamp ?? Date.now()).getTime()) / 86400000)).toFixed(1)
+                        : "0",
+                },
+            };
+            if (isJson())
+                return printJson(jsonOk(report));
+            console.log(chalk.cyan.bold(`\n  Performance Report ${opts.since ? `(${opts.since})` : ""}\n`));
+            console.log(chalk.white.bold("  Execution"));
+            console.log(`    Trades:          ${stats.totalTrades} (${stats.successRate.toFixed(0)}% success)`);
+            console.log(`    Volume:          $${formatUsd(logVolume)}`);
+            console.log(`    Symbols Traded:  ${symbolSet.size}`);
+            console.log(`    Avg/Day:         ${report.insights.avgTradesPerDay}`);
+            console.log(chalk.white.bold("\n  Portfolio"));
+            console.log(`    Total Equity:    $${formatUsd(totalEquity)}`);
+            console.log(`    Unrealized PnL:  ${formatPnl(totalUPnl)}`);
+            console.log(chalk.white.bold("\n  Costs & Income"));
+            console.log(`    Trading Fees:    ${chalk.red(`-$${formatUsd(totalFees)}`)}`);
+            console.log(`    Funding Income:  ${formatPnl(totalFunding)}`);
+            console.log(`    Net:             ${formatPnl(totalFunding - totalFees)}`);
+            console.log();
+        });
+    });
+}
+function parseSinceDate(since) {
+    if (!since)
+        return undefined;
+    const match = since.match(/^(\d+)(h|d|w)$/);
+    if (match) {
+        const [, num, unit] = match;
+        const ms = { h: 3600000, d: 86400000, w: 604800000 }[unit] ?? 86400000;
+        return new Date(Date.now() - parseInt(num) * ms);
+    }
+    return new Date(since);
+}
+/** Take equity snapshot for given adapters. */
+async function takeSnapshot(getAdapterForExchange, exchanges) {
+    const ts = new Date().toISOString();
+    const snaps = [];
+    const results = await Promise.allSettled(exchanges.map(async (ex) => {
+        const adapter = await getAdapterForExchange(ex);
+        const [balance, positions] = await Promise.all([
+            adapter.getBalance(),
+            adapter.getPositions(),
+        ]);
+        const snap = {
+            ts,
+            exchange: ex,
+            equity: Number(balance.equity),
+            available: Number(balance.available),
+            marginUsed: Number(balance.marginUsed),
+            unrealizedPnl: Number(balance.unrealizedPnl),
+            positionCount: positions.filter(p => Number(p.size) > 0).length,
+        };
+        saveEquitySnapshot(snap);
+        return snap;
+    }));
+    for (const r of results) {
+        if (r.status === "fulfilled")
+            snaps.push(r.value);
+    }
+    return snaps;
+}
+function registerPnlSubcommands(parent, getAdapterForExchange, isJson) {
+    // ── snapshot ──
+    parent
+        .command("snapshot")
+        .description("Take equity snapshot across all exchanges")
+        .option("--exchanges <list>", "Comma-separated exchange list", EXCHANGES.join(","))
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const exchanges = opts.exchanges.split(",").map(e => e.trim());
+            const snaps = await takeSnapshot(getAdapterForExchange, exchanges);
+            if (isJson()) {
+                printJson(jsonOk({ snapshots: snaps }));
+            }
+            else {
+                const total = snaps.reduce((s, sn) => s + sn.equity, 0);
+                console.log(chalk.cyan.bold("Equity Snapshot\n"));
+                for (const s of snaps) {
+                    console.log(`  ${s.exchange.padEnd(14)} $${formatUsd(s.equity)}  ` +
+                        `avail $${formatUsd(s.available)}  ` +
+                        `uPnL ${formatPnl(s.unrealizedPnl)}  ` +
+                        `pos: ${s.positionCount}`);
+                }
+                console.log(`\n  ${"Total".padEnd(14)} $${formatUsd(total)}`);
+                console.log(chalk.gray(`\n  Saved at ${snaps[0]?.ts ?? "—"}`));
+            }
+        });
+    });
+    // ── track ──
+    parent
+        .command("track")
+        .description("Continuously track equity (foreground)")
+        .option("--interval <sec>", "Snapshot interval in seconds", "300")
+        .option("--exchanges <list>", "Comma-separated exchange list", EXCHANGES.join(","))
+        .action(async (opts) => {
+        const intervalMs = parseInt(opts.interval) * 1000;
+        const exchanges = opts.exchanges.split(",").map(e => e.trim());
+        console.log(chalk.cyan(`PnL tracker started — snapshot every ${opts.interval}s for [${exchanges.join(", ")}]`));
+        console.log(chalk.gray("Press Ctrl+C to stop\n"));
+        const controller = new AbortController();
+        process.on("SIGINT", () => controller.abort());
+        // Initial snapshot
+        const snaps = await takeSnapshot(getAdapterForExchange, exchanges);
+        const total = snaps.reduce((s, sn) => s + sn.equity, 0);
+        console.log(`${chalk.gray(new Date().toLocaleTimeString())} Total equity: $${formatUsd(total)}`);
+        while (!controller.signal.aborted) {
+            await new Promise((resolve) => {
+                const timer = setTimeout(resolve, intervalMs);
+                controller.signal.addEventListener("abort", () => { clearTimeout(timer); resolve(); }, { once: true });
+            });
+            if (controller.signal.aborted)
+                break;
+            try {
+                const s = await takeSnapshot(getAdapterForExchange, exchanges);
+                const t = s.reduce((sum, sn) => sum + sn.equity, 0);
+                const delta = t - total;
+                console.log(`${chalk.gray(new Date().toLocaleTimeString())} ` +
+                    `Total: $${formatUsd(t)}  ${formatPnl(delta)}`);
+            }
+            catch (err) {
+                console.error(chalk.red(`Snapshot error: ${err instanceof Error ? err.message : err}`));
+            }
+        }
+    });
+    // ── perf (unified: daily/weekly/summary) ──
+    parent
+        .command("perf")
+        .description("Performance breakdown — daily, weekly, or summary stats")
+        .option("--period <period>", "daily, weekly, or summary", "daily")
+        .option("--exchange <name>", "Single exchange filter")
+        .option("--days <n>", "Number of days (daily mode)", "14")
+        .option("--weeks <n>", "Number of weeks (weekly mode)", "8")
+        .option("--since <period>", "Time range (e.g. 7d, 2w, 30d)")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const mode = opts.period.toLowerCase();
+            const defaultSince = mode === "weekly"
+                ? new Date(Date.now() - parseInt(opts.weeks) * 7 * 86400000)
+                : new Date(Date.now() - parseInt(opts.days) * 86400000);
+            const since = parseSinceDate(opts.since) ?? defaultSince;
+            const snapshots = readEquityHistory({ exchange: opts.exchange, since });
+            if (snapshots.length === 0) {
+                if (isJson()) {
+                    printJson(jsonError("NO_DATA", "No equity snapshots found. Run 'perp history snapshot' or 'perp history track' first."));
+                }
+                else {
+                    console.log(chalk.yellow("No equity snapshots found. Run 'perp history snapshot' or 'perp history track' first."));
+                }
+                return;
+            }
+            if (mode === "summary") {
+                const metrics = computePnlMetrics(snapshots, opts.exchange);
+                if (isJson()) {
+                    printJson(jsonOk({ ...metrics, dailyReturns: undefined, dailyCount: metrics.dailyReturns.length }));
+                }
+                else {
+                    console.log(chalk.cyan.bold(`Performance Summary${opts.exchange ? ` (${opts.exchange})` : ""}\n`));
+                    console.log(`  Period:          ${metrics.period.from} → ${metrics.period.to} (${metrics.period.days} days)`);
+                    console.log(`  Total Return:    ${formatPnl(metrics.totalReturn)} (${metrics.totalReturnPct >= 0 ? "+" : ""}${metrics.totalReturnPct.toFixed(2)}%)`);
+                    console.log(`  Peak Equity:     $${formatUsd(metrics.peakEquity)}`);
+                    console.log(`  Avg Daily PnL:   ${formatPnl(metrics.avgDailyPnl)}`);
+                    console.log();
+                    console.log(`  Sharpe Ratio:    ${metrics.sharpeRatio >= 0 ? chalk.green(metrics.sharpeRatio.toFixed(2)) : chalk.red(metrics.sharpeRatio.toFixed(2))}`);
+                    console.log(`  Max Drawdown:    ${chalk.red(`$${formatUsd(metrics.maxDrawdown)}`)} (${chalk.red(`-${metrics.maxDrawdownPct.toFixed(2)}%`)})`);
+                    console.log(`  Current DD:      $${formatUsd(metrics.currentDrawdown)} (-${metrics.currentDrawdownPct.toFixed(2)}%)`);
+                    console.log();
+                    console.log(`  Win Days:        ${chalk.green(String(metrics.winDays))} / ${metrics.winDays + metrics.lossDays}`);
+                    console.log(`  Win Rate:        ${metrics.winRate.toFixed(1)}%`);
+                    if (metrics.bestDay)
+                        console.log(`  Best Day:        ${metrics.bestDay.date}  ${formatPnl(metrics.bestDay.pnl)}`);
+                    if (metrics.worstDay)
+                        console.log(`  Worst Day:       ${metrics.worstDay.date}  ${formatPnl(metrics.worstDay.pnl)}`);
+                }
+                return;
+            }
+            const daily = computeDailyPnl(snapshots, opts.exchange);
+            if (mode === "weekly") {
+                const weekly = aggregateWeekly(daily);
+                if (isJson()) {
+                    printJson(jsonOk({ weekly }));
+                    return;
+                }
+                console.log(chalk.cyan.bold(`Weekly PnL${opts.exchange ? ` (${opts.exchange})` : ""}\n`));
+                const rows = weekly.map(w => [w.date, `$${formatUsd(w.startEquity)}`, `$${formatUsd(w.endEquity)}`, formatPnl(w.pnl), `${w.pnlPct >= 0 ? "+" : ""}${w.pnlPct.toFixed(2)}%`]);
+                console.log(makeTable(["Week", "Start", "End", "PnL", "PnL %"], rows));
+            }
+            else {
+                // daily (default)
+                if (isJson()) {
+                    printJson(jsonOk({ daily }));
+                    return;
+                }
+                console.log(chalk.cyan.bold(`Daily PnL${opts.exchange ? ` (${opts.exchange})` : ""}\n`));
+                const rows = daily.map(d => [d.date, `$${formatUsd(d.startEquity)}`, `$${formatUsd(d.endEquity)}`, formatPnl(d.pnl), `${d.pnlPct >= 0 ? "+" : ""}${d.pnlPct.toFixed(2)}%`]);
+                console.log(makeTable(["Date", "Start", "End", "PnL", "PnL %"], rows));
+            }
+        });
+    });
 }

package/dist/commands/manage.js

@@ -3,7 +3,7 @@ import { printJson, jsonOk } from "../utils.js";
 import { setEnvVar } from "./init.js";
 import chalk from "chalk";
 export function registerManageCommands(program, getAdapter, isJson, getPacificaAdapter) {
-    const manage = program.command("manage").description("Account management");
+    const manage = program.command("manage").description("Exchange account settings (margin, subaccount, API keys, builder)");
     // Ensure adapter is initialized before accessing PacificaAdapter
     async function pac() {
         const adapter = await getAdapter();
@@ -27,16 +27,18 @@ export function registerManageCommands(program, getAdapter, isJson, getPacificaA
             return printJson(jsonOk(result));
         console.log(chalk.green(`\n  Margin mode for ${symbol.toUpperCase()} set to ${m}.\n`));
     });
-    manage
+    const withdrawCmd = manage
         .command("withdraw <amount> <address>")
-        .description("Withdraw funds to a Solana address")
+        .description("Use 'perp withdraw pacifica <amount>'")
         .action(async (amount, address) => {
+        console.log(chalk.yellow("\n  Use 'perp withdraw pacifica <amount>' instead.\n"));
         const a = await pac();
         const result = await a.sdk.withdraw({ amount, dest_address: address }, a.publicKey, a.signer);
         if (isJson())
             return printJson(jsonOk(result));
         console.log(chalk.green(`\n  Withdrawal of $${amount} to ${address} submitted.\n`));
     });
+    withdrawCmd._hidden = true;
     // Subaccounts
     const sub = manage.command("sub").description("Subaccount management");
     sub
@@ -274,7 +276,7 @@ export function registerManageCommands(program, getAdapter, isJson, getPacificaA
     manage
         .command("setup-api-key")
         .description("Generate & register a Lighter API key (required for trading)")
-        .option("--key-index <n>", "API key index (2-254, default: 2)", "2")
+        .option("--key-index <n>", "API key index (4-254, default: 4)", "4")
         .action(async (opts) => {
         const adapter = await getAdapter();
         const { LighterAdapter } = await import("../exchanges/lighter.js");

package/dist/commands/market.js

@@ -1,5 +1,6 @@
 import { PacificaAdapter } from "../exchanges/pacifica.js";
-import { makeTable, formatUsd, formatPercent, printJson, jsonOk, jsonError } from "../utils.js";
+import { HyperliquidAdapter } from "../exchanges/hyperliquid.js";
+import { makeTable, formatUsd, formatPercent, printJson, jsonOk, jsonError, withJsonErrors } from "../utils.js";
 import chalk from "chalk";
 export function registerMarketCommands(program, getAdapter, isJson) {
     const market = program.command("market").description("Market data commands");
@@ -139,7 +140,7 @@ export function registerMarketCommands(program, getAdapter, isJson) {
         const rows = history.map((h) => [
             new Date(h.time).toLocaleString(),
             formatPercent(h.rate),
-            `$${formatUsd(h.price)}`,
+            h.price != null ? `$${formatUsd(h.price)}` : chalk.gray("n/a"),
         ]);
         console.log(makeTable(["Time", "Funding Rate", "Oracle"], rows));
     });
@@ -222,4 +223,36 @@ export function registerMarketCommands(program, getAdapter, isJson) {
         ]);
         console.log(makeTable(["Time", "Open", "High", "Low", "Close", "Volume", "Trades"], rows));
     });
+    // ── market hip3 ── (HIP-3 deployed perp dexes on Hyperliquid)
+    market
+        .command("hip3")
+        .description("List HIP-3 deployed perp dexes (Hyperliquid only)")
+        .action(async () => {
+        await withJsonErrors(isJson(), async () => {
+            const adapter = await getAdapter();
+            if (!(adapter instanceof HyperliquidAdapter)) {
+                if (isJson())
+                    return printJson(jsonError("INVALID_EXCHANGE", "HIP-3 dexes are only available on Hyperliquid. Use -e hyperliquid."));
+                console.error(chalk.red("\n  HIP-3 dexes are only available on Hyperliquid. Use -e hyperliquid.\n"));
+                return;
+            }
+            const dexes = await adapter.listDeployedDexes();
+            if (isJson())
+                return printJson(jsonOk(dexes));
+            if (dexes.length === 0) {
+                console.log(chalk.gray("\n  No deployed dexes found.\n"));
+                return;
+            }
+            console.log(chalk.cyan.bold("\n  HIP-3 Deployed Perp DEXes\n"));
+            const rows = dexes.map(d => [
+                chalk.white.bold(d.name),
+                chalk.gray(d.deployer.slice(0, 10) + "..."),
+                String(d.assets.length),
+                d.assets.slice(0, 5).join(", ") + (d.assets.length > 5 ? ` +${d.assets.length - 5}` : ""),
+            ]);
+            console.log(makeTable(["DEX", "Deployer", "Assets", "Markets"], rows));
+            console.log(chalk.gray(`\n  Use --dex <name> to trade on a deployed dex.`));
+            console.log(chalk.gray(`  Example: perp -e hl --dex xyz market list\n`));
+        });
+    });
 }

package/dist/commands/multileg.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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;