perp-cli 0.11.0 → 0.12.1

package/dist/__tests__/utils.test.js

@@ -1,76 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { formatUsd, formatPnl, formatPercent, printJson } from "../utils.js";
-describe("formatUsd", () => {
-    it("formats numeric strings", () => {
-        expect(formatUsd("1234.5")).toBe("1,234.50");
-    });
-    it("formats numbers", () => {
-        expect(formatUsd(99999.999)).toBe("100,000.00");
-    });
-    it("returns original string for NaN", () => {
-        expect(formatUsd("abc")).toBe("abc");
-    });
-    it("formats zero", () => {
-        expect(formatUsd(0)).toBe("0.00");
-    });
-    it("formats negative numbers", () => {
-        expect(formatUsd(-42.1)).toBe("-42.10");
-    });
-});
-describe("formatPnl", () => {
-    it("positive PnL has + prefix", () => {
-        const result = formatPnl(100);
-        expect(result).toContain("+$100.00");
-    });
-    it("negative PnL has - prefix", () => {
-        const result = formatPnl(-50);
-        expect(result).toContain("-$50.00");
-    });
-    it("zero PnL", () => {
-        const result = formatPnl(0);
-        expect(result).toContain("$0.00");
-    });
-    it("handles string input", () => {
-        const result = formatPnl("123.456");
-        expect(result).toContain("$123.46");
-    });
-    it("handles NaN", () => {
-        expect(formatPnl("abc")).toBe("abc");
-    });
-});
-describe("formatPercent", () => {
-    it("positive percent", () => {
-        const result = formatPercent(0.0015);
-        expect(result).toContain("+0.1500%");
-    });
-    it("negative percent", () => {
-        const result = formatPercent(-0.0025);
-        expect(result).toContain("-0.2500%");
-    });
-    it("zero percent", () => {
-        const result = formatPercent(0);
-        expect(result).toContain("0.0000%");
-    });
-    it("handles NaN", () => {
-        expect(formatPercent("abc")).toBe("abc");
-    });
-});
-describe("printJson", () => {
-    it("outputs valid JSON to console", () => {
-        const logs = [];
-        const origLog = console.log;
-        console.log = (...args) => logs.push(args.join(" "));
-        printJson({ a: 1, b: "hello" });
-        console.log = origLog;
-        const parsed = JSON.parse(logs[0]);
-        expect(parsed).toEqual({ a: 1, b: "hello" });
-    });
-    it("handles arrays", () => {
-        const logs = [];
-        const origLog = console.log;
-        console.log = (...args) => logs.push(args.join(" "));
-        printJson([1, 2, 3]);
-        console.log = origLog;
-        expect(JSON.parse(logs[0])).toEqual([1, 2, 3]);
-    });
-});

package/dist/arb/reconcile.d.ts

@@ -1,28 +0,0 @@
-import type { ExchangeAdapter } from "../exchanges/interface.js";
-export interface ReconciliationIssue {
-    type: "orphan" | "phantom" | "size_mismatch";
-    symbol: string;
-    exchange: string;
-    side: "long" | "short";
-    localSize: number | null;
-    exchangeSize: number | null;
-    severity: "warning" | "critical";
-    suggestion: string;
-}
-export interface ReconciliationResult {
-    issues: ReconciliationIssue[];
-    healthy: number;
-    fixesApplied?: string[];
-}
-/**
- * Reconcile local arb state with actual exchange positions.
- *
- * Detects three types of issues:
- * - **Orphan**: Position exists on exchange but not in local arb state (manual entry?)
- * - **Phantom**: Position exists in local state but not on exchange (liquidated? manually closed?)
- * - **Size mismatch**: Both exist but sizes differ beyond tolerance
- */
-export declare function reconcileArbPositions(adapters: Map<string, ExchangeAdapter>, opts?: {
-    fix?: boolean;
-    tolerancePct?: number;
-}): Promise<ReconciliationResult>;

package/dist/arb/reconcile.js

