@tradejs/node 3.1.8-beta.212 → 3.1.8

package/dist/runtimeStrategies.mjs

@@ -4,8 +4,9 @@ import {
   listRuntimeDeployments,
   loadResolvedRuntimeStrategies,
   verifyRuntimeDeclaration
-} from "./chunk-F7ODY5W4.mjs";
-import "./chunk-MEZIXBZ3.mjs";
+} from "./chunk-LPHWIFLB.mjs";
+import "./chunk-B6X2HEGL.mjs";
+import "./chunk-C3KRBNUR.mjs";
 import "./chunk-LZDXRXIU.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {

package/dist/strategies.mjs

@@ -22,7 +22,7 @@ import {
   resolveHyperliquidPerpFromSignalSymbol,
   resolveStrategyConfig,
   validateEntryProtectionAtArrival
-} from "./chunk-SVAUSZUE.mjs";
+} from "./chunk-B6X2HEGL.mjs";
 import {
   DEFAULT_AI_MODEL,
   MAX_AI_SERIES_POINTS,
@@ -32,29 +32,27 @@ import {
   buildAiPrompts,
   buildAiSystemPrompt,
   buildCompactAiIndicatorsSnapshot,
-  getDeterministicAiGateContext,
-  getOpenRouterModelKwargs,
-  invokeAiChat,
-  resetAiRuntimeCache,
-  runAiPrompt,
-  runAiPromptLocal,
-  trimSeriesDeep
-} from "./chunk-733VVTWU.mjs";
-import {
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
   getAvailableStrategyNames,
+  getDeterministicAiGateContext,
+  getOpenRouterModelKwargs,
   getRegisteredManifests,
   getRegisteredStrategies,
   getStrategyCreator,
   getStrategyDefaults,
   getStrategyManifest,
   getStrategyPluginSource,
+  invokeAiChat,
   isKnownStrategy,
   registerStrategyEntries,
+  resetAiRuntimeCache,
   resetStrategyRegistryCache,
-  strategies
-} from "./chunk-MEZIXBZ3.mjs";
+  runAiPrompt,
+  runAiPromptLocal,
+  strategies,
+  trimSeriesDeep
+} from "./chunk-C3KRBNUR.mjs";
 import "./chunk-LZDXRXIU.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/node",
-  "version": "3.1.8-beta.212",
+  "version": "3.1.8",
   "description": "Node-only runtime for the TradeJS TypeScript framework: strategies, backtests, Pine strategy loading, and plugin registries.",
   "keywords": [
     "tradejs",
@@ -85,9 +85,9 @@
   "dependencies": {
     "@langchain/core": "^1.2.3",
     "@langchain/openai": "^1.5.5",
-    "@tradejs/core": "^3.1.8-beta.212",
-    "@tradejs/infra": "^3.1.8-beta.212",
-    "@tradejs/types": "^3.1.8-beta.212",
+    "@tradejs/core": "^3.1.8",
+    "@tradejs/infra": "^3.1.8",
+    "@tradejs/types": "^3.1.8",
     "chalk": "4.1.2",
     "ioredis": "5.11.1",
     "lodash": "^4.18.1",

package/dist/chunk-MEZIXBZ3.mjs

@@ -1,295 +0,0 @@
-import {
-  getTradejsProjectCwd,
-  importTradejsModule,
-  loadTradejsConfig,
-  resolvePluginModuleSpecifier
-} from "./chunk-LZDXRXIU.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
-};