@tradejs/strategies 1.0.5 → 1.0.8

package/dist/index.mjs

@@ -1,25 +1,39 @@
 import {
-  breakoutManifest
-} from "./chunk-3PN7ZSJJ.mjs";
+  breakoutManifest,
+  config as config2
+} from "./chunk-37ZWRG3W.mjs";
 import {
-  config,
+  config as config6,
   trendLineManifest
-} from "./chunk-MVIV5ZII.mjs";
+} from "./chunk-TDUTYEGH.mjs";
 import {
+  config as config5,
+  trendShiftAiAdapter,
+  trendShiftManifest
+} from "./chunk-SOVTOGY4.mjs";
+import {
+  config as config4,
+  reverseTrendLineAiAdapter,
+  reverseTrendLineManifest
+} from "./chunk-UK4YHD2E.mjs";
+import {
+  config as config3,
   maStrategyAiAdapter,
   maStrategyManifest,
   maStrategyMlAdapter
-} from "./chunk-RDK2JK3K.mjs";
+} from "./chunk-H4MHFD4B.mjs";
 import {
   adaptiveMomentumRibbonAiAdapter,
   adaptiveMomentumRibbonManifest,
-  adaptiveMomentumRibbonMlAdapter
-} from "./chunk-RYEPHOGL.mjs";
+  adaptiveMomentumRibbonMlAdapter,
+  config
+} from "./chunk-IMLNXICX.mjs";
 import {
+  config as config7,
   volumeDivergenceAiAdapter,
   volumeDivergenceManifest,
   volumeDivergenceMlAdapter
-} from "./chunk-ULLCAH5C.mjs";
+} from "./chunk-QVWMBYYM.mjs";
 import "./chunk-HEBXNMVQ.mjs";
 
 // src/index.ts
@@ -40,48 +54,81 @@ var strategyEntries = [
   {
     manifest: breakoutManifest,
     creator: createLazyStrategyCreator(
-      () => import("./strategy-Y4SOK6FF.mjs"),
+      () => import("./strategy-JQIJILHQ.mjs"),
       "BreakoutStrategyCreator"
     )
   },
   {
     manifest: trendLineManifest,
     creator: createLazyStrategyCreator(
-      () => import("./strategy-UZBWST3G.mjs"),
+      () => import("./strategy-D7H5J3C4.mjs"),
       "TrendlineStrategyCreator"
     )
   },
+  {
+    manifest: trendShiftManifest,
+    creator: createLazyStrategyCreator(
+      () => import("./strategy-QEIPAPY4.mjs"),
+      "TrendShiftStrategyCreator"
+    )
+  },
+  {
+    manifest: reverseTrendLineManifest,
+    creator: createLazyStrategyCreator(
+      () => import("./strategy-HQIPCUOY.mjs"),
+      "ReverseTrendLineStrategyCreator"
+    )
+  },
   {
     manifest: maStrategyManifest,
     creator: createLazyStrategyCreator(
-      () => import("./strategy-ZVNTA6UR.mjs"),
+      () => import("./strategy-ABIO65CR.mjs"),
       "MaStrategyCreator"
     )
   },
   {
     manifest: adaptiveMomentumRibbonManifest,
     creator: createLazyStrategyCreator(
-      () => import("./strategy-UHRWSGZC.mjs"),
+      () => import("./strategy-XTUKPYPM.mjs"),
       "AdaptiveMomentumRibbonStrategyCreator"
     )
   },
   {
     manifest: volumeDivergenceManifest,
     creator: createLazyStrategyCreator(
-      () => import("./strategy-M3BRWDRR.mjs"),
+      () => import("./strategy-WYN4FZ5S.mjs"),
       "VolumeDivergenceStrategyCreator"
     )
   }
 ];
+var builtInStrategyDefaultConfigs = {
+  Breakout: config2,
+  TrendLine: config6,
+  TrendShift: config5,
+  ReverseTrendLine: config4,
+  MaStrategy: config3,
+  AdaptiveMomentumRibbon: config,
+  VolumeDivergence: config7
+};
+var getBuiltInStrategyDefaultConfig = (strategyName) => builtInStrategyDefaultConfigs[strategyName];
 var index_default = defineStrategyPlugin({ strategyEntries });
 export {
   adaptiveMomentumRibbonAiAdapter,
+  config as adaptiveMomentumRibbonDefaultConfig,
   adaptiveMomentumRibbonMlAdapter,
+  config2 as breakoutDefaultConfig,
   index_default as default,
+  getBuiltInStrategyDefaultConfig,
   maStrategyAiAdapter,
+  config3 as maStrategyDefaultConfig,
   maStrategyMlAdapter,
+  reverseTrendLineAiAdapter,
+  config4 as reverseTrendLineDefaultConfig,
   strategyEntries,
-  config as trendLineDefaultConfig,
+  config6 as trendLineDefaultConfig,
+  trendShiftAiAdapter,
+  config5 as trendShiftDefaultConfig,
   volumeDivergenceAiAdapter,
+  config7 as volumeDivergenceDefaultConfig,
   volumeDivergenceMlAdapter
 };

