perp-cli 0.6.4 → 0.7.1

package/dist/bot/strategies/apex-strategy.js

@@ -0,0 +1,185 @@
+import { registerStrategy } from "../strategy-registry.js";
+import { scoreOpportunity, detectPulse, tierRank, evaluateGuard, createGuardState, GUARD_PRESETS, } from "../apex/index.js";
+const DEFAULT_CONFIG = {
+    maxSlots: 3,
+    minRadarScore: 200,
+    minPulseTier: "IMMEDIATE_MOVER",
+    guardPreset: "moderate",
+    dailyLossLimit: 250,
+    size: 0.1,
+    leverage: 5,
+};
+function resolveConfig(raw) {
+    return {
+        maxSlots: Number(raw.maxSlots ?? DEFAULT_CONFIG.maxSlots),
+        minRadarScore: Number(raw.minRadarScore ?? DEFAULT_CONFIG.minRadarScore),
+        minPulseTier: raw.minPulseTier ?? DEFAULT_CONFIG.minPulseTier,
+        guardPreset: String(raw.guardPreset ?? DEFAULT_CONFIG.guardPreset),
+        dailyLossLimit: Number(raw.dailyLossLimit ?? DEFAULT_CONFIG.dailyLossLimit),
+        size: Number(raw.size ?? DEFAULT_CONFIG.size),
+        leverage: Number(raw.leverage ?? DEFAULT_CONFIG.leverage),
+    };
+}
+export class ApexStrategy {
+    name = "apex";
+    cfg = DEFAULT_CONFIG;
+    guardConfig = GUARD_PRESETS.moderate;
+    slots = [];
+    pulseHistory = new Map();
+    dailyLoss = 0;
+    describe() {
+        return {
+            description: "APEX orchestrator: Radar screening + Pulse momentum + Guard trailing stops. Multi-slot concurrent positions.",
+            params: [
+                { name: "maxSlots", type: "number", required: false, default: 3, description: "Max concurrent positions" },
+                { name: "minRadarScore", type: "number", required: false, default: 200, description: "Minimum Radar score to consider (0-400)" },
+                { name: "minPulseTier", type: "string", required: false, default: "IMMEDIATE_MOVER", description: "Minimum Pulse tier for entry" },
+                { name: "guardPreset", type: "string", required: false, default: "moderate", description: "Guard stop preset: conservative, moderate, aggressive" },
+                { name: "dailyLossLimit", type: "number", required: false, default: 250, description: "Daily loss limit in USD" },
+                { name: "size", type: "number", required: true, description: "Position size per slot" },
+                { name: "leverage", type: "number", required: false, default: 5, description: "Leverage to set on entry" },
+            ],
+        };
+    }
+    async init(ctx, _snapshot) {
+        this.cfg = resolveConfig(ctx.config);
+        this.guardConfig = GUARD_PRESETS[this.cfg.guardPreset] ?? GUARD_PRESETS.moderate;
+        this.slots = [];
+        this.pulseHistory.clear();
+        this.dailyLoss = 0;
+        ctx.log(`  [APEX] Initialized | slots=${this.cfg.maxSlots} radar>=${this.cfg.minRadarScore} pulse>=${this.cfg.minPulseTier} guard=${this.cfg.guardPreset}`);
+    }
+    async onTick(ctx, snapshot) {
+        const actions = [];
+        // Daily loss circuit breaker
+        if (this.dailyLoss >= this.cfg.dailyLossLimit) {
+            ctx.log(`  [APEX] Daily loss limit reached ($${this.dailyLoss.toFixed(2)}/$${this.cfg.dailyLossLimit})`);
+            return [];
+        }
+        // ── Phase 1: Manage existing slots (Guard) ──
+        const closedSlots = [];
+        for (let i = 0; i < this.slots.length; i++) {
+            const slot = this.slots[i];
+            const roe = this.calculateRoe(slot, snapshot.price);
+            const { action, newState } = evaluateGuard(roe, slot.guard, this.guardConfig);
+            slot.guard = newState;
+            if (action === "close") {
+                ctx.log(`  [APEX] Guard close slot ${slot.symbol} ${slot.side} | ROE=${roe.toFixed(2)}% floor=${newState.currentFloor.toFixed(2)}%`);
+                actions.push({
+                    type: "place_order",
+                    side: slot.side === "buy" ? "sell" : "buy",
+                    price: snapshot.price.toFixed(2),
+                    size: String(slot.size),
+                    orderType: "market",
+                    reduceOnly: true,
+                });
+                // Track daily loss
+                if (roe < 0) {
+                    this.dailyLoss += Math.abs(roe / 100) * slot.size * slot.entryPrice;
+                }
+                closedSlots.push(i);
+            }
+        }
+        // Remove closed slots (reverse order to preserve indices)
+        for (const idx of closedSlots.reverse()) {
+            this.slots.splice(idx, 1);
+        }
+        // ── Phase 2: Record pulse history ──
+        const currentOi = parseFloat(snapshot.openInterest);
+        const currentVolume = snapshot.volume24h;
+        const historyKey = ctx.symbol;
+        const existing = this.pulseHistory.get(historyKey) ?? [];
+        existing.push({ oi: currentOi, volume: currentVolume });
+        // Keep last 10 entries
+        if (existing.length > 10)
+            existing.shift();
+        this.pulseHistory.set(historyKey, existing);
+        // ── Phase 3: Look for new entries if slots available ──
+        if (this.slots.length < this.cfg.maxSlots) {
+            // Already tracking this symbol in a slot?
+            const symbolInSlot = this.slots.some(s => s.symbol === ctx.symbol);
+            if (!symbolInSlot) {
+                // Score with Radar
+                const radarScore = scoreOpportunity(snapshot, null);
+                radarScore.symbol = ctx.symbol;
+                // Detect Pulse
+                const pulse = detectPulse(snapshot, this.pulseHistory);
+                pulse.symbol = ctx.symbol;
+                const meetsRadar = radarScore.total >= this.cfg.minRadarScore;
+                const meetsPulse = tierRank(pulse.tier) >= tierRank(this.cfg.minPulseTier);
+                if (meetsRadar && meetsPulse) {
+                    // Determine direction from funding + technicals
+                    const side = this.determineSide(snapshot, radarScore, pulse);
+                    ctx.log(`  [APEX] Entry signal | ${ctx.symbol} ${side} | radar=${radarScore.total} pulse=${pulse.tier}(${pulse.confidence.toFixed(2)}) ` +
+                        `OI%=${(pulse.oiChange * 100).toFixed(1)} vol=${pulse.volumeRatio.toFixed(1)}x`);
+                    // Set leverage first
+                    actions.push({
+                        type: "set_leverage",
+                        leverage: this.cfg.leverage,
+                    });
+                    // Enter position
+                    actions.push({
+                        type: "place_order",
+                        side,
+                        price: snapshot.price.toFixed(2),
+                        size: String(this.cfg.size),
+                        orderType: "market",
+                    });
+                    this.slots.push({
+                        symbol: ctx.symbol,
+                        side,
+                        entryPrice: snapshot.price,
+                        size: this.cfg.size,
+                        guard: createGuardState(),
+                    });
+                }
+                else {
+                    ctx.log(`  [APEX] No entry | radar=${radarScore.total}/${this.cfg.minRadarScore} ` +
+                        `pulse=${pulse.tier} | slots=${this.slots.length}/${this.cfg.maxSlots}`);
+                }
+            }
+        }
+        return actions;
+    }
+    async onStop(ctx) {
+        const actions = [];
+        // Close all active slots
+        for (const slot of this.slots) {
+            ctx.log(`  [APEX] Closing slot ${slot.symbol} ${slot.side} on stop`);
+            actions.push({
+                type: "place_order",
+                side: slot.side === "buy" ? "sell" : "buy",
+                price: "0",
+                size: String(slot.size),
+                orderType: "market",
+                reduceOnly: true,
+            });
+        }
+        this.slots = [];
+        return actions;
+    }
+    // ── Private helpers ──
+    calculateRoe(slot, currentPrice) {
+        if (slot.entryPrice === 0)
+            return 0;
+        const priceDelta = currentPrice - slot.entryPrice;
+        const direction = slot.side === "buy" ? 1 : -1;
+        return (direction * priceDelta / slot.entryPrice) * 100;
+    }
+    determineSide(snapshot, _radarScore, _pulse) {
+        // Funding-based bias: negative funding → longs are cheap → buy
+        // Positive funding → shorts are cheap → sell
+        const fr = snapshot.fundingRate;
+        // RSI confirmation
+        const rsi = snapshot.rsi;
+        const rsiOversold = !isNaN(rsi) && rsi < 35;
+        const rsiOverbought = !isNaN(rsi) && rsi > 65;
+        if (fr < -0.0001 || rsiOversold)
+            return "buy";
+        if (fr > 0.0001 || rsiOverbought)
+            return "sell";
+        // Default to buy in ambiguous conditions
+        return "buy";
+    }
+}
+registerStrategy("apex", (_config) => new ApexStrategy());

