perp-cli 0.4.8 → 0.4.10

package/dist/commands/account.js

@@ -1,42 +1,277 @@
 import { PacificaAdapter } from "../exchanges/pacifica.js";
-import { HyperliquidAdapter } from "../exchanges/hyperliquid.js";
-import { makeTable, formatUsd, formatPnl, printJson, jsonOk, jsonError, symbolMatch } from "../utils.js";
+import { makeTable, formatUsd, formatPnl, printJson, jsonOk, jsonError, symbolMatch, withJsonErrors } from "../utils.js";
 import chalk from "chalk";
+import { assessRisk } from "../risk.js";
+const EXCHANGES = ["pacifica", "hyperliquid", "lighter"];
+async function fetchExchangeSnapshot(name, getAdapter) {
+    try {
+        const adapter = await getAdapter(name);
+        const [balance, positions, orders] = await Promise.all([
+            adapter.getBalance(),
+            adapter.getPositions(),
+            adapter.getOpenOrders(),
+        ]);
+        return {
+            exchange: name,
+            connected: true,
+            balance,
+            positions,
+            openOrders: orders.length,
+        };
+    }
+    catch (err) {
+        return {
+            exchange: name,
+            connected: false,
+            balance: null,
+            positions: [],
+            openOrders: 0,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function buildSummary(snapshots) {
+    let totalEquity = 0;
+    let totalAvailable = 0;
+    let totalMarginUsed = 0;
+    let totalUnrealizedPnl = 0;
+    let totalPositions = 0;
+    let totalOpenOrders = 0;
+    const allPositions = [];
+    for (const snap of snapshots) {
+        if (snap.balance) {
+            totalEquity += Number(snap.balance.equity);
+            totalAvailable += Number(snap.balance.available);
+            totalMarginUsed += Number(snap.balance.marginUsed);
+            totalUnrealizedPnl += Number(snap.balance.unrealizedPnl);
+        }
+        totalPositions += snap.positions.length;
+        totalOpenOrders += snap.openOrders;
+        for (const pos of snap.positions) {
+            allPositions.push({ ...pos, exchange: snap.exchange });
+        }
+    }
+    // Risk metrics
+    const marginUtilization = totalEquity > 0 ? (totalMarginUsed / totalEquity) * 100 : 0;
+    let largestPosition = null;
+    for (const pos of allPositions) {
+        const notional = Math.abs(Number(pos.size) * Number(pos.markPrice));
+        if (!largestPosition || notional > largestPosition.notional) {
+            largestPosition = { symbol: pos.symbol, exchange: pos.exchange, notional };
+        }
+    }
+    const exchangeConcentration = snapshots
+        .filter(s => s.balance && Number(s.balance.equity) > 0)
+        .map(s => ({
+        exchange: s.exchange,
+        pct: totalEquity > 0 ? (Number(s.balance.equity) / totalEquity) * 100 : 0,
+    }))
+        .sort((a, b) => b.pct - a.pct);
+    // Full risk assessment (reuses same data, no extra API calls)
+    const riskBalances = snapshots
+        .filter(s => s.balance)
+        .map(s => ({ exchange: s.exchange, balance: s.balance }));
+    const riskPositions = allPositions.map(p => ({ exchange: p.exchange, position: p }));
+    const assessment = assessRisk(riskBalances, riskPositions);
+    return {
+        totalEquity,
+        totalAvailable,
+        totalMarginUsed,
+        totalUnrealizedPnl,
+        totalPositions,
+        totalOpenOrders,
+        exchanges: snapshots,
+        positions: allPositions,
+        riskMetrics: {
+            marginUtilization,
+            largestPosition,
+            exchangeConcentration,
+        },
+        risk: {
+            level: assessment.level,
+            canTrade: assessment.canTrade,
+            violations: assessment.violations,
+        },
+    };
+}
 function pac(adapter) {
     if (!(adapter instanceof PacificaAdapter))
         throw new Error("This command requires --exchange pacifica");
     return adapter;
 }
-export function registerAccountCommands(program, getAdapter, isJson) {
+export function registerAccountCommands(program, getAdapter, isJson, getAdapterForExchange) {
     const account = program.command("account").description("Account commands");
-    account
-        .command("info")
-        .description("Show account balance and info")
-        .action(async () => {
-        const adapter = await getAdapter();
-        const bal = await adapter.getBalance();
-        if (isJson())
-            return printJson(jsonOk(bal));
-        console.log(chalk.cyan.bold(`\n  ${adapter.name.toUpperCase()} Account Info\n`));
-        console.log(`  Equity:       $${formatUsd(bal.equity)}`);
-        console.log(`  Available:    $${formatUsd(bal.available)}`);
-        console.log(`  Margin Used:  $${formatUsd(bal.marginUsed)}`);
-        console.log(`  Unreal. PnL:  ${formatPnl(bal.unrealizedPnl)}`);
-        console.log();
-    });
+    async function fetchExchangeBalance(exName, adapter) {
+        const name = exName.toLowerCase();
+        const [bal, fundingPayments] = await Promise.all([
+            adapter.getBalance(),
+            adapter.getFundingPayments(200).catch(() => []),
+        ]);
+        let spotBalances = [];
+        try {
+            if (name === "hyperliquid") {
+                const { HyperliquidSpotAdapter } = await import("../exchanges/hyperliquid-spot.js");
+                const hlSpot = new HyperliquidSpotAdapter(adapter);
+                await hlSpot.init();
+                const raw = await hlSpot.getSpotBalances();
+                const markets = await hlSpot.getSpotMarkets();
+                const priceMap = new Map(markets.map(m => [m.baseToken.toUpperCase(), Number(m.markPrice)]));
+                const stripSuffix = (t) => t.replace(/-SPOT$/i, "").toUpperCase();
+                spotBalances = raw
+                    .filter(b => Number(b.total) > 0)
+                    .map(b => {
+                    const base = stripSuffix(b.token);
+                    return {
+                        ...b,
+                        valueUsd: base === "USDC" ? Number(b.total) : (priceMap.get(base) ?? 0) * Number(b.total),
+                    };
+                });
+            }
+            else if (name === "lighter") {
+                const { LighterAdapter } = await import("../exchanges/lighter.js");
+                const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
+                const ltSpot = new LighterSpotAdapter(adapter);
+                await ltSpot.init();
+                const raw = await ltSpot.getSpotBalances();
+                const markets = await ltSpot.getSpotMarkets();
+                const priceMap = new Map(markets.map(m => [m.baseToken.toUpperCase(), Number(m.markPrice)]));
+                spotBalances = raw
+                    .filter(b => Number(b.total) > 0)
+                    .map(b => ({
+                    ...b,
+                    valueUsd: b.token === "USDC" || b.token === "USDC_SPOT"
+                        ? Number(b.total)
+                        : (priceMap.get(b.token.toUpperCase()) ?? 0) * Number(b.total),
+                }));
+            }
+        }
+        catch { /* spot not available */ }
+        const cutoff24h = Date.now() - 24 * 60 * 60 * 1000;
+        const recent = fundingPayments.filter(f => f.time >= cutoff24h);
+        const funding24h = recent.reduce((sum, f) => sum + Number(f.payment), 0);
+        const totalSpotUsd = spotBalances.reduce((s, b) => s + (b.valueUsd ?? 0), 0);
+        return {
+            exchange: name,
+            perp: bal,
+            spot: spotBalances,
+            funding24h,
+            fundingPayments24h: recent.length,
+            totalSpotValueUsd: totalSpotUsd,
+            totalAccountValueUsd: Number(bal.equity) + totalSpotUsd,
+        };
+    }
+    function printSingleBalance(exName, r) {
+        console.log(chalk.cyan.bold(`\n  ${exName.toUpperCase()} Account Balance\n`));
+        console.log(chalk.white.bold("  Perp Account"));
+        console.log(`    Equity:       $${formatUsd(r.perp.equity)}`);
+        console.log(`    Available:    $${formatUsd(r.perp.available)}`);
+        console.log(`    Margin Used:  $${formatUsd(r.perp.marginUsed)}`);
+        console.log(`    Unreal. PnL:  ${formatPnl(r.perp.unrealizedPnl)}`);
+        if (r.spot.length > 0) {
+            console.log(chalk.white.bold("\n  Spot Holdings"));
+            const rows = r.spot.map(b => [
+                chalk.white.bold(b.token),
+                b.total,
+                b.available,
+                b.held !== "0" ? b.held : chalk.gray("-"),
+                b.valueUsd ? `$${formatUsd(b.valueUsd)}` : chalk.gray("-"),
+            ]);
+            console.log(makeTable(["Token", "Total", "Available", "Held", "Value"], rows));
+        }
+        console.log(chalk.white.bold("  Funding (24h)"));
+        console.log(`    Payments:     ${r.fundingPayments24h}`);
+        console.log(`    Total:        ${formatPnl(r.funding24h)}`);
+        if (r.totalSpotValueUsd > 0) {
+            console.log(chalk.white.bold("\n  Total"));
+            console.log(`    Perp Equity:  $${formatUsd(r.perp.equity)}`);
+            console.log(`    Spot Value:   $${formatUsd(r.totalSpotValueUsd)}`);
+            console.log(`    Total Value:  $${formatUsd(r.totalAccountValueUsd)}`);
+        }
+    }
     account
         .command("balance")
-        .description("Alias for 'account info' — show account balance")
+        .alias("info")
+        .description("Account overview: perp balance, spot holdings, and 24h funding")
         .action(async () => {
+        // Detect if user explicitly set -e (single exchange mode)
+        const explicitExchange = program.getOptionValueSource?.("exchange") === "cli";
+        // Multi-exchange mode: show all exchanges
+        if (!explicitExchange && getAdapterForExchange) {
+            const results = [];
+            const errors = {};
+            await Promise.all(EXCHANGES.map(async (ex) => {
+                try {
+                    const adapter = await getAdapterForExchange(ex);
+                    results.push(await fetchExchangeBalance(ex, adapter));
+                }
+                catch (err) {
+                    errors[ex] = err instanceof Error ? err.message : String(err);
+                }
+            }));
+            // Sort by equity desc
+            results.sort((a, b) => b.totalAccountValueUsd - a.totalAccountValueUsd);
+            if (isJson()) {
+                const grandTotal = results.reduce((s, r) => s + r.totalAccountValueUsd, 0);
+                return printJson(jsonOk({
+                    exchanges: results,
+                    errors: Object.keys(errors).length > 0 ? errors : undefined,
+                    totalEquity: results.reduce((s, r) => s + Number(r.perp.equity), 0),
+                    totalSpotValueUsd: results.reduce((s, r) => s + r.totalSpotValueUsd, 0),
+                    totalAccountValueUsd: grandTotal,
+                    totalFunding24h: results.reduce((s, r) => s + r.funding24h, 0),
+                }));
+            }
+            console.log(chalk.cyan.bold("\n  All Exchanges — Account Balance\n"));
+            // Summary table
+            const balRows = results.map(r => [
+                chalk.white.bold(r.exchange),
+                `$${formatUsd(r.perp.equity)}`,
+                `$${formatUsd(r.perp.available)}`,
+                `$${formatUsd(r.perp.marginUsed)}`,
+                r.totalSpotValueUsd > 0 ? `$${formatUsd(r.totalSpotValueUsd)}` : chalk.gray("-"),
+                formatPnl(r.funding24h),
+                `$${formatUsd(r.totalAccountValueUsd)}`,
+            ]);
+            const grandEquity = results.reduce((s, r) => s + Number(r.perp.equity), 0);
+            const grandSpot = results.reduce((s, r) => s + r.totalSpotValueUsd, 0);
+            const grandFunding = results.reduce((s, r) => s + r.funding24h, 0);
+            const grandTotal = results.reduce((s, r) => s + r.totalAccountValueUsd, 0);
+            balRows.push([
+                chalk.cyan.bold("TOTAL"),
+                chalk.cyan.bold(`$${formatUsd(grandEquity)}`),
+                "",
+                "",
+                grandSpot > 0 ? chalk.cyan.bold(`$${formatUsd(grandSpot)}`) : "",
+                formatPnl(grandFunding),
+                chalk.cyan.bold(`$${formatUsd(grandTotal)}`),
+            ]);
+            console.log(makeTable(["Exchange", "Equity", "Available", "Margin", "Spot", "Funding 24h", "Total"], balRows));
+            // Spot details per exchange
+            for (const r of results) {
+                if (r.spot.length > 0) {
+                    console.log(chalk.white.bold(`  ${r.exchange.toUpperCase()} Spot Holdings`));
+                    const rows = r.spot.map(b => [
+                        chalk.white.bold(b.token),
+                        b.total,
+                        b.valueUsd ? `$${formatUsd(b.valueUsd)}` : chalk.gray("-"),
+                    ]);
+                    console.log(makeTable(["Token", "Total", "Value"], rows));
+                }
+            }
+            // Errors
+            for (const [ex, msg] of Object.entries(errors)) {
+                console.log(chalk.gray(`  ${ex}: ${msg}`));
+            }
+            console.log();
+            return;
+        }
+        // Single exchange mode (explicit -e or no getAdapterForExchange)
         const adapter = await getAdapter();
-        const bal = await adapter.getBalance();
+        const exName = adapter.name.toLowerCase();
+        const result = await fetchExchangeBalance(exName, adapter);
         if (isJson())
-            return printJson(jsonOk(bal));
-        console.log(chalk.cyan.bold(`\n  ${adapter.name.toUpperCase()} Account Balance\n`));
-        console.log(`  Equity:       $${formatUsd(bal.equity)}`);
-        console.log(`  Available:    $${formatUsd(bal.available)}`);
-        console.log(`  Margin Used:  $${formatUsd(bal.marginUsed)}`);
-        console.log(`  Unreal. PnL:  ${formatPnl(bal.unrealizedPnl)}`);
+            return printJson(jsonOk(result));
+        printSingleBalance(exName, result);
         console.log();
     });
     account
@@ -172,42 +407,9 @@ export function registerAccountCommands(program, getAdapter, isJson) {
         ]);
         console.log(makeTable(["Time", "Symbol", "Payment"], rows));
     });
-    account
-        .command("portfolio")
-        .description("Portfolio overview")
-        .action(async () => {
-        const adapter = await getAdapter();
-        if (adapter instanceof PacificaAdapter) {
-            const portfolio = await adapter.sdk.getPortfolio(adapter.publicKey);
-            printJson(jsonOk(portfolio));
-        }
-        else if (adapter instanceof HyperliquidAdapter) {
-            const state = await adapter.client.info.perpetuals.getClearinghouseState(adapter.address);
-            printJson(jsonOk(state));
-        }
-    });
-    account
-        .command("balance-history")
-        .description("Balance change history")
-        .action(async () => {
-        const adapter = await getAdapter();
-        const p = pac(adapter);
-        const raw = await p.sdk.getBalanceHistory(p.publicKey);
-        if (isJson())
-            return printJson(jsonOk(raw));
-        const history = (raw.data ?? raw);
-        if (!Array.isArray(history) || history.length === 0) {
-            console.log(chalk.gray("\n  No balance history.\n"));
-            return;
-        }
-        const rows = history.slice(0, 30).map((h) => [
-            new Date(Number(h.created_at ?? h.timestamp ?? 0)).toLocaleString(),
-            String(h.type ?? h.event_type ?? ""),
-            formatPnl(String(h.amount ?? h.change ?? "0")),
-            `$${formatUsd(String(h.balance ?? "0"))}`,
-        ]);
-        console.log(makeTable(["Time", "Type", "Change", "Balance"], rows));
-    });
+    // "account portfolio" removed — use top-level "portfolio" for cross-exchange view
+    // or "account balance" for single-exchange balance
+    // "account balance-history" removed — Pacifica-only, rarely used
     account
         .command("margin <symbol>")
         .description("Margin details for a specific symbol position")
@@ -422,4 +624,106 @@ export function registerAccountCommands(program, getAdapter, isJson) {
         ]);
         console.log(makeTable(["ID", "Symbol", "Side", "Size", "Filled", "Duration"], rows));
     });
