npm - autoworkflow - Versions diffs - 3.1.5 → 3.6.0 - Mend

autoworkflow 3.1.5 → 3.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (124) hide show

package/.claude/commands/analyze.md +19 -0
package/.claude/commands/audit.md +26 -0
package/.claude/commands/build.md +39 -0
package/.claude/commands/commit.md +25 -0
package/.claude/commands/fix.md +23 -0
package/.claude/commands/plan.md +18 -0
package/.claude/commands/suggest.md +23 -0
package/.claude/commands/verify.md +18 -0
package/.claude/hooks/post-bash-router.sh +20 -0
package/.claude/hooks/post-commit.sh +140 -0
package/.claude/hooks/post-edit.sh +190 -17
package/.claude/hooks/pre-edit.sh +221 -0
package/.claude/hooks/session-check.sh +90 -0
package/.claude/settings.json +56 -6
package/.claude/settings.local.json +5 -1
package/.claude/skills/actix.md +337 -0
package/.claude/skills/alembic.md +504 -0
package/.claude/skills/angular.md +237 -0
package/.claude/skills/api-design.md +187 -0
package/.claude/skills/aspnet-core.md +377 -0
package/.claude/skills/astro.md +245 -0
package/.claude/skills/auth-clerk.md +327 -0
package/.claude/skills/auth-firebase.md +367 -0
package/.claude/skills/auth-nextauth.md +359 -0
package/.claude/skills/auth-supabase.md +368 -0
package/.claude/skills/axum.md +386 -0
package/.claude/skills/blazor.md +456 -0
package/.claude/skills/chi.md +348 -0
package/.claude/skills/code-review.md +133 -0
package/.claude/skills/csharp.md +296 -0
package/.claude/skills/css-modules.md +325 -0
package/.claude/skills/cypress.md +343 -0
package/.claude/skills/debugging.md +133 -0
package/.claude/skills/diesel.md +392 -0
package/.claude/skills/django.md +301 -0
package/.claude/skills/docker.md +319 -0
package/.claude/skills/doctrine.md +473 -0
package/.claude/skills/documentation.md +182 -0
package/.claude/skills/dotnet.md +409 -0
package/.claude/skills/drizzle.md +293 -0
package/.claude/skills/echo.md +321 -0
package/.claude/skills/eloquent.md +256 -0
package/.claude/skills/emotion.md +426 -0
package/.claude/skills/entity-framework.md +370 -0
package/.claude/skills/express.md +316 -0
package/.claude/skills/fastapi.md +329 -0
package/.claude/skills/fastify.md +299 -0
package/.claude/skills/fiber.md +315 -0
package/.claude/skills/flask.md +322 -0
package/.claude/skills/gin.md +342 -0
package/.claude/skills/git.md +116 -0
package/.claude/skills/github-actions.md +353 -0
package/.claude/skills/go.md +377 -0
package/.claude/skills/gorm.md +409 -0
package/.claude/skills/graphql.md +478 -0
package/.claude/skills/hibernate.md +379 -0
package/.claude/skills/hono.md +306 -0
package/.claude/skills/java.md +400 -0
package/.claude/skills/jest.md +313 -0
package/.claude/skills/jpa.md +282 -0
package/.claude/skills/kotlin.md +347 -0
package/.claude/skills/kubernetes.md +363 -0
package/.claude/skills/laravel.md +414 -0
package/.claude/skills/mcp-browser.md +320 -0
package/.claude/skills/mcp-database.md +219 -0
package/.claude/skills/mcp-fetch.md +241 -0
package/.claude/skills/mcp-filesystem.md +204 -0
package/.claude/skills/mcp-github.md +217 -0
package/.claude/skills/mcp-memory.md +240 -0
package/.claude/skills/mcp-search.md +218 -0
package/.claude/skills/mcp-slack.md +262 -0
package/.claude/skills/micronaut.md +388 -0
package/.claude/skills/mongodb.md +319 -0
package/.claude/skills/mongoose.md +355 -0
package/.claude/skills/mysql.md +281 -0
package/.claude/skills/nestjs.md +335 -0
package/.claude/skills/nextjs-app-router.md +260 -0
package/.claude/skills/nextjs-pages.md +172 -0
package/.claude/skills/nuxt.md +202 -0
package/.claude/skills/openapi.md +489 -0
package/.claude/skills/performance.md +199 -0
package/.claude/skills/php.md +398 -0
package/.claude/skills/playwright.md +371 -0
package/.claude/skills/postgresql.md +257 -0
package/.claude/skills/prisma.md +293 -0
package/.claude/skills/pydantic.md +304 -0
package/.claude/skills/pytest.md +313 -0
package/.claude/skills/python.md +272 -0
package/.claude/skills/quarkus.md +377 -0
package/.claude/skills/react.md +230 -0
package/.claude/skills/redis.md +391 -0
package/.claude/skills/refactoring.md +143 -0
package/.claude/skills/remix.md +246 -0
package/.claude/skills/rest-api.md +490 -0
package/.claude/skills/rocket.md +366 -0
package/.claude/skills/rust.md +341 -0
package/.claude/skills/sass.md +380 -0
package/.claude/skills/sea-orm.md +382 -0
package/.claude/skills/security.md +167 -0
package/.claude/skills/sequelize.md +395 -0
package/.claude/skills/spring-boot.md +416 -0
package/.claude/skills/sqlalchemy.md +269 -0
package/.claude/skills/sqlx-rust.md +408 -0
package/.claude/skills/state-jotai.md +346 -0
package/.claude/skills/state-mobx.md +353 -0
package/.claude/skills/state-pinia.md +431 -0
package/.claude/skills/state-redux.md +337 -0
package/.claude/skills/state-tanstack-query.md +434 -0
package/.claude/skills/state-zustand.md +340 -0
package/.claude/skills/styled-components.md +403 -0
package/.claude/skills/svelte.md +238 -0
package/.claude/skills/sveltekit.md +207 -0
package/.claude/skills/symfony.md +437 -0
package/.claude/skills/tailwind.md +279 -0
package/.claude/skills/terraform.md +394 -0
package/.claude/skills/testing-library.md +371 -0
package/.claude/skills/trpc.md +426 -0
package/.claude/skills/typeorm.md +368 -0
package/.claude/skills/vitest.md +330 -0
package/.claude/skills/vue.md +202 -0
package/.claude/skills/warp.md +365 -0
package/README.md +163 -52
package/package.json +1 -1
package/system/triggers.md +256 -17

package/.claude/skills/rocket.md ADDED Viewed

@@ -0,0 +1,366 @@
+# Rocket Framework Skill
+## Application Setup
+\`\`\`rust
+#[macro_use] extern crate rocket;
+use rocket::{Build, Rocket, fairing::AdHoc};
+#[launch]
+fn rocket() -> Rocket<Build> {
+    rocket::build()
+        .attach(DbPool::init())
+        .attach(AdHoc::config::<AppConfig>())
+        .mount("/", routes![health])
+        .mount("/api/v1/auth", routes![login, register])
+        .mount("/api/v1/users", routes![
+            list_users,
+            create_user,
+            get_user,
+            update_user,
+            delete_user
+        ])
+        .register("/", catchers![
+            not_found,
+            internal_error,
+            unauthorized
+        ])
+}
+#[get("/health")]
+fn health() -> &'static str {
+    "OK"
+}
+\`\`\`
+## Database with rocket_db_pools
+\`\`\`rust
+use rocket_db_pools::{Database, Connection};
+use rocket_db_pools::sqlx::{self, PgPool};
+#[derive(Database)]
+#[database("postgres")]
+pub struct DbPool(PgPool);
+// Access in handlers
+#[get("/<id>")]
+async fn get_user(
+    mut db: Connection<DbPool>,
+    id: &str,
+) -> Result<Json<User>, AppError> {
+    let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", id)
+        .fetch_optional(&mut **db)
+        .await?
+        .ok_or(AppError::NotFound)?;
+    Ok(Json(user))
+}
+\`\`\`
+## Request Guards
+\`\`\`rust
+use rocket::{
+    request::{self, Request, FromRequest, Outcome},
+    http::Status,
+};
+pub struct AuthUser {
+    pub user_id: String,
+    pub role: String,
+}
+#[rocket::async_trait]
+impl<'r> FromRequest<'r> for AuthUser {
+    type Error = AppError;
+    async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
+        let auth_header = request.headers().get_one("Authorization");
+        let token = match auth_header {
+            Some(h) if h.starts_with("Bearer ") => &h[7..],
+            _ => return Outcome::Error((Status::Unauthorized, AppError::Unauthorized)),
+        };
+        match validate_token(token) {
+            Ok(claims) => Outcome::Success(AuthUser {
+                user_id: claims.sub,
+                role: claims.role,
+            }),
+            Err(_) => Outcome::Error((Status::Unauthorized, AppError::Unauthorized)),
+        }
+    }
+}
+// Use in protected routes
+#[get("/profile")]
+async fn get_profile(
+    auth: AuthUser,
+    mut db: Connection<DbPool>,
+) -> Result<Json<User>, AppError> {
+    let user = find_user(&mut db, &auth.user_id).await?;
+    Ok(Json(user))
+}
+// Optional auth
+#[get("/posts")]
+async fn list_posts(
+    auth: Option<AuthUser>,
+    mut db: Connection<DbPool>,
+) -> Result<Json<Vec<Post>>, AppError> {
+    let posts = if let Some(user) = auth {
+        // Return user's posts
+        get_user_posts(&mut db, &user.user_id).await?
+    } else {
+        // Return public posts
+        get_public_posts(&mut db).await?
+    };
+    Ok(Json(posts))
+}
+\`\`\`
+## Request Data and Forms
+\`\`\`rust
+use rocket::serde::{Deserialize, json::Json};
+use rocket::form::Form;
+// JSON body
+#[derive(Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub struct CreateUserRequest {
+    pub email: String,
+    pub name: String,
+    pub password: String,
+}
+#[post("/", data = "<body>")]
+async fn create_user(
+    mut db: Connection<DbPool>,
+    body: Json<CreateUserRequest>,
+) -> Result<(Status, Json<User>), AppError> {
+    // Validate
+    if body.email.is_empty() {
+        return Err(AppError::Validation("Email is required".into()));
+    }
+    let user = User::new(&body.email, &body.name, &body.password)?;
+    save_user(&mut db, &user).await?;
+    Ok((Status::Created, Json(user)))
+}
+// Form data
+#[derive(FromForm)]
+pub struct LoginForm {
+    email: String,
+    password: String,
+}
+#[post("/login", data = "<form>")]
+async fn login_form(form: Form<LoginForm>) -> Result<Json<TokenResponse>, AppError> {
+    // Process form...
+}
+// Query parameters
+#[get("/?<page>&<per_page>")]
+async fn list_users(
+    mut db: Connection<DbPool>,
+    page: Option<u32>,
+    per_page: Option<u32>,
+) -> Result<Json<Vec<User>>, AppError> {
+    let page = page.unwrap_or(1);
+    let per_page = per_page.unwrap_or(20).min(100);
+    let offset = (page - 1) * per_page;
+    let users = sqlx::query_as!(User,
+        "SELECT * FROM users LIMIT $1 OFFSET $2",
+        per_page as i64,
+        offset as i64
+    )
+    .fetch_all(&mut **db)
+    .await?;
+    Ok(Json(users))
+}
+\`\`\`
+## Error Handling
+\`\`\`rust
+use rocket::{
+    response::{self, Responder, Response},
+    http::{Status, ContentType},
+    Request,
+};
+use thiserror::Error;
+#[derive(Error, Debug)]
+pub enum AppError {
+    #[error("Resource not found")]
+    NotFound,
+    #[error("Unauthorized")]
+    Unauthorized,
+    #[error("Validation error: {0}")]
+    Validation(String),
+    #[error("Database error")]
+    Database(#[from] sqlx::Error),
+}
+impl<'r> Responder<'r, 'static> for AppError {
+    fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
+        let (status, message) = match &self {
+            AppError::NotFound => (Status::NotFound, self.to_string()),
+            AppError::Unauthorized => (Status::Unauthorized, self.to_string()),
+            AppError::Validation(_) => (Status::BadRequest, self.to_string()),
+            AppError::Database(e) => {
+                eprintln!("Database error: {:?}", e);
+                (Status::InternalServerError, "Internal server error".into())
+            }
+        };
+        let body = format!(r#"{{"error":"{}"}}"#, message);
+        Response::build()
+            .status(status)
+            .header(ContentType::JSON)
+            .sized_body(body.len(), std::io::Cursor::new(body))
+            .ok()
+    }
+}
+// Error catchers
+#[catch(404)]
+fn not_found() -> Json<serde_json::Value> {
+    Json(serde_json::json!({
+        "error": "Resource not found"
+    }))
+}
+#[catch(500)]
+fn internal_error() -> Json<serde_json::Value> {
+    Json(serde_json::json!({
+        "error": "Internal server error"
+    }))
+}
+#[catch(401)]
+fn unauthorized() -> Json<serde_json::Value> {
+    Json(serde_json::json!({
+        "error": "Unauthorized"
+    }))
+}
+\`\`\`
+## Fairings (Middleware)
+\`\`\`rust
+use rocket::{
+    fairing::{self, Fairing, Info, Kind},
+    Data, Request, Response,
+};
+pub struct RequestTimer;
+#[rocket::async_trait]
+impl Fairing for RequestTimer {
+    fn info(&self) -> Info {
+        Info {
+            name: "Request Timer",
+            kind: Kind::Request | Kind::Response,
+        }
+    }
+    async fn on_request(&self, request: &mut Request<'_>, _: &mut Data<'_>) {
+        request.local_cache(|| std::time::Instant::now());
+    }
+    async fn on_response<'r>(&self, request: &'r Request<'_>, _: &mut Response<'r>) {
+        let start = request.local_cache(|| std::time::Instant::now());
+        let duration = start.elapsed();
+        println!("{} {} - {:?}", request.method(), request.uri(), duration);
+    }
+}
+// CORS fairing
+use rocket::fairing::AdHoc;
+pub fn cors_fairing() -> AdHoc {
+    AdHoc::on_response("CORS", |_, response| Box::pin(async move {
+        response.set_header(rocket::http::Header::new("Access-Control-Allow-Origin", "*"));
+        response.set_header(rocket::http::Header::new("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE"));
+        response.set_header(rocket::http::Header::new("Access-Control-Allow-Headers", "Authorization, Content-Type"));
+    }))
+}
+// Attach fairings
+#[launch]
+fn rocket() -> Rocket<Build> {
+    rocket::build()
+        .attach(RequestTimer)
+        .attach(cors_fairing())
+        // ...
+}
+\`\`\`
+## Testing
+\`\`\`rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rocket::local::asynchronous::Client;
+    use rocket::http::{Status, ContentType};
+    async fn create_client() -> Client {
+        Client::tracked(rocket())
+            .await
+            .expect("valid rocket instance")
+    }
+    #[rocket::async_test]
+    async fn test_health() {
+        let client = create_client().await;
+        let response = client.get("/health").dispatch().await;
+        assert_eq!(response.status(), Status::Ok);
+    }
+    #[rocket::async_test]
+    async fn test_create_user() {
+        let client = create_client().await;
+        let response = client
+            .post("/api/v1/users")
+            .header(ContentType::JSON)
+            .body(r#"{"email":"test@example.com","name":"Test","password":"password123"}"#)
+            .dispatch()
+            .await;
+        assert_eq!(response.status(), Status::Created);
+    }
+    #[rocket::async_test]
+    async fn test_get_user_not_found() {
+        let client = create_client().await;
+        let response = client.get("/api/v1/users/nonexistent").dispatch().await;
+        assert_eq!(response.status(), Status::NotFound);
+    }
+    #[rocket::async_test]
+    async fn test_protected_route_without_auth() {
+        let client = create_client().await;
+        let response = client.get("/api/v1/users/profile").dispatch().await;
+        assert_eq!(response.status(), Status::Unauthorized);
+    }
+}
+\`\`\`
+## ✅ DO
+- Use request guards for auth and validation
+- Implement \`Responder\` for custom error types
+- Register error catchers with \`register\`
+- Use fairings for cross-cutting concerns
+- Use \`rocket_db_pools\` for database connections
+## ❌ DON'T
+- Don't use \`.unwrap()\` in handlers - return \`Result\`
+- Don't forget to mount routes with \`mount\`
+- Don't block async handlers with sync code
+- Don't expose internal errors to clients

package/.claude/skills/rust.md ADDED Viewed

@@ -0,0 +1,341 @@
+# Rust Skill
+## Ownership & Borrowing
+\`\`\`rust
+// Ownership - values have a single owner
+let s1 = String::from("hello");
+let s2 = s1; // s1 is MOVED, can no longer be used
+// Clone for explicit copy
+let s1 = String::from("hello");
+let s2 = s1.clone(); // Both valid
+// Borrowing - references without ownership
+fn print_length(s: &String) -> usize {
+    s.len()  // Can read but not modify
+}
+// Mutable borrow - only ONE at a time
+fn append(s: &mut String) {
+    s.push_str(" world");
+}
+let mut s = String::from("hello");
+append(&mut s);  // s is now "hello world"
+// Lifetimes - ensure references are valid
+fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+    if x.len() > y.len() { x } else { y }
+}
+\`\`\`
+## Error Handling with Result and Option
+\`\`\`rust
+use std::fs::File;
+use std::io::{self, Read};
+// Result<T, E> for operations that can fail
+fn read_file(path: &str) -> Result<String, io::Error> {
+    let mut file = File::open(path)?;  // ? propagates error
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?;
+    Ok(contents)
+}
+// Option<T> for values that may not exist
+fn find_user(id: u32) -> Option<User> {
+    users.iter().find(|u| u.id == id).cloned()
+}
+// Pattern matching on Result/Option
+fn process_user(id: u32) -> Result<(), AppError> {
+    match find_user(id) {
+        Some(user) => {
+            println!("Found: {}", user.name);
+            Ok(())
+        }
+        None => Err(AppError::NotFound),
+    }
+}
+// Combinators for cleaner code
+fn get_user_email(id: u32) -> Option<String> {
+    find_user(id)
+        .filter(|u| u.is_active)
+        .map(|u| u.email.clone())
+}
+// Converting between Option and Result
+fn require_user(id: u32) -> Result<User, AppError> {
+    find_user(id).ok_or(AppError::NotFound)
+}
+// unwrap_or for defaults
+let name = user.nickname.unwrap_or_else(|| user.name.clone());
+\`\`\`
+## Custom Error Types with thiserror
+\`\`\`rust
+use thiserror::Error;
+#[derive(Error, Debug)]
+pub enum AppError {
+    #[error("User not found: {0}")]
+    NotFound(String),
+    #[error("Unauthorized access")]
+    Unauthorized,
+    #[error("Validation failed: {0}")]
+    Validation(String),
+    #[error("Database error")]
+    Database(#[from] sqlx::Error),
+    #[error("IO error")]
+    Io(#[from] std::io::Error),
+    #[error("External service error: {0}")]
+    External(String),
+}
+// Using the error
+fn get_user(id: &str) -> Result<User, AppError> {
+    let user = db.find_user(id)
+        .map_err(AppError::Database)?
+        .ok_or_else(|| AppError::NotFound(id.to_string()))?;
+    if !user.is_active {
+        return Err(AppError::Validation("User is inactive".into()));
+    }
+    Ok(user)
+}
+\`\`\`
+## Structs and Implementations
+\`\`\`rust
+use serde::{Deserialize, Serialize};
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct User {
+    pub id: String,
+    pub email: String,
+    pub name: String,
+    #[serde(skip_serializing)]
+    password_hash: String,
+    pub is_active: bool,
+}
+impl User {
+    // Constructor
+    pub fn new(email: String, name: String, password: &str) -> Result<Self, AppError> {
+        let password_hash = hash_password(password)?;
+        Ok(Self {
+            id: Uuid::new_v4().to_string(),
+            email,
+            name,
+            password_hash,
+            is_active: true,
+        })
+    }
+    // Method
+    pub fn verify_password(&self, password: &str) -> bool {
+        verify_password(password, &self.password_hash)
+    }
+    // Builder pattern
+    pub fn with_id(mut self, id: String) -> Self {
+        self.id = id;
+        self
+    }
+}
+// Default trait implementation
+impl Default for User {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            email: String::new(),
+            name: String::from("Anonymous"),
+            password_hash: String::new(),
+            is_active: false,
+        }
+    }
+}
+\`\`\`
+## Traits
+\`\`\`rust
+// Define a trait
+pub trait Repository<T> {
+    fn find_by_id(&self, id: &str) -> Result<Option<T>, AppError>;
+    fn create(&self, entity: &T) -> Result<(), AppError>;
+    fn update(&self, entity: &T) -> Result<(), AppError>;
+    fn delete(&self, id: &str) -> Result<(), AppError>;
+}
+// Implement for a specific type
+pub struct PostgresUserRepository {
+    pool: PgPool,
+}
+impl Repository<User> for PostgresUserRepository {
+    fn find_by_id(&self, id: &str) -> Result<Option<User>, AppError> {
+        sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", id)
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(AppError::Database)
+    }
+    // ... other implementations
+}
+// Trait bounds in functions
+fn process<T: Repository<User> + Send + Sync>(repo: &T) -> Result<(), AppError> {
+    let user = repo.find_by_id("123")?;
+    // ...
+    Ok(())
+}
+// Using impl Trait for return types
+fn create_repository() -> impl Repository<User> {
+    PostgresUserRepository::new()
+}
+\`\`\`
+## Async/Await
+\`\`\`rust
+use tokio;
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let result = fetch_data().await?;
+    println!("Got: {:?}", result);
+    Ok(())
+}
+async fn fetch_data() -> Result<Data, AppError> {
+    let client = reqwest::Client::new();
+    let response = client
+        .get("https://api.example.com/data")
+        .send()
+        .await?
+        .json::<Data>()
+        .await?;
+    Ok(response)
+}
+// Concurrent execution
+async fn fetch_all(urls: Vec<String>) -> Vec<Result<Response, Error>> {
+    let futures: Vec<_> = urls.into_iter()
+        .map(|url| fetch_url(url))
+        .collect();
+    futures::future::join_all(futures).await
+}
+// With timeout
+use tokio::time::{timeout, Duration};
+async fn fetch_with_timeout(url: &str) -> Result<Response, AppError> {
+    timeout(Duration::from_secs(5), fetch_url(url))
+        .await
+        .map_err(|_| AppError::External("Request timed out".into()))?
+}
+\`\`\`
+## Collections and Iterators
+\`\`\`rust
+// Vector operations
+let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
+// Map, filter, collect
+let doubled: Vec<i32> = numbers.iter()
+    .filter(|&n| n % 2 == 0)
+    .map(|n| n * 2)
+    .collect();
+// HashMap
+use std::collections::HashMap;
+let mut scores: HashMap<String, i32> = HashMap::new();
+scores.insert("Alice".to_string(), 100);
+scores.entry("Bob".to_string()).or_insert(0);
+// Iterate with enumerate
+for (index, value) in numbers.iter().enumerate() {
+    println!("{}: {}", index, value);
+}
+// Fold/reduce
+let sum: i32 = numbers.iter().fold(0, |acc, x| acc + x);
+// Find and position
+let first_even = numbers.iter().find(|&n| n % 2 == 0);
+let position = numbers.iter().position(|&n| n > 3);
+\`\`\`
+## Testing
+\`\`\`rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_user_creation() {
+        let user = User::new(
+            "test@example.com".to_string(),
+            "Test User".to_string(),
+            "password123"
+        ).unwrap();
+        assert_eq!(user.email, "test@example.com");
+        assert!(user.is_active);
+    }
+    #[test]
+    fn test_password_verification() {
+        let user = User::new(
+            "test@example.com".to_string(),
+            "Test".to_string(),
+            "password123"
+        ).unwrap();
+        assert!(user.verify_password("password123"));
+        assert!(!user.verify_password("wrong"));
+    }
+    #[test]
+    #[should_panic(expected = "invalid email")]
+    fn test_invalid_email_panics() {
+        User::new("invalid".to_string(), "Test".to_string(), "pass").unwrap();
+    }
+    // Async tests with tokio
+    #[tokio::test]
+    async fn test_fetch_user() {
+        let repo = MockUserRepository::new();
+        let user = repo.find_by_id("123").await.unwrap();
+        assert!(user.is_some());
+    }
+}
+\`\`\`
+## ✅ DO
+- Handle all \`Result\` and \`Option\` cases explicitly
+- Use \`?\` operator for error propagation
+- Use \`thiserror\` for library errors, \`anyhow\` for applications
+- Prefer iterators over manual loops
+- Use \`clippy\` and \`rustfmt\`
+- Derive common traits: \`Debug\`, \`Clone\`, \`Serialize\`, \`Deserialize\`
+- Use \`Arc<T>\` for shared ownership across threads
+## ❌ DON'T
+- Don't use \`.unwrap()\` in production code (use \`?\` or handle errors)
+- Don't ignore compiler warnings
+- Don't fight the borrow checker - redesign if needed
+- Don't use \`unsafe\` without good reason
+- Don't clone everything to avoid borrowing (refactor instead)
+- Don't use \`String\` when \`&str\` suffices