support multiple contexts, dont sort all suggestions to keep sorting of contexts

src/cmd/source.rs

···
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
-            .required("filename", SyntaxShape::String, "the file to source")
+            .required("filename", SyntaxShape::Filepath, "the file to source")
             .input_output_type(Type::Nothing, Type::Nothing)
             .category(Category::Core)
     }

src/completion/context.rs

···
     engine_guard: &EngineState,
     byte_pos: usize,
     global_offset: usize,
-) -> Option<CompletionContext> {
+) -> Vec<CompletionContext> {
     use nu_parser::{TokenContents, lex};
 
     console_log!("[completion] Context is None, entering fallback logic");
···
                             cmd_first_word.clone()
                         };
 
+                        let mut context = Vec::with_capacity(2);
                         if let Some(signature) = get_command_signature(engine_guard, &cmd_name) {
                             // Check if command has any positional arguments
                             let has_positional_args = !signature.required_positional.is_empty()
···
                                     "[completion] Right after command {cmd_name:?}, setting CommandArgument context with arg_index: {arg_count}"
                                 );
 
-                                return Some(CompletionContext::CommandArgument {
+                                context.push(CompletionContext::CommandArgument {
                                     prefix: String::new(),
                                     span: Span::new(byte_pos, byte_pos),
-                                    command_name: cmd_name,
+                                    command_name: cmd_name.clone(),
                                     arg_index: arg_count,
                                 });
-                            } else {
-                                // No positional arguments
-                                // If this is a subcommand (contains spaces), don't show subcommands
-                                // Only show subcommands if we're using just the base command (single word)
-                                if is_subcommand && full_cmd_exists {
-                                    console_log!(
-                                        "[completion] Command {cmd_name:?} is a subcommand with no positional args, not showing completions"
-                                    );
-                                    return None;
-                                } else {
-                                    // Show subcommands of the base command
-                                    console_log!(
-                                        "[completion] Command {cmd_name:?} has no positional args, showing subcommands"
-                                    );
-                                    return Some(CompletionContext::Command {
-                                        prefix: String::new(),
-                                        span: Span::new(byte_pos, byte_pos),
-                                        parent_command: Some(cmd_first_word),
-                                    });
-                                }
                             }
+                        }
+                        // No positional arguments
+                        // If this is a subcommand (contains spaces), don't show subcommands
+                        // Only show subcommands if we're using just the base command (single word)
+                        if is_subcommand && full_cmd_exists {
+                            console_log!(
+                                "[completion] Command {cmd_name:?} is a subcommand with no positional args, not showing completions"
+                            );
                         } else {
-                            // Couldn't find signature
-                            // If this is a subcommand, don't show completions
-                            // Otherwise, show subcommands of the first word
-                            if is_subcommand && full_cmd_exists {
-                                console_log!(
-                                    "[completion] Could not find signature for subcommand {cmd_name:?}, not showing completions"
-                                );
-                                return None;
-                            } else {
-                                console_log!(
-                                    "[completion] Could not find signature for {cmd_name:?}, showing subcommands"
-                                );
-                                return Some(CompletionContext::Command {
-                                    prefix: String::new(),
-                                    span: Span::new(byte_pos, byte_pos),
-                                    parent_command: Some(cmd_first_word),
-                                });
-                            }
+                            // Show subcommands of the base command
+                            console_log!(
+                                "[completion] Command {cmd_name:?} has no positional args, showing subcommands"
+                            );
+                            context.push(CompletionContext::Command {
+                                prefix: String::new(),
+                                span: Span::new(byte_pos, byte_pos),
+                                parent_command: Some(cmd_first_word),
+                            });
                         }
+                        // reverse to put subcommands in the beginning
+                        context.reverse();
+                        return context;
                     } else {
                         // Not right after command, complete the command itself
                         console_log!("[completion] Set Command context with prefix: {cmd:?}");
-                        return Some(CompletionContext::Command {
+                        return vec![CompletionContext::Command {
                             prefix: cmd.to_string(),
                             span: local_span,
                             parent_command: None,
-                        });
+                        }];
                     }
                 }
             }
