# git-who: git blame for file trees, not lines

> git-who is a Go CLI that ranks the people responsible for a path, a tag or a revision range, instead of the last person to touch a single line. It is a small tool with a narrow question, and the README is honest about what it does not do.

**sinclairtarget/git-who** — Git blame for file trees

- Repository: https://github.com/sinclairtarget/git-who
- Stars: 2,677 · Forks: 55
- Language: Go
- License: MIT
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/sinclairtarget-git-who

## The question git-who answers that git blame cannot

git blame answers who wrote this line. That is the wrong question when you are looking at a directory with two hundred files and trying to work out who to ask about it. The README frames the tool around a different question: who wrote this code, meaning which people are responsible for entire components or subsystems. The stated analogy is git blame for file trees rather than individual files.

The audience is anyone doing ownership work on a repository they did not write: a new maintainer taking over a module, a reviewer deciding who to request a review from, or an engineer trying to find out whether a subsystem still has anyone active behind it. The README's own demo is about Vim, which suggests the intended use case is large, long-lived codebases where the answer is not obvious from recent commit history.

## How git-who turns a repository into an author table

The mechanism visible in the README is straightforward: git-who walks commits reachable from a given starting point, attributes each commit to its author, and aggregates. The table subcommand prints one row per author with two metrics: Last Edit and Commits. The README's cpython example shows Guido van Rossum at 11,213 commits and Fred Drake at 5,465, with a trailing row reading ...3,026 more..., so the output is truncated rather than complete.

Filtering happens at two levels. A path argument restricts the walk to commits that touched files under that path, which is how git who Tools/ produces a different ranking from git who. A commit-ish argument restricts the walk to commits reachable from that revision, so git who v3.7.1 shows the state of authorship at that tag. A revision range works the same way: git who v3.10.9..v3.11.9 shows commits made between those two releases, and the README notes that a bot account, Miss Islington (bot), tops that list. That is a useful detail, because it tells you the tool counts whatever the commit metadata says and does not try to separate humans from automation.

The sorting flags change the question slightly rather than the data. The -m flag sorts by the Last Edit column, so the most recent editors come first. The -c flag sorts by first edit, putting the earliest contributors at the top. The -l flag sorts by number of lines modified and adds columns to the table. Those four flags are the whole of the visible option surface described in the README excerpt.

## Installing git-who and running a first query

The README lists several installation routes. Precompiled binaries are on the releases page. Homebrew is supported on macOS, and there is a go install path for anyone with a Go toolchain. A packaging status badge points at Repology for other distributions, and Docker is covered by a section the README references but the excerpt does not include.

The Homebrew route on macOS is a single command:

```bash
brew install git-who
```

If you have Go installed, the module path is the same as the repository:

```bash
go install github.com/sinclairtarget/git-who@latest
```

Building from source needs more than Go. The README states that Go, Ruby and the rake gem are required, and that the last two are only needed for source builds, not for running a binary release. The sequence is clone, change directory, run rake, then check the version:

```bash
git clone git@github.com:sinclairtarget/git-who.git
cd git-who
rake
./git-who --version
```

After installation, the intended invocation is as a Git subcommand. The README explains that git who works automatically as long as Git can find git-who on your PATH, and points at a Git Alias section for the details. A first real query is the default table view against the current repository:

```bash
git who
```

You should see a box-drawn table with Author, Last Edit and Commits columns, sorted by commit count, with a final row summarizing the authors not shown. To narrow it to one directory, pass a path:

```bash
git who Tools/
```

The README notes that when a path name and a commit-ish collide, -- disambiguates, so git who -- foo targets the file or directory called foo even if a branch shares the name or the path was deleted from the current tree.

## Commit counts are not contribution, and the README does not pretend otherwise

The central limitation is the metric. Commits are a count of commits, not of work. A contributor who lands one large refactor and a contributor who lands forty small fixes are not comparable, and the table will rank the second one higher. The -l flag switches to lines modified, which swaps one crude proxy for another: a reformatting pass or a vendored dependency import can dominate the line count without representing understanding of the code.

The bot row in the README's own revision-range example makes this concrete. Miss Islington (bot) tops the v3.10.9..v3.11.9 table at 2,551 commits, and the tool reports that faithfully. It does not classify authors, filter bots, or merge identities. Two email addresses used by the same person appear as two rows, and the README excerpt does not describe any author-mapping file or mailmap integration.

There is also a scale question. The cpython example truncates at ten rows and reports 3,026 more authors, which means the default view is a summary rather than an inventory. If you need the full list, the README excerpt does not document a flag for that. Finally, git-who is the wrong tool for the question it is most likely to be confused with. If you need to know who last touched a specific function, use git blame. git-who will only tell you that the file's directory belongs, in aggregate, to some set of people.

## git-who versus git shortlog and git blame

The obvious alternative is git shortlog -sn, which also counts commits per author. The difference is scope and filtering. git shortlog operates on the commit range you hand it and does not know about paths in the same way: you can pipe git log -- path into it, but that is composition, not a built-in argument. git-who takes a path or a commit-ish directly and produces a table with a Last Edit column alongside the count, which is the piece git shortlog does not give you. Knowing that an author has 800 commits in a directory and that their last one was eight months ago is a different signal from knowing they have 800 commits.

The other alternative is git blame itself, and the README is explicit that the two answer different questions. git blame is line-oriented and file-oriented; git-who is tree-oriented. They are complements. A practical pattern is to use git-who to find the directory owner, then git blame on the specific file to find the line author, but the README does not describe any integration between the two and you would be running two separate commands.

## Maintenance status, licence and what an upgrade costs you

The repository is not archived, and the last push was on 2026-05-28. The most recent tagged release in the list is v1.3 from 2026-01-24, following v1.2 in 2025-07-31 and v1.1 in 2025-05-30. That is a release cadence of roughly two per year, with commits landing between them.

The licence is MIT, which permits commercial and private use, modification and redistribution provided the copyright notice and permission notice are retained. That is a permissive licence with no copyleft obligation and no source-disclosure requirement. This is a description of the licence text, not legal advice; if the licence matters to your organisation's policy, read the LICENSE file in the repository.

Upgrade cost is low by construction. git-who is a single binary with no daemon and no configuration file described in the README. The dependencies listed in go.mod are small and mostly indirect: doublestar for glob matching, go-cmp, go-runewidth and golang.org/x/term, plus uniseg and golang.org/x/sys as indirect requirements. There is no database, no cache directory and no state to migrate between versions. Upgrading means replacing the binary. The one thing to check after an upgrade is whether the table output format changed, since anything parsing that box-drawn output will break on a column change.

## Conclusion

Adopt git-who if you need a quick ownership picture of a directory, a release tag or a range like v3.10.9..v3.11.9, and you are comfortable with commit counts as a proxy for contribution. Do not adopt it if you need line-level attribution, per-file blame or a machine-readable report: the README documents three human-readable subcommands and no export format. Before relying on it, run it on a path you already know well, such as Tools/ in a clone you have worked in, and check whether the ranking matches what you believe about that directory. The MIT licence lets you do that without asking anyone.

## FAQ

### How do I install git-who?

The README lists precompiled binaries on the releases page, brew install git-who on macOS, and go install github.com/sinclairtarget/git-who@latest for anyone with a Go toolchain. Building from source additionally requires Ruby and the rake gem.

### What is the difference between git-who and git blame?

git blame tells you who wrote a line of code, while git-who tells you the people responsible for entire components or subsystems. The README describes git-who as git blame for file trees rather than individual files.

### How do I check who am I in git with git-who?

git-who does not report the current user's identity. It reports authorship across a repository, so the table subcommand shows every author who has made commits, not which one you are.

## Sources

- [Issues](https://github.com/sinclairtarget/git-who/issues)
- [License: MIT](https://github.com/sinclairtarget/git-who/blob/master/LICENSE)
- [README](https://github.com/sinclairtarget/git-who/blob/master/README.md)
- [Releases](https://github.com/sinclairtarget/git-who/releases)
- [sinclairtarget/git-who on GitHub](https://github.com/sinclairtarget/git-who)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/sinclairtarget-git-who