@tradejs/node 3.1.8-beta.210 → 3.1.8-beta.213

package/dist/ai.mjs

@@ -14,8 +14,7 @@ import {
   runAiPrompt,
   runAiPromptLocal,
   trimSeriesDeep
-} from "./chunk-733VVTWU.mjs";
-import "./chunk-MEZIXBZ3.mjs";
+} from "./chunk-C3KRBNUR.mjs";
 import "./chunk-LZDXRXIU.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {

package/dist/backtest.mjs

@@ -1,17 +1,15 @@
-import {
-  buildMlPayload,
-  enrichSignalWithMarketContextStages
-} from "./chunk-SVAUSZUE.mjs";
-import {
-  buildAiPayload
-} from "./chunk-733VVTWU.mjs";
 import {
   BUILTIN_CONNECTOR_NAMES,
   getConnectorCreatorByName
 } from "./chunk-QVKUROR2.mjs";
 import {
+  buildMlPayload,
+  enrichSignalWithMarketContextStages
+} from "./chunk-B6X2HEGL.mjs";
+import {
+  buildAiPayload,
   getStrategyCreator
-} from "./chunk-MEZIXBZ3.mjs";
+} from "./chunk-C3KRBNUR.mjs";
 import {
   getTradejsProjectCwd
 } from "./chunk-LZDXRXIU.mjs";

package/dist/{chunk-SVAUSZUE.mjs → chunk-B6X2HEGL.mjs}

@@ -1,13 +1,11 @@
 import {
   askAI,
+  getStrategyManifest,
   getStrategyProfileMlAdapter,
   resolveStrategyPolicyProfile,
-  runAiPromptLocal
-} from "./chunk-733VVTWU.mjs";
-import {
-  getStrategyManifest,
+  runAiPromptLocal,
   setStrategyRuntimeFactory
-} from "./chunk-MEZIXBZ3.mjs";
+} from "./chunk-C3KRBNUR.mjs";
 import {
   getTradejsProjectCwd,
   loadTradejsConfig

package/dist/{chunk-733VVTWU.mjs → chunk-C3KRBNUR.mjs}

@@ -1,6 +1,9 @@
 import {
-  getStrategyManifest
-} from "./chunk-MEZIXBZ3.mjs";
+  getTradejsProjectCwd,
+  importTradejsModule,
+  loadTradejsConfig,
+  resolvePluginModuleSpecifier
+} from "./chunk-LZDXRXIU.mjs";
 
 // src/ai.ts
 import {
@@ -581,6 +584,278 @@ var buildAiMarketContext = (signal) => ({
   }
 });
 
+// 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
+    })
+  }
+);
+
 // src/strategy/policyProfiles.ts
 var profileMatches = (profile, universe, assetClass) => {
   const { appliesTo } = profile;
@@ -1171,6 +1446,20 @@ export {
   MAX_AI_SERIES_POINTS,
   trimSeriesDeep,
   buildCompactAiIndicatorsSnapshot,
+  setStrategyRuntimeFactory,
+  ensureStrategyPluginsLoaded,
+  ensureIndicatorPluginsLoaded,
+  getStrategyCreator,
+  getStrategyDefaults,
+  getStrategyPluginSource,
+  getAvailableStrategyNames,
+  getRegisteredStrategies,
+  getRegisteredManifests,
+  getStrategyManifest,
+  isKnownStrategy,
+  registerStrategyEntries,
+  resetStrategyRegistryCache,
+  strategies,
   resolveStrategyPolicyProfile,
   getStrategyProfileMlAdapter,
   DEFAULT_AI_MODEL,

package/dist/{chunk-F7ODY5W4.mjs → chunk-LPHWIFLB.mjs}

@@ -1,7 +1,7 @@
 import {
   getStrategyCreator,
   getStrategyPluginSource
-} from "./chunk-MEZIXBZ3.mjs";
+} from "./chunk-C3KRBNUR.mjs";
 import {
   loadTradejsConfig
 } from "./chunk-LZDXRXIU.mjs";

package/dist/cli.mjs

@@ -4,11 +4,9 @@ import {
   SCREENSHOT_CONCURRENCY_LIMIT
 } from "./chunk-KMJQQ53K.mjs";
 import {
-  askAI
-} from "./chunk-733VVTWU.mjs";
-import {
+  askAI,
   ensureStrategyPluginsLoaded
-} from "./chunk-MEZIXBZ3.mjs";
+} from "./chunk-C3KRBNUR.mjs";
 import {
   getTradejsProjectCwd,
   loadTradejsConfig

package/dist/registry.mjs

@@ -1,5 +1,4 @@
-import "./chunk-SVAUSZUE.mjs";
-import "./chunk-733VVTWU.mjs";
+import "./chunk-B6X2HEGL.mjs";
 import {
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
@@ -13,7 +12,7 @@ import {
   registerStrategyEntries,
   resetStrategyRegistryCache,
   strategies
-} from "./chunk-MEZIXBZ3.mjs";
+} from "./chunk-C3KRBNUR.mjs";
 import "./chunk-LZDXRXIU.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {