rusty

Plugin rusty from marketplace fullstack-agents in adelabdelgawad/rust-fullstack-agents. Commands read from the repo's manifest — 1 month ago.

Skills (40)

• auth-session

  Implement cookie-based authentication and session management in Leptos+Axum using tower-sessions and axum-login. Trigger keywords: auth, login, logout, session, cookie, AuthUser, AuthnBackend, protected route, tower-sessions, axum-login.

• axum-handler

  Write Axum 0.8 handlers with correct path syntax, extractor ordering, state injection, and IntoResponse error handling. Auto-triggers when adding routes, extractors, or handler functions in an Axum 0.8 project.

• axum-middleware

  Apply Tower and Axum middleware correctly — ServiceBuilder ordering, from_fn signatures, route_layer vs layer, tower-http layers, and graceful shutdown. Auto-triggers when adding middleware, layers, or shutdown logic to an Axum server.

• axum-websocket

  Implement WebSocket handlers in Axum 0.8 with correct Message types, broadcast rooms via tokio broadcast channels, heartbeat pings, and proper close-code handling. Auto-triggers when adding WebSocket routes or real-time messaging to an Axum project.

• background-jobs

  Schedule and process background jobs in Rust+Leptos+Axum using apalis with a Postgres backend. Trigger keywords: background job, queue, worker, async task, cron, scheduled, apalis, email queue, retry, dead letter.

• batch-error-resolution

  Resolve cascading Rust compiler errors in a single pass without intermediate rebuilds. Trigger keywords: cascade, multiple errors, cargo check, clippy errors, batch fix, compiler errors, 30 errors, type mismatch, missing trait, lifetime, From conversion, enum variant, exhaustive match, AppError. Aut

• cargo-leptos-config

  Configure cargo-leptos via [package.metadata.leptos] or [[workspace.metadata.leptos]]. Auto-triggers when adding/modifying Cargo.toml metadata for a Leptos project, changing site-addr/style/assets, or debugging cargo leptos build failures.

• data-table

  Canonical Leptos data-table page — layout/design, four-owner state model, hydration boundary, island contract (TableData + Selection + refetch_action + sort/filter pushState), mutation reconciliation (MutationBinder + ReconcileStrategy + SelectionPolicy), label bundle, server-fn + DTO shape, and the

• debug

  Root-cause-first debugging for Rust+Leptos+Axum+SQLx projects. Four-phase discipline: Reproduce, Investigate, Fix, Verify. Trigger keywords: bug, error, panic, stack trace, unexpected behavior, crash, test failure, hydration mismatch, async stall, compile error.

• dto-domain

  Separate Row, Dto, and Domain types in Leptos+SQLx projects; enforce newtype wrappers, conversion direction, and validation placement. Trigger keywords: DTO, domain, Row, struct, serialize, deserialize, newtype, UserId, validation, FromRow, wire type, From, TryFrom, serde_json::Value, sensitive fiel

• leptos-action-form

  Build progressive-enhancement forms with ActionForm, ServerAction, and optimistic UI. Auto-triggers when adding any form that calls a #[server] fn, implementing mutation UI, or wiring pending/value/input signals to feedback elements.

• leptos-component

  Write Leptos components and islands with correct prop declarations, signal types, view! macro usage, and reactivity primitives (RwSignal/Memo/Effect). Auto-triggers when adding or editing any #[component] or #[island] function, declaring props, or using signals/effects in Leptos 0.8+ under islands m

• leptos-data-loading

  Load async data in Leptos using Resource, LocalResource, Suspense, and Transition with correct SSR streaming modes. Auto-triggers when adding data fetching, Suspense/Transition wrappers, or choosing between SSR streaming strategies.

• leptos-error-handling

  Define AppError enums with FromServerFnError, map sqlx errors, implement IntoResponse for Axum, and use ErrorBoundary in views. Auto-triggers when adding error types, handling server fn errors, or wiring ErrorBoundary components.

• leptos-hydration-discipline

  Canonical reference for all 12 Leptos hydration anti-patterns with grep detectors. Auto-triggers on any hydration mismatch, panic during hydration, blank content on first load, or before committing any .rs file that touches view! macros or #[server] functions.

• leptos-islands

  Apply Leptos 0.8+ Islands architecture to enterprise SSR applications — admin panels, CRUD systems, PBX/callcenter dashboards, table-heavy management UIs. Auto-triggers when adding `#[island]`/`#[component]`, designing hydration boundaries, building modals/sheets/dialogs/forms, debugging dead button

• leptos-routing

  Configure Leptos router with typed paths, nested routes, params, and Axum server-side mounting. Auto-triggers when adding routes, reading path/query params, implementing nested layouts, or wiring leptos_routes_with_context.

• leptos-server-fn

  Write Leptos #[server] functions with correct encoding, extractor usage, response manipulation, and Send bounds. Auto-triggers when adding or editing #[server] fns, choosing between server fns vs Axum handlers, or debugging 500 errors from server fn calls.

• quality-gates

  Non-skippable 11-step verify chain for Rust+Leptos+Axum+SQLx projects. Covers fmt, clippy (ssr+hydrate), sqlx offline check, migration safety, hydration lints, Rust correctness lints, patterns review, and cargo audit. Blocks completion on any failure.

• rust-codebase-scanning

  Mandatory pre-generation scan that reads actual project style from Cargo.toml, existing server fns, components, repo modules, error enums, and migrations. Run before the first code generation of every session.

• rust-collections

  Canonical reference for Vec<T>, String/&str, and HashMap<K,V> usage in Rust. Covers: Vec push/get-vs-index, capacity/with_capacity, iteration, iterator-invalidation borrow-checker trap (holding &T into Vec while pushing), String UTF-8 internals, why integer indexing a String panics at compile time,

• rust-concurrency

  Detect and fix concurrency bugs in Rust: data races prevented by Send/Sync, deadlocks from inconsistent lock ordering, poisoned Mutex after panic, MutexGuard held across .await (deadlock + !Send future), Rc/RefCell in spawned or async contexts, blocking calls inside async without spawn_blocking, Arc

• rust-error-handling

  Define, map, and propagate errors in Rust+Leptos+Axum+SQLx projects using thiserror, anyhow, IntoResponse, and FromServerFnError. Trigger keywords: error, AppError, thiserror, anyhow, Result, unwrap, propagate, 500, 404, 422, map_err, Box<dyn Error>, ServerFnError, IntoResponse. Auto-triggers on ANY

• rust-iterators-closures

  Canonical reference for iterator and closure idioms in Rust. Detects and fixes: C-style index loops where an iterator adapter fits, unused lazy iterators (map/filter with no terminal), needless intermediate Vec from chained collect+loop, .clone() inside .map() to dodge a borrow, unwrap() inside map/

• rust-lifetimes

  Detect lifetime bugs and teach lifetime best practices in Rust. Covers why lifetimes exist (preventing dangling references), the three lifetime elision rules, lifetime annotations on functions/structs/methods, 'static and its overuse as a silence-fix, generic lifetime parameters, lifetime bounds (T:

• rust-ownership-borrowing

  Canonical reference for Rust ownership, borrowing, and slice rules with grep detectors for common borrow-checker bugs. Covers: move semantics and ownership transfer, Copy vs move types, the borrowing rules (any number of shared `&` references XOR exactly one `&mut`; references must always be valid),

• rust-panic-vs-result

  Language-level Rust error-handling philosophy (Ch 9). Covers panic! vs Result<T,E> vs Option, the ? operator, From-based error conversion, unwrap/expect discipline, Result in main, and the \"bad state vs expected failure\" decision rule from the Book. Keywords: panic, unwrap, expect, Result, Option,

• rust-pattern-matching

  Canonical reference for exhaustive, idiomatic Rust pattern matching — match exhaustiveness (compiler-enforced, E0004 non-exhaustive), Option/Result matching, if let / let else / while let, match guards, @ bindings, | or-patterns, ..= ranges, destructuring structs / tuples / enums, refutable vs irref

• rust-smart-pointers

  Detect and fix smart-pointer and interior-mutability bugs in Rust. Covers Box<T> (heap allocation, recursive types, trait objects), Deref/DerefMut coercions, Drop, Rc<T> (shared single-thread ownership), Arc<T> (atomic multi-thread), RefCell<T> (interior mutability, runtime borrow check, BorrowMutEr

• rust-testing

  Idiomatic Rust test writing: #[test], assert_eq!/assert_ne!/assert! with custom messages, #[should_panic(expected="...")], returning Result<(),E> with ? instead of unwrap chains, #[cfg(test)] mod tests unit placement, integration tests in tests/ directory, doc tests, tests/common/mod.rs helpers, #[i

• rust-traits-generics
• rust-unsafe
• sqlx-errors
• sqlx-migrations
• sqlx-offline
• sqlx-pool
• sqlx-query
• sqlx-types
• using-rusty
• workspace-architecture

Slash commands (10)

• /rusty:analyze

  Analyze codebase structure, architecture, dependencies, or patterns — produces workspace inventory, server-fn coverage map, migration ledger, and module DAG.

• /rusty:datatable

  Build, refit, or audit a canonical Leptos data-table page — invokes the `data-table` skill and chains the standard codebase-scanning + patterns-compliance + hydration-discipline reviews.

• /rusty:debug

  Debug errors, analyze logs, profile performance, or diagnose hydration mismatches — enforces root-cause-first discipline before proposing any fix.

• /rusty:gate

  Run the full quality-gates suite — fmt, clippy (ssr + hydrate), sqlx prepare check, migration lint, hydration lint, Rust correctness lints, patterns review, and cargo audit. Required before every commit or PR.

• /rusty:generate

  Generate code artifacts following Rust+Leptos+Axum+SQLx patterns — entities, pages, forms, server functions, handlers, migrations, jobs, websockets, auth, or Docker services.

• /rusty:optimize

  Optimize for async performance, query efficiency, WASM bundle size, code cleanliness, or structural refactoring.

• /rusty:review

  Review code for quality, security, performance, pattern compliance, hydration correctness, or language-level Rust correctness using dedicated review agents.

• /rusty:scaffold

  Scaffold new projects or modules — single-crate Leptos+Axum project, workspace variant, or domain/auth/jobs/Docker modules within an existing project.

• /rusty:status

  Show detected workspace layout, Leptos/Axum/SQLx versions, active modules, scan cache age, and sqlx offline cache freshness — with suggested next actions.

• /rusty:validate

  Validate that an entity, server function architecture, hydration boundary, or quality-gates spec follows the project's architecture patterns.

Hooks (5)

• SessionStart

  $CLAUDE_PLUGIN_ROOT/hooks/session-start

• UserPromptSubmit

  $CLAUDE_PLUGIN_ROOT/hooks/prompt-scan

• PreToolUse

  $CLAUDE_PLUGIN_ROOT/hooks/pre-edit-gate

• PostToolUse

  $CLAUDE_PLUGIN_ROOT/hooks/post-rs-fmt

• Stop

  $CLAUDE_PLUGIN_ROOT/hooks/stop-gate

Similar plugins