polyrepo-cli 1.0.0

package/src/commands/switchMaster.js

@@ -0,0 +1,76 @@
+import { confirm } from '@inquirer/prompts'
+import pc from 'picocolors'
+import { discoverRepos, inspectRepos } from '../repos.js'
+import { MASTER_BRANCH } from '../config.js'
+import { loadConfig } from '../loadConfig.js'
+import { syncMaster } from '../masterSync.js'
+import { selectPackages } from '../selectPackages.js'
+import { heading, stepHeading, ok, fail, warn, columnWidths, formatRow } from '../ui.js'
+import { startSpinner } from '../spinner.js'
+
+export async function switchMasterCommand({ configPath, packages, yes = false } = {}) {
+  const config = loadConfig({ configPath })
+  const discovered = discoverRepos(config)
+  if (discovered.length === 0) {
+    console.log(pc.yellow('No repos found.'))
+    return
+  }
+
+  heading(`Switch to ${MASTER_BRANCH}`)
+
+  const spinner = startSpinner(`Checking ${discovered.length} package(s)...`)
+  const repos = await inspectRepos(discovered)
+  spinner.stop()
+
+  const selected = await selectPackages({
+    items: repos,
+    packages,
+    message: 'Pick repos to switch to master and update:',
+    buildChoice: (all) => {
+      const columns = [{ value: (r) => r.dir }]
+      const widths = columnWidths(all, columns)
+      return (r) => ({
+        name:
+          formatRow(r, columns, widths) +
+          pc.dim(`  (currently on: ${r.branch ?? '(detached)'}${r.clean ? '' : ', dirty'})`),
+        value: r,
+        checked: r.branch !== MASTER_BRANCH,
+      })
+    },
+  })
+
+  if (selected.length === 0) {
+    console.log(pc.dim('Nothing selected.'))
+    return
+  }
+
+  if (!yes) {
+    const proceed = await confirm({
+      message: `Switch ${selected.length} repo(s) to ${MASTER_BRANCH} and fast-forward?`,
+      default: true,
+    })
+    if (!proceed) {
+      console.log(pc.dim('Cancelled.'))
+      return
+    }
+  }
+
+  let index = 0
+  for (const repo of selected) {
+    index += 1
+    stepHeading(index, selected.length, repo.dir)
+
+    if (!repo.clean) {
+      warn(`Working tree is dirty — skipping to avoid discarding local changes.`)
+      continue
+    }
+
+    const result = syncMaster(repo)
+    if (!result.ok) {
+      fail(result.message)
+      continue
+    }
+
+    ok(`Now on ${MASTER_BRANCH}, up to date with origin.`)
+  }
+}

package/src/commands/tag.js

