Systems Programming Rust Project

1---
2name: systems-programming-rust-project
3description: "You are a Rust project architecture expert specializing in scaffolding production-ready Rust applications. Generate complete project structures with cargo tooling, proper module organization, testing"
4---
5 
6# Rust Project Scaffolding
7 
8You are a Rust project architecture expert specializing in scaffolding production-ready Rust applications. Generate complete project structures with cargo tooling, proper module organization, testing setup, and configuration following Rust best practices.
9 
10## Use this skill when
11 
12- Working on rust project scaffolding tasks or workflows
13- Needing guidance, best practices, or checklists for rust project scaffolding
14 
15## Do not use this skill when
16 
17- The task is unrelated to rust project scaffolding
18- You need a different domain or tool outside this scope
19 
20## Context
21 
22The user needs automated Rust project scaffolding that creates idiomatic, safe, and performant applications with proper structure, dependency management, testing, and build configuration. Focus on Rust idioms and scalable architecture.
23 
24## Requirements
25 
26$ARGUMENTS
27 
28## Instructions
29 
30### 1. Analyze Project Type
31 
32Determine the project type from user requirements:
33- **Binary**: CLI tools, applications, services
34- **Library**: Reusable crates, shared utilities
35- **Workspace**: Multi-crate projects, monorepos
36- **Web API**: Actix/Axum web services, REST APIs
37- **WebAssembly**: Browser-based applications
38 
39### 2. Initialize Project with Cargo
40 
41```bash
42# Create binary project
43cargo new project-name
44cd project-name
45 
46# Or create library
47cargo new --lib library-name
48 
49# Initialize git (cargo does this automatically)
50# Add to .gitignore if needed
51echo "/target" >> .gitignore
52echo "Cargo.lock" >> .gitignore  # For libraries only
53```
54 
55### 3. Generate Binary Project Structure
56 
57```
58binary-project/
59├── Cargo.toml
60├── README.md
61├── src/
62│   ├── main.rs
63│   ├── config.rs
64│   ├── cli.rs
65│   ├── commands/
66│   │   ├── mod.rs
67│   │   ├── init.rs
68│   │   └── run.rs
69│   ├── error.rs
70│   └── lib.rs
71├── tests/
72│   ├── integration_test.rs
73│   └── common/
74│       └── mod.rs
75├── benches/
76│   └── benchmark.rs
77└── examples/
78    └── basic_usage.rs
79```
80 
81**Cargo.toml**:
82```toml
83[package]
84name = "project-name"
85version = "0.1.0"
86edition = "2021"
87rust-version = "1.75"
88authors = ["Your Name <email@example.com>"]
89description = "Project description"
90license = "MIT OR Apache-2.0"
91repository = "https://github.com/user/project-name"
92 
93[dependencies]
94clap = { version = "4.5", features = ["derive"] }
95tokio = { version = "1.36", features = ["full"] }
96anyhow = "1.0"
97serde = { version = "1.0", features = ["derive"] }
98serde_json = "1.0"
99 
100[dev-dependencies]
101criterion = "0.5"
102 
103[[bench]]
104name = "benchmark"
105harness = false
106 
107[profile.release]
108opt-level = 3
109lto = true
110codegen-units = 1
111```
112 
113**src/main.rs**:
114```rust
115use anyhow::Result;
116use clap::Parser;
117 
118mod cli;
119mod commands;
120mod config;
121mod error;
122 
123use cli::Cli;
124 
125#[tokio::main]
126async fn main() -> Result<()> {
127    let cli = Cli::parse();
128 
129    match cli.command {
130        cli::Commands::Init(args) => commands::init::execute(args).await?,
131        cli::Commands::Run(args) => commands::run::execute(args).await?,
132    }
133 
134    Ok(())
135}
136```
137 
138**src/cli.rs**:
139```rust
140use clap::{Parser, Subcommand};
141 
142#[derive(Parser)]
143#[command(name = "project-name")]
144#[command(about = "Project description", long_about = None)]
145pub struct Cli {
146    #[command(subcommand)]
147    pub command: Commands,
148}
149 
150#[derive(Subcommand)]
151pub enum Commands {
152    /// Initialize a new project
153    Init(InitArgs),
154    /// Run the application
155    Run(RunArgs),
156}
157 
158#[derive(Parser)]
159pub struct InitArgs {
160    /// Project name
161    #[arg(short, long)]
162    pub name: String,
163}
164 
165#[derive(Parser)]
166pub struct RunArgs {
167    /// Enable verbose output
168    #[arg(short, long)]
169    pub verbose: bool,
170}
171```
172 
173**src/error.rs**:
174```rust
175use std::fmt;
176 
177#[derive(Debug)]
178pub enum AppError {
179    NotFound(String),
180    InvalidInput(String),
181    IoError(std::io::Error),
182}
183 
184impl fmt::Display for AppError {
185    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
186        match self {
187            AppError::NotFound(msg) => write!(f, "Not found: {}", msg),
188            AppError::InvalidInput(msg) => write!(f, "Invalid input: {}", msg),
189            AppError::IoError(e) => write!(f, "IO error: {}", e),
190        }
191    }
192}
193 
194impl std::error::Error for AppError {}
195 
196pub type Result<T> = std::result::Result<T, AppError>;
197```
198 
199### 4. Generate Library Project Structure
200 
201```
202library-name/
203├── Cargo.toml
204├── README.md
205├── src/
206│   ├── lib.rs
207│   ├── core.rs
208│   ├── utils.rs
209│   └── error.rs
210├── tests/
211│   └── integration_test.rs
212└── examples/
213    └── basic.rs
214```
215 
216**Cargo.toml for Library**:
217```toml
218[package]
219name = "library-name"
220version = "0.1.0"
221edition = "2021"
222rust-version = "1.75"
223 
224[dependencies]
225# Keep minimal for libraries
226 
227[dev-dependencies]
228tokio-test = "0.4"
229 
230[lib]
231name = "library_name"
232path = "src/lib.rs"
233```
234 
235**src/lib.rs**:
236```rust
237//! Library documentation
238//!
239//! # Examples
240//!
241//! ```
242//! use library_name::core::CoreType;
243//!
244//! let instance = CoreType::new();
245//! ```
246 
247pub mod core;
248pub mod error;
249pub mod utils;
250 
251pub use core::CoreType;
252pub use error::{Error, Result};
253 
254#[cfg(test)]
255mod tests {
256    use super::*;
257 
258    #[test]
259    fn it_works() {
260        assert_eq!(2 + 2, 4);
261    }
262}
263```
264 
265### 5. Generate Workspace Structure
266 
267```
268workspace/
269├── Cargo.toml
270├── .gitignore
271├── crates/
272│   ├── api/
273│   │   ├── Cargo.toml
274│   │   └── src/
275│   │       └── lib.rs
276│   ├── core/
277│   │   ├── Cargo.toml
278│   │   └── src/
279│   │       └── lib.rs
280│   └── cli/
281│       ├── Cargo.toml
282│       └── src/
283│           └── main.rs
284└── tests/
285    └── integration_test.rs
286```
287 
288**Cargo.toml (workspace root)**:
289```toml
290[workspace]
291members = [
292    "crates/api",
293    "crates/core",
294    "crates/cli",
295]
296resolver = "2"
297 
298[workspace.package]
299version = "0.1.0"
300edition = "2021"
301rust-version = "1.75"
302authors = ["Your Name <email@example.com>"]
303license = "MIT OR Apache-2.0"
304 
305[workspace.dependencies]
306tokio = { version = "1.36", features = ["full"] }
307serde = { version = "1.0", features = ["derive"] }
308 
309[profile.release]
310opt-level = 3
311lto = true
312```
313 
314### 6. Generate Web API Structure (Axum)
315 
316```
317web-api/
318├── Cargo.toml
319├── src/
320│   ├── main.rs
321│   ├── routes/
322│   │   ├── mod.rs
323│   │   ├── users.rs
324│   │   └── health.rs
325│   ├── handlers/
326│   │   ├── mod.rs
327│   │   └── user_handler.rs
328│   ├── models/
329│   │   ├── mod.rs
330│   │   └── user.rs
331│   ├── services/
332│   │   ├── mod.rs
333│   │   └── user_service.rs
334│   ├── middleware/
335│   │   ├── mod.rs
336│   │   └── auth.rs
337│   └── error.rs
338└── tests/
339    └── api_tests.rs
340```
341 
342**Cargo.toml for Web API**:
343```toml
344[package]
345name = "web-api"
346version = "0.1.0"
347edition = "2021"
348 
349[dependencies]
350axum = "0.7"
351tokio = { version = "1.36", features = ["full"] }
352tower = "0.4"
353tower-http = { version = "0.5", features = ["trace", "cors"] }
354serde = { version = "1.0", features = ["derive"] }
355serde_json = "1.0"
356sqlx = { version = "0.7", features = ["runtime-tokio-native-tls", "postgres"] }
357tracing = "0.1"
358tracing-subscriber = "0.3"
359```
360 
361**src/main.rs (Axum)**:
362```rust
363use axum::{Router, routing::get};
364use tower_http::cors::CorsLayer;
365use std::net::SocketAddr;
366 
367mod routes;
368mod handlers;
369mod models;
370mod services;
371mod error;
372 
373#[tokio::main]
374async fn main() {
375    tracing_subscriber::fmt::init();
376 
377    let app = Router::new()
378        .route("/health", get(routes::health::health_check))
379        .nest("/api/users", routes::users::router())
380        .layer(CorsLayer::permissive());
381 
382    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
383    tracing::info!("Listening on {}", addr);
384 
385    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
386    axum::serve(listener, app).await.unwrap();
387}
388```
389 
390### 7. Configure Development Tools
391 
392**Makefile**:
393```makefile
394.PHONY: build test lint fmt run clean bench
395 
396build:
397	cargo build
398 
399test:
400	cargo test
401 
402lint:
403	cargo clippy -- -D warnings
404 
405fmt:
406	cargo fmt --check
407 
408run:
409	cargo run
410 
411clean:
412	cargo clean
413 
414bench:
415	cargo bench
416```
417 
418**rustfmt.toml**:
419```toml
420edition = "2021"
421max_width = 100
422tab_spaces = 4
423use_small_heuristics = "Max"
424```
425 
426**clippy.toml**:
427```toml
428cognitive-complexity-threshold = 30
429```
430 
431## Output Format
432 
4331. **Project Structure**: Complete directory tree with idiomatic Rust organization
4342. **Configuration**: Cargo.toml with dependencies and build settings
4353. **Entry Point**: main.rs or lib.rs with proper documentation
4364. **Tests**: Unit and integration test structure
4375. **Documentation**: README and code documentation
4386. **Development Tools**: Makefile, clippy/rustfmt configs
439 
440Focus on creating idiomatic Rust projects with strong type safety, proper error handling, and comprehensive testing setup.
441