···
     console_log!("[completion] last_word_start={last_word_start}, last_word={last_word:?}");
 
     if is_cmd_context {
-        Some(CompletionContext::Command {
+        vec![CompletionContext::Command {
             prefix: last_word.to_string(),
             span: Span::new(last_word_start, byte_pos),
             parent_command: None,
-        })
+        }]
     } else {
         // Check if this is a variable or cell path (starts with $)
         let trimmed_word = last_word.trim();
···
                 if let Some(var_id) = var_id {
                     let prefix_byte_len = cell_prefix.len();
                     let cell_span_start = byte_pos.saturating_sub(prefix_byte_len);
-                    Some(CompletionContext::CellPath {
+                    vec![CompletionContext::CellPath {
                         prefix: cell_prefix.to_string(),
                         span: Span::new(cell_span_start, byte_pos),
                         var_id,
                         path_so_far: path_so_far.iter().map(|s| s.to_string()).collect(),
-                    })
+                    }]
                 } else {
                     let var_prefix = trimmed_word[1..].to_string();
-                    Some(CompletionContext::Variable {
+                    vec![CompletionContext::Variable {
                         prefix: var_prefix,
                         span: Span::new(last_word_start, byte_pos),
-                    })
+                    }]
                 }
             } else {
                 // Simple variable completion
                 let var_prefix = trimmed_word[1..].to_string();
-                Some(CompletionContext::Variable {
+                vec![CompletionContext::Variable {
                     prefix: var_prefix,
                     span: Span::new(last_word_start, byte_pos),
-                })
+                }]
             }
         } else if trimmed_word.starts_with('-') {
             // Try to find command by looking backwards through shapes
···
                 }
             }
             if let Some(cmd_name) = found_cmd {
-                Some(CompletionContext::Flag {
+                vec![CompletionContext::Flag {
                     prefix: trimmed_word.to_string(),
                     span: Span::new(last_word_start, byte_pos),
                     command_name: cmd_name,
-                })
+                }]
             } else {
-                Some(CompletionContext::Argument {
+                vec![CompletionContext::Argument {
                     prefix: last_word.to_string(),
                     span: Span::new(last_word_start, byte_pos),
-                })
+                }]
             }
         } else {
             // Try to find command and argument index
···
                 }
             }
             if let Some(cmd_name) = found_cmd {
-                Some(CompletionContext::CommandArgument {
+                vec![CompletionContext::CommandArgument {
                     prefix: trimmed_word.to_string(),
                     span: Span::new(last_word_start, byte_pos),
                     command_name: cmd_name,
                     arg_index: arg_count,
-                })
+                }]
             } else {
-                Some(CompletionContext::Argument {
+                vec![CompletionContext::Argument {
                     prefix: last_word.to_string(),
                     span: Span::new(last_word_start, byte_pos),
-                })
+                }]
             }
         }
     }
···
     engine_guard: &EngineState,
     byte_pos: usize,
     global_offset: usize,
-) -> Option<CompletionContext> {
+) -> Vec<CompletionContext> {
     // First try to determine context from shapes
     if let Some(ctx) =
         determine_context_from_shape(input, shapes, working_set, byte_pos, global_offset)
     {
-        return Some(ctx);
+        return vec![ctx];
     }
 
     // Fallback to token-based context determination

src/completion/files.rs

···
-use crate::completion::helpers::to_char_span;
-use crate::completion::types::Suggestion;
-use nu_protocol::Span;
-
-pub fn generate_file_suggestions(
-    prefix: &str,
-    span: Span,
-    root: &std::sync::Arc<vfs::VfsPath>,
-    description: Option<String>,
-    input: &str,
-) -> Vec<Suggestion> {
-    let (dir, file_prefix) = prefix
-        .rfind('/')
-        .map(|idx| (&prefix[..idx + 1], &prefix[idx + 1..]))
-        .unwrap_or(("", prefix));
-
-    let dir_to_join = (dir.len() > 1 && dir.ends_with('/'))
-        .then(|| &dir[..dir.len() - 1])
-        .unwrap_or(dir);
-
-    let target_dir = if !dir.is_empty() {
-        match root.join(dir_to_join) {
-            Ok(d) if d.is_dir().unwrap_or(false) => Some(d),
-            _ => None,
-        }
-    } else {
-        Some(root.join("").unwrap())
-    };
-
-    let mut file_suggestions = Vec::new();
-    if let Some(d) = target_dir {
-        if let Ok(iterator) = d.read_dir() {
-            let char_span = to_char_span(input, span);
-            for entry in iterator {
-                let name = entry.filename();
-                if name.starts_with(file_prefix) {
-                    let full_completion = format!("{}{}", dir, name);
-                    file_suggestions.push(Suggestion {
-                        name: full_completion.clone(),
-                        description: description.clone(),
-                        is_command: false,
-                        rendered: full_completion,
-                        span_start: char_span.start,
-                        span_end: char_span.end,
-                    });
-                }
-            }
-        }
-    }
-    file_suggestions
-}

src/completion/mod.rs

···
 use super::*;
 
 pub mod context;
-pub mod files;
 pub mod helpers;
 pub mod suggestions;
 pub mod types;
···
     );
 
     // Generate suggestions based on context
