An AI code reviewer for GitHub that learns how your team works
Repo code16/donkey, read from GitHub 16 h ago. code16 has not joined Take My Repo.
code16/donkey is a public repo on GitHub by code16. An AI code reviewer for GitHub that learns how your team works. It declares no license on GitHub. Public does not mean open source: without a license, nobody is granted the right to reuse it. It is written mainly in PHP, has 0 stars and last changed on 2026-11-20. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
An AI code reviewer for GitHub that learns how your team works.
Donkey reviews pull requests the moment they open: it leaves inline comments with ready-to-commit suggestions, answers questions in the thread, and gets better every time someone tells it it was wrong. It runs as a GitHub App on your own infrastructure, with your own model API key, set in the organization settings.
suggestion blocks you can commit in one click, plus a check run on the commit.CLAUDE.md and AGENTS.md from the repository root and from the directories of changed files.@donkey answers questions, in a finding's thread or on the pull request.@donkey run security, or let it join automatic reviews.@donkey remember … teaches it about a repository. Dismissals, reactions and resolved threads become proposed learnings that an admin approves, scoped to one repository or the whole organization.| Comment | What it does |
|---|---|
@donkey review |
Review the changes since the last review |
@donkey full review |
Review the whole pull request again |
@donkey run <agent> / @donkey agents |
Run one specialist agent / list them |
@donkey <question> |
Ask anything about the pull request, or about a finding when asked in its thread |
@donkey ignore: <why> |
In a finding's thread: dismiss it and teach Donkey |
@donkey remember <fact> |
Save a fact about the repository for future reviews |
@donkey pause / @donkey resume |
Stop or restart automatic reviews on this pull request |
@donkey help |
List the commands |
donkey is the default handle; change it in the organization settings.
pgsql and redis extensions, and ComposerDocker Compose can provide PostgreSQL and Redis, or the whole stack (see Deploy with Docker).
Two ways to run Donkey: with Docker (recommended for a server, nothing to install but Docker) or natively for development.
The repository ships a production image (PHP-FPM, nginx, Horizon, Reverb and the scheduler, with Bun and kodus-graph included) and a Compose file that adds PostgreSQL with pgvector and Redis.
Create the GitHub App (see step 2 below) and save its private key as github-app.pem next to compose.prod.yaml.
Create the environment file and fill it in:
cp .env.docker.example .env
Only APP_URL, the GITHUB_* values and mail need filling in; everything else has a working default. APP_KEY and the Reverb keys are generated on first start and kept in the storage volume (storage/app/private/generated.env); set them in .env to use your own. .env also sets COMPOSE_FILE=compose.prod.yaml, so plain docker compose commands (up -d, logs, ps…) use the production stack.
Start it. Images are built by GitHub Actions on every push to main and published to GHCR (ghcr.io/<owner>/donkey-app and donkey-web), so the server never builds anything:
docker login ghcr.io # only if the packages are private: a token with read:packages
./deploy.sh # pull the latest images and restart; ./deploy.sh <commit-sha> rolls back
To build on the server instead, run docker compose up -d --build.
Migrations run automatically before the app starts, on every start. The first run also creates the app key, Reverb keys and the OAuth keys for the MCP server (storage/oauth-*.key in the storage volume): keep that volume, or MCP clients have to sign in again. The web container is reached through your reverse proxy and also proxies WebSockets (/app) to Reverb, so one hostname is enough. Keep TRUSTED_PROXIES=*.
The web container listens on 127.0.0.1:8090 (change it with DONKEY_PORT). Point a TLS-terminating reverse proxy at it, forwarding the Upgrade/Connection headers so WebSockets work, plus Host and X-Forwarded-*. With nginx:
location / {
proxy_pass http://127.0.0.1:8090;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
Open your APP_URL, register, create an organization and connect GitHub from Repositories → Connect GitHub.
To upgrade, run ./deploy.sh again (or git pull and the same up -d --build command when building on the server); migrations run again. Data lives in the pgsql-data, redis-data and storage volumes. Logs go to docker compose logs.
php artisan backup:run writes storage/backups/donkey-<date>.tar.gz with a pg_dump of the database and the files that cannot be rebuilt: storage/app (organization avatars, the GitHub App key, generated.env holding the generated APP_KEY and Reverb keys, built code graphs; repository clones are left out, they are cloned again on demand) and the MCP OAuth keys. The scheduler runs it every night at 01:30 in production and keeps the last 7 (--keep=N to change). Redis is not backed up: it only holds queues, cache and sessions, so the worst a loss costs is in-flight jobs and a new sign-in.
The archive contains secrets and sits in the same storage volume as the data, so keep a copy off the server. To have each backup also uploaded to S3 (or any S3-compatible storage: R2, Scaleway, MinIO…) under backups/, with the same retention, add to .env:
BACKUP_DISK=s3
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_DEFAULT_REGION=
AWS_BUCKET=
# AWS_ENDPOINT=https://... # S3-compatible providers
# AWS_USE_PATH_STYLE_ENDPOINT=true # MinIO and some others
Use a private bucket, ideally with versioning or object lock, and a key that can only read, write and delete in it. Without S3, download the latest archive yourself (or rsync/restic the directory):
docker compose exec -T app sh -c 'cat storage/backups/$(ls storage/backups | tail -1)' > donkey-backup.tar.gz
Keep APP_KEY. Organization AI API keys are encrypted with it. If you set APP_KEY in .env instead of letting Donkey generate it, it is not in the archive (the command warns): back up .env too, or the AI keys are lost on restore.
To restore, on the same or a fresh install (started once with docker compose up -d, same .env):
# with BACKUP_DISK set, the file name is enough: it is downloaded from the bucket
docker compose exec app php artisan backup:restore donkey-<date>.tar.gz
# otherwise, copy the archive in first
docker compose exec -T app sh -c 'mkdir -p storage/backups && cat > storage/backups/restore.tar.gz' < donkey-backup.tar.gz
docker compose exec app php artisan backup:restore restore.tar.gz
docker compose restart
This replaces the database and the saved files, then the restart loads the restored keys. The GitHub App key mounted from the host (github-app.pem) is left as is.
git clone <your-fork-or-this-repo-url> donkey
cd donkey
Start PostgreSQL (with pgvector) and Redis:
docker compose up -d pgsql redis
This exposes PostgreSQL on port 5434 and Redis on port 6380.
In GitHub, go to Settings → Developer settings → GitHub Apps → New GitHub App (for an organization, use the organization's settings).
| Setting | Value |
|---|---|
| Homepage URL | your APP_URL |
| Callback URL | <APP_URL>/github/setup (also set "Request user authorization (OAuth) during installation") |
| Setup URL | <APP_URL>/github/setup (also set "Redirect on update") |
| Webhook URL | <APP_URL>/webhooks/github |
| Webhook secret | a long random string |
During development, expose your machine with a tunnel (for example ngrok http 8000) and use its address as APP_URL; GitHub must be able to reach the webhook URL.
Repository permissions: Pull requests: read & write · Contents: read · Checks: read & write · Issues: read & write · Metadata: read.
Subscribe to events: Pull request · Issue comment · Pull request review comment · Pull request review thread · Installation and installation repositories.
Then generate a private key and save it as storage/app/private/github-app.pem.
composer setup
This installs PHP and JavaScript dependencies, creates .env, generates the app key, runs the migrations and builds the assets. It also installs Bun and kodus-graph locally (no global install, no curl | bash).
Then edit .env:
APP_URL=https://your-host
# PostgreSQL + Redis (the ports from docker compose)
DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5434
DB_DATABASE=donkey
DB_USERNAME=donkey
DB_PASSWORD=donkey
QUEUE_CONNECTION=redis
CACHE_STORE=redis
REDIS_PORT=6380
# GitHub App
GITHUB_APP_ID=
GITHUB_APP_SLUG=
GITHUB_APP_CLIENT_ID=
GITHUB_APP_CLIENT_SECRET=
GITHUB_APP_PRIVATE_KEY_PATH=storage/app/private/github-app.pem
GITHUB_WEBHOOK_SECRET=
Real-time updates use Laravel Reverb. Generate its credentials with php artisan install:broadcasting if your .env has no REVERB_* values, and set BROADCAST_CONNECTION=reverb.
Mail is only needed for invitations, email verification and budget alerts; set MAIL_* to a real mailer in production (the default log mailer writes emails to storage/logs).
If
.env.exampleand your database settings disagree,.envalways wins. After pulling new code, runphp artisan migrate.
composer dev
This starts the web server, Horizon (queues), Reverb (websockets) and the Vite dev server. Open http://localhost:8000, register, create an organization, and connect GitHub from Repositories → Connect GitHub.
Reviews also need the scheduler for the nightly jobs (learning proposals, decay and pruning):
php artisan schedule:work
| File | What it controls |
|---|---|
config/reviews.php |
Provider and model, size limits, ignored paths, verifier, conversation settings |
config/graph.php |
Code graph: enable/disable, binary location, timeouts |
config/agents.php |
Templates offered when creating an agent |
config/learning.php |
Memory and learning: embeddings, prompt budget, decay |
config/ai_pricing.php |
Price per million tokens used for cost estimates |
config/retention.php |
How long webhooks, usage, audit events and conversations are kept |
config/auto_join.php |
Public email providers that can never be auto-joined |
Useful environment variables: REGISTRATION_ENABLED=false (close sign-ups once your own account exists; people with a pending invitation can still register), REVIEW_VERIFIER_ENABLED, GRAPH_ENABLED, LEARNING_EMBEDDINGS_PROVIDER (set it, for example to openai, to enable similarity search over memories and learnings).
@donkey ignore: <why>, add facts with @donkey remember …, then approve the proposed learnings in Knowledge.Before changing a prompt or switching models, measure the effect on pull requests with known, planted problems:
php artisan eval:run
It reports recall (planted bugs found), precision (how much of what it said was right), severity accuracy and cost. Cases live in tests/Evals/cases. Each run calls the model, so it asks for confirmation first.
composer test # Pest
vendor/bin/pint --dirty --format agent # code style
vendor/bin/phpstan analyse # Larastan
Tests never reach the network: every HTTP request must be faked. See PHASES.md for how the project was built, phase by phase, and PHASE6_HANDOFF.md for the work still open.
Laravel 13 · Livewire 4 · Tailwind CSS · Alpine.js · Laravel Reverb · Laravel Horizon · laravel/ai · kodus-graph · PostgreSQL + pgvector
Add your license here.
code16/donkey is a public repo on GitHub by code16. An AI code reviewer for GitHub that learns how your team works.
It declares no license on GitHub. Public does not mean open source: without a license, nobody is granted the right to reuse it.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-20. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
A simple class for business days counting


Github Action to detect remaining Spatie\ray calls in a Laravel application
Take My Repo has not tested this on your machine. Requirements come from the project's own documentation.