merge-followthrough

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { PrRow } from '../types'
5
6// Watches the PRs you authored in this repo. When one merges it does the
7// routine Claude used to spend a turn on (checkout main, pull --ff-only,
8// delete the merged local branch) and tells Claude on your next prompt.
9
10const prs = atom({ plugin: 'merge-followthrough', key: 'prs' } as const, [])
11const merged = atom({ plugin: 'merge-followthrough', key: 'merged' } as const, [])
12
13const POLL_MS = 60_000
14const MERGED_PROMPT = /^\s*(#?\d+[\s,]*(and\s+)?)*(merged|megerd|mered|,erged)\b/i
15
16type GhPr = {
17  number: number
18  title: string
19  headRefName: string
20  state: 'OPEN' | 'MERGED' | 'CLOSED'
21  isDraft: boolean
22  mergeable: string
23  statusCheckRollup?: { status?: string; conclusion?: string; state?: string }[]
24}
25
26function checksOf(rollup: GhPr['statusCheckRollup']): PrRow['checks'] {
27  if (!rollup || rollup.length === 0) return 'none'
28  const states = rollup.map(c => (c.conclusion || c.state || c.status || '').toUpperCase())
29  if (states.some(s => ['FAILURE', 'ERROR', 'CANCELLED', 'TIMED_OUT', 'ACTION_REQUIRED'].includes(s))) return 'fail'
30  if (states.some(s => ['', 'PENDING', 'QUEUED', 'IN_PROGRESS', 'EXPECTED'].includes(s))) return 'pending'
31  return 'pass'
32}
33
34async function git($: EngineInterface, args: string[]) {
35  return $.process.run(['git', ...args], { timeoutMs: 60_000 })
36}
37
38async function defaultBranch($: EngineInterface): Promise<string> {
39  const r = await git($, ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'])
40  return r.exitCode === 0 ? r.stdout.trim().replace(/^origin\//, '') : 'main'
41}
42
43async function isClean($: EngineInterface): Promise<boolean> {
44  const r = await git($, ['status', '--porcelain', '--untracked-files=no'])
45  return r.exitCode === 0 && r.stdout.trim() === ''
46}
47
48// The routine: fast-forward the default branch, drop the merged branch.
49async function followThrough($: EngineInterface, pr: { number: number; branch: string }): Promise<string> {
50  const main = await defaultBranch($)
51  const parts: string[] = []
52  const current = (await git($, ['rev-parse', '--abbrev-ref', 'HEAD'])).stdout.trim()
53
54  if (!(await isClean($))) {
55    return `#${pr.number} merged. Working tree has uncommitted changes on ${current}, so I left git alone.`
56  }
57  if (current !== main) {
58    const co = await git($, ['checkout', '-q', main])
59    if (co.exitCode !== 0) return `#${pr.number} merged. Could not check out ${main}: ${co.stderr.trim().slice(0, 200)}`
60    parts.push(`checked out ${main}`)
61  }
62  const pull = await git($, ['pull', '--ff-only', '-q'])
63  if (pull.exitCode !== 0) {
64    parts.push(`pull failed: ${pull.stderr.trim().slice(0, 200)}`)
65  } else {
66    const head = (await git($, ['log', '--oneline', '-1'])).stdout.trim()
67    parts.push(`${main} is at ${head}`)
68  }
69  if (pr.branch && pr.branch !== main) {
70    const exists = await git($, ['rev-parse', '--verify', '-q', `refs/heads/${pr.branch}`])
71    if (exists.exitCode === 0) {
72      // -D is safe here: GitHub says the PR merged, and squash merges defeat -d.
73      const del = await git($, ['branch', '-D', pr.branch])
74      parts.push(del.exitCode === 0 ? `deleted local branch ${pr.branch}` : `kept ${pr.branch} (${del.stderr.trim()})`)
75    }
76  }
77  await git($, ['fetch', '-q', '--prune'])
78
79  return `#${pr.number} merged: ${parts.join('; ')}.`
80}
81
82async function fetchPrs($: EngineInterface): Promise<GhPr[] | undefined> {
83  const r = await $.process.run(
84    ['gh', 'pr', 'list', '--author', '@me', '--state', 'all', '--limit', '20',
85      '--json', 'number,title,headRefName,state,isDraft,mergeable,statusCheckRollup'],
86    { timeoutMs: 30_000 },
87  ).catch(() => undefined)
88  if (!r || r.exitCode !== 0) return undefined
89  try {
90    return JSON.parse(r.stdout) as GhPr[]
91  } catch {
92    return undefined
93  }
94}
95
96// Numbers seen open this session, so a merge is noticed once.
97const seenOpen = new Set<number>()
98const handled = new Set<number>()
99let isRepo = false
100
101async function poll($: EngineInterface) {
102  const list = await fetchPrs($)
103  if (!list) return
104  const open = list.filter(p => p.state === 'OPEN')
105  await update($, prs, () =>
106    open.map(p => ({
107      number: p.number,
108      title: p.title,
109      branch: p.headRefName,
110      state: p.state,
111      isDraft: p.isDraft,
112      checks: checksOf(p.statusCheckRollup),
113      mergeable: p.mergeable,
114    })),
115  )
116  for (const p of list) {
117    if (p.state === 'OPEN') seenOpen.add(p.number)
118    if (p.state === 'MERGED' && seenOpen.has(p.number) && !handled.has(p.number)) {
119      handled.add(p.number)
120      const note = await followThrough($, { number: p.number, branch: p.headRefName })
121      await update($, merged, list => [...list, { number: p.number, note }])
122      $.ui.toast(note, { timeoutMs: 8000 })
123    }
124  }
125}
126
127export const register: Register = on => {
128  on('session.start', async ($, e, next) => {
129    const inside = await git($, ['rev-parse', '--is-inside-work-tree']).catch(() => undefined)
130    isRepo = inside?.exitCode === 0
131    if (!isRepo) return next(e)
132
133    await $.command.register({ name: 'prs', description: 'Refresh the PR band and pull main if PRs merged' })
134
135    // The hand-typed `! git checkout main; git pull` at the start of a session.
136    const main = await defaultBranch($)
137    const current = (await git($, ['rev-parse', '--abbrev-ref', 'HEAD'])).stdout.trim()
138    if (current === main && (await isClean($))) {
139      const before = (await git($, ['rev-parse', 'HEAD'])).stdout.trim()
140      const pull = await git($, ['pull', '--ff-only', '-q'])
141      const after = (await git($, ['rev-parse', 'HEAD'])).stdout.trim()
142      if (pull.exitCode === 0 && before !== after) {
143        const count = (await git($, ['rev-list', '--count', `${before}..${after}`])).stdout.trim()
144        $.ui.toast(`${main} fast-forwarded ${count} commit(s)`)
145      }
146    }
147
148    void poll($)
149    $.clock.every(POLL_MS, () => void poll($))
150
151    return next(e)
152  })
153
154  on('command.run', { command: 'prs' }, async $ => {
155    await poll($)
156    const open = await read($, prs)
157    return { text: open.length === 0 ? 'No open PRs.' : `${open.length} open PR(s); see the band above the prompt.` }
158  })
159
160  on('prompt.submit', async ($, e, next) => {
161    if (!isRepo) return next(e)
162    const context = [...(e.context ?? [])]
163
164    // You typed "616 merged": make sure the routine ran before Claude starts.
165    if (e.origin.kind === 'composer' && MERGED_PROMPT.test(e.text)) {
166      await poll($)
167      const numbers = [...e.text.matchAll(/\d+/g)].map(m => Number(m[0]))
168      for (const n of numbers) {
169        if (handled.has(n)) continue
170        const view = await $.process.run(['gh', 'pr', 'view', String(n), '--json', 'state,headRefName'])
171          .catch(() => undefined)
172        if (!view || view.exitCode !== 0) continue
173        const pr = JSON.parse(view.stdout) as { state: string; headRefName: string }
174        if (pr.state !== 'MERGED') continue
175        handled.add(n)
176        const note = await followThrough($, { number: n, branch: pr.headRefName })
177        await update($, merged, list => [...list, { number: n, note }])
178      }
179      if (numbers.length === 0) {
180        // Plain "merged": pull anyway.
181        const note = await followThrough($, { number: 0, branch: '' })
182        await update($, merged, list => [...list, { number: 0, note: note.replace('#0 merged', 'merged') }])
183      }
184    }
185
186    const notes = await read($, merged)
187    if (notes.length > 0) {
188      context.push(
189        `[merge-followthrough] Already done, no need to repeat:\n${notes.map(n => `- ${n.note}`).join('\n')}`,
190      )
191      await update($, merged, () => [])
192    }
193
194    return next(context.length > 0 ? { ...e, context } : e)
195  })
196
197  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
198    const open = await read($, prs)
199    if (!isRepo || open.length === 0 || e.props.hasSurvey) return next(e)
200
201    const { Box, Text } = $.ui.resolve(e)
202    const mark = { pass: '✓', fail: '✗', pending: '…', none: '·' } as const
203    const color = { pass: 'green', fail: 'red', pending: 'yellow', none: 'gray' } as const
204
205    return (
206      <Box flexDirection="column">
207        {open.slice(0, 4).map(p => (
208          <Box key={String(p.number)}>
209            <Text color={color[p.checks]}>{mark[p.checks]} </Text>
210            <Text bold>#{p.number} </Text>
211            <Text dimColor wrap="truncate">
212              {p.isDraft ? 'draft · ' : ''}
213              {p.mergeable === 'CONFLICTING' ? 'conflicts · ' : ''}
214              {p.title}
215            </Text>
216          </Box>
217        ))}
218        {open.length > 4 && <Text dimColor>+{open.length - 4} more open PRs</Text>}
219      </Box>
220    )
221  })
222}
223

1export type PrRow = {
2  number: number
3  title: string
4  branch: string
5  state: 'OPEN' | 'MERGED' | 'CLOSED'
6  isDraft: boolean
7  checks: 'pass' | 'fail' | 'pending' | 'none'
8  mergeable: string
9}
10
11declare module 'claude-code' {
12  interface PluginState {
13    'merge-followthrough': {
14      prs: PrRow[]
15      merged: { number: number; note: string }[]
16    }
17  }
18}
19