@tradejs/node 3.1.0 → 3.1.2

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
+};

package/dist/cli.js

@@ -952,6 +952,7 @@ var createStrategyRegistryState = () => ({
   strategyCreators: /* @__PURE__ */ new Map(),
   strategyManifestsMap: /* @__PURE__ */ new Map(),
   strategyEntriesMap: /* @__PURE__ */ new Map(),
+  strategySourcesMap: /* @__PURE__ */ new Map(),
   pluginsLoadPromise: null
 });
 var registryStateByProjectRoot = sharedStrategyRegistry.registryStateByProjectRoot;
@@ -1022,6 +1023,7 @@ var registerEntries = (entries, source, state) => {
     }
     state.strategyManifestsMap.set(strategyName, entry.manifest);
     state.strategyEntriesMap.set(strategyName, entry);
+    state.strategySourcesMap.set(strategyName, source);
     materializeStrategyCreator(strategyName, state);
   }
 };

package/dist/cli.mjs

@@ -4,9 +4,11 @@ import {
   SCREENSHOT_CONCURRENCY_LIMIT
 } from "./chunk-KMJQQ53K.mjs";
 import {
-  askAI,
+  askAI
+} from "./chunk-SEQJ6V6B.mjs";
+import {
   ensureStrategyPluginsLoaded
-} from "./chunk-KOQSLFT2.mjs";
+} from "./chunk-XN7BC7XK.mjs";
 import {
   getTradejsProjectCwd,
   loadTradejsConfig

package/dist/registry-DHTLjQcr.d.mts

@@ -0,0 +1,17 @@
+import { StrategyManifest, StrategyCreator, StrategyRegistryEntry } from '@tradejs/types';
+
+declare const ensureStrategyPluginsLoaded: (cwd?: string) => Promise<void>;
+declare const ensureIndicatorPluginsLoaded: (cwd?: string) => Promise<void>;
+declare const getStrategyCreator: (name: string, cwd?: string) => Promise<StrategyCreator | undefined>;
+declare const getStrategyDefaults: (name: string, cwd?: string) => Promise<StrategyRegistryEntry["defaults"] | undefined>;
+declare const getStrategyPluginSource: (name: string, cwd?: string) => Promise<string | undefined>;
+declare const getAvailableStrategyNames: (cwd?: string) => Promise<string[]>;
+declare const getRegisteredStrategies: (cwd?: string) => Record<string, StrategyCreator>;
+declare const getRegisteredManifests: (cwd?: string) => StrategyManifest[];
+declare const getStrategyManifest: (name?: string, cwd?: string) => StrategyManifest | undefined;
+declare const isKnownStrategy: (name: string, cwd?: string) => boolean;
+declare const registerStrategyEntries: (entries: readonly StrategyRegistryEntry[], cwd?: string) => void;
+declare const resetStrategyRegistryCache: (cwd?: string) => void;
+declare const strategies: Record<string, StrategyCreator>;
+
+export { ensureStrategyPluginsLoaded as a, getRegisteredManifests as b, getRegisteredStrategies as c, getStrategyCreator as d, ensureIndicatorPluginsLoaded as e, getStrategyDefaults as f, getAvailableStrategyNames as g, getStrategyManifest as h, getStrategyPluginSource as i, isKnownStrategy as j, resetStrategyRegistryCache as k, registerStrategyEntries as r, strategies as s };

package/dist/registry-DHTLjQcr.d.ts

@@ -0,0 +1,17 @@
+import { StrategyManifest, StrategyCreator, StrategyRegistryEntry } from '@tradejs/types';
+
+declare const ensureStrategyPluginsLoaded: (cwd?: string) => Promise<void>;
+declare const ensureIndicatorPluginsLoaded: (cwd?: string) => Promise<void>;
+declare const getStrategyCreator: (name: string, cwd?: string) => Promise<StrategyCreator | undefined>;
+declare const getStrategyDefaults: (name: string, cwd?: string) => Promise<StrategyRegistryEntry["defaults"] | undefined>;
+declare const getStrategyPluginSource: (name: string, cwd?: string) => Promise<string | undefined>;
+declare const getAvailableStrategyNames: (cwd?: string) => Promise<string[]>;
+declare const getRegisteredStrategies: (cwd?: string) => Record<string, StrategyCreator>;
+declare const getRegisteredManifests: (cwd?: string) => StrategyManifest[];
+declare const getStrategyManifest: (name?: string, cwd?: string) => StrategyManifest | undefined;
+declare const isKnownStrategy: (name: string, cwd?: string) => boolean;
+declare const registerStrategyEntries: (entries: readonly StrategyRegistryEntry[], cwd?: string) => void;
+declare const resetStrategyRegistryCache: (cwd?: string) => void;
+declare const strategies: Record<string, StrategyCreator>;
+
+export { ensureStrategyPluginsLoaded as a, getRegisteredManifests as b, getRegisteredStrategies as c, getStrategyCreator as d, ensureIndicatorPluginsLoaded as e, getStrategyDefaults as f, getAvailableStrategyNames as g, getStrategyManifest as h, getStrategyPluginSource as i, isKnownStrategy as j, resetStrategyRegistryCache as k, registerStrategyEntries as r, strategies as s };

package/dist/registry.d.mts

@@ -1,16 +1,2 @@
-import { StrategyManifest, StrategyCreator, StrategyRegistryEntry } from '@tradejs/types';
-
-declare const ensureStrategyPluginsLoaded: (cwd?: string) => Promise<void>;
-declare const ensureIndicatorPluginsLoaded: (cwd?: string) => Promise<void>;
-declare const getStrategyCreator: (name: string, cwd?: string) => Promise<StrategyCreator | undefined>;
-declare const getStrategyDefaults: (name: string, cwd?: string) => Promise<StrategyRegistryEntry["defaults"] | undefined>;
-declare const getAvailableStrategyNames: (cwd?: string) => Promise<string[]>;
-declare const getRegisteredStrategies: (cwd?: string) => Record<string, StrategyCreator>;
-declare const getRegisteredManifests: (cwd?: string) => StrategyManifest[];
-declare const getStrategyManifest: (name?: string, cwd?: string) => StrategyManifest | undefined;
-declare const isKnownStrategy: (name: string, cwd?: string) => boolean;
-declare const registerStrategyEntries: (entries: readonly StrategyRegistryEntry[], cwd?: string) => void;
-declare const resetStrategyRegistryCache: (cwd?: string) => void;
-declare const strategies: Record<string, StrategyCreator>;
-
-export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyDefaults, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies };
+export { e as ensureIndicatorPluginsLoaded, a as ensureStrategyPluginsLoaded, g as getAvailableStrategyNames, b as getRegisteredManifests, c as getRegisteredStrategies, d as getStrategyCreator, f as getStrategyDefaults, h as getStrategyManifest, j as isKnownStrategy, r as registerStrategyEntries, k as resetStrategyRegistryCache, s as strategies } from './registry-DHTLjQcr.mjs';
+import '@tradejs/types';

