coderabbit-band
A band above the prompt with the open CodeRabbit threads and nitpicks of the branch's MR
newbandguardcommandprocesstimer
A band above the prompt with the open CodeRabbit threads and nitpicks of the branch's MR
Personal Claude Code mods: plugins of function hooks that restyle the transcript, add rows around the prompt and react to tool calls. Built and used on Claude Code 2.1.287+, Linux.
| Mod | What it does | Commands | Needs | ||
|---|---|---|---|---|---|
| quiet-bash | One-line tool rows (✓ <description>, red ✗ exit N on failure, +N −M on edits, duration for calls ≥10 s). Hides every tool's result block (Bash output, Edit diffs, WebFetch, MCP and Agent results; interactive tools, SendUserFile and image Reads keep theirs), finished read-only rows (Read/Grep/Glob, and calls the engine ran read-only like ls or git status, and every Claude in Chrome step but navigate), collapsed tool groups unless one failed, and timed-out GitLab pipeline-wait notices. Inline PNG thumbnails under rows that read, sent or wrote a PNG (at most 3 written ones per call), relative paths included; a group holding a thumbnail stays open, even under /quiet | /quiet brings it all back; /thumb [big] <path> shows a PNG (relative to the session's directory) as thumb #N: <path> | ImageMagick (magick) for thumbnails; a terminal with kitty graphics (see herdr) | ||
| quiet-spinner | Plain spinner words (thinking, writing, running, waiting, preparing) and Took 1m 4s instead of the whimsical ones | – | – | ||
| usage-percent | Row under the prompt: `ctx 34% \ | 5h 41% \ | wk 86%, yellow from 80 %, red from 95 %. In Nx repos also memory in the middle (claude.slice usage + app.slice pressure, yellow from 20 %, red from 50 %) and on the right the session's own nx serve projects (▶ admin api; a bare nx serve or run-many -t serve shows ▶ serve) and the branch's pipeline (ci ⏳ test, ⏸` when it waits on a manual job or an approval; none for Azure remotes) | – | gh / glab logged in for the pipeline; systemd claude.slice for memory |
| reminder-log | Tallies the reminders Claude Code injects for the model, per session; drops the token counter and repeated commit attribution blocks (sent again after a compaction) | /reminders prints the tally of the last 30 days | – | ||
| mr-banner | Colored card with a link under each MR/PR created, merged, approved or reviewed | – | GitLab MCP server named gitlab, or glab / gh | ||
| coderabbit-band | Band above the prompt with the open CodeRabbit threads (by severity) and nitpicks of the current branch's GitLab MR, with a link. Shows only when something is open | /coderabbit hides it until the counts change | glab logged in; GitLab remote | ||
| redact | Secrets in prompts and tool output reach the model as ‹secret:…› tokens; only Write/Edit turn them back into the real value. See redact | – | betterleaks on PATH | ||
| mem-guard | Bash commands that run Node tools go into a memory-capped claude-cmd.slice scope. Refused, with the fix in the message: nx affected/run-many without --parallel=1, a pnpm script that has a :lite twin, jest without a worker cap (--maxWorkers=N, -w N or --runInBand; a percentage doesn't count), pkill -f/pgrep -f with an unbracketed pattern, ci:local, heavy runs and dev-server starts while the slice is above 75 % or under pressure, a third heavy command or a third dev server at once, and writes by a check-runner subagent. See mem-guard | – | Linux with systemd: a user claude-cmd.slice, ps; see mem-guard | ||
| handover | Skill plus mod: the handover skill writes a one-sentence handover for a cold session to ~/.claude/handover.md; the mod files it per session under ~/.claude/handovers/<session id>.md, so parallel sessions in one repo never overwrite each other. A band above the prompt shows it; after /clear that session's sentence waits in the prompt (Tab takes it) and the next prompt spends it. A new terminal suggests nothing but lists the repo's open sentences (newest first, 14 days) | /handover-copy copies it and hides the band; /handover lists, /handover N puts one in the prompt | – | ||
| herdr-notify | GNOME popup when Claude waits for a permission, an answer or a new prompt (a Notification hook, not a plugin). Skipped while that pane is the focused one in herdr. Clicking it raises Ghostty and focuses that session's herdr pane. Hook: `"Notification": [{"matcher": "permission_prompt\ | idle_prompt\ | elicitation_dialog", "hooks": [{"type": "command", "command": "bash \"$HOME/.claude/skills/herdr-notify/notify.sh\""}]}]` | – | herdr, Ghostty, notify-send, jq |
| stack-down | On /clear and exit (also logout, a finished -p run, SIGINT/SIGTERM/SIGHUP), stops what the session left running in its repo: the nx processes it started (with their workers), and the repo's Docker Compose projects (compose down, volumes kept) unless another Claude session works in the same repo. Only for a session at a repo's top level (git rev-parse --show-toplevel); one started above the repos, such as ~/Dev, stops nothing | – | docker compose, git | ||
| review-walk | Skill plus mod: /review-walk takes the findings of the reviews already run in the conversation (/code-review, a repo's own review skill, CodeRabbit threads, MR comments), merges and ranks them, and asks fix / issue / skip one finding at a time; fixes wait until every finding is decided. The mod puts Finding N/M, a progress bar and the decisions so far over each question, and a band above the prompt between them. Decisions you authorised up front ("apply every Fix") are recorded through its ReviewWalkDecide tool instead of a question. The walk starts only after the skill runs, so a review on its own draws no band | /review-walk | A review run first: it walks findings, it never reviews. Any review skill or source works |
The model sees exactly what it would without them: the mods change what is drawn, except reminder-log, which drops two kinds of injected reminders, redact, which hides secrets, mem-guard, which runs Node commands inside a systemd scope and refuses some with a mem-guard: … error, and stack-down, which stops the session's own servers and, when no other session is in the repo, its Compose stacks when the session ends.
Three mods call out on their own:
get_merge_request on the gitlab MCP server for the link and title. gh/glab commands cost nothing extra.glab for GitLab origin remotes: a 60 s timer checks the branch, and a fetch (glab mr view plus all pages of the MR's discussions) runs every minute for 15 min after a git push, every 5 min while the band shows something, every 15 min otherwise, and once 5 s after a thread is resolved.ps and pwdx for nx serve processes, and docker inspect once per container a server runs in, to read its compose project directory. The pipeline (gh run list / glab ci get) is fetched when HEAD moves, 15 s after a git push, every minute while it runs and every 5 min otherwise.From the marketplace (gets updates; herdr-notify and herdr-link-toast are not in it):
claude plugin marketplace add schreibse/claude-code-mods
claude plugin install quiet-bash@schreibse-mods # per modThen turn on updates: /plugin → Marketplaces → schreibse-mods → Enable auto-update. See Updates.
From a clone, to adapt a mod or work on it. Claude Code loads every plugin folder under ~/.claude/skills/ at session start. Don't install the same mod from the marketplace too: the installed copy silently replaces the folder.
~/.claude/skills: clone straight into it: ``sh git clone https://github.com/schreibse/claude-code-mods ~/.claude/skills ``sh git clone https://github.com/schreibse/claude-code-mods ~/src/claude-code-mods ln -s ~/src/claude-code-mods/quiet-bash ~/.claude/skills/quiet-bash # per mod ``New sessions pick them up; a running one needs /exit and claude --continue.
Leave a mod out: claude plugin uninstall <mod>@schreibse-mods, or delete or unlink its folder. Try one for a single session: claude --plugin-dir ~/src/claude-code-mods/<mod>.
Where they run. Built and used only in the terminal CLI on Fedora (Linux, systemd, cgroup v2). The engine also loads user-scope mods in the local session the desktop app starts for its Code tab, and draws them there (desktop surface); untested here. See Setting up for what each mod needs.
This repo is the skills folder itself, so .gitignore ignores everything and re-includes each mod: a new mod needs a !/<name>/ line or git won't see it. .claude-plugin/types/ is generated by the engine and stays untracked.
Each mod has its own version (plugin.json) and a CHANGELOG.md in its folder; each release is a git tag <mod>--v<version>.
Plugin updated: <mod> · Run /reload-plugins to apply. Without it nothing tells you; check by hand: ``sh claude plugin marketplace update schreibse-mods claude plugin update quiet-bash@schreibse-mods # per mod; "already at the latest version" if none ``CHANGELOG.md. Read every version you skipped: a major version means you have to act (a new hook in settings.json, a new dependency, a removed command).git -C ~/.claude/skills pull --ff-only, then read the changelogs of the mods whose version moved (git -C ~/.claude/skills diff ORIG_HEAD -- '*/.claude-plugin/plugin.json').betterleaks scans every prompt and tool result before it reaches the model. Each value it flags becomes ‹secret:xxxxxxxx› and stays hidden wherever it appears later, even where the scanner would not recognise it again.
| The model's call | What happens |
|---|---|
| Write, Edit, NotebookEdit with a token | the real value is written to the file |
| Write that would drop a secret the file holds | refused: use Edit |
| Agent, SendMessage, TodoWrite with a token | passed on as the token |
| Any other tool with a token (Bash, WebFetch, MCP …) | refused, so the value never leaves |
| A token the mod no longer knows (after a restart) | refused, never restored wrongly |
Cut-short output. Before Bash or any tool with a file_path/path (Read, Grep, Edit …) runs, every file the call names (Bash: the first 10 words that could be paths, files up to 1 MB) is scanned whole, so cut -c1-60 .env, cut -d= -f2 or a Read of a few lines from a PEM key still come back as tokens. Multi-line secrets are hidden line by line. Bash words resolve against the directory each segment runs in (cd sub && cut -c1-40 .env), and ~/, $HOME/ and ${HOME}/ expand to the home directory.
Rules. betterleaks' defaults plus redact/betterleaks.toml: Sentry DSN keys, and client secrets too short for the generic rules. A client secret containing dev, local, test, example, changeme or placeholder stays visible, so local dev clients keep working in commands.
Not covered:
git show HEAD:.env | cut …, printenv | cut …); the transcript file's structured tool records, which keep real values (the model does not read them).cut -c1-40 *.env), quoted paths with spaces and a cd inside a subshell ((cd sub && cut -c1-40 .env)).client-secret rule needs some entropy (≥ 3.0), so short, repetitive client secrets stay visible.base64, rev, xxd) or sent (curl -T file). redact keeps secrets out of the model's context by accident; it is not a sandbox against a model trying to get them.‹secret:…› token is refused like any other tool call carrying one.The vault lives in session memory: /exit forgets it.
The status line shows redacted N once a value is hidden: N counts vault entries, so a PEM key counts once per line. A toast per call names the rules that hid new values. Without betterleaks the status line says off (no betterleaks) and nothing is hidden. A betterleaks run that fails leaves that call unredacted (values already in the vault stay hidden): one toast per failure streak, the status says off (betterleaks), and the next call scans again.
Every Bash command that names a Node tool (node, npx, pnpm, npm, npm exec, yarn, nx, jest, vitest, playwright, tsc, ngc) runs as systemd-run --user --scope --slice=claude-cmd.slice -p MemoryMax=30% -p MemorySwapMax=4% -- bash -c '…', so an overrun dies with exit 137 instead of taking the desktop down. Leading cd … && stay outside the wrapper, so the shell's directory still moves.
The rules read what each part of a command runs (after &&, |, ;, &, $( ), inside bash -c '…', following cd), never words it only mentions, so a commit message saying pkill -f passes. Not looked into: xargs, make, eval, scripts.
At once, counted per scope in claude-cmd.slice from one ps scan (skipped when ps fails):
tsc, ngc, an nx task); the nx daemon and dev servers don't count;nx serve, nx run x:serve, a serve* script): the API and one app.A command counts as heavy for these checks when it runs one of those tools, docker compose up, or a test, build, lint, typecheck, e2e or serve* script.
check-runner subagents (an agent type of the owner's) only run checks: git commands that change the tree or history, sed -i, --write/--fix, starting or stopping servers or processes, and writes outside /tmp are refused with "Report the failure instead of fixing it".
Assumes this setup; the messages name it:
claude-cmd.slice user unit. Without it systemd makes the slice with no limit of its own: each command is still capped at 30 % of RAM, but the headroom check has nothing to measure and stays off: ``ini # ~/.config/systemd/user/claude-cmd.slice [Slice] MemoryMax=30% MemorySwapMax=4% ` A full slice can livelock without ever reaching the OOM killer, so let systemd-oomd kill a scope in it under sustained pressure: systemctl --user set-property claude-cmd.slice ManagedOOMMemoryPressure=kill ManagedOOMMemoryPressureLimit=50%. systemd turns a percentage into bytes of the machine's RAM (on 27 GiB: 8.2G and 1.1G), so the same unit fits any machine. Check what a machine gets: systemd-run --user --scope -q -p MemoryMax=30% -- sh -c 'cat /sys/fs/cgroup$(cut -d: -f3 /proc/self/cgroup)/memory.max'`fuser -k 4700/tcp.:lite twin (lint:affected:lite, typecheck:lite, test:affected:lite) and a slow ci:local script.git@work:org/repo) reads as ci no login (work) though you are logged in.Under herdr (here inside Ghostty), quiet-bash's thumbnails draw only their alt text, and links in mr-banner, coderabbit-band and Claude's own output aren't clickable.
Cause: Claude Code turns on kitty graphics only for terminals whose XTVERSION answer is kitty (≥ 0.28) or starts with ghostty, and hyperlinks only for terminals it recognises. herdr forwards both, but answers with its own name, so Claude Code turns both off.
Fix: force both on, inside herdr only, before Claude Code starts (it reads them at startup):
# ~/.bashrc.d/herdr-terminal.sh
if [ -n "$HERDR_ENV" ]; then
export CLAUDE_CODE_FORCE_TERMINAL_IMAGES=1
export FORCE_HYPERLINK=1
fiAlso turn on herdr's kitty graphics passthrough (off by default) in ~/.config/herdr/config.toml:
[experimental]
kitty_graphics = trueThen herdr server reload-config, open a new herdr pane (old panes keep the old environment) and start Claude Code there. Check it: /thumb /path/to/some.png should draw the picture.
herdr opens a ctrl+clicked link in the background with no feedback, and ignores file:// links altogether. herdr-link-toast opens http(s) links with xdg-open and shows a toast. It also opens the path in quiet-bash's thumbnail captions, which link to http://localhost/open-file/<path> because file:// isn't clickable in herdr. Such a link opens only when the path ends in .png; any other gets a "Could not open link" toast. Needs python3 ≥ 3.9. Install:
herdr plugin link ~/.claude/skills/herdr-link-toastWithout herdr, in plain kitty or Ghostty, none of this is needed. Terminals without the kitty graphics protocol show the thumbnail's alt text (its path).
Read before installing for someone. The mods were written for one machine; several carry its names and need Linux.
1. Check the host. Mods need Claude Code 2.1.287+. They load in the terminal CLI and, from ~/.claude/skills, in a desktop app's local Code-tab session. A desktop-app session can also be given a folder through CLAUDE_CODE_PLUGIN_DIRS in the env block of ~/.claude/settings.json. Nothing here has been tried in the desktop app, VS Code, JetBrains, macOS, WSL or native Windows: say so to the person instead of promising it works.
2. Pick mods by platform.
| Works anywhere | Needs Linux | Never on macOS or Windows |
|---|---|---|
quiet-spinner, reminder-log, mr-banner, coderabbit-band, redact (with betterleaks), handover, review-walk; usage-percent's ctx/5h/wk and pipeline parts | usage-percent's memory and dev-server parts (cgroup v2, /proc, pwdx; they stay empty elsewhere); stack-down (ps, /proc/<pid>/cwd, setsid) | mem-guard: it wraps every Node command in systemd-run, so without systemd every node/pnpm/nx call fails. Leave it out. herdr-notify, herdr-link-toast: Linux, herdr, Ghostty, GNOME |
/, ~). There, quiet-bash thumbnails and redact's Bash pre-scan find nothing, and handover leaves spent files behind./handover-copy can't copy from the desktop app.3. Adapt to the OS you are on. The mods do not detect the OS; you are running on it, so adapt the person's copy and test it there. The plugin API has no OS call: on Windows $.env.get('OS') is Windows_NT, elsewhere uname -s says Darwin or Linux. Known gaps:
:lite, pkill -f, ci:local), skip scoped() and the ps/cgroup checks when systemd-run is missing.HOME may be unset (USERPROFILE), and spent sentences are removed with rm./ and ~ only, not C:\….pwdx (lsof -a -d cwd -p <pid> instead); the memory zone needs cgroup v2 and stays empty.Write each OS change as its own commit with a test, so it can come back upstream.
4. Replace the owner's names. Names in this README and in the messages are examples from the owner's repos; use the person's own. The API project there is ec-api, not api, and the dev-server rules only work with the real project names: read them from the repo (npx nx show projects).
| Mod | Owner-specific | Where |
|---|---|---|
| mem-guard | claude-cmd.slice and its 30 % / 4 % limits; port 4700; :lite scripts; ci:local "~45 min"; the check-runner agent type; 2 heavy commands, 2 dev servers | hooks/rules.ts, hooks/register.ts |
| usage-percent | claude.slice (usage) and app.slice (pressure) under the user manager; Nx repos only (nx.json) | hooks/register.tsx |
| stack-down | another session is a process whose command is claude (native install); an npm install runs as node …/cli.js, goes unseen, and its repo's Compose stacks go down anyway | hooks/targets.ts |
| mr-banner, coderabbit-band, quiet-bash | the GitLab MCP server named gitlab (mcp__gitlab__…) | hooks/*.ts(x) |
| coderabbit-band, usage-percent | any remote that isn't GitHub (or Azure) is taken for GitLab | hooks/register.tsx |
| herdr-notify | Ghostty's desktop entry com.mitchellh.ghostty | notify.sh |
5. Install and check. Install as above (from a clone when you adapted a mod: an update replaces a marketplace copy), then run claude plugin validate <mod> and claude plugin test <mod> for each mod you install. Start a new session and check what the person should now see: the usage row, a tool row with ✓, and for redact, nothing until it hides a value, then redacted N in the status line.
Each mod is .claude-plugin/plugin.json, hooks/hooks.json and hooks/register.ts(x), plus types/index.d.ts when it keeps session state. Per mod:
claude plugin validate <mod> # what it hooks and calls, and what the engine would refuse
claude plugin test <mod> # its *.test.ts(x)
tsc -p <mod> # once the engine has laid .claude-plugin/types/Edits in ~/.claude/skills hot-reload into running sessions that loaded the mod.
Marketplace users only get a change once the mod's version moves, so a change meant for them bumps it in the same commit:
version in <mod>/.claude-plugin/plugin.json: major when users must act, minor for a feature, patch for a fix.## <version> — <date> to <mod>/CHANGELOG.md, with an Action needed line on a major.claude plugin validate --strict . (the marketplace) and claude plugin validate --strict <mod>.claude plugin tag --push <mod>.gh release create <mod>--v<version> --verify-tag --title "<mod> <version>" --notes-file <entry>, with the new changelog entry as the notes; links in it must be absolute.hooks/register.tsx 147 lines1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register, Timer } from 'claude-code'
3
4import { ICONS, SEVERITIES, discussionsIn, fingerprint, isWorthShowing, openCount, tallyOf } from './tally'
5import type { Tally } from '../types'
6
7const TICK_MS = 60_000
8const SHOWN_MS = 300_000
9const QUIET_MS = 900_000
10// CodeRabbit reviews a push within minutes, so poll every tick for a while after one.
11const AFTER_PUSH_MS = 900_000
12const AFTER_RESOLVE_MS = 5_000
13
14const tally = atom({ plugin: 'coderabbit-band', key: 'tally' } as const, null)
15const hiddenAt = atom({ plugin: 'coderabbit-band', key: 'hiddenAt' } as const, null)
16
17type Poll = { root: string; branch: string; dueAt: number; fastUntil: number; isBusy: boolean }
18
19const CODERABBIT_ORANGE = '#FF570A'
20const HOSTS_WITHOUT_CODERABBIT = /github\.com|dev\.azure\.com|visualstudio\.com/
21
22export function isGitPush(command: string): boolean {
23 return /\bgit(?:\s+-[Cc]\s+\S+)*\s+push\b/.test(command)
24}
25
26async function fetchTally($: EngineInterface, root: string, branch: string): Promise<Tally | null> {
27 const mr = await $.process.run(['glab', 'mr', 'view', branch, '-F', 'json'], { cwd: root, timeoutMs: 20_000 })
28 if (mr.exitCode !== 0) {
29 return null
30 }
31 const { iid, web_url, state } = JSON.parse(mr.stdout) as { iid: number; web_url: string; state: string }
32 if (state !== 'opened') {
33 return null
34 }
35 const notes = await $.process.run(
36 ['glab', 'api', '--paginate', '--output', 'ndjson', `projects/:fullpath/merge_requests/${iid}/discussions?per_page=100`],
37 { cwd: root, timeoutMs: 20_000 },
38 )
39 return notes.exitCode === 0 ? tallyOf(discussionsIn(notes.stdout), `!${iid}`, web_url) : null
40}
41
42async function tick($: EngineInterface, poll: Poll) {
43 if (poll.isBusy) {
44 return
45 }
46 poll.isBusy = true
47 try {
48 const branch = (await $.process.run(['git', 'branch', '--show-current'], { cwd: poll.root })).stdout.trim()
49 const now = await $.clock.now()
50 if (branch === poll.branch && now < poll.dueAt) {
51 return
52 }
53 poll.branch = branch
54 const found = branch === '' ? null : await fetchTally($, poll.root, branch).catch(() => null)
55 await update($, tally, () => found)
56 poll.dueAt = now + (now < poll.fastUntil ? TICK_MS : isWorthShowing(found) ? SHOWN_MS : QUIET_MS)
57 } finally {
58 poll.isBusy = false
59 }
60}
61
62function startTick($: EngineInterface, poll: Poll): void {
63 void tick($, poll).catch((error: unknown) => $.ui.log(`coderabbit-band: ${String(error)}`, { to: 'debug' }))
64}
65
66export const register: Register = on => {
67 let poll: Poll | null = null
68 let timer: Timer | null = null
69
70 on('session.start', async ($, e, next) => {
71 const result = await next(e)
72 await $.command.register({ name: 'coderabbit', description: 'Hide or show the CodeRabbit band' })
73 timer?.cancel()
74 timer = null
75 poll = null
76 const root = await $.session.root()
77 const remote = await $.process.run(['git', 'remote', 'get-url', 'origin'], { cwd: root })
78 if (remote.exitCode === 0 && !HOSTS_WITHOUT_CODERABBIT.test(remote.stdout)) {
79 const current: Poll = { root, branch: '', dueAt: 0, fastUntil: 0, isBusy: false }
80 poll = current
81 startTick($, current)
82 timer = $.clock.every(TICK_MS, () => startTick($, current))
83 }
84 return result
85 })
86
87 on('command.run', { command: 'coderabbit' }, async $ => {
88 const shown = await read($, tally)
89 if (!isWorthShowing(shown)) {
90 return { text: 'No open CodeRabbit threads or nitpicks on this branch.' }
91 }
92 const isHidden = (await read($, hiddenAt)) === fingerprint(shown)
93 await update($, hiddenAt, () => (isHidden ? null : fingerprint(shown)))
94 return { text: isHidden ? 'CodeRabbit band shown.' : 'CodeRabbit band hidden until its counts change.' }
95 })
96
97 on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
98 const result = await next(e)
99 const current = poll
100 if (current !== null && isGitPush(e.command)) {
101 const now = await $.clock.now()
102 current.fastUntil = now + AFTER_PUSH_MS
103 current.dueAt = now + TICK_MS
104 }
105 return result
106 })
107
108 on('tool.call', async ($, e, next) => {
109 const result = await next(e)
110 const current = poll
111 // `@coderabbitai resolve` can go out through any GitLab MCP note tool or a glab command, so the whole call is searched.
112 if (current !== null && (e.tool === 'mcp__gitlab__resolve_merge_request_thread' || /@coderabbitai resolve/.test(JSON.stringify(e)))) {
113 current.dueAt = 0
114 $.clock.after(AFTER_RESOLVE_MS, () => startTick($, current))
115 }
116 return result
117 })
118
119 on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
120 const shown = await read($, tally)
121 const band = await next(e)
122 if (e.props.hasSurvey || !isWorthShowing(shown) || (await read($, hiddenAt)) === fingerprint(shown)) {
123 return band
124 }
125 const { Box, Link, Text } = $.ui.resolve(e)
126 const open = openCount(shown)
127 const counts = SEVERITIES.filter(severity => shown.open[severity] > 0).map(severity => `${ICONS[severity]} ${shown.open[severity]}`)
128 return (
129 <Box flexDirection="column">
130 {band}
131 <Box flexDirection="column" paddingX={1} borderStyle="round" borderColor={CODERABBIT_ORANGE}>
132 <Box>
133 <Text>🐇 </Text>
134 <Text backgroundColor={CODERABBIT_ORANGE} color="white" bold> CODERABBIT </Text>
135 <Text color={CODERABBIT_ORANGE} bold> {shown.ref}</Text>
136 <Text> {open} open{counts.length > 0 ? ` · ${counts.join(' ')}` : ''}</Text>
137 {shown.nitpicks > 0 ? <Text dimColor> · 🧹 {shown.nitpicks} nits</Text> : null}
138 <Box flexGrow={1} />
139 <Text dimColor>/coderabbit to hide</Text>
140 </Box>
141 <Link href={shown.url} />
142 </Box>
143 </Box>
144 )
145 })
146}
147hooks/tally.ts 43 lines1import type { Severity, Tally } from '../types'
2
3type Note = { author?: { username?: string }; body?: string; resolvable?: boolean; resolved?: boolean; created_at?: string }
4type Discussion = { notes?: Note[] }
5
6export const SEVERITIES: readonly Severity[] = ['critical', 'major', 'minor', 'trivial', 'other']
7export const ICONS: Record<Severity, string> = { critical: '🔴', major: '🟠', minor: '🟡', trivial: '🔵', other: '⚪' }
8
9const isRabbit = (note: Note | undefined) => /coderabbit/i.test(note?.author?.username ?? '')
10
11// A thread opens with `_🎯 Functional Correctness_ | _🟠 Major_ | _⚡ Quick win_`.
12export function severityOf(body: string): Severity {
13 const label = /^_[^_\n]+_ \| _[^\w_\n]*(\w+)_/.exec(body)?.[1]?.toLowerCase()
14 return SEVERITIES.find(severity => severity === label) ?? 'other'
15}
16
17// `glab api --paginate --output ndjson` prints one discussion per line, across all pages.
18export const discussionsIn = (ndjson: string): Discussion[] => ndjson.split('\n').filter(line => line.trim() !== '').map(line => JSON.parse(line) as Discussion)
19
20export function tallyOf(discussions: readonly Discussion[], ref: string, url: string): Tally | null {
21 const firsts = discussions.flatMap(discussion => (isRabbit(discussion.notes?.[0]) ? [discussion.notes![0]!] : []))
22 if (firsts.length === 0) {
23 return null
24 }
25 const open = Object.fromEntries(SEVERITIES.map(severity => [severity, 0])) as Record<Severity, number>
26 for (const note of firsts) {
27 if (note.resolvable && !note.resolved) {
28 open[severityOf(note.body ?? '')] += 1
29 }
30 }
31 const reviews = firsts.filter(note => /Actionable comments posted|Nitpick comments/.test(note.body ?? ''))
32 const latest = reviews.sort((a, b) => (a.created_at ?? '').localeCompare(b.created_at ?? '')).at(-1)
33 const nitpicks = Number(/Nitpick comments \((\d+)\)/.exec(latest?.body ?? '')?.[1] ?? 0)
34 return { ref, url, open, nitpicks }
35}
36
37export const openCount = (tally: Tally) => SEVERITIES.reduce((sum, severity) => sum + tally.open[severity], 0)
38
39export const isWorthShowing = (tally: Tally | null): tally is Tally => tally !== null && openCount(tally) + tally.nitpicks > 0
40
41// Hiding holds until the counts change.
42export const fingerprint = (tally: Tally) => `${tally.ref}:${SEVERITIES.map(severity => tally.open[severity]).join('.')}:${tally.nitpicks}`
43types/index.d.ts 9 lines1export type Severity = 'critical' | 'major' | 'minor' | 'trivial' | 'other'
2export type Tally = { ref: string; url: string; open: Record<Severity, number>; nitpicks: number }
3
4declare module 'claude-code' {
5 interface PluginState {
6 'coderabbit-band': { tally: Tally | null; hiddenAt: string | null }
7 }
8}
9