@tradejs/node 3.0.1 → 3.1.1

package/dist/{chunk-OGAWBO3Z.mjs → chunk-W26Y6IRP.mjs}

@@ -1,11 +1,13 @@
 import {
   askAI,
-  getStrategyManifest,
   getStrategyProfileMlAdapter,
   resolveStrategyPolicyProfile,
-  runAiPromptLocal,
+  runAiPromptLocal
+} from "./chunk-SEQJ6V6B.mjs";
+import {
+  getStrategyManifest,
   setStrategyRuntimeFactory
-} from "./chunk-VRXU4E4O.mjs";
+} from "./chunk-XN7BC7XK.mjs";
 import {
   getTradejsProjectCwd,
   loadTradejsConfig
@@ -2774,6 +2776,7 @@ var executeEntryOrder = async ({
       deploymentId: signal.deploymentId,
       policyProfileId: signal.policyProfileId,
       runtimeConfigId: signal.runtimeConfigId,
+      runtimeReleaseVersion: signal.runtimeReleaseVersion,
       runtimeLineage: signal.runtimeLineage,
       ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {}
     });
@@ -3719,6 +3722,9 @@ var createStrategyRuntime = ({
     deploymentId: requestedDeploymentId,
     policyProfileId,
     runtimeConfigId,
+    runtimeReleaseVersion,
+    entriesPaused = false,
+    runtimeLineage,
     runtimeConfigSnapshot,
     data,
     btcData,
@@ -4377,6 +4383,7 @@ var createStrategyRuntime = ({
       });
       const signal = decision.signal;
       if (signal) {
+        if (runtimeLineage) signal.runtimeLineage = runtimeLineage;
         if (universe) signal.universe = universe;
         if (assetClass) signal.assetClass = assetClass;
         if (accountId) signal.accountId = accountId;
@@ -4387,6 +4394,9 @@ var createStrategyRuntime = ({
             signal.signalId = `${signal.signalId}:${runtimeConfigId}`;
           }
         }
+        if (runtimeReleaseVersion) {
+          signal.runtimeReleaseVersion = runtimeReleaseVersion;
+        }
         if (decisionHookCtx.policyProfileId) {
           signal.policyProfileId = decisionHookCtx.policyProfileId;
         }
@@ -4493,6 +4503,15 @@ var createStrategyRuntime = ({
         quality,
         minAiQuality
       });
+      if (entriesPaused) {
+        const skipReason = "RUNTIME_ENTRIES_PAUSED";
+        if (signal) {
+          signal.orderStatus = "skipped";
+          signal.orderSkipReason = skipReason;
+          signal.runtimeReleaseVersion = runtimeReleaseVersion;
+        }
+        return signal ?? skipReason;
+      }
       if (!shouldMakeOrder) {
         if (signal) {
           signal.orderStatus = "skipped";

package/dist/chunk-XN7BC7XK.mjs

@@ -0,0 +1,295 @@
+import {
+  getTradejsProjectCwd,
+  importTradejsModule,
+  loadTradejsConfig,
+  resolvePluginModuleSpecifier
+} from "./chunk-WS5DYEVZ.mjs";
+
+// src/strategy/manifests.ts
+import {
+  registerIndicatorEntries,
+  resetIndicatorRegistryCache
+} from "@tradejs/core/indicators";
+import { logger } from "@tradejs/infra/logger";
+var SHARED_STRATEGY_REGISTRY_KEY = "__tradejsNodeSharedStrategyRegistryV1__";
+var sharedRegistryScope = globalThis;
+var sharedStrategyRegistry = sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] ?? (sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] = {
+  registryStateByProjectRoot: /* @__PURE__ */ new Map()
+});
+var createStrategyRegistryState = () => ({
+  strategyCreators: /* @__PURE__ */ new Map(),
+  strategyManifestsMap: /* @__PURE__ */ new Map(),
+  strategyEntriesMap: /* @__PURE__ */ new Map(),
+  strategySourcesMap: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot = sharedStrategyRegistry.registryStateByProjectRoot;
+var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createStrategyRegistryState();
+    registryStateByProjectRoot.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
+var toUniqueModules = (modules = []) => [
+  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
+];
+var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+  const config = await loadTradejsConfig(cwd);
+  return {
+    strategyModules: toUniqueModules(config.strategies),
+    indicatorModules: toUniqueModules(config.indicators)
+  };
+};
+var extractModuleEntries = (moduleExport, key) => {
+  if (!moduleExport || typeof moduleExport !== "object") {
+    return null;
+  }
+  const candidate = moduleExport;
+  if (Array.isArray(candidate[key])) {
+    return candidate[key];
+  }
+  const defaultExport = candidate.default;
+  if (defaultExport && Array.isArray(defaultExport[key])) {
+    return defaultExport[key];
+  }
+  return null;
+};
+var extractStrategyPluginDefinition = (moduleExport) => {
+  const strategyEntries = extractModuleEntries(
+    moduleExport,
+    "strategyEntries"
+  );
+  return strategyEntries ? { strategyEntries } : null;
+};
+var extractIndicatorPluginDefinition = (moduleExport) => {
+  const indicatorEntries = extractModuleEntries(
+    moduleExport,
+    "indicatorEntries"
+  );
+  return indicatorEntries ? { indicatorEntries } : null;
+};
+var registerEntries = (entries, source, state) => {
+  for (const entry of entries) {
+    const strategyName = entry.manifest?.name;
+    if (!strategyName) {
+      logger.warn("Skip strategy entry without name from %s", source);
+      continue;
+    }
+    if (state.strategyCreators.has(strategyName)) {
+      logger.warn(
+        'Skip duplicate strategy "%s" from %s: already registered',
+        strategyName,
+        source
+      );
+      continue;
+    }
+    state.strategyManifestsMap.set(strategyName, entry.manifest);
+    state.strategyEntriesMap.set(strategyName, entry);
+    state.strategySourcesMap.set(strategyName, source);
+    materializeStrategyCreator(strategyName, state);
+  }
+};
+var materializeStrategyCreator = (strategyName, state) => {
+  if (state.strategyCreators.has(strategyName) || !sharedStrategyRegistry.strategyRuntimeFactory) {
+    return;
+  }
+  const entry = state.strategyEntriesMap.get(strategyName);
+  if (!entry) return;
+  state.strategyCreators.set(
+    strategyName,
+    sharedStrategyRegistry.strategyRuntimeFactory({
+      strategyName,
+      defaults: entry.defaults,
+      createCore: entry.createCore,
+      manifest: entry.manifest,
+      detectorKey: entry.detectorKey,
+      detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
+      resolveRegisteredManifest: (name) => state.strategyManifestsMap.get(name)
+    })
+  );
+};
+var setStrategyRuntimeFactory = (factory) => {
+  sharedStrategyRegistry.strategyRuntimeFactory = factory;
+  for (const state of registryStateByProjectRoot.values()) {
+    for (const strategyName of state.strategyEntriesMap.keys()) {
+      materializeStrategyCreator(strategyName, state);
+    }
+  }
+};
+var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  if (typeof importTradejsModule === "function") {
+    return importTradejsModule(moduleName, cwd);
+  }
+  return import(
+    /* webpackIgnore: true */
+    moduleName
+  );
+};
+var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+  const { projectRoot, state } = getStrategyRegistryState(cwd);
+  if (!state.pluginsLoadPromise) {
+    resetIndicatorRegistryCache(projectRoot);
+    state.pluginsLoadPromise = (async () => {
+      const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames(projectRoot);
+      const strategySet = new Set(strategyModules);
+      const indicatorSet = new Set(indicatorModules);
+      const pluginModuleNames = [
+        .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
+      ];
+      if (!pluginModuleNames.length) {
+        return;
+      }
+      for (const moduleName of pluginModuleNames) {
+        try {
+          const resolvedModuleName = resolvePluginModuleSpecifier(
+            moduleName,
+            projectRoot
+          );
+          const moduleExport = await importStrategyPluginModule(
+            resolvedModuleName,
+            projectRoot
+          );
+          if (strategySet.has(moduleName)) {
+            const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+            if (!pluginDefinition) {
+              logger.warn(
+                'Skip strategy plugin "%s": export { strategyEntries } is missing',
+                moduleName
+              );
+            } else {
+              registerEntries(
+                pluginDefinition.strategyEntries,
+                moduleName,
+                state
+              );
+            }
+          }
+          if (indicatorSet.has(moduleName)) {
+            const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
+            if (!indicatorPluginDefinition) {
+              logger.warn(
+                'Skip indicator plugin "%s": export { indicatorEntries } is missing',
+                moduleName
+              );
+            } else {
+              registerIndicatorEntries(
+                indicatorPluginDefinition.indicatorEntries,
+                moduleName,
+                projectRoot
+              );
+            }
+          }
+          if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+            logger.warn(
+              'Skip plugin "%s": no strategy/indicator sections requested in config',
+              moduleName
+            );
+          }
+        } catch (error) {
+          logger.warn(
+            'Failed to load plugin "%s": %s',
+            moduleName,
+            String(error)
+          );
+        }
+      }
+    })();
+  }
+  await state.pluginsLoadPromise;
+};
+var ensureIndicatorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => ensureStrategyPluginsLoaded(cwd);
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.get(name);
+};
+var getStrategyDefaults = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyEntriesMap.get(name)?.defaults;
+};
+var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategySourcesMap.get(name);
+};
+var getAvailableStrategyNames = async (cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
+};
+var getRegisteredStrategies = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return Object.fromEntries(state.strategyCreators.entries());
+};
+var getRegisteredManifests = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyManifestsMap.values()];
+};
+var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+  if (!name) {
+    return void 0;
+  }
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyManifestsMap.get(name);
+};
+var isKnownStrategy = (name, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.has(name);
+};
+var registerStrategyEntries = (entries, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  registerEntries(entries, "runtime", state);
+};
+var resetStrategyRegistryCache = (cwd) => {
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd) {
+    registryStateByProjectRoot.clear();
+    resetIndicatorRegistryCache();
+    return;
+  }
+  const projectRoot = getTradejsProjectCwd(normalizedCwd);
+  registryStateByProjectRoot.delete(projectRoot);
+  resetIndicatorRegistryCache(projectRoot);
+};
+var strategies = new Proxy(
+  {},
+  {
+    get: (_target, property) => {
+      if (typeof property !== "string") {
+        return void 0;
+      }
+      return getStrategyRegistryState().state.strategyCreators.get(property);
+    },
+    ownKeys: () => {
+      return [...getStrategyRegistryState().state.strategyCreators.keys()];
+    },
+    getOwnPropertyDescriptor: () => ({
+      enumerable: true,
+      configurable: true
+    })
+  }
+);
+
+export {
+  setStrategyRuntimeFactory,
+  ensureStrategyPluginsLoaded,
+  ensureIndicatorPluginsLoaded,
+  getStrategyCreator,
+  getStrategyDefaults,
+  getStrategyPluginSource,
+  getAvailableStrategyNames,
+  getRegisteredStrategies,
+  getRegisteredManifests,
+  getStrategyManifest,
+  isKnownStrategy,
+  registerStrategyEntries,
+  resetStrategyRegistryCache,
+  strategies
+};