chore: cargo fmt

5 files changed, 107 insertions, 114 deletions

diff --git a/crates/mozart-core/src/version_bumper.rs b/crates/mozart-core/src/version_bumper.rs
index 3bc672f..5d6e75e 100644
--- a/crates/mozart-core/src/version_bumper.rs
+++ b/crates/mozart-core/src/version_bumper.rs
@@ -401,8 +401,12 @@ fn split_and_parts(constraint: &str) -> (Vec<&str>, &str) {
                 }
                 // If what follows starts with an operator, split here
                 if i < bytes.len()
-                    && (bytes[i] == b'>' || bytes[i] == b'<' || bytes[i] == b'!'
-                        || bytes[i] == b'=' || bytes[i] == b'^' || bytes[i] == b'~')
+                    && (bytes[i] == b'>'
+                        || bytes[i] == b'<'
+                        || bytes[i] == b'!'
+                        || bytes[i] == b'='
+                        || bytes[i] == b'^'
+                        || bytes[i] == b'~')
                 {
                     parts.push(&constraint[current_start..space_start]);
                     current_start = i;
@@ -418,9 +422,7 @@ fn split_and_parts(constraint: &str) -> (Vec<&str>, &str) {
 
 /// Check if a constraint part is a lower bound (can be bumped).
 fn is_lower_bound(part: &str) -> bool {
-    part.starts_with(">=")
-        || part.starts_with('^')
-        || part.starts_with('~')
+    part.starts_with(">=") || part.starts_with('^') || part.starts_with('~')
 }
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
diff --git a/crates/mozart/src/commands/audit.rs b/crates/mozart/src/commands/audit.rs
index a26f579..dffa2e4 100644
--- a/crates/mozart/src/commands/audit.rs
+++ b/crates/mozart/src/commands/audit.rs
@@ -552,8 +552,14 @@ fn render_plain(result: &AuditResult) {
 
     for pkg in &result.abandoned {
         match &pkg.replacement {
-            Some(repl) => println!("{} ({}) is abandoned. Use {} instead.", pkg.name, pkg.version, repl),
-            None => println!("{} ({}) is abandoned. No replacement was suggested.", pkg.name, pkg.version),
+            Some(repl) => println!(
+                "{} ({}) is abandoned. Use {} instead.",
+                pkg.name, pkg.version, repl
+            ),
+            None => println!(
+                "{} ({}) is abandoned. No replacement was suggested.",
+                pkg.name, pkg.version
+            ),
         }
     }
 }
@@ -610,8 +616,14 @@ fn render_summary(result: &AuditResult) {
 
     for pkg in &result.abandoned {
         match &pkg.replacement {
-            Some(repl) => println!("{} ({}) is abandoned. Use {} instead.", pkg.name, pkg.version, repl),
-            None => println!("{} ({}) is abandoned. No replacement was suggested.", pkg.name, pkg.version),
+            Some(repl) => println!(
+                "{} ({}) is abandoned. Use {} instead.",
+                pkg.name, pkg.version, repl
+            ),
+            None => println!(
+                "{} ({}) is abandoned. No replacement was suggested.",
+                pkg.name, pkg.version
+            ),
         }
     }
 }
diff --git a/crates/mozart/src/commands/remove.rs b/crates/mozart/src/commands/remove.rs
index 7b19453..ee02ad8 100644
--- a/crates/mozart/src/commands/remove.rs
+++ b/crates/mozart/src/commands/remove.rs
@@ -532,10 +532,8 @@ async fn remove_unused(
     })?;
 
     // Build set of resolved package names
-    let resolved_names: std::collections::HashSet<String> = resolved
-        .iter()
-        .map(|p| p.name.to_lowercase())
-        .collect();
+    let resolved_names: std::collections::HashSet<String> =
+        resolved.iter().map(|p| p.name.to_lowercase()).collect();
 
     // Find packages in the old lock that are not in the new resolution
     let mut unused: Vec<String> = Vec::new();
@@ -563,14 +561,12 @@ async fn remove_unused(
     console.info(&format!("Found {} unused package(s).", unused.len()));
 
     if args.dry_run {
-        console.info(&console::comment(
-            "Dry run: lock file not modified.",
-        ));
+        console.info(&console::comment("Dry run: lock file not modified."));
         return Ok(());
     }
 
     // Re-generate lock file without unused packages
-    let composer_json_content = std::fs::read_to_string(&working_dir.join("composer.json"))?;
+    let composer_json_content = std::fs::read_to_string(working_dir.join("composer.json"))?;
     let new_lock = lockfile::generate_lock_file(&lockfile::LockFileGenerationRequest {
         resolved_packages: resolved,
         composer_json_content,
diff --git a/crates/mozart/src/commands/update.rs b/crates/mozart/src/commands/update.rs
index 582aa83..7924eca 100644
--- a/crates/mozart/src/commands/update.rs
+++ b/crates/mozart/src/commands/update.rs
@@ -927,11 +927,11 @@ pub async fn execute(
     }
 
     // Apply --patch-only filter: restrict updates to patch-level changes only
-    if args.patch_only {
-        if let Some(ref lock) = old_lock {
-            console.info("Patch-only mode: restricting updates to patch-level changes.");
-            resolved = apply_patch_only(resolved, lock);
-        }
+    if args.patch_only
+        && let Some(ref lock) = old_lock
+    {
+        console.info("Patch-only mode: restricting updates to patch-level changes.");
+        resolved = apply_patch_only(resolved, lock);
     }
 
     // Step 9: Generate new lock file
@@ -1021,102 +1021,90 @@ pub async fn execute(
     }
 
     // Step 11b: Bump composer.json constraints if --bump-after-update
-    if let Some(ref bump_mode) = args.bump_after_update {
-        if !args.dry_run {
-            let mode = bump_mode.as_deref().unwrap_or("all");
-            let bump_require = mode == "all" || mode == "no-dev";
-            let bump_require_dev = mode == "all" || mode == "dev";
+    if let Some(ref bump_mode) = args.bump_after_update
+        && !args.dry_run
+    {
+        let mode = bump_mode.as_deref().unwrap_or("all");
+        let bump_require = mode == "all" || mode == "no-dev";
+        let bump_require_dev = mode == "all" || mode == "dev";
 
-            // Build locked versions map from the new lock
-            let mut locked_versions: HashMap<String, (String, Option<String>)> = HashMap::new();
-            for pkg in &new_lock.packages {
+        // Build locked versions map from the new lock
+        let mut locked_versions: HashMap<String, (String, Option<String>)> = HashMap::new();
+        for pkg in &new_lock.packages {
+            locked_versions.insert(
+                pkg.name.to_lowercase(),
+                (pkg.version.clone(), pkg.version_normalized.clone()),
+            );
+        }
+        if let Some(ref dev_pkgs) = new_lock.packages_dev {
+            for pkg in dev_pkgs {
                 locked_versions.insert(
                     pkg.name.to_lowercase(),
-                    (
-                        pkg.version.clone(),
-                        pkg.version_normalized.clone(),
-                    ),
+                    (pkg.version.clone(), pkg.version_normalized.clone()),
                 );
             }
-            if let Some(ref dev_pkgs) = new_lock.packages_dev {
-                for pkg in dev_pkgs {
-                    locked_versions.insert(
-                        pkg.name.to_lowercase(),
-                        (
-                            pkg.version.clone(),
-                            pkg.version_normalized.clone(),
-                        ),
-                    );
-                }
-            }
+        }
 
-            let mut bumped = 0u32;
-            let mut root = composer_json.clone();
+        let mut bumped = 0u32;
+        let mut root = composer_json.clone();
 
-            if bump_require {
-                for (pkg_name, constraint) in &composer_json.require {
-                    if is_platform_package(pkg_name) {
-                        continue;
-                    }
-                    if let Some((pretty_version, version_normalized)) =
-                        locked_versions.get(&pkg_name.to_lowercase())
-                        && let Some(new_constraint) =
-                            mozart_core::version_bumper::bump_requirement(
-                                constraint,
-                                pretty_version,
-                                version_normalized.as_deref(),
-                            )
-                    {
-                        console.info(&format!(
-                            "  Bumping {}: {} => {}",
-                            pkg_name, constraint, new_constraint
-                        ));
-                        root.require.insert(pkg_name.clone(), new_constraint);
-                        bumped += 1;
-                    }
+        if bump_require {
+            for (pkg_name, constraint) in &composer_json.require {
+                if is_platform_package(pkg_name) {
+                    continue;
+                }
+                if let Some((pretty_version, version_normalized)) =
+                    locked_versions.get(&pkg_name.to_lowercase())
+                    && let Some(new_constraint) = mozart_core::version_bumper::bump_requirement(
+                        constraint,
+                        pretty_version,
+                        version_normalized.as_deref(),
+                    )
+                {
+                    console.info(&format!(
+                        "  Bumping {}: {} => {}",
+                        pkg_name, constraint, new_constraint
+                    ));
+                    root.require.insert(pkg_name.clone(), new_constraint);
+                    bumped += 1;
                 }
             }
+        }
 
-            if bump_require_dev {
-                for (pkg_name, constraint) in &composer_json.require_dev {
-                    if is_platform_package(pkg_name) {
-                        continue;
-                    }
-                    if let Some((pretty_version, version_normalized)) =
-                        locked_versions.get(&pkg_name.to_lowercase())
-                        && let Some(new_constraint) =
-                            mozart_core::version_bumper::bump_requirement(
-                                constraint,
-                                pretty_version,
-                                version_normalized.as_deref(),
-                            )
-                    {
-                        console.info(&format!(
-                            "  Bumping {}: {} => {}",
-                            pkg_name, constraint, new_constraint
-                        ));
-                        root.require_dev.insert(pkg_name.clone(), new_constraint);
-                        bumped += 1;
-                    }
+        if bump_require_dev {
+            for (pkg_name, constraint) in &composer_json.require_dev {
+                if is_platform_package(pkg_name) {
+                    continue;
+                }
+                if let Some((pretty_version, version_normalized)) =
+                    locked_versions.get(&pkg_name.to_lowercase())
+                    && let Some(new_constraint) = mozart_core::version_bumper::bump_requirement(
+                        constraint,
+                        pretty_version,
+                        version_normalized.as_deref(),
+                    )
+                {
+                    console.info(&format!(
+                        "  Bumping {}: {} => {}",
+                        pkg_name, constraint, new_constraint
+                    ));
+                    root.require_dev.insert(pkg_name.clone(), new_constraint);
+                    bumped += 1;
                 }
             }
+        }
 
-            if bumped > 0 {
-                package::write_to_file(&root, &composer_json_path)?;
+        if bumped > 0 {
+            package::write_to_file(&root, &composer_json_path)?;
 
-                // Update lock file content-hash to match the new composer.json
-                let new_content = std::fs::read_to_string(&composer_json_path)?;
-                let new_hash =
-                    lockfile::LockFile::compute_content_hash(&new_content)?;
-                let mut updated_lock = new_lock.clone();
-                updated_lock.content_hash = new_hash;
-                updated_lock.write_to_file(&lock_path)?;
+            // Update lock file content-hash to match the new composer.json
+            let new_content = std::fs::read_to_string(&composer_json_path)?;
+            let new_hash = lockfile::LockFile::compute_content_hash(&new_content)?;
+            let mut updated_lock = new_lock.clone();
+            updated_lock.content_hash = new_hash;
+            updated_lock.write_to_file(&lock_path)?;
 
-                console.info(&format!(
-                    "{} constraint(s) bumped.",
-                    bumped
-                ));
-            }
+            console.info(&format!("{} constraint(s) bumped.", bumped));
         }
     }
 
diff --git a/crates/mozart/src/commands/validate.rs b/crates/mozart/src/commands/validate.rs
index 4623b55..49fdc9a 100644
--- a/crates/mozart/src/commands/validate.rs
+++ b/crates/mozart/src/commands/validate.rs
@@ -140,7 +140,8 @@ pub async fn execute(
         if vendor_dir.exists() {
             validate_dependencies(&vendor_dir, args, console);
         } else {
-            console.info("No vendor directory found. Run `mozart install` to install dependencies.");
+            console
+                .info("No vendor directory found. Run `mozart install` to install dependencies.");
         }
     }
 
@@ -426,11 +427,8 @@ fn validate_dependencies(
 
             let Ok(json_value) = serde_json::from_str::<serde_json::Value>(&content) else {
                 dep_errors += 1;
-                let pkg_name = format!(
-                    "{}/{}",
-                    vendor_str,
-                    pkg_entry.file_name().to_string_lossy()
-                );
+                let pkg_name =
+                    format!("{}/{}", vendor_str, pkg_entry.file_name().to_string_lossy());
                 eprintln!(
                     "{}",
                     mozart_core::console::warning(&format!(
@@ -446,11 +444,8 @@ fn validate_dependencies(
             dep_count += 1;
 
             if result.has_errors() || result.has_warnings() {
-                let pkg_name = format!(
-                    "{}/{}",
-                    vendor_str,
-                    pkg_entry.file_name().to_string_lossy()
-                );
+                let pkg_name =
+                    format!("{}/{}", vendor_str, pkg_entry.file_name().to_string_lossy());
 
                 for e in &result.errors {
                     eprintln!(