@tradejs/cli 3.1.0 → 3.1.2

package/dist/lib/coreResearch.js

@@ -46,7 +46,7 @@ module.exports = __toCommonJS(coreResearch_exports);
 
 // src/lib/coreResearch/orchestrator.ts
 var import_promises4 = __toESM(require("fs/promises"));
-var import_node_path5 = __toESM(require("path"));
+var import_node_path6 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 var import_node_crypto5 = require("crypto");
 var import_coreResearch = require("@tradejs/infra/coreResearch");
@@ -2116,6 +2116,10 @@ var summarizeCoreResearchTrace = async (filePaths = []) => {
   };
 };
 
+// src/lib/researchRoots.ts
+var import_node_path5 = __toESM(require("path"));
+var SOURCE_REPOSITORY_ROOT_ENV = "TRADEJS_SOURCE_REPOSITORY_ROOT";
+
 // src/lib/coreResearch/orchestrator.ts
 var summarizeSupplementalFiles = async (params) => {
   const loaded = await readCoreResearchVariant({
@@ -2308,7 +2312,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
   const primarySourceHashes = Object.fromEntries(
     analyses.flatMap(
       (analysis) => analysis.files.map((file) => [
-        import_node_path5.default.relative(paths.researchDir, file.path),
+        import_node_path6.default.relative(paths.researchDir, file.path),
         file.sha256
       ])
     )
@@ -2327,8 +2331,8 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
   const supplementalSourceHashes = Object.fromEntries(
     await Promise.all(
       supplementalSourcePaths.map(async (filePath) => [
-        import_node_path5.default.relative(paths.researchDir, import_node_path5.default.resolve(filePath)),
-        await sha256File(import_node_path5.default.resolve(filePath))
+        import_node_path6.default.relative(paths.researchDir, import_node_path6.default.resolve(filePath)),
+        await sha256File(import_node_path6.default.resolve(filePath))
       ])
     )
   );
@@ -2405,7 +2409,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
     "trades.jsonl": await sha256File(paths.tradesPath),
     "report.html": await sha256File(paths.reportPath)
   };
-  const resolvedRunsPath = import_node_path5.default.join(paths.researchDir, "resolved-runs.json");
+  const resolvedRunsPath = import_node_path6.default.join(paths.researchDir, "resolved-runs.json");
   try {
     artifactHashes["resolved-runs.json"] = await sha256File(resolvedRunsPath);
   } catch (error) {
@@ -2415,7 +2419,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
     for (const name of await import_promises4.default.readdir(paths.runLogDir)) {
       if (!name.endsWith(".log")) continue;
       artifactHashes[`runs/${name}`] = await sha256File(
-        import_node_path5.default.join(paths.runLogDir, name)
+        import_node_path6.default.join(paths.runLogDir, name)
       );
     }
   } catch (error) {
@@ -2472,12 +2476,14 @@ var analyzeCoreResearch = async (spec, options = {}) => {
   }
 };
 var createCoreResearchSpecTemplate = (params) => {
-  const rootDir = "data/research/core";
-  const projectRoot = process.cwd();
+  const rootDir = import_node_path6.default.relative(
+    import_node_path6.default.resolve(params.projectRoot),
+    import_node_path6.default.join(import_node_path6.default.resolve(params.projectRoot), "data", "research", "core")
+  ).replace(/\\/g, "/");
   const lineage = (() => {
     try {
       const gitSha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], {
-        cwd: projectRoot,
+        cwd: params.sourceRepositoryRoot,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
@@ -2485,13 +2491,23 @@ var createCoreResearchSpecTemplate = (params) => {
         "git",
         ["diff", "--binary", "--no-ext-diff", "HEAD"],
         {
-          cwd: projectRoot,
+          cwd: params.sourceRepositoryRoot,
           encoding: "utf8",
           stdio: ["ignore", "pipe", "ignore"]
         }
       );
+      const sourceRepository = (0, import_node_child_process.execFileSync)(
+        "git",
+        ["remote", "get-url", "origin"],
+        {
+          cwd: params.sourceRepositoryRoot,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        }
+      ).trim();
       return {
         gitSha,
+        ...sourceRepository ? { sourceRepository } : {},
         ...dirtyDiff ? {
           dirtyDiffSha256: (0, import_node_crypto5.createHash)("sha256").update(dirtyDiff).digest("hex")
         } : {}
@@ -2592,11 +2608,11 @@ var createCoreResearchSpecTemplate = (params) => {
 };
 var runCommand = async (params) => {
   if (!params.command.length) throw new Error("Cannot run an empty command");
-  await import_promises4.default.mkdir(import_node_path5.default.dirname(params.logPath), { recursive: true });
+  await import_promises4.default.mkdir(import_node_path6.default.dirname(params.logPath), { recursive: true });
   const chunks = [];
   const child = (0, import_node_child_process.spawn)(params.command[0], params.command.slice(1), {
     cwd: params.cwd,
-    env: process.env,
+    env: { ...process.env, ...params.env },
     stdio: ["ignore", "pipe", "pipe"]
   });
   const capture = (chunk) => {
@@ -2664,7 +2680,7 @@ var validateCoreResearchRunCommand = (params) => {
 };
 var runCoreResearch = async (params) => {
   const { spec } = params;
-  const cwd = import_node_path5.default.resolve(params.cwd ?? process.cwd());
+  const cwd = import_node_path6.default.resolve(params.cwd ?? process.cwd());
   const prepared = await prepareCoreResearch(spec);
   const resolvedVariants = [];
   for (const variant of spec.variants) {
@@ -2682,7 +2698,7 @@ var runCoreResearch = async (params) => {
       artifactHashes: { variant: sha256Json(variant) }
     });
     let runId = "";
-    const backtestLogPath = import_node_path5.default.join(
+    const backtestLogPath = import_node_path6.default.join(
       prepared.paths.runLogDir,
       `${variant.id}-backtest.log`
     );
@@ -2691,6 +2707,14 @@ var runCoreResearch = async (params) => {
         command: variant.command,
         cwd,
         logPath: backtestLogPath,
+        env: {
+          PROJECT_CWD: cwd,
+          ...params.sourceRepositoryRoot ? {
+            [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path6.default.resolve(
+              params.sourceRepositoryRoot
+            )
+          } : {}
+        },
         onLine: (line) => {
           const match = line.match(
             /backtest run id:\s*([0-9]{12}-[a-f0-9]{8})/i
@@ -2701,12 +2725,12 @@ var runCoreResearch = async (params) => {
       if (!runId) {
         throw new Error(`Backtest for ${variant.id} did not report a run id`);
       }
-      const exportLogPath = import_node_path5.default.join(
+      const exportLogPath = import_node_path6.default.join(
         prepared.paths.runLogDir,
         `${variant.id}-export.log`
       );
       const exportParts = [];
-      const cliPath = import_node_path5.default.resolve(process.argv[1]);
+      const cliPath = import_node_path6.default.resolve(process.argv[1]);
       await runCommand({
         command: [
           process.execPath,
@@ -2723,9 +2747,17 @@ var runCoreResearch = async (params) => {
         ],
         cwd,
         logPath: exportLogPath,
+        env: {
+          PROJECT_CWD: cwd,
+          ...params.sourceRepositoryRoot ? {
+            [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path6.default.resolve(
+              params.sourceRepositoryRoot
+            )
+          } : {}
+        },
         onLine: (line) => {
           const match = line.match(/^part\d+:\s+(.+)$/);
-          if (match) exportParts.push(import_node_path5.default.resolve(cwd, match[1].trim()));
+          if (match) exportParts.push(import_node_path6.default.resolve(cwd, match[1].trim()));
         }
       });
       if (!exportParts.length) {
@@ -2736,7 +2768,7 @@ var runCoreResearch = async (params) => {
       const traceFiles = await (0, import_coreResearch.listCoreResearchTraceFiles)({
         strategyName: spec.strategy,
         runId,
-        outDir: import_node_path5.default.resolve(cwd, "data/research/core/trace")
+        outDir: import_node_path6.default.resolve(cwd, "data/research/core/trace")
       });
       resolvedVariants.push({
         ...variant,
@@ -2756,7 +2788,7 @@ var runCoreResearch = async (params) => {
           ...Object.fromEntries(
             await Promise.all(
               exportParts.map(async (filePath) => [
-                import_node_path5.default.basename(filePath),
+                import_node_path6.default.basename(filePath),
                 await sha256File(filePath)
               ])
             )
@@ -2775,7 +2807,7 @@ var runCoreResearch = async (params) => {
     }
   }
   await writeJsonAtomic(
-    import_node_path5.default.join(prepared.paths.researchDir, "resolved-runs.json"),
+    import_node_path6.default.join(prepared.paths.researchDir, "resolved-runs.json"),
     {
       schema: "tradejs-core-research-resolved-runs/v1",
       researchId: spec.researchId,

package/dist/lib/researchRoots.js

@@ -0,0 +1,59 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/researchRoots.ts
+var researchRoots_exports = {};
+__export(researchRoots_exports, {
+  SOURCE_REPOSITORY_ROOT_ENV: () => SOURCE_REPOSITORY_ROOT_ENV,
+  resolveResearchRoots: () => resolveResearchRoots
+});
+module.exports = __toCommonJS(researchRoots_exports);
+var import_node_path = __toESM(require("path"));
+var SOURCE_REPOSITORY_ROOT_ENV = "TRADEJS_SOURCE_REPOSITORY_ROOT";
+var firstNonEmpty = (...values) => values.map((value) => String(value || "").trim()).find(Boolean);
+var resolveResearchRoots = (options = {}) => {
+  const cwd = import_node_path.default.resolve(options.cwd || process.cwd());
+  const env = options.env || process.env;
+  const projectRoot = import_node_path.default.resolve(
+    firstNonEmpty(options.projectRoot, env.PROJECT_CWD, cwd) || cwd
+  );
+  const sourceRepositoryRoot = import_node_path.default.resolve(
+    firstNonEmpty(
+      options.sourceRepositoryRoot,
+      env[SOURCE_REPOSITORY_ROOT_ENV],
+      cwd
+    ) || cwd
+  );
+  return { projectRoot, sourceRepositoryRoot };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SOURCE_REPOSITORY_ROOT_ENV,
+  resolveResearchRoots
+});

package/dist/lib/runtimeLineage.js

@@ -272,14 +272,29 @@ var resolveRuntimeGateFingerprint = async ({
   gateFingerprintCache.set(cacheKey, result);
   return result;
 };
-var buildRuntimeLineage = async ({
+async function buildRuntimeLineage({
   projectRoot,
   strategyName,
   compositionId,
+  releaseVersion,
+  strategyPackageVersion,
+  runtimePackageVersion,
   config,
   runContext,
   env = process.env
-}) => {
+}) {
+  if (releaseVersion != null) {
+    if (!Number.isSafeInteger(releaseVersion) || releaseVersion <= 0) {
+      throw new Error(`Invalid runtime releaseVersion: ${releaseVersion}`);
+    }
+    return {
+      schemaVersion: 2,
+      releaseVersion,
+      strategyPackageVersion,
+      runtimePackageVersion,
+      maxLossValue: resolveRuntimeMaxLossValue(config)
+    };
+  }
   const git = resolveGitLineage(projectRoot);
   const hyperliquidPerpUniverseFingerprint = typeof import_strategies.getHyperliquidPerpUniverseSnapshot === "function" ? (0, import_strategies.getHyperliquidPerpUniverseSnapshot)().fingerprint : await resolveSnapshotFingerprint(
     projectRoot,
@@ -314,8 +329,8 @@ var buildRuntimeLineage = async ({
     contextFingerprint: fingerprintRuntimeValue(context),
     maxLossValue: resolveRuntimeMaxLossValue(config)
   };
-};
-var runtimeLineageKey = (lineage) => [
+}
+var runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineage.releaseVersion].join(":") : [
   lineage.schemaVersion,
   lineage.compositionId ?? "unbound-composition",
   lineage.gitSha ?? "unknown",

package/dist/lib/runtimeModeConfig.js

@@ -41,7 +41,7 @@ var buildRuntimeModeStrategyConfig = ({
   ...strategyConfig,
   ENV: env,
   MAKE_ORDERS: makeOrders,
-  INTERVAL: interval,
+  INTERVAL: strategyConfig.INTERVAL ?? interval,
   ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
   ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
 });

package/dist/lib/runtimeSignalsStorage.js

@@ -63,7 +63,8 @@ var toRuntimeSignalBucketRef = (signal) => ({
   symbol: signal.symbol,
   strategy: signal.strategy,
   timestamp: signal.timestamp,
-  ...signal.runtimeConfigId && signal.runtimeConfigId !== "config" ? { runtimeConfigId: signal.runtimeConfigId } : {}
+  ...signal.runtimeConfigId && signal.runtimeConfigId !== "config" ? { runtimeConfigId: signal.runtimeConfigId } : {},
+  ...signal.runtimeReleaseVersion ? { runtimeReleaseVersion: signal.runtimeReleaseVersion } : {}
 });
 var shouldStoreRuntimeSignalDiagnostics = (signal) => signal.orderStatus === "completed" || signal.orderStatus === "failed";
 var toStoredRuntimeSignal = (signal) => {

package/dist/scripts/agentRun.js

@@ -37,7 +37,7 @@ var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 var import_promises = __toESM(require("fs/promises"));
 var import_node_os = __toESM(require("os"));
-var import_node_path = __toESM(require("path"));
+var import_node_path2 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 var import_constants = require("@tradejs/core/constants");
 var import_aiEndpoints = require("@tradejs/core/aiEndpoints");
@@ -240,6 +240,26 @@ ${diffText}`)) {
   return changedFiles;
 };
 
+// src/lib/researchRoots.ts
+var import_node_path = __toESM(require("path"));
+var SOURCE_REPOSITORY_ROOT_ENV = "TRADEJS_SOURCE_REPOSITORY_ROOT";
+var firstNonEmpty = (...values) => values.map((value) => String(value || "").trim()).find(Boolean);
+var resolveResearchRoots = (options = {}) => {
+  const cwd = import_node_path.default.resolve(options.cwd || process.cwd());
+  const env = options.env || process.env;
+  const projectRoot2 = import_node_path.default.resolve(
+    firstNonEmpty(options.projectRoot, env.PROJECT_CWD, cwd) || cwd
+  );
+  const sourceRepositoryRoot = import_node_path.default.resolve(
+    firstNonEmpty(
+      options.sourceRepositoryRoot,
+      env[SOURCE_REPOSITORY_ROOT_ENV],
+      cwd
+    ) || cwd
+  );
+  return { projectRoot: projectRoot2, sourceRepositoryRoot };
+};
+
 // src/scripts/agentRun.ts
 import_args.default.example(
   "yarn cli:node8g agent-run --runId 1710000000000-trendline --strategy TrendLine",
@@ -250,7 +270,7 @@ import_args.default.option(["r", "runId"], "Research run id");
 import_args.default.option(["s", "strategy"], "Strategy name");
 import_args.default.option("json", "Print structured JSON summary", false);
 var flags = import_args.default.parse(process.argv);
-var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var { projectRoot } = resolveResearchRoots();
 var AGENT_SYSTEM_PROMPT = `You are a senior TypeScript trading research coding agent working inside a standalone TradeJS strategy repository.
 
 Output ONLY one of:
@@ -328,7 +348,7 @@ var listFilesRecursive = async (targetPath) => {
     const entries = await import_promises.default.readdir(targetPath, { withFileTypes: true });
     const nested = await Promise.all(
       entries.map(async (entry) => {
-        const absolutePath = import_node_path.default.join(targetPath, entry.name);
+        const absolutePath = import_node_path2.default.join(targetPath, entry.name);
         if (entry.isDirectory()) {
           return listFilesRecursive(absolutePath);
         }
@@ -341,7 +361,7 @@ var listFilesRecursive = async (targetPath) => {
   }
 };
 var collectStrategyContextFiles = async (worktreePath, strategy) => {
-  const strategyRoot = import_node_path.default.join(worktreePath, "src", strategy);
+  const strategyRoot = import_node_path2.default.join(worktreePath, "src", strategy);
   const strategyFiles = await listFilesRecursive(strategyRoot);
   const files = strategyFiles.filter(
     (filePath) => /\.(ts|tsx|md)$/.test(filePath)
@@ -349,7 +369,7 @@ var collectStrategyContextFiles = async (worktreePath, strategy) => {
   return [...new Set(files)].sort((left, right) => left.localeCompare(right));
 };
 var renderFileContext = async (worktreePath, filePath) => {
-  const relativePath = import_node_path.default.relative(worktreePath, filePath).replace(/\\/g, "/");
+  const relativePath = import_node_path2.default.relative(worktreePath, filePath).replace(/\\/g, "/");
   const content = await import_promises.default.readFile(filePath, "utf8");
   return [
     `=== FILE: ${relativePath} ===`,
@@ -461,8 +481,8 @@ var requestAgentDiff = async (userName, messages) => {
   return normalized;
 };
 var applyDiff = async (worktreePath, diffText) => {
-  const tempDir = await import_promises.default.mkdtemp(import_node_path.default.join(import_node_os.default.tmpdir(), "tradejs-agent-"));
-  const patchPath = import_node_path.default.join(tempDir, "agent.patch");
+  const tempDir = await import_promises.default.mkdtemp(import_node_path2.default.join(import_node_os.default.tmpdir(), "tradejs-agent-"));
+  const patchPath = import_node_path2.default.join(tempDir, "agent.patch");
   try {
     await import_promises.default.writeFile(patchPath, diffText, "utf8");
     await runCommandOrThrow(
@@ -500,7 +520,8 @@ var runValidationSuite = async (worktreePath, agentRun) => {
     const result = await runCommand(command[0], command.slice(1), {
       cwd: worktreePath,
       env: {
-        PROJECT_CWD: worktreePath,
+        PROJECT_CWD: projectRoot,
+        [SOURCE_REPOSITORY_ROOT_ENV]: worktreePath,
         DOTENV_CONFIG_PATH: process.env.DOTENV_CONFIG_PATH
       }
     });
@@ -682,10 +703,15 @@ var createStrategyCheckout = async (strategy, branchName) => {
   const organization = process.env.AGENT_GITHUB_ORGANIZATION?.trim() || "TradeJS-Dev";
   const repository = getResearchAgentRepository(strategy, organization);
   const baseBranch = process.env.AGENT_GITHUB_BASE_BRANCH?.trim() || "main";
-  const checkoutRoot = await import_promises.default.mkdtemp(
-    import_node_path.default.join(import_node_os.default.tmpdir(), "tradejs-strategy-agent-")
+  const checkoutBase = import_node_path2.default.join(
+    projectRoot,
+    "data",
+    "cache",
+    "research-agent-checkouts"
   );
-  const checkoutPath = import_node_path.default.join(checkoutRoot, "repository");
+  await import_promises.default.mkdir(checkoutBase, { recursive: true });
+  const checkoutRoot = await import_promises.default.mkdtemp(import_node_path2.default.join(checkoutBase, "strategy-"));
+  const checkoutPath = import_node_path2.default.join(checkoutRoot, "repository");
   await runCommandOrThrow(
     "git",
     [