perp-cli 0.6.4 → 0.7.1

package/dist/risk.js

@@ -59,7 +59,9 @@ export function getLiquidationDistances(positions, limits) {
         const liquidationPrice = Number(p.liquidationPrice);
         const distancePct = calcLiquidationDistance(markPrice, liquidationPrice, p.side);
         let status = "safe";
-        if (distancePct < lim.minLiquidationDistance)
+        if (distancePct < lim.minLiquidationDistance * 0.3)
+            status = "critical";
+        else if (distancePct < lim.minLiquidationDistance)
             status = "danger";
         else if (distancePct < lim.minLiquidationDistance * 1.5)
             status = "warning";

package/dist/smart-order.d.ts

@@ -18,7 +18,7 @@
  *
  * Fallback: if the IOC limit fails, falls back to market order.
  */
-import type { ExchangeAdapter } from "./exchanges/interface.js";
+import type { ExchangeAdapter } from "./exchanges/index.js";
 export interface SmartOrderOpts {
     /** Extra ticks of tolerance beyond best price. Default: 1 */
     tickTolerance?: number;

package/dist/strategies/dca.d.ts

@@ -1,4 +1,4 @@
-import type { ExchangeAdapter } from "../exchanges/interface.js";
+import type { ExchangeAdapter } from "../exchanges/index.js";
 export interface DCAParams {
     symbol: string;
     side: "buy" | "sell";

package/dist/strategies/funding-arb.d.ts

@@ -1,4 +1,4 @@
-import type { ExchangeAdapter } from "../exchanges/interface.js";
+import type { ExchangeAdapter } from "../exchanges/index.js";
 export interface FundingArbParams {
     minSpread: number;
     closeSpread: number;

package/dist/strategies/funding-arb.js

@@ -41,6 +41,10 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
     const positions = [];
     let cycleCount = 0;
     let lastRebalanceCheck = 0;
+    let running = true;
+    const shutdown = () => { running = false; log(`[ARB] Shutdown signal received, finishing current cycle...`); };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
     log(`[ARB] Funding rate arbitrage started`);
     log(`[ARB] Entry spread: >= ${params.minSpread}% | Close spread: <= ${closeSpread}%`);
     log(`[ARB] Size: ${params.size} | Interval: ${params.intervalSec}s`);
@@ -52,211 +56,219 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
         log(`[ARB] Max drawdown: $${params.maxDrawdown}`);
     if (params.symbols?.length)
         log(`[ARB] Symbols: ${params.symbols.join(", ")}`);
-    while (true) {
-        cycleCount++;
-        try {
-            const rates = await fetchAllRates();
-            // Group by symbol
-            const rateMap = new Map();
-            for (const r of rates) {
-                if (params.symbols?.length && !params.symbols.includes(r.symbol))
-                    continue;
-                if (!rateMap.has(r.symbol))
-                    rateMap.set(r.symbol, []);
-                rateMap.get(r.symbol).push(r);
-            }
-            // ── Phase 1: Check positions for close conditions ──
-            for (let i = positions.length - 1; i >= 0; i--) {
-                const pos = positions[i];
-                const symbolRates = rateMap.get(pos.symbol);
-                if (!symbolRates)
-                    continue;
-                const longRate = symbolRates.find((r) => r.exchange === pos.longExchange);
-                const shortRate = symbolRates.find((r) => r.exchange === pos.shortExchange);
-                if (!longRate || !shortRate)
-                    continue;
-                const currentSpread = computeAnnualSpread(shortRate.fundingRate, shortRate.exchange, longRate.fundingRate, longRate.exchange);
-                if (currentSpread <= closeSpread) {
-                    log(`[ARB] CLOSE signal: ${pos.symbol} spread ${currentSpread.toFixed(1)}% <= ${closeSpread}%`);
-                    if (params.autoExecute) {
-                        const longAdapter = adapters.get(pos.longExchange);
-                        const shortAdapter = adapters.get(pos.shortExchange);
-                        if (longAdapter && shortAdapter) {
-                            try {
-                                await Promise.all([
-                                    longAdapter.marketOrder(pos.symbol, "sell", pos.size),
-                                    shortAdapter.marketOrder(pos.symbol, "buy", pos.size),
-                                ]);
-                                log(`[ARB] CLOSED ${pos.symbol} — both legs unwound`);
-                                // Estimate P&L from funding collected
-                                const hoursOpen = (Date.now() - pos.openedAt) / (1000 * 60 * 60);
-                                // entrySpread is annualized %; convert to per-hour rate
-                                const hourlySpreadRate = pos.entrySpread / 100 / (24 * 365);
-                                const estimatedFunding = hourlySpreadRate * hoursOpen * Number(pos.size) * pos.entryPrices.long;
-                                log(`[ARB] Est. funding P&L: ~$${estimatedFunding.toFixed(2)} (${hoursOpen.toFixed(1)}h open)`);
-                            }
-                            catch (err) {
-                                const msg = err instanceof Error ? err.message : String(err);
-                                log(`[ARB] Close error: ${msg}`);
-                                continue; // don't remove position if close failed
+    try {
+        while (running) {
+            cycleCount++;
+            try {
+                const rates = await fetchAllRates();
+                // Group by symbol
+                const rateMap = new Map();
+                for (const r of rates) {
+                    if (params.symbols?.length && !params.symbols.includes(r.symbol))
+                        continue;
+                    if (!rateMap.has(r.symbol))
+                        rateMap.set(r.symbol, []);
+                    rateMap.get(r.symbol).push(r);
+                }
+                // ── Phase 1: Check positions for close conditions ──
+                for (let i = positions.length - 1; i >= 0; i--) {
+                    const pos = positions[i];
+                    const symbolRates = rateMap.get(pos.symbol);
+                    if (!symbolRates)
+                        continue;
+                    const longRate = symbolRates.find((r) => r.exchange === pos.longExchange);
+                    const shortRate = symbolRates.find((r) => r.exchange === pos.shortExchange);
+                    if (!longRate || !shortRate)
+                        continue;
+                    const currentSpread = computeAnnualSpread(shortRate.fundingRate, shortRate.exchange, longRate.fundingRate, longRate.exchange);
+                    if (currentSpread <= closeSpread) {
+                        log(`[ARB] CLOSE signal: ${pos.symbol} spread ${currentSpread.toFixed(1)}% <= ${closeSpread}%`);
+                        if (params.autoExecute) {
+                            const longAdapter = adapters.get(pos.longExchange);
+                            const shortAdapter = adapters.get(pos.shortExchange);
+                            if (longAdapter && shortAdapter) {
+                                try {
+                                    await Promise.all([
+                                        longAdapter.marketOrder(pos.symbol, "sell", pos.size),
+                                        shortAdapter.marketOrder(pos.symbol, "buy", pos.size),
+                                    ]);
+                                    log(`[ARB] CLOSED ${pos.symbol} — both legs unwound`);
+                                    // Estimate P&L from funding collected
+                                    const hoursOpen = (Date.now() - pos.openedAt) / (1000 * 60 * 60);
+                                    // entrySpread is annualized %; convert to per-hour rate
+                                    const hourlySpreadRate = pos.entrySpread / 100 / (24 * 365);
+                                    const estimatedFunding = hourlySpreadRate * hoursOpen * Number(pos.size) * pos.entryPrices.long;
+                                    log(`[ARB] Est. funding P&L: ~$${estimatedFunding.toFixed(2)} (${hoursOpen.toFixed(1)}h open)`);
+                                }
+                                catch (err) {
+                                    const msg = err instanceof Error ? err.message : String(err);
+                                    log(`[ARB] Close error: ${msg}`);
+                                    continue; // don't remove position if close failed
+                                }
                             }
                         }
+                        positions.splice(i, 1);
                     }
-                    positions.splice(i, 1);
                 }
-            }
-            // ── Phase 2: Max drawdown check ──
-            if (params.maxDrawdown && params.autoExecute && positions.length > 0) {
-                try {
-                    const snapshots = await fetchAllBalances(adapters);
-                    const totalPnl = snapshots.reduce((s, e) => s + e.unrealizedPnl, 0);
-                    if (totalPnl < -params.maxDrawdown) {
-                        log(`[ARB] MAX DRAWDOWN hit: uPnL $${totalPnl.toFixed(2)} < -$${params.maxDrawdown}`);
-                        log(`[ARB] Closing all ${positions.length} positions...`);
-                        await closeAllPositions(positions, adapters, log);
-                        positions.length = 0;
+                // ── Phase 2: Max drawdown check ──
+                if (params.maxDrawdown && params.autoExecute && positions.length > 0) {
+                    try {
+                        const snapshots = await fetchAllBalances(adapters);
+                        const totalPnl = snapshots.reduce((s, e) => s + e.unrealizedPnl, 0);
+                        if (totalPnl < -params.maxDrawdown) {
+                            log(`[ARB] MAX DRAWDOWN hit: uPnL $${totalPnl.toFixed(2)} < -$${params.maxDrawdown}`);
+                            log(`[ARB] Closing all ${positions.length} positions...`);
+                            await closeAllPositions(positions, adapters, log);
+                            positions.length = 0;
+                        }
                     }
+                    catch { /* non-critical */ }
                 }
-                catch { /* non-critical */ }
-            }
-            // ── Phase 3: Balance check + rebalance trigger ──
-            let balanceSnapshots = null;
-            const shouldCheckBalance = params.autoRebalance && (Date.now() - lastRebalanceCheck > 300_000); // every 5 min
-            if (shouldCheckBalance || (params.autoExecute && positions.length < maxPos)) {
-                try {
-                    balanceSnapshots = await fetchAllBalances(adapters);
-                    lastRebalanceCheck = Date.now();
-                    if (params.autoRebalance) {
-                        const threshold = params.rebalanceThreshold ?? 100;
-                        const lowExchanges = balanceSnapshots.filter((s) => s.available < threshold);
-                        if (lowExchanges.length > 0) {
-                            const plan = computeRebalancePlan(balanceSnapshots, { minMove: 50, reserve: 20 });
-                            if (plan.moves.length > 0) {
-                                log(`[ARB] Rebalance needed: ${plan.summary}`);
-                                for (const move of plan.moves) {
-                                    log(`[ARB]   $${move.amount} ${move.from} → ${move.to}`);
+                // ── Phase 3: Balance check + rebalance trigger ──
+                let balanceSnapshots = null;
+                const shouldCheckBalance = params.autoRebalance && (Date.now() - lastRebalanceCheck > 300_000); // every 5 min
+                if (shouldCheckBalance || (params.autoExecute && positions.length < maxPos)) {
+                    try {
+                        balanceSnapshots = await fetchAllBalances(adapters);
+                        lastRebalanceCheck = Date.now();
+                        if (params.autoRebalance) {
+                            const threshold = params.rebalanceThreshold ?? 100;
+                            const lowExchanges = balanceSnapshots.filter((s) => s.available < threshold);
+                            if (lowExchanges.length > 0) {
+                                const plan = computeRebalancePlan(balanceSnapshots, { minMove: 50, reserve: 20 });
+                                if (plan.moves.length > 0) {
+                                    log(`[ARB] Rebalance needed: ${plan.summary}`);
+                                    for (const move of plan.moves) {
+                                        log(`[ARB]   $${move.amount} ${move.from} → ${move.to}`);
+                                    }
+                                    log(`[ARB] Run 'perp rebalance execute' to rebalance.`);
                                 }
-                                log(`[ARB] Run 'perp rebalance execute' to rebalance.`);
                             }
                         }
                     }
+                    catch { /* non-critical */ }
                 }
-                catch { /* non-critical */ }
-            }
-            // ── Phase 4: Find new entry opportunities ──
-            if (positions.length < maxPos) {
-                for (const [symbol, symbolRates] of rateMap) {
-                    if (symbolRates.length < 2)
-                        continue;
-                    if (positions.find((p) => symbolMatch(p.symbol, symbol)))
-                        continue;
-                    if (positions.length >= maxPos)
-                        break;
-                    // Only consider exchanges we have adapters for
-                    const available = symbolRates.filter((r) => adapters.has(r.exchange));
-                    if (available.length < 2)
-                        continue;
-                    available.sort((a, b) => a.fundingRate - b.fundingRate);
-                    const lowest = available[0];
-                    const highest = available[available.length - 1];
-                    if (lowest.exchange === highest.exchange)
-                        continue;
-                    const annualSpread = computeAnnualSpread(highest.fundingRate, highest.exchange, lowest.fundingRate, lowest.exchange);
-                    if (annualSpread >= params.minSpread) {
-                        const longEx = lowest.exchange;
-                        const shortEx = highest.exchange;
-                        log(`[ARB] ENTRY signal: ${symbol} spread ${annualSpread.toFixed(1)}% — long ${longEx} (${(lowest.fundingRate * 100).toFixed(4)}%) / short ${shortEx} (${(highest.fundingRate * 100).toFixed(4)}%)`);
-                        if (params.autoExecute) {
-                            const longAdapter = adapters.get(longEx);
-                            const shortAdapter = adapters.get(shortEx);
-                            if (!longAdapter || !shortAdapter) {
-                                log(`[ARB] Skip: adapter not available for ${longEx} or ${shortEx}`);
-                                continue;
-                            }
-                            // Check orderbook liquidity & adjust size
-                            const requestedUsd = params.sizeUsd ?? Number(params.size) * highest.markPrice;
-                            const liq = await checkArbLiquidity(longAdapter, shortAdapter, symbol, requestedUsd, 0.5, log);
-                            if (!liq.viable)
-                                continue;
-                            // Compute matched size (same for both legs)
-                            const matched = computeMatchedSize(liq.adjustedSizeUsd, highest.markPrice, longEx, shortEx);
-                            if (!matched) {
-                                log(`[ARB] Skip ${symbol}: can't compute matched size (min notional or precision issue)`);
-                                continue;
-                            }
-                            // Check balances before trading
-                            if (balanceSnapshots) {
-                                if (!hasEnoughBalance(balanceSnapshots, longEx, matched.notional) ||
-                                    !hasEnoughBalance(balanceSnapshots, shortEx, matched.notional)) {
-                                    log(`[ARB] Skip ${symbol}: insufficient balance on ${longEx} or ${shortEx} (need ~$${matched.notional.toFixed(0)} per leg)`);
+                // ── Phase 4: Find new entry opportunities ──
+                if (positions.length < maxPos) {
+                    for (const [symbol, symbolRates] of rateMap) {
+                        if (symbolRates.length < 2)
+                            continue;
+                        if (positions.find((p) => symbolMatch(p.symbol, symbol)))
+                            continue;
+                        if (positions.length >= maxPos)
+                            break;
+                        // Only consider exchanges we have adapters for
+                        const available = symbolRates.filter((r) => adapters.has(r.exchange));
+                        if (available.length < 2)
+                            continue;
+                        available.sort((a, b) => a.fundingRate - b.fundingRate);
+                        const lowest = available[0];
+                        const highest = available[available.length - 1];
+                        if (lowest.exchange === highest.exchange)
+                            continue;
+                        const annualSpread = computeAnnualSpread(highest.fundingRate, highest.exchange, lowest.fundingRate, lowest.exchange);
+                        if (annualSpread >= params.minSpread) {
+                            const longEx = lowest.exchange;
+                            const shortEx = highest.exchange;
+                            log(`[ARB] ENTRY signal: ${symbol} spread ${annualSpread.toFixed(1)}% — long ${longEx} (${(lowest.fundingRate * 100).toFixed(4)}%) / short ${shortEx} (${(highest.fundingRate * 100).toFixed(4)}%)`);
+                            if (params.autoExecute) {
+                                const longAdapter = adapters.get(longEx);
+                                const shortAdapter = adapters.get(shortEx);
+                                if (!longAdapter || !shortAdapter) {
+                                    log(`[ARB] Skip: adapter not available for ${longEx} or ${shortEx}`);
                                     continue;
                                 }
-                            }
-                            try {
-                                log(`[ARB] Opening: ${matched.size} ${symbol} on both legs ($${matched.notional.toFixed(0)}/leg, slippage ~${liq.longSlippage.toFixed(2)}%/${liq.shortSlippage.toFixed(2)}%)...`);
-                                await Promise.all([
-                                    longAdapter.marketOrder(symbol, "buy", matched.size),
-                                    shortAdapter.marketOrder(symbol, "sell", matched.size),
-                                ]);
-                                // Verify fills match, correct if needed
+                                // Check orderbook liquidity & adjust size
+                                const requestedUsd = params.sizeUsd ?? Number(params.size) * highest.markPrice;
+                                const liq = await checkArbLiquidity(longAdapter, shortAdapter, symbol, requestedUsd, 0.5, log);
+                                if (!liq.viable)
+                                    continue;
+                                // Compute matched size (same for both legs)
+                                const matched = computeMatchedSize(liq.adjustedSizeUsd, highest.markPrice, longEx, shortEx);
+                                if (!matched) {
+                                    log(`[ARB] Skip ${symbol}: can't compute matched size (min notional or precision issue)`);
+                                    continue;
+                                }
+                                // Check balances before trading
+                                if (balanceSnapshots) {
+                                    if (!hasEnoughBalance(balanceSnapshots, longEx, matched.notional) ||
+                                        !hasEnoughBalance(balanceSnapshots, shortEx, matched.notional)) {
+                                        log(`[ARB] Skip ${symbol}: insufficient balance on ${longEx} or ${shortEx} (need ~$${matched.notional.toFixed(0)} per leg)`);
+                                        continue;
+                                    }
+                                }
                                 try {
-                                    const recon = await reconcileArbFills(longAdapter, shortAdapter, symbol, log);
-                                    if (!recon.matched) {
-                                        log(`[ARB] WARNING: fills not matched after correction attempt`);
+                                    log(`[ARB] Opening: ${matched.size} ${symbol} on both legs ($${matched.notional.toFixed(0)}/leg, slippage ~${liq.longSlippage.toFixed(2)}%/${liq.shortSlippage.toFixed(2)}%)...`);
+                                    await Promise.all([
+                                        longAdapter.marketOrder(symbol, "buy", matched.size),
+                                        shortAdapter.marketOrder(symbol, "sell", matched.size),
+                                    ]);
+                                    // Verify fills match, correct if needed
+                                    try {
+                                        const recon = await reconcileArbFills(longAdapter, shortAdapter, symbol, log);
+                                        if (!recon.matched) {
+                                            log(`[ARB] WARNING: fills not matched after correction attempt`);
+                                        }
                                     }
+                                    catch { /* non-critical */ }
+                                    positions.push({
+                                        symbol,
+                                        longExchange: longEx,
+                                        shortExchange: shortEx,
+                                        size: matched.size,
+                                        entrySpread: annualSpread,
+                                        openedAt: Date.now(),
+                                        entryPrices: { long: lowest.markPrice, short: highest.markPrice },
+                                    });
+                                    log(`[ARB] OPENED ${symbol} delta-neutral (${positions.length}/${maxPos})`);
+                                }
+                                catch (err) {
+                                    const msg = err instanceof Error ? err.message : String(err);
+                                    log(`[ARB] Entry error: ${msg}`);
                                 }
-                                catch { /* non-critical */ }
-                                positions.push({
-                                    symbol,
-                                    longExchange: longEx,
-                                    shortExchange: shortEx,
-                                    size: matched.size,
-                                    entrySpread: annualSpread,
-                                    openedAt: Date.now(),
-                                    entryPrices: { long: lowest.markPrice, short: highest.markPrice },
-                                });
-                                log(`[ARB] OPENED ${symbol} delta-neutral (${positions.length}/${maxPos})`);
-                            }
-                            catch (err) {
-                                const msg = err instanceof Error ? err.message : String(err);
-                                log(`[ARB] Entry error: ${msg}`);
                             }
                         }
                     }
                 }
+                // ── Update job state ──
+                if (jobId) {
+                    updateJobState(jobId, {
+                        result: {
+                            cycle: cycleCount,
+                            activePositions: positions.length,
+                            positions: positions.map((p) => ({
+                                symbol: p.symbol,
+                                long: p.longExchange,
+                                short: p.shortExchange,
+                                size: p.size,
+                                entrySpread: p.entrySpread,
+                                hoursOpen: ((Date.now() - p.openedAt) / 3_600_000).toFixed(1),
+                            })),
+                            lastCheck: new Date().toISOString(),
+                        },
+                    });
+                }
+                // Periodic status log
+                if (cycleCount % 10 === 0) {
+                    const posInfo = positions.length > 0
+                        ? positions.map((p) => `${p.symbol}(${p.entrySpread.toFixed(0)}%)`).join(", ")
+                        : "none";
+                    log(`[ARB] Cycle ${cycleCount} | ${positions.length} positions: ${posInfo} | ${rateMap.size} symbols`);
+                }
             }
-            // ── Update job state ──
-            if (jobId) {
-                updateJobState(jobId, {
-                    result: {
-                        cycle: cycleCount,
-                        activePositions: positions.length,
-                        positions: positions.map((p) => ({
-                            symbol: p.symbol,
-                            long: p.longExchange,
-                            short: p.shortExchange,
-                            size: p.size,
-                            entrySpread: p.entrySpread,
-                            hoursOpen: ((Date.now() - p.openedAt) / 3_600_000).toFixed(1),
-                        })),
-                        lastCheck: new Date().toISOString(),
-                    },
-                });
-            }
-            // Periodic status log
-            if (cycleCount % 10 === 0) {
-                const posInfo = positions.length > 0
-                    ? positions.map((p) => `${p.symbol}(${p.entrySpread.toFixed(0)}%)`).join(", ")
-                    : "none";
-                log(`[ARB] Cycle ${cycleCount} | ${positions.length} positions: ${posInfo} | ${rateMap.size} symbols`);
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log(`[ARB] Cycle error: ${msg}`);
             }
+            if (running)
+                await sleep(params.intervalSec * 1000);
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            log(`[ARB] Cycle error: ${msg}`);
-        }
-        await sleep(params.intervalSec * 1000);
     }
+    finally {
+        process.removeListener("SIGINT", shutdown);
+        process.removeListener("SIGTERM", shutdown);
+    }
+    log(`[ARB] Funding rate arbitrage stopped. Positions: ${positions.length}`);
 }
 async function closeAllPositions(positions, adapters, log) {
     for (const pos of positions) {

package/dist/strategies/grid.d.ts

@@ -1,4 +1,4 @@
-import type { ExchangeAdapter } from "../exchanges/interface.js";
+import type { ExchangeAdapter } from "../exchanges/index.js";
 export interface GridParams {
     symbol: string;
     side: "long" | "short" | "neutral";

package/dist/strategies/grid.js

@@ -131,7 +131,7 @@ export async function runGrid(adapter, params, jobId, log = console.log) {
                     const equity = parseFloat(bal.equity);
                     if (equity > state.peakEquity)
                         state.peakEquity = equity;
-                    const drawdown = ((state.peakEquity - equity) / state.peakEquity) * 100;
+                    const drawdown = state.peakEquity > 0 ? ((state.peakEquity - equity) / state.peakEquity) * 100 : 0;
                     if (drawdown > params.trailingStop) {
                         log(`[GRID] Trailing stop triggered (${drawdown.toFixed(1)}% drawdown). Stopping.`);
                         break;

package/dist/strategies/index.d.ts

@@ -0,0 +1,12 @@
+export { runGrid } from "./grid.js";
+export type { GridParams, GridState } from "./grid.js";
+export { runDCA } from "./dca.js";
+export type { DCAParams, DCAState } from "./dca.js";
+export { runTWAP } from "./twap.js";
+export type { TWAPParams, TWAPState } from "./twap.js";
+export { runFundingArb } from "./funding-arb.js";
+export type { FundingArbParams } from "./funding-arb.js";
+export { runTrailingStop } from "./trailing-stop.js";
+export type { TrailingStopParams, TrailingStopResult } from "./trailing-stop.js";
+export { runSplitOrder } from "./split-order.js";
+export type { SplitOrderParams, SplitSlice, SplitOrderResult } from "./split-order.js";

package/dist/strategies/index.js

@@ -0,0 +1,7 @@
+// strategies/ barrel — public API
+export { runGrid } from "./grid.js";
+export { runDCA } from "./dca.js";
+export { runTWAP } from "./twap.js";
+export { runFundingArb } from "./funding-arb.js";
+export { runTrailingStop } from "./trailing-stop.js";
+export { runSplitOrder } from "./split-order.js";

package/dist/strategies/split-order.d.ts

@@ -12,7 +12,7 @@
  *   3. Place IOC limit at best price + slippage tolerance
  *   4. Wait for book to refresh, then repeat
  */
-import type { ExchangeAdapter } from "../exchanges/interface.js";
+import type { ExchangeAdapter } from "../exchanges/index.js";
 export interface SplitOrderParams {
     symbol: string;
     side: "buy" | "sell";

package/dist/strategies/trailing-stop.d.ts

@@ -1,4 +1,4 @@
-import type { ExchangeAdapter } from "../exchanges/interface.js";
+import type { ExchangeAdapter } from "../exchanges/index.js";
 export interface TrailingStopParams {
     symbol: string;
     trailPct: number;

package/dist/strategies/twap.d.ts

@@ -1,4 +1,4 @@
-import type { ExchangeAdapter } from "../exchanges/interface.js";
+import type { ExchangeAdapter } from "../exchanges/index.js";
 export interface TWAPParams {
     symbol: string;
     side: "buy" | "sell";

package/dist/trade-validator.d.ts

@@ -1,4 +1,4 @@
-import type { ExchangeAdapter } from "./exchanges/interface.js";
+import type { ExchangeAdapter } from "./exchanges/index.js";
 export interface CheckResult {
     check: "symbol_valid" | "balance_sufficient" | "price_fresh" | "liquidity_ok" | "risk_limits" | "position_exists";
     passed: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perp-cli",
-  "version": "0.6.4",
+  "version": "0.7.1",
   "description": "Multi-DEX Perpetual Futures CLI - Pacifica, Hyperliquid, Lighter",
   "bin": {
     "perp": "dist/index.js",
@@ -46,6 +46,7 @@
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@msgpack/msgpack": "^3.1.3",
     "@solana/web3.js": "^1.98.0",
+    "@types/react": "^19.2.14",
     "bs58": "^6.0.0",
     "chalk": "^5.4.1",
     "cli-table3": "^0.6.5",
@@ -53,7 +54,11 @@
     "dotenv": "^16.5.0",
     "ethers": "^6.13.2",
     "hyperliquid": "^1.7.7",
+    "ink": "^6.8.0",
+    "ink-spinner": "^5.0.0",
+    "ink-table": "^3.1.0",
     "lighter-ts-sdk": "^1.0.10",
+    "react": "^19.2.4",
     "tweetnacl": "^1.0.3",
     "ws": "^8.19.0",
     "yaml": "^2.8.2",
@@ -62,6 +67,7 @@
   "devDependencies": {
     "@types/node": "^25.3.3",
     "@types/ws": "^8.18.1",
+    "ts-morph": "^27.0.2",
     "tsup": "^8.4.0",
     "tsx": "^4.21.0",
     "typescript": "^5.7.0",

package/skills/perp-cli/SKILL.md

@@ -98,6 +98,26 @@ perp --json arb close ETH                   # sells spot + buys back perp
 
 Spot exchanges: HL, LT. Pacifica is perp-only.
 
+## Bot Engine (19 Strategies)
+
+```bash
+perp bot list-strategies                              # list all 19 strategies
+perp bot run <strategy> [symbol]                      # run any registered strategy
+perp bot run funding-auto                             # multi-exchange funding arb
+perp bot apex [symbol]                                # APEX orchestrator (Radar+Pulse+Guard)
+perp bot reflect                                      # performance analysis (win rate, fees, PnL)
+perp bot preset-list                                  # list strategy presets
+perp bot preset <name> [symbol]                       # run from preset
+perp bot start <config.yaml>                          # start from YAML/JSON config
+perp bot quick-grid <symbol>                          # quick grid bot
+perp bot quick-dca <symbol> <side> <amount> <interval>
+perp bot quick-arb                                    # quick funding arb
+```
+
+**Strategies:** simple-mm, engine-mm, avellaneda-mm, regime-mm, grid-mm, liquidation-mm, momentum-breakout, mean-reversion, aggressive-taker, funding-arb, funding-auto, basis-arb, hedge-agent, rfq-agent, claude-agent, grid, dca, twap, apex
+
+**Flags:** `--dry-run` (simulate without executing), `--headless` (no TUI, log only)
+
 ## Core Workflow: Single Trade
 
 ```bash