@tradejs/node 1.0.0

package/dist/strategies.mjs

@@ -0,0 +1,847 @@
+import {
+  buildMlPayload
+} from "./chunk-PXJJPAQT.mjs";
+import {
+  require_lodash
+} from "./chunk-GKDBAF3A.mjs";
+import {
+  createLoadPineScript
+} from "./chunk-CVTV6S2V.mjs";
+import "./chunk-5YNMSWL3.mjs";
+import {
+  MAX_AI_SERIES_POINTS,
+  askAI,
+  buildAiHumanPrompt,
+  buildAiPayload,
+  buildAiSystemPrompt,
+  trimSeriesDeep
+} from "./chunk-ZIMX3JX2.mjs";
+import {
+  ensureIndicatorPluginsLoaded,
+  ensureStrategyPluginsLoaded,
+  getAvailableStrategyNames,
+  getRegisteredManifests,
+  getRegisteredStrategies,
+  getStrategyCreator,
+  getStrategyManifest,
+  isKnownStrategy,
+  registerStrategyEntries,
+  resetStrategyRegistryCache,
+  strategies
+} from "./chunk-MHCXPD2B.mjs";
+import "./chunk-DE7ADBIR.mjs";
+import {
+  __toESM
+} from "./chunk-6DZX6EAA.mjs";
+
+// src/closeOppositePositionsBeforeOpen.ts
+var import_lodash = __toESM(require_lodash());
+import { logger } from "@tradejs/infra/logger";
+var closeOppositePositionsBeforeOpen = async ({
+  connector,
+  entryContext
+}) => {
+  const {
+    symbol: currentSymbol,
+    direction: currentDirection,
+    timestamp,
+    prices,
+    strategy: strategyName
+  } = entryContext;
+  const price = prices.currentPrice;
+  try {
+    logger.log(
+      "info",
+      "[%s] checking open positions before open: %s %s",
+      strategyName,
+      currentSymbol,
+      currentDirection
+    );
+    const positions = await connector.getPositions();
+    const openPositions = (positions || []).filter(
+      (item) => item && Number(item.qty) > 0
+    );
+    logger.log(
+      "info",
+      "[%s] open positions found: %s",
+      strategyName,
+      openPositions.length
+    );
+    const oppositePositions = openPositions.filter(
+      (item) => item.symbol !== currentSymbol && item.direction !== currentDirection
+    );
+    if (import_lodash.default.isEmpty(oppositePositions)) {
+      logger.log(
+        "info",
+        "[%s] no opposite positions to close before open: %s",
+        strategyName,
+        currentSymbol
+      );
+      return;
+    }
+    for (const position of oppositePositions) {
+      logger.log(
+        "info",
+        "[%s] closing opposite position: %s %s qty=%s",
+        strategyName,
+        position.symbol,
+        position.direction,
+        position.qty
+      );
+      try {
+        await connector.closePosition({
+          symbol: position.symbol,
+          price,
+          timestamp,
+          direction: position.direction
+        });
+        logger.log(
+          "info",
+          "[%s] opposite position closed: %s",
+          strategyName,
+          position.symbol
+        );
+      } catch (err) {
+        logger.log(
+          "error",
+          "[%s] failed to close opposite position: %s %s",
+          strategyName,
+          position.symbol,
+          err
+        );
+      }
+    }
+  } catch (err) {
+    logger.log(
+      "error",
+      "[%s] failed to load open positions before open: %s %s",
+      strategyName,
+      currentSymbol,
+      err
+    );
+  }
+};
+
+// src/strategies.ts
+export * from "@tradejs/core/strategies";
+
+// src/strategyRuntime.ts
+import path from "path";
+import { SIGNALS_PRELOAD_DAYS } from "@tradejs/core/constants";
+import {
+  buildDefaultIndicatorPeriods,
+  createStrategyAPI,
+  createStrategyIndicatorsState
+} from "@tradejs/core/strategies";
+import { getTimestamp } from "@tradejs/core/time";
+import { logger as logger3 } from "@tradejs/infra/logger";
+
+// src/strategyHelpers/runtime.ts
+import { logger as logger2 } from "@tradejs/infra/logger";
+import {
+  buildMlFeatures,
+  buildMlTrainingRow,
+  fetchMlThreshold,
+  trimMlTrainingRowWindows
+} from "@tradejs/infra/ml";
+var formatAiError = (err) => {
+  const error = err;
+  const safeJson = (value) => {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  };
+  const details = {
+    message: String(error?.message ?? "unknown"),
+    status: error?.status ?? null,
+    code: error?.code ?? null,
+    type: error?.type ?? null,
+    providerError: error?.error ?? null
+  };
+  return safeJson(details);
+};
+var enrichSignalWithMl = async ({
+  signal,
+  env,
+  ml
+}) => {
+  if (env !== "BACKTEST" && ml && ml.enabled !== false && ml.strategyConfig && typeof ml.mlThreshold === "number") {
+    const strategy = signal.strategy;
+    const fullRow = buildMlTrainingRow(
+      buildMlPayload({
+        signal,
+        context: {
+          strategyConfig: ml.strategyConfig,
+          strategyName: strategy,
+          symbol: signal.symbol
+        }
+      }),
+      null
+    );
+    const row = trimMlTrainingRowWindows(fullRow, 5);
+    const features = buildMlFeatures(row);
+    const mlResult = await fetchMlThreshold({
+      strategy,
+      features,
+      threshold: ml.mlThreshold
+    });
+    if (mlResult) {
+      signal.ml = mlResult;
+    }
+  }
+};
+var enrichSignalWithAi = async ({
+  signal,
+  symbol,
+  direction,
+  env,
+  ai
+}) => {
+  if (env === "BACKTEST" || ai?.enabled === false) {
+    return void 0;
+  }
+  try {
+    const { askAI: askAI2 } = await import("./ai-NNJ3RLLL.mjs");
+    const analysis = await askAI2(signal);
+    if (typeof analysis?.quality === "number") {
+      const normalizedQuality = Math.round(analysis.quality);
+      const aiApprovedCurrentTrade = analysis?.direction === direction;
+      return aiApprovedCurrentTrade ? normalizedQuality : 0;
+    }
+  } catch (err) {
+    logger2.error("AI analysis error: %s %s", symbol, formatAiError(err));
+  }
+  return void 0;
+};
+var enrichSignalWithMlAi = async ({
+  signal,
+  symbol,
+  direction,
+  env,
+  ml,
+  ai
+}) => {
+  await enrichSignalWithMl({ signal, env, ml });
+  return enrichSignalWithAi({ signal, symbol, direction, env, ai });
+};
+var executeEntryOrder = async ({
+  connector,
+  symbol,
+  direction,
+  qty,
+  currentPrice,
+  timestamp,
+  takeProfits,
+  stopLossPrice,
+  signal,
+  beforePlaceOrder
+}) => {
+  await beforePlaceOrder?.();
+  const orderPlaced = await connector.placeOrder(
+    {
+      symbol,
+      qty,
+      price: currentPrice,
+      isLimit: false,
+      timestamp,
+      direction,
+      signal
+    },
+    takeProfits,
+    stopLossPrice
+  );
+  signal.orderStatus = orderPlaced ? "completed" : "failed";
+  signal.orderSkipReason = void 0;
+  const currentPosition = await connector.getPosition(symbol);
+  if (currentPosition?.price) {
+    signal.prices.currentPrice = currentPosition.price;
+    return currentPosition.price;
+  }
+  return currentPrice;
+};
+
+// src/strategyHelpers/config.ts
+var import_lodash2 = __toESM(require_lodash());
+import { getData, redisKeys } from "@tradejs/infra/redis";
+var resolveStrategyConfig = async ({
+  strategyName,
+  userName,
+  symbol,
+  baseConfig,
+  defaults
+}) => {
+  const mergeIfNotEmpty = (target, patch) => patch && !import_lodash2.default.isEmpty(patch) ? {
+    ...target,
+    ...patch
+  } : target;
+  let config = {
+    ...defaults,
+    ...baseConfig
+  };
+  let isConfigFromBacktest = false;
+  if (config.ENV !== "BACKTEST") {
+    const userConfig = await getData(
+      redisKeys.strategyConfig(userName, strategyName),
+      {}
+    );
+    config = mergeIfNotEmpty(config, userConfig);
+    const results = await getData(
+      redisKeys.strategyResults(userName, strategyName),
+      {}
+    );
+    const backtestResult = results?.[symbol];
+    if (backtestResult && !import_lodash2.default.isEmpty(backtestResult.config)) {
+      config = mergeIfNotEmpty(
+        config,
+        backtestResult.config
+      );
+      isConfigFromBacktest = true;
+    }
+  }
+  return { config, isConfigFromBacktest };
+};
+
+// src/strategyRuntime.ts
+var resolveEntryRuntimePolicy = ({
+  decision,
+  config,
+  manifest
+}) => {
+  const manifestDefaults = manifest?.entryRuntimeDefaults;
+  const adapterMl = manifest?.mlAdapter?.mapEntryRuntimeFromConfig?.(config);
+  const adapterAi = manifest?.aiAdapter?.mapEntryRuntimeFromConfig?.(config);
+  const ml = manifestDefaults?.ml || adapterMl || decision.runtime?.ml ? {
+    ...manifestDefaults?.ml,
+    ...adapterMl,
+    ...decision.runtime?.ml
+  } : void 0;
+  const ai = manifestDefaults?.ai || adapterAi || decision.runtime?.ai ? {
+    ...manifestDefaults?.ai,
+    ...adapterAi,
+    ...decision.runtime?.ai
+  } : void 0;
+  return {
+    ...manifestDefaults,
+    ...decision.runtime,
+    ml,
+    ai
+  };
+};
+var shouldExecuteEntryDecision = ({
+  makeOrdersEnabled,
+  env,
+  signal,
+  quality,
+  minAiQuality
+}) => makeOrdersEnabled && (!signal || env === "BACKTEST" || quality == null || quality >= minAiQuality);
+var getEntrySkipReason = ({
+  makeOrdersEnabled,
+  env,
+  quality,
+  minAiQuality
+}) => {
+  if (!makeOrdersEnabled) {
+    return "MAKE_ORDERS_DISABLED";
+  }
+  if (env !== "BACKTEST" && quality != null && Number.isFinite(quality) && quality < minAiQuality) {
+    return `AI_QUALITY_BELOW_MIN (${quality} < ${minAiQuality})`;
+  }
+  return "ENTRY_POLICY_BLOCKED";
+};
+var handleExitDecision = async ({
+  connector,
+  symbol,
+  decision,
+  onRuntimeError
+}) => {
+  try {
+    await connector.closePosition({
+      symbol,
+      price: decision.closePlan.price,
+      timestamp: decision.closePlan.timestamp,
+      direction: decision.closePlan.direction
+    });
+  } catch (err) {
+    await onRuntimeError?.({
+      stage: "closePosition",
+      error: err,
+      decision
+    });
+    logger3.error("close order error: %s %s", symbol, err);
+    return "ORDER_ERROR";
+  }
+  return decision.code;
+};
+var executeEntryDecision = async ({
+  connector,
+  symbol,
+  decision,
+  runtime,
+  manifest,
+  hookBase,
+  invokeHook,
+  notifyRuntimeError
+}) => {
+  const signal = decision.signal;
+  const beforePlaceOrder = async () => {
+    await invokeHook(
+      "beforePlaceOrder",
+      manifest?.hooks?.beforePlaceOrder,
+      {
+        ...hookBase,
+        entryContext: decision.entryContext,
+        runtime,
+        decision,
+        signal
+      },
+      { decision, signal }
+    );
+    try {
+      await runtime.beforePlaceOrder?.();
+    } catch (error) {
+      await notifyRuntimeError({
+        stage: "runtime.beforePlaceOrder",
+        error,
+        decision,
+        signal
+      });
+      throw error;
+    }
+  };
+  try {
+    if (signal) {
+      await executeEntryOrder({
+        connector,
+        symbol,
+        direction: decision.entryContext.direction,
+        qty: decision.orderPlan.qty,
+        currentPrice: decision.entryContext.prices.currentPrice,
+        timestamp: decision.entryContext.timestamp,
+        takeProfits: decision.orderPlan.takeProfits,
+        stopLossPrice: decision.orderPlan.stopLossPrice,
+        signal,
+        beforePlaceOrder
+      });
+      await invokeHook(
+        "afterPlaceOrder",
+        manifest?.hooks?.afterPlaceOrder,
+        {
+          ...hookBase,
+          decision,
+          runtime,
+          signal,
+          orderResult: signal
+        },
+        { decision, signal }
+      );
+      return signal;
+    }
+    await beforePlaceOrder();
+    await connector.placeOrder(
+      {
+        symbol,
+        qty: decision.orderPlan.qty,
+        price: decision.entryContext.prices.currentPrice,
+        timestamp: decision.entryContext.timestamp,
+        direction: decision.entryContext.direction
+      },
+      decision.orderPlan.takeProfits,
+      decision.orderPlan.stopLossPrice
+    );
+    await invokeHook(
+      "afterPlaceOrder",
+      manifest?.hooks?.afterPlaceOrder,
+      {
+        ...hookBase,
+        decision,
+        runtime,
+        signal,
+        orderResult: decision.code
+      },
+      { decision, signal }
+    );
+  } catch (err) {
+    if (signal) {
+      signal.orderStatus = "failed";
+    }
+    await notifyRuntimeError({
+      stage: "placeOrder",
+      error: err,
+      decision,
+      signal
+    });
+    logger3.error("order error: %s %s", symbol, err);
+    return signal ?? "ORDER_ERROR";
+  }
+  return signal ?? decision.code;
+};
+var createStrategyRuntime = ({
+  strategyName,
+  defaults,
+  createCore,
+  manifest: staticManifest,
+  strategyDirectory
+}) => {
+  const resolveManifest = (name) => {
+    if (!name) {
+      return void 0;
+    }
+    if (staticManifest?.name === name) {
+      return staticManifest;
+    }
+    return getStrategyManifest(name);
+  };
+  const loadPineScript = createLoadPineScript(
+    strategyDirectory ? path.resolve(strategyDirectory) : path.resolve(
+      process.cwd(),
+      "packages",
+      "strategies",
+      "src",
+      strategyName
+    )
+  );
+  return async ({
+    userName,
+    config: baseConfig,
+    symbol,
+    data,
+    btcData,
+    btcBinanceData,
+    btcCoinbaseData,
+    connector
+  }) => {
+    const { config, isConfigFromBacktest } = await resolveStrategyConfig({
+      strategyName,
+      userName,
+      symbol,
+      baseConfig,
+      defaults
+    });
+    const env = String(config.ENV ?? "BACKTEST");
+    const strategyManifest = resolveManifest(strategyName);
+    const hookBase = {
+      connector,
+      strategyName,
+      userName,
+      symbol,
+      config,
+      env,
+      isConfigFromBacktest
+    };
+    const notifyRuntimeError = async ({
+      stage,
+      error,
+      decision,
+      signal
+    }) => {
+      const errorStrategyName = decision?.kind === "entry" ? decision.entryContext.strategy : strategyName;
+      const errorManifest = resolveManifest(errorStrategyName) ?? strategyManifest;
+      const errorHookBase = {
+        ...hookBase,
+        strategyName: errorStrategyName
+      };
+      const onRuntimeError = errorManifest?.hooks?.onRuntimeError;
+      if (!onRuntimeError) {
+        return;
+      }
+      try {
+        await onRuntimeError({
+          ...errorHookBase,
+          stage,
+          error,
+          decision,
+          signal
+        });
+      } catch (hookError) {
+        logger3.error(
+          "runtime hook onRuntimeError failed: %s %s",
+          strategyName,
+          hookError
+        );
+      }
+    };
+    const invokeHook = async (stage, hook, params, errorContext = {}) => {
+      if (!hook) {
+        return void 0;
+      }
+      try {
+        return await hook(params);
+      } catch (error) {
+        logger3.error(
+          'strategy hook "%s" failed for %s: %s',
+          stage,
+          strategyName,
+          error
+        );
+        await notifyRuntimeError({
+          stage,
+          error,
+          decision: errorContext.decision,
+          signal: errorContext.signal
+        });
+        return void 0;
+      }
+    };
+    const indicatorsState = createStrategyIndicatorsState({
+      env,
+      data,
+      btcData,
+      btcBinanceData,
+      btcCoinbaseData,
+      periods: buildDefaultIndicatorPeriods(config)
+    });
+    const strategyApi = createStrategyAPI({
+      strategy: strategyName,
+      symbol,
+      interval: config.INTERVAL ?? "15",
+      env,
+      connector,
+      cachedData: data,
+      indicatorsState,
+      preloadStart: getTimestamp(SIGNALS_PRELOAD_DAYS),
+      backtestPriceMode: config.BACKTEST_PRICE_MODE,
+      isConfigFromBacktest
+    });
+    const core = await createCore({
+      userName,
+      symbol,
+      config,
+      isConfigFromBacktest,
+      connector,
+      data,
+      btcData,
+      loadPineScript,
+      strategyApi,
+      indicatorsState
+    });
+    await invokeHook("onInit", strategyManifest?.hooks?.onInit, {
+      ...hookBase,
+      data,
+      btcData
+    });
+    return async (candle, btcCandle) => {
+      data.push(candle);
+      btcData.push(btcCandle);
+      indicatorsState.setCurrentBar(candle, btcCandle);
+      const decision = await core(candle, btcCandle);
+      const decisionStrategyName = decision.kind === "entry" ? decision.entryContext.strategy : strategyName;
+      const decisionManifest = resolveManifest(decisionStrategyName) ?? strategyManifest;
+      const decisionHookBase = {
+        ...hookBase,
+        strategyName: decisionStrategyName
+      };
+      await invokeHook(
+        "afterCoreDecision",
+        decisionManifest?.hooks?.afterCoreDecision,
+        {
+          ...decisionHookBase,
+          decision,
+          candle,
+          btcCandle
+        },
+        { decision }
+      );
+      if (decision.kind === "skip") {
+        await invokeHook("onSkip", decisionManifest?.hooks?.onSkip, {
+          ...decisionHookBase,
+          decision,
+          candle,
+          btcCandle
+        });
+        return decision.code;
+      }
+      const makeOrdersEnabled = typeof config.MAKE_ORDERS === "boolean" ? config.MAKE_ORDERS : true;
+      if (decision.kind === "exit") {
+        if (!makeOrdersEnabled) {
+          return decision.code;
+        }
+        const closeGate = await invokeHook(
+          "beforeClosePosition",
+          decisionManifest?.hooks?.beforeClosePosition,
+          {
+            ...decisionHookBase,
+            decision
+          },
+          { decision }
+        );
+        if (closeGate?.allow === false) {
+          return closeGate.reason ? `CLOSE_BLOCKED_BY_HOOK:${closeGate.reason}` : "CLOSE_BLOCKED_BY_HOOK";
+        }
+        return handleExitDecision({
+          connector,
+          symbol,
+          decision,
+          onRuntimeError: async ({ stage, error, decision: exitDecision }) => {
+            await notifyRuntimeError({
+              stage,
+              error,
+              decision: exitDecision
+            });
+          }
+        });
+      }
+      const runtime = resolveEntryRuntimePolicy({
+        decision,
+        config,
+        manifest: decisionManifest
+      });
+      const signal = decision.signal;
+      if (signal) {
+        try {
+          await enrichSignalWithMl({
+            signal,
+            env,
+            ml: runtime.ml
+          });
+        } catch (error) {
+          await notifyRuntimeError({
+            stage: "enrichSignalWithMl",
+            error,
+            decision,
+            signal
+          });
+          throw error;
+        }
+        await invokeHook(
+          "afterEnrichMl",
+          decisionManifest?.hooks?.afterEnrichMl,
+          {
+            ...decisionHookBase,
+            decision,
+            runtime,
+            signal
+          },
+          { decision, signal }
+        );
+      }
+      let quality;
+      if (signal) {
+        try {
+          quality = await enrichSignalWithAi({
+            signal,
+            symbol,
+            direction: signal.direction,
+            env,
+            ai: runtime.ai
+          });
+        } catch (error) {
+          await notifyRuntimeError({
+            stage: "enrichSignalWithAi",
+            error,
+            decision,
+            signal
+          });
+          throw error;
+        }
+        await invokeHook(
+          "afterEnrichAi",
+          decisionManifest?.hooks?.afterEnrichAi,
+          {
+            ...decisionHookBase,
+            decision,
+            runtime,
+            signal,
+            quality
+          },
+          { decision, signal }
+        );
+      }
+      const minAiQuality = runtime.ai?.minQuality ?? 4;
+      const shouldMakeOrder = shouldExecuteEntryDecision({
+        makeOrdersEnabled,
+        env,
+        signal,
+        quality,
+        minAiQuality
+      });
+      if (!shouldMakeOrder) {
+        if (signal) {
+          signal.orderStatus = "skipped";
+          signal.orderSkipReason = getEntrySkipReason({
+            makeOrdersEnabled,
+            env,
+            quality,
+            minAiQuality
+          });
+        }
+        return signal ?? decision.code;
+      }
+      const entryGate = await invokeHook(
+        "beforeEntryGate",
+        decisionManifest?.hooks?.beforeEntryGate,
+        {
+          ...decisionHookBase,
+          decision,
+          runtime,
+          signal,
+          quality,
+          makeOrdersEnabled,
+          minAiQuality
+        },
+        { decision, signal }
+      );
+      if (entryGate?.allow === false) {
+        const skipReason = entryGate.reason ? `HOOK_BEFORE_ENTRY_GATE:${entryGate.reason}` : "HOOK_BEFORE_ENTRY_GATE";
+        if (signal) {
+          signal.orderStatus = "skipped";
+          signal.orderSkipReason = skipReason;
+        }
+        return signal ?? skipReason;
+      }
+      return executeEntryDecision({
+        connector,
+        symbol,
+        decision,
+        runtime,
+        manifest: decisionManifest,
+        hookBase: decisionHookBase,
+        invokeHook,
+        notifyRuntimeError
+      });
+    };
+  };
+};
+
+// src/strategies.ts
+var createCloseOppositeBeforePlaceOrderHook = ({
+  isEnabled
+}) => {
+  return async ({ connector, entryContext, config }) => {
+    if (!isEnabled(config)) {
+      return;
+    }
+    await closeOppositePositionsBeforeOpen({
+      connector,
+      entryContext
+    });
+  };
+};
+export {
+  MAX_AI_SERIES_POINTS,
+  askAI,
+  buildAiHumanPrompt,
+  buildAiPayload,
+  buildAiSystemPrompt,
+  closeOppositePositionsBeforeOpen,
+  createCloseOppositeBeforePlaceOrderHook,
+  createStrategyRuntime,
+  enrichSignalWithAi,
+  enrichSignalWithMl,
+  enrichSignalWithMlAi,
+  ensureIndicatorPluginsLoaded,
+  ensureStrategyPluginsLoaded,
+  executeEntryOrder,
+  getAvailableStrategyNames,
+  getRegisteredManifests,
+  getRegisteredStrategies,
+  getStrategyCreator,
+  getStrategyManifest,
+  isKnownStrategy,
+  registerStrategyEntries,
+  resetStrategyRegistryCache,
+  resolveStrategyConfig,
+  strategies,
+  trimSeriesDeep
+};