package/dist/registry.d.ts

@@ -1,16 +1,2 @@
-import { StrategyManifest, StrategyCreator, StrategyRegistryEntry } from '@tradejs/types';
-
-declare const ensureStrategyPluginsLoaded: (cwd?: string) => Promise<void>;
-declare const ensureIndicatorPluginsLoaded: (cwd?: string) => Promise<void>;
-declare const getStrategyCreator: (name: string, cwd?: string) => Promise<StrategyCreator | undefined>;
-declare const getStrategyDefaults: (name: string, cwd?: string) => Promise<StrategyRegistryEntry["defaults"] | undefined>;
-declare const getAvailableStrategyNames: (cwd?: string) => Promise<string[]>;
-declare const getRegisteredStrategies: (cwd?: string) => Record<string, StrategyCreator>;
-declare const getRegisteredManifests: (cwd?: string) => StrategyManifest[];
-declare const getStrategyManifest: (name?: string, cwd?: string) => StrategyManifest | undefined;
-declare const isKnownStrategy: (name: string, cwd?: string) => boolean;
-declare const registerStrategyEntries: (entries: readonly StrategyRegistryEntry[], cwd?: string) => void;
-declare const resetStrategyRegistryCache: (cwd?: string) => void;
-declare const strategies: Record<string, StrategyCreator>;
-
-export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyDefaults, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies };
+export { e as ensureIndicatorPluginsLoaded, a as ensureStrategyPluginsLoaded, g as getAvailableStrategyNames, b as getRegisteredManifests, c as getRegisteredStrategies, d as getStrategyCreator, f as getStrategyDefaults, h as getStrategyManifest, j as isKnownStrategy, r as registerStrategyEntries, k as resetStrategyRegistryCache, s as strategies } from './registry-DHTLjQcr.js';
+import '@tradejs/types';

package/dist/registry.js

@@ -930,6 +930,7 @@ var createStrategyRegistryState = () => ({
   strategyCreators: /* @__PURE__ */ new Map(),
   strategyManifestsMap: /* @__PURE__ */ new Map(),
   strategyEntriesMap: /* @__PURE__ */ new Map(),
+  strategySourcesMap: /* @__PURE__ */ new Map(),
   pluginsLoadPromise: null
 });
 var registryStateByProjectRoot = sharedStrategyRegistry.registryStateByProjectRoot;
@@ -1000,6 +1001,7 @@ var registerEntries = (entries, source, state) => {
     }
     state.strategyManifestsMap.set(strategyName, entry.manifest);
     state.strategyEntriesMap.set(strategyName, entry);
+    state.strategySourcesMap.set(strategyName, source);
     materializeStrategyCreator(strategyName, state);
   }
 };
@@ -4458,6 +4460,7 @@ var executeEntryOrder = async ({
       deploymentId: signal.deploymentId,
       policyProfileId: signal.policyProfileId,
       runtimeConfigId: signal.runtimeConfigId,
+      runtimeReleaseVersion: signal.runtimeReleaseVersion,
       runtimeLineage: signal.runtimeLineage,
       ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {}
     });
@@ -5382,6 +5385,9 @@ var createStrategyRuntime = ({
     deploymentId: requestedDeploymentId,
     policyProfileId,
     runtimeConfigId,
+    runtimeReleaseVersion,
+    entriesPaused = false,
+    runtimeLineage,
     runtimeConfigSnapshot,
     data,
     btcData,
@@ -6040,6 +6046,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;
@@ -6050,6 +6057,9 @@ var createStrategyRuntime = ({
             signal.signalId = `${signal.signalId}:${runtimeConfigId}`;
           }
         }
+        if (runtimeReleaseVersion) {
+          signal.runtimeReleaseVersion = runtimeReleaseVersion;
+        }
         if (decisionHookCtx.policyProfileId) {
           signal.policyProfileId = decisionHookCtx.policyProfileId;
         }
@@ -6156,6 +6166,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/registry.mjs

@@ -1,4 +1,5 @@
-import "./chunk-MKLTJQLY.mjs";
+import "./chunk-W26Y6IRP.mjs";
+import "./chunk-SEQJ6V6B.mjs";
 import {
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
@@ -12,7 +13,7 @@ import {
   registerStrategyEntries,
   resetStrategyRegistryCache,
   strategies
-} from "./chunk-KOQSLFT2.mjs";
+} from "./chunk-XN7BC7XK.mjs";
 import "./chunk-WS5DYEVZ.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {