Skip to content
Back to search

gitwarren

GitWarren: code review on your own machine, for you and your coding agents.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/klarluft/gitwarren-app with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/klarluft/gitwarren-app'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/klarluft--gitwarren-app/badge.svg)](/listings/klarluft--gitwarren-app)

HTML

<a href="/listings/klarluft--gitwarren-app"><img src="/api/listings/klarluft--gitwarren-app/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

The desktop app

Download it from **[gitwarren.com](https://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](docs/cli.md).

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](docs/agents.md#installing-it-as-a-plugin).

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 30 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "gitwarren",
  3. "owner": {
  4. "name": "Klarluft B.V.",
  5. "email": "contact@klarluft.com",
  6. "url": "https://klarluft.com"
  7. },
  8. "description": "GitWarren: code review on your own machine, for you and your coding agents.",
  9. "plugins": [
  10. {
  11. "name": "gitwarren",
  12. "source": "./",
  13. "description": "Code review on your own machine, for you and your coding agent. The agent opens a review of what it changed and hands you a link; you comment on lines; it replies and fixes. Nothing leaves your computer.",
  14. "version": "1.0.1",
  15. "author": {
  16. "name": "Klarluft B.V.",
  17. "email": "contact@klarluft.com",
  18. "url": "https://klarluft.com"
  19. },
  20. "homepage": "https://gitwarren.com",
  21. "tags": [
  22. "code-review",
  23. "git",
  24. "diff",
  25. "mcp",
  26. "local-first"
  27. ]
  28. }
  29. ]
  30. }
