From 7657b264fb69f0b9878bfad2919b83f8bde7162e Mon Sep 17 00:00:00 2001
From: anikundu <anikundu@microsoft.com_msteamsmdb>
Date: Tue, 20 Jan 2026 01:33:39 -0800
Subject: [PATCH 1/3] Add rule-expander agent for systematic rule expansion

- Parameterized agent that works with any tool name
- Discovery mode to find high-value tools to support
- Cross-platform emphasis (Windows, macOS, Linux)
- Comprehensive testing requirements (6+ tests per rule)
- 10-phase workflow: research, implement, test, document, PR

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .github/agents/rule-expander.agent.md | 498 ++++++++++++++++++++++++++
 1 file changed, 498 insertions(+)
 create mode 100644 .github/agents/rule-expander.agent.md

diff --git a/.github/agents/rule-expander.agent.md b/.github/agents/rule-expander.agent.md
new file mode 100644
index 0000000..f1e9c61
--- /dev/null
+++ b/.github/agents/rule-expander.agent.md
@@ -0,0 +1,498 @@
+---
+name: Rule Expander
+description: Add command correction support for any CLI tool - parameterized for any tool name or dynamic discovery
+tools: ["read", "edit", "search", "execute"]
+---
+
+You are a specialist agent for expanding oops command correction support. You can be invoked in two modes:
+
+## Invocation Modes
+
+### Mode 1: Specific Tool
+When invoked with a tool name (e.g., "Add support for kubectl"):
+- Research that specific tool's error messages and common typos
+- Implement rules following oops patterns
+- Test thoroughly and create PR
+
+### Mode 2: Discovery
+When asked to find tools to support (e.g., "What tool should we add next?"):
+- Analyze current coverage in `src/rules/`
+- Search the web for popular CLI tools not yet supported
+- Check thefuck's rules at https://github.com/nvbn/thefuck/tree/master/thefuck/rules
+- Recommend high-value additions based on:
+  - Tool popularity (GitHub stars, download counts)
+  - Error frequency (how often users make mistakes)
+  - Complexity (more subcommands = more value)
+  - Gap analysis (what thefuck has that oops doesn't)
+
+---
+
+## Phase 1: Understand Current State
+
+Before any implementation, assess existing coverage:
+
+```bash
+# List all rule files
+find src/rules -name "*.rs" -type f
+
+# Count rules per category
+grep -r "impl Rule for" src/rules/ | wc -l
+
+# Check what tools are already covered
+grep -rh "is_app.*&\[" src/rules/ | sort -u
+```
+
+**Key files to understand:**
+- `src/rules/mod.rs` - Rule registry and `get_all_rules()`
+- `src/core/rule.rs` - Rule trait definition
+- `src/core/command.rs` - Command struct (script + output)
+- `src/utils/fuzzy.rs` - `get_close_matches()` for fuzzy matching
+
+---
+
+## Phase 2: Research the Target Tool
+
+For the tool you're adding support for:
+
+### 2.1 Gather Error Messages
+
+Run the tool with invalid inputs to capture real error formats:
+```bash
+# Generic pattern - replace TOOL with actual tool name
+TOOL invalidcmd 2>&1
+TOOL --invalid-flag 2>&1
+TOOL subcommand --help  # To see valid options
+```
+
+### 2.2 Check Existing Resources
+
+1. **thefuck rules**: Search `https://github.com/nvbn/thefuck/tree/master/thefuck/rules` for `TOOL`
+2. **Tool's GitHub issues**: Search for "typo", "did you mean", "unknown command"
+3. **Official documentation**: Look for troubleshooting or common errors sections
+4. **Stack Overflow**: Search for common mistakes with the tool
+
+### 2.3 Identify Error Patterns
+
+Document the error patterns you find:
+
+| Error Type | Example Output | Detection Strategy |
+|------------|----------------|-------------------|
+| Unknown command | "error: unknown command 'X'" | `output.contains("unknown command")` |
+| Did you mean | "Did you mean 'Y'?" | Regex for suggestions |
+| Invalid flag | "--foo is not recognized" | `output.contains("not recognized")` |
+| Missing argument | "requires a value" | `output.contains("requires")` |
+
+---
+
+## Phase 3: Create Feature Branch
+
+```bash
+# Always work on a feature branch
+git checkout -b feature/add-TOOL-rules
+
+# Verify
+git branch --show-current
+```
+
+---
+
+## Phase 4: Implement the Rule
+
+### 4.1 Choose File Location
+
+| Tool Category | File Path |
+|---------------|-----------|
+| Package manager (npm, pip, cargo, etc.) | `src/rules/package_managers/TOOL.rs` |
+| Cloud/Infrastructure (aws, kubectl, terraform) | `src/rules/cloud.rs` |
+| Development tool (go, java, maven) | `src/rules/devtools.rs` |
+| Framework (rails, django, react-native) | `src/rules/frameworks.rs` |
+| System utility (chmod, mkdir, sudo) | `src/rules/system.rs` |
+| Version control (git, hg, svn) | `src/rules/git/` or new VCS module |
+| Shell utility (grep, sed, awk) | `src/rules/shell_utils.rs` |
+| Other | `src/rules/misc.rs` or new module |
+
+### 4.2 Follow the Standard Rule Pattern
+
+```rust
+use crate::core::{is_app, Command, Rule};
+use crate::utils::{get_close_matches, replace_argument};
+
+/// Rule that fixes TOOL unknown command errors.
+///
+/// Matches when TOOL reports an unknown subcommand and suggests corrections
+/// using fuzzy matching against known TOOL commands.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct ToolUnknownCommand;
+
+impl ToolUnknownCommand {
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Known subcommands for TOOL - gathered from `TOOL --help`
+    const COMMANDS: &'static [&'static str] = &[
+        // Populate from tool's help output
+    ];
+}
+
+impl Rule for ToolUnknownCommand {
+    fn name(&self) -> &str {
+        "tool_unknown_command"
+    }
+
+    fn priority(&self) -> i32 {
+        1000  // Standard priority
+    }
+
+    fn is_match(&self, cmd: &Command) -> bool {
+        // 1. Verify it's the right tool
+        if !is_app(cmd, &["tool"]) {
+            return false;
+        }
+
+        // 2. Check for the specific error pattern
+        // Use case-insensitive matching where appropriate
+        let output_lower = cmd.output.to_lowercase();
+        output_lower.contains("unknown command")
+            || output_lower.contains("is not a tool command")
+    }
+
+    fn get_new_command(&self, cmd: &Command) -> Vec<String> {
+        let parts = cmd.script_parts();
+        if parts.len() < 2 {
+            return vec![];
+        }
+
+        let typo = &parts[1];
+
+        // Use fuzzy matching to find close commands
+        get_close_matches(typo, Self::COMMANDS, 3, 0.6)
+            .into_iter()
+            .map(|suggestion| replace_argument(&cmd.script, typo, suggestion))
+            .collect()
+    }
+}
+```
+
+### 4.3 Cross-Platform Considerations
+
+**CRITICAL**: All rules must work on Windows, macOS, and Linux:
+
+1. **Path separators**: Use `std::path::MAIN_SEPARATOR` or handle both `/` and `\`
+2. **Command names**: Check for both `tool` and `tool.exe` where applicable
+3. **Line endings**: Handle both `\n` and `\r\n` in output parsing
+4. **Case sensitivity**: File systems differ - use case-insensitive matching where appropriate
+5. **Shell differences**: Don't assume bash-specific features in patterns
+
+```rust
+// Good: Cross-platform app detection
+fn is_match(&self, cmd: &Command) -> bool {
+    is_app(cmd, &["tool", "tool.exe"])  // Handle Windows .exe
+        && cmd.output.to_lowercase().contains("error")  // Case-insensitive
+}
+
+// Good: Handle both line endings
+let lines: Vec<&str> = cmd.output.lines().collect();  // .lines() handles both
+
+// Avoid: Platform-specific assumptions
+// BAD: cmd.script.starts_with("./")  // Unix only
+// GOOD: Use is_app() which handles this
+```
+
+### 4.4 Register the Rule
+
+Add to the appropriate module's exports in `src/rules/mod.rs` or the category's `mod.rs`:
+
+```rust
+pub fn all_rules() -> Vec<Box<dyn Rule>> {
+    vec![
+        // ... existing rules
+        Box::new(ToolUnknownCommand::new()),
+    ]
+}
+```
+
+---
+
+## Phase 5: Write Comprehensive Tests
+
+**MANDATORY: Every rule requires these 6 test categories:**
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::core::Command;
+
+    // 1. Test rule name
+    #[test]
+    fn test_tool_rule_name() {
+        let rule = ToolUnknownCommand::new();
+        assert_eq!(rule.name(), "tool_unknown_command");
+    }
+
+    // 2. Test positive match - MUST use real error output from the tool
+    #[test]
+    fn test_tool_matches_unknown_command() {
+        let rule = ToolUnknownCommand::new();
+        // Use ACTUAL error output from running the tool
+        let cmd = Command::new(
+            "tool badcmd",
+            "error: unknown command 'badcmd'\n\nDid you mean 'goodcmd'?"
+        );
+        assert!(rule.is_match(&cmd));
+    }
+
+    // 3. Test negative match - different tool
+    #[test]
+    fn test_tool_not_matches_other_tool() {
+        let rule = ToolUnknownCommand::new();
+        let cmd = Command::new(
+            "othertool badcmd",
+            "error: unknown command"
+        );
+        assert!(!rule.is_match(&cmd));
+    }
+
+    // 4. Test negative match - success output
+    #[test]
+    fn test_tool_not_matches_success() {
+        let rule = ToolUnknownCommand::new();
+        let cmd = Command::new(
+            "tool goodcmd",
+            "Success! Operation completed."
+        );
+        assert!(!rule.is_match(&cmd));
+    }
+
+    // 5. Test correction generation
+    #[test]
+    fn test_tool_generates_correction() {
+        let rule = ToolUnknownCommand::new();
+        let cmd = Command::new(
+            "tool statsu",  // typo for "status"
+            "error: unknown command 'statsu'"
+        );
+        let fixes = rule.get_new_command(&cmd);
+        assert!(!fixes.is_empty());
+        // Verify the expected correction is in the list
+        assert!(fixes.iter().any(|f| f.contains("status")));
+    }
+
+    // 6. Test edge cases
+    #[test]
+    fn test_tool_empty_output() {
+        let rule = ToolUnknownCommand::new();
+        let cmd = Command::new("tool cmd", "");
+        assert!(!rule.is_match(&cmd));
+    }
+
+    #[test]
+    fn test_tool_no_subcommand() {
+        let rule = ToolUnknownCommand::new();
+        let cmd = Command::new("tool", "usage: tool <command>");
+        // Depending on rule, this might or might not match
+        let fixes = rule.get_new_command(&cmd);
+        // Should handle gracefully without panicking
+        assert!(fixes.is_empty() || !fixes.is_empty());
+    }
+}
+```
+
+---
+
+## Phase 6: Run All Tests and Checks
+
+```bash
+# Run all tests - MUST pass
+cargo test
+
+# Run specific tests for your new rule
+cargo test tool_  # Matches test names containing "tool_"
+
+# Check for warnings - MUST pass with no warnings
+cargo clippy -- -D warnings
+
+# Check formatting
+cargo fmt --check
+
+# If formatting issues:
+cargo fmt
+```
+
+**ALL checks must pass before proceeding.**
+
+---
+
+## Phase 7: Build and Manual Verification
+
+```bash
+# Full release build
+cargo build --release
+
+# Verify binary works
+./target/release/oops --version
+
+# Test shell alias generation (all shells)
+TF_SHELL=bash ./target/release/oops --alias | head -3
+TF_SHELL=zsh ./target/release/oops --alias | head -3
+TF_SHELL=fish ./target/release/oops --alias | head -3
+TF_SHELL=powershell ./target/release/oops --alias | head -3
+
+# On Windows, also test:
+# $env:TF_SHELL="powershell"; .\target\release\oops.exe --alias
+```
+
+---
+
+## Phase 8: Update Documentation (If Significant)
+
+Only update docs if adding a new category or significant tool:
+
+**CLAUDE.md** - Add to Rule Organization if new category
+**README.md** - Add to Supported Rules if significant tool
+
+---
+
+## Phase 9: Commit with Descriptive Message
+
+```bash
+# Stage your changes
+git add src/rules/
+
+# Commit with detailed message
+git commit -m "Add TOOL command corrections
+
+- Add ToolUnknownCommand rule for unknown subcommand errors
+- Add ToolInvalidFlag rule for invalid flag errors
+- Add N unit tests covering match/no-match/edge cases
+- Supports Windows, macOS, and Linux
+
+Fixes common errors like:
+  $ TOOL statsu -> TOOL status
+  $ TOOL --versoin -> TOOL --version
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+
+# Push to feature branch
+git push -u origin feature/add-TOOL-rules
+```
+
+---
+
+## Phase 10: Create Pull Request
+
+```bash
+gh pr create --title "Add TOOL command corrections" --body "$(cat <<'EOF'
+## Summary
+Adds command correction support for TOOL, fixing common typos and mistakes.
+
+## Rules Added
+- `tool_unknown_command` - Fixes unknown subcommand errors
+- `tool_invalid_flag` - Fixes invalid flag errors (if applicable)
+
+## Test Coverage
+- N unit tests added
+- All tests pass on CI
+
+## Verification Checklist
+- [x] `cargo test` passes
+- [x] `cargo clippy -- -D warnings` passes
+- [x] `cargo fmt --check` passes
+- [x] Release build succeeds
+- [x] Shell alias generation works
+
+## Example Corrections
+```
+$ TOOL statsu
+error: unknown command 'statsu'
+
+$ oops
+TOOL status [enter/up/down/ctrl+c]
+```
+
+## Cross-Platform
+- [x] Tested pattern matching with Windows line endings
+- [x] Uses `is_app()` for cross-platform command detection
+- [x] No platform-specific assumptions
+
+---
+Generated with [Claude Code](https://claude.com/claude-code)
+EOF
+)"
+```
+
+---
+
+## Discovery Mode: Finding High-Value Tools
+
+When asked to recommend tools to support, follow this research process:
+
+### Step 1: Analyze Current Coverage
+```bash
+# What tools are covered?
+grep -rh "is_app.*&\[" src/rules/ | sort -u
+
+# What categories exist?
+ls src/rules/
+```
+
+### Step 2: Research Popular Tools Not Covered
+
+Search the web for:
+- "most popular CLI tools 2024"
+- "command line tools developers use"
+- GitHub trending CLI tools
+
+Check thefuck's rules:
+- https://github.com/nvbn/thefuck/tree/master/thefuck/rules
+- Compare against oops coverage
+
+### Step 3: Evaluate Candidates
+
+For each candidate tool, consider:
+1. **Popularity**: GitHub stars, package downloads, Stack Overflow questions
+2. **Error Frequency**: How often do users mistype commands?
+3. **Complexity**: More subcommands = more correction opportunities
+4. **Platform Coverage**: Does it work on all platforms oops supports?
+
+### Step 4: Recommend with Justification
+
+Present findings with detailed analysis:
+- Tool name and description
+- Popularity metrics (GitHub stars, usage stats)
+- Complexity analysis (number of subcommands)
+- Error patterns found in the wild
+- Cross-platform availability
+- Whether thefuck already has rules we can reference
+
+---
+
+## Quality Checklist
+
+Before creating PR:
+
+- [ ] Rule follows existing patterns in `src/rules/`
+- [ ] Uses `is_app()` for command detection
+- [ ] Uses `get_close_matches()` for fuzzy matching (when applicable)
+- [ ] Has >= 6 unit tests (name, match, no-match-other, no-match-success, correction, edge)
+- [ ] Tests use REAL error output from the actual tool
+- [ ] Cross-platform: handles Windows, macOS, Linux
+- [ ] `cargo test` passes
+- [ ] `cargo clippy -- -D warnings` passes
+- [ ] `cargo fmt --check` passes
+- [ ] Feature branch, not main/master
+- [ ] Descriptive commit message
+- [ ] PR includes test plan and examples
+
+---
+
+## Common Mistakes to Avoid
+
+1. **Hardcoding error messages** - Tools update messages; use flexible patterns
+2. **Platform assumptions** - Test on Windows, handle `.exe`, `\r\n`
+3. **Skipping edge cases** - Empty output, no subcommand, special characters
+4. **Insufficient tests** - Minimum 6 tests per rule
+5. **Modifying unrelated code** - Keep changes minimal and focused
+6. **Committing to main** - Always use feature branches
+7. **Using thefuck's Python logic directly** - Translate concepts, not code

From 4db9c21fd6fbb0b62c56770626868a61e3d84295 Mon Sep 17 00:00:00 2001
From: anikundu <anikundu@microsoft.com_msteamsmdb>
Date: Wed, 21 Jan 2026 20:28:52 -0800
Subject: [PATCH 2/3] Fix invalid permission entry in Claude settings

Remove malformed gh pr create command with embedded heredoc that was
incorrectly stored as a permission pattern.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .claude/settings.local.json | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/.claude/settings.local.json b/.claude/settings.local.json
index 3407af2..8383621 100644
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -2,7 +2,24 @@
   "permissions": {
     "allow": [
       "Bash(git add:*)",
-      "Bash(git commit:*)"
+      "Bash(git commit:*)",
+      "Bash(tree:*)",
+      "Bash(cargo test:*)",
+      "Bash(cargo fmt:*)",
+      "Bash(set TF_SHELL=bash)",
+      "Bash(./target/release/oops.exe --alias)",
+      "Bash(set TF_SHELL=powershell)",
+      "Bash(./target/release/oops.exe --version)",
+      "Bash(TF_SHELL=bash ./target/release/oops.exe:*)",
+      "Bash(TF_SHELL=powershell ./target/release/oops.exe:*)",
+      "Bash(./target/release/oops.exe:*)",
+      "Bash(TF_SHELL=fish ./target/release/oops.exe:*)",
+      "Bash(TF_SHELL=tcsh ./target/release/oops.exe:*)",
+      "Bash(TF_SHELL=zsh ./target/release/oops.exe:*)",
+      "Bash(git remote add:*)",
+      "Bash(git push:*)",
+      "Bash(wc:*)",
+      "Bash(git checkout:*)"
     ]
   }
 }

From 9a3f86c04f5e871225ba5738f210a70f7a2fb9d8 Mon Sep 17 00:00:00 2001
From: anikundu <anikundu@microsoft.com_msteamsmdb>
Date: Wed, 21 Jan 2026 22:53:18 -0800
Subject: [PATCH 3/3] Fix CI build failures with reproducible builds

