Skip to main content
Glama

GitWarren

Build status Version on npm Downloads a month from npm License: GPL-3.0-or-later MCP server rated A on Glama

Code review for your own git repositories, on your own machines. Your machines, your agents, no one else's server — and no account.

Built for the moment a coding agent — Claude Code, Codex, or anything else that edits files on your disk — has just finished, and its work is sitting in your worktree uncommitted. Read that diff here, on your own machine, before it becomes a commit.

gitwarren.com has downloads for macOS, Windows and Linux.


What it does

Tell GitWarren which local git repositories you care about, then open reviews against them — a review is a comparison of two refs, presented the way a pull request is, with conversation, commits and files changed tabs, and a browse files tab for the code the change did not touch.

  • Review work before it is a commit. If the branch you are reviewing is checked out in a worktree, GitWarren finds that worktree — wherever it is — and folds its staged, unstaged and untracked changes into the diff. That is exactly when review is most useful, and it is the part that makes this worth having.

  • Prose as well as code. Diffs read unified or side by side, with the changed words picked out of a changed line. A Markdown file can be read rendered, with its edits marked like tracked changes, and commented on paragraph by paragraph.

  • Nothing is cached. Every branch name, commit and diff on screen is read from git at the moment it is shown.

  • Nothing leaves your machine. Reviews live in one SQLite file in your application-data directory. No account, no telemetry; the desktop app's one outbound request is the update check.

  • Agents are first-class. Local AI agents get the same capabilities through an MCP server over stdio — they open reviews, read your comments, reply in a thread and resolve what they fixed.

  • Desktop app or browser. It runs as an Electron app on macOS, Windows and Linux, or as a command that serves the same review UI into a browser tab. Same renderer either way; the shell is the only thing that differs.

  • Your other machines too. A machine with no screen at all — a VPS, a WSL distro, a box an agent works on — runs the headless half and is reviewed from somewhere else, over SSH, over wsl.exe, or over your own tailnet, and its repositories are listed on the same home screen as this machine's. Reviews live on the machine the code is on and stay there; nothing is replicated or relayed anywhere but the computers you already own.

Comments go on the line, the way a pull request does them. The agent that wrote the code answers in the same thread, while you are still reading the diff:


Related MCP server: git-mcp-server

Install

The desktop app

Download it from gitwarren.com, or on macOS:

brew install --cask klarluft/tap/gitwarren

The command line

Serves the same review UI in a browser instead of an Electron window — for a machine that will not have the app on it, or one with no screen at all:

brew install klarluft/tap/gitwarren-cli               # macOS and Linux, brings its own Node
curl -fsSL https://gitwarren.com/install.sh | sh      # macOS and Linux, no Homebrew needed
npx gitwarren serve                                   # anywhere Node 22.14+ is, including Windows

Then gitwarren serve --open. See The gitwarren command line.

Into a coding agent

If you arrive from a coding agent, start here instead. The plugin brings the MCP server and a note that teaches the agent when to open a review and how to answer your comments:

/plugin marketplace add klarluft/gitwarren-app       # Claude Code, then:
/plugin install gitwarren@gitwarren
gemini extensions install https://github.com/klarluft/gitwarren-app
npx skills add klarluft/gitwarren-app                 # the note alone, for any agent

Cursor, Codex, VS Code and Kiro read the same repository from their plugin screens. See Installing it as a plugin.


Documentation

Guide

What is in it

Reviews

What a review is, how uncommitted work is found, reading and navigating a large diff, side by side and wrapped lines, Markdown previews, browsing and searching the repository, marking files reviewed, opening a file in your editor, keyboard shortcuts

Agent access (MCP)

The MCP tools, installing the plugin, how an agent links you back into the app, comment threads, images

The gitwarren command line

serve, service install, the four ways to install the CLI, updating and removing it

Your other machines

Reaching a repository over SSH, over wsl.exe from Windows, on your tailnet, and from a phone

Architecture

The stack, the shared service layer both surfaces call, and what is and is not stored

Development

Running from source, the project layout, database migrations

Releasing

Cutting a release, auto-update, code signing and notarization

The Glama build spec

The fields Glama's admin page actually reads, and why they say what they say

Known limitations