README.md · README · 206 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <img src="src/renderer/src/assets/logo.png" alt="" width="112" height="112" />
  2. # GitWarren
  3. [![Build status](https://github.com/klarluft/gitwarren-app/actions/workflows/ci.yml/badge.svg)](https://github.com/klarluft/gitwarren-app/actions/workflows/ci.yml)
  4. [![Version on npm](https://img.shields.io/npm/v/gitwarren)](https://www.npmjs.com/package/gitwarren)
  5. [![Downloads a month from npm](https://img.shields.io/npm/dm/gitwarren)](https://www.npmjs.com/package/gitwarren)
  6. [![License: GPL-3.0-or-later](https://img.shields.io/badge/license-GPL--3.0--or--later-blue)](LICENSE)
  7. [![MCP server rated A on Glama](https://glama.ai/mcp/servers/klarluft/gitwarren-app/badges/score.svg)](https://glama.ai/mcp/servers/klarluft/gitwarren-app)
  8. **Code review for your own git repositories, on your own machines.** Your
  9. machines, your agents, no one else's server — and no account.
  10. Built for the moment a coding agent — Claude Code, Codex, or anything else that
  11. edits files on your disk — has just finished, and its work is sitting in your
  12. worktree uncommitted. Read that diff here, on your own machine, before it
  13. becomes a commit.
  14. **[gitwarren.com](https://gitwarren.com)** has downloads for macOS, Windows and
  15. Linux.
  16. <a href="https://gitwarren.com"><img src="docs/review-uncommitted.png" alt="A GitWarren review: the files-changed tab with staged, unstaged and untracked work folded into the diff, and the amber uncommitted badge in the branch header" width="800" /></a>
  17. ---
  18. ## What it does
  19. Tell GitWarren which local git repositories you care about, then open **reviews**
  20. against them — a review is a comparison of two refs, presented the way a pull
  21. request is, with *conversation*, *commits* and *files changed* tabs, and a
  22. *browse files* tab for the code the change did not touch.
  23. - **Review work before it is a commit.** If the branch you are reviewing is
  24. checked out in a worktree, GitWarren finds that worktree — wherever it is — and
  25. folds its staged, unstaged and untracked changes into the diff. That is exactly
  26. when review is most useful, and it is the part that makes this worth having.
  27. - **Prose as well as code.** Diffs read unified or side by side, with the
  28. changed words picked out of a changed line. A Markdown file can be read
  29. rendered, with its edits marked like tracked changes, and commented on
  30. paragraph by paragraph.
  31. - **Nothing is cached.** Every branch name, commit and diff on screen is read
  32. from git at the moment it is shown.
  33. - **Nothing leaves your machine.** Reviews live in one SQLite file in your
  34. application-data directory. No account, no telemetry; the desktop app's one
  35. outbound request is the update check.
  36. - **Agents are first-class.** Local AI agents get the same capabilities through
  37. an MCP server over stdio — they open reviews, read your comments, reply in a
  38. thread and resolve what they fixed.
  39. - **Desktop app or browser.** It runs as an Electron app on macOS, Windows and
  40. Linux, or as a command that serves the same review UI into a browser tab. Same
  41. renderer either way; the shell is the only thing that differs.
  42. - **Your other machines too.** A machine with no screen at all — a VPS, a WSL
  43. distro, a box an agent works on — runs the headless half and is reviewed from
  44. somewhere else, over SSH, over `wsl.exe`, or over your own tailnet, and its
  45. repositories are listed on the same home screen as this machine's. Reviews
  46. live on the machine the code is on and stay there; nothing is replicated or
  47. relayed anywhere but the computers you already own.
  48. Comments go on the line, the way a pull request does them. The agent that
  49. wrote the code answers in the same thread, while you are still reading the
  50. diff:
  51. <a href="https://gitwarren.com"><img src="docs/comment-on-a-line.gif" alt="A line in the diff is hovered, the comment composer opens, a question about Escape handling is typed and submitted, and Claude Code answers in the same thread" width="800" /></a>
  52. ---
  53. ## Install
  54. ### The desktop app
  55. Download it from **[gitwarren.com](https://gitwarren.com)**, or on macOS:
  56. ```bash
  57. brew install --cask klarluft/tap/gitwarren
  58. ```
  59. ### The command line
  60. Serves the same review UI in a browser instead of an Electron window — for a
  61. machine that will not have the app on it, or one with no screen at all:
  62. ```bash
  63. brew install klarluft/tap/gitwarren-cli # macOS and Linux, brings its own Node
  64. curl -fsSL https://gitwarren.com/install.sh | sh # macOS and Linux, no Homebrew needed
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 84 on GitHub
  65. npx gitwarren serve # anywhere Node 22.14+ is, including Windows
  66. ```
  67. Then `gitwarren serve --open`. See
  68. [The `gitwarren` command line](docs/cli.md).
  69. ### Into a coding agent
  70. If you arrive from a coding agent, start here instead. The plugin brings the MCP
  71. server and a note that teaches the agent when to open a review and how to answer
  72. your comments:
  73. ```bash
  74. /plugin marketplace add klarluft/gitwarren-app # Claude Code, then:
  75. /plugin install gitwarren@gitwarren
  76. gemini extensions install https://github.com/klarluft/gitwarren-app
  77. npx skills add klarluft/gitwarren-app # the note alone, for any agent
  78. ```
  79. Cursor, Codex, VS Code and Kiro read the same repository from their plugin
  80. screens. See [Installing it as a plugin](docs/agents.md#installing-it-as-a-plugin).
  81. ---
  82. ## Documentation
  83. | Guide | What is in it |
  84. | --- | --- |
  85. | [Reviews](docs/reviews.md) | 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 |
  86. | [Agent access (MCP)](docs/agents.md) | The MCP tools, installing the plugin, how an agent links you back into the app, comment threads, images |
  87. | [The `gitwarren` command line](docs/cli.md) | `serve`, `service install`, the four ways to install the CLI, updating and removing it |
  88. | [Your other machines](docs/remote-hosts.md) | Reaching a repository over SSH, over `wsl.exe` from Windows, on your tailnet, and from a phone |
  89. | [Architecture](docs/architecture.md) | The stack, the shared service layer both surfaces call, and what is and is not stored |
  90. | [Development](docs/development.md) | Running from source, the project layout, database migrations |
  91. | [Releasing](docs/releasing.md) | Cutting a release, auto-update, code signing and notarization |
  92. | [The Glama build spec](docs/glama-build-spec.md) | The fields Glama's admin page actually reads, and why they say what they say |
  93. | [Known limitations](docs/limitations.md) | What GitWarren does not do, and why |
  94. | [GitWarren across hosts](docs/across-hosts.md) | The design plan behind the remote-host model |
  95. Agents setting GitWarren up on a user's machine should read
  96. [llms-install.md](llms-install.md).
  97. ---
  98. ## Contributing
  99. Contributions are welcome. Anything larger than a bug fix starts as a discussion
  100. in
  101. [Ideas](https://github.com/klarluft/gitwarren-app/discussions/categories/ideas),
  102. so the shape can be agreed before you spend time on it; once it is settled it
  103. becomes an issue. See [CONTRIBUTING.md](CONTRIBUTING.md) for the development
  104. workflow, the two design constraints that changes need to respect, and what a
  105. good pull request looks like here.
  106. Before a first contribution can be merged you will be asked to sign the
  107. [Contributor License Agreement](CLA.md). A bot handles it on your pull request;
  108. it takes about ten seconds and only happens once. The CLA keeps copyright in the
  109. codebase in one place, which is what makes it possible to offer GitWarren under
  110. a commercial licence alongside the GPL, or to change licence later, without
  111. having to track down every past contributor. You keep full ownership of your
  112. work and can use it elsewhere however you like.
  113. ---
  114. ## Support and privacy
  115. Questions, ideas and setups worth copying go to
  116. [Discussions](https://github.com/klarluft/gitwarren-app/discussions) —
  117. [Q&A](https://github.com/klarluft/gitwarren-app/discussions/categories/q-a) if
  118. you are stuck on something,
  119. [Ideas](https://github.com/klarluft/gitwarren-app/discussions/categories/ideas)
  120. for a feature, and
  121. [Show and tell](https://github.com/klarluft/gitwarren-app/discussions/categories/show-and-tell)
  122. for an agent or remote-machine arrangement other people should steal. Bugs you
  123. can describe — what GitWarren does, and when — go to
  124. [issues](https://github.com/klarluft/gitwarren-app/issues). Anything you would
  125. rather not post publicly goes to **contact@klarluft.com**.
  126. GitWarren keeps everything on your machine: reviews live in one SQLite file in
  127. your application-data directory, the diff is read from your git worktree, and
  128. there is no account and no telemetry. The desktop app's one outbound request is
  129. the auto-update check against this repository's GitHub Releases. The website's
  130. [privacy policy](https://gitwarren.com/privacy/) covers gitwarren.com itself.
  131. ---
  132. ## License
  133. GitWarren is free software, licensed under the **GNU General Public License,
  134. version 3 or (at your option) any later version**. The full text is in
  135. [LICENSE](LICENSE).
  136. In short: you may use, study, modify and redistribute it, including
  137. commercially. If you distribute a modified version, or a program that
  138. incorporates this one, you must release that under the GPL as well and make the
  139. source available. That reciprocity is the point — it keeps GitWarren and
  140. anything built on it open.
  141. The copyright is held by **Klarluft B.V.** (Rotterdam, The Netherlands · KVK
  142. 86875590), and every contribution is covered by the [CLA](CLA.md). Because the
  143. copyright sits in one place rather than being spread across contributors, a
  144. licence other than the GPL — for embedding GitWarren in a closed-source product,
  145. for instance — can be granted on request: email **contact@klarluft.com**.
  146. [Michal Wrzosek](https://github.com/michal-wrzosek) (<michal@wrzosek.pl>) is the
  147. creator of GitWarren and currently its main maintainer.
  148. ```
  149. Copyright © 2026 Klarluft B.V.
  150. This program is free software: you can redistribute it and/or modify it under
  151. the terms of the GNU General Public License as published by the Free Software
  152. Foundation, either version 3 of the License, or (at your option) any later
  153. version.
  154. This program is distributed in the hope that it will be useful, but WITHOUT ANY
  155. WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  156. PARTICULAR PURPOSE. See the GNU General Public License for more details.
  157. You should have received a copy of the GNU General Public License along with
  158. this program. If not, see <https://www.gnu.org/licenses/>.
  159. ```
packaging/install.sh · Bundled script · 158 lines · 1 finding marked
  1. #!/bin/sh
  2. # GitWarren's command line, installed from a release tarball.
  3. #
  4. # curl -fsSL https://gitwarren.com/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 4 on GitHub
  5. #
  6. # For a Linux or macOS machine with no Homebrew and no Node: the tarball brings
  7. # its own Node, so nothing has to be on the machine but a shell, `tar` and
  8. # `curl` (or `wget`). Windows is not served here - `npx gitwarren` is the
  9. # answer there, and a `.tar.gz` is not how anything is installed on it.
  10. #
  11. # ## It lays the files out exactly as the app does
  12. #
  13. # When the desktop app installs GitWarren onto another machine over ssh
  14. # (`src/core/hosts/install.ts`), the tarball goes into
  15. # `~/.gitwarren/daemon/<version>/` and the stable `~/.gitwarren/bin/gitwarren`
  16. # points into it. This script produces the same layout by the same steps,
  17. # down to the unpack-then-rename and the final `gitwarren service install
  18. # --no-login-item`, which is what writes the launchers. So a machine set up by
  19. # this script is one the app already knows how to upgrade, and a machine the
  20. # app set up is one this script can bring forward - there is one layout, not
  21. # two.
  22. #
  23. # Set GITWARREN_VERSION to install a specific release instead of the latest.
  24. #
  25. # ## Afterwards, the program does this itself
  26. #
  27. # `gitwarren update` is this script from the inside, and is the better way to
  28. # move forward: it restarts the background daemon, which this cannot - a
  29. # launcher pointing at the new install does nothing for a `serve` that is
  30. # already running - and it removes the version it replaced, which this does not
  31. # either. `gitwarren uninstall` undoes the whole of it, launchers and login
  32. # item included. Both are in `src/cli/`.
  33. #
  34. # This script stays the way *in*, because there is nothing to run yet when it
  35. # is needed.
  36. set -eu
  37. repo="klarluft/gitwarren-app"
  38. root="$HOME/.gitwarren"
  39. say() { printf '%s\n' "$*" >&2; }
  40. die() { say "install.sh: $*"; exit 1; }
  41. # 1. Which tarball. The same mapping as `targetFromUname` in
  42. # src/core/hosts/release.ts: Linux says aarch64 where macOS says arm64.
  43. kernel="$(uname -s)"
  44. machine="$(uname -m)"
  45. case "$machine" in
  46. x86_64 | amd64) arch="x64" ;;
  47. aarch64 | arm64) arch="arm64" ;;
  48. *) die "no GitWarren build for $kernel/$machine. Linux and macOS on x86-64 or arm64 are what the release builds." ;;
  49. esac
  50. case "$kernel" in
  51. Linux) target="linux-$arch" ;;
  52. Darwin) target="darwin-$arch" ;;
  53. *) die "no GitWarren build for $kernel/$machine. Linux and macOS on x86-64 or arm64 are what the release builds." ;;
  54. esac
  55. # 2. How to fetch. curl first because it is what the one-liner names; wget
  56. # because a minimal Debian has that and not curl.
  57. if command -v curl >/dev/null 2>&1; then
  58. fetch() { curl -fsSL "$1" -o "$2"; }
  59. latest_tag() { curl -fsSLI -o /dev/null -w '%{url_effective}' "https://github.com/$repo/releases/latest"; }
  60. elif command -v wget >/dev/null 2>&1; then
  61. fetch() { wget -qO "$2" "$1"; }
  62. latest_tag() { wget -qO /dev/null --max-redirect=5 -S "https://github.com/$repo/releases/latest" 2>&1 | sed -n 's/^ *Location: *//p' | tail -1; }
  63. else
  64. die "neither curl nor wget is installed, and one of them is needed to download GitWarren."
  65. fi
  66. # 3. Which version. `releases/latest` on github.com, not the API: it answers
  67. # with a redirect to the newest stable release, and it has no rate limit to
  68. # run into. Prereleases are skipped by it, which is right for a one-liner.
  69. version="${GITWARREN_VERSION:-}"
  70. if [ -z "$version" ]; then
  71. version="$(latest_tag | sed -n 's|.*/tag/v\{0,1\}\([^/]*\)$|\1|p')"
  72. [ -n "$version" ] || die "could not work out the latest release from https://github.com/$repo/releases/latest"
  73. fi
  74. version="${version#v}"
  75. dest="$root/daemon/$version"
  76. launcher="$root/bin/gitwarren"
  77. if [ -x "$launcher" ] && [ "$("$launcher" --version 2>/dev/null || true)" = "$version" ]; then
  78. say "GitWarren $version is already installed at $dest."
  79. say "Run \`gitwarren serve\` to start it, or \`gitwarren doctor\` to check it over."
  80. exit 0
  81. fi
  82. asset="gitwarren-daemon-$version-$target.tar.gz"
  83. url="https://github.com/$repo/releases/download/v$version/$asset"
  84. work="$(mktemp -d "${TMPDIR:-/tmp}/gitwarren-install.XXXXXX")"
  85. trap 'rm -rf "$work"' EXIT
  86. say "Downloading GitWarren $version for $target..."
  87. fetch "$url" "$work/$asset" || die "could not download $url"
  88. # 4. The checksum, from the same release. The Homebrew formula attached to
  89. # every release names the sha256 of each tarball, and was written by the run
  90. # that built them - so it is the release's own statement of what the bytes
  91. # should be, and checking against it costs one small download.
  92. if command -v sha256sum >/dev/null 2>&1; then
  93. sum() { sha256sum "$1" | cut -d' ' -f1; }
  94. elif command -v shasum >/dev/null 2>&1; then
  95. sum() { shasum -a 256 "$1" | cut -d' ' -f1; }
  96. else
  97. sum() { :; }
  98. fi
  99. if fetch "https://github.com/$repo/releases/download/v$version/gitwarren-cli.rb" "$work/formula.rb" 2>/dev/null; then
  100. expected="$(grep -A1 -F "/$asset\"" "$work/formula.rb" | sed -n 's/.*sha256 "\([0-9a-f]*\)".*/\1/p' | head -1)"
  101. actual="$(sum "$work/$asset")"
  102. if [ -n "$expected" ] && [ -n "$actual" ] && [ "$expected" != "$actual" ]; then
  103. die "the download did not match the checksum the release published for $asset. Not installing it."
  104. fi
  105. fi
  106. # 5. Unpack beside the destination and rename into place, so an interrupted
  107. # unpack can never leave a directory that exists, looks installed, and
  108. # cannot run. Same as the app's installer.
  109. mkdir -p "$root/daemon" "$root/bin"
  110. stage="$root/daemon/.install-$$"
  111. rm -rf "$stage"
  112. mkdir -p "$stage"
  113. tar xzf "$work/$asset" -C "$stage"
  114. chmod +x "$stage/gitwarren-daemon/bin/"* 2>/dev/null || true
  115. [ -x "$stage/gitwarren-daemon/bin/gitwarren" ] || { rm -rf "$stage"; die "the tarball did not contain bin/gitwarren"; }
  116. if [ -e "$dest" ]; then mv "$dest" "$stage/.previous"; fi
  117. mv "$stage/gitwarren-daemon" "$dest"
  118. rm -rf "$stage"
  119. # 6. The launchers, written by the binary just unpacked - which is also the
  120. # proof that it runs on this machine. `~/.gitwarren/bin/gitwarren` is the
  121. # command to put on PATH; `gitwarren-mcp` beside it is what an agent starts.
  122. if ! "$dest/bin/gitwarren" service install --no-login-item >/dev/null; then
  123. die "GitWarren unpacked into $dest but could not run. The $target build may be the wrong one for this machine."
  124. fi
  125. say ""
  126. say "GitWarren $version is installed."
  127. say ""
  128. case ":$PATH:" in
  129. *":$root/bin:"*) ;;
  130. *)
  131. say "Add its bin directory to your PATH - for example, in your shell's rc file:"
  132. say ""
  133. say " export PATH=\"\$HOME/.gitwarren/bin:\$PATH\""
  134. say ""
  135. ;;
  136. esac
  137. say "Then:"
  138. say ""
  139. say " gitwarren serve run it now, in this terminal"
  140. say " gitwarren service install or keep it running in the background, from now and at every login"
  141. say " gitwarren agent-setup the sentence to give a coding agent so it can use GitWarren"
  142. say ""
  143. say "From here on GitWarren looks after itself: \`gitwarren update\` moves to the next"
  144. say "release and \`gitwarren uninstall\` takes all of this back off the machine."

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.