package/dist/bot/strategies/avellaneda-mm.d.ts

@@ -0,0 +1,27 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class AvellanedaMmStrategy implements Strategy {
+    readonly name = "avellaneda-mm";
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        })[];
+    };
+    private get params();
+    private _config;
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(_ctx: StrategyContext): Promise<StrategyAction[]>;
+    /** Estimate sigma from ATR or use override */
+    private estimateSigma;
+}

package/dist/bot/strategies/avellaneda-mm.js

@@ -0,0 +1,111 @@
+import { registerStrategy } from "../strategy-registry.js";
+import { calculateATR } from "../indicators.js";
+export class AvellanedaMmStrategy {
+    name = "avellaneda-mm";
+    describe() {
+        return {
+            description: "Avellaneda-Stoikov optimal market making with inventory-adjusted reservation price",
+            params: [
+                { name: "gamma", type: "number", required: false, default: 0.1, description: "Risk aversion parameter" },
+                { name: "kappa", type: "number", required: false, default: 1.5, description: "Order arrival rate" },
+                { name: "sigma", type: "number", required: false, default: 0, description: "Volatility override (0 = auto)" },
+                { name: "maxPosition", type: "number", required: true, description: "Maximum position size" },
+                { name: "timeHorizon", type: "number", required: false, default: 86400, description: "Session length in seconds" },
+                { name: "size", type: "number", required: true, description: "Order size per level" },
+            ],
+        };
+    }
+    get params() {
+        return this._config;
+    }
+    _config = {};
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("inventory", 0);
+        ctx.state.set("sessionStart", Date.now());
+        const p = this.params;
+        ctx.log(`  [AVELLANEDA-MM] gamma=${p.gamma}, kappa=${p.kappa}, sigma=${p.sigma || "auto"}, maxPos=${p.maxPosition}, T=${p.timeHorizon}s`);
+    }
+    async onTick(ctx, snapshot) {
+        const params = this.params;
+        const actions = [];
+        actions.push({ type: "cancel_all" });
+        const gamma = params.gamma || 0.1;
+        const kappa = params.kappa || 1.5;
+        const mid = snapshot.price;
+        // Estimate sigma (volatility) from ATR or use override
+        const sigma = this.estimateSigma(snapshot, params.sigma);
+        // Time remaining: fraction of session left
+        const sessionStart = ctx.state.get("sessionStart") ?? Date.now();
+        const elapsed = (Date.now() - sessionStart) / 1000;
+        const timeHorizon = params.timeHorizon || 86400;
+        const timeRemaining = Math.max(timeHorizon - elapsed, 1) / timeHorizon; // (T-t)/T normalized
+        // Current inventory
+        const q = ctx.state.get("inventory") ?? 0;
+        // Avellaneda-Stoikov reservation price:
+        // r = mid - q * gamma * sigma^2 * (T-t)
+        const reservationPrice = mid - q * gamma * (sigma ** 2) * timeRemaining;
+        // Optimal spread:
+        // delta = gamma * sigma^2 * (T-t) + (2/gamma) * ln(1 + gamma/kappa)
+        const optimalSpread = gamma * (sigma ** 2) * timeRemaining + (2 / gamma) * Math.log(1 + gamma / kappa);
+        const spreadInPrice = optimalSpread * mid; // convert to price terms
+        const bidPrice = reservationPrice - spreadInPrice / 2;
+        const askPrice = reservationPrice + spreadInPrice / 2;
+        // Clamp to max position: skip orders that would exceed
+        const size = params.size;
+        if (q < params.maxPosition && bidPrice > 0) {
+            actions.push({
+                type: "place_order",
+                side: "buy",
+                price: bidPrice.toFixed(6),
+                size: String(size),
+                orderType: "limit",
+            });
+        }
+        if (q > -params.maxPosition && askPrice > 0) {
+            actions.push({
+                type: "place_order",
+                side: "sell",
+                price: askPrice.toFixed(6),
+                size: String(size),
+                orderType: "limit",
+            });
+        }
+        // Update inventory estimate
+        const prevMid = ctx.state.get("prevMid") ?? mid;
+        if (mid > prevMid && q < params.maxPosition) {
+            ctx.state.set("inventory", q + size * 0.5);
+        }
+        else if (mid < prevMid && q > -params.maxPosition) {
+            ctx.state.set("inventory", q - size * 0.5);
+        }
+        ctx.state.set("prevMid", mid);
+        if (ctx.tick % 10 === 0) {
+            ctx.log(`  [AVELLANEDA-MM] r=$${reservationPrice.toFixed(2)}, spread=$${spreadInPrice.toFixed(4)}, q=${q.toFixed(4)}, sigma=${sigma.toFixed(6)}, T-t=${timeRemaining.toFixed(3)}`);
+        }
+        return actions;
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+    /** Estimate sigma from ATR or use override */
+    estimateSigma(snapshot, sigmaOverride) {
+        if (sigmaOverride > 0)
+            return sigmaOverride;
+        if (snapshot.klines.length >= 15) {
+            const candles = snapshot.klines.map(k => ({
+                high: parseFloat(k.high),
+                low: parseFloat(k.low),
+                close: parseFloat(k.close),
+            }));
+            const atr = calculateATR(candles, 14);
+            if (atr.length > 0) {
+                // Normalize ATR to fractional volatility
+                return atr[atr.length - 1] / snapshot.price;
+            }
+        }
+        // Fallback: use 24h volatility from snapshot
+        return snapshot.volatility24h / 100 || 0.02;
+    }
+}
+registerStrategy("avellaneda-mm", (_config) => new AvellanedaMmStrategy());