@@ -0,0 +1,120 @@
+import { confirm } from '@inquirer/prompts'
+import pc from 'picocolors'
+import { discoverRepos, inspectRepos } from '../repos.js'
+import { loadConfig } from '../loadConfig.js'
+import { syncMaster } from '../masterSync.js'
+import { tagName, tagExists, tagExistsAsync, createAndPushTag } from '../tags.js'
+import { selectPackages } from '../selectPackages.js'
+import { pMap } from '../pMap.js'
+import { heading, stepHeading, ok, fail, columnWidths, formatRow } from '../ui.js'
+import { releaseOne } from './release.js'
+
+// For packages whose version was bumped outside `polyrepo bump` (or before `bump`
+// started tagging), there's no `v<version>` tag yet — `polyrepo release` refuses
+// to touch those. This puts just the tag on the current version, on
+// master's current tip, without touching the version number or opening a
+// PR — no need to bump again just to get a tag. Offers to release
+// right after, since "I just caught this package's tag up" and "I want a
+// release for it" are almost always the same reason to run this.
+export async function tagCommand({ configPath, packages, yes = false, dryRun = false, release = false } = {}) {
+  const config = loadConfig({ configPath })
+  const repos = (await inspectRepos(discoverRepos(config))).filter((r) => r.version)
+  if (repos.length === 0) {
+    console.log(pc.yellow('No repos found.'))
+    return
+  }
+
+  heading('Tag current versions')
+
+  console.log(pc.dim(`Checking ${repos.length} package(s) for an existing tag...`))
+  const withTag = await pMap(repos, async (r) => {
+    const tag = tagName(r.version)
+    const alreadyTagged = await tagExistsAsync(r, tag)
+    console.log(pc.dim(`  ${r.dir}: ${tag} — ${alreadyTagged ? 'already tagged' : 'not tagged yet'}`))
+    return { ...r, tag, alreadyTagged }
+  })
+
+  const selected = await selectPackages({
+    items: withTag,
+    packages,
+    message: 'Pick packages to tag at their current version:',
+    buildChoice: (all) => {
+      const columns = [
+        { value: (r) => r.dir },
+        { value: (r) => r.version, style: (r, t) => pc.dim(t) },
+        { value: (r) => r.tag, style: (r, t) => pc.dim(t) },
+      ]
+      const widths = columnWidths(all, columns)
+      return (r) => ({
+        name: formatRow(r, columns, widths) + (r.alreadyTagged ? pc.dim('  (already tagged)') : ''),
+        value: r,
+        checked: !r.alreadyTagged,
+      })
+    },
+  })
+
+  if (selected.length === 0) {
+    console.log(pc.dim('Nothing selected.'))
+    return
+  }
+
+  if (!yes) {
+    const proceed = await confirm({
+      message: `Tag ${selected.length} package(s) at their current version?${dryRun ? ' (dry run — nothing will actually be pushed)' : ''}`,
+      default: true,
+    })
+    if (!proceed) {
+      console.log(pc.dim('Cancelled.'))
+      return
+    }
+  }
+
+  const ready = []
+  let index = 0
+  for (const repo of selected) {
+    index += 1
+    stepHeading(index, selected.length, `${repo.dir}  ${repo.tag}`)
+
+    const syncResult = syncMaster(repo)
+    if (!syncResult.ok) {
+      fail(syncResult.message)
+      continue
+    }
+    ok('master is up to date.')
+
+    // Re-checked here (not just trusting the table above) in case it
+    // changed between listing and now — same reasoning as bump's
+    // detectBumpState re-check right before acting.
+    if (tagExists(repo, repo.tag)) {
+      ok(`Tag ${repo.tag} already exists on origin.`)
+      ready.push(repo)
+      continue
+    }
+
+    const tagResult = createAndPushTag(repo, repo.tag, { dryRun })
+    if (!tagResult.ok) {
+      fail(tagResult.message)
+      continue
+    }
+    ok(`Tagged and pushed ${repo.tag}.`)
+    if (!dryRun) ready.push(repo)
+  }
+
+  if (dryRun || ready.length === 0) return
+
+  let wantRelease = release
+  if (!wantRelease && !yes) {
+    wantRelease = await confirm({
+      message: `Create a GitHub Release for the ${ready.length} package(s) just tagged?`,
+      default: true,
+    })
+  }
+  if (!wantRelease) return
+
+  let releaseIndex = 0
+  for (const repo of ready) {
+    releaseIndex += 1
+    stepHeading(releaseIndex, ready.length, `${repo.dir}  ${repo.tag}`)
+    releaseOne(repo, repo.tag, { dryRun })
+  }
+}

package/src/config.js

@@ -0,0 +1,5 @@
+export const MASTER_BRANCH = 'master'
+
+export function bumpBranchName(version) {
+  return `${version}-version-bump`
+}