@@ -1,162 +0,0 @@
-import { getPositions, removePosition, updatePosition } from "./state.js";
-/** Normalize symbol for comparison (strip -PERP suffix, uppercase) */
-function normalizeSymbol(symbol) {
-    return symbol.toUpperCase().replace(/-PERP$/, "");
-}
-/** Find a matching exchange position by symbol */
-function findExchangePosition(positions, symbol, side) {
-    const norm = normalizeSymbol(symbol);
-    return positions.find(p => normalizeSymbol(p.symbol) === norm && p.side === side);
-}
-/**
- * Reconcile local arb state with actual exchange positions.
- *
- * Detects three types of issues:
- * - **Orphan**: Position exists on exchange but not in local arb state (manual entry?)
- * - **Phantom**: Position exists in local state but not on exchange (liquidated? manually closed?)
- * - **Size mismatch**: Both exist but sizes differ beyond tolerance
- */
-export async function reconcileArbPositions(adapters, opts) {
-    const tolerancePct = opts?.tolerancePct ?? 1;
-    const shouldFix = opts?.fix ?? false;
-    const issues = [];
-    const fixesApplied = [];
-    let healthy = 0;
-    const localPositions = getPositions();
-    // Fetch all exchange positions
-    const exchangePositions = new Map();
-    for (const [name, adapter] of adapters) {
-        try {
-            const pos = await adapter.getPositions();
-            exchangePositions.set(name, pos);
-        }
-        catch {
-            exchangePositions.set(name, []);
-        }
-    }
-    // Track which exchange positions are accounted for
-    const accountedFor = new Set(); // "exchange:symbol:side"
-    // Check each local arb position against exchange
-    for (const arb of localPositions) {
-        // Check long leg
-        const longPositions = exchangePositions.get(arb.longExchange) ?? [];
-        const longMatch = findExchangePosition(longPositions, arb.symbol, "long");
-        if (!longMatch) {
-            issues.push({
-                type: "phantom",
-                symbol: arb.symbol,
-                exchange: arb.longExchange,
-                side: "long",
-                localSize: arb.longSize,
-                exchangeSize: null,
-                severity: "critical",
-                suggestion: `Local state has long ${arb.symbol} on ${arb.longExchange} but exchange has no position. May have been liquidated or manually closed.`,
-            });
-            if (shouldFix) {
-                removePosition(arb.symbol);
-                fixesApplied.push(`Removed phantom position ${arb.symbol} (long leg missing on ${arb.longExchange})`);
-                continue; // Skip short leg check since we removed the position
-            }
-        }
-        else {
-            accountedFor.add(`${arb.longExchange}:${normalizeSymbol(arb.symbol)}:long`);
-            const exchangeSize = Math.abs(Number(longMatch.size));
-            const localSize = Math.abs(arb.longSize);
-            const diffPct = localSize > 0 ? (Math.abs(exchangeSize - localSize) / localSize) * 100 : 0;
-            if (diffPct > tolerancePct) {
-                issues.push({
-                    type: "size_mismatch",
-                    symbol: arb.symbol,
-                    exchange: arb.longExchange,
-                    side: "long",
-                    localSize,
-                    exchangeSize,
-                    severity: "warning",
-                    suggestion: `Long size mismatch: local ${localSize} vs exchange ${exchangeSize} (${diffPct.toFixed(1)}% diff). Partial fill or manual adjustment?`,
-                });
-                if (shouldFix) {
-                    updatePosition(arb.symbol, { longSize: exchangeSize });
-                    fixesApplied.push(`Updated ${arb.symbol} long size: ${localSize} → ${exchangeSize}`);
-                }
-            }
-            else {
-                healthy++;
-            }
-        }
-        // Check short leg
-        const shortPositions = exchangePositions.get(arb.shortExchange) ?? [];
-        const shortMatch = findExchangePosition(shortPositions, arb.symbol, "short");
-        if (!shortMatch) {
-            // Don't double-report if we already removed via fix
-            if (shouldFix && !getPositions().find(p => p.symbol === arb.symbol))
-                continue;
-            issues.push({
-                type: "phantom",
-                symbol: arb.symbol,
-                exchange: arb.shortExchange,
-                side: "short",
-                localSize: arb.shortSize,
-                exchangeSize: null,
-                severity: "critical",
-                suggestion: `Local state has short ${arb.symbol} on ${arb.shortExchange} but exchange has no position. May have been liquidated or manually closed.`,
-            });
-            if (shouldFix) {
-                removePosition(arb.symbol);
-                fixesApplied.push(`Removed phantom position ${arb.symbol} (short leg missing on ${arb.shortExchange})`);
-            }
-        }
-        else {
-            accountedFor.add(`${arb.shortExchange}:${normalizeSymbol(arb.symbol)}:short`);
-            const exchangeSize = Math.abs(Number(shortMatch.size));
-            const localSize = Math.abs(arb.shortSize);
-            const diffPct = localSize > 0 ? (Math.abs(exchangeSize - localSize) / localSize) * 100 : 0;
-            if (diffPct > tolerancePct) {
-                issues.push({
-                    type: "size_mismatch",
-                    symbol: arb.symbol,
-                    exchange: arb.shortExchange,
-                    side: "short",
-                    localSize,
-                    exchangeSize,
-                    severity: "warning",
-                    suggestion: `Short size mismatch: local ${localSize} vs exchange ${exchangeSize} (${diffPct.toFixed(1)}% diff). Partial fill or manual adjustment?`,
-                });
-                if (shouldFix) {
-                    updatePosition(arb.symbol, { shortSize: exchangeSize });
-                    fixesApplied.push(`Updated ${arb.symbol} short size: ${localSize} → ${exchangeSize}`);
-                }
-            }
-            else {
-                healthy++;
-            }
-        }
-    }
-    // Check for orphan positions (on exchange but not in local state)
-    for (const [exchangeName, positions] of exchangePositions) {
-        for (const pos of positions) {
-            const key = `${exchangeName}:${normalizeSymbol(pos.symbol)}:${pos.side}`;
-            if (!accountedFor.has(key)) {
-                // Check if this exchange is used in any arb position
-                const isArbExchange = localPositions.some(p => p.longExchange === exchangeName || p.shortExchange === exchangeName);
-                // Only report orphans on exchanges that are part of arb state
-                if (isArbExchange || localPositions.length > 0) {
-                    issues.push({
-                        type: "orphan",
-                        symbol: pos.symbol,
-                        exchange: exchangeName,
-                        side: pos.side,
-                        localSize: null,
-                        exchangeSize: Math.abs(Number(pos.size)),
-                        severity: "warning",
-                        suggestion: `Position on ${exchangeName} not tracked in arb state. Manual entry or untracked strategy?`,
-                    });
-                }
-            }
-        }
-    }
-    return {
-        issues,
-        healthy,
-        ...(fixesApplied.length > 0 ? { fixesApplied } : {}),
-    };
-}

package/dist/commands/alert.d.ts

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