autocomplete to suggestions

2025-08-07 12:08:02 +02:00
parent 96cde3ca0d
commit dff320d534
20 changed files with 199 additions and 198 deletions
--- a/canvas/CANVAS_MIGRATION.md
+++ b/canvas/CANVAS_MIGRATION.md
@@ -2,7 +2,7 @@

 ## Overview

-This guide covers the migration from the legacy canvas library structure to the new clean, modular architecture. The new design separates core canvas functionality from autocomplete features, providing better type safety and maintainability.
+This guide covers the migration from the legacy canvas library structure to the new clean, modular architecture. The new design separates core canvas functionality from suggestions features, providing better type safety and maintainability.

 ## Key Changes

@@ -10,7 +10,7 @@ This guide covers the migration from the legacy canvas library structure to the
 ```
 # Old Structure (LEGACY)
 src/
-├── state.rs              # Mixed canvas + autocomplete
+├── state.rs              # Mixed canvas + suggestions
 ├── actions/edit.rs       # Mixed concerns
 ├── gui/render.rs         # Everything together
 └── suggestions.rs        # Legacy file
@@ -21,9 +21,9 @@ src/
 │   ├── state.rs         # CanvasState trait only
 │   ├── actions/edit.rs  # Canvas actions only
 │   └── gui.rs           # Canvas rendering
-├── autocomplete/         # Rich autocomplete features
-│   ├── state.rs         # AutocompleteCanvasState trait
-│   ├── types.rs         # SuggestionItem, AutocompleteState
+├── suggestions/         # Suggestions dropdown features (not inline autocomplete)
+│   ├── state.rs         # Suggestion provider types
+│   ├── gui.rs           # Suggestions dropdown rendering
 │   ├── actions.rs       # Autocomplete actions
 │   └── gui.rs           # Autocomplete dropdown rendering
 └── dispatcher.rs         # Action routing
@@ -31,7 +31,7 @@ src/

 ### 2. **Trait Separation**
 - **CanvasState**: Core form functionality (navigation, input, validation)
- **AutocompleteCanvasState**: Optional rich autocomplete features
+- Suggestions module: Optional dropdown suggestions support

 ### 3. **Rich Suggestions**
 Replaced simple string suggestions with typed, rich suggestion objects.
@@ -93,34 +93,29 @@ impl CanvasState for YourFormState {

 ### Step 3: Implement Rich Autocomplete (Optional)

-**If you want rich autocomplete features:**
+**If you want suggestions dropdown features:**

 ```rust
-use canvas::autocomplete::{AutocompleteCanvasState, SuggestionItem, AutocompleteState};
+use canvas::{SuggestionItem};