package/dist/{strategy-ZVNTA6UR.mjs → strategy-ABIO65CR.mjs}

@@ -1,44 +1,12 @@
 import {
+  config,
   maStrategyManifest
-} from "./chunk-RDK2JK3K.mjs";
+} from "./chunk-H4MHFD4B.mjs";
 import "./chunk-HEBXNMVQ.mjs";
 
 // src/MaStrategy/strategy.ts
 import { createStrategyRuntime } from "@tradejs/node/strategies";
 
-// src/MaStrategy/config.ts
-var config = {
-  ENV: "BACKTEST",
-  INTERVAL: "15",
-  MAKE_ORDERS: true,
-  CLOSE_OPPOSITE_POSITIONS: false,
-  BACKTEST_PRICE_MODE: "mid",
-  AI_ENABLED: false,
-  ML_ENABLED: false,
-  ML_THRESHOLD: 0.1,
-  MIN_AI_QUALITY: 3,
-  FEE_PERCENT: 5e-3,
-  MAX_LOSS_VALUE: 10,
-  MAX_CORRELATION: 0.45,
-  TRADE_COOLDOWN_MS: 0,
-  MA_FAST: 21,
-  MA_SLOW: 55,
-  LONG: {
-    enable: true,
-    direction: "LONG",
-    TP: 2,
-    SL: 1,
-    minRiskRatio: 1.5
-  },
-  SHORT: {
-    enable: true,
-    direction: "SHORT",
-    TP: 2,
-    SL: 1,
-    minRiskRatio: 1.5
-  }
-};
-
 // src/MaStrategy/core.ts
 import { round } from "@tradejs/core/math";
 