package/src/configFile.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const PROJECT_ROOT = path.join(__dirname, '..')
+export const DEFAULT_CONFIG_PATH = path.join(PROJECT_ROOT, 'polyrepo.config.json')
+
+// Same --config / POLYREPO_CONFIG / default resolution `loadConfig` uses, split
+// out so `polyrepo setup` can find "the file to edit" without also pulling in
+// loadConfig's read-side behavior (POLYREPO_ROOT override, resolving every path
+// to absolute) — setup edits the file's own raw, possibly-relative paths.
+export function resolveConfigFilePath(configPath) {
+  if (configPath) return path.resolve(configPath)
+  if (process.env.POLYREPO_CONFIG) return path.resolve(process.env.POLYREPO_CONFIG)
+  return DEFAULT_CONFIG_PATH
+}
+
+// Raw (possibly relative, exactly as a person typed them) roots/packages —
+// no existence checks, no POLYREPO_ROOT override. Returns an empty config if the
+// file doesn't exist yet, so `polyrepo setup` can start from scratch at a new
+// --config path instead of erroring.
+export function readConfigFile(filePath) {
+  if (!fs.existsSync(filePath)) return { roots: [], packages: [] }
+  const text = fs.readFileSync(filePath, 'utf8')
+  const parsed = JSON.parse(text)
+  return {
+    roots: Array.isArray(parsed.roots) ? parsed.roots : [],
+    packages: Array.isArray(parsed.packages) ? parsed.packages : [],
+  }
+}
+
+export function writeConfigFile(filePath, data) {
+  const text = JSON.stringify({ roots: data.roots, packages: data.packages }, null, 2) + '\n'
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, text)
+}

package/src/crossDeps.js

@@ -0,0 +1,31 @@
+import semver from 'semver'
+import { readPackageDependencies } from './repos.js'
+
+// After bumping a package, other local packages that depend on it (e.g.
+// css-magic-gradient depends on color-value-tools) can be left pointing at
+// a version range that no longer matches — nothing enforces that today, so
+// it's easy to bump one package and forget the ones that reference it.
+// `repos` must already be inspected (name + version populated).
+export function findStaleLocalDeps(repos) {
+  const versionByName = new Map(repos.map((r) => [r.name, r.version]))
+  const issues = []
+
+  for (const repo of repos) {
+    const deps = readPackageDependencies(repo)
+    for (const [depName, range] of Object.entries(deps)) {
+      if (depName === repo.name || !versionByName.has(depName)) continue
+      // Not every dependency value is a semver range — "workspace:*"
+      // (yarn/pnpm workspaces), "file:../x", "link:../y", and "npm:pkg@range"
+      // aliases are all common and none of them are something to compare a
+      // version against. semver.satisfies() doesn't throw for these (it
+      // just quietly returns false), so it can't be used to detect them —
+      // validRange() is the actual check.
+      if (!semver.validRange(range)) continue
+      const localVersion = versionByName.get(depName)
+      if (!semver.satisfies(localVersion, range)) {
+        issues.push({ repo, depName, range, localVersion })
+      }
+    }
+  }
+  return issues
+}

package/src/exec.js