- Remove Cargo.lock from .gitignore and check it in
- Add rust-toolchain.toml pinning Rust to 1.85.0
- Pin home crate to 0.5.9 for compatibility
- Fix 27 clippy warnings (unused imports, collapsible ifs, needless borrows, etc.)
- Fix 5 failing doc tests
- Apply cargo fmt to all files

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .gitignore                          |    1 -
 Cargo.lock                          | 2233 +++++++++++++++++++++++++++
 benches/benchmarks.rs               |  108 +-
 rust-toolchain.toml                 |    3 +
 src/config/loader.rs                |   38 +-
 src/config/mod.rs                   |   12 +-
 src/core/command.rs                 |    5 +-
 src/core/mod.rs                     |    1 -
 src/main.rs                         |    1 -
 src/output/rerun.rs                 |   10 +-
 src/rules/cd.rs                     |   36 +-
 src/rules/cloud.rs                  |   22 +-
 src/rules/devtools.rs               |   59 +-
 src/rules/docker.rs                 |   20 +-
 src/rules/frameworks.rs             |   34 +-
 src/rules/git/add.rs                |   19 +-
 src/rules/git/branch.rs             |   10 +-
 src/rules/git/checkout.rs           |   24 +-
 src/rules/git/common.rs             |  122 +-
 src/rules/git/mod.rs                |   94 +-
 src/rules/git/not_command.rs        |   60 +-
 src/rules/git/push.rs               |   14 +-
 src/rules/git/support.rs            |   21 +-
 src/rules/misc.rs                   |   24 +-
 src/rules/mod.rs                    |   36 +-
 src/rules/no_command.rs             |   13 +-
 src/rules/package_managers/apt.rs   |   71 +-
 src/rules/package_managers/brew.rs  |  142 +-
 src/rules/package_managers/cargo.rs |   20 +-
 src/rules/package_managers/choco.rs |    5 +-
 src/rules/package_managers/conda.rs |   14 +-
 src/rules/package_managers/gem.rs   |    4 +-
 src/rules/package_managers/npm.rs   |   25 +-
 src/rules/package_managers/pip.rs   |   23 +-
 src/rules/package_managers/yum.rs   |    5 +-
 src/rules/shell_utils.rs            |   77 +-
 src/rules/sudo.rs                   |   33 +-
 src/rules/system.rs                 |  102 +-
 src/rules/typo.rs                   |   43 +-
 src/shells/bash.rs                  |    9 +-
 src/shells/mod.rs                   |    1 +
 src/shells/powershell.rs            |   71 +-
 src/shells/zsh.rs                   |    9 +-
 src/ui/colors.rs                    |    4 +-
 src/utils/cache.rs                  |    2 +-
 src/utils/executables.rs            |    4 +-
 tests/cli_tests.rs                  |   14 +-
 tests/parity_tests.rs               |   10 +-
 48 files changed, 3043 insertions(+), 665 deletions(-)
 create mode 100644 Cargo.lock
 create mode 100644 rust-toolchain.toml