package/dist/bot/strategies/basis-arb.d.ts

@@ -0,0 +1,27 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class BasisArbStrategy implements Strategy {
+    readonly name = "basis-arb";
+    private _config;
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        })[];
+    };
+    private get annualizedBasisThreshold();
+    private get size();
+    private get holdingPeriodHours();
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(ctx: StrategyContext): Promise<StrategyAction[]>;
+}

package/dist/bot/strategies/basis-arb.js

@@ -0,0 +1,97 @@
+import { registerStrategy } from "../strategy-registry.js";
+export class BasisArbStrategy {
+    name = "basis-arb";
+    _config = {};
+    describe() {
+        return {
+            description: "Basis arbitrage — collect funding by positioning against extreme rates",
+            params: [
+                { name: "annualizedBasisThreshold", type: "number", required: false, default: 30, description: "Annualized funding % to trigger entry" },
+                { name: "size", type: "number", required: true, description: "Position size" },
+                { name: "holdingPeriodHours", type: "number", required: false, default: 24, description: "Max hours to hold position" },
+            ],
+        };
+    }
+    get annualizedBasisThreshold() { return Number(this._config.annualizedBasisThreshold ?? 30); }
+    get size() { return Number(this._config.size ?? 0.1); }
+    get holdingPeriodHours() { return Number(this._config.holdingPeriodHours ?? 24); }
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("position", null);
+        ctx.log(`  [BASIS] Ready | threshold=${this.annualizedBasisThreshold}% holdingPeriod=${this.holdingPeriodHours}h size=${this.size}`);
+    }
+    async onTick(ctx, snapshot) {
+        const actions = [];
+        const price = snapshot.price;
+        const fundingRate = snapshot.fundingRate;
+        // Annualize: funding is per 8h period -> 3x daily -> 1095x annual
+        const annualized = fundingRate * 3 * 365 * 100; // in %
+        const position = ctx.state.get("position");
+        if (!position) {
+            // Check for entry signal
+            if (Math.abs(annualized) >= this.annualizedBasisThreshold) {
+                // Positive funding = longs pay shorts -> go short to collect
+                // Negative funding = shorts pay longs -> go long to collect
+                const side = annualized > 0 ? "sell" : "buy";
+                const newPosition = {
+                    side,
+                    entry: price,
+                    entryFunding: fundingRate,
+                    entryTime: Date.now(),
+                    size: this.size,
+                };
+                ctx.state.set("position", newPosition);
+                ctx.log(`  [BASIS] ${side.toUpperCase()} @ $${price.toFixed(2)} | funding=${annualized.toFixed(1)}% annualized (collecting ${side === "sell" ? "positive" : "negative"} funding)`);
+                actions.push({
+                    type: "place_order",
+                    side,
+                    price: price.toFixed(2),
+                    size: String(this.size),
+                    orderType: "market",
+                });
+            }
+            return actions;
+        }
+        // Manage existing position — check exit conditions
+        const hoursHeld = (Date.now() - position.entryTime) / (1000 * 60 * 60);
+        const currentAnnualized = Math.abs(annualized);
+        const holdingExpired = hoursHeld >= this.holdingPeriodHours;
+        // Exit when funding normalizes (< threshold/2 for hysteresis) or holding period expires
+        const fundingNormalized = currentAnnualized < this.annualizedBasisThreshold / 2;
+        // Also exit if funding flipped against us
+        const fundingFlipped = (position.side === "sell" && annualized < 0) ||
+            (position.side === "buy" && annualized > 0);
+        if (holdingExpired || fundingNormalized || fundingFlipped) {
+            const reason = holdingExpired
+                ? `holding period ${this.holdingPeriodHours}h expired`
+                : fundingFlipped
+                    ? "funding flipped against position"
+                    : `funding normalized (${currentAnnualized.toFixed(1)}%)`;
+            ctx.log(`  [BASIS] Close ${position.side} @ $${price.toFixed(2)} — ${reason} (held ${hoursHeld.toFixed(1)}h)`);
+            ctx.state.set("position", null);
+            actions.push({
+                type: "place_order",
+                side: position.side === "buy" ? "sell" : "buy",
+                price: price.toFixed(2),
+                size: String(position.size),
+                orderType: "market",
+                reduceOnly: true,
+            });
+        }
+        return actions;
+    }
+    async onStop(ctx) {
+        const position = ctx.state.get("position");
+        if (!position)
+            return [];
+        return [{
+                type: "place_order",
+                side: position.side === "buy" ? "sell" : "buy",
+                price: "0",
+                size: String(position.size),
+                orderType: "market",
+                reduceOnly: true,
+            }];
+    }
+}
+registerStrategy("basis-arb", (_config) => new BasisArbStrategy());