@@ -0,0 +1,132 @@
+import { spawnSync, spawn } from 'node:child_process'
+import pc from 'picocolors'
+
+// Runs a command, always printing what ran and its output so the caller
+// never has to wait for a whole queue to finish before seeing progress —
+// each command reports itself the moment it's done.
+//
+// `mutating: true` marks a command that changes remote/shared state (push,
+// commit, gh pr create/merge) — under --dry-run those are printed but never
+// actually executed, while read-only commands (fetch, checkout, status)
+// still run for real so the printed state stays accurate.
+//
+// `interactive: true` hands the command the real terminal (stdio: 'inherit')
+// instead of capturing it — needed for `npm publish`, which can stop and
+// wait on a real TTY for a 2FA/OTP code. Capturing its output would make
+// that prompt invisible and leave the process hanging forever.
+// On Windows, `npm` (and anything else that resolves to a .cmd/.bat shim
+// instead of a real .exe) can't be spawned directly — CreateProcess doesn't
+// know what to do with a batch file, so spawnSync silently fails to launch
+// it at all (`status` comes back null) unless the shell is involved. `git`
+// and `gh` are real executables and don't need this, but turning it on
+// unconditionally on Windows is the standard fix and is safe here since
+// every arg still goes through spawnSync's own array (each element quoted
+// for the shell), not a hand-built command string.
+const NEEDS_SHELL = process.platform === 'win32'
+
+export function run(cwd, cmd, args, { quiet = false, mutating = false, dryRun = false, interactive = false } = {}) {
+  const prefix = mutating && dryRun ? pc.magenta('  [dry-run] $ ') : pc.dim('  $ ')
+  if (!quiet) console.log(`${prefix}${cmd} ${args.join(' ')}`)
+  if (mutating && dryRun) return { ok: true, stdout: '', stderr: '', status: 0, skipped: true }
+
+  if (interactive) {
+    const result = spawnSync(cmd, args, { cwd, stdio: 'inherit', shell: NEEDS_SHELL })
+    return { ok: result.status === 0, stdout: '', stderr: '', status: result.status }
+  }
+
+  const result = spawnSync(cmd, args, { cwd, encoding: 'utf8', shell: NEEDS_SHELL })
+  const stdout = (result.stdout || '').trim()
+  // If the process couldn't even be spawned (bad cwd, command not found),
+  // result.error is set and stdout/stderr never got produced — surface that
+  // instead of silently reporting an empty failure.
+  const stderr = (result.stderr || '').trim() || (result.error ? result.error.message : '')
+  if (!quiet) {
+    if (stdout) console.log(indent(stdout))
+    if (stderr) console.log(indent(stderr))
+  }
+  const ok = result.status === 0
+  return { ok, stdout, stderr, status: result.status }
+}
+
+const ASYNC_TIMEOUT_MS = 30_000
+
+// Async counterpart to `run()`, used only for read-only lookups that get
+// fanned out across many repos at once (see pMap.js) — a registry check or
+// `git log` for one repo doesn't need to wait for the same call on the
+// other sixteen. Always quiet: interleaved "$ git ..." lines from several
+// repos at once would be noise, not progress — callers report their own
+// summary once the whole batch settles. Never used for mutating commands;
+// those stay on the synchronous, one-at-a-time `run()` above so their
+// progress prints in the order things actually happen.
+//
+// Guarded with a hard timeout: under real concurrency (several of these in
+// flight at once — that's the whole point of using this over `run()`) a
+// spawned process has occasionally been observed to just never emit
+// 'close' at all (seen with `git ls-remote` specifically, intermittently,
+// only when several ran concurrently — never reproduced running the exact
+// same call alone, so this reads as a spawn/network edge case rather than
+// anything wrong with the git invocation itself). Without a limit here,
+// one wedged child process would hang the whole pMap batch — and every
+// command built on it — forever, with the terminal just sitting there
+// giving no indication why.
+export function runAsync(cwd, cmd, args) {
+  return new Promise((resolve) => {
+    let settled = false
+    const child = spawn(cmd, args, { cwd, shell: NEEDS_SHELL })
+    let stdout = ''
+    let stderr = ''
+
+    const timer = setTimeout(() => {
+      if (settled) return
+      settled = true
+      child.kill()
+      resolve({ ok: false, stdout: '', stderr: `timed out after ${ASYNC_TIMEOUT_MS / 1000}s`, status: null })
+    }, ASYNC_TIMEOUT_MS)
+
+    child.stdout?.on('data', (d) => (stdout += d))
+    child.stderr?.on('data', (d) => (stderr += d))
+    child.on('error', (err) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve({ ok: false, stdout: '', stderr: err.message, status: null })
+    })
+    child.on('close', (status) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve({ ok: status === 0, stdout: stdout.trim(), stderr: stderr.trim(), status })
+    })
+  })
+}
+
+export function gitAsync(cwd, args) {
+  return runAsync(cwd, 'git', args)
+}
+
+export function ghAsync(cwd, args) {
+  return runAsync(cwd, 'gh', args)
+}
+
+export function npmAsync(cwd, args) {
+  return runAsync(cwd, 'npm', args)
+}
+
+function indent(text) {
+  return text
+    .split('\n')
+    .map((line) => `    ${line}`)
+    .join('\n')
+}
+
+export function git(cwd, args, opts) {
+  return run(cwd, 'git', args, opts)
+}
+
+export function gh(cwd, args, opts) {
+  return run(cwd, 'gh', args, opts)
+}
+
+export function npm(cwd, args, opts) {
+  return run(cwd, 'npm', args, opts)
+}

package/src/export.js

