@tradejs/node 1.0.3 → 1.0.4

package/dist/strategies.mjs

@@ -1,6 +1,6 @@
 import {
   buildMlPayload
-} from "./chunk-H4HXW3EZ.mjs";
+} from "./chunk-RBE4PZER.mjs";
 import {
   require_lodash
 } from "./chunk-GKDBAF3A.mjs";
@@ -15,7 +15,7 @@ import {
   buildAiPayload,
   buildAiSystemPrompt,
   trimSeriesDeep
-} from "./chunk-QDYCJ2OK.mjs";
+} from "./chunk-LMAKIC3C.mjs";
 import {
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
@@ -28,10 +28,10 @@ import {
   registerStrategyEntries,
   resetStrategyRegistryCache,
   strategies
-} from "./chunk-CK2PW4L5.mjs";
+} from "./chunk-ZY6ULOWK.mjs";
 import {
   getTradejsProjectCwd
-} from "./chunk-3C76HVLA.mjs";
+} from "./chunk-P2ZUWONT.mjs";
 import {
   __toESM
 } from "./chunk-6DZX6EAA.mjs";
@@ -206,7 +206,7 @@ var enrichSignalWithAi = async ({
     return void 0;
   }
   try {
-    const { askAI: askAI2 } = await import("./ai-MDMDKAEE.mjs");
+    const { askAI: askAI2 } = await import("./ai-G7ATN4YL.mjs");
     const analysis = await askAI2(signal);
     if (typeof analysis?.quality === "number") {
       const normalizedQuality = Math.round(analysis.quality);
@@ -353,10 +353,151 @@ var getEntrySkipReason = ({
   }
   return "ENTRY_POLICY_BLOCKED";
 };
+var buildHookCtx = ({
+  connector,
+  strategyName,
+  userName,
+  symbol,
+  strategyConfig,
+  env,
+  isConfigFromBacktest
+}) => ({
+  connector,
+  strategyName,
+  userName,
+  symbol,
+  strategyConfig,
+  env,
+  isConfigFromBacktest
+});
+var buildHookEntry = ({
+  decision,
+  runtime
+}) => ({
+  context: decision.entryContext,
+  orderPlan: decision.orderPlan,
+  signal: decision.signal,
+  runtime: {
+    raw: decision.runtime,
+    resolved: runtime
+  }
+});
+var buildHookPolicy = ({
+  quality,
+  makeOrdersEnabled,
+  minAiQuality
+}) => ({
+  aiQuality: quality,
+  makeOrdersEnabled,
+  minAiQuality
+});
+var buildMlHookContext = ({
+  signal,
+  env,
+  ml
+}) => {
+  if (env === "BACKTEST") {
+    return {
+      config: ml,
+      attempted: false,
+      applied: false,
+      skippedReason: "BACKTEST"
+    };
+  }
+  if (!ml) {
+    return {
+      attempted: false,
+      applied: false,
+      skippedReason: "NO_RUNTIME"
+    };
+  }
+  if (ml.enabled === false) {
+    return {
+      config: ml,
+      attempted: false,
+      applied: false,
+      skippedReason: "DISABLED"
+    };
+  }
+  if (!ml.strategyConfig) {
+    return {
+      config: ml,
+      attempted: false,
+      applied: false,
+      skippedReason: "NO_STRATEGY_CONFIG"
+    };
+  }
+  if (typeof ml.mlThreshold !== "number") {
+    return {
+      config: ml,
+      attempted: false,
+      applied: false,
+      skippedReason: "NO_THRESHOLD"
+    };
+  }
+  if (signal.ml) {
+    return {
+      config: ml,
+      attempted: true,
+      applied: true,
+      result: signal.ml
+    };
+  }
+  return {
+    config: ml,
+    attempted: true,
+    applied: false,
+    skippedReason: "NO_RESULT"
+  };
+};
+var buildAiHookContext = ({
+  env,
+  ai,
+  quality
+}) => {
+  if (env === "BACKTEST") {
+    return {
+      config: ai,
+      attempted: false,
+      applied: false,
+      skippedReason: "BACKTEST"
+    };
+  }
+  if (!ai) {
+    return {
+      attempted: false,
+      applied: false,
+      skippedReason: "NO_RUNTIME"
+    };
+  }
+  if (ai.enabled === false) {
+    return {
+      config: ai,
+      attempted: false,
+      applied: false,
+      skippedReason: "DISABLED"
+    };
+  }
+  if (typeof quality === "number") {
+    return {
+      config: ai,
+      attempted: true,
+      applied: true,
+      quality
+    };
+  }
+  return {
+    config: ai,
+    attempted: true,
+    applied: false,
+    skippedReason: "NO_QUALITY"
+  };
+};
 var handleExitDecision = async ({
   connector,
   symbol,
   decision,
+  market,
   onRuntimeError
 }) => {
   try {
@@ -370,7 +511,8 @@ var handleExitDecision = async ({
     await onRuntimeError?.({
       stage: "closePosition",
       error: err,
-      decision
+      decision,
+      market
     });
     logger3.error("close order error: %s %s", symbol, err);
     return "ORDER_ERROR";
@@ -383,7 +525,12 @@ var executeEntryDecision = async ({
   decision,
   runtime,
   manifest,
-  hookBase,
+  hookCtx,
+  market,
+  entry,
+  policy,
+  ml,
+  ai,
   invokeHook,
   notifyRuntimeError
 }) => {
@@ -393,13 +540,15 @@ var executeEntryDecision = async ({
       "beforePlaceOrder",
       manifest?.hooks?.beforePlaceOrder,
       {
-        ...hookBase,
-        entryContext: decision.entryContext,
-        runtime,
+        ctx: hookCtx,
+        market,
         decision,
-        signal
+        entry,
+        policy,
+        ml,
+        ai
       },
-      { decision, signal }
+      { decision, entry, market }
     );
     try {
       await runtime.beforePlaceOrder?.();
@@ -408,7 +557,8 @@ var executeEntryDecision = async ({
         stage: "runtime.beforePlaceOrder",
         error,
         decision,
-        signal
+        entry,
+        market
       });
       throw error;
     }
@@ -431,13 +581,18 @@ var executeEntryDecision = async ({
         "afterPlaceOrder",
         manifest?.hooks?.afterPlaceOrder,
         {
-          ...hookBase,
+          ctx: hookCtx,
+          market,
           decision,
-          runtime,
-          signal,
-          orderResult: signal
+          entry,
+          policy,
+          ml,
+          ai,
+          order: {
+            result: signal
+          }
         },
-        { decision, signal }
+        { decision, entry, market }
       );
       return signal;
     }
@@ -457,13 +612,18 @@ var executeEntryDecision = async ({
       "afterPlaceOrder",
       manifest?.hooks?.afterPlaceOrder,
       {
-        ...hookBase,
+        ctx: hookCtx,
+        market,
         decision,
-        runtime,
-        signal,
-        orderResult: decision.code
+        entry,
+        policy,
+        ml,
+        ai,
+        order: {
+          result: decision.code
+        }
       },
-      { decision, signal }
+      { decision, entry, market }
     );
   } catch (err) {
     if (signal) {
@@ -473,7 +633,8 @@ var executeEntryDecision = async ({
       stage: "placeOrder",
       error: err,
       decision,
-      signal
+      entry,
+      market
     });
     logger3.error("order error: %s %s", symbol, err);
     return signal ?? "ORDER_ERROR";
@@ -530,33 +691,37 @@ var createStrategyRuntime = ({
       strategyName,
       userName,
       symbol,
-      config,
+      strategyConfig: config,
       env,
       isConfigFromBacktest
     };
+    const getHookCtx = (name = strategyName) => buildHookCtx({
+      ...hookBase,
+      strategyName: name
+    });
     const notifyRuntimeError = async ({
       stage,
       error,
       decision,
-      signal
+      entry,
+      market
     }) => {
       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,
+          ctx: getHookCtx(errorStrategyName),
+          market,
           decision,
-          signal
+          entry,
+          error: {
+            stage,
+            cause: error
+          }
         });
       } catch (hookError) {
         logger3.error(
@@ -583,7 +748,8 @@ var createStrategyRuntime = ({
           stage,
           error,
           decision: errorContext.decision,
-          signal: errorContext.signal
+          entry: errorContext.entry,
+          market: errorContext.market
         });
         return void 0;
       }
@@ -622,39 +788,45 @@ var createStrategyRuntime = ({
       indicatorsState
     });
     await invokeHook("onInit", strategyManifest?.hooks?.onInit, {
-      ...hookBase,
-      data,
-      btcData
+      ctx: getHookCtx(),
+      market: {
+        data,
+        btcData
+      }
     });
     return async (candle, btcCandle) => {
       data.push(candle);
       btcData.push(btcCandle);
       indicatorsState.setCurrentBar(candle, btcCandle);
+      const market = {
+        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
-      };
+      const decisionHookCtx = getHookCtx(decisionStrategyName);
       await invokeHook(
         "afterCoreDecision",
         decisionManifest?.hooks?.afterCoreDecision,
         {
-          ...decisionHookBase,
-          decision,
-          candle,
-          btcCandle
+          ctx: decisionHookCtx,
+          market,
+          decision
         },
-        { decision }
+        { decision, market }
       );
       if (decision.kind === "skip") {
-        await invokeHook("onSkip", decisionManifest?.hooks?.onSkip, {
-          ...decisionHookBase,
-          decision,
-          candle,
-          btcCandle
-        });
+        await invokeHook(
+          "onSkip",
+          decisionManifest?.hooks?.onSkip,
+          {
+            ctx: decisionHookCtx,
+            market,
+            decision
+          },
+          { decision, market }
+        );
         return decision.code;
       }
       const makeOrdersEnabled = typeof config.MAKE_ORDERS === "boolean" ? config.MAKE_ORDERS : true;
@@ -666,10 +838,11 @@ var createStrategyRuntime = ({
           "beforeClosePosition",
           decisionManifest?.hooks?.beforeClosePosition,
           {
-            ...decisionHookBase,
+            ctx: decisionHookCtx,
+            market,
             decision
           },
-          { decision }
+          { decision, market }
         );
         if (closeGate?.allow === false) {
           return closeGate.reason ? `CLOSE_BLOCKED_BY_HOOK:${closeGate.reason}` : "CLOSE_BLOCKED_BY_HOOK";
@@ -678,11 +851,18 @@ var createStrategyRuntime = ({
           connector,
           symbol,
           decision,
-          onRuntimeError: async ({ stage, error, decision: exitDecision }) => {
+          market,
+          onRuntimeError: async ({
+            stage,
+            error,
+            decision: exitDecision,
+            market: errorMarket
+          }) => {
             await notifyRuntimeError({
               stage,
               error,
-              decision: exitDecision
+              decision: exitDecision,
+              market: errorMarket
             });
           }
         });
@@ -693,6 +873,11 @@ var createStrategyRuntime = ({
         manifest: decisionManifest
       });
       const signal = decision.signal;
+      const entry = buildHookEntry({
+        decision,
+        runtime
+      });
+      let ml;
       if (signal) {
         try {
           await enrichSignalWithMl({
@@ -705,23 +890,31 @@ var createStrategyRuntime = ({
             stage: "enrichSignalWithMl",
             error,
             decision,
-            signal
+            entry,
+            market
           });
           throw error;
         }
+        ml = buildMlHookContext({
+          signal,
+          env,
+          ml: runtime.ml
+        });
         await invokeHook(
           "afterEnrichMl",
           decisionManifest?.hooks?.afterEnrichMl,
           {
-            ...decisionHookBase,
+            ctx: decisionHookCtx,
+            market,
             decision,
-            runtime,
-            signal
+            entry,
+            ml
           },
-          { decision, signal }
+          { decision, entry, market }
         );
       }
       let quality;
+      let ai;
       if (signal) {
         try {
           quality = await enrichSignalWithAi({
@@ -736,24 +929,36 @@ var createStrategyRuntime = ({
             stage: "enrichSignalWithAi",
             error,
             decision,
-            signal
+            entry,
+            market
           });
           throw error;
         }
+        ai = buildAiHookContext({
+          env,
+          ai: runtime.ai,
+          quality
+        });
         await invokeHook(
           "afterEnrichAi",
           decisionManifest?.hooks?.afterEnrichAi,
           {
-            ...decisionHookBase,
+            ctx: decisionHookCtx,
+            market,
             decision,
-            runtime,
-            signal,
-            quality
+            entry,
+            ml: ml ?? buildMlHookContext({ signal, env, ml: runtime.ml }),
+            ai
           },
-          { decision, signal }
+          { decision, entry, market }
         );
       }
       const minAiQuality = runtime.ai?.minQuality ?? 4;
+      const policy = buildHookPolicy({
+        quality,
+        makeOrdersEnabled,
+        minAiQuality
+      });
       const shouldMakeOrder = shouldExecuteEntryDecision({
         makeOrdersEnabled,
         env,
@@ -777,15 +982,15 @@ var createStrategyRuntime = ({
         "beforeEntryGate",
         decisionManifest?.hooks?.beforeEntryGate,
         {
-          ...decisionHookBase,
+          ctx: decisionHookCtx,
+          market,
           decision,
-          runtime,
-          signal,
-          quality,
-          makeOrdersEnabled,
-          minAiQuality
+          entry,
+          policy,
+          ml,
+          ai
         },
-        { decision, signal }
+        { decision, entry, market }
       );
       if (entryGate?.allow === false) {
         const skipReason = entryGate.reason ? `HOOK_BEFORE_ENTRY_GATE:${entryGate.reason}` : "HOOK_BEFORE_ENTRY_GATE";
@@ -801,7 +1006,12 @@ var createStrategyRuntime = ({
         decision,
         runtime,
         manifest: decisionManifest,
-        hookBase: decisionHookBase,
+        hookCtx: decisionHookCtx,
+        market,
+        entry,
+        policy,
+        ml,
+        ai,
         invokeHook,
         notifyRuntimeError
       });
@@ -813,13 +1023,13 @@ var createStrategyRuntime = ({
 var createCloseOppositeBeforePlaceOrderHook = ({
   isEnabled
 }) => {
-  return async ({ connector, entryContext, config }) => {
-    if (!isEnabled(config)) {
+  return async ({ ctx, entry }) => {
+    if (!isEnabled(ctx.strategyConfig)) {
       return;
     }
     await closeOppositePositionsBeforeOpen({
-      connector,
-      entryContext
+      connector: ctx.connector,
+      entryContext: entry.context
     });
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/node",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Node-only TradeJS runtime for strategies, backtests, Pine loading, and plugin registries.",
   "keywords": [
     "tradejs",
@@ -54,15 +54,16 @@
   "dependencies": {
     "@langchain/core": "^0.3.68",
     "@langchain/openai": "^0.6.11",
-    "@tradejs/core": "^1.0.3",
-    "@tradejs/infra": "^1.0.3",
-    "@tradejs/types": "^1.0.3",
+    "@tradejs/core": "^1.0.4",
+    "@tradejs/infra": "^1.0.4",
+    "@tradejs/types": "^1.0.4",
     "chalk": "4.1.2",
     "ioredis": "5.8.0",
     "pinets": "0.8.12",
     "progress": "^2.0.3",
     "puppeteer": "24.15.0",
-    "ts-node": "^10.9.2"
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0"
   },
   "devDependencies": {
     "@types/node": "^20",