gitroots 0.0.0-stage → 0.5.0

package/src/commands/completion.js

@@ -0,0 +1,69 @@
+// gitroots completion bash|zsh|fish · and the hidden `gitroots __complete <kind>` it calls for live ids
+const TREE = {
+  status: [], repo: ['list', 'view'], branch: ['list', 'rules', 'restore'], clone: [], hooks: ['install', 'uninstall'], check: [],
+  pr: ['list', 'view', 'diff', 'create', 'approve', 'review', 'merge'], audit: ['follow'], watch: [], sessions: [],
+  attach: '@sessions', transfer: '@sessions', backup: '@sessions', backups: [], restore: '@sessions', tunnel: ['ls', 'close'], share: '@sessions',
+  login: [], logout: [], whoami: [], doctor: [], update: [], uninstall: [], completion: ['bash', 'zsh', 'fish'], demo: ['reset'], help: [],
+};
+const FLAGS = '--json --help --no-color --repo --since --actor --action --decision --to --machine --label --pick --fork --point --port --read-only --expires --yes --all --base --head --title --draft';
+
+export async function run(cmd, rest, flags, store) {
+  if (cmd === '__complete') {
+    const kind = rest[0];
+    const ids = kind === 'sessions' ? store.sessions().map((s) => s.id)
+      : kind === 'prs' ? store.prs().map((p) => String(p.number))
+        : kind === 'machines' ? store.machines().map((m) => m.name)
+          : kind === 'repos' ? store.repos().map((r) => r.name)
+            : kind === 'backups' ? store.backups().map((b) => b.id) : [];
+    process.stdout.write(`${ids.join('\n')}\n`);
+    return 0;
+  }
+  const shell = rest[0] || (process.env.SHELL || '').split('/').pop();
+  const cmds = Object.keys(TREE).join(' ');
+  const subs = Object.entries(TREE).filter(([, v]) => Array.isArray(v) && v.length);
+  if (shell === 'bash') {
+    process.stdout.write(`# gitroots bash completion · eval "$(gitroots completion bash)"
+_gitroots() {
+  local cur prev words cword
+  cur="\${COMP_WORDS[COMP_CWORD]}"; prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  if [ "$COMP_CWORD" -eq 1 ]; then COMPREPLY=( $(compgen -W "${cmds}" -- "$cur") ); return; fi
+  case "$cur" in -*) COMPREPLY=( $(compgen -W "${FLAGS}" -- "$cur") ); return;; esac
+  case "$prev" in --to|--machine) COMPREPLY=( $(compgen -W "$(gitroots __complete machines 2>/dev/null)" -- "$cur") ); return;; esac
+  case "\${COMP_WORDS[1]}" in
+${subs.map(([k, v]) => `    ${k}) if [ "$COMP_CWORD" -eq 2 ]; then COMPREPLY=( $(compgen -W "${v.join(' ')}" -- "$cur") ); fi;;`).join('\n')}
+    attach|transfer|backup|restore|share) COMPREPLY=( $(compgen -W "$(gitroots __complete sessions 2>/dev/null)" -- "$cur") );;
+  esac
+}
+complete -F _gitroots gitroots
+`);
+    return 0;
+  }
+  if (shell === 'zsh') {
+    process.stdout.write(`#compdef gitroots
+# gitroots zsh completion · gitroots completion zsh > "\${fpath[1]}/_gitroots"  (or: source <(gitroots completion zsh))
+_gitroots() {
+  local -a cmds
+  cmds=(${cmds})
+  if (( CURRENT == 2 )); then compadd -a cmds; return; fi
+  if [[ $words[CURRENT] == -* ]]; then compadd -- ${FLAGS}; return; fi
+  if [[ $words[CURRENT-1] == (--to|--machine) ]]; then compadd -- \${(f)"$(gitroots __complete machines 2>/dev/null)"}; return; fi
+  case $words[2] in
+${subs.map(([k, v]) => `    ${k}) (( CURRENT == 3 )) && compadd -- ${v.join(' ')};;`).join('\n')}
+    attach|transfer|backup|restore|share) compadd -- \${(f)"$(gitroots __complete sessions 2>/dev/null)"};;
+  esac
+}
+compdef _gitroots gitroots
+`);
+    return 0;
+  }
+  if (shell === 'fish') {
+    const lines = ['# gitroots fish completion · gitroots completion fish > ~/.config/fish/completions/gitroots.fish', 'complete -c gitroots -f'];
+    lines.push(`complete -c gitroots -n __fish_use_subcommand -a "${cmds}"`);
+    for (const [k, v] of subs) lines.push(`complete -c gitroots -n "__fish_seen_subcommand_from ${k}" -a "${v.join(' ')}"`);
+    lines.push('complete -c gitroots -n "__fish_seen_subcommand_from attach transfer backup restore share" -a "(gitroots __complete sessions 2>/dev/null)"');
+    lines.push('complete -c gitroots -l to -l machine -a "(gitroots __complete machines 2>/dev/null)"');
+    process.stdout.write(`${lines.join('\n')}\n`);
+    return 0;
+  }
+  throw new Error('usage: gitroots completion bash|zsh|fish');
+}

package/src/commands/demo.js

@@ -0,0 +1,12 @@
+// gitroots demo reset
+import { c } from '../ui/ansi.js';
+import { line } from '../ui/term.js';
+import { Store, home } from '../data/store.js';
+
+export async function run(_cmd, rest) {
+  const [sub] = rest;
+  if (sub !== 'reset') throw new Error('usage: gitroots demo reset');
+  Store.reset();
+  line(`  ${c.g('✓')} Demo org reset ${c.m(`· ${home()}/state.json removed`)}`);
+  return 0;
+}

package/src/commands/doctor.js

@@ -0,0 +1,81 @@
+// gitroots doctor
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { c, pad, state as colorState } from '../ui/ansi.js';
+import { line, motion, imageProtocol } from '../ui/term.js';
+import { json } from '../ui/components.js';
+import { VERSION, DOWNLOAD_BASE, installMethod, nativePaths, platformKey, isBinary } from '../runtime.js';
+import { latestVersion, newer, onPath } from '../installer.js';
+import { home } from '../data/store.js';
+import { readConfig } from '../api.js';
+import { tryGit } from '../git/checks.js';
+
+export async function run(_cmd, _rest, flags, store) {
+  const checks = [];
+  const add = (group, name, status, detail, fix) => checks.push({ group, name, status, detail, fix });
+
+  const method = installMethod();
+  add('install', 'gitroots', 'ok', `${VERSION} · ${method}${isBinary ? ` · ${process.execPath}` : ''}`);
+  add('install', 'platform', 'ok', platformKey());
+  if (!isBinary) {
+    const major = Number(process.versions.node.split('.')[0]);
+    add('install', 'node', major >= 18 ? 'ok' : 'fail', process.version, major >= 18 ? null : 'install Node 18 or newer, or the standalone build: curl -fsSL ' + DOWNLOAD_BASE + '/install.sh | bash');
+  }
+  if (method === 'native') {
+    const { bin } = nativePaths();
+    add('install', 'PATH', onPath(bin) ? 'ok' : 'warn', onPath(bin) ? `${bin} is on PATH` : `${bin} is not on PATH`, onPath(bin) ? null : `add  export PATH="${bin}:$PATH"  to your shell profile`);
+  }
+  const which = spawnSync(process.platform === 'win32' ? 'where' : 'sh', process.platform === 'win32' ? ['gitroots'] : ['-c', 'command -v gitroots'], { encoding: 'utf8' });
+  const found = (which.stdout || '').split('\n')[0].trim();
+  add('install', 'on PATH', found ? 'ok' : 'warn', found || 'gitroots is not on PATH in this shell', found ? null : method === 'npm' ? 'check npm prefix -g is on PATH' : null);
+
+  try {
+    const latest = await latestVersion(DOWNLOAD_BASE, 4000);
+    add('install', 'updates', newer(latest, VERSION) ? 'warn' : 'ok', newer(latest, VERSION) ? `${latest} is available` : 'up to date', newer(latest, VERSION) ? 'gitroots update' : null);
+  } catch (e) {
+    add('install', 'updates', 'warn', `couldn't check (${e.message})`);
+  }
+
+  const git = spawnSync('git', ['--version'], { encoding: 'utf8' });
+  add('git', 'git', git.status === 0 ? 'ok' : 'fail', git.status === 0 ? git.stdout.trim() : 'not found', git.status === 0 ? null : 'install git');
+  const top = tryGit(['rev-parse', '--show-toplevel']);
+  if (top) {
+    const hooks = path.resolve(tryGit(['rev-parse', '--git-path', 'hooks']) || '.git/hooks');
+    const hook = path.join(hooks, 'pre-push');
+    const ours = fs.existsSync(hook) && fs.readFileSync(hook, 'utf8').includes('# gitroots push checks');
+    add('git', 'push checks', ours ? 'ok' : 'warn', ours ? `installed in ${path.basename(top)}` : `not installed in ${path.basename(top)}`, ours ? null : 'gitroots hooks install');
+    const url = tryGit(['remote', 'get-url', 'origin']);
+    const repo = store.repoByRemote(url);
+    const cfg = fs.existsSync(path.join(top, '.gitroots.json'));
+    add('git', 'rules', repo || cfg ? 'ok' : 'warn', repo ? `gitroots repo ${repo.name}` : cfg ? '.gitroots.json' : 'no rules for this repo · only the secrets scan applies', repo || cfg ? null : 'add a .gitroots.json with "protected": ["main"]');
+  } else add('git', 'repository', 'ok', 'not inside a git repo (skipped hook checks)');
+
+  const cfg = readConfig();
+  if (store.api) {
+    try {
+      const me = await store.api.me();
+      add('account', 'signed in', me ? 'ok' : 'fail', me ? `${me.username} · ${cfg.server} · org ${cfg.org ? cfg.org.slug : 'none'}` : 'user not found', me ? null : 'gitroots login');
+    } catch (e) { add('account', 'signed in', 'fail', e.message, 'gitroots login'); }
+  } else add('account', 'signed in', 'warn', 'no · using the sample org', 'gitroots login');
+
+  try { fs.mkdirSync(home(), { recursive: true }); fs.accessSync(home(), fs.constants.W_OK); add('account', 'state', 'ok', home()); } catch { add('account', 'state', 'fail', `${home()} is not writable`, 'set GITROOTS_HOME to a writable folder'); }
+
+  const img = imageProtocol();
+  add('terminal', 'colors', colorState.color ? 'ok' : 'warn', colorState.color ? (colorState.truecolor ? 'truecolor' : '256 colors') : 'off (piped or NO_COLOR)');
+  add('terminal', 'motion', 'ok', motion() ? 'on' : 'off (piped, NO_COLOR, CI or reduced motion)');
+  add('terminal', 'logo image', 'ok', img ? `${img} graphics` : 'plain text logo (Kitty, Ghostty, WezTerm or iTerm2 show the image)');
+
+  if (flags.json) { json(checks); return checks.some((x) => x.status === 'fail') ? 1 : 0; }
+  let group = '';
+  for (const x of checks) {
+    if (x.group !== group) { if (group) line(); line(c.m(x.group.toUpperCase())); group = x.group; }
+    const mark = x.status === 'ok' ? c.g('✓') : x.status === 'warn' ? c.w('◐') : c.r('✕');
+    line(`  ${mark} ${pad(x.name, 13)}${x.status === 'fail' ? c.r(x.detail) : x.status === 'warn' ? c.w(x.detail) : c.s(x.detail)}${x.fix ? `   ${c.g(`→ ${x.fix}`)}` : ''}`);
+  }
+  const fails = checks.filter((x) => x.status === 'fail').length;
+  const warns = checks.filter((x) => x.status === 'warn').length;
+  line();
+  line(fails ? c.r(`✕ ${fails} problem${fails > 1 ? 's' : ''}`) + (warns ? c.w(` · ◐ ${warns} to look at`) : '') : warns ? c.w(`◐ ${warns} thing${warns > 1 ? 's' : ''} to look at`) : c.g('✓ all good'));
+  return fails ? 1 : 0;
+}

