issue-flow 0.5.2 → 0.7.0

package/dist/chunk-EWMSQQL2.js

@@ -0,0 +1,725 @@
+#!/usr/bin/env node
+import {
+  listPullRequests
+} from "./chunk-CW6UE3NW.js";
+import {
+  runHeadless
+} from "./chunk-KUDAY57D.js";
+import {
+  applyPlaceholders,
+  loadPrompt
+} from "./chunk-SLHZPB3C.js";
+import {
+  getCurrentBranch,
+  getIssueDir,
+  loadPrReviewConfig,
+  run
+} from "./chunk-OVFYJLOH.js";
+import {
+  getGlobalTimeout,
+  getSessionPublisher,
+  isoNow,
+  loadTaskPlan,
+  printError,
+  printInfo,
+  printSuccess,
+  printWarning,
+  saveTaskPlan,
+  writeFileAtomic
+} from "./chunk-2Y3UO7H2.js";
+
+// src/commands/pr-review.ts
+import { join as join4 } from "path";
+
+// src/core/pr-review/discovery.ts
+import { join } from "path";
+import { createInterface } from "readline";
+var PrDiscoveryError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "PrDiscoveryError";
+    this.exitCode = exitCode;
+  }
+};
+var MAX_PROMPT_ATTEMPTS = 3;
+var SOURCE_LABELS = {
+  argument: "the command argument",
+  session: "the current session",
+  plan: "tasks.json",
+  branch: "the current branch"
+};
+async function loadPlanPullRequest(issue) {
+  try {
+    const plan = await loadTaskPlan(join(await getIssueDir(issue), "tasks.json"));
+    return plan.pullRequest ?? null;
+  } catch {
+    return null;
+  }
+}
+var defaultSources = {
+  sessionPullRequests: () => getSessionPublisher().snapshot().pullRequests,
+  planPullRequest: loadPlanPullRequest,
+  currentBranch: getCurrentBranch,
+  branchPullRequests: listPullRequests
+};
+function mostRecent(pullRequests) {
+  let latest = null;
+  for (const pr of pullRequests) {
+    if (latest === null || pr.number > latest.number) {
+      latest = pr;
+    }
+  }
+  return latest;
+}
+function parsePrArgument(arg) {
+  const trimmed = arg.trim();
+  const fromUrl = trimmed.match(/\/pull\/(\d+)/);
+  if (fromUrl?.[1] !== void 0) {
+    return Number(fromUrl[1]);
+  }
+  const plain = trimmed.match(/^#?(\d+)$/);
+  return plain?.[1] === void 0 ? null : Number(plain[1]);
+}
+function isInteractiveByDefault() {
+  const ci = process.env.CI;
+  const inCi = ci !== void 0 && ci !== "" && ci !== "0" && ci.toLowerCase() !== "false";
+  return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && !inCi;
+}
+function describe(pr) {
+  const parts = [`#${pr.number}`];
+  if (pr.title !== null) parts.push(`"${pr.title}"`);
+  if (pr.headBranch !== null) parts.push(`(${pr.headBranch})`);
+  return parts.join(" ");
+}
+async function confirm(query, stdin, stdout, warn) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  const queued = [];
+  let pending = null;
+  let closed = false;
+  rl.on("line", (line) => {
+    if (pending !== null) {
+      const resolve = pending;
+      pending = null;
+      resolve(line);
+      return;
+    }
+    queued.push(line);
+  });
+  rl.on("close", () => {
+    closed = true;
+    if (pending !== null) {
+      const resolve = pending;
+      pending = null;
+      resolve(null);
+    }
+  });
+  const ask = () => new Promise((resolve) => {
+    const buffered = queued.shift();
+    if (buffered !== void 0) {
+      resolve(buffered);
+      return;
+    }
+    if (closed) {
+      resolve(null);
+      return;
+    }
+    stdout.write(query);
+    pending = resolve;
+  });
+  try {
+    for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS; attempt++) {
+      const answer = await ask();
+      if (answer === null) {
+        return false;
+      }
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "" || normalized === "y" || normalized === "yes") {
+        return true;
+      }
+      if (normalized === "n" || normalized === "no") {
+        return false;
+      }
+      warn(`Invalid answer: '${answer.trim()}'. Enter y or n.`);
+    }
+    return false;
+  } finally {
+    rl.close();
+  }
+}
+async function resolvePullRequest(prArg, opts = {}) {
+  const info = opts.info ?? printInfo;
+  const warn = opts.warn ?? printWarning;
+  const sources = { ...defaultSources, ...opts.sources };
+  if (prArg !== void 0 && prArg.trim() !== "") {
+    const number = parsePrArgument(prArg);
+    if (number === null) {
+      throw new PrDiscoveryError(
+        `Invalid Pull Request reference '${prArg.trim()}'. Use a number (e.g. 184) or a GitHub Pull Request URL.`
+      );
+    }
+    const url = prArg.trim().includes("/pull/") ? prArg.trim() : null;
+    return { number, url, title: null, headBranch: null, source: "argument" };
+  }
+  const discovered = await discover(sources, opts.issue, warn);
+  if (discovered === null) {
+    throw new PrDiscoveryError(
+      "No Pull Request found for this branch, in tasks.json or in the current session. Run `issue-flow pr-review <number>` with the Pull Request number."
+    );
+  }
+  const interactive = opts.yes === true ? false : opts.interactive ?? isInteractiveByDefault();
+  if (!interactive) {
+    info(
+      `Reviewing Pull Request ${describe(discovered)}, found in ${SOURCE_LABELS[discovered.source]}.`
+    );
+    return discovered;
+  }
+  info(`Pull Request found in ${SOURCE_LABELS[discovered.source]}:`);
+  info(`  number: #${discovered.number}`);
+  info(`  title:  ${discovered.title ?? "(unknown)"}`);
+  info(`  branch: ${discovered.headBranch ?? "(unknown)"}`);
+  const accepted = await confirm(
+    `Review Pull Request #${discovered.number}? (Y/n): `,
+    opts.stdin ?? process.stdin,
+    opts.stdout ?? process.stdout,
+    warn
+  );
+  if (!accepted) {
+    throw new PrDiscoveryError(
+      `Cancelled: Pull Request #${discovered.number} was not confirmed. Run \`issue-flow pr-review <number>\` to review a specific Pull Request.`
+    );
+  }
+  return discovered;
+}
+async function discover(sources, issue, warn) {
+  if (issue !== void 0 && issue !== "") {
+    try {
+      const fromPlan = await sources.planPullRequest(issue);
+      if (fromPlan !== null) {
+        return {
+          number: fromPlan.number,
+          url: fromPlan.url,
+          title: null,
+          headBranch: fromPlan.headBranch,
+          source: "plan"
+        };
+      }
+    } catch {
+    }
+  }
+  let sessionPrs = [];
+  try {
+    sessionPrs = sources.sessionPullRequests();
+  } catch {
+  }
+  const fromSession = mostRecent(sessionPrs);
+  if (fromSession !== null) {
+    return {
+      number: fromSession.number,
+      url: fromSession.url,
+      title: fromSession.title,
+      headBranch: null,
+      source: "session"
+    };
+  }
+  let branch = "";
+  try {
+    branch = await sources.currentBranch();
+  } catch (err) {
+    warn(
+      `Could not detect the current branch: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (branch === "") {
+    return null;
+  }
+  let branchPrs = [];
+  try {
+    branchPrs = await sources.branchPullRequests(branch);
+  } catch (err) {
+    warn(
+      `Could not list Pull Requests for branch '${branch}': ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+  const fromBranch = mostRecent(branchPrs);
+  if (fromBranch === null) {
+    return null;
+  }
+  return {
+    number: fromBranch.number,
+    url: fromBranch.url,
+    title: fromBranch.title,
+    headBranch: branch,
+    source: "branch"
+  };
+}
+
+// src/core/pr-review/publisher.ts
+import { mkdir } from "fs/promises";
+import { join as join3 } from "path";
+
+// src/core/pr-review/report.ts
+import { readdir, readFile } from "fs/promises";
+import { join as join2 } from "path";
+var RECOMMENDATIONS = {
+  APPROVE: "APPROVE",
+  APPROVE_WITH_SUGGESTIONS: "APPROVE_WITH_SUGGESTIONS",
+  REQUEST_CHANGES: "REQUEST_CHANGES"
+};
+function parsePrReviewResult(output) {
+  const block = output.match(/<pr-review-result>([\s\S]*?)<\/pr-review-result>/);
+  const scope = block?.[1] ?? output;
+  const line = scope.match(/RECOMMENDATION:\s*([^\n\r]+)/i);
+  if (line?.[1] === void 0) {
+    return {
+      ok: false,
+      error: block ? "The <pr-review-result> block has no RECOMMENDATION line." : "No <pr-review-result> block and no RECOMMENDATION line in the output."
+    };
+  }
+  const raw = line[1].trim().replace(/[*`]/g, "").replace(/^_+|[_.]+$/g, "").trim();
+  const normalized = raw.toUpperCase().replace(/[\s-]+/g, "_");
+  const recommendation = RECOMMENDATIONS[normalized];
+  if (recommendation === void 0) {
+    return {
+      ok: false,
+      error: `Unknown recommendation '${raw}'. Expected APPROVE, APPROVE_WITH_SUGGESTIONS or REQUEST_CHANGES.`
+    };
+  }
+  return { ok: true, result: { recommendation, blockers: parseBlockers(scope) } };
+}
+function parseBlockers(scope) {
+  const match = scope.match(/BLOCKERS:([\s\S]*)/i);
+  if (match?.[1] === void 0) return [];
+  return match[1].split("\n").map((entry) => entry.trim()).filter((entry) => /^[-*]\s+/.test(entry)).map((entry) => entry.replace(/^[-*]\s+/, "").trim()).filter((entry) => entry !== "" && !/^(none|nenhum|n\/a)\.?$/i.test(entry));
+}
+var REPORT_SECTIONS = [
+  "Executive summary",
+  "Strengths",
+  "Issues found",
+  "Suggested improvements",
+  "Architectural observations",
+  "Risks identified",
+  "Required before merge",
+  "Final recommendation"
+];
+var SECTION_ALIASES = {
+  "Executive summary": ["executive summary", "summary", "overview", "resumo executivo", "resumo"],
+  Strengths: ["strengths", "positives", "highlights", "what went well", "pontos positivos"],
+  "Issues found": ["issues found", "issues", "problems", "findings", "problemas encontrados"],
+  "Suggested improvements": [
+    "suggested improvements",
+    "suggestions",
+    "improvements",
+    "sugestoes de melhoria",
+    "sugestoes"
+  ],
+  "Architectural observations": [
+    "architectural observations",
+    "architecture",
+    "architectural notes",
+    "observacoes arquiteturais",
+    "arquitetura"
+  ],
+  "Risks identified": ["risks identified", "risks", "riscos identificados", "riscos"],
+  "Required before merge": [
+    "required before merge",
+    "blockers",
+    "must fix before merge",
+    "itens obrigatorios antes do merge"
+  ],
+  "Final recommendation": [
+    "final recommendation",
+    "recommendation",
+    "verdict",
+    "recomendacao final",
+    "recomendacao"
+  ]
+};
+function normalizeHeading(heading) {
+  return heading.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/^\d+[.)]\s*/, "").replace(/[*_`#]/g, "").replace(/[.:;!?]+$/, "").replace(/\s+/g, " ").trim();
+}
+function matchSection(heading) {
+  const normalized = normalizeHeading(heading);
+  for (const section of REPORT_SECTIONS) {
+    if (SECTION_ALIASES[section].includes(normalized)) return section;
+  }
+  return null;
+}
+function splitBody(body) {
+  const sections = /* @__PURE__ */ new Map();
+  const extra = [];
+  let current = null;
+  let buffer = [];
+  const flush = () => {
+    const content = buffer.join("\n").trim();
+    buffer = [];
+    if (content === "") return;
+    if (current === null) {
+      extra.push(content);
+      return;
+    }
+    const previous = sections.get(current);
+    sections.set(current, previous === void 0 ? content : `${previous}
+
+${content}`);
+  };
+  for (const line of body.split("\n")) {
+    const heading = line.match(/^#{1,6}\s+(.*)$/);
+    if (heading?.[1] === void 0) {
+      buffer.push(line);
+      continue;
+    }
+    flush();
+    const section = matchSection(heading[1]);
+    current = section;
+    if (section === null) {
+      buffer.push(line);
+    }
+  }
+  flush();
+  return { sections, extra: extra.join("\n\n").trim() };
+}
+var FINDING_LINE = /^[-*]\s*\[(\w+)\]\s+(.+)$/;
+var FINDING_LOCATION = /^(\S+?)(?::(\d+))?\s+[—–-]\s+(.+)$/;
+var SEVERITY_ALIASES = {
+  blocker: "blocker",
+  blocking: "blocker",
+  critical: "blocker",
+  high: "high",
+  major: "high",
+  medium: "medium",
+  moderate: "medium",
+  low: "low",
+  minor: "low",
+  nit: "low"
+};
+function parseFindings(body) {
+  const { sections } = splitBody(body);
+  const scopes = [sections.get("Issues found"), sections.get("Required before merge")];
+  const findings = [];
+  for (const scope of scopes) {
+    if (scope === void 0) continue;
+    for (const line of scope.split("\n")) {
+      const item = line.trim().match(FINDING_LINE);
+      if (item?.[1] === void 0 || item[2] === void 0) continue;
+      const severity = SEVERITY_ALIASES[item[1].toLowerCase()];
+      if (severity === void 0) continue;
+      const rest = item[2].trim();
+      const location = rest.match(FINDING_LOCATION);
+      if (location?.[1] === void 0 || location[3] === void 0) {
+        findings.push({ severity, file: null, line: null, title: rest });
+        continue;
+      }
+      findings.push({
+        severity,
+        file: location[1],
+        line: location[2] === void 0 ? null : Number(location[2]),
+        title: location[3].trim()
+      });
+    }
+  }
+  return dedupeFindings(findings);
+}
+function dedupeFindings(findings) {
+  const seen = /* @__PURE__ */ new Set();
+  return findings.filter((finding) => {
+    const key = `${finding.file ?? ""}:${finding.line ?? ""}:${finding.title}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function buildReportMarkdown(input) {
+  const pr = input.pullRequest;
+  const parts = [`# Pull Request Review \u2014 #${pr.number} (round ${input.round})`, ""];
+  const heading = pr.url === null ? `#${pr.number}` : `[#${pr.number}](${pr.url})`;
+  parts.push(`- **Pull Request:** ${heading}${pr.title === null ? "" : ` \u2014 ${pr.title}`}`);
+  if (pr.headBranch !== null) parts.push(`- **Head branch:** ${pr.headBranch}`);
+  if (input.headSha != null) parts.push(`- **Head SHA:** ${input.headSha}`);
+  parts.push(`- **Round:** ${input.round}`);
+  parts.push(`- **Reviewed at:** ${input.at}`);
+  parts.push(`- **Recommendation:** ${input.recommendation ?? "UNPARSED"}`);
+  parts.push("");
+  if (input.parseError != null && input.parseError !== "") {
+    parts.push(`> Verdict could not be parsed: ${input.parseError}`, "");
+  }
+  const { sections, extra } = splitBody(input.body);
+  for (const section of REPORT_SECTIONS) {
+    parts.push(`## ${section}`, "", sections.get(section) ?? "_Not reported._", "");
+  }
+  if (input.parseError != null && input.parseError !== "") {
+    parts.push("## Raw agent output", "", "```text", input.body.trim(), "```", "");
+  } else if (extra !== "") {
+    parts.push("## Additional notes", "", extra, "");
+  }
+  return `${parts.join("\n").trimEnd()}
+`;
+}
+async function prReviewDir(opts) {
+  const slug = opts.issue === void 0 || opts.issue === "" ? `pr-${opts.pullRequest}` : opts.issue.replace(/^#/, "");
+  return join2(await getIssueDir(slug), "pr-review");
+}
+function reportFileName(pullRequest, round) {
+  return `pr-${pullRequest}-round-${round}.md`;
+}
+var REPORT_FILE = /^pr-(\d+)-round-(\d+)\.md$/;
+async function readPrReviewIndex(dir) {
+  try {
+    const parsed = JSON.parse(await readFile(join2(dir, "index.json"), "utf-8"));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const index = parsed;
+    if (!Array.isArray(index.rounds) || typeof index.pullRequest !== "object") return null;
+    return {
+      schemaVersion: 1,
+      pullRequest: index.pullRequest,
+      rounds: index.rounds
+    };
+  } catch {
+    return null;
+  }
+}
+async function roundsOnDisk(dir, pullRequest) {
+  try {
+    return (await readdir(dir)).map((name) => name.match(REPORT_FILE)).filter((match) => match !== null).filter((match) => Number(match[1]) === pullRequest).map((match) => Number(match[2]));
+  } catch {
+    return [];
+  }
+}
+async function resolveRound(dir, pullRequest, explicit) {
+  if (explicit !== void 0) return explicit;
+  const index = await readPrReviewIndex(dir);
+  const known = [
+    ...(index?.rounds ?? []).map((entry) => entry.round),
+    ...await roundsOnDisk(dir, pullRequest)
+  ];
+  return known.length === 0 ? 1 : Math.max(...known) + 1;
+}
+function upsertRound(index, entry) {
+  const rounds = index.rounds.filter((existing) => existing.round !== entry.round);
+  rounds.push(entry);
+  rounds.sort((a, b) => a.round - b.round);
+  return { ...index, rounds };
+}
+
+// src/core/pr-review/publisher.ts
+var LocalReportPublisher = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  async publish(report) {
+    await mkdir(this.dir, { recursive: true });
+    const fileName = reportFileName(report.pullRequest.number, report.round);
+    await writeFileAtomic(join3(this.dir, fileName), report.markdown);
+    const existing = await readPrReviewIndex(this.dir);
+    const index = {
+      schemaVersion: 1,
+      pullRequest: report.pullRequest,
+      rounds: existing?.rounds ?? []
+    };
+    const updated = upsertRound(index, {
+      round: report.round,
+      at: report.at,
+      recommendation: report.recommendation,
+      headSha: report.headSha,
+      reportPath: fileName,
+      findings: report.findings
+    });
+    await writeFileAtomic(join3(this.dir, "index.json"), `${JSON.stringify(updated, null, 2)}
+`);
+  }
+};
+var PUBLISHERS = {
+  local: (dir) => new LocalReportPublisher(dir)
+};
+function createPrReviewPublisher(dir, kind = "local") {
+  return PUBLISHERS[kind](dir);
+}
+
+// src/commands/pr-review.ts
+var FAIL_ON_LEVELS = ["request-changes", "suggestions", "none"];
+var DEFAULT_FAIL_ON = "request-changes";
+var NO_ISSUE = "none";
+var NO_PATH = "(none)";
+function exitCodeFor(recommendation, failOn) {
+  if (failOn === "none") {
+    return 0;
+  }
+  if (recommendation === "REQUEST_CHANGES") {
+    return 2;
+  }
+  return failOn === "suggestions" && recommendation === "APPROVE_WITH_SUGGESTIONS" ? 2 : 0;
+}
+function parseFailOn(value) {
+  if (value === void 0 || value === "") {
+    return DEFAULT_FAIL_ON;
+  }
+  const normalized = value.trim().toLowerCase();
+  return FAIL_ON_LEVELS.find((level) => level === normalized) ?? null;
+}
+async function fetchPullRequestMetadata(number) {
+  try {
+    const result = await run("gh", [
+      "pr",
+      "view",
+      String(number),
+      "--json",
+      "title,url,headRefName,headRefOid"
+    ]);
+    if (result.exitCode !== 0) {
+      return null;
+    }
+    const parsed = JSON.parse(result.stdout);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function mergePullRequest(target, meta) {
+  return {
+    number: target.number,
+    url: target.url ?? meta?.url ?? null,
+    title: target.title ?? meta?.title ?? null,
+    headBranch: target.headBranch ?? meta?.headRefName ?? null
+  };
+}
+async function persistState(input) {
+  try {
+    const plan = await loadTaskPlan(input.tasksPath);
+    plan.pipeline.prReviewCompleted = input.recommendation === "APPROVE" || input.recommendation === "APPROVE_WITH_SUGGESTIONS";
+    plan.prReview = {
+      // Preserved, never turned on here: opting the pipeline in is `run
+      // --pr-review`'s decision, not a side effect of a manual review.
+      enabled: plan.prReview?.enabled ?? false,
+      pullRequestNumber: input.pullRequestNumber,
+      // `--round <n>` rewrites an earlier round, which must not shrink the count.
+      rounds: Math.max(plan.prReview?.rounds ?? 0, input.round),
+      lastRecommendation: input.recommendation ?? plan.prReview?.lastRecommendation,
+      lastReviewedAt: input.at
+    };
+    await saveTaskPlan(input.tasksPath, plan);
+  } catch {
+  }
+}
+async function runPrReview(prArg, opts = {}) {
+  const failOn = parseFailOn(opts.failOn);
+  if (failOn === null) {
+    printError(`Invalid --fail-on value '${opts.failOn}'. Expected ${FAIL_ON_LEVELS.join(", ")}.`);
+    return 1;
+  }
+  const explicitRound = opts.round === void 0 ? void 0 : Number(opts.round);
+  if (explicitRound !== void 0 && (!Number.isInteger(explicitRound) || explicitRound < 1)) {
+    printError(`Invalid --round value '${opts.round}'. Expected a positive integer.`);
+    return 1;
+  }
+  const issueRef = opts.issue?.replace(/^#/, "").trim();
+  const issue = issueRef === void 0 || issueRef === "" ? void 0 : issueRef;
+  let target;
+  try {
+    target = await resolvePullRequest(prArg, { issue, yes: opts.yes });
+  } catch (err) {
+    if (err instanceof PrDiscoveryError) {
+      printError(err.message);
+      return err.exitCode;
+    }
+    printError(
+      `Could not determine which Pull Request to review: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return 1;
+  }
+  const issueDir = issue === void 0 ? null : await getIssueDir(issue);
+  const tasksPath = issueDir === null ? null : join4(issueDir, "tasks.json");
+  const prdPath = issueDir === null ? null : join4(issueDir, "prd.md");
+  const dir = await prReviewDir({ issue, pullRequest: target.number });
+  const round = await resolveRound(dir, target.number, explicitRound);
+  const reportPath = join4(dir, reportFileName(target.number, round));
+  const template = await loadPrompt("pr-review");
+  const prompt = applyPlaceholders(template, {
+    __PR_NUMBER__: String(target.number),
+    __ISSUE_NUMBER__: issue ?? NO_ISSUE,
+    __TASKS_PATH__: tasksPath ?? NO_PATH,
+    __PRD_PATH__: prdPath ?? NO_PATH,
+    __REPORT_PATH__: reportPath,
+    __ROUND__: String(round)
+  });
+  const result = await runHeadless({
+    prompt,
+    maxTurns: 40,
+    timeout: getGlobalTimeout() ?? 9e5,
+    outputFormat: "text",
+    allowedTools: ["Bash", "Read", "Glob", "Grep"],
+    statusMessage: `Reviewing Pull Request #${target.number} (round ${round})...`
+  });
+  if (!result.success) {
+    printError(`PR review failed: ${result.error}`);
+    return 1;
+  }
+  const parsed = parsePrReviewResult(result.result);
+  const recommendation = parsed.ok ? parsed.result.recommendation : null;
+  const blockers = parsed.ok ? parsed.result.blockers : [];
+  const meta = await fetchPullRequestMetadata(target.number);
+  const pullRequest = mergePullRequest(target, meta);
+  const at = isoNow();
+  const headSha = meta?.headRefOid ?? null;
+  const report = {
+    pullRequest,
+    round,
+    at,
+    headSha,
+    recommendation,
+    blockers,
+    findings: parseFindings(result.result),
+    markdown: buildReportMarkdown({
+      pullRequest,
+      round,
+      at,
+      headSha,
+      recommendation,
+      body: result.result,
+      parseError: parsed.ok ? null : parsed.error
+    })
+  };
+  const publisher = opts.publisher ?? createPrReviewPublisher(dir, (await loadPrReviewConfig()).publisher);
+  try {
+    await publisher.publish(report);
+  } catch (err) {
+    printError(
+      `Could not publish the review report: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return 1;
+  }
+  if (tasksPath !== null) {
+    await persistState({
+      tasksPath,
+      pullRequestNumber: target.number,
+      round,
+      recommendation,
+      at
+    });
+  }
+  printInfo(`Report: ${reportPath}`);
+  if (!parsed.ok || recommendation === null) {
+    printError(`PR review could not be parsed: ${parsed.ok ? "no recommendation" : parsed.error}`);
+    return 1;
+  }
+  if (recommendation === "REQUEST_CHANGES") {
+    printError(`PR review #${target.number}: REQUEST_CHANGES`);
+    for (const blocker of blockers) {
+      console.log(`  - ${blocker}`);
+    }
+    return exitCodeFor(recommendation, failOn);
+  }
+  printSuccess(
+    recommendation === "APPROVE" ? `PR review #${target.number}: APPROVE` : `PR review #${target.number}: APPROVE_WITH_SUGGESTIONS \u2014 no blockers, improvements suggested`
+  );
+  return exitCodeFor(recommendation, failOn);
+}
+
+export {
+  mostRecent,
+  prReviewDir,
+  readPrReviewIndex,
+  exitCodeFor,
+  runPrReview
+};
+//# sourceMappingURL=chunk-EWMSQQL2.js.map