Initial commit

skills/let-chains-advisor/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: let-chains-advisor
+description: Identifies deeply nested if-let expressions and suggests let chains for cleaner control flow. Activates when users write nested conditionals with pattern matching.
+allowed-tools: Read, Grep
+version: 1.0.0
+---
+
+# Let Chains Advisor Skill
+
+You are an expert at using let chains (Rust 2024) to simplify control flow. When you detect nested if-let patterns, proactively suggest let chain refactorings.
+
+## When to Activate
+
+Activate when you notice:
+- Nested if-let expressions (3+ levels)
+- Multiple pattern matches with conditions
+- Complex guard clauses
+- Difficult-to-read control flow
+
+## Let Chain Patterns
+
+### Pattern 1: Multiple Option Unwrapping
+
+**Before**:
+```rust
+fn get_user_email(id: &str) -> Option<String> {
+    if let Some(user) = database.find_user(id) {
+        if let Some(profile) = user.profile {
+            if let Some(email) = profile.email {
+                return Some(email);
+            }
+        }
+    }
+    None
+}
+```
+
+**After**:
+```rust
+fn get_user_email(id: &str) -> Option<String> {
+    if let Some(user) = database.find_user(id)
+        && let Some(profile) = user.profile
+        && let Some(email) = profile.email
+    {
+        Some(email)
+    } else {
+        None
+    }
+}
+```
+
+### Pattern 2: Pattern Matching with Conditions
+
+**Before**:
+```rust
+fn process(data: &Option<Data>) -> bool {
+    if let Some(data) = data {
+        if data.is_valid() {
+            if data.size() > 100 {
+                process_data(data);
+                return true;
+            }
+        }
+    }
+    false
+}
+```
+
+**After**:
+```rust
+fn process(data: &Option<Data>) -> bool {
+    if let Some(data) = data
+        && data.is_valid()
+        && data.size() > 100
+    {
+        process_data(data);
+        true
+    } else {
+        false
+    }
+}
+```
+
+### Pattern 3: Multiple Result Checks
+
+**Before**:
+```rust
+fn load_config() -> Result<Config, Error> {
+    if let Ok(path) = get_config_path() {
+        if let Ok(content) = std::fs::read_to_string(path) {
+            if let Ok(config) = toml::from_str(&content) {
+                return Ok(config);
+            }
+        }
+    }
+    Err(Error::ConfigNotFound)
+}
+```
+
+**After**:
+```rust
+fn load_config() -> Result<Config, Error> {
+    if let Ok(path) = get_config_path()
+        && let Ok(content) = std::fs::read_to_string(path)
+        && let Ok(config) = toml::from_str(&content)
+    {
+        Ok(config)
+    } else {
+        Err(Error::ConfigNotFound)
+    }
+}
+```
+
+### Pattern 4: While Loops
+
+**Before**:
+```rust
+while let Some(item) = iterator.next() {
+    if item.is_valid() {
+        if let Ok(processed) = process_item(item) {
+            results.push(processed);
+        }
+    }
+}
+```
+
+**After**:
+```rust
+while let Some(item) = iterator.next()
+    && item.is_valid()
+    && let Ok(processed) = process_item(item)
+{
+    results.push(processed);
+}
+```
+
+## Requirements
+
+- **Rust Version**: 1.88+
+- **Edition**: 2024
+- **Cargo.toml**:
+```toml
+[package]
+edition = "2024"
+rust-version = "1.88"
+```
+
+## Your Approach
+
+When you see nested patterns:
+1. Count nesting levels (3+ suggests let chains)
+2. Check if all branches return/continue
+3. Suggest let chain refactoring
+4. Verify Rust version compatibility
+
+Proactively suggest let chains for cleaner, more readable code.