@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/native/pr-automation.js

@@ -0,0 +1,373 @@
+// @bun
+// packages/runtime/src/control-plane/native/pr-automation.ts
+var UPLOADED_SNAPSHOT_PR_MARKER = "<!-- rig:uploaded-snapshot -->";
+function positiveInt(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function resolvePrAutomationLimits(config) {
+  return {
+    maxPrFixIterations: positiveInt(config?.automation?.maxPrFixIterations, 30)
+  };
+}
+function buildPrAutomationBody(input) {
+  const lines = [
+    input.summary?.trim() || "Rig completed this task autonomously.",
+    "",
+    `Run: ${input.runId}`
+  ];
+  if (/^\d+$/.test(input.taskId)) {
+    lines.push("", `Closes #${input.taskId}`);
+  }
+  if (input.uploadedSnapshot) {
+    lines.push("", UPLOADED_SNAPSHOT_PR_MARKER, "This PR was seeded from an uploaded local working-tree snapshot. Review local snapshot provenance before merging if repository policy requires it.");
+  }
+  return lines.join(`
+`);
+}
+function wildcardToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function isAllowedFailure(name, allowedFailures) {
+  return allowedFailures.some((pattern) => wildcardToRegExp(pattern).test(name));
+}
+function isPendingCheck(check) {
+  const conclusion = String(check.conclusion ?? "").toLowerCase();
+  const state = String(check.state ?? check.status ?? "").toLowerCase();
+  return ["pending", "queued", "in_progress", "waiting", "requested", "expected", "action_required"].includes(conclusion) || ["pending", "queued", "in_progress", "waiting", "requested", "expected"].includes(state);
+}
+function isPassingCheck(check) {
+  const conclusion = String(check.conclusion ?? "").toLowerCase();
+  const state = String(check.state ?? check.status ?? "").toLowerCase();
+  return ["success", "successful", "passed", "neutral", "skipped"].includes(conclusion) || ["success", "successful", "passed", "completed"].includes(state);
+}
+function isFailingCheck(check) {
+  const conclusion = String(check.conclusion ?? "").toLowerCase();
+  const state = String(check.state ?? check.status ?? "").toLowerCase();
+  return ["failure", "failed", "timed_out", "action_required", "cancelled", "error"].includes(conclusion) || ["failure", "failed", "timed_out", "action_required", "cancelled", "error"].includes(state);
+}
+function collectPendingPrChecks(input) {
+  const allowedFailures = input.allowedFailures ?? [];
+  const pending = [];
+  for (const check of input.checks ?? []) {
+    const name = check.name.trim();
+    if (!name || isAllowedFailure(name, allowedFailures))
+      continue;
+    if (isPendingCheck(check) && !isPassingCheck(check))
+      pending.push(name);
+  }
+  return pending;
+}
+function collectActionablePrFeedback(input) {
+  const allowedFailures = input.allowedFailures ?? [];
+  const feedback = [];
+  for (const check of input.checks ?? []) {
+    const name = check.name.trim();
+    if (!name || !isFailingCheck(check) || isAllowedFailure(name, allowedFailures))
+      continue;
+    feedback.push(`Check failed: ${name}${check.detailsUrl ? ` (${check.detailsUrl})` : ""}`);
+  }
+  for (const thread of input.reviewThreads ?? []) {
+    if (thread.resolved === true)
+      continue;
+    const body = thread.body.trim();
+    if (!body)
+      continue;
+    feedback.push(`Review feedback from ${thread.author?.trim() || "reviewer"}: ${body}`);
+  }
+  return feedback;
+}
+function parseJsonArray(value) {
+  if (!value?.trim())
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function parsePrChecks(value) {
+  return parseJsonArray(value).flatMap((entry) => {
+    if (!entry || typeof entry !== "object")
+      return [];
+    const record = entry;
+    const name = typeof record.name === "string" ? record.name : "";
+    if (!name.trim())
+      return [];
+    return [{
+      name,
+      status: typeof record.status === "string" ? record.status : null,
+      state: typeof record.state === "string" ? record.state : null,
+      conclusion: typeof record.conclusion === "string" ? record.conclusion : null,
+      detailsUrl: typeof record.detailsUrl === "string" ? record.detailsUrl : typeof record.link === "string" ? record.link : null
+    }];
+  });
+}
+function parsePrViewReviewThreads(value) {
+  if (!value?.trim())
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    const feedback = [];
+    const reviewThreads = parsed.reviewThreads;
+    if (Array.isArray(reviewThreads)) {
+      feedback.push(...reviewThreads.flatMap((entry) => {
+        if (!entry || typeof entry !== "object")
+          return [];
+        const record = entry;
+        const body = typeof record.body === "string" ? record.body : null;
+        if (!body)
+          return [];
+        return [{
+          id: typeof record.id === "string" ? record.id : null,
+          body,
+          resolved: typeof record.resolved === "boolean" ? record.resolved : false,
+          author: typeof record.author === "string" ? record.author : null
+        }];
+      }));
+    }
+    const reviews = parsed.reviews;
+    if (Array.isArray(reviews)) {
+      feedback.push(...reviews.flatMap((entry) => {
+        if (!entry || typeof entry !== "object")
+          return [];
+        const record = entry;
+        const state = typeof record.state === "string" ? record.state.toUpperCase() : "";
+        if (state !== "CHANGES_REQUESTED")
+          return [];
+        const body = typeof record.body === "string" && record.body.trim() ? record.body : "Changes requested by reviewer.";
+        const author = record.author && typeof record.author === "object" ? record.author.login : null;
+        return [{
+          id: typeof record.id === "string" ? record.id : null,
+          body,
+          resolved: false,
+          author: typeof author === "string" ? author : null
+        }];
+      }));
+    }
+    const reviewDecision = typeof parsed.reviewDecision === "string" ? parsed.reviewDecision.toUpperCase() : "";
+    if (reviewDecision === "CHANGES_REQUESTED" && feedback.length === 0) {
+      feedback.push({ body: "Changes requested by reviewer.", resolved: false });
+    }
+    return feedback;
+  } catch {
+    return [];
+  }
+}
+function findPrUrl(output) {
+  return output?.split(/\s+/).map((part) => part.trim()).find((part) => /^https?:\/\/\S+\/pull\/\d+$/i.test(part)) ?? null;
+}
+function normalizePrUrl(stdout) {
+  const url = findPrUrl(stdout);
+  if (!url)
+    throw new Error("gh pr create did not return a PR URL");
+  return url;
+}
+async function runChecked(command, args, cwd, label = "gh") {
+  const result = await command(args, cwd ? { cwd } : undefined);
+  if (result.exitCode !== 0) {
+    throw new Error(`${label} ${args.join(" ")} failed (${result.exitCode}): ${result.stderr ?? result.stdout ?? ""}`.trim());
+  }
+  return result;
+}
+var RIG_RUNTIME_COMMIT_EXCLUDES = [
+  ".rig",
+  "artifacts",
+  "node_modules"
+];
+function statusPathFromShortLine(line) {
+  const rawPath = line.length > 3 ? line.slice(3).trim() : "";
+  const renamedPath = rawPath.includes(" -> ") ? rawPath.split(" -> ").at(-1).trim() : rawPath;
+  if (renamedPath.startsWith('"') && renamedPath.endsWith('"')) {
+    try {
+      return JSON.parse(renamedPath);
+    } catch {
+      return renamedPath.slice(1, -1);
+    }
+  }
+  return renamedPath;
+}
+function hasCommittableRunChanges(statusText) {
+  return statusText.split(/\r?\n/).map((line) => statusPathFromShortLine(line)).filter(Boolean).some((path) => !RIG_RUNTIME_COMMIT_EXCLUDES.some((excluded) => path === excluded || path.startsWith(`${excluded}/`)));
+}
+async function commitRunChanges(input) {
+  const status = await runChecked(input.command, ["status", "--short"], input.cwd, "git");
+  const statusText = status.stdout ?? "";
+  if (!statusText.trim() || !hasCommittableRunChanges(statusText)) {
+    return { committed: false, status: statusText };
+  }
+  await runChecked(input.command, [
+    "add",
+    "-A",
+    "--",
+    ".",
+    ":(exclude).rig",
+    ":(exclude).rig/**",
+    ":(exclude)artifacts",
+    ":(exclude)artifacts/**",
+    ":(exclude)node_modules",
+    ":(exclude)node_modules/**"
+  ], input.cwd, "git");
+  const staged = await input.command(["diff", "--cached", "--quiet"], { cwd: input.cwd });
+  if (staged.exitCode === 0) {
+    return { committed: false, status: statusText };
+  }
+  if (staged.exitCode !== 1) {
+    throw new Error(`git diff --cached --quiet failed (${staged.exitCode}): ${staged.stderr ?? staged.stdout ?? ""}`.trim());
+  }
+  await runChecked(input.command, ["commit", "-m", input.message], input.cwd, "git");
+  return { committed: true, status: statusText };
+}
+async function closeIssueAfterMergedPr(input) {
+  await input.updateTaskSource(input.projectRoot, {
+    taskId: input.taskId,
+    sourceTask: input.sourceTask,
+    update: {
+      status: "closed",
+      comment: [
+        "<!-- rig:status-comment -->",
+        "### Rig status: closed",
+        "",
+        "Rig PR merged and closed this task.",
+        "",
+        `- Run: ${input.runId}`,
+        `- PR merged: ${input.prUrl}`
+      ].join(`
+`)
+    }
+  });
+}
+function parseGitHubRepoFromPrUrl(prUrl) {
+  const match = /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/\d+\/?$/i.exec(prUrl.trim());
+  return match ? { owner: match[1], repo: match[2] } : null;
+}
+async function resolveRepoDefaultMergeFlag(input) {
+  const repo = parseGitHubRepoFromPrUrl(input.prUrl);
+  if (!repo)
+    throw new Error(`Cannot resolve GitHub repository from PR URL: ${input.prUrl}`);
+  const result = await input.command(["api", `repos/${repo.owner}/${repo.repo}`], input.cwd ? { cwd: input.cwd } : undefined);
+  if (result.exitCode !== 0) {
+    throw new Error(`Could not read repository merge policy for ${repo.owner}/${repo.repo}: ${result.stderr ?? result.stdout ?? "gh api failed"}`.trim());
+  }
+  try {
+    const parsed = JSON.parse(result.stdout ?? "{}");
+    if (parsed.allow_merge_commit !== false)
+      return "--merge";
+    if (parsed.allow_squash_merge !== false)
+      return "--squash";
+    if (parsed.allow_rebase_merge !== false)
+      return "--rebase";
+  } catch (error) {
+    throw new Error(`Could not parse repository merge policy for ${repo.owner}/${repo.repo}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  throw new Error(`Repository ${repo.owner}/${repo.repo} has no enabled merge method for repo-default merge.`);
+}
+async function runRepoDefaultMerge(input) {
+  const merge = input.config?.merge ?? {};
+  if (merge.mode === "off")
+    return;
+  const method = merge.method ?? "repo-default";
+  const args = ["pr", "merge", input.prUrl];
+  if (method === "repo-default") {
+    args.push(await resolveRepoDefaultMergeFlag({ prUrl: input.prUrl, command: input.command, cwd: input.cwd }));
+  } else {
+    args.push(`--${method}`);
+  }
+  if (merge.deleteBranch === true) {
+    args.push("--delete-branch");
+  }
+  if (merge.bypass === true) {
+    args.push("--admin");
+  }
+  await runChecked(input.command, args, input.cwd);
+}
+async function runPrAutomation(input) {
+  const prConfig = input.config?.pr ?? {};
+  if (prConfig.mode === "off") {
+    return { status: "skipped", iterations: 0, actionableFeedback: [] };
+  }
+  const body = buildPrAutomationBody({
+    taskId: input.taskId,
+    runId: input.runId,
+    summary: input.sourceTask?.title ? `Rig completed: ${input.sourceTask.title}` : null,
+    uploadedSnapshot: input.uploadedSnapshot
+  });
+  if (input.gitCommand) {
+    await runChecked(input.gitCommand, ["push", "--set-upstream", "origin", input.branch], input.projectRoot, "git");
+  }
+  const createArgs = [
+    "pr",
+    "create",
+    "--head",
+    input.branch,
+    "--title",
+    input.sourceTask?.title?.trim() || `Rig task ${input.taskId}`,
+    "--body",
+    body
+  ];
+  const createResult = await input.command(createArgs, { cwd: input.projectRoot });
+  const existingPrUrl = createResult.exitCode === 0 ? null : /pull request .*already exists/i.test(`${createResult.stderr ?? ""}
+${createResult.stdout ?? ""}`) ? findPrUrl(`${createResult.stderr ?? ""}
+${createResult.stdout ?? ""}`) : null;
+  if (createResult.exitCode !== 0 && !existingPrUrl) {
+    throw new Error(`gh ${createArgs.join(" ")} failed (${createResult.exitCode}): ${createResult.stderr ?? createResult.stdout ?? ""}`.trim());
+  }
+  const prUrl = existingPrUrl ?? normalizePrUrl(createResult.stdout);
+  await input.lifecycle?.onPrOpened?.({ prUrl });
+  const { maxPrFixIterations } = resolvePrAutomationLimits(input.config);
+  let latestFeedback = [];
+  for (let iteration = 1;iteration <= maxPrFixIterations; iteration += 1) {
+    await input.lifecycle?.onReviewCiStarted?.({ prUrl, iteration });
+    const checks = prConfig.watchChecks === false ? [] : parsePrChecks((await runChecked(input.command, ["pr", "checks", prUrl, "--json", "name,state,link"], input.projectRoot)).stdout);
+    const reviewThreads = prConfig.autoFixReview === false ? [] : parsePrViewReviewThreads((await runChecked(input.command, ["pr", "view", prUrl, "--json", "reviewDecision,reviews"], input.projectRoot)).stdout);
+    latestFeedback = collectActionablePrFeedback({
+      checks,
+      reviewThreads,
+      allowedFailures: input.config?.merge?.allowedFailures ?? []
+    });
+    const pendingChecks = collectPendingPrChecks({ checks, allowedFailures: input.config?.merge?.allowedFailures ?? [] });
+    if (latestFeedback.length === 0 && pendingChecks.length > 0) {
+      const timeoutMs = positiveInt(prConfig.pendingTimeoutMs, 600000);
+      const pollMs = positiveInt(prConfig.pendingPollMs, 15000);
+      if (iteration >= maxPrFixIterations || timeoutMs <= 0) {
+        return { status: "needs_attention", prUrl, iterations: iteration, actionableFeedback: pendingChecks.map((name) => `Check still pending: ${name}`), merged: false };
+      }
+      await (input.sleep ?? Bun.sleep)(Math.min(pollMs, timeoutMs));
+      continue;
+    }
+    if (latestFeedback.length === 0) {
+      if (input.config?.merge?.mode === "off" || input.config?.merge?.mode === "pr-ready") {
+        return { status: "opened", prUrl, iterations: iteration, actionableFeedback: [], merged: false };
+      }
+      await input.lifecycle?.onMergeStarted?.({ prUrl });
+      await runRepoDefaultMerge({ prUrl, config: input.config, command: input.command, cwd: input.projectRoot });
+      await input.lifecycle?.onMerged?.({ prUrl });
+      return { status: "merged", prUrl, iterations: iteration, actionableFeedback: [], merged: true };
+    }
+    if (iteration >= maxPrFixIterations || prConfig.autoFixChecks === false && prConfig.autoFixReview === false) {
+      return { status: "needs_attention", prUrl, iterations: iteration, actionableFeedback: latestFeedback, merged: false };
+    }
+    await input.lifecycle?.onFeedback?.({ prUrl, iteration, feedback: latestFeedback });
+    await input.steerPi([
+      `PR automation found actionable feedback on ${prUrl}.`,
+      `Fix iteration ${iteration + 1}/${maxPrFixIterations}.`,
+      "",
+      ...latestFeedback.map((entry) => `- ${entry}`)
+    ].join(`
+`));
+  }
+  return { status: "needs_attention", prUrl, iterations: maxPrFixIterations, actionableFeedback: latestFeedback, merged: false };
+}
+export {
+  runRepoDefaultMerge,
+  runPrAutomation,
+  resolvePrAutomationLimits,
+  hasCommittableRunChanges,
+  commitRunChanges,
+  collectPendingPrChecks,
+  collectActionablePrFeedback,
+  closeIssueAfterMergedPr,
+  buildPrAutomationBody,
+  UPLOADED_SNAPSHOT_PR_MARKER
+};