-    let mut suggestions = generate_suggestions(
+    let suggestions = generate_suggestions(
         &input,
         context,
         &working_set,
···
     drop(working_set);
     drop(engine_guard);
 
-    suggestions.sort();
     let suggestions = serde_json::to_string(&suggestions).unwrap_or_else(|_| "[]".to_string());
     console_log!("{suggestions}");
     suggestions

src/completion/suggestions.rs

···
 use crate::completion::context::get_command_signature;
-use crate::completion::files::generate_file_suggestions;
 use crate::completion::helpers::to_char_span;
 use crate::completion::types::{CompletionContext, Suggestion};
 use crate::completion::variables::*;
···
             },
             name: display_name,
             description: desc.map(|d| d.to_string()),
-            is_command: true,
             span_start: span.start,
             span_end: span.end,
         });
         cmd_count += 1;
     }
     console_log!("[completion] Found {cmd_count} command suggestions");
+    suggestions.sort();
     suggestions
 }
 
···
 ) -> Vec<Suggestion> {
     console_log!("[completion] Generating Argument suggestions with prefix: {prefix:?}");
     // File completion
-    let file_suggestions = generate_file_suggestions(&prefix, span, root, None, input);
-    let file_count = file_suggestions.len();
-    console_log!("[completion] Found {file_count} file suggestions");
+    let mut file_suggestions = generate_file_suggestions(&prefix, span, root, None, input);
+    console_log!(
+        "[completion] Found {file_count} file suggestions",
+        file_count = file_suggestions.len()
+    );
+    file_suggestions.sort();
     file_suggestions
 }
 
···
                     Suggestion {
                         name: flag_name.clone(),
                         description: Some(flag.desc.clone()),
-                        is_command: false,
                         rendered: {
                             let flag_colored = ansi_term::Color::Cyan.bold().paint(&flag_name);
                             format!("{flag_colored} {}", flag.desc)
···
     } else {
         console_log!("[completion] Could not find signature for command: {command_name:?}");
     }
+    suggestions.sort();
     suggestions
 }
 