@@ -134,15 +102,7 @@ var detectCross = (maFast, maSlow) => {
   return null;
 };
 var createMaStrategyCore = async ({ config: config2, strategyApi, indicatorsState }) => {
-  const {
-    ENV,
-    FEE_PERCENT,
-    MAX_LOSS_VALUE,
-    MAX_CORRELATION,
-    TRADE_COOLDOWN_MS,
-    LONG,
-    SHORT
-  } = config2;
+  const { FEE_PERCENT, MAX_LOSS_VALUE, TRADE_COOLDOWN_MS, LONG, SHORT } = config2;
   const lastTradeController = strategyApi.createLastTradeController({
     enabled: Number(TRADE_COOLDOWN_MS ?? 0) > 0,
     cooldownMs: Number(TRADE_COOLDOWN_MS ?? 0)
@@ -205,9 +165,6 @@ var createMaStrategyCore = async ({ config: config2, strategyApi, indicatorsStat
       return strategyApi.skip(`RISK_RATIO:${round(riskRatio)}`);
     }
     const correlation = indicatorsState.latestNumber("correlation");
-    if (ENV !== "BACKTEST" && correlation != null && correlation >= MAX_CORRELATION) {
-      return strategyApi.skip(`MAX_CORRELATION:${round(correlation)}`);
-    }
     lastTradeController.markTrade(timestamp);
     return strategyApi.entry({
       code: cross.kind === "bullish" ? "MA_BULLISH_CROSS" : "MA_BEARISH_CROSS",

package/dist/strategy-D7H5J3C4.mjs

@@ -0,0 +1,348 @@
+import {
+  buildTrendlineStructuralContext,
+  buildTrendlineTimingContext,
+  config,
+  trendLineManifest
+} from "./chunk-TDUTYEGH.mjs";
+import "./chunk-HEBXNMVQ.mjs";
+
+// src/TrendLine/strategy.ts
+import { createStrategyRuntime } from "@tradejs/node/strategies";
+
+// src/TrendLine/core.ts
+import { round as round2 } from "@tradejs/core/math";
+import { createTrendlineEngine } from "@tradejs/core/indicators";
+
+// src/TrendLine/filters.ts
+import { diffRel } from "@tradejs/core/math";
+import { ATR_PCT } from "@tradejs/indicators";
+var MAX_CANDLE_VOLATILITY = 0.025;
+var filterByVeryVolatility = (data) => {
+  const lastCandle = data[data.length - 1];
+  const prevCandle = data[data.length - 2];
+  const isVeryVolatility = diffRel(lastCandle.low, lastCandle.high) > MAX_CANDLE_VOLATILITY || diffRel(prevCandle.low, prevCandle.high) > MAX_CANDLE_VOLATILITY;
+  if (isVeryVolatility) {
+    return false;
+  }
+  return true;
+};
+
+// src/TrendLine/figures.ts
+var buildTrendLineFigures = (bestLine) => ({
+  lines: [
+    {
+      id: bestLine.id,
+      kind: "trendline",
+      points: [...bestLine.points ?? []].sort(
+        (left, right) => left.timestamp - right.timestamp
+      ),
+      color: bestLine.mode === "lows" ? "#facc15" : "#fb923c",
+      width: 2,
+      style: "solid"
+    }
+  ],
+  points: [
+    {
+      id: `${bestLine.id}-points`,
+      kind: "trendline_points",
+      points: [...bestLine.points ?? [], ...bestLine.touches ?? []].sort(
+        (left, right) => left.timestamp - right.timestamp
+      ),
+      color: "#ef4444",
+      radius: 4
+    }
+  ]
+});
+
+// src/TrendLine/risk.ts
+import { round } from "@tradejs/core/math";
+var MIN_STOP_BUFFER_PCT = 0.15;
+var LINE_BUFFER_ATR_FACTOR = 0.35;
+var LINE_BUFFER_BASE_SL_FACTOR = 0.15;
+var ATR_STOP_FLOOR_FACTOR = 0.8;
+var MIN_STOP_LOSS_FACTOR = 0.75;
+var MAX_STOP_LOSS_FACTOR = 2.25;
+var clampNumber = (value, min, max) => Math.min(Math.max(value, min), max);
+var getTimingStopFactor = (entryTiming) => {
+  if (entryTiming === "ready_retest") {
+    return 0.9;
+  }
+  if (entryTiming === "ready_follow_through") {
+    return 1.05;
+  }
+  return 1;
+};
+var getTimingTargetRiskRatio = ({
+  direction,
+  entryTiming
+}) => {
+  if (direction === "LONG") {
+    if (entryTiming === "ready_retest") {
+      return 2.45;
+    }
+    if (entryTiming === "ready_follow_through") {
+      return 2.3;
+    }
+    return 2.6;
+  }
+  if (entryTiming === "ready_retest") {
+    return 2.3;
+  }
+  if (entryTiming === "ready_follow_through") {
+    return 2.15;
+  }
+  return 2.45;
+};
+var buildTrendlineRiskPlan = ({
+  direction,
+  modeConfig,
+  structuralContext,
+  timingContext
+}) => {
+  const baseStopLossDelta = modeConfig.SL;
+  const atrPct = structuralContext.atrPct ?? baseStopLossDelta;
+  const priceVsLinePctAbs = structuralContext.priceVsLinePctAbs ?? 0;
+  const breakVsAtrRatio = structuralContext.breakVsAtrRatio ?? 0;
+  const touches = structuralContext.touches ?? 0;
+  const distance = structuralContext.distance ?? null;
+  const lineBufferPct = Math.max(
+    atrPct * LINE_BUFFER_ATR_FACTOR,
+    baseStopLossDelta * LINE_BUFFER_BASE_SL_FACTOR,
+    MIN_STOP_BUFFER_PCT
+  );
+  const lineInvalidationPct = priceVsLinePctAbs + lineBufferPct;
+  const volatilityFloorPct = Math.max(
+    atrPct * ATR_STOP_FLOOR_FACTOR,
+    baseStopLossDelta * MIN_STOP_LOSS_FACTOR
+  );
+  let stopLossDelta = Math.max(lineInvalidationPct, volatilityFloorPct);
+  if (touches >= 6) {
+    stopLossDelta *= 0.95;
+  } else if (touches > 0 && touches <= 4) {
+    stopLossDelta *= 1.05;
+  }
+  if (distance != null && distance >= 250) {
+    stopLossDelta *= 1.08;
+  } else if (distance != null && distance <= 120) {
+    stopLossDelta *= 0.95;
+  }
+  stopLossDelta *= getTimingStopFactor(timingContext.entryTiming);
+  if (direction === "SHORT") {
+    stopLossDelta *= 1.08;
+  }
+  if (breakVsAtrRatio >= 1.5) {
+    stopLossDelta *= 0.95;
+  }
+  stopLossDelta = clampNumber(
+    stopLossDelta,
+    baseStopLossDelta * MIN_STOP_LOSS_FACTOR,
+    baseStopLossDelta * MAX_STOP_LOSS_FACTOR
+  );
+  let targetRiskRatio = getTimingTargetRiskRatio({
+    direction,
+    entryTiming: timingContext.entryTiming
+  });
+  if (breakVsAtrRatio >= 1.25) {
+    targetRiskRatio += 0.2;
+  } else if (breakVsAtrRatio > 0 && breakVsAtrRatio < 0.75) {
+    targetRiskRatio -= 0.15;
+  }
+  if (touches >= 6) {
+    targetRiskRatio += 0.1;
+  }
+  if (distance != null && distance >= 120 && distance <= 350) {
+    targetRiskRatio += 0.1;
+  }
+  if (direction === "SHORT" && distance != null && distance > 450) {
+    targetRiskRatio -= 0.25;
+  }
+  if (direction === "LONG" && distance != null && distance > 500) {
+    targetRiskRatio -= 0.15;
+  }
+  const minTargetRiskRatio = modeConfig.minRiskRatio + 0.05;
+  const maxTargetRiskRatio = Math.max(modeConfig.TP / modeConfig.SL, minTargetRiskRatio) + 0.4;
+  targetRiskRatio = clampNumber(
+    targetRiskRatio,
+    minTargetRiskRatio,
+    maxTargetRiskRatio
+  );
+  return {
+    stopLossDelta: round(stopLossDelta, 3),
+    targetRiskRatio: round(targetRiskRatio, 2),
+    takeProfitDelta: round(stopLossDelta * targetRiskRatio, 3)
+  };
+};
+
+// src/TrendLine/core.ts
+var buildTrendlineSignalSeed = ({
+  direction,
+  currentPrice,
+  indicators,
+  bestLine,
+  trendlineTiming
+}) => ({
+  direction,
+  prices: { currentPrice },
+  indicators,
+  additionalIndicators: {
+    touches: bestLine.touches.length + 2,
+    distance: bestLine.distance,
+    trendLine: bestLine,
+    ...trendlineTiming ? { trendlineTiming } : {}
+  },
+  figures: {
+    trendLine: bestLine
+  }
+});
+var isOpenPosition = (position) => Boolean(
+  position && typeof position.price === "number" && Number.isFinite(position.price) && typeof position.qty === "number" && Number.isFinite(position.qty) && position.qty > 0 && (position.direction === "LONG" || position.direction === "SHORT")
+);
+var isFailedBreakout = ({
+  direction,
+  priceVsLinePct
+}) => {
+  if (priceVsLinePct == null) {
+    return false;
+  }
+  return direction === "LONG" ? priceVsLinePct < 0 : priceVsLinePct > 0;
+};
+var createTrendLineCore = async ({ config: config2, data: cachedData, strategyApi, indicatorsState }) => {
+  const { TRENDLINE, FEE_PERCENT, MAX_LOSS_VALUE, HIGHS, LOWS } = config2;
+  const lastTradeController = strategyApi.createLastTradeController();
+  const trendlineOptions = {
+    bestLines: 1,
+    capture: true,
+    ...TRENDLINE
+  };
+  const getLowsTrendlines = createTrendlineEngine(cachedData, {
+    mode: "lows",
+    ...trendlineOptions
+  });
+  const getHighsTrendlines = createTrendlineEngine(cachedData, {
+    mode: "highs",
+    ...trendlineOptions
+  });
+  return async (candle) => {
+    const lowsTrendlines = getLowsTrendlines.next(candle);
+    const highsTrendlines = getHighsTrendlines.next(candle);
+    indicatorsState.onBar();
+    const currentPosition = await strategyApi.getCurrentPosition();
+    if (isOpenPosition(currentPosition)) {
+      const { currentPrice: currentPrice2 } = await strategyApi.getMarketData();
+      const activeLine = currentPosition.direction === "LONG" ? highsTrendlines[0] : lowsTrendlines[0];
+      const activeModeConfig = currentPosition.direction === "LONG" ? HIGHS : LOWS;
+      if (activeLine) {
+        const indicators2 = indicatorsState.snapshot();
+        const manageSignalSeed = buildTrendlineSignalSeed({
+          direction: activeModeConfig.direction,
+          currentPrice: currentPrice2,
+          indicators: indicators2,
+          bestLine: activeLine
+        });
+        const structuralContext2 = buildTrendlineStructuralContext(manageSignalSeed);
+        if (isFailedBreakout({
+          direction: currentPosition.direction,
+          priceVsLinePct: structuralContext2.priceVsLinePct
+        })) {
+          return strategyApi.exit({
+            code: "TRENDLINE_FAILED_BREAKOUT_EXIT",
+            direction: currentPosition.direction
+          });
+        }
+      }
+      return strategyApi.skip("POSITION_EXISTS");
+    }
+    const bestLine = lowsTrendlines.length > 0 ? lowsTrendlines[0] : highsTrendlines[0];
+    if (!bestLine) {
+      return strategyApi.skip("NO_TRENDLINE");
+    }
+    if (lastTradeController.isInCooldown(candle.timestamp)) {
+      return strategyApi.skip("DEV_TRADE_COOLDOWN");
+    }
+    const modeConfig = bestLine.mode === "highs" ? HIGHS : LOWS;
+    const { direction, minRiskRatio, enable } = modeConfig;
+    if (!enable) {
+      return strategyApi.skip("STRATEGY_DISABLED");
+    }
+    const { fullData, timestamp, currentPrice } = await strategyApi.getMarketData();
+    if (!filterByVeryVolatility(fullData)) {
+      return strategyApi.skip("VERY_VOLATILITY");
+    }
+    const indicators = indicatorsState.snapshot();
+    const signalSeed = buildTrendlineSignalSeed({
+      direction,
+      currentPrice,
+      indicators,
+      bestLine
+    });
+    const structuralContext = buildTrendlineStructuralContext(signalSeed);
+    if (structuralContext.structuralHardBlockReasons.length > 0) {
+      return strategyApi.skip(
+        `TRENDLINE_STRUCTURE:${structuralContext.structuralHardBlockReasons[0]}`
+      );
+    }
+    const timingContext = buildTrendlineTimingContext({
+      signal: signalSeed,
+      candles: fullData,
+      structuralContext
+    });
+    if (!timingContext.entryReadyNow) {
+      const timingCode = timingContext.entryTiming === "stale_breakout" ? "STALE_BREAKOUT" : timingContext.entryTiming === "wait_retest_confirmation" ? "WAIT_RETEST_CONFIRMATION" : "WAIT_RETEST";
+      return strategyApi.skip(`TRENDLINE_TIMING:${timingCode}`);
+    }
+    const riskPlan = buildTrendlineRiskPlan({
+      direction,
+      modeConfig,
+      structuralContext,
+      timingContext
+    });
+    const { stopLossPrice, takeProfitPrice, riskRatio, qty } = strategyApi.getDirectionalTpSlPrices({
+      price: currentPrice,
+      direction,
+      takeProfitDelta: riskPlan.takeProfitDelta,
+      stopLossDelta: riskPlan.stopLossDelta,
+      unit: "percent",
+      maxLossValue: MAX_LOSS_VALUE,
+      feePercent: Number(FEE_PERCENT ?? 0)
+    });
+    if (!qty || !Number.isFinite(qty) || qty <= 0) {
+      return strategyApi.skip("INVALID_QTY");
+    }
+    if (riskRatio <= minRiskRatio) {
+      return strategyApi.skip(`RISK_RATIO:${round2(riskRatio)}`);
+    }
+    lastTradeController.markTrade(timestamp);
+    return strategyApi.entry({
+      code: "TRENDLINE_SIGNAL",
+      figures: {
+        ...buildTrendLineFigures(bestLine)
+      },
+      direction,
+      indicators,
+      additionalIndicators: buildTrendlineSignalSeed({
+        direction,
+        currentPrice,
+        indicators,
+        bestLine,
+        trendlineTiming: timingContext
+      }).additionalIndicators,
+      orderPlan: {
+        qty,
+        stopLossPrice,
+        takeProfits: [{ rate: 1, price: takeProfitPrice }]
+      }
+    });
+  };
+};
+
+// src/TrendLine/strategy.ts
+var TrendlineStrategyCreator = createStrategyRuntime({
+  strategyName: "TrendLine",
+  defaults: config,
+  createCore: createTrendLineCore,
+  manifest: trendLineManifest,
+  strategyDirectory: __dirname
+});
+export {
+  TrendlineStrategyCreator
+};