Merge pull request #163 from jhult/feat/file-injection

feat(tui): `@file` injection with typeahead autocomplete

Author: Kuberwastaken

src-rust/crates/cli/src/main.rs

@@ -1947,17 +1947,22 @@ async fn run_interactive(
         app.notifications.tick();
 
         // Process file injection dialog outcome (if any)
-        if let Some((outcome, pending_input, _pending_imgs)) = app.file_injection_dialog.take_outcome() {
+        if let Some((outcome, pending_input, pending_imgs)) = app.file_injection_dialog.take_outcome() {
             use claurst_tui::FileInjectionOutcome;
 
             if matches!(outcome, FileInjectionOutcome::Abort) {
                 // Abort: input already restored to prompt by app.rs handler
                 continue;
             }
 
-            // InjectAll or SkipOversized: restore input to prompt for resubmission
-            // Images attached when dialog was shown are discarded; user can re-attach if needed
+            // InjectAll: bypass size limit on resubmission, restore stashed input+images,
+            // then synthesize Enter to send immediately.
+            app.file_injection_force = true;
+            for img in pending_imgs {
+                app.prompt_input.add_image(img);
+            }
             app.set_prompt_text(pending_input);
+            app.pending_auto_submit = true;
         }
 
         // Draw the UI
@@ -2052,6 +2057,18 @@ async fn run_interactive(
                         continue;
                     }
                     if key.code == KeyCode::Enter && !app.is_streaming && !any_dialog_open {
+                        // If a file-ref suggestion is active, accept it instead of submitting.
+                        if !app.prompt_input.suggestions.is_empty()
+                            && app.prompt_input.suggestion_index.is_some()
+                            && app.prompt_input.suggestions.get(app.prompt_input.suggestion_index.unwrap())
+                                .map(|s| s.source == claurst_tui::prompt_input::TypeaheadSource::FileRef)
+                                .unwrap_or(false)
+                        {
+                            app.prompt_input.accept_suggestion();
+                            app.prompt_input.insert_char(' ');
+                            app.refresh_prompt_input();
+                            continue;
+                        }
                         // If a slash-command suggestion is active, accept and execute immediately.
                         if !app.prompt_input.suggestions.is_empty()
                             && app.prompt_input.suggestion_index.is_some()
@@ -2430,7 +2447,7 @@ async fn run_interactive(
                         }
 
                         // Fire UserPromptSubmit hook (non-blocking)
-                        if !config.hooks.is_empty() {
+                        if !cmd_ctx.config.hooks.is_empty() {
                             let hook_ctx = claurst_core::hooks::HookContext {
                                 event: "UserPromptSubmit".to_string(),
                                 tool_name: None,
@@ -2440,7 +2457,7 @@ async fn run_interactive(
                                 session_id: Some(tool_ctx.session_id.clone()),
                             };
                             claurst_core::hooks::run_hooks(
-                                &config.hooks,
+                                &cmd_ctx.config.hooks,
                                 claurst_core::config::HookEvent::UserPromptSubmit,
                                 &hook_ctx,
                                 &tool_ctx.working_dir,
@@ -2452,27 +2469,46 @@ async fn run_interactive(
                         let pending_imgs = app.prompt_input.clear_images();
 
                         // Check for file injection if enabled
-                        if config.file_injection_enabled {
+                        if app.config.file_injection_enabled {
                             use claurst_tui::file_injection::parse_at_refs;
 
-                            let (within_limit, oversized) = parse_at_refs(&input, &tool_ctx.working_dir, config.file_injection_max_size);
+                            // file_injection_force is set when user chose "inject anyways" in the
+                            // warning dialog — pass limit 0 so all files are treated as within
+                            // limit. Also drop any directory refs silently on force re-submit so
+                            // they don't loop back to the directory warning.
+                            let was_force = app.file_injection_force;
+                            let effective_limit = if app.file_injection_force {
+                                app.file_injection_force = false;
+                                0
+                            } else {
+                                app.config.file_injection_max_size
+                            };
+                            let (within_limit, mut oversized) = parse_at_refs(&input, &tool_ctx.working_dir, effective_limit);
+                            if was_force {
+                                oversized.retain(|f| !matches!(f.issue, Some(claurst_tui::AtFileIssue::IsDirectory)));
+                            }
 
                             if !oversized.is_empty() {
-                                // Show dialog with oversized files
-                                let oversized_summaries: Vec<(String, usize, String)> = oversized
+                                // Show either the directory warning or the file warning, never both.
+                                // Directories take precedence: if any are present, show only those.
+                                let has_dirs = oversized.iter().any(|f| matches!(f.issue, Some(claurst_tui::AtFileIssue::IsDirectory)));
+                                let oversized_summaries: Vec<(String, usize, claurst_tui::AtFileIssue)> = oversized
                                     .iter()
-                                    .map(|f| {
-                                        let issue_str = match &f.issue {
-                                            Some(claurst_tui::AtFileIssue::TooLarge(kb)) => format!("TooLarge: {} KB", kb),
-                                            Some(claurst_tui::AtFileIssue::Binary) => "Binary".to_string(),
-                                            Some(claurst_tui::AtFileIssue::Unreadable(e)) => e.clone(),
-                                            None => "Unknown".to_string(),
-                                        };
-                                        (f.path.display().to_string(), f.size_kb, issue_str)
+                                    .filter(|f| {
+                                        let is_dir = matches!(f.issue, Some(claurst_tui::AtFileIssue::IsDirectory));
+                                        if has_dirs { is_dir } else { !is_dir }
                                     })
+                                    .filter_map(|f| f.issue.clone().map(|issue| (f.path.display().to_string(), f.size_kb, issue)))
                                     .collect();
 
-                                app.file_injection_dialog.show(input.clone(), pending_imgs, oversized_summaries);
+                                app.file_injection_dialog.show(
+                                    input.clone(),
+                                    pending_imgs,
+                                    oversized_summaries,
+                                    app.config.file_injection_max_size,
+                                    Some(tool_ctx.working_dir.clone()),
+                                );
+                                app.set_prompt_text(input);
                                 continue;
                             }
 

src-rust/crates/core/src/lib.rs

@@ -1558,11 +1558,22 @@ pub mod config {
                     config.skills.urls.push(u.clone());
                 }
             }
-            // Copy file autocomplete and injection settings.
-            config.file_autocomplete_limit = self.file_autocomplete_limit;
-            config.file_autocomplete_show_hidden_files = self.file_autocomplete_show_hidden_files;
-            config.file_injection_enabled = self.file_injection_enabled;
-            config.file_injection_max_size = self.file_injection_max_size;
+            // Copy file autocomplete and injection settings from the top-level Settings
+            // fields, but only when they were explicitly set (differ from their defaults).
+            // If they're at defaults, the nested "config" section value (already in `config`
+            // via the clone above) takes precedence.
+            if self.file_autocomplete_limit != default_file_autocomplete_limit() {
+                config.file_autocomplete_limit = self.file_autocomplete_limit;
+            }
+            if self.file_autocomplete_show_hidden_files {
+                config.file_autocomplete_show_hidden_files = true;
+            }
+            if self.file_injection_enabled != default_true() {
+                config.file_injection_enabled = self.file_injection_enabled;
+            }
+            if self.file_injection_max_size != default_file_injection_max_size() {
+                config.file_injection_max_size = self.file_injection_max_size;
+            }
             config
         }
 

src-rust/crates/tui/src/app.rs

@@ -889,6 +889,9 @@ pub struct App {
     /// File injection warning dialog.
     /// Shown when oversized or binary files are detected in @refs.
     pub file_injection_dialog: crate::file_injection_dialog::FileInjectionDialogState,
+    /// When true, the next file injection size check uses limit 0 (no limit),
+    /// letting files that were "allowed" through the warning dialog be injected.
+    pub file_injection_force: bool,
     /// First-launch onboarding welcome dialog.
     pub onboarding_dialog: crate::onboarding_dialog::OnboardingDialogState,
     /// Effort-level picker (/effort with no args).
@@ -1340,6 +1343,7 @@ impl App {
             bypass_permissions_dialog: crate::bypass_permissions_dialog::BypassPermissionsDialogState::new(),
             bypass_permissions_dialog_shown: false,
             file_injection_dialog: crate::file_injection_dialog::FileInjectionDialogState::new(),
+            file_injection_force: false,
             onboarding_dialog: crate::onboarding_dialog::OnboardingDialogState::new(),
             effort_picker: crate::effort_picker::EffortPickerState::new(),
             key_input_dialog: crate::key_input_dialog::KeyInputDialogState::new(),
@@ -2647,9 +2651,16 @@ impl App {
         self.history_index = self.prompt_input.history_pos;
     }
 
-    fn refresh_prompt_input(&mut self) {
+    pub fn refresh_prompt_input(&mut self) {
         self.prompt_input.mode = self.prompt_mode();
-        self.prompt_input.update_suggestions(PROMPT_SLASH_COMMANDS);
+        if self.file_injection_dialog.visible {
+            // Don't update suggestions while the injection dialog is open.
+            self.sync_legacy_prompt_fields();
+            return;
+        }
+        let file_autocomplete_limit = self.config.file_autocomplete_limit;
+        let file_autocomplete_show_hidden = self.config.file_autocomplete_show_hidden_files;
+        self.prompt_input.update_suggestions(PROMPT_SLASH_COMMANDS, file_autocomplete_limit, file_autocomplete_show_hidden);
         self.sync_legacy_prompt_fields();
     }
 
@@ -2882,25 +2893,27 @@ impl App {
 
         // File injection dialog: shown when oversized files are detected in @refs.
         if self.file_injection_dialog.visible {
+            let is_directory_only = self.file_injection_dialog.is_directory_only();
             match key.code {
-                KeyCode::Char('i') | KeyCode::Char('I') => {
-                    self.file_injection_dialog.selected = 0; // InjectAll
-                }
-                KeyCode::Char('s') | KeyCode::Char('S') => {
-                    self.file_injection_dialog.selected = 1; // SkipOversized
+                KeyCode::Enter => {
+                    if is_directory_only {
+                        // Directories can't be injected; Enter = abort, restore input.
+                        if let Some(input) = self.file_injection_dialog.pending_input.clone() {
+                            self.set_prompt_text(input);
+                        }
+                        self.file_injection_dialog.dismiss();
+                    } else {
+                        // Enter = inject (Allow).
+                        self.file_injection_dialog.selected = 0;
+                        self.file_injection_dialog.confirm();
+                    }
                 }
                 KeyCode::Esc => {
-                    self.file_injection_dialog.selected = 2; // Abort
-                    self.file_injection_dialog.confirm();
-                    // Restore input to prompt when aborting
-                    if let Some(input) = &self.file_injection_dialog.pending_input {
-                        self.set_prompt_text(input.clone());
+                    // Esc = abort, restore input.
+                    if let Some(input) = self.file_injection_dialog.pending_input.clone() {
+                        self.set_prompt_text(input);
                     }
-                }
-                KeyCode::Up | KeyCode::Char('k') => self.file_injection_dialog.select_prev(),
-                KeyCode::Down | KeyCode::Char('j') => self.file_injection_dialog.select_next(),
-                KeyCode::Enter => {
-                    self.file_injection_dialog.confirm();
+                    self.file_injection_dialog.dismiss();
                 }
                 _ => {}
             }
@@ -4171,12 +4184,17 @@ impl App {
                 self.refresh_prompt_input();
             }
             KeyCode::Enter if !self.is_streaming => {
-                // If a slash-command suggestion is selected, accept it instead of submitting.
+                // If a suggestion is selected, accept it instead of submitting.
                 if !self.prompt_input.suggestions.is_empty()
                     && self.prompt_input.suggestion_index.is_some()
-                    && self.prompt_input.text.starts_with('/')
                 {
+                    let is_file_ref = self.prompt_input.suggestions
+                        .get(self.prompt_input.suggestion_index.unwrap())
+                        .map_or(false, |s| s.source == crate::prompt_input::TypeaheadSource::FileRef);
                     self.prompt_input.accept_suggestion();
+                    if is_file_ref {
+                        self.prompt_input.insert_char(' ');
+                    }
                     self.refresh_prompt_input();
                     return false;
                 }
@@ -4209,7 +4227,7 @@ impl App {
             // when the cursor is already on the first/last visual row
             // (issue #149 follow-up).
             KeyCode::Up => {
-                if !self.prompt_input.suggestions.is_empty() && self.prompt_input.text.starts_with('/') {
+                if !self.prompt_input.suggestions.is_empty() && (self.prompt_input.text.starts_with('/') || self.prompt_input.has_active_file_ref()) {
                     self.prompt_input.suggestion_prev();
                 } else {
                     let area = self.last_input_area.get();
@@ -4223,7 +4241,7 @@ impl App {
                 self.refresh_prompt_input();
             }
             KeyCode::Down => {
-                if !self.prompt_input.suggestions.is_empty() && self.prompt_input.text.starts_with('/') {
+                if !self.prompt_input.suggestions.is_empty() && (self.prompt_input.text.starts_with('/') || self.prompt_input.has_active_file_ref()) {
                     self.prompt_input.suggestion_next();
                 } else {
                     let area = self.last_input_area.get();
@@ -4673,29 +4691,53 @@ impl App {
                 self.refresh_global_search();
                 false
             }
-            "submit" => !self.is_streaming,
+            "submit" => {
+                if !self.is_streaming {
+                    if !self.prompt_input.suggestions.is_empty()
+                        && self.prompt_input.suggestion_index.is_some()
+                    {
+                        self.prompt_input.accept_suggestion();
+                        self.refresh_prompt_input();
+                        false
+                    } else {
+                        true
+                    }
+                } else {
+                    false
+                }
+            }
             "historyPrev" => {
-                // Slash-command suggestions take priority over history.
+                // Suggestions (slash commands or file refs) take priority over cursor/history.
                 if !self.prompt_input.suggestions.is_empty()
-                    && self.prompt_input.text.starts_with('/')
+                    && (self.prompt_input.text.starts_with('/') || self.prompt_input.has_active_file_ref())
                 {
                     self.prompt_input.suggestion_prev();
                     self.refresh_prompt_input();
-                } else if !self.prompt_input.history.is_empty() {
-                    self.prompt_input.history_up();
+                } else {
+                    let width = self.last_input_area.get().width.saturating_sub(4) as usize;
+                    let moved = !self.prompt_input.text.is_empty()
+                        && self.prompt_input.move_visual_up(width);
+                    if !moved && !self.prompt_input.history.is_empty() {
+                        self.prompt_input.history_up();
+                    }
                     self.refresh_prompt_input();
                 }
                 false
             }
             "historyNext" => {
-                // Slash-command suggestions take priority over history.
+                // Suggestions (slash commands or file refs) take priority over cursor/history.
                 if !self.prompt_input.suggestions.is_empty()
-                    && self.prompt_input.text.starts_with('/')
+                    && (self.prompt_input.text.starts_with('/') || self.prompt_input.has_active_file_ref())
                 {
                     self.prompt_input.suggestion_next();
                     self.refresh_prompt_input();
-                } else if self.prompt_input.history_pos.is_some() {
-                    self.prompt_input.history_down();
+                } else {
+                    let width = self.last_input_area.get().width.saturating_sub(4) as usize;
+                    let moved = !self.prompt_input.text.is_empty()
+                        && self.prompt_input.move_visual_down(width);
+                    if !moved && self.prompt_input.history_pos.is_some() {
+                        self.prompt_input.history_down();
+                    }
                     self.refresh_prompt_input();
                 }
                 false