git-band

1// git-band: one line above the prompt with the session repo's git state, so
2// nobody has to ask "which branch did that land on". Runs git and gh locally,
3// no model calls. Refreshes at start, after each turn and after git commands.
4
5import { atom, read, update } from 'claude-code'
6import type { EngineInterface, Register, RenderElement } from 'claude-code'
7
8import type { GitInfo, PrInfo } from '../types'
9
10const DANGER = /^(main|master|staging|prod|production)$/
11const info = atom({ plugin: 'git-band', key: 'info' } as const, null as GitInfo | null)
12const pr = atom({ plugin: 'git-band', key: 'pr' } as const, null as PrInfo | null)
13
14// Files Claude wrote this session (absolute paths); a reload forgets them.
15const claudeFiles = new Set<string>()
16
17async function git($: EngineInterface, root: string, ...args: string[]): Promise<string | null> {
18  const r = await $.process.run(['git', '-C', root, ...args], { timeoutMs: 5000 })
19  return r.exitCode === 0 ? r.stdout.trim() : null
20}
21
22async function refresh($: EngineInterface): Promise<void> {
23  const repo = await $.session.repo()
24  if (repo === null) return void (await update($, info, () => null))
25  const root = repo.root
26  const branch = (await git($, root, 'rev-parse', '--abbrev-ref', 'HEAD')) ?? '?'
27  const upstream = await git($, root, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}')
28  const counts = upstream === null ? null : await git($, root, 'rev-list', '--left-right', '--count', '@{u}...HEAD')
29  const [behind, ahead] = (counts ?? '0 0').split(/\s+/).map(Number)
30  const status = (await git($, root, 'status', '--porcelain')) ?? ''
31  const paths = status === '' ? [] : status.split('\n').map(l => l.slice(3).split(' -> ').pop() ?? '')
32  const byClaude = paths.filter(p => claudeFiles.has(`${root}/${p}`)).length
33  const gitDir = await git($, root, 'rev-parse', '--absolute-git-dir')
34  const commonDir = await git($, root, 'rev-parse', '--path-format=absolute', '--git-common-dir')
35  const stash = await git($, root, 'stash', 'list')
36
37  await update($, info, () => ({
38    branch,
39    upstream,
40    ahead: ahead || 0,
41    behind: behind || 0,
42    changed: paths.length,
43    byClaude,
44    worktree: gitDir !== null && commonDir !== null && gitDir !== commonDir ? root.split('/').pop() ?? null : null,
45    stash: stash === null || stash === '' ? 0 : stash.split('\n').length,
46  }))
47}
48
49async function refreshPr($: EngineInterface): Promise<void> {
50  const repo = await $.session.repo()
51  if (repo === null || repo.remote === null) return
52  const r = await $.process.run(['gh', 'pr', 'view', '--json', 'number,state,statusCheckRollup'], {
53    cwd: repo.root,
54    timeoutMs: 15000,
55  })
56  if (r.exitCode !== 0) return void (await update($, pr, () => null))
57  try {
58    const j = JSON.parse(r.stdout) as {
59      number: number
60      state: string
61      statusCheckRollup?: { conclusion?: string; status?: string; state?: string }[]
62    }
63    const checks = j.statusCheckRollup ?? []
64    const states = checks.map(c => (c.conclusion || c.state || c.status || '').toUpperCase())
65    const ci: PrInfo['ci'] =
66      checks.length === 0 ? 'none'
67      : states.some(s => /FAIL|ERROR|CANCEL|TIMED_OUT/.test(s)) ? 'failing'
68      : states.some(s => /PENDING|QUEUED|IN_PROGRESS|EXPECTED|^$/.test(s)) ? 'running'
69      : 'passing'
70    await update($, pr, () => ({ number: j.number, state: j.state.toLowerCase(), ci }))
71  } catch {
72    await update($, pr, () => null)
73  }
74}
75
76export const register: Register = on => {
77  on('session.start', async ($, e, next) => {
78    void refresh($)
79    void refreshPr($)
80    $.clock.every(5 * 60_000, () => void refreshPr($))
81    return next(e)
82  })
83
84  on('turn.complete', async ($, e, next) => {
85    const result = await next(e)
86    if (e.agentId === undefined) void refresh($)
87    return result
88  })
89
90  on('tool.call', { tool: /^(Edit|Write|NotebookEdit)$/ }, async ($, e, next) => {
91    const ran = await next(e)
92    const input = e as unknown as { file_path?: string; notebook_path?: string }
93    const path = input.file_path ?? input.notebook_path
94    if (ran.deny === undefined && ran.isError !== true && path !== undefined) claudeFiles.add(path)
95    return ran
96  })
97
98  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
99    const ran = await next(e)
100    if (!/\bgit\b/.test(e.command)) return ran
101    await refresh($)
102    if (/\bgit\s+commit\b/.test(e.command) && ran.isError !== true && ran.deny === undefined) {
103      const repo = await $.session.repo()
104      const head = repo === null ? null : await git($, repo.root, 'log', '-1', '--format=%h %s')
105      const now = await read($, info)
106      if (head !== null) $.ui.toast(`commit ${head.slice(0, 60)} → ${now?.branch ?? '?'}`)
107    }
108    if (/\bgit\s+push\b|\bgh\s+pr\b/.test(e.command)) void refreshPr($)
109    return ran
110  })
111
112  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next): Promise<RenderElement> => {
113    const below = await next(e)
114    const g = await read($, info)
115    if (e.props.hasSurvey || g === null) return below
116    const p = await read($, pr)
117    const { Box, Text } = $.ui.resolve(e)
118    const yours = g.changed - g.byClaude
119    const ciColor = p?.ci === 'failing' ? 'red' : p?.ci === 'running' ? 'yellow' : 'green'
120
121    return (
122      <Box flexDirection="column">
123        <Box flexWrap="wrap">
124          <Text color={DANGER.test(g.branch) ? 'red' : 'cyan'} bold>⎇ {g.branch}</Text>
125          {g.upstream !== null && <Text dimColor> → {g.upstream}</Text>}
126          {(g.ahead > 0 || g.behind > 0) && (
127            <Text color={g.ahead > 0 ? 'yellow' : undefined} dimColor={g.ahead === 0}>
128              {' · '}{g.ahead} not pushed{g.behind > 0 ? `, ${g.behind} behind` : ''}
129            </Text>
130          )}
131          {g.upstream === null && <Text color="yellow"> · no upstream</Text>}
132          <Text dimColor>
133            {' · '}
134            {g.changed === 0 ? 'clean' : `${g.changed} changed (${g.byClaude} Claude, ${yours} you)`}
135          </Text>
136          {p !== null && (
137            <Text dimColor>
138              {' · '}PR #{p.number} {p.state}
139            </Text>
140          )}
141          {p !== null && p.ci !== 'none' && <Text color={ciColor}> CI {p.ci}</Text>}
142          {g.worktree !== null && <Text dimColor> · wt {g.worktree}</Text>}
143          {g.stash > 0 && <Text dimColor> · stash {g.stash}</Text>}
144        </Box>
145        {below}
146      </Box>
147    )
148  })
149}
150

1export type GitInfo = {
2  branch: string
3  upstream: string | null
4  ahead: number
5  behind: number
6  changed: number
7  byClaude: number
8  worktree: string | null
9  stash: number
10}
11
12export type PrInfo = { number: number; state: string; ci: 'passing' | 'failing' | 'running' | 'none' }
13
14declare module 'claude-code' {
15  interface PluginState {
16    'git-band': { info: GitInfo | null; pr: PrInfo | null }
17  }
18}
19