superacli 1.1.0 → 1.1.2

package/ref-btcbot/src/cli.js

@@ -1,104 +0,0 @@
-#!/usr/bin/env node
-
-const { getConfig, ensureDataDirs, validateConfig } = require("./config")
-const { StateRepository } = require("./core/state-repository")
-const { runCycle, runLoop } = require("./core/bot-runner")
-const { createServer } = require("./web/server")
-const { loadCandles, runBacktest } = require("./services/backtest-service")
-
-function output(data) {
-  console.log(JSON.stringify(data, null, 2))
-}
-
-async function main() {
-  const config = getConfig()
-  ensureDataDirs(config)
-  const validation = validateConfig(config)
-  const repository = new StateRepository(config)
-  const [command, subcommand, arg] = process.argv.slice(2)
-
-  if (command === "config" && subcommand === "validate") {
-    output(validation)
-    process.exit(validation.ok ? 0 : 1)
-  }
-
-  if (!validation.ok) {
-    output(validation)
-    process.exit(1)
-  }
-
-  if (command === "status" && subcommand === "show") {
-    output({
-      ok: true,
-      state: repository.getState(),
-      snapshot: repository.getSnapshot(),
-      orders: repository.listOrders().slice(0, 20)
-    })
-    return
-  }
-
-  if (command === "positions" && subcommand === "list") {
-    output({ ok: true, position: repository.getState().position, snapshot: repository.getSnapshot() })
-    return
-  }
-
-  if (command === "orders" && subcommand === "list") {
-    output({ ok: true, orders: repository.listOrders() })
-    return
-  }
-
-  if (command === "risk" && subcommand === "report") {
-    const snapshot = repository.getSnapshot()
-    output({ ok: true, risk: snapshot ? snapshot.risk : null, runtime: repository.getState().runtime })
-    return
-  }
-
-  if (command === "run" && subcommand === "once") {
-    output(await runCycle(config, repository))
-    return
-  }
-
-  if (command === "run" && subcommand === "loop") {
-    const iterations = Number(arg) > 0 ? Number(arg) : 3
-    output(await runLoop(config, repository, { iterations }))
-    return
-  }
-
-  if (command === "backtest" && subcommand === "run") {
-    if (!arg) {
-      output({ ok: false, error: "Pass a candle JSON file path" })
-      process.exit(1)
-    }
-    output(runBacktest(config, loadCandles(arg)))
-    return
-  }
-
-  if (command === "server") {
-    const server = createServer(config, repository)
-    await server.start()
-    output({ ok: true, url: `http://localhost:${config.port}` })
-    return
-  }
-
-  output({
-    ok: false,
-    error: "Unknown command",
-    commands: [
-      "config validate",
-      "status show",
-      "positions list",
-      "orders list",
-      "risk report",
-      "run once",
-      "run loop [iterations]",
-      "backtest run <file>",
-      "server"
-    ]
-  })
-  process.exit(1)
-}
-
-main().catch((error) => {
-  output({ ok: false, error: error.message })
-  process.exit(1)
-})

package/ref-btcbot/src/config.js

