Fix cargo fmt formatting errors

Apply rustfmt formatting to resolve CI build failures:
- Consolidate function parameters onto single lines where appropriate
- Remove extra blank lines
- Format multi-line error messages consistently
- Format chained method calls according to rustfmt style

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

Co-Authored-By: Claude <noreply@anthropic.com>
Co-authored-by: Christian Schilling <christian-schilling@users.noreply.github.com>

Author: 3 people

josh-cli/src/bin/josh.rs

@@ -15,11 +15,7 @@ fn from_josh_err(err: josh::JoshError) -> anyhow::Error {
 
 /// Spawn a git command directly to the terminal so users can see progress
 /// Falls back to captured output if not in a TTY environment
-fn spawn_git_command(
-    cwd: &std::path::Path,
-    args: &[&str],
-    env: &[(&str, &str)],
-) -> Result<i32> {
+fn spawn_git_command(cwd: &std::path::Path, args: &[&str], env: &[(&str, &str)]) -> Result<i32> {
     debug!("spawn_git_command: {:?}", args);
     let mut command = ProcessCommand::new("git");
     command.current_dir(cwd).args(args);
@@ -280,14 +276,12 @@ fn apply_josh_filtering(
     filter: &str,
     remote_name: &str,
 ) -> Result<()> {
-
     // Use josh API directly instead of calling josh-filter binary
     let filterobj = josh::filter::parse(filter)
         .map_err(from_josh_err)
         .context("Failed to parse filter")?;
 
-    josh::cache_sled::sled_load(&repo_path.join(".git"))
-        .context("Failed to load sled cache")?;
+    josh::cache_sled::sled_load(&repo_path.join(".git")).context("Failed to load sled cache")?;
 
     let cache = std::sync::Arc::new(
         josh::cache_stack::CacheStack::new()
@@ -358,14 +352,13 @@ fn apply_josh_filtering(
 
     // Fetch the filtered refs to create standard remote refs
     let path_env = std::env::var("PATH").unwrap_or_default();
-    let exit_code = spawn_git_command(
-        repo_path,
-        &["fetch", remote_name],
-        &[("PATH", &path_env)],
-    )?;
+    let exit_code = spawn_git_command(repo_path, &["fetch", remote_name], &[("PATH", &path_env)])?;
 
     if exit_code != 0 {
-        return Err(anyhow::anyhow!("Failed to fetch filtered refs: exit code {}", exit_code));
+        return Err(anyhow::anyhow!(
+            "Failed to fetch filtered refs: exit code {}",
+            exit_code
+        ));
     }
 
     Ok(())
@@ -379,8 +372,8 @@ fn handle_clone(args: &CloneArgs) -> Result<()> {
     std::fs::create_dir_all(&output_dir)?;
 
     // Initialize a new git repository inside the directory using git2
-    let _repo = git2::Repository::init(&output_dir)
-        .context("Failed to initialize git repository")?;
+    let _repo =
+        git2::Repository::init(&output_dir).context("Failed to initialize git repository")?;
 
     let original_dir = std::env::current_dir()?;
 
@@ -422,8 +415,7 @@ fn handle_clone(args: &CloneArgs) -> Result<()> {
     let default_branch = if args.branch == "HEAD" {
         // Read the remote HEAD symref to get the default branch
         let head_ref = format!("refs/remotes/origin/HEAD");
-        let repo = git2::Repository::open(&output_dir)
-            .context("Failed to open repository")?;
+        let repo = git2::Repository::open(&output_dir).context("Failed to open repository")?;
 
         let head_reference = repo
             .find_reference(&head_ref)
@@ -491,8 +483,7 @@ fn handle_clone(args: &CloneArgs) -> Result<()> {
 
 fn handle_pull(args: &PullArgs) -> Result<()> {
     // Check if we're in a git repository
-    let repo = git2::Repository::open_from_env()
-        .context("Not in a git repository")?;
+    let repo = git2::Repository::open_from_env().context("Not in a git repository")?;
     let repo_path = repo.path().parent().unwrap().to_path_buf();
 
     // Create FetchArgs from PullArgs
@@ -543,23 +534,20 @@ fn handle_pull(args: &PullArgs) -> Result<()> {
 
 fn handle_fetch(args: &FetchArgs) -> Result<()> {
     // Check if we're in a git repository
-    let repo = git2::Repository::open_from_env()
-        .context("Not in a git repository")?;
+    let repo = git2::Repository::open_from_env().context("Not in a git repository")?;
     let repo_path = repo.path().parent().unwrap().to_path_buf();
 
     handle_fetch_internal(args, &repo_path)
 }
 
 fn handle_fetch_internal(args: &FetchArgs, repo_path: &std::path::Path) -> Result<()> {
-    let repo = git2::Repository::open(repo_path)
-        .context("Failed to open repository")?;
+    let repo = git2::Repository::open(repo_path).context("Failed to open repository")?;
 
     // Get PATH environment variable for shell commands
     let path_env = std::env::var("PATH").unwrap_or_default();
 
     // Read the remote URL from josh-remote config
-    let config = repo.config()
-        .context("Failed to get git config")?;
+    let config = repo.config().context("Failed to get git config")?;
 
     let remote_url = config
         .get_string(&format!("josh-remote.{}.url", args.remote))
@@ -643,12 +631,10 @@ fn handle_fetch_internal(args: &FetchArgs, repo_path: &std::path::Path) -> Resul
 
 fn handle_push(args: &PushArgs) -> Result<()> {
     // Read filter from git config for the specific remote
-    let repo = git2::Repository::open_from_env()
-        .context("Not in a git repository")?;
+    let repo = git2::Repository::open_from_env().context("Not in a git repository")?;
     let repo_path = repo.path().parent().unwrap();
 
-    let config = repo.config()
-        .context("Failed to get git config")?;
+    let config = repo.config().context("Failed to get git config")?;
 
     // Step 2: Apply reverse filtering and push to actual remote
     let filter_str = config
@@ -660,8 +646,7 @@ fn handle_push(args: &PushArgs) -> Result<()> {
         .map_err(from_josh_err)
         .context("Failed to parse filter")?;
 
-    josh::cache_sled::sled_load(repo_path)
-        .context("Failed to load sled cache")?;
+    josh::cache_sled::sled_load(repo_path).context("Failed to load sled cache")?;
     let cache = std::sync::Arc::new(
         josh::cache_stack::CacheStack::new()
             .with_backend(josh::cache_sled::SledCacheBackend::default())
@@ -861,7 +846,11 @@ fn handle_push(args: &PushArgs) -> Result<()> {
             )?;
 
             if exit_code != 0 {
-                return Err(anyhow::anyhow!("git push failed for {}: exit code {}", refname, exit_code));
+                return Err(anyhow::anyhow!(
+                    "git push failed for {}: exit code {}",
+                    refname,
+                    exit_code
+                ));
             }
 
             println!("Pushed {} to {}/{}", oid, args.remote, refname);
@@ -879,16 +868,14 @@ fn handle_remote(args: &RemoteArgs) -> Result<()> {
 
 fn handle_remote_add(args: &RemoteAddArgs) -> Result<()> {
     // Check if we're in a git repository
-    let repo = git2::Repository::open_from_env()
-        .context("Not in a git repository")?;
+    let repo = git2::Repository::open_from_env().context("Not in a git repository")?;
     let repo_path = repo.path().parent().unwrap();
 
     handle_remote_add_internal(args, repo_path)
 }
 
 fn handle_remote_add_internal(args: &RemoteAddArgs, repo_path: &std::path::Path) -> Result<()> {
-    let repo = git2::Repository::open(repo_path)
-        .context("Failed to open repository")?;
+    let repo = git2::Repository::open(repo_path).context("Failed to open repository")?;
 
     // Store the remote information in josh-remote config instead of adding a git remote
     let remote_path = if args.url.starts_with("http") || args.url.starts_with("ssh://") {
@@ -909,8 +896,7 @@ fn handle_remote_add_internal(args: &RemoteAddArgs, repo_path: &std::path::Path)
         format!("{}:prune=trivial-merge", args.filter)
     };
 
-    let mut config = repo.config()
-        .context("Failed to get git config")?;
+    let mut config = repo.config().context("Failed to get git config")?;
 
     // Store remote URL in josh-remote section
     config
@@ -947,7 +933,10 @@ fn handle_remote_add_internal(args: &RemoteAddArgs, repo_path: &std::path::Path)
     )?;
 
     if exit_code != 0 {
-        return Err(anyhow::anyhow!("Failed to add git remote: exit code {}", exit_code));
+        return Err(anyhow::anyhow!(
+            "Failed to add git remote: exit code {}",
+            exit_code
+        ));
     }
 
     // Set up namespace configuration for the remote
@@ -965,7 +954,10 @@ fn handle_remote_add_internal(args: &RemoteAddArgs, repo_path: &std::path::Path)
     )?;
 
     if exit_code != 0 {
-        return Err(anyhow::anyhow!("Failed to set remote uploadpack: exit code {}", exit_code));
+        return Err(anyhow::anyhow!(
+            "Failed to set remote uploadpack: exit code {}",
+            exit_code
+        ));
     }
 
     println!(
@@ -978,8 +970,7 @@ fn handle_remote_add_internal(args: &RemoteAddArgs, repo_path: &std::path::Path)
 
 /// Handle the `josh filter` command - apply filtering to existing refs without fetching
 fn handle_filter(args: &FilterArgs) -> Result<()> {
-    let repo = git2::Repository::open_from_env()
-        .context("Not in a git repository")?;
+    let repo = git2::Repository::open_from_env().context("Not in a git repository")?;
     let repo_path = repo.path().parent().unwrap().to_path_buf();
 
     handle_filter_internal(args, &repo_path, true)
@@ -991,12 +982,10 @@ fn handle_filter_internal(
     repo_path: &std::path::Path,
     print_messages: bool,
 ) -> Result<()> {
-    let repo = git2::Repository::open(repo_path)
-        .context("Failed to open repository")?;
+    let repo = git2::Repository::open(repo_path).context("Failed to open repository")?;
 
     // Read the filter from git config for this remote
-    let config = repo.config()
-        .context("Failed to get git config")?;
+    let config = repo.config().context("Failed to get git config")?;
 
     let filter_key = format!("josh-remote.{}.filter", args.remote);
     let filter = config

josh-core/src/changes.rs

@@ -56,7 +56,12 @@ fn split_changes(
 
     let base_tree = std::iter::once(repo.find_commit(base)?.tree()?);
     let trees: Vec<git2::Tree> = base_tree
-        .chain(commits.iter().map(|commit| commit.tree()).collect::<Result<Vec<_>, _>>()?)
+        .chain(
+            commits
+                .iter()
+                .map(|commit| commit.tree())
+                .collect::<Result<Vec<_>, _>>()?,
+        )
         .collect();
 
     let diffs: Vec<git2::Diff> = trees