+    // ── Portfolio (top-level command) ──
+    if (getAdapterForExchange) {
+        program
+            .command("portfolio")
+            .description("Cross-exchange portfolio overview (all exchanges at once)")
+            .option("--exchange <exchanges>", "Comma-separated exchanges to include (default: all)")
+            .action(async (opts) => {
+            await withJsonErrors(isJson(), async () => {
+                const exchanges = opts.exchange
+                    ? opts.exchange.split(",").map(e => e.trim())
+                    : [...EXCHANGES];
+                const snapshots = await Promise.all(exchanges.map(ex => fetchExchangeSnapshot(ex, getAdapterForExchange)));
+                const summary = buildSummary(snapshots);
+                if (isJson()) {
+                    return printJson(jsonOk(summary));
+                }
+                // ── Header ──
+                console.log(chalk.cyan.bold("\n  Cross-Exchange Portfolio\n"));
+                // ── Balance Summary ──
+                console.log(chalk.white.bold("  Balances"));
+                const balRows = snapshots.map(s => {
+                    if (!s.connected) {
+                        return [chalk.white(s.exchange), chalk.red("disconnected"), "-", "-", "-", chalk.gray(s.error ?? "")];
+                    }
+                    const b = s.balance;
+                    return [
+                        chalk.white.bold(s.exchange),
+                        `$${formatUsd(b.equity)}`,
+                        `$${formatUsd(b.available)}`,
+                        `$${formatUsd(b.marginUsed)}`,
+                        formatPnl(b.unrealizedPnl),
+                        chalk.green("connected"),
+                    ];
+                });
+                // Totals row
+                balRows.push([
+                    chalk.cyan.bold("TOTAL"),
+                    chalk.cyan.bold(`$${formatUsd(summary.totalEquity)}`),
+                    chalk.cyan.bold(`$${formatUsd(summary.totalAvailable)}`),
+                    chalk.cyan.bold(`$${formatUsd(summary.totalMarginUsed)}`),
+                    formatPnl(summary.totalUnrealizedPnl),
+                    "",
+                ]);
+                console.log(makeTable(["Exchange", "Equity", "Available", "Margin Used", "uPnL", "Status"], balRows));
+                // ── Positions ──
+                if (summary.positions.length > 0) {
+                    console.log(chalk.white.bold("\n  Open Positions"));
+                    const posRows = summary.positions.map(p => {
+                        const sideColor = p.side === "long" ? chalk.green : chalk.red;
+                        const notional = Math.abs(Number(p.size) * Number(p.markPrice));
+                        return [
+                            chalk.white.bold(p.symbol),
+                            chalk.gray(p.exchange),
+                            sideColor(p.side.toUpperCase()),
+                            p.size,
+                            `$${formatUsd(p.entryPrice)}`,
+                            `$${formatUsd(p.markPrice)}`,
+                            formatPnl(p.unrealizedPnl),
+                            `$${formatUsd(notional)}`,
+                            `${p.leverage}x`,
+                        ];
+                    });
+                    console.log(makeTable(["Symbol", "Exchange", "Side", "Size", "Entry", "Mark", "uPnL", "Notional", "Lev"], posRows));
+                }
+                else {
+                    console.log(chalk.gray("\n  No open positions.\n"));
+                }
+                // ── Risk Metrics ──
+                console.log(chalk.white.bold("\n  Risk Metrics"));
+                const levelColor = {
+                    low: chalk.green,
+                    medium: chalk.yellow,
+                    high: chalk.red,
+                    critical: chalk.bgRed.white,
+                }[summary.risk.level];
+                console.log(`  Risk Level:         ${levelColor(summary.risk.level.toUpperCase())}`);
+                console.log(`  Can Trade:          ${summary.risk.canTrade ? chalk.green("YES") : chalk.red("NO")}`);
+                const mu = summary.riskMetrics.marginUtilization;
+                const muColor = mu < 30 ? chalk.green : mu < 60 ? chalk.yellow : chalk.red;
+                console.log(`  Margin Utilization: ${muColor(`${mu.toFixed(1)}%`)}`);
+                if (summary.riskMetrics.largestPosition) {
+                    const lp = summary.riskMetrics.largestPosition;
+                    console.log(`  Largest Position:   ${lp.symbol} on ${lp.exchange} ($${formatUsd(lp.notional)})`);
+                }
+                if (summary.riskMetrics.exchangeConcentration.length > 0) {
+                    console.log(`  Exchange Allocation:`);
+                    for (const ec of summary.riskMetrics.exchangeConcentration) {
+                        const bar = "\u2588".repeat(Math.round(ec.pct / 5)) + "\u2591".repeat(20 - Math.round(ec.pct / 5));
+                        console.log(`    ${ec.exchange.padEnd(12)} ${bar} ${ec.pct.toFixed(1)}%`);
+                    }
+                }
+                if (summary.risk.violations.length > 0) {
+                    console.log(chalk.red.bold("\n  Risk Violations"));
+                    for (const v of summary.risk.violations) {
+                        const sevColor = { low: chalk.green, medium: chalk.yellow, high: chalk.red, critical: chalk.bgRed.white }[v.severity];
+                        console.log(`    ${sevColor(v.severity.toUpperCase().padEnd(8))} ${v.message}`);
+                    }
+                }
+                console.log();
+            });
+        });
+    }
 }