@@ -1,80 +0,0 @@
-const fs = require("fs")
-const path = require("path")
-const dotenv = require("dotenv")
-
-let loaded = false
-
-function loadEnv() {
-  if (loaded) return
-  dotenv.config({ path: path.resolve(process.cwd(), ".env"), quiet: true })
-  loaded = true
-}
-
-function toNumber(value, fallback) {
-  const num = Number(value)
-  return Number.isFinite(num) ? num : fallback
-}
-
-function toBool(value, fallback) {
-  if (value === undefined) return fallback
-  return String(value).toLowerCase() === "true"
-}
-
-function getConfig(overrides = {}) {
-  loadEnv()
-  const env = { ...process.env, ...overrides }
-  return {
-    port: toNumber(env.PORT, 4310),
-    dataDir: path.resolve(process.cwd(), env.DATA_DIR || "./data"),
-    market: {
-      symbol: env.BTC_SYMBOL || "BTCUSDT",
-      interval: env.BTC_INTERVAL || "15m",
-      klinesUrl: env.BINANCE_KLINES_URL || "https://api.binance.com/api/v3/klines"
-    },
-    strategy: {
-      spotInventoryBtc: toNumber(env.SPOT_INVENTORY_BTC, 0.25),
-      minHedgeRatio: toNumber(env.MIN_HEDGE_RATIO, 0),
-      maxHedgeRatio: toNumber(env.MAX_HEDGE_RATIO, 1),
-      volWindow: toNumber(env.VOL_WINDOW, 20),
-      trendFast: toNumber(env.TREND_FAST, 8),
-      trendSlow: toNumber(env.TREND_SLOW, 21),
-      atrWindow: toNumber(env.ATR_WINDOW, 14),
-      zscoreWindow: toNumber(env.ZSCORE_WINDOW, 20),
-      rebalanceThresholdBtc: toNumber(env.REBALANCE_THRESHOLD_BTC, 0.01)
-    },
-    risk: {
-      maxGrossNotional: toNumber(env.MAX_GROSS_NOTIONAL, 50000),
-      maxNotionalPerOrder: toNumber(env.MAX_NOTIONAL_PER_ORDER, 15000),
-      cooldownMs: toNumber(env.RISK_COOLDOWN_MS, 900000)
-    },
-    runtime: {
-      pollIntervalMs: toNumber(env.POLL_INTERVAL_MS, 5000),
-      liveTradingEnabled: toBool(env.LIVE_TRADING_ENABLED, false)
-    }
-  }
-}
-
-function ensureDataDirs(config) {
-  const dirs = [config.dataDir, path.join(config.dataDir, "ledgers")]
-  dirs.forEach((dir) => fs.mkdirSync(dir, { recursive: true }))
-}
-
-function validateConfig(config) {
-  const issues = []
-  if (config.strategy.spotInventoryBtc <= 0) issues.push("SPOT_INVENTORY_BTC must be > 0")
-  if (config.strategy.maxHedgeRatio < config.strategy.minHedgeRatio) issues.push("MAX_HEDGE_RATIO must be >= MIN_HEDGE_RATIO")
-  if (config.risk.maxGrossNotional <= 0) issues.push("MAX_GROSS_NOTIONAL must be > 0")
-  if (config.risk.maxNotionalPerOrder <= 0) issues.push("MAX_NOTIONAL_PER_ORDER must be > 0")
-  if (config.runtime.pollIntervalMs <= 0) issues.push("POLL_INTERVAL_MS must be > 0")
-  return {
-    ok: issues.length === 0,
-    issues,
-    config
-  }
-}
-
-module.exports = {
-  getConfig,
-  ensureDataDirs,
-  validateConfig
-}

package/ref-btcbot/src/core/bot-runner.js

@@ -1,78 +0,0 @@
-const { fetchCandles } = require("../services/market-data")
-const { buildSignal } = require("../strategy/hedge-strategy")
-const { markPrice } = require("./paper-exchange")
-const { createExchange } = require("./exchange-factory")
-const { evaluateRisk, applyRiskCooldown } = require("./risk-engine")
-
-function buildReport(state, signal, mark, order, risk) {
-  return {
-    ts: new Date().toISOString(),
-    mode: state.mode,
-    signal,
-    mark,
-    risk,
-    position: state.position,
-    runtime: state.runtime,
-    order: order || null
-  }
-}
-
-async function runCycle(config, repository) {
-  const state = repository.getState()
-  const exchange = createExchange(config, state)
-  const candles = await fetchCandles(config, 160)
-  const signal = buildSignal(candles, config.strategy, state)
-  const latestPrice = signal.price || candles[candles.length - 1].close
-  const risk = evaluateRisk(config, state, signal)
-  let order = null
-
-  if (risk.ok && signal.shouldRebalance) {
-    order = exchange.executeOrder(
-      signal.deltaBtc < 0 ? "sell" : "buy",
-      Math.abs(signal.deltaBtc),
-      latestPrice
-    )
-    repository.appendOrder({ ...order, reasons: signal.reasons })
-  }
-
-  if (!risk.ok && risk.violations.includes("order_notional_limit")) {
-    applyRiskCooldown(state, config, risk.violations.join(","))
-  }
-
-  state.runtime.lastSignal = signal
-  state.runtime.lastRunAt = new Date().toISOString()
-  const mark = markPrice(state, latestPrice)
-  const report = buildReport(state, signal, mark, order, risk)
-
-  repository.saveState(state)
-  repository.saveSnapshot(report)
-  repository.appendRun(report)
-
-  return report
-}
-
-async function runLoop(config, repository, options = {}) {
-  const iterations = Number(options.iterations) > 0 ? Number(options.iterations) : null
-  const waitMs = config.runtime.pollIntervalMs
-  let count = 0
-  const reports = []
-
-  while (iterations === null || count < iterations) {
-    const report = await runCycle(config, repository)
-    reports.push(report)
-    count += 1
-    if (iterations !== null && count >= iterations) break
-    await new Promise((resolve) => setTimeout(resolve, waitMs))
-  }
-
-  return {
-    ok: true,
-    iterations: count,
-    last: reports[reports.length - 1]
-  }
-}
-
-module.exports = {
-  runCycle,
-  runLoop
-}

