format

src/cmd/glob.rs

···
     // Normalize pattern: remove leading / for relative matching
     let normalized_pattern = pattern_str.trim_start_matches('/');
     let is_recursive = normalized_pattern.contains("**");
-    
+
     // Collect matching paths
     let mut matches = Vec::new();
-    
+
     fn walk_directory(
         current_path: Arc<vfs::VfsPath>,
         current_relative_path: String,
···
         if let Ok(entries) = current_path.read_dir() {
             for entry in entries {
                 let filename = entry.filename();
-                let entry_path = current_path.join(&filename)
+                let entry_path =
+                    current_path
+                        .join(&filename)
+                        .map_err(|e| ShellError::GenericError {
+                            error: "path error".into(),
+                            msg: e.to_string(),
+                            span: None,
+                            help: None,
+                            inner: vec![],
+                        })?;
+
+                // Build relative path from base
+                let new_relative = if current_relative_path.is_empty() {
+                    filename.clone()
+                } else {
+                    format!("{}/{}", current_relative_path, filename)
+                };
+
+                let metadata = entry_path
+                    .metadata()
                     .map_err(|e| ShellError::GenericError {
                         error: "path error".into(),
                         msg: e.to_string(),
···
                         help: None,
                         inner: vec![],
                     })?;
-                
-                // Build relative path from base
-                let new_relative = if current_relative_path.is_empty() {
-                    filename.clone()
-                } else {
-                    format!("{}/{}", current_relative_path, filename)
-                };
-                
-                let metadata = entry_path.metadata().map_err(|e| ShellError::GenericError {
-                    error: "path error".into(),
-                    msg: e.to_string(),
-                    span: None,
-                    help: None,
-                    inner: vec![],
-                })?;
-                
+
                 // Check if this path matches the pattern
                 // For patterns without path separators, match just the filename
                 // For patterns with path separators, match the full relative path
···
                 } else {
                     &filename
                 };
-                
+
                 if pattern.matches(path_to_match) {
                     let should_include = match metadata.file_type {
                         VfsFileType::Directory => !no_dirs,
···
                         matches.push(new_relative.clone());
                     }
                 }
-                
+
                 // Recursively walk into subdirectories
                 if metadata.file_type == VfsFileType::Directory {
                     // Continue if: recursive pattern, or we haven't reached max depth, or pattern has more components
-                    let should_recurse = is_recursive 
+                    let should_recurse = is_recursive
                         || current_depth < max_depth
-                        || (normalized_pattern.contains('/') && current_depth < normalized_pattern.split('/').count());
-                    
+                        || (normalized_pattern.contains('/')
+                            && current_depth < normalized_pattern.split('/').count());
+
                     if should_recurse {
                         walk_directory(
                             Arc::new(entry_path),
···
 
         // Determine if pattern is absolute (starts with /)
         let is_absolute = pattern_str.starts_with('/');
-        let base_path = if is_absolute {
-            get_vfs()
-        } else {
-            get_pwd()
-        };
+        let base_path = if is_absolute { get_vfs() } else { get_pwd() };
 
         // Use the glob_match function
         let options = GlobOptions {
···
             no_dirs,
             no_files,
         };
-        
+
         let matches = glob_match(&pattern_str, base_path, options)?;
 
         // Convert matches to Value stream
         let signals = engine_state.signals().clone();
-        let values = matches.into_iter().map(move |path| Value::string(path, span));
-        
+        let values = matches
+            .into_iter()
+            .map(move |path| Value::string(path, span));
+
         Ok(PipelineData::list_stream(
             ListStream::new(values, span, signals.clone()),
             None,
         ))
     }
 }
-

src/cmd/ls.rs

···
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use crate::{
-    cmd::glob::{expand_path, GlobOptions},
+    cmd::glob::{GlobOptions, expand_path},
     error::to_shell_err,
     globals::{get_pwd, get_vfs},
 };
-use std::sync::Arc;
 use jacquard::chrono;
 use nu_engine::CallExt;
 use nu_protocol::{
     Category, ListStream, PipelineData, Record, ShellError, Signature, SyntaxShape, Type, Value,
     engine::{Command, EngineState, Stack},
 };
+use std::sync::Arc;
 
 #[derive(Clone)]
 pub struct Ls;
···
             };
 
             let is_absolute = path_str.starts_with('/');
-            let base_path: Arc<vfs::VfsPath> = if is_absolute {
-                get_vfs()
-            } else {
-                pwd.clone()
-            };
+            let base_path: Arc<vfs::VfsPath> = if is_absolute { get_vfs() } else { pwd.clone() };
 
             let options = GlobOptions {
                 max_depth: None,
···
             Ok(Some(Value::record(record, span)))
         };
 
-        let entries = matches
-            .into_iter()
-            .flat_map(move |rel_path| {
-                make_record(&rel_path)
-                    .transpose()
-                    .map(|res| res.unwrap_or_else(|err| Value::error(err, span)))
-            });
+        let entries = matches.into_iter().flat_map(move |rel_path| {
+            make_record(&rel_path)
+                .transpose()
+                .map(|res| res.unwrap_or_else(|err| Value::error(err, span)))
+        });
 
         let signals = engine_state.signals().clone();
         Ok(PipelineData::list_stream(

src/cmd/mv.rs

···
 use std::io::{Read, Write};
 
 use crate::{
-    cmd::glob::{expand_path, GlobOptions},
+    cmd::glob::{GlobOptions, expand_path},
     error::to_shell_err,
     globals::{get_pwd, get_vfs},
 };
-use std::sync::Arc;
 use nu_engine::CallExt;
 use nu_protocol::{
     Category, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
     engine::{Command, EngineState, Stack},
 };
+use std::sync::Arc;
 use vfs::{VfsError, VfsFileType};
 
 #[derive(Clone)]
···
 
         // Expand source path (glob or single) into list of paths
         let is_absolute = source_str.starts_with('/');
-        let base_path: Arc<vfs::VfsPath> = if is_absolute {
-            get_vfs()
-        } else {
-            get_pwd()
-        };
+        let base_path: Arc<vfs::VfsPath> = if is_absolute { get_vfs() } else { get_pwd() };
 
         let options = GlobOptions {
             max_depth: None,
···
         };
 
         let matches = expand_path(&source_str, base_path.clone(), options)?;
-        let is_glob = matches.len() > 1 || source_str.contains('*') || source_str.contains('?') || source_str.contains('[') || source_str.contains("**");
+        let is_glob = matches.len() > 1
+            || source_str.contains('*')
+            || source_str.contains('?')
+            || source_str.contains('[')
+            || source_str.contains("**");
 
         // Resolve destination
         let dest = get_pwd()
···
 
         // For glob patterns, destination must be a directory
         if is_glob {
-            let dest_meta = dest.metadata().map_err(to_shell_err(call.arguments_span()))?;
+            let dest_meta = dest
+                .metadata()
+                .map_err(to_shell_err(call.arguments_span()))?;
             if dest_meta.file_type != VfsFileType::Directory {
                 return Err(ShellError::GenericError {
                     error: "destination must be a directory".to_string(),
···
 
         // Move each matching file/directory
         for rel_path in matches {
-            let source = base_path.join(&rel_path).map_err(to_shell_err(call.arguments_span()))?;
-            let source_meta = source.metadata().map_err(to_shell_err(call.arguments_span()))?;
+            let source = base_path
+                .join(&rel_path)
+                .map_err(to_shell_err(call.arguments_span()))?;
+            let source_meta = source
+                .metadata()
+                .map_err(to_shell_err(call.arguments_span()))?;
 
             // Determine destination path
             let dest_entry = if is_glob {
                 // For glob patterns, use filename in destination directory
                 let filename = rel_path.split('/').last().unwrap_or(&rel_path);
-                dest.join(filename).map_err(to_shell_err(call.arguments_span()))?
+                dest.join(filename)
+                    .map_err(to_shell_err(call.arguments_span()))?
             } else {
                 // For single path, use destination as-is
                 dest.clone()
···
 
             match source_meta.file_type {
                 VfsFileType::File => move_file(&source, &dest_entry, call.arguments_span())?,
-                VfsFileType::Directory => move_directory(&source, &dest_entry, call.arguments_span())?,
+                VfsFileType::Directory => {
+                    move_directory(&source, &dest_entry, call.arguments_span())?
+                }
             }
         }
 

src/cmd/open.rs

···
 use std::ops::Not;
 
 use crate::{
-    cmd::glob::{expand_path, GlobOptions},
+    cmd::glob::{GlobOptions, expand_path},
     globals::{get_pwd, get_vfs},
 };
-use std::sync::Arc;
 use nu_command::{FromCsv, FromJson, FromOds, FromToml, FromTsv, FromXlsx, FromXml, FromYaml};
 use nu_engine::CallExt;
 use nu_protocol::{
-    ByteStream, Category, ListStream, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
+    ByteStream, Category, ListStream, PipelineData, ShellError, Signature, SyntaxShape, Type,
+    Value,
     engine::{Command, EngineState, Stack},
 };
+use std::sync::Arc;
 
 #[derive(Clone)]
 pub struct Open;
···
 
         // Expand path (glob or single) into list of paths
         let is_absolute = path_str.starts_with('/');
-        let base_path: Arc<vfs::VfsPath> = if is_absolute {
-            get_vfs()
-        } else {
-            get_pwd()
-        };
+        let base_path: Arc<vfs::VfsPath> = if is_absolute { get_vfs() } else { get_pwd() };
 
         let options = GlobOptions {
             max_depth: None,
···
                         match cmd.run(engine_state, stack, call, data) {
                             Ok(pipeline_data) => {
                                 // Convert pipeline data to value
-                                pipeline_data.into_value(span).unwrap_or_else(|e| {
-                                    Value::error(e, span)
-                                })
+                                pipeline_data
+                                    .into_value(span)
+                                    .unwrap_or_else(|e| Value::error(e, span))
                             }
                             Err(e) => Value::error(e, span),
                         }
                     } else {
-                        data.into_value(span).unwrap_or_else(|e| Value::error(e, span))
+                        data.into_value(span)
+                            .unwrap_or_else(|e| Value::error(e, span))
                     };
                     results.push(value);
                 }
···
         }
 
         // If single file, return the single result directly (for backward compatibility)
-        if results.len() == 1 && !path_str.contains('*') && !path_str.contains('?') && !path_str.contains('[') && !path_str.contains("**") {
+        if results.len() == 1
+            && !path_str.contains('*')
+            && !path_str.contains('?')
+            && !path_str.contains('[')
+            && !path_str.contains("**")
+        {
             match results.into_iter().next().unwrap() {
                 Value::Error { error, .. } => Err(*error),
                 val => Ok(PipelineData::Value(val, None)),

src/cmd/rm.rs

···
 use crate::{
-    cmd::glob::{expand_path, GlobOptions},
+    cmd::glob::{GlobOptions, expand_path},
     error::to_shell_err,
     globals::{get_pwd, get_vfs},
 };
-use std::sync::Arc;
 use nu_engine::CallExt;
 use nu_protocol::{
     Category, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
     engine::{Command, EngineState, Stack},
 };
+use std::sync::Arc;
 use vfs::VfsFileType;
 
 #[derive(Clone)]
···
 
         // Expand path (glob or single) into list of paths
         let is_absolute = path_str.starts_with('/');
-        let base_path: Arc<vfs::VfsPath> = if is_absolute {
-            get_vfs()
-        } else {
-            get_pwd()
-        };
+        let base_path: Arc<vfs::VfsPath> = if is_absolute { get_vfs() } else { get_pwd() };
 
         let options = GlobOptions {
             max_depth: None,

src/cmd/source_file.rs

···
     error::{CommandError, to_shell_err},
     globals::{get_pwd, get_vfs, print_to_console, set_pwd},
 };
-use std::sync::Arc;
 use nu_engine::{CallExt, get_eval_block_with_early_return};
 use nu_parser::parse;
 use nu_protocol::{
     Category, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
     engine::{Command, EngineState, Stack, StateWorkingSet},
 };
+use std::sync::Arc;
 
 #[derive(Clone)]
 pub struct SourceFile;
···
 
         let pwd = get_pwd();
         let is_absolute = path_str.starts_with('/');
-        let base_path: Arc<vfs::VfsPath> = if is_absolute {
-            get_vfs()
-        } else {
-            pwd.clone()
-        };
+        let base_path: Arc<vfs::VfsPath> = if is_absolute { get_vfs() } else { pwd.clone() };
 
         // Check if it's a glob pattern (contains *, ?, [, or **)
-        let is_glob = path_str.contains('*') 
-            || path_str.contains('?') 
-            || path_str.contains('[') 
+        let is_glob = path_str.contains('*')
+            || path_str.contains('?')
+            || path_str.contains('[')
             || path_str.contains("**");
 
         let paths_to_source = if is_glob {
             // Expand glob pattern
             let options = crate::cmd::glob::GlobOptions {
                 max_depth: None,
-                no_dirs: true,  // Only source files, not directories
+                no_dirs: true, // Only source files, not directories
                 no_files: false,
             };
             glob_match(&path_str, base_path.clone(), options)?
···
         // Source each matching file
         for rel_path in paths_to_source {
             let full_path = base_path.join(&rel_path).map_err(to_shell_err(span))?;
-            
+
             let metadata = full_path.metadata().map_err(to_shell_err(span))?;
             if metadata.file_type != vfs::VfsFileType::File {
                 continue;

src/lib.rs

···
 
 use crate::{
     cmd::{
-        Cd, Eval, Fetch, Glob, Job, JobKill, JobList, Ls, Mkdir, Mv, Open, Print, Pwd, Random, Rm, Save,
-        SourceFile, Sys,
+        Cd, Eval, Fetch, Glob, Job, JobKill, JobList, Ls, Mkdir, Mv, Open, Print, Pwd, Random, Rm,
+        Save, SourceFile, Sys,
     },
     default_context::add_shell_command_context,
     globals::{InterruptBool, get_pwd, get_vfs, print_to_console, set_interrupt},