package/dist/commands/agent.js

@@ -30,9 +30,11 @@ function extractSchema(cmd, parentPath = "perp") {
     const fullCommand = `${parentPath} ${cmd.name()}`.trim();
     const args = (cmd.registeredArguments ?? []).map((a) => {
         const desc = a.description || "";
+        // Args are always values (not flags), so infer from name/desc semantics, never "boolean"
+        const rawType = inferType(`<${a.name()}>`, desc);
         return {
             name: a.name(),
-            type: inferType(a.name(), desc),
+            type: rawType === "boolean" ? "string" : rawType,
             required: a.required,
             description: desc,
             enum: inferEnum(desc),
@@ -63,7 +65,7 @@ function extractSchema(cmd, parentPath = "perp") {
 export function registerAgentCommands(program, getAdapter, isJson) {
     const agent = program
         .command("agent")
-        .description("Agent-friendly commands (structured I/O for AI agents)");
+        .description("Agent-friendly commands");
     // ── agent schema ── dump full command tree as JSON
     agent
         .command("schema")
@@ -85,10 +87,12 @@ export function registerAgentCommands(program, getAdapter, isJson) {
         };
         printJson(jsonOk(envelope));
     });
-    // ── Top-level schema alias ──
-    program
+    // ── Top-level schema alias (hidden) ──
+    const schemaAlias = program
         .command("schema")
-        .description("Output CLI schema as JSON (alias for agent schema)")
+        .description("Output CLI schema as JSON (alias for agent schema)");
+    schemaAlias._hidden = true;
+    schemaAlias
         .action(() => {
         const errorCodeDocs = {};
         for (const [key, val] of Object.entries(ERROR_CODES)) {