@tradejs/cli 1.0.6 → 1.0.9

package/dist/lib/derivativesContextBackfill.js

@@ -0,0 +1,487 @@
+"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/derivativesContextBackfill.ts
+var derivativesContextBackfill_exports = {};
+__export(derivativesContextBackfill_exports, {
+  backfillDerivativesContextForBacktest: () => backfillDerivativesContextForBacktest,
+  backfillDerivativesContextForSignals: () => backfillDerivativesContextForSignals,
+  isBacktestDerivativesContextEnabled: () => isBacktestDerivativesContextEnabled,
+  isSignalsDerivativesContextEnabled: () => isSignalsDerivativesContextEnabled,
+  resolveDerivativesContextBackfillSymbols: () => resolveDerivativesContextBackfillSymbols,
+  resolveDerivativesContextBackfillWindow: () => resolveDerivativesContextBackfillWindow,
+  resolveDerivativesContextIntervals: () => resolveDerivativesContextIntervals,
+  resolveDerivativesContextLookbackMs: () => resolveDerivativesContextLookbackMs,
+  shouldBackfillDerivativesContextForBacktest: () => shouldBackfillDerivativesContextForBacktest,
+  shouldBackfillDerivativesContextForSignals: () => shouldBackfillDerivativesContextForSignals
+});
+module.exports = __toCommonJS(derivativesContextBackfill_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_progress = __toESM(require("progress"));
+var import_async = require("@tradejs/core/async");
+var import_constants = require("@tradejs/core/constants");
+var import_indicators = require("@tradejs/core/indicators");
+var import_timescale = require("@tradejs/infra/timescale");
+var import_userSettings = require("@tradejs/infra/userSettings");
+var HOUR_MS = 60 * 60 * 1e3;
+var DAY_MS = 24 * HOUR_MS;
+var DEFAULT_LOOKBACK_HOURS = 48;
+var DEFAULT_INTERVALS = ["15m", "1h"];
+var coinalyzeIntervalMap = {
+  "15m": "15min",
+  "1h": "1hour"
+};
+var lastRequestTs = 0;
+var asInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var parseList = (value) => String(value ?? "").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
+var normalizeSymbols = (symbols) => [
+  ...new Set(
+    symbols.map(
+      (symbol) => String(symbol || "").trim().toUpperCase()
+    ).filter(Boolean)
+  )
+];
+var resolveDerivativesContextBackfillSymbols = (_requestedSymbols = []) => [...import_constants.DERIVATIVES_CONTEXT_REFERENCE_SYMBOLS];
+var chunkArray = (items, size) => {
+  const chunks = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+};
+var isBacktestDerivativesContextEnabled = () => {
+  return isDerivativesContextBackfillEnabled("BACKTEST");
+};
+var isSignalsDerivativesContextEnabled = () => isDerivativesContextBackfillEnabled("CRON");
+var isDerivativesContextBackfillEnabled = (env) => {
+  const normalized = String(process.env.DERIVATIVES_CONTEXT_ENABLED ?? "").trim().toLowerCase();
+  if (!normalized) return false;
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (normalized === "backtest") {
+    return env === "BACKTEST";
+  }
+  if (normalized === "live") {
+    return env !== "BACKTEST";
+  }
+  return false;
+};
+var shouldBackfillDerivativesContextForBacktest = (params) => !params.cacheOnly && (params.aiEnabled || params.mlEnabled) && isBacktestDerivativesContextEnabled();
+var shouldBackfillDerivativesContextForSignals = (params) => !params.cacheOnly && isSignalsDerivativesContextEnabled();
+var resolveDerivativesContextIntervals = () => {
+  const intervals = (0, import_indicators.normalizeDerivativesIntervals)(
+    process.env.DERIVATIVES_CONTEXT_INTERVALS
+  );
+  return intervals.length ? intervals : DEFAULT_INTERVALS;
+};
+var resolveDerivativesContextLookbackMs = () => {
+  const hours = Number(process.env.DERIVATIVES_CONTEXT_LOOKBACK_HOURS);
+  const normalizedHours = Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_LOOKBACK_HOURS;
+  return normalizedHours * HOUR_MS;
+};
+var resolveDerivativesContextBackfillWindow = (params) => {
+  const { startMs, endMs, preloadStartMs, nowMs = Date.now() } = params;
+  const safeEndMs = Math.min(endMs, nowMs);
+  const safeStartMs = Math.max(0, Math.min(startMs, safeEndMs));
+  const lookbackFromMs = safeStartMs - resolveDerivativesContextLookbackMs();
+  const requestedFromMs = preloadStartMs != null ? Math.max(Number(preloadStartMs), lookbackFromMs) : lookbackFromMs;
+  const fromMs = Math.max(
+    0,
+    Math.min(
+      Number.isFinite(requestedFromMs) ? requestedFromMs : safeStartMs,
+      safeStartMs
+    )
+  );
+  return {
+    fromMs: Math.trunc(fromMs),
+    toMs: Math.trunc(safeEndMs),
+    testStartMs: Math.trunc(safeStartMs)
+  };
+};
+var getCoinalyzeApiKey = async (userName) => {
+  const settings = await (0, import_userSettings.getUserSettings)(userName);
+  return settings.COINALYZE_API_KEY.trim() || String(process.env.COINALYZE_API_KEY ?? "").trim();
+};
+var getCoinalyzeBaseUrl = () => process.env.COINALYZE_BASE_URL?.trim() || "https://api.coinalyze.net/v1";
+var getRequestDelayMs = () => Math.max(
+  100,
+  asInt(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_REQUEST_DELAY_MS ?? process.env.COINALYZE_MIN_REQUEST_DELAY_MS,
+    200
+  )
+);
+var getRequestTimeoutMs = () => Math.max(5e3, asInt(process.env.COINALYZE_REQUEST_TIMEOUT_MS, 45e3));
+var fetchJsonWithRateLimit = async (url, apiKey) => {
+  const requestDelayMs = getRequestDelayMs();
+  const requestTimeoutMs = getRequestTimeoutMs();
+  const maxRetries = asInt(process.env.COINALYZE_MAX_RETRIES, 4);
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    const waitMs = Math.max(0, lastRequestTs + requestDelayMs - Date.now());
+    if (waitMs > 0) {
+      await (0, import_async.delay)(waitMs);
+    }
+    lastRequestTs = Date.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), requestTimeoutMs);
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: {
+          api_key: apiKey,
+          "x-api-key": apiKey,
+          Authorization: `Bearer ${apiKey}`
+        },
+        signal: controller.signal
+      });
+    } catch (error) {
+      clearTimeout(timer);
+      const abortError = error instanceof Error && (error.name === "AbortError" || String(error.message).toLowerCase().includes("aborted"));
+      if (attempt < maxRetries && abortError) {
+        await (0, import_async.delay)(Math.min(12e3, 800 * 2 ** attempt));
+        continue;
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (response.ok) {
+      return response.json();
+    }
+    const text = await response.text();
+    const retryAfterRaw = Number(response.headers.get("retry-after") ?? "");
+    const retryAfterMs = Number.isFinite(retryAfterRaw) && retryAfterRaw > 0 ? retryAfterRaw * 1e3 : null;
+    const transient = response.status === 429 || response.status >= 500;
+    if (attempt < maxRetries && transient) {
+      await (0, import_async.delay)(retryAfterMs ?? Math.min(12e3, 800 * 2 ** attempt));
+      continue;
+    }
+    throw new Error(`Coinalyze ${response.status}: ${text}`);
+  }
+  throw new Error("Coinalyze request failed after retries");
+};
+var fetchCoinalyzeMarkets = async (apiKey) => {
+  const raw = await fetchJsonWithRateLimit(
+    `${getCoinalyzeBaseUrl()}/future-markets`,
+    apiKey
+  );
+  return Array.isArray(raw) ? raw : [];
+};
+var selectBestMarket = (candidates, exchangePriority) => {
+  const scored = candidates.map((item) => {
+    let score = 0;
+    if (item.is_perpetual) score += 50;
+    if (String(item.quote_asset || "").toUpperCase() === "USDT") score += 25;
+    if (item.symbol.includes("_PERP")) score += 10;
+    const exchange = String(item.exchange || "").toUpperCase();
+    const idx = exchangePriority.indexOf(exchange);
+    if (idx >= 0) {
+      score += (exchangePriority.length - idx) * 10;
+    }
+    return { item, score };
+  });
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.item.symbol.localeCompare(b.item.symbol);
+  });
+  return scored[0]?.item ?? null;
+};
+var buildMatches = (tickers, markets, exchangePriority) => {
+  const marketByTicker = /* @__PURE__ */ new Map();
+  for (const market of markets) {
+    const key = String(market.symbol_on_exchange || "").trim().toUpperCase();
+    if (!key) continue;
+    const list = marketByTicker.get(key) ?? [];
+    list.push(market);
+    marketByTicker.set(key, list);
+  }
+  const matches = [];
+  const unmatched = [];
+  for (const ticker of tickers) {
+    const candidates = marketByTicker.get(ticker) ?? [];
+    const selected = selectBestMarket(candidates, exchangePriority);
+    if (!selected) {
+      unmatched.push(ticker);
+      continue;
+    }
+    matches.push({
+      symbol: ticker,
+      marketSymbol: selected.symbol,
+      exchange: selected.exchange
+    });
+  }
+  return { matches, unmatched };
+};
+var normalizeMetricPoint = (metric, point) => {
+  if (metric === "oi") {
+    return {
+      ...point,
+      open_interest: point.open_interest ?? point.openInterest ?? point.oi ?? point.c
+    };
+  }
+  if (metric === "funding") {
+    return {
+      ...point,
+      funding_rate: point.funding_rate ?? point.fundingRate ?? point.rate ?? point.c
+    };
+  }
+  return {
+    ...point,
+    liq_long: point.liq_long ?? point.long_liq ?? point.long ?? point.l,
+    liq_short: point.liq_short ?? point.short_liq ?? point.short ?? point.s
+  };
+};
+var toSeriesMap = (raw, metric) => {
+  const out = /* @__PURE__ */ new Map();
+  if (!Array.isArray(raw)) return out;
+  for (const item of raw) {
+    const symbol = String(item.symbol || "").trim().toUpperCase();
+    const history = Array.isArray(item.history) ? item.history : [];
+    if (!symbol) continue;
+    out.set(
+      symbol,
+      history.filter((point) => point && typeof point === "object").map((point) => normalizeMetricPoint(metric, point))
+    );
+  }
+  return out;
+};
+var fetchMetricBatch = async (params) => {
+  const { endpoint, metric, marketSymbols, apiKey, interval, fromMs, toMs } = params;
+  const url = new URL(`${getCoinalyzeBaseUrl()}${endpoint}`);
+  url.searchParams.set("symbols", marketSymbols.join(","));
+  url.searchParams.set("interval", coinalyzeIntervalMap[interval] || interval);
+  url.searchParams.set("from", String(Math.floor(fromMs / 1e3)));
+  url.searchParams.set("to", String(Math.floor(toMs / 1e3)));
+  const raw = await fetchJsonWithRateLimit(url.toString(), apiKey);
+  return toSeriesMap(raw, metric);
+};
+var skippedBackfillResult = () => ({
+  skipped: true,
+  rows: 0,
+  matchedSymbols: 0,
+  unmatchedSymbols: 0,
+  failedWindows: 0,
+  skippedWindows: 0
+});
+var backfillDerivativesContext = async (params, enabled) => {
+  const { userName, startMs, endMs } = params;
+  const requestedSymbols = normalizeSymbols(params.symbols);
+  const symbols = resolveDerivativesContextBackfillSymbols(requestedSymbols);
+  if (!enabled || !requestedSymbols.length || !symbols.length) {
+    return skippedBackfillResult();
+  }
+  const intervals = resolveDerivativesContextIntervals();
+  if (!intervals.length) {
+    return skippedBackfillResult();
+  }
+  const apiKey = await getCoinalyzeApiKey(userName);
+  if (!apiKey) {
+    throw new Error(
+      `Missing COINALYZE_API_KEY for derivatives context backfill (user=${userName})`
+    );
+  }
+  const {
+    fromMs,
+    toMs: safeEndMs,
+    testStartMs: safeStartMs
+  } = resolveDerivativesContextBackfillWindow({
+    startMs,
+    endMs,
+    preloadStartMs: params.preloadStartMs
+  });
+  if (safeEndMs <= fromMs) {
+    return skippedBackfillResult();
+  }
+  const exchangePriority = parseList(
+    process.env.COINALYZE_EXCHANGE_PRIORITY || process.env.DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY || "A,6,0"
+  );
+  const markets = await fetchCoinalyzeMarkets(apiKey);
+  if (!markets.length) {
+    throw new Error("No markets returned by Coinalyze /future-markets");
+  }
+  const { matches, unmatched } = buildMatches(
+    symbols,
+    markets,
+    exchangePriority
+  );
+  if (!matches.length) {
+    throw new Error(
+      "No matched derivatives reference symbols between BTC/ETH and Coinalyze"
+    );
+  }
+  await (0, import_timescale.waitForDbReady)();
+  const batchDays = asInt(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_BATCH_DAYS,
+    30
+  );
+  const symbolBatchSize = asInt(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_SYMBOL_BATCH_SIZE,
+    8
+  );
+  const symbolBatches = chunkArray(matches, symbolBatchSize);
+  const windowsPerPair = Math.ceil((safeEndMs - fromMs) / (batchDays * DAY_MS));
+  const totalWindows = symbolBatches.length * intervals.length * windowsPerPair;
+  const bar = new import_progress.default(
+    ":current/:total [:bar][:percent] :eta(s) :batch rows=:rows fail=:fail skip=:skip",
+    {
+      total: Math.max(1, totalWindows),
+      width: 24
+    }
+  );
+  const oiPath = process.env.COINALYZE_OI_PATH?.trim() || "/open-interest-history";
+  const fundingPath = process.env.COINALYZE_FUNDING_PATH?.trim() || "/funding-rate-history";
+  const liqPath = process.env.COINALYZE_LIQ_PATH?.trim() || "/liquidation-history";
+  let totalRows = 0;
+  let failedWindows = 0;
+  let skippedWindows = 0;
+  console.log(
+    import_chalk.default.cyan(
+      `derivatives context backfill: referenceSymbols=${matches.length}, requestedSymbols=${requestedSymbols.length}, unmatched=${unmatched.length}, intervals=${intervals.join(",")}, window=${new Date(fromMs).toISOString()}..${new Date(safeEndMs).toISOString()}, testStart=${new Date(safeStartMs).toISOString()}`
+    )
+  );
+  for (const interval of intervals) {
+    const edgesBySymbol = await (0, import_timescale.getDerivativesDataEdgesForSymbols)(
+      matches.map((item) => item.symbol),
+      interval
+    );
+    for (let batchIdx = 0; batchIdx < symbolBatches.length; batchIdx += 1) {
+      const batch = symbolBatches[batchIdx];
+      let cursor = fromMs;
+      while (cursor < safeEndMs) {
+        const toMs = Math.min(safeEndMs, cursor + batchDays * DAY_MS);
+        const missingBatch = batch.filter((item) => {
+          const edges = edgesBySymbol.get(item.symbol.toUpperCase());
+          return edges?.min == null || edges?.max == null || edges.min > cursor || edges.max < toMs;
+        });
+        try {
+          if (!missingBatch.length) {
+            skippedWindows += 1;
+          } else {
+            const marketSymbols = missingBatch.map((item) => item.marketSymbol);
+            const oiMap = await fetchMetricBatch({
+              endpoint: oiPath,
+              metric: "oi",
+              marketSymbols,
+              apiKey,
+              interval,
+              fromMs: cursor,
+              toMs
+            });
+            const fundingMap = await fetchMetricBatch({
+              endpoint: fundingPath,
+              metric: "funding",
+              marketSymbols,
+              apiKey,
+              interval,
+              fromMs: cursor,
+              toMs
+            });
+            const liqMap = await fetchMetricBatch({
+              endpoint: liqPath,
+              metric: "liq",
+              marketSymbols,
+              apiKey,
+              interval,
+              fromMs: cursor,
+              toMs
+            });
+            const rows = missingBatch.flatMap((item) => {
+              const marketSymbol = item.marketSymbol.toUpperCase();
+              const points = (0, import_indicators.mergeCoinalyzeMetrics)({
+                symbol: item.symbol,
+                oiRaw: oiMap.get(marketSymbol) ?? [],
+                fundingRaw: fundingMap.get(marketSymbol) ?? [],
+                liqRaw: liqMap.get(marketSymbol) ?? []
+              });
+              return (0, import_indicators.coinalyzePointsToRows)(points, interval, "coinalyze");
+            });
+            if (rows.length) {
+              await (0, import_timescale.upsertDerivatives)(rows);
+              totalRows += rows.length;
+            }
+          }
+        } catch (error) {
+          failedWindows += 1;
+          console.error(
+            import_chalk.default.red(
+              `derivatives context backfill window failed batch=${batchIdx + 1}/${symbolBatches.length} interval=${interval} ${new Date(cursor).toISOString()}..${new Date(toMs).toISOString()}: ${error}`
+            )
+          );
+        } finally {
+          bar.tick(1, {
+            batch: import_chalk.default.gray(
+              `${batchIdx + 1}/${symbolBatches.length} ${interval}`
+            ),
+            rows: totalRows,
+            fail: failedWindows,
+            skip: skippedWindows
+          });
+        }
+        cursor = toMs + 1;
+      }
+    }
+  }
+  console.log("");
+  console.log(
+    import_chalk.default.green(
+      `derivatives context backfill done: rows=${totalRows}, failed_windows=${failedWindows}, skipped_windows=${skippedWindows}`
+    )
+  );
+  if (failedWindows > 0) {
+    throw new Error(
+      `Derivatives context backfill failed for ${failedWindows} window(s)`
+    );
+  }
+  return {
+    skipped: false,
+    rows: totalRows,
+    matchedSymbols: matches.length,
+    unmatchedSymbols: unmatched.length,
+    failedWindows,
+    skippedWindows
+  };
+};
+var backfillDerivativesContextForBacktest = async (params) => backfillDerivativesContext(params, isBacktestDerivativesContextEnabled());
+var backfillDerivativesContextForSignals = async (params) => backfillDerivativesContext(params, isSignalsDerivativesContextEnabled());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  backfillDerivativesContextForBacktest,
+  backfillDerivativesContextForSignals,
+  isBacktestDerivativesContextEnabled,
+  isSignalsDerivativesContextEnabled,
+  resolveDerivativesContextBackfillSymbols,
+  resolveDerivativesContextBackfillWindow,
+  resolveDerivativesContextIntervals,
+  resolveDerivativesContextLookbackMs,
+  shouldBackfillDerivativesContextForBacktest,
+  shouldBackfillDerivativesContextForSignals
+});

