@tradejs/cli 1.0.6 → 1.0.9

package/dist/scripts/agentRun.js

@@ -0,0 +1,909 @@
+"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/scripts/agentRun.ts
+var agentRun_exports = {};
+__export(agentRun_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(agentRun_exports);
+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_path2 = __toESM(require("path"));
+var import_node_child_process = require("child_process");
+var import_redis = require("@tradejs/infra/redis");
+var import_userSettings = require("@tradejs/infra/userSettings");
+
+// src/lib/telegramReports.ts
+var import_cli = require("@tradejs/node/cli");
+var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
+var buildPartHeader = (index, total) => `\u{1F4E9} <b>Part ${index}/${total}</b>`;
+var splitLongLine = (line, limit) => {
+  const chunks = [];
+  for (let index = 0; index < line.length; index += limit) {
+    chunks.push(line.slice(index, index + limit));
+  }
+  return chunks;
+};
+var splitTelegramReport = (message, limit = TELEGRAM_REPORT_CHUNK_LIMIT) => {
+  const normalizedLimit = Math.max(100, Math.floor(limit));
+  if (message.length <= normalizedLimit) {
+    return [message];
+  }
+  const chunks = [];
+  let current = "";
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    chunks.push(current);
+    current = "";
+  };
+  for (const line of message.split("\n")) {
+    const next = current ? `${current}
+${line}` : line;
+    if (next.length <= normalizedLimit) {
+      current = next;
+      continue;
+    }
+    flush();
+    if (line.length <= normalizedLimit) {
+      current = line;
+      continue;
+    }
+    chunks.push(...splitLongLine(line, normalizedLimit));
+  }
+  flush();
+  return chunks;
+};
+var sendTelegramReport = async (message, options = {}) => {
+  const chunks = splitTelegramReport(message);
+  if (chunks.length === 1) {
+    await (0, import_cli.sendTextToTG)(chunks[0], options);
+    return chunks.length;
+  }
+  for (const [index, chunk] of chunks.entries()) {
+    const header = buildPartHeader(index + 1, chunks.length);
+    await (0, import_cli.sendTextToTG)(`${header}
+
+${chunk}`, {
+      userName: options.userName,
+      markup: index === chunks.length - 1 ? options.markup : void 0
+    });
+  }
+  return chunks.length;
+};
+
+// src/lib/researchAgent.ts
+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;
+};
+
+// src/scripts/agentRun.ts
+import_args.default.example(
+  "yarn cli:node8g agent-run --runId 1710000000000-trendline --strategy TrendLine",
+  "Run the OpenRouter-based research follow-up coding agent in a git worktree"
+);
+import_args.default.option(["U", "user"], "Use user config", "root");
+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 AGENT_SYSTEM_PROMPT = `You are a senior TypeScript trading research coding agent working inside the TradeJS monorepo.
+
+Output ONLY one of:
+1. A unified git diff relative to repo root that can be applied with git apply.
+2. The exact token NO_CHANGES if no safe change should be made.
+
+Rules:
+- Keep the patch small and surgical.
+- Prefer strategy-scoped tests and notes updates over broad refactors.
+- If you change strategy logic, also add or update tests in the same strategy directory.
+- Do not touch package boundaries or unrelated files.
+- Do not add markdown fences, commentary, or explanations.
+- Do not modify files outside the allowed paths listed by the user.
+- Deleting files is not allowed.
+`;
+var trimTextTail = (value, limit = 4e3) => value.length <= limit ? value : value.slice(-limit);
+var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var isOpenRouterEndpoint = (value) => {
+  try {
+    return new URL(value).hostname.toLowerCase().includes("openrouter");
+  } catch {
+    return value.toLowerCase().includes("openrouter");
+  }
+};
+var resolveChatCompletionsUrl = (endpoint) => {
+  const normalized = endpoint.replace(/\/+$/, "");
+  if (normalized.endsWith("/chat/completions")) {
+    return normalized;
+  }
+  if (normalized.endsWith("/v1")) {
+    return `${normalized}/chat/completions`;
+  }
+  return `${normalized}/chat/completions`;
+};
+var runCommand = async (command, commandArgs, options = {}) => new Promise((resolve, reject) => {
+  const child = (0, import_node_child_process.spawn)(command, commandArgs, {
+    cwd: options.cwd || projectRoot,
+    env: {
+      ...process.env,
+      ...options.env
+    },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString();
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  child.on("error", reject);
+  child.on("close", (code) => {
+    resolve({
+      exitCode: code ?? 1,
+      stdout,
+      stderr
+    });
+  });
+});
+var runCommandOrThrow = async (command, commandArgs, options = {}) => {
+  const result = await runCommand(command, commandArgs, options);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `${command} ${commandArgs.join(" ")} failed: ${trimTextTail(
+        result.stderr || result.stdout,
+        2e3
+      )}`
+    );
+  }
+  return result;
+};
+var listFilesRecursive = async (targetPath) => {
+  try {
+    const entries = await import_promises.default.readdir(targetPath, { withFileTypes: true });
+    const nested = await Promise.all(
+      entries.map(async (entry) => {
+        const absolutePath = import_node_path2.default.join(targetPath, entry.name);
+        if (entry.isDirectory()) {
+          return listFilesRecursive(absolutePath);
+        }
+        return [absolutePath];
+      })
+    );
+    return nested.flat().sort((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+};
+var collectStrategyContextFiles = async (worktreePath, strategy) => {
+  const strategyRoot = import_node_path2.default.join(
+    worktreePath,
+    "packages",
+    "strategies",
+    "src",
+    strategy
+  );
+  const notePath = import_node_path2.default.join(worktreePath, getResearchAgentNotePath(strategy));
+  const strategyFiles = await listFilesRecursive(strategyRoot);
+  const files = strategyFiles.filter(
+    (filePath) => /\.(ts|tsx|md)$/.test(filePath)
+  );
+  try {
+    await import_promises.default.access(notePath);
+    files.push(notePath);
+  } catch {
+  }
+  return [...new Set(files)].sort((left, right) => left.localeCompare(right));
+};
+var renderFileContext = async (worktreePath, filePath) => {
+  const relativePath = import_node_path2.default.relative(worktreePath, filePath).replace(/\\/g, "/");
+  const content = await import_promises.default.readFile(filePath, "utf8");
+  return [
+    `=== FILE: ${relativePath} ===`,
+    content,
+    `=== END FILE: ${relativePath} ===`
+  ].join("\n");
+};
+var buildPrompt = async (worktreePath, run, allowedPaths) => {
+  const files = await collectStrategyContextFiles(worktreePath, run.strategy);
+  const contexts = await Promise.all(
+    files.map((filePath) => renderFileContext(worktreePath, filePath))
+  );
+  return [
+    `Strategy: ${run.strategy}`,
+    `Research run id: ${run.runId}`,
+    `Allowed paths: ${allowedPaths.join(", ")}`,
+    `Backtest config: ${run.config}`,
+    `Window: ${run.days} days, timeframe=${run.timeframe}, connector=${run.connector}`,
+    "",
+    "Research run summary:",
+    JSON.stringify(
+      {
+        status: run.status,
+        finishedAt: run.finishedAt,
+        backtestResult: run.artifacts.backtestResult,
+        aiTrainLocal: run.artifacts.aiTrainLocal,
+        strategyConfig: run.artifacts.strategyConfig
+      },
+      null,
+      2
+    ),
+    "",
+    "Task:",
+    "- Inspect the research results and current strategy files.",
+    "- Produce the smallest safe follow-up patch.",
+    "- Prefer notes and tests if the data does not justify a production logic change.",
+    "- If you change strategy logic, include matching regression tests.",
+    "",
+    contexts.join("\n\n")
+  ].join("\n");
+};
+var extractAssistantContent = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      if (!item || typeof item !== "object") {
+        return "";
+      }
+      const record = item;
+      if (record.type === "text" && typeof record.text === "string") {
+        return record.text;
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  return "";
+};
+var requestAgentDiff = async (userName, messages) => {
+  const settings = await (0, import_userSettings.getUserSettings)(userName);
+  if (!settings.AI_API_KEY || !settings.AI_API_ENDPOINT) {
+    throw new Error(`AI settings are incomplete for user ${userName}`);
+  }
+  if (!isOpenRouterEndpoint(settings.AI_API_ENDPOINT)) {
+    throw new Error(
+      `Research agent requires OpenRouter endpoint, got: ${settings.AI_API_ENDPOINT}`
+    );
+  }
+  const response = await fetch(
+    resolveChatCompletionsUrl(settings.AI_API_ENDPOINT),
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${settings.AI_API_KEY}`,
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://tradejs.dev",
+        "X-Title": "TradeJS Research Agent"
+      },
+      body: JSON.stringify({
+        model: RESEARCH_AGENT_MODEL,
+        messages,
+        reasoning: {
+          effort: RESEARCH_AGENT_REASONING_EFFORT,
+          exclude: true
+        },
+        temperature: 0.2
+      })
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `OpenRouter request failed (${response.status}): ${await response.text()}`
+    );
+  }
+  const payload = await response.json();
+  const content = extractAssistantContent(
+    payload.choices?.[0]?.message?.content
+  );
+  const normalized = normalizeDiffOutput(content);
+  if (!normalized) {
+    throw new Error("Research agent returned empty content");
+  }
+  return normalized;
+};
+var applyDiff = async (worktreePath, diffText) => {
+  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(
+      "git",
+      [
+        "-C",
+        worktreePath,
+        "apply",
+        "--index",
+        "--whitespace=nowarn",
+        patchPath
+      ],
+      { cwd: worktreePath }
+    );
+  } finally {
+    await import_promises.default.rm(tempDir, { recursive: true, force: true });
+  }
+};
+var getChangedFilesFromGit = async (worktreePath) => {
+  const result = await runCommandOrThrow(
+    "git",
+    ["-C", worktreePath, "status", "--short"],
+    { cwd: worktreePath }
+  );
+  return result.stdout.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => line.slice(3).trim());
+};
+var runValidationSuite = async (worktreePath, agentRun) => {
+  const commands = [
+    ["prettify", ["yarn", "prettify"]],
+    ["typecheck", ["yarn", "typecheck"]],
+    ["unit", ["yarn", "unit"]]
+  ];
+  agentRun.validation = {
+    prettify: "pending",
+    typecheck: "pending",
+    unit: "pending"
+  };
+  for (const [key, command] of commands) {
+    const result = await runCommand(command[0], command.slice(1), {
+      cwd: worktreePath,
+      env: {
+        PROJECT_CWD: worktreePath,
+        DOTENV_CONFIG_PATH: process.env.DOTENV_CONFIG_PATH
+      }
+    });
+    if (result.exitCode !== 0) {
+      agentRun.validation[key] = "failed";
+      throw new Error(
+        `${key} failed: ${trimTextTail(result.stderr || result.stdout, 2e3)}`
+      );
+    }
+    agentRun.validation[key] = "passed";
+  }
+};
+var buildAgentTelegramReport = (agentRun) => {
+  const lines = [
+    `<b>Research agent: ${escapeHtml(agentRun.strategy)}</b>`,
+    `Status: <b>${escapeHtml(agentRun.status)}</b>`,
+    `Run: <code>${escapeHtml(agentRun.runId)}</code>`,
+    `Model: <code>${escapeHtml(agentRun.model || RESEARCH_AGENT_MODEL)}</code>`,
+    `Reasoning: <code>${escapeHtml(agentRun.reasoningEffort || RESEARCH_AGENT_REASONING_EFFORT)}</code>`
+  ];
+  if (agentRun.branchName) {
+    lines.push(`Branch: <code>${escapeHtml(agentRun.branchName)}</code>`);
+  }
+  if (agentRun.commitHash) {
+    lines.push(`Commit: <code>${escapeHtml(agentRun.commitHash)}</code>`);
+  }
+  if (agentRun.commitMessage) {
+    lines.push(
+      `Commit message: <code>${escapeHtml(agentRun.commitMessage)}</code>`
+    );
+  }
+  if (typeof agentRun.pullRequestNumber === "number") {
+    lines.push(`PR: <code>#${agentRun.pullRequestNumber}</code>`);
+  }
+  if (agentRun.pullRequestUrl) {
+    lines.push(`PR URL: <code>${escapeHtml(agentRun.pullRequestUrl)}</code>`);
+  }
+  if (agentRun.changedFiles?.length) {
+    lines.push(
+      `Changed files: <code>${escapeHtml(agentRun.changedFiles.join(", "))}</code>`
+    );
+  }
+  if (agentRun.summary) {
+    lines.push(`Summary: <code>${escapeHtml(agentRun.summary)}</code>`);
+  }
+  if (agentRun.validation) {
+    lines.push(
+      `Validation: <code>${escapeHtml(
+        Object.entries(agentRun.validation).map(([key, value]) => `${key}=${value}`).join(", ")
+      )}</code>`
+    );
+  }
+  if (agentRun.error) {
+    lines.push("");
+    lines.push("<b>Error</b>");
+    lines.push(`<code>${escapeHtml(agentRun.error)}</code>`);
+  }
+  return lines.join("\n");
+};
+var loadRun = async (userName, runId, strategy) => {
+  if (runId) {
+    const record = await (0, import_redis.getData)(
+      import_redis.redisKeys.researchRun(userName, runId),
+      null
+    );
+    if (record) {
+      return record;
+    }
+  }
+  if (strategy) {
+    const latest = await (0, import_redis.getData)(
+      import_redis.redisKeys.researchLatestRun(userName, strategy),
+      null
+    );
+    if (latest) {
+      return latest;
+    }
+  }
+  throw new Error(
+    `Research run not found for user=${userName}, runId=${runId || "n/a"}, strategy=${strategy || "n/a"}`
+  );
+};
+var saveAgentRun = async (userName, runId, strategy, agentRun) => {
+  const run = await (0, import_redis.getData)(
+    import_redis.redisKeys.researchRun(userName, runId),
+    null
+  );
+  if (!run) {
+    return;
+  }
+  run.artifacts = {
+    ...run.artifacts,
+    agentRun
+  };
+  await (0, import_redis.setData)(import_redis.redisKeys.researchRun(userName, runId), run, { expire: 0 });
+  await (0, import_redis.setData)(import_redis.redisKeys.researchLatestRun(userName, strategy), run, {
+    expire: 0
+  });
+};
+var resolveGithubRepository = async (worktreePath) => {
+  if (process.env.AGENT_GITHUB_REPOSITORY?.trim()) {
+    return process.env.AGENT_GITHUB_REPOSITORY.trim();
+  }
+  const remote = await runCommandOrThrow(
+    "git",
+    ["-C", worktreePath, "remote", "get-url", "origin"],
+    { cwd: worktreePath }
+  );
+  const repository = parseGithubRepositoryFromRemote(remote.stdout.trim());
+  if (!repository) {
+    throw new Error(`Unable to resolve GitHub repository from origin remote`);
+  }
+  return repository;
+};
+var createGithubPullRequest = async (params) => {
+  const token = process.env.AGENT_GITHUB_TOKEN?.trim() || process.env.GITHUB_TOKEN?.trim();
+  if (!token) {
+    throw new Error("AGENT_GITHUB_TOKEN is required to create pull requests");
+  }
+  const repository = await resolveGithubRepository(params.worktreePath);
+  const [owner, repo] = repository.split("/");
+  if (!owner || !repo) {
+    throw new Error(`Invalid GitHub repository value: ${repository}`);
+  }
+  const baseBranch = process.env.AGENT_GITHUB_BASE_BRANCH?.trim() || "stable";
+  const head = `${owner}:${params.branchName}`;
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "Content-Type": "application/json",
+    "User-Agent": "TradeJS-Research-Agent"
+  };
+  const existingResponse = await fetch(
+    `https://api.github.com/repos/${owner}/${repo}/pulls?state=open&head=${encodeURIComponent(
+      head
+    )}&base=${encodeURIComponent(baseBranch)}`,
+    { headers }
+  );
+  if (!existingResponse.ok) {
+    throw new Error(
+      `GitHub PR lookup failed (${existingResponse.status}): ${await existingResponse.text()}`
+    );
+  }
+  const existing = await existingResponse.json();
+  if (existing[0]) {
+    return {
+      number: existing[0].number,
+      url: existing[0].html_url,
+      title: existing[0].title,
+      reused: true
+    };
+  }
+  const response = await fetch(
+    `https://api.github.com/repos/${owner}/${repo}/pulls`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        title: params.title,
+        head: params.branchName,
+        base: baseBranch,
+        body: params.body
+      })
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `GitHub PR create failed (${response.status}): ${await response.text()}`
+    );
+  }
+  const payload = await response.json();
+  return {
+    number: payload.number,
+    url: payload.html_url,
+    title: payload.title,
+    reused: false
+  };
+};
+var createWorktree = async (branchName) => {
+  const worktreeToken = branchName.replace(/[/:]+/g, "--");
+  const worktreeRoot = import_node_path2.default.join(projectRoot, ".agent-worktrees");
+  const worktreePath = import_node_path2.default.join(worktreeRoot, worktreeToken);
+  await import_promises.default.mkdir(worktreeRoot, { recursive: true });
+  await runCommand("git", ["worktree", "remove", "--force", worktreePath], {
+    cwd: projectRoot
+  });
+  await runCommandOrThrow("git", ["fetch", "origin", "stable"], {
+    cwd: projectRoot
+  });
+  await runCommandOrThrow(
+    "git",
+    ["worktree", "add", "-B", branchName, worktreePath, "origin/stable"],
+    {
+      cwd: projectRoot
+    }
+  );
+  return worktreePath;
+};
+var cleanupWorktree = async (worktreePath) => {
+  await runCommand("git", ["worktree", "remove", "--force", worktreePath], {
+    cwd: projectRoot
+  });
+};
+var main = async () => {
+  const userName = String(flags.user || "root").trim() || "root";
+  const requestedRunId = String(flags.runId || "").trim();
+  const requestedStrategy = String(flags.strategy || "").trim();
+  const jsonOutput = Boolean(flags.json);
+  const run = await loadRun(userName, requestedRunId, requestedStrategy);
+  const branchName = buildResearchAgentBranchName(run.strategy, run.runId);
+  const commitMessage = buildResearchAgentCommitMessage(
+    run.strategy,
+    run.runId
+  );
+  const prTitle = buildResearchAgentPrTitle(run.strategy, run.runId);
+  const allowedPrefixes = getResearchAgentAllowedPathPrefixes(run.strategy);
+  const agentRun = {
+    status: "running",
+    strategy: run.strategy,
+    runId: run.runId,
+    branchName,
+    commitMessage,
+    pullRequestTitle: prTitle,
+    model: RESEARCH_AGENT_MODEL,
+    reasoningEffort: RESEARCH_AGENT_REASONING_EFFORT,
+    summary: "Awaiting model patch",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  let worktreePath = "";
+  await saveAgentRun(userName, run.runId, run.strategy, agentRun);
+  try {
+    worktreePath = await createWorktree(branchName);
+    const userPrompt = await buildPrompt(worktreePath, run, allowedPrefixes);
+    const messages = [
+      { role: "system", content: AGENT_SYSTEM_PROMPT },
+      { role: "user", content: userPrompt }
+    ];
+    let diffText = "";
+    let changedFiles = [];
+    for (let attempt = 1; attempt <= 2; attempt += 1) {
+      diffText = await requestAgentDiff(userName, messages);
+      if (diffText === "NO_CHANGES") {
+        agentRun.status = "no_changes";
+        agentRun.summary = "Model decided not to change code or notes";
+        agentRun.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await saveAgentRun(userName, run.runId, run.strategy, agentRun);
+        await sendTelegramReport(buildAgentTelegramReport(agentRun), {
+          userName
+        });
+        if (jsonOutput) {
+          console.log(JSON.stringify(agentRun));
+        } else {
+          console.log(import_chalk.default.yellow(agentRun.summary));
+        }
+        return;
+      }
+      changedFiles = assertDiffAllowed(diffText, allowedPrefixes);
+      try {
+        await applyDiff(worktreePath, diffText);
+        break;
+      } catch (error) {
+        if (attempt >= 2) {
+          throw error;
+        }
+        messages.push({ role: "assistant", content: diffText });
+        messages.push({
+          role: "user",
+          content: `The previous unified diff failed to apply.
+Error:
+${String(
+            error?.message || error
+          )}
+
+Return a corrected unified diff only. Keep the same allowed paths.`
+        });
+      }
+    }
+    agentRun.summary = `Applied model diff touching ${changedFiles.length} file(s)`;
+    await runValidationSuite(worktreePath, agentRun);
+    const effectiveChangedFiles = await getChangedFilesFromGit(worktreePath);
+    if (!effectiveChangedFiles.length) {
+      agentRun.status = "no_changes";
+      agentRun.summary = "Patch applied cleanly but produced no working tree changes";
+      agentRun.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await saveAgentRun(userName, run.runId, run.strategy, agentRun);
+      await sendTelegramReport(buildAgentTelegramReport(agentRun), {
+        userName
+      });
+      if (jsonOutput) {
+        console.log(JSON.stringify(agentRun));
+      } else {
+        console.log(import_chalk.default.yellow(agentRun.summary));
+      }
+      return;
+    }
+    await runCommandOrThrow("git", ["-C", worktreePath, "add", "."], {
+      cwd: worktreePath
+    });
+    await runCommandOrThrow(
+      "git",
+      ["-C", worktreePath, "commit", "-m", commitMessage],
+      {
+        cwd: worktreePath,
+        env: {
+          GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME || "TradeJS Research Agent",
+          GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL || "research-agent@tradejs.dev",
+          GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME || "TradeJS Research Agent",
+          GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL || "research-agent@tradejs.dev"
+        }
+      }
+    );
+    await runCommandOrThrow(
+      "git",
+      ["-C", worktreePath, "push", "-u", "origin", branchName],
+      { cwd: worktreePath }
+    );
+    const commitHash = (await runCommandOrThrow(
+      "git",
+      ["-C", worktreePath, "rev-parse", "HEAD"],
+      {
+        cwd: worktreePath
+      }
+    )).stdout.trim();
+    agentRun.status = "completed";
+    agentRun.commitHash = commitHash;
+    agentRun.changedFiles = effectiveChangedFiles;
+    agentRun.summary = `Committed validated patch on branch ${branchName}`;
+    const prBody = buildResearchAgentPrBody({
+      strategy: run.strategy,
+      runId: run.runId,
+      config: run.config,
+      connector: run.connector,
+      timeframe: run.timeframe,
+      days: run.days,
+      recent: run.recent,
+      changedFiles: effectiveChangedFiles,
+      validation: agentRun.validation,
+      summary: agentRun.summary,
+      aiTrainLocal: run.artifacts.aiTrainLocal ?? null
+    });
+    const pr = await createGithubPullRequest({
+      worktreePath,
+      branchName,
+      title: prTitle,
+      body: prBody
+    });
+    agentRun.pullRequestNumber = pr.number;
+    agentRun.pullRequestUrl = pr.url;
+    agentRun.pullRequestTitle = pr.title;
+    agentRun.summary = pr.reused ? `Committed validated patch on branch ${branchName}; reused PR #${pr.number}` : `Committed validated patch on branch ${branchName}; created PR #${pr.number}`;
+    agentRun.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await saveAgentRun(userName, run.runId, run.strategy, agentRun);
+    await sendTelegramReport(buildAgentTelegramReport(agentRun), {
+      userName
+    });
+    if (jsonOutput) {
+      console.log(JSON.stringify(agentRun));
+    } else {
+      console.log(import_chalk.default.green(agentRun.summary));
+      console.log(import_chalk.default.gray(`branch=${branchName}`));
+      console.log(import_chalk.default.gray(`commit=${commitHash}`));
+      if (agentRun.pullRequestUrl) {
+        console.log(import_chalk.default.gray(`pullRequest=${agentRun.pullRequestUrl}`));
+      }
+    }
+  } catch (error) {
+    agentRun.status = "failed";
+    agentRun.error = error?.message || String(error);
+    agentRun.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await saveAgentRun(userName, run.runId, run.strategy, agentRun);
+    try {
+      await sendTelegramReport(buildAgentTelegramReport(agentRun), {
+        userName
+      });
+    } catch {
+    }
+    if (jsonOutput) {
+      console.log(JSON.stringify(agentRun));
+    } else {
+      console.error(import_chalk.default.red(agentRun.error));
+    }
+    process.exit(1);
+  } finally {
+    if (worktreePath) {
+      await cleanupWorktree(worktreePath);
+    }
+  }
+};
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(import_chalk.default.red(error?.message || String(error)));
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});