Repowise PR Bot

Know what a pull request breaks before you merge it.

The bot reads the index of your repository and comments on the pull requests that need it: the callers a change breaks, the file that usually moves with it, the tests to run first. Free and deterministic, or an AI review of every code change for cents a pull request.

Install on GitHubSee a real review
Signals
Free, deterministic
AI review
About 9 cents a PR
Review check
On every push
Runs onGitHubGitHub ActionsGitLabBitbucket
repowise-bot · commented on a pull request

3 things to check

Signals · no model
Reaches
hook_flag_enabled added the required *. 5 callers outside this PR still expect the old one.
Moves with
.../perf/dialects/ts_js.py changed with this file in 11 past commits and is not in this PR.
Run first
test_cobol.py, test_bare_name_index_kinds.py: they import the changed files.
Merge check
Repowise code healthhealth of changed files 2.1, unchanged

Full report · no sign-in

Every caller of the contracts it changes, and health before and after.

Composed from real Signals comments on repowise-dev/repowise #2650, #2599 and #2609. The check row is the optional merge gate.

The comment

One comment, and only when it counts.

No model in Signals
The comment is built from the index of your repository: parsed code, the call graph, git history and a 25-marker health scorer. The same diff always gets the same comment, and no line of your code goes to a model.
Quiet unless it counts
In Signals a pull request with nothing to act on gets no comment. It speaks when a contract breaks, a companion file is missing, tests are missing or health drops. AI review speaks when it has a point to raise, and the Repowise review check reports every push, clean or not.
One comment, kept current
New commits edit the comment in place instead of stacking new ones. If a later push clears every signal, the stale comment is deleted.
A real repowise-bot comment on a repowise-dev/repowise pull request: three things to check (20 new findings across 5 files, a file getting worse, and 3 files that usually change with this PR's files but are not in it), health of changed files 7.1 to 7.3, and a link to the full report.
A real Signals comment on a repowise-dev/repowise pull request, as GitHub shows it.

What Signals catches

The things a reviewer cannot see in the diff.

A diff shows what changed. It does not show who calls it, what usually changes with it, or which tests cover it. Signals reads that from the index of your repository, with no model involved, and puts it on the PR.

  1. Callers a change breaks

    When a pull request changes a function's signature, the bot names the callers outside the pull request, with the full list on the report page. Symbol level, not file level, so a body-only edit stays quiet.

    hook_flag_enabled in packages/cli/src/repowise/cli/commands/augment_cmd/_shared.py added the required *. 5 callers outside this PR still expect the old one: .../augment_cmd/read_skeleton.py::enabled, .../augment_cmd/replacement.py::offer, .../augment_cmd/reread.py::enabled (+2 more)

    From a real comment on repowise-dev/repowise #2650

  2. Files that usually change together

    Git history knows which files move as a pair. When one of them is missing from a pull request, the bot names it, and when it is one file, how often they changed together.

    .../perf/dialects/python.py changed with .../perf/dialects/ts_js.py in 11 past commits and is not in this PR

    From a real comment on repowise-dev/repowise #2599

  3. Tests to run first

    The test files that import what changed, found from the import graph, so a reviewer knows which suites matter for this diff.

    Run .../parser/test_cobol.py, .../ingestion/test_bare_name_index_kinds.py, … first: they import the changed files

    From a real comment on repowise-dev/repowise #2609

  4. Safe moves and who to ask

    A refactor that only moves code says so in one line, so nobody hunts for breakage that is not there. The people who own the risky files are suggested as reviewers.

    ↪️ 15 symbols moved from parser_helpers.py to type_heads.py; … No caller has to change.

    👀 Suggested reviewers @Laex

    From a real comment on repowise-dev/repowise #2584

Also in the comment when it matters: the health change of the files you touched, hotspots, new findings and dead code. Everything that is context and not a decision sits behind one fold.

Review modes

Two modes, chosen per repository.

Pick a mode per repository in your settings. Signals is free and deterministic. AI review is paid from credits, pay as you go with no per-seat review fee, with a monthly AI spend limit per repository, $5 by default, and a limit per pull request, 60 cents by default. When one is reached the bot posts the free Signals comment and notes the pause.

AI review

Pro and Teams

About 9 cents a pull request

Every pull request that changes code

A model reviews every code change and goes deeper when the diff is risky: a wide blast radius, a hotspot, a high change risk. The deep review reads the code around the diff, a separate check confirms each point against the lines it cites, and each confirmed point posts as its own thread on that line.

repowise-botbotcommented on Oct 23
call_graph.py

P1 · Interface-only files displace direct importers from the cap

The sort key ranks any file with interface_calls above a file that only imports the target. The cap_collection call that follows keeps entries[:20], so a real importing dependent can be dropped from the shown callers and counted only as omitted. Sort every via: interface entry after all others first, then by the direct counts.

Checked: import-only entries sort as (0, 0) and interface-only entries as (0, -n), so interface-only files sort first and can displace importers at the 20-file cap.

Prompt for your agent

A real review thread on the diff of repowise-dev/repowise #4506

The author confirmed the point on this pull request and fixed it, with a test that fails on the old key, before it merged. Depth is light, auto or deep per repository, and /repowise review deep asks for a deep review on any pull request. A clean pull request gets no comment: the Repowise review check on the commit says it was reviewed.

Turn on AI review with Pro

Signals

Free on public repositories

Free, deterministic, no model call

Only when there is something to act on

Built from the index of your repository, so the same diff always gets the same comment and no line of your code goes to a model.

repowise-botbotcommented on Sep 26

🔍 2 things to check

  1. 2 files that usually change with this PR's files are not in it: packages/core/src/repowise/core/ingestion/models.py, packages/core/src/repowise/core/ingestion/parser.py
  2. Run .../parser/test_cobol.py, .../ingestion/test_bare_name_index_kinds.py, .../ingestion/test_call_resolver_strategies.py first: they import the changed files

✅ Health of changed files: 2.1 (unchanged)

A real comment, footer trimmed, on repowise-dev/repowise #2609

Two signals fired, so it spoke. A pull request with none gets no comment.

Cost

100 pull requests a month, reviewed for cents each.

What a month of review costs a 10-developer team opening 100 pull requests. Repowise prices the review a pull request gets, not the seats on the team, so the bill follows the reviews that run and a quiet month costs less.

Repowise PR bot

Estimated from the credit ledger on repowise-dev/repowise, October 2026

  • SignalsDeterministic, no model call. Free on public repositories$0 /mo
  • AI reviewAbout 9 cents a PR in credits, every code PR. Pro $15 a month, $5 included, no per-seat review feeabout $9 /mo

AI reviewers at list price

List prices from each vendor's pricing page, as of October 2026, for 10 developers and 100 pull requests a month

  • Qodo Pro TeamPooled credits at $0.012, about 139 a review on Qodo's estimateabout $167 /mo
  • GitHub Copilot Business$19 a seat, plus reviews at GitHub's published averages: $0.25 Lite, $1.50 Balanced, $10 Max$190 + usage /mo
  • CodeRabbit Essentials$24 a developer a month, billed annually$240 /mo
  • Greptile$1 a Base review ($3 Plus, $10 Apex), no seat fee$100 /mo
  • Cursor BugbotCursor Teams from $30 a user, Bugbot usage-basedfrom $300 + usage /mo

The working for every row is in AI code review pricing, compared.

Where it runs

On the pull request, and in the pipeline you already have.

The bot is a GitHub App. The gates behind it are open source and run anywhere: they judge a change on what it adds, never on the repository's past, and need no account, index, model or API key.

  • GitHub App

    The bot comments on pull requests, posts the optional merge check and marks findings on the lines. Public, private and organization repositories.

  • GitLab CI

    One include adds a job per gate to merge request pipelines. Doc drift and security findings land in the Code Quality widget.

  • Any CI, through the CLI

    Every gate is a plain command with an exit code. Jenkins and Bitbucket pipelines work too: the gates read the target branch from their pull request variables.

The gates

Patch coverage
Fails the change when its tests ran fewer of the changed lines than your minimum, with a stricter floor for the hotspots and the files that keep needing fixes. A change with only a few executable lines is reported, never failed.
Change risk
Fails a change bigger and more spread out than a percentile of your own recent commits, 95 for example. Judged against this repository's history, not a global constant.
Documentation drift
Fails when a document names a file, link, heading or command the change removed.
Security
Fails when the change adds a secret or a risky call at or above the severity you set.

With a coverage upload, the bot comment and the PR report show patch coverage and the uncovered ranges of each file, and Repowise / coverage can be a required check. The bot can open a draft pull request that adds the upload workflow for you.

Read the CI gates guideSet up coverage on the bot
GitHub Actions, after your tests write the report
- uses: repowise-dev/repowise@v0.59.0
  with:
    checks: coverage,doc-drift,security,risk
    coverage-report: coverage/lcov.info
    coverage-fail-under: 80
    coverage-fail-under-risky: 90
    risk-fail-above-percentile: 95
GitLab, .gitlab-ci.yml
include:
  - remote: https://raw.githubusercontent.com/repowise-dev/repowise/main/ci/gitlab/repowise.gitlab-ci.yml

variables:
  REPOWISE_COVERAGE_REPORT: coverage/lcov.info
  REPOWISE_COVERAGE_FAIL_UNDER: "80"
Any other CI
pip install repowise
repowise coverage check "origin/$TARGET...HEAD" --report coverage/lcov.info --fail-under 80
repowise risk --fail-above-percentile 95

Merge gate and controls

Gate the merge when you are ready.

The gate is off by default, because a bot that fails your build on day one gets uninstalled on day one. Configure it in your settings or in a .repowise/bot.yaml in the repository.

A check that can block the merge
Turn on the Repowise code health check as advisory, or blocking with a rule such as fail when repository health drops, or fail when the PR adds new findings. Branch protection can require it like any other check.
Findings on the lines
Off by default. Turn it on and changed signatures with outside callers and high and critical new findings are marked on the diff. AI review points also show as check annotations.
Threads that close themselves
When a later push changes the lines an AI review point quoted, the bot replies on that thread and resolves it. Replies and thumbs on each point are recorded.
Labels, if you want them
Optional repowise: labels such as gate-failed or missing-tests, kept in sync on every push.
Quiet when you ask
Add [skip repowise] to a PR title to skip one pull request. Comment /repowise recheck to run it again. Ignore generated or vendored paths per repository.

Every PR gets a page

The comment stays short. The page has everything.

Each comment links to a public report for that pull request: every caller of a changed contract, health before and after, the change-risk score, the tests that guard the change, and for an AI review, the pass that ran and the points the check withheld. No sign-in, so anyone on the PR can open it. A plain-text version is there for coding agents.

Open this report
repowise.dev/pr/repowise-dev/repowise/4506

repowise-dev/repowise · #4506

feat(context): list callers that reach an implementation through its interface

Change risk

9.1out of 10 · riskier than 67% of commits

Health of changed files

was 7.55, now 7.45

Files changed
3
Callers outside
0no contract changed
Code files tested
1 of 2inferred
New issues
97 medium

Run first

tests/unit/server/mcp/test_wrapper_callers.py · reaches the changed files through the call graph

Redrawn from the public report for repowise-dev/repowise #4506.

Security

Reads your code. Never runs it.

  • It cannot merge. It writes comments and, if you ask, a check and labels. The one file change it can make is the coverage setup pull request, opened as a draft for you to review.
  • In Signals mode no line of your code goes to a model, because there is no model.
  • AI review runs only on repositories where you turn it on in your settings. A repository file cannot switch it on or raise its cap, so a fork cannot turn paid review on. Once on, it reviews every pull request, forks included, within the monthly cap.

GitHub permissions requested

Contents
Read. Write only for the one-click coverage setup
Metadata
Read
Pull requests
Write, to comment
Issues
Write, because GitHub stores PR comments as issue comments
Checks
Write, only if you turn on the merge gate or findings on lines
Workflows
Write, only for the one-click coverage setup

Pricing

Free on public repositories. Pro for private. Teams for the organization.

Install free and Signals runs on every public repository. Pro adds private repositories and AI review, paid from credits the plan includes, with a cap on every pull request and a spend limit on every repository. Teams puts one install and one credit pool behind the whole organization.

Free

$0

Public repositories

  • Signals on every public repository, no PR cap
  • The merge gate and findings on lines
  • A public report for every pull request
  • No model runs and no credits are spent
Install on GitHub

Pro

AI review

$15 a month

or $12 a month billed yearly

  • Everything in Free, on private repositories too
  • AI review, about 9 cents a pull request
  • $5 of AI credits a month included, about 55 reviewed pull requests
  • AI spend limits per repository, $5 a month and 60 cents a pull request by default
Upgrade to Pro

Teams

$20 a seat a month

From 3 seats

  • Everything in Pro, across the team's repositories
  • One organization install for every member
  • A shared credit pool, $5 a seat a month
  • A $100 a day AI spend cap for the team
Book a demo

FREQUENTLY ASKED

Questions teams ask first

Does it comment on every pull request?

No. In Signals mode, the default, a pull request with nothing to act on gets no comment. AI review, on Pro or Teams, reviews every pull request that changes code, and the Repowise review check on each push says whether it was reviewed and what is still open.

Does it run a model on Free?

No. On Free the bot runs Signals only: the comment comes from an index of your repository, built from parsed code, the call graph, git history and a 25-marker health scorer. A model runs only for AI review, on Pro or Teams, on repositories where you turn it on.

What does AI review cost?

About 9 cents a pull request, paid from credits, so 100 pull requests come to about $9. Most pushes get a single pass of a few cents; a risky change gets one deep review. Signals costs nothing. Pro is $15 a month and includes $5 of credits, about 55 reviewed pull requests; past that, credits are pay as you go with no per-seat review fee. Each repository has a monthly AI spend limit, $5 by default, and a limit per pull request, 60 cents by default. When a limit or the balance runs out, the bot posts the free Signals comment and says the AI pass is paused.

Can it gate on test coverage?

Yes. Upload a coverage report from CI and the bot's Repowise / coverage check fails a pull request below your patch coverage minimum. The Repowise GitHub Action and GitLab template run the same gate in your own pipeline, with path-scoped and risk-weighted gates, and need no account or API key.

Do I need a Repowise account?

Not on public repositories. Install the GitHub App and the bot comments on their pull requests. Sign in with GitHub to choose a review mode, turn on the merge gate, or add private repositories, which need Pro.

Which languages does it understand?

The same languages the Repowise index parses, including Python, TypeScript and JavaScript, Go, Java, Kotlin, C#, Rust, C and C++, Ruby, PHP and Swift: 42 in all, 28 of them parsed to a full syntax tree. The co-change and ownership signals come from git history and work for any file.

How is this different from an AI code reviewer?

An AI reviewer reads the diff. Repowise also knows the rest of the repository: who calls a changed function, which files history says belong together, and which tests import the change. That evidence is there for free, without a model, and the AI modes build on it instead of guessing.

Is GitHub the only host?

For the bot, yes, today. It is a GitHub App and works on public, private and organization repositories. The CI gates also run on GitLab through the Repowise template, and in any other CI as plain commands.

Can I turn it off for one pull request or one path?

Put [skip repowise] in the pull request title to skip it. Ignore paths such as vendor/ or generated files per repository in your settings or .repowise/bot.yaml.

How do I uninstall it?

On GitHub: your account's Settings, Applications, Installed GitHub Apps, or your organization's Settings, GitHub Apps. Uninstalling removes its access at once.

Install it on the repository you are working on today.

Free on public repositories, no account needed. Your next pull request shows you what it does.

Install on GitHubStart freeBook a demo

Already installed? Manage installs