Open-source project
prontolabs/pronto avatar
prontolabs/pronto

pronto diffs against master, and its CI example fetches ten commits deep

Quick automated code review of your changes

2,670 stars251 forksRubyMIT

At a glance

What is it?
A Ruby gem that runs linters over changed lines only, then posts findings as GitHub comments, commit statuses or batched pull request reviews. Its own repository shows where the edges are: a master default, a depth 10 shallow fetch, one exit code for every kind of finding, and a gem release that stopped in December 2025 while the branch kept moving.
Who is it for?
pronto suits a repository whose default branch is master, or one where you pass -c on every invocation, and the formatter set is the reason to try it: five GitHub shapes plus GitLab and Bitbucket on top of one diff engine. Two things to check before wiring it into a pipeline.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 77 days ago.
What is it written in?
Mainly Ruby, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • prontolabs/pronto2,670 ★ · -2
Star history
Repository2026-10-042026-11-15
prontolabs/pronto2.7k2.7k

-2 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The README warns that it can be ahead of the gem you installed

The line under the introduction says it plainly: this README might be ahead of the latest release, and it links to the copy for v0.11.5. That is not a hedge left over from an old template. The newest gem release is 0.11.5 from 5 December 2025, and the default branch master took its last commit on 30 August 2026, close to nine months later. Everything between those two dates, the flag table and the formatter list included, describes a master branch that `gem install pronto` will not hand you. The two earlier tags sit at v0.11.4 in May 2025 and v0.11.3 in January 2025, so the release line has also been quiet for most of a year. A reader who pins the gem and reads this page is reading documentation for different code.

The GitHub Actions example fetches ten commits and no tags

The workflow offered as a copy and paste file starts with a fetch that is unusually narrow:

