@pourkit/cli 0.0.0-next-20260529095319

package/dist/issues/close-issues-on-merge.js

@@ -0,0 +1,842 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../common/logger/src/index.ts
+import { createWriteStream } from "fs";
+import { mkdirSync } from "fs";
+import path from "path";
+import { styleText } from "util";
+function createLogger(name, filePath) {
+  let fileStream;
+  if (filePath) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    fileStream = createWriteStream(filePath, { flags: "a" });
+  }
+  const write = (terminal, plain = terminal) => {
+    process.stdout.write(`${terminal}
+`);
+    if (fileStream) {
+      fileStream.write(`${plain}
+`);
+    }
+  };
+  return {
+    line(msg) {
+      const ts = timestamp();
+      write(`${ts.terminal} ${msg}`, `${ts.plain} ${msg}`);
+    },
+    raw(msg) {
+      write(msg);
+    },
+    step(step, msg) {
+      const ts = timestamp();
+      write(
+        `${ts.terminal} ${formatStep(step)} ${formatStepMessage(step, msg)}`,
+        `${ts.plain} [${step}] ${msg}`
+      );
+    },
+    status(status) {
+      const ts = timestamp();
+      write(
+        `${ts.terminal} ${color(["bold", "cyan"], "POURKIT")} ${color("cyan", status)}`,
+        `${ts.plain} POURKIT ${status}`
+      );
+    },
+    kv(key, value) {
+      const ts = timestamp();
+      write(
+        `${ts.terminal} ${color("dim", key)}=${formatValue(key, value)}`,
+        `${ts.plain} ${key}=${value}`
+      );
+    },
+    async close() {
+      await new Promise((resolve) => {
+        if (!fileStream) {
+          resolve();
+          return;
+        }
+        const timer = setTimeout(() => {
+          if (!fileStream.destroyed) {
+            fileStream.destroy();
+          }
+          resolve();
+        }, 2e3);
+        fileStream.end(() => {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+    }
+  };
+}
+function timestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const time = now.toTimeString().slice(0, 8);
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  const plain = `${time}.${ms}`;
+  return { terminal: color("dim", plain), plain };
+}
+function formatStep(step) {
+  return color(stepStyle(step), `[${step}]`);
+}
+function formatStepMessage(step, msg) {
+  if (step === "error") {
+    return color("red", msg);
+  }
+  if (step === "warn") {
+    return color("yellow", msg);
+  }
+  return msg;
+}
+function formatValue(key, value) {
+  if (/SUCCESS|CREATED|COMMITS/.test(key)) {
+    return color("green", value);
+  }
+  if (/BRANCH|PATH|FILE|URL/.test(key)) {
+    return color("cyan", value);
+  }
+  return color("bold", value);
+}
+function stepStyle(step) {
+  switch (step) {
+    case "sandcastle":
+      return ["bold", "cyan"];
+    case "git":
+      return ["bold", "magenta"];
+    case "review":
+    case "reviewer":
+      return ["bold", "blue"];
+    case "cleanup":
+      return ["bold", "yellow"];
+    case "error":
+      return ["bold", "red"];
+    case "warn":
+      return ["bold", "yellow"];
+    case "info":
+      return "cyan";
+    default:
+      return "green";
+  }
+}
+function color(format, text) {
+  if (process.env.NO_COLOR) {
+    return text;
+  }
+  try {
+    return styleText(format, text);
+  } catch {
+    return text;
+  }
+}
+var init_src = __esm({
+  "../common/logger/src/index.ts"() {
+    "use strict";
+  }
+});
+
+// shared/common.ts
+var common_exports = {};
+__export(common_exports, {
+  TYPE_LABELS: () => TYPE_LABELS,
+  createLogger: () => createLogger,
+  ensureDir: () => ensureDir,
+  execCapture: () => execCapture,
+  execCaptureWithRetry: () => execCaptureWithRetry,
+  execJson: () => execJson,
+  execJsonWithRetry: () => execJsonWithRetry,
+  parseWorktreeListPorcelain: () => parseWorktreeListPorcelain,
+  readMaybeEnvInt: () => readMaybeEnvInt,
+  repoRelative: () => repoRelative,
+  repoRoot: () => repoRoot,
+  sleep: () => sleep,
+  slugify: () => slugify
+});
+import { mkdir } from "fs/promises";
+import path2 from "path";
+import { execFile, spawnSync } from "child_process";
+import { promisify } from "util";
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+function repoRoot(explicitRoot = process.env.POURKIT_ROOT) {
+  if (explicitRoot?.trim()) {
+    const root = explicitRoot.trim();
+    const insideResult = spawnSync(
+      "git",
+      ["-C", root, "rev-parse", "--is-inside-work-tree"],
+      { encoding: "utf8" }
+    );
+    if (insideResult.status !== 0 || insideResult.stdout.trim() !== "true") {
+      throw new Error(
+        `POURKIT_ROOT is not a valid Git worktree: ${root}
+${insideResult.stderr || insideResult.stdout}`
+      );
+    }
+    const topLevelResult = spawnSync(
+      "git",
+      ["-C", root, "rev-parse", "--show-toplevel"],
+      { encoding: "utf8" }
+    );
+    if (topLevelResult.status !== 0) {
+      throw new Error(
+        `Failed to validate POURKIT_ROOT as a Git worktree: ${root}
+${topLevelResult.stderr || topLevelResult.stdout}`
+      );
+    }
+    return topLevelResult.stdout.trim();
+  }
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    throw new Error(
+      `Failed to resolve repo root: ${result.stderr || result.stdout}`
+    );
+  }
+  return result.stdout.trim();
+}
+function repoRelative(root, ...segments) {
+  return path2.join(root, ...segments);
+}
+function slugify(value) {
+  const slug = value.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 50);
+  return slug || "issue";
+}
+function formatCommand(command, args) {
+  return [command, ...args].map((part) => {
+    if (/^[A-Za-z0-9_\/.=:,@+-]+$/.test(part)) {
+      return part;
+    }
+    return `'${part.replace(/'/g, "'\\''")}'`;
+  }).join(" ");
+}
+function readMaybeEnvInt(value, fallback) {
+  const parsed = Number(value ?? fallback);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+async function execCapture(command, args, options = {}) {
+  if (options.logger && options.label) {
+    options.logger.step(
+      options.label,
+      `running ${formatCommand(command, args)}`
+    );
+  }
+  let stdout = "";
+  let stderr = "";
+  let code = 0;
+  try {
+    const result = await execFileAsync(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      encoding: "utf8",
+      maxBuffer: 20 * 1024 * 1024
+    });
+    stdout = typeof result.stdout === "string" ? result.stdout : String(result.stdout ?? "");
+    stderr = typeof result.stderr === "string" ? result.stderr : String(result.stderr ?? "");
+  } catch (error) {
+    const err = error;
+    stdout = typeof err.stdout === "string" ? err.stdout : "";
+    stderr = typeof err.stderr === "string" ? err.stderr : "";
+    code = typeof err.code === "number" ? err.code : 1;
+  }
+  if (code !== 0) {
+    throw new Error(
+      [
+        `command failed: ${formatCommand(command, args)}`,
+        `exit code: ${code}`,
+        stdout ? `stdout:
+${stdout}` : "",
+        stderr ? `stderr:
+${stderr}` : ""
+      ].filter(Boolean).join("\n")
+    );
+  }
+  return { code, stdout, stderr };
+}
+async function execJson(command, args, options = {}) {
+  const result = await execCapture(command, args, options);
+  return JSON.parse(result.stdout);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function execCaptureWithRetry(command, args, options = {}) {
+  const retries = options.retries ?? 3;
+  const backoffMs = options.backoffMs ?? 2e3;
+  let lastError = null;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return await execCapture(command, args, options);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (!TRANSIENT_GH_ERROR.test(lastError.message)) {
+        throw lastError;
+      }
+      if (options.logger) {
+        options.logger.step(
+          options.label ?? command,
+          `transient failure (attempt ${attempt}/${retries}), retrying`
+        );
+      }
+      if (attempt < retries) {
+        await sleep(backoffMs * Math.pow(2, attempt - 1));
+      }
+    }
+  }
+  throw lastError;
+}
+async function execJsonWithRetry(command, args, options = {}) {
+  const result = await execCaptureWithRetry(command, args, options);
+  return JSON.parse(result.stdout);
+}
+function parseWorktreeListPorcelain(text, branch) {
+  const entries = text.trim().split("\n\n");
+  for (const entry of entries) {
+    const lines = entry.trim().split("\n");
+    let path3 = "";
+    let entryBranch = "";
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        path3 = line.slice("worktree ".length);
+      } else if (line.startsWith("branch refs/heads/")) {
+        entryBranch = line.slice("branch refs/heads/".length);
+      }
+    }
+    if (entryBranch === branch && path3) {
+      return path3;
+    }
+  }
+  return null;
+}
+var execFileAsync, TRANSIENT_GH_ERROR, TYPE_LABELS;
+var init_common = __esm({
+  "shared/common.ts"() {
+    "use strict";
+    init_src();
+    execFileAsync = promisify(execFile);
+    TRANSIENT_GH_ERROR = /HTTP (502|503|504)\b|Could not close the issue|GraphQL:.*closeIssue/;
+    TYPE_LABELS = [
+      "type:bugfix",
+      "type:infra",
+      "type:feature",
+      "type:polish",
+      "type:refactor"
+    ];
+  }
+});
+
+// issues/close-issues-on-merge.ts
+init_common();
+init_common();
+import { fileURLToPath } from "url";
+
+// providers/github-client.ts
+import { Octokit } from "octokit";
+var REMOTE_PATTERN = /github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/;
+function resolveGitHubToken(env) {
+  const token = env.POURKIT_GITHUB_TOKEN ?? env.GH_TOKEN ?? env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error(
+      "GitHub token is required. Set POURKIT_GITHUB_TOKEN, GH_TOKEN, or GITHUB_TOKEN."
+    );
+  }
+  return token;
+}
+async function resolveGitHubRepository(options) {
+  if (options?.repository) {
+    const parts = options.repository.split("/");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw new Error(
+        `Invalid repository format: "${options.repository}". Expected "owner/repo".`
+      );
+    }
+    return { owner: parts[0], repo: parts[1] };
+  }
+  const env = options?.env ?? process.env;
+  const envRepo = env.GITHUB_REPOSITORY;
+  if (envRepo) {
+    const parts = envRepo.split("/");
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      return { owner: parts[0], repo: parts[1] };
+    }
+    throw new Error(
+      `Invalid repository format: "${envRepo}". Expected "owner/repo".`
+    );
+  }
+  const { execCapture: execCapture2 } = await Promise.resolve().then(() => (init_common(), common_exports));
+  const cwd = options?.cwd;
+  try {
+    const result = await execCapture2("git", ["remote", "get-url", "origin"], {
+      cwd
+    });
+    const remote = result.stdout.trim();
+    const match = remote.match(REMOTE_PATTERN);
+    if (match) {
+      return { owner: match[1], repo: match[2] };
+    }
+  } catch {
+  }
+  throw new Error(
+    "Could not resolve GitHub repository. Set GITHUB_REPOSITORY env var or ensure a valid 'origin' remote exists."
+  );
+}
+async function requireGitHubClient(options) {
+  const env = options?.env ?? process.env;
+  const token = resolveGitHubToken(env);
+  const repo = await resolveGitHubRepository(options);
+  const octokit = new Octokit({ auth: token });
+  return { octokit, ...repo };
+}
+
+// issues/blocked-issue.ts
+function parseBlockedBy(body) {
+  if (!body) return [];
+  const bm = body.match(/## Blocked by\s*\n([\s\S]*?)(?=\n## |$)/i);
+  if (!bm) return [];
+  const refs = [];
+  const re = /#(\d+)/g;
+  let m;
+  while ((m = re.exec(bm[1])) !== null) {
+    refs.push(Number(m[1]));
+  }
+  return refs;
+}
+async function reconcileBlockedIssue(issue, deps) {
+  const blockers = parseBlockedBy(issue.body);
+  if (blockers.length === 0) {
+    await deps.transitions.moveToNeedsTriage(issue.number);
+    return "needs-triage";
+  }
+  const stillBlocked = await anyBlockerStillOpen(blockers, deps.getIssueState);
+  if (stillBlocked) {
+    return "still-blocked";
+  }
+  const labels = issue.labels ?? [];
+  const typeLabels = labels.filter((l) => deps.typeLabels.includes(l.name));
+  if (typeLabels.length === 1) {
+    await deps.transitions.removeBlocked(issue.number);
+    const alreadyReady = labels.some((l) => l.name === deps.readyLabel);
+    if (!alreadyReady) {
+      await deps.transitions.addReadyForAgent(issue.number);
+    }
+    return "unblocked";
+  }
+  await deps.transitions.moveToNeedsTriage(issue.number);
+  return "needs-triage";
+}
+async function reconcileBlockedIssues(issues, deps) {
+  const results = [];
+  for (const issue of issues) {
+    const result = await reconcileBlockedIssue(issue, deps);
+    results.push({ issueNumber: issue.number, result });
+  }
+  return results;
+}
+async function anyBlockerStillOpen(refs, getIssueState) {
+  for (const ref of refs) {
+    const state = await getIssueState(ref);
+    if (state !== "CLOSED") {
+      return true;
+    }
+  }
+  return false;
+}
+
+// issues/issue-transitions.ts
+function createIssueTransitions(deps, labels) {
+  return {
+    async removeBlocked(issueNumber) {
+      await deps.removeLabel(issueNumber, labels.blocked);
+    },
+    async addReadyForAgent(issueNumber) {
+      const issue = await deps.fetchIssue(issueNumber);
+      if (!issue.labels.includes(labels.readyForAgent)) {
+        await deps.addLabels(issueNumber, [labels.readyForAgent]);
+      }
+    },
+    async moveToNeedsTriage(issueNumber) {
+      if (deps.updateLabels) {
+        await deps.updateLabels(
+          issueNumber,
+          [labels.blocked, labels.readyForAgent],
+          [labels.needsTriage]
+        );
+      } else {
+        await deps.removeLabel(issueNumber, labels.blocked);
+        const issue = await deps.fetchIssue(issueNumber);
+        if (issue.labels.includes(labels.readyForAgent)) {
+          await deps.removeLabel(issueNumber, labels.readyForAgent);
+        }
+        await deps.addLabels(issueNumber, [labels.needsTriage]);
+      }
+    },
+    async moveToReadyForHuman(issueNumber) {
+      try {
+        await deps.removeLabel(issueNumber, labels.agentInProgress);
+      } catch {
+      }
+      try {
+        await deps.removeLabel(issueNumber, labels.readyForAgent);
+      } catch {
+      }
+      await deps.addLabels(issueNumber, [labels.readyForHuman]);
+    },
+    async closeCompleted(issueNumber) {
+      try {
+        await deps.removeLabel(issueNumber, labels.agentInProgress);
+      } catch {
+      }
+      try {
+        await deps.removeLabel(issueNumber, labels.prOpenAwaitingMerge);
+      } catch {
+      }
+      if (!deps.closeIssue) {
+        throw new Error("closeIssue is required for closeCompleted");
+      }
+      await deps.closeIssue(issueNumber);
+    }
+  };
+}
+
+// issues/close-issues-on-merge.ts
+var ROOT = repoRoot();
+process.chdir(ROOT);
+var LOG_DIR = repoRelative(ROOT, "pourkit", "logs");
+var RUN_ID = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+var LOG_PATH = repoRelative(
+  ROOT,
+  "pourkit",
+  "logs",
+  `close-issues-on-merge-${RUN_ID}.log`
+);
+var logger = createLogger("close-issues-on-merge", LOG_PATH);
+var __filename = fileURLToPath(import.meta.url);
+async function main() {
+  try {
+    await ensureDir(LOG_DIR);
+    logger.status("starting");
+    const client = await requireGitHubClient();
+    const context = readContext(client);
+    logger.kv("POURKIT_PR_NUMBER", String(context.prNumber));
+    logger.kv("POURKIT_PR_TITLE", context.prTitle);
+    await closeIssuesOnMerge(context);
+    logger.status("completed");
+  } catch (error) {
+    logger.status("failed");
+    logger.line(
+      error instanceof Error ? error.stack ?? error.message : String(error)
+    );
+    process.exitCode = 1;
+  } finally {
+    await logger.close();
+  }
+}
+async function closeIssuesOnMerge(context) {
+  const issueNumbers = parseClosingIssueNumbers(context.prBody);
+  if (issueNumbers.length === 0) {
+    logger.step(
+      "skip",
+      "No issues referenced with closing keywords. Skipping."
+    );
+    return;
+  }
+  logger.kv("closing_issue_count", String(issueNumbers.length));
+  for (const issueNumber of issueNumbers) {
+    try {
+      await processIssue(context, issueNumber);
+    } catch (error) {
+      logger.step(
+        "error",
+        `Error processing issue #${issueNumber}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+async function processIssue(context, issueNumber) {
+  const issue = await getIssue(context, issueNumber);
+  if (issue.pull_request) {
+    logger.step(
+      "skip",
+      `#${issueNumber} is a pull request, not an issue. Skipping.`
+    );
+    return;
+  }
+  if (issue.state === "open") {
+    await commentOnClosedIssue(context, issueNumber);
+    await closeIssue(context, issueNumber);
+    logger.step("close", `Closed issue #${issueNumber}`);
+  } else {
+    logger.step("skip", `Issue #${issueNumber} is already closed.`);
+  }
+  const blockedIssues = await listIssuesBlockedBy(context, issueNumber);
+  if (blockedIssues.length === 0) {
+    logger.step(
+      "skip",
+      `Issue #${issueNumber} was not blocking any other issues.`
+    );
+    return;
+  }
+  logger.step(
+    "unblock",
+    `Issue #${issueNumber} was blocking ${blockedIssues.length} issue(s).`
+  );
+  const getIssueState = async (blockedIssueNumber) => {
+    const { data } = await context.client.octokit.rest.issues.get({
+      owner: context.client.owner,
+      repo: context.client.repo,
+      issue_number: blockedIssueNumber
+    });
+    return data.state.toUpperCase();
+  };
+  const transitionDeps = {
+    fetchIssue: async (issueNumber2) => {
+      const { data } = await context.client.octokit.rest.issues.get({
+        owner: context.client.owner,
+        repo: context.client.repo,
+        issue_number: issueNumber2
+      });
+      return {
+        labels: data.labels.map(
+          (l) => typeof l === "string" ? l : l.name ?? ""
+        )
+      };
+    },
+    addLabels: async (issueNumber2, labels) => {
+      await withRetryOnTransient(
+        () => context.client.octokit.rest.issues.addLabels({
+          owner: context.client.owner,
+          repo: context.client.repo,
+          issue_number: issueNumber2,
+          labels
+        })
+      );
+    },
+    removeLabel: async (issueNumber2, label) => {
+      try {
+        await withRetryOnTransient(
+          () => context.client.octokit.rest.issues.removeLabel({
+            owner: context.client.owner,
+            repo: context.client.repo,
+            issue_number: issueNumber2,
+            name: label
+          })
+        );
+      } catch (error) {
+        if (typeof error === "object" && error !== null && "status" in error && error.status === 404) {
+        } else {
+          throw error;
+        }
+      }
+    },
+    updateLabels: async (issueNumber2, removes, adds) => {
+      for (const label of removes) {
+        try {
+          await withRetryOnTransient(
+            () => context.client.octokit.rest.issues.removeLabel({
+              owner: context.client.owner,
+              repo: context.client.repo,
+              issue_number: issueNumber2,
+              name: label
+            })
+          );
+        } catch (error) {
+          if (typeof error === "object" && error !== null && "status" in error && error.status === 404) {
+          } else {
+            throw error;
+          }
+        }
+      }
+      if (adds.length > 0) {
+        await withRetryOnTransient(
+          () => context.client.octokit.rest.issues.addLabels({
+            owner: context.client.owner,
+            repo: context.client.repo,
+            issue_number: issueNumber2,
+            labels: adds
+          })
+        );
+      }
+    }
+  };
+  const transitions = createIssueTransitions(transitionDeps, {
+    blocked: "blocked",
+    readyForAgent: "ready-for-agent",
+    needsTriage: "needs-triage",
+    agentInProgress: "agent-in-progress",
+    readyForHuman: "ready-for-human",
+    prOpenAwaitingMerge: "pr-open-awaiting-merge"
+  });
+  for (const blockedIssue of blockedIssues) {
+    try {
+      const [reconcileEntry] = await reconcileBlockedIssues([blockedIssue], {
+        getIssueState,
+        transitions,
+        typeLabels: TYPE_LABELS,
+        readyLabel: "ready-for-agent"
+      });
+      if (reconcileEntry.result === "still-blocked") {
+        logger.step(
+          "skip",
+          `Issue #${blockedIssue.number} is still blocked by another issue.`
+        );
+        continue;
+      }
+      try {
+        await commentOnUnblockedIssue(
+          context,
+          blockedIssue.number,
+          issueNumber
+        );
+        logger.step("unblocked", `Unblocked issue #${blockedIssue.number}.`);
+      } catch (error) {
+        logger.step(
+          "error",
+          `Failed to unblock issue #${blockedIssue.number} from #${issueNumber}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    } catch (error) {
+      logger.step(
+        "error",
+        `Failed to check blockers for issue #${blockedIssue.number}.`
+      );
+    }
+  }
+}
+async function getIssue(context, issueNumber) {
+  const { data } = await context.client.octokit.rest.issues.get({
+    owner: context.client.owner,
+    repo: context.client.repo,
+    issue_number: issueNumber
+  });
+  return {
+    number: data.number,
+    id: data.id,
+    state: data.state,
+    pull_request: data.pull_request,
+    title: data.title,
+    body: data.body ?? null
+  };
+}
+async function closeIssue(context, issueNumber) {
+  const maxRetries = 3;
+  const backoffMs = 2e3;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      await context.client.octokit.rest.issues.update({
+        owner: context.client.owner,
+        repo: context.client.repo,
+        issue_number: issueNumber,
+        state: "closed",
+        state_reason: "completed"
+      });
+      return;
+    } catch (error) {
+      const isTransient = error instanceof Error && /HTTP (502|503|504)\b/.test(error.message);
+      const isOctokitTransient = typeof error === "object" && error !== null && "status" in error && (error.status === 502 || error.status === 503 || error.status === 504);
+      if (!isTransient && !isOctokitTransient || attempt === maxRetries) {
+        throw error;
+      }
+      await new Promise(
+        (r) => setTimeout(r, backoffMs * Math.pow(2, attempt - 1))
+      );
+    }
+  }
+}
+async function commentOnClosedIssue(context, issueNumber) {
+  await context.client.octokit.rest.issues.createComment({
+    owner: context.client.owner,
+    repo: context.client.repo,
+    issue_number: issueNumber,
+    body: `Closed automatically because PR #${context.prNumber} (${context.prTitle}) merged into \`next\`.`
+  });
+}
+async function listIssuesBlockedBy(context, blockingIssueNumber) {
+  const { data } = await context.client.octokit.rest.issues.listForRepo({
+    owner: context.client.owner,
+    repo: context.client.repo,
+    state: "open",
+    labels: "blocked",
+    per_page: 100
+  });
+  const allIssues = data.filter((issue) => !issue.pull_request).map((issue) => ({
+    number: issue.number,
+    body: issue.body ?? null,
+    labels: issue.labels.map((l) => ({
+      name: typeof l === "string" ? l : l.name ?? ""
+    }))
+  }));
+  const matching = [];
+  for (const issue of allIssues) {
+    const blockers = parseBlockedBy(issue.body);
+    if (blockers.includes(blockingIssueNumber)) {
+      matching.push({
+        number: issue.number,
+        body: issue.body,
+        labels: issue.labels
+      });
+    }
+  }
+  return matching;
+}
+async function commentOnUnblockedIssue(context, blockedIssueNumber, issueNumber) {
+  await context.client.octokit.rest.issues.createComment({
+    owner: context.client.owner,
+    repo: context.client.repo,
+    issue_number: blockedIssueNumber,
+    body: `Unblocked automatically because #${issueNumber} was closed by PR #${context.prNumber}.`
+  });
+}
+function readContext(client) {
+  const prNumber = Number(process.env.POURKIT_PR_NUMBER);
+  const prTitle = process.env.POURKIT_PR_TITLE?.trim();
+  const prBody = process.env.POURKIT_PR_BODY ?? "";
+  if (!Number.isInteger(prNumber) || prNumber <= 0) {
+    throw new Error("POURKIT_PR_NUMBER is required");
+  }
+  if (!prTitle) {
+    throw new Error("POURKIT_PR_TITLE is required");
+  }
+  return { client, prNumber, prTitle, prBody };
+}
+function parseClosingIssueNumbers(body) {
+  if (!body) return [];
+  const regex = /(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\s*:?\s*#(\d+)/gi;
+  const issueNumbers = /* @__PURE__ */ new Set();
+  let match;
+  while ((match = regex.exec(body)) !== null) {
+    issueNumbers.add(Number.parseInt(match[1], 10));
+  }
+  return [...issueNumbers];
+}
+async function withRetryOnTransient(fn, maxAttempts = 2) {
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const isTransient = error instanceof Error && /HTTP (502|503|504)\b/.test(error.message) || typeof error === "object" && error !== null && "status" in error && (error.status === 502 || error.status === 503 || error.status === 504);
+      if (!isTransient || attempt === maxAttempts) {
+        throw error;
+      }
+      await new Promise((r) => setTimeout(r, 2e3 * Math.pow(2, attempt - 1)));
+    }
+  }
+  throw lastError;
+}
+if (process.argv[1] === __filename) {
+  void main();
+}
+export {
+  main,
+  parseClosingIssueNumbers
+};
+//# sourceMappingURL=close-issues-on-merge.js.map