package/ref-btcbot/src/core/exchange-factory.js

@@ -1,19 +0,0 @@
-const { executePerpMarketOrder } = require("./paper-exchange")
-const { createLiveExchange } = require("./live-exchange")
-
-function createExchange(config, state) {
-  if (config.runtime.liveTradingEnabled) {
-    return createLiveExchange(config, state)
-  }
-
-  return {
-    mode: "paper",
-    executeOrder(side, qty, price) {
-      return executePerpMarketOrder(state, side, qty, price)
-    }
-  }
-}
-
-module.exports = {
-  createExchange
-}

package/ref-btcbot/src/core/live-exchange.js

@@ -1,12 +0,0 @@
-function createLiveExchange() {
-  return {
-    mode: "live",
-    executeOrder() {
-      throw new Error("Live trading is not implemented in v1. Keep LIVE_TRADING_ENABLED=false.")
-    }
-  }
-}
-
-module.exports = {
-  createLiveExchange
-}

package/ref-btcbot/src/core/paper-exchange.js

@@ -1,82 +0,0 @@
-function round(value) {
-  return Number(value.toFixed(6))
-}
-
-function createInitialState(config) {
-  return {
-    mode: "paper",
-    createdAt: new Date().toISOString(),
-    position: {
-      spotQty: round(config.strategy.spotInventoryBtc),
-      perpQty: 0,
-      avgPerpEntry: 0,
-      realizedPnl: 0
-    },
-    balances: {
-      quote: 100000
-    },
-    runtime: {
-      loopActive: false,
-      cooldownUntil: null,
-      consecutiveLosses: 0,
-      lastSignal: null,
-      lastError: null,
-      lastRunAt: null
-    }
-  }
-}
-
-function markPrice(state, price) {
-  const perpUnrealized = state.position.perpQty === 0
-    ? 0
-    : (price - state.position.avgPerpEntry) * state.position.perpQty
-  const spotValue = state.position.spotQty * price
-  const netDelta = state.position.spotQty + state.position.perpQty
-  return {
-    spotValue: round(spotValue),
-    perpUnrealized: round(perpUnrealized),
-    netDeltaBtc: round(netDelta),
-    grossNotional: round((Math.abs(state.position.spotQty) + Math.abs(state.position.perpQty)) * price),
-    equityEstimate: round(state.balances.quote + spotValue + state.position.realizedPnl + perpUnrealized)
-  }
-}
-
-function executePerpMarketOrder(state, side, qty, price) {
-  const signedQty = side === "sell" ? -Math.abs(qty) : Math.abs(qty)
-  const previousQty = state.position.perpQty
-  const nextQty = round(previousQty + signedQty)
-  let realized = 0
-  let nextEntry = state.position.avgPerpEntry
-
-  if (previousQty === 0 || Math.sign(previousQty) === Math.sign(nextQty)) {
-    const weightedNotional = Math.abs(previousQty * state.position.avgPerpEntry) + Math.abs(signedQty * price)
-    nextEntry = nextQty === 0 ? 0 : round(weightedNotional / Math.abs(nextQty))
-  } else {
-    const closingQty = Math.min(Math.abs(previousQty), Math.abs(signedQty))
-    realized = round((price - state.position.avgPerpEntry) * Math.sign(previousQty) * closingQty)
-    nextEntry = nextQty === 0 ? 0 : round(price)
-  }
-
-  state.position.perpQty = nextQty
-  state.position.avgPerpEntry = nextEntry
-  state.position.realizedPnl = round(state.position.realizedPnl + realized)
-  state.runtime.consecutiveLosses = realized < 0 ? state.runtime.consecutiveLosses + 1 : 0
-
-  return {
-    id: `ord_${Date.now()}`,
-    ts: new Date().toISOString(),
-    mode: state.mode,
-    side,
-    qty: round(Math.abs(qty)),
-    price: round(price),
-    realizedPnl: realized,
-    perpQtyAfter: nextQty,
-    avgPerpEntryAfter: nextEntry
-  }
-}
-
-module.exports = {
-  createInitialState,
-  markPrice,
-  executePerpMarketOrder
-}

package/ref-btcbot/src/core/risk-engine.js

