Log

English · Русский

Kitten for kitty: a git history overlay — a commit list screen (current branch or all branches, with a branch graph) and, for the selected commit, its changes on the very same review screen review uses for uncommitted work — file tree + unified diff, syntax highlighting, line comments, go-to-definition, Find in Files, and copy to the clipboard for pasting into a Claude prompt.

All branches (a) with the branch graph — a merged feature and an unmerged one — colored ref labels, and the details panel (i) with the full message and author:

The review screen is literally the same class as in review; log adds the commit list, the branch graph, and the details panel. The only difference is where the files come from: the commit snapshot rather than the working tree — so search lands on the code as it was in that commit. Definitions are the exception: they resolve against the working-tree version of the same file, which is the one the language server has indexed — see Go to definition.

What it can do

• Commit list of the current branch; the a toggle — show all branches (--all).
• Branch graph on the left (g toggle) — colored merge/branch lanes, as in an IDE; commits that aren't on any remote yet get bright green nodes — on any local branch, not only the one p would push.
• Details panel on the right (i toggle): full commit message, author, email, date, committer (if different), and the list of branches that contain the commit. Shown in windows from 90 columns wide; in a narrower one i doesn't bring it up.
• Ref labels in the row: local branches, origin & name (a collapsed local+remote pair), remotes, and tags. With the graph on, the hash and the labels take the color of the commit's line, so you can tell which branch sits on which line; with it off, each label type has its own color.
• git fetch straight from the overlay (f) — pull remotes and reread the list.
• git push (p) — push the current branch after a y confirmation.
• Copy hash of the selected commit (⌘c) — for pasting into a prompt/command.
• Lazy loading: commits are fetched in batches as you scroll down.
• Filter (/ or ⌘f) — by subject, short hash, and author.
• For the selected commit (Enter / →) — its changes relative to the first parent on the full review screen: file tree + unified diff with syntax highlighting, word-diff, sticky header, a "hunks only ↔ whole file" mode (a), jump between changes ([ / ]), horizontal scroll (h / l), and search (⌘f, n / N).
• Everything review can do with a diff works on a commit too: line comments (c) exported as markdown (w) or sent straight to Claude (s), go-to-definition (⌥+click or d, ⌃o back), Find in Files (⌘⇧F), file marks, the tree filter (f), and opening a file in the editor (e). Definitions and matches are looked up in the commit snapshot, so they agree with the diff on screen.
• Russian keyboard layout for shortcuts (by key position).

The project folder and git root are determined from the cwd of the window the hotkey is pressed in. If that folder is not a repository but holds several, log shows all of them — see Several repositories in one folder.

Several repositories in one folder

Opened from a folder of independent repositories, log merges their commits into one feed ordered by time. The repository name and the age of the commit get their own columns:

Scrolling down only ever appends — a repository read up to some date cannot slip older commits into what you have already passed. The filter (/) matches the repository name too, so typing web leaves that repository's history alone on screen.

The branch graph is off here: independent repositories share no history to draw. Press R, pick a repository, and both the graph and the usual single-repository layout come back; Esc releases the focus.

f fetches every repository at once and reports which ones failed. p still pushes one repository — the one the selected commit belongs to, and its name is in the confirmation. Opening a commit (Enter) shows it exactly as before: one commit always belongs to one repository.

Setup

familiar enable log

Reload the config with Cmd+Ctrl+, (macOS) or restart kitty. Open with: cmd+shift+l.

Minimal fallback — a manual map in ~/.config/kitty/kitty.conf (or an include file):

map cmd+shift+l kitten /path/to/familiar/plugins/log.py

Unlike familiar enable, this bare map lacks the toggle-to-close behavior, the guard against re-opening the overlay on top of itself, the full-screen open from a split (the stack-layout switch), the Cyrillic key duplicates, and the cmd+c / cmd+shift+c / cmd+f pass-through for copying and search inside the overlay.

Keys

Commit list

Key	Action
↑/↓	navigate commits
PgUp PgDn	page up/down
Home / End	to start / end of list
Enter →	open commit changes
⌘c	copy hash of the selected commit
f	git fetch — pull remotes and reread
p	git push the current branch; asks y to confirm. A branch with no upstream is created on origin and bound to it. Shown only while something is unpushed
a	current branch ↔ all branches (--all)
R	focus one repository (only when the folder holds several)
g	branch graph on/off (needs a single repository)
i	details panel on/off
/ ⌘f	filter by subject / hash / author
Esc	clear the applied filter; with no filter — ask to close the overlay
q ⌃c	quit

f and p run git without access to the kitten's terminal (closed stdin, GIT_TERMINAL_PROMPT=0): a remote that wants an interactive password won't ask for it and returns an error instead — you need a credential helper or an SSH key.

Commit file tree (Enter/→ from the list)

Key	Action
↑/↓	navigate files (diff on the right updates)
⇧↑/⇧↓	mark a range of files; ⇧/⌥+click marks with the mouse
g / G	first / last file
Home / End	first / last row of the tree
Enter Space	collapse/expand folder
→ Tab	go to diff
f	filter the tree by file name
⌘⇧f	Find in Files across the commit snapshot
e	open the file in an editor
r	reread the commit
u	show/hide "noisy" folders (.idea, node_modules, …)
⌘c	copy @path of the file/folder (all marked ones, if any)
← Esc	back to commit list

Commit diff (→/Tab from the tree)

Key	Action
↑/↓	cursor over diff lines
g / G	to start / end of diff
Enter	on the ┈ separator — reveal the next 50 hidden lines; on a code line — comment it
c	comment the line under the cursor (empty text deletes the comment)
{ / }	jump between commented lines
w / s / x	copy the comments as markdown / send them to Claude / clear them
⌥+click, d	go to the definition of the symbol (d — for a selected word)
⌃o	back from a jump
[ / ]	previous / next change (moves the focus into the diff)
PgUp PgDn	scroll the diff
e	open the file in an editor at the top visible line
h / l	horizontal scroll (long lines)
a	view mode: hunks only ↔ the whole file
v	pane view: unified diff ↔ final code (IDE-style)
⌘f n/N	search the diff and jump between matches
⌘c	copy the selection (or the line under the cursor)
⌘shift+c	copy @path#L42 (#L42-58 for a selected range)
← Tab	back to the tree
Esc	clear selection/search → back to the tree → back to the list → ask to close

Esc at the bottom of the cascade (the commit list, no filter applied) doesn't close the overlay silently: a centered kitty-style dialog asks first — y / Enter / a click on Yes closes, n / Esc / No keeps it open, ←/→/Tab switch the buttons. ⌃c quits at once even over the dialog; q works only while the dialog isn't shown.

Mouse: click a commit to select, click again to open; wheel scrolls the list without moving the selection (the arrows bring the view back to it). In the diff — as in review: click to place the cursor, click on ┈ to reveal the next 50 lines, drag with the left button to select (inside a line — text, across lines — whole lines), then ⌘c; Shift is only needed for kitty's own terminal selection over the mouse capture. Both panes have a scrollbar; the wheel scrolls the pane it's over, without moving the selection.

File statuses, "noisy" folders, comments, go-to-definition and Find in Files — all as in review. What log doesn't have is +/-: staging and reverting only make sense for the working tree, and a commit is already history.

Working with Claude Code

From history it's easy to point Claude Code at a specific spot in the code:

• ⌘c copies the commit hash (in the list), the @-mention @path/to/file.py of a file (in the tree), or the selection / line under the cursor (in the diff).
• ⌘shift+c in the diff copies @path/to/file.py#L42, or #L42-58 when a range of lines is selected with the mouse.
• c leaves a comment on a line and s sends the whole set to the window under the overlay as markdown — the export names the commit, so Claude knows what was reviewed.

Paths are relative to the repository root, the way Claude Code expects them — it resolves @path against the directory it was started in. Land on a line in the diff → ⌘shift+c → Cmd+V into the prompt, no need to describe where to look in words.