rebenga

Plugin rebenga from marketplace ownconfig in catmargiela/ownconfig. Commands read from the repo's manifest — 1 month ago.

Skills (13)

• api-design

  HTTP API conventions for the Go backend — naming, status codes, error envelope, validation errors, cursor pagination, idempotency, versioning, timestamps, money, rate limits. Use when designing a new endpoint, changing a response shape, or reviewing an API handler.

• click-path-audit

  Trace each interactive element of a screen through handlers and state to find actions undone by others. Use when the user says « ce bouton ne marche pas » ("this button does nothing"), state resets, or after a store refactor.

• contract-first

  Keep an API contract aligned between one provider (Go API, sqlc types) and several clients (Next.js front end, Tauri desktop app). Use before changing an endpoint, a payload, a response field or a shared type, or when a client breaks after an API-side change.

• e2e-testing

  End-to-end testing patterns for web apps with Playwright — locators, fixtures, reused auth, flakiness, CI. Use when the talk is about end-to-end tests, user journeys to test, Playwright or a flaky test.

• golang-testing

  Go testing conventions — table-driven subtests, httptest handlers, a real Postgres instead of mocked sqlc, fuzzing, benchmarks, race detector, golden files. Use when writing Go tests, a Go test is flaky, or coverage of a Go package is questioned.

• issue-batch

  Work through a batch of GitHub issues in parallel, then comment on them, close them and move them to "Done" on a GitHub Projects board. Use when the user says « fais les issues #X, #Y » ("do issues #X, #Y"), « traite les issues ouvertes » ("handle the open issues"), « mets-les en done » ("mark them

• iterative-retrieval

  Delegate to subagents without dumping all the context on them — minimal task and pointers, then the agent reports what it is missing in a fixed section, and you relaunch in 2 or 3 rounds at most. Use when delegating to agents, especially in a parallel batch (issues, reviews, explorations), or when t

• mirror-sync

  Keep a module or front end duplicated across two repos in sync (for example a web app and its desktop app). Use when a patch must be « reporté de l'autre côté » ("carried over to the other side"), or when the user talks about a mirror (miroir), a copy or two front ends to keep aligned.

• postgres-patterns

  Postgres indexing, EXPLAIN reading, N+1 and keyset pagination with sqlc, locking, and zero-downtime goose migrations. Use on a slow query, a new index, a new migration, a schema change, or a job queue in Postgres.

• prod-e2e

  A Playwright suite versioned in the repo and run safely against production — disposable test accounts, read-only journeys, credentials from environment variables. Use when verifying production after a deploy, testing in prod, or writing production e2e tests.

• production-audit

  Evidence-based ship-or-block review of a client release from local files only — diff, auth, migrations, env, jobs, observability, rollback, tests, Tauri signing. Use before a release, or when the user asks « on peut livrer ? » ("can we ship?").

• tauri-release

  Publish a release of a Tauri v2 desktop app (macOS, Windows) through GitHub Actions and tauri-action, updater included. Use when the user says « sors une version » ("cut a release"), « publie la release » ("publish the release"), « tag la v… » ("tag v…"), or when a Tauri release has failed.

• tdd-workflow

  Test-first RED, GREEN, REFACTOR loop with proof at every step. Use when the code must be written tests first, for a new feature or a bug fix done test-first.

Slash commands (15)

• /rebenga:build-fix

  Re-runs the failing build, delegates the repair to the build-fixer agent, then proves it green with a fresh run.

• /rebenga:canary-watch

  Captures the observable state of a production site, then compares it after a deployment — statuses, assets, console errors, latency, key elements — and returns a PASS/FAIL verdict.

• /rebenga:config-doctor

  Checks that ~/.claude still matches the config repository — links, registered hooks, settings.json, theme, plugin version, git state, dispatcher, Python engine.

• /rebenga:context-budget

  Estimates the context resident on every turn (CLAUDE.md, skills, agents, MCP, plugins) and proposes the three most cost-effective savings.

• /rebenga:deploy-verify

  Deploys with the project's script after consent, then proves from command output that services, migrations, health, proxy, bundle and .env are good.

• /rebenga:dual-review

  Independent double review of a diff or PR against a PASS/FAIL checklist, with a fix loop capped at three rounds.

• /rebenga:env-set

  Sets or rotates a secret in a .env without the value ever appearing in the conversation, the shell history or a tool's output.

• /rebenga:go-review

  Go review of the current diff or of the given paths, delegated to the go-reviewer agent.

• /rebenga:hookify

  Turns a behaviour to forbid into a tested hook check in the config repository — from a description or from analysing recent sessions.

• /rebenga:migration-check

  Checks the SQL migrations in the diff — static checks, dry run in a rolled-back transaction, sqlc regeneration, Go build and vet.

• /rebenga:plan

  Explore the codebase and produce an approved implementation plan before writing a single line of code.

• /rebenga:python-review

  Python review of the current diff or of the given paths, delegated to the python-reviewer agent.

• /rebenga:refactor-clean

  Cleans up dead code and unused dependencies and exports, on a green test baseline, via the refactor-cleaner agent.

• /rebenga:token-log

  Lists one by one the Bash commands that went through output compression — date, command, processor, size before/after, gain.

• /rebenga:token-stats

  Summary of Bash output compression — commands compressed, characters and tokens saved, most cost-effective processors and commands.

Subagents (12)

• conversation-analyzer

  Scans recent Claude Code transcripts for the user's repeated corrections, frustrations and recurring tool refusals or errors, and proposes a candidate mechanical rule for each. Use via `/hookify` with no argument, or when asking "what do I always correct?" (« qu'est-ce que je corrige toujours ? »).

• database-reviewer

  Reviews SQL queries, ORM query code, migrations, indexes and schema changes — injection, performance, locks, reversibility, permissions. Use automatically as soon as SQL, a migration, an ORM query, an index or a schema is written or modified.

• e2e-runner

  Writes and runs end-to-end tests for a web application (Playwright preferably, Cypress otherwise). Use automatically to test a user journey end to end.

• go-reviewer

  Reviews Go code for correctness, error handling, concurrency and security. Use after writing or modifying `.go` files, or via `/go-review`.

• planner

  Explores the codebase and produces a concrete implementation plan — files, ordered steps, checks, risks. Use before a feature, a refactor or a change that touches several files. Never writes code.

• pr-test-analyzer

  Maps each changed behavior of a PR or diff to the tests that exercise it, flags gaps and tests that prove nothing, and runs the relevant tests. Use before merging a PR or when you want to know whether a change is really covered. Never writes tests.

• python-reviewer

  Reviews Python code for correctness, error handling, typing and security. Use after writing or modifying `.py` files, or via `/python-review`.

• refactor-cleaner

  Finds and removes dead code, unused exports, dependencies and files, and duplication, backed by tool evidence. Use for a repository cleanup or before a refactor.

• rust-tauri-reviewer

  Reviews Rust code and Tauri v2 configuration — errors, async, unsafe, capabilities, CSP, IPC, updater. Use after writing or modifying `.rs`, `Cargo.toml`, `tauri.conf.json` or `src-tauri/capabilities/*` files, and before a desktop app release.

• silent-failure-hunter

  Hunts silent failures — swallowed errors, fallbacks that mask an outage, errors logged but never propagated — in Go, TypeScript/React and Rust/Tauri. Use after a change touching network, database, file or IPC calls, or before merging a PR.

• tdd-guide

  Implements a feature or fixes a bug in strict test-first — RED, GREEN, REFACTOR, with the runner output as proof at each step. Use automatically when implementing a feature or a fix by writing the tests first.

• typescript-reviewer

  Reviews TypeScript / JavaScript logic and Node code — typing, async, error handling, security. Use after writing or modifying `.ts`/`.js` files outside UI components (for React/Next, prefer `web-reviewer`).