···
 
         if let Some(arg) = arg {
             // Check the SyntaxShape to determine completion type
-            // Only suggest files/dirs for Filepath type (or "any" when type is unknown)
+            // Only suggest files/dirs for Filepath type
             match &arg.shape {
                 nu_protocol::SyntaxShape::Filepath | nu_protocol::SyntaxShape::Any => {
                     // File/directory completion
···
                     console_log!(
                         "[completion] Found {file_count} file suggestions for argument {arg_index}"
                     );
-
-                    // If the argument is optional and of type Any or Filepath, also show subcommands
-                    if is_optional {
-                        console_log!(
-                            "[completion] Argument {arg_index} is optional and of type {:?}, also showing subcommands",
-                            arg.shape
-                        );
-                        let subcommand_suggestions = generate_command_suggestions(
-                            input,
-                            working_set,
-                            prefix.clone(),
-                            span,
-                            Some(command_name.clone()),
-                        );
-                        let subcommand_count = subcommand_suggestions.len();
-                        suggestions.extend(subcommand_suggestions);
-                        console_log!(
-                            "[completion] Found {subcommand_count} subcommand suggestions"
-                        );
-                    }
                 }
                 _ => {
                     // For other types, don't suggest files
···
         let file_suggestions = generate_file_suggestions(&prefix, span, root, None, input);
         suggestions.extend(file_suggestions);
     }
+    suggestions.sort();
     suggestions
 }
 
···
             suggestions.push(Suggestion {
                 name: var_name.clone(),
                 description: Some(var_type.clone()),
-                is_command: false,
                 rendered: {
                     let var_colored = ansi_term::Color::Blue.bold().paint(&var_name);
                     format!("{var_colored} {var_type}")
···
     }
 
     console_log!("[completion] Found {var_count} variable suggestions");
+    suggestions.sort();
     suggestions
 }
 
···
                 suggestions.push(Suggestion {
                     name: col_name.clone(),
                     description: Some(type_str.to_string()),
-                    is_command: false,
                     rendered: {
                         let col_colored = ansi_term::Color::Yellow.paint(&col_name);
                         format!("{col_colored} {type_str}")
···
             console_log!("[completion] Variable type: {ty:?}", ty = var_info.ty);
         }
     }
+    suggestions.sort();
     suggestions
 }
 
+pub fn generate_file_suggestions(
+    prefix: &str,
+    span: Span,
+    root: &std::sync::Arc<vfs::VfsPath>,
+    description: Option<String>,
+    input: &str,
+) -> Vec<Suggestion> {
+    let (dir, file_prefix) = prefix
+        .rfind('/')
+        .map(|idx| (&prefix[..idx + 1], &prefix[idx + 1..]))
+        .unwrap_or(("", prefix));
+
+    let dir_to_join = (dir.len() > 1 && dir.ends_with('/'))
+        .then(|| &dir[..dir.len() - 1])
+        .unwrap_or(dir);
+
+    let target_dir = if !dir.is_empty() {
+        match root.join(dir_to_join) {
+            Ok(d) if d.is_dir().unwrap_or(false) => Some(d),
+            _ => None,
+        }
+    } else {
+        Some(root.join("").unwrap())
+    };
+
+    let mut file_suggestions = Vec::new();
+    if let Some(d) = target_dir {
+        if let Ok(iterator) = d.read_dir() {
+            let char_span = to_char_span(input, span);
+            for entry in iterator {
+                let name = entry.filename();
+                if name.starts_with(file_prefix) {
+                    let full_completion = format!("{}{}", dir, name);
+                    file_suggestions.push(Suggestion {
+                        name: full_completion.clone(),
+                        description: description.clone(),
+                        rendered: full_completion,
+                        span_start: char_span.start,
+                        span_end: char_span.end,
+                    });
+                }
+            }
+        }
+    }
+    file_suggestions
+}
+
 pub fn generate_suggestions(
     input: &str,
-    context: Option<CompletionContext>,
+    contexts: Vec<CompletionContext>,
     working_set: &StateWorkingSet,
     engine_guard: &EngineState,
     stack_guard: &Stack,
     root: &std::sync::Arc<vfs::VfsPath>,
     byte_pos: usize,
 ) -> Vec<Suggestion> {
-    console_log!("context: {context:?}");
+    console_log!("contexts: {contexts:?}");
 
-    match context {
-        Some(CompletionContext::Command {
-            prefix,
-            span,
-            parent_command,
-        }) => generate_command_suggestions(input, working_set, prefix, span, parent_command),
-        Some(CompletionContext::Argument { prefix, span }) => {
-            generate_argument_suggestions(input, prefix, span, root)
-        }
-        Some(CompletionContext::Flag {
-            prefix,
-            span,
-            command_name,
-        }) => generate_flag_suggestions(input, engine_guard, prefix, span, command_name),
-        Some(CompletionContext::CommandArgument {
-            prefix,
-            span,
-            command_name,
-            arg_index,
-        }) => generate_command_argument_suggestions(
-            input,
-            engine_guard,
-            working_set,
-            prefix,
-            span,
-            command_name,
-            arg_index,
-            root,
-        ),
-        Some(CompletionContext::Variable { prefix, span }) => {
-            generate_variable_suggestions(input, working_set, prefix, span, byte_pos)
-        }
-        Some(CompletionContext::CellPath {
-            prefix,
-            span,
-            var_id,
-            path_so_far,
-        }) => generate_cell_path_suggestions(
-            input,
-            working_set,
-            engine_guard,
-            stack_guard,
-            prefix,
-            span,
-            var_id,
-            path_so_far,
-        ),
-        _ => {
-            console_log!("[completion] Context is None, no suggestions generated");
-            Vec::new()
-        }
+    let mut suggestions = Vec::new();
+    for context in contexts {
+        let mut sug = match context {
+            CompletionContext::Command {
+                prefix,
+                span,
+                parent_command,
+            } => generate_command_suggestions(input, working_set, prefix, span, parent_command),
+            CompletionContext::Argument { prefix, span } => {
+                generate_argument_suggestions(input, prefix, span, root)
+            }
+            CompletionContext::Flag {
+                prefix,
+                span,
+                command_name,
+            } => generate_flag_suggestions(input, engine_guard, prefix, span, command_name),
+            CompletionContext::CommandArgument {
+                prefix,
+                span,
+                command_name,
+                arg_index,
+            } => generate_command_argument_suggestions(
+                input,
+                engine_guard,
+                working_set,
+                prefix,
+                span,
+                command_name,
+                arg_index,
+                root,
+            ),
+            CompletionContext::Variable { prefix, span } => {
+                generate_variable_suggestions(input, working_set, prefix, span, byte_pos)
+            }
+            CompletionContext::CellPath {
+                prefix,
+                span,
+                var_id,
+                path_so_far,
+            } => generate_cell_path_suggestions(
+                input,
+                working_set,
+                engine_guard,
+                stack_guard,
+                prefix,
+                span,
+                var_id,
+                path_so_far,
+            ),
+        };
+        suggestions.append(&mut sug);
     }
+
+    suggestions
 }

src/completion/types.rs

···
 pub struct Suggestion {
     pub name: String,
     pub description: Option<String>,
-    pub is_command: bool,
     pub rendered: String,
     pub span_start: usize, // char index (not byte)
     pub span_end: usize,   // char index (not byte)
···
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum CompletionContext {
     Command {
         prefix: String,

www/src/main.ts

···
 type Candidate = {
   name: string;
   description: string;
-  is_command: boolean;
   rendered: string;
   span_start: number;
   span_end: number;
···
     completionCandidates = matches.map((cmd) => ({
       name: cmd,
       description: "",
-      is_command: true,
       rendered: cmd,
       span_start: 0,
       span_end: currentLine.length,