yml
- run: |
    git fetch --no-tags --prune --depth=10 origin +refs/heads/*:refs/remotes/origin/*

Depth 10 keeps the checkout cheap, and --no-tags leaves no tag to compare against. Pronto's own documented modes need more history than that. `pronto run --commit=$(git log --pretty=format:%H | tail -1)` analyzes every change back to the initial commit, and in a ten commit window that initial commit is simply absent. The same file then runs `pronto run -f github_status github_pr -c origin/${{ github.base_ref }}`, so the diff base is a remote tracking ref the shallow fetch just created. The file still pins `actions/checkout@v2` and `ruby/setup-ruby@v1`, action majors from an earlier era than the branch's last commit.

One exit code covers warnings, errors and security findings

The options table is six rows long and one of them decides how a pipeline reacts. `--exit-code` exits with a non-zero code if there were any warnings or errors. There is no separate status per severity, and no threshold in the table for how many findings it takes. The runners ship as separate gems and cover style through pronto-rubocop, duplication through pronto-flay and security holes through pronto-brakeman, and all three arrive through that one flag. A pipeline that wants to block on a security finding while only commenting on style finds nothing in this table to express the difference, so it has to filter the formatter output itself or run two invocations narrowed with `-r/--runner`.

master is the default diff base and the exception lives in a callout

Pronto runs its checks on a diff between the current HEAD and a commit-ish, and the default for that commit-ish is master. This repository's own default branch is master, so the default is exactly right for the tool's own repository and wrong for most of the rest of GitHub, where the convention is main. The escape hatch is a single callout near the top: if the default branch is not master, invoke `pronto run -c=<branch>` or set the `default_commit` config value. The installation section does not mention it, and every worked example on the page hardcodes `-c origin/master` or the GitHub Actions base ref. GitLab and Bitbucket take the same flag, so a main based mirror of any of the three needs the edit repeated in every invocation.

Thirty comments per review, written with an unbalanced parenthesis

The mode that posts findings as pull request reviews rather than loose comments splits its output to stay under provider rate limits, and the arithmetic is given as a fence with no language tag at all:

code
X = N / {PRONTO_WARNINGS_PER_REVIEW || warnings_per_review || 30})

The expression ends with a closing parenthesis that has nothing open in front of it, which is a small sign the line was typed into a README rather than run anywhere. The precedence is the environment variable, then `warnings_per_review` in config, then 30, and the sentence after the fence repeats that 30 default in words. The worked command then sets PRONTO_WARNINGS_PER_REVIEW to the same 30 the default already supplies:

sh
$ PRONTO_WARNINGS_PER_REVIEW=30 PRONTO_GITHUB_ACCESS_TOKEN=token pronto run -f github_pr_review -c origin/master

So the one number in this section that looks adjustable ships as a no-op in its own example.

Five GitHub formatter flags and a token that can sit in a config file

The formatter flags are the reason to care about this gem. `github` writes comments on commits, `github_pr` puts them on the pull request diff, `github_pr_review` batches them into reviews, `github_status` submits commit statuses, and `github_combined_status` collapses the per runner statuses into one when you do not want a row per check. All of them need `PRONTO_GITHUB_ACCESS_TOKEN`, an OAuth token with access to the repository, and the same page also accepts that value in `.pronto.yml`. A YAML file in the repository root is an ordinary thing to commit, so the documented alternative to an environment variable is a live credential sitting in a tracked file. GitLab has its own `GitlabFormatter`, and the page points at a Bitbucket integration, but only the GitHub path gets a complete worked example.

The rake task loads every pronto gem the machine happens to have

The path that avoids GitHub Actions is a Ruby snippet rather than a shell command:

ruby
Pronto::GemNames.new.to_a.each { |gem_name| require "pronto/#{gem_name}" }

`Pronto::GemNames.new.to_a` walks whatever pronto-* gems are installed and requires each one, so the runner set becomes whatever the machine already has instead of a declared list. The same snippet names three formatter classes, `GithubFormatter`, `GithubPullRequestFormatter` and `GithubPullRequestReviewFormatter`, pairs them with a status formatter, and hands the array to `Pronto.run('origin/master', '.', formatters)`. The install section offers the declared alternative, two `gem 'pronto-...', require: false` lines in a Gemfile, which is the form where the runner list stays visible and reviewable.

Runners live in other repositories while this one dogfoods rubocop

Everything pronto actually checks is a separate gem: pronto-rubocop for the styleguide, pronto-flay for duplication, pronto-brakeman for security holes, each linked from the introduction to its own repository under the same org. The runner inventory is therefore not in this repository and can drift from what the runners section on the site says. What is in the repository is the consumer side. There is a .rubocop.yml, a .rspec, a spec directory, a Rakefile, a Gemfile, pronto.gemspec, a CHANGELOG.md, a CONTRIBUTING.md, an MIT LICENSE and a pronto.gif. Installing the main gem gives you the diff engine and the formatters, and the install section is explicit that runners go in alongside it, with two commands and two Gemfile lines shown as the two ways.

Editorial conclusion

pronto suits a repository whose default branch is master, or one where you pass -c on every invocation, and the formatter set is the reason to try it: five GitHub shapes plus GitLab and Bitbucket on top of one diff engine. Two things to check before wiring it into a pipeline. First, the newest gem release is 0.11.5 from 5 December 2025 while master took its last commit on 30 August 2026, so decide whether you want the released gem or the branch. Second, --exit-code returns the same non-zero status for warnings and errors, so a security finding from pronto-brakeman and a style note from pronto-rubocop will fail the same job until you split the run by -r.

Frequently asked questions

What does the pronto gem actually check?

It runs analysis on a diff between the current HEAD and a commit-ish, which defaults to master, so only changed lines are examined. The checks themselves are separate gems: pronto-rubocop, pronto-flay and pronto-brakeman, installed alongside the main gem.

How do I make pronto compare against main instead of master?

Pass the base explicitly with `pronto run -c=<branch>`, or set the `default_commit` config value in `.pronto.yml`. This repository's own default branch is master, and the worked examples on the page all pass `-c origin/master` or the GitHub Actions base ref.

Why does pronto post several pull request reviews instead of one?

The github_pr_review formatter divides pending comments into batches so a single run does not hit the provider rate limit. The batch size comes from PRONTO_WARNINGS_PER_REVIEW, then warnings_per_review in config, then a default of 30.

Where does pronto keep its GitHub access token?

In the PRONTO_GITHUB_ACCESS_TOKEN environment variable, or as a value in `.pronto.yml`. It is an OAuth token that needs access to the repository, and the same variable is set on the command line in the PRONTO_PULL_REQUEST_ID examples.

Does pronto work outside GitHub?

Yes. `GitlabFormatter` posts comments on GitLab commits and the page carries a Bitbucket integration section. Outside CI entirely, pronto runs from a shell with `--staged` for the index and `--unstaged` for work in progress.

Official sources

  1. Issues
  2. License: MIT
  3. prontolabs/pronto on GitHub
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/prontolabs-pronto.svg)](https://hysenlabs.com/projects/prontolabs-pronto)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/prontolabs-pronto.svg)](https://hysenlabs.com/projects/prontolabs-pronto)

Was this useful?