@tradejs/node 1.0.3 → 1.0.4

package/dist/strategies.js

@@ -5546,7 +5546,7 @@ var init_aiShared = __esm({
 });
 
 // src/tradejsConfig.ts
-var import_fs, import_path, import_module, import_url, import_logger2, CONFIG_FILE_NAMES, TS_MODULE_RE, cachedByCwd, announcedConfigFile, tsNodeRegistered, getTradejsProjectCwd, normalizeConfig, getRequireFn, ensureTsNodeRegistered, toImportSpecifier, isTsModulePath, isRelativeModulePath, isBareModuleSpecifier, importConfigFile, importTradejsModule, resolveExportedConfig, findConfigFilePath, resolvePluginModuleSpecifier, loadTradejsConfig;
+var import_fs, import_path, import_module, import_url, import_logger2, CONFIG_FILE_NAMES, TS_MODULE_RE, cachedByCwd, announcedConfigFile, tsNodeRegistered, tsconfigPathsRegisteredByCwd, getTradejsProjectCwd, normalizeConfig, getRequireFn, ensureTsNodeRegistered, ensureTsconfigPathsRegistered, toImportSpecifier, isTsModulePath, isRelativeModulePath, isBareModuleSpecifier, importConfigFile, importTradejsModule, resolveExportedConfig, findConfigFilePath, resolvePluginModuleSpecifier, loadTradejsConfig;
 var init_tradejsConfig = __esm({
   "src/tradejsConfig.ts"() {
     "use strict";
@@ -5566,6 +5566,7 @@ var init_tradejsConfig = __esm({
     cachedByCwd = /* @__PURE__ */ new Map();
     announcedConfigFile = /* @__PURE__ */ new Set();
     tsNodeRegistered = false;
+    tsconfigPathsRegisteredByCwd = /* @__PURE__ */ new Set();
     getTradejsProjectCwd = (cwd) => {
       const explicit = String(cwd ?? "").trim();
       if (explicit) {
@@ -5607,6 +5608,28 @@ var init_tradejsConfig = __esm({
       });
       tsNodeRegistered = true;
     };
+    ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
+      const projectRoot = getTradejsProjectCwd(cwd);
+      if (tsconfigPathsRegisteredByCwd.has(projectRoot)) {
+        return;
+      }
+      const tsconfigPathsModule = await import("tsconfig-paths");
+      const loadConfig = tsconfigPathsModule.loadConfig;
+      const register = tsconfigPathsModule.register;
+      if (typeof loadConfig !== "function" || typeof register !== "function") {
+        return;
+      }
+      const loadedConfig = loadConfig(projectRoot);
+      if (loadedConfig.resultType !== "success") {
+        return;
+      }
+      register({
+        baseUrl: loadedConfig.absoluteBaseUrl,
+        paths: loadedConfig.paths,
+        addMatchAll: false
+      });
+      tsconfigPathsRegisteredByCwd.add(projectRoot);
+    };
     toImportSpecifier = (moduleName) => {
       if (moduleName.startsWith("file://")) {
         return moduleName;
@@ -5634,6 +5657,7 @@ var init_tradejsConfig = __esm({
       if (ext === ".ts" || ext === ".mts") {
         const requireFn = getRequireFn(import_path.default.dirname(configFilePath));
         await ensureTsNodeRegistered();
+        await ensureTsconfigPathsRegistered(import_path.default.dirname(configFilePath));
         return requireFn(configFilePath);
       }
       return import(
@@ -5641,7 +5665,7 @@ var init_tradejsConfig = __esm({
         configFileUrl
       );
     };
-    importTradejsModule = async (moduleName) => {
+    importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
       const normalized = String(moduleName ?? "").trim();
       if (!normalized) {
         return {};
@@ -5655,13 +5679,15 @@ var init_tradejsConfig = __esm({
         }
       }
       const requireFn = getRequireFn(
-        import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : getTradejsProjectCwd()
+        import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : cwd
       );
       if (isTsModulePath(modulePath)) {
         await ensureTsNodeRegistered();
+        await ensureTsconfigPathsRegistered(cwd);
         return requireFn(modulePath);
       }
       if (isBareModuleSpecifier(normalized)) {
+        await ensureTsconfigPathsRegistered(cwd);
         return requireFn(normalized);
       }
       try {
@@ -5672,6 +5698,7 @@ var init_tradejsConfig = __esm({
       } catch (error) {
         if (isTsModulePath(modulePath)) {
           await ensureTsNodeRegistered();
+          await ensureTsconfigPathsRegistered(cwd);
           return requireFn(modulePath);
         }
         throw error;
@@ -5834,9 +5861,9 @@ var init_manifests = __esm({
         state.strategyManifestsMap.set(strategyName, entry.manifest);
       }
     };
-    importStrategyPluginModule = async (moduleName) => {
+    importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
       if (typeof importTradejsModule === "function") {
-        return importTradejsModule(moduleName);
+        return importTradejsModule(moduleName, cwd);
       }
       return import(
         /* webpackIgnore: true */
@@ -5863,7 +5890,10 @@ var init_manifests = __esm({
                 moduleName,
                 projectRoot
               );
-              const moduleExport = await importStrategyPluginModule(resolvedModuleName);
+              const moduleExport = await importStrategyPluginModule(
+                resolvedModuleName,
+                projectRoot
+              );
               if (strategySet.has(moduleName)) {
                 const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
                 if (!pluginDefinition) {
@@ -6678,10 +6708,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 {
@@ -6695,7 +6866,8 @@ var handleExitDecision = async ({
     await onRuntimeError?.({
       stage: "closePosition",
       error: err,
-      decision
+      decision,
+      market
     });
     import_logger5.logger.error("close order error: %s %s", symbol, err);
     return "ORDER_ERROR";
@@ -6708,7 +6880,12 @@ var executeEntryDecision = async ({
   decision,
   runtime,
   manifest,
-  hookBase,
+  hookCtx,
+  market,
+  entry,
+  policy,
+  ml,
+  ai,
   invokeHook,
   notifyRuntimeError
 }) => {
@@ -6718,13 +6895,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?.();
@@ -6733,7 +6912,8 @@ var executeEntryDecision = async ({
         stage: "runtime.beforePlaceOrder",
         error,
         decision,
-        signal
+        entry,
+        market
       });
       throw error;
     }
@@ -6756,13 +6936,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;
     }
@@ -6782,13 +6967,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) {
@@ -6798,7 +6988,8 @@ var executeEntryDecision = async ({
       stage: "placeOrder",
       error: err,
       decision,
-      signal
+      entry,
+      market
     });
     import_logger5.logger.error("order error: %s %s", symbol, err);
     return signal ?? "ORDER_ERROR";
@@ -6855,33 +7046,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) {
         import_logger5.logger.error(
@@ -6908,7 +7103,8 @@ var createStrategyRuntime = ({
           stage,
           error,
           decision: errorContext.decision,
-          signal: errorContext.signal
+          entry: errorContext.entry,
+          market: errorContext.market
         });
         return void 0;
       }
@@ -6947,39 +7143,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;
@@ -6991,10 +7193,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";
@@ -7003,11 +7206,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
             });
           }
         });
@@ -7018,6 +7228,11 @@ var createStrategyRuntime = ({
         manifest: decisionManifest
       });
       const signal = decision.signal;
+      const entry = buildHookEntry({
+        decision,
+        runtime
+      });
+      let ml;
       if (signal) {
         try {
           await enrichSignalWithMl({
@@ -7030,23 +7245,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({
@@ -7061,24 +7284,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,
@@ -7102,15 +7337,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";
@@ -7126,7 +7361,12 @@ var createStrategyRuntime = ({
         decision,
         runtime,
         manifest: decisionManifest,
-        hookBase: decisionHookBase,
+        hookCtx: decisionHookCtx,
+        market,
+        entry,
+        policy,
+        ml,
+        ai,
         invokeHook,
         notifyRuntimeError
       });
@@ -7138,13 +7378,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
     });
   };
 };