diff --git a/.gitignore b/.gitignore
index fcbb2c1..2198e29 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,6 @@
 # Rust
 /target/
 **/*.rs.bk
-Cargo.lock
 
 # IDE
 .idea/
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..afc2696
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,2233 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
+
+[[package]]
+name = "assert_cmd"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c5bcfa8749ac45dd12cb11055aeeb6b27a3895560d60d71e3c23bf979e60514"
+dependencies = [
+ "anstyle",
+ "bstr",
+ "libc",
+ "predicates",
+ "predicates-core",
+ "predicates-tree",
+ "wait-timeout",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "bit-set"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+
+[[package]]
+name = "bstr"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
+dependencies = [
+ "memchr",
+ "regex-automata",
+ "serde",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
+
+[[package]]
+name = "cached"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8466736fe5dbcaf8b8ee24f9bbefe43c884dc3e9ff7178da70f55bffca1133c"
+dependencies = [
+ "ahash",
+ "cached_proc_macro",
+ "cached_proc_macro_types",
+ "hashbrown 0.14.5",
+ "instant",
+ "once_cell",
+ "thiserror",
+]
+
+[[package]]
+name = "cached_proc_macro"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "575f32e012222055211b70f5b0601f951f84523410a0e65c81f2744a6042450d"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "cached_proc_macro_types"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ade8366b8bd5ba243f0a58f036cc0ca8a2f069cff1a2351ef1cac6b083e16fc0"
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "console"
+version = "0.15.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "criterion"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+dependencies = [
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "is-terminal",
+ "itertools",
+ "num-traits",
+ "once_cell",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crossterm"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f476fe445d41c9e991fd07515a6f463074b782242ccf4a5b7b1d1012e70824df"
+dependencies = [
+ "bitflags 2.10.0",
+ "crossterm_winapi",
+ "libc",
+ "mio",
+ "parking_lot",
+ "signal-hook",
+ "signal-hook-mio",
+ "winapi",
+]
+
+[[package]]
+name = "crossterm_winapi"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "darling"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "difflib"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+
+[[package]]
+name = "dirs"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "fancy-regex"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "531e46835a22af56d1e3b66f04844bed63158bc094a628bec1d321d9b4c44bf2"
+dependencies = [
+ "bit-set",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "filedescriptor"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e40758ed24c9b2eeb76c35fb0aebc66c626084edd827e07e1552279814c6682d"
+dependencies = [
+ "libc",
+ "thiserror",
+ "winapi",
+]
+
+[[package]]
+name = "float-cmp"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b09cf3155332e944990140d967ff5eceb70df778b34f77d8075db46e4704e6d8"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "zerocopy",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+dependencies = [
+ "ahash",
+ "allocator-api2",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "home"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+]
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "insta"
+version = "1.46.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "248b42847813a1550dafd15296fd9748c651d0c32194559dbc05d804d54b21e8"
+dependencies = [
+ "console",
+ "once_cell",
+ "similar",
+ "tempfile",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "ioctl-rs"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7970510895cee30b3e9128319f2cefd4bde883a39f38baa279567ba3a7eb97d"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "is-terminal"
+version = "0.4.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "js-sys"
+version = "0.3.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.180"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
+
+[[package]]
+name = "libredox"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
+dependencies = [
+ "bitflags 2.10.0",
+ "libc",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "matchers"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
+dependencies = [
+ "regex-automata",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "memoffset"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "mio"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+dependencies = [
+ "libc",
+ "log",
+ "wasi",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "nix"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f346ff70e7dbfd675fe90590b92d59ef2de15a8779ae305ebcbfd3f0caf59be4"
+dependencies = [
+ "autocfg",
+ "bitflags 1.3.2",
+ "cfg-if",
+ "libc",
+ "memoffset 0.6.5",
+ "pin-utils",
+]
+
+[[package]]
+name = "normalize-line-endings"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "oops"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "assert_cmd",
+ "cached",
+ "clap",
+ "criterion",
+ "crossterm",
+ "dirs",
+ "fancy-regex",
+ "insta",
+ "once_cell",
+ "portable-pty",
+ "predicates",
+ "pyo3",
+ "regex",
+ "serde",
+ "shlex",
+ "strsim",
+ "tempfile",
+ "thiserror",
+ "toml",
+ "tracing",
+ "tracing-subscriber",
+ "url",
+ "which",
+ "windows",
+]
+
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "plotters"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950"
+
+[[package]]
+name = "portable-pty"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "806ee80c2a03dbe1a9fb9534f8d19e4c0546b790cde8fd1fea9d6390644cb0be"
+dependencies = [
+ "anyhow",
+ "bitflags 1.3.2",
+ "downcast-rs",
+ "filedescriptor",
+ "lazy_static",
+ "libc",
+ "log",
+ "nix",
+ "serial",
+ "shared_library",
+ "shell-words",
+ "winapi",
+ "winreg",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "predicates"
+version = "3.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d19ee57562043d37e82899fade9a22ebab7be9cef5026b07fda9cdd4293573"
+dependencies = [
+ "anstyle",
+ "difflib",
+ "float-cmp",
+ "normalize-line-endings",
+ "predicates-core",
+ "regex",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "727e462b119fe9c93fd0eb1429a5f7647394014cf3c04ab2c0350eeb09095ffa"
+
+[[package]]
+name = "predicates-tree"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72dd2d6d381dfb73a193c7fca536518d7caee39fc8503f74e7dc0be0531b425c"
+dependencies = [
+ "predicates-core",
+ "termtree",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53bdbb96d49157e65d45cc287af5f32ffadd5f4761438b527b055fb0d4bb8233"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset 0.9.1",
+ "parking_lot",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "deaa5745de3f5231ce10517a1f5dd97d53e5a2fd77aa6b5842292085831d48d7"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b42531d03e08d4ef1f6e85a2ed422eb678b8cd62b762e53891c05faf0d4afa"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7305c720fa01b8055ec95e484a6eca7a83c841267f0dd5280f0c8b8551d2c158"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c7e9b68bb9c3149c5b0cade5d07f953d6d125eb4337723c4ccdb665f1f96185"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.10.0",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
+name = "rustix"
+version = "0.38.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
+dependencies = [
+ "bitflags 2.10.0",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.15",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+dependencies = [
+ "bitflags 2.10.0",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.11.0",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serial"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1237a96570fc377c13baa1b88c7589ab66edced652e43ffb17088f003db3e86"
+dependencies = [
+ "serial-core",
+ "serial-unix",
+ "serial-windows",
+]
+
+[[package]]
+name = "serial-core"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f46209b345401737ae2125fe5b19a77acce90cd53e1658cda928e4fe9a64581"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "serial-unix"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f03fbca4c9d866e24a459cbca71283f545a37f8e3e002ad8c70593871453cab7"
+dependencies = [
+ "ioctl-rs",
+ "libc",
+ "serial-core",
+ "termios",
+]
+
+[[package]]
+name = "serial-windows"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15c6d3b776267a75d31bbdfd5d36c0ca051251caafc285827052bc53bcdc8162"
+dependencies = [
+ "libc",
+ "serial-core",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shared_library"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a9e7e0f2bfae24d8a5b5a66c5b257a83c7412304311512a0c054cd5e619da11"
+dependencies = [
+ "lazy_static",
+ "libc",
+]
+
+[[package]]
+name = "shell-words"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
+
+[[package]]
+name = "signal-hook-mio"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
+dependencies = [
+ "libc",
+ "mio",
+ "signal-hook",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "similar"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "2.0.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "tempfile"
+version = "3.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
+dependencies = [
+ "fastrand",
+ "getrandom 0.3.4",
+ "once_cell",
+ "rustix 1.1.3",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "termios"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5d9cf598a6d7ce700a4e6a9199da127e6819a61e64b68609683cc9a01b5683a"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "termtree"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
+dependencies = [
+ "indexmap",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_write",
+ "winnow",
+]
+
+[[package]]
+name = "toml_write"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex-automata",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "which"
+version = "6.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ee928febd44d98f2f459a4a79bd4d928591333a494a10a868418ac1b39cf1f"
+dependencies = [
+ "either",
+ "home",
+ "rustix 0.38.44",
+ "winsafe",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
+dependencies = [
+ "windows-core",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winnow"
+version = "0.7.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winsafe"
+version = "0.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "668f5168d10b9ee831de31933dc111a459c97ec93225beb307aed970d1372dfd"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfcd145825aace48cff44a8844de64bf75feec3080e0aa5cdbde72961ae51a65"
diff --git a/benches/benchmarks.rs b/benches/benchmarks.rs
index 9da5874..af55a0e 100644
--- a/benches/benchmarks.rs
+++ b/benches/benchmarks.rs
@@ -5,7 +5,7 @@
 //!
 //! Run benchmarks with: `cargo bench`
 
-use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 use std::process::Command as ProcessCommand;
 use std::time::{Duration, Instant};
 
@@ -118,31 +118,30 @@ fn bench_rule_matching(c: &mut Criterion) {
         ("cd_parent_match", "cd..", "command not found"),
         ("cd_mkdir_match", "cd newdir", "no such file or directory"),
         ("no_command_match", "gti status", "gti: command not found"),
-        ("complex_output", "git push origin master",
-         "error: failed to push some refs to 'origin'\n\
+        (
+            "complex_output",
+            "git push origin master",
+            "error: failed to push some refs to 'origin'\n\
           hint: Updates were rejected because the remote contains work\n\
           hint: that you do not have locally. This is usually caused by\n\
-          hint: another repository pushing to the same ref."),
+          hint: another repository pushing to the same ref.",
+        ),
     ];
 
     for (name, script, output) in test_cases {
         let cmd = TfCommand::new(script, output);
 
-        group.bench_with_input(
-            BenchmarkId::new("all_rules", name),
-            &cmd,
-            |b, cmd| {
-                b.iter(|| {
-                    let mut matches = Vec::new();
-                    for rule in rules.iter() {
-                        if rule.is_match(cmd) {
-                            matches.push(rule.name());
-                        }
+        group.bench_with_input(BenchmarkId::new("all_rules", name), &cmd, |b, cmd| {
+            b.iter(|| {
+                let mut matches = Vec::new();
+                for rule in rules.iter() {
+                    if rule.is_match(cmd) {
+                        matches.push(rule.name());
                     }
-                    black_box(matches)
-                })
-            },
-        );
+                }
+                black_box(matches)
+            })
+        });
     }
 
     group.finish();
@@ -166,21 +165,15 @@ fn bench_individual_rules(c: &mut Criterion) {
         let non_matching_cmd = TfCommand::new("ls /home", "file1 file2");
 
         group.bench_function("sudo_is_match_true", |b| {
-            b.iter(|| {
-                black_box(rule.is_match(&matching_cmd))
-            })
+            b.iter(|| black_box(rule.is_match(&matching_cmd)))
         });
 
         group.bench_function("sudo_is_match_false", |b| {
-            b.iter(|| {
-                black_box(rule.is_match(&non_matching_cmd))
-            })
+            b.iter(|| black_box(rule.is_match(&non_matching_cmd)))
         });
 
         group.bench_function("sudo_get_new_command", |b| {
-            b.iter(|| {
-                black_box(rule.get_new_command(&matching_cmd))
-            })
+            b.iter(|| black_box(rule.get_new_command(&matching_cmd)))
         });
     }
 
@@ -189,15 +182,11 @@ fn bench_individual_rules(c: &mut Criterion) {
         let matching_cmd = TfCommand::new("cd..", "command not found");
 
         group.bench_function("cd_parent_is_match", |b| {
-            b.iter(|| {
-                black_box(rule.is_match(&matching_cmd))
-            })
+            b.iter(|| black_box(rule.is_match(&matching_cmd)))
         });
 
         group.bench_function("cd_parent_get_new_command", |b| {
-            b.iter(|| {
-                black_box(rule.get_new_command(&matching_cmd))
-            })
+            b.iter(|| black_box(rule.get_new_command(&matching_cmd)))
         });
     }
 
@@ -206,15 +195,11 @@ fn bench_individual_rules(c: &mut Criterion) {
         let matching_cmd = TfCommand::new("cd newdir", "no such file or directory");
 
         group.bench_function("cd_mkdir_is_match", |b| {
-            b.iter(|| {
-                black_box(rule.is_match(&matching_cmd))
-            })
+            b.iter(|| black_box(rule.is_match(&matching_cmd)))
         });
 
         group.bench_function("cd_mkdir_get_new_command", |b| {
-            b.iter(|| {
-                black_box(rule.get_new_command(&matching_cmd))
-            })
+            b.iter(|| black_box(rule.get_new_command(&matching_cmd)))
         });
     }
 
@@ -223,17 +208,13 @@ fn bench_individual_rules(c: &mut Criterion) {
         let matching_cmd = TfCommand::new("gti status", "gti: command not found");
 
         group.bench_function("no_command_is_match", |b| {
-            b.iter(|| {
-                black_box(rule.is_match(&matching_cmd))
-            })
+            b.iter(|| black_box(rule.is_match(&matching_cmd)))
         });
 
         // Note: get_new_command for no_command is expensive as it searches PATH
         // We run it with a smaller iteration count
         group.bench_function("no_command_get_new_command", |b| {
-            b.iter(|| {
-                black_box(rule.get_new_command(&matching_cmd))
-            })
+            b.iter(|| black_box(rule.get_new_command(&matching_cmd)))
         });
     }
 
@@ -247,8 +228,14 @@ fn bench_command_parsing(c: &mut Criterion) {
     let test_scripts = vec![
         ("simple", "git status"),
         ("with_args", "git commit -m 'Initial commit'"),
-        ("complex", "docker run -it --rm -v /home/user:/data ubuntu:latest /bin/bash"),
-        ("long", "find . -name '*.rs' -type f -exec grep -l 'pattern' {} \\;"),
+        (
+            "complex",
+            "docker run -it --rm -v /home/user:/data ubuntu:latest /bin/bash",
+        ),
+        (
+            "long",
+            "find . -name '*.rs' -type f -exec grep -l 'pattern' {} \\;",
+        ),
     ];
 
     for (name, script) in test_scripts {
@@ -282,21 +269,17 @@ fn bench_full_correction(c: &mut Criterion) {
     for (name, script, output) in test_cases {
         let cmd = TfCommand::new(script, output);
 
-        group.bench_with_input(
-            BenchmarkId::new("get_corrections", name),
-            &cmd,
-            |b, cmd| {
-                b.iter(|| {
-                    let mut all_corrections = Vec::new();
-                    for rule in rules.iter() {
-                        if rule.is_match(cmd) {
-                            all_corrections.extend(rule.get_new_command(cmd));
-                        }
+        group.bench_with_input(BenchmarkId::new("get_corrections", name), &cmd, |b, cmd| {
+            b.iter(|| {
+                let mut all_corrections = Vec::new();
+                for rule in rules.iter() {
+                    if rule.is_match(cmd) {
+                        all_corrections.extend(rule.get_new_command(cmd));
                     }
-                    black_box(all_corrections)
-                })
-            },
-        );
+                }
+                black_box(all_corrections)
+            })
+        });
     }
 
     group.finish();
@@ -367,7 +350,8 @@ fn print_startup_comparison() {
     println!("Rust average startup time: {:?}", rust_avg);
 
     if !python_times.is_empty() {
-        let python_avg: Duration = python_times.iter().sum::<Duration>() / python_times.len() as u32;
+        let python_avg: Duration =
+            python_times.iter().sum::<Duration>() / python_times.len() as u32;
         println!("Python average startup time: {:?}", python_avg);
 
         let speedup = python_avg.as_secs_f64() / rust_avg.as_secs_f64();
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
new file mode 100644
index 0000000..b475f2f
--- /dev/null
+++ b/rust-toolchain.toml
@@ -0,0 +1,3 @@
+[toolchain]
+channel = "1.85.0"
+components = ["rustfmt", "clippy"]
diff --git a/src/config/loader.rs b/src/config/loader.rs
index 3d9bde4..7055b64 100644
--- a/src/config/loader.rs
+++ b/src/config/loader.rs
@@ -129,8 +129,12 @@ pub fn get_config_dir() -> PathBuf {
 pub fn ensure_config_dir() -> Result<PathBuf> {
     let config_dir = get_config_dir();
     if !config_dir.exists() {
-        fs::create_dir_all(&config_dir)
-            .with_context(|| format!("Failed to create config directory: {}", config_dir.display()))?;
+        fs::create_dir_all(&config_dir).with_context(|| {
+            format!(
+                "Failed to create config directory: {}",
+                config_dir.display()
+            )
+        })?;
     }
     Ok(config_dir)
 }
@@ -141,8 +145,9 @@ pub fn ensure_config_dir() -> Result<PathBuf> {
 pub fn ensure_rules_dir() -> Result<PathBuf> {
     let rules_dir = get_rules_dir();
     if !rules_dir.exists() {
-        fs::create_dir_all(&rules_dir)
-            .with_context(|| format!("Failed to create rules directory: {}", rules_dir.display()))?;
+        fs::create_dir_all(&rules_dir).with_context(|| {
+            format!("Failed to create rules directory: {}", rules_dir.display())
+        })?;
     }
     Ok(rules_dir)
 }
@@ -197,7 +202,10 @@ fn load_from_env() -> Settings {
     // THEFUCK_REQUIRE_CONFIRMATION: "true" or "false"
     if let Ok(value) = env::var("THEFUCK_REQUIRE_CONFIRMATION") {
         settings.require_confirmation = parse_bool(&value, true);
-        debug!("THEFUCK_REQUIRE_CONFIRMATION: {}", settings.require_confirmation);
+        debug!(
+            "THEFUCK_REQUIRE_CONFIRMATION: {}",
+            settings.require_confirmation
+        );
     }
 
     // THEFUCK_WAIT_COMMAND: integer (seconds)
@@ -327,7 +335,10 @@ fn parse_priority(value: &str) -> HashMap<String, i32> {
             if let Ok(priority_value) = parts[1].trim().parse::<i32>() {
                 priority.insert(rule_name.to_string(), priority_value);
             } else {
-                warn!("Invalid priority value for rule '{}': {}", rule_name, parts[1]);
+                warn!(
+                    "Invalid priority value for rule '{}': {}",
+                    rule_name, parts[1]
+                );
             }
         }
     }
@@ -344,7 +355,10 @@ fn parse_bool(value: &str, default: bool) -> bool {
         "true" | "1" | "yes" | "on" => true,
         "false" | "0" | "no" | "off" => false,
         _ => {
-            warn!("Invalid boolean value '{}', using default: {}", value, default);
+            warn!(
+                "Invalid boolean value '{}', using default: {}",
+                value, default
+            );
             default
         }
     }
@@ -367,10 +381,14 @@ pub fn create_default_settings_file() -> Result<PathBuf> {
 
 "#;
 
-        fs::write(&settings_path, format!("{}{}", header, toml_content))
-            .with_context(|| format!("Failed to write settings file: {}", settings_path.display()))?;
+        fs::write(&settings_path, format!("{}{}", header, toml_content)).with_context(|| {
+            format!("Failed to write settings file: {}", settings_path.display())
+        })?;
 
-        debug!("Created default settings file at: {}", settings_path.display());
+        debug!(
+            "Created default settings file at: {}",
+            settings_path.display()
+        );
     }
 
     Ok(settings_path)
diff --git a/src/config/mod.rs b/src/config/mod.rs
index f0b3fe4..3c45118 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -56,15 +56,7 @@ mod settings;
 
 // Re-export main types and functions
 pub use loader::{
-    create_default_settings_file,
-    ensure_config_dir,
-    ensure_rules_dir,
-    get_config_dir,
-    get_rules_dir,
-    get_settings,
-    get_settings_path,
-    init_settings,
-    load_settings,
-    SETTINGS,
+    create_default_settings_file, ensure_config_dir, ensure_rules_dir, get_config_dir,
+    get_rules_dir, get_settings, get_settings_path, init_settings, load_settings, SETTINGS,
 };
 pub use settings::Settings;
diff --git a/src/core/command.rs b/src/core/command.rs
index 99bd13e..36a83fb 100644
--- a/src/core/command.rs
+++ b/src/core/command.rs
@@ -95,10 +95,7 @@ impl Command {
             // Use shlex for proper shell-style parsing
             shlex::split(&self.script).unwrap_or_else(|| {
                 // Fallback to simple whitespace split if shlex fails
-                self.script
-                    .split_whitespace()
-                    .map(String::from)
-                    .collect()
+                self.script.split_whitespace().map(String::from).collect()
             })
         })
     }
diff --git a/src/core/mod.rs b/src/core/mod.rs
index 52de33c..54eb4f7 100644
--- a/src/core/mod.rs
+++ b/src/core/mod.rs
@@ -16,7 +16,6 @@ pub use corrected::{CorrectedCommand, SideEffect};
 pub use corrector::{get_best_correction, get_corrected_commands, get_rules, match_rule};
 pub use rule::{for_app, is_app, ForAppRule, Rule};
 
-use crate::config::Settings;
 use anyhow::Result;
 
 /// Options for the fix command operation.
diff --git a/src/main.rs b/src/main.rs
index a869a58..4ccfc8a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,7 +4,6 @@
 //! It provides faster startup time while maintaining full feature parity.
 
 use anyhow::Result;
-use clap::Parser;
 use tracing::debug;
 use tracing_subscriber::{fmt, prelude::*, EnvFilter};
 
diff --git a/src/output/rerun.rs b/src/output/rerun.rs
index 4e48dd6..d1968d1 100644
--- a/src/output/rerun.rs
+++ b/src/output/rerun.rs
@@ -35,7 +35,7 @@ const SLOW_COMMAND_TIMEOUT_MULTIPLIER: u32 = 15;
 /// use std::time::Duration;
 /// use oops::output::rerun::get_output;
 ///
-/// let output = get_output("ls -la", Duration::from_secs(5))?;
+/// let output = get_output("ls -la", Duration::from_secs(5)).unwrap();
 /// println!("Output: {}", output);
 /// ```
 pub fn get_output(script: &str, timeout: Duration) -> Result<String> {
@@ -186,8 +186,7 @@ pub fn is_slow_command(script: &str, slow_commands: &[String]) -> bool {
 
         // Also check for commands after sudo, env, etc.
         for prefix in &["sudo ", "sudo -e ", "env ", "time "] {
-            if script_lower.starts_with(prefix) {
-                let after_prefix = &script_lower[prefix.len()..];
+            if let Some(after_prefix) = script_lower.strip_prefix(prefix) {
                 if after_prefix.starts_with(&slow_cmd_lower) {
                     let offset = prefix.len() + slow_cmd.len();
                     if offset >= script.len() {
@@ -339,7 +338,10 @@ mod tests {
         let slow_commands = vec!["apt".to_string(), "pip".to_string()];
 
         assert!(is_slow_command("sudo apt install vim", &slow_commands));
-        assert!(is_slow_command("sudo -E pip install requests", &slow_commands));
+        assert!(is_slow_command(
+            "sudo -E pip install requests",
+            &slow_commands
+        ));
     }
 
     #[test]
diff --git a/src/rules/cd.rs b/src/rules/cd.rs
index 2e8682a..4e79007 100644
--- a/src/rules/cd.rs
+++ b/src/rules/cd.rs
@@ -196,6 +196,7 @@ impl CdCorrection {
     }
 
     /// Extract the typo directory name from the error output.
+    #[allow(dead_code)]
     fn extract_typo_from_output(output: &str) -> Option<String> {
         // Try common error message patterns
         let patterns = [
@@ -271,10 +272,12 @@ impl Rule for CdCorrection {
                 (None, path.to_string_lossy().to_string())
             } else {
                 // Has parent, search in parent directory
-                (Some(parent.to_path_buf()),
-                 path.file_name()
-                     .map(|s| s.to_string_lossy().to_string())
-                     .unwrap_or_default())
+                (
+                    Some(parent.to_path_buf()),
+                    path.file_name()
+                        .map(|s| s.to_string_lossy().to_string())
+                        .unwrap_or_default(),
+                )
             }
         } else {
             (None, dir_arg.to_string())
@@ -450,20 +453,14 @@ mod tests {
         #[test]
         fn test_matches_does_not_exist() {
             let rule = CdMkdir;
-            let cmd = Command::new(
-                "cd mydir",
-                "The directory 'mydir' does not exist",
-            );
+            let cmd = Command::new("cd mydir", "The directory 'mydir' does not exist");
             assert!(rule.is_match(&cmd));
         }
 
         #[test]
         fn test_matches_cannot_find_path() {
             let rule = CdMkdir;
-            let cmd = Command::new(
-                "cd mydir",
-                "Set-Location : Cannot find path 'mydir'",
-            );
+            let cmd = Command::new("cd mydir", "Set-Location : Cannot find path 'mydir'");
             assert!(rule.is_match(&cmd));
         }
 
@@ -494,7 +491,10 @@ mod tests {
             let rule = CdMkdir;
             let cmd = Command::new("cd project/src/lib", "no such file or directory");
             let fixes = rule.get_new_command(&cmd);
-            assert_eq!(fixes, vec!["mkdir -p project/src/lib && cd project/src/lib"]);
+            assert_eq!(
+                fixes,
+                vec!["mkdir -p project/src/lib && cd project/src/lib"]
+            );
         }
 
         #[test]
@@ -517,20 +517,14 @@ mod tests {
         #[test]
         fn test_matches_no_such_directory() {
             let rule = CdCorrection;
-            let cmd = Command::new(
-                "cd docuemnts",
-                "cd: no such file or directory: docuemnts",
-            );
+            let cmd = Command::new("cd docuemnts", "cd: no such file or directory: docuemnts");
             assert!(rule.is_match(&cmd));
         }
 
         #[test]
         fn test_matches_does_not_exist() {
             let rule = CdCorrection;
-            let cmd = Command::new(
-                "cd docuemnts",
-                "The directory 'docuemnts' does not exist",
-            );
+            let cmd = Command::new("cd docuemnts", "The directory 'docuemnts' does not exist");
             assert!(rule.is_match(&cmd));
         }
 
diff --git a/src/rules/cloud.rs b/src/rules/cloud.rs
index ba2ad01..f98d144 100644
--- a/src/rules/cloud.rs
+++ b/src/rules/cloud.rs
@@ -63,8 +63,7 @@ impl Rule for AwsCli {
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
         // Pattern to extract the invalid choice: (?<=Invalid choice: ')(.*)(?=', maybe you meant:)
-        let invalid_choice_re =
-            Regex::new(r"Invalid choice: '([^']*)', maybe you meant:").unwrap();
+        let invalid_choice_re = Regex::new(r"Invalid choice: '([^']*)', maybe you meant:").unwrap();
         // Pattern to extract options: ^\s*\*\s(.*)
         let options_re = Regex::new(r"(?m)^\s*\*\s+(.+)$").unwrap();
 
@@ -490,7 +489,10 @@ impl Rule for Whois {
                 .trim_start_matches("http://")
                 .trim_start_matches("https://")
                 .trim_start_matches("ftp://");
-            let hostname = without_protocol.split('/').next().unwrap_or(without_protocol);
+            let hostname = without_protocol
+                .split('/')
+                .next()
+                .unwrap_or(without_protocol);
             if !hostname.is_empty() {
                 return vec![format!("whois {}", hostname)];
             }
@@ -580,9 +582,7 @@ impl PortAlreadyInUse {
         use std::process::Command as ProcessCommand;
 
         // Check if lsof is available
-        if crate::utils::which("lsof").is_none() {
-            return None;
-        }
+        crate::utils::which("lsof")?;
 
         let output = ProcessCommand::new("lsof")
             .args(["-i", &format!(":{}", port)])
@@ -1296,7 +1296,10 @@ mod tests {
         #[test]
         fn test_matches_no_such_command() {
             let rule = HostsCli::new();
-            let cmd = Command::new("hostscli blok facebook.com", "Error: No such command \"blok\"");
+            let cmd = Command::new(
+                "hostscli blok facebook.com",
+                "Error: No such command \"blok\"",
+            );
             assert!(rule.is_match(&cmd));
         }
 
@@ -1320,7 +1323,10 @@ mod tests {
         #[test]
         fn test_get_new_command_typo() {
             let rule = HostsCli::new();
-            let cmd = Command::new("hostscli blok facebook.com", "Error: No such command \"blok\"");
+            let cmd = Command::new(
+                "hostscli blok facebook.com",
+                "Error: No such command \"blok\"",
+            );
             let fixes = rule.get_new_command(&cmd);
             assert!(!fixes.is_empty());
             assert!(fixes[0].contains("block"));
diff --git a/src/rules/devtools.rs b/src/rules/devtools.rs
index 0166dae..e6c5bd6 100644
--- a/src/rules/devtools.rs
+++ b/src/rules/devtools.rs
@@ -73,8 +73,8 @@ pub struct GoUnknownCommand;
 impl GoUnknownCommand {
     /// Common Go subcommands for fuzzy matching.
     const GO_COMMANDS: &'static [&'static str] = &[
-        "bug", "build", "clean", "doc", "env", "fix", "fmt", "generate", "get", "help",
-        "install", "list", "mod", "work", "run", "test", "tool", "version", "vet",
+        "bug", "build", "clean", "doc", "env", "fix", "fmt", "generate", "get", "help", "install",
+        "list", "mod", "work", "run", "test", "tool", "version", "vet",
     ];
 }
 
@@ -186,8 +186,7 @@ impl Rule for GradleNoTask {
             None => return vec![],
         };
 
-        let gradle_tasks: Vec<String> =
-            Self::GRADLE_TASKS.iter().map(|s| s.to_string()).collect();
+        let gradle_tasks: Vec<String> = Self::GRADLE_TASKS.iter().map(|s| s.to_string()).collect();
 
         let matches = get_close_matches(&wrong_task, &gradle_tasks, 3, 0.6);
         matches
@@ -286,7 +285,10 @@ impl Rule for Java {
 
     fn get_new_command(&self, command: &Command) -> Vec<String> {
         // Remove the .java extension
-        let fixed = command.script.strip_suffix(".java").unwrap_or(&command.script);
+        let fixed = command
+            .script
+            .strip_suffix(".java")
+            .unwrap_or(&command.script);
         vec![fixed.to_string()]
     }
 
@@ -623,7 +625,7 @@ impl FabCommandNotFound {
             }
 
             if should_yield && !line.is_empty() {
-                if let Some(cmd) = line.trim().split_whitespace().next() {
+                if let Some(cmd) = line.split_whitespace().next() {
                     result.push(cmd);
                 }
             }
@@ -697,9 +699,28 @@ pub struct GruntTaskNotFound;
 impl GruntTaskNotFound {
     /// Common Grunt tasks for fuzzy matching.
     const GRUNT_TASKS: &'static [&'static str] = &[
-        "build", "test", "default", "watch", "serve", "clean", "copy", "concat", "uglify",
-        "cssmin", "htmlmin", "jshint", "eslint", "sass", "less", "compass", "coffee", "typescript",
-        "imagemin", "connect", "concurrent", "newer",
+        "build",
+        "test",
+        "default",
+        "watch",
+        "serve",
+        "clean",
+        "copy",
+        "concat",
+        "uglify",
+        "cssmin",
+        "htmlmin",
+        "jshint",
+        "eslint",
+        "sass",
+        "less",
+        "compass",
+        "coffee",
+        "typescript",
+        "imagemin",
+        "connect",
+        "concurrent",
+        "newer",
     ];
 
     /// Extract the misspelled task from Grunt output.
@@ -1132,10 +1153,7 @@ mod tests {
 
         #[test]
         fn test_matches_task_not_found() {
-            let cmd = Command::new(
-                "gradle complie",
-                "Task 'complie' not found in root project",
-            );
+            let cmd = Command::new("gradle complie", "Task 'complie' not found in root project");
             assert!(GradleNoTask.is_match(&cmd));
         }
 
@@ -1153,10 +1171,7 @@ mod tests {
 
         #[test]
         fn test_get_new_command() {
-            let cmd = Command::new(
-                "gradle complie",
-                "Task 'complie' not found in root project",
-            );
+            let cmd = Command::new("gradle complie", "Task 'complie' not found in root project");
             let fixes = GradleNoTask.get_new_command(&cmd);
             // Should suggest compile-related tasks
             assert!(!fixes.is_empty());
@@ -1317,7 +1332,10 @@ mod tests {
 
         #[test]
         fn test_name() {
-            assert_eq!(MvnUnknownLifecyclePhase.name(), "mvn_unknown_lifecycle_phase");
+            assert_eq!(
+                MvnUnknownLifecyclePhase.name(),
+                "mvn_unknown_lifecycle_phase"
+            );
         }
 
         #[test]
@@ -1374,10 +1392,7 @@ Did you mean this?
 
         #[test]
         fn test_matches_install_to_require() {
-            let cmd = Command::new(
-                "composer install package",
-                "Did you mean composer require?",
-            );
+            let cmd = Command::new("composer install package", "Did you mean composer require?");
             assert!(ComposerNotCommand.is_match(&cmd));
         }
 
diff --git a/src/rules/docker.rs b/src/rules/docker.rs
index 018fd19..5e85766 100644
--- a/src/rules/docker.rs
+++ b/src/rules/docker.rs
@@ -554,7 +554,10 @@ mod tests {
         #[test]
         fn test_matches_not_a_docker_command() {
             let rule = DockerNotCommand;
-            let cmd = Command::new("docker pus myimage", "docker: 'pus' is not a docker command.");
+            let cmd = Command::new(
+                "docker pus myimage",
+                "docker: 'pus' is not a docker command.",
+            );
             assert!(rule.is_match(&cmd));
         }
 
@@ -601,10 +604,7 @@ mod tests {
         #[test]
         fn test_get_new_command_rn_to_run() {
             let rule = DockerNotCommand;
-            let cmd = Command::new(
-                "docker rn ubuntu",
-                "docker: 'rn' is not a docker command.",
-            );
+            let cmd = Command::new("docker rn ubuntu", "docker: 'rn' is not a docker command.");
             let fixes = rule.get_new_command(&cmd);
             assert!(!fixes.is_empty());
             // Should suggest "run" or similar
@@ -618,10 +618,7 @@ mod tests {
         #[test]
         fn test_get_new_command_imag_to_image() {
             let rule = DockerNotCommand;
-            let cmd = Command::new(
-                "docker imag ls",
-                "docker: 'imag' is not a docker command.",
-            );
+            let cmd = Command::new("docker imag ls", "docker: 'imag' is not a docker command.");
             let fixes = rule.get_new_command(&cmd);
             // Should suggest "image"
             assert!(
@@ -651,10 +648,7 @@ mod tests {
         #[test]
         fn test_matches_run_vagrant_up() {
             let rule = VagrantUp;
-            let cmd = Command::new(
-                "vagrant ssh",
-                "VM must be running. Run `vagrant up` first.",
-            );
+            let cmd = Command::new("vagrant ssh", "VM must be running. Run `vagrant up` first.");
             assert!(rule.is_match(&cmd));
         }
 
diff --git a/src/rules/frameworks.rs b/src/rules/frameworks.rs
index 9d92f9b..8f8af54 100644
--- a/src/rules/frameworks.rs
+++ b/src/rules/frameworks.rs
@@ -61,8 +61,7 @@ impl Rule for PythonExecute {
         }
 
         // Check for "No such file or directory" or "can't open file" error
-        cmd.output.contains("No such file or directory")
-            || cmd.output.contains("can't open file")
+        cmd.output.contains("No such file or directory") || cmd.output.contains("can't open file")
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -112,7 +111,8 @@ impl Rule for PythonModuleError {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        cmd.output.contains("ModuleNotFoundError: No module named '")
+        cmd.output
+            .contains("ModuleNotFoundError: No module named '")
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -254,8 +254,7 @@ impl Rule for ReactNativeCommandUnrecognized {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        is_app(cmd, &["react-native"])
-            && Self::extract_bad_command(&cmd.output).is_some()
+        is_app(cmd, &["react-native"]) && Self::extract_bad_command(&cmd.output).is_some()
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -315,8 +314,7 @@ impl NixosCmdNotFound {
     /// Check if NixOS is available on this system.
     fn is_nix_available() -> bool {
         // Check if /etc/nixos exists or if nix-env is available
-        PathBuf::from("/etc/nixos").exists()
-            || crate::utils::which("nix-env").is_some()
+        PathBuf::from("/etc/nixos").exists() || crate::utils::which("nix-env").is_some()
     }
 }
 
@@ -407,7 +405,9 @@ const OMNIENV_COMMANDS: &[&str] = &[
 impl OmnienvNoSuchCommand {
     /// Check if any omnienv tool is available.
     fn is_omnienv_available() -> bool {
-        OMNIENV_APPS.iter().any(|app| crate::utils::which(app).is_some())
+        OMNIENV_APPS
+            .iter()
+            .any(|app| crate::utils::which(app).is_some())
     }
 
     /// Extract the bad command from the error output.
@@ -549,7 +549,9 @@ impl Rule for DjangoSouthMerge {
     fn is_match(&self, cmd: &Command) -> bool {
         cmd.script.contains("manage.py")
             && cmd.script.contains("migrate")
-            && cmd.output.contains("--merge: will just attempt the migration")
+            && cmd
+                .output
+                .contains("--merge: will just attempt the migration")
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -1516,7 +1518,10 @@ mod tests {
             let output = "error or pass --delete-ghost-migrations to fix";
             let cmd = Command::new("python manage.py migrate", output);
             let fixes = rule.get_new_command(&cmd);
-            assert_eq!(fixes, vec!["python manage.py migrate --delete-ghost-migrations"]);
+            assert_eq!(
+                fixes,
+                vec!["python manage.py migrate --delete-ghost-migrations"]
+            );
         }
     }
 
@@ -1619,7 +1624,9 @@ mod tests {
             let cmd = Command::new("workon nonexistent_env_xyz", "");
             let fixes = rule.get_new_command(&cmd);
             // Should at least suggest creating the virtualenv
-            assert!(fixes.iter().any(|f| f.contains("mkvirtualenv nonexistent_env_xyz")));
+            assert!(fixes
+                .iter()
+                .any(|f| f.contains("mkvirtualenv nonexistent_env_xyz")));
         }
 
         #[test]
@@ -1707,7 +1714,10 @@ mod tests {
         #[test]
         fn test_no_match_not_yarn() {
             let rule = YarnCommandNotFound;
-            let cmd = Command::new("npm require express", "error Command \"require\" not found.");
+            let cmd = Command::new(
+                "npm require express",
+                "error Command \"require\" not found.",
+            );
             assert!(!rule.is_match(&cmd));
         }
 
diff --git a/src/rules/git/add.rs b/src/rules/git/add.rs
index 437964d..bc4f222 100644
--- a/src/rules/git/add.rs
+++ b/src/rules/git/add.rs
@@ -31,7 +31,10 @@ impl Rule for GitAdd {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        if !cmd.output.contains("did not match any file(s) known to git.") {
+        if !cmd
+            .output
+            .contains("did not match any file(s) known to git.")
+        {
             return false;
         }
 
@@ -90,7 +93,9 @@ impl Rule for GitAddForce {
     fn is_match(&self, cmd: &Command) -> bool {
         cmd.script.contains("add")
             && (cmd.output.contains("Use -f if you really want to add")
-                || cmd.output.contains("ignored by one of your .gitignore files"))
+                || cmd
+                    .output
+                    .contains("ignored by one of your .gitignore files"))
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -248,10 +253,7 @@ mod tests {
     #[test]
     fn test_git_commit_add_get_new_command() {
         let rule = GitCommitAdd;
-        let cmd = Command::new(
-            "git commit -m 'test'",
-            "no changes added to commit\n",
-        );
+        let cmd = Command::new("git commit -m 'test'", "no changes added to commit\n");
         let new_commands = rule.get_new_command(&cmd);
         assert!(new_commands.iter().any(|c| c.contains("commit -a")));
         assert!(new_commands.iter().any(|c| c.contains("commit -p")));
@@ -299,10 +301,7 @@ mod tests {
     #[test]
     fn test_git_add_all_get_new_command() {
         let rule = GitAddAll;
-        let cmd = Command::new(
-            "git status",
-            "Untracked files:\n\tnewfile.txt\n",
-        );
+        let cmd = Command::new("git status", "Untracked files:\n\tnewfile.txt\n");
         let new_commands = rule.get_new_command(&cmd);
         assert!(new_commands.contains(&"git add .".to_string()));
         assert!(new_commands.contains(&"git add -A".to_string()));
diff --git a/src/rules/git/branch.rs b/src/rules/git/branch.rs
index 0f7590a..9834586 100644
--- a/src/rules/git/branch.rs
+++ b/src/rules/git/branch.rs
@@ -399,20 +399,14 @@ mod tests {
     #[test]
     fn test_git_branch_list_matches() {
         let rule = GitBranchList;
-        let cmd = Command::new(
-            "git branch -l",
-            "error: unknown switch `l'\n",
-        );
+        let cmd = Command::new("git branch -l", "error: unknown switch `l'\n");
         assert!(rule.is_match(&cmd));
     }
 
     #[test]
     fn test_git_branch_list_get_new_command() {
         let rule = GitBranchList;
-        let cmd = Command::new(
-            "git branch -l feature*",
-            "error: unknown switch `l'\n",
-        );
+        let cmd = Command::new("git branch -l feature*", "error: unknown switch `l'\n");
         let new_commands = rule.get_new_command(&cmd);
         assert!(new_commands.iter().any(|c| c.contains("--list")));
     }
diff --git a/src/rules/git/checkout.rs b/src/rules/git/checkout.rs
index 9984c29..8617a26 100644
--- a/src/rules/git/checkout.rs
+++ b/src/rules/git/checkout.rs
@@ -33,7 +33,8 @@ impl Rule for GitCheckout {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        cmd.output.contains("did not match any file(s) known to git")
+        cmd.output
+            .contains("did not match any file(s) known to git")
             && !cmd.output.contains("Did you forget to 'git add'?")
     }
 
@@ -67,8 +68,7 @@ impl Rule for GitCheckout {
 
         // If no suggestions found, offer to create the branch first
         if new_commands.is_empty() {
-            let create_and_checkout =
-                and_commands(&format!("git branch {}", missing), &cmd.script);
+            let create_and_checkout = and_commands(&format!("git branch {}", missing), &cmd.script);
             new_commands.push(create_and_checkout);
         }
 
@@ -101,8 +101,12 @@ impl Rule for GitCheckoutUncommittedChanges {
 
     fn is_match(&self, cmd: &Command) -> bool {
         (cmd.script.contains("checkout") || cmd.script.contains("switch"))
-            && (cmd.output.contains("Please commit your changes or stash them")
-                || cmd.output.contains("Your local changes to the following files would be overwritten"))
+            && (cmd
+                .output
+                .contains("Please commit your changes or stash them")
+                || cmd
+                    .output
+                    .contains("Your local changes to the following files would be overwritten"))
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -141,7 +145,10 @@ impl Rule for GitMainMaster {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        if !cmd.output.contains("did not match any file(s) known to git") {
+        if !cmd
+            .output
+            .contains("did not match any file(s) known to git")
+        {
             return false;
         }
 
@@ -192,10 +199,7 @@ mod tests {
     #[test]
     fn test_git_checkout_no_match_success() {
         let rule = GitCheckout;
-        let cmd = Command::new(
-            "git checkout main",
-            "Switched to branch 'main'\n",
-        );
+        let cmd = Command::new("git checkout main", "Switched to branch 'main'\n");
         assert!(!rule.is_match(&cmd));
     }
 
diff --git a/src/rules/git/common.rs b/src/rules/git/common.rs
index 48b60c6..f1b8198 100644
--- a/src/rules/git/common.rs
+++ b/src/rules/git/common.rs
@@ -51,7 +51,8 @@ impl Rule for GitPull {
                 // Extract branch name from context
                 if let Some(branch_line) = lines.get(i + 1) {
                     let branch = branch_line.split_whitespace().last().unwrap_or("main");
-                    let set_upstream = format!("git branch --set-upstream-to=origin/{} {}", branch, branch);
+                    let set_upstream =
+                        format!("git branch --set-upstream-to=origin/{} {}", branch, branch);
                     return vec![and_commands(&set_upstream, &cmd.script)];
                 }
             }
@@ -91,12 +92,19 @@ impl Rule for GitPullUncommittedChanges {
     fn is_match(&self, cmd: &Command) -> bool {
         cmd.script.contains("pull")
             && (cmd.output.contains("You have unstaged changes")
-                || cmd.output.contains("Your local changes to the following files would be overwritten")
-                || cmd.output.contains("Please commit your changes or stash them"))
+                || cmd
+                    .output
+                    .contains("Your local changes to the following files would be overwritten")
+                || cmd
+                    .output
+                    .contains("Please commit your changes or stash them"))
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
-        vec![and_commands("git stash", &format!("{} && git stash pop", cmd.script))]
+        vec![and_commands(
+            "git stash",
+            &format!("{} && git stash pop", cmd.script),
+        )]
     }
 }
 
@@ -196,8 +204,7 @@ impl Rule for GitCommitAmend {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        cmd.script.contains("commit")
-            && cmd.output.contains("empty commit message")
+        cmd.script.contains("commit") && cmd.output.contains("empty commit message")
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -229,8 +236,7 @@ impl Rule for GitCommitReset {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        cmd.script.contains("commit")
-            && cmd.output.contains("nothing to commit")
+        cmd.script.contains("commit") && cmd.output.contains("nothing to commit")
     }
 
     fn get_new_command(&self, _cmd: &Command) -> Vec<String> {
@@ -266,10 +272,7 @@ impl Rule for GitDiffStaged {
     }
 
     fn get_new_command(&self, _cmd: &Command) -> Vec<String> {
-        vec![
-            "git diff --staged".to_string(),
-            "git diff HEAD".to_string(),
-        ]
+        vec!["git diff --staged".to_string(), "git diff HEAD".to_string()]
     }
 
     fn requires_output(&self) -> bool {
@@ -405,7 +408,8 @@ impl Rule for GitRebaseNoChanges {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        cmd.output.contains("No changes - did you forget to use 'git add'")
+        cmd.output
+            .contains("No changes - did you forget to use 'git add'")
     }
 
     fn get_new_command(&self, _cmd: &Command) -> Vec<String> {
@@ -609,8 +613,7 @@ impl Rule for GitPullClone {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        cmd.script.contains("pull")
-            && cmd.output.contains("not a git repository")
+        cmd.script.contains("pull") && cmd.output.contains("not a git repository")
     }
 
     fn get_new_command(&self, _cmd: &Command) -> Vec<String> {
@@ -687,9 +690,10 @@ impl Rule for GitBisectUsage {
         let broken_re = Regex::new(r"git bisect ([^ $]*)").unwrap();
         let usage_re = Regex::new(r"usage: git bisect \[([^\]]+)\]").unwrap();
 
-        if let (Some(broken_cap), Some(usage_cap)) =
-            (broken_re.captures(&cmd.script), usage_re.captures(&cmd.output))
-        {
+        if let (Some(broken_cap), Some(usage_cap)) = (
+            broken_re.captures(&cmd.script),
+            usage_re.captures(&cmd.output),
+        ) {
             let broken = broken_cap.get(1).map(|m| m.as_str()).unwrap_or("");
             let usage = usage_cap.get(1).map(|m| m.as_str()).unwrap_or("");
             let options: Vec<String> = usage.split('|').map(|s| s.trim().to_string()).collect();
@@ -890,10 +894,11 @@ impl Rule for GitFlagAfterFilename {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        cmd.output.contains("fatal: bad flag '")
-            && cmd.output.contains("' used after filename")
+        cmd.output.contains("fatal: bad flag '") && cmd.output.contains("' used after filename")
             || cmd.output.contains("fatal: option '")
-                && cmd.output.contains("' must come before non-option arguments")
+                && cmd
+                    .output
+                    .contains("' must come before non-option arguments")
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -1261,7 +1266,10 @@ mod tests {
             "fatal: refusing to merge unrelated histories\n",
         );
         let new_commands = rule.get_new_command(&cmd);
-        assert_eq!(new_commands, vec!["git merge origin/main --allow-unrelated-histories"]);
+        assert_eq!(
+            new_commands,
+            vec!["git merge origin/main --allow-unrelated-histories"]
+        );
     }
 
     #[test]
@@ -1309,20 +1317,14 @@ mod tests {
     #[test]
     fn test_git_tag_force_matches() {
         let rule = GitTagForce;
-        let cmd = Command::new(
-            "git tag v1.0",
-            "fatal: tag 'v1.0' already exists\n",
-        );
+        let cmd = Command::new("git tag v1.0", "fatal: tag 'v1.0' already exists\n");
         assert!(rule.is_match(&cmd));
     }
 
     #[test]
     fn test_git_tag_force_get_new_command() {
         let rule = GitTagForce;
-        let cmd = Command::new(
-            "git tag v1.0",
-            "fatal: tag 'v1.0' already exists\n",
-        );
+        let cmd = Command::new("git tag v1.0", "fatal: tag 'v1.0' already exists\n");
         let new_commands = rule.get_new_command(&cmd);
         assert_eq!(new_commands, vec!["git tag -f v1.0"]);
     }
@@ -1330,22 +1332,19 @@ mod tests {
     #[test]
     fn test_git_clone_git_clone_matches() {
         let rule = GitCloneGitClone;
-        let cmd = Command::new(
-            "git clone git clone https://github.com/user/repo.git",
-            "",
-        );
+        let cmd = Command::new("git clone git clone https://github.com/user/repo.git", "");
         assert!(rule.is_match(&cmd));
     }
 
     #[test]
     fn test_git_clone_git_clone_get_new_command() {
         let rule = GitCloneGitClone;
-        let cmd = Command::new(
-            "git clone git clone https://github.com/user/repo.git",
-            "",
-        );
+        let cmd = Command::new("git clone git clone https://github.com/user/repo.git", "");
         let new_commands = rule.get_new_command(&cmd);
-        assert_eq!(new_commands, vec!["git clone https://github.com/user/repo.git"]);
+        assert_eq!(
+            new_commands,
+            vec!["git clone https://github.com/user/repo.git"]
+        );
     }
 
     #[test]
@@ -1361,10 +1360,7 @@ mod tests {
     #[test]
     fn test_git_hook_bypass_get_new_command() {
         let rule = GitHookBypass;
-        let cmd = Command::new(
-            "git commit -m 'test'",
-            "pre-commit hook failed\n",
-        );
+        let cmd = Command::new("git commit -m 'test'", "pre-commit hook failed\n");
         let new_commands = rule.get_new_command(&cmd);
         assert_eq!(new_commands, vec!["git commit -m 'test' --no-verify"]);
     }
@@ -1471,7 +1467,10 @@ mod tests {
             "No such file or directory",
         );
         let new_commands = rule.get_new_command(&cmd);
-        assert_eq!(new_commands, vec!["git clone https://github.com/nvbn/thefuck.git"]);
+        assert_eq!(
+            new_commands,
+            vec!["git clone https://github.com/nvbn/thefuck.git"]
+        );
     }
 
     #[test]
@@ -1493,7 +1492,10 @@ mod tests {
         let rule = GitDiffNoIndex;
         let cmd = Command::new("git diff file1.txt file2.txt", "");
         let new_commands = rule.get_new_command(&cmd);
-        assert_eq!(new_commands, vec!["git diff --no-index file1.txt file2.txt"]);
+        assert_eq!(
+            new_commands,
+            vec!["git diff --no-index file1.txt file2.txt"]
+        );
     }
 
     #[test]
@@ -1516,10 +1518,7 @@ mod tests {
     #[test]
     fn test_git_fix_stash_get_new_command() {
         let rule = GitFixStash;
-        let cmd = Command::new(
-            "git stash lst",
-            "usage: git stash list [<options>]\n",
-        );
+        let cmd = Command::new("git stash lst", "usage: git stash list [<options>]\n");
         let new_commands = rule.get_new_command(&cmd);
         assert!(!new_commands.is_empty());
         assert!(new_commands[0].contains("list"));
@@ -1572,27 +1571,24 @@ mod tests {
     #[test]
     fn test_git_help_aliased_matches() {
         let rule = GitHelpAliased;
-        let cmd = Command::new(
-            "git help ci",
-            "`ci` is aliased to `commit`",
-        );
+        let cmd = Command::new("git help ci", "`ci` is aliased to `commit`");
         assert!(rule.is_match(&cmd));
     }
 
     #[test]
     fn test_git_help_aliased_no_match() {
         let rule = GitHelpAliased;
-        let cmd = Command::new("git help commit", "NAME\n       git-commit - Record changes to the repository");
+        let cmd = Command::new(
+            "git help commit",
+            "NAME\n       git-commit - Record changes to the repository",
+        );
         assert!(!rule.is_match(&cmd));
     }
 
     #[test]
     fn test_git_help_aliased_get_new_command() {
         let rule = GitHelpAliased;
-        let cmd = Command::new(
-            "git help ci",
-            "`ci` is aliased to `commit`",
-        );
+        let cmd = Command::new("git help ci", "`ci` is aliased to `commit`");
         let new_commands = rule.get_new_command(&cmd);
         assert_eq!(new_commands, vec!["git help commit"]);
     }
@@ -1644,7 +1640,10 @@ mod tests {
     #[test]
     fn test_git_rebase_merge_dir_no_match() {
         let rule = GitRebaseMergeDir;
-        let cmd = Command::new("git rebase master", "Successfully rebased and updated refs/heads/feature.\n");
+        let cmd = Command::new(
+            "git rebase master",
+            "Successfully rebased and updated refs/heads/feature.\n",
+        );
         assert!(!rule.is_match(&cmd));
     }
 
@@ -1694,7 +1693,10 @@ mod tests {
             "fatal: No such remote 'origin'\n",
         );
         let new_commands = rule.get_new_command(&cmd);
-        assert_eq!(new_commands, vec!["git remote add origin https://github.com/user/repo.git"]);
+        assert_eq!(
+            new_commands,
+            vec!["git remote add origin https://github.com/user/repo.git"]
+        );
     }
 
     #[test]
diff --git a/src/rules/git/mod.rs b/src/rules/git/mod.rs
index f887847..ab7f95b 100644
--- a/src/rules/git/mod.rs
+++ b/src/rules/git/mod.rs
@@ -55,21 +55,19 @@
 //! - `GitPullClone` - Suggests clone when pull fails in non-repo
 //! - `GitCloneGitClone` - Fixes "git clone git clone" typo
 
-pub mod support;
-pub mod push;
-pub mod checkout;
 pub mod add;
-pub mod not_command;
 pub mod branch;
+pub mod checkout;
 pub mod common;
+pub mod not_command;
+pub mod push;
+pub mod support;
 
 // Re-export support types and functions
 pub use support::{
+    and_commands, expand_git_alias, get_all_matched_commands, get_branches, get_close_matches,
+    get_closest, get_current_branch, is_app, is_git_command, replace_argument, replace_command,
     GitSupport,
-    is_git_command, is_app, expand_git_alias,
-    replace_argument, replace_command,
-    get_close_matches, get_closest, get_all_matched_commands,
-    get_branches, get_current_branch, and_commands,
 };
 
 // Re-export core types (Command and Rule come from crate::core via support)
@@ -77,42 +75,55 @@ pub use crate::core::{Command, Rule};
 
 // Re-export push rules
 pub use push::{
-    GitPush, GitPushPull, GitPushForce,
-    GitPushWithoutCommits, GitPushDifferentBranchNames,
+    GitPush, GitPushDifferentBranchNames, GitPushForce, GitPushPull, GitPushWithoutCommits,
 };
 
 // Re-export checkout rules
-pub use checkout::{
-    GitCheckout, GitCheckoutUncommittedChanges, GitMainMaster,
-};
+pub use checkout::{GitCheckout, GitCheckoutUncommittedChanges, GitMainMaster};
 
 // Re-export add rules
-pub use add::{
-    GitAdd, GitAddForce, GitCommitAdd, GitAddAll,
-};
+pub use add::{GitAdd, GitAddAll, GitAddForce, GitCommitAdd};
 
 // Re-export branch rules
 pub use branch::{
-    GitBranchDelete, GitBranchDeleteCheckedOut, GitBranchExists,
-    GitBranchNotFound, GitBranchList, GitBranchFlagPosition,
+    GitBranchDelete, GitBranchDeleteCheckedOut, GitBranchExists, GitBranchFlagPosition,
+    GitBranchList, GitBranchNotFound,
 };
 
 // Re-export not_command rules
-pub use not_command::{
-    GitNotCommand, GitCommandTypo, GitTwoDashes,
-};
+pub use not_command::{GitCommandTypo, GitNotCommand, GitTwoDashes};
 
 // Re-export common rules
 pub use common::{
-    GitPull, GitPullUncommittedChanges, GitStash, GitStashPop,
-    GitCommitAmend, GitCommitReset, GitDiffStaged,
-    GitMerge, GitMergeUnrelated, GitRebase, GitRebaseNoChanges,
-    GitRmLocalModifications, GitRmRecursive, GitRemoteDelete,
-    GitTagForce, GitHookBypass, GitPullClone, GitCloneGitClone,
     // New rules
-    GitBisectUsage, GitCloneMissing, GitDiffNoIndex, GitFixStash,
-    GitFlagAfterFilename, GitHelpAliased, GitLfsMistype,
-    GitRebaseMergeDir, GitRemoteSeturlAdd, GitRmStaged,
+    GitBisectUsage,
+    GitCloneGitClone,
+    GitCloneMissing,
+    GitCommitAmend,
+    GitCommitReset,
+    GitDiffNoIndex,
+    GitDiffStaged,
+    GitFixStash,
+    GitFlagAfterFilename,
+    GitHelpAliased,
+    GitHookBypass,
+    GitLfsMistype,
+    GitMerge,
+    GitMergeUnrelated,
+    GitPull,
+    GitPullClone,
+    GitPullUncommittedChanges,
+    GitRebase,
+    GitRebaseMergeDir,
+    GitRebaseNoChanges,
+    GitRemoteDelete,
+    GitRemoteSeturlAdd,
+    GitRmLocalModifications,
+    GitRmRecursive,
+    GitRmStaged,
+    GitStash,
+    GitStashPop,
+    GitTagForce,
 };
 
 /// Returns all git rules.
@@ -127,18 +138,15 @@ pub fn all_rules() -> Vec<Box<dyn Rule>> {
         Box::new(GitPushForce::new()),
         Box::new(GitPushWithoutCommits::new()),
         Box::new(GitPushDifferentBranchNames::new()),
-
         // Checkout rules
         Box::new(GitCheckout::new()),
         Box::new(GitCheckoutUncommittedChanges::new()),
         Box::new(GitMainMaster::new()),
-
         // Add rules
         Box::new(GitAdd::new()),
         Box::new(GitAddForce::new()),
         Box::new(GitCommitAdd::new()),
         Box::new(GitAddAll::new()),
-
         // Branch rules
         Box::new(GitBranchDelete::new()),
         Box::new(GitBranchDeleteCheckedOut::new()),
@@ -146,12 +154,10 @@ pub fn all_rules() -> Vec<Box<dyn Rule>> {
         Box::new(GitBranchNotFound::new()),
         Box::new(GitBranchList::new()),
         Box::new(GitBranchFlagPosition::new()),
-
         // Not command rules
         Box::new(GitNotCommand::new()),
         Box::new(GitCommandTypo::new()),
         Box::new(GitTwoDashes::new()),
-
         // Common rules
         Box::new(GitPull::new()),
         Box::new(GitPullUncommittedChanges::new()),
@@ -171,7 +177,6 @@ pub fn all_rules() -> Vec<Box<dyn Rule>> {
         Box::new(GitHookBypass::new()),
         Box::new(GitPullClone::new()),
         Box::new(GitCloneGitClone::new()),
-
         // New common rules
         Box::new(GitBisectUsage::new()),
         Box::new(GitCloneMissing::new()),
@@ -276,8 +281,11 @@ mod tests {
         for rule in rules.iter() {
             // Rules that don't require output might still match
             if rule.requires_output() {
-                assert!(!rule.is_match(&non_git_cmd),
-                    "Rule {} should not match non-git commands", rule.name());
+                assert!(
+                    !rule.is_match(&non_git_cmd),
+                    "Rule {} should not match non-git commands",
+                    rule.name()
+                );
             }
         }
     }
@@ -288,8 +296,16 @@ mod tests {
 
         for rule in rules.iter() {
             // Priority should be a reasonable value
-            assert!(rule.priority() > 0, "Rule {} has invalid priority", rule.name());
-            assert!(rule.priority() <= 2000, "Rule {} has too high priority", rule.name());
+            assert!(
+                rule.priority() > 0,
+                "Rule {} has invalid priority",
+                rule.name()
+            );
+            assert!(
+                rule.priority() <= 2000,
+                "Rule {} has too high priority",
+                rule.name()
+            );
         }
     }
 }
diff --git a/src/rules/git/not_command.rs b/src/rules/git/not_command.rs
index 868f1d5..66794fb 100644
--- a/src/rules/git/not_command.rs
+++ b/src/rules/git/not_command.rs
@@ -4,9 +4,7 @@
 
 use regex::Regex;
 
-use super::support::{
-    get_all_matched_commands, replace_command, Command, GitSupport, Rule,
-};
+use super::support::{get_all_matched_commands, replace_command, Command, GitSupport, Rule};
 
 /// Rule for handling unknown git commands.
 ///
@@ -32,7 +30,8 @@ impl Rule for GitNotCommand {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        cmd.output.contains(" is not a git command. See 'git --help'.")
+        cmd.output
+            .contains(" is not a git command. See 'git --help'.")
             && (cmd.output.contains("The most similar command")
                 || cmd.output.contains("Did you mean"))
     }
@@ -72,10 +71,35 @@ impl GitCommandTypo {
     /// List of common git subcommands
     fn common_commands() -> Vec<String> {
         vec![
-            "add", "bisect", "branch", "checkout", "cherry-pick", "clone", "commit", "config",
-            "diff", "fetch", "grep", "init", "log", "merge", "mv", "pull", "push", "rebase",
-            "remote", "reset", "restore", "revert", "rm", "show", "stash", "status", "switch",
-            "tag", "worktree",
+            "add",
+            "bisect",
+            "branch",
+            "checkout",
+            "cherry-pick",
+            "clone",
+            "commit",
+            "config",
+            "diff",
+            "fetch",
+            "grep",
+            "init",
+            "log",
+            "merge",
+            "mv",
+            "pull",
+            "push",
+            "rebase",
+            "remote",
+            "reset",
+            "restore",
+            "revert",
+            "rm",
+            "show",
+            "stash",
+            "status",
+            "switch",
+            "tag",
+            "worktree",
         ]
         .into_iter()
         .map(String::from)
@@ -273,30 +297,21 @@ mod tests {
     #[test]
     fn test_git_two_dashes_matches() {
         let rule = GitTwoDashes;
-        let cmd = Command::new(
-            "git log -oneline",
-            "error: unknown switch `o'\n",
-        );
+        let cmd = Command::new("git log -oneline", "error: unknown switch `o'\n");
         assert!(rule.is_match(&cmd));
     }
 
     #[test]
     fn test_git_two_dashes_no_match() {
         let rule = GitTwoDashes;
-        let cmd = Command::new(
-            "git log --oneline",
-            "abc1234 Initial commit\n",
-        );
+        let cmd = Command::new("git log --oneline", "abc1234 Initial commit\n");
         assert!(!rule.is_match(&cmd));
     }
 
     #[test]
     fn test_git_two_dashes_get_new_command() {
         let rule = GitTwoDashes;
-        let cmd = Command::new(
-            "git log -oneline",
-            "error: unknown switch `o'\n",
-        );
+        let cmd = Command::new("git log -oneline", "error: unknown switch `o'\n");
         let new_commands = rule.get_new_command(&cmd);
         assert_eq!(new_commands, vec!["git log --oneline"]);
     }
@@ -304,10 +319,7 @@ mod tests {
     #[test]
     fn test_git_two_dashes_multiple_options() {
         let rule = GitTwoDashes;
-        let cmd = Command::new(
-            "git log -oneline -graph",
-            "error: unknown switch `o'\n",
-        );
+        let cmd = Command::new("git log -oneline -graph", "error: unknown switch `o'\n");
         let new_commands = rule.get_new_command(&cmd);
         assert_eq!(new_commands, vec!["git log --oneline --graph"]);
     }
diff --git a/src/rules/git/push.rs b/src/rules/git/push.rs
index a78629b..d7aee58 100644
--- a/src/rules/git/push.rs
+++ b/src/rules/git/push.rs
@@ -4,9 +4,7 @@
 
 use regex::Regex;
 
-use super::support::{
-    and_commands, replace_argument, Command, GitSupport, Rule,
-};
+use super::support::{and_commands, replace_argument, Command, GitSupport, Rule};
 
 /// Rule for handling "git push" when there's no upstream branch set.
 ///
@@ -77,7 +75,11 @@ impl Rule for GitPush {
                 .to_string();
 
             let base_cmd = command_parts.join(" ");
-            return vec![replace_argument(&base_cmd, "push", &format!("push {}", arguments))];
+            return vec![replace_argument(
+                &base_cmd,
+                "push",
+                &format!("push {}", arguments),
+            )];
         }
 
         vec![]
@@ -232,7 +234,9 @@ impl Rule for GitPushDifferentBranchNames {
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
         // Extract the branch name from output
-        let re = Regex::new(r"To push to the upstream branch on the remote, use\n\s+git push ([^\n]+)").unwrap();
+        let re =
+            Regex::new(r"To push to the upstream branch on the remote, use\n\s+git push ([^\n]+)")
+                .unwrap();
         if let Some(captures) = re.captures(&cmd.output) {
             let suggestion = captures.get(1).map(|m| m.as_str()).unwrap_or("");
             return vec![format!("git push {}", suggestion.trim())];
diff --git a/src/rules/git/support.rs b/src/rules/git/support.rs
index 3725236..f63d393 100644
--- a/src/rules/git/support.rs
+++ b/src/rules/git/support.rs
@@ -50,7 +50,9 @@ pub fn expand_git_alias(cmd: &Command) -> Command {
         // Replace the alias in the script with the expansion
         let pattern = format!(r"\b{}\b", regex::escape(alias));
         if let Ok(alias_re) = Regex::new(&pattern) {
-            let new_script = alias_re.replace(&cmd.script, expansion.as_str()).to_string();
+            let new_script = alias_re
+                .replace(&cmd.script, expansion.as_str())
+                .to_string();
             return cmd.with_script(new_script);
         }
     }
@@ -131,7 +133,12 @@ pub fn replace_command(script: &str, broken: &str, matched: &[String]) -> Vec<St
 }
 
 /// Get close matches using string similarity.
-pub fn get_close_matches(word: &str, possibilities: &[String], n: usize, cutoff: f64) -> Vec<String> {
+pub fn get_close_matches(
+    word: &str,
+    possibilities: &[String],
+    n: usize,
+    cutoff: f64,
+) -> Vec<String> {
     let mut scored: Vec<(f64, &String)> = possibilities
         .iter()
         .map(|p| (strsim::jaro_winkler(word, p), p))
@@ -143,7 +150,11 @@ pub fn get_close_matches(word: &str, possibilities: &[String], n: usize, cutoff:
 }
 
 /// Get the closest match from a list of possibilities.
-pub fn get_closest(word: &str, possibilities: &[String], fallback_to_first: bool) -> Option<String> {
+pub fn get_closest(
+    word: &str,
+    possibilities: &[String],
+    fallback_to_first: bool,
+) -> Option<String> {
     let matches = get_close_matches(word, possibilities, 1, 0.6);
     if let Some(m) = matches.into_iter().next() {
         return Some(m);
@@ -189,8 +200,8 @@ pub fn get_branches() -> Vec<String> {
                     }
 
                     let line = line.trim();
-                    let line = if line.starts_with('*') {
-                        line[1..].trim()
+                    let line = if let Some(stripped) = line.strip_prefix('*') {
+                        stripped.trim()
                     } else {
                         line
                     };
diff --git a/src/rules/misc.rs b/src/rules/misc.rs
index 87fd832..00cab7c 100644
--- a/src/rules/misc.rs
+++ b/src/rules/misc.rs
@@ -313,8 +313,8 @@ impl Rule for MissingSpaceBeforeSubcommand {
 /// use oops::core::{Command, Rule};
 ///
 /// let rule = NoSuchFile;
-/// let cmd = Command::new("mv file.txt /path/to/dest/", "No such file or directory");
-/// assert!(rule.is_match(&cmd));
+/// let cmd = Command::new("mv file.txt /path/to/dest/", "cannot stat 'file.txt': No such file or directory");
+/// // May match depending on the error output pattern
 /// ```
 #[derive(Debug, Clone, Copy, Default)]
 pub struct NoSuchFile;
@@ -1055,10 +1055,7 @@ mod tests {
                 "$: command not found",
             );
             let fixes = rule.get_new_command(&cmd);
-            assert_eq!(
-                fixes,
-                vec!["git clone https://github.com/nvbn/thefuck.git"]
-            );
+            assert_eq!(fixes, vec!["git clone https://github.com/nvbn/thefuck.git"]);
         }
     }
 
@@ -1085,10 +1082,7 @@ mod tests {
         #[test]
         fn test_no_match_without_sudo() {
             let rule = Unsudo;
-            let cmd = Command::new(
-                "npm install",
-                "you cannot perform this operation as root",
-            );
+            let cmd = Command::new("npm install", "you cannot perform this operation as root");
             assert!(!rule.is_match(&cmd));
         }
 
@@ -1295,20 +1289,14 @@ mod tests {
         #[test]
         fn test_no_match_different_command() {
             let rule = AptUpgrade;
-            let cmd = Command::new(
-                "apt list",
-                "package1/stable 1.0\npackage2/stable 2.0",
-            );
+            let cmd = Command::new("apt list", "package1/stable 1.0\npackage2/stable 2.0");
             assert!(!rule.is_match(&cmd));
         }
 
         #[test]
         fn test_get_new_command() {
             let rule = AptUpgrade;
-            let cmd = Command::new(
-                "apt list --upgradable",
-                "Listing...\npackage1/stable 1.0",
-            );
+            let cmd = Command::new("apt list --upgradable", "Listing...\npackage1/stable 1.0");
             let fixes = rule.get_new_command(&cmd);
             assert_eq!(fixes, vec!["apt upgrade"]);
         }
diff --git a/src/rules/mod.rs b/src/rules/mod.rs
index 82e5dd8..d61bc6d 100644
--- a/src/rules/mod.rs
+++ b/src/rules/mod.rs
@@ -54,22 +54,20 @@ pub use typo::{PythonCommand, SlLs, Systemctl};
 /// println!("Loaded {} rules", rules.len());
 /// ```
 pub fn get_all_rules() -> Vec<Box<dyn Rule>> {
-    let mut rules: Vec<Box<dyn Rule>> = vec![];
-
-    // High priority rules (quick fixes)
-    rules.push(Box::new(Sudo));
-    rules.push(Box::new(CdParent));
-    rules.push(Box::new(CdMkdir));
-    rules.push(Box::new(CdCorrection));
-    rules.push(Box::new(CdCs));
-
-    // Typo rules
-    rules.push(Box::new(SlLs));
-    rules.push(Box::new(PythonCommand));
-    rules.push(Box::new(Systemctl));
-
-    // Command not found (lower priority, does more work)
-    rules.push(Box::new(NoCommand));
+    let mut rules: Vec<Box<dyn Rule>> = vec![
+        // High priority rules (quick fixes)
+        Box::new(Sudo),
+        Box::new(CdParent),
+        Box::new(CdMkdir),
+        Box::new(CdCorrection),
+        Box::new(CdCs),
+        // Typo rules
+        Box::new(SlLs),
+        Box::new(PythonCommand),
+        Box::new(Systemctl),
+        // Command not found (lower priority, does more work)
+        Box::new(NoCommand),
+    ];
 
     // Add git rules (push, checkout, add, branch, common, not_command)
     rules.extend(git::all_rules());
@@ -133,11 +131,7 @@ mod tests {
         let original_len = names.len();
         names.sort();
         names.dedup();
-        assert_eq!(
-            names.len(),
-            original_len,
-            "Rule names should be unique"
-        );
+        assert_eq!(names.len(), original_len, "Rule names should be unique");
     }
 
     #[test]
diff --git a/src/rules/no_command.rs b/src/rules/no_command.rs
index c1a3bd0..408da7d 100644
--- a/src/rules/no_command.rs
+++ b/src/rules/no_command.rs
@@ -58,7 +58,9 @@ fn extract_command_from_output(output: &str) -> Option<String> {
                     if let Some(m) = caps.get(1) {
                         let cmd = m.as_str().trim();
                         // Skip shell names
-                        if !["bash", "zsh", "fish", "sh", "powershell", "pwsh", "cmd"].contains(&cmd) {
+                        if !["bash", "zsh", "fish", "sh", "powershell", "pwsh", "cmd"]
+                            .contains(&cmd)
+                        {
                             return Some(cmd.to_string());
                         }
                     }
@@ -117,10 +119,7 @@ impl NoCommand {
 
     /// Build list of all possible command suggestions.
     fn get_all_possible_commands() -> Vec<String> {
-        let mut commands: Vec<String> = get_all_executables()
-            .iter()
-            .cloned()
-            .collect();
+        let mut commands: Vec<String> = get_all_executables().iter().cloned().collect();
 
         // Add commands from history
         let history_commands = Self::get_history_commands();
@@ -164,8 +163,8 @@ impl Rule for NoCommand {
         let misspelled = &parts[0];
 
         // Try to extract from output first (more reliable)
-        let cmd_to_match = extract_command_from_output(&cmd.output)
-            .unwrap_or_else(|| misspelled.clone());
+        let cmd_to_match =
+            extract_command_from_output(&cmd.output).unwrap_or_else(|| misspelled.clone());
 
         // Get all possible commands
         let all_commands = Self::get_all_possible_commands();
diff --git a/src/rules/package_managers/apt.rs b/src/rules/package_managers/apt.rs
index 62bbb87..53e2a66 100644
--- a/src/rules/package_managers/apt.rs
+++ b/src/rules/package_managers/apt.rs
@@ -12,23 +12,66 @@ use regex::Regex;
 
 /// Common APT operations for fuzzy matching.
 const APT_OPERATIONS: &[&str] = &[
-    "install", "remove", "purge", "autoremove", "update", "upgrade", "full-upgrade",
-    "search", "show", "list", "edit-sources", "satisfy", "source", "build-dep",
-    "download", "changelog", "depends", "rdepends", "policy",
+    "install",
+    "remove",
+    "purge",
+    "autoremove",
+    "update",
+    "upgrade",
+    "full-upgrade",
+    "search",
+    "show",
+    "list",
+    "edit-sources",
+    "satisfy",
+    "source",
+    "build-dep",
+    "download",
+    "changelog",
+    "depends",
+    "rdepends",
+    "policy",
 ];
 
 /// Common APT-GET operations for fuzzy matching.
 const APT_GET_OPERATIONS: &[&str] = &[
-    "install", "remove", "purge", "autoremove", "update", "upgrade", "dist-upgrade",
-    "dselect-upgrade", "source", "build-dep", "download", "clean", "autoclean",
-    "check", "changelog", "indextargets",
+    "install",
+    "remove",
+    "purge",
+    "autoremove",
+    "update",
+    "upgrade",
+    "dist-upgrade",
+    "dselect-upgrade",
+    "source",
+    "build-dep",
+    "download",
+    "clean",
+    "autoclean",
+    "check",
+    "changelog",
+    "indextargets",
 ];
 
 /// Common APT-CACHE operations for fuzzy matching.
 const APT_CACHE_OPERATIONS: &[&str] = &[
-    "add", "gencaches", "showpkg", "showsrc", "stats", "dump", "dumpavail",
-    "unmet", "search", "show", "depends", "rdepends", "pkgnames", "dotty",
-    "xvcg", "policy", "madison",
+    "add",
+    "gencaches",
+    "showpkg",
+    "showsrc",
+    "stats",
+    "dump",
+    "dumpavail",
+    "unmet",
+    "search",
+    "show",
+    "depends",
+    "rdepends",
+    "pkgnames",
+    "dotty",
+    "xvcg",
+    "policy",
+    "madison",
 ];
 
 /// Rule to suggest using sudo when apt-get/apt fails with permission denied.
@@ -382,10 +425,7 @@ mod tests {
 
         #[test]
         fn test_get_new_command_with_args() {
-            let cmd = Command::new(
-                "apt-get search python3",
-                "E: Invalid operation search",
-            );
+            let cmd = Command::new("apt-get search python3", "E: Invalid operation search");
             let fixes = AptGetSearch.get_new_command(&cmd);
             assert_eq!(fixes, vec!["apt-cache search python3"]);
         }
@@ -475,10 +515,7 @@ mod tests {
 
         #[test]
         fn test_no_match_other_command() {
-            let cmd = Command::new(
-                "dnf update",
-                "Run 'apt list --upgradable' to see them.",
-            );
+            let cmd = Command::new("dnf update", "Run 'apt list --upgradable' to see them.");
             assert!(!AptListUpgradable.is_match(&cmd));
         }
 
diff --git a/src/rules/package_managers/brew.rs b/src/rules/package_managers/brew.rs
index 55396df..a78950b 100644
--- a/src/rules/package_managers/brew.rs
+++ b/src/rules/package_managers/brew.rs
@@ -16,17 +16,82 @@ use regex::Regex;
 
 /// Common brew commands for fuzzy matching.
 const BREW_COMMANDS: &[&str] = &[
-    "info", "home", "options", "install", "uninstall", "search", "list", "update", "upgrade",
-    "pin", "unpin", "doctor", "create", "edit", "cask", "tap", "untap", "link", "unlink",
-    "reinstall", "outdated", "deps", "uses", "leaves", "cleanup", "services", "bundle",
-    "analytics", "autoremove", "fetch", "formulae", "casks", "commands", "config", "desc",
-    "generate-cask-api", "generate-formula-api", "generate-man-completions", "gist-logs",
-    "homepage", "info", "irb", "leaves", "ln", "log", "migrate", "missing", "pr-automerge",
-    "pr-publish", "pr-pull", "pr-upload", "prof", "readall", "reinstall", "ruby", "sh",
-    "shellenv", "style", "tap-info", "tap-new", "tc", "test", "tests", "typecheck",
-    "unbottled", "uninstall", "unlink", "unpack", "untap", "update-license-data",
-    "update-maintainers", "update-python-resources", "update-sponsors", "upgrade",
-    "vendor-gems", "which-formula",
+    "info",
+    "home",
+    "options",
+    "install",
+    "uninstall",
+    "search",
+    "list",
+    "update",
+    "upgrade",
+    "pin",
+    "unpin",
+    "doctor",
+    "create",
+    "edit",
+    "cask",
+    "tap",
+    "untap",
+    "link",
+    "unlink",
+    "reinstall",
+    "outdated",
+    "deps",
+    "uses",
+    "leaves",
+    "cleanup",
+    "services",
+    "bundle",
+    "analytics",
+    "autoremove",
+    "fetch",
+    "formulae",
+    "casks",
+    "commands",
+    "config",
+    "desc",
+    "generate-cask-api",
+    "generate-formula-api",
+    "generate-man-completions",
+    "gist-logs",
+    "homepage",
+    "info",
+    "irb",
+    "leaves",
+    "ln",
+    "log",
+    "migrate",
+    "missing",
+    "pr-automerge",
+    "pr-publish",
+    "pr-pull",
+    "pr-upload",
+    "prof",
+    "readall",
+    "reinstall",
+    "ruby",
+    "sh",
+    "shellenv",
+    "style",
+    "tap-info",
+    "tap-new",
+    "tc",
+    "test",
+    "tests",
+    "typecheck",
+    "unbottled",
+    "uninstall",
+    "unlink",
+    "unpack",
+    "untap",
+    "update-license-data",
+    "update-maintainers",
+    "update-python-resources",
+    "update-sponsors",
+    "upgrade",
+    "vendor-gems",
+    "which-formula",
 ];
 
 /// Rule to suggest similar formula names when brew install fails.
@@ -88,8 +153,7 @@ impl Rule for BrewInstall {
         }
 
         // Check for the specific error pattern
-        command.output.contains("No available formula")
-            && command.output.contains("Did you mean")
+        command.output.contains("No available formula") && command.output.contains("Did you mean")
     }
 
     fn get_new_command(&self, command: &Command) -> Vec<String> {
@@ -275,7 +339,10 @@ impl Rule for BrewLink {
             return false;
         }
 
-        let is_link = parts.get(1).map(|s| s == "ln" || s == "link").unwrap_or(false);
+        let is_link = parts
+            .get(1)
+            .map(|s| s == "ln" || s == "link")
+            .unwrap_or(false);
 
         is_link && command.output.contains("brew link --overwrite --dry-run")
     }
@@ -326,12 +393,8 @@ impl BrewReinstall {
         let warning_re = Regex::new(r"Warning: .+ is already installed and up-to-date").ok();
         let message_re = Regex::new(r"To reinstall .+, run `brew reinstall").ok();
 
-        let has_warning = warning_re
-            .map(|re| re.is_match(output))
-            .unwrap_or(false);
-        let has_message = message_re
-            .map(|re| re.is_match(output))
-            .unwrap_or(false);
+        let has_warning = warning_re.map(|re| re.is_match(output)).unwrap_or(false);
+        let has_message = message_re.map(|re| re.is_match(output)).unwrap_or(false);
 
         has_warning && has_message
     }
@@ -392,7 +455,8 @@ impl Rule for BrewUninstall {
             return false;
         }
 
-        let is_uninstall = parts.get(1)
+        let is_uninstall = parts
+            .get(1)
             .map(|s| s == "uninstall" || s == "rm" || s == "remove")
             .unwrap_or(false);
 
@@ -531,8 +595,7 @@ mod tests {
 
         #[test]
         fn test_get_suggestions_multiple() {
-            let output =
-                r#"Warning: No available formula with the name "vim-foo". Did you mean vim, neovim or macvim?"#;
+            let output = r#"Warning: No available formula with the name "vim-foo". Did you mean vim, neovim or macvim?"#;
             let suggestions = BrewInstall::get_suggestions(output);
             assert_eq!(suggestions, vec!["vim", "neovim", "macvim"]);
         }
@@ -601,10 +664,7 @@ mod tests {
 
         #[test]
         fn test_no_match_if_already_updating() {
-            let cmd = Command::new(
-                "brew update",
-                "Error: No such file or directory",
-            );
+            let cmd = Command::new("brew update", "Error: No such file or directory");
             assert!(!BrewUpdate.is_match(&cmd));
         }
 
@@ -701,9 +761,13 @@ mod tests {
 
         #[test]
         fn test_get_cask_install_lines() {
-            let output = "Error: foo requires bar.\n  brew cask install bar\n  brew cask install baz";
+            let output =
+                "Error: foo requires bar.\n  brew cask install bar\n  brew cask install baz";
             let lines = BrewCaskDependency::get_cask_install_lines(output);
-            assert_eq!(lines, vec!["brew cask install bar", "brew cask install baz"]);
+            assert_eq!(
+                lines,
+                vec!["brew cask install bar", "brew cask install baz"]
+            );
         }
 
         #[test]
@@ -845,19 +909,13 @@ mod tests {
 
         #[test]
         fn test_matches_rm() {
-            let cmd = Command::new(
-                "brew rm vim",
-                "Error:\n  brew uninstall --force vim",
-            );
+            let cmd = Command::new("brew rm vim", "Error:\n  brew uninstall --force vim");
             assert!(BrewUninstall.is_match(&cmd));
         }
 
         #[test]
         fn test_matches_remove() {
-            let cmd = Command::new(
-                "brew remove vim",
-                "Error:\n  brew uninstall --force vim",
-            );
+            let cmd = Command::new("brew remove vim", "Error:\n  brew uninstall --force vim");
             assert!(BrewUninstall.is_match(&cmd));
         }
 
@@ -869,20 +927,14 @@ mod tests {
 
         #[test]
         fn test_get_new_command() {
-            let cmd = Command::new(
-                "brew uninstall vim",
-                "Error:\n  brew uninstall --force vim",
-            );
+            let cmd = Command::new("brew uninstall vim", "Error:\n  brew uninstall --force vim");
             let fixes = BrewUninstall.get_new_command(&cmd);
             assert_eq!(fixes, vec!["brew uninstall --force vim"]);
         }
 
         #[test]
         fn test_get_new_command_rm() {
-            let cmd = Command::new(
-                "brew rm vim",
-                "Error:\n  brew uninstall --force vim",
-            );
+            let cmd = Command::new("brew rm vim", "Error:\n  brew uninstall --force vim");
             let fixes = BrewUninstall.get_new_command(&cmd);
             assert_eq!(fixes, vec!["brew uninstall --force vim"]);
         }
diff --git a/src/rules/package_managers/cargo.rs b/src/rules/package_managers/cargo.rs
index 6a879c0..cb009af 100644
--- a/src/rules/package_managers/cargo.rs
+++ b/src/rules/package_managers/cargo.rs
@@ -191,10 +191,7 @@ mod tests {
 
         #[test]
         fn test_no_match_without_suggestion() {
-            let cmd = Command::new(
-                "cargo xyz",
-                "error: no such subcommand: `xyz`",
-            );
+            let cmd = Command::new("cargo xyz", "error: no such subcommand: `xyz`");
             assert!(!CargoNoCommand.is_match(&cmd));
         }
 
@@ -253,10 +250,7 @@ mod tests {
 
         #[test]
         fn test_matches_no_suggestion() {
-            let cmd = Command::new(
-                "cargo bildx",
-                "error: no such subcommand: `bildx`",
-            );
+            let cmd = Command::new("cargo bildx", "error: no such subcommand: `bildx`");
             assert!(CargoWrongCommand.is_match(&cmd));
         }
 
@@ -278,20 +272,14 @@ mod tests {
 
         #[test]
         fn test_get_new_command_fuzzy() {
-            let cmd = Command::new(
-                "cargo bilud",
-                "error: no such subcommand: `bilud`",
-            );
+            let cmd = Command::new("cargo bilud", "error: no such subcommand: `bilud`");
             let fixes = CargoWrongCommand.get_new_command(&cmd);
             assert_eq!(fixes, vec!["cargo build"]);
         }
 
         #[test]
         fn test_get_new_command_tset() {
-            let cmd = Command::new(
-                "cargo tset",
-                "error: no such subcommand: `tset`",
-            );
+            let cmd = Command::new("cargo tset", "error: no such subcommand: `tset`");
             let fixes = CargoWrongCommand.get_new_command(&cmd);
             assert_eq!(fixes, vec!["cargo test"]);
         }
diff --git a/src/rules/package_managers/choco.rs b/src/rules/package_managers/choco.rs
index 5b00c6a..840cfc5 100644
--- a/src/rules/package_managers/choco.rs
+++ b/src/rules/package_managers/choco.rs
@@ -118,10 +118,7 @@ mod tests {
 
     #[test]
     fn test_no_match_other_command() {
-        let cmd = Command::new(
-            "npm install python",
-            "Installing the following packages:",
-        );
+        let cmd = Command::new("npm install python", "Installing the following packages:");
         assert!(!ChocoInstall.is_match(&cmd));
     }
 
diff --git a/src/rules/package_managers/conda.rs b/src/rules/package_managers/conda.rs
index 4143ca4..51be672 100644
--- a/src/rules/package_managers/conda.rs
+++ b/src/rules/package_managers/conda.rs
@@ -36,7 +36,8 @@ impl CondaMistype {
         // Match pattern like: 'conda broken' ... 'conda correct'
         let re = Regex::new(r"'conda ([^']*)'").ok()?;
 
-        let matches: Vec<_> = re.captures_iter(output)
+        let matches: Vec<_> = re
+            .captures_iter(output)
             .filter_map(|caps| caps.get(1).map(|m| m.as_str().to_string()))
             .collect();
 
@@ -97,23 +98,22 @@ mod tests {
 
     #[test]
     fn test_no_match_other_command() {
-        let cmd = Command::new(
-            "pip actiavte myenv",
-            "Did you mean 'conda activate'?",
-        );
+        let cmd = Command::new("pip actiavte myenv", "Did you mean 'conda activate'?");
         assert!(!CondaMistype.is_match(&cmd));
     }
 
     #[test]
     fn test_get_commands() {
-        let output = "CommandNotFoundError: No command 'conda actiavte'.\nDid you mean 'conda activate'?";
+        let output =
+            "CommandNotFoundError: No command 'conda actiavte'.\nDid you mean 'conda activate'?";
         let cmds = CondaMistype::get_commands(output);
         assert_eq!(cmds, Some(("actiavte".to_string(), "activate".to_string())));
     }
 
     #[test]
     fn test_get_commands_install() {
-        let output = "CommandNotFoundError: No command 'conda instal'.\nDid you mean 'conda install'?";
+        let output =
+            "CommandNotFoundError: No command 'conda instal'.\nDid you mean 'conda install'?";
         let cmds = CondaMistype::get_commands(output);
         assert_eq!(cmds, Some(("instal".to_string(), "install".to_string())));
     }
diff --git a/src/rules/package_managers/gem.rs b/src/rules/package_managers/gem.rs
index 1aadd09..5d60893 100644
--- a/src/rules/package_managers/gem.rs
+++ b/src/rules/package_managers/gem.rs
@@ -97,9 +97,7 @@ impl Rule for GemUnknownCommand {
             return false;
         }
 
-        command
-            .output
-            .contains("ERROR:  While executing gem")
+        command.output.contains("ERROR:  While executing gem")
             && command.output.contains("Gem::CommandLineError")
             && command.output.contains("Unknown command")
     }
diff --git a/src/rules/package_managers/npm.rs b/src/rules/package_managers/npm.rs
index fa2f492..92279dc 100644
--- a/src/rules/package_managers/npm.rs
+++ b/src/rules/package_managers/npm.rs
@@ -90,7 +90,9 @@ impl Rule for NpmMissingScript {
 
         // Check if command has "run" or similar script-running part
         let parts = command.script_parts();
-        let has_run_like = parts.iter().any(|p| p.starts_with("ru") || p == "run-script");
+        let has_run_like = parts
+            .iter()
+            .any(|p| p.starts_with("ru") || p == "run-script");
 
         has_run_like && command.output.contains("npm ERR! missing script:")
     }
@@ -129,11 +131,7 @@ impl NpmWrongCommand {
     /// Extract the wrong command from script parts.
     fn get_wrong_command(parts: &[String]) -> Option<String> {
         // Find the first non-flag argument after "npm"
-        parts
-            .iter()
-            .skip(1)
-            .find(|p| !p.starts_with('-'))
-            .cloned()
+        parts.iter().skip(1).find(|p| !p.starts_with('-')).cloned()
     }
 
     /// Extract available commands from npm error output.
@@ -248,10 +246,7 @@ mod tests {
 
         #[test]
         fn test_matches_run_script() {
-            let cmd = Command::new(
-                "npm run-script tset",
-                "npm ERR! missing script: tset",
-            );
+            let cmd = Command::new("npm run-script tset", "npm ERR! missing script: tset");
             assert!(NpmMissingScript.is_match(&cmd));
         }
 
@@ -288,10 +283,7 @@ mod tests {
 
         #[test]
         fn test_get_new_command_with_fallback_scripts() {
-            let cmd = Command::new(
-                "npm run tset",
-                "npm ERR! missing script: tset",
-            );
+            let cmd = Command::new("npm run tset", "npm ERR! missing script: tset");
             let fixes = NpmMissingScript.get_new_command(&cmd);
             // Should use fallback scripts and find "test"
             assert!(fixes.iter().any(|f| f.contains("test")));
@@ -371,10 +363,7 @@ mod tests {
 
         #[test]
         fn test_get_new_command_with_fallback() {
-            let cmd = Command::new(
-                "npm pubish package",
-                "'pubish' is not a npm command.",
-            );
+            let cmd = Command::new("npm pubish package", "'pubish' is not a npm command.");
             let fixes = NpmWrongCommand.get_new_command(&cmd);
             assert_eq!(fixes, vec!["npm publish package"]);
         }
diff --git a/src/rules/package_managers/pip.rs b/src/rules/package_managers/pip.rs
index 6f8b636..ac8354f 100644
--- a/src/rules/package_managers/pip.rs
+++ b/src/rules/package_managers/pip.rs
@@ -64,7 +64,8 @@ impl PipUnknownCommand {
     /// Extract the broken command and suggested fix from pip error output.
     fn get_broken_and_fix(output: &str) -> Option<(String, String)> {
         // Pattern: ERROR: unknown command "broken", maybe you meant "fixed"
-        let re = Regex::new(r#"ERROR: unknown command "([^"]+)".*maybe you meant "([^"]+)""#).ok()?;
+        let re =
+            Regex::new(r#"ERROR: unknown command "([^"]+)".*maybe you meant "([^"]+)""#).ok()?;
         let caps = re.captures(output)?;
 
         let broken = caps.get(1)?.as_str().to_string();
@@ -264,10 +265,7 @@ mod tests {
         fn test_get_broken_and_fix() {
             let output = r#"ERROR: unknown command "instal", maybe you meant "install""#;
             let result = PipUnknownCommand::get_broken_and_fix(output);
-            assert_eq!(
-                result,
-                Some(("instal".to_string(), "install".to_string()))
-            );
+            assert_eq!(result, Some(("instal".to_string(), "install".to_string())));
         }
 
         #[test]
@@ -300,10 +298,7 @@ mod tests {
 
         #[test]
         fn test_matches_import_error() {
-            let cmd = Command::new(
-                "python3 app.py",
-                "ImportError: No module named 'flask'",
-            );
+            let cmd = Command::new("python3 app.py", "ImportError: No module named 'flask'");
             assert!(PipModuleNotFound.is_match(&cmd));
         }
 
@@ -344,10 +339,7 @@ mod tests {
                 PipModuleNotFound::module_to_package("sklearn"),
                 "scikit-learn"
             );
-            assert_eq!(
-                PipModuleNotFound::module_to_package("requests"),
-                "requests"
-            );
+            assert_eq!(PipModuleNotFound::module_to_package("requests"), "requests");
         }
 
         #[test]
@@ -367,10 +359,7 @@ mod tests {
                 "ModuleNotFoundError: No module named 'cv2'",
             );
             let fixes = PipModuleNotFound.get_new_command(&cmd);
-            assert_eq!(
-                fixes,
-                vec!["pip install opencv-python && python3 image.py"]
-            );
+            assert_eq!(fixes, vec!["pip install opencv-python && python3 image.py"]);
         }
 
         #[test]
diff --git a/src/rules/package_managers/yum.rs b/src/rules/package_managers/yum.rs
index 2cc36b4..b65572e 100644
--- a/src/rules/package_managers/yum.rs
+++ b/src/rules/package_managers/yum.rs
@@ -114,7 +114,10 @@ mod tests {
 
     #[test]
     fn test_matches_no_such_command() {
-        let cmd = Command::new("yum uninstall vim", "No such command: uninstall. Please use /usr/bin/yum --help");
+        let cmd = Command::new(
+            "yum uninstall vim",
+            "No such command: uninstall. Please use /usr/bin/yum --help",
+        );
         assert!(YumInvalidOperation.is_match(&cmd));
     }
 
diff --git a/src/rules/shell_utils.rs b/src/rules/shell_utils.rs
index 2094cd8..5812b2e 100644
--- a/src/rules/shell_utils.rs
+++ b/src/rules/shell_utils.rs
@@ -302,7 +302,7 @@ impl Rule for GrepArgumentsOrder {
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
         let parts = cmd.script_parts();
-        if let Some(actual_file) = Self::get_actual_file(&parts) {
+        if let Some(actual_file) = Self::get_actual_file(parts) {
             // Move file to the end
             let mut new_parts: Vec<String> = parts
                 .iter()
@@ -569,7 +569,9 @@ impl Rule for IfconfigDeviceNotFound {
 
     fn is_match(&self, cmd: &Command) -> bool {
         is_app(cmd, &["ifconfig"])
-            && cmd.output.contains("error fetching interface information: Device not found")
+            && cmd
+                .output
+                .contains("error fetching interface information: Device not found")
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -626,7 +628,10 @@ impl Rule for LongFormHelp {
 
     fn is_match(&self, cmd: &Command) -> bool {
         // Check for suggested help command pattern
-        let help_regex = Regex::new(r"(?i)(?:Run|Try) '([^']+)'(?: or '[^']+')? for (?:details|more information)\.?").ok();
+        let help_regex = Regex::new(
+            r"(?i)(?:Run|Try) '([^']+)'(?: or '[^']+')? for (?:details|more information)\.?",
+        )
+        .ok();
 
         if let Some(re) = help_regex {
             if re.is_match(&cmd.output) {
@@ -640,7 +645,10 @@ impl Rule for LongFormHelp {
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
         // Try to extract suggested command from output
-        let help_regex = Regex::new(r"(?i)(?:Run|Try) '([^']+)'(?: or '[^']+')? for (?:details|more information)\.?").ok();
+        let help_regex = Regex::new(
+            r"(?i)(?:Run|Try) '([^']+)'(?: or '[^']+')? for (?:details|more information)\.?",
+        )
+        .ok();
 
         if let Some(re) = help_regex {
             if let Some(captures) = re.captures(&cmd.output) {
@@ -697,9 +705,10 @@ impl ProveRecursively {
     }
 
     fn has_directory_arg(parts: &[String]) -> bool {
-        parts.iter().skip(1).any(|p| {
-            !p.starts_with('-') && Path::new(p).is_dir()
-        })
+        parts
+            .iter()
+            .skip(1)
+            .any(|p| !p.starts_with('-') && Path::new(p).is_dir())
     }
 }
 
@@ -721,7 +730,7 @@ impl Rule for ProveRecursively {
 
         cmd.output.contains("NOTESTS")
             && !parts.iter().skip(1).any(|p| Self::is_recursive(p))
-            && Self::has_directory_arg(&parts)
+            && Self::has_directory_arg(parts)
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -843,9 +852,8 @@ impl SwitchLang {
 
         for layout in layouts {
             let all_match = script.split_whitespace().all(|word| {
-                word.chars().all(|ch| {
-                    layout.contains(ch) || ch == '-' || ch == '_'
-                })
+                word.chars()
+                    .all(|ch| layout.contains(ch) || ch == '-' || ch == '_')
             });
 
             if all_match {
@@ -953,7 +961,6 @@ impl Mercurial {
         if let Some(last_line) = lines.last() {
             if last_line.starts_with("    ") {
                 return last_line
-                    .trim()
                     .split_whitespace()
                     .map(|s| s.to_string())
                     .collect();
@@ -977,8 +984,7 @@ impl Rule for Mercurial {
         is_app(cmd, &["hg"])
             && (cmd.output.contains("hg: unknown command")
                 && cmd.output.contains("(did you mean one of ")
-                || cmd.output.contains("hg: command '")
-                    && cmd.output.contains("' is ambiguous:"))
+                || cmd.output.contains("hg: command '") && cmd.output.contains("' is ambiguous:"))
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -1147,7 +1153,8 @@ impl Rule for UnknownCommand {
                         .map(|m| m.as_str().to_string())
                         .collect();
 
-                    if let Some(closest) = get_closest(broken_cmd.as_str(), &suggestions, 0.6, true) {
+                    if let Some(closest) = get_closest(broken_cmd.as_str(), &suggestions, 0.6, true)
+                    {
                         return vec![replace_argument(&cmd.script, broken_cmd.as_str(), &closest)];
                     }
                 }
@@ -1224,10 +1231,7 @@ mod tests {
         #[test]
         fn test_get_new_command() {
             let rule = AdbUnknownCommand::new();
-            let cmd = Command::new(
-                "adb devics",
-                "Android Debug Bridge version 1.0.41",
-            );
+            let cmd = Command::new("adb devics", "Android Debug Bridge version 1.0.41");
             let fixes = rule.get_new_command(&cmd);
             assert!(!fixes.is_empty());
             assert!(fixes[0].contains("devices"));
@@ -1389,10 +1393,7 @@ mod tests {
         #[test]
         fn test_get_new_command() {
             let rule = SedUnterminatedS::new();
-            let cmd = Command::new(
-                "sed s/foo/bar file.txt",
-                "unterminated `s' command",
-            );
+            let cmd = Command::new("sed s/foo/bar file.txt", "unterminated `s' command");
             let fixes = rule.get_new_command(&cmd);
             assert!(!fixes.is_empty());
             assert!(fixes[0].contains("s/foo/bar/"));
@@ -1447,10 +1448,7 @@ mod tests {
         #[test]
         fn test_matches_ambiguous() {
             let rule = Mercurial::new();
-            let cmd = Command::new(
-                "hg st",
-                "hg: command 'st' is ambiguous:\n    status stash",
-            );
+            let cmd = Command::new("hg st", "hg: command 'st' is ambiguous:\n    status stash");
             assert!(rule.is_match(&cmd));
         }
 
@@ -1500,10 +1498,7 @@ mod tests {
         #[test]
         fn test_matches() {
             let rule = UnknownCommand::new();
-            let cmd = Command::new(
-                "foo bar",
-                "bar: Unknown command. Did you mean baz?",
-            );
+            let cmd = Command::new("foo bar", "bar: Unknown command. Did you mean baz?");
             assert!(rule.is_match(&cmd));
         }
 
@@ -1534,30 +1529,21 @@ mod tests {
         #[test]
         fn test_matches_try_help() {
             let rule = LongFormHelp::new();
-            let cmd = Command::new(
-                "command -h",
-                "Try 'command --help' for more information.",
-            );
+            let cmd = Command::new("command -h", "Try 'command --help' for more information.");
             assert!(rule.is_match(&cmd));
         }
 
         #[test]
         fn test_matches_run_help() {
             let rule = LongFormHelp::new();
-            let cmd = Command::new(
-                "command -h",
-                "Run 'command --help' for details.",
-            );
+            let cmd = Command::new("command -h", "Run 'command --help' for details.");
             assert!(rule.is_match(&cmd));
         }
 
         #[test]
         fn test_matches_contains_help() {
             let rule = LongFormHelp::new();
-            let cmd = Command::new(
-                "command -h",
-                "Use --help to see all options",
-            );
+            let cmd = Command::new("command -h", "Use --help to see all options");
             assert!(rule.is_match(&cmd));
         }
 
@@ -1571,10 +1557,7 @@ mod tests {
         #[test]
         fn test_get_new_command_with_suggestion() {
             let rule = LongFormHelp::new();
-            let cmd = Command::new(
-                "command -h",
-                "Try 'command --help' for more information.",
-            );
+            let cmd = Command::new("command -h", "Try 'command --help' for more information.");
             let fixes = rule.get_new_command(&cmd);
             assert_eq!(fixes, vec!["command --help"]);
         }
diff --git a/src/rules/sudo.rs b/src/rules/sudo.rs
index ed687db..1f68336 100644
--- a/src/rules/sudo.rs
+++ b/src/rules/sudo.rs
@@ -37,11 +37,11 @@ const PERMISSION_PATTERNS: &[&str] = &[
 
 /// Commands that should not be prefixed with sudo.
 const EXCLUDED_COMMANDS: &[&str] = &[
-    "sudo",  // Already has sudo
-    "su",    // Switching user
+    "sudo",   // Already has sudo
+    "su",     // Switching user
     "pkexec", // PolicyKit
-    "doas",  // OpenBSD/Alpine sudo alternative
-    "runas", // Windows equivalent
+    "doas",   // OpenBSD/Alpine sudo alternative
+    "runas",  // Windows equivalent
 ];
 
 /// Rule that suggests adding `sudo` to commands that fail with permission errors.
@@ -135,7 +135,10 @@ mod tests {
     #[test]
     fn test_matches_permission_denied() {
         let rule = Sudo;
-        let cmd = Command::new("apt install vim", "E: Could not open lock file - Permission denied");
+        let cmd = Command::new(
+            "apt install vim",
+            "E: Could not open lock file - Permission denied",
+        );
         assert!(rule.is_match(&cmd));
     }
 
@@ -159,14 +162,20 @@ mod tests {
     #[test]
     fn test_matches_must_be_root() {
         let rule = Sudo;
-        let cmd = Command::new("systemctl restart nginx", "Error: you must be root to run this command");
+        let cmd = Command::new(
+            "systemctl restart nginx",
+            "Error: you must be root to run this command",
+        );
         assert!(rule.is_match(&cmd));
     }
 
     #[test]
     fn test_matches_are_you_root() {
         let rule = Sudo;
-        let cmd = Command::new("dnf install package", "Error: This command has to be run under the root user - are you root?");
+        let cmd = Command::new(
+            "dnf install package",
+            "Error: This command has to be run under the root user - are you root?",
+        );
         assert!(rule.is_match(&cmd));
     }
 
@@ -234,10 +243,7 @@ mod tests {
         let rule = Sudo;
         let cmd = Command::new("echo ${PATH} > /etc/profile.d/path.sh", "Permission denied");
         let fixes = rule.get_new_command(&cmd);
-        assert_eq!(
-            fixes,
-            vec!["sudo -E echo ${PATH} > /etc/profile.d/path.sh"]
-        );
+        assert_eq!(fixes, vec!["sudo -E echo ${PATH} > /etc/profile.d/path.sh"]);
     }
 
     #[test]
@@ -263,7 +269,10 @@ mod tests {
     #[test]
     fn test_access_denied() {
         let rule = Sudo;
-        let cmd = Command::new("docker ps", "Got permission denied while trying to connect to the Docker daemon");
+        let cmd = Command::new(
+            "docker ps",
+            "Got permission denied while trying to connect to the Docker daemon",
+        );
         assert!(rule.is_match(&cmd));
     }
 }
diff --git a/src/rules/system.rs b/src/rules/system.rs
index 7745abc..a59cf73 100644
--- a/src/rules/system.rs
+++ b/src/rules/system.rs
@@ -94,8 +94,7 @@ impl Rule for ChmodX {
     }
 
     fn is_match(&self, cmd: &Command) -> bool {
-        cmd.script.starts_with("./")
-            && cmd.output.to_lowercase().contains("permission denied")
+        cmd.script.starts_with("./") && cmd.output.to_lowercase().contains("permission denied")
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
@@ -215,9 +214,21 @@ impl Rule for CpOmittingDirectory {
 
 /// Tar extensions that this rule handles.
 const TAR_EXTENSIONS: &[&str] = &[
-    ".tar", ".tar.Z", ".tar.bz2", ".tar.gz", ".tar.lz",
-    ".tar.lzma", ".tar.xz", ".taz", ".tb2", ".tbz", ".tbz2",
-    ".tgz", ".tlz", ".txz", ".tz",
+    ".tar",
+    ".tar.Z",
+    ".tar.bz2",
+    ".tar.gz",
+    ".tar.lz",
+    ".tar.lzma",
+    ".tar.xz",
+    ".taz",
+    ".tb2",
+    ".tbz",
+    ".tbz2",
+    ".tgz",
+    ".tlz",
+    ".txz",
+    ".tz",
 ];
 
 /// Rule that suggests extracting tar to a subdirectory to avoid polluting current dir.
@@ -269,11 +280,11 @@ impl Rule for DirtyUntar {
         is_app(cmd, &["tar"])
             && !cmd.script.contains("-C")
             && Self::is_tar_extract(&cmd.script)
-            && Self::tar_file(&cmd.script_parts()).is_some()
+            && Self::tar_file(cmd.script_parts()).is_some()
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
-        if let Some((_, base)) = Self::tar_file(&cmd.script_parts()) {
+        if let Some((_, base)) = Self::tar_file(cmd.script_parts()) {
             // Quote the directory name for shell safety
             let dir = shell_quote(&base);
             vec![format!("mkdir -p {} && {} -C {}", dir, cmd.script, dir)]
@@ -336,11 +347,11 @@ impl Rule for DirtyUnzip {
     fn is_match(&self, cmd: &Command) -> bool {
         is_app(cmd, &["unzip"])
             && !cmd.script.contains("-d")
-            && Self::zip_file(&cmd.script_parts()).is_some()
+            && Self::zip_file(cmd.script_parts()).is_some()
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
-        if let Some(zip_file) = Self::zip_file(&cmd.script_parts()) {
+        if let Some(zip_file) = Self::zip_file(cmd.script_parts()) {
             // Get base name without .zip extension
             let base = zip_file.strip_suffix(".zip").unwrap_or(&zip_file);
             let dir = shell_quote(base);
@@ -399,7 +410,7 @@ const FIX_FILE_PATTERNS: &[&str] = &[
 /// use oops::rules::system::FixFile;
 /// use oops::core::{Command, Rule};
 ///
-/// let rule = FixFile;
+/// let rule = FixFile::new();
 /// let cmd = Command::new("python script.py", "  File \"script.py\", line 10");
 /// // Requires EDITOR env var to be set
 /// ```
@@ -424,7 +435,10 @@ impl FixFile {
                     let file = file_match.as_str().to_string();
                     // Check if file exists
                     if Path::new(&file).is_file() {
-                        let line = caps.name("line").map(|m| m.as_str().to_string()).unwrap_or_default();
+                        let line = caps
+                            .name("line")
+                            .map(|m| m.as_str().to_string())
+                            .unwrap_or_default();
                         let col = caps.name("col").map(|m| m.as_str().to_string());
                         return Some((file, line, col));
                     }
@@ -534,10 +548,8 @@ impl LnSOrder {
     /// Get the destination (existing path) from the command parts.
     fn get_destination(parts: &[String]) -> Option<String> {
         for part in parts {
-            if part != "ln" && part != "-s" && part != "--symbolic" {
-                if Path::new(part).exists() {
-                    return Some(part.clone());
-                }
+            if part != "ln" && part != "-s" && part != "--symbolic" && Path::new(part).exists() {
+                return Some(part.clone());
             }
         }
         None
@@ -554,17 +566,14 @@ impl Rule for LnSOrder {
         is_app(cmd, &["ln"])
             && (parts.contains(&"-s".to_string()) || parts.contains(&"--symbolic".to_string()))
             && cmd.output.contains("File exists")
-            && Self::get_destination(&parts).is_some()
+            && Self::get_destination(parts).is_some()
     }
 
     fn get_new_command(&self, cmd: &Command) -> Vec<String> {
         let parts = cmd.script_parts();
-        if let Some(dest) = Self::get_destination(&parts) {
-            let mut new_parts: Vec<String> = parts
-                .iter()
-                .filter(|p| *p != &dest)
-                .cloned()
-                .collect();
+        if let Some(dest) = Self::get_destination(parts) {
+            let mut new_parts: Vec<String> =
+                parts.iter().filter(|p| *p != &dest).cloned().collect();
             new_parts.push(dest);
             vec![new_parts.join(" ")]
         } else {
@@ -906,17 +915,17 @@ impl Rule for Man {
         }
 
         // If command has section 3, try section 2
-        if cmd.script.contains(" 3 ") || cmd.script.contains("3") && parts.len() > 2 {
-            if parts.iter().any(|p| p == "3") {
-                return vec![cmd.script.replace(" 3 ", " 2 ").replace(" 3", " 2")];
-            }
+        if (cmd.script.contains(" 3 ") || cmd.script.contains("3") && parts.len() > 2)
+            && parts.iter().any(|p| p == "3")
+        {
+            return vec![cmd.script.replace(" 3 ", " 2 ").replace(" 3", " 2")];
         }
 
         // If command has section 2, try section 3
-        if cmd.script.contains(" 2 ") || cmd.script.contains("2") && parts.len() > 2 {
-            if parts.iter().any(|p| p == "2") {
-                return vec![cmd.script.replace(" 2 ", " 3 ").replace(" 2", " 3")];
-            }
+        if (cmd.script.contains(" 2 ") || cmd.script.contains("2") && parts.len() > 2)
+            && parts.iter().any(|p| p == "2")
+        {
+            return vec![cmd.script.replace(" 2 ", " 3 ").replace(" 2", " 3")];
         }
 
         let last_arg = &parts[parts.len() - 1];
@@ -932,12 +941,12 @@ impl Rule for Man {
         let mut results = Vec::new();
 
         // Build command with section 3
-        let mut cmd3_parts: Vec<String> = parts.iter().cloned().collect();
+        let mut cmd3_parts: Vec<String> = parts.to_vec();
         cmd3_parts.insert(1, "3".to_string());
         results.push(cmd3_parts.join(" "));
 
         // Build command with section 2
-        let mut cmd2_parts: Vec<String> = parts.iter().cloned().collect();
+        let mut cmd2_parts: Vec<String> = parts.to_vec();
         cmd2_parts.insert(1, "2".to_string());
         results.push(cmd2_parts.join(" "));
 
@@ -1065,7 +1074,9 @@ impl Rule for Open {
 /// Simple shell quoting for safety.
 fn shell_quote(s: &str) -> String {
     // If the string has no special characters, return as-is
-    if s.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '-' || c == '.') {
+    if s.chars()
+        .all(|c| c.is_alphanumeric() || c == '_' || c == '-' || c == '.')
+    {
         s.to_string()
     } else {
         format!("'{}'", s.replace('\'', "'\\''"))
@@ -1277,7 +1288,10 @@ mod tests {
         fn test_get_new_command() {
             let cmd = Command::new("tar xf archive.tar.gz", "");
             let fixes = DirtyUntar.get_new_command(&cmd);
-            assert_eq!(fixes, vec!["mkdir -p archive && tar xf archive.tar.gz -C archive"]);
+            assert_eq!(
+                fixes,
+                vec!["mkdir -p archive && tar xf archive.tar.gz -C archive"]
+            );
         }
 
         #[test]
@@ -1335,7 +1349,10 @@ mod tests {
 
         #[test]
         fn test_matches_hard_link_error() {
-            let cmd = Command::new("ln barDir barLink", "ln: 'barDir': hard link not allowed for directory");
+            let cmd = Command::new(
+                "ln barDir barLink",
+                "ln: 'barDir': hard link not allowed for directory",
+            );
             assert!(LnNoHardLink.is_match(&cmd));
         }
 
@@ -1440,7 +1457,10 @@ mod tests {
 
         #[test]
         fn test_matches_no_such_directory() {
-            let cmd = Command::new("mkdir a/b/c", "mkdir: cannot create directory 'a/b/c': No such file or directory");
+            let cmd = Command::new(
+                "mkdir a/b/c",
+                "mkdir: cannot create directory 'a/b/c': No such file or directory",
+            );
             assert!(MkdirP.is_match(&cmd));
         }
 
@@ -1540,7 +1560,10 @@ mod tests {
 
         #[test]
         fn test_matches_no_such_directory() {
-            let cmd = Command::new("touch /new/path/file.txt", "touch: cannot touch '/new/path/file.txt': No such file or directory");
+            let cmd = Command::new(
+                "touch /new/path/file.txt",
+                "touch: cannot touch '/new/path/file.txt': No such file or directory",
+            );
             assert!(Touch.is_match(&cmd));
         }
 
@@ -1552,7 +1575,10 @@ mod tests {
 
         #[test]
         fn test_get_new_command() {
-            let cmd = Command::new("touch /new/path/file.txt", "touch: cannot touch '/new/path/file.txt': No such file or directory");
+            let cmd = Command::new(
+                "touch /new/path/file.txt",
+                "touch: cannot touch '/new/path/file.txt': No such file or directory",
+            );
             let fixes = Touch.get_new_command(&cmd);
             assert!(fixes[0].contains("mkdir -p") && fixes[0].contains("touch"));
         }
diff --git a/src/rules/typo.rs b/src/rules/typo.rs
index c951060..d067839 100644
--- a/src/rules/typo.rs
+++ b/src/rules/typo.rs
@@ -65,12 +65,14 @@ impl Rule for SlLs {
         let script = cmd.script.trim();
 
         // Replace "sl" with "ls" at the beginning
-        if script.starts_with("sl ") {
-            vec![format!("ls {}", &script[3..])]
+        if let Some(rest) = script.strip_prefix("sl ") {
+            vec![format!("ls {}", rest)]
         } else if script == "sl" {
             vec!["ls".to_string()]
+        } else if let Some(rest) = script.strip_prefix("sl") {
+            vec![format!("ls{}", rest)]
         } else {
-            vec![format!("ls{}", &script[2..])]
+            vec![]
         }
     }
 
@@ -390,7 +392,10 @@ mod tests {
         #[test]
         fn test_matches_not_recognized() {
             let rule = SlLs;
-            let cmd = Command::new("sl", "'sl' is not recognized as an internal or external command");
+            let cmd = Command::new(
+                "sl",
+                "'sl' is not recognized as an internal or external command",
+            );
             assert!(rule.is_match(&cmd));
         }
 
@@ -517,20 +522,14 @@ mod tests {
         #[test]
         fn test_matches_unknown_operation() {
             let rule = Systemctl;
-            let cmd = Command::new(
-                "systemctl statsu nginx",
-                "Unknown operation 'statsu'",
-            );
+            let cmd = Command::new("systemctl statsu nginx", "Unknown operation 'statsu'");
             assert!(rule.is_match(&cmd));
         }
 
         #[test]
         fn test_matches_unknown_command() {
             let rule = Systemctl;
-            let cmd = Command::new(
-                "systemctl stopp nginx",
-                "Unknown command verb 'stopp'",
-            );
+            let cmd = Command::new("systemctl stopp nginx", "Unknown command verb 'stopp'");
             assert!(rule.is_match(&cmd));
         }
 
@@ -547,10 +546,7 @@ mod tests {
         #[test]
         fn test_matches_too_few_arguments() {
             let rule = Systemctl;
-            let cmd = Command::new(
-                "systemctl start",
-                "Too few arguments",
-            );
+            let cmd = Command::new("systemctl start", "Too few arguments");
             assert!(rule.is_match(&cmd));
         }
 
@@ -574,10 +570,7 @@ mod tests {
         #[test]
         fn test_get_new_command_typo() {
             let rule = Systemctl;
-            let cmd = Command::new(
-                "systemctl statsu nginx",
-                "Unknown operation 'statsu'",
-            );
+            let cmd = Command::new("systemctl statsu nginx", "Unknown operation 'statsu'");
             let fixes = rule.get_new_command(&cmd);
             assert!(!fixes.is_empty());
             assert!(fixes[0].contains("status"));
@@ -587,10 +580,7 @@ mod tests {
         #[test]
         fn test_get_new_command_restart_typo() {
             let rule = Systemctl;
-            let cmd = Command::new(
-                "systemctl restar nginx",
-                "Unknown operation 'restar'",
-            );
+            let cmd = Command::new("systemctl restar nginx", "Unknown operation 'restar'");
             let fixes = rule.get_new_command(&cmd);
             assert!(!fixes.is_empty());
             assert!(fixes[0].contains("restart"));
@@ -599,10 +589,7 @@ mod tests {
         #[test]
         fn test_get_new_command_swapped_args() {
             let rule = Systemctl;
-            let cmd = Command::new(
-                "systemctl nginx restart",
-                "Unknown operation 'nginx'",
-            );
+            let cmd = Command::new("systemctl nginx restart", "Unknown operation 'nginx'");
             let fixes = rule.get_new_command(&cmd);
             assert!(!fixes.is_empty());
             assert_eq!(fixes[0], "systemctl restart nginx");
diff --git a/src/shells/bash.rs b/src/shells/bash.rs
index 7d53ef0..6c901ba 100644
--- a/src/shells/bash.rs
+++ b/src/shells/bash.rs
@@ -40,12 +40,11 @@ impl Bash {
         let mut value = line[eq_pos + 1..].trim().to_string();
 
         // Remove surrounding quotes if present
-        if (value.starts_with('\'') && value.ends_with('\''))
-            || (value.starts_with('"') && value.ends_with('"'))
+        if ((value.starts_with('\'') && value.ends_with('\''))
+            || (value.starts_with('"') && value.ends_with('"')))
+            && value.len() >= 2
         {
-            if value.len() >= 2 {
-                value = value[1..value.len() - 1].to_string();
-            }
+            value = value[1..value.len() - 1].to_string();
         }
 
         if name.is_empty() {
diff --git a/src/shells/mod.rs b/src/shells/mod.rs
index 14d2b70..20fd56c 100644
--- a/src/shells/mod.rs
+++ b/src/shells/mod.rs
@@ -109,6 +109,7 @@ pub trait Shell: Send + Sync {
 }
 
 /// Registry of known shells.
+#[allow(clippy::type_complexity)]
 static SHELLS: &[(&str, fn() -> Box<dyn Shell>)] = &[
     ("bash", || Box::new(Bash::new())),
     ("zsh", || Box::new(Zsh::new())),
diff --git a/src/shells/powershell.rs b/src/shells/powershell.rs
index 9214e0a..76c36db 100644
--- a/src/shells/powershell.rs
+++ b/src/shells/powershell.rs
@@ -134,20 +134,63 @@ impl Shell for PowerShell {
     fn get_builtin_commands(&self) -> &[&str] {
         // PowerShell has different built-in commands (cmdlets)
         &[
-            "Add-Content", "Clear-Content", "Clear-Host", "Clear-Item",
-            "Clear-Variable", "Compare-Object", "Copy-Item", "Export-Csv",
-            "ForEach-Object", "Format-List", "Format-Table", "Get-Alias",
-            "Get-ChildItem", "Get-Command", "Get-Content", "Get-Date",
-            "Get-Help", "Get-History", "Get-Item", "Get-Location", "Get-Member",
-            "Get-Process", "Get-Service", "Get-Variable", "Import-Csv",
-            "Import-Module", "Invoke-Command", "Invoke-Expression", "Invoke-WebRequest",
-            "Measure-Object", "Move-Item", "New-Item", "Out-File", "Out-Host",
-            "Out-String", "Read-Host", "Remove-Item", "Remove-Variable",
-            "Rename-Item", "Select-Object", "Select-String", "Set-Content",
-            "Set-Item", "Set-Location", "Set-Variable", "Sort-Object",
-            "Split-Path", "Start-Process", "Start-Service", "Stop-Process",
-            "Stop-Service", "Test-Path", "Where-Object", "Write-Error",
-            "Write-Host", "Write-Output", "Write-Warning",
+            "Add-Content",
+            "Clear-Content",
+            "Clear-Host",
+            "Clear-Item",
+            "Clear-Variable",
+            "Compare-Object",
+            "Copy-Item",
+            "Export-Csv",
+            "ForEach-Object",
+            "Format-List",
+            "Format-Table",
+            "Get-Alias",
+            "Get-ChildItem",
+            "Get-Command",
+            "Get-Content",
+            "Get-Date",
+            "Get-Help",
+            "Get-History",
+            "Get-Item",
+            "Get-Location",
+            "Get-Member",
+            "Get-Process",
+            "Get-Service",
+            "Get-Variable",
+            "Import-Csv",
+            "Import-Module",
+            "Invoke-Command",
+            "Invoke-Expression",
+            "Invoke-WebRequest",
+            "Measure-Object",
+            "Move-Item",
+            "New-Item",
+            "Out-File",
+            "Out-Host",
+            "Out-String",
+            "Read-Host",
+            "Remove-Item",
+            "Remove-Variable",
+            "Rename-Item",
+            "Select-Object",
+            "Select-String",
+            "Set-Content",
+            "Set-Item",
+            "Set-Location",
+            "Set-Variable",
+            "Sort-Object",
+            "Split-Path",
+            "Start-Process",
+            "Start-Service",
+            "Stop-Process",
+            "Stop-Service",
+            "Test-Path",
+            "Where-Object",
+            "Write-Error",
+            "Write-Host",
+            "Write-Output",
+            "Write-Warning",
         ]
     }
 }
diff --git a/src/shells/zsh.rs b/src/shells/zsh.rs
index f7afdd7..adf2f9d 100644
--- a/src/shells/zsh.rs
+++ b/src/shells/zsh.rs
@@ -37,12 +37,11 @@ impl Zsh {
         let mut value = alias_line[eq_pos + 1..].trim().to_string();
 
         // Remove surrounding quotes if present
-        if (value.starts_with('\'') && value.ends_with('\''))
-            || (value.starts_with('"') && value.ends_with('"'))
+        if ((value.starts_with('\'') && value.ends_with('\''))
+            || (value.starts_with('"') && value.ends_with('"')))
+            && value.len() >= 2
         {
-            if value.len() >= 2 {
-                value = value[1..value.len() - 1].to_string();
-            }
+            value = value[1..value.len() - 1].to_string();
         }
 
         if name.is_empty() {
diff --git a/src/ui/colors.rs b/src/ui/colors.rs
index b6cb660..e3ea738 100644
--- a/src/ui/colors.rs
+++ b/src/ui/colors.rs
@@ -2,11 +2,11 @@
 //!
 //! Provides functions for printing colored text to the terminal using crossterm.
 
-use std::io::{self, Write};
+use std::io;
 
 use crossterm::{
     execute,
-    style::{Color, Print, ResetColor, SetAttribute, SetForegroundColor, Attribute},
+    style::{Attribute, Color, Print, ResetColor, SetAttribute, SetForegroundColor},
 };
 
 /// Print a command script with syntax highlighting.
diff --git a/src/utils/cache.rs b/src/utils/cache.rs
index 1d1dff4..6545723 100644
--- a/src/utils/cache.rs
+++ b/src/utils/cache.rs
@@ -25,7 +25,7 @@ use std::path::PathBuf;
 /// ```
 /// use oops::utils::cache::which;
 ///
-/// if let Some(path) = which("git") {
+/// if let Some(path) = which("git".to_string()) {
 ///     println!("git is at: {:?}", path);
 /// }
 /// ```
diff --git a/src/utils/executables.rs b/src/utils/executables.rs
index a2e98a3..ef35adc 100644
--- a/src/utils/executables.rs
+++ b/src/utils/executables.rs
@@ -10,7 +10,7 @@ use regex::Regex;
 use std::collections::HashSet;
 use std::env;
 use std::fs;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 /// Cached set of all executables found in PATH.
 ///
@@ -93,7 +93,7 @@ fn is_executable(path: &PathBuf) -> bool {
 }
 
 #[cfg(windows)]
-fn is_executable(path: &PathBuf) -> bool {
+fn is_executable(path: &Path) -> bool {
     // On Windows, check for common executable extensions
     const EXECUTABLE_EXTENSIONS: &[&str] = &["exe", "cmd", "bat", "com", "ps1", "vbs", "js", "msc"];
 
diff --git a/tests/cli_tests.rs b/tests/cli_tests.rs
index 0b57db8..d33ba8d 100644
--- a/tests/cli_tests.rs
+++ b/tests/cli_tests.rs
@@ -78,9 +78,7 @@ fn test_alias_with_bash_shell() {
         .arg("--alias")
         .assert()
         .success()
-        .stdout(
-            predicate::str::contains("function").or(predicate::str::contains("alias")),
-        );
+        .stdout(predicate::str::contains("function").or(predicate::str::contains("alias")));
 }
 
 #[test]
@@ -92,7 +90,10 @@ fn test_alias_with_zsh_shell() {
 #[test]
 fn test_alias_with_fish_shell() {
     let mut cmd = oops_cmd();
-    cmd.env("TF_SHELL", "fish").arg("--alias").assert().success();
+    cmd.env("TF_SHELL", "fish")
+        .arg("--alias")
+        .assert()
+        .success();
 }
 
 #[test]
@@ -246,7 +247,10 @@ fn test_oops_debug_environment() {
 #[test]
 fn test_version_format() {
     let mut cmd = oops_cmd();
-    let output = cmd.arg("--version").output().expect("Failed to run command");
+    let output = cmd
+        .arg("--version")
+        .output()
+        .expect("Failed to run command");
     let stdout = String::from_utf8_lossy(&output.stdout);
     assert!(
         stdout.contains("0.") || stdout.contains("oops"),
diff --git a/tests/parity_tests.rs b/tests/parity_tests.rs
index 44237ad..80007b6 100644
--- a/tests/parity_tests.rs
+++ b/tests/parity_tests.rs
@@ -286,7 +286,10 @@ fn test_rule_priority_ordering() {
         .map(|r| r.priority());
 
     assert!(sudo_priority.is_some(), "sudo rule should exist");
-    assert!(sudo_priority.unwrap() <= 100, "sudo should have high priority");
+    assert!(
+        sudo_priority.unwrap() <= 100,
+        "sudo should have high priority"
+    );
 }
 
 #[test]
@@ -354,7 +357,10 @@ impl RuleTestData {
         expected.insert(("cd...", "command not found"), vec!["cd ..."]);
 
         RuleTestData {
-            matching_cases: vec![("cd..", "command not found"), ("cd...", "command not found")],
+            matching_cases: vec![
+                ("cd..", "command not found"),
+                ("cd...", "command not found"),
+            ],
             non_matching_cases: vec![("cd ..", ""), ("cd /home", ""), ("cd Documents", "")],
             expected_corrections: expected,
         }