package/dist/lib/researchAgent.js

@@ -0,0 +1,195 @@
+"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/researchAgent.ts
+var researchAgent_exports = {};
+__export(researchAgent_exports, {
+  RESEARCH_AGENT_BRANCH_PREFIX: () => RESEARCH_AGENT_BRANCH_PREFIX,
+  RESEARCH_AGENT_MODEL: () => RESEARCH_AGENT_MODEL,
+  RESEARCH_AGENT_REASONING_EFFORT: () => RESEARCH_AGENT_REASONING_EFFORT,
+  assertDiffAllowed: () => assertDiffAllowed,
+  buildResearchAgentBranchName: () => buildResearchAgentBranchName,
+  buildResearchAgentCommitMessage: () => buildResearchAgentCommitMessage,
+  buildResearchAgentPrBody: () => buildResearchAgentPrBody,
+  buildResearchAgentPrTitle: () => buildResearchAgentPrTitle,
+  getResearchAgentAllowedPathPrefixes: () => getResearchAgentAllowedPathPrefixes,
+  getResearchAgentNotePath: () => getResearchAgentNotePath,
+  normalizeDiffOutput: () => normalizeDiffOutput,
+  parseChangedFilesFromDiff: () => parseChangedFilesFromDiff,
+  parseGithubRepositoryFromRemote: () => parseGithubRepositoryFromRemote,
+  toUpperSnakeCase: () => toUpperSnakeCase
+});
+module.exports = __toCommonJS(researchAgent_exports);
+var import_node_path = __toESM(require("path"));
+var RESEARCH_AGENT_MODEL = "openai/gpt-5.4";
+var RESEARCH_AGENT_REASONING_EFFORT = "medium";
+var RESEARCH_AGENT_BRANCH_PREFIX = "codex/research";
+var toUpperSnakeCase = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+var RESEARCH_NOTE_FILE_OVERRIDES = {
+  TrendLine: "AI_TRENDLINE_REPLAY_NOTES.md",
+  ReverseTrendLine: "AI_REVERSE_TRENDLINE_REPLAY_NOTES.md",
+  AdaptiveMomentumRibbon: "AI_ADAPTIVE_MOMENTUM_RIBBON_REPLAY_NOTES.md",
+  VolumeDivergence: "AI_VOLUME_DIVERGENCE_REPLAY_NOTES.md"
+};
+var buildResearchAgentBranchName = (strategy, runId) => {
+  const normalizedStrategy = strategy.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  const normalizedRunId = runId.trim().replace(/[^a-zA-Z0-9-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  return `${RESEARCH_AGENT_BRANCH_PREFIX}/${normalizedStrategy}-${normalizedRunId}`;
+};
+var buildResearchAgentCommitMessage = (strategy, runId) => `Research agent: ${strategy} follow-up for ${runId}`;
+var buildResearchAgentPrTitle = (strategy, runId) => `Research agent: ${strategy} follow-up for ${runId}`;
+var getResearchAgentNotePath = (strategy) => import_node_path.default.join(
+  "notes",
+  RESEARCH_NOTE_FILE_OVERRIDES[strategy] || `AI_${toUpperSnakeCase(strategy)}_REPLAY_NOTES.md`
+);
+var getResearchAgentAllowedPathPrefixes = (strategy) => [
+  `packages/strategies/src/${strategy}/`,
+  getResearchAgentNotePath(strategy)
+];
+var parseGithubRepositoryFromRemote = (value) => {
+  const trimmed = value.trim();
+  const sshMatch = trimmed.match(/github\.com:([^/]+\/[^/.]+)(?:\.git)?$/i);
+  if (sshMatch?.[1]) {
+    return sshMatch[1];
+  }
+  const httpsMatch = trimmed.match(/github\.com\/([^/]+\/[^/.]+)(?:\.git)?$/i);
+  if (httpsMatch?.[1]) {
+    return httpsMatch[1];
+  }
+  return null;
+};
+var buildResearchAgentPrBody = (params) => {
+  const validationSummary = Object.entries(params.validation || {}).map(([key, value]) => `- \`${key}\`: ${value}`).join("\n");
+  const aiRun = params.aiTrainLocal?.run;
+  const aiOutcome = params.aiTrainLocal?.outcome;
+  const lines = [
+    "## Why",
+    `Automated research follow-up for \`${params.strategy}\` from run \`${params.runId}\`.`,
+    `Research config: \`${params.config}\`, connector \`${params.connector}\`, timeframe \`${params.timeframe}\`, window \`${params.days}d\`, recent rows \`${params.recent}\`.`
+  ];
+  if (params.summary) {
+    lines.push(params.summary);
+  }
+  if (aiRun || aiOutcome) {
+    lines.push("");
+    lines.push("### AI train snapshot");
+    if (aiRun) {
+      lines.push(
+        `- Rows: \`${aiRun.totalRows ?? 0}\`, approved: \`${aiRun.approvedRows ?? 0}\`, minQuality: \`${aiRun.minQuality ?? "n/a"}\``
+      );
+    }
+    if (aiOutcome) {
+      lines.push(
+        `- approvalRate=\`${aiOutcome.approvalRate ?? 0}\`, precisionApproved=\`${aiOutcome.precisionApproved ?? 0}\`, recallWinners=\`${aiOutcome.recallWinners ?? 0}\``
+      );
+      lines.push(
+        `- avgProfitApproved=\`${aiOutcome.avgProfitApproved ?? 0}\`, avgProfitApprovedPerMonth=\`${aiOutcome.avgProfitApprovedPerMonth ?? 0}\`, expectancyDelta=\`${aiOutcome.expectancyDelta ?? 0}\``
+      );
+    }
+  }
+  lines.push("");
+  lines.push("## What changed");
+  for (const file of params.changedFiles) {
+    lines.push(`- \`${file}\``);
+  }
+  lines.push("");
+  lines.push("## Validation");
+  lines.push(validationSummary || "- Validation did not run");
+  lines.push("");
+  lines.push("## Notes");
+  lines.push("- Created automatically by the TradeJS research agent.");
+  lines.push("- Base branch: `stable`.");
+  return lines.join("\n");
+};
+var normalizeDiffOutput = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const fenced = trimmed.match(/```(?:diff)?\s*([\s\S]*?)```/i);
+  const content = fenced?.[1]?.trim() || trimmed;
+  return content.trim();
+};
+var parseChangedFilesFromDiff = (diffText) => {
+  const files = /* @__PURE__ */ new Set();
+  const lines = diffText.split("\n");
+  for (const line of lines) {
+    if (!line.startsWith("+++ ")) {
+      continue;
+    }
+    const filePath = line.slice(4).trim();
+    if (!filePath || filePath === "/dev/null") {
+      continue;
+    }
+    const normalized = filePath.startsWith("b/") ? filePath.slice(2) : filePath;
+    if (normalized) {
+      files.add(normalized);
+    }
+  }
+  return [...files];
+};
+var assertDiffAllowed = (diffText, allowedPrefixes) => {
+  if (!diffText || diffText === "NO_CHANGES") {
+    return [];
+  }
+  if (/\n\+\+\+\s+\/dev\/null\b/.test(`
+${diffText}`)) {
+    throw new Error("Research agent diff must not delete files");
+  }
+  const changedFiles = parseChangedFilesFromDiff(diffText);
+  if (!changedFiles.length) {
+    throw new Error("Research agent diff did not contain any changed files");
+  }
+  for (const filePath of changedFiles) {
+    const allowed = allowedPrefixes.some(
+      (prefix) => prefix.endsWith("/") ? filePath.startsWith(prefix) : filePath === prefix || filePath.startsWith(`${prefix}/`)
+    );
+    if (!allowed) {
+      throw new Error(`Research agent changed disallowed path: ${filePath}`);
+    }
+  }
+  return changedFiles;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RESEARCH_AGENT_BRANCH_PREFIX,
+  RESEARCH_AGENT_MODEL,
+  RESEARCH_AGENT_REASONING_EFFORT,
+  assertDiffAllowed,
+  buildResearchAgentBranchName,
+  buildResearchAgentCommitMessage,
+  buildResearchAgentPrBody,
+  buildResearchAgentPrTitle,
+  getResearchAgentAllowedPathPrefixes,
+  getResearchAgentNotePath,
+  normalizeDiffOutput,
+  parseChangedFilesFromDiff,
+  parseGithubRepositoryFromRemote,
+  toUpperSnakeCase
+});