@tradejs/strategies 1.0.5 → 1.0.8

package/dist/chunk-IMLNXICX.mjs

@@ -0,0 +1,547 @@
+// src/AdaptiveMomentumRibbon/adapters/ai.ts
+import { mapAiRuntimeFromConfig } from "@tradejs/core/strategies";
+var ADAPTIVE_MOMENTUM_RIBBON_CONTEXT_PROMPT = `
+AdaptiveMomentumRibbon addon:
+- This is a momentum entry based on an oscillator zero-cross, not a trendline breakout and not a line-reversal setup.
+- LONG appears when \`signalOsc\` crosses above 0 and the ribbon switches into \`activeBuy\`; SHORT is the mirror case.
+- \`invalidationLevel\` is the structural invalidation level on the signal bar. If \`invalidated=true\` or \`invalidationLevel\` sits on the wrong side of the current price, do not treat the setup as confirmed.
+- \`channelState\` and \`channelBiasAligned\` describe where price sits relative to the Keltner Channel. For LONG it is a negative sign if price is still below \`kcMidline\`; for SHORT it is a negative sign if price is above \`kcMidline\`.
+- \`invalidationDistancePct\` and \`structuralRewardRiskRatio\` describe how compact the structure is. Do not overstate quality when invalidation is too wide or reward/risk versus invalidation is weak.
+- \`quality=5\` requires very clean momentum: correct channel side, strong \`signalOsc\`, sane invalidation distance, and no coin/BTC bias conflicts.
+- If \`approvalAllowedNow=false\` or \`deterministicQuality<4\`, this is usually watch mode rather than a ready live approval.
+`;
+var ADAPTIVE_MOMENTUM_RIBBON_PAYLOAD_PROMPT = `
+- \`payload.additionalIndicators.adaptiveMomentumRibbonContext\` contains a compact signal summary:
+  signalOsc / oscillatorStrength / channelState / channelExtensionPct / invalidationDistancePct / structuralRewardRiskRatio / coinBiasAligned / btcBiasAligned / deterministicQuality / approvalAllowedNow / structuralHardBlockReasons.
+- Use this context as the primary strategy-specific interpretation instead of re-deriving it only from generic series.
+`;
+var toFiniteNumberOrNull = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+};
+var getLastFiniteNumber = (value) => {
+  if (Array.isArray(value)) {
+    for (let i = value.length - 1; i >= 0; i -= 1) {
+      const item = toFiniteNumberOrNull(value[i]);
+      if (item != null) {
+        return item;
+      }
+    }
+    return null;
+  }
+  return toFiniteNumberOrNull(value);
+};
+var getBias = (fast, slow) => {
+  if (fast == null || slow == null) {
+    return null;
+  }
+  if (fast > slow) {
+    return "bullish";
+  }
+  if (fast < slow) {
+    return "bearish";
+  }
+  return null;
+};
+var getSignalDirection = (signal) => signal.direction === "LONG" || signal.direction === "SHORT" ? signal.direction : null;
+var asBoolean = (value) => value === true || value === 1;
+var getRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var getPrimarySession = (signal, additionalIndicators) => {
+  const marketContext = getRecord(
+    additionalIndicators?.marketContext ?? signal.additionalIndicators?.marketContext
+  );
+  const tradingSession = getRecord(marketContext?.tradingSession);
+  const primarySession = tradingSession?.primarySession;
+  if (primarySession === "asia" || primarySession === "europe" || primarySession === "us" || primarySession === "off_hours") {
+    return primarySession;
+  }
+  const timestamp = toFiniteNumberOrNull(signal.timestamp);
+  if (timestamp == null) {
+    return null;
+  }
+  const date = new Date(timestamp);
+  const minuteUtc = date.getUTCHours() * 60 + date.getUTCMinutes();
+  const activeSessions = [
+    minuteUtc >= 0 && minuteUtc < 8 * 60 ? "asia" : null,
+    minuteUtc >= 7 * 60 && minuteUtc < 16 * 60 ? "europe" : null,
+    minuteUtc >= 13 * 60 && minuteUtc < 22 * 60 ? "us" : null
+  ].filter(
+    (session) => session != null
+  );
+  if (activeSessions.includes("us")) {
+    return "us";
+  }
+  if (activeSessions.includes("europe")) {
+    return "europe";
+  }
+  if (activeSessions.includes("asia")) {
+    return "asia";
+  }
+  return "off_hours";
+};
+var getAdaptiveMomentumRibbonSnapshot = (signal) => {
+  const additional = getRecord(signal.additionalIndicators);
+  const amr = additional?.amr;
+  return amr && typeof amr === "object" ? amr : {};
+};
+var getAdaptiveMomentumRibbonConfigSnapshot = (signal) => {
+  const additional = getRecord(signal.additionalIndicators);
+  return getRecord(additional?.amrConfigSnapshot);
+};
+var isAtLeast = (value, threshold) => value != null && value >= threshold;
+var isInRange = (value, min, max) => value != null && value >= min && value <= max;
+var getDirectionalInvalidationDistancePct = ({
+  signalDirection,
+  currentPrice,
+  invalidationLevel
+}) => {
+  if (signalDirection == null || currentPrice == null || currentPrice <= 0 || invalidationLevel == null) {
+    return null;
+  }
+  if (signalDirection === "LONG") {
+    if (invalidationLevel >= currentPrice) {
+      return null;
+    }
+    return (currentPrice - invalidationLevel) / currentPrice * 100;
+  }
+  if (invalidationLevel <= currentPrice) {
+    return null;
+  }
+  return (invalidationLevel - currentPrice) / currentPrice * 100;
+};
+var getDirectionalRewardPct = ({
+  signalDirection,
+  currentPrice,
+  takeProfitPrice
+}) => {
+  if (signalDirection == null || currentPrice == null || currentPrice <= 0 || takeProfitPrice == null) {
+    return null;
+  }
+  return signalDirection === "LONG" ? (takeProfitPrice - currentPrice) / currentPrice * 100 : (currentPrice - takeProfitPrice) / currentPrice * 100;
+};
+var getDirectionalChannelExtensionPct = ({
+  signalDirection,
+  currentPrice,
+  kcUpper,
+  kcLower
+}) => {
+  if (signalDirection == null || currentPrice == null || currentPrice <= 0) {
+    return null;
+  }
+  if (signalDirection === "LONG") {
+    if (kcUpper == null || currentPrice <= kcUpper) {
+      return null;
+    }
+    return (currentPrice - kcUpper) / currentPrice * 100;
+  }
+  if (kcLower == null || currentPrice >= kcLower) {
+    return null;
+  }
+  return (kcLower - currentPrice) / currentPrice * 100;
+};
+var getChannelState = ({
+  signalDirection,
+  currentPrice,
+  kcMidline,
+  kcUpper,
+  kcLower
+}) => {
+  if (signalDirection == null || currentPrice == null || kcMidline == null) {
+    return "unknown";
+  }
+  if (signalDirection === "LONG") {
+    if (kcUpper != null && currentPrice >= kcUpper) {
+      return "above_upper";
+    }
+    if (currentPrice >= kcMidline) {
+      return "inside_channel";
+    }
+    if (kcLower != null && currentPrice <= kcLower) {
+      return "below_lower";
+    }
+    return "below_midline";
+  }
+  if (kcLower != null && currentPrice <= kcLower) {
+    return "below_lower";
+  }
+  if (currentPrice <= kcMidline) {
+    return "inside_channel";
+  }
+  if (kcUpper != null && currentPrice >= kcUpper) {
+    return "above_upper";
+  }
+  return "above_midline";
+};
+var getRetestPrice = (context) => {
+  if (context.signalDirection === "LONG") {
+    if (context.kcMidline != null && context.channelState === "below_midline") {
+      return context.kcMidline;
+    }
+    return context.kcUpper ?? context.kcMidline ?? context.invalidationLevel;
+  }
+  if (context.signalDirection === "SHORT") {
+    if (context.kcMidline != null && context.channelState === "above_midline") {
+      return context.kcMidline;
+    }
+    return context.kcLower ?? context.kcMidline ?? context.invalidationLevel;
+  }
+  return null;
+};
+var getDeterministicAdaptiveMomentumRibbonQuality = (context) => {
+  if (context.hardBlockReasons.length > 0) {
+    return 2;
+  }
+  const biasConflictCount = Number(context.coinBiasAligned === false) + Number(context.btcBiasAligned === false);
+  const noBiasConflict = biasConflictCount === 0;
+  const oscillatorModerate = isAtLeast(context.oscillatorStrength, 0.3);
+  const oscillatorStrong = isAtLeast(context.oscillatorStrength, 0.55);
+  const oscillatorElite = isAtLeast(context.oscillatorStrength, 0.9);
+  const invalidationCompact = isInRange(
+    context.invalidationDistancePct,
+    0.15,
+    1.8
+  );
+  const invalidationTight = isInRange(
+    context.invalidationDistancePct,
+    0.2,
+    1.25
+  );
+  const structuralRrModerate = isAtLeast(
+    context.structuralRewardRiskRatio,
+    1.2
+  );
+  const structuralRrStrong = isAtLeast(context.structuralRewardRiskRatio, 1.8);
+  const channelSupportive = context.channelBiasAligned === true;
+  const channelExpansion = context.signalDirection === "LONG" ? context.channelState === "above_upper" : context.channelState === "below_lower";
+  const channelExtensionStrong = isAtLeast(context.channelExtensionPct, 0.08);
+  const sessionAllowsApproval = context.sessionAllowsApproval !== false;
+  const slowestDetector = context.momentumPeriod === 48 && context.butterworthSmoothing === 6;
+  if (!sessionAllowsApproval) {
+    return 3;
+  }
+  if (channelSupportive && channelExpansion && channelExtensionStrong && oscillatorElite && invalidationTight && structuralRrStrong && noBiasConflict) {
+    return 5;
+  }
+  if (channelSupportive && channelExpansion && !slowestDetector && oscillatorModerate && invalidationCompact && structuralRrModerate && biasConflictCount < 2 && (biasConflictCount === 0 || oscillatorStrong)) {
+    return 4;
+  }
+  return 3;
+};
+var getHardBlockReasonText = (reason) => {
+  switch (reason) {
+    case "invalidated":
+      return "the signal is already invalidated relative to invalidationLevel";
+    case "inactive_signal_state":
+      return "the active ribbon state does not confirm the current direction";
+    case "oscillator_conflict":
+      return "signalOsc conflicts with the signal direction";
+    case "invalidation_wrong_side":
+      return "invalidationLevel is on the wrong side of the current price";
+    default:
+      return reason;
+  }
+};
+var buildAdaptiveMomentumRibbonContext = (signal, additionalIndicators) => {
+  const signalDirection = getSignalDirection(signal);
+  const snapshot = getAdaptiveMomentumRibbonSnapshot(signal);
+  const configSnapshot = getAdaptiveMomentumRibbonConfigSnapshot(signal);
+  const momentumPeriod = toFiniteNumberOrNull(configSnapshot?.momentumPeriod);
+  const butterworthSmoothing = toFiniteNumberOrNull(
+    configSnapshot?.butterworthSmoothing
+  );
+  const currentPrice = toFiniteNumberOrNull(signal.prices?.currentPrice);
+  const takeProfitPrice = toFiniteNumberOrNull(signal.prices?.takeProfitPrice);
+  const signalOsc = toFiniteNumberOrNull(snapshot.signalOsc);
+  const oscillatorStrength = signalOsc != null ? Math.abs(signalOsc) : null;
+  const kcMidline = toFiniteNumberOrNull(snapshot.kcMidline);
+  const kcUpper = toFiniteNumberOrNull(snapshot.kcUpper);
+  const kcLower = toFiniteNumberOrNull(snapshot.kcLower);
+  const invalidationLevel = toFiniteNumberOrNull(snapshot.invalidationLevel);
+  const entryLong = asBoolean(snapshot.entryLong);
+  const entryShort = asBoolean(snapshot.entryShort);
+  const activeBuy = asBoolean(snapshot.activeBuy);
+  const activeSell = asBoolean(snapshot.activeSell);
+  const invalidated = asBoolean(snapshot.invalidated);
+  const channelState = getChannelState({
+    signalDirection,
+    currentPrice,
+    kcMidline,
+    kcUpper,
+    kcLower
+  });
+  const channelBiasAligned = signalDirection === "LONG" ? kcMidline != null && currentPrice != null ? currentPrice >= kcMidline : null : signalDirection === "SHORT" ? kcMidline != null && currentPrice != null ? currentPrice <= kcMidline : null : null;
+  const channelExtensionPct = getDirectionalChannelExtensionPct({
+    signalDirection,
+    currentPrice,
+    kcUpper,
+    kcLower
+  });
+  const invalidationDistancePct = getDirectionalInvalidationDistancePct({
+    signalDirection,
+    currentPrice,
+    invalidationLevel
+  });
+  const rewardPct = getDirectionalRewardPct({
+    signalDirection,
+    currentPrice,
+    takeProfitPrice
+  });
+  const structuralRewardRiskRatio = rewardPct != null && invalidationDistancePct != null && invalidationDistancePct > 0 ? rewardPct / invalidationDistancePct : null;
+  const coinBias = getBias(
+    getLastFiniteNumber(signal.indicators?.maFast),
+    getLastFiniteNumber(signal.indicators?.maSlow)
+  );
+  const btcBias = getBias(
+    getLastFiniteNumber(signal.indicators?.btcMaFast),
+    getLastFiniteNumber(signal.indicators?.btcMaSlow)
+  );
+  const coinBiasAligned = signalDirection === "LONG" ? coinBias == null ? null : coinBias === "bullish" : signalDirection === "SHORT" ? coinBias == null ? null : coinBias === "bearish" : null;
+  const btcBiasAligned = signalDirection === "LONG" ? btcBias == null ? null : btcBias === "bullish" : signalDirection === "SHORT" ? btcBias == null ? null : btcBias === "bearish" : null;
+  const primarySession = getPrimarySession(signal, additionalIndicators);
+  const sessionAllowsApproval = primarySession == null ? null : primarySession === "off_hours";
+  const hardBlockReasons = [];
+  if (invalidated) {
+    hardBlockReasons.push("invalidated");
+  }
+  if (signalDirection === "LONG" && (!entryLong || !activeBuy) || signalDirection === "SHORT" && (!entryShort || !activeSell)) {
+    hardBlockReasons.push("inactive_signal_state");
+  }
+  if (signalDirection === "LONG" && !isAtLeast(signalOsc, Number.EPSILON) || signalDirection === "SHORT" && !(signalOsc != null && signalOsc < -Number.EPSILON)) {
+    hardBlockReasons.push("oscillator_conflict");
+  }
+  if (signalDirection != null && invalidationLevel != null && currentPrice != null && (signalDirection === "LONG" && invalidationLevel >= currentPrice || signalDirection === "SHORT" && invalidationLevel <= currentPrice)) {
+    hardBlockReasons.push("invalidation_wrong_side");
+  }
+  const deterministicQuality = getDeterministicAdaptiveMomentumRibbonQuality({
+    signalDirection,
+    momentumPeriod,
+    butterworthSmoothing,
+    entryLong,
+    entryShort,
+    activeBuy,
+    activeSell,
+    invalidated,
+    signalOsc,
+    oscillatorStrength,
+    kcMidline,
+    kcUpper,
+    kcLower,
+    invalidationLevel,
+    channelState,
+    channelBiasAligned,
+    channelExtensionPct,
+    invalidationDistancePct,
+    structuralRewardRiskRatio,
+    coinMaBias: coinBias,
+    btcMaBias: btcBias,
+    coinBiasAligned,
+    btcBiasAligned,
+    primarySession,
+    sessionAllowsApproval,
+    hardBlockReasons
+  });
+  return {
+    signalDirection,
+    momentumPeriod,
+    butterworthSmoothing,
+    entryLong,
+    entryShort,
+    activeBuy,
+    activeSell,
+    invalidated,
+    signalOsc,
+    oscillatorStrength,
+    kcMidline,
+    kcUpper,
+    kcLower,
+    invalidationLevel,
+    channelState,
+    channelBiasAligned,
+    channelExtensionPct,
+    invalidationDistancePct,
+    structuralRewardRiskRatio,
+    coinMaBias: coinBias,
+    btcMaBias: btcBias,
+    coinBiasAligned,
+    btcBiasAligned,
+    primarySession,
+    sessionAllowsApproval,
+    hardBlockReasons,
+    structuralHardBlockReasons: hardBlockReasons,
+    deterministicQuality,
+    approvalAllowedNow: deterministicQuality >= 4,
+    maxAllowedQuality: deterministicQuality
+  };
+};
+var getAdaptiveMomentumRibbonContextFromPayload = (payload, signal) => {
+  const additional = payload.additionalIndicators;
+  const context = additional?.adaptiveMomentumRibbonContext;
+  return context && typeof context === "object" ? context : buildAdaptiveMomentumRibbonContext(signal);
+};
+var clampQuality = (value, maxAllowedQuality) => {
+  const resolved = typeof value === "number" ? value : maxAllowedQuality;
+  return Math.max(1, Math.min(maxAllowedQuality, Math.round(resolved)));
+};
+var postProcessAnalysis = ({
+  signal,
+  payload,
+  analysis
+}) => {
+  const context = getAdaptiveMomentumRibbonContextFromPayload(payload, signal);
+  const signalDirection = getSignalDirection(signal);
+  const requestedDirection = analysis.direction === signalDirection ? signalDirection : null;
+  const finalDirection = requestedDirection != null && context.approvalAllowedNow ? requestedDirection : null;
+  const finalQuality = clampQuality(
+    typeof analysis.quality === "number" ? analysis.quality : context.deterministicQuality,
+    context.maxAllowedQuality
+  );
+  const needRetest = finalDirection == null;
+  const retestPrice = needRetest ? getRetestPrice(context) : null;
+  if (finalDirection == null) {
+    return {
+      ...analysis,
+      direction: null,
+      quality: finalQuality,
+      needRetest: true,
+      retestPrice,
+      takeProfitPrice: null,
+      stopLossPrice: null,
+      qualityReason: analysis.qualityReason || (context.hardBlockReasons.length > 0 ? `AdaptiveMomentumRibbon guardrail: ${context.hardBlockReasons.map(getHardBlockReasonText).join("; ")}.` : "AdaptiveMomentumRibbon keeps the setup in watch mode until momentum confirmation becomes cleaner."),
+      triggerInvalidation: analysis.triggerInvalidation || (retestPrice != null ? `Wait for confirmation relative to level ${retestPrice}.` : "Wait for cleaner momentum confirmation and better price positioning inside the Keltner channel."),
+      comment: analysis.comment || (context.hardBlockReasons.length > 0 ? `AdaptiveMomentumRibbon rejected: ${context.hardBlockReasons.map(getHardBlockReasonText).join("; ")}.` : "AdaptiveMomentumRibbon keeps the signal in watch mode until continuation confirmation becomes cleaner.")
+    };
+  }
+  return {
+    ...analysis,
+    direction: finalDirection,
+    quality: finalQuality,
+    needRetest: false,
+    retestPrice: null,
+    takeProfitPrice: signal.prices?.takeProfitPrice ?? null,
+    stopLossPrice: signal.prices?.stopLossPrice ?? null
+  };
+};
+var adaptiveMomentumRibbonAiAdapter = {
+  buildPayload: ({ signal, basePayload }) => {
+    const additionalIndicators = getRecord(basePayload.additionalIndicators);
+    return {
+      ...basePayload,
+      additionalIndicators: {
+        ...additionalIndicators ?? {},
+        adaptiveMomentumRibbonContext: buildAdaptiveMomentumRibbonContext(
+          signal,
+          additionalIndicators
+        )
+      }
+    };
+  },
+  postProcessAnalysis,
+  buildSystemPromptAddon: () => `${ADAPTIVE_MOMENTUM_RIBBON_CONTEXT_PROMPT}
+${ADAPTIVE_MOMENTUM_RIBBON_PAYLOAD_PROMPT}`,
+  buildHumanPromptAddon: ({ signal, payload }) => {
+    const context = getAdaptiveMomentumRibbonContextFromPayload(
+      payload,
+      signal
+    );
+    return `
+
+Additional AdaptiveMomentumRibbon context:
+- momentumPeriod=${context.momentumPeriod ?? "n/a"}
+- butterworthSmoothing=${context.butterworthSmoothing ?? "n/a"}
+- signalOsc=${context.signalOsc?.toFixed?.(3) ?? "n/a"}
+- oscillatorStrength=${context.oscillatorStrength?.toFixed?.(3) ?? "n/a"}
+- channelState=${context.channelState}
+- channelBiasAligned=${context.channelBiasAligned}
+- channelExtensionPct=${context.channelExtensionPct?.toFixed?.(3) ?? "n/a"}%
+- invalidationDistancePct=${context.invalidationDistancePct?.toFixed?.(3) ?? "n/a"}%
+- structuralRewardRiskRatio=${context.structuralRewardRiskRatio?.toFixed?.(3) ?? "n/a"}
+- coinBiasAligned=${context.coinBiasAligned}
+- btcBiasAligned=${context.btcBiasAligned}
+- primarySession=${context.primarySession ?? "n/a"}
+- sessionAllowsApproval=${context.sessionAllowsApproval}
+- deterministicQuality=${context.deterministicQuality}
+- approvalAllowedNow=${context.approvalAllowedNow}
+- hardBlockReasons=${context.hardBlockReasons.join(", ") || "none"}
+
+Interpretation rules for AdaptiveMomentumRibbon:
+- a zero-cross alone does not make quality high;
+- pay attention to Keltner channel side, sane invalidation distance, and bias alignment;
+- if \`signalOsc\` already conflicts with direction or the signal is invalidated, do not treat the entry as confirmed.
+`;
+  },
+  mapEntryRuntimeFromConfig: (config2) => mapAiRuntimeFromConfig(
+    config2
+  )
+};
+
+// src/AdaptiveMomentumRibbon/adapters/ml.ts
+import { mapMlRuntimeFromConfig } from "@tradejs/core/strategies";
+var adaptiveMomentumRibbonMlAdapter = {
+  mapEntryRuntimeFromConfig: (config2) => mapMlRuntimeFromConfig(
+    config2
+  )
+};
+
+// src/AdaptiveMomentumRibbon/manifest.ts
+var adaptiveMomentumRibbonManifest = {
+  name: "AdaptiveMomentumRibbon",
+  aiAdapter: adaptiveMomentumRibbonAiAdapter,
+  mlAdapter: adaptiveMomentumRibbonMlAdapter
+};
+
+// src/AdaptiveMomentumRibbon/config.ts
+var config = {
+  ENV: "BACKTEST",
+  INTERVAL: "15",
+  MAKE_ORDERS: true,
+  CLOSE_OPPOSITE_POSITIONS: false,
+  BACKTEST_PRICE_MODE: "mid",
+  AI_ENABLED: false,
+  AI_MODE: "llm",
+  ML_ENABLED: false,
+  ML_THRESHOLD: 0.1,
+  MIN_AI_QUALITY: 3,
+  FEE_PERCENT: 5e-3,
+  MAX_LOSS_VALUE: 10,
+  AMR_LOOKBACK_BARS: 200,
+  AMR_MOMENTUM_PERIOD: 32,
+  AMR_BUTTERWORTH_SMOOTHING: 4,
+  AMR_WAIT_CLOSE: true,
+  AMR_CONFIRM_ON_NEXT_BAR: true,
+  AMR_MIN_SIGNAL_OSC_ABS: 0.55,
+  AMR_REQUIRE_KC_BIAS: true,
+  AMR_MIN_BARS_BETWEEN_SIGNALS: 12,
+  AMR_SHOW_INVALIDATION_LEVELS: true,
+  AMR_SHOW_KELTNER_CHANNEL: true,
+  AMR_KC_LENGTH: 20,
+  AMR_KC_MA_TYPE: "EMA",
+  AMR_ATR_LENGTH: 14,
+  AMR_ATR_MULTIPLIER: 2,
+  AMR_EXIT_ON_INVALIDATION: true,
+  AMR_LINE_PLOTS: ["kcMidline", "kcUpper", "kcLower", "invalidationLevel"],
+  LONG: {
+    enable: true,
+    direction: "LONG",
+    TP: 2,
+    SL: 1
+  },
+  SHORT: {
+    enable: true,
+    direction: "SHORT",
+    TP: 2,
+    SL: 1
+  }
+};
+
+export {
+  adaptiveMomentumRibbonAiAdapter,
+  adaptiveMomentumRibbonMlAdapter,
+  adaptiveMomentumRibbonManifest,
+  config
+};