@@ -1,42 +0,0 @@
-function nowMs() {
-  return Date.now()
-}
-
-function evaluateRisk(config, state, signal) {
-  const violations = []
-  const cooldownUntil = state.runtime.cooldownUntil ? Date.parse(state.runtime.cooldownUntil) : null
-
-  if (cooldownUntil && cooldownUntil > nowMs()) {
-    violations.push("cooldown_active")
-  }
-
-  if (!signal.ready) {
-    violations.push("signal_not_ready")
-  }
-
-  const orderNotional = Math.abs(signal.deltaBtc || 0) * (signal.price || 0)
-  if (orderNotional > config.risk.maxNotionalPerOrder) {
-    violations.push("order_notional_limit")
-  }
-
-  const grossAfter = (Math.abs(state.position.spotQty) + Math.abs(signal.targetPerpBtc || 0)) * (signal.price || 0)
-  if (grossAfter > config.risk.maxGrossNotional) {
-    violations.push("gross_notional_limit")
-  }
-
-  return {
-    ok: violations.length === 0,
-    violations
-  }
-}
-
-function applyRiskCooldown(state, config, reason) {
-  state.runtime.cooldownUntil = new Date(Date.now() + config.risk.cooldownMs).toISOString()
-  state.runtime.lastError = reason
-  return state
-}
-
-module.exports = {
-  evaluateRisk,
-  applyRiskCooldown
-}

package/ref-btcbot/src/core/state-repository.js

@@ -1,47 +0,0 @@
-const path = require("path")
-const { JsonStore } = require("../storage/json-store")
-const { createInitialState } = require("./paper-exchange")
-
-class StateRepository {
-  constructor(config) {
-    this.config = config
-    this.store = new JsonStore(config.dataDir)
-    this.ledger = new JsonStore(path.join(config.dataDir, "ledgers"))
-  }
-
-  getState() {
-    return this.store.read("state", createInitialState(this.config))
-  }
-
-  saveState(state) {
-    return this.store.write("state", state)
-  }
-
-  appendOrder(order) {
-    return this.ledger.append("orders", order, 1000)
-  }
-
-  appendRun(run) {
-    return this.ledger.append("runs", run, 1000)
-  }
-
-  saveSnapshot(snapshot) {
-    return this.store.write("snapshot", snapshot)
-  }
-
-  getSnapshot() {
-    return this.store.read("snapshot", null)
-  }
-
-  listOrders() {
-    return this.ledger.read("orders", [])
-  }
-
-  listRuns() {
-    return this.ledger.read("runs", [])
-  }
-}
-
-module.exports = {
-  StateRepository
-}

package/ref-btcbot/src/services/backtest-service.js

@@ -1,44 +0,0 @@
-const fs = require("fs")
-const path = require("path")
-const { buildSignal } = require("../strategy/hedge-strategy")
-const { createInitialState, executePerpMarketOrder, markPrice } = require("../core/paper-exchange")
-const { evaluateRisk } = require("../core/risk-engine")
-
-function loadCandles(file) {
-  const target = path.resolve(process.cwd(), file)
-  const raw = JSON.parse(fs.readFileSync(target, "utf-8"))
-  return Array.isArray(raw) ? raw : raw.candles
-}
-
-function runBacktest(config, candles) {
-  const state = createInitialState(config)
-  const trades = []
-
-  for (let i = 40; i < candles.length; i += 1) {
-    const window = candles.slice(0, i + 1)
-    const signal = buildSignal(window, config.strategy, state)
-    const risk = evaluateRisk(config, state, signal)
-    if (!signal.ready || !risk.ok || !signal.shouldRebalance) continue
-    const order = executePerpMarketOrder(
-      state,
-      signal.deltaBtc < 0 ? "sell" : "buy",
-      Math.abs(signal.deltaBtc),
-      signal.price
-    )
-    trades.push({ ...order, reasons: signal.reasons })
-    state.runtime.lastSignal = signal
-  }
-
-  const latest = candles[candles.length - 1]
-  return {
-    ok: true,
-    trades,
-    totals: markPrice(state, latest.close),
-    position: state.position
-  }
-}
-
-module.exports = {
-  loadCandles,
-  runBacktest
-}

package/ref-btcbot/src/services/market-data.js