package/dist/bot/strategies/claude-agent.d.ts

@@ -0,0 +1,31 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class ClaudeAgentStrategy implements Strategy {
+    readonly name = "claude-agent";
+    private _config;
+    private get params();
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "string";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        } | {
+            name: string;
+            type: "string";
+            required: boolean;
+            default: string;
+            description: string;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        })[];
+    };
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(_ctx: StrategyContext): Promise<StrategyAction[]>;
+}

package/dist/bot/strategies/claude-agent.js

@@ -0,0 +1,155 @@
+import { registerStrategy } from "../strategy-registry.js";
+const DEFAULT_PROMPT = `You are a trading assistant. Given the following market snapshot, decide whether to BUY, SELL, or HOLD.
+Respond with ONLY one of: BUY <size>, SELL <size>, or HOLD.
+Examples: "BUY 0.1", "SELL 0.05", "HOLD"`;
+export class ClaudeAgentStrategy {
+    name = "claude-agent";
+    _config = {};
+    get params() {
+        return {
+            apiKey: String(this._config.apiKey ?? ""),
+            model: String(this._config.model ?? "claude-3-5-haiku-latest"),
+            maxPositionSize: Number(this._config.maxPositionSize ?? 0.1),
+            promptTemplate: String(this._config.promptTemplate ?? DEFAULT_PROMPT),
+            tickInterval: Number(this._config.tickInterval ?? 10),
+            apiBase: String(this._config.apiBase ?? "https://api.anthropic.com"),
+        };
+    }
+    describe() {
+        return {
+            description: "Sends market snapshots to an LLM API for trading decisions; parses BUY/SELL/HOLD responses",
+            params: [
+                { name: "apiKey", type: "string", required: true, description: "LLM API key (Anthropic or compatible)" },
+                { name: "model", type: "string", required: false, default: "claude-3-5-haiku-latest", description: "Model name to use" },
+                { name: "maxPositionSize", type: "number", required: false, default: 0.1, description: "Maximum order size per LLM decision" },
+                { name: "promptTemplate", type: "string", required: false, default: DEFAULT_PROMPT, description: "System prompt sent to LLM" },
+                { name: "tickInterval", type: "number", required: false, default: 10, description: "Ticks between LLM calls" },
+                { name: "apiBase", type: "string", required: false, default: "https://api.anthropic.com", description: "API base URL" },
+            ],
+        };
+    }
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        const { apiKey, model, maxPositionSize, tickInterval } = this.params;
+        if (!apiKey) {
+            ctx.log("  [CLAUDE-AGENT] No apiKey configured — running in noop mode");
+        }
+        else {
+            ctx.log(`  [CLAUDE-AGENT] model=${model} maxSize=${maxPositionSize} ` +
+                `interval=${tickInterval}ticks`);
+        }
+        ctx.state.set("lastDecision", "HOLD");
+        ctx.state.set("lastCallTick", -1);
+    }
+    async onTick(ctx, snapshot) {
+        const { apiKey, model, maxPositionSize, promptTemplate, tickInterval, apiBase } = this.params;
+        if (!apiKey) {
+            ctx.log("  [CLAUDE-AGENT] No apiKey — skipping LLM call (noop)");
+            return [{ type: "noop" }];
+        }
+        const lastCallTick = ctx.state.get("lastCallTick");
+        if (ctx.tick - lastCallTick < tickInterval) {
+            return [{ type: "noop" }];
+        }
+        ctx.state.set("lastCallTick", ctx.tick);
+        const userMessage = buildMarketMessage(snapshot, ctx.symbol);
+        let rawDecision;
+        try {
+            rawDecision = await callLlm(apiBase, apiKey, model, promptTemplate, userMessage);
+            ctx.state.set("lastDecision", rawDecision);
+            ctx.log(`  [CLAUDE-AGENT] LLM response: "${rawDecision}"`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.log(`  [CLAUDE-AGENT] LLM call failed: ${msg}`);
+            return [{ type: "noop" }];
+        }
+        return parseDecision(rawDecision, maxPositionSize, snapshot.price);
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+}
+// ── Helpers ──
+function buildMarketMessage(snapshot, symbol) {
+    const lines = [
+        `Symbol: ${symbol}`,
+        `Price: ${snapshot.price.toFixed(4)}`,
+        `Funding Rate: ${(snapshot.fundingRate * 100).toFixed(4)}%`,
+        `24h Volatility: ${snapshot.volatility24h.toFixed(2)}%`,
+        `24h Volume: ${snapshot.volume24h.toFixed(2)}`,
+        `Open Interest: ${snapshot.openInterest}`,
+    ];
+    const bestBid = snapshot.orderbook.bids[0];
+    const bestAsk = snapshot.orderbook.asks[0];
+    if (bestBid)
+        lines.push(`Best Bid: ${bestBid[0]} (${bestBid[1]})`);
+    if (bestAsk)
+        lines.push(`Best Ask: ${bestAsk[0]} (${bestAsk[1]})`);
+    return lines.join("\n");
+}
+async function callLlm(apiBase, apiKey, model, systemPrompt, userMessage) {
+    const url = `${apiBase.replace(/\/$/, "")}/v1/messages`;
+    const body = JSON.stringify({
+        model,
+        max_tokens: 64,
+        system: systemPrompt,
+        messages: [{ role: "user", content: userMessage }],
+    });
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01",
+        },
+        body,
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new Error(`LLM API error ${response.status}: ${text}`);
+    }
+    const data = (await response.json());
+    const textBlock = data.content?.find((c) => c.type === "text");
+    return textBlock?.text?.trim() ?? "HOLD";
+}
+function parseDecision(raw, maxPositionSize, price) {
+    const upper = raw.trim().toUpperCase();
+    if (upper === "HOLD" || upper.startsWith("HOLD")) {
+        return [{ type: "noop" }];
+    }
+    // Match "BUY <size>" or "SELL <size>"
+    const buyMatch = upper.match(/^BUY\s+([\d.]+)/);
+    if (buyMatch) {
+        const size = Math.min(parseFloat(buyMatch[1]), maxPositionSize);
+        if (size > 0) {
+            return [
+                {
+                    type: "place_order",
+                    side: "buy",
+                    price: price.toFixed(6),
+                    size: size.toFixed(6),
+                    orderType: "market",
+                },
+            ];
+        }
+    }
+    const sellMatch = upper.match(/^SELL\s+([\d.]+)/);
+    if (sellMatch) {
+        const size = Math.min(parseFloat(sellMatch[1]), maxPositionSize);
+        if (size > 0) {
+            return [
+                {
+                    type: "place_order",
+                    side: "sell",
+                    price: price.toFixed(6),
+                    size: size.toFixed(6),
+                    orderType: "market",
+                },
+            ];
+        }
+    }
+    // Unrecognised response — treat as noop
+    return [{ type: "noop" }];
+}
+registerStrategy("claude-agent", (_config) => new ClaudeAgentStrategy());

package/dist/bot/strategies/dca-strategy.d.ts

@@ -0,0 +1,25 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class DCAStrategy implements Strategy {
+    readonly name = "dca";
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        })[];
+    };
+    private get params();
+    private _config;
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(_ctx: StrategyContext): Promise<StrategyAction[]>;
+}