What GitWarren does not do, and why

GitWarren across hosts

The design plan behind the remote-host model

Agents setting GitWarren up on a user's machine should read llms-install.md.


Contributing

Contributions are welcome. Anything larger than a bug fix starts as a discussion in Ideas, so the shape can be agreed before you spend time on it; once it is settled it becomes an issue. See CONTRIBUTING.md for the development workflow, the two design constraints that changes need to respect, and what a good pull request looks like here.

Before a first contribution can be merged you will be asked to sign the Contributor License Agreement. A bot handles it on your pull request; it takes about ten seconds and only happens once. The CLA keeps copyright in the codebase in one place, which is what makes it possible to offer GitWarren under a commercial licence alongside the GPL, or to change licence later, without having to track down every past contributor. You keep full ownership of your work and can use it elsewhere however you like.


Support and privacy

Questions, ideas and setups worth copying go to Discussions — Q&A if you are stuck on something, Ideas for a feature, and Show and tell for an agent or remote-machine arrangement other people should steal. Bugs you can describe — what GitWarren does, and when — go to issues. Anything you would rather not post publicly goes to contact@klarluft.com.

GitWarren keeps everything on your machine: reviews live in one SQLite file in your application-data directory, the diff is read from your git worktree, and there is no account and no telemetry. The desktop app's one outbound request is the auto-update check against this repository's GitHub Releases. The website's privacy policy covers gitwarren.com itself.


License

GitWarren is free software, licensed under the GNU General Public License, version 3 or (at your option) any later version. The full text is in LICENSE.

In short: you may use, study, modify and redistribute it, including commercially. If you distribute a modified version, or a program that incorporates this one, you must release that under the GPL as well and make the source available. That reciprocity is the point — it keeps GitWarren and anything built on it open.

The copyright is held by Klarluft B.V. (Rotterdam, The Netherlands · KVK 86875590), and every contribution is covered by the CLA. Because the copyright sits in one place rather than being spread across contributors, a licence other than the GPL — for embedding GitWarren in a closed-source product, for instance — can be granted on request: email contact@klarluft.com.

Michal Wrzosek (michal@wrzosek.pl) is the creator of GitWarren and currently its main maintainer.

Copyright © 2026 Klarluft B.V.

This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program. If not, see <https://www.gnu.org/licenses/>.

Available Tools

17 tools
add_repositoryAdd repositoryA

Start tracking a git repository. path may be any directory inside the working tree - it is resolved to the repository root before being stored, so the same repository cannot be added twice under two different paths. name defaults to the folder name. Fails with NOT_A_GIT_REPOSITORY if the path is not inside a git repository.

Inputs: path (required), name.

add_review_commentAdd review commentA

Start a new discussion on a review. Omit filePath and line for a comment on the review as a whole; give both to attach it to a line, the way a pull-request review comment works. side picks which side of the diff line counts on - "head" (the default) for the code as it will be, "base" to remark on a line the change removed. Add startLine to comment on a block rather than a single line; line is then the last line of it, and the one the whole range follows if the code moves. The line is not required to be part of the diff. A line the patch does not print is looked up in the file itself at the head, so a remark on code this branch did not touch anchors and follows that code exactly as one on a changed line does - people read these in the review's Browse files tab. Only a line that is in neither the diff nor the file (past the end of it, or on the "base" side outside the patch) is kept without an anchor; the returned thread says which happened. Comments are attributed automatically from the MCP handshake - see agent_identity.

To include a screenshot, write the file to disk first, then reference it as an ordinary markdown image:

The dropdown renders behind the modal:

![dropdown behind modal](/tmp/dropdown-bug.png)

The file is copied into GitWarren and the path rewritten, so the image survives /tmp being cleaned. Always write alt text - it is what agents without vision see.

If the path contains a space - "Screen Shot 2026-09-01 at 10.32.14.png", as macOS names screenshots - wrap it in angle brackets, or markdown does not read it as an image at all and it is left as plain text:

![login screen](</tmp/Screen Shot 2026-09-01 at 10.32.14.png>)

PNG, JPEG, GIF and WebP are accepted, up to 10 MB. A path that does not resolve is left in the text as written rather than failing the call, so check the returned body if it matters.

Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.

