@quickchatai/pi-quickreview
QuickReview for pi, an open-source AI code reviewer. Adds /qcr-review, /qcr-scan and /qcr-setup to your pi session.
Package details
Install @quickchatai/pi-quickreview from npm and Pi will load the resources declared by the package manifest.
$ pi install npm:@quickchatai/pi-quickreview- Package
@quickchatai/pi-quickreview- Version
1.7.0- Published
- Nov 20, 2026
- Downloads
- 2,172/mo · 902/wk
- Author
- mateusz-quickchat
- License
- MIT
- Types
- extension, skill
- Size
- 7.3 MB
- Dependencies
- 1 dependency · 5 peers
Pi manifest JSON
{
"skills": [
"./skills"
],
"extensions": [
"./dist/src/plugin/index.js"
]
}Security note
Pi packages can execute code and influence agent behavior. Review the source before installing third-party packages.
README
QuickReview for pi
QuickReview is an open-source AI code reviewer. This package runs it inside your own pi session.
pi install npm:@quickchatai/pi-quickreview
That adds three commands:
| Command | What it does |
|---|---|
/qcr-review |
reviews this branch with your uncommitted changes, a pull request, or a branch |
/qcr-scan |
scans the whole repository, or one folder of it, for defects |
/qcr-setup |
checks what a review needs, and sets up the model and this repo's profile |
Each command is also a skill of the same name, so the model in your session knows the command and can tell you the line to type.
It is the same review core the QuickReview bot runs. What a review looks like, how it works and how it was measured are in the project's README.
Your first review
Type /qcr-review inside a git repository. It reviews the current branch
against its base, together with your uncommitted changes, as one review.
- What you need. pi 1.4.0 or a later 1.x, and a model credential in pi: a
login made with
/login, or a provider key in the environment. Any provider pi supports works. With no credential,/qcr-reviewstops and names/login. - Look before you spend.
/qcr-review --previewshows the plan and the price, and runs nothing. - It runs in the background. The command returns at once and you keep chatting. The status line shows the review's progress, and the result arrives in the session as a message.
- It is slow and it costs money. A review reads the change through many
lenses, each a narrow reviewer that looks for one kind of problem, and a
validator then re-checks every finding against the code. On the one model
with a measured price, that took about two dollars and more than fifteen
minutes per pull request
(Benchmarks).
/qcr-review quickruns at lower reasoning for about half the cost. - It reads your code and runs none of it. It never writes to your checkout either.
- It posts nothing unless you say yes. After a pull request review it
asks, with "No, keep it here" offered first. On the shipped defaults a yes
is recorded and nothing is sent, because
dry_runis on until you turn it off in a qcr config.
/qcr-setup checks what a review needs here and lists what is missing.
Commands
/qcr-review [preset] [target]
The review runs in the background: the command returns at once, you keep chatting, the status line shows the review's progress, and the result arrives in the session as a message. It is also kept as markdown and JSON under the qcr state home. One review runs per session at a time, and ending the session stops it.
The target:
| You type | It reviews |
|---|---|
| nothing | the current branch against its base, together with its uncommitted changes, as one review |
123, #123 or a pull request URL |
that pull request |
| a branch name | that branch |
--uncommitted |
the uncommitted changes alone |
The preset goes first when you give one:
quick: lower reasoning, about half the cost.full: the whole target again, at the highest reasoning.security: the wholepass-sec-*security family, planned as a request whatever the change's signals say, and the validator. Every other lens is skipped.state-machines: the wholepass-sm-*state-machine family, planned as a request whatever the change's signals say, and the validator. Every other lens is skipped.
The flags:
--previewshows the plan and the price without running anything.--stopstops the review that is running.--securityasks for a security review on top of the plan: all fourteenpass-sec-*lenses are planned, at the risk tier, except any your profile switched off. Thesecuritypreset already asks for it. The profile that reviews only security on every review issecurity(--profile security).--state-machinesasks for a state-machine review on top of the plan: the eightpass-sm-*lenses (implicit state machines gone wrong: flags that can disagree, a status written with no check of the old one, a state a dispatch does not handle, a transient state an error leaves set, an event delivered twice or out of order). The profile that reviews only state machines isstate-machines(--profile state-machines).--model MODELnames the model the whole review runs on, for this run:provider/id, an id pi knows, or either with a:level, read the way pi's own--modelreads it. It replaces every tier and lens model your config pins./qcr-setup modelkeeps a choice instead.--base REFnames the base a branch is reviewed against.--repo OWNER/NAMEnames the pull request's repository when it is not the one you are in.--profile NAMEreviews under that profile.--limit USDsets this run's limit (see Which model).--jsongives the result as JSON, for pi's print mode.
After a pull request review, your posting rule decides whether it goes to the pull request as a comment-only review (see Settings).
/qcr-scan [--delta] [--sha REF] [--path DIR] [--model M] [--preview]
The scan reads the whole repo for defects, or with --path one folder of it.
It is priced first and starts only on your yes. --preview shows the price
and starts nothing.
--deltascans only the files that changed since the last scan, and--sha REFscans the tree atREF.- It runs on one model, picked the same way a review picks its own.
--modelnames it for one run. - It runs in the background in this pi, like a review: a status line while it
runs, the new findings as a message when it ends, and
/qcr-scan stopto stop it. - Its cases are SDK sessions of this pi, behind the same read-only bash guard as the review's lenses.
/qcr-scan findings,status,unitsand the other scan subcommands pass through as typed.- The scan sandbox (a container) and dismissing a finding belong to the
qcrapp (qcr scan).
/qcr-setup
/qcr-setup checks the pi version, the model credential, git, and GitHub
access for pull request targets. It also shows the model reviews run on and
why.
It then offers to set up this repo's profile (.qcr/), with No offered
first. On your yes, your agent in the session surveys the repo, reads its
review history, interviews you and writes the profile for you to commit.
/qcr-setup profilestarts the profile setup straight away./qcr-setup modelpicks the provider reviews run on (see Which model).
Its checks are steps on a setup checklist (src/setupchecklist.ts) that the
qcr app extends with its own steps.
Commands that are gone
/review, /scan and /selfimprove are gone. pi's command namespace is
shared with every other extension, so the commands carry the qcr- prefix:
/review is /qcr-review and /scan is /qcr-scan. /selfimprove is a
command of the qcr app's own pi (qcr pi).
Settings
Your own defaults live in pi's settings (~/.pi/agent/settings.json, or the
project's .pi/settings.json), under quickreview:
{
"quickreview": {
"posting": "ask",
"preset": "quick"
}
}
postingdecides what happens after a pull request review:ask(the default) asks, with "No, keep it here" offered first;neverkeeps every review in the session;alwaysposts without asking.presetis the preset a/qcr-reviewwithout one runs under.
Rules for one repository live in its profile, not here.
Which model
A review runs on a model this pi has a credential for, on any provider pi
supports: a login made with /login, a stored API key, or a provider key in
the environment. Nothing names a provider for you.
- With one usable provider, the review runs on it. Its model is the newest version pi's catalog lists for that provider, or pi's own default there when the newest is priced far below it.
- With several, the provider this pi session is on goes first, then a stored
login before an environment key. When two tie,
/qcr-reviewasks once which one to use and remembers the answer. With nobody to ask it takes the first and says which model runs and how to change it. /qcr-setup modelshows the usable providers and picks one, or hands the pick back to QuickReview. The choice is kept inqcr-model.jsonbeside pi's logins, the one file the plugin writes there, so theqcrCLI on the same pi home runs on the same model.--modelon/qcr-reviewor/qcr-scannames the model for one run, and[models] modelin a qcr config pins it for every run.--modelis the whole run's model: it replaces every tier and lens a config pinned.- The dollar estimate was measured on one model. There, a review whose
estimate is within your limit ($2 by default, or
--limit) starts without asking, a dearer one asks first, and the review stops at twice its estimate. On any other model, the preview shows no estimate and the review stops at a spend limit ($15, or--limit); the first review on such a model asks once. A model pi has no price for has no dollar stop, and its spend shows as unknown. - A login whose tokens are shorter than a review runs here, because this pi renews it while the review goes.
The whole rule, the refusals and the price are in docs/llm-setup.md.
A provider that another pi extension registered, or one keyed with
pi --api-key, cannot be borrowed: the review's sessions run in a host of
their own, which loads no extension and holds no key of your session.
Which pi
The package declares ^1.4.0 for pi (peerDependencies): pi 1.4.0 and any
later 1.x. At load the plugin reads the running pi's version, and outside
that range it registers no command at all and says why, once. A review
engine written against one pi's SDK never half-runs on another. Only pi
versions the plugin's offline canaries ran on belong in the range.
The qcr CLI (@quickchatai/quickreview) and the QuickReview image pin pi
exactly instead; qcr pi starts that pinned pi with this plugin preloaded.
What it needs
- pi in the range above.
- A model credential in pi, for any provider (
/loginin pi, or a provider key in the environment). The review borrows the login of the provider it runs on and no other: pi renews it when needed, and the review only ever holds a copy that cannot refresh. With no credential at all,/qcr-reviewstops and names/login. The scan borrows it the same way. - For a pull request: the App when a qcr install configures one, else
GITHUB_TOKEN,GH_TOKENorgh auth login, in that order. - For posting: a qcr config with
dry_run = false. The shipped defaults keepdry_runon, and then a post is recorded under the qcr state home (review/dryrun/) and nothing is sent; the post question says so.
What it never does
- The review and the scan never write to your checkout: they read the tree as it is.
- The review and the scan never run your code, tests or app: they read code (and the review, CI).
- It never runs the
qcrCLI. - It never posts unless you say yes to the post question (or your posting
rule is
always), and then it posts one comment-only review through the same mutation gate the bot uses. It never approves, requests changes or dismisses a review. - It never refreshes your login itself, and never hands a token to the model's tools.
- It never gives your session a tool. The review's lens passes run in their own sessions, with none of your pi extensions, skills or settings, and your session only sees the result. The skills it ships are instructions for your session's model, naming the commands.
- It never sets or flips
dry_run. - It never starts
claude.
What ships in the package
dist/: the compiled review core and the plugin.skills/: one skill per command, rendered at pack time from the same skill source as QuickReview's plugins for other coding-agent CLIs, and checked against it.assets/: the data the core reads, which is the agents, prompts and seeds, the schemas, the profiles and the shipped config defaults.
assets/ is copied from the repository at pack time and checked file by file
against its source, so the prompts in the package are byte-identical to the
ones the bot runs. They sit under assets/, not at the package root, so pi
never offers them as your slash commands.