Initial commit: Hammerwork job queue library

- Database-driven job queue for Rust with Postgres and MySQL support
- Async/await architecture with configurable retry logic
- Worker pools with graceful shutdown
- Type-safe job handling with JSON payloads
- Comprehensive examples and documentation

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: CodingAnarchy

.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git init:*)",
+      "Bash(git remote add:*)",
+      "Bash(git add:*)"
+    ],
+    "deny": []
+  }
+}

.gitignore

@@ -0,0 +1 @@
+/target

CLAUDE.md

@@ -0,0 +1,89 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Hammerwork is a high-performance, database-driven job queue library for Rust with support for both PostgreSQL and MySQL. It provides async/await job processing with configurable retry logic, delayed jobs, and worker pools.
+
+## Common Development Commands
+
+### Building and Testing
+```bash
+# Build the project
+cargo build
+
+# Run tests
+cargo test
+
+# Run tests with specific features
+cargo test --features postgres
+cargo test --features mysql
+
+# Run examples
+cargo run --example postgres_example --features postgres
+cargo run --example mysql_example --features mysql
+
+# Check code formatting
+cargo fmt --check
+
+# Run clippy for linting
+cargo clippy -- -D warnings
+```
+
+### Feature Flags
+The project uses feature flags for database support:
+- `postgres`: Enable PostgreSQL support
+- `mysql`: Enable MySQL support
+- `default`: No database features enabled by default
+
+## Architecture
+
+The codebase follows a modular architecture with clear separation of concerns:
+
+### Core Components
+
+1. **Job (`src/job.rs`)**
+   - Defines the `Job` struct with UUID, payload, status, retry logic
+   - Job statuses: Pending, Running, Completed, Failed, Retrying
+   - Supports delayed execution and configurable retry attempts
+
+2. **Queue (`src/queue.rs`)**
+   - `DatabaseQueue` trait defines the interface for database operations
+   - `JobQueue<DB>` generic struct wraps database connection pools
+   - Database-specific implementations in `postgres` and `mysql` modules
+   - Uses database transactions for atomic job operations
+
+3. **Worker (`src/worker.rs`)**
+   - `Worker<DB>` processes jobs from specific queues
+   - Configurable polling intervals, retry delays, and max retries
+   - `WorkerPool<DB>` manages multiple workers with graceful shutdown
+   - Uses async channels for shutdown coordination
+
+4. **Error Handling (`src/error.rs`)**
+   - `HammerworkError` enum using thiserror for structured error handling
+   - Wraps SQLx, serialization, and custom errors
+
+### Database Schema
+
+Both PostgreSQL and MySQL implementations use a single table `hammerwork_jobs` with:
+- Job metadata (id, queue_name, status, attempts)
+- Timing information (created_at, scheduled_at, started_at, completed_at)
+- Payload data (JSON/JSONB) and error messages
+- Optimized indexes for queue polling
+
+### Key Design Patterns
+
+- **Generic over Database**: Uses `sqlx::Database` trait to support multiple databases
+- **Feature-gated implementations**: Database-specific code behind feature flags
+- **Async-first**: Built on Tokio with async/await throughout
+- **Transaction safety**: Uses database transactions for job state changes
+- **Type-safe job handling**: Job handlers return `Result<()>` for error handling
+
+## Development Notes
+
+- SQLx compile-time query checking requires database connections
+- PostgreSQL uses `FOR UPDATE SKIP LOCKED` for efficient job polling
+- MySQL implementation uses transaction-based locking (less optimal)
+- Tracing is integrated for observability
+- Examples demonstrate both database configurations