package/src/commands/pr.js

@@ -0,0 +1,322 @@
+// gitroots pr list · view · diff · approve · review · merge
+import { c, h, pad } from '../ui/ansi.js';
+import { line, runSteps, confirm } from '../ui/term.js';
+import { dot, json, next } from '../ui/components.js';
+import { tryGit } from '../git/checks.js';
+import { sampleNote } from '../connected.js';
+
+export async function run(_cmd, rest, flags, store) {
+  const [sub = 'list', ...args] = rest;
+  switch (sub) {
+    case 'list': case 'ls': return list(args, flags, store);
+    case 'view': case 'show': return view(args, flags, store);
+    case 'diff': return diff(args, flags, store);
+    case 'approve': return approve(args, flags, store);
+    case 'review': return review(args, flags, store);
+    case 'merge': return merge(args, flags, store);
+    case 'create': case 'new': case 'open': return create(args, flags, store);
+    default:
+      if (/^#?\d+$/.test(sub)) return view([sub], flags, store);
+      throw new Error(`unknown: gitroots pr ${sub} · list, view, diff, create, approve, review, merge`);
+  }
+}
+
+function stateCell(p, me) {
+  if (p.state === 'merged') return c.g(`✓ merged ${p.mergedAt || ''}`.trim());
+  if (p.state === 'closed') return c.m('○ closed');
+  if (p.state === 'draft') return c.m('○ draft');
+  if (p.checks.state === 'fail') return c.r('✕ checks failed');
+  if (p.checks.state === 'running') return c.i('○ checks running');
+  if (p.changesRequested) return c.r('✕ changes requested');
+  if (p.needs && p.needs.who === me && !p.approvals.some((a) => a.by === me)) return c.w('◐ needs you');
+  if (p.approvals.length >= p.required) return c.g('✓ ready to merge');
+  return c.m(`○ waiting for ${p.required - p.approvals.length} more`);
+}
+
+function checksCell(p) {
+  return p.checks.state === 'pass' ? c.g('✓') : p.checks.state === 'fail' ? c.r('✕') : c.i('⠼');
+}
+
+function list([repo], flags, store) {
+  const want = flags.state || 'all';
+  let prs = store.prs(repo).filter((p) => want === 'all' || p.state === want);
+  prs = [...prs].sort((a, b) => b.number - a.number);
+  if (flags.json) { json(prs); return 0; }
+  const me = store.org.user;
+  line(`  ${h(`${pad('#', 7)}${pad('TITLE', 40)}${pad('FROM → INTO', 35)}${pad('AUTHOR', 10)}${pad('APPROVALS', 12)}${pad('CHECKS', 9)}STATE`)}`);
+  for (const p of prs) {
+    const num = stateCell(p, me).includes('needs you') ? c.b(pad(String(p.number), 7)) : pad(String(p.number), 7);
+    const agent = p.agent ? `   ${c.m(p.agent)}` : '';
+    line(`  ${num}${pad(p.title, 40)}${pad(`${p.from} → ${p.into}`, 35)}${pad(p.author, 10)}${pad(`${p.approvals.length} / ${p.required}`, 12)}${pad(checksCell(p), 9)}${stateCell(p, me)}${agent}`);
+  }
+  if (!prs.length) line(c.m('  no pull requests'));
+  const mine = prs.find((p) => stateCell(p, me).includes('needs you'));
+  sampleNote(store, 'pull requests are');
+  line();
+  line(next(`gitroots pr view ${(mine || prs[0] || { number: '<n>' }).number}`));
+  return 0;
+}
+
+function needPr(args, store) {
+  if (!args[0]) throw new Error('which pull request? e.g. gitroots pr view 412');
+  return store.pr(args[0]);
+}
+
+function view(args, flags, store) {
+  const p = needPr(args, store);
+  if (flags.json) { json(p); return 0; }
+  const me = store.org.user;
+  const add = p.files.reduce((n, f) => n + f.add, 0);
+  const del = p.files.reduce((n, f) => n + f.del, 0);
+  line(`  ${c.b(`#${p.number} ${p.title}`)}   ${c.m(`${p.repo} · ${p.from} → ${p.into} · opened by ${p.author} · ${p.opened}`)}`);
+  line();
+  if (p.files.length) {
+    line(`  ${c.s(pad('files', 12))}${p.files.length} changed   ${c.g(`+${add}`)}  ${c.r(`−${del}`)}`);
+    for (const f of p.files.slice(0, 3)) {
+      line(`  ${' '.repeat(12)}${pad(f.path, 51)}${c.g(pad(`+${f.add}`, 5))}${c.r(`−${f.del}`)}${f.flag ? `   ${c.w(`◐ ${f.flag}`)}` : ''}`);
+    }
+    if (p.files.length > 3) line(`  ${' '.repeat(12)}${c.m(`+ ${p.files.length - 3} more · gitroots pr diff ${p.number}`)}`);
+  } else {
+    line(`  ${c.s(pad('commits', 12))}${p.commits}`);
+  }
+  const ch = p.checks;
+  const checks = ch.state === 'pass'
+    ? `${c.g('✓')} tests ${ch.tests || 'pass'}   ${c.g('✓')} lint   ${c.g('✓')} secrets scan   ${c.g('✓')} branch rules`
+    : ch.state === 'fail' ? `${c.r('✕')} ${ch.failed}` : `${c.i('⠼')} running`;
+  line(`  ${c.s(pad('checks', 12))}${checks}`);
+  const appr = p.approvals.map((a) => `${c.g('✓')} ${a.by} ${c.m(`· ${a.ago}`)}`);
+  const missing = p.required - p.approvals.length;
+  if (missing > 0) {
+    if (p.needs && !p.approvals.some((a) => a.by === p.needs.who)) appr.push(`${c.w('○')} ${p.needs.who === me ? 'you' : p.needs.who} ${c.m(`(needed · ${p.needs.why})`)}`);
+    const others = missing - (p.needs && !p.approvals.some((a) => a.by === p.needs.who) ? 1 : 0);
+    if (others > 0) appr.push(c.m(`○ ${others} more`));
+  }
+  line(`  ${c.s(pad('approvals', 12))}${appr.join('    ')}`);
+  if (p.changesRequested) line(`  ${c.s(pad('review', 12))}${c.r('✕')} changes requested by ${p.changesRequested.by} ${c.m(`· ${p.changesRequested.note}`)}`);
+  for (const n of p.notes) line(`  ${c.s(pad('notes', 12))}${c.w('◐')} ${n}`);
+  line();
+  if (p.state === 'merged') line(next(`gitroots audit --pr ${p.number}`));
+  else if (missing > 0 && !p.approvals.some((a) => a.by === me)) line(`  ${c.g(`→ gitroots pr approve ${p.number}`)}     ${c.m('or')}  ${c.s(`gitroots pr review ${p.number} --request-changes`)}   ${dot()}   ${c.s(`gitroots pr diff ${p.number}`)}`);
+  else if (missing <= 0) line(`  ${next(`gitroots pr merge ${p.number}`)}`);
+  else line(`  ${c.m(`waiting for ${missing} more approval${missing > 1 ? 's' : ''}`)}`);
+  return 0;
+}
+
+function diff(args, flags, store) {
+  const p = needPr(args, store);
+  if (flags.json) { json(p.files); return 0; }
+  if (!p.files.length) { line(c.m(`  no file list recorded for #${p.number}`)); return 0; }
+  const max = Math.max(...p.files.map((f) => f.add + f.del));
+  line(`  ${c.b(`#${p.number}`)} ${c.m(`${p.from} → ${p.into}`)}`);
+  line();
+  for (const f of p.files) {
+    const n = Math.max(1, Math.round(((f.add + f.del) / max) * 30));
+    const a = Math.round((f.add / (f.add + f.del || 1)) * n);
+    line(`  ${pad(f.path, 52)}${c.g(pad(`+${f.add}`, 6))}${c.r(pad(`−${f.del}`, 6))}${c.g('+'.repeat(a))}${c.r('−'.repeat(n - a))}${f.flag ? `  ${c.w(`◐ ${f.flag}`)}` : ''}`);
+  }
+  line();
+  line(next(`gitroots pr approve ${p.number}`));
+  return 0;
+}
+
+function approve(args, flags, store) {
+  const p = needPr(args, store);
+  const me = store.org.user;
+  if (p.state !== 'open') throw new Error(`#${p.number} is ${p.state}`);
+  if (p.author === me) throw new Error(`you opened #${p.number} · someone else has to approve it`);
+  if (p.approvals.some((a) => a.by === me)) {
+    if (flags.json) { json({ pr: p.number, approvals: p.approvals.length, already: true }); return 0; }
+    line(`  ${c.m('○')} You already approved #${p.number} ${dot()} ${p.approvals.length} / ${p.required} approvals`);
+    return 0;
+  }
+  p.approvals.push({ by: me, ago: 'just now', note: flags.m || flags.message || '' });
+  if (p.changesRequested && p.changesRequested.by === me) delete p.changesRequested;
+  const extra = p.needs && p.needs.who === me ? ` ${dot()} ${p.needs.why.replace(/^tech lead for /, 'tech lead sign-off for ')} recorded` : '';
+  const ev = store.record({ actor: me, action: 'approve', target: `PR #${p.number}`, decision: 'recorded', note: flags.m || '', repo: p.repo, pr: p.number });
+  store.save();
+  if (flags.json) { json({ pr: p.number, approvals: p.approvals.length, required: p.required, event: ev.id }); return 0; }
+  line(`  ${c.g('✓')} Approved #${p.number} ${dot()} ${p.approvals.length} / ${p.required} approvals${extra} ${c.m(`· ${ev.id}`)}`);
+  line();
+  line(p.approvals.length >= p.required ? next(`gitroots pr merge ${p.number}`) : c.m(`  waiting for ${p.required - p.approvals.length} more`));
+  return 0;
+}
+
+function review(args, flags, store) {
+  const p = needPr(args, store);
+  const me = store.org.user;
+  const note = flags.m || flags.message || '';
+  if (flags.approve) return approve(args, flags, store);
+  if (flags['request-changes']) {
+    if (!note) throw new Error('say what needs to change: -m "…"');
+    p.changesRequested = { by: me, note };
+    p.approvals = p.approvals.filter((a) => a.by !== me);
+    const ev = store.record({ actor: me, action: 'request changes', target: `PR #${p.number}`, decision: 'recorded', note, repo: p.repo, pr: p.number });
+    store.save();
+    if (flags.json) { json({ pr: p.number, changesRequested: true, event: ev.id }); return 0; }
+    line(`  ${c.r('✕')} Changes requested on #${p.number} ${dot()} ${p.author} notified ${c.m(`· ${ev.id}`)}`);
+    return 0;
+  }
+  if (!note) throw new Error('usage: gitroots pr review <n> --request-changes -m "…" | --approve | --comment -m "…"');
+  const ev = store.record({ actor: me, action: 'comment', target: `PR #${p.number}`, decision: 'recorded', note, repo: p.repo, pr: p.number });
+  store.save();
+  if (flags.json) { json({ pr: p.number, comment: note, event: ev.id }); return 0; }
+  line(`  ${c.g('✓')} Comment added to #${p.number} ${c.m(`· ${ev.id}`)}`);
+  return 0;
+}
+
+async function merge(args, flags, store) {
+  const p = needPr(args, store);
+  const me = store.org.user;
+  if (p.state === 'draft') throw new Error(`#${p.number} is a draft · mark it ready first`);
+  if (p.state !== 'open') throw new Error(`#${p.number} is already ${p.state}`);
+  const rule = store.ruleFor(p.repo, p.into);
+  const method = flags.rebase ? 'rebase' : flags['merge-commit'] ? 'merge commit' : 'squash';
+  const json_ = Boolean(flags.json);
+
+  if (!json_) {
+    line(`  ${c.b(`#${p.number} ${p.title}`)}   ${c.m(`${p.from} → ${p.into} · ${p.commits} commits · ${method}`)}`);
+    const ok = await confirm(`Merge into ${c.b(p.into)}?`, { assumeYes: flags.yes || flags.y });
+    if (!ok) { line(c.m('  nothing merged')); return 1; }
+    line();
+  }
+
+  const conflictBase = store.branches(p.repo).find((b) => b.name === p.into)?.commit || 'HEAD';
+  const steps = [
+    {
+      name: 'Approvals', live: 'counting approvals…', ms: 600,
+      run: async () => (p.approvals.length >= p.required
+        ? { detail: `${p.approvals.length} / ${p.required} · ${p.approvals.map((a) => a.by).join(', ')}` }
+        : { status: 'fail', detail: `${p.approvals.length} / ${p.required} · needs ${p.required - p.approvals.length} more` }),
+    },
+    {
+      name: 'Checks', live: 'waiting for the latest run…', ms: 900,
+      run: async () => (p.checks.state === 'pass' ? { detail: `tests ${p.checks.tests || 'pass'} · lint · secrets scan` }
+        : p.checks.state === 'fail' ? { status: 'fail', detail: p.checks.failed } : { status: 'fail', detail: 'still running · try again when they finish' }),
+    },
+    {
+      name: 'Branch rules', live: `checking ${p.into} rules…`, ms: 600,
+      run: async () => (p.changesRequested ? { status: 'fail', detail: `changes requested by ${p.changesRequested.by}` }
+        : { detail: `${p.into}: ${rule.protected ? `PR only, ${rule.approvals} approvals, checks green` : 'open branch'}` }),
+    },
+    { name: 'Conflicts', live: `test-merging into ${p.into}…`, ms: 800, ok: `none with ${p.into} at ${conflictBase}` },
+    { name: 'Merge', live: `pushing to ${store.repo(p.repo).remote}…`, ms: 1000, ok: method === 'squash' ? `squashed ${p.commits} commits` : method === 'rebase' ? `rebased ${p.commits} commits` : 'merge commit created' },
+  ];
+
+  const results = json_ ? await silentSteps(steps) : await runSteps(steps, { nameWidth: 16, stopOnFail: true, showQueued: true });
+  const failed = results.find((r) => r.status === 'fail');
+  if (failed) {
+    const ev = store.record({ actor: me, action: 'merge', target: `PR #${p.number} → ${p.into}`, decision: 'blocked', note: failed.detail, repo: p.repo, pr: p.number });
+    store.save();
+    if (json_) { json({ merged: false, pr: p.number, reason: failed.detail, event: ev.id }); return 1; }
+    line();
+    line(`  ${c.r(c.b(`✕ Not merged`))}   ${failed.name.trim()}: ${failed.detail} ${c.m(`· ${ev.id}`)}`);
+    line();
+    line(next(`gitroots pr view ${p.number}`));
+    return 1;
+  }
+
+  const sha = Math.floor(Math.random() * 0xfffffff).toString(16).padStart(7, '0');
+  const now = new Date();
+  const hhmm = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+  p.state = 'merged';
+  p.mergedAt = hhmm;
+  p.mergeSha = sha;
+  const branches = store.d.branches[p.repo] || [];
+  const target = branches.find((b) => b.name === p.into);
+  if (target) { target.commit = sha; target.by = me; target.age = 'now'; }
+  if (!flags['keep-branch']) {
+    const idx = branches.findIndex((b) => b.name === p.from);
+    if (idx > -1) {
+      store.d.deletedBranches = store.d.deletedBranches || {};
+      (store.d.deletedBranches[p.repo] = store.d.deletedBranches[p.repo] || []).push(branches[idx]);
+      branches.splice(idx, 1);
+    }
+  }
+  const repo = store.repo(p.repo);
+  repo.openPrs = Math.max(0, repo.openPrs - 1);
+  repo.lastPush = 'just now';
+  const ev = store.record({ actor: me, action: 'merge', target: `PR #${p.number} → ${p.into}`, decision: 'allowed', note: `${p.approvals.length} approvals · checks green`, repo: p.repo, pr: p.number });
+  store.save();
+
+  if (json_) { json({ merged: true, pr: p.number, into: p.into, sha, event: ev.id }); return 0; }
+  const ahead = store.prs(p.repo).find((x) => x.state === 'open' && x.from === p.into);
+  line();
+  line(`  ${c.g(c.b(`✓ Merged #${p.number} into ${p.into}`))}   ${c.m('as')} ${sha} ${c.m(`· by ${me} · ${hhmm}`)}`);
+  if (!flags['keep-branch']) line(`    ${c.s(pad('branch', 10))}${p.from} deleted ${c.m(`(restore with gitroots branch restore ${p.repo} ${p.from})`)}`);
+  line(`    ${c.s(pad('audit', 10))}${ev.id} ${dot()} approvals, checks and the merge are recorded together`);
+  if (ahead) line(`    ${c.s(pad('next', 10))}release PR #${ahead.number} waits for ${ahead.required - ahead.approvals.length} approval${ahead.required - ahead.approvals.length === 1 ? '' : 's'}`);
+  line();
+  line(`  ${next(ahead ? `gitroots pr view ${ahead.number}` : `gitroots pr list ${p.repo}`, `gitroots audit --pr ${p.number}`)}`);
+  return 0;
+}
+
+async function silentSteps(steps) {
+  const out = [];
+  for (const s of steps) {
+    const r = s.run ? await s.run({ progress() {} }) : {};
+    const res = { ...s, ...r, status: r.status || 'ok', detail: r.detail ?? s.ok };
+    out.push(res);
+    if (res.status === 'fail') break;
+  }
+  return out;
+}
+
+// gitroots pr create [--base staging] [--head branch] [--title "…"] [--repo erp] [--draft]
+function create(args, flags, store) {
+  const cwd = process.cwd();
+  const inGit = Boolean(tryGit(['rev-parse', '--show-toplevel'], cwd));
+  const head = flags.head || (inGit ? tryGit(['rev-parse', '--abbrev-ref', 'HEAD'], cwd) : '');
+  if (!head) throw new Error('which branch? run inside a git repo or pass --head <branch>');
+  if (inGit && flags.head && !tryGit(['rev-parse', '--verify', '--quiet', flags.head], cwd)) throw new Error(`no branch ${flags.head} in this repo`);
+  const url = inGit ? tryGit(['remote', 'get-url', 'origin'], cwd) : '';
+  const repo = flags.repo ? store.repo(flags.repo) : store.repoByRemote(url);
+  if (!repo) throw new Error(`this repository is not in ${store.org.name} · pass --repo <name>`);
+  const base = flags.base || flags.into || (store.ruleFor(repo.name, 'staging').protected ? 'staging' : repo.default);
+  if (head === base) throw new Error(`head and base are both ${base} · switch to your feature branch`);
+  const rule = store.ruleFor(repo.name, base);
+  if (store.prs(repo.name).some((p) => p.state === 'open' && p.from === head && p.into === base)) throw new Error(`a PR from ${head} into ${base} is already open`);
+
+  // Real numbers when the commits are here: files and lines changed against the base.
+  let files = [];
+  let commits = 0;
+  if (inGit) {
+    const baseRef = ['origin/' + base, base].find((r) => tryGit(['rev-parse', '--verify', '--quiet', r], cwd));
+    if (baseRef) {
+      commits = Number(tryGit(['rev-list', '--count', `${baseRef}..${head}`], cwd)) || 0;
+      files = tryGit(['diff', '--numstat', `${baseRef}...${head}`], cwd).split('\n').filter(Boolean).map((l) => {
+        const [a, d, p] = l.split('\t');
+        return { path: p, add: Number(a) || 0, del: Number(d) || 0 };
+      });
+    }
+  }
+  const paths = store.protectedPaths(repo.name);
+  const notes = [];
+  let needs;
+  for (const f of files) {
+    if (/(^|\/)migrations?\//.test(f.path)) { f.flag = 'changes data'; needs = { who: store.org.user, why: 'tech lead for migrations' }; }
+    const hit = paths.find((p) => store.matchPath(p.pattern, f.path));
+    if (hit) { f.flag = `needs ${hit.needs}`; notes.push(`${f.path} needs ${hit.needs}`); }
+  }
+  const title = flags.title || flags.t || (inGit ? tryGit(['log', '-1', '--format=%s', head], cwd) : '') || head;
+  const number = Math.max(...store.d.prs.map((p) => p.number)) + 1;
+  const pr = {
+    number, repo: repo.name, title, from: head, into: base, author: store.org.user, opened: 'just now', at: new Date().toISOString(),
+    required: rule.approvals || 1, approvals: [], checks: { state: 'running' }, state: flags.draft ? 'draft' : 'open', commits: commits || 1, files, notes,
+  };
+  if (needs) pr.needs = needs;
+  store.d.prs.push(pr);
+  repo.openPrs += 1;
+  const ev = store.record({ actor: store.org.user, action: 'open pr', target: `PR #${number} ${head} → ${base}`, decision: 'allowed', repo: repo.name, pr: number });
+  store.save();
+  if (flags.json) { json({ ...pr, event: ev.id }); return 0; }
+  const add = files.reduce((n, f) => n + f.add, 0);
+  const del = files.reduce((n, f) => n + f.del, 0);
+  line(`  ${c.g('✓')} ${c.b(`Opened #${number} ${title}`)}${flags.draft ? c.m(' (draft)') : ''}`);
+  line(`    ${c.s(pad('branch', 11))}${head} → ${base} ${dot()} ${repo.name}`);
+  if (files.length) line(`    ${c.s(pad('changes', 11))}${files.length} files ${c.g(`+${add}`)} ${c.r(`−${del}`)} ${dot()} ${commits} commit${commits === 1 ? '' : 's'}`);
+  line(`    ${c.s(pad('rules', 11))}${rule.protected ? `${rule.approvals} approval${rule.approvals === 1 ? '' : 's'} · checks green` : '1 approval'}${notes.length ? ` ${dot()} ${c.w(`◐ ${notes.length} protected path${notes.length > 1 ? 's' : ''}`)}` : ''}`);
+  line(`    ${c.s(pad('checks', 11))}${c.i('○ running')}`);
+  line();
+  line(next(`gitroots pr view ${number}`));
+  return 0;
+}