@@ -0,0 +1,136 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { columnWidths } from './ui.js'
+
+// Reuses the exact columns/rows already computed for the terminal table —
+// what gets saved to a file is always what you'd have seen on screen (same
+// --quick/--path choices), not a separate export-only data shape.
+function toRecords(rows, columns) {
+  return rows.map((row) => Object.fromEntries(columns.map((col) => [col.label, String(col.value(row))])))
+}
+
+// A cell that's exactly the checkmark/cross the terminal table uses for a
+// plain yes/no fact (e.g. Release, or npm when it's up to date) becomes a
+// real boolean here — JSON is for machines, "✓" isn't a value a JSON
+// consumer can branch on without string-matching it back out. Everything
+// else (an actual outdated registry version, "⚠ N" stale deps, "clean"/
+// "dirty", "—" for not-applicable) carries more information than a plain
+// yes/no and stays as text — collapsing those to booleans would throw
+// real data away, not just reformat it.
+function toJsonValue(text) {
+  if (text === '✓') return true
+  if (text === '✗') return false
+  return text
+}
+
+function formatAsJson(rows, columns) {
+  const records = rows.map((row) =>
+    Object.fromEntries(columns.map((col) => [col.label, toJsonValue(String(col.value(row)))])),
+  )
+  return JSON.stringify(records, null, 2) + '\n'
+}
+
+function formatAsMarkdown(rows, columns) {
+  const headers = columns.map((c) => c.label)
+  const escape = (v) => v.replace(/\|/g, '\\|')
+  const records = toRecords(rows, columns)
+  const lines = [
+    `| ${headers.join(' | ')} |`,
+    `| ${headers.map(() => '---').join(' | ')} |`,
+    ...records.map((r) => `| ${headers.map((h) => escape(r[h])).join(' | ')} |`),
+  ]
+  return lines.join('\n') + '\n'
+}
+
+// Same aligned-column layout `printTable` prints to the terminal, minus the
+// ANSI color codes `col.style` would add — a plain-text file shouldn't be
+// full of escape sequences.
+function formatAsText(rows, columns) {
+  const widths = columnWidths(rows, columns)
+  const header = columns.map((col, i) => col.label.padEnd(widths[i])).join('  ')
+  const separator = widths.map((w) => '-'.repeat(w)).join('  ')
+  const lines = [header, separator, ...rows.map((row) => columns.map((col, i) => String(col.value(row)).padEnd(widths[i])).join('  '))]
+  return lines.join('\n') + '\n'
+}
+
+// RFC 4180: a field only needs quoting when it contains a comma, a quote,
+// or a newline — quoting everything unconditionally would still be valid
+// CSV, but leaves the common case (plain version numbers, branch names)
+// needlessly noisy to read.
+function csvEscape(value) {
+  return /[",\n\r]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value
+}
+
+function formatAsCsv(rows, columns) {
+  const headers = columns.map((c) => c.label)
+  const records = toRecords(rows, columns)
+  const lines = [
+    headers.map(csvEscape).join(','),
+    ...records.map((r) => headers.map((h) => csvEscape(r[h])).join(',')),
+  ]
+  return lines.join('\n') + '\n'
+}
+
+function htmlEscape(value) {
+  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;')
+}
+
+// A standalone document (not just a bare <table> fragment) so --output
+// report.html is directly openable in a browser and still readable, not
+// just an unstyled table dumped on a blank page.
+function formatAsHtml(rows, columns) {
+  const headers = columns.map((c) => c.label)
+  const records = toRecords(rows, columns)
+  const theadCells = headers.map((h) => `<th>${htmlEscape(h)}</th>`).join('')
+  const bodyRows = records
+    .map((r) => `    <tr>${headers.map((h) => `<td>${htmlEscape(r[h])}</td>`).join('')}</tr>`)
+    .join('\n')
+  return `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>polyrepo list</title>
+<style>
+  table { border-collapse: collapse; font-family: monospace; }
+  th, td { border: 1px solid #ccc; padding: 4px 8px; text-align: left; }
+  th { background: #eee; }
+</style>
+</head>
+<body>
+<table>
+  <thead><tr>${theadCells}</tr></thead>
+  <tbody>
+${bodyRows}
+  </tbody>
+</table>
+</body>
+</html>
+`
+}
+
+const FORMATTERS = { json: formatAsJson, md: formatAsMarkdown, csv: formatAsCsv, html: formatAsHtml, txt: formatAsText }
+
+export const EXPORT_FORMATS = Object.keys(FORMATTERS)
+
+export function exportTable(rows, columns, format) {
+  return FORMATTERS[format](rows, columns)
+}
+
+// Guesses a format from the --output file's own extension, for when
+// --format isn't given explicitly — .json/.md/.csv/.html are unambiguous,
+// anything else (including no extension at all) falls back to plain text.
+export function inferExportFormat(outputPath) {
+  const ext = path.extname(outputPath).toLowerCase()
+  if (ext === '.json') return 'json'
+  if (ext === '.md' || ext === '.markdown') return 'md'
+  if (ext === '.csv') return 'csv'
+  if (ext === '.html' || ext === '.htm') return 'html'
+  return 'txt'
+}
+
+export function writeExport(outputPath, content) {
+  const resolved = path.resolve(outputPath)
+  fs.mkdirSync(path.dirname(resolved), { recursive: true })
+  fs.writeFileSync(resolved, content)
+  return resolved
+}

package/src/filterByNames.js

@@ -0,0 +1,16 @@
+import pc from 'picocolors'
+
+// Same "--packages a,b,c" matching selectPackages.js uses to skip its
+// checkbox, factored out for read-only commands (outdated, prs) that never
+// show a checkbox at all — there's nothing to pick, just a report to
+// narrow down. `names` undefined means "no filter, return everything".
+export function filterByNames(items, names) {
+  if (!names) return items
+  const wanted = new Set(names.map((n) => n.trim().toLowerCase()).filter(Boolean))
+  const selected = items.filter((r) => wanted.has(r.dir.toLowerCase()))
+  const found = new Set(selected.map((r) => r.dir.toLowerCase()))
+  for (const name of wanted) {
+    if (!found.has(name)) console.log(pc.yellow(`Unknown package, ignoring: ${name}`))
+  }
+  return selected
+}

package/src/github.js

@@ -0,0 +1,57 @@
+import { gh, git } from './exec.js'
+
+// Looks up an existing PR for `branch` in the given state, quietly (no
+// command echo — this runs before we know whether there's anything
+// interesting to report, so the caller decides what to print).
+function findPr(repo, branch, state) {
+  const result = gh(repo.path, ['pr', 'list', '--head', branch, '--state', state, '--json', 'number,url'], {
+    quiet: true,
+  })
+  if (!result.ok || !result.stdout) return null
+  try {
+    const list = JSON.parse(result.stdout)
+    return list[0] ?? null
+  } catch {
+    return null
+  }
+}
+
+// Figures out where a previous (possibly interrupted) bump attempt for this
+// exact branch left off, so a re-run resumes instead of failing on
+// "branch already exists" or opening a duplicate PR:
+//   - 'merged'   — the PR already landed; only a local master sync is left.
+//   - 'open'     — a PR exists and just needs merging.
+//   - 'branch'   — the branch was pushed but no PR was ever opened.
+//   - 'fresh'    — nothing exists yet, do the full flow.
+export function detectBumpState(repo, branch) {
+  const merged = findPr(repo, branch, 'merged')
+  if (merged) return { status: 'merged', pr: merged }
+
+  const open = findPr(repo, branch, 'open')
+  if (open) return { status: 'open', pr: open }
+
+  if (remoteBranchExists(repo, branch)) return { status: 'branch' }
+
+  return { status: 'fresh' }
+}
+
+function remoteBranchExists(repo, branch) {
+  const result = git(repo.path, ['ls-remote', '--exit-code', '--heads', 'origin', branch], { quiet: true })
+  return result.ok
+}
+
+export function createPr(repo, { base, branch, title, body, dryRun }) {
+  const result = gh(
+    repo.path,
+    ['pr', 'create', '--base', base, '--head', branch, '--title', title, '--body', body],
+    { mutating: true, dryRun },
+  )
+  if (!result.ok) return { ok: false }
+  const match = result.stdout.match(/\/pull\/(\d+)/)
+  if (!match) return { ok: false, message: `Could not parse PR number from: ${result.stdout}` }
+  return { ok: true, number: match[1] }
+}
+
+export function mergePr(repo, number, { dryRun } = {}) {
+  return gh(repo.path, ['pr', 'merge', number, '--merge', '--delete-branch=false'], { mutating: true, dryRun })
+}