-impl AutocompleteCanvasState for YourFormState {
-    type SuggestionData = YourDataType; // e.g., Hit, CustomRecord, etc.
-
-    fn supports_autocomplete(&self, field_index: usize) -> bool {
-        // Define which fields support autocomplete
+impl YourFormState {
+    fn supports_suggestions(&self, field_index: usize) -> bool {
+        // Define which fields support suggestions
        matches!(field_index, 2 | 3 | 5) // Example: only certain fields
    }

-    fn autocomplete_state(&self) -> Option<&AutocompleteState<Self::SuggestionData>> {
-        Some(&self.autocomplete)
-    }
+    // Manage your own suggestion state or rely on FormEditor APIs

-    fn autocomplete_state_mut(&mut self) -> Option<&mut AutocompleteState<Self::SuggestionData>> {
-        Some(&mut self.autocomplete)
-    }
+    // Manage your own suggestion state or rely on FormEditor APIs
 }
 ```

-**Add autocomplete field to your state:**
+**Add suggestions storage to your state (optional, if you need to persist outside the editor):**
 ```rust
 pub struct YourFormState {
    // ... existing fields
-    pub autocomplete: AutocompleteState<YourDataType>,
+    // Optional: your own suggestions cache if needed
+    // pub suggestion_cache: Vec<SuggestionItem>,
 }
 ```

@@ -149,9 +144,9 @@ form_state.set_autocomplete_suggestions(suggestions);

 **Old rendering:**
 ```rust
-// Manual autocomplete rendering
-if form_state.autocomplete_active {
-    render_autocomplete_dropdown(/* ... */);
+// Manual suggestions rendering
+if editor.is_suggestions_active() {
+    suggestions::gui::render_suggestions_dropdown(/* ... */);
 }
 ```

@@ -162,13 +157,12 @@ use canvas::canvas::render_canvas;

 let active_field_rect = render_canvas(f, area, form_state, theme, edit_mode, highlight_state);

-// Optional: Rich autocomplete (if implementing AutocompleteCanvasState)
-if form_state.is_autocomplete_active() {
-    if let Some(autocomplete_state) = form_state.autocomplete_state() {
-        canvas::autocomplete::render_autocomplete_dropdown(
-            f, f.area(), active_field_rect.unwrap(), theme, autocomplete_state
-        );
-    }
+// Suggestions dropdown (if active)
+if editor.is_suggestions_active() {
+    canvas::suggestions::render_suggestions_dropdown(
+        f, f.area(), active_field_rect.unwrap(), theme, &editor
+    );
+}
 }
 ```

@@ -181,16 +175,16 @@ form_state.deactivate_suggestions();

 # NEW - Option A: Add your own method
 impl YourFormState {
-    pub fn deactivate_autocomplete(&mut self) {
+    pub fn deactivate_suggestions(&mut self) {
        self.autocomplete_active = false;
        self.autocomplete_suggestions.clear();
        self.selected_suggestion_index = None;
    }
 }
-form_state.deactivate_autocomplete();
+editor.ui_state_mut().deactivate_suggestions();

-# NEW - Option B: Use rich autocomplete trait
-form_state.deactivate_autocomplete(); // If implementing AutocompleteCanvasState
+# NEW - Option B: Suggestions via editor APIs
+editor.ui_state_mut().deactivate_suggestions();
 ```

 ## Benefits of New Architecture
@@ -217,8 +211,8 @@ let suggestions: Vec<SuggestionItem<UserRecord>> = vec![
 - **Display Overrides**: Show friendly text while storing normalized data

 ### 4. **Future-Proof**
- Easy to add new autocomplete features
- Canvas features don't interfere with autocomplete
+- Easy to add new suggestion features
+- Canvas features don't interfere with suggestions
 - Modular: Use only what you need

 ## Advanced Features
@@ -262,7 +256,7 @@ SuggestionItem::new(user, "John Doe (Manager)".to_string(), "123".to_string());
 ## Breaking Changes Summary

 1. **Import paths changed**: Add `canvas::` or `dispatcher::` prefixes
-2. **Legacy suggestion methods removed**: Replace with rich autocomplete or custom methods
+2. **Legacy suggestion methods removed**: Replace with SuggestionItem-based dropdown or custom methods
 3. **No more simple suggestions**: Use `SuggestionItem` for typed suggestions
 4. **Trait split**: `AutocompleteCanvasState` is now separate and optional

@@ -283,11 +277,11 @@ SuggestionItem::new(user, "John Doe (Manager)".to_string(), "123".to_string());

 - [ ] Updated all import paths
 - [ ] Removed legacy methods from CanvasState implementation
- [ ] Added custom autocomplete methods if needed
- [ ] Updated suggestion usage to SuggestionItem
+- [ ] Added custom suggestion methods if needed
+- [ ] Updated usage to SuggestionItem
 - [ ] Updated rendering calls
 - [ ] Tested form functionality
- [ ] Tested autocomplete functionality (if using)
+- [ ] Tested suggestions functionality (if using)

 ## Example: Complete Migration

@@ -305,29 +299,25 @@ impl CanvasState for FormState {
 **After:**
 ```rust
 use canvas::canvas::{CanvasState, CanvasAction};
-use canvas::autocomplete::{AutocompleteCanvasState, SuggestionItem};
+use canvas::SuggestionItem;

 impl CanvasState for FormState {
-    // Only core canvas methods, no suggestion methods
+    // Only core canvas methods
    fn current_field(&self) -> usize { /* ... */ }
    fn get_current_input(&self) -> &str { /* ... */ }
    // ... other core methods only
 }

-impl AutocompleteCanvasState for FormState {
+// Use FormEditor + SuggestionsProvider for suggestions dropdown
    type SuggestionData = Hit;
    
-    fn supports_autocomplete(&self, field_index: usize) -> bool {
+    fn supports_suggestions(&self, field_index: usize) -> bool {
        self.fields[field_index].is_link
    }
    
-    fn autocomplete_state(&self) -> Option<&AutocompleteState<Self::SuggestionData>> {
-        Some(&self.autocomplete)
-    }
+    // Maintain suggestion state through FormEditor and DataProvider
    
-    fn autocomplete_state_mut(&mut self) -> Option<&mut AutocompleteState<Self::SuggestionData>> {
-        Some(&mut self.autocomplete)
-    }
+    // Maintain suggestion state through FormEditor and DataProvider
 }
 ```

--- a/canvas/Cargo.toml
+++ b/canvas/Cargo.toml
@@ -30,15 +30,15 @@ tokio-test = "0.4.4"

 [features]
 default = []
-gui = ["ratatui"]
-autocomplete = ["tokio"]
+gui = ["ratatui", "crossterm"]
+suggestions = ["tokio"]
 cursor-style = ["crossterm"]
 validation = ["regex"]

 [[example]]
-name = "autocomplete"
-required-features = ["autocomplete", "gui"]
-path = "examples/autocomplete.rs"
+name = "suggestions"
+required-features = ["suggestions", "gui", "cursor-style"]
+path = "examples/suggestions.rs"

 [[example]]
 name = "canvas_gui_demo"
@@ -48,3 +48,19 @@ path = "examples/canvas_gui_demo.rs"
 [[example]]
 name = "validation_1"
 required-features = ["gui", "validation"]
+
+[[example]]
+name = "validation_2"
+required-features = ["gui", "validation"]
+
+[[example]]
+name = "validation_3"
+required-features = ["gui", "validation"]
+
+[[example]]
+name = "validation_4"
+required-features = ["gui", "validation"]
+
+[[example]]
+name = "validation_5"
+required-features = ["gui", "validation"]
--- a/canvas/README.md
+++ b/canvas/README.md
@@ -7,7 +7,7 @@ A reusable, type-safe canvas system for building form-based TUI applications wit
 - **Type-Safe Actions**: No more string-based action names - everything is compile-time checked
 - **Generic Design**: Implement `CanvasState` once, get navigation, editing, and suggestions for free
 - **Vim-Like Experience**: Modal editing with familiar keybindings
- **Suggestion System**: Built-in autocomplete and suggestions support
+- **Suggestion System**: Built-in suggestions dropdown support
 - **Framework Agnostic**: Works with any TUI framework or raw terminal handling
 - **Async Ready**: Full async/await support for modern Rust applications
 - **Batch Operations**: Execute multiple actions atomically
@@ -144,7 +144,7 @@ pub enum CanvasAction {

 ## 🔧 Advanced Features

-### Suggestions and Autocomplete
+### Suggestions Dropdown (not inline autocomplete)

 ```rust
 impl CanvasState for MyForm {
@@ -170,7 +170,7 @@ impl CanvasState for MyForm {
            CanvasAction::SelectSuggestion => {
                if let Some(suggestion) = self.suggestions.get_selected() {
                    *self.get_current_input_mut() = suggestion.clone();
-                    self.deactivate_autocomplete();
+                    self.deactivate_suggestions();
                    Some("Applied suggestion".to_string())
                }
                None
--- a/canvas/examples/canvas_cursor_auto.rs
+++ b/canvas/examples/canvas_cursor_auto.rs
@@ -346,7 +346,7 @@ impl DataProvider for CursorDemoData {
        self.fields[index].1 = value;
    }

-    fn supports_autocomplete(&self, _field_index: usize) -> bool {
+    fn supports_suggestions(&self, _field_index: usize) -> bool {
        false
    }

--- a/canvas/examples/full_canvas_demo.rs
+++ b/canvas/examples/full_canvas_demo.rs
@@ -345,7 +345,7 @@ impl DataProvider for FullDemoData {
        self.fields[index].1 = value;
    }

-    fn supports_autocomplete(&self, _field_index: usize) -> bool {
+    fn supports_suggestions(&self, _field_index: usize) -> bool {
        false
    }

--- a/canvas/examples/autocomplete.rs
+++ b/canvas/examples/autocomplete.rs
@@ -1,5 +1,5 @@
-// examples/autocomplete.rs
-// Run with: cargo run --example autocomplete --features "autocomplete,gui"
+// examples/suggestions.rs
+// Run with: cargo run --example suggestions --features "suggestions,gui"

 use std::io;
 use crossterm::{
@@ -22,8 +22,8 @@ use canvas::{
        modes::AppMode,
        theme::CanvasTheme,
    },
-    autocomplete::gui::render_autocomplete_dropdown,
-    FormEditor, DataProvider, AutocompleteProvider, SuggestionItem,
+    suggestions::gui::render_suggestions_dropdown,
+    FormEditor, DataProvider, SuggestionsProvider, SuggestionItem,
 };

 use async_trait::async_trait;
@@ -108,7 +108,7 @@ impl DataProvider for ContactForm {
        }
    }
    
-    fn supports_autocomplete(&self, field_index: usize) -> bool {
+    fn supports_suggestions(&self, field_index: usize) -> bool {
        field_index == 1 // Only email field
    }
 }
@@ -120,11 +120,9 @@ impl DataProvider for ContactForm {
 struct EmailAutocomplete;

 #[async_trait]
-impl AutocompleteProvider for EmailAutocomplete {
-    type SuggestionData = EmailSuggestion;
-    
+impl SuggestionsProvider for EmailAutocomplete {
    async fn fetch_suggestions(&mut self, _field_index: usize, query: &str) 
-        -> Result<Vec<SuggestionItem<Self::SuggestionData>>> 
+        -> Result<Vec<SuggestionItem>> 
    {
        // Extract domain part from email
        let (email_prefix, domain_part) = if let Some(at_pos) = query.find('@') {
@@ -153,10 +151,6 @@ impl AutocompleteProvider for EmailAutocomplete {
                if domain.starts_with(&domain_part) || domain_part.is_empty() {
                    let full_email = format!("{}@{}", email_prefix, domain);
                    results.push(SuggestionItem {
-                        data: EmailSuggestion {
-                            email: full_email.clone(),
-                            provider: provider.to_string(),
-                        },
                        display_text: format!("{} ({})", full_email, provider),
                        value_to_store: full_email,
                    });
@@ -175,7 +169,7 @@ impl AutocompleteProvider for EmailAutocomplete {

 struct AppState {
    editor: FormEditor<ContactForm>,
-    autocomplete: EmailAutocomplete,
+    suggestions_provider: EmailAutocomplete,
    debug_message: String,
 }

@@ -190,8 +184,8 @@ impl AppState {
        
        Self {
            editor,
-            autocomplete: EmailAutocomplete,
-            debug_message: "Type in email field, Tab to trigger autocomplete, Enter to select, Esc to cancel".to_string(),
+            suggestions_provider: EmailAutocomplete,
+            debug_message: "Type in email field, Tab to trigger suggestions, Enter to select, Esc to cancel".to_string(),
        }
    }
 }
@@ -207,14 +201,14 @@ async fn handle_key_press(key: KeyCode, modifiers: KeyModifiers, state: &mut App

    // Handle input based on key
    let result = match key {
-        // === AUTOCOMPLETE KEYS ===
+        // === SUGGESTIONS KEYS ===
        KeyCode::Tab => {
-            if state.editor.is_autocomplete_active() {
-                state.editor.autocomplete_next();
+            if state.editor.is_suggestions_active() {
+                state.editor.suggestions_next();
                Ok("Navigated to next suggestion".to_string())
-            } else if state.editor.data_provider().supports_autocomplete(state.editor.current_field()) {
-                state.editor.trigger_autocomplete(&mut state.autocomplete).await
-                    .map(|_| "Triggered autocomplete".to_string())
+            } else if state.editor.data_provider().supports_suggestions(state.editor.current_field()) {
+                state.editor.trigger_suggestions(&mut state.suggestions_provider).await
+                    .map(|_| "Triggered suggestions".to_string())
            } else {
                state.editor.move_to_next_field();
                Ok("Moved to next field".to_string())
@@ -222,8 +216,8 @@ async fn handle_key_press(key: KeyCode, modifiers: KeyModifiers, state: &mut App
        }

        KeyCode::Enter => {
-            if state.editor.is_autocomplete_active() {
-                if let Some(applied) = state.editor.apply_autocomplete() {
+            if state.editor.is_suggestions_active() {
+                if let Some(applied) = state.editor.apply_suggestion() {
                    Ok(format!("Applied: {}", applied))
                } else {
                    Ok("No suggestion to apply".to_string())
@@ -235,9 +229,9 @@ async fn handle_key_press(key: KeyCode, modifiers: KeyModifiers, state: &mut App
        }

        KeyCode::Esc => {
-            if state.editor.is_autocomplete_active() {
-                // Autocomplete will be cleared automatically by mode change
-                Ok("Cancelled autocomplete".to_string())
+            if state.editor.is_suggestions_active() {
+                // Suggestions will be cleared automatically by mode change
+                Ok("Cancelled suggestions".to_string())
            } else {
                // Toggle between edit and readonly mode
                let new_mode = match state.editor.mode() {
@@ -324,9 +318,9 @@ fn ui(f: &mut Frame, state: &AppState, theme: &DemoTheme) {
        theme,
    );

-    // Render autocomplete dropdown if active
+    // Render suggestions dropdown if active
    if let Some(input_rect) = active_field_rect {
-        render_autocomplete_dropdown(
+        render_suggestions_dropdown(
            f,
            chunks[0],
            input_rect,
@@ -336,8 +330,8 @@ fn ui(f: &mut Frame, state: &AppState, theme: &DemoTheme) {
    }

    // Status info
-    let autocomplete_status = if state.editor.is_autocomplete_active() {
-        if state.editor.ui_state().is_autocomplete_loading() {
+    let autocomplete_status = if state.editor.is_suggestions_active() {
+        if state.editor.ui_state().is_suggestions_loading() {
            "Loading suggestions..."
        } else if !state.editor.suggestions().is_empty() {
            "Use Tab to navigate, Enter to select, Esc to cancel"
@@ -345,7 +339,7 @@ fn ui(f: &mut Frame, state: &AppState, theme: &DemoTheme) {
            "No suggestions found"
        }
    } else {
-        "Tab to trigger autocomplete"
+        "Tab to trigger suggestions"
    };

    let status_lines = vec![
@@ -354,9 +348,9 @@ fn ui(f: &mut Frame, state: &AppState, theme: &DemoTheme) {
            state.editor.current_field() + 1, 
            state.editor.data_provider().field_count(), 
            state.editor.cursor_position()))),
-        Line::from(Span::raw(format!("Autocomplete: {}", autocomplete_status))),
+        Line::from(Span::raw(format!("Suggestions: {}", autocomplete_status))),
        Line::from(Span::raw(state.debug_message.clone())),
-        Line::from(Span::raw("F10: Quit | Tab: Trigger/Navigate autocomplete | Enter: Select | Esc: Cancel/Toggle mode")),
+        Line::from(Span::raw("F10: Quit | Tab: Trigger/Navigate suggestions | Enter: Select | Esc: Cancel/Toggle mode")),
    ];

    let status = Paragraph::new(status_lines)
--- a/canvas/examples/validation_1.rs
+++ b/canvas/examples/validation_1.rs
@@ -447,7 +447,7 @@ impl DataProvider for ValidationDemoData {
        self.fields[index].1 = value;
    }

-    fn supports_autocomplete(&self, _field_index: usize) -> bool {
+    fn supports_suggestions(&self, _field_index: usize) -> bool {
        false
    }

--- a/canvas/examples/validation_5.rs
+++ b/canvas/examples/validation_5.rs
@@ -848,21 +848,21 @@ fn run_app<B: Backend>(
                (_, KeyCode::Tab, _) => editor.next_field(),
                (_, KeyCode::BackTab, _) => editor.prev_field(),

-                // Validation commands
-                (_, KeyCode::Char('v'), _) => {
+                // Validation commands (ONLY in ReadOnly mode)
+                (AppMode::ReadOnly, KeyCode::Char('v'), _) => {
                    let field = editor.current_field();
                    editor.validate_field(field);
                },
-                (_, KeyCode::Char('V'), _) => editor.validate_all_fields(),
-                (_, KeyCode::Char('c'), _) => {
+                (AppMode::ReadOnly, KeyCode::Char('V'), _) => editor.validate_all_fields(),
+                (AppMode::ReadOnly, KeyCode::Char('c'), _) => {
                    let field = editor.current_field();
                    editor.clear_validation_state(Some(field));
                },
-                (_, KeyCode::Char('C'), _) => editor.clear_validation_state(None),
+                (AppMode::ReadOnly, KeyCode::Char('C'), _) => editor.clear_validation_state(None),

-                // UI toggles
-                (_, KeyCode::Char('r'), _) => editor.toggle_history_view(),
-                (_, KeyCode::Char('e'), _) => editor.cycle_examples(),
+                // UI toggles (ONLY in ReadOnly mode for alpha keys to avoid blocking text input)
+                (AppMode::ReadOnly, KeyCode::Char('r'), _) => editor.toggle_history_view(),
+                (AppMode::ReadOnly, KeyCode::Char('e'), _) => editor.cycle_examples(),
                (_, KeyCode::F(1), _) => editor.toggle_validation(),

                // Editing
--- a/canvas/src/autocomplete/mod.rs
+++ b/canvas/src/autocomplete/mod.rs
@@ -1,12 +0,0 @@
-// src/autocomplete/mod.rs
-
-pub mod state;
-#[cfg(feature = "gui")]
-pub mod gui;
-
-// Re-export the main autocomplete types
-pub use state::{AutocompleteProvider, SuggestionItem};
-
-// Re-export GUI functions if available
-#[cfg(feature = "gui")]
-pub use gui::render_autocomplete_dropdown;
--- a/canvas/src/autocomplete/state.rs
+++ b/canvas/src/autocomplete/state.rs
@@ -1,5 +0,0 @@
-// src/autocomplete/state.rs
-//! Autocomplete provider types
-
-// Re-export the main types from data_provider
-pub use crate::data_provider::{AutocompleteProvider, SuggestionItem};
--- a/canvas/src/canvas/actions/types.rs
+++ b/canvas/src/canvas/actions/types.rs
@@ -30,12 +30,12 @@ pub enum CanvasAction {
    DeleteBackward,
    DeleteForward,

-    // Autocomplete actions
-    TriggerAutocomplete,
-    SuggestionUp,
-    SuggestionDown,
-    SelectSuggestion,
-    ExitSuggestions,
+    // Suggestions actions
+        TriggerSuggestions,
+        SuggestionUp,
+        SuggestionDown,
+        SelectSuggestion,
+        ExitSuggestions,

    // Custom actions
    Custom(String),
@@ -101,7 +101,7 @@ impl CanvasAction {
            Self::InsertChar(_c) => "insert character",
            Self::DeleteBackward => "delete backward",
            Self::DeleteForward => "delete forward",
-            Self::TriggerAutocomplete => "trigger autocomplete",
+            Self::TriggerSuggestions => "trigger suggestions",
            Self::SuggestionUp => "suggestion up",
            Self::SuggestionDown => "suggestion down",
            Self::SelectSuggestion => "select suggestion",
@@ -139,10 +139,10 @@ impl CanvasAction {
        ]
    }

-    /// Get all autocomplete-related actions
-    pub fn autocomplete_actions() -> Vec<CanvasAction> {
+    /// Get all suggestions-related actions
+    pub fn suggestions_actions() -> Vec<CanvasAction> {
        vec![
-            Self::TriggerAutocomplete,
+            Self::TriggerSuggestions,
            Self::SuggestionUp,
            Self::SuggestionDown,
            Self::SelectSuggestion,
--- a/canvas/src/canvas/gui.rs
+++ b/canvas/src/canvas/gui.rs
@@ -19,7 +19,7 @@ use crate::editor::FormEditor;
 #[cfg(feature = "gui")]
 use std::cmp::{max, min};

-/// Render ONLY the canvas form fields - no autocomplete
+/// Render ONLY the canvas form fields - no suggestions rendering here
 /// Updated to work with FormEditor instead of CanvasState trait
 #[cfg(feature = "gui")]
 pub fn render_canvas<T: CanvasTheme, D: DataProvider>(
--- a/canvas/src/canvas/state.rs
+++ b/canvas/src/canvas/state.rs
@@ -14,8 +14,8 @@ pub struct EditorState {
    // Mode state
    pub(crate) current_mode: AppMode,

-    // Autocomplete state
-    pub(crate) autocomplete: AutocompleteUIState,
+    // Suggestions dropdown state
+    pub(crate) suggestions: SuggestionsUIState,

    // Selection state (for vim visual mode)
    pub(crate) selection: SelectionState,
@@ -26,7 +26,7 @@ pub struct EditorState {
 }

 #[derive(Debug, Clone)]
-pub struct AutocompleteUIState {
+pub struct SuggestionsUIState {
    pub(crate) is_active: bool,
    pub(crate) is_loading: bool,
    pub(crate) selected_index: Option<usize>,
@@ -47,7 +47,7 @@ impl EditorState {
            cursor_pos: 0,
            ideal_cursor_column: 0,
            current_mode: AppMode::Edit,
-            autocomplete: AutocompleteUIState {
+            suggestions: SuggestionsUIState {
                is_active: false,
                is_loading: false,
                selected_index: None,
@@ -83,14 +83,14 @@ impl EditorState {
        self.current_mode
    }

-    /// Check if autocomplete is active (for user's business logic)
-    pub fn is_autocomplete_active(&self) -> bool {
-        self.autocomplete.is_active
+    /// Check if suggestions dropdown is active (for user's business logic)
+    pub fn is_suggestions_active(&self) -> bool {
+        self.suggestions.is_active
    }

-    /// Check if autocomplete is loading (for user's business logic)
-    pub fn is_autocomplete_loading(&self) -> bool {
-        self.autocomplete.is_loading
+    /// Check if suggestions dropdown is loading (for user's business logic)
+    pub fn is_suggestions_loading(&self) -> bool {
+        self.suggestions.is_loading
    }

    /// Get selection state (for user's business logic)
@@ -128,18 +128,18 @@ impl EditorState {
        self.ideal_cursor_column = self.cursor_pos;
    }

-    pub(crate) fn activate_autocomplete(&mut self, field_index: usize) {
-        self.autocomplete.is_active = true;
-        self.autocomplete.is_loading = true;
-        self.autocomplete.active_field = Some(field_index);
-        self.autocomplete.selected_index = None;
+    pub(crate) fn activate_suggestions(&mut self, field_index: usize) {
+        self.suggestions.is_active = true;
+        self.suggestions.is_loading = true;
+        self.suggestions.active_field = Some(field_index);
+        self.suggestions.selected_index = None;
    }

-    pub(crate) fn deactivate_autocomplete(&mut self) {
-        self.autocomplete.is_active = false;
-        self.autocomplete.is_loading = false;
-        self.autocomplete.active_field = None;
-        self.autocomplete.selected_index = None;
+    pub(crate) fn deactivate_suggestions(&mut self) {
+        self.suggestions.is_active = false;
+        self.suggestions.is_loading = false;
+        self.suggestions.active_field = None;
+        self.suggestions.selected_index = None;
    }
 }

--- a/canvas/src/data_provider.rs
+++ b/canvas/src/data_provider.rs
@@ -18,8 +18,8 @@ pub trait DataProvider {
    /// Set field value (library calls this when text changes)
    fn set_field_value(&mut self, index: usize, value: String);

-    /// Check if field supports autocomplete (optional)
-    fn supports_autocomplete(&self, _field_index: usize) -> bool {
+    /// Check if field supports suggestions (optional)
+    fn supports_suggestions(&self, _field_index: usize) -> bool {
        false
    }

@@ -36,10 +36,10 @@ pub trait DataProvider {
    }
 }

-/// Optional: User implements this for autocomplete data
+/// Optional: User implements this for suggestions data
 #[async_trait]
-pub trait AutocompleteProvider {
-    /// Fetch autocomplete suggestions (user's business logic)
+pub trait SuggestionsProvider {
+    /// Fetch suggestions (user's business logic)
    async fn fetch_suggestions(&mut self, field_index: usize, query: &str)
        -> Result<Vec<SuggestionItem>>;
 }
--- a/canvas/src/editor.rs
+++ b/canvas/src/editor.rs
@@ -7,7 +7,7 @@ use crate::canvas::CursorManager;

 use anyhow::Result;
 use crate::canvas::state::EditorState;
-use crate::data_provider::{DataProvider, AutocompleteProvider, SuggestionItem};
+use crate::data_provider::{DataProvider, SuggestionsProvider, SuggestionItem};
 use crate::canvas::modes::AppMode;
 use crate::canvas::state::SelectionState;

@@ -70,9 +70,9 @@ impl<D: DataProvider> FormEditor<D> {
        self.ui_state.mode()
    }

-    /// Check if autocomplete is active (for user's logic)
-    pub fn is_autocomplete_active(&self) -> bool {
-        self.ui_state.is_autocomplete_active()
+    /// Check if suggestions dropdown is active (for user's logic)
+    pub fn is_suggestions_active(&self) -> bool {
+        self.ui_state.is_suggestions_active()
    }

    /// Get current field text (convenience method)
@@ -580,50 +580,51 @@ impl<D: DataProvider> FormEditor<D> {
    }

    // ===================================================================
-    // ASYNC OPERATIONS: Only autocomplete needs async
+    // ASYNC OPERATIONS: Only suggestions need async
    // ===================================================================

-    /// Trigger autocomplete (async because it fetches data)
-    pub async fn trigger_autocomplete<A>(&mut self, provider: &mut A) -> Result<()>
+    /// Trigger suggestions (async because it fetches data)
+    pub async fn trigger_suggestions<A>(&mut self, provider: &mut A) -> Result<()>
    where
-        A: AutocompleteProvider,
+        A: SuggestionsProvider,
    {
        let field_index = self.ui_state.current_field;

-        if !self.data_provider.supports_autocomplete(field_index) {
+        if !self.data_provider.supports_suggestions(field_index) {
            return Ok(());
        }

-        // Activate autocomplete UI
-        self.ui_state.activate_autocomplete(field_index);
+        // Activate suggestions UI
+        self.ui_state.activate_suggestions(field_index);

        // Fetch suggestions from user (no conversion needed!)
        let query = self.current_text();
        self.suggestions = provider.fetch_suggestions(field_index, query).await?;

        // Update UI state
-        self.ui_state.autocomplete.is_loading = false;
+        self.ui_state.suggestions.is_loading = false;
        if !self.suggestions.is_empty() {
-            self.ui_state.autocomplete.selected_index = Some(0);
+            self.ui_state.suggestions.selected_index = Some(0);
        }

        Ok(())
    }

-    /// Navigate autocomplete suggestions
-    pub fn autocomplete_next(&mut self) {
-        if !self.ui_state.autocomplete.is_active || self.suggestions.is_empty() {
+    /// Navigate suggestions
+    pub fn suggestions_next(&mut self) {
+        if !self.ui_state.suggestions.is_active || self.suggestions.is_empty() {
            return;
        }

-        let current = self.ui_state.autocomplete.selected_index.unwrap_or(0);
+        let current = self.ui_state.suggestions.selected_index.unwrap_or(0);
        let next = (current + 1) % self.suggestions.len();
-        self.ui_state.autocomplete.selected_index = Some(next);
+        self.ui_state.suggestions.selected_index = Some(next);
    }

-    /// Apply selected autocomplete suggestion
-    pub fn apply_autocomplete(&mut self) -> Option<String> {
-        if let Some(selected_index) = self.ui_state.autocomplete.selected_index {
+    /// Apply selected suggestion
+    /// Apply selected suggestion
+    pub fn apply_suggestion(&mut self) -> Option<String> {
+        if let Some(selected_index) = self.ui_state.suggestions.selected_index {
            if let Some(suggestion) = self.suggestions.get(selected_index).cloned() {
                let field_index = self.ui_state.current_field;

@@ -637,8 +638,8 @@ impl<D: DataProvider> FormEditor<D> {
                self.ui_state.cursor_pos = suggestion.value_to_store.len();
                self.ui_state.ideal_cursor_column = self.ui_state.cursor_pos;

-                // Close autocomplete
-                self.ui_state.deactivate_autocomplete();
+                // Close suggestions
+                self.ui_state.deactivate_suggestions();
                self.suggestions.clear();

                // Validate the new content if validation is enabled
@@ -951,8 +952,8 @@ impl<D: DataProvider> FormEditor<D> {
        }

        self.set_mode(AppMode::ReadOnly);
-        // Deactivate autocomplete when exiting edit mode
-        self.ui_state.deactivate_autocomplete();
+        // Deactivate suggestions when exiting edit mode
+        self.ui_state.deactivate_suggestions();

        Ok(())
    }
--- a/canvas/src/lib.rs
+++ b/canvas/src/lib.rs
@@ -4,9 +4,9 @@ pub mod canvas;
 pub mod editor;
 pub mod data_provider;

-// Only include autocomplete module if feature is enabled
-#[cfg(feature = "autocomplete")]
-pub mod autocomplete;
+// Only include suggestions module if feature is enabled
+#[cfg(feature = "suggestions")]
+pub mod suggestions;

 // Only include validation module if feature is enabled
 #[cfg(feature = "validation")]
@@ -21,7 +21,7 @@ pub use canvas::CursorManager;

 // Main API exports
 pub use editor::FormEditor;
-pub use data_provider::{DataProvider, AutocompleteProvider, SuggestionItem};
+pub use data_provider::{DataProvider, SuggestionsProvider, SuggestionItem};

 // UI state (read-only access for users)
 pub use canvas::state::EditorState;
@@ -51,5 +51,5 @@ pub use canvas::gui::render_canvas;
 #[cfg(feature = "gui")]
 pub use canvas::gui::render_canvas_default;

-#[cfg(all(feature = "gui", feature = "autocomplete"))]
-pub use autocomplete::gui::render_autocomplete_dropdown;
+#[cfg(all(feature = "gui", feature = "suggestions"))]
+pub use suggestions::gui::render_suggestions_dropdown;
--- a/canvas/src/autocomplete/gui.rs
+++ b/canvas/src/autocomplete/gui.rs
@@ -1,5 +1,5 @@
-// src/autocomplete/gui.rs
-//! Autocomplete GUI updated to work with FormEditor
+// src/suggestions/gui.rs
+//! Suggestions dropdown GUI (not inline autocomplete) updated to work with FormEditor

 #[cfg(feature = "gui")]
 use ratatui::{
@@ -17,9 +17,9 @@ use crate::editor::FormEditor;
 #[cfg(feature = "gui")]
 use unicode_width::UnicodeWidthStr;

-/// Render autocomplete dropdown for FormEditor - call this AFTER rendering canvas
+/// Render suggestions dropdown for FormEditor - call this AFTER rendering canvas
 #[cfg(feature = "gui")]
-pub fn render_autocomplete_dropdown<T: CanvasTheme, D: DataProvider>(
+pub fn render_suggestions_dropdown<T: CanvasTheme, D: DataProvider>(
    f: &mut Frame,
    frame_area: Rect,
    input_rect: Rect,
@@ -28,14 +28,14 @@ pub fn render_autocomplete_dropdown<T: CanvasTheme, D: DataProvider>(
 ) {
    let ui_state = editor.ui_state();

-    if !ui_state.is_autocomplete_active() {
+    if !ui_state.is_suggestions_active() {
        return;
    }

-    if ui_state.autocomplete.is_loading {
+    if ui_state.suggestions.is_loading {
        render_loading_indicator(f, frame_area, input_rect, theme);
    } else if !editor.suggestions().is_empty() {
-        render_suggestions_dropdown(f, frame_area, input_rect, theme, editor.suggestions(), ui_state.autocomplete.selected_index);
+        render_suggestions_dropdown_list(f, frame_area, input_rect, theme, editor.suggestions(), ui_state.suggestions.selected_index);
    }
 }

@@ -71,7 +71,7 @@ fn render_loading_indicator<T: CanvasTheme>(

 /// Show actual suggestions list
 #[cfg(feature = "gui")]
-fn render_suggestions_dropdown<T: CanvasTheme>(
+fn render_suggestions_dropdown_list<T: CanvasTheme>(
    f: &mut Frame,
    frame_area: Rect,
    input_rect: Rect,
--- a/canvas/src/suggestions/mod.rs
+++ b/canvas/src/suggestions/mod.rs
@@ -0,0 +1,12 @@
+// src/suggestions/mod.rs
+
+pub mod state;
+#[cfg(feature = "gui")]
+pub mod gui;
+
+// Re-export the main suggestion types
+pub use state::{SuggestionsProvider, SuggestionItem};
+
+// Re-export GUI functions if available
+#[cfg(feature = "gui")]
+pub use gui::render_suggestions_dropdown;
--- a/canvas/src/suggestions/state.rs
+++ b/canvas/src/suggestions/state.rs
@@ -0,0 +1,5 @@
+// src/suggestions/state.rs
+//! Suggestions provider types (for dropdown suggestions, not real inline autocomplete)
+
+// Re-export the main types from data_provider
+pub use crate::data_provider::{SuggestionsProvider, SuggestionItem};
--- a/canvas/view_docs.sh
+++ b/canvas/view_docs.sh
@@ -27,7 +27,7 @@ show_module() {

 # Main modules
 show_module "canvas" "CANVAS SYSTEM"
-show_module "autocomplete" "AUTOCOMPLETE SYSTEM" 
+show_module "suggestions" "SUGGESTIONS SYSTEM" 
 show_module "config" "CONFIGURATION SYSTEM"

 # Show lib.rs and other root files
@@ -45,7 +45,7 @@ fi
 echo -e "\n\033[1;36m=========================================="
 echo "To view specific module documentation:"
 echo "  ./view_canvas_docs.sh canvas"
-echo "  ./view_canvas_docs.sh autocomplete" 
+echo "  ./view_canvas_docs.sh suggestions" 
 echo "  ./view_canvas_docs.sh config"
 echo "==========================================\033[0m"