@@ -1,32 +0,0 @@
-async function fetchJson(url) {
-  const response = await fetch(url)
-  if (!response.ok) {
-    throw new Error(`Market data request failed with status ${response.status}`)
-  }
-  return response.json()
-}
-
-function normalizeKline(row) {
-  return {
-    openTime: Number(row[0]),
-    open: Number(row[1]),
-    high: Number(row[2]),
-    low: Number(row[3]),
-    close: Number(row[4]),
-    volume: Number(row[5]),
-    closeTime: Number(row[6])
-  }
-}
-
-async function fetchCandles(config, limit = 120) {
-  const url = new URL(config.market.klinesUrl)
-  url.searchParams.set("symbol", config.market.symbol)
-  url.searchParams.set("interval", config.market.interval)
-  url.searchParams.set("limit", String(limit))
-  const rows = await fetchJson(url.toString())
-  return rows.map(normalizeKline)
-}
-
-module.exports = {
-  fetchCandles
-}

package/ref-btcbot/src/storage/json-store.js

@@ -1,45 +0,0 @@
-const fs = require("fs")
-const path = require("path")
-
-class JsonStore {
-  constructor(baseDir) {
-    this.baseDir = baseDir
-    fs.mkdirSync(baseDir, { recursive: true })
-  }
-
-  file(name) {
-    return path.join(this.baseDir, `${name}.json`)
-  }
-
-  read(name, fallback) {
-    const file = this.file(name)
-    if (!fs.existsSync(file)) return fallback
-    const raw = fs.readFileSync(file, "utf-8")
-    if (!raw.trim()) return fallback
-    return JSON.parse(raw)
-  }
-
-  write(name, value) {
-    const file = this.file(name)
-    fs.writeFileSync(file, JSON.stringify(value, null, 2))
-    return value
-  }
-
-  update(name, fallback, updater) {
-    const current = this.read(name, fallback)
-    const next = updater(current)
-    return this.write(name, next)
-  }
-
-  append(name, item, maxItems = 500) {
-    return this.update(name, [], (current) => {
-      const next = Array.isArray(current) ? current.slice() : []
-      next.unshift(item)
-      return next.slice(0, maxItems)
-    })
-  }
-}
-
-module.exports = {
-  JsonStore
-}

package/ref-btcbot/src/strategy/hedge-strategy.js

@@ -1,65 +0,0 @@
-const { sma, atr, zscore, realizedVol } = require("./indicators")
-
-function clamp(value, min, max) {
-  return Math.max(min, Math.min(max, value))
-}
-
-function round(value) {
-  return Number(value.toFixed(6))
-}
-
-function buildSignal(candles, config, state) {
-  const closes = candles.map((c) => c.close)
-  const fast = sma(closes, config.trendFast)
-  const slow = sma(closes, config.trendSlow)
-  const vol = realizedVol(closes, config.volWindow)
-  const range = atr(candles, config.atrWindow)
-  const meanReversionZ = zscore(closes, config.zscoreWindow)
-  const latest = candles[candles.length - 1]
-
-  if (!fast || !slow || !vol || !range || latest === undefined) {
-    return {
-      ready: false,
-      reasons: ["insufficient_market_history"]
-    }
-  }
-
-  const trendBias = fast < slow ? 0.2 : -0.1
-  const volBias = clamp(vol / 0.8, 0, 1)
-  const reversionBias = clamp(Math.max(0, meanReversionZ) / 2.5, 0, 0.35)
-  const drawdownBias = state.runtime && state.runtime.consecutiveLosses >= 2 ? 0.15 : 0
-
-  const hedgeRatio = clamp(
-    config.minHedgeRatio + volBias + reversionBias + trendBias + drawdownBias,
-    config.minHedgeRatio,
-    config.maxHedgeRatio
-  )
-
-  const targetPerpBtc = round(-config.spotInventoryBtc * hedgeRatio)
-  const currentPerpBtc = round((state.position && state.position.perpQty) || 0)
-  const deltaBtc = round(targetPerpBtc - currentPerpBtc)
-  const shouldRebalance = Math.abs(deltaBtc) >= config.rebalanceThresholdBtc
-
-  return {
-    ready: true,
-    price: latest.close,
-    trend: round((fast - slow) / slow),
-    volatility: round(vol),
-    atr: round(range),
-    meanReversionZ: round(meanReversionZ),
-    hedgeRatio: round(hedgeRatio),
-    targetPerpBtc,
-    currentPerpBtc,
-    deltaBtc,
-    shouldRebalance,
-    reasons: [
-      volBias > 0.55 ? "high_realized_vol" : "moderate_realized_vol",
-      meanReversionZ > 1 ? "price_extended_above_mean" : "mean_reversion_neutral",
-      fast < slow ? "downtrend_requires_more_hedge" : "trend_supportive"
-    ]
-  }
-}
-
-module.exports = {
-  buildSignal
-}