When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.

Inputs: body (required), reviewId (required), line, side, +4 more.

agent_identityAgent identityA
Idempotent

Show how comments from this session will be attributed, and optionally set a label for the session. The tool name ("Claude Code", "Codex", ...) is taken from the MCP handshake and cannot be changed - it is what makes attribution consistent across sessions. label is a short handle for this session ("auth-refactor"), worth setting when more than one agent is working the same review; it is remembered until this server process exits.

Inputs: label.

create_reviewCreate reviewA

Open a review comparing two refs in a tracked repository. baseRef is what the changes are measured against (usually the trunk) and headRef is the branch under review; the diff is taken from their merge base, like a pull request. Both refs must exist and share history, or the call fails with INVALID_INPUT. title defaults to " into ". If the head branch is checked out in a worktree, its uncommitted changes are part of the review as well - a review can be opened on work that has never been committed. Passing the same ref as both endpoints is allowed and does exactly that: the review then holds only the uncommitted work on that ref, and its title defaults to "Uncommitted work on ".

Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.

When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.

Inputs: baseRef (required), headRef (required), repositoryId (required), title, +1 more.

delete_review_commentDelete a commentA
DestructiveIdempotent

Delete one message. If it was the only message in its thread, the thread goes with it. As with editing, an agent can only delete messages written by its own tool.

Inputs: id (required).

get_repositoryGet repositoryA
Read-only

Fetch one tracked repository by id, with its live git state.

Inputs: id (required).

get_reviewGet reviewA
Read-only

Fetch one review by id, with the repository it belongs to attached (including the repository path, so the changes can be inspected with git directly).

Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.

When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.

Inputs: id (required).

list_repositoriesList repositoriesA
Read-only

List every git repository tracked in GitWarren, each with its live git state (whether the folder still exists, whether it is still a repository, and the current branch). Git state is read fresh on every call and is never cached.

Inputs: no named parameters.

list_review_commentsList review commentsA
Read-only

Every discussion on a review: review-level threads and line comments alike, each with its full message history and who wrote each message. Line threads also carry an anchor saying where they land in the code as it stands right now - "anchored" (the line is unchanged), "moved" (the code shifted and anchor.line is its current line) or "outdated" (the line is gone, so the comment may be about code that has since been rewritten). Threads about files the diff does not contain are resolved against those files at the head rather than against the patch, so a comment on unchanged code reports an honest anchor too. Check the anchor before acting on a line comment. An outdated one still carries anchorSnapshot, the code as it read when the comment was written, which is how to tell what was being objected to before it was rewritten.

A body may contain images, written as markdown pointing at a gitwarren://attachment/... URL - that is an internal token, not something to fetch. Each one is resolved in the comment's attachments array, where path is a real file on disk: read it with your own image tools. alt is the description whoever attached it wrote, and is worth reading first - it is often enough on its own, and it is all you get if you cannot see images.

Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.

When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.

Inputs: reviewId (required).

list_reviewsList reviewsA
Read-only

List reviews, newest activity first. Filter with repositoryId and/or status ("open" or "closed"); omit both to list every review across all tracked repositories. A review records the two refs being compared, not the commits they resolved to - read the repository with git to see the actual changes.

Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.

When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.

Inputs: status, repositoryId.

remove_repositoryRemove repositoryA
DestructiveIdempotent

Stop tracking a repository. This only removes it from GitWarren - the working copy on disk is never touched.

Inputs: id (required).

remove_reviewRemove reviewA
DestructiveIdempotent

Delete a review. This removes only the review record - no branch, commit or file in the repository is touched. To file a finished review away without deleting it, set its status to "closed" instead.

Inputs: id (required).

reply_to_review_commentReply to a review commentA

Add a message to an existing thread. Use this rather than opening a new thread when responding to something someone already raised, so the discussion stays in one place. Thread ids come from list_review_comments.

To include a screenshot, write the file to disk first, then reference it as an ordinary markdown image:

The dropdown renders behind the modal:

![dropdown behind modal](/tmp/dropdown-bug.png)

The file is copied into GitWarren and the path rewritten, so the image survives /tmp being cleaned. Always write alt text - it is what agents without vision see.

If the path contains a space - "Screen Shot 2026-09-01 at 10.32.14.png", as macOS names screenshots - wrap it in angle brackets, or markdown does not read it as an image at all and it is left as plain text:

![login screen](</tmp/Screen Shot 2026-09-01 at 10.32.14.png>)

PNG, JPEG, GIF and WebP are accepted, up to 10 MB. A path that does not resolve is left in the text as written rather than failing the call, so check the returned body if it matters.

Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.

When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.

Inputs: body (required), threadId (required), agentLabel.

resolve_review_commentResolve or reopen a threadA
Idempotent

Mark a discussion settled, or reopen one. Set resolved to true once the point has been addressed, false to bring it back. Resolving records who did it; it never deletes the messages, which stay readable.

Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.

When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.

Inputs: resolved (required), threadId (required).

update_repositoryUpdate repositoryA
Idempotent

Rename a tracked repository, or repoint it at a moved working copy. Provide at least one of name or path. A new path is validated and resolved exactly as it is when adding.

Inputs: id (required), name, path.

update_reviewUpdate reviewA
Idempotent

Change a review's title, description or endpoints, or set its status to "closed" or "open" again. Provide at least one field. New refs are validated exactly as they are on creation.

Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.

When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.

Inputs: id (required), title, status, baseRef, +2 more.

update_review_commentEdit a commentA
Idempotent

Replace the text of one message. An agent can only edit messages written by its own tool - correcting yourself is expected, rewriting someone else's review is not.

Each result carries guiUrl, a link that opens this in GitWarren. Show it to the user - it exists to be clicked, and it is how they see this without going and finding it themselves. The link works whether or not GitWarren is running right now, so hand it over without checking anything. If the user says it will not open - the browser reports that the connection was refused - then GitWarren is not running on their machine, and starting it makes the same link work. When the page is served by gitwarren serve or by a plugin rather than by the app, the link also carries that launch's token, which the page exchanges for a cookie; a link minted before a restart says it needs a token, and the newest link is the one that works.

When this machine is reachable on the user's tailnet, results also carry webUrl. The two links are for two situations and neither replaces the other: guiUrl opens GitWarren on the machine the user is sitting at, which is the right one when that is this machine; webUrl opens the same review in a browser from any of their devices - a phone, a laptop across the room - because it names this machine on their tailnet. Offer webUrl when the user is not at this machine, and both when you do not know.

Inputs: id (required), body (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.3/5.0

    Scored across 17 tools

    Disambiguation5/5

    Every tool targets a distinct resource plus action: repositories, reviews, and review comments each have clear list/get/create/update/delete boundaries. The potential confusion between add_review_comment and reply_to_review_comment is fully resolved by their descriptions (new thread vs. reply to existing thread), and resolve/update/delete comments are clearly separate operations.

    Naming Consistency4/5

    The set overwhelmingly follows a snake_case verb_noun pattern (list_repositories, create_review, update_review_comment). It loses one point for minor inconsistencies: agent_identity is a noun rather than a verb-led name, and delete_review_comment uses 'delete' while the other destructive tools use 'remove'.

    Tool Count4/5

    At 17 tools the server is slightly above the ideal 3-15 range, but the count is justified by covering two resource domains (tracked repositories and reviews) plus full threaded comment operations and an identity/attribution tool. It feels a touch heavy rather than bloated or redundant.

    Completeness5/5

    Repositories have full lifecycle coverage (list/get/add/update/remove), reviews have list/get/create/update/remove plus open/closed status handling through update, and comments support listing, adding, replying, resolving, editing, and deleting. The identity tool fills the attribution gap that a multi-agent review workflow needs, leaving no obvious dead ends.

    Maintenance

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      A collaborative code and markdown review tool that bridges human reviewers and AI agents, enabling both to browse files, inspect git diffs, leave structured comments, and save a final review report from the same UI in real time.
      2
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      A local MCP server that provides a safe, explicit set of Git operations for version control tasks like status, diff, branching, staging, committing, fetching, merging, and pushing.
      13
      5 npm
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      A review handoff tool for agent-driven coding sessions that captures worktree diffs, creates shareable review URLs, and streams reviewer feedback back to the agent.
      1
      ISC