table structure docs are made

.envrc

@@ -0,0 +1 @@
+use flake

.gitignore

@@ -1,2 +1,8 @@
 /target
 .env
+/tantivy_indexes
+server/tantivy_indexes
+steel_decimal/tests/property_tests.proptest-regressions
+.direnv/
+canvas/*.toml
+.aider*

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "client"]
+	path = client
+	url = git@gitlab.com:filipriec/komp_ac_client.git
+[submodule "canvas"]
+	path = canvas
+	url = git@gitlab.com:filipriec/tui-canvas.git
+[submodule "server"]
+	path = server
+	url = git@gitlab.com:filipriec/komp_ac_server.git

Cargo.toml

@@ -1,19 +1,55 @@
 [workspace]
-members = ["client", "server", "common"]
+members = ["client", "server", "common", "search", "canvas"]
 resolver = "2"
 
 [workspace.package]
 # TODO: idk how to do the name, fix later
-# name = "Multieko2"
-version = "0.3.13"
+# name = "komp_ac"
+version = "0.5.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 authors = ["Filip Priečinský <filippriec@gmail.com>"]
 description = "Poriadny uctovnicky software."
 readme = "README.md"
-repository = "https://gitlab.com/filipriec/multieko2"
+repository = "https://gitlab.com/filipriec/komp_ac"
 categories = ["command-line-interface"]
 
 # [workspace.metadata]
 # TODO:
-# documentation = "https://docs.rs/accounting-client"`
+# documentation = "https://docs.rs/accounting-client"
+
+[workspace.dependencies]
+# Async and gRPC
+tokio = { version = "1.44.2", features = ["full"] }
+tonic = "0.13.0"
+prost = "0.13.5"
+async-trait = "0.1.88"
+prost-types = "0.13.0"
+
+# Data Handling & Serialization
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.140"
+time = "0.3.41"
+
+# Utilities & Error Handling
+anyhow = "1.0.98"
+dotenvy = "0.15.7"
+lazy_static = "1.5.0"
+tracing = "0.1.41"
+
+# Search crate
+tantivy = "0.24.1"
+
+# Steel_decimal crate
+rust_decimal = { version = "1.37.2", features = ["maths", "serde"] }
+rust_decimal_macros = "1.37.1"
+thiserror = "2.0.12"
+regex = "1.11.1"
+
+# Canvas crate
+ratatui = { version = "0.29.0", features = ["crossterm"] }
+crossterm = "0.28.1"
+toml = "0.8.20"
+unicode-width = "0.2.0"
+
+common = { path = "./common" }

README.md

@@ -18,3 +18,8 @@ Client with tracing:
 ```
 ENABLE_TRACING=1 RUST_LOG=client=debug cargo watch -x 'run --package client -- client'
 ```
+
+Client with debug that cant be traced
+```
+cargo run --package client --features ui-debug -- client
+```

client/Cargo.toml

@@ -1,28 +0,0 @@
-[package]
-name = "client"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-
-[dependencies]
-anyhow = "1.0.98"
-async-trait = "0.1.88"
-common = { path = "../common" }
-
-crossterm = "0.28.1"
-dirs = "6.0.0"
-dotenvy = "0.15.7"
-lazy_static = "1.5.0"
-prost = "0.13.5"
-ratatui = { version = "0.29.0", features = ["crossterm"] }
-serde = { version = "1.0.219", features = ["derive"] }
-serde_json = "1.0.140"
-time = "0.3.41"
-tokio = { version = "1.44.2", features = ["full", "macros"] }
-toml = "0.8.20"
-tonic = "0.13.0"
-tracing = "0.1.41"
-tracing-subscriber = "0.3.19"
-tui-textarea = { version = "0.7.0", features = ["crossterm", "ratatui", "search"] }
-unicode-segmentation = "1.12.0"
-unicode-width = "0.2.0"

client/config.toml

@@ -1,93 +0,0 @@
-# config.toml
-[keybindings]
-
-enter_command_mode = [":", "ctrl+;"]
-next_buffer = ["ctrl+l"]
-previous_buffer = ["ctrl+h"] 
-close_buffer = ["ctrl+k"]
-
-[keybindings.general]
-move_up = ["k", "Up"]
-move_down = ["j", "Down"]
-next_option = ["l", "Right"]
-previous_option = ["h", "Left"]
-select = ["Enter"]
-toggle_sidebar = ["ctrl+t"]
-toggle_buffer_list = ["ctrl+b"]
-next_field = ["Tab"]
-prev_field = ["Shift+Tab"]
-exit_table_scroll = ["esc"]
-
-[keybindings.common]
-save = ["ctrl+s"]
-quit = ["ctrl+q"]
-# !!!change to space b r in the future and from edit mode 
-revert = ["ctrl+r"]
-
-force_quit = ["ctrl+shift+q"]
-save_and_quit = ["ctrl+shift+s"]
-move_up = ["Up"]
-move_down = ["Down"]
-toggle_sidebar = ["ctrl+t"]
-toggle_buffer_list = ["ctrl+b"]
-
-# MODE SPECIFIC
-# READ ONLY MODE
-[keybindings.read_only]
-enter_edit_mode_before = ["i"]
-enter_edit_mode_after = ["a"]
-previous_entry = ["left","q"]
-next_entry = ["right","1"]
-
-move_left = ["h"]
-move_right = ["l"]
-move_up = ["k"]
-move_down = ["j"]
-move_word_next = ["w"]
-move_word_end = ["e"]
-move_word_prev = ["b"]
-move_word_end_prev = ["ge"]
-move_line_start = ["0"]
-move_line_end = ["$"]
-move_first_line = ["gg"]
-move_last_line = ["x"]
-enter_highlight_mode = ["v"]
-enter_highlight_mode_linewise = ["ctrl+v"]
-
-[keybindings.highlight]
-exit_highlight_mode = ["esc"]
-enter_highlight_mode_linewise = ["ctrl+v"]
-
-[keybindings.edit]
-# BIG CHANGES NOW EXIT HANDLES EITHER IF THOSE
-# exit_edit_mode = ["esc","ctrl+e"]
-# exit_suggestion_mode = ["esc"]
-# select_suggestion = ["enter"]
-# next_field = ["enter"]
-enter_decider = ["enter"]
-prev_field = ["shift+enter"]
-exit = ["esc", "ctrl+e"]
-delete_char_forward = ["delete"]
-delete_char_backward = ["backspace"]
-move_left = ["left"]
-move_right = ["right"]
-suggestion_down = ["ctrl+n", "tab"]
-suggestion_up = ["ctrl+p", "shift+tab"]
-
-[keybindings.command]
-exit_command_mode = ["ctrl+g", "esc"]
-command_execute = ["enter"]
-command_backspace = ["backspace"]
-save = ["w"]
-quit = ["q"]
-force_quit = ["q!"]
-save_and_quit = ["wq"]
-revert = ["r"]
-find_file_palette_toggle = ["ff"]
-
-[editor]
-keybinding_mode = "vim"  # Options: "default", "vim", "emacs"
-
-[colors]
-theme = "dark" 
-# Options: "light", "dark", "high_contrast"

client/docs/project_structure.txt

@@ -1,49 +0,0 @@
-client/
-├── Cargo.toml
-├── config.toml
-└── src/
-    ├── main.rs            # Entry point with minimal code
-    ├── lib.rs             # Core exports
-    ├── app.rs             # Application lifecycle and main loop
-    │
-    ├── ui/                # UI components and rendering
-    │   ├── mod.rs
-    │   ├── theme.rs       # Theme definitions (from colors.rs)
-    │   ├── layout.rs      # Layout definitions
-    │   ├── render.rs      # Main render coordinator
-    │   └── components/    # UI components
-    │       ├── mod.rs
-    │       ├── command_line.rs
-    │       ├── form.rs
-    │       ├── preview_card.rs
-    │       └── status_line.rs
-    │
-    ├── input/             # Input handling
-    │   ├── mod.rs
-    │   ├── handler.rs     # Main input handler (lightweight coordinator)
-    │   ├── commands.rs    # Command processing
-    │   ├── navigation.rs  # Navigation between entries and fields
-    │   └── edit.rs        # Edit mode logic
-    │
-    ├── editor/            # Text editing functionality
-    │   ├── mod.rs
-    │   ├── cursor.rs      # Cursor movement
-    │   └── text.rs        # Text manipulation (word movements, etc.)
-    │
-    ├── state/             # Application state
-    │   ├── mod.rs
-    │   ├── app_state.rs   # Main application state
-    │   └── form_state.rs  # Form state
-    │
-    ├── model/             # Data models
-    │   ├── mod.rs
-    │   └── entry.rs       # Entry model with business logic
-    │
-    ├── service/           # External services
-    │   ├── mod.rs
-    │   ├── terminal.rs    # Terminal setup and management
-    │   └── grpc.rs        # gRPC client (extracted from terminal.rs)
-    │
-    └── config/            # Configuration
-        ├── mod.rs
-        └── keybindings.rs # Keybinding definitions and matching

client/src/components/admin.rs

@@ -1,10 +0,0 @@
-// src/components/admin.rs
-pub mod admin_panel;
-pub mod admin_panel_admin;
-pub mod add_table;
-pub mod add_logic;
-
-pub use admin_panel::*;
-pub use admin_panel_admin::*;
-pub use add_table::*;
-pub use add_logic::*;

client/src/components/admin/add_logic.rs

@@ -1,313 +0,0 @@
-// src/components/admin/add_logic.rs
-use crate::config::colors::themes::Theme;
-use crate::state::app::highlight::HighlightState;
-use crate::state::app::state::AppState;
-use crate::state::pages::add_logic::{AddLogicFocus, AddLogicState};
-use crate::state::pages::canvas_state::CanvasState;
-use ratatui::{
-    layout::{Alignment, Constraint, Direction, Layout, Rect},
-    style::{Modifier, Style},
-    text::{Line, Span},
-    widgets::{Block, BorderType, Borders, Paragraph},
-    Frame,
-};
-use crate::components::handlers::canvas::render_canvas;
-use crate::components::common::{dialog, autocomplete}; // Added autocomplete
-use crate::config::binds::config::EditorKeybindingMode;
-
-pub fn render_add_logic(
-    f: &mut Frame,
-    area: Rect,
-    theme: &Theme,
-    app_state: &AppState,
-    add_logic_state: &mut AddLogicState,
-    is_edit_mode: bool,
-    highlight_state: &HighlightState,
-) {
-    let main_block = Block::default()
-        .title(" Add New Logic Script ")
-        .title_alignment(Alignment::Center)
-        .borders(Borders::ALL)
-        .border_type(BorderType::Rounded)
-        .border_style(Style::default().fg(theme.border))
-        .style(Style::default().bg(theme.bg));
-    let inner_area = main_block.inner(area);
-    f.render_widget(main_block, area);
-
-    // Handle full-screen script editing
-    if add_logic_state.current_focus == AddLogicFocus::InsideScriptContent {
-        let mut editor_ref = add_logic_state.script_content_editor.borrow_mut();
-        let border_style_color = if is_edit_mode { theme.highlight } else { theme.secondary };
-        let border_style = Style::default().fg(border_style_color);
-
-        editor_ref.set_cursor_line_style(Style::default());
-        editor_ref.set_cursor_style(Style::default().add_modifier(Modifier::REVERSED));
-
-        let script_title_hint = match add_logic_state.editor_keybinding_mode {
-            EditorKeybindingMode::Vim => {
-                let vim_mode_status = crate::components::common::text_editor::TextEditor::get_vim_mode_status(&add_logic_state.vim_state);
-                format!("Script {}", vim_mode_status)
-            }
-            EditorKeybindingMode::Emacs | EditorKeybindingMode::Default => {
-                if is_edit_mode {
-                    "Script (Editing)".to_string()
-                } else {
-                    "Script".to_string()
-                }
-            }
-        };
-
-        editor_ref.set_block(
-            Block::default()
-                .title(Span::styled(script_title_hint, Style::default().fg(theme.fg)))
-                .title_alignment(Alignment::Center)
-                .borders(Borders::ALL)
-                .border_type(BorderType::Rounded)
-                .border_style(border_style),
-        );
-        f.render_widget(&*editor_ref, inner_area);
-
-        // Drop the editor borrow before accessing autocomplete state
-        drop(editor_ref);
-
-        // === SCRIPT EDITOR AUTOCOMPLETE RENDERING ===
-        if add_logic_state.script_editor_autocomplete_active && !add_logic_state.script_editor_suggestions.is_empty() {
-            // Get the current cursor position from textarea
-            let current_cursor = {
-                let editor_borrow = add_logic_state.script_content_editor.borrow();
-                editor_borrow.cursor() // Returns (row, col) as (usize, usize)
-            };
-            
-            let (cursor_line, cursor_col) = current_cursor;
-            
-            // Account for TextArea's block borders (1 for each side)
-            let block_offset_x = 1;
-            let block_offset_y = 1;
-            
-            // Position autocomplete at current cursor position
-            // Add 1 to column to position dropdown right after the cursor
-            let autocomplete_x = cursor_col + 1;
-            let autocomplete_y = cursor_line;
-            
-            let input_rect = Rect {
-                x: (inner_area.x + block_offset_x + autocomplete_x as u16).min(inner_area.right().saturating_sub(20)),
-                y: (inner_area.y + block_offset_y + autocomplete_y as u16).min(inner_area.bottom().saturating_sub(5)),
-                width: 1, // Minimum width for positioning
-                height: 1,
-            };
-
-            // Render autocomplete dropdown
-            autocomplete::render_autocomplete_dropdown(
-                f,
-                input_rect,
-                f.area(), // Full frame area for clamping
-                theme,
-                &add_logic_state.script_editor_suggestions,
-                add_logic_state.script_editor_selected_suggestion_index,
-            );
-        }
-
-        return; // Exit early for fullscreen mode
-    }
-
-    // Regular layout with preview
-    let main_chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(3),  // Top info
-            Constraint::Length(9),  // Canvas for 3 inputs (each 1 line + 1 padding = 2 lines * 3 + 2 border = 8, +1 for good measure)
-            Constraint::Min(5),     // Script preview
-            Constraint::Length(3),  // Buttons
-        ])
-        .split(inner_area);
-
-    let top_info_area = main_chunks[0];
-    let canvas_area = main_chunks[1];
-    let script_content_area = main_chunks[2];
-    let buttons_area = main_chunks[3];
-
-    // Top info
-    let profile_text = Paragraph::new(vec![
-        Line::from(Span::styled(
-            format!("Profile: {}", add_logic_state.profile_name),
-            Style::default().fg(theme.fg),
-        )),
-        Line::from(Span::styled(
-            format!(
-                "Table: {}",
-                add_logic_state
-                    .selected_table_name
-                    .clone()
-                    .unwrap_or_else(|| add_logic_state.selected_table_id
-                        .map(|id| format!("ID {}", id))
-                        .unwrap_or_else(|| "Global (Not Selected)".to_string()))
-            ),
-            Style::default().fg(theme.fg),
-        )),
-    ])
-    .block(
-        Block::default()
-            .borders(Borders::BOTTOM)
-            .border_style(Style::default().fg(theme.secondary)),
-    );
-    f.render_widget(profile_text, top_info_area);
-
-    // Canvas
-    let focus_on_canvas_inputs = matches!(
-        add_logic_state.current_focus,
-        AddLogicFocus::InputLogicName
-            | AddLogicFocus::InputTargetColumn
-            | AddLogicFocus::InputDescription
-    );
-    // Call render_canvas and get the active_field_rect
-    let active_field_rect = render_canvas(
-        f,
-        canvas_area,
-        add_logic_state, // Pass the whole state as it impl CanvasState
-        &add_logic_state.fields(),
-        &add_logic_state.current_field(),
-        &add_logic_state.inputs(),
-        theme,
-        is_edit_mode && focus_on_canvas_inputs, // is_edit_mode for canvas fields
-        highlight_state,
-    );
-
-    // --- Render Autocomplete for Target Column ---
-    // `is_edit_mode` here refers to the general edit mode of the EventHandler
-    if is_edit_mode && add_logic_state.current_field() == 1 { // Target Column field
-        if let Some(suggestions) = add_logic_state.get_suggestions() { // Uses CanvasState impl
-            let selected = add_logic_state.get_selected_suggestion_index();
-            if !suggestions.is_empty() { // Only render if there are suggestions to show
-                if let Some(input_rect) = active_field_rect {
-                    autocomplete::render_autocomplete_dropdown(
-                        f,
-                        input_rect,
-                        f.area(), // Full frame area for clamping
-                        theme,
-                        suggestions,
-                        selected,
-                    );
-                }
-            }
-        }
-    }
-
-    // Script content preview
-    {
-        let mut editor_ref = add_logic_state.script_content_editor.borrow_mut();
-        editor_ref.set_cursor_line_style(Style::default());
-
-        let is_script_preview_focused = add_logic_state.current_focus == AddLogicFocus::ScriptContentPreview;
-
-        if is_script_preview_focused {
-            editor_ref.set_cursor_style(Style::default().add_modifier(Modifier::REVERSED));
-        } else {
-            let underscore_cursor_style = Style::default()
-                .add_modifier(Modifier::UNDERLINED)
-                .fg(theme.secondary);
-            editor_ref.set_cursor_style(underscore_cursor_style);
-        }
-
-        let border_style_color = if is_script_preview_focused {
-            theme.highlight
-        } else {
-            theme.secondary
-        };
-
-        let title_text = "Script Preview"; // Title doesn't need to change based on focus here
-
-        let title_style = if is_script_preview_focused {
-            Style::default().fg(theme.highlight).add_modifier(Modifier::BOLD)
-        } else {
-            Style::default().fg(theme.fg)
-        };
-
-        editor_ref.set_block(
-            Block::default()
-                .title(Span::styled(title_text, title_style))
-                .borders(Borders::ALL)
-                .border_type(BorderType::Rounded)
-                .border_style(Style::default().fg(border_style_color)),
-        );
-        f.render_widget(&*editor_ref, script_content_area);
-    }
-
-    // Buttons
-    let get_button_style = |button_focus: AddLogicFocus, current_focus_state: AddLogicFocus| {
-        let is_focused = current_focus_state == button_focus;
-        let base_style = Style::default().fg(if is_focused {
-            theme.highlight
-        } else {
-            theme.secondary
-        });
-        if is_focused {
-            base_style.add_modifier(Modifier::BOLD)
-        } else {
-            base_style
-        }
-    };
-
-    let get_button_border_style = |is_focused: bool, current_theme: &Theme| {
-        if is_focused {
-            Style::default().fg(current_theme.highlight)
-        } else {
-            Style::default().fg(current_theme.secondary)
-        }
-    };
-
-    let button_chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([
-            Constraint::Percentage(50),
-            Constraint::Percentage(50),
-        ])
-        .split(buttons_area);
-
-    let save_button = Paragraph::new(" Save Logic ")
-        .style(get_button_style(
-            AddLogicFocus::SaveButton,
-            add_logic_state.current_focus,
-        ))
-        .alignment(Alignment::Center)
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .border_type(BorderType::Rounded)
-                .border_style(get_button_border_style(
-                    add_logic_state.current_focus == AddLogicFocus::SaveButton,
-                    theme,
-                )),
-        );
-    f.render_widget(save_button, button_chunks[0]);
-
-    let cancel_button = Paragraph::new(" Cancel ")
-        .style(get_button_style(
-            AddLogicFocus::CancelButton,
-            add_logic_state.current_focus,
-        ))
-        .alignment(Alignment::Center)
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .border_type(BorderType::Rounded)
-                .border_style(get_button_border_style(
-                    add_logic_state.current_focus == AddLogicFocus::CancelButton,
-                    theme,
-                )),
-        );
-    f.render_widget(cancel_button, button_chunks[1]);
-
-    // Dialog
-    if app_state.ui.dialog.dialog_show {
-        dialog::render_dialog(
-            f,
-            f.area(),
-            theme,
-            &app_state.ui.dialog.dialog_title,
-            &app_state.ui.dialog.dialog_message,
-            &app_state.ui.dialog.dialog_buttons,
-            app_state.ui.dialog.dialog_active_button_index,
-            app_state.ui.dialog.is_loading,
-        );
-    }
-}

client/src/components/admin/add_table.rs

@@ -1,572 +0,0 @@
-// src/components/admin/add_table.rs
-use crate::config::colors::themes::Theme;
-use crate::state::app::highlight::HighlightState;
-use crate::state::app::state::AppState;
-use crate::state::pages::add_table::{AddTableFocus, AddTableState};
-use crate::state::pages::canvas_state::CanvasState;
-// use crate::state::pages::add_table::{ColumnDefinition, LinkDefinition}; // Not directly used here
-use ratatui::{
-    layout::{Alignment, Constraint, Direction, Layout, Rect},
-    style::{Modifier, Style},
-    text::{Line, Span},
-    widgets::{Block, BorderType, Borders, Cell, Paragraph, Row, Table},
-    Frame,
-};
-use crate::components::handlers::canvas::render_canvas;
-use crate::components::common::dialog;
-
-/// Renders the Add New Table page layout, structuring the display of table information,
-/// input fields, and action buttons. Adapts layout based on terminal width.
-pub fn render_add_table(
-    f: &mut Frame,
-    area: Rect,
-    theme: &Theme,
-    app_state: &AppState, // Currently unused, might be needed later
-    add_table_state: &mut AddTableState,
-    is_edit_mode: bool, // Determines if canvas inputs are in edit mode
-    highlight_state: &HighlightState, // For text highlighting in canvas
-) {
-    // --- Configuration ---
-    // Threshold width to switch between wide and narrow layouts
-    const NARROW_LAYOUT_THRESHOLD: u16 = 120; // Adjust this value as needed
-
-    // --- State Checks ---
-    let focus_on_canvas_inputs = matches!(
-        add_table_state.current_focus,
-        AddTableFocus::InputTableName
-            | AddTableFocus::InputColumnName
-            | AddTableFocus::InputColumnType
-    );
-
-    // --- Main Page Block ---
-    let main_block = Block::default()
-        .title(" Add New Table ")
-        .title_alignment(Alignment::Center)
-        .borders(Borders::ALL)
-        .border_type(BorderType::Rounded)
-        .border_style(Style::default().fg(theme.border))
-        .style(Style::default().bg(theme.bg));
-    let inner_area = main_block.inner(area);
-    f.render_widget(main_block, area);
-
-    // --- Fullscreen Columns Table Check (Narrow Screens Only) ---
-    if area.width < NARROW_LAYOUT_THRESHOLD && add_table_state.current_focus == AddTableFocus::InsideColumnsTable {
-        // Render ONLY the columns table taking the full inner area
-        let columns_border_style = Style::default().fg(theme.highlight); // Always highlighted when fullscreen
-        let column_rows: Vec<Row<'_>> = add_table_state
-            .columns
-            .iter()
-            .map(|col_def| {
-                Row::new(vec![
-                    Cell::from(if col_def.selected { "[*]" } else { "[ ]" }),
-                    Cell::from(col_def.name.clone()),
-                    Cell::from(col_def.data_type.clone()),
-                ])
-                .style(Style::default().fg(theme.fg))
-            })
-            .collect();
-        let header_cells = ["Sel", "Name", "Type"]
-            .iter()
-            .map(|h| Cell::from(*h).style(Style::default().fg(theme.accent)));
-        let header = Row::new(header_cells).height(1).bottom_margin(1);
-        let columns_table = Table::new(column_rows, [Constraint::Length(5), Constraint::Percentage(50), Constraint::Percentage(50)])
-            .header(header)
-            .block(
-                Block::default()
-                    .title(Span::styled(" Columns (Fullscreen) ", theme.fg)) // Indicate fullscreen
-                    .title_alignment(Alignment::Center)
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Rounded)
-                    .border_style(columns_border_style),
-            )
-            .row_highlight_style(
-                Style::default()
-                .add_modifier(Modifier::REVERSED)
-                .fg(theme.highlight),
-            )
-            .highlight_symbol(" > "); // Use the inside symbol
-        f.render_stateful_widget(columns_table, inner_area, &mut add_table_state.column_table_state);
-        return; // IMPORTANT: Stop rendering here for fullscreen mode
-    }
-
-    // --- Fullscreen Indexes Table Check ---
-    if add_table_state.current_focus == AddTableFocus::InsideIndexesTable { // Remove width check
-        // Render ONLY the indexes table taking the full inner area
-        let indexes_border_style = Style::default().fg(theme.highlight); // Always highlighted when fullscreen
-        let index_rows: Vec<Row<'_>> = add_table_state
-            .indexes
-            .iter()
-            .map(|index_def| {
-                Row::new(vec![
-                    Cell::from(if index_def.selected { "[*]" } else { "[ ]" }),
-                    Cell::from(index_def.name.clone()),
-                ])
-                .style(Style::default().fg(theme.fg))
-            })
-            .collect();
-        let index_header_cells = ["Sel", "Column Name"]
-            .iter()
-            .map(|h| Cell::from(*h).style(Style::default().fg(theme.accent)));
-        let index_header = Row::new(index_header_cells).height(1).bottom_margin(1);
-        let indexes_table = Table::new(index_rows, [Constraint::Length(5), Constraint::Percentage(95)])
-            .header(index_header)
-            .block(
-                Block::default()
-                    .title(Span::styled(" Indexes (Fullscreen) ", theme.fg)) // Indicate fullscreen
-                    .title_alignment(Alignment::Center)
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Rounded)
-                    .border_style(indexes_border_style),
-            )
-            .row_highlight_style(Style::default().add_modifier(Modifier::REVERSED).fg(theme.highlight))
-            .highlight_symbol(" > "); // Use the inside symbol
-        f.render_stateful_widget(indexes_table, inner_area, &mut add_table_state.index_table_state);
-        return; // IMPORTANT: Stop rendering here for fullscreen mode
-    }
-
-    // --- Fullscreen Links Table Check ---
-    if add_table_state.current_focus == AddTableFocus::InsideLinksTable {
-        // Render ONLY the links table taking the full inner area
-        let links_border_style = Style::default().fg(theme.highlight); // Always highlighted when fullscreen
-        let link_rows: Vec<Row<'_>> = add_table_state
-            .links
-            .iter()
-            .map(|link_def| {
-                Row::new(vec![
-                    Cell::from(if link_def.selected { "[*]" } else { "[ ]" }), // Selection first
-                    Cell::from(link_def.linked_table_name.clone()), // Table name second
-                ])
-                .style(Style::default().fg(theme.fg))
-            })
-            .collect();
-        let link_header_cells = ["Sel", "Available Table"]
-
-            .iter()
-            .map(|h| Cell::from(*h).style(Style::default().fg(theme.accent)));
-        let link_header = Row::new(link_header_cells).height(1).bottom_margin(1);
-        let links_table = Table::new(link_rows, [Constraint::Length(5), Constraint::Percentage(95)])
-            .header(link_header)
-            .block(
-                Block::default()
-                    .title(Span::styled(" Links (Fullscreen) ", theme.fg)) // Indicate fullscreen
-                    .title_alignment(Alignment::Center)
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Rounded)
-                    .border_style(links_border_style),
-            )
-            .row_highlight_style(Style::default().add_modifier(Modifier::REVERSED).fg(theme.highlight))
-            .highlight_symbol(" > "); // Use the inside symbol
-        f.render_stateful_widget(links_table, inner_area, &mut add_table_state.link_table_state);
-        return; // IMPORTANT: Stop rendering here for fullscreen mode
-    }
-
-    // --- Area Variable Declarations ---
-    let top_info_area: Rect;
-    let columns_area: Rect;
-    let canvas_area: Rect;
-    let add_button_area: Rect;
-    let indexes_area: Rect;
-    let links_area: Rect;
-    let bottom_buttons_area: Rect;
-
-    // --- Layout Decision ---
-    if area.width >= NARROW_LAYOUT_THRESHOLD {
-        // --- WIDE Layout (Based on first screenshot) ---
-        let main_chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([
-                Constraint::Length(3), // Top Info (Profile/Table Name) - Increased to 3 lines
-                Constraint::Min(10),   // Middle Area (Columns | Right Pane)
-                Constraint::Length(3), // Bottom Buttons
-            ])
-            .split(inner_area);
-
-        top_info_area = main_chunks[0];
-        let middle_area = main_chunks[1];
-        bottom_buttons_area = main_chunks[2];
-
-        // Split Middle Horizontally
-        let middle_chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([
-                Constraint::Percentage(50), // Left: Columns Table
-                Constraint::Percentage(50), // Right: Inputs etc.
-            ])
-            .split(middle_area);
-
-        columns_area = middle_chunks[0];
-        let right_pane_area = middle_chunks[1];
-
-        // Split Right Pane Vertically
-        let right_pane_chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([
-                Constraint::Length(5), // Input Canvas Area
-                Constraint::Length(3), // Add Button Area
-                Constraint::Min(5),    // Indexes & Links Area
-            ])
-            .split(right_pane_area);
-
-        canvas_area = right_pane_chunks[0];
-        add_button_area = right_pane_chunks[1];
-        let indexes_links_area = right_pane_chunks[2];
-
-        // Split Indexes/Links Horizontally
-        let indexes_links_chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([
-                Constraint::Percentage(50), // Indexes Table
-                Constraint::Percentage(50), // Links Table
-            ])
-            .split(indexes_links_area);
-        indexes_area = indexes_links_chunks[0];
-        links_area = indexes_links_chunks[1];
-
-        // --- Top Info Rendering (Wide - 2 lines) ---
-        let profile_text = Paragraph::new(vec![
-            Line::from(Span::styled(
-                format!("Profile: {}", add_table_state.profile_name),
-                theme.fg,
-            )),
-            Line::from(Span::styled(
-                format!("Table name: {}", add_table_state.table_name),
-                theme.fg,
-            )),
-        ])
-        .block(
-            Block::default()
-                .borders(Borders::BOTTOM)
-                .border_style(Style::default().fg(theme.secondary)),
-        );
-        f.render_widget(profile_text, top_info_area);
-    } else {
-        // --- NARROW Layout (Based on second screenshot) ---
-        let main_chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([
-                Constraint::Length(1), // Top: Profile & Table Name (Single Row)
-                Constraint::Length(5), // Column Definition Input Canvas Area
-                Constraint::Length(3), // Add Button Area
-                Constraint::Min(5),    // Columns Table Area
-                Constraint::Min(5),    // Indexes & Links Area
-                Constraint::Length(3), // Bottom: Save/Cancel Buttons
-            ])
-            .split(inner_area);
-
-        top_info_area = main_chunks[0];
-        canvas_area = main_chunks[1];
-        add_button_area = main_chunks[2];
-        columns_area = main_chunks[3];
-        let indexes_links_area = main_chunks[4];
-        bottom_buttons_area = main_chunks[5];
-
-        // Split Indexes/Links Horizontally
-        let indexes_links_chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([
-                Constraint::Percentage(50), // Indexes Table
-                Constraint::Percentage(50), // Links Table
-            ])
-            .split(indexes_links_area);
-        indexes_area = indexes_links_chunks[0];
-        links_area = indexes_links_chunks[1];
-
-        // --- Top Info Rendering (Narrow - 1 line) ---
-        let top_info_chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([
-                Constraint::Percentage(50),
-                Constraint::Percentage(50),
-            ])
-            .split(top_info_area);
-
-        let profile_text = Paragraph::new(Span::styled(
-            format!("Profile: {}", add_table_state.profile_name),
-            theme.fg,
-        ))
-        .alignment(Alignment::Left);
-        f.render_widget(profile_text, top_info_chunks[0]);
-
-        let table_name_text = Paragraph::new(Span::styled(
-            format!("Table: {}", add_table_state.table_name),
-            theme.fg,
-        ))
-        .alignment(Alignment::Left);
-        f.render_widget(table_name_text, top_info_chunks[1]);
-    }
-
-    // --- Common Widget Rendering (Uses calculated areas) ---
-
-    // --- Columns Table Rendering ---
-    let columns_focused = matches!(add_table_state.current_focus, AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable);
-    let columns_border_style = if columns_focused {
-        Style::default().fg(theme.highlight)
-    } else {
-        Style::default().fg(theme.secondary)
-    };
-    let column_rows: Vec<Row<'_>> = add_table_state
-        .columns
-        .iter()
-        .map(|col_def| {
-            Row::new(vec![
-                Cell::from(if col_def.selected { "[*]" } else { "[ ]" }),
-                Cell::from(col_def.name.clone()),
-                Cell::from(col_def.data_type.clone()),
-            ])
-            .style(Style::default().fg(theme.fg))
-        })
-        .collect();
-    let header_cells = ["Sel", "Name", "Type"]
-        .iter()
-        .map(|h| Cell::from(*h).style(Style::default().fg(theme.accent)));
-    let header = Row::new(header_cells).height(1).bottom_margin(1);
-    let columns_table = Table::new(
-        column_rows,
-        [ // Define constraints for 3 columns: Sel, Name, Type
-            Constraint::Length(5),
-            Constraint::Percentage(60),
-            Constraint::Percentage(35),
-        ],
-    )
-    .header(header)
-    .block(
-        Block::default()
-            .title(Span::styled(" Columns ", theme.fg))
-            .title_alignment(Alignment::Center)
-            .borders(Borders::ALL)
-            .border_type(BorderType::Rounded)
-            .border_style(columns_border_style),
-    )
-    .row_highlight_style(
-        Style::default()
-            .add_modifier(Modifier::REVERSED)
-            .fg(theme.highlight),
-    )
-    .highlight_symbol(" > ");
-    f.render_stateful_widget(
-        columns_table,
-        columns_area,
-        &mut add_table_state.column_table_state,
-    );
-
-    // --- Canvas Rendering (Column Definition Input) ---
-    let _active_field_rect = render_canvas(
-        f,
-        canvas_area,
-        add_table_state,
-        &add_table_state.fields(),
-        &add_table_state.current_field(),
-        &add_table_state.inputs(),
-        theme,
-        is_edit_mode && focus_on_canvas_inputs,
-        highlight_state,
-    );
-
-    // --- Button Style Helpers ---
-    let get_button_style = |button_focus: AddTableFocus, current_focus| {
-        // Only handles text style (FG + Bold) now, no BG
-        let is_focused = current_focus == button_focus;
-        let base_style = Style::default().fg(if is_focused {
-            theme.highlight // Highlighted text color
-        } else {
-            theme.secondary // Normal text color
-        });
-        if is_focused {
-            base_style.add_modifier(Modifier::BOLD)
-        } else {
-            base_style
-        }
-    };
-    // Updated signature to accept bool and theme
-    let get_button_border_style = |is_focused: bool, theme: &Theme| {
-        if is_focused {
-            Style::default().fg(theme.highlight)
-        } else {
-            Style::default().fg(theme.secondary)
-        }
-    };
-
-    // --- Add Button Rendering ---
-    // Determine if the add button is focused
-    let is_add_button_focused = add_table_state.current_focus == AddTableFocus::AddColumnButton;
-
-    // Create the Add button Paragraph widget
-    let add_button = Paragraph::new(" Add ")
-        .style(get_button_style(AddTableFocus::AddColumnButton, add_table_state.current_focus)) // Use existing closure
-        .alignment(Alignment::Center)
-        .block(
-            Block::default()
-            .borders(Borders::ALL)
-            .border_type(BorderType::Rounded)
-            .border_style(get_button_border_style(is_add_button_focused, theme)), // Pass bool and theme
-        );
-
-    // Render the button in its designated area
-    f.render_widget(add_button, add_button_area);
-
-    // --- Indexes Table Rendering ---
-    let indexes_focused = matches!(add_table_state.current_focus, AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable);
-    let indexes_border_style = if indexes_focused {
-        Style::default().fg(theme.highlight)
-    } else {
-        Style::default().fg(theme.secondary)
-    };
-    let index_rows: Vec<Row<'_>> = add_table_state
-        .indexes
-        .iter()
-        .map(|index_def| { // Use index_def now
-            Row::new(vec![
-                Cell::from(if index_def.selected { "[*]" } else { "[ ]" }), // Display selection
-                Cell::from(index_def.name.clone()),
-            ])
-                .style(Style::default().fg(theme.fg))
-        })
-        .collect();
-    let index_header_cells = ["Sel", "Column Name"]
-        .iter()
-        .map(|h| Cell::from(*h).style(Style::default().fg(theme.accent)));
-    let index_header = Row::new(index_header_cells).height(1).bottom_margin(1);
-    let indexes_table =
-        Table::new(index_rows, [Constraint::Length(5), Constraint::Percentage(95)])
-            .header(index_header)
-            .block(
-                Block::default()
-                    .title(Span::styled(" Indexes ", theme.fg))
-                    .title_alignment(Alignment::Center)
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Rounded)
-                    .border_style(indexes_border_style),
-            )
-            .row_highlight_style(
-                Style::default()
-                    .add_modifier(Modifier::REVERSED)
-                    .fg(theme.highlight),
-            )
-            .highlight_symbol(" > ");
-    f.render_stateful_widget(
-        indexes_table,
-        indexes_area,
-        &mut add_table_state.index_table_state,
-    );
-
-    // --- Links Table Rendering ---
-    let links_focused = matches!(add_table_state.current_focus, AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable);
-    let links_border_style = if links_focused {
-        Style::default().fg(theme.highlight)
-    } else {
-        Style::default().fg(theme.secondary)
-    };
-    let link_rows: Vec<Row<'_>> = add_table_state
-        .links
-        .iter()
-        .map(|link_def| {
-            Row::new(vec![
-                Cell::from(if link_def.selected { "[*]" } else { "[ ]" }),
-                Cell::from(link_def.linked_table_name.clone()),
-            ])
-            .style(Style::default().fg(theme.fg))
-        })
-        .collect();
-    let link_header_cells = ["Sel", "Available Table"]
-        .iter()
-        .map(|h| Cell::from(*h).style(Style::default().fg(theme.accent)));
-    let link_header = Row::new(link_header_cells).height(1).bottom_margin(1);
-    let links_table =
-        Table::new(link_rows, [Constraint::Length(5), Constraint::Percentage(95)])
-            .header(link_header)
-            .block(
-                Block::default()
-                    .title(Span::styled(" Links ", theme.fg))
-                    .title_alignment(Alignment::Center)
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Rounded)
-                    .border_style(links_border_style),
-            )
-            .row_highlight_style(
-                Style::default()
-                    .add_modifier(Modifier::REVERSED)
-                    .fg(theme.highlight),
-            )
-            .highlight_symbol(" > ");
-    f.render_stateful_widget(
-        links_table,
-        links_area,
-        &mut add_table_state.link_table_state,
-    );
-
-    // --- Save/Cancel Buttons Rendering ---
-    let bottom_button_chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([
-            Constraint::Percentage(33), // Save Button
-            Constraint::Percentage(34), // Delete Button
-            Constraint::Percentage(33), // Cancel Button
-        ])
-        .split(bottom_buttons_area);
-
-    let save_button = Paragraph::new(" Save table ")
-        .style(get_button_style(
-            AddTableFocus::SaveButton,
-            add_table_state.current_focus,
-        ))
-        .alignment(Alignment::Center)
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .border_type(BorderType::Rounded)
-                .border_style(get_button_border_style(
-                    add_table_state.current_focus == AddTableFocus::SaveButton, // Pass bool
-                    theme,
-                )),
-        );
-    f.render_widget(save_button, bottom_button_chunks[0]);
-
-    let delete_button = Paragraph::new(" Delete Selected ")
-        .style(get_button_style(
-            AddTableFocus::DeleteSelectedButton,
-            add_table_state.current_focus,
-        ))
-        .alignment(Alignment::Center)
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .border_type(BorderType::Rounded)
-                .border_style(get_button_border_style(
-                    add_table_state.current_focus == AddTableFocus::DeleteSelectedButton, // Pass bool
-                    theme,
-                )),
-        );
-    f.render_widget(delete_button, bottom_button_chunks[1]);
-
-    let cancel_button = Paragraph::new(" Cancel ")
-        .style(get_button_style(
-            AddTableFocus::CancelButton,
-            add_table_state.current_focus,
-        ))
-        .alignment(Alignment::Center)
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .border_type(BorderType::Rounded)
-                .border_style(get_button_border_style(
-                    add_table_state.current_focus == AddTableFocus::CancelButton, // Pass bool
-                    theme,
-                )),
-        );
-    f.render_widget(cancel_button, bottom_button_chunks[2]);
-
-    // --- DIALOG ---
-    // Render the dialog overlay if it's active
-    if app_state.ui.dialog.dialog_show { // Use the passed-in app_state
-        dialog::render_dialog(
-            f,
-            f.area(), // Render over the whole frame area
-            theme,
-            &app_state.ui.dialog.dialog_title,
-            &app_state.ui.dialog.dialog_message,
-            &app_state.ui.dialog.dialog_buttons,
-            app_state.ui.dialog.dialog_active_button_index,
-            app_state.ui.dialog.is_loading,
-        );
-    }
-}

client/src/components/admin/admin_panel.rs

@@ -1,131 +0,0 @@
-// src/components/admin/admin_panel.rs
-
-use crate::config::colors::themes::Theme;
-use crate::state::pages::auth::AuthState;
-use crate::state::app::state::AppState;
-use crate::state::pages::admin::AdminState;
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
-use ratatui::{
-    layout::{Constraint, Direction, Layout, Rect},
-    style::Style,
-    text::{Line, Span, Text},
-    widgets::{Block, BorderType, Borders, List, ListItem, Paragraph, Wrap},
-    Frame,
-};
-use super::admin_panel_admin::render_admin_panel_admin;
-
-pub fn render_admin_panel(
-    f: &mut Frame,
-    app_state: &AppState,
-    auth_state: &AuthState,
-    admin_state: &mut AdminState,
-    area: Rect,
-    theme: &Theme,
-    profile_tree: &ProfileTreeResponse,
-    selected_profile: &Option<String>,
-) {
-    let block = Block::default()
-        .borders(Borders::ALL)
-        .border_type(BorderType::Rounded)
-        .border_style(Style::default().fg(theme.accent))
-        .style(Style::default().bg(theme.bg));
-
-    let inner_area = block.inner(area);
-    f.render_widget(block, area);
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(3), Constraint::Min(1)])
-        .split(inner_area);
-
-    // Content
-    let content_chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)])
-        .split(chunks[1]);
-
-    if auth_state.role.as_deref() != Some("admin") {
-        render_admin_panel_non_admin(
-            f,
-            admin_state,
-            &content_chunks,
-            theme,
-            profile_tree,
-            selected_profile,
-        );
-    } else {
-        render_admin_panel_admin(
-            f,
-            chunks[1],
-            app_state,
-            admin_state,
-            theme,
-        );
-    }
-}
-
-/// Renders the view for non-admin users (profile list and details).
-fn render_admin_panel_non_admin(
-    f: &mut Frame,
-    admin_state: &AdminState,
-    content_chunks: &[Rect],
-    theme: &Theme,
-    profile_tree: &ProfileTreeResponse,
-    selected_profile: &Option<String>,
-) {
-    // Profile list - Use data from admin_state
-    let items: Vec<ListItem> = admin_state
-        .profiles
-        .iter()
-        .map(|p| {
-            ListItem::new(Line::from(vec![
-                Span::styled(
-                    if Some(p) == selected_profile.as_ref() { "✓ " } else { "  " },
-                    Style::default().fg(theme.accent),
-                ),
-                Span::styled(p, Style::default().fg(theme.fg)),
-            ]))
-        })
-        .collect();
-
-    let list = List::new(items)
-        .block(Block::default().title("Profiles"))
-        .highlight_style(Style::default().bg(theme.highlight).fg(theme.bg));
-
-    let mut profile_list_state_clone = admin_state.profile_list_state.clone();
-    f.render_stateful_widget(list, content_chunks[0], &mut profile_list_state_clone);
-
-    // Profile details - Use selection info from admin_state
-    if let Some(profile) = admin_state
-        .get_selected_index()
-        .and_then(|i| profile_tree.profiles.get(i))
-    {
-        let mut text = Text::default();
-        text.lines.push(Line::from(vec![
-            Span::styled("Profile: ", Style::default().fg(theme.accent)),
-            Span::styled(&profile.name, Style::default().fg(theme.highlight)),
-        ]));
-
-        text.lines.push(Line::from(""));
-        text.lines.push(Line::from(Span::styled(
-            "Tables:",
-            Style::default().fg(theme.accent),
-        )));
-
-        for table in &profile.tables {
-            let mut line = vec![Span::styled(format!("├─ {}", table.name), theme.fg)];
-            if !table.depends_on.is_empty() {
-                line.push(Span::styled(
-                    format!(" → {}", table.depends_on.join(", ")),
-                    Style::default().fg(theme.secondary),
-                ));
-            }
-            text.lines.push(Line::from(line));
-        }
-
-        let details_widget = Paragraph::new(text)
-            .block(Block::default().title("Details"))
-            .wrap(Wrap { trim: true });
-        f.render_widget(details_widget, content_chunks[1]);
-    }
-}

client/src/components/admin/admin_panel_admin.rs

@@ -1,180 +0,0 @@
-// src/components/admin/admin_panel_admin.rs
-
-use crate::config::colors::themes::Theme;
-use crate::state::pages::admin::{AdminFocus, AdminState};
-use crate::state::app::state::AppState;
-use ratatui::{
-    layout::{Alignment, Constraint, Direction, Layout, Rect},
-    style::Style,
-    text::{Line, Span, Text},
-    widgets::{Block, BorderType, Borders, List, ListItem, Paragraph},
-    Frame,
-};
-
-pub fn render_admin_panel_admin(
-    f: &mut Frame,
-    area: Rect,
-    app_state: &AppState,
-    admin_state: &mut AdminState,
-    theme: &Theme,
-) {
-    let main_chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Min(0), Constraint::Length(1)].as_ref())
-        .split(area);
-    let panes_area = main_chunks[0];
-    let buttons_area = main_chunks[1];
-
-    let pane_chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([
-            Constraint::Percentage(25), // Profiles
-            Constraint::Percentage(40), // Tables
-            Constraint::Percentage(35), // Dependencies
-        ].as_ref())
-        .split(panes_area);
-
-    let profiles_pane = pane_chunks[0];
-    let tables_pane = pane_chunks[1];
-    let deps_pane = pane_chunks[2];
-
-    // --- Profiles Pane (Left) ---
-    let profile_pane_has_focus = matches!(admin_state.current_focus, AdminFocus::ProfilesPane | AdminFocus::InsideProfilesList);
-    let profile_border_style = if profile_pane_has_focus {
-        Style::default().fg(theme.highlight)
-    } else {
-        Style::default().fg(theme.border)
-    };
-    let profiles_block = Block::default().title(" Profiles ").borders(Borders::ALL).border_type(BorderType::Rounded).border_style(profile_border_style);
-    let profiles_inner_area = profiles_block.inner(profiles_pane);
-    f.render_widget(profiles_block, profiles_pane);
-    let profile_list_items: Vec<ListItem> = app_state.profile_tree.profiles.iter().enumerate().map(|(idx, profile)| {
-        let is_persistently_selected = admin_state.selected_profile_index == Some(idx);
-        let is_nav_highlighted = admin_state.profile_list_state.selected() == Some(idx) && admin_state.current_focus == AdminFocus::InsideProfilesList;
-        let prefix = if is_persistently_selected { "[*] " } else { "[ ] " };
-        let item_style = if is_nav_highlighted { Style::default().fg(theme.highlight).add_modifier(ratatui::style::Modifier::BOLD) }
-                         else if is_persistently_selected { Style::default().fg(theme.accent) }
-                         else { Style::default().fg(theme.fg) };
-        ListItem::new(Line::from(vec![Span::styled(prefix, item_style), Span::styled(&profile.name, item_style)]))
-    }).collect();
-    let profile_list = List::new(profile_list_items)
-        .highlight_style(if admin_state.current_focus == AdminFocus::InsideProfilesList { Style::default().add_modifier(ratatui::style::Modifier::REVERSED) } else { Style::default() })
-        .highlight_symbol(if admin_state.current_focus == AdminFocus::InsideProfilesList { "> " } else { "  " });
-    f.render_stateful_widget(profile_list, profiles_inner_area, &mut admin_state.profile_list_state);
-
-
-    // --- Tables Pane (Middle) ---
-    let table_pane_has_focus = matches!(admin_state.current_focus, AdminFocus::Tables | AdminFocus::InsideTablesList);
-    let table_border_style = if table_pane_has_focus { Style::default().fg(theme.highlight) } else { Style::default().fg(theme.border) };
-    
-    let profile_to_display_tables_for_idx: Option<usize>;
-    if admin_state.current_focus == AdminFocus::InsideProfilesList {
-        profile_to_display_tables_for_idx = admin_state.profile_list_state.selected();
-    } else {
-        profile_to_display_tables_for_idx = admin_state.selected_profile_index
-            .or_else(|| admin_state.profile_list_state.selected());
-    }
-    let tables_pane_title_profile_name = profile_to_display_tables_for_idx
-        .and_then(|idx| app_state.profile_tree.profiles.get(idx))
-        .map_or("None Selected", |p| p.name.as_str());
-    let tables_block = Block::default().title(format!(" Tables (Profile: {}) ", tables_pane_title_profile_name)).borders(Borders::ALL).border_type(BorderType::Rounded).border_style(table_border_style);
-    let tables_inner_area = tables_block.inner(tables_pane);
-    f.render_widget(tables_block, tables_pane);
-
-    let table_list_items_for_display: Vec<ListItem> =
-        if let Some(profile_data_for_tables) = profile_to_display_tables_for_idx
-            .and_then(|idx| app_state.profile_tree.profiles.get(idx)) {
-            profile_data_for_tables.tables.iter().enumerate().map(|(idx, table)| {
-                let is_table_persistently_selected = admin_state.selected_table_index == Some(idx) &&
-                                                     profile_to_display_tables_for_idx == admin_state.selected_profile_index;
-                let is_table_nav_highlighted = admin_state.table_list_state.selected() == Some(idx) &&
-                                               admin_state.current_focus == AdminFocus::InsideTablesList;
-                let prefix = if is_table_persistently_selected { "[*] " } else { "[ ] " };
-                let style = if is_table_nav_highlighted { Style::default().fg(theme.highlight).add_modifier(ratatui::style::Modifier::BOLD) }
-                            else if is_table_persistently_selected { Style::default().fg(theme.accent) }
-                            else { Style::default().fg(theme.fg) };
-                ListItem::new(Line::from(vec![Span::styled(prefix, style), Span::styled(&table.name, style)]))
-            }).collect()
-        } else {
-            vec![ListItem::new("Select a profile to see tables")]
-        };
-    let table_list = List::new(table_list_items_for_display)
-        .highlight_style(if admin_state.current_focus == AdminFocus::InsideTablesList { Style::default().add_modifier(ratatui::style::Modifier::REVERSED) } else { Style::default() })
-        .highlight_symbol(if admin_state.current_focus == AdminFocus::InsideTablesList { "> " } else { "  " });
-    f.render_stateful_widget(table_list, tables_inner_area, &mut admin_state.table_list_state);
-
-
-    // --- Dependencies Pane (Right) ---
-    let mut deps_pane_title_table_name = "N/A".to_string();
-    let dependencies_to_display: Vec<String>;
-
-    if admin_state.current_focus == AdminFocus::InsideTablesList {
-        // If navigating tables, show dependencies for the '>' highlighted table.
-        // The profile context is `profile_to_display_tables_for_idx` (from Tables pane logic).
-        if let Some(p_idx_for_current_tables) = profile_to_display_tables_for_idx {
-            if let Some(current_profile_showing_tables) = app_state.profile_tree.profiles.get(p_idx_for_current_tables) {
-                if let Some(table_nav_idx) = admin_state.table_list_state.selected() { // The '>' highlighted table
-                    if let Some(navigated_table) = current_profile_showing_tables.tables.get(table_nav_idx) {
-                        deps_pane_title_table_name = navigated_table.name.clone();
-                        dependencies_to_display = navigated_table.depends_on.clone();
-                    } else {
-                        dependencies_to_display = Vec::new(); // Navigated table index out of bounds
-                    }
-                } else {
-                    dependencies_to_display = Vec::new(); // No table navigated with '>'
-                }
-            } else {
-                dependencies_to_display = Vec::new(); // Profile for tables out of bounds
-            }
-        } else {
-            dependencies_to_display = Vec::new(); // No profile active for table display
-        }
-    } else {
-        // Otherwise, show dependencies for the '[*]' persistently selected table & profile.
-        if let Some(p_idx) = admin_state.selected_profile_index { // Must be a persistently selected profile
-            if let Some(selected_profile) = app_state.profile_tree.profiles.get(p_idx) {
-                if let Some(t_idx) = admin_state.selected_table_index { // Must be a persistently selected table
-                    if let Some(selected_table) = selected_profile.tables.get(t_idx) {
-                        deps_pane_title_table_name = selected_table.name.clone();
-                        dependencies_to_display = selected_table.depends_on.clone();
-                    } else { dependencies_to_display = Vec::new(); }
-                } else { dependencies_to_display = Vec::new(); }
-            } else { dependencies_to_display = Vec::new(); }
-        } else { dependencies_to_display = Vec::new(); }
-    }
-
-    let deps_block = Block::default()
-        .title(format!(" Dependencies (Table: {}) ", deps_pane_title_table_name))
-        .borders(Borders::ALL)
-        .border_type(BorderType::Rounded)
-        .border_style(Style::default().fg(theme.border));
-    let deps_inner_area = deps_block.inner(deps_pane);
-    f.render_widget(deps_block, deps_pane);
-
-    let mut deps_content = Text::default();
-    deps_content.lines.push(Line::from(Span::styled(
-                "Depends On:",
-                Style::default().fg(theme.accent),
-    )));
-
-    if !dependencies_to_display.is_empty() {
-        for dep in dependencies_to_display {
-            deps_content.lines.push(Line::from(Span::styled(format!("- {}", dep), theme.fg)));
-        }
-    } else {
-        deps_content.lines.push(Line::from(Span::styled("  None", theme.secondary)));
-    }
-    let deps_paragraph = Paragraph::new(deps_content);
-    f.render_widget(deps_paragraph, deps_inner_area);
-
-    // --- Buttons Row ---
-    let button_chunks = Layout::default().direction(Direction::Horizontal).constraints([Constraint::Percentage(33), Constraint::Percentage(34), Constraint::Percentage(33)].as_ref()).split(buttons_area);
-    let btn_base_style = Style::default().fg(theme.secondary);
-    let get_btn_style = |button_focus: AdminFocus| { if admin_state.current_focus == button_focus { btn_base_style.add_modifier(ratatui::style::Modifier::REVERSED) } else { btn_base_style } };
-    let btn1 = Paragraph::new("Add Logic").style(get_btn_style(AdminFocus::Button1)).alignment(Alignment::Center);
-    let btn2 = Paragraph::new("Add Table").style(get_btn_style(AdminFocus::Button2)).alignment(Alignment::Center);
-    let btn3 = Paragraph::new("Change Table").style(get_btn_style(AdminFocus::Button3)).alignment(Alignment::Center);
-    f.render_widget(btn1, button_chunks[0]);
-    f.render_widget(btn2, button_chunks[1]);
-    f.render_widget(btn3, button_chunks[2]);
-}

client/src/components/auth.rs

@@ -1,6 +0,0 @@
-// src/components/form.rs
-pub mod login;
-pub mod register;
-
-pub use login::*;
-pub use register::*;

client/src/components/auth/login.rs

@@ -1,149 +0,0 @@
-// src/components/auth/login.rs
-
-use crate::{
-    config::colors::themes::Theme,
-    state::pages::auth::LoginState,
-    components::common::dialog,
-    state::app::state::AppState,
-};
-use ratatui::{
-    layout::{Alignment, Constraint, Direction, Layout, Rect, Margin},
-    style::{Style, Modifier, Color},
-    widgets::{Block, BorderType, Borders, Paragraph},
-    Frame,
-};
-use crate::state::app::highlight::HighlightState;
-
-pub fn render_login(
-    f: &mut Frame,
-    area: Rect,
-    theme: &Theme,
-    login_state: &LoginState,
-    app_state: &AppState,
-    is_edit_mode: bool,
-    highlight_state: &HighlightState,
-) {
-    // Main container
-    let block = Block::default()
-        .borders(Borders::ALL)
-        .border_type(BorderType::Plain)
-        .border_style(Style::default().fg(theme.border))
-        .title(" Login ")
-        .style(Style::default().bg(theme.bg));
-
-    f.render_widget(block, area);
-
-    let inner_area = area.inner(Margin {
-        horizontal: 1,
-        vertical: 1,
-    });
-
-    // Layout chunks
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(4),  // Form (2 fields + padding)
-            Constraint::Length(1),  // Error message
-            Constraint::Length(3),  // Buttons
-        ])
-        .split(inner_area);
-
-    // --- FORM RENDERING ---
-    crate::components::handlers::canvas::render_canvas(
-        f,
-        chunks[0],
-        login_state,
-        &["Username/Email", "Password"],
-        &login_state.current_field,
-        &[&login_state.username, &login_state.password],
-        theme,
-        is_edit_mode,
-        highlight_state,
-    );
-
-    // --- ERROR MESSAGE ---
-    if let Some(err) = &login_state.error_message {
-        f.render_widget(
-            Paragraph::new(err.as_str())
-                .style(Style::default().fg(Color::Red))
-                .alignment(Alignment::Center),
-            chunks[1],
-        );
-    }
-
-    // --- BUTTONS ---
-    let button_chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-        .split(chunks[2]);
-
-    // Login Button
-    let login_button_index = 0;
-    let login_active = if app_state.ui.focus_outside_canvas {
-        app_state.focused_button_index== login_button_index
-    } else {
-        false
-    };    
-    let mut login_style = Style::default().fg(theme.fg);
-    let mut login_border = Style::default().fg(theme.border);
-    if login_active {
-        login_style = login_style.fg(theme.highlight).add_modifier(Modifier::BOLD);
-        login_border = login_border.fg(theme.accent);
-    }
-
-    f.render_widget(
-        Paragraph::new("Login")
-            .style(login_style)
-            .alignment(Alignment::Center)
-            .block(
-                Block::default()
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Plain)
-                    .border_style(login_border),
-            ),
-        button_chunks[0],
-    );
-
-    // Return Button
-    let return_button_index = 1; // Assuming Return is the second general element
-    let return_active = if app_state.ui.focus_outside_canvas {
-        app_state.focused_button_index== return_button_index
-    } else {
-        false // Not active if focus is in canvas or other modes
-    };    
-    let mut return_style = Style::default().fg(theme.fg);
-    let mut return_border = Style::default().fg(theme.border);
-    if return_active {
-        return_style = return_style.fg(theme.highlight).add_modifier(Modifier::BOLD);
-        return_border = return_border.fg(theme.accent);
-    }
-
-    f.render_widget(
-        Paragraph::new("Return")
-            .style(return_style)
-            .alignment(Alignment::Center)
-            .block(
-                Block::default()
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Plain)
-                    .border_style(return_border),
-            ),
-        button_chunks[1],
-    );
-
-    // --- DIALOG ---
-    // Check the correct field name for showing the dialog
-    if app_state.ui.dialog.dialog_show {
-        // Pass all 7 arguments correctly
-        dialog::render_dialog(
-            f,
-            f.area(),
-            theme,
-            &app_state.ui.dialog.dialog_title,
-            &app_state.ui.dialog.dialog_message,
-            &app_state.ui.dialog.dialog_buttons, // Pass buttons slice
-            app_state.ui.dialog.dialog_active_button_index, 
-            app_state.ui.dialog.is_loading,
-        );
-    }
-}

client/src/components/auth/register.rs

@@ -1,174 +0,0 @@
-// src/components/auth/register.rs
-
-use crate::{
-    config::colors::themes::Theme,
-    state::pages::auth::RegisterState, // Use RegisterState
-    components::common::{dialog, autocomplete},    
-    state::app::state::AppState,
-    state::pages::canvas_state::CanvasState,
-    modes::handlers::mode_manager::AppMode,
-};
-use ratatui::{
-    layout::{Alignment, Constraint, Direction, Layout, Rect, Margin},
-    style::{Style, Modifier, Color},
-    widgets::{Block, BorderType, Borders, Paragraph},
-    Frame,
-};
-use crate::state::app::highlight::HighlightState;
-
-pub fn render_register(
-    f: &mut Frame,
-    area: Rect,
-    theme: &Theme,
-    state: &RegisterState, // Use RegisterState
-    app_state: &AppState,
-    is_edit_mode: bool,
-    highlight_state: &HighlightState,
-) {
-    let block = Block::default()
-        .borders(Borders::ALL)
-        .border_type(BorderType::Plain)
-        .border_style(Style::default().fg(theme.border))
-        .title(" Register ") // Update title
-        .style(Style::default().bg(theme.bg));
-
-    f.render_widget(block, area);
-
-    let inner_area = area.inner(Margin {
-        horizontal: 1,
-        vertical: 1,
-    });
-
-    // Adjust constraints for 4 fields + error + buttons
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(7), // Form (5 fields + padding)
-            Constraint::Length(1), // Help text line
-            Constraint::Length(1), // Error message
-            Constraint::Length(3), // Buttons
-        ])
-        .split(inner_area);
-
-    // --- FORM RENDERING (Using render_canvas) ---
-    let active_field_rect = crate::components::handlers::canvas::render_canvas(
-        f,
-        chunks[0], // Area for the canvas
-        state,     // The state object (RegisterState)
-        &[         // Field labels
-            "Username",
-            "Email*",
-            "Password*",
-            "Confirm Password",
-            "Role* (Tab)",
-        ],
-        &state.current_field(), // Pass current field index
-        &state.inputs().iter().map(|s| *s).collect::<Vec<&String>>(), // Pass inputs directly
-        theme,
-        is_edit_mode,
-        highlight_state,
-    );
-
-    // --- HELP TEXT ---
-    let help_text = Paragraph::new("* are optional fields")
-        .style(Style::default().fg(theme.fg))
-        .alignment(Alignment::Center);
-    f.render_widget(help_text, chunks[1]);
-
-   
-    // --- ERROR MESSAGE ---
-    if let Some(err) = &state.error_message {
-        f.render_widget(
-            Paragraph::new(err.as_str())
-                .style(Style::default().fg(Color::Red))
-                .alignment(Alignment::Center),
-            chunks[2],
-        );
-    }
-
-    // --- BUTTONS ---
-    let button_chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-        .split(chunks[3]);
-
-    // Register Button
-    let register_button_index = 0;
-    let register_active = if app_state.ui.focus_outside_canvas {
-        app_state.focused_button_index== register_button_index
-    } else {
-        false
-    };
-    let mut register_style = Style::default().fg(theme.fg);
-    let mut register_border = Style::default().fg(theme.border);
-    if register_active {
-        register_style = register_style.fg(theme.highlight).add_modifier(Modifier::BOLD);
-        register_border = register_border.fg(theme.accent);
-    }
-
-    f.render_widget(
-        Paragraph::new("Register") // Update button text
-            .style(register_style)
-            .alignment(Alignment::Center)
-            .block(
-                Block::default()
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Plain)
-                    .border_style(register_border),
-            ),
-        button_chunks[0],
-    );
-
-    // Return Button (logic remains similar)
-    let return_button_index = 1;
-    let return_active = if app_state.ui.focus_outside_canvas {
-        app_state.focused_button_index== return_button_index
-    } else {
-        false
-    };
-    let mut return_style = Style::default().fg(theme.fg);
-    let mut return_border = Style::default().fg(theme.border);
-    if return_active {
-        return_style = return_style.fg(theme.highlight).add_modifier(Modifier::BOLD);
-        return_border = return_border.fg(theme.accent);
-    }
-
-    f.render_widget(
-        Paragraph::new("Return")
-            .style(return_style)
-            .alignment(Alignment::Center)
-            .block(
-                Block::default()
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Plain)
-                    .border_style(return_border),
-            ),
-        button_chunks[1],
-    );
-
-    // --- Render Autocomplete Dropdown (Draw AFTER buttons) ---
-    if app_state.current_mode == AppMode::Edit {
-        if let Some(suggestions) = state.get_suggestions() {
-            let selected = state.get_selected_suggestion_index();
-            if !suggestions.is_empty() {
-                if let Some(input_rect) = active_field_rect {
-                    autocomplete::render_autocomplete_dropdown(f, input_rect, f.area(), theme, suggestions, selected);
-                }    
-            }
-        }
-    }
-
-    // --- DIALOG --- (Keep dialog logic)
-    if app_state.ui.dialog.dialog_show {
-        dialog::render_dialog(
-            f,
-            f.area(),
-            theme,
-            &app_state.ui.dialog.dialog_title,
-            &app_state.ui.dialog.dialog_message,
-            &app_state.ui.dialog.dialog_buttons,
-            app_state.ui.dialog.dialog_active_button_index,
-            app_state.ui.dialog.is_loading,
-        );
-    }
-}

client/src/components/common.rs

@@ -1,16 +0,0 @@
-// src/components/common.rs
-pub mod command_line;
-pub mod status_line;
-pub mod text_editor;
-pub mod background;
-pub mod dialog;
-pub mod autocomplete;
-pub mod find_file_palette;
-
-pub use command_line::*;
-pub use status_line::*;
-pub use text_editor::*;
-pub use background::*;
-pub use dialog::*;
-pub use autocomplete::*;
-pub use find_file_palette::*;

client/src/components/common/autocomplete.rs

@@ -1,90 +0,0 @@
-// src/components/common/autocomplete.rs
-
-use crate::config::colors::themes::Theme;
-use ratatui::{
-    layout::Rect,
-    style::{Color, Modifier, Style},
-    widgets::{Block, List, ListItem, ListState},
-    Frame,
-};
-use unicode_width::UnicodeWidthStr;
-
-/// Renders an opaque dropdown list for autocomplete suggestions.
-pub fn render_autocomplete_dropdown(
-    f: &mut Frame,
-    input_rect: Rect,
-    frame_area: Rect,
-    theme: &Theme,
-    suggestions: &[String],
-    selected_index: Option<usize>,
-) {
-    if suggestions.is_empty() {
-        return;
-    }
-    // --- Calculate Dropdown Size & Position ---
-    let max_suggestion_width = suggestions.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
-    let horizontal_padding: u16 = 2;
-    let dropdown_width = (max_suggestion_width + horizontal_padding).max(10);
-    let dropdown_height = (suggestions.len() as u16).min(5);
-
-    let mut dropdown_area = Rect {
-        x: input_rect.x, // Align horizontally with input
-        y: input_rect.y + 1, // Position directly below input
-        width: dropdown_width,
-        height: dropdown_height,
-    };
-
-    // --- Clamping Logic (prevent rendering off-screen) ---
-    // Clamp vertically (if it goes below the frame)
-    if dropdown_area.bottom() > frame_area.height {
-        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height); // Try rendering above
-    }
-    // Clamp horizontally (if it goes past the right edge)
-    if dropdown_area.right() > frame_area.width {
-        dropdown_area.x = frame_area.width.saturating_sub(dropdown_width);
-    }
-    // Ensure x is not negative (if clamping pushes it left)
-    dropdown_area.x = dropdown_area.x.max(0);
-    // Ensure y is not negative (if clamping pushes it up)
-    dropdown_area.y = dropdown_area.y.max(0);
-    // --- End Clamping ---
-
-    // Render a solid background block first to ensure opacity
-    let background_block = Block::default().style(Style::default().bg(Color::DarkGray));
-    f.render_widget(background_block, dropdown_area);
-
-    // Create list items, ensuring each has a defined background
-    let items: Vec<ListItem> = suggestions
-        .iter()
-        .enumerate()
-        .map(|(i, s)| {
-            let is_selected = selected_index == Some(i);
-            let s_width = s.width() as u16;
-            let padding_needed = dropdown_width.saturating_sub(s_width);
-            let padded_s = format!("{}{}", s, " ".repeat(padding_needed as usize));
-
-            ListItem::new(padded_s).style(if is_selected {
-                Style::default()
-                    .fg(theme.bg) // Text color on highlight
-                    .bg(theme.highlight) // Highlight background
-                    .add_modifier(Modifier::BOLD)
-            } else {
-                // Style for non-selected items (matching background block)
-                Style::default()
-                    .fg(theme.fg) // Text color on gray
-                    .bg(Color::DarkGray) // Explicit gray background
-            })
-        })
-        .collect();
-
-    // Create the list widget (without its own block)
-    let list = List::new(items);
-
-    // State for managing selection highlight (still needed for logic)
-    let mut profile_list_state = ListState::default();
-    profile_list_state.select(selected_index);
-
-    // Render the list statefully *over* the background block
-    f.render_stateful_widget(list, dropdown_area, &mut profile_list_state);
-}
-

client/src/components/common/background.rs

@@ -1,15 +0,0 @@
-// src/components/handlers/background.rs
-use ratatui::{
-    widgets::{Block},
-    layout::Rect,
-    style::Style,
-    Frame,
-};
-use crate::config::colors::themes::Theme;
-
-pub fn render_background(f: &mut Frame, area: Rect, theme: &Theme) {
-    let background = Block::default()
-        .style(Style::default().bg(theme.bg));
-    
-    f.render_widget(background, area);
-}

client/src/components/common/command_line.rs

@@ -1,69 +0,0 @@
-// src/components/common/command_line.rs
-
-use ratatui::{
-    widgets::{Block, Paragraph},
-    style::Style,
-    layout::Rect,
-    Frame,
-};
-use crate::config::colors::themes::Theme;
-use unicode_width::UnicodeWidthStr; // Import for width calculation
-
-pub fn render_command_line(
-    f: &mut Frame,
-    area: Rect,
-    input: &str,    // This is event_handler.command_input
-    active: bool,   // This is event_handler.command_mode
-    theme: &Theme,
-    message: &str,  // This is event_handler.command_message
-) {
-    // Original logic for determining display_text
-    let display_text = if !active {
-        // If not in normal command mode, but there's a message (e.g. from Find File palette closing)
-        // Or if command mode is off and message is empty (render minimally)
-        if message.is_empty() {
-            "".to_string() // Render an empty string, background will cover
-        } else {
-            message.to_string()
-        }
-    } else { // active is true (normal command mode)
-        let prompt = ":";
-        if message.is_empty() || message == ":" {
-            format!("{}{}", prompt, input)
-        } else {
-            if input.is_empty() { // If command was just executed, input is cleared, show message
-                message.to_string()
-            } else { // Show input and message
-                format!("{}{} | {}", prompt, input, message)
-            }
-        }
-    };
-
-    let content_width = UnicodeWidthStr::width(display_text.as_str());
-    let available_width = area.width as usize;
-    let padding_needed = available_width.saturating_sub(content_width);
-
-    let display_text_padded = if padding_needed > 0 {
-        format!("{}{}", display_text, " ".repeat(padding_needed))
-    } else {
-        // If text is too long, ratatui's Paragraph will handle truncation.
-        // We could also truncate here if specific behavior is needed:
-        // display_text.chars().take(available_width).collect::<String>()
-        display_text
-    };
-
-    // Determine style based on active state, but apply to the whole paragraph
-    let text_style = if active {
-        Style::default().fg(theme.accent)
-    } else {
-        // If not active, but there's a message, use default foreground.
-        // If message is also empty, this style won't matter much for empty text.
-        Style::default().fg(theme.fg)
-    };
-
-    let paragraph = Paragraph::new(display_text_padded)
-        .block(Block::default().style(Style::default().bg(theme.bg))) // Block ensures bg for whole area
-        .style(text_style); // Style for the text itself
-
-    f.render_widget(paragraph, area);
-}

client/src/components/common/dialog.rs

@@ -1,183 +0,0 @@
-use crate::config::colors::themes::Theme;
-use ratatui::{
-    layout::{Constraint, Direction, Layout, Margin, Rect},
-    prelude::Alignment,
-    style::{Modifier, Style},
-    text::{Line, Span, Text},
-    widgets::{Block, BorderType, Borders, Paragraph, Clear},
-    Frame,
-};
-use unicode_segmentation::UnicodeSegmentation; // For grapheme clusters
-use unicode_width::UnicodeWidthStr; // For accurate width calculation
-
-pub fn render_dialog(
-    f: &mut Frame,
-    area: Rect,
-    theme: &Theme,
-    dialog_title: &str,
-    dialog_message: &str,
-    dialog_buttons: &[String],
-    dialog_active_button_index: usize,
-    is_loading: bool,
-) {
-    // Calculate required height based on the actual number of lines in the message
-    let message_lines: Vec<_> = dialog_message.lines().collect();
-    let message_height = message_lines.len() as u16;
-    let button_row_height = if dialog_buttons.is_empty() { 0 } else { 3 };
-    let vertical_padding = 2; // Block borders (top/bottom)
-    let inner_vertical_margin = 2; // Margin inside block (top/bottom)
-
-    // Calculate required height based on actual message lines
-    let required_inner_height =
-        message_height + button_row_height + inner_vertical_margin;
-    let required_total_height = required_inner_height + vertical_padding;
-
-    // Use a fixed percentage width, clamped to min/max
-    let width_percentage: u16 = 60;
-    let dialog_width = (area.width * width_percentage / 100)
-        .max(20) // Minimum width
-        .min(area.width); // Maximum width
-
-    // Ensure height doesn't exceed available area
-    let dialog_height = required_total_height.min(area.height);
-
-    // Calculate centered area manually
-    let dialog_x = area.x + (area.width.saturating_sub(dialog_width)) / 2;
-    let dialog_y = area.y + (area.height.saturating_sub(dialog_height)) / 2;
-    let dialog_area = Rect::new(dialog_x, dialog_y, dialog_width, dialog_height);
-
-    // Clear the area first before drawing the dialog
-    f.render_widget(Clear, dialog_area);
-
-    let block = Block::default()
-        .borders(Borders::ALL)
-        .border_type(BorderType::Rounded)
-        .border_style(Style::default().fg(theme.accent))
-        .title(format!(" {} ", dialog_title)) // Add padding to title
-        .style(Style::default().bg(theme.bg));
-
-    f.render_widget(block, dialog_area);
-
-    // Calculate inner area *after* defining the block
-    let inner_area = dialog_area.inner(Margin {
-        horizontal: 2, // Left/Right padding inside border
-        vertical: 1,   // Top/Bottom padding inside border
-    });
-
-    if is_loading {
-        // --- Loading State ---
-        let loading_text = Paragraph::new(dialog_message) // Use the message passed for loading
-            .style(Style::default().fg(theme.fg).add_modifier(Modifier::ITALIC))
-            .alignment(Alignment::Center);
-        // Render loading message centered in the inner area
-        f.render_widget(loading_text, inner_area);
-    } else {
-        // --- Normal State (Message + Buttons) ---
-
-        // Layout for Message and Buttons based on actual message height
-        let mut constraints = vec![
-            // Allocate space for message, ensuring at least 1 line height
-            Constraint::Length(message_height.max(1)), // Use actual calculated height
-        ];
-        if button_row_height > 0 {
-            constraints.push(Constraint::Length(button_row_height));
-        }
-
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints(constraints)
-            .split(inner_area);
-
-        // Render Message
-        let available_width = inner_area.width as usize;
-        let ellipsis = "...";
-        let ellipsis_width = UnicodeWidthStr::width(ellipsis);
-
-        let processed_lines: Vec<Line> = message_lines
-            .into_iter()
-            .map(|line| {
-                let line_width = UnicodeWidthStr::width(line);
-                if line_width > available_width {
-                    // Truncate with ellipsis
-                    let mut truncated_len = 0;
-                    let mut current_width = 0;
-                    for (idx, grapheme) in line.grapheme_indices(true) {
-                        let grapheme_width = UnicodeWidthStr::width(grapheme);
-                        if current_width + grapheme_width
-                            > available_width.saturating_sub(ellipsis_width)
-                        {
-                            break;
-                        }
-                        current_width += grapheme_width;
-                        truncated_len = idx + grapheme.len();
-                    }
-                    let truncated_line =
-                        format!("{}{}", &line[..truncated_len], ellipsis);
-                    Line::from(Span::styled(
-                            truncated_line,
-                            Style::default().fg(theme.fg),
-                    ))
-                } else {
-                    Line::from(Span::styled(line, Style::default().fg(theme.fg)))
-                }
-            })
-        .collect();
-
-        let message_paragraph =
-            Paragraph::new(Text::from(processed_lines)).alignment(Alignment::Center);
-        f.render_widget(message_paragraph, chunks[0]); // Render message in the first chunk
-
-        // Render Buttons if they exist and there's a chunk for them
-        if !dialog_buttons.is_empty() && chunks.len() > 1 {
-            let button_area = chunks[1];
-            let button_count = dialog_buttons.len();
-
-            let button_constraints = std::iter::repeat(Constraint::Ratio(
-                    1,
-                    button_count as u32,
-            ))
-                .take(button_count)
-                .collect::<Vec<_>>();
-
-            let button_chunks = Layout::default()
-                .direction(Direction::Horizontal)
-                .constraints(button_constraints)
-                .horizontal_margin(1) // Add space between buttons
-                .split(button_area);
-
-            for (i, button_label) in dialog_buttons.iter().enumerate() {
-                if i >= button_chunks.len() {
-                    break;
-                }
-
-                let is_active = i == dialog_active_button_index;
-                let (button_style, border_style) = if is_active {
-                    (
-                        Style::default()
-                        .fg(theme.highlight)
-                        .add_modifier(Modifier::BOLD),
-                        Style::default().fg(theme.accent),
-                    )
-                } else {
-                    (
-                        Style::default().fg(theme.fg),
-                        Style::default().fg(theme.border),
-                    )
-                };
-
-                let button_block = Block::default()
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Plain)
-                    .border_style(border_style);
-
-                f.render_widget(
-                    Paragraph::new(button_label.as_str())
-                    .block(button_block)
-                    .style(button_style)
-                    .alignment(Alignment::Center),
-                    button_chunks[i],
-                );
-            }
-        }
-    }
-}

client/src/components/common/find_file_palette.rs

@@ -1,142 +0,0 @@
-// src/components/common/find_file_palette.rs
-
-use crate::config::colors::themes::Theme;
-use crate::modes::general::command_navigation::NavigationState; // Corrected path
-use ratatui::{
-    layout::{Constraint, Direction, Layout, Rect},
-    style::Style,
-    widgets::{Block, List, ListItem, Paragraph},
-    Frame,
-};
-use unicode_width::UnicodeWidthStr;
-
-const PALETTE_MAX_VISIBLE_OPTIONS: usize = 15;
-const PADDING_CHAR: &str = " ";
-
-pub fn render_find_file_palette(
-    f: &mut Frame,
-    area: Rect,
-    theme: &Theme,
-    navigation_state: &NavigationState,
-) {
-    let palette_display_input = navigation_state.get_display_input(); // Use the new method
-
-    let num_total_filtered = navigation_state.filtered_options.len();
-    let current_selected_list_idx = navigation_state.selected_index;
-
-    let mut display_start_offset = 0;
-    if num_total_filtered > PALETTE_MAX_VISIBLE_OPTIONS {
-        if let Some(sel_idx) = current_selected_list_idx {
-            if sel_idx >= display_start_offset + PALETTE_MAX_VISIBLE_OPTIONS {
-                display_start_offset = sel_idx - PALETTE_MAX_VISIBLE_OPTIONS + 1;
-            } else if sel_idx < display_start_offset {
-                display_start_offset = sel_idx;
-            }
-            display_start_offset = display_start_offset
-                .min(num_total_filtered.saturating_sub(PALETTE_MAX_VISIBLE_OPTIONS));
-        }
-    }
-    display_start_offset = display_start_offset.max(0);
-
-    let display_end_offset = (display_start_offset + PALETTE_MAX_VISIBLE_OPTIONS)
-        .min(num_total_filtered);
-
-    // navigation_state.filtered_options is Vec<(usize, String)>
-    // We only need the String part for display.
-    let visible_options_slice: Vec<&String> = if num_total_filtered > 0 {
-        navigation_state.filtered_options
-            [display_start_offset..display_end_offset]
-            .iter()
-            .map(|(_, opt_str)| opt_str)
-            .collect()
-    } else {
-        Vec::new()
-    };
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1), // For palette input line
-            Constraint::Min(0), // For options list, take remaining space
-        ])
-        .split(area);
-    
-    // Ensure list_area height does not exceed PALETTE_MAX_VISIBLE_OPTIONS
-    let list_area_height = std::cmp::min(chunks[1].height, PALETTE_MAX_VISIBLE_OPTIONS as u16);
-    let final_list_area = Rect::new(chunks[1].x, chunks[1].y, chunks[1].width, list_area_height);
-
-
-    let input_area = chunks[0];
-    // let list_area = chunks[1]; // Use final_list_area
-
-    let prompt_prefix = match navigation_state.navigation_type {
-        crate::modes::general::command_navigation::NavigationType::FindFile => "Find File: ",
-        crate::modes::general::command_navigation::NavigationType::TableTree => "Table Path: ",
-    };
-    let base_prompt_text = format!("{}{}", prompt_prefix, palette_display_input);
-    let prompt_text_width = UnicodeWidthStr::width(base_prompt_text.as_str());
-    let input_area_width = input_area.width as usize;
-    let input_padding_needed =
-        input_area_width.saturating_sub(prompt_text_width);
-
-    let padded_prompt_text = if input_padding_needed > 0 {
-        format!(
-            "{}{}",
-            base_prompt_text,
-            PADDING_CHAR.repeat(input_padding_needed)
-        )
-    } else {
-        base_prompt_text
-    };
-
-    let input_paragraph = Paragraph::new(padded_prompt_text)
-        .style(Style::default().fg(theme.accent).bg(theme.bg));
-    f.render_widget(input_paragraph, input_area);
-
-    let mut display_list_items: Vec<ListItem> =
-        Vec::with_capacity(PALETTE_MAX_VISIBLE_OPTIONS);
-
-    for (idx_in_visible_slice, opt_str) in
-        visible_options_slice.iter().enumerate()
-    {
-        // The selected_index in navigation_state is relative to the full filtered_options list.
-        // We need to check if the current item (from the visible slice) corresponds to the selected_index.
-        let original_filtered_idx = display_start_offset + idx_in_visible_slice;
-        let is_selected =
-            current_selected_list_idx == Some(original_filtered_idx);
-
-        let style = if is_selected {
-            Style::default().fg(theme.bg).bg(theme.accent)
-        } else {
-            Style::default().fg(theme.fg).bg(theme.bg)
-        };
-
-        let opt_width = opt_str.width() as u16;
-        let list_item_width = final_list_area.width;
-        let padding_amount = list_item_width.saturating_sub(opt_width);
-        let padded_opt_str = format!(
-            "{}{}",
-            opt_str,
-            PADDING_CHAR.repeat(padding_amount as usize)
-        );
-        display_list_items.push(ListItem::new(padded_opt_str).style(style));
-    }
-
-    // Fill remaining lines in the list area to maintain fixed height appearance
-    let num_rendered_options = display_list_items.len();
-    if num_rendered_options < PALETTE_MAX_VISIBLE_OPTIONS && (final_list_area.height as usize) > num_rendered_options {
-        for _ in num_rendered_options..(final_list_area.height as usize) {
-            let empty_padded_str =
-                PADDING_CHAR.repeat(final_list_area.width as usize);
-            display_list_items.push(
-                ListItem::new(empty_padded_str)
-                    .style(Style::default().fg(theme.bg).bg(theme.bg)),
-            );
-        }
-    }
-
-
-    let options_list_widget = List::new(display_list_items)
-        .block(Block::default().style(Style::default().bg(theme.bg)));
-    f.render_widget(options_list_widget, final_list_area);
-}

client/src/components/common/status_line.rs

@@ -1,98 +0,0 @@
-// src/components/common/status_line.rs
-use ratatui::{
-    style::Style,
-    layout::Rect,
-    Frame,
-    text::{Line, Span},
-    widgets::Paragraph,
-};
-use unicode_width::UnicodeWidthStr;
-use crate::config::colors::themes::Theme;
-use std::path::Path;
-
-pub fn render_status_line(
-    f: &mut Frame,
-    area: Rect,
-    current_dir: &str,
-    theme: &Theme,
-    is_edit_mode: bool,
-    current_fps: f64,
-) {
-    let program_info = format!("multieko2 v{}", env!("CARGO_PKG_VERSION"));
-    let mode_text = if is_edit_mode { "[EDIT]" } else { "[READ-ONLY]" };
-
-    let home_dir = dirs::home_dir().map(|p| p.to_string_lossy().into_owned()).unwrap_or_default();
-    let display_dir = if current_dir.starts_with(&home_dir) {
-        current_dir.replacen(&home_dir, "~", 1)
-    } else {
-        current_dir.to_string()
-    };
-
-    let available_width = area.width as usize;
-    let mode_width = UnicodeWidthStr::width(mode_text);
-    let program_info_width = UnicodeWidthStr::width(program_info.as_str());
-    let fps_text = format!("{:.0} FPS", current_fps);
-    let fps_width = UnicodeWidthStr::width(fps_text.as_str());
-    let separator = " | ";
-    let separator_width = UnicodeWidthStr::width(separator);
-
-    let fixed_width_with_fps = mode_width + separator_width + separator_width +
-        program_info_width + separator_width + fps_width;
-    let show_fps = fixed_width_with_fps <= available_width; // Use <= to show if it fits exactly
-
-    let remaining_width_for_dir = available_width.saturating_sub(
-        mode_width + separator_width + // after mode
-        separator_width + program_info_width + // after program_info
-        if show_fps { separator_width + fps_width } else { 0 } // after fps
-    );
-
-    // Original directory display logic
-    let dir_display_text_str = if UnicodeWidthStr::width(display_dir.as_str()) <= remaining_width_for_dir {
-        display_dir // display_dir is already a String here
-    } else {
-        let dir_name = Path::new(current_dir) // Use original current_dir for path logic
-            .file_name()
-            .and_then(|n| n.to_str())
-            .unwrap_or(current_dir); // Fallback to current_dir if no filename
-        if UnicodeWidthStr::width(dir_name) <= remaining_width_for_dir {
-            dir_name.to_string()
-        } else {
-            dir_name.chars().take(remaining_width_for_dir).collect::<String>()
-        }
-    };
-
-    // Calculate current content width based on what will be displayed
-    let mut current_content_width = mode_width + separator_width +
-                                    UnicodeWidthStr::width(dir_display_text_str.as_str()) +
-                                    separator_width + program_info_width;
-    if show_fps {
-        current_content_width += separator_width + fps_width;
-    }
-
-    let mut line_spans = vec![
-        Span::styled(mode_text, Style::default().fg(theme.accent)),
-        Span::styled(separator, Style::default().fg(theme.border)),
-        Span::styled(dir_display_text_str.as_str(), Style::default().fg(theme.fg)),
-        Span::styled(separator, Style::default().fg(theme.border)),
-        Span::styled(program_info.as_str(), Style::default().fg(theme.secondary)),
-    ];
-
-    if show_fps {
-        line_spans.push(Span::styled(separator, Style::default().fg(theme.border)));
-        line_spans.push(Span::styled(fps_text.as_str(), Style::default().fg(theme.secondary)));
-    }
-
-    // Calculate padding
-    let padding_needed = available_width.saturating_sub(current_content_width);
-    if padding_needed > 0 {
-        line_spans.push(Span::styled(
-            " ".repeat(padding_needed),
-            Style::default().bg(theme.bg), // Ensure padding uses background color
-        ));
-    }
-
-    let paragraph = Paragraph::new(Line::from(line_spans))
-        .style(Style::default().bg(theme.bg));
-
-    f.render_widget(paragraph, area);
-}

client/src/components/common/text_editor.rs

@@ -1,331 +0,0 @@
-// src/components/common/text_editor.rs
-use crate::config::binds::config::{EditorConfig, EditorKeybindingMode};
-use crossterm::event::{KeyEvent, KeyCode, KeyModifiers};
-use ratatui::style::{Color, Style, Modifier};
-use tui_textarea::{Input, Key, TextArea, CursorMove};
-use std::fmt;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum VimMode {
-    Normal,
-    Insert,
-    Visual,
-    Operator(char),
-}
-
-impl VimMode {
-    pub fn cursor_style(&self) -> Style {
-        let color = match self {
-            Self::Normal => Color::Reset,
-            Self::Insert => Color::LightBlue,
-            Self::Visual => Color::LightYellow,
-            Self::Operator(_) => Color::LightGreen,
-        };
-        Style::default().fg(color).add_modifier(Modifier::REVERSED)
-    }
-}
-
-impl fmt::Display for VimMode {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        match self {
-            Self::Normal => write!(f, "NORMAL"),
-            Self::Insert => write!(f, "INSERT"),
-            Self::Visual => write!(f, "VISUAL"),
-            Self::Operator(c) => write!(f, "OPERATOR({})", c),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-enum Transition {
-    Nop,
-    Mode(VimMode),
-    Pending(Input),
-}
-
-#[derive(Debug, Clone)]
-pub struct VimState {
-    pub mode: VimMode,
-    pub pending: Input,
-}
-
-impl Default for VimState {
-    fn default() -> Self {
-        Self {
-            mode: VimMode::Normal,
-            pending: Input::default(),
-        }
-    }
-}
-
-impl VimState {
-    pub fn new(mode: VimMode) -> Self {
-        Self {
-            mode,
-            pending: Input::default(),
-        }
-    }
-
-    fn with_pending(self, pending: Input) -> Self {
-        Self {
-            mode: self.mode,
-            pending,
-        }
-    }
-
-    fn transition(&self, input: Input, textarea: &mut TextArea<'_>) -> Transition {
-        if input.key == Key::Null {
-            return Transition::Nop;
-        }
-
-        match self.mode {
-            VimMode::Normal | VimMode::Visual | VimMode::Operator(_) => {
-                match input {
-                    Input { key: Key::Char('h'), .. } => textarea.move_cursor(CursorMove::Back),
-                    Input { key: Key::Char('j'), .. } => textarea.move_cursor(CursorMove::Down),
-                    Input { key: Key::Char('k'), .. } => textarea.move_cursor(CursorMove::Up),
-                    Input { key: Key::Char('l'), .. } => textarea.move_cursor(CursorMove::Forward),
-                    Input { key: Key::Char('w'), .. } => textarea.move_cursor(CursorMove::WordForward),
-                    Input { key: Key::Char('e'), ctrl: false, .. } => {
-                        textarea.move_cursor(CursorMove::WordEnd);
-                        if matches!(self.mode, VimMode::Operator(_)) {
-                            textarea.move_cursor(CursorMove::Forward);
-                        }
-                    }
-                    Input { key: Key::Char('b'), ctrl: false, .. } => textarea.move_cursor(CursorMove::WordBack),
-                    Input { key: Key::Char('^'), .. } => textarea.move_cursor(CursorMove::Head),
-                    Input { key: Key::Char('$'), .. } => textarea.move_cursor(CursorMove::End),
-                    Input { key: Key::Char('0'), .. } => textarea.move_cursor(CursorMove::Head),
-                    Input { key: Key::Char('D'), .. } => {
-                        textarea.delete_line_by_end();
-                        return Transition::Mode(VimMode::Normal);
-                    }
-                    Input { key: Key::Char('C'), .. } => {
-                        textarea.delete_line_by_end();
-                        textarea.cancel_selection();
-                        return Transition::Mode(VimMode::Insert);
-                    }
-                    Input { key: Key::Char('p'), .. } => {
-                        textarea.paste();
-                        return Transition::Mode(VimMode::Normal);
-                    }
-                    Input { key: Key::Char('u'), ctrl: false, .. } => {
-                        textarea.undo();
-                        return Transition::Mode(VimMode::Normal);
-                    }
-                    Input { key: Key::Char('r'), ctrl: true, .. } => {
-                        textarea.redo();
-                        return Transition::Mode(VimMode::Normal);
-                    }
-                    Input { key: Key::Char('x'), .. } => {
-                        textarea.delete_next_char();
-                        return Transition::Mode(VimMode::Normal);
-                    }
-                    Input { key: Key::Char('i'), .. } => {
-                        textarea.cancel_selection();
-                        return Transition::Mode(VimMode::Insert);
-                    }
-                    Input { key: Key::Char('a'), .. } => {
-                        textarea.cancel_selection();
-                        textarea.move_cursor(CursorMove::Forward);
-                        return Transition::Mode(VimMode::Insert);
-                    }
-                    Input { key: Key::Char('A'), .. } => {
-                        textarea.cancel_selection();
-                        textarea.move_cursor(CursorMove::End);
-                        return Transition::Mode(VimMode::Insert);
-                    }
-                    Input { key: Key::Char('o'), .. } => {
-                        textarea.move_cursor(CursorMove::End);
-                        textarea.insert_newline();
-                        return Transition::Mode(VimMode::Insert);
-                    }
-                    Input { key: Key::Char('O'), .. } => {
-                        textarea.move_cursor(CursorMove::Head);
-                        textarea.insert_newline();
-                        textarea.move_cursor(CursorMove::Up);
-                        return Transition::Mode(VimMode::Insert);
-                    }
-                    Input { key: Key::Char('I'), .. } => {
-                        textarea.cancel_selection();
-                        textarea.move_cursor(CursorMove::Head);
-                        return Transition::Mode(VimMode::Insert);
-                    }
-                    Input { key: Key::Char('v'), ctrl: false, .. } if self.mode == VimMode::Normal => {
-                        textarea.start_selection();
-                        return Transition::Mode(VimMode::Visual);
-                    }
-                    Input { key: Key::Char('V'), ctrl: false, .. } if self.mode == VimMode::Normal => {
-                        textarea.move_cursor(CursorMove::Head);
-                        textarea.start_selection();
-                        textarea.move_cursor(CursorMove::End);
-                        return Transition::Mode(VimMode::Visual);
-                    }
-                    Input { key: Key::Esc, .. } | Input { key: Key::Char('v'), ctrl: false, .. } if self.mode == VimMode::Visual => {
-                        textarea.cancel_selection();
-                        return Transition::Mode(VimMode::Normal);
-                    }
-                    Input { key: Key::Char('g'), ctrl: false, .. } if matches!(
-                        self.pending,
-                        Input { key: Key::Char('g'), ctrl: false, .. }
-                    ) => {
-                        textarea.move_cursor(CursorMove::Top)
-                    }
-                    Input { key: Key::Char('G'), ctrl: false, .. } => textarea.move_cursor(CursorMove::Bottom),
-                    Input { key: Key::Char(c), ctrl: false, .. } if self.mode == VimMode::Operator(c) => {
-                        textarea.move_cursor(CursorMove::Head);
-                        textarea.start_selection();
-                        let cursor = textarea.cursor();
-                        textarea.move_cursor(CursorMove::Down);
-                        if cursor == textarea.cursor() {
-                            textarea.move_cursor(CursorMove::End);
-                        }
-                    }
-                    Input { key: Key::Char(op @ ('y' | 'd' | 'c')), ctrl: false, .. } if self.mode == VimMode::Normal => {
-                        textarea.start_selection();
-                        return Transition::Mode(VimMode::Operator(op));
-                    }
-                    Input { key: Key::Char('y'), ctrl: false, .. } if self.mode == VimMode::Visual => {
-                        textarea.move_cursor(CursorMove::Forward);
-                        textarea.copy();
-                        return Transition::Mode(VimMode::Normal);
-                    }
-                    Input { key: Key::Char('d'), ctrl: false, .. } if self.mode == VimMode::Visual => {
-                        textarea.move_cursor(CursorMove::Forward);
-                        textarea.cut();
-                        return Transition::Mode(VimMode::Normal);
-                    }
-                    Input { key: Key::Char('c'), ctrl: false, .. } if self.mode == VimMode::Visual => {
-                        textarea.move_cursor(CursorMove::Forward);
-                        textarea.cut();
-                        return Transition::Mode(VimMode::Insert);
-                    }
-                    // Arrow keys work in normal mode
-                    Input { key: Key::Up, .. } => textarea.move_cursor(CursorMove::Up),
-                    Input { key: Key::Down, .. } => textarea.move_cursor(CursorMove::Down),
-                    Input { key: Key::Left, .. } => textarea.move_cursor(CursorMove::Back),
-                    Input { key: Key::Right, .. } => textarea.move_cursor(CursorMove::Forward),
-                    input => return Transition::Pending(input),
-                }
-
-                // Handle the pending operator
-                match self.mode {
-                    VimMode::Operator('y') => {
-                        textarea.copy();
-                        Transition::Mode(VimMode::Normal)
-                    }
-                    VimMode::Operator('d') => {
-                        textarea.cut();
-                        Transition::Mode(VimMode::Normal)
-                    }
-                    VimMode::Operator('c') => {
-                        textarea.cut();
-                        Transition::Mode(VimMode::Insert)
-                    }
-                    _ => Transition::Nop,
-                }
-            }
-            VimMode::Insert => match input {
-                Input { key: Key::Esc, .. } | Input { key: Key::Char('c'), ctrl: true, .. } => {
-                    Transition::Mode(VimMode::Normal)
-                }
-                input => {
-                    textarea.input(input);
-                    Transition::Mode(VimMode::Insert)
-                }
-            },
-        }
-    }
-}
-
-pub struct TextEditor;
-
-impl TextEditor {
-    pub fn new_textarea(editor_config: &EditorConfig) -> TextArea<'static> {
-        let mut textarea = TextArea::default();
-
-        if editor_config.show_line_numbers {
-            textarea.set_line_number_style(Style::default().fg(Color::DarkGray));
-        }
-
-        textarea.set_tab_length(editor_config.tab_width);
-
-        textarea
-    }
-
-    pub fn handle_input(
-        textarea: &mut TextArea<'static>,
-        key_event: KeyEvent,
-        keybinding_mode: &EditorKeybindingMode,
-        vim_state: &mut VimState,
-    ) -> bool {
-        match keybinding_mode {
-            EditorKeybindingMode::Vim => {
-                Self::handle_vim_input(textarea, key_event, vim_state)
-            }
-            _ => {
-                let tui_input: Input = key_event.into();
-                textarea.input(tui_input)
-            }
-        }
-    }
-
-    fn handle_vim_input(
-        textarea: &mut TextArea<'static>,
-        key_event: KeyEvent,
-        vim_state: &mut VimState,
-    ) -> bool {
-        let input = Self::convert_key_event_to_input(key_event);
-        
-        *vim_state = match vim_state.transition(input, textarea) {
-            Transition::Mode(mode) if vim_state.mode != mode => {
-                // Update cursor style based on mode
-                textarea.set_cursor_style(mode.cursor_style());
-                VimState::new(mode)
-            }
-            Transition::Nop | Transition::Mode(_) => vim_state.clone(),
-            Transition::Pending(input) => vim_state.clone().with_pending(input),
-        };
-
-        true // Always consider input as handled in vim mode
-    }
-
-    fn convert_key_event_to_input(key_event: KeyEvent) -> Input {
-        let key = match key_event.code {
-            KeyCode::Char(c) => Key::Char(c),
-            KeyCode::Enter => Key::Enter,
-            KeyCode::Left => Key::Left,
-            KeyCode::Right => Key::Right,
-            KeyCode::Up => Key::Up,
-            KeyCode::Down => Key::Down,
-            KeyCode::Backspace => Key::Backspace,
-            KeyCode::Delete => Key::Delete,
-            KeyCode::Home => Key::Home,
-            KeyCode::End => Key::End,
-            KeyCode::PageUp => Key::PageUp,
-            KeyCode::PageDown => Key::PageDown,
-            KeyCode::Tab => Key::Tab,
-            KeyCode::Esc => Key::Esc,
-            _ => Key::Null,
-        };
-
-        Input {
-            key,
-            ctrl: key_event.modifiers.contains(KeyModifiers::CONTROL),
-            alt: key_event.modifiers.contains(KeyModifiers::ALT),
-            shift: key_event.modifiers.contains(KeyModifiers::SHIFT),
-        }
-    }
-
-    pub fn get_vim_mode_status(vim_state: &VimState) -> String {
-        vim_state.mode.to_string()
-    }
-
-    pub fn is_vim_insert_mode(vim_state: &VimState) -> bool {
-        matches!(vim_state.mode, VimMode::Insert)
-    }
-
-    pub fn is_vim_normal_mode(vim_state: &VimState) -> bool {
-        matches!(vim_state.mode, VimMode::Normal)
-    }
-}

client/src/components/form.rs

@@ -1,4 +0,0 @@
-// src/components/form.rs
-pub mod form;
-
-pub use form::*;

client/src/components/form/form.rs

@@ -1,78 +0,0 @@
-// src/components/form/form.rs
-use ratatui::{
-    widgets::{Paragraph, Block, Borders},
-    layout::{Layout, Constraint, Direction, Rect, Margin, Alignment},
-    style::Style,
-    Frame,
-};
-use crate::config::colors::themes::Theme;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::highlight::HighlightState;
-use crate::components::handlers::canvas::render_canvas;
-
-pub fn render_form(
-    f: &mut Frame,
-    area: Rect,
-    form_state_param: &impl CanvasState,
-    fields: &[&str],
-    current_field_idx: &usize,
-    inputs: &[&String],
-    theme: &Theme,
-    is_edit_mode: bool,
-    highlight_state: &HighlightState,
-    total_count: u64,
-    current_position: u64,
-) {
-    // Create Adresar card
-    let adresar_card = Block::default()
-        .borders(Borders::ALL)
-        .border_style(Style::default().fg(theme.border))
-        .title(" Adresar ")
-        .style(Style::default().bg(theme.bg).fg(theme.fg));
-
-    f.render_widget(adresar_card, area);
-
-    // Define inner area
-    let inner_area = area.inner(Margin {
-        horizontal: 1,
-        vertical: 1,
-    });
-
-    // Create main layout
-    let main_layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1),
-            Constraint::Min(1),
-        ])
-        .split(inner_area);
-
-    // Render count/position
-    let count_position_text = if total_count == 0 && current_position == 1 {
-        "Total: 0 | New Entry".to_string()
-    } else if current_position > total_count && total_count > 0 {
-        format!("Total: {} | New Entry ({})", total_count, current_position)
-    } else if total_count == 0 && current_position > 1 { // Should not happen if logic is correct
-        format!("Total: 0 | New Entry ({})", current_position)
-    }
-    else {
-        format!("Total: {} | Position: {}/{}", total_count, current_position, total_count)
-    };
-    let count_para = Paragraph::new(count_position_text)
-        .style(Style::default().fg(theme.fg))
-        .alignment(Alignment::Left);
-    f.render_widget(count_para, main_layout[0]);
-
-    // Delegate input handling to canvas
-    render_canvas(
-        f,
-        main_layout[1],
-        form_state_param,
-        fields,
-        current_field_idx,
-        inputs,
-        theme,
-        is_edit_mode,
-        highlight_state,
-    );
-}

client/src/components/handlers.rs

@@ -1,8 +0,0 @@
-// src/components/handlers.rs
-pub mod canvas;
-pub mod sidebar;
-pub mod buffer_list;
-
-pub use canvas::*;
-pub use sidebar::*;
-pub use buffer_list::*;

client/src/components/handlers/buffer_list.rs

@@ -1,81 +0,0 @@
-// src/components/handlers/buffer_list.rs
-
-use crate::config::colors::themes::Theme;
-use crate::state::app::buffer::BufferState;
-use crate::state::app::state::AppState;  // Add this import
-use ratatui::{
-    layout::{Alignment, Rect},
-    style::Style,
-    text::{Line, Span},
-    widgets::Paragraph,
-    Frame,
-};
-use unicode_width::UnicodeWidthStr;
-use crate::functions::common::buffer::get_view_layer;
-
-pub fn render_buffer_list(
-    f: &mut Frame,
-    area: Rect,
-    theme: &Theme,
-    buffer_state: &BufferState,
-    app_state: &AppState,  // Add this parameter
-) {
-    // --- Style Definitions ---
-    let active_style = Style::default()
-        .fg(theme.bg)
-        .bg(theme.highlight);
-
-    let inactive_style = Style::default()
-        .fg(theme.fg)
-        .bg(theme.bg);
-
-    // --- Determine Active Layer ---
-    let active_layer = match buffer_state.history.get(buffer_state.active_index) {
-        Some(view) => get_view_layer(view),
-        None => 1,
-    };
-
-    // --- Create Spans ---
-    let mut spans = Vec::new();
-    let mut current_width = 0;
-
-    // TODO: Replace with actual table name from server response
-    let current_table_name = Some("2025_customer");
-
-    for (original_index, view) in buffer_state.history.iter().enumerate() {
-        // Filter: Only process views matching the active layer
-        if get_view_layer(view) != active_layer {
-            continue;
-        }
-
-        let is_active = original_index == buffer_state.active_index;
-        let buffer_name = view.display_name_with_context(current_table_name);
-        let buffer_text = format!(" {} ", buffer_name);
-        let text_width = UnicodeWidthStr::width(buffer_text.as_str());
-
-        // Calculate width needed for this buffer (separator + text)
-        let needed_width = text_width;
-        if current_width + needed_width > area.width as usize {
-            break;
-        }
-
-        // Add the buffer text itself
-        let text_style = if is_active { active_style } else { inactive_style };
-        spans.push(Span::styled(buffer_text, text_style));
-        current_width += text_width;
-    }
-
-    // --- Filler Span ---
-    let remaining_width = area.width.saturating_sub(current_width as u16);
-    if !spans.is_empty() || remaining_width > 0 {
-        spans.push(Span::styled(
-                " ".repeat(remaining_width as usize),
-                inactive_style,
-        ));
-    }
-
-    // --- Render ---
-    let buffer_line = Line::from(spans);
-    let paragraph = Paragraph::new(buffer_line).alignment(Alignment::Left);
-    f.render_widget(paragraph, area);
-}

client/src/components/handlers/canvas.rs

@@ -1,194 +0,0 @@
-// src/components/handlers/canvas.rs
-use ratatui::{
-    widgets::{Paragraph, Block, Borders},
-    layout::{Layout, Constraint, Direction, Rect},
-    style::{Style, Modifier},
-    text::{Line, Span},
-    Frame,
-    prelude::Alignment,
-};
-use crate::config::colors::themes::Theme;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::highlight::HighlightState; // Ensure correct import path
-use std::cmp::{min, max};
-
-pub fn render_canvas(
-    f: &mut Frame,
-    area: Rect,
-    form_state: &impl CanvasState,
-    fields: &[&str],
-    current_field_idx: &usize,
-    inputs: &[&String],
-    theme: &Theme,
-    is_edit_mode: bool,
-    highlight_state: &HighlightState, // Using the enum state
-) -> Option<Rect> {
-    // ... (setup code remains the same) ...
-    let columns = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)])
-        .split(area);
-
-    let border_style = if form_state.has_unsaved_changes() {
-        Style::default().fg(theme.warning)
-    } else if is_edit_mode {
-        Style::default().fg(theme.accent)
-    } else {
-        Style::default().fg(theme.secondary)
-    };
-    let input_container = Block::default()
-        .borders(Borders::ALL)
-        .border_style(border_style)
-        .style(Style::default().bg(theme.bg));
-
-    let input_block = Rect {
-        x: columns[1].x,
-        y: columns[1].y,
-        width: columns[1].width,
-        height: fields.len() as u16 + 2,
-    };
-
-    f.render_widget(&input_container, input_block);
-
-    let input_area = input_container.inner(input_block);
-    let input_rows = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints(vec![Constraint::Length(1); fields.len()])
-        .split(input_area);
-
-    let mut active_field_input_rect = None;
-
-    // Render labels
-    for (i, field) in fields.iter().enumerate() {
-        let label = Paragraph::new(Line::from(Span::styled(
-            format!("{}:", field),
-            Style::default().fg(theme.fg)),
-        ));
-        f.render_widget(label, Rect {
-            x: columns[0].x,
-            y: input_block.y + 1 + i as u16,
-            width: columns[0].width,
-            height: 1,
-        });
-    }
-
-
-    // Render inputs and cursor
-    for (i, input) in inputs.iter().enumerate() {
-        let is_active = i == *current_field_idx;
-        let current_cursor_pos = form_state.current_cursor_pos();
-        let text = input.as_str();
-        let text_len = text.chars().count();
-
-        let line: Line;
-
-        // --- Use match on the highlight_state enum ---
-        match highlight_state {
-            HighlightState::Off => {
-                // Not in highlight mode, render normally
-                line = Line::from(Span::styled(
-                    text,
-                    if is_active { Style::default().fg(theme.highlight) } else { Style::default().fg(theme.fg) }
-                ));
-            }
-            HighlightState::Characterwise { anchor } => {
-                // --- Character-wise Highlight Logic ---
-                let (anchor_field, anchor_char) = *anchor;
-                let start_field = min(anchor_field, *current_field_idx);
-                let end_field = max(anchor_field, *current_field_idx);
-
-                // Use start_char and end_char consistently
-                let (start_char, end_char) = if anchor_field == *current_field_idx {
-                    (min(anchor_char, current_cursor_pos), max(anchor_char, current_cursor_pos))
-                } else if anchor_field < *current_field_idx {
-                    (anchor_char, current_cursor_pos)
-                } else {
-                    (current_cursor_pos, anchor_char)
-                };
-
-                let highlight_style = Style::default().fg(theme.highlight).bg(theme.highlight_bg).add_modifier(Modifier::BOLD);
-                let normal_style_in_highlight = Style::default().fg(theme.highlight);
-                let normal_style_outside = Style::default().fg(theme.fg);
-
-                if i >= start_field && i <= end_field {
-                    // This line is within the character-wise highlight range
-                    if start_field == end_field { // Case 1: Single Line Highlight
-                        // Use start_char and end_char here
-                        let clamped_start = start_char.min(text_len);
-                        let clamped_end = end_char.min(text_len); // Use text_len for slicing logic
-
-                        let before: String = text.chars().take(clamped_start).collect();
-                        let highlighted: String = text.chars().skip(clamped_start).take(clamped_end.saturating_sub(clamped_start) + 1).collect();
-                        // Define 'after' here
-                        let after: String = text.chars().skip(clamped_end + 1).collect();
-
-                        line = Line::from(vec![
-                            Span::styled(before, normal_style_in_highlight),
-                            Span::styled(highlighted, highlight_style),
-                            Span::styled(after, normal_style_in_highlight), // Use defined 'after'
-                        ]);
-                    } else if i == start_field { // Case 2: Multi-Line Highlight - Start Line
-                        // Use start_char here
-                        let safe_start = start_char.min(text_len);
-                        let before: String = text.chars().take(safe_start).collect();
-                        let highlighted: String = text.chars().skip(safe_start).collect();
-                        line = Line::from(vec![
-                            Span::styled(before, normal_style_in_highlight),
-                            Span::styled(highlighted, highlight_style),
-                        ]);
-                    } else if i == end_field { // Case 3: Multi-Line Highlight - End Line (Corrected index)
-                        // Use end_char here
-                        let safe_end_inclusive = if text_len > 0 { end_char.min(text_len - 1) } else { 0 };
-                        let highlighted: String = text.chars().take(safe_end_inclusive + 1).collect();
-                        let after: String = text.chars().skip(safe_end_inclusive + 1).collect();
-                        line = Line::from(vec![
-                            Span::styled(highlighted, highlight_style),
-                            Span::styled(after, normal_style_in_highlight),
-                        ]);
-                    } else { // Case 4: Multi-Line Highlight - Middle Line (Corrected index)
-                        line = Line::from(Span::styled(text, highlight_style)); // Highlight whole line
-                    }
-                } else { // Case 5: Line Outside Character-wise Highlight Range
-                    line = Line::from(Span::styled(
-                        text,
-                        // Use normal styling (active or inactive)
-                        if is_active { normal_style_in_highlight } else { normal_style_outside }
-                    ));
-                }
-            }
-            HighlightState::Linewise { anchor_line } => {
-                // --- Linewise Highlight Logic ---
-                let start_field = min(*anchor_line, *current_field_idx);
-                let end_field = max(*anchor_line, *current_field_idx);
-                let highlight_style = Style::default().fg(theme.highlight).bg(theme.highlight_bg).add_modifier(Modifier::BOLD);
-                let normal_style_in_highlight = Style::default().fg(theme.highlight);
-                let normal_style_outside = Style::default().fg(theme.fg);
-
-                if i >= start_field && i <= end_field {
-                    // Highlight the entire line
-                    line = Line::from(Span::styled(text, highlight_style));
-                } else {
-                    // Line outside linewise highlight range
-                    line = Line::from(Span::styled(
-                        text,
-                        // Use normal styling (active or inactive)
-                        if is_active { normal_style_in_highlight } else { normal_style_outside }
-                    ));
-                }
-            }
-        } // End match highlight_state
-
-        let input_display = Paragraph::new(line).alignment(Alignment::Left);
-        f.render_widget(input_display, input_rows[i]);
-
-        if is_active {
-            active_field_input_rect = Some(input_rows[i]);
-            let cursor_x = input_rows[i].x + form_state.current_cursor_pos() as u16;
-            let cursor_y = input_rows[i].y;
-            f.set_cursor_position((cursor_x, cursor_y));
-        }
-    }
-
-    active_field_input_rect
-}
-

client/src/components/handlers/sidebar.rs

@@ -1,150 +0,0 @@
-// src/components/handlers/sidebar.rs
-use ratatui::{
-    widgets::{Block, List, ListItem},
-    layout::{Rect, Direction, Layout, Constraint},
-    style::Style,
-    Frame,
-};
-use crate::config::colors::themes::Theme;
-use common::proto::multieko2::table_definition::{ProfileTreeResponse};
-use ratatui::text::{Span, Line};
-use crate::components::utils::text::truncate_string;
-
-// Reduced sidebar width
-const SIDEBAR_WIDTH: u16 = 20;
-
-// --- Icons ---
-const ICON_PROFILE: &str = "📁";
-const ICON_TABLE: &str = "📄";
-                                 
-pub fn calculate_sidebar_layout(show_sidebar: bool, main_content_area: Rect) -> (Option<Rect>, Rect) {
-    if show_sidebar {
-        let chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([
-                Constraint::Length(SIDEBAR_WIDTH),
-                Constraint::Min(0),
-            ])
-            .split(main_content_area);
-        (Some(chunks[0]), chunks[1])
-    } else {
-        (None, main_content_area)
-    }
-}
-
-pub fn render_sidebar(
-    f: &mut Frame,
-    area: Rect,
-    theme: &Theme,
-    profile_tree: &ProfileTreeResponse,
-    selected_profile: &Option<String>,
-) {
-    let sidebar_block = Block::default().style(Style::default().bg(theme.bg));
-    let mut items = Vec::new();
-        let profile_name_available_width = (SIDEBAR_WIDTH as usize).saturating_sub(3);
-    let table_name_available_width = (SIDEBAR_WIDTH as usize).saturating_sub(5);
-
-    if let Some(profile_name) = selected_profile {
-        // Find the selected profile in the tree
-        if let Some(profile) = profile_tree
-            .profiles
-            .iter()
-            .find(|p| &p.name == profile_name)
-        {
-            // Add profile name as header
-            items.push(ListItem::new(Line::from(vec![
-                Span::styled(format!("{} ", ICON_PROFILE), Style::default().fg(theme.accent)),
-                Span::styled(
-                    truncate_string(&profile.name, profile_name_available_width),
-                    Style::default().fg(theme.highlight)
-                ),
-            ])));
-
-            // List tables for the selected profile
-            for table in &profile.tables {
-                // Get table name without year prefix to save space
-                let display_name = if table.name.starts_with("2025_") {
-                    &table.name[5..] // Skip "2025_" prefix
-                } else {
-                    &table.name
-                };
-                items.push(ListItem::new(Line::from(vec![
-                    Span::raw("  "), // Indentation
-                    Span::styled(format!("{} ", ICON_TABLE), Style::default().fg(theme.secondary)),
-                    Span::styled(
-                        truncate_string(display_name, table_name_available_width),
-                        theme.fg
-                    ),
-                ])));
-            }
-        }
-    } else {
-        // Show full profile tree when no profile is selected (compact version)
-        for (profile_idx, profile) in profile_tree.profiles.iter().enumerate() {
-            // Profile header - more compact
-            items.push(ListItem::new(Line::from(vec![
-                Span::styled(format!("{} ", ICON_PROFILE), Style::default().fg(theme.accent)),
-                Span::styled(
-                    &profile.name,
-                    Style::default().fg(theme.highlight)
-                ),
-            ])));
-            // Tables with compact prefixes
-            for (table_idx, table) in profile.tables.iter().enumerate() {
-                let is_last_table = table_idx == profile.tables.len() - 1;
-                let is_last_profile = profile_idx == profile_tree.profiles.len() - 1;
-
-                // Shorter prefix characters
-                let prefix = match (is_last_profile, is_last_table) {
-                    (true, true) => " └",
-                    (true, false) => " ├",
-                    (false, true) => "│└",
-                    (false, false) => "│├",
-                };
-
-                // Get table name without year prefix to save space
-                let display_name = if table.name.starts_with("2025_") {
-                    &table.name[5..] // Skip "2025_" prefix
-                } else {
-                    &table.name
-                };
-
-                // Adjust available width if dependency arrow is shown
-                let current_table_available_width = if !table.depends_on.is_empty() {
-                    table_name_available_width.saturating_sub(1)
-                } else {
-                    table_name_available_width
-                };
-
-                let line = vec![
-                    Span::styled(prefix, Style::default().fg(theme.fg)),
-                    Span::styled(format!("{} ", ICON_TABLE), Style::default().fg(theme.secondary)),
-                    Span::styled(truncate_string(display_name, current_table_available_width), Style::default().fg(theme.fg)),
-                ];
-
-                items.push(ListItem::new(Line::from(line)));
-            }
-
-            // Compact separator between profiles
-            if profile_idx < profile_tree.profiles.len() - 1 {
-                items.push(ListItem::new(Line::from(
-                    Span::styled("│", Style::default().fg(theme.secondary))
-                )));
-            }
-        }
-
-        if profile_tree.profiles.is_empty() {
-            items.push(ListItem::new(Span::styled(
-                "No profiles",
-                Style::default().fg(theme.secondary)
-            )));
-        }
-    }
-
-    let list = List::new(items)
-        .block(sidebar_block)
-        .highlight_style(Style::default().fg(theme.highlight))
-        .highlight_symbol(">");
-
-    f.render_widget(list, area);
-}

client/src/components/intro.rs

@@ -1,4 +0,0 @@
-// src/components/intro.rs
-pub mod intro;
-
-pub use intro::*;

client/src/components/intro/intro.rs

@@ -1,87 +0,0 @@
-// src/components/intro/intro.rs
-use ratatui::{
-    layout::{Alignment, Constraint, Direction, Layout, Rect},
-    style::Style,
-    text::{Line, Span},
-    widgets::{Block, BorderType, Borders, Paragraph},
-    prelude::Margin,
-    Frame,
-};
-use crate::config::colors::themes::Theme;
-use crate::state::pages::intro::IntroState;
-
-pub fn render_intro(f: &mut Frame, intro_state: &IntroState, area: Rect, theme: &Theme) {
-    let block = Block::default()
-        .borders(Borders::ALL)
-        .border_type(BorderType::Rounded)
-        .border_style(Style::default().fg(theme.accent))
-        .style(Style::default().bg(theme.bg));
-
-    let inner_area = block.inner(area);
-    f.render_widget(block, area);
-
-    // Center layout
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Percentage(40),
-            Constraint::Length(5),
-            Constraint::Percentage(40),
-        ])
-        .split(inner_area);
-
-    // Title
-    let title = Line::from(vec![
-        Span::styled("multieko2", Style::default().fg(theme.highlight)),
-        Span::styled(" v", Style::default().fg(theme.fg)),
-        Span::styled(env!("CARGO_PKG_VERSION"), Style::default().fg(theme.secondary)),
-    ]);
-    let title_para = Paragraph::new(title)
-        .alignment(Alignment::Center);
-    f.render_widget(title_para, chunks[1]);
-
-    // Buttons - now with 4 options
-    let button_area = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-        ])
-        .split(chunks[1].inner(Margin {
-            horizontal: 1,
-            vertical: 1
-        }));
-
-    let buttons = ["Continue", "Admin", "Login", "Register"];
-    for (i, &text) in buttons.iter().enumerate() {
-        render_button(f, button_area[i], text, intro_state.selected_option == i, theme);
-    }
-}
-
-fn render_button(f: &mut Frame, area: Rect, text: &str, selected: bool, theme: &Theme) {
-    let button_style = Style::default()
-        .fg(if selected { theme.highlight } else { theme.fg })
-        .bg(theme.bg)
-        .add_modifier(if selected {
-            ratatui::style::Modifier::BOLD
-        } else {
-            ratatui::style::Modifier::empty()
-        });
-
-    let border_style = Style::default()
-        .fg(if selected { theme.accent } else { theme.border });
-
-    let button = Paragraph::new(text)
-        .style(button_style)
-        .alignment(Alignment::Center)
-        .block(
-            Block::default()
-            .borders(Borders::ALL)
-            .border_type(BorderType::Double)
-            .border_style(border_style),
-        );
-
-    f.render_widget(button, area);
-}

client/src/components/mod.rs

@@ -1,16 +0,0 @@
-// src/components/mod.rs
-pub mod handlers;
-pub mod intro;
-pub mod admin;
-pub mod common;
-pub mod form;
-pub mod auth;
-pub mod utils;
-
-pub use handlers::*;
-pub use intro::*;
-pub use admin::*;
-pub use common::*;
-pub use form::*;
-pub use auth::*;
-pub use utils::*;

client/src/components/utils.rs

@@ -1,4 +0,0 @@
-// src/components/utils.rs
-pub mod text;
-
-pub use text::*;

client/src/components/utils/text.rs

@@ -1,29 +0,0 @@
-// src/components/utils/text.rs
-
-use unicode_width::UnicodeWidthStr;
-use unicode_segmentation::UnicodeSegmentation;
-
-/// Truncates a string to a maximum width, adding an ellipsis if truncated.
-/// Considers unicode character widths.
-pub fn truncate_string(s: &str, max_width: usize) -> String {
-    if UnicodeWidthStr::width(s) <= max_width {
-        s.to_string()
-    } else {
-        let ellipsis = "…";
-        let ellipsis_width = UnicodeWidthStr::width(ellipsis);
-        let mut truncated_width = 0;
-        let mut end_byte_index = 0;
-
-        // Iterate over graphemes to handle multi-byte characters correctly
-        for (i, g) in s.grapheme_indices(true) {
-            let char_width = UnicodeWidthStr::width(g);
-            if truncated_width + char_width + ellipsis_width > max_width {
-                break;
-            }
-            truncated_width += char_width;
-            end_byte_index = i + g.len();
-        }
-
-        format!("{}{}", &s[..end_byte_index], ellipsis)
-    }
-}

client/src/config/binds.rs

@@ -1,7 +0,0 @@
-// src/config/binds.rs
- 
-pub mod config;
-pub mod key_sequences;
-
-pub use config::*;
-pub use key_sequences::*;

client/src/config/binds/config.rs

@@ -1,604 +0,0 @@
-// src/config/binds/config.rs
-
-use serde::{Deserialize, Serialize}; // Added Serialize for EditorKeybindingMode if needed elsewhere
-use std::collections::HashMap;
-use std::path::Path;
-use anyhow::{Context, Result};
-use crossterm::event::{KeyCode, KeyModifiers};
-
-// NEW: Editor Keybinding Mode Enum
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub enum EditorKeybindingMode {
-    #[serde(rename = "default")]
-    Default,
-    #[serde(rename = "vim")]
-    Vim,
-    #[serde(rename = "emacs")]
-    Emacs,
-}
-
-impl Default for EditorKeybindingMode {
-    fn default() -> Self {
-        EditorKeybindingMode::Default
-    }
-}
-
-// NEW: Editor Configuration Struct
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct EditorConfig {
-    #[serde(default)]
-    pub keybinding_mode: EditorKeybindingMode,
-    #[serde(default = "default_show_line_numbers")]
-    pub show_line_numbers: bool,
-    #[serde(default = "default_tab_width")]
-    pub tab_width: u8,
-}
-
-fn default_show_line_numbers() -> bool {
-    true
-}
-
-fn default_tab_width() -> u8 {
-    4
-}
-
-impl Default for EditorConfig {
-    fn default() -> Self {
-        EditorConfig {
-            keybinding_mode: EditorKeybindingMode::default(),
-            show_line_numbers: default_show_line_numbers(),
-            tab_width: default_tab_width(),
-        }
-    }
-}
-
-#[derive(Debug, Deserialize, Default)]
-pub struct ColorsConfig {
-    #[serde(default = "default_theme")]
-    pub theme: String,
-}
-
-fn default_theme() -> String {
-    "light".to_string()
-}
-
-#[derive(Debug, Deserialize)]
-pub struct Config {
-    #[serde(rename = "keybindings")]
-    pub keybindings: ModeKeybindings,
-    #[serde(default)]
-    pub colors: ColorsConfig,
-    // NEW: Add editor configuration
-    #[serde(default)]
-    pub editor: EditorConfig,
-}
-
-// ... (rest of your Config struct and impl Config remains the same)
-// Make sure ModeKeybindings is also deserializable if it's not already
-#[derive(Debug, Deserialize, Default)] // Added Default here if not present
-pub struct ModeKeybindings {
-    #[serde(default)]
-    pub general: HashMap<String, Vec<String>>,
-    #[serde(default)]
-    pub read_only: HashMap<String, Vec<String>>,
-    #[serde(default)]
-    pub edit: HashMap<String, Vec<String>>,
-    #[serde(default)]
-    pub highlight: HashMap<String, Vec<String>>,
-    #[serde(default)]
-    pub command: HashMap<String, Vec<String>>,
-    #[serde(default)]
-    pub common: HashMap<String, Vec<String>>,
-    #[serde(flatten)]
-    pub global: HashMap<String, Vec<String>>,
-}
-
-impl Config {
-    /// Loads the configuration from "config.toml" in the client crate directory.
-    pub fn load() -> Result<Self> {
-        let manifest_dir = env!("CARGO_MANIFEST_DIR");
-        let config_path = Path::new(manifest_dir).join("config.toml");
-        let config_str = std::fs::read_to_string(&config_path)
-             .with_context(|| format!("Failed to read config file at {:?}", config_path))?;
-        let config: Config = toml::from_str(&config_str)
-            .with_context(|| format!("Failed to parse config file: {}. Check for syntax errors or missing fields like an empty [editor] section if you added it.", config_str))?; // Enhanced error message
-        Ok(config)
-    }
-
-    pub fn get_general_action(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
-        self.get_action_for_key_in_mode(&self.keybindings.general, key, modifiers)
-            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.global, key, modifiers))
-    }
-
-    /// Common actions for Edit/Read-only modes
-    pub fn get_common_action(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
-        self.get_action_for_key_in_mode(&self.keybindings.common, key, modifiers)
-    }
-
-    /// Gets an action for a key in Read-Only mode, also checking common keybindings.
-    pub fn get_read_only_action_for_key(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
-        self.get_action_for_key_in_mode(&self.keybindings.read_only, key, modifiers)
-            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.common, key, modifiers))
-            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.global, key, modifiers))
-    }
-
-    /// Gets an action for a key in Edit mode, also checking common keybindings.
-    pub fn get_edit_action_for_key(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
-        self.get_action_for_key_in_mode(&self.keybindings.edit, key, modifiers)
-            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.common, key, modifiers))
-            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.global, key, modifiers))
-    }
-
-    /// Gets an action for a key in Highlight mode, also checking common/global keybindings.
-    pub fn get_highlight_action_for_key(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
-        self.get_action_for_key_in_mode(&self.keybindings.highlight, key, modifiers)
-            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.common, key, modifiers))
-            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.read_only, key, modifiers))
-            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.global, key, modifiers))
-    }
-
-    /// Gets an action for a key in Command mode, also checking common keybindings.
-    pub fn get_command_action_for_key(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
-        self.get_action_for_key_in_mode(&self.keybindings.command, key, modifiers)
-            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.common, key, modifiers))
-            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.global, key, modifiers))
-    }
-
-    /// Context-aware keybinding resolution
-    pub fn get_action_for_current_context(
-        &self,
-        is_edit_mode: bool,
-        command_mode: bool,
-        key: KeyCode,
-        modifiers: KeyModifiers
-    ) -> Option<&str> {
-        match (command_mode, is_edit_mode) {
-            (true, _) => self.get_command_action_for_key(key, modifiers),
-            (_, true) => self.get_edit_action_for_key(key, modifiers)
-                .or_else(|| self.get_common_action(key, modifiers)),
-            _ => self.get_read_only_action_for_key(key, modifiers)
-                .or_else(|| self.get_common_action(key, modifiers))
-                // Add global bindings check for read-only mode
-                .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.global, key, modifiers)),
-        }
-    }
-
-    /// Helper function to get an action for a key in a specific mode.
-    pub fn get_action_for_key_in_mode<'a>(
-        &self,
-        mode_bindings: &'a HashMap<String, Vec<String>>,
-        key: KeyCode,
-        modifiers: KeyModifiers,
-    ) -> Option<&'a str> {
-        for (action, bindings) in mode_bindings {
-            for binding in bindings {
-                if Self::matches_keybinding(binding, key, modifiers) {
-                    return Some(action.as_str());
-                }
-            }
-        }
-        None
-    }
-
-    /// Checks if a sequence of keys matches any keybinding.
-    pub fn matches_key_sequence(&self, sequence: &[KeyCode]) -> Option<&str> {
-        if sequence.is_empty() {
-            return None;
-        }
-
-        // Convert key sequence to a string (for simple character sequences).
-        let sequence_str: String = sequence.iter().filter_map(|key| {
-            if let KeyCode::Char(c) = key {
-                Some(*c)
-            } else {
-                None
-            }
-        }).collect();
-
-        if sequence_str.is_empty() {
-            return None;
-        }
-
-        // Check if this sequence matches any binding in the mode-specific sections.
-        for (action, bindings) in &self.keybindings.read_only {
-            for binding in bindings {
-                if binding == &sequence_str {
-                    return Some(action);
-                }
-            }
-        }
-
-        for (action, bindings) in &self.keybindings.edit {
-            for binding in bindings {
-                if binding == &sequence_str {
-                    return Some(action);
-                }
-            }
-        }
-
-        for (action, bindings) in &self.keybindings.command {
-            for binding in bindings {
-                if binding == &sequence_str {
-                    return Some(action);
-                }
-            }
-        }
-
-        // Check common keybindings
-        for (action, bindings) in &self.keybindings.common {
-            for binding in bindings {
-                if binding == &sequence_str {
-                    return Some(action);
-                }
-            }
-        }
-
-        // Finally check global bindings
-        for (action, bindings) in &self.keybindings.global {
-            for binding in bindings {
-                if binding == &sequence_str {
-                    return Some(action);
-                }
-            }
-        }
-
-        None
-    }
-
-    /// Checks if a keybinding matches a key and modifiers.
-    fn matches_keybinding(
-        binding: &str,
-        key: KeyCode,
-        modifiers: KeyModifiers,
-    ) -> bool {
-        // For multi-character bindings without modifiers, handle them in matches_key_sequence.
-        if binding.len() > 1 && !binding.contains('+') {
-            return match binding.to_lowercase().as_str() {
-                "left" => key == KeyCode::Left,
-                "right" => key == KeyCode::Right,
-                "up" => key == KeyCode::Up,
-                "down" => key == KeyCode::Down,
-                "esc" => key == KeyCode::Esc,
-                "enter" => key == KeyCode::Enter,
-                "delete" => key == KeyCode::Delete,
-                "backspace" => key == KeyCode::Backspace,
-                "tab" => key == KeyCode::Tab,
-                "backtab" => key == KeyCode::BackTab,
-                _ => false,
-            };
-        }
-
-        let parts: Vec<&str> = binding.split('+').collect();
-        let mut expected_modifiers = KeyModifiers::empty();
-        let mut expected_key = None;
-
-        for part in parts {
-            match part.to_lowercase().as_str() {
-                "ctrl" => expected_modifiers |= KeyModifiers::CONTROL,
-                "shift" => expected_modifiers |= KeyModifiers::SHIFT,
-                "alt" => expected_modifiers |= KeyModifiers::ALT,
-                "left" => expected_key = Some(KeyCode::Left),
-                "right" => expected_key = Some(KeyCode::Right),
-                "up" => expected_key = Some(KeyCode::Up),
-                "down" => expected_key = Some(KeyCode::Down),
-                "esc" => expected_key = Some(KeyCode::Esc),
-                "enter" => expected_key = Some(KeyCode::Enter),
-                "delete" => expected_key = Some(KeyCode::Delete),
-                "backspace" => expected_key = Some(KeyCode::Backspace),
-                "tab" => expected_key = Some(KeyCode::Tab),
-                "backtab" => expected_key = Some(KeyCode::BackTab),
-                ":" => expected_key = Some(KeyCode::Char(':')),
-                part => {
-                    if part.len() == 1 {
-                        let c = part.chars().next().unwrap();
-                        expected_key = Some(KeyCode::Char(c));
-                    }
-                }
-            }
-        }
-
-        modifiers == expected_modifiers && Some(key) == expected_key
-    }
-
-    /// Gets an action for a command string.
-    pub fn get_action_for_command(&self, command: &str) -> Option<&str> {
-        // First check command mode bindings
-        for (action, bindings) in &self.keybindings.command {
-            for binding in bindings {
-                if binding == command {
-                    return Some(action);
-                }
-            }
-        }
-
-        // Then check common bindings
-        for (action, bindings) in &self.keybindings.common {
-            for binding in bindings {
-                if binding == command {
-                    return Some(action);
-                }
-            }
-        }
-
-        // Finally check global bindings
-        for (action, bindings) in &self.keybindings.global {
-            for binding in bindings {
-                if binding == command {
-                    return Some(action);
-                }
-            }
-        }
-
-        None
-    }
-
-    /// Checks if a key is bound to entering Edit mode (before cursor).
-    pub fn is_enter_edit_mode_before(&self, key: KeyCode, modifiers: KeyModifiers) -> bool {
-        if let Some(bindings) = self.keybindings.read_only.get("enter_edit_mode_before") {
-            bindings.iter().any(|b| Self::matches_keybinding(b, key, modifiers))
-        } else {
-            false
-        }
-    }
-
-    /// Checks if a key is bound to entering Edit mode (after cursor).
-    pub fn is_enter_edit_mode_after(&self, key: KeyCode, modifiers: KeyModifiers) -> bool {
-        if let Some(bindings) = self.keybindings.read_only.get("enter_edit_mode_after") {
-            bindings.iter().any(|b| Self::matches_keybinding(b, key, modifiers))
-        } else {
-            false
-        }
-    }
-
-    /// Checks if a key is bound to entering Edit mode.
-    pub fn is_enter_edit_mode(&self, key: KeyCode, modifiers: KeyModifiers) -> bool {
-        self.is_enter_edit_mode_before(key, modifiers) || self.is_enter_edit_mode_after(key, modifiers)
-    }
-
-    /// Checks if a key is bound to exiting Edit mode.
-    pub fn is_exit_edit_mode(&self, key: KeyCode, modifiers: KeyModifiers) -> bool {
-        if let Some(bindings) = self.keybindings.edit.get("exit_edit_mode") {
-            bindings.iter().any(|b| Self::matches_keybinding(b, key, modifiers))
-        } else {
-            false
-        }
-    }
-
-    /// Checks if a key is bound to entering Command mode.
-    /// This method is no longer used in event.rs since we now handle command mode entry only in read-only mode directly.
-    pub fn is_enter_command_mode(&self, key: KeyCode, modifiers: KeyModifiers) -> bool {
-        if let Some(bindings) = self.keybindings.command.get("enter_command_mode") {
-            bindings.iter().any(|b| Self::matches_keybinding(b, key, modifiers))
-        } else {
-            false
-        }
-    }
-
-
-    /// Checks if a key is bound to exiting Command mode.
-    pub fn is_exit_command_mode(&self, key: KeyCode, modifiers: KeyModifiers) -> bool {
-        if let Some(bindings) = self.keybindings.command.get("exit_command_mode") {
-            bindings.iter().any(|b| Self::matches_keybinding(b, key, modifiers))
-        } else {
-            false
-        }
-    }
-
-    /// Checks if a key is bound to executing a command.
-    pub fn is_command_execute(&self, key: KeyCode, modifiers: KeyModifiers) -> bool {
-        if let Some(bindings) = self.keybindings.command.get("command_execute") {
-            bindings.iter().any(|b| Self::matches_keybinding(b, key, modifiers))
-        } else {
-            // Fall back to Enter key if no command_execute is defined.
-            key == KeyCode::Enter && modifiers.is_empty()
-        }
-    }
-
-    /// Checks if a key is bound to backspacing in Command mode.
-    pub fn is_command_backspace(&self, key: KeyCode, modifiers: KeyModifiers) -> bool {
-        if let Some(bindings) = self.keybindings.command.get("command_backspace") {
-            bindings.iter().any(|b| Self::matches_keybinding(b, key, modifiers))
-        } else {
-            // Fall back to Backspace key if no command_backspace is defined.
-            key == KeyCode::Backspace && modifiers.is_empty()
-        }
-    }
-
-    /// Checks if a key is bound to a specific action.
-    pub fn has_key_for_action(&self, action: &str, key_char: char) -> bool {
-        // Check all mode-specific keybindings for the action
-        if let Some(bindings) = self.keybindings.read_only.get(action) {
-            if bindings.iter().any(|binding| binding == &key_char.to_string()) {
-                return true;
-            }
-        }
-
-        if let Some(bindings) = self.keybindings.edit.get(action) {
-            if bindings.iter().any(|binding| binding == &key_char.to_string()) {
-                return true;
-            }
-        }
-
-        if let Some(bindings) = self.keybindings.command.get(action) {
-            if bindings.iter().any(|binding| binding == &key_char.to_string()) {
-                return true;
-            }
-        }
-
-        if let Some(bindings) = self.keybindings.common.get(action) {
-            if bindings.iter().any(|binding| binding == &key_char.to_string()) {
-                return true;
-            }
-        }
-
-        if let Some(bindings) = self.keybindings.global.get(action) {
-            if bindings.iter().any(|binding| binding == &key_char.to_string()) {
-                return true;
-            }
-        }
-
-        false
-    }
-
-    /// This method handles all keybinding formats, both with and without +
-    pub fn matches_key_sequence_generalized(&self, sequence: &[KeyCode]) -> Option<&str> {
-        if sequence.is_empty() {
-            return None;
-        }
-
-        // Get string representations of the sequence
-        let sequence_str = sequence.iter()
-            .map(|k| crate::config::binds::key_sequences::key_to_string(k))
-            .collect::<Vec<String>>()
-            .join("");
-
-        // Add the missing sequence_plus definition
-        let sequence_plus = sequence.iter()
-            .map(|k| crate::config::binds::key_sequences::key_to_string(k))
-            .collect::<Vec<String>>()
-            .join("+");
-
-        // Check for matches in all binding formats across all modes
-        // First check read_only mode
-        if let Some(action) = self.check_bindings_for_sequence(&self.keybindings.read_only, &sequence_str, &sequence_plus, sequence) {
-            return Some(action);
-        }
-
-        // Then check edit mode
-        if let Some(action) = self.check_bindings_for_sequence(&self.keybindings.edit, &sequence_str, &sequence_plus, sequence) {
-            return Some(action);
-        }
-
-        // Then check command mode
-        if let Some(action) = self.check_bindings_for_sequence(&self.keybindings.command, &sequence_str, &sequence_plus, sequence) {
-            return Some(action);
-        }
-
-        // Then check common keybindings
-        if let Some(action) = self.check_bindings_for_sequence(&self.keybindings.common, &sequence_str, &sequence_plus, sequence) {
-            return Some(action);
-        }
-
-        // Finally check global bindings
-        if let Some(action) = self.check_bindings_for_sequence(&self.keybindings.global, &sequence_str, &sequence_plus, sequence) {
-            return Some(action);
-        }
-
-        None
-    }
-
-    /// Helper method to check a specific mode's bindings against a key sequence
-    fn check_bindings_for_sequence<'a>(
-        &self,
-        mode_bindings: &'a HashMap<String, Vec<String>>,
-        sequence_str: &str,
-        sequence_plus: &str,
-        sequence: &[KeyCode]
-    ) -> Option<&'a str> {
-        for (action, bindings) in mode_bindings {
-            for binding in bindings {
-                let normalized_binding = binding.to_lowercase();
-
-                // Check if binding matches any of our formats
-                if normalized_binding == sequence_str || normalized_binding == sequence_plus {
-                    return Some(action);
-                }
-
-                // Special case for + format in bindings
-                if binding.contains('+') {
-                    let normalized_sequence = sequence.iter()
-                        .map(|k| crate::config::binds::key_sequences::key_to_string(k))
-                        .collect::<Vec<String>>();
-
-                    let binding_parts: Vec<&str> = binding.split('+').collect();
-
-                    if binding_parts.len() == sequence.len() {
-                        let matches = binding_parts.iter().enumerate().all(|(i, part)| {
-                            part.to_lowercase() == normalized_sequence[i].to_lowercase()
-                        });
-
-                        if matches {
-                            return Some(action);
-                        }
-                    }
-                }
-            }
-        }
-        None
-    }
-
-    /// Check if the current key sequence is a prefix of a longer binding
-    pub fn is_key_sequence_prefix(&self, sequence: &[KeyCode]) -> bool {
-        if sequence.is_empty() {
-            return false;
-        }
-
-        // Get string representation of the sequence
-        let sequence_str = sequence.iter()
-            .map(|k| crate::config::binds::key_sequences::key_to_string(k))
-            .collect::<Vec<String>>()
-            .join("");
-
-        // Check in each mode if our sequence is a prefix
-        if self.is_prefix_in_mode(&self.keybindings.read_only, &sequence_str, sequence) {
-            return true;
-        }
-
-        if self.is_prefix_in_mode(&self.keybindings.edit, &sequence_str, sequence) {
-            return true;
-        }
-
-        if self.is_prefix_in_mode(&self.keybindings.command, &sequence_str, sequence) {
-            return true;
-        }
-
-        if self.is_prefix_in_mode(&self.keybindings.common, &sequence_str, sequence) {
-            return true;
-        }
-
-        if self.is_prefix_in_mode(&self.keybindings.global, &sequence_str, sequence) {
-            return true;
-        }
-
-        false
-    }
-
-    /// Helper method to check if a sequence is a prefix in a specific mode
-    fn is_prefix_in_mode(
-        &self,
-        mode_bindings: &HashMap<String, Vec<String>>,
-        sequence_str: &str,
-        sequence: &[KeyCode]
-    ) -> bool {
-        for (_, bindings) in mode_bindings {
-            for binding in bindings {
-                let normalized_binding = binding.to_lowercase();
-
-                // Check standard format
-                if normalized_binding.starts_with(sequence_str) &&
-                   normalized_binding.len() > sequence_str.len() {
-                    return true;
-                }
-
-                // Check + format
-                if binding.contains('+') {
-                    let binding_parts: Vec<&str> = binding.split('+').collect();
-                    let sequence_parts = sequence.iter()
-                        .map(|k| crate::config::binds::key_sequences::key_to_string(k))
-                        .collect::<Vec<String>>();
-
-                    if binding_parts.len() > sequence_parts.len() {
-                        let prefix_matches = sequence_parts.iter().enumerate().all(|(i, part)| {
-                            binding_parts.get(i).map_or(false, |b| b.to_lowercase() == part.to_lowercase())
-                        });
-
-                        if prefix_matches {
-                            return true;
-                        }
-                    }
-                }
-            }
-        }
-        false
-    }
-}

client/src/config/binds/key_sequences.rs

@@ -1,172 +0,0 @@
-// client/src/config/key_sequences.rs
-use crossterm::event::{KeyCode, KeyModifiers};
-use std::time::{Duration, Instant};
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct ParsedKey {
-    pub code: KeyCode,
-    pub modifiers: KeyModifiers,
-}
-
-#[derive(Debug, Clone)]
-pub struct KeySequenceTracker {
-    pub current_sequence: Vec<KeyCode>,
-    pub last_key_time: Instant,
-    pub timeout: Duration,
-}
-
-impl KeySequenceTracker {
-    pub fn new(timeout_ms: u64) -> Self {
-        Self {
-            current_sequence: Vec::new(),
-            last_key_time: Instant::now(),
-            timeout: Duration::from_millis(timeout_ms),
-        }
-    }
-
-    pub fn reset(&mut self) {
-        self.current_sequence.clear();
-        self.last_key_time = Instant::now();
-    }
-
-    pub fn add_key(&mut self, key: KeyCode) -> bool {
-        // Check if timeout has expired
-        let now = Instant::now();
-        if now.duration_since(self.last_key_time) > self.timeout {
-            self.reset();
-        }
-
-        self.current_sequence.push(key);
-        self.last_key_time = now;
-        true
-    }
-
-    pub fn get_sequence(&self) -> Vec<KeyCode> {
-        self.current_sequence.clone()
-    }
-
-    // Convert a sequence of keys to a string representation
-    pub fn sequence_to_string(&self) -> String {
-        self.current_sequence.iter().map(|k| key_to_string(k)).collect()
-    }
-
-    // Convert a sequence to a format with + between keys
-    pub fn sequence_to_plus_format(&self) -> String {
-        if self.current_sequence.is_empty() {
-            return String::new();
-        }
-
-        let parts: Vec<String> = self.current_sequence.iter()
-            .map(|k| key_to_string(k))
-            .collect();
-
-        parts.join("+")
-    }
-}
-
-// Helper function to convert any KeyCode to a string representation
-pub fn key_to_string(key: &KeyCode) -> String {
-    match key {
-        KeyCode::Char(c) => c.to_string(),
-        KeyCode::Left => "left".to_string(),
-        KeyCode::Right => "right".to_string(),
-        KeyCode::Up => "up".to_string(),
-        KeyCode::Down => "down".to_string(),
-        KeyCode::Esc => "esc".to_string(),
-        KeyCode::Enter => "enter".to_string(),
-        KeyCode::Backspace => "backspace".to_string(),
-        KeyCode::Delete => "delete".to_string(),
-        KeyCode::Tab => "tab".to_string(),
-        KeyCode::BackTab => "backtab".to_string(),
-        KeyCode::Home => "home".to_string(),
-        KeyCode::End => "end".to_string(),
-        KeyCode::PageUp => "pageup".to_string(),
-        KeyCode::PageDown => "pagedown".to_string(),
-        KeyCode::Insert => "insert".to_string(),
-        _ => format!("{:?}", key).to_lowercase(),
-    }
-}
-
-// Helper function to convert a string to a KeyCode
-pub fn string_to_keycode(s: &str) -> Option<KeyCode> {
-    match s.to_lowercase().as_str() {
-        "left" => Some(KeyCode::Left),
-        "right" => Some(KeyCode::Right),
-        "up" => Some(KeyCode::Up),
-        "down" => Some(KeyCode::Down),
-        "esc" => Some(KeyCode::Esc),
-        "enter" => Some(KeyCode::Enter),
-        "backspace" => Some(KeyCode::Backspace),
-        "delete" => Some(KeyCode::Delete),
-        "tab" => Some(KeyCode::Tab),
-        "backtab" => Some(KeyCode::BackTab),
-        "home" => Some(KeyCode::Home),
-        "end" => Some(KeyCode::End),
-        "pageup" => Some(KeyCode::PageUp),
-        "pagedown" => Some(KeyCode::PageDown),
-        "insert" => Some(KeyCode::Insert),
-        s if s.len() == 1 => s.chars().next().map(KeyCode::Char),
-        _ => None,
-    }
-}
-
-pub fn parse_binding(binding: &str) -> Vec<ParsedKey> {
-    let mut sequence = Vec::new();
-
-    // Handle different binding formats
-    let parts: Vec<String> = if binding.contains('+') {
-        // Format with explicit '+' separators like "g+left"
-        binding.split('+').map(|s| s.to_string()).collect()
-    } else if binding.contains(' ') {
-        // Format with spaces like "g left"
-        binding.split(' ').map(|s| s.to_string()).collect()
-    } else if is_compound_key(binding) {
-        // A single compound key like "left" or "enter"
-        vec![binding.to_string()]
-    } else {
-        // Simple character sequence like "gg"
-        binding.chars().map(|c| c.to_string()).collect()
-    };
-
-    for part in &parts {
-        if let Some(key) = parse_key_part(part) {
-            sequence.push(key);
-        }
-    }
-    sequence
-}
-
-fn is_compound_key(part: &str) -> bool {
-    matches!(part.to_lowercase().as_str(),
-        "esc" | "up" | "down" | "left" | "right" | "enter" |
-        "backspace" | "delete" | "tab" | "backtab" | "home" |
-        "end" | "pageup" | "pagedown" | "insert"
-    )
-}
-
-fn parse_key_part(part: &str) -> Option<ParsedKey> {
-    let mut modifiers = KeyModifiers::empty();
-    let mut code = None;
-
-    if part.contains('+') {
-        // This handles modifiers like "ctrl+s"
-        let components: Vec<&str> = part.split('+').collect();
-
-        for component in components {
-            match component.to_lowercase().as_str() {
-                "ctrl" => modifiers |= KeyModifiers::CONTROL,
-                "shift" => modifiers |= KeyModifiers::SHIFT,
-                "alt" => modifiers |= KeyModifiers::ALT,
-                _ => {
-                    // Last component is the key
-                    code = string_to_keycode(component);
-                }
-            }
-        }
-    } else {
-        // Simple key without modifiers
-        code = string_to_keycode(part);
-    }
-
-    code.map(|code| ParsedKey { code, modifiers })
-}

client/src/config/colors.rs

@@ -1,4 +0,0 @@
-// src/config/colors.rs
-pub mod themes;
-
-pub use themes::*;

client/src/config/colors/themes.rs

@@ -1,76 +0,0 @@
-// src/client/themes/colors.rs
-use ratatui::style::Color;
-
-#[derive(Debug, Clone)]
-pub struct Theme {
-    pub bg: Color,
-    pub fg: Color,
-    pub accent: Color,
-    pub secondary: Color,
-    pub highlight: Color,
-    pub warning: Color,
-    pub border: Color,
-    pub highlight_bg: Color,
-    pub inactive_highlight_bg: Color,// admin panel no idea what it really is
-}
-
-impl Theme {
-    pub fn from_str(theme_name: &str) -> Self {
-        match theme_name.to_lowercase().as_str() {
-            "dark" => Self::dark(),
-            "high_contrast" => Self::high_contrast(),
-            _ => Self::light(),
-        }
-    }
-
-    // Default light theme
-    pub fn light() -> Self {
-        Self {
-            bg: Color::Rgb(245, 245, 245), // Light gray
-            fg: Color::Rgb(64, 64, 64),    // Dark gray
-            accent: Color::Rgb(173, 216, 230), // Pastel blue
-            secondary: Color::Rgb(255, 165, 0), // Orange for secondary
-            highlight: Color::Rgb(152, 251, 152), // Pastel green
-            warning: Color::Rgb(255, 182, 193), // Pastel pink
-            border: Color::Rgb(220, 220, 220), // Light gray border
-            highlight_bg: Color::Rgb(70, 70, 70), // Darker grey for highlight background
-            inactive_highlight_bg: Color::Rgb(50, 50, 50),
-        }
-    }
-
-    // High-contrast dark theme
-    pub fn dark() -> Self {
-        Self {
-            bg: Color::Rgb(30, 30, 30),     // Dark background
-            fg: Color::Rgb(255, 255, 255),  // White text
-            accent: Color::Rgb(0, 191, 255), // Bright blue
-            secondary: Color::Rgb(255, 215, 0), // Gold for secondary
-            highlight: Color::Rgb(50, 205, 50), // Bright green
-            warning: Color::Rgb(255, 99, 71), // Bright red
-            border: Color::Rgb(100, 100, 100), // Medium gray border
-            highlight_bg: Color::Rgb(180, 180, 180), // Lighter grey for highlight background
-            inactive_highlight_bg: Color::Rgb(50, 50, 50),
-        }
-    }
-
-    // High-contrast light theme
-    pub fn high_contrast() -> Self {
-        Self {
-            bg: Color::Rgb(255, 255, 255), // White background
-            fg: Color::Rgb(0, 0, 0),       // Black text
-            accent: Color::Rgb(0, 0, 255), // Blue
-            secondary: Color::Rgb(255, 140, 0), // Dark orange for secondary
-            highlight: Color::Rgb(0, 128, 0), // Green
-            warning: Color::Rgb(255, 0, 0), // Red
-            border: Color::Rgb(0, 0, 0),   // Black border
-            highlight_bg: Color::Rgb(180, 180, 180), // Lighter grey for highlight background
-            inactive_highlight_bg: Color::Rgb(50, 50, 50),
-        }
-    }
-}
-
-impl Default for Theme {
-    fn default() -> Self {
-        Self::light() // Default to light theme
-    }
-}

client/src/config/mod.rs

@@ -1,5 +0,0 @@
-// src/config/mod.rs
-
-pub mod binds;
-pub mod colors;
-pub mod storage;

client/src/config/storage.rs

@@ -1,4 +0,0 @@
-// src/config/storage.rs
-pub mod storage;
-
-pub use storage::*;

client/src/config/storage/storage.rs

@@ -1,101 +0,0 @@
-// src/config/storage/storage.rs
-use serde::{Deserialize, Serialize};
-use std::fs::{self, File};
-use std::io::Write;
-use std::path::PathBuf;
-use anyhow::{Context, Result};
-use tracing::{error, info};
-
-#[cfg(unix)]
-use std::os::unix::fs::PermissionsExt;
-
-pub const APP_NAME: &str = "multieko2_client";
-pub const TOKEN_FILE_NAME: &str = "auth.token";
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct StoredAuthData {
-    pub access_token: String,
-    pub user_id: String,
-    pub role: String,
-    pub username: String,
-}
-
-pub fn get_token_storage_path() -> Result<PathBuf> {
-    let state_dir = dirs::state_dir()
-        .or_else(|| dirs::home_dir().map(|home| home.join(".local").join("state")))
-        .ok_or_else(|| anyhow::anyhow!("Could not determine state directory"))?;
-
-    let app_state_dir = state_dir.join(APP_NAME);
-    fs::create_dir_all(&app_state_dir)
-        .with_context(|| format!("Failed to create app state directory at {:?}", app_state_dir))?;
-    
-    Ok(app_state_dir.join(TOKEN_FILE_NAME))
-}
-
-pub fn save_auth_data(data: &StoredAuthData) -> Result<()> {
-    let path = get_token_storage_path()?;
-    
-    let json_data = serde_json::to_string(data)
-        .context("Failed to serialize auth data")?;
-    
-    let mut file = File::create(&path)
-        .with_context(|| format!("Failed to create token file at {:?}", path))?;
-    
-    file.write_all(json_data.as_bytes())
-        .context("Failed to write token data to file")?;
-    
-    // Set file permissions to 600 (owner read/write only) on Unix
-    #[cfg(unix)]
-    {
-        file.set_permissions(std::fs::Permissions::from_mode(0o600))
-            .context("Failed to set token file permissions")?;
-    }
-    
-    info!("Auth data saved to {:?}", path);
-    Ok(())
-}
-
-pub fn load_auth_data() -> Result<Option<StoredAuthData>> {
-    let path = get_token_storage_path()?;
-    
-    if !path.exists() {
-        info!("Token file not found at {:?}", path);
-        return Ok(None);
-    }
-    
-    let json_data = fs::read_to_string(&path)
-        .with_context(|| format!("Failed to read token file at {:?}", path))?;
-    
-    if json_data.trim().is_empty() {
-        info!("Token file is empty at {:?}", path);
-        return Ok(None);
-    }
-    
-    match serde_json::from_str::<StoredAuthData>(&json_data) {
-        Ok(data) => {
-            info!("Auth data loaded from {:?}", path);
-            Ok(Some(data))
-        }
-        Err(e) => {
-            error!("Failed to deserialize token data from {:?}: {}. Deleting corrupt file.", path, e);
-            if let Err(del_e) = fs::remove_file(&path) {
-                error!("Failed to delete corrupt token file: {}", del_e);
-            }
-            Ok(None)
-        }
-    }
-}
-
-pub fn delete_auth_data() -> Result<()> {
-    let path = get_token_storage_path()?;
-    
-    if path.exists() {
-        fs::remove_file(&path)
-            .with_context(|| format!("Failed to delete token file at {:?}", path))?;
-        info!("Token file deleted from {:?}", path);
-    } else {
-        info!("Token file not found for deletion at {:?}", path);
-    }
-    
-    Ok(())
-}

client/src/functions/common.rs

@@ -1,5 +0,0 @@
-// src/functions/common.rs
-
-pub mod buffer;
-
-pub use buffer::*;

client/src/functions/common/buffer.rs

@@ -1,35 +0,0 @@
-// src/functions/common/buffer.rs
-
-use crate::state::app::buffer::BufferState;
-use crate::state::app::buffer::AppView;
-
-pub fn get_view_layer(view: &AppView) -> u8 {
-    match view {
-        AppView::Intro => 1,
-        AppView::Login | AppView::Register | AppView::Admin | AppView::AddTable | AppView::AddLogic => 2,
-        AppView::Form | AppView::Scratch => 3,
-    }
-}
-
-/// Switches the active buffer index.
-pub fn switch_buffer(buffer_state: &mut BufferState, next: bool) -> bool {
-    if buffer_state.history.len() <= 1 {
-        return false;
-    }
-
-    let len = buffer_state.history.len();
-    let current_index = buffer_state.active_index;
-    let new_index = if next {
-        (current_index + 1) % len
-    } else {
-        (current_index + len - 1) % len
-    };
-
-    if new_index != current_index {
-        buffer_state.active_index = new_index;
-        true
-    } else {
-        false
-    }
-}
-

client/src/functions/mod.rs

@@ -1,6 +0,0 @@
-// src/functions/mod.rs
-
-pub mod common;
-pub mod modes;
-
-pub use modes::*;

client/src/functions/modes.rs

@@ -1,9 +0,0 @@
-// src/functions/modes.rs
-
-pub mod read_only;
-pub mod edit;
-pub mod navigation;
-
-pub use read_only::*;
-pub use edit::*;
-pub use navigation::*;

client/src/functions/modes/edit.rs

@@ -1,6 +0,0 @@
-// src/functions/modes/edit.rs
-
-pub mod form_e;
-pub mod auth_e;
-pub mod add_table_e;
-pub mod add_logic_e;

client/src/functions/modes/edit/add_logic_e.rs

@@ -1,135 +0,0 @@
-// src/functions/modes/edit/add_logic_e.rs
-use crate::state::pages::add_logic::AddLogicState;
-use crate::state::pages::canvas_state::CanvasState;
-use anyhow::Result;
-use crossterm::event::{KeyCode, KeyEvent};
-
-pub async fn execute_edit_action(
-    action: &str,
-    key: KeyEvent, // Keep key for insert_char
-    state: &mut AddLogicState,
-    ideal_cursor_column: &mut usize,
-) -> Result<String> {
-    let mut message = String::new();
-
-    match action {
-        "next_field" => {
-            let current_field = state.current_field();
-            let next_field = (current_field + 1) % AddLogicState::INPUT_FIELD_COUNT;
-            state.set_current_field(next_field);
-            *ideal_cursor_column = state.current_cursor_pos();
-            message = format!("Focus on field {}", state.fields()[next_field]);
-        }
-        "prev_field" => {
-            let current_field = state.current_field();
-            let prev_field = if current_field == 0 {
-                AddLogicState::INPUT_FIELD_COUNT - 1
-            } else {
-                current_field - 1
-            };
-            state.set_current_field(prev_field);
-            *ideal_cursor_column = state.current_cursor_pos();
-            message = format!("Focus on field {}", state.fields()[prev_field]);
-        }
-        "delete_char_forward" => {
-            let current_pos = state.current_cursor_pos();
-            let current_input_mut = state.get_current_input_mut();
-            if current_pos < current_input_mut.len() {
-                current_input_mut.remove(current_pos);
-                state.set_has_unsaved_changes(true);
-                if state.current_field() == 1 { state.update_target_column_suggestions(); }
-            }
-        }
-        "delete_char_backward" => {
-            let current_pos = state.current_cursor_pos();
-            if current_pos > 0 {
-                let new_pos = current_pos - 1;
-                state.get_current_input_mut().remove(new_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-                state.set_has_unsaved_changes(true);
-                if state.current_field() == 1 { state.update_target_column_suggestions(); }
-            }
-        }
-        "move_left" => {
-            let current_pos = state.current_cursor_pos();
-            if current_pos > 0 {
-                let new_pos = current_pos - 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-        }
-        "move_right" => {
-            let current_pos = state.current_cursor_pos();
-            let input_len = state.get_current_input().len();
-            if current_pos < input_len {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-        }
-        "insert_char" => {
-            if let KeyCode::Char(c) = key.code {
-                let current_pos = state.current_cursor_pos();
-                state.get_current_input_mut().insert(current_pos, c);
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-                state.set_has_unsaved_changes(true);
-                if state.current_field() == 1 {
-                    state.update_target_column_suggestions();
-                }
-            }
-        }
-        "suggestion_down" => {
-            if state.in_target_column_suggestion_mode && !state.target_column_suggestions.is_empty() {
-                let current_selection = state.selected_target_column_suggestion_index.unwrap_or(0);
-                let next_selection = (current_selection + 1) % state.target_column_suggestions.len();
-                state.selected_target_column_suggestion_index = Some(next_selection);
-            }
-        }
-        "suggestion_up" => {
-             if state.in_target_column_suggestion_mode && !state.target_column_suggestions.is_empty() {
-                let current_selection = state.selected_target_column_suggestion_index.unwrap_or(0);
-                let prev_selection = if current_selection == 0 {
-                    state.target_column_suggestions.len() - 1
-                } else {
-                    current_selection - 1
-                };
-                state.selected_target_column_suggestion_index = Some(prev_selection);
-            }
-        }
-        "select_suggestion" => {
-            if state.in_target_column_suggestion_mode {
-                let mut selected_suggestion_text: Option<String> = None;
-
-                if let Some(selected_idx) = state.selected_target_column_suggestion_index {
-                    if let Some(suggestion) = state.target_column_suggestions.get(selected_idx) {
-                        selected_suggestion_text = Some(suggestion.clone());
-                    }
-                }
-
-                if let Some(suggestion_text) = selected_suggestion_text {
-                    state.target_column_input = suggestion_text.clone();
-                    state.target_column_cursor_pos = state.target_column_input.len();
-                    *ideal_cursor_column = state.target_column_cursor_pos;
-                    state.set_has_unsaved_changes(true);
-                    message = format!("Selected column: '{}'", suggestion_text);
-                }
-
-                state.in_target_column_suggestion_mode = false;
-                state.show_target_column_suggestions = false;
-                state.selected_target_column_suggestion_index = None;
-                state.update_target_column_suggestions();
-            } else {
-                let current_field = state.current_field();
-                let next_field = (current_field + 1) % AddLogicState::INPUT_FIELD_COUNT;
-                state.set_current_field(next_field);
-                *ideal_cursor_column = state.current_cursor_pos();
-                message = format!("Focus on field {}", state.fields()[next_field]);
-            }
-        }
-        _ => {}
-    }
-    Ok(message)
-}

client/src/functions/modes/edit/add_table_e.rs

@@ -1,341 +0,0 @@
-// src/functions/modes/edit/add_table_e.rs
-use crate::state::pages::add_table::AddTableState;
-use crate::state::pages::canvas_state::CanvasState; // Use trait
-use crossterm::event::{KeyCode, KeyEvent};
-use anyhow::Result;
-
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() {
-        CharType::Whitespace
-    } else if c.is_alphanumeric() {
-        CharType::Alphanumeric
-    } else {
-        CharType::Punctuation
-    }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos >= len {
-        return len;
-    }
-
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-
-    while pos < len && get_char_type(chars[pos]) == initial_type {
-        pos += 1;
-    }
-
-    while pos < len && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos += 1;
-    }
-
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.min(len - 1);
-
-    if get_char_type(chars[pos]) == CharType::Whitespace {
-        pos = find_next_word_start(text, pos);
-    }
-
-    if pos >= len {
-        return len.saturating_sub(1);
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type {
-        pos += 1;
-    }
-
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    pos
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-    if pos == 0 && get_char_type(chars[pos]) != CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos > 0 {
-        pos - 1
-    } else {
-        0
-    }
-}
-
-/// Executes edit actions for the AddTable view canvas.
-pub async fn execute_edit_action(
-    action: &str,
-    key: KeyEvent, // Needed for insert_char
-    state: &mut AddTableState,
-    ideal_cursor_column: &mut usize,
-    // Add other params like grpc_client if needed for future actions (e.g., validation)
-) -> Result<String> {
-    // Use the CanvasState trait methods implemented for AddTableState
-    match action {
-        "insert_char" => {
-            if let KeyCode::Char(c) = key.code {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.insert(cursor_pos, c);
-                    *field_value = chars.into_iter().collect();
-                    state.set_current_cursor_pos(cursor_pos + 1);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = state.current_cursor_pos();
-                }
-            } else {
-                return Ok("Error: insert_char called without a char key.".to_string());
-            }
-            Ok("".to_string()) // No message needed for char insertion
-        }
-        "delete_char_backward" => {
-            if state.current_cursor_pos() > 0 {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.remove(cursor_pos - 1);
-                    *field_value = chars.into_iter().collect();
-                    let new_pos = cursor_pos - 1;
-                    state.set_current_cursor_pos(new_pos);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = new_pos;
-                }
-            }
-            Ok("".to_string())
-        }
-        "delete_char_forward" => {
-            let cursor_pos = state.current_cursor_pos();
-            let field_value = state.get_current_input_mut();
-            let mut chars: Vec<char> = field_value.chars().collect();
-            if cursor_pos < chars.len() {
-                chars.remove(cursor_pos);
-                *field_value = chars.into_iter().collect();
-                state.set_has_unsaved_changes(true);
-                *ideal_cursor_column = cursor_pos;
-            }
-            Ok("".to_string())
-        }
-        "next_field" => {
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let last_field_index = num_fields - 1;
-                // Prevent cycling forward
-                if current_field < last_field_index {
-                    state.set_current_field(current_field + 1);
-                }
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-            }
-            Ok("".to_string())
-        }
-        "prev_field" => {
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                if current_field > 0 {
-                    state.set_current_field(current_field - 1);
-                }
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-            }
-            Ok("".to_string())
-        }
-        "move_left" => {
-            let new_pos = state.current_cursor_pos().saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if current_pos < current_input.len() {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_up" => {
-            let current_field = state.current_field();
-            // Prevent moving up from the first field
-            if current_field > 0 {
-                let new_field = current_field - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-            }
-            Ok("ahoj".to_string())
-        }
-        "move_down" => {
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let last_field_index = num_fields - 1;
-                if current_field < last_field_index {
-                    let new_field = current_field + 1;
-                    state.set_current_field(new_field);
-                    let current_input = state.get_current_input();
-                    let max_pos = current_input.len();
-                    state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-                }
-            }
-            Ok("".to_string())
-        }
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            let new_pos = current_input.len();
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_first_line" => {
-            if AddTableState::INPUT_FIELD_COUNT > 0 {
-                state.set_current_field(0);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-            }
-            Ok("".to_string())
-        }
-        "move_last_line" => {
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let new_field = num_fields - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-            }
-            Ok("".to_string())
-        }
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_next_word_start(current_input, state.current_cursor_pos());
-                let final_pos = new_pos.min(current_input.len());
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-
-                let final_pos = if new_pos == current_pos {
-                    find_word_end(current_input, new_pos + 1)
-                } else {
-                    new_pos
-                };
-
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(current_input, state.current_cursor_pos());
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(current_input, state.current_cursor_pos());
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        // Actions handled by main event loop (mode changes, save, revert)
-        "exit_edit_mode" | "save" | "revert" => {
-            Ok("Action handled by main loop".to_string())
-        }
-        _ => Ok(format!("Unknown or unhandled edit action: {}", action)),
-    }
-}

client/src/functions/modes/edit/auth_e.rs

@@ -1,473 +0,0 @@
-// src/functions/modes/edit/auth_e.rs
-
-use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState;
-use crate::state::pages::auth::RegisterState;
-use crate::tui::functions::common::form::{revert, save};
-use crossterm::event::{KeyCode, KeyEvent};
-use std::any::Any;
-use anyhow::Result;
-
-pub async fn execute_common_action<S: CanvasState + Any>(
-    action: &str,
-    state: &mut S,
-    grpc_client: &mut GrpcClient,
-    current_position: &mut u64,
-    total_count: u64,
-) -> Result<String> {
-    match action {
-        "save" | "revert" => {
-            if !state.has_unsaved_changes() {
-                return Ok("No changes to save or revert.".to_string());
-            }
-            if let Some(form_state) =
-                (state as &mut dyn Any).downcast_mut::<FormState>()
-            {
-                match action {
-                    "save" => {
-                        let outcome = save(
-                            form_state,
-                            grpc_client,
-                        )
-                        .await?;
-                        let message = format!("Save successful: {:?}", outcome); // Simple message for now
-                        Ok(message)
-                    }
-                    "revert" => {
-                        revert(
-                            form_state,
-                            grpc_client,
-                        )
-                        .await
-                    }
-                    _ => unreachable!(),
-                }
-            } else {
-                Ok(format!(
-                    "Action '{}' not implemented for this state type.",
-                    action
-                ))
-            }
-        }
-        _ => Ok(format!("Common action '{}' not handled here.", action)),
-    }
-}
-
-pub async fn execute_edit_action<S: CanvasState + Any + Send>(
-    action: &str,
-    key: KeyEvent,
-    state: &mut S,
-    ideal_cursor_column: &mut usize,
-) -> Result<String> {
-    match action {
-        "insert_char" => {
-            if let KeyCode::Char(c) = key.code {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.insert(cursor_pos, c);
-                    *field_value = chars.into_iter().collect();
-                    state.set_current_cursor_pos(cursor_pos + 1);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = state.current_cursor_pos();
-                }
-            } else {
-                return Ok("Error: insert_char called without a char key."
-                    .to_string());
-            }
-            Ok("working?".to_string())
-        }
-
-        "delete_char_backward" => {
-            if state.current_cursor_pos() > 0 {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.remove(cursor_pos - 1);
-                    *field_value = chars.into_iter().collect();
-                    let new_pos = cursor_pos - 1;
-                    state.set_current_cursor_pos(new_pos);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = new_pos;
-                }
-            }
-            Ok("".to_string())
-        }
-
-        "delete_char_forward" => {
-            let cursor_pos = state.current_cursor_pos();
-            let field_value = state.get_current_input_mut();
-            let mut chars: Vec<char> = field_value.chars().collect();
-            if cursor_pos < chars.len() {
-                chars.remove(cursor_pos);
-                *field_value = chars.into_iter().collect();
-                state.set_has_unsaved_changes(true);
-                *ideal_cursor_column = cursor_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "next_field" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = (current_field + 1).min(num_fields - 1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "prev_field" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = current_field.saturating_sub(1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_left" => {
-            let new_pos = state.current_cursor_pos().saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if current_pos < current_input.len() {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_up" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = current_field.saturating_sub(1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_down" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let new_field = (state.current_field() + 1).min(num_fields - 1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            let new_pos = current_input.len();
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-
-        "move_first_line" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                state.set_current_field(0);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("Moved to first field".to_string())
-        }
-
-        "move_last_line" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let new_field = num_fields - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("Moved to last field".to_string())
-        }
-
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_next_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                let final_pos = new_pos.min(current_input.len());
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-
-                let final_pos = if new_pos == current_pos {
-                    find_word_end(current_input, new_pos + 1)
-                } else {
-                    new_pos
-                };
-
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("Moved to previous word end".to_string())
-        }
-
-        // --- Autocomplete Actions ---
-        "suggestion_down" | "suggestion_up" | "select_suggestion" | "exit_suggestion_mode" => {
-            // Attempt to downcast to RegisterState to handle suggestion logic here
-            if let Some(register_state) = (state as &mut dyn Any).downcast_mut::<RegisterState>() {
-                // Only handle if it's the role field (index 4)
-                if register_state.current_field() == 4 {
-                    match action {
-                        "suggestion_down" if register_state.in_suggestion_mode => {
-                            let max_index = register_state.role_suggestions.len().saturating_sub(1);
-                            let current_index = register_state.selected_suggestion_index.unwrap_or(0);
-                            register_state.selected_suggestion_index = Some(if current_index >= max_index { 0 } else { current_index + 1 });
-                            Ok("Suggestion changed down".to_string())
-                        }
-                        "suggestion_up" if register_state.in_suggestion_mode => {
-                            let max_index = register_state.role_suggestions.len().saturating_sub(1);
-                            let current_index = register_state.selected_suggestion_index.unwrap_or(0);
-                            register_state.selected_suggestion_index = Some(if current_index == 0 { max_index } else { current_index.saturating_sub(1) });
-                            Ok("Suggestion changed up".to_string())
-                        }
-                        "select_suggestion" if register_state.in_suggestion_mode => {
-                            if let Some(index) = register_state.selected_suggestion_index {
-                                if let Some(selected_role) = register_state.role_suggestions.get(index).cloned() {
-                                    register_state.role = selected_role.clone(); // Update the role field
-                                    register_state.in_suggestion_mode = false; // Exit suggestion mode
-                                    register_state.show_role_suggestions = false; // Hide suggestions
-                                    register_state.selected_suggestion_index = None; // Clear selection
-                                    Ok(format!("Selected role: {}", selected_role)) // Return success message
-                                } else {
-                                    Ok("Selected suggestion index out of bounds.".to_string()) // Error case
-                                }
-                            } else {
-                                Ok("No suggestion selected".to_string())
-                            }
-                        }
-                        "exit_suggestion_mode" => { // Handle Esc or other conditions
-                            register_state.show_role_suggestions = false;
-                            register_state.selected_suggestion_index = None;
-                            register_state.in_suggestion_mode = false;
-                            Ok("Suggestions hidden".to_string())
-                        }
-                        _ => {
-                            // Action is suggestion-related but state doesn't match (e.g., not in suggestion mode)
-                            Ok("Suggestion action ignored: State mismatch.".to_string())
-                        }
-                    }
-                } else {
-                    // It's RegisterState, but not the role field
-                    Ok("Suggestion action ignored: Not on role field.".to_string())
-                 }
-            } else {
-                // Downcast failed - this action is only for RegisterState
-                Ok(format!("Action '{}' not applicable for this state type.", action))
-            }
-        }
-        // --- End Autocomplete Actions ---
-
-
-        _ => Ok(format!("Unknown or unhandled edit action: {}", action)),
-    }
-}
-
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() {
-        CharType::Whitespace
-    } else if c.is_alphanumeric() {
-        CharType::Alphanumeric
-    } else {
-        CharType::Punctuation
-    }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos >= len {
-        return len;
-    }
-
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-
-    while pos < len && get_char_type(chars[pos]) == initial_type {
-        pos += 1;
-    }
-
-    while pos < len && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos += 1;
-    }
-
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.min(len - 1);
-
-    if get_char_type(chars[pos]) == CharType::Whitespace {
-        pos = find_next_word_start(text, pos);
-    }
-
-    if pos >= len {
-        return len.saturating_sub(1);
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type {
-        pos += 1;
-    }
-
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    pos
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-    if pos == 0 && get_char_type(chars[pos]) != CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos > 0 {
-        pos - 1
-    } else {
-        0
-    }
-}

client/src/functions/modes/edit/form_e.rs

@@ -1,432 +0,0 @@
-// src/functions/modes/edit/form_e.rs
-
-use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState;
-use crate::tui::functions::common::form::{revert, save};
-use crate::tui::functions::common::form::SaveOutcome;
-use crate::modes::handlers::event::EventOutcome;
-use crossterm::event::{KeyCode, KeyEvent};
-use std::any::Any;
-use anyhow::Result;
-
-pub async fn execute_common_action<S: CanvasState + Any>(
-    action: &str,
-    state: &mut S,
-    grpc_client: &mut GrpcClient,
-) -> Result<EventOutcome> {
-    match action {
-        "save" | "revert" => {
-            if !state.has_unsaved_changes() {
-                return Ok(EventOutcome::Ok("No changes to save or revert.".to_string()));
-            }
-            if let Some(form_state) =
-                (state as &mut dyn Any).downcast_mut::<FormState>()
-            {
-                match action {
-                    "save" => {
-                        let save_result = save(
-                            form_state,
-                            grpc_client,
-                        ).await;
-                        
-                        match save_result {
-                            Ok(save_outcome) => {
-                                let message = match save_outcome {
-                                    SaveOutcome::NoChange => "No changes to save.".to_string(),
-                                    SaveOutcome::UpdatedExisting => "Entry updated.".to_string(),
-                                    SaveOutcome::CreatedNew(_) => "New entry created.".to_string(),
-                                };
-                                Ok(EventOutcome::DataSaved(save_outcome, message))
-                            }
-                            Err(e) => Err(e),
-                        }
-                    }
-                    "revert" => {
-                        let revert_result = revert(
-                            form_state,
-                            grpc_client,
-                        ).await;
-                        
-                        match revert_result {
-                            Ok(message) => Ok(EventOutcome::Ok(message)),
-                            Err(e) => Err(e),
-                        }
-                    }
-                    _ => unreachable!(),
-                }
-            } else {
-                Ok(EventOutcome::Ok(format!(
-                    "Action '{}' not implemented for this state type.",
-                    action
-                )))
-            }
-        }
-        _ => Ok(EventOutcome::Ok(format!("Common action '{}' not handled here.", action))),
-    }
-}
-
-pub async fn execute_edit_action<S: CanvasState>(
-    action: &str,
-    key: KeyEvent,
-    state: &mut S,
-    ideal_cursor_column: &mut usize,
-) -> Result<String> {
-    match action {
-        "insert_char" => {
-            if let KeyCode::Char(c) = key.code {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.insert(cursor_pos, c);
-                    *field_value = chars.into_iter().collect();
-                    state.set_current_cursor_pos(cursor_pos + 1);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = state.current_cursor_pos();
-                }
-            } else {
-                return Ok("Error: insert_char called without a char key."
-                    .to_string());
-            }
-            Ok("".to_string())
-        }
-
-        "delete_char_backward" => {
-            if state.current_cursor_pos() > 0 {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.remove(cursor_pos - 1);
-                    *field_value = chars.into_iter().collect();
-                    let new_pos = cursor_pos - 1;
-                    state.set_current_cursor_pos(new_pos);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = new_pos;
-                }
-            }
-            Ok("".to_string())
-        }
-
-        "delete_char_forward" => {
-            let cursor_pos = state.current_cursor_pos();
-            let field_value = state.get_current_input_mut();
-            let mut chars: Vec<char> = field_value.chars().collect();
-            if cursor_pos < chars.len() {
-                chars.remove(cursor_pos);
-                *field_value = chars.into_iter().collect();
-                state.set_has_unsaved_changes(true);
-                *ideal_cursor_column = cursor_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "next_field" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = (current_field + 1) % num_fields;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "prev_field" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = if current_field == 0 {
-                    num_fields - 1
-                } else {
-                    current_field - 1
-                };
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_left" => {
-            let new_pos = state.current_cursor_pos().saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if current_pos < current_input.len() {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_up" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = current_field.saturating_sub(1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_down" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let new_field = (state.current_field() + 1).min(num_fields - 1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            let new_pos = current_input.len();
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-
-        "move_first_line" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                state.set_current_field(0);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("Moved to first field".to_string())
-        }
-
-        "move_last_line" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let new_field = num_fields - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("Moved to last field".to_string())
-        }
-
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_next_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                let final_pos = new_pos.min(current_input.len());
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-
-                let final_pos = if new_pos == current_pos {
-                    find_word_end(current_input, new_pos + 1)
-                } else {
-                    new_pos
-                };
-
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("Moved to previous word end".to_string())
-        }
-
-        _ => Ok(format!("Unknown or unhandled edit action: {}", action)),
-    }
-}
-
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() {
-        CharType::Whitespace
-    } else if c.is_alphanumeric() {
-        CharType::Alphanumeric
-    } else {
-        CharType::Punctuation
-    }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos >= len {
-        return len;
-    }
-
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-
-    while pos < len && get_char_type(chars[pos]) == initial_type {
-        pos += 1;
-    }
-
-    while pos < len && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos += 1;
-    }
-
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.min(len - 1);
-
-    if get_char_type(chars[pos]) == CharType::Whitespace {
-        pos = find_next_word_start(text, pos);
-    }
-
-    if pos >= len {
-        return len.saturating_sub(1);
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type {
-        pos += 1;
-    }
-
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    pos
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-    if pos == 0 && get_char_type(chars[pos]) != CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos > 0 {
-        pos - 1
-    } else {
-        0
-    }
-}

client/src/functions/modes/navigation.rs

@@ -1,5 +0,0 @@
-// src/functions/modes/navigation.rs
-
-pub mod admin_nav;
-pub mod add_table_nav;
-pub mod add_logic_nav;

client/src/functions/modes/navigation/add_logic_nav.rs

@@ -1,440 +0,0 @@
-// src/functions/modes/navigation/add_logic_nav.rs
-use crate::config::binds::config::{Config, EditorKeybindingMode};
-use crate::state::{
-    app::state::AppState,
-    pages::add_logic::{AddLogicFocus, AddLogicState},
-    app::buffer::AppView,
-    app::buffer::BufferState,
-};
-use crossterm::event::{KeyEvent, KeyCode, KeyModifiers};
-use crate::services::GrpcClient;
-use tokio::sync::mpsc;
-use anyhow::Result;
-use crate::components::common::text_editor::TextEditor;
-use crate::services::ui_service::UiService;
-use tui_textarea::CursorMove; // Ensure this import is present
-
-pub type SaveLogicResultSender = mpsc::Sender<Result<String>>;
-
-pub fn handle_add_logic_navigation(
-    key_event: KeyEvent,
-    config: &Config,
-    app_state: &mut AppState,
-    add_logic_state: &mut AddLogicState,
-    is_edit_mode: &mut bool,
-    buffer_state: &mut BufferState,
-    grpc_client: GrpcClient,
-    _save_logic_sender: SaveLogicResultSender, // Marked as unused
-    command_message: &mut String,
-) -> bool {
-    // === FULLSCREEN SCRIPT EDITING - COMPLETE ISOLATION ===
-    if add_logic_state.current_focus == AddLogicFocus::InsideScriptContent {
-        // === AUTOCOMPLETE HANDLING ===
-        if add_logic_state.script_editor_autocomplete_active {
-            match key_event.code {
-                // ... (Char, Backspace, Tab, Down, Up cases remain the same) ...
-                KeyCode::Char(c) if c.is_alphanumeric() || c == '_' => {
-                    add_logic_state.script_editor_filter_text.push(c);
-                    add_logic_state.update_script_editor_suggestions();
-                    {
-                        let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                        TextEditor::handle_input(
-                            &mut editor_borrow,
-                            key_event,
-                            &add_logic_state.editor_keybinding_mode,
-                            &mut add_logic_state.vim_state,
-                        );
-                    }
-                    *command_message = format!("Filtering: @{}", add_logic_state.script_editor_filter_text);
-                    return true;
-                }
-                KeyCode::Backspace => {
-                    if !add_logic_state.script_editor_filter_text.is_empty() {
-                        add_logic_state.script_editor_filter_text.pop();
-                        add_logic_state.update_script_editor_suggestions();
-                        {
-                            let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                            TextEditor::handle_input(
-                                &mut editor_borrow,
-                                key_event,
-                                &add_logic_state.editor_keybinding_mode,
-                                &mut add_logic_state.vim_state,
-                            );
-                        }
-                        *command_message = if add_logic_state.script_editor_filter_text.is_empty() {
-                            "Autocomplete: @".to_string()
-                        } else {
-                            format!("Filtering: @{}", add_logic_state.script_editor_filter_text)
-                        };
-                    } else {
-                        let should_deactivate = if let Some((trigger_line, trigger_col)) = add_logic_state.script_editor_trigger_position {
-                            let current_cursor = {
-                                let editor_borrow = add_logic_state.script_content_editor.borrow();
-                                editor_borrow.cursor()
-                            };
-                            current_cursor.0 == trigger_line && current_cursor.1 == trigger_col + 1
-                        } else {
-                            false
-                        };
-                        if should_deactivate {
-                            add_logic_state.deactivate_script_editor_autocomplete();
-                            *command_message = "Autocomplete cancelled".to_string();
-                        }
-                        {
-                            let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                            TextEditor::handle_input(
-                                &mut editor_borrow,
-                                key_event,
-                                &add_logic_state.editor_keybinding_mode,
-                                &mut add_logic_state.vim_state,
-                            );
-                        }
-                    }
-                    return true;
-                }
-                KeyCode::Tab | KeyCode::Down => {
-                    if !add_logic_state.script_editor_suggestions.is_empty() {
-                        let current = add_logic_state.script_editor_selected_suggestion_index.unwrap_or(0);
-                        let next = (current + 1) % add_logic_state.script_editor_suggestions.len();
-                        add_logic_state.script_editor_selected_suggestion_index = Some(next);
-                        *command_message = format!("Selected: {}", add_logic_state.script_editor_suggestions[next]);
-                    }
-                    return true;
-                }
-                KeyCode::Up => {
-                    if !add_logic_state.script_editor_suggestions.is_empty() {
-                        let current = add_logic_state.script_editor_selected_suggestion_index.unwrap_or(0);
-                        let prev = if current == 0 {
-                            add_logic_state.script_editor_suggestions.len() - 1
-                        } else {
-                            current - 1
-                        };
-                        add_logic_state.script_editor_selected_suggestion_index = Some(prev);
-                        *command_message = format!("Selected: {}", add_logic_state.script_editor_suggestions[prev]);
-                    }
-                    return true;
-                }
-                KeyCode::Enter => {
-                    if let Some(selected_idx) = add_logic_state.script_editor_selected_suggestion_index {
-                        if let Some(suggestion) = add_logic_state.script_editor_suggestions.get(selected_idx).cloned() {
-                            let trigger_pos = add_logic_state.script_editor_trigger_position;
-                            let filter_len = add_logic_state.script_editor_filter_text.len();
-
-                            add_logic_state.deactivate_script_editor_autocomplete();
-                            add_logic_state.has_unsaved_changes = true;
-
-                            if let Some(pos) = trigger_pos {
-                                let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-
-                                if suggestion == "sql" {
-                                    replace_autocomplete_text(&mut editor_borrow, pos, filter_len, "sql");
-                                    editor_borrow.insert_str("('')");
-                                    // Move cursor back twice to be between the single quotes
-                                    editor_borrow.move_cursor(CursorMove::Back); // Before ')'
-                                    editor_borrow.move_cursor(CursorMove::Back); // Before ''' (inside '')
-                                    *command_message = "Inserted: @sql('')".to_string();
-                                } else {
-                                    let is_table_selection = add_logic_state.is_table_name_suggestion(&suggestion);
-                                    replace_autocomplete_text(&mut editor_borrow, pos, filter_len, &suggestion);
-
-                                    if is_table_selection {
-                                        editor_borrow.insert_str(".");
-                                        let new_cursor = editor_borrow.cursor();
-                                        drop(editor_borrow); // Release borrow before calling add_logic_state methods
-
-                                        add_logic_state.script_editor_trigger_position = Some(new_cursor);
-                                        add_logic_state.script_editor_autocomplete_active = true;
-                                        add_logic_state.script_editor_filter_text.clear();
-                                        add_logic_state.trigger_column_autocomplete_for_table(suggestion.clone());
-
-                                        let profile_name = add_logic_state.profile_name.clone();
-                                        let table_name_for_fetch = suggestion.clone();
-                                        let mut client_clone = grpc_client.clone();
-                                        tokio::spawn(async move {
-                                            match UiService::fetch_columns_for_table(&mut client_clone, &profile_name, &table_name_for_fetch).await {
-                                                Ok(_columns) => {
-                                                    // Result handled by main UI loop
-                                                }
-                                                Err(e) => {
-                                                    tracing::error!("Failed to fetch columns for {}.{}: {}", profile_name, table_name_for_fetch, e);
-                                                }
-                                            }
-                                        });
-                                        *command_message = format!("Selected table '{}', fetching columns...", suggestion);
-                                    } else {
-                                        *command_message = format!("Inserted: {}", suggestion);
-                                    }
-                                }
-                            }
-                            return true;
-                        }
-                    }
-                    add_logic_state.deactivate_script_editor_autocomplete();
-                    {
-                        let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                        TextEditor::handle_input(
-                            &mut editor_borrow,
-                            key_event,
-                            &add_logic_state.editor_keybinding_mode,
-                            &mut add_logic_state.vim_state,
-                        );
-                    }
-                    return true;
-                }
-                KeyCode::Esc => {
-                    add_logic_state.deactivate_script_editor_autocomplete();
-                    *command_message = "Autocomplete cancelled".to_string();
-                }
-                _ => {
-                    add_logic_state.deactivate_script_editor_autocomplete();
-                    *command_message = "Autocomplete cancelled".to_string();
-                    {
-                        let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                        TextEditor::handle_input(
-                            &mut editor_borrow,
-                            key_event,
-                            &add_logic_state.editor_keybinding_mode,
-                            &mut add_logic_state.vim_state,
-                        );
-                    }
-                    return true;
-                }
-            }
-        }
-
-        if key_event.code == KeyCode::Char('@') && key_event.modifiers == KeyModifiers::NONE {
-            let should_trigger = match add_logic_state.editor_keybinding_mode {
-                EditorKeybindingMode::Vim => *is_edit_mode,
-                _ => true,
-            };
-            if should_trigger {
-                let cursor_before = {
-                    let editor_borrow = add_logic_state.script_content_editor.borrow();
-                    editor_borrow.cursor()
-                };
-                {
-                    let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                    TextEditor::handle_input(
-                        &mut editor_borrow,
-                        key_event,
-                        &add_logic_state.editor_keybinding_mode,
-                        &mut add_logic_state.vim_state,
-                    );
-                }
-                add_logic_state.script_editor_trigger_position = Some(cursor_before);
-                add_logic_state.script_editor_autocomplete_active = true;
-                add_logic_state.script_editor_filter_text.clear();
-                add_logic_state.update_script_editor_suggestions();
-                add_logic_state.has_unsaved_changes = true;
-                *command_message = "Autocomplete: @ (Tab/↑↓ to navigate, Enter to select, Esc to cancel)".to_string();
-                return true;
-            }
-        }
-
-        if key_event.code == KeyCode::Esc && key_event.modifiers == KeyModifiers::NONE {
-            match add_logic_state.editor_keybinding_mode {
-                EditorKeybindingMode::Vim => {
-                    if *is_edit_mode {
-                        {
-                            let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                            TextEditor::handle_input(
-                                &mut editor_borrow,
-                                key_event,
-                                &add_logic_state.editor_keybinding_mode,
-                                &mut add_logic_state.vim_state,
-                            );
-                        }
-                        if TextEditor::is_vim_normal_mode(&add_logic_state.vim_state) {
-                            *is_edit_mode = false;
-                            *command_message = "VIM: Normal Mode. Esc again to exit script.".to_string();
-                        }
-                    } else {
-                        add_logic_state.current_focus = AddLogicFocus::ScriptContentPreview;
-                        app_state.ui.focus_outside_canvas = true;
-                        *is_edit_mode = false;
-                        *command_message = "Exited script editing.".to_string();
-                    }
-                }
-                _ => {
-                    if *is_edit_mode {
-                        *is_edit_mode = false;
-                        *command_message = "Exited script edit. Esc again to exit script.".to_string();
-                    } else {
-                        add_logic_state.current_focus = AddLogicFocus::ScriptContentPreview;
-                        app_state.ui.focus_outside_canvas = true;
-                        *is_edit_mode = false;
-                        *command_message = "Exited script editing.".to_string();
-                    }
-                }
-            }
-            return true;
-        }
-
-        let changed = {
-            let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-            TextEditor::handle_input(
-                &mut editor_borrow,
-                key_event,
-                &add_logic_state.editor_keybinding_mode,
-                &mut add_logic_state.vim_state,
-            )
-        };
-        if changed {
-            add_logic_state.has_unsaved_changes = true;
-        }
-        if add_logic_state.editor_keybinding_mode == EditorKeybindingMode::Vim {
-            *is_edit_mode = !TextEditor::is_vim_normal_mode(&add_logic_state.vim_state);
-        }
-        return true;
-    }
-
-    let action = config.get_general_action(key_event.code, key_event.modifiers);
-    let current_focus = add_logic_state.current_focus;
-    let mut handled = true;
-    let mut new_focus = current_focus;
-
-    match action.as_deref() {
-        Some("exit_table_scroll") => {
-            handled = false;
-        }
-        Some("move_up") => {
-            match current_focus {
-                AddLogicFocus::InputLogicName => {}
-                AddLogicFocus::InputTargetColumn => new_focus = AddLogicFocus::InputLogicName,
-                AddLogicFocus::InputDescription => new_focus = AddLogicFocus::InputTargetColumn,
-                AddLogicFocus::ScriptContentPreview => new_focus = AddLogicFocus::InputDescription,
-                AddLogicFocus::SaveButton => new_focus = AddLogicFocus::ScriptContentPreview,
-                AddLogicFocus::CancelButton => new_focus = AddLogicFocus::SaveButton,
-                _ => handled = false,
-            }
-        }
-        Some("move_down") => {
-            match current_focus {
-                AddLogicFocus::InputLogicName => new_focus = AddLogicFocus::InputTargetColumn,
-                AddLogicFocus::InputTargetColumn => new_focus = AddLogicFocus::InputDescription,
-                AddLogicFocus::InputDescription => {
-                    add_logic_state.last_canvas_field = 2;
-                    new_focus = AddLogicFocus::ScriptContentPreview;
-                },
-                AddLogicFocus::ScriptContentPreview => new_focus = AddLogicFocus::SaveButton,
-                AddLogicFocus::SaveButton => new_focus = AddLogicFocus::CancelButton,
-                AddLogicFocus::CancelButton => {}
-                _ => handled = false,
-            }
-        }
-        Some("next_option") => {
-            match current_focus {
-                AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription =>
-                    { new_focus = AddLogicFocus::ScriptContentPreview; }
-                AddLogicFocus::ScriptContentPreview => new_focus = AddLogicFocus::SaveButton,
-                AddLogicFocus::SaveButton => new_focus = AddLogicFocus::CancelButton,
-                AddLogicFocus::CancelButton => { }
-                _ => handled = false,
-            }
-        }
-        Some("previous_option") => {
-            match current_focus {
-                AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription =>
-                    { }
-                AddLogicFocus::ScriptContentPreview => new_focus = AddLogicFocus::InputDescription,
-                AddLogicFocus::SaveButton => new_focus = AddLogicFocus::ScriptContentPreview,
-                AddLogicFocus::CancelButton => new_focus = AddLogicFocus::SaveButton,
-                _ => handled = false,
-            }
-        }
-        Some("next_field") => {
-            new_focus = match current_focus {
-                AddLogicFocus::InputLogicName => AddLogicFocus::InputTargetColumn,
-                AddLogicFocus::InputTargetColumn => AddLogicFocus::InputDescription,
-                AddLogicFocus::InputDescription => AddLogicFocus::ScriptContentPreview,
-                AddLogicFocus::ScriptContentPreview => AddLogicFocus::SaveButton,
-                AddLogicFocus::SaveButton => AddLogicFocus::CancelButton,
-                AddLogicFocus::CancelButton => AddLogicFocus::InputLogicName,
-                _ => current_focus,
-            };
-        }
-        Some("prev_field") => {
-            new_focus = match current_focus {
-                AddLogicFocus::InputLogicName => AddLogicFocus::CancelButton,
-                AddLogicFocus::InputTargetColumn => AddLogicFocus::InputLogicName,
-                AddLogicFocus::InputDescription => AddLogicFocus::InputTargetColumn,
-                AddLogicFocus::ScriptContentPreview => AddLogicFocus::InputDescription,
-                AddLogicFocus::SaveButton => AddLogicFocus::ScriptContentPreview,
-                AddLogicFocus::CancelButton => AddLogicFocus::SaveButton,
-                _ => current_focus,
-            };
-        }
-        Some("select") => {
-            match current_focus {
-                AddLogicFocus::ScriptContentPreview => {
-                    new_focus = AddLogicFocus::InsideScriptContent;
-                    *is_edit_mode = false;
-                    app_state.ui.focus_outside_canvas = false;
-                    let mode_hint = match add_logic_state.editor_keybinding_mode {
-                        EditorKeybindingMode::Vim => "VIM mode - 'i'/'a'/'o' to edit",
-                        _ => "Enter/Ctrl+E to edit",
-                    };
-                    *command_message = format!("Fullscreen script editing. {} or Esc to exit.", mode_hint);
-                }
-                AddLogicFocus::SaveButton => {
-                    *command_message = "Save logic action".to_string();
-                }
-                AddLogicFocus::CancelButton => {
-                    buffer_state.update_history(AppView::Admin);
-                    app_state.ui.show_add_logic = false;
-                    *command_message = "Cancelled Add Logic".to_string();
-                    *is_edit_mode = false;
-                }
-                AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription => {
-                    *is_edit_mode = !*is_edit_mode;
-                    *command_message = format!("Field edit mode: {}", if *is_edit_mode { "ON" } else { "OFF" });
-                }
-                _ => handled = false,
-            }
-        }
-        Some("toggle_edit_mode") => {
-            match current_focus {
-                AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription => {
-                    *is_edit_mode = !*is_edit_mode;
-                    *command_message = format!("Canvas field edit mode: {}", if *is_edit_mode { "ON" } else { "OFF" });
-                }
-                _ => {
-                    *command_message = "Cannot toggle edit mode here.".to_string();
-                }
-            }
-        }
-        _ => handled = false,
-    }
-
-    if handled && current_focus != new_focus {
-        add_logic_state.current_focus = new_focus;
-        let new_is_canvas_input_focus = matches!(new_focus,
-            AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription
-        );
-        if new_is_canvas_input_focus {
-            *is_edit_mode = false;
-            app_state.ui.focus_outside_canvas = false;
-        } else {
-            app_state.ui.focus_outside_canvas = true;
-            if matches!(new_focus, AddLogicFocus::ScriptContentPreview) {
-                *is_edit_mode = false;
-            }
-        }
-    }
-    handled
-}
-
-fn replace_autocomplete_text(
-    editor: &mut tui_textarea::TextArea,
-    trigger_pos: (usize, usize),
-    filter_len: usize,
-    replacement: &str,
-) {
-    // use tui_textarea::CursorMove; // Already imported at the top of the module
-    let filter_start_pos = (trigger_pos.0, trigger_pos.1 + 1);
-    editor.move_cursor(CursorMove::Jump(filter_start_pos.0 as u16, filter_start_pos.1 as u16));
-    for _ in 0..filter_len {
-        editor.delete_next_char();
-    }
-    editor.insert_str(replacement);
-}

client/src/functions/modes/navigation/add_table_nav.rs

@@ -1,205 +0,0 @@
-// src/functions/modes/navigation/add_table_nav.rs
-use crate::config::binds::config::Config;
-use crate::state::{
-    app::state::AppState,
-    pages::add_table::{AddTableFocus, AddTableState},
-};
-use crossterm::event::{KeyEvent};
-use ratatui::widgets::TableState;
-use crate::tui::functions::common::add_table::{handle_add_column_action, handle_save_table_action};
-use crate::ui::handlers::context::DialogPurpose;
-use crate::services::GrpcClient;
-use tokio::sync::mpsc;
-use anyhow::Result;
-
-pub type SaveTableResultSender = mpsc::Sender<Result<String>>;
-
-fn navigate_table_up(table_state: &mut TableState, item_count: usize) -> bool {
-    if item_count == 0 { return false; }
-    let current_selection = table_state.selected();
-    match current_selection {
-        Some(index) => {
-            if index > 0 { table_state.select(Some(index - 1)); true }
-            else { false }
-        }
-        None => { table_state.select(Some(0)); true }
-    }
-}
-
-fn navigate_table_down(table_state: &mut TableState, item_count: usize) -> bool {
-     if item_count == 0 { return false; }
-    let current_selection = table_state.selected();
-    match current_selection {
-        Some(index) => {
-            if index < item_count - 1 { table_state.select(Some(index + 1)); true }
-            else { false }
-        }
-        None => { table_state.select(Some(0)); true }
-    }
-}
-
-pub fn handle_add_table_navigation(
-    key: KeyEvent,
-    config: &Config,
-    app_state: &mut AppState,
-    add_table_state: &mut AddTableState,
-    grpc_client: GrpcClient,
-    save_result_sender: SaveTableResultSender,
-    command_message: &mut String,
-) -> bool {
-    let action = config.get_general_action(key.code, key.modifiers);
-    let current_focus = add_table_state.current_focus;
-    let mut handled = true;
-    let mut new_focus = current_focus;
-
-    if matches!(current_focus, AddTableFocus::InsideColumnsTable | AddTableFocus::InsideIndexesTable | AddTableFocus::InsideLinksTable) {
-        if matches!(action.as_deref(), Some("next_option") | Some("previous_option")) {
-            *command_message = "Press Esc to exit table item navigation first.".to_string();
-            return true;
-        }
-    }
-
-    match action.as_deref() {
-       Some("exit_table_scroll") => {
-           match current_focus {
-               AddTableFocus::InsideColumnsTable => {
-                   add_table_state.column_table_state.select(None);
-                   new_focus = AddTableFocus::ColumnsTable;
-                   // *command_message = "Exited Columns Table".to_string(); // Minimal change: remove message
-               }
-               AddTableFocus::InsideIndexesTable => {
-                   add_table_state.index_table_state.select(None);
-                   new_focus = AddTableFocus::IndexesTable;
-                   // *command_message = "Exited Indexes Table".to_string();
-               }
-               AddTableFocus::InsideLinksTable => {
-                   add_table_state.link_table_state.select(None);
-                   new_focus = AddTableFocus::LinksTable;
-                   // *command_message = "Exited Links Table".to_string();
-               }
-               _ => handled = false,
-           }
-       }
-        Some("move_up") => {
-            match current_focus {
-                AddTableFocus::InputTableName => {
-                    // MINIMAL CHANGE: Do nothing, new_focus remains current_focus
-                    // *command_message = "At top of form.".to_string(); // Remove message
-                }
-                AddTableFocus::InputColumnName => new_focus = AddTableFocus::InputTableName,
-                AddTableFocus::InputColumnType => new_focus = AddTableFocus::InputColumnName,
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::AddColumnButton,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::InsideColumnsTable => { navigate_table_up(&mut add_table_state.column_table_state, add_table_state.columns.len()); }
-                AddTableFocus::InsideIndexesTable => { navigate_table_up(&mut add_table_state.index_table_state, add_table_state.indexes.len()); }
-                AddTableFocus::InsideLinksTable => { navigate_table_up(&mut add_table_state.link_table_state, add_table_state.links.len()); }
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::CancelButton => new_focus = AddTableFocus::DeleteSelectedButton,
-            }
-        }
-        Some("move_down") => {
-            match current_focus {
-                AddTableFocus::InputTableName => new_focus = AddTableFocus::InputColumnName,
-                AddTableFocus::InputColumnName => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::InputColumnType => {
-                    add_table_state.last_canvas_field = 2;
-                    new_focus = AddTableFocus::AddColumnButton;
-                },
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::InsideColumnsTable => { navigate_table_down(&mut add_table_state.column_table_state, add_table_state.columns.len()); }
-                AddTableFocus::InsideIndexesTable => { navigate_table_down(&mut add_table_state.index_table_state, add_table_state.indexes.len()); }
-                AddTableFocus::InsideLinksTable => { navigate_table_down(&mut add_table_state.link_table_state, add_table_state.links.len()); }
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::DeleteSelectedButton,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::CancelButton,
-                AddTableFocus::CancelButton => {
-                    // MINIMAL CHANGE: Do nothing, new_focus remains current_focus
-                    // *command_message = "At bottom of form.".to_string(); // Remove message
-                }
-            }
-        }
-        Some("next_option") => { // This logic should already be non-wrapping
-            match current_focus {
-                AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType =>
-                    { new_focus = AddTableFocus::AddColumnButton; }
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::DeleteSelectedButton,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::CancelButton,
-                AddTableFocus::CancelButton => { /* *command_message = "At last focusable area.".to_string(); */ } // No change in focus
-                _ => handled = false,
-            }
-        }
-        Some("previous_option") => { // This logic should already be non-wrapping
-            match current_focus {
-                AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType =>
-                    { /* *command_message = "At first focusable area.".to_string(); */ } // No change in focus
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::AddColumnButton,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::CancelButton => new_focus = AddTableFocus::DeleteSelectedButton,
-                _ => handled = false,
-            }
-        }
-        Some("next_field") => {
-            new_focus = match current_focus {
-                AddTableFocus::InputTableName => AddTableFocus::InputColumnName, AddTableFocus::InputColumnName => AddTableFocus::InputColumnType, AddTableFocus::InputColumnType => AddTableFocus::AddColumnButton, AddTableFocus::AddColumnButton => AddTableFocus::ColumnsTable,
-                AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable => AddTableFocus::IndexesTable, AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable => AddTableFocus::LinksTable, AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable => AddTableFocus::SaveButton,
-                AddTableFocus::SaveButton => AddTableFocus::DeleteSelectedButton, AddTableFocus::DeleteSelectedButton => AddTableFocus::CancelButton, AddTableFocus::CancelButton => AddTableFocus::InputTableName,
-            };
-        }
-        Some("prev_field") => {
-            new_focus = match current_focus {
-                AddTableFocus::InputTableName => AddTableFocus::CancelButton, AddTableFocus::InputColumnName => AddTableFocus::InputTableName, AddTableFocus::InputColumnType => AddTableFocus::InputColumnName, AddTableFocus::AddColumnButton => AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable => AddTableFocus::AddColumnButton, AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable => AddTableFocus::ColumnsTable, AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable => AddTableFocus::IndexesTable,
-                AddTableFocus::SaveButton => AddTableFocus::LinksTable, AddTableFocus::DeleteSelectedButton => AddTableFocus::SaveButton, AddTableFocus::CancelButton => AddTableFocus::DeleteSelectedButton,
-            };
-        }
-        Some("select") => {
-            match current_focus {
-                AddTableFocus::ColumnsTable => { new_focus = AddTableFocus::InsideColumnsTable; if add_table_state.column_table_state.selected().is_none() && !add_table_state.columns.is_empty() { add_table_state.column_table_state.select(Some(0)); } /* Message removed */ }
-                AddTableFocus::IndexesTable => { new_focus = AddTableFocus::InsideIndexesTable; if add_table_state.index_table_state.selected().is_none() && !add_table_state.indexes.is_empty() { add_table_state.index_table_state.select(Some(0)); } /* Message removed */ }
-                AddTableFocus::LinksTable => { new_focus = AddTableFocus::InsideLinksTable; if add_table_state.link_table_state.selected().is_none() && !add_table_state.links.is_empty() { add_table_state.link_table_state.select(Some(0)); } /* Message removed */ }
-                AddTableFocus::InsideColumnsTable => { if let Some(index) = add_table_state.column_table_state.selected() { if let Some(col) = add_table_state.columns.get_mut(index) { col.selected = !col.selected; add_table_state.has_unsaved_changes = true; /* Message removed */ }} /* else { Message removed } */ }
-                AddTableFocus::InsideIndexesTable => { if let Some(index) = add_table_state.index_table_state.selected() { if let Some(idx_def) = add_table_state.indexes.get_mut(index) { idx_def.selected = !idx_def.selected; add_table_state.has_unsaved_changes = true; /* Message removed */ }} /* else { Message removed } */ }
-                AddTableFocus::InsideLinksTable => { if let Some(index) = add_table_state.link_table_state.selected() { if let Some(link) = add_table_state.links.get_mut(index) { link.selected = !link.selected; add_table_state.has_unsaved_changes = true; /* Message removed */ }} /* else { Message removed } */ }
-                AddTableFocus::AddColumnButton => { if let Some(focus_after_add) = handle_add_column_action(add_table_state, command_message) { new_focus = focus_after_add; } else { /* Message already set by handle_add_column_action */ }}
-                AddTableFocus::SaveButton => { if add_table_state.table_name.is_empty() { *command_message = "Cannot save: Table name is empty.".to_string(); } else if add_table_state.columns.is_empty() { *command_message = "Cannot save: No columns defined.".to_string(); } else { *command_message = "Saving table...".to_string(); app_state.show_loading_dialog("Saving", "Please wait..."); let mut client_clone = grpc_client.clone(); let state_clone = add_table_state.clone(); let sender_clone = save_result_sender.clone(); tokio::spawn(async move { let result = handle_save_table_action(&mut client_clone, &state_clone).await; let _ = sender_clone.send(result).await; }); }}
-                AddTableFocus::DeleteSelectedButton => { let columns_to_delete: Vec<(usize, String, String)> = add_table_state.columns.iter().enumerate().filter(|(_, col)| col.selected).map(|(index, col)| (index, col.name.clone(), col.data_type.clone())).collect(); if columns_to_delete.is_empty() { *command_message = "No columns selected for deletion.".to_string(); } else { let column_details: String = columns_to_delete.iter().map(|(index, name, dtype)| format!("{}. {} ({})", index + 1, name, dtype)).collect::<Vec<String>>().join("\n"); let message = format!("Delete the following columns?\n\n{}", column_details); app_state.show_dialog("Confirm Deletion", &message, vec!["Confirm".to_string(), "Cancel".to_string()], DialogPurpose::ConfirmDeleteColumns); }}
-                AddTableFocus::CancelButton => { *command_message = "Action: Cancel Add Table (Not Implemented)".to_string(); }
-                _ => { handled = false; }
-            }
-        }
-        _ => handled = false,
-    }
-
-    if handled && current_focus != new_focus {
-        add_table_state.current_focus = new_focus;
-        // Minimal change: Command message update logic can be simplified or removed if not desired
-        // For now, let's keep it minimal and only update if it was truly a focus change,
-        // and not a boundary message.
-        if !command_message.starts_with("At ") && current_focus != new_focus { // Avoid overwriting boundary messages
-            // *command_message = format!("Focus: {:?}", add_table_state.current_focus); // Optional: restore if needed
-        }
-
-
-        let new_is_canvas_input_focus = matches!(new_focus,
-            AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType
-        );
-        app_state.ui.focus_outside_canvas = !new_is_canvas_input_focus;
-    }
-    // If not handled, command_message remains as it was (e.g., from a deeper function call or previous event)
-    // or can be cleared if that's the desired default. For minimal change, we leave it.
-
-    handled
-}

client/src/functions/modes/navigation/admin_nav.rs

@@ -1,351 +0,0 @@
-// src/functions/modes/navigation/admin_nav.rs
-use crate::state::pages::admin::{AdminFocus, AdminState};
-use crate::state::app::state::AppState;
-use crate::config::binds::config::Config;
-use crate::state::app::buffer::{BufferState, AppView};
-use crate::state::pages::add_table::{AddTableState, LinkDefinition};
-use ratatui::widgets::ListState;
-use crate::state::pages::add_logic::{AddLogicState, AddLogicFocus}; // Added AddLogicFocus import
-
-// Helper functions list_select_next and list_select_previous remain the same
-fn list_select_next(list_state: &mut ListState, item_count: usize) {
-    if item_count == 0 {
-        list_state.select(None);
-        return;
-    }
-    let i = match list_state.selected() {
-        Some(i) => if i >= item_count - 1 { 0 } else { i + 1 },
-        None => 0,
-    };
-    list_state.select(Some(i));
-}
-
-fn list_select_previous(list_state: &mut ListState, item_count: usize) {
-    if item_count == 0 {
-        list_state.select(None);
-        return;
-    }
-    let i = match list_state.selected() {
-        Some(i) => if i == 0 { item_count - 1 } else { i - 1 },
-        None => if item_count > 0 { item_count - 1 } else { 0 },
-    };
-    list_state.select(Some(i));
-}
-
-pub fn handle_admin_navigation(
-    key: crossterm::event::KeyEvent,
-    config: &Config,
-    app_state: &mut AppState,
-    admin_state: &mut AdminState,
-    buffer_state: &mut BufferState,
-    command_message: &mut String,
-) -> bool {
-    let action = config.get_general_action(key.code, key.modifiers).map(String::from);
-    let current_focus = admin_state.current_focus;
-    let profile_count = app_state.profile_tree.profiles.len();
-    let mut handled = false;
-
-    match current_focus {
-        AdminFocus::ProfilesPane => {
-            match action.as_deref() {
-                Some("select") => {
-                    admin_state.current_focus = AdminFocus::InsideProfilesList;
-                    if !app_state.profile_tree.profiles.is_empty() {
-                        if admin_state.profile_list_state.selected().is_none() {
-                            admin_state.profile_list_state.select(Some(0));
-                        }
-                    }
-                    *command_message = "Navigating profiles. Use Up/Down. Esc to exit.".to_string();
-                    handled = true;
-                }
-                Some("next_option") | Some("move_down") => {
-                    admin_state.current_focus = AdminFocus::Tables;
-                    *command_message = "Focus: Tables Pane".to_string();
-                    handled = true;
-                }
-                Some("previous_option") | Some("move_up") => {
-                    // No wrap-around: Stay on ProfilesPane if trying to go "before" it
-                    *command_message = "At first focusable pane.".to_string();
-                    handled = true;
-                }
-                _ => handled = false,
-            }
-        }
-
-        AdminFocus::InsideProfilesList => {
-            match action.as_deref() {
-                Some("move_up") => {
-                    if profile_count > 0 {
-                        list_select_previous(&mut admin_state.profile_list_state, profile_count);
-                        *command_message = "".to_string();
-                        handled = true;
-                    }
-                }
-                Some("move_down") => {
-                    if profile_count > 0 {
-                        list_select_next(&mut admin_state.profile_list_state, profile_count);
-                        *command_message = "".to_string();
-                        handled = true;
-                    }
-                }
-                Some("select") => {
-                    admin_state.selected_profile_index = admin_state.profile_list_state.selected();
-                    admin_state.selected_table_index = None; // Deselect table when profile changes
-                    if let Some(profile_idx) = admin_state.selected_profile_index {
-                        if let Some(profile) = app_state.profile_tree.profiles.get(profile_idx) {
-                            if !profile.tables.is_empty() {
-                                admin_state.table_list_state.select(Some(0)); // Auto-select first table for nav
-                            } else {
-                                admin_state.table_list_state.select(None);
-                            }
-                        }
-                    } else {
-                        admin_state.table_list_state.select(None);
-                    }
-                    *command_message = format!(
-                        "Profile '{}' set as active.",
-                        admin_state.get_selected_profile_name().unwrap_or(&"N/A".to_string())
-                    );
-                    handled = true;
-                }
-                Some("exit_table_scroll") => {
-                    admin_state.current_focus = AdminFocus::ProfilesPane;
-                    *command_message = "Focus: Profiles Pane".to_string();
-                    handled = true;
-                }
-                _ => handled = false,
-            }
-        }
-
-        AdminFocus::Tables => {
-            match action.as_deref() {
-                Some("select") => {
-                    admin_state.current_focus = AdminFocus::InsideTablesList;
-                    let current_profile_idx = admin_state.selected_profile_index
-                        .or_else(|| admin_state.profile_list_state.selected());
-                    if let Some(profile_idx) = current_profile_idx {
-                        if let Some(profile) = app_state.profile_tree.profiles.get(profile_idx) {
-                             if !profile.tables.is_empty() {
-                                if admin_state.table_list_state.selected().is_none() {
-                                    admin_state.table_list_state.select(Some(0));
-                                }
-                             } else {
-                                admin_state.table_list_state.select(None);
-                             }
-                        } else {
-                            admin_state.table_list_state.select(None);
-                        }
-                    } else {
-                        admin_state.table_list_state.select(None);
-                         *command_message = "Select a profile first to view its tables.".to_string();
-                    }
-                    if admin_state.current_focus == AdminFocus::InsideTablesList && !admin_state.table_list_state.selected().is_none() {
-                        *command_message = "Navigating tables. Use Up/Down. Esc to exit.".to_string();
-                    } else if admin_state.table_list_state.selected().is_none() {
-                         if current_profile_idx.is_none() {
-                            *command_message = "No profile selected to view tables.".to_string();
-                         } else {
-                            *command_message = "No tables in selected profile.".to_string();
-                         }
-                         admin_state.current_focus = AdminFocus::Tables; // Stay in Tables pane if no tables to enter
-                    }
-                    handled = true;
-                }
-                Some("previous_option") | Some("move_up") => {
-                    admin_state.current_focus = AdminFocus::ProfilesPane;
-                    *command_message = "Focus: Profiles Pane".to_string();
-                    handled = true;
-                }
-                Some("next_option") | Some("move_down") => {
-                    admin_state.current_focus = AdminFocus::Button1;
-                    *command_message = "Focus: Add Logic Button".to_string();
-                    handled = true;
-                }
-                _ => handled = false,
-            }
-        }
-
-        AdminFocus::InsideTablesList => {
-            match action.as_deref() {
-                Some("move_up") => {
-                    let current_profile_idx = admin_state.selected_profile_index
-                        .or_else(|| admin_state.profile_list_state.selected());
-                    if let Some(p_idx) = current_profile_idx {
-                        if let Some(profile) = app_state.profile_tree.profiles.get(p_idx) {
-                            if !profile.tables.is_empty() {
-                                list_select_previous(&mut admin_state.table_list_state, profile.tables.len());
-                                *command_message = "".to_string();
-                                handled = true;
-                            } else {
-                                *command_message = "No tables to navigate.".to_string();
-                                handled = true;
-                            }
-                        }
-                    } else {
-                        *command_message = "No active profile for tables.".to_string();
-                        handled = true;
-                    }
-                }
-                Some("move_down") => {
-                    let current_profile_idx = admin_state.selected_profile_index
-                        .or_else(|| admin_state.profile_list_state.selected());
-                    if let Some(p_idx) = current_profile_idx {
-                        if let Some(profile) = app_state.profile_tree.profiles.get(p_idx) {
-                             if !profile.tables.is_empty() {
-                                list_select_next(&mut admin_state.table_list_state, profile.tables.len());
-                                *command_message = "".to_string();
-                                handled = true;
-                            } else {
-                                *command_message = "No tables to navigate.".to_string();
-                                handled = true;
-                            }
-                        }
-                    } else {
-                        *command_message = "No active profile for tables.".to_string();
-                        handled = true;
-                    }
-                }
-                Some("select") => { // This is for persistently selecting a table with [*]
-                    admin_state.selected_table_index = admin_state.table_list_state.selected();
-                    let table_name = admin_state.selected_profile_index
-                         .and_then(|p_idx| app_state.profile_tree.profiles.get(p_idx))
-                         .and_then(|p| admin_state.selected_table_index.and_then(|t_idx| p.tables.get(t_idx)))
-                         .map_or("N/A", |t| t.name.as_str());
-                    *command_message = format!("Table '{}' set as active.", table_name);
-                    handled = true;
-                }
-                Some("exit_table_scroll") => {
-                    admin_state.current_focus = AdminFocus::Tables;
-                    *command_message = "Focus: Tables Pane".to_string();
-                    handled = true;
-                }
-                _ => handled = false,
-            }
-        }
-
-        AdminFocus::Button1 => { // Add Logic Button
-            match action.as_deref() {
-                Some("select") => { // Typically "Enter" key
-                    if let Some(p_idx) = admin_state.selected_profile_index {
-                        if let Some(profile) = app_state.profile_tree.profiles.get(p_idx) {
-                            if let Some(t_idx) = admin_state.selected_table_index {
-                                if let Some(table) = profile.tables.get(t_idx) {
-                                    // Both profile and table are selected, proceed
-                                    admin_state.add_logic_state = AddLogicState {
-                                        profile_name: profile.name.clone(),
-                                        selected_table_name: Some(table.name.clone()),
-                                        selected_table_id: Some(table.id), // If you have table IDs
-                                        editor_keybinding_mode: config.editor.keybinding_mode.clone(),
-                                        current_focus: AddLogicFocus::default(),
-                                        ..AddLogicState::default()
-                                    };
-                                    
-                                    // Store table info for later fetching
-                                    app_state.pending_table_structure_fetch = Some((
-                                        profile.name.clone(),
-                                        table.name.clone()
-                                    ));
-                                    
-                                    buffer_state.update_history(AppView::AddLogic);
-                                    app_state.ui.focus_outside_canvas = false;
-                                    *command_message = format!(
-                                        "Opening Add Logic for table '{}' in profile '{}'...",
-                                        table.name, profile.name
-                                    );
-                                } else {
-                                    *command_message = "Error: Selected table data not found.".to_string();
-                                }
-                            } else {
-                                *command_message = "Select a table first!".to_string();
-                            }
-                        } else {
-                            *command_message = "Error: Selected profile data not found.".to_string();
-                        }
-                    } else {
-                        *command_message = "Select a profile first!".to_string();
-                    }
-                    handled = true;
-                }
-                Some("previous_option") | Some("move_up") => {
-                    admin_state.current_focus = AdminFocus::Tables;
-                    *command_message = "Focus: Tables Pane".to_string();
-                    handled = true;
-                }
-                Some("next_option") | Some("move_down") => {
-                    admin_state.current_focus = AdminFocus::Button2;
-                    *command_message = "Focus: Add Table Button".to_string();
-                    handled = true;
-                }
-                _ => handled = false,
-            }
-        }
-
-        AdminFocus::Button2 => { // Add Table Button
-            match action.as_deref() {
-                Some("select") => {
-                     if let Some(p_idx) = admin_state.selected_profile_index {
-                        if let Some(profile) = app_state.profile_tree.profiles.get(p_idx) {
-                            let selected_profile_name = profile.name.clone();
-                            // Prepare links from the selected profile's existing tables
-                            let available_links: Vec<LinkDefinition> = profile.tables.iter()
-                                .map(|table| LinkDefinition {
-                                    linked_table_name: table.name.clone(),
-                                    is_required: false, // Default, can be changed in AddTable screen
-                                    selected: false,
-                                }).collect();
-
-                            admin_state.add_table_state = AddTableState {
-                                profile_name: selected_profile_name,
-                                links: available_links,
-                                ..AddTableState::default() // Reset other fields
-                            };
-                            buffer_state.update_history(AppView::AddTable);
-                            app_state.ui.focus_outside_canvas = false;
-                            *command_message = format!("Opening Add Table for profile '{}'...", admin_state.add_table_state.profile_name);
-                            handled = true;
-                        } else {
-                             *command_message = "Error: Selected profile index out of bounds.".to_string();
-                             handled = true;
-                        }
-                    } else {
-                        *command_message = "Please select a profile ([*]) first to add a table.".to_string();
-                        handled = true;
-                    }
-                }
-                Some("previous_option") | Some("move_up") => {
-                    admin_state.current_focus = AdminFocus::Button1;
-                    *command_message = "Focus: Add Logic Button".to_string();
-                    handled = true;
-                }
-                Some("next_option") | Some("move_down") => {
-                    admin_state.current_focus = AdminFocus::Button3;
-                    *command_message = "Focus: Change Table Button".to_string();
-                    handled = true;
-                }
-                _ => handled = false,
-            }
-        }
-
-        AdminFocus::Button3 => { // Change Table Button
-            match action.as_deref() {
-                Some("select") => {
-                    // Future: Logic to load selected table into AddTableState for editing
-                    *command_message = "Action: Change Table (Not Implemented)".to_string();
-                    handled = true;
-                }
-                Some("previous_option") | Some("move_up") => {
-                    admin_state.current_focus = AdminFocus::Button2;
-                    *command_message = "Focus: Add Table Button".to_string();
-                    handled = true;
-                }
-                Some("next_option") | Some("move_down") => {
-                    // No wrap-around: Stay on Button3 if trying to go "after" it
-                    *command_message = "At last focusable button.".to_string();
-                    handled = true;
-                }
-                _ => handled = false,
-            }
-        }
-    }
-    handled
-}

client/src/functions/modes/read_only.rs

@@ -1,6 +0,0 @@
-// src/functions/modes/read_only.rs
-
-pub mod auth_ro;
-pub mod form_ro;
-pub mod add_table_ro;
-pub mod add_logic_ro;

client/src/functions/modes/read_only/add_logic_ro.rs

@@ -1,235 +0,0 @@
-// src/functions/modes/read_only/add_logic_ro.rs
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::pages::add_logic::AddLogicState; // Changed
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::state::AppState;
-use anyhow::Result;
-
-// Word navigation helpers (get_char_type, find_next_word_start, etc.)
-// can be kept as they are generic.
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() { CharType::Whitespace }
-    else if c.is_alphanumeric() { CharType::Alphanumeric }
-    else { CharType::Punctuation }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos >= len { return len; }
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == initial_type { pos += 1; }
-    while pos < len && get_char_type(chars[pos]) == CharType::Whitespace { pos += 1; }
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 { return 0; }
-    let mut pos = current_pos.min(len - 1);
-    if get_char_type(chars[pos]) == CharType::Whitespace {
-        pos = find_next_word_start(text, pos);
-    }
-    if pos >= len { return len.saturating_sub(1); }
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type { pos += 1; }
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 { return 0; }
-    let mut pos = current_pos.saturating_sub(1);
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace { pos -= 1; }
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace { return 0; }
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type { pos -= 1; }
-    pos
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-    let prev_start = find_prev_word_start(text, current_pos);
-    if prev_start == 0 { return 0; }
-    find_word_end(text, prev_start.saturating_sub(1))
-}
-
-
-/// Executes read-only actions for the AddLogic view canvas.
-pub async fn execute_action(
-    action: &str,
-    app_state: &mut AppState,
-    state: &mut AddLogicState,
-    ideal_cursor_column: &mut usize,
-    key_sequence_tracker: &mut KeySequenceTracker,
-    command_message: &mut String,
-) -> Result<String> {
-    match action {
-        "move_up" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddLogicState::INPUT_FIELD_COUNT;
-            if num_fields == 0 { return Ok("No fields.".to_string()); }
-            let current_field = state.current_field();
-
-            if current_field > 0 {
-                let new_field = current_field - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = if current_input.is_empty() { 0 } else { current_input.len().saturating_sub(1) };
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-            } else {
-                *command_message = "At top of form.".to_string();
-            }
-            Ok(command_message.clone())
-        }
-        "move_down" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddLogicState::INPUT_FIELD_COUNT;
-            if num_fields == 0 { return Ok("No fields.".to_string()); }
-            let current_field = state.current_field();
-            let last_field_index = num_fields - 1;
-
-            if current_field < last_field_index {
-                let new_field = current_field + 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = if current_input.is_empty() { 0 } else { current_input.len().saturating_sub(1) };
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-            } else {
-                // Move focus outside canvas when moving down from the last field
-                // FIX: Go to ScriptContentPreview instead of SaveButton
-                app_state.ui.focus_outside_canvas = true;
-                state.last_canvas_field = 2;
-                state.current_focus = crate::state::pages::add_logic::AddLogicFocus::ScriptContentPreview; // FIXED!
-                *command_message = "Focus moved to script preview".to_string();
-            }
-            Ok(command_message.clone())
-        }
-        // ... (rest of the actions remain the same) ...
-        "move_first_line" => {
-            key_sequence_tracker.reset();
-            if AddLogicState::INPUT_FIELD_COUNT > 0 {
-                state.set_current_field(0);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = if current_input.is_empty() { 0 } else { current_input.len().saturating_sub(1) };
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_last_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddLogicState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let last_field_index = num_fields - 1;
-                state.set_current_field(last_field_index);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = if current_input.is_empty() { 0 } else { current_input.len().saturating_sub(1) };
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_left" => {
-            let current_pos = state.current_cursor_pos();
-            let new_pos = current_pos.saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if !current_input.is_empty() && current_pos < current_input.len().saturating_sub(1) {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_next_word_start(current_input, state.current_cursor_pos());
-                let final_pos = new_pos.min(current_input.len().saturating_sub(1));
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-                let final_pos = if new_pos == current_pos && current_pos < current_input.len().saturating_sub(1) {
-                    find_word_end(current_input, current_pos + 1)
-                } else {
-                    new_pos
-                };
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(current_input, state.current_cursor_pos());
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(current_input, state.current_cursor_pos());
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = current_input.len().saturating_sub(1);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            } else {
-                state.set_current_cursor_pos(0);
-                *ideal_cursor_column = 0;
-            }
-            Ok("".to_string())
-        }
-        "enter_edit_mode_before" | "enter_edit_mode_after" | "enter_command_mode" | "exit_highlight_mode" => {
-             key_sequence_tracker.reset();
-             Ok("Mode change handled by main loop".to_string())
-        }
-        _ => {
-             key_sequence_tracker.reset();
-             command_message.clear();
-             Ok(format!("Unknown read-only action: {}", action))
-        },
-    }
-}
-

client/src/functions/modes/read_only/add_table_ro.rs

@@ -1,267 +0,0 @@
-// src/functions/modes/read_only/add_table_ro.rs
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::pages::add_table::AddTableState;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::state::AppState;
-use anyhow::Result;
-
-// Re-use word navigation helpers if they are public or move them to a common module
-// For now, duplicating them here for simplicity. Consider refactoring later.
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() { CharType::Whitespace }
-    else if c.is_alphanumeric() { CharType::Alphanumeric }
-    else { CharType::Punctuation }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos >= len { return len; }
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == initial_type { pos += 1; }
-    while pos < len && get_char_type(chars[pos]) == CharType::Whitespace { pos += 1; }
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 { return 0; }
-    let mut pos = current_pos.min(len - 1);
-    if get_char_type(chars[pos]) == CharType::Whitespace {
-        pos = find_next_word_start(text, pos);
-    }
-    if pos >= len { return len.saturating_sub(1); }
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type { pos += 1; }
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 { return 0; }
-    let mut pos = current_pos.saturating_sub(1);
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace { pos -= 1; }
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace { return 0; }
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type { pos -= 1; }
-    pos
-}
-
-// Note: find_prev_word_end might need adjustments based on desired behavior.
-// This version finds the end of the word *before* the previous word start.
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-    let prev_start = find_prev_word_start(text, current_pos);
-    if prev_start == 0 { return 0; }
-    // Find the end of the word that starts at prev_start - 1
-    find_word_end(text, prev_start.saturating_sub(1))
-}
-
-
-/// Executes read-only actions for the AddTable view canvas.
-pub async fn execute_action(
-    action: &str,
-    app_state: &mut AppState, // Needed for focus_outside_canvas
-    state: &mut AddTableState,
-    ideal_cursor_column: &mut usize,
-    key_sequence_tracker: &mut KeySequenceTracker,
-    command_message: &mut String, // Keep for potential messages
-) -> Result<String> {
-    // Use the CanvasState trait methods implemented for AddTableState
-    match action {
-        "move_up" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields == 0 {
-                *command_message = "No fields.".to_string();
-                return Ok(command_message.clone());
-            }
-            let current_field = state.current_field(); // Gets the index (0, 1, or 2)
-
-            if current_field > 0 {
-                // This handles moving from field 2 -> 1, or 1 -> 0
-                let new_field = current_field - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = current_input.len(); // Allow cursor at end
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos; // Update ideal column as cursor moved
-                *command_message = "".to_string(); // Clear message for successful internal navigation
-            } else {
-                // current_field is 0 (InputTableName), and user pressed Up.
-                // Forbid moving up. Do not change focus or cursor.
-                *command_message = "At top of form.".to_string();
-            }
-            Ok(command_message.clone())
-        }
-        "move_down" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields == 0 {
-                *command_message = "No fields.".to_string();
-                return Ok(command_message.clone());
-            }
-            let current_field = state.current_field();
-            let last_field_index = num_fields - 1;
-
-            if current_field < last_field_index {
-                let new_field = current_field + 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = current_input.len(); // Allow cursor at end
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos; // Update ideal column
-                *command_message = "".to_string();
-            } else {
-                // Move focus outside canvas when moving down from the last field
-                app_state.ui.focus_outside_canvas = true;
-                // Set focus to the first element outside canvas (AddColumnButton)
-                state.current_focus =
-                    crate::state::pages::add_table::AddTableFocus::AddColumnButton;
-                *command_message = "Focus moved below canvas".to_string();
-            }
-            Ok(command_message.clone())
-        }
-        // ... (other actions like "move_first_line", "move_left", etc. remain the same) ...
-        "move_first_line" => {
-            key_sequence_tracker.reset();
-            if AddTableState::INPUT_FIELD_COUNT > 0 {
-                state.set_current_field(0);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = current_input.len();
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos; // Update ideal column
-            }
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_last_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let last_field_index = num_fields - 1;
-                state.set_current_field(last_field_index);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = current_input.len();
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos; // Update ideal column
-            }
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_left" => {
-            let current_pos = state.current_cursor_pos();
-            let new_pos = current_pos.saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            // Allow moving cursor one position past the end
-            if current_pos < current_input.len() {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            let new_pos = find_next_word_start(
-                current_input,
-                state.current_cursor_pos(),
-            );
-            let final_pos = new_pos.min(current_input.len()); // Allow cursor at end
-            state.set_current_cursor_pos(final_pos);
-            *ideal_cursor_column = final_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            let new_pos = find_word_end(current_input, current_pos);
-            // If find_word_end returns current_pos, try starting search from next char
-            let final_pos =
-                if new_pos == current_pos && current_pos < current_input.len() {
-                    find_word_end(current_input, current_pos + 1)
-                } else {
-                    new_pos
-                };
-            let max_valid_index = current_input.len(); // Allow cursor at end
-            let clamped_pos = final_pos.min(max_valid_index);
-            state.set_current_cursor_pos(clamped_pos);
-            *ideal_cursor_column = clamped_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            let new_pos = find_prev_word_start(
-                current_input,
-                state.current_cursor_pos(),
-            );
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            let new_pos = find_prev_word_end(
-                current_input,
-                state.current_cursor_pos(),
-            );
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            let new_pos = current_input.len(); // Allow cursor at end
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        // Actions handled by main event loop (mode changes)
-        "enter_edit_mode_before" | "enter_edit_mode_after"
-        | "enter_command_mode" | "exit_highlight_mode" => {
-            key_sequence_tracker.reset();
-            // These actions are primarily mode changes handled by the main event loop.
-            // The message here might be overridden by the main loop's message for mode change.
-            *command_message = "Mode change initiated".to_string();
-            Ok(command_message.clone())
-        }
-        _ => {
-            key_sequence_tracker.reset();
-            *command_message =
-                format!("Unknown read-only action: {}", action);
-            Ok(command_message.clone())
-        }
-    }
-}
-

client/src/functions/modes/read_only/auth_ro.rs

@@ -1,343 +0,0 @@
-// src/functions/modes/read_only/auth_ro.rs
-
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::state::AppState;
-use anyhow::Result;
-
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-pub async fn execute_action<S: CanvasState>(
-    action: &str,
-    app_state: &mut AppState,
-    state: &mut S,
-    ideal_cursor_column: &mut usize,
-    key_sequence_tracker: &mut KeySequenceTracker,
-    command_message: &mut String,
-) -> Result<String> {
-    match action {
-        "previous_entry" | "next_entry" => {
-            key_sequence_tracker.reset();
-            Ok(format!(
-                "Action '{}' should be handled by context-specific logic",
-                action
-            ))
-        }
-        "move_up" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate.".to_string());
-            }
-            let current_field = state.current_field();
-            let new_field = current_field.saturating_sub(1);
-            state.set_current_field(new_field);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-
-            Ok("move up from functions/modes/read_only/auth_ro.rs".to_string())
-        }
-        "move_down" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate.".to_string());
-            }
-            let current_field = state.current_field();
-            let last_field_index = num_fields - 1;
-
-            if current_field == last_field_index {
-                // Already on the last field, move focus outside
-                app_state.ui.focus_outside_canvas = true;
-                app_state.focused_button_index= 0;
-                key_sequence_tracker.reset();
-                Ok("Focus moved below canvas".to_string())
-            } else {
-                // Move to the next field within the canvas
-                let new_field = (current_field + 1).min(last_field_index);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = if current_input.is_empty() {
-                    0
-                } else {
-                    current_input.len().saturating_sub(1)
-                };
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                Ok("".to_string()) // Clear previous debug message
-            }
-        }
-        "move_first_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate to.".to_string());
-            }
-            state.set_current_field(0);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_last_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate to.".to_string());
-            }
-            let last_field_index = num_fields - 1;
-            state.set_current_field(last_field_index);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "exit_edit_mode" => {
-            key_sequence_tracker.reset();
-            command_message.clear();
-            Ok("".to_string())
-        }
-        "move_left" => {
-            let current_pos = state.current_cursor_pos();
-            let new_pos = current_pos.saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if !current_input.is_empty()
-                && current_pos < current_input.len().saturating_sub(1)
-            {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos =
-                    find_next_word_start(current_input, state.current_cursor_pos());
-                let final_pos = new_pos.min(current_input.len().saturating_sub(1));
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-
-                let final_pos = if new_pos != current_pos {
-                    new_pos
-                } else {
-                    find_word_end(current_input, new_pos + 1)
-                };
-
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("Moved to previous word end".to_string())
-        }
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = current_input.len().saturating_sub(1);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            } else {
-                state.set_current_cursor_pos(0);
-                *ideal_cursor_column = 0;
-            }
-            Ok("".to_string())
-        }
-        _ => {
-             key_sequence_tracker.reset();
-             Ok(format!("Unknown read-only action: {}", action))
-        },
-    }
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() {
-        CharType::Whitespace
-    } else if c.is_alphanumeric() {
-        CharType::Alphanumeric
-    } else {
-        CharType::Punctuation
-    }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() {
-        return 0;
-    }
-    let current_pos = current_pos.min(chars.len());
-
-    if current_pos == chars.len() {
-        return current_pos;
-    }
-
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-
-    while pos < chars.len() && get_char_type(chars[pos]) == initial_type {
-        pos += 1;
-    }
-
-    while pos < chars.len() && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos += 1;
-    }
-
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.min(len - 1);
-    let current_type = get_char_type(chars[pos]);
-    if current_type != CharType::Whitespace {
-        while pos < len && get_char_type(chars[pos]) == current_type {
-            pos += 1;
-        }
-        return pos.saturating_sub(1);
-    }
-
-    pos = find_next_word_start(text, pos);
-    if pos >= len {
-        return len.saturating_sub(1);
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type {
-        pos += 1;
-    }
-
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if get_char_type(chars[pos]) != CharType::Whitespace {
-        let word_type = get_char_type(chars[pos]);
-        while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-            pos -= 1;
-        }
-    }
-
-    if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
-         0
-    } else {
-        pos
-    }
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-     let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
-        return 0;
-    }
-     if pos == 0 && get_char_type(chars[0]) != CharType::Whitespace {
-         return 0;
-     }
-
-    let word_type = get_char_type(chars[pos]);
-     while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos > 0 {
-        pos - 1
-    } else {
-        0
-    }
-}

client/src/functions/modes/read_only/form_ro.rs

@@ -1,329 +0,0 @@
-// src/functions/modes/read_only/form_ro.rs
-
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::pages::canvas_state::CanvasState;
-use anyhow::Result;
-
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-pub async fn execute_action<S: CanvasState>(
-    action: &str,
-    state: &mut S,
-    ideal_cursor_column: &mut usize,
-    key_sequence_tracker: &mut KeySequenceTracker,
-    command_message: &mut String,
-) -> Result<String> {
-    match action {
-        "previous_entry" | "next_entry" => {
-            key_sequence_tracker.reset();
-            Ok(format!(
-                "Action '{}' should be handled by context-specific logic",
-                action
-            ))
-        }
-        "move_up" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate.".to_string());
-            }
-            let current_field = state.current_field();
-            let new_field = current_field.saturating_sub(1);
-            state.set_current_field(new_field);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            Ok("".to_string())
-        }
-        "move_down" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate.".to_string());
-            }
-            let current_field = state.current_field();
-            let new_field = (current_field + 1).min(num_fields - 1);
-            state.set_current_field(new_field);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            Ok("".to_string())
-        }
-        "move_first_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate to.".to_string());
-            }
-            state.set_current_field(0);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_last_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate to.".to_string());
-            }
-            let last_field_index = num_fields - 1;
-            state.set_current_field(last_field_index);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "exit_edit_mode" => {
-            key_sequence_tracker.reset();
-            command_message.clear();
-            Ok("".to_string())
-        }
-        "move_left" => {
-            let current_pos = state.current_cursor_pos();
-            let new_pos = current_pos.saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if !current_input.is_empty()
-                && current_pos < current_input.len().saturating_sub(1)
-            {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos =
-                    find_next_word_start(current_input, state.current_cursor_pos());
-                let final_pos = new_pos.min(current_input.len().saturating_sub(1));
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-
-                let final_pos = if new_pos != current_pos {
-                    new_pos
-                } else {
-                    find_word_end(current_input, new_pos + 1)
-                };
-
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("Moved to previous word end".to_string())
-        }
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = current_input.len().saturating_sub(1);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            } else {
-                state.set_current_cursor_pos(0);
-                *ideal_cursor_column = 0;
-            }
-            Ok("".to_string())
-        }
-        _ => {
-             key_sequence_tracker.reset();
-             Ok(format!("Unknown read-only action: {}", action))
-        },
-    }
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() {
-        CharType::Whitespace
-    } else if c.is_alphanumeric() {
-        CharType::Alphanumeric
-    } else {
-        CharType::Punctuation
-    }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() {
-        return 0;
-    }
-    let current_pos = current_pos.min(chars.len());
-
-    if current_pos == chars.len() {
-        return current_pos;
-    }
-
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-
-    while pos < chars.len() && get_char_type(chars[pos]) == initial_type {
-        pos += 1;
-    }
-
-    while pos < chars.len() && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos += 1;
-    }
-
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.min(len - 1);
-    let current_type = get_char_type(chars[pos]);
-    if current_type != CharType::Whitespace {
-        while pos < len && get_char_type(chars[pos]) == current_type {
-            pos += 1;
-        }
-        return pos.saturating_sub(1);
-    }
-
-    pos = find_next_word_start(text, pos);
-    if pos >= len {
-        return len.saturating_sub(1);
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type {
-        pos += 1;
-    }
-
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if get_char_type(chars[pos]) != CharType::Whitespace {
-        let word_type = get_char_type(chars[pos]);
-        while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-            pos -= 1;
-        }
-    }
-
-    if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
-         0
-    } else {
-        pos
-    }
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-     let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
-        return 0;
-    }
-     if pos == 0 && get_char_type(chars[0]) != CharType::Whitespace {
-         return 0;
-     }
-
-    let word_type = get_char_type(chars[pos]);
-     while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos > 0 {
-        pos - 1
-    } else {
-        0
-    }
-}

client/src/lib.rs

@@ -1,12 +0,0 @@
-// client/src/lib.rs
-pub mod ui;
-pub mod tui;
-pub mod config;
-pub mod state;
-pub mod components;
-pub mod modes;
-pub mod functions;
-pub mod services;
-
-pub use ui::run_ui;
-

client/src/main.rs

@@ -1,16 +0,0 @@
-// client/src/main.rs
-use client::run_ui;
-use dotenvy::dotenv;
-use anyhow::Result;
-use tracing_subscriber;
-use std::env;
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    if env::var("ENABLE_TRACING").is_ok() {
-        tracing_subscriber::fmt::init();
-    }
-
-    dotenv().ok();
-    run_ui().await
-}

client/src/modes/canvas.rs

@@ -1,4 +0,0 @@
-// src/client/modes/canvas.rs
-pub mod edit;
-pub mod common_mode;
-pub mod read_only;

client/src/modes/canvas/common_mode.rs

@@ -1,84 +0,0 @@
-// src/modes/canvas/common_mode.rs
-
-use crate::tui::terminal::core::TerminalCore;
-use crate::state::pages::{form::FormState, auth::LoginState, auth::RegisterState, auth::AuthState};
-use crate::state::app::state::AppState;
-use crate::services::grpc_client::GrpcClient;
-use crate::services::auth::AuthClient;
-use crate::modes::handlers::event::EventOutcome;
-use crate::tui::functions::common::form::SaveOutcome;
-use anyhow::{Context, Result};
-use crate::tui::functions::common::{
-    form::{save as form_save, revert as form_revert},
-    login::{save as login_save, revert as login_revert},
-    register::{revert as register_revert},
-};
-
-pub async fn handle_core_action(
-    action: &str,
-    form_state: &mut FormState,
-    auth_state: &mut AuthState,
-    login_state: &mut LoginState,
-    register_state: &mut RegisterState,
-    grpc_client: &mut GrpcClient,
-    auth_client: &mut AuthClient,
-    terminal: &mut TerminalCore,
-    app_state: &mut AppState,
-) -> Result<EventOutcome> {
-    match action {
-        "save" => {
-            if app_state.ui.show_login {
-                let message = login_save(auth_state, login_state, auth_client, app_state).await.context("Login save action failed")?;
-                Ok(EventOutcome::Ok(message))
-            } else {
-                let save_outcome = form_save(
-                    form_state,
-                    grpc_client,
-                ).await.context("Register save action failed")?;
-                let message = match save_outcome {
-                    SaveOutcome::NoChange => "No changes to save.".to_string(),
-                    SaveOutcome::UpdatedExisting => "Entry updated.".to_string(),
-                    SaveOutcome::CreatedNew(_) => "New entry created.".to_string(),
-                };
-                Ok(EventOutcome::DataSaved(save_outcome, message))
-            }
-        },
-        "force_quit" => {
-            terminal.cleanup()?;
-            Ok(EventOutcome::Exit("Force exiting without saving.".to_string()))
-        },
-        "save_and_quit" => {
-            let message = if app_state.ui.show_login {
-                login_save(auth_state, login_state, auth_client, app_state).await.context("Login save n quit action failed")?
-            } else {
-                let save_outcome = form_save(
-                    form_state,
-                    grpc_client,
-                ).await?;
-                match save_outcome {
-                    SaveOutcome::NoChange => "No changes to save.".to_string(),
-                    SaveOutcome::UpdatedExisting => "Entry updated.".to_string(),
-                    SaveOutcome::CreatedNew(_) => "New entry created.".to_string(),
-                }
-            };
-            terminal.cleanup()?;
-            Ok(EventOutcome::Exit(format!("{}. Exiting application.", message)))
-        },
-        "revert" => {
-            if app_state.ui.show_login {
-                let message = login_revert(login_state, app_state).await;
-                Ok(EventOutcome::Ok(message))
-            } else if app_state.ui.show_register {
-                let message = register_revert(register_state, app_state).await;
-                Ok(EventOutcome::Ok(message))
-            } else {
-                let message = form_revert(
-                    form_state,
-                    grpc_client,
-                ).await.context("Form revert x action failed")?;
-                Ok(EventOutcome::Ok(message))
-            }
-        },
-        _ => Ok(EventOutcome::Ok(format!("Core action not handled: {}", action))),
-    }
-}

client/src/modes/canvas/edit.rs

@@ -1,252 +0,0 @@
-// src/modes/canvas/edit.rs
-use crate::config::binds::config::Config;
-use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::{
-    auth::{LoginState, RegisterState},
-    canvas_state::CanvasState,
-};
-use crate::state::pages::form::FormState; // <<< ADD THIS LINE
-// AddLogicState is already imported
-// AddTableState is already imported
-use crate::state::pages::admin::AdminState;
-use crate::modes::handlers::event::EventOutcome;
-use crate::functions::modes::edit::{add_logic_e, auth_e, form_e, add_table_e};
-use crate::state::app::state::AppState;
-use anyhow::Result;
-use crossterm::event::KeyEvent; // Removed KeyCode, KeyModifiers as they were unused
-use tracing::debug;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum EditEventOutcome {
-    Message(String),
-    ExitEditMode,
-}
-
-pub async fn handle_edit_event(
-    key: KeyEvent,
-    config: &Config,
-    form_state: &mut FormState, // Now FormState is in scope
-    login_state: &mut LoginState,
-    register_state: &mut RegisterState,
-    admin_state: &mut AdminState,
-    ideal_cursor_column: &mut usize,
-    current_position: &mut u64,
-    total_count: u64,
-    grpc_client: &mut GrpcClient,
-    app_state: &AppState,
-) -> Result<EditEventOutcome> {
-    // --- Global command mode check ---
-    if let Some("enter_command_mode") = config.get_action_for_key_in_mode(
-        &config.keybindings.global, // Assuming command mode can be entered globally
-        key.code,
-        key.modifiers,
-    ) {
-        // This check might be redundant if EventHandler already prevents entering Edit mode
-        // when command_mode is true. However, it's a safeguard.
-        return Ok(EditEventOutcome::Message(
-            "Cannot enter command mode from edit mode here.".to_string(),
-        ));
-    }
-
-    // --- Common actions (save, revert) ---
-    if let Some(action) = config.get_action_for_key_in_mode(
-        &config.keybindings.common,
-        key.code,
-        key.modifiers,
-    ).as_deref() {
-        if matches!(action, "save" | "revert") {
-            let message_string: String = if app_state.ui.show_login {
-                auth_e::execute_common_action(action, login_state, grpc_client, current_position, total_count).await?
-            } else if app_state.ui.show_register {
-                auth_e::execute_common_action(action, register_state, grpc_client, current_position, total_count).await?
-            } else if app_state.ui.show_add_table {
-                // TODO: Implement common actions for AddTable if needed
-                format!("Action '{}' not implemented for Add Table in edit mode.", action)
-            } else if app_state.ui.show_add_logic {
-                // TODO: Implement common actions for AddLogic if needed
-                format!("Action '{}' not implemented for Add Logic in edit mode.", action)
-            } else { // Assuming Form view
-                let outcome = form_e::execute_common_action(action, form_state, grpc_client).await?;
-                match outcome {
-                    EventOutcome::Ok(msg) | EventOutcome::DataSaved(_, msg) => msg,
-                    _ => format!("Unexpected outcome from common action: {:?}", outcome),
-                }
-            };
-            return Ok(EditEventOutcome::Message(message_string));
-        }
-    }
-
-    // --- Edit-specific actions ---
-    if let Some(action_str) = config.get_edit_action_for_key(key.code, key.modifiers).as_deref() {
-        // --- Handle "enter_decider" (Enter key) ---
-        if action_str == "enter_decider" {
-            let effective_action = if app_state.ui.show_register
-                && register_state.in_suggestion_mode
-                && register_state.current_field() == 4 { // Role field
-                "select_suggestion"
-            } else if app_state.ui.show_add_logic
-                && admin_state.add_logic_state.in_target_column_suggestion_mode
-                && admin_state.add_logic_state.current_field() == 1 { // Target Column field
-                "select_suggestion"
-            } else {
-                "next_field" // Default action for Enter
-            };
-
-            let msg = if app_state.ui.show_login {
-                auth_e::execute_edit_action(effective_action, key, login_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_add_table {
-                add_table_e::execute_edit_action(effective_action, key, &mut admin_state.add_table_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_add_logic {
-                add_logic_e::execute_edit_action(effective_action, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_register {
-                auth_e::execute_edit_action(effective_action, key, register_state, ideal_cursor_column).await?
-            } else { // Form view
-                form_e::execute_edit_action(effective_action, key, form_state, ideal_cursor_column).await?
-            };
-            return Ok(EditEventOutcome::Message(msg));
-        }
-
-        // --- Handle "exit" (Escape key) ---
-        if action_str == "exit" {
-            if app_state.ui.show_register && register_state.in_suggestion_mode {
-                let msg = auth_e::execute_edit_action("exit_suggestion_mode", key, register_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            } else if app_state.ui.show_add_logic && admin_state.add_logic_state.in_target_column_suggestion_mode {
-                admin_state.add_logic_state.in_target_column_suggestion_mode = false;
-                admin_state.add_logic_state.show_target_column_suggestions = false;
-                admin_state.add_logic_state.selected_target_column_suggestion_index = None;
-                return Ok(EditEventOutcome::Message("Exited column suggestions".to_string()));
-            } else {
-                return Ok(EditEventOutcome::ExitEditMode);
-            }
-        }
-
-        // --- Autocomplete for AddLogicState Target Column ---
-        if app_state.ui.show_add_logic && admin_state.add_logic_state.current_field() == 1 { // Target Column field
-            if action_str == "suggestion_down" { // "Tab" is mapped to suggestion_down
-                if !admin_state.add_logic_state.in_target_column_suggestion_mode {
-                    // Attempt to open suggestions
-                    if let Some(profile_name) = admin_state.add_logic_state.profile_name.clone().into() {
-                        if let Some(table_name) = admin_state.add_logic_state.selected_table_name.clone() {
-                            debug!("Fetching table structure for autocomplete: Profile='{}', Table='{}'", profile_name, table_name);
-                            match grpc_client.get_table_structure(profile_name, table_name).await {
-                                Ok(ts_response) => {
-                                    admin_state.add_logic_state.table_columns_for_suggestions =
-                                        ts_response.columns.into_iter().map(|c| c.name).collect();
-                                    admin_state.add_logic_state.update_target_column_suggestions();
-                                    if !admin_state.add_logic_state.target_column_suggestions.is_empty() {
-                                        admin_state.add_logic_state.in_target_column_suggestion_mode = true;
-                                        // update_target_column_suggestions handles initial selection
-                                        return Ok(EditEventOutcome::Message("Column suggestions shown".to_string()));
-                                    } else {
-                                        return Ok(EditEventOutcome::Message("No column suggestions for current input".to_string()));
-                                    }
-                                }
-                                Err(e) => {
-                                    debug!("Error fetching table structure: {}", e);
-                                    admin_state.add_logic_state.table_columns_for_suggestions.clear(); // Clear old data on error
-                                    admin_state.add_logic_state.update_target_column_suggestions();
-                                    return Ok(EditEventOutcome::Message(format!("Error fetching columns: {}", e)));
-                                }
-                            }
-                        } else {
-                             return Ok(EditEventOutcome::Message("No table selected for column suggestions".to_string()));
-                        }
-                    } else { // Should not happen if AddLogic is properly initialized
-                        return Ok(EditEventOutcome::Message("Profile name missing for column suggestions".to_string()));
-                    }
-                } else { // Already in suggestion mode, navigate down
-                    let msg = add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?;
-                    return Ok(EditEventOutcome::Message(msg));
-                }
-            } else if admin_state.add_logic_state.in_target_column_suggestion_mode && action_str == "suggestion_up" {
-                 let msg = add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            }
-        }
-
-        // --- Autocomplete for RegisterState Role Field ---
-        if app_state.ui.show_register && register_state.current_field() == 4 { // Role field
-            if !register_state.in_suggestion_mode && action_str == "suggestion_down" { // Tab
-                register_state.update_role_suggestions();
-                if !register_state.role_suggestions.is_empty() {
-                    register_state.in_suggestion_mode = true;
-                    // update_role_suggestions should handle initial selection
-                    return Ok(EditEventOutcome::Message("Role suggestions shown".to_string()));
-                } else {
-                    // If Tab doesn't open suggestions, it might fall through to "next_field"
-                    // or you might want specific behavior. For now, let it fall through.
-                }
-            }
-            if register_state.in_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up") {
-                let msg = auth_e::execute_edit_action(action_str, key, register_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            }
-        }
-
-        // --- Dispatch other edit actions ---
-        let msg = if app_state.ui.show_login {
-            auth_e::execute_edit_action(action_str, key, login_state, ideal_cursor_column).await?
-        } else if app_state.ui.show_add_table {
-            add_table_e::execute_edit_action(action_str, key, &mut admin_state.add_table_state, ideal_cursor_column).await?
-        } else if app_state.ui.show_add_logic {
-            // If not a suggestion action handled above for AddLogic
-             if !(admin_state.add_logic_state.in_target_column_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up")) {
-                add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
-            } else { String::new() /* Already handled */ }
-        } else if app_state.ui.show_register {
-            if !(register_state.in_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up")) {
-                auth_e::execute_edit_action(action_str, key, register_state, ideal_cursor_column).await?
-            } else { String::new() /* Already handled */ }
-        } else { // Form view
-            form_e::execute_edit_action(action_str, key, form_state, ideal_cursor_column).await?
-        };
-        return Ok(EditEventOutcome::Message(msg));
-    }
-
-    // --- Character insertion ---
-    // If character insertion happens while in suggestion mode, exit suggestion mode first.
-    let mut exited_suggestion_mode_for_typing = false;
-    if app_state.ui.show_register && register_state.in_suggestion_mode {
-        register_state.in_suggestion_mode = false;
-        register_state.show_role_suggestions = false;
-        register_state.selected_suggestion_index = None;
-        exited_suggestion_mode_for_typing = true;
-    }
-    if app_state.ui.show_add_logic && admin_state.add_logic_state.in_target_column_suggestion_mode {
-        admin_state.add_logic_state.in_target_column_suggestion_mode = false;
-        admin_state.add_logic_state.show_target_column_suggestions = false;
-        admin_state.add_logic_state.selected_target_column_suggestion_index = None;
-        exited_suggestion_mode_for_typing = true;
-    }
-
-    let mut char_insert_msg = if app_state.ui.show_login {
-        auth_e::execute_edit_action("insert_char", key, login_state, ideal_cursor_column).await?
-    } else if app_state.ui.show_add_table {
-        add_table_e::execute_edit_action("insert_char", key, &mut admin_state.add_table_state, ideal_cursor_column).await?
-    } else if app_state.ui.show_add_logic {
-        add_logic_e::execute_edit_action("insert_char", key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
-    } else if app_state.ui.show_register {
-        auth_e::execute_edit_action("insert_char", key, register_state, ideal_cursor_column).await?
-    } else { // Form view
-        form_e::execute_edit_action("insert_char", key, form_state, ideal_cursor_column).await?
-    };
-
-    // After character insertion, update suggestions if applicable
-    if app_state.ui.show_register && register_state.current_field() == 4 {
-        register_state.update_role_suggestions();
-        // If we just exited suggestion mode by typing, don't immediately show them again unless Tab is pressed.
-        // However, update_role_suggestions will set show_role_suggestions if matches are found.
-        // This is fine, as the render logic checks in_suggestion_mode.
-    }
-    if app_state.ui.show_add_logic && admin_state.add_logic_state.current_field() == 1 {
-        admin_state.add_logic_state.update_target_column_suggestions();
-    }
-
-    if exited_suggestion_mode_for_typing && char_insert_msg.is_empty() {
-        char_insert_msg = "Suggestions hidden".to_string();
-    }
-
-
-    Ok(EditEventOutcome::Message(char_insert_msg))
-}

client/src/modes/canvas/read_only.rs

@@ -1,287 +0,0 @@
-// src/modes/canvas/read_only.rs
-
-use crate::config::binds::config::Config;
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::{canvas_state::CanvasState, auth::RegisterState};
-use crate::state::pages::auth::LoginState;
-use crate::state::pages::form::FormState;
-use crate::state::pages::add_logic::AddLogicState;
-use crate::state::pages::add_table::AddTableState;
-use crate::state::app::state::AppState;
-use crate::functions::modes::read_only::{add_logic_ro, auth_ro, form_ro, add_table_ro};
-use crossterm::event::KeyEvent;
-use anyhow::Result;
-
-pub async fn handle_read_only_event(
-    app_state: &mut AppState,
-    key: KeyEvent,
-    config: &Config,
-    form_state: &mut FormState,
-    login_state: &mut LoginState,
-    register_state: &mut RegisterState,
-    add_table_state: &mut AddTableState,
-    add_logic_state: &mut AddLogicState,
-    key_sequence_tracker: &mut KeySequenceTracker,
-    current_position: &mut u64,
-    total_count: u64,
-    grpc_client: &mut GrpcClient,
-    command_message: &mut String,
-    edit_mode_cooldown: &mut bool,
-    ideal_cursor_column: &mut usize,
-) -> Result<(bool, String)> {
-    if config.is_enter_edit_mode_before(key.code, key.modifiers) {
-        *edit_mode_cooldown = true;
-        *command_message = "Entering Edit mode".to_string();
-        return Ok((false, command_message.clone()));
-    }
-
-    if config.is_enter_edit_mode_after(key.code, key.modifiers) {
-        // Determine target state to adjust cursor
-        let target_state: &mut dyn CanvasState = if app_state.ui.show_login { login_state }
-            else if app_state.ui.show_add_logic { add_logic_state }
-            else if app_state.ui.show_register { register_state }
-            else if app_state.ui.show_add_table { add_table_state }
-            else { form_state };
-        let current_input = target_state.get_current_input();
-        let current_pos = target_state.current_cursor_pos();
-
-        if !current_input.is_empty() && current_pos < current_input.len() {
-            target_state.set_current_cursor_pos(current_pos + 1);
-            *ideal_cursor_column = target_state.current_cursor_pos();
-        }
-        *edit_mode_cooldown = true;
-        *command_message = "Entering Edit mode (after cursor)".to_string();
-        return Ok((false, command_message.clone()));
-    }
-
-    const CONTEXT_ACTIONS_FORM: &[&str] = &[
-        "previous_entry",
-        "next_entry",
-    ];
-    const CONTEXT_ACTIONS_LOGIN: &[&str] = &[
-        "previous_entry",
-        "next_entry",
-    ];
-
-    if key.modifiers.is_empty() {
-        key_sequence_tracker.add_key(key.code);
-        let sequence = key_sequence_tracker.get_sequence();
-
-        if let Some(action) = config.matches_key_sequence_generalized(&sequence).as_deref() {
-            let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
-                crate::tui::functions::form::handle_action(
-                    action,
-                    form_state,
-                    grpc_client,
-                    current_position,
-                    total_count,
-                    ideal_cursor_column,
-                )
-                .await?
-            } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) { // Handle login context actions
-                crate::tui::functions::login::handle_action(action).await?
-            } else if app_state.ui.show_add_table {
-                add_table_ro::execute_action(
-                    action,
-                    app_state,
-                    add_table_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_add_logic {
-                add_logic_ro::execute_action(
-                    action,
-                    app_state,
-                    add_logic_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_register{
-                auth_ro::execute_action(
-                    action,
-                    app_state,
-                    register_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_login {
-                auth_ro::execute_action(
-                    action,
-                    app_state,
-                    login_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                )
-                .await?
-            } else {
-                form_ro::execute_action(
-                    action,
-                    form_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                )
-                .await?
-            };
-            key_sequence_tracker.reset();
-            return Ok((false, result));
-        }
-
-        if config.is_key_sequence_prefix(&sequence) {
-            return Ok((false, command_message.clone()));
-        }
-
-        if sequence.len() == 1 && !config.is_key_sequence_prefix(&sequence) {
-            if let Some(action) = config.get_read_only_action_for_key(key.code, key.modifiers).as_deref() {
-                let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
-                    crate::tui::functions::form::handle_action(
-                        action,
-                        form_state,
-                        grpc_client,
-                        current_position,
-                        total_count,
-                        ideal_cursor_column,
-                    )
-                    .await?
-                } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) { // Handle login context actions
-                    crate::tui::functions::login::handle_action(action).await?
-                } else if app_state.ui.show_add_table {
-                    add_table_ro::execute_action(
-                        action,
-                        app_state,
-                        add_table_state,
-                        ideal_cursor_column,
-                        key_sequence_tracker,
-                        command_message,
-                    ).await?
-                } else if app_state.ui.show_add_logic {
-                    add_logic_ro::execute_action(
-                        action,
-                        app_state,
-                        add_logic_state,
-                        ideal_cursor_column,
-                        key_sequence_tracker,
-                        command_message,
-                    ).await?
-                } else if app_state.ui.show_register {
-                    auth_ro::execute_action(
-                        action,
-                        app_state,
-                        register_state,
-                        ideal_cursor_column,
-                        key_sequence_tracker,
-                        command_message,
-                    ).await?
-                } else if app_state.ui.show_login { // Handle login general actions
-                    auth_ro::execute_action(
-                        action,
-                        app_state,
-                        login_state,
-                        ideal_cursor_column,
-                        key_sequence_tracker,
-                        command_message,
-                    )
-                    .await?
-                } else {
-                    form_ro::execute_action(
-                        action,
-                        form_state,
-                        ideal_cursor_column,
-                        key_sequence_tracker,
-                        command_message,
-                    )
-                    .await?
-                };
-                key_sequence_tracker.reset();
-                return Ok((false, result));
-            }
-        }
-        key_sequence_tracker.reset();
-    } else {
-        key_sequence_tracker.reset();
-
-        if let Some(action) = config.get_read_only_action_for_key(key.code, key.modifiers).as_deref() {
-            let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
-                crate::tui::functions::form::handle_action(
-                    action,
-                    form_state,
-                    grpc_client,
-                    current_position,
-                    total_count,
-                    ideal_cursor_column,
-                )
-                .await?
-            } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
-                crate::tui::functions::login::handle_action(action).await?
-            } else if app_state.ui.show_add_table {
-                add_table_ro::execute_action(
-                    action,
-                    app_state,
-                    add_table_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_add_logic {
-                add_logic_ro::execute_action(
-                    action,
-                    app_state,
-                    add_logic_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_register {
-                auth_ro::execute_action(
-                    action,
-                    app_state,
-                    register_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_login { // Handle login general actions
-                auth_ro::execute_action(
-                    action,
-                    app_state,
-                    login_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                )
-                .await?
-            } else {
-                form_ro::execute_action(
-                    action,
-                    form_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                )
-                .await?
-            };
-            return Ok((false, result));
-        }
-    }
-
-    if !*edit_mode_cooldown {
-        let default_key = "i".to_string();
-        let edit_key = config
-            .keybindings
-            .read_only
-            .get("enter_edit_mode_before")
-            .and_then(|keys| keys.first())
-            .map(|k| k.to_string())
-            .unwrap_or(default_key);
-        *command_message = format!("Read-only mode - press {} to edit", edit_key);
-    }
-
-    *edit_mode_cooldown = false;
-
-    Ok((false, command_message.clone()))
-}

client/src/modes/common.rs

@@ -1,6 +0,0 @@
-// src/client/modes/common.rs
-pub mod command_mode;
-pub mod highlight;
-pub mod commands;
-
-pub use commands::*;

client/src/modes/common/command_mode.rs

@@ -1,145 +0,0 @@
-// src/modes/common/command_mode.rs
-
-use crossterm::event::{KeyEvent, KeyCode, KeyModifiers};
-use crate::config::binds::config::Config;
-use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::form::FormState;
-use crate::state::{app::state::AppState, pages::auth::LoginState, pages::auth::RegisterState};
-use crate::modes::common::commands::CommandHandler;
-use crate::tui::terminal::core::TerminalCore;
-use crate::tui::functions::common::form::{save, revert};
-use crate::modes::handlers::event::EventOutcome;
-use crate::tui::functions::common::form::SaveOutcome;
-use anyhow::Result;
-
-pub async fn handle_command_event(
-    key: KeyEvent,
-    config: &Config,
-    app_state: &AppState,
-    login_state: &LoginState,
-    register_state: &RegisterState,
-    form_state: &mut FormState,
-    command_input: &mut String,
-    command_message: &mut String,
-    grpc_client: &mut GrpcClient,
-    command_handler: &mut CommandHandler,
-    terminal: &mut TerminalCore,
-    current_position: &mut u64,
-    total_count: u64,
-) -> Result<EventOutcome> {
-    // Exit command mode (via configurable keybinding)
-    if config.is_exit_command_mode(key.code, key.modifiers) {
-        command_input.clear();
-        *command_message = "".to_string();
-        return Ok(EventOutcome::Ok("Exited command mode".to_string()));
-    }
-
-    // Execute command (via configurable keybinding, defaults to Enter)
-    if config.is_command_execute(key.code, key.modifiers) {
-        return process_command(
-            config,
-            form_state,
-            app_state,
-            login_state,
-            register_state,
-            command_input,
-            command_message,
-            grpc_client,
-            command_handler,
-            terminal,
-            current_position,
-            total_count,
-        ).await;
-    }
-
-    // Backspace (via configurable keybinding, defaults to Backspace)
-    if config.is_command_backspace(key.code, key.modifiers) {
-        command_input.pop();
-        return Ok(EventOutcome::Ok("".to_string()));
-    }
-
-    // Regular character input - accept any character in command mode
-    if let KeyCode::Char(c) = key.code {
-        // Accept regular or shifted characters (e.g., 'a' or 'A')
-        if key.modifiers.is_empty() || key.modifiers == KeyModifiers::SHIFT {
-            command_input.push(c);
-            return Ok(EventOutcome::Ok("".to_string()));
-        }
-    }
-
-    // Ignore all other keys
-    Ok(EventOutcome::Ok("".to_string()))
-}
-
-async fn process_command(
-    config: &Config,
-    form_state: &mut FormState,
-    app_state: &AppState,
-    login_state: &LoginState,
-    register_state: &RegisterState,
-    command_input: &mut String,
-    command_message: &mut String,
-    grpc_client: &mut GrpcClient,
-    command_handler: &mut CommandHandler,
-    terminal: &mut TerminalCore,
-    current_position: &mut u64,
-    total_count: u64,
-) -> Result<EventOutcome> {
-    // Clone the trimmed command to avoid borrow issues
-    let command = command_input.trim().to_string();
-    if command.is_empty() {
-        *command_message = "Empty command".to_string();
-        return Ok(EventOutcome::Ok(command_message.clone()));
-    }
-
-    // Get the action for the command (now checks global and common bindings too)
-    let action = config.get_action_for_command(&command)
-        .unwrap_or("unknown");
-
-    match action {
-        "force_quit" | "save_and_quit" | "quit" => {
-            let (should_exit, message) = command_handler
-                .handle_command(
-                    action,
-                    terminal,
-                    app_state,
-                    form_state,
-                    login_state,
-                    register_state,
-                )
-                .await?;
-            command_input.clear();
-            if should_exit {
-                Ok(EventOutcome::Exit(message))
-            } else {
-                Ok(EventOutcome::Ok(message))
-            }
-        },
-        "save" => {
-            let outcome = save(
-                form_state,
-                grpc_client,
-            ).await?;
-            let message = match outcome {
-                SaveOutcome::CreatedNew(_) => "New entry created".to_string(),
-                SaveOutcome::UpdatedExisting => "Entry updated".to_string(),
-                SaveOutcome::NoChange => "No changes to save".to_string(),
-            };
-            command_input.clear();
-            Ok(EventOutcome::DataSaved(outcome, message))
-        },
-        "revert" => {
-            let message = revert(
-                form_state,
-                grpc_client,
-            ).await?;
-            command_input.clear();
-            Ok(EventOutcome::Ok(message))
-        },
-        _ => {
-            let message = format!("Unhandled action: {}", action);
-            command_input.clear();
-            Ok(EventOutcome::Ok(message))
-        }
-    }
-}

client/src/modes/common/commands.rs

@@ -1,72 +0,0 @@
-// src/modes/common/commands.rs
-use crate::tui::terminal::core::TerminalCore;
-use crate::state::app::state::AppState;
-use crate::state::pages::{form::FormState, auth::LoginState, auth::RegisterState};
-use crate::state::pages::canvas_state::CanvasState;
-use anyhow::Result;
-
-pub struct CommandHandler;
-
-impl CommandHandler {
-    pub fn new() -> Self {
-        Self
-    }
-
-    pub async fn handle_command(
-        &mut self,
-        action: &str,
-        terminal: &mut TerminalCore,
-        app_state: &AppState,
-        form_state: &FormState,
-        login_state: &LoginState,
-        register_state: &RegisterState,
-    ) -> Result<(bool, String)> {
-        match action {
-            "quit" => self.handle_quit(terminal, app_state, form_state, login_state, register_state).await,
-            "force_quit" => self.handle_force_quit(terminal).await,
-            "save_and_quit" => self.handle_save_quit(terminal).await,
-            _ => Ok((false, format!("Unknown command: {}", action))),
-        }
-    }
-
-    async fn handle_quit(
-        &self,
-        terminal: &mut TerminalCore,
-        app_state: &AppState,
-        form_state: &FormState,
-        login_state: &LoginState,
-        register_state: &RegisterState,
-    ) -> Result<(bool, String)> {
-        // Use actual unsaved changes state instead of is_saved flag
-        let has_unsaved = if app_state.ui.show_login {
-            login_state.has_unsaved_changes()
-        } else if app_state.ui.show_register {
-            register_state.has_unsaved_changes()
-        } else {
-            form_state.has_unsaved_changes
-        };
-
-        if !has_unsaved {
-            terminal.cleanup()?;
-            Ok((true, "Exiting.".into()))
-        } else {
-            Ok((false, "No changes saved. Use :q! to force quit.".into()))
-        }
-    }
-
-    async fn handle_force_quit(
-        &self,
-        terminal: &mut TerminalCore,
-    ) -> Result<(bool, String)> {
-        terminal.cleanup()?;
-        Ok((true, "Force exiting without saving.".into()))
-    }
-
-    async fn handle_save_quit(
-        &mut self,
-        terminal: &mut TerminalCore,
-    ) -> Result<(bool, String)> {
-        terminal.cleanup()?;
-        Ok((true, "State saved. Exiting.".into()))
-    }
-}

client/src/modes/general.rs

@@ -1,4 +0,0 @@
-// src/client/modes/general.rs
-pub mod navigation;
-pub mod dialog;
-pub mod command_navigation;

client/src/modes/general/command_navigation.rs

@@ -1,448 +0,0 @@
-// src/modes/general/command_navigation.rs
-use crate::config::binds::config::Config;
-use crate::modes::handlers::event::EventOutcome;
-use anyhow::Result;
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
-use crossterm::event::{KeyCode, KeyEvent};
-use std::collections::{HashMap, HashSet};
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum NavigationType {
-    FindFile,
-    TableTree,
-}
-
-#[derive(Debug, Clone)]
-pub struct TableDependencyGraph {
-    all_tables: HashSet<String>,
-    dependents_map: HashMap<String, Vec<String>>,
-    root_tables: Vec<String>,
-}
-
-impl TableDependencyGraph {
-    pub fn from_profile_tree(profile_tree: &ProfileTreeResponse) -> Self {
-        let mut dependents_map: HashMap<String, Vec<String>> = HashMap::new();
-        let mut all_tables_set: HashSet<String> = HashSet::new();
-        let mut table_dependencies: HashMap<String, Vec<String>> = HashMap::new();
-
-        for profile in &profile_tree.profiles {
-            for table in &profile.tables {
-                all_tables_set.insert(table.name.clone());
-                table_dependencies.insert(table.name.clone(), table.depends_on.clone());
-
-                for dependency_name in &table.depends_on {
-                    dependents_map
-                        .entry(dependency_name.clone())
-                        .or_default()
-                        .push(table.name.clone());
-                }
-            }
-        }
-
-        let root_tables: Vec<String> = all_tables_set
-            .iter()
-            .filter(|name| {
-                table_dependencies
-                    .get(*name)
-                    .map_or(true, |deps| deps.is_empty())
-            })
-            .cloned()
-            .collect();
-
-        let mut sorted_root_tables = root_tables;
-        sorted_root_tables.sort();
-
-        for dependents_list in dependents_map.values_mut() {
-            dependents_list.sort();
-        }
-
-        Self {
-            all_tables: all_tables_set,
-            dependents_map,
-            root_tables: sorted_root_tables,
-        }
-    }
-
-    pub fn get_dependent_children(&self, path: &str) -> Vec<String> {
-        if path.is_empty() {
-            return self.root_tables.clone();
-        }
-
-        let path_segments: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
-        if let Some(last_segment_name) = path_segments.last() {
-            if self.all_tables.contains(*last_segment_name) {
-                return self
-                    .dependents_map
-                    .get(*last_segment_name)
-                    .cloned()
-                    .unwrap_or_default();
-            }
-        }
-        Vec::new()
-    }
-}
-
-pub struct NavigationState {
-    pub active: bool,
-    pub input: String,
-    pub selected_index: Option<usize>,
-    pub filtered_options: Vec<(usize, String)>,
-    pub navigation_type: NavigationType,
-    pub current_path: String,
-    pub graph: Option<TableDependencyGraph>,
-    pub all_options: Vec<String>,
-}
-
-impl NavigationState {
-    pub fn new() -> Self {
-        Self {
-            active: false,
-            input: String::new(),
-            selected_index: None,
-            filtered_options: Vec::new(),
-            navigation_type: NavigationType::FindFile,
-            current_path: String::new(),
-            graph: None,
-            all_options: Vec::new(),
-        }
-    }
-
-    pub fn activate_find_file(&mut self, options: Vec<String>) {
-        self.active = true;
-        self.navigation_type = NavigationType::FindFile;
-        self.all_options = options;
-        self.input.clear();
-        self.current_path.clear();
-        self.graph = None;
-        self.update_filtered_options(); // Initial filter with empty input
-    }
-
-    pub fn activate_table_tree(&mut self, graph: TableDependencyGraph) {
-        self.active = true;
-        self.navigation_type = NavigationType::TableTree;
-        self.graph = Some(graph);
-        self.input.clear();
-        self.current_path.clear();
-        self.update_options_for_path(); // Initial options are root tables
-    }
-
-    pub fn deactivate(&mut self) {
-        self.active = false;
-        self.input.clear();
-        self.all_options.clear();
-        self.filtered_options.clear();
-        self.selected_index = None;
-        self.current_path.clear();
-        self.graph = None;
-    }
-
-    pub fn add_char(&mut self, c: char) {
-        match self.navigation_type {
-            NavigationType::FindFile => {
-                self.input.push(c);
-                self.update_filtered_options();
-            }
-            NavigationType::TableTree => {
-                if c == '/' {
-                    if !self.input.is_empty() {
-                        // Append current input to path
-                        if self.current_path.is_empty() {
-                            self.current_path = self.input.clone();
-                        } else {
-                            self.current_path.push('/');
-                            self.current_path.push_str(&self.input);
-                        }
-                        self.input.clear();
-                        self.update_options_for_path();
-                    }
-                    // If input is empty and char is '/', do nothing or define behavior
-                } else {
-                    self.input.push(c);
-                    self.update_filtered_options(); // Filter current level options based on input
-                }
-            }
-        }
-    }
-
-    pub fn remove_char(&mut self) {
-        match self.navigation_type {
-            NavigationType::FindFile => {
-                self.input.pop();
-                self.update_filtered_options();
-            }
-            NavigationType::TableTree => {
-                if self.input.is_empty() {
-                    // If input is empty, try to go up in path
-                    if !self.current_path.is_empty() {
-                        if let Some(last_slash_idx) =
-                            self.current_path.rfind('/')
-                        {
-                            // Set input to the segment being removed from path
-                            self.input = self.current_path
-                                [last_slash_idx + 1..]
-                                .to_string();
-                            self.current_path =
-                                self.current_path[..last_slash_idx].to_string();
-                        } else {
-                            // Path was a single segment
-                            self.input = self.current_path.clone();
-                            self.current_path.clear();
-                        }
-                        self.update_options_for_path();
-                        // After path change, current input might match some options, so filter
-                        self.update_filtered_options();
-                    }
-                } else {
-                    self.input.pop();
-                    self.update_filtered_options();
-                }
-            }
-        }
-    }
-
-    pub fn move_up(&mut self) {
-        if self.filtered_options.is_empty() {
-            self.selected_index = None;
-            return;
-        }
-        self.selected_index = match self.selected_index {
-            Some(0) => Some(self.filtered_options.len() - 1),
-            Some(current) => Some(current - 1),
-            None => Some(self.filtered_options.len() - 1),
-        };
-    }
-
-    pub fn move_down(&mut self) {
-        if self.filtered_options.is_empty() {
-            self.selected_index = None;
-            return;
-        }
-        self.selected_index = match self.selected_index {
-            Some(current) if current >= self.filtered_options.len() - 1 => {
-                Some(0)
-            }
-            Some(current) => Some(current + 1),
-            None => Some(0),
-        };
-    }
-
-    pub fn get_selected_option_str(&self) -> Option<&str> {
-        self.selected_index
-            .and_then(|idx| self.filtered_options.get(idx))
-            .map(|(_, option_str)| option_str.as_str())
-    }
-
-    pub fn autocomplete_selected(&mut self) {
-        if let Some(selected_option_str) = self.get_selected_option_str() {
-            // The current `self.input` is the text being typed for the current segment/filter.
-            // We replace it with the full string of the selected option.
-            self.input = selected_option_str.to_string();
-
-            // After updating the input, we need to re-filter the options.
-            // This will typically result in the filtered_options containing only the
-            // autocompleted item (or items that start with it, if any).
-            self.update_filtered_options();
-        }
-    }
-
-    // Returns the string to display in the input line of the palette
-    pub fn get_display_input(&self) -> String {
-        match self.navigation_type {
-            NavigationType::FindFile => self.input.clone(),
-            NavigationType::TableTree => {
-                if self.current_path.is_empty() {
-                    self.input.clone()
-                } else {
-                    format!("{}/{}", self.current_path, self.input)
-                }
-            }
-        }
-    }
-
-    // Gets the full path of the currently selected item for TableTree, or input for FindFile
-    pub fn get_selected_value(&self) -> Option<String> {
-        match self.navigation_type {
-            NavigationType::FindFile => {
-                if self.input.is_empty() { None } else { Some(self.input.clone()) }
-            }
-            NavigationType::TableTree => {
-                self.get_selected_option_str().map(|selected_name| {
-                    if self.current_path.is_empty() {
-                        selected_name.to_string()
-                    } else {
-                        format!("{}/{}", self.current_path, selected_name)
-                    }
-                })
-            }
-        }
-    }
-
-    // Update self.all_options based on current_path (for TableTree)
-    fn update_options_for_path(&mut self) {
-        if let NavigationType::TableTree = self.navigation_type {
-            if let Some(graph) = &self.graph {
-                self.all_options =
-                    graph.get_dependent_children(&self.current_path);
-            } else {
-                self.all_options.clear();
-            }
-        }
-        // For FindFile, all_options is set once at activation.
-        self.update_filtered_options();
-    }
-
-    // Update self.filtered_options based on self.all_options and self.input
-    fn update_filtered_options(&mut self) {
-        let filter_text = match self.navigation_type {
-            NavigationType::FindFile => &self.input,
-            NavigationType::TableTree => &self.input, // For TableTree, input is the current segment being typed
-        }
-        .to_lowercase();
-
-        if filter_text.is_empty() {
-            self.filtered_options = self
-                .all_options
-                .iter()
-                .enumerate()
-                .map(|(i, opt)| (i, opt.clone()))
-                .collect();
-        } else {
-            self.filtered_options = self
-                .all_options
-                .iter()
-                .enumerate()
-                .filter(|(_, opt)| opt.to_lowercase().contains(&filter_text))
-                .map(|(i, opt)| (i, opt.clone()))
-                .collect();
-        }
-
-        if self.filtered_options.is_empty() {
-            self.selected_index = None;
-        } else {
-            self.selected_index = Some(0); // Default to selecting the first item
-        }
-    }
-}
-
-pub async fn handle_command_navigation_event(
-    navigation_state: &mut NavigationState,
-    key: KeyEvent,
-    config: &Config,
-) -> Result<EventOutcome> {
-    if !navigation_state.active {
-        return Ok(EventOutcome::Ok(String::new()));
-    }
-
-    match key.code {
-        KeyCode::Esc => {
-            navigation_state.deactivate();
-            Ok(EventOutcome::Ok("Navigation cancelled".to_string()))
-        }
-        KeyCode::Enter => {
-            if let Some(selected_value) = navigation_state.get_selected_value() {
-                let message = match navigation_state.navigation_type {
-                    NavigationType::FindFile => format!("Selected file: {}", selected_value),
-                    NavigationType::TableTree => format!("Selected table: {}", selected_value),
-                };
-                navigation_state.deactivate();
-                Ok(EventOutcome::Ok(message))
-            } else {
-                // Enhanced Enter behavior for TableTree: if input is a valid partial path, try to navigate
-                if navigation_state.navigation_type == NavigationType::TableTree && !navigation_state.input.is_empty() {
-                    // Check if current input is a prefix of any option or a full option name
-                    if let Some(selected_opt_str) = navigation_state.get_selected_option_str() {
-                        if navigation_state.input == selected_opt_str {
-                            // Input exactly matches the selected option, try to navigate
-                            let input_before_slash = navigation_state.input.clone();
-                            navigation_state.add_char('/');
-                            
-                            if navigation_state.input.is_empty() {
-                                return Ok(EventOutcome::Ok(format!("Navigated to: {}/", input_before_slash)));
-                            } else {
-                                return Ok(EventOutcome::Ok(format!("Selected leaf: {}", input_before_slash)));
-                            }
-                        }
-                    }
-                }
-                Ok(EventOutcome::Ok("No valid selection to confirm or navigate".to_string()))
-            }
-        }
-        KeyCode::Tab => {
-            if let Some(selected_opt_str) = navigation_state.get_selected_option_str() {
-                // Scenario 1: Input already exactly matches the selected option
-                if navigation_state.input == selected_opt_str {
-                    // Only attempt to navigate deeper for TableTree mode
-                    if navigation_state.navigation_type == NavigationType::TableTree {
-                        let path_before_nav = navigation_state.current_path.clone();
-                        let input_before_nav = navigation_state.input.clone();
-
-                        navigation_state.add_char('/');
-
-                        if navigation_state.input.is_empty() &&
-                           (navigation_state.current_path != path_before_nav || !navigation_state.all_options.is_empty()) {
-                            // Navigation successful
-                        } else {
-                            // Revert if navigation didn't happen
-                            if !navigation_state.input.is_empty() && navigation_state.input != input_before_nav {
-                                navigation_state.input = input_before_nav;
-                                if navigation_state.current_path != path_before_nav {
-                                    navigation_state.current_path = path_before_nav;
-                                }
-                                navigation_state.update_options_for_path();
-                            }
-                        }
-                    }
-                } else {
-                    // Scenario 2: Input is a partial match - autocomplete
-                    navigation_state.autocomplete_selected();
-                }
-            }
-            Ok(EventOutcome::Ok(String::new()))
-        }
-        KeyCode::Up => {
-            navigation_state.move_up();
-            Ok(EventOutcome::Ok(String::new()))
-        }
-        KeyCode::Down => {
-            navigation_state.move_down();
-            Ok(EventOutcome::Ok(String::new()))
-        }
-        KeyCode::Backspace => {
-            navigation_state.remove_char();
-            Ok(EventOutcome::Ok(String::new()))
-        }
-        KeyCode::Char(c) => {
-            navigation_state.add_char(c);
-            Ok(EventOutcome::Ok(String::new()))
-        }
-        _ => {
-            if let Some(action) = config.get_general_action(key.code, key.modifiers) {
-                match action {
-                    "move_up" => {
-                        navigation_state.move_up();
-                        Ok(EventOutcome::Ok(String::new()))
-                    }
-                    "move_down" => {
-                        navigation_state.move_down();
-                        Ok(EventOutcome::Ok(String::new()))
-                    }
-                    "select" => {
-                        if let Some(selected_value) = navigation_state.get_selected_value() {
-                            let message = match navigation_state.navigation_type {
-                                NavigationType::FindFile => format!("Selected file: {}", selected_value),
-                                NavigationType::TableTree => format!("Selected table: {}", selected_value),
-                            };
-                            navigation_state.deactivate();
-                            Ok(EventOutcome::Ok(message))
-                        } else {
-                            Ok(EventOutcome::Ok("No selection".to_string()))
-                        }
-                    }
-                    _ => Ok(EventOutcome::Ok(String::new())),
-                }
-            } else {
-                Ok(EventOutcome::Ok(String::new()))
-            }
-        }
-    }
-}

client/src/modes/general/dialog.rs

@@ -1,163 +0,0 @@
-// src/modes/general/dialog.rs
-
-use crossterm::event::{Event, KeyCode};
-use crate::config::binds::config::Config;
-use crate::ui::handlers::context::DialogPurpose;
-use crate::state::app::{state::AppState, buffer::AppView};
-use crate::state::app::buffer::BufferState;
-use crate::state::pages::auth::{LoginState, RegisterState};
-use crate::state::pages::admin::AdminState;
-use crate::modes::handlers::event::EventOutcome;
-use crate::tui::functions::common::{login, register};
-use crate::tui::functions::common::add_table::handle_delete_selected_columns;
-use anyhow::Result;
-
-/// Handles key events specifically when a dialog is active.
-/// Returns Some(Result<EventOutcome, Error>) if the event was handled (consumed),
-/// otherwise returns None.
-pub async fn handle_dialog_event(
-    event: &Event,
-    config: &Config,
-    app_state: &mut AppState,
-    login_state: &mut LoginState,
-    register_state: &mut RegisterState,
-    buffer_state: &mut BufferState,
-    admin_state: &mut AdminState,
-) -> Option<Result<EventOutcome>> {
-    if let Event::Key(key) = event {
-        // Always allow Esc to dismiss
-        if key.code == KeyCode::Esc {
-            app_state.hide_dialog();
-            return Some(Ok(EventOutcome::Ok("Dialog dismissed".to_string())));
-        }
-
-        // Check general bindings for dialog actions
-        if let Some(action) = config.get_general_action(key.code, key.modifiers) {
-            match action {
-                "move_down" | "next_option" => {
-                    let current_index = app_state.ui.dialog.dialog_active_button_index;
-                    let num_buttons = app_state.ui.dialog.dialog_buttons.len();
-                    if num_buttons > 0 && current_index < num_buttons - 1 {
-                        app_state.ui.dialog.dialog_active_button_index += 1;
-                    }
-                    return Some(Ok(EventOutcome::Ok(String::new())));
-                }
-                "move_up" | "previous_option" => {
-                    let current_index = app_state.ui.dialog.dialog_active_button_index;
-                    if current_index > 0 {
-                        app_state.ui.dialog.dialog_active_button_index -= 1;
-                    }
-                    return Some(Ok(EventOutcome::Ok(String::new())));
-                }
-                "select" => {
-                    let selected_index = app_state.ui.dialog.dialog_active_button_index;
-                    let purpose = match app_state.ui.dialog.purpose {
-                        Some(p) => p,
-                        None => {
-                            app_state.hide_dialog();
-                            return Some(Ok(EventOutcome::Ok("Internal Error: Dialog context lost".to_string())));
-                        }
-                    };
-
-                    // Handle Dialog Actions Directly Here
-                    match purpose {
-                        DialogPurpose::LoginSuccess => {
-                            match selected_index {
-                                0 => { // "Menu" button selected
-                                    app_state.hide_dialog();
-                                    let message = login::back_to_main(login_state, app_state, buffer_state).await;
-                                    return Some(Ok(EventOutcome::Ok(message)));
-                                }
-                                1 => {
-                                    app_state.hide_dialog();
-                                    return Some(Ok(EventOutcome::Ok("Exiting dialog".to_string())));
-                                }
-                                _ => {
-                                    app_state.hide_dialog();
-                                    return Some(Ok(EventOutcome::Ok("Unknown dialog button selected".to_string())));
-                                }
-                            }
-                        }
-                        DialogPurpose::LoginFailed => {
-                            match selected_index {
-                                0 => { // "OK" button selected
-                                    app_state.hide_dialog();
-                                    return Some(Ok(EventOutcome::Ok("Login failed dialog dismissed".to_string())));
-                                }
-                                _ => {
-                                    app_state.hide_dialog();
-                                    return Some(Ok(EventOutcome::Ok("Unknown dialog button selected".to_string())));
-                                }
-                            }
-                        }
-                        DialogPurpose::RegisterSuccess => { // Add this arm
-                            match selected_index {
-                                0 => { // "OK" button for RegisterSuccess
-                                    app_state.hide_dialog();
-                                    let message = register::back_to_login(register_state, app_state, buffer_state).await;
-                                    return Some(Ok(EventOutcome::Ok(message)));
-                                }
-                                _ => { // Default for RegisterSuccess
-                                    app_state.hide_dialog();
-                                    return Some(Ok(EventOutcome::Ok("Unknown dialog button selected".to_string())));
-                                }
-                            }
-                        }
-                        DialogPurpose::RegisterFailed => { // Add this arm
-                             match selected_index {
-                                0 => { // "OK" button for RegisterFailed
-                                    app_state.hide_dialog(); // Just dismiss
-                                    return Some(Ok(EventOutcome::Ok("Register failed dialog dismissed".to_string())));
-                                }
-                                _ => { // Default for RegisterFailed
-                                    app_state.hide_dialog();
-                                    return Some(Ok(EventOutcome::Ok("Unknown dialog button selected".to_string())));
-                                }
-                            }
-                        }
-                        DialogPurpose::ConfirmDeleteColumns => {
-                            match selected_index {
-                                0 => { // "Confirm" button selected
-                                    let outcome_message = handle_delete_selected_columns(&mut admin_state.add_table_state);
-                                    app_state.hide_dialog();
-                                    return Some(Ok(EventOutcome::Ok(outcome_message)));
-                                }
-                                1 => { // "Cancel" button selected
-                                    app_state.hide_dialog();
-                                    return Some(Ok(EventOutcome::Ok("Deletion cancelled.".to_string())));
-                                }
-                                _ => { /* Handle unexpected index */ }
-                            }
-                        }
-                        DialogPurpose::SaveTableSuccess => {
-                            match selected_index {
-                                0 => { // "OK" button selected
-                                    app_state.hide_dialog();
-                                    buffer_state.update_history(AppView::Admin); // Navigate back
-                                    return Some(Ok(EventOutcome::Ok("Save success dialog dismissed.".to_string())));
-                                }
-                                _ => { /* Handle unexpected index */ }
-                            }
-                        }
-                        DialogPurpose::SaveLogicSuccess => {
-                            match selected_index {
-                                0 => { // "OK" button selected
-                                    app_state.hide_dialog();
-                                    buffer_state.update_history(AppView::Admin);
-                                    return Some(Ok(EventOutcome::Ok("Save success dialog dismissed.".to_string())));
-                                }
-                                _ => { /* Handle unexpected index */ }
-                            }
-                        }
-                    }
-                }
-                _ => {} // Ignore other general actions when dialog is shown
-            }
-        }
-        // If it was a key event but not handled above, consume it
-        Some(Ok(EventOutcome::Ok(String::new())))
-    } else {
-        // If it wasn't a key event, consume it too while dialog is active
-        Some(Ok(EventOutcome::Ok(String::new())))
-    }
-}

client/src/modes/general/navigation.rs

@@ -1,169 +0,0 @@
-// src/modes/general/navigation.rs
-
-use crossterm::event::KeyEvent;
-use crate::config::binds::config::Config;
-use crate::state::app::state::AppState;
-use crate::state::pages::form::FormState;
-use crate::state::pages::auth::LoginState;
-use crate::state::pages::auth::RegisterState;
-use crate::state::pages::intro::IntroState;
-use crate::state::pages::admin::AdminState;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::ui::handlers::context::UiContext;
-use crate::modes::handlers::event::EventOutcome;
-use crate::modes::general::command_navigation::{handle_command_navigation_event, NavigationState};
-use anyhow::Result;
-
-pub async fn handle_navigation_event(
-    key: KeyEvent,
-    config: &Config,
-    form_state: &mut FormState,
-    app_state: &mut AppState,
-    login_state: &mut LoginState,
-    register_state: &mut RegisterState,
-    intro_state: &mut IntroState,
-    admin_state: &mut AdminState,
-    command_mode: &mut bool,
-    command_input: &mut String,
-    command_message: &mut String,
-    navigation_state: &mut NavigationState,
-) -> Result<EventOutcome> {
-    // Handle command navigation first if active
-    if navigation_state.active {
-        return handle_command_navigation_event(navigation_state, key, config).await;
-    }
-
-    if let Some(action) = config.get_general_action(key.code, key.modifiers) {
-        match action {
-            "move_up" => {
-                move_up(app_state, login_state, register_state, intro_state, admin_state);
-                return Ok(EventOutcome::Ok(String::new()));
-            }
-            "move_down" => {
-                move_down(app_state, intro_state, admin_state);
-                return Ok(EventOutcome::Ok(String::new()));
-            }
-            "next_option" => {
-                next_option(app_state, intro_state);
-                return Ok(EventOutcome::Ok(String::new()));
-            }
-            "previous_option" => {
-                previous_option(app_state, intro_state);
-                return Ok(EventOutcome::Ok(String::new()));
-            }
-            "next_field" => {
-                next_field(form_state);
-                return Ok(EventOutcome::Ok(String::new()));
-            }
-            "prev_field" => {
-                prev_field(form_state);
-                return Ok(EventOutcome::Ok(String::new()));
-            }
-            "enter_command_mode" => {
-                handle_enter_command_mode(command_mode, command_input, command_message);
-                return Ok(EventOutcome::Ok(String::new()));
-            }
-            "select" => {
-                let (context, index) = if app_state.ui.show_intro {
-                    (UiContext::Intro, intro_state.selected_option)
-                } else if app_state.ui.show_login && app_state.ui.focus_outside_canvas {
-                    (UiContext::Login, app_state.focused_button_index)
-                } else if app_state.ui.show_register && app_state.ui.focus_outside_canvas {
-                    (UiContext::Register, app_state.focused_button_index)
-                } else if app_state.ui.show_admin {
-                    (UiContext::Admin, admin_state.get_selected_index().unwrap_or(0))
-                } else if app_state.ui.dialog.dialog_show {
-                     (UiContext::Dialog, app_state.ui.dialog.dialog_active_button_index)
-                } else {
-                    return Ok(EventOutcome::Ok("Select (No Action)".to_string()));
-                };
-                return Ok(EventOutcome::ButtonSelected { context, index });
-            }
-            _ => {}
-        }
-    }
-    Ok(EventOutcome::Ok(String::new()))
-}
-
-pub fn move_up(app_state: &mut AppState, login_state: &mut LoginState, register_state: &mut RegisterState, intro_state: &mut IntroState, admin_state: &mut AdminState) {
-    if app_state.ui.focus_outside_canvas && app_state.ui.show_login || app_state.ui.show_register{
-        if app_state.focused_button_index == 0 {
-            app_state.ui.focus_outside_canvas = false;
-            if app_state.ui.show_login {
-                let last_field_index = login_state.fields().len().saturating_sub(1);
-                login_state.set_current_field(last_field_index);
-            } else {
-                let last_field_index = register_state.fields().len().saturating_sub(1);
-                register_state.set_current_field(last_field_index);
-            }
-        } else {
-            app_state.focused_button_index = app_state.focused_button_index.saturating_sub(1);
-        }
-    } else if app_state.ui.show_intro {
-        intro_state.previous_option();
-    } else if app_state.ui.show_admin {
-        admin_state.previous();
-    }
-}
-
-pub fn move_down(app_state: &mut AppState, intro_state: &mut IntroState, admin_state: &mut AdminState) {
-    if app_state.ui.focus_outside_canvas && app_state.ui.show_login || app_state.ui.show_register {
-        let num_general_elements = 2;
-        if app_state.focused_button_index < num_general_elements - 1 {
-            app_state.focused_button_index += 1;
-        }
-    } else if app_state.ui.show_intro {
-        intro_state.next_option();
-    } else if app_state.ui.show_admin {
-        admin_state.next();
-    }
-}
-
-pub fn next_option(app_state: &mut AppState, intro_state: &mut IntroState) { 
-    if app_state.ui.show_intro {
-        intro_state.next_option();
-    } else {
-        // Get option count from state instead of parameter
-        let option_count = app_state.profile_tree.profiles.len();
-        app_state.focused_button_index = (app_state.focused_button_index + 1) % option_count;
-    }
-}
-
-pub fn previous_option(app_state: &mut AppState, intro_state: &mut IntroState) {
-    if app_state.ui.show_intro {
-        intro_state.previous_option();
-    } else {
-        let option_count = app_state.profile_tree.profiles.len();
-        app_state.focused_button_index = if app_state.focused_button_index == 0 {
-            option_count.saturating_sub(1)
-        } else {
-            app_state.focused_button_index - 1
-        };
-    }
-}
-
-pub fn next_field(form_state: &mut FormState) {
-    if !form_state.fields.is_empty() {
-        form_state.current_field = (form_state.current_field + 1) % form_state.fields.len();
-    }
-}
-
-pub fn prev_field(form_state: &mut FormState) {
-    if !form_state.fields.is_empty() {
-        if form_state.current_field == 0 {
-            form_state.current_field = form_state.fields.len() - 1;
-        } else {
-            form_state.current_field -= 1;
-        }
-    }
-}
-
-pub fn handle_enter_command_mode(
-    command_mode: &mut bool,
-    command_input: &mut String,
-    command_message: &mut String
-) {
-    *command_mode = true;
-    command_input.clear();
-    command_message.clear();
-}

client/src/modes/handlers.rs

@@ -1,3 +0,0 @@
-// src/client/modes/handlers.rs
-pub mod event;
-pub mod mode_manager;

client/src/modes/handlers/event.rs

@@ -1,780 +0,0 @@
-// src/modes/handlers/event.rs
-use crate::config::binds::config::Config;
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::functions::common::buffer;
-use crate::functions::modes::navigation::add_logic_nav;
-use crate::functions::modes::navigation::add_logic_nav::SaveLogicResultSender;
-use crate::functions::modes::navigation::add_table_nav::SaveTableResultSender;
-use crate::functions::modes::navigation::{add_table_nav, admin_nav};
-use crate::modes::general::command_navigation::{
-    handle_command_navigation_event, NavigationState, TableDependencyGraph,
-};
-use crate::modes::{
-    canvas::{common_mode, edit, read_only},
-    common::{command_mode, commands::CommandHandler},
-    general::{dialog, navigation},
-    handlers::mode_manager::{AppMode, ModeManager},
-};
-use crate::services::auth::AuthClient;
-use crate::services::grpc_client::GrpcClient;
-use crate::state::{
-    app::{
-        buffer::{AppView, BufferState},
-        highlight::HighlightState,
-        state::AppState,
-    },
-    pages::{
-        admin::AdminState,
-        auth::{AuthState, LoginState, RegisterState},
-        canvas_state::CanvasState,
-        form::FormState,
-        intro::IntroState,
-    },
-};
-use crate::tui::functions::common::login::LoginResult;
-use crate::tui::functions::common::register::RegisterResult;
-use crate::tui::{
-    functions::common::{form::SaveOutcome, login, register},
-    terminal::core::TerminalCore,
-    {admin, intro},
-};
-use crate::ui::handlers::context::UiContext;
-use crate::ui::handlers::rat_state::UiStateHandler;
-use anyhow::Result;
-use crossterm::cursor::SetCursorStyle;
-use crossterm::event::KeyCode;
-use crossterm::event::{Event, KeyEvent};
-use tokio::sync::mpsc;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum EventOutcome {
-    Ok(String),
-    Exit(String),
-    DataSaved(SaveOutcome, String),
-    ButtonSelected { context: UiContext, index: usize },
-}
-
-impl EventOutcome {
-    pub fn get_message_if_ok(&self) -> String {
-        match self {
-            EventOutcome::Ok(msg) => msg.clone(),
-            _ => String::new(),
-        }
-    }
-}
-
-pub struct EventHandler {
-    pub command_mode: bool,
-    pub command_input: String,
-    pub command_message: String,
-    pub is_edit_mode: bool,
-    pub highlight_state: HighlightState,
-    pub edit_mode_cooldown: bool,
-    pub ideal_cursor_column: usize,
-    pub key_sequence_tracker: KeySequenceTracker,
-    pub auth_client: AuthClient,
-    pub login_result_sender: mpsc::Sender<LoginResult>,
-    pub register_result_sender: mpsc::Sender<RegisterResult>,
-    pub save_table_result_sender: SaveTableResultSender,
-    pub save_logic_result_sender: SaveLogicResultSender,
-    pub navigation_state: NavigationState,
-}
-
-impl EventHandler {
-    pub async fn new(
-        login_result_sender: mpsc::Sender<LoginResult>,
-        register_result_sender: mpsc::Sender<RegisterResult>,
-        save_table_result_sender: SaveTableResultSender,
-        save_logic_result_sender: SaveLogicResultSender,
-    ) -> Result<Self> {
-        Ok(EventHandler {
-            command_mode: false,
-            command_input: String::new(),
-            command_message: String::new(),
-            is_edit_mode: false,
-            highlight_state: HighlightState::Off,
-            edit_mode_cooldown: false,
-            ideal_cursor_column: 0,
-            key_sequence_tracker: KeySequenceTracker::new(400),
-            auth_client: AuthClient::new().await?,
-            login_result_sender,
-            register_result_sender,
-            save_table_result_sender,
-            save_logic_result_sender,
-            navigation_state: NavigationState::new(),
-        })
-    }
-
-    pub fn is_navigation_active(&self) -> bool {
-        self.navigation_state.active
-    }
-
-    pub fn activate_find_file(&mut self, options: Vec<String>) {
-        self.navigation_state.activate_find_file(options);
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn handle_event(
-        &mut self,
-        event: Event,
-        config: &Config,
-        terminal: &mut TerminalCore,
-        grpc_client: &mut GrpcClient,
-        command_handler: &mut CommandHandler,
-        form_state: &mut FormState,
-        auth_state: &mut AuthState,
-        login_state: &mut LoginState,
-        register_state: &mut RegisterState,
-        intro_state: &mut IntroState,
-        admin_state: &mut AdminState,
-        buffer_state: &mut BufferState,
-        app_state: &mut AppState,
-    ) -> Result<EventOutcome> {
-        let mut current_mode = ModeManager::derive_mode(app_state, self, admin_state);
-
-        // Handle active command navigation first
-        if current_mode == AppMode::General && self.navigation_state.active {
-            if let Event::Key(key_event) = event {
-                let outcome =
-                    handle_command_navigation_event(&mut self.navigation_state, key_event, config)
-                        .await?;
-
-                if !self.navigation_state.active {
-                    self.command_message = outcome.get_message_if_ok();
-                    current_mode = ModeManager::derive_mode(app_state, self, admin_state);
-                }
-                app_state.update_mode(current_mode);
-                return Ok(outcome);
-            }
-            app_state.update_mode(current_mode);
-            return Ok(EventOutcome::Ok(String::new()));
-        }
-
-        app_state.update_mode(current_mode);
-
-        let current_view = {
-            let ui = &app_state.ui;
-            if ui.show_intro {
-                AppView::Intro
-            } else if ui.show_login {
-                AppView::Login
-            } else if ui.show_register {
-                AppView::Register
-            } else if ui.show_admin {
-                AppView::Admin
-            } else if ui.show_add_logic {
-                AppView::AddLogic
-            } else if ui.show_add_table {
-                AppView::AddTable
-            } else if ui.show_form {
-                AppView::Form
-            } else {
-                AppView::Scratch
-            }
-        };
-        buffer_state.update_history(current_view);
-
-        if app_state.ui.dialog.dialog_show {
-            if let Event::Key(key_event) = event {
-                if let Some(dialog_result) = dialog::handle_dialog_event(
-                    &Event::Key(key_event),
-                    config,
-                    app_state,
-                    login_state,
-                    register_state,
-                    buffer_state,
-                    admin_state,
-                )
-                .await
-                {
-                    return dialog_result;
-                }
-            } else if let Event::Resize(_, _) = event {
-                // Handle resize if needed
-            }
-            return Ok(EventOutcome::Ok(String::new()));
-        }
-
-        if let Event::Key(key_event) = event {
-            let key_code = key_event.code;
-            let modifiers = key_event.modifiers;
-
-            if UiStateHandler::toggle_sidebar(&mut app_state.ui, config, key_code, modifiers) {
-                let message = format!(
-                    "Sidebar {}",
-                    if app_state.ui.show_sidebar {
-                        "shown"
-                    } else {
-                        "hidden"
-                    }
-                );
-                return Ok(EventOutcome::Ok(message));
-            }
-            if UiStateHandler::toggle_buffer_list(&mut app_state.ui, config, key_code, modifiers) {
-                let message = format!(
-                    "Buffer {}",
-                    if app_state.ui.show_buffer_list {
-                        "shown"
-                    } else {
-                        "hidden"
-                    }
-                );
-                return Ok(EventOutcome::Ok(message));
-            }
-
-            if !matches!(current_mode, AppMode::Edit | AppMode::Command) {
-                if let Some(action) = config.get_action_for_key_in_mode(
-                    &config.keybindings.global,
-                    key_code,
-                    modifiers,
-                ) {
-                    match action {
-                        "next_buffer" => {
-                            if buffer::switch_buffer(buffer_state, true) {
-                                return Ok(EventOutcome::Ok("Switched to next buffer".to_string()));
-                            }
-                        }
-                        "previous_buffer" => {
-                            if buffer::switch_buffer(buffer_state, false) {
-                                return Ok(EventOutcome::Ok(
-                                    "Switched to previous buffer".to_string(),
-                                ));
-                            }
-                        }
-                        "close_buffer" => {
-                            let current_table_name = Some("2025_customer");
-                            let message =
-                                buffer_state.close_buffer_with_intro_fallback(current_table_name);
-                            return Ok(EventOutcome::Ok(message));
-                        }
-                        _ => {}
-                    }
-                }
-            }
-
-            match current_mode {
-                AppMode::General => {
-                    if app_state.ui.show_admin && auth_state.role.as_deref() == Some("admin") {
-                        if admin_nav::handle_admin_navigation(
-                            key_event,
-                            config,
-                            app_state,
-                            admin_state,
-                            buffer_state,
-                            &mut self.command_message,
-                        ) {
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
-                        }
-                    }
-
-                    if app_state.ui.show_add_logic {
-                        let client_clone = grpc_client.clone();
-                        let sender_clone = self.save_logic_result_sender.clone();
-
-                        if add_logic_nav::handle_add_logic_navigation(
-                            key_event,
-                            config,
-                            app_state,
-                            &mut admin_state.add_logic_state,
-                            &mut self.is_edit_mode,
-                            buffer_state,
-                            client_clone,
-                            sender_clone,
-                            &mut self.command_message,
-                        ) {
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
-                        }
-                    }
-
-                    if app_state.ui.show_add_table {
-                        let client_clone = grpc_client.clone();
-                        let sender_clone = self.save_table_result_sender.clone();
-
-                        if add_table_nav::handle_add_table_navigation(
-                            key_event,
-                            config,
-                            app_state,
-                            &mut admin_state.add_table_state,
-                            client_clone,
-                            sender_clone,
-                            &mut self.command_message,
-                        ) {
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
-                        }
-                    }
-
-                    let nav_outcome = navigation::handle_navigation_event(
-                        key_event,
-                        config,
-                        form_state,
-                        app_state,
-                        login_state,
-                        register_state,
-                        intro_state,
-                        admin_state,
-                        &mut self.command_mode,
-                        &mut self.command_input,
-                        &mut self.command_message,
-                        &mut self.navigation_state,
-                    )
-                    .await;
-
-                    match nav_outcome {
-                        Ok(EventOutcome::ButtonSelected { context, index }) => {
-                            let message = match context {
-                                UiContext::Intro => {
-                                    intro::handle_intro_selection(app_state, buffer_state, index);
-                                    if app_state.ui.show_admin {
-                                        if !app_state.profile_tree.profiles.is_empty() {
-                                            admin_state.profile_list_state.select(Some(0));
-                                        }
-                                    }
-                                    format!("Intro Option {} selected", index)
-                                }
-                                UiContext::Login => match index {
-                                    0 => login::initiate_login(
-                                        login_state,
-                                        app_state,
-                                        self.auth_client.clone(),
-                                        self.login_result_sender.clone(),
-                                    ),
-                                    1 => {
-                                        login::back_to_main(login_state, app_state, buffer_state)
-                                            .await
-                                    }
-                                    _ => "Invalid Login Option".to_string(),
-                                },
-                                UiContext::Register => match index {
-                                    0 => register::initiate_registration(
-                                        register_state,
-                                        app_state,
-                                        self.auth_client.clone(),
-                                        self.register_result_sender.clone(),
-                                    ),
-                                    1 => {
-                                        register::back_to_login(
-                                            register_state,
-                                            app_state,
-                                            buffer_state,
-                                        )
-                                        .await
-                                    }
-                                    _ => "Invalid Login Option".to_string(),
-                                },
-                                UiContext::Admin => {
-                                    admin::handle_admin_selection(app_state, admin_state);
-                                    format!("Admin Option {} selected", index)
-                                }
-                                UiContext::Dialog => {
-                                    "Internal error: Unexpected dialog state".to_string()
-                                }
-                            };
-                            return Ok(EventOutcome::Ok(message));
-                        }
-                        other => return other,
-                    }
-                }
-
-                AppMode::ReadOnly => {
-                    if config.get_read_only_action_for_key(key_code, modifiers)
-                        == Some("enter_highlight_mode_linewise")
-                        && ModeManager::can_enter_highlight_mode(current_mode)
-                    {
-                        let current_field_index = if app_state.ui.show_login {
-                            login_state.current_field()
-                        } else if app_state.ui.show_register {
-                            register_state.current_field()
-                        } else {
-                            form_state.current_field()
-                        };
-                        self.highlight_state = HighlightState::Linewise {
-                            anchor_line: current_field_index,
-                        };
-                        self.command_message = "-- LINE HIGHLIGHT --".to_string();
-                        return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    } else if config.get_read_only_action_for_key(key_code, modifiers)
-                        == Some("enter_highlight_mode")
-                        && ModeManager::can_enter_highlight_mode(current_mode)
-                    {
-                        let current_field_index = if app_state.ui.show_login {
-                            login_state.current_field()
-                        } else if app_state.ui.show_register {
-                            register_state.current_field()
-                        } else {
-                            form_state.current_field()
-                        };
-                        let current_cursor_pos = if app_state.ui.show_login {
-                            login_state.current_cursor_pos()
-                        } else if app_state.ui.show_register {
-                            register_state.current_cursor_pos()
-                        } else {
-                            form_state.current_cursor_pos()
-                        };
-                        let anchor = (current_field_index, current_cursor_pos);
-                        self.highlight_state = HighlightState::Characterwise { anchor };
-                        self.command_message = "-- HIGHLIGHT --".to_string();
-                        return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    } else if config
-                        .get_read_only_action_for_key(key_code, modifiers)
-                        .as_deref()
-                        == Some("enter_edit_mode_before")
-                        && ModeManager::can_enter_edit_mode(current_mode)
-                    {
-                        self.is_edit_mode = true;
-                        self.edit_mode_cooldown = true;
-                        self.command_message = "Edit mode".to_string();
-                        terminal.set_cursor_style(SetCursorStyle::BlinkingBar)?;
-                        return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    } else if config
-                        .get_read_only_action_for_key(key_code, modifiers)
-                        .as_deref()
-                        == Some("enter_edit_mode_after")
-                        && ModeManager::can_enter_edit_mode(current_mode)
-                    {
-                        let current_input = if app_state.ui.show_login || app_state.ui.show_register
-                        {
-                            login_state.get_current_input()
-                        } else {
-                            form_state.get_current_input()
-                        };
-                        let current_cursor_pos =
-                            if app_state.ui.show_login || app_state.ui.show_register {
-                                login_state.current_cursor_pos()
-                            } else {
-                                form_state.current_cursor_pos()
-                            };
-
-                        if !current_input.is_empty() && current_cursor_pos < current_input.len() {
-                            if app_state.ui.show_login || app_state.ui.show_register {
-                                login_state.set_current_cursor_pos(current_cursor_pos + 1);
-                                self.ideal_cursor_column = login_state.current_cursor_pos();
-                            } else {
-                                form_state.set_current_cursor_pos(current_cursor_pos + 1);
-                                self.ideal_cursor_column = form_state.current_cursor_pos();
-                            }
-                        }
-                        self.is_edit_mode = true;
-                        self.edit_mode_cooldown = true;
-                        app_state.ui.focus_outside_canvas = false;
-                        self.command_message = "Edit mode (after cursor)".to_string();
-                        terminal.set_cursor_style(SetCursorStyle::BlinkingBar)?;
-                        return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    } else if config.get_read_only_action_for_key(key_code, modifiers)
-                        == Some("enter_command_mode")
-                        && ModeManager::can_enter_command_mode(current_mode)
-                    {
-                        self.command_mode = true;
-                        self.command_input.clear();
-                        self.command_message.clear();
-                        return Ok(EventOutcome::Ok(String::new()));
-                    }
-
-                    if let Some(action) = config.get_common_action(key_code, modifiers) {
-                        match action {
-                            "save" | "force_quit" | "save_and_quit" | "revert" => {
-                                return common_mode::handle_core_action(
-                                    action,
-                                    form_state,
-                                    auth_state,
-                                    login_state,
-                                    register_state,
-                                    grpc_client,
-                                    &mut self.auth_client,
-                                    terminal,
-                                    app_state,
-                                )
-                                .await;
-                            }
-                            _ => {}
-                        }
-                    }
-
-                    // Extracting values to avoid borrow conflicts
-                    let mut current_position = form_state.current_position;
-                    let total_count = form_state.total_count;
-
-                    let (_should_exit, message) = read_only::handle_read_only_event(
-                        app_state,
-                        key_event,
-                        config,
-                        form_state,
-                        login_state,
-                        register_state,
-                        &mut admin_state.add_table_state,
-                        &mut admin_state.add_logic_state,
-                        &mut self.key_sequence_tracker,
-                        &mut current_position,
-                        total_count,
-                        grpc_client,
-                        &mut self.command_message,
-                        &mut self.edit_mode_cooldown,
-                        &mut self.ideal_cursor_column,
-                    )
-                    .await?;
-                    return Ok(EventOutcome::Ok(message));
-                }
-
-                AppMode::Highlight => {
-                    if config.get_highlight_action_for_key(key_code, modifiers)
-                        == Some("exit_highlight_mode")
-                    {
-                        self.highlight_state = HighlightState::Off;
-                        self.command_message = "Exited highlight mode".to_string();
-                        terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
-                        return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    } else if config.get_highlight_action_for_key(key_code, modifiers)
-                        == Some("enter_highlight_mode_linewise")
-                    {
-                        if let HighlightState::Characterwise { anchor } = self.highlight_state {
-                            self.highlight_state = HighlightState::Linewise {
-                                anchor_line: anchor.0,
-                            };
-                            self.command_message = "-- LINE HIGHLIGHT --".to_string();
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
-                        }
-                        return Ok(EventOutcome::Ok("".to_string()));
-                    }
-
-                    // Extracting values to avoid borrow conflicts
-                    let mut current_position = form_state.current_position;
-                    let total_count = form_state.total_count;
-
-                    let (_should_exit, message) = read_only::handle_read_only_event(
-                        app_state,
-                        key_event,
-                        config,
-                        form_state,
-                        login_state,
-                        register_state,
-                        &mut admin_state.add_table_state,
-                        &mut admin_state.add_logic_state,
-                        &mut self.key_sequence_tracker,
-                        &mut current_position,
-                        total_count,
-                        grpc_client,
-                        &mut self.command_message,
-                        &mut self.edit_mode_cooldown,
-                        &mut self.ideal_cursor_column,
-                    )
-                    .await?;
-                    return Ok(EventOutcome::Ok(message));
-                }
-
-                AppMode::Edit => {
-                    if let Some(action) = config.get_common_action(key_code, modifiers) {
-                        match action {
-                            "save" | "force_quit" | "save_and_quit" | "revert" => {
-                                return common_mode::handle_core_action(
-                                    action,
-                                    form_state,
-                                    auth_state,
-                                    login_state,
-                                    register_state,
-                                    grpc_client,
-                                    &mut self.auth_client,
-                                    terminal,
-                                    app_state,
-                                )
-                                .await;
-                            }
-                            _ => {}
-                        }
-                    }
-
-                    // Extracting values to avoid borrow conflicts
-                    let mut current_position = form_state.current_position;
-                    let total_count = form_state.total_count;
-
-                    let edit_result = edit::handle_edit_event(
-                        key_event,
-                        config,
-                        form_state,
-                        login_state,
-                        register_state,
-                        admin_state,
-                        &mut self.ideal_cursor_column,
-                        &mut current_position,
-                        total_count,
-                        grpc_client,
-                        app_state,
-                    )
-                    .await;
-
-                    match edit_result {
-                        Ok(edit::EditEventOutcome::ExitEditMode) => {
-                            self.is_edit_mode = false;
-                            self.edit_mode_cooldown = true;
-                            let has_changes = if app_state.ui.show_login {
-                                login_state.has_unsaved_changes()
-                            } else if app_state.ui.show_register {
-                                register_state.has_unsaved_changes()
-                            } else {
-                                form_state.has_unsaved_changes()
-                            };
-                            self.command_message = if has_changes {
-                                "Exited edit mode (unsaved changes remain)".to_string()
-                            } else {
-                                "Read-only mode".to_string()
-                            };
-                            terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
-                            let current_input = if app_state.ui.show_login {
-                                login_state.get_current_input()
-                            } else if app_state.ui.show_register {
-                                register_state.get_current_input()
-                            } else {
-                                form_state.get_current_input()
-                            };
-                            let current_cursor_pos = if app_state.ui.show_login {
-                                login_state.current_cursor_pos()
-                            } else if app_state.ui.show_register {
-                                register_state.current_cursor_pos()
-                            } else {
-                                form_state.current_cursor_pos()
-                            };
-                            if !current_input.is_empty()
-                                && current_cursor_pos >= current_input.len()
-                            {
-                                let new_pos = current_input.len() - 1;
-                                let target_state: &mut dyn CanvasState = if app_state.ui.show_login
-                                {
-                                    login_state
-                                } else if app_state.ui.show_register {
-                                    register_state
-                                } else {
-                                    form_state
-                                };
-                                target_state.set_current_cursor_pos(new_pos);
-                                self.ideal_cursor_column = new_pos;
-                            }
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
-                        }
-                        Ok(edit::EditEventOutcome::Message(msg)) => {
-                            if !msg.is_empty() {
-                                self.command_message = msg;
-                            }
-                            self.key_sequence_tracker.reset();
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
-                        }
-                        Err(e) => {
-                            return Err(e.into());
-                        }
-                    }
-                }
-
-                AppMode::Command => {
-                    if config.is_exit_command_mode(key_code, modifiers) {
-                        self.command_input.clear();
-                        self.command_message.clear();
-                        self.command_mode = false;
-                        self.key_sequence_tracker.reset();
-                        return Ok(EventOutcome::Ok("Exited command mode".to_string()));
-                    }
-
-                    if config.is_command_execute(key_code, modifiers) {
-
-                        // Extracting values to avoid borrow conflicts
-                        let mut current_position = form_state.current_position;
-                        let total_count = form_state.total_count;
-
-                        let outcome = command_mode::handle_command_event(
-                            key_event,
-                            config,
-                            app_state,
-                            login_state,
-                            register_state,
-                            form_state,
-                            &mut self.command_input,
-                            &mut self.command_message,
-                            grpc_client,
-                            command_handler,
-                            terminal,
-                            &mut current_position,
-                            total_count,
-                        )
-                        .await?;
-
-                        // Update form_state with potentially changed position
-                        form_state.current_position = current_position;
-                        
-                        self.command_mode = false;
-                        self.key_sequence_tracker.reset();
-                        let new_mode = ModeManager::derive_mode(app_state, self, admin_state);
-                        app_state.update_mode(new_mode);
-                        return Ok(outcome);
-                    }
-
-                    if key_code == KeyCode::Backspace {
-                        self.command_input.pop();
-                        self.key_sequence_tracker.reset();
-                        return Ok(EventOutcome::Ok(String::new()));
-                    }
-
-                    if let KeyCode::Char(c) = key_code {
-                        if c == 'f' {
-                            // Assuming 'f' is part of the sequence, e.g. ":f" or " f"
-                            self.key_sequence_tracker.add_key(key_code);
-                            let sequence = self.key_sequence_tracker.get_sequence();
-
-                            if config.matches_key_sequence_generalized(&sequence)
-                                == Some("find_file_palette_toggle")
-                            {
-                                if app_state.ui.show_form || app_state.ui.show_intro {
-                                    // Build table graph from profile data
-                                    let graph = TableDependencyGraph::from_profile_tree(
-                                        &app_state.profile_tree,
-                                    );
-
-                                    // Activate navigation with graph
-                                    self.navigation_state.activate_table_tree(graph);
-
-                                    self.command_mode = false; // Exit command mode
-                                    self.command_input.clear();
-                                    // Message is set by render_find_file_palette's prompt_prefix
-                                    self.command_message.clear(); // Clear old command message
-                                    self.key_sequence_tracker.reset();
-                                    // ModeManager will derive AppMode::General due to navigation_state.active
-                                    // app_state.update_mode(AppMode::General); // This will be handled by ModeManager
-                                    return Ok(EventOutcome::Ok(
-                                        "Table tree palette activated".to_string(),
-                                    ));
-                                } else {
-                                    self.key_sequence_tracker.reset();
-                                    self.command_input.push('f');
-                                    if sequence.len() > 1 && sequence[0] == KeyCode::Char('f') {
-                                        self.command_input.push('f');
-                                    }
-                                    self.command_message =
-                                        "Find File not available in this view.".to_string();
-                                    return Ok(EventOutcome::Ok(self.command_message.clone()));
-                                }
-                            }
-
-                            if config.is_key_sequence_prefix(&sequence) {
-                                return Ok(EventOutcome::Ok(String::new()));
-                            }
-                        }
-
-                        if c != 'f' && !self.key_sequence_tracker.current_sequence.is_empty() {
-                            self.key_sequence_tracker.reset();
-                        }
-
-                        self.command_input.push(c);
-                        return Ok(EventOutcome::Ok(String::new()));
-                    }
-
-                    self.key_sequence_tracker.reset();
-                    return Ok(EventOutcome::Ok(String::new()));
-                }
-            }
-        } else if let Event::Resize(_, _) = event {
-            return Ok(EventOutcome::Ok("Resized".to_string()));
-        }
-
-        self.edit_mode_cooldown = false;
-        Ok(EventOutcome::Ok(self.command_message.clone()))
-    }
-
-    fn is_processed_command(&self, command: &str) -> bool {
-        matches!(command, "w" | "q" | "q!" | "wq" | "r")
-    }
-}

client/src/modes/handlers/mode_manager.rs

@@ -1,100 +0,0 @@
-// src/modes/handlers/mode_manager.rs
-use crate::state::app::state::AppState;
-use crate::modes::handlers::event::EventHandler;
-use crate::state::pages::add_logic::AddLogicFocus;
-use crate::state::app::highlight::HighlightState;
-use crate::state::pages::admin::AdminState;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AppMode {
-    General,   // For intro and admin screens
-    ReadOnly,  // Canvas read-only mode
-    Edit,      // Canvas edit mode
-    Highlight, // Cnavas highlight/visual mode
-    Command,   // Command mode overlay
-}
-
-pub struct ModeManager;
-
-impl ModeManager {
-    // Determine current mode based on app state
-    pub fn derive_mode(
-        app_state: &AppState,
-        event_handler: &EventHandler,
-        admin_state: &AdminState,
-    ) -> AppMode {
-        if event_handler.navigation_state.active {
-            return AppMode::General;
-        }
-
-        if event_handler.command_mode {
-            return AppMode::Command;
-        }
-
-        if !matches!(event_handler.highlight_state, HighlightState::Off) {
-            return AppMode::Highlight;
-        }
-
-        let is_canvas_view = app_state.ui.show_login
-            || app_state.ui.show_register
-            || app_state.ui.show_form
-            || app_state.ui.show_add_table
-            || app_state.ui.show_add_logic;
-
-        if app_state.ui.show_add_logic {
-            // Specific logic for AddLogic view
-            match admin_state.add_logic_state.current_focus {
-                AddLogicFocus::InputLogicName
-                | AddLogicFocus::InputTargetColumn
-                | AddLogicFocus::InputDescription => {
-                    // These are canvas inputs
-                    if event_handler.is_edit_mode {
-                        AppMode::Edit
-                    } else {
-                        AppMode::ReadOnly
-                    }
-                }
-                _ => AppMode::General,
-            }
-        } else if app_state.ui.show_add_table {
-            if app_state.ui.focus_outside_canvas {
-                AppMode::General
-            } else {
-                if event_handler.is_edit_mode { 
-                    AppMode::Edit 
-                } else { 
-                    AppMode::ReadOnly 
-                }
-            }
-        } else if is_canvas_view {
-            if app_state.ui.focus_outside_canvas {
-                AppMode::General
-            } else {
-                if event_handler.is_edit_mode {
-                    AppMode::Edit
-                } else {
-                    AppMode::ReadOnly
-                }
-            }
-        } else {
-            AppMode::General
-        }
-    }
-
-    // Mode transition rules
-pub fn can_enter_command_mode(current_mode: AppMode) -> bool {
-        !matches!(current_mode, AppMode::Edit)
-    }
-
-    pub fn can_enter_edit_mode(current_mode: AppMode) -> bool {
-        matches!(current_mode, AppMode::ReadOnly)
-    }
-
-    pub fn can_enter_read_only_mode(current_mode: AppMode) -> bool {
-        matches!(current_mode, AppMode::Edit | AppMode::Command | AppMode::Highlight)
-    }
-
-    pub fn can_enter_highlight_mode(current_mode: AppMode) -> bool {
-        matches!(current_mode, AppMode::ReadOnly)
-    }
-}

client/src/modes/highlight.rs

@@ -1,2 +0,0 @@
-// src/client/modes/highlight.rs
-pub mod highlight;

client/src/modes/highlight/highlight.rs

@@ -1,67 +0,0 @@
-// src/modes/highlight/highlight.rs
-// (This file is intentionally simple for now, reusing ReadOnly logic)
-
-use crate::config::binds::config::Config;
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::services::grpc_client::GrpcClient;
-use crate::state::app::state::AppState;
-use crate::state::pages::auth::{LoginState, RegisterState};
-use crate::state::pages::admin::AdminState;
-use crate::state::pages::form::FormState;
-use crate::modes::handlers::event::EventOutcome;
-use crate::modes::read_only;
-use crossterm::event::KeyEvent;
-use anyhow::Result;
-
-/// Handles events when in Highlight mode.
-/// Currently, it mostly delegates to the read_only handler for movement.
-/// Exiting highlight mode is handled directly in the main event handler.
-pub async fn handle_highlight_event(
-    app_state: &mut AppState,
-    key: KeyEvent,
-    config: &Config,
-    form_state: &mut FormState,
-    login_state: &mut LoginState,
-    register_state: &mut RegisterState,
-    admin_state: &mut AdminState,
-    key_sequence_tracker: &mut KeySequenceTracker,
-    current_position: &mut u64,
-    total_count: u64,
-    grpc_client: &mut GrpcClient,
-    command_message: &mut String,
-    edit_mode_cooldown: &mut bool,
-    ideal_cursor_column: &mut usize,
-) -> Result<EventOutcome> {
-    // Delegate movement and other actions to the read_only handler
-    // The rendering logic will use the highlight_anchor to draw the selection
-    let (should_exit, message) = read_only::handle_read_only_event(
-        app_state,
-        key,
-        config,
-        form_state,
-        login_state,
-        register_state,
-        &mut admin_state.add_table_state,
-        &mut admin_state.add_logic_state,
-        key_sequence_tracker,
-        current_position,
-        total_count,
-        grpc_client,
-        command_message, // Pass the message buffer
-        edit_mode_cooldown,
-        ideal_cursor_column,
-    )
-    .await?;
-
-    // ReadOnly handler doesn't return EventOutcome directly, adapt if needed
-    // For now, assume Ok outcome unless ReadOnly signals an exit (which we ignore here)
-    if should_exit {
-        // This exit is likely for the whole app, let the main loop handle it
-        // We just return the message from read_only
-        Ok(EventOutcome::Ok(message))
-    } else {
-        Ok(EventOutcome::Ok(message))
-    }
-}
-
-

client/src/modes/mod.rs

@@ -1,11 +0,0 @@
-// src/client/modes/mod.rs
-pub mod handlers;
-pub mod canvas;
-pub mod general;
-pub mod common;
-pub mod highlight;
-
-pub use handlers::*;
-pub use canvas::*;
-pub use general::*;
-pub use common::*;

client/src/services/auth.rs

@@ -1,49 +0,0 @@
-// src/services/auth.rs
-use tonic::transport::Channel;
-use common::proto::multieko2::auth::{
-    auth_service_client::AuthServiceClient,
-    LoginRequest, LoginResponse,
-    RegisterRequest, AuthResponse,
-};
-use anyhow::{Context, Result};
-
-#[derive(Clone)]
-pub struct AuthClient {
-    client: AuthServiceClient<Channel>,
-}
-
-impl AuthClient {
-    pub async fn new() -> Result<Self> {
-        let client = AuthServiceClient::connect("http://[::1]:50051")
-            .await
-            .context("Failed to connect to auth service")?;
-        Ok(Self { client })
-    }
-
-    /// Login user via gRPC.
-    pub async fn login(&mut self, identifier: String, password: String) -> Result<LoginResponse> {
-        let request = tonic::Request::new(LoginRequest { identifier, password });
-        let response = self.client.login(request).await?.into_inner();
-        Ok(response)
-    }
-
-    /// Registers a new user via gRPC.
-    pub async fn register(
-        &mut self,
-        username: String,
-        email: String,
-        password: Option<String>,
-        password_confirmation: Option<String>,
-        role: Option<String>,
-    ) -> Result<AuthResponse> {
-        let request = tonic::Request::new(RegisterRequest {
-            username,
-            email,
-            password: password.unwrap_or_default(),
-            password_confirmation: password_confirmation.unwrap_or_default(),
-            role: role.unwrap_or_default(),
-        });
-        let response = self.client.register(request).await?.into_inner();
-        Ok(response)
-    }
-}

client/src/services/grpc_client.rs

@@ -1,200 +0,0 @@
-// src/services/grpc_client.rs
-
-use tonic::transport::Channel;
-use common::proto::multieko2::common::{CountResponse, Empty};
-use common::proto::multieko2::table_structure::table_structure_service_client::TableStructureServiceClient;
-use common::proto::multieko2::table_structure::{GetTableStructureRequest, TableStructureResponse};
-use common::proto::multieko2::table_definition::{
-    table_definition_client::TableDefinitionClient,
-    PostTableDefinitionRequest, ProfileTreeResponse, TableDefinitionResponse,
-};
-use common::proto::multieko2::table_script::{
-    table_script_client::TableScriptClient,
-    PostTableScriptRequest, TableScriptResponse,
-};
-use common::proto::multieko2::tables_data::{
-    tables_data_client::TablesDataClient,
-    GetTableDataByPositionRequest,
-    GetTableDataResponse,
-    GetTableDataCountRequest,
-    PostTableDataRequest, PostTableDataResponse, PutTableDataRequest,
-    PutTableDataResponse,
-};
-use anyhow::{Context, Result}; // Added Context
-use std::collections::HashMap; // NEW
-
-#[derive(Clone)]
-pub struct GrpcClient {
-    table_structure_client: TableStructureServiceClient<Channel>,
-    table_definition_client: TableDefinitionClient<Channel>,
-    table_script_client: TableScriptClient<Channel>,
-    tables_data_client: TablesDataClient<Channel>, // NEW
-}
-
-impl GrpcClient {
-    pub async fn new() -> Result<Self> {
-        let table_structure_client = TableStructureServiceClient::connect(
-            "http://[::1]:50051",
-        )
-        .await
-        .context("Failed to connect to TableStructureService")?;
-        let table_definition_client = TableDefinitionClient::connect(
-            "http://[::1]:50051",
-        )
-        .await
-        .context("Failed to connect to TableDefinitionService")?;
-        let table_script_client =
-            TableScriptClient::connect("http://[::1]:50051")
-                .await
-                .context("Failed to connect to TableScriptService")?;
-        let tables_data_client =
-            TablesDataClient::connect("http://[::1]:50051")
-                .await
-                .context("Failed to connect to TablesDataService")?; // NEW
-
-        Ok(Self {
-            // adresar_client, // REMOVE
-            table_structure_client,
-            table_definition_client,
-            table_script_client,
-            tables_data_client, // NEW
-        })
-    }
-
-    pub async fn get_table_structure(
-        &mut self,
-        profile_name: String,
-        table_name: String,
-    ) -> Result<TableStructureResponse> {
-        let grpc_request = GetTableStructureRequest {
-            profile_name,
-            table_name,
-        };
-        let request = tonic::Request::new(grpc_request);
-        let response = self
-            .table_structure_client
-            .get_table_structure(request)
-            .await
-            .context("gRPC GetTableStructure call failed")?;
-        Ok(response.into_inner())
-    }
-
-    pub async fn get_profile_tree(
-        &mut self,
-    ) -> Result<ProfileTreeResponse> {
-        let request = tonic::Request::new(Empty::default());
-        let response = self
-            .table_definition_client
-            .get_profile_tree(request)
-            .await
-            .context("gRPC GetProfileTree call failed")?;
-        Ok(response.into_inner())
-    }
-
-    pub async fn post_table_definition(
-        &mut self,
-        request: PostTableDefinitionRequest,
-    ) -> Result<TableDefinitionResponse> {
-        let tonic_request = tonic::Request::new(request);
-        let response = self
-            .table_definition_client
-            .post_table_definition(tonic_request)
-            .await
-            .context("gRPC PostTableDefinition call failed")?;
-        Ok(response.into_inner())
-    }
-
-    pub async fn post_table_script(
-        &mut self,
-        request: PostTableScriptRequest,
-    ) -> Result<TableScriptResponse> {
-        let tonic_request = tonic::Request::new(request);
-        let response = self
-            .table_script_client
-            .post_table_script(tonic_request)
-            .await
-            .context("gRPC PostTableScript call failed")?;
-        Ok(response.into_inner())
-    }
-
-    // NEW Methods for TablesData service
-    pub async fn get_table_data_count(
-        &mut self,
-        profile_name: String,
-        table_name: String,
-    ) -> Result<u64> {
-        let grpc_request = GetTableDataCountRequest {
-            profile_name,
-            table_name,
-        };
-        let request = tonic::Request::new(grpc_request);
-        let response = self
-            .tables_data_client
-            .get_table_data_count(request)
-            .await
-            .context("gRPC GetTableDataCount call failed")?;
-        Ok(response.into_inner().count as u64)
-    }
-
-    pub async fn get_table_data_by_position(
-        &mut self,
-        profile_name: String,
-        table_name: String,
-        position: i32,
-    ) -> Result<GetTableDataResponse> {
-        let grpc_request = GetTableDataByPositionRequest {
-            profile_name,
-            table_name,
-            position,
-        };
-        let request = tonic::Request::new(grpc_request);
-        let response = self
-            .tables_data_client
-            .get_table_data_by_position(request)
-            .await
-            .context("gRPC GetTableDataByPosition call failed")?;
-        Ok(response.into_inner())
-    }
-
-    pub async fn post_table_data(
-        &mut self,
-        profile_name: String,
-        table_name: String,
-        data: HashMap<String, String>,
-    ) -> Result<PostTableDataResponse> {
-        let grpc_request = PostTableDataRequest {
-            profile_name,
-            table_name,
-            data,
-        };
-        let request = tonic::Request::new(grpc_request);
-        let response = self
-            .tables_data_client
-            .post_table_data(request)
-            .await
-            .context("gRPC PostTableData call failed")?;
-        Ok(response.into_inner())
-    }
-
-    pub async fn put_table_data(
-        &mut self,
-        profile_name: String,
-        table_name: String,
-        id: i64,
-        data: HashMap<String, String>,
-    ) -> Result<PutTableDataResponse> {
-        let grpc_request = PutTableDataRequest {
-            profile_name,
-            table_name,
-            id,
-            data,
-        };
-        let request = tonic::Request::new(grpc_request);
-        let response = self
-            .tables_data_client
-            .put_table_data(request)
-            .await
-            .context("gRPC PutTableData call failed")?;
-        Ok(response.into_inner())
-    }
-}

client/src/services/mod.rs

@@ -1,9 +0,0 @@
-// services/mod.rs
-
-pub mod grpc_client;
-pub mod auth;
-pub mod ui_service;
-
-pub use grpc_client::*;
-pub use ui_service::*;
-pub use auth::*;

client/src/services/ui_service.rs

@@ -1,265 +0,0 @@
-// src/services/ui_service.rs
-
-use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::form::FormState;
-use crate::tui::functions::common::form::SaveOutcome;
-use crate::state::pages::add_logic::AddLogicState;
-use crate::state::app::state::AppState;
-use anyhow::{Context, Result};
-
-pub struct UiService;
-
-impl UiService {
-    pub async fn initialize_add_logic_table_data(
-        grpc_client: &mut GrpcClient,
-        add_logic_state: &mut AddLogicState,
-        profile_tree: &common::proto::multieko2::table_definition::ProfileTreeResponse,
-    ) -> Result<String> {
-        let profile_name_clone_opt = Some(add_logic_state.profile_name.clone());
-        let table_name_opt_clone = add_logic_state.selected_table_name.clone();
-
-        // Collect table names from SAME profile only
-        let same_profile_table_names: Vec<String> = profile_tree.profiles
-            .iter()
-            .find(|profile| profile.name == add_logic_state.profile_name)
-            .map(|profile| profile.tables.iter().map(|table| table.name.clone()).collect())
-            .unwrap_or_default();
-
-        // Set same profile table names for autocomplete
-        add_logic_state.set_same_profile_table_names(same_profile_table_names.clone());
-
-        if let (Some(profile_name_clone), Some(table_name_clone)) = (profile_name_clone_opt, table_name_opt_clone) {
-            match grpc_client.get_table_structure(profile_name_clone.clone(), table_name_clone.clone()).await {
-                Ok(response) => {
-                    let column_names: Vec<String> = response.columns
-                        .into_iter()
-                        .map(|col| col.name)
-                        .collect();
-
-                    add_logic_state.set_table_columns(column_names.clone());
-
-                    Ok(format!(
-                        "Loaded {} columns for table '{}' and {} tables from profile '{}'",
-                        column_names.len(),
-                        table_name_clone,
-                        same_profile_table_names.len(),
-                        add_logic_state.profile_name
-                    ))
-                }
-                Err(e) => {
-                    tracing::warn!(
-                        "Failed to fetch table structure for {}.{}: {}",
-                        profile_name_clone,
-                        table_name_clone,
-                        e
-                    );
-                    Ok(format!(
-                        "Warning: Could not load table structure for '{}'. Autocomplete will use {} tables from profile '{}'.",
-                        table_name_clone,
-                        same_profile_table_names.len(),
-                        add_logic_state.profile_name
-                    ))
-                }
-            }
-        } else {
-            Ok(format!(
-                "No table selected for Add Logic. Loaded {} tables from profile '{}' for autocomplete.",
-                same_profile_table_names.len(),
-                add_logic_state.profile_name
-            ))
-        }
-    }
-
-    /// Fetches columns for a specific table (used for table.column autocomplete)
-    pub async fn fetch_columns_for_table(
-        grpc_client: &mut GrpcClient,
-        profile_name: &str,
-        table_name: &str,
-    ) -> Result<Vec<String>> {
-        match grpc_client.get_table_structure(profile_name.to_string(), table_name.to_string()).await {
-            Ok(response) => {
-                let column_names: Vec<String> = response.columns
-                    .into_iter()
-                    .map(|col| col.name)
-                    .collect();
-                Ok(column_names)
-            }
-            Err(e) => {
-                tracing::warn!("Failed to fetch columns for {}.{}: {}", profile_name, table_name, e);
-                Err(e.into())
-            }
-        }
-    }
-    
-    // MODIFIED: To set initial view table in AppState and return initial column names
-    pub async fn initialize_app_state_and_form(
-        grpc_client: &mut GrpcClient,
-        app_state: &mut AppState,
-        // Returns (initial_profile, initial_table, initial_columns)
-    ) -> Result<(String, String, Vec<String>)> {
-        let profile_tree = grpc_client
-            .get_profile_tree()
-            .await
-            .context("Failed to get profile tree")?;
-        app_state.profile_tree = profile_tree;
-
-        // Determine initial table to load (e.g., first table of first profile, or a default)
-        // For now, let's hardcode a default for simplicity, but this should be more dynamic
-        let initial_profile_name = app_state
-            .profile_tree
-            .profiles
-            .first()
-            .map(|p| p.name.clone())
-            .unwrap_or_else(|| "default".to_string());
-
-        let initial_table_name = app_state
-            .profile_tree
-            .profiles
-            .first()
-            .and_then(|p| p.tables.first().map(|t| t.name.clone()))
-            .unwrap_or_else(|| "2025_company_data1".to_string()); // Fallback if no tables
-
-        app_state.set_current_view_table(
-            initial_profile_name.clone(),
-            initial_table_name.clone(),
-        );
-
-        let table_structure = grpc_client
-            .get_table_structure(
-                initial_profile_name.clone(),
-                initial_table_name.clone(),
-            )
-            .await
-            .context(format!(
-                "Failed to get initial table structure for {}.{}",
-                initial_profile_name, initial_table_name
-            ))?;
-
-        let column_names: Vec<String> = table_structure
-            .columns
-            .iter()
-            .map(|col| col.name.clone())
-            .collect();
-
-        Ok((initial_profile_name, initial_table_name, column_names))
-    }
-
-    // NEW: Fetches and sets count for the current table in FormState
-    pub async fn fetch_and_set_table_count(
-        grpc_client: &mut GrpcClient,
-        form_state: &mut FormState,
-    ) -> Result<()> {
-        let total_count = grpc_client
-            .get_table_data_count(
-                form_state.profile_name.clone(),
-                form_state.table_name.clone(),
-            )
-            .await
-            .context(format!(
-                "Failed to get count for table {}.{}",
-                form_state.profile_name, form_state.table_name
-            ))?;
-        form_state.total_count = total_count;
-
-        // Set initial position: if table has items, point to first, else point to new entry
-        if total_count > 0 {
-            form_state.current_position = 1;
-        } else {
-            form_state.current_position = 1; // For a new entry in an empty table
-        }
-        Ok(())
-    }
-
-    // MODIFIED: Generic table data loading
-    pub async fn load_table_data_by_position(
-        grpc_client: &mut GrpcClient,
-        form_state: &mut FormState, // Takes &mut FormState to update it
-                                    // position is now read from form_state.current_position
-    ) -> Result<String> {
-        // Ensure current_position is valid before fetching
-        if form_state.current_position == 0 || (form_state.total_count > 0 && form_state.current_position > form_state.total_count) {
-             // This indicates a "new entry" state, no data to load from server.
-             // The caller should handle this by calling form_state.reset_to_empty()
-             // or ensuring this function isn't called for a new entry position.
-             // For now, let's assume reset_to_empty was called if needed.
-            form_state.reset_to_empty(); // Ensure fields are clear for new entry
-            return Ok(format!(
-                "New entry mode for table {}.{}",
-                form_state.profile_name, form_state.table_name
-            ));
-        }
-        if form_state.total_count == 0 && form_state.current_position == 1 {
-            // Table is empty, this is the position for a new entry
-            form_state.reset_to_empty();
-            return Ok(format!(
-                "New entry mode for empty table {}.{}",
-                form_state.profile_name, form_state.table_name
-            ));
-        }
-
-
-        match grpc_client
-            .get_table_data_by_position(
-                form_state.profile_name.clone(),
-                form_state.table_name.clone(),
-                form_state.current_position as i32,
-            )
-            .await
-        {
-            Ok(response) => {
-                form_state.update_from_response(&response.data);
-                // ID, values, current_field, current_cursor_pos, has_unsaved_changes are set by update_from_response
-                Ok(format!(
-                    "Loaded entry {}/{} for table {}.{}",
-                    form_state.current_position,
-                    form_state.total_count,
-                    form_state.profile_name,
-                    form_state.table_name
-                ))
-            }
-            Err(e) => {
-                // If loading fails (e.g., record deleted, network error), what should happen?
-                // Maybe reset to a new entry state or show an error and keep current data.
-                // For now, log error and return error message.
-                tracing::error!(
-                    "Error loading entry {} for table {}.{}: {}",
-                    form_state.current_position,
-                    form_state.profile_name,
-                    form_state.table_name,
-                    e
-                );
-                // Potentially clear form or revert to a safe state
-                // form_state.reset_to_empty();
-                Err(anyhow::anyhow!(
-                    "Error loading entry {}: {}",
-                    form_state.current_position,
-                    e
-                ))
-            }
-        }
-    }
-
-    // MODIFIED: To work with FormState's count and position
-    pub async fn handle_save_outcome(
-        save_outcome: SaveOutcome,
-        _grpc_client: &mut GrpcClient, // May not be needed if count is fetched separately
-        _app_state: &mut AppState,     // May not be needed directly
-        form_state: &mut FormState,
-    ) -> Result<()> {
-        match save_outcome {
-            SaveOutcome::CreatedNew(new_id) => {
-                // form_state.total_count and form_state.current_position should have been updated
-                // by the `save` function itself.
-                // Ensure form_state.id is set.
-                form_state.id = new_id;
-                // Potentially, re-fetch count to be absolutely sure, but save should be authoritative.
-                // UiService::fetch_and_set_table_count(grpc_client, form_state).await?;
-            }
-            SaveOutcome::UpdatedExisting | SaveOutcome::NoChange => {
-                // No changes to total_count or current_position needed from here.
-            }
-        }
-        Ok(())
-    }
-}
-

client/src/state/app.rs

@@ -1,5 +0,0 @@
-// src/state/app.rs
-
-pub mod state;
-pub mod buffer;
-pub mod highlight;

client/src/state/app/buffer.rs

@@ -1,119 +0,0 @@
-// src/state/app/buffer.rs
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum AppView {
-    Intro,
-    Login,
-    Register,
-    Admin,
-    AddTable,
-    AddLogic,
-    Form,
-    Scratch,
-}
-
-impl AppView {
-    /// Returns the display name for the view.
-    /// For Form, pass the current table name to get dynamic naming.
-    pub fn display_name(&self) -> &str {
-        match self {
-            AppView::Intro => "Intro",
-            AppView::Login => "Login",
-            AppView::Register => "Register",
-            AppView::Admin => "Admin_Panel",
-            AppView::AddTable => "Add_Table",
-            AppView::AddLogic => "Add_Logic",
-            AppView::Form => "Form",
-            AppView::Scratch => "*scratch*",
-        }
-    }
-
-    /// Returns the display name with dynamic context (for Form buffers)
-    pub fn display_name_with_context(&self, current_table_name: Option<&str>) -> String {
-        match self {
-            AppView::Form => {
-                current_table_name
-                    .unwrap_or("Data Form")
-                    .to_string()
-            }
-            _ => self.display_name().to_string(),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct BufferState {
-    pub history: Vec<AppView>,
-    pub active_index: usize,
-}
-
-impl Default for BufferState {
-    fn default() -> Self {
-        Self {
-            history: vec![AppView::Intro],
-            active_index: 0,
-        }
-    }
-}
-
-impl BufferState {
-    pub fn update_history(&mut self, view: AppView) {
-        let existing_pos = self.history.iter().position(|v| v == &view);
-        match existing_pos {
-            Some(pos) => self.active_index = pos,
-            None => {
-                self.history.push(view.clone());
-                self.active_index = self.history.len() - 1;
-            }
-        }
-    }
-
-    pub fn get_active_view(&self) -> Option<&AppView> {
-        self.history.get(self.active_index)
-    }
-
-    pub fn close_active_buffer(&mut self) -> bool {
-        if self.history.is_empty() {
-            self.history.push(AppView::Intro);
-            self.active_index = 0;
-            return false;
-        }
-
-        let current_index = self.active_index;
-        self.history.remove(current_index);
-
-        if self.history.is_empty() {
-            self.history.push(AppView::Intro);
-            self.active_index = 0;
-        } else if self.active_index >= self.history.len() {
-            self.active_index = self.history.len() - 1;
-        }
-        true
-    }
-
-    pub fn close_buffer_with_intro_fallback(&mut self, current_table_name: Option<&str>) -> String {
-        let current_view_cloned = self.get_active_view().cloned();
-
-        if let Some(AppView::Intro) = current_view_cloned {
-            if self.history.len() == 1 {
-                self.close_active_buffer();
-                return "Intro buffer reset".to_string();
-            }
-        }
-
-        let closed_name = current_view_cloned
-            .as_ref()
-            .map(|v| v.display_name_with_context(current_table_name))
-            .unwrap_or_else(|| "Unknown".to_string());
-
-        if self.close_active_buffer() {
-            if self.history.len() == 1 && matches!(self.history.get(0), Some(AppView::Intro)) {
-                format!("Closed '{}' - returned to Intro", closed_name)
-            } else {
-                format!("Closed '{}'", closed_name)
-            }
-        } else {
-            format!("Buffer '{}' could not be closed", closed_name)
-        }
-    }
-}

client/src/state/app/highlight.rs

@@ -1,20 +0,0 @@
-// src/state/app/highlight.rs
-
-/// Represents the different states of text highlighting.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum HighlightState {
-    /// Highlighting is inactive.
-    Off,
-    /// Highlighting character by character. Stores the anchor point (line index, char index).
-    Characterwise { anchor: (usize, usize) },
-    /// Highlighting line by line. Stores the anchor line index.
-    Linewise { anchor_line: usize },
-}
-
-impl Default for HighlightState {
-    /// The default state is no highlighting.
-    fn default() -> Self {
-        HighlightState::Off
-    }
-}
-

client/src/state/app/state.rs

@@ -1,197 +0,0 @@
-// src/state/state.rs
-
-use std::env;
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
-use crate::modes::handlers::mode_manager::AppMode;
-use crate::ui::handlers::context::DialogPurpose;
-use anyhow::Result;
-
-pub struct DialogState {
-    pub dialog_show: bool,
-    pub dialog_title: String,
-    pub dialog_message: String,
-    pub dialog_buttons: Vec<String>,
-    pub dialog_active_button_index: usize,
-    pub purpose: Option<DialogPurpose>,
-    pub is_loading: bool,
-}
-
-pub struct UiState {
-    pub show_sidebar: bool,
-    pub show_buffer_list: bool,
-    pub show_intro: bool,
-    pub show_admin: bool,
-    pub show_add_table: bool,
-    pub show_add_logic: bool,
-    pub show_form: bool,
-    pub show_login: bool,
-    pub show_register: bool,
-    pub focus_outside_canvas: bool,
-    pub dialog: DialogState,
-}
-
-pub struct AppState {
-    // Core editor state
-    pub current_dir: String,
-    pub profile_tree: ProfileTreeResponse,
-    pub selected_profile: Option<String>,
-    pub current_mode: AppMode,
-    pub current_view_profile_name: Option<String>,
-    pub current_view_table_name: Option<String>,
-
-    pub focused_button_index: usize,
-    pub pending_table_structure_fetch: Option<(String, String)>,
-
-    // UI preferences
-    pub ui: UiState,
-}
-
-impl AppState {
-    pub fn new() -> Result<Self> {
-        let current_dir = env::current_dir()?
-            .to_string_lossy()
-            .to_string();
-        Ok(AppState {
-            current_dir,
-            profile_tree: ProfileTreeResponse::default(),
-            selected_profile: None,
-            current_view_profile_name: None,
-            current_view_table_name: None,
-            current_mode: AppMode::General,
-            focused_button_index: 0,
-            pending_table_structure_fetch: None,
-            ui: UiState::default(),
-        })
-    }
-
-    pub fn update_mode(&mut self, mode: AppMode) {
-        self.current_mode = mode;
-    }
-    
-    pub fn set_current_view_table(&mut self, profile_name: String, table_name: String) {
-        self.current_view_profile_name = Some(profile_name);
-        self.current_view_table_name = Some(table_name);
-    }
-
-    // Add dialog helper methods
-    /// Shows a dialog with the given title, message, and buttons.
-    /// The first button (index 0) is active by default.
-    pub fn show_dialog(
-        &mut self,
-        title: &str,
-        message: &str,
-        buttons: Vec<String>,
-        purpose: DialogPurpose,
-    ) {
-        self.ui.dialog.dialog_title = title.to_string();
-        self.ui.dialog.dialog_message = message.to_string();
-        self.ui.dialog.dialog_buttons = buttons;
-        self.ui.dialog.dialog_active_button_index = 0;
-        self.ui.dialog.purpose = Some(purpose);
-        self.ui.dialog.is_loading = false;
-        self.ui.dialog.dialog_show = true;
-        self.ui.focus_outside_canvas = true;
-    }
-
-    /// Shows a dialog specifically for loading states.
-    pub fn show_loading_dialog(&mut self, title: &str, message: &str) {
-        self.ui.dialog.dialog_title = title.to_string();
-        self.ui.dialog.dialog_message = message.to_string();
-        self.ui.dialog.dialog_buttons.clear(); // No buttons during loading
-        self.ui.dialog.dialog_active_button_index = 0;
-        self.ui.dialog.purpose = None; // Purpose is set when loading finishes
-        self.ui.dialog.is_loading = true;
-        self.ui.dialog.dialog_show = true;
-        self.ui.focus_outside_canvas = true; // Keep focus management consistent
-    }
-
-    /// Updates the content of an existing dialog, typically after loading.
-    pub fn update_dialog_content(
-        &mut self,
-        message: &str,
-        buttons: Vec<String>,
-        purpose: DialogPurpose,
-    ) {
-        if self.ui.dialog.dialog_show {
-            self.ui.dialog.dialog_message = message.to_string();
-            self.ui.dialog.dialog_buttons = buttons;
-            self.ui.dialog.dialog_active_button_index = 0; // Reset focus
-            self.ui.dialog.purpose = Some(purpose);
-            self.ui.dialog.is_loading = false; // Loading finished
-                                               // Keep dialog_show = true
-                                               // Keep focus_outside_canvas = true
-        }
-    }
-
-
-    /// Hides the dialog and clears its content.
-    pub fn hide_dialog(&mut self) {
-        self.ui.dialog.dialog_show = false;
-        self.ui.dialog.dialog_title.clear();
-        self.ui.dialog.dialog_message.clear();
-        self.ui.dialog.dialog_buttons.clear();
-        self.ui.dialog.dialog_active_button_index = 0;
-        self.ui.dialog.purpose = None;
-        self.ui.focus_outside_canvas = false;
-    }
-
-    /// Sets the active button index, wrapping around if necessary.
-    pub fn next_dialog_button(&mut self) {
-        if !self.ui.dialog.dialog_buttons.is_empty() {
-            let next_index = (self.ui.dialog.dialog_active_button_index + 1)
-                % self.ui.dialog.dialog_buttons.len();
-            self.ui.dialog.dialog_active_button_index = next_index; // Use new name
-        }
-    }
-
-    /// Sets the active button index, wrapping around if necessary.
-    pub fn previous_dialog_button(&mut self) {
-        if !self.ui.dialog.dialog_buttons.is_empty() {
-            let len = self.ui.dialog.dialog_buttons.len();
-            let prev_index =
-                (self.ui.dialog.dialog_active_button_index + len - 1) % len;
-            self.ui.dialog.dialog_active_button_index = prev_index; // Use new name
-        }
-    }
-
-    /// Gets the label of the currently active button, if any.
-    pub fn get_active_dialog_button_label(&self) -> Option<&str> {
-        self.ui.dialog
-            .dialog_buttons // Use new name
-            .get(self.ui.dialog.dialog_active_button_index) // Use new name
-            .map(|s| s.as_str())
-    }
-}
-
-impl Default for UiState {
-    fn default() -> Self {
-        Self {
-            show_sidebar: false,
-            show_intro: true,
-            show_admin: false,
-            show_add_table: false,
-            show_add_logic: false,
-            show_form: false,
-            show_login: false,
-            show_register: false,
-            show_buffer_list: true,
-            focus_outside_canvas: false,
-            dialog: DialogState::default(),
-        }
-    }
-}
-
-// Update the Default implementation for DialogState itself
-impl Default for DialogState {
-    fn default() -> Self {
-        Self {
-            dialog_show: false,
-            dialog_title: String::new(),
-            dialog_message: String::new(),
-            dialog_buttons: Vec::new(),
-            dialog_active_button_index: 0,
-            purpose: None,
-            is_loading: false,
-        }
-    }
-}

client/src/state/mod.rs

@@ -1,3 +0,0 @@
-// src/state/mod.rs
-pub mod app;
-pub mod pages;

client/src/state/pages.rs

@@ -1,9 +0,0 @@
-// src/state/pages.rs
-
-pub mod form;
-pub mod auth;
-pub mod admin;
-pub mod intro;
-pub mod add_table;
-pub mod add_logic;
-pub mod canvas_state;

client/src/state/pages/add_logic.rs

@@ -1,346 +0,0 @@
-// src/state/pages/add_logic.rs
-use crate::config::binds::config::{EditorConfig, EditorKeybindingMode};
-use crate::state::pages::canvas_state::CanvasState;
-use crate::components::common::text_editor::{TextEditor, VimState};
-use std::cell::RefCell;
-use std::rc::Rc;
-use tui_textarea::TextArea;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum AddLogicFocus {
-    #[default]
-    InputLogicName,
-    InputTargetColumn,
-    InputDescription,
-    ScriptContentPreview,
-    InsideScriptContent,
-    SaveButton,
-    CancelButton,
-}
-
-#[derive(Clone, Debug)]
-pub struct AddLogicState {
-    pub profile_name: String,
-    pub selected_table_id: Option<i64>,
-    pub selected_table_name: Option<String>,
-    pub logic_name_input: String,
-    pub target_column_input: String,
-    pub script_content_editor: Rc<RefCell<TextArea<'static>>>,
-    pub description_input: String,
-    pub current_focus: AddLogicFocus,
-    pub last_canvas_field: usize,
-    pub logic_name_cursor_pos: usize,
-    pub target_column_cursor_pos: usize,
-    pub description_cursor_pos: usize,
-    pub has_unsaved_changes: bool,
-    pub editor_keybinding_mode: EditorKeybindingMode,
-    pub vim_state: VimState,
-
-    // New fields for Target Column Autocomplete
-    pub table_columns_for_suggestions: Vec<String>, // All columns for the table
-    pub target_column_suggestions: Vec<String>,     // Filtered suggestions
-    pub show_target_column_suggestions: bool,
-    pub selected_target_column_suggestion_index: Option<usize>,
-    pub in_target_column_suggestion_mode: bool,
-
-    // Script Editor Autocomplete
-    pub script_editor_autocomplete_active: bool,
-    pub script_editor_suggestions: Vec<String>,
-    pub script_editor_selected_suggestion_index: Option<usize>,
-    pub script_editor_trigger_position: Option<(usize, usize)>, // (line, column)
-    pub all_table_names: Vec<String>,
-    pub script_editor_filter_text: String,
-    
-    // New fields for same-profile table names and column autocomplete
-    pub same_profile_table_names: Vec<String>, // Tables from same profile only
-    pub script_editor_awaiting_column_autocomplete: Option<String>, // Table name waiting for column fetch
-}
-
-impl AddLogicState {
-    pub fn new(editor_config: &EditorConfig) -> Self {
-        let editor = TextEditor::new_textarea(editor_config);
-        AddLogicState {
-            profile_name: "default".to_string(),
-            selected_table_id: None,
-            selected_table_name: None,
-            logic_name_input: String::new(),
-            target_column_input: String::new(),
-            script_content_editor: Rc::new(RefCell::new(editor)),
-            description_input: String::new(),
-            current_focus: AddLogicFocus::InputLogicName,
-            last_canvas_field: 2,
-            logic_name_cursor_pos: 0,
-            target_column_cursor_pos: 0,
-            description_cursor_pos: 0,
-            has_unsaved_changes: false,
-            editor_keybinding_mode: editor_config.keybinding_mode.clone(),
-            vim_state: VimState::default(),
-
-            table_columns_for_suggestions: Vec::new(),
-            target_column_suggestions: Vec::new(),
-            show_target_column_suggestions: false,
-            selected_target_column_suggestion_index: None,
-            in_target_column_suggestion_mode: false,
-
-            script_editor_autocomplete_active: false,
-            script_editor_suggestions: Vec::new(),
-            script_editor_selected_suggestion_index: None,
-            script_editor_trigger_position: None,
-            all_table_names: Vec::new(),
-            script_editor_filter_text: String::new(),
-            
-            same_profile_table_names: Vec::new(),
-            script_editor_awaiting_column_autocomplete: None,
-        }
-    }
-
-    pub const INPUT_FIELD_COUNT: usize = 3;
-
-    /// Updates the target_column_suggestions based on current input.
-    pub fn update_target_column_suggestions(&mut self) {
-        let current_input = self.target_column_input.to_lowercase();
-        if self.table_columns_for_suggestions.is_empty() {
-            self.target_column_suggestions.clear();
-            self.show_target_column_suggestions = false;
-            self.selected_target_column_suggestion_index = None;
-            return;
-        }
-
-        if current_input.is_empty() {
-            self.target_column_suggestions = self.table_columns_for_suggestions.clone();
-        } else {
-            self.target_column_suggestions = self
-                .table_columns_for_suggestions
-                .iter()
-                .filter(|name| name.to_lowercase().contains(&current_input))
-                .cloned()
-                .collect();
-        }
-
-        self.show_target_column_suggestions = !self.target_column_suggestions.is_empty();
-        if self.show_target_column_suggestions {
-            if let Some(selected_idx) = self.selected_target_column_suggestion_index {
-                if selected_idx >= self.target_column_suggestions.len() {
-                    self.selected_target_column_suggestion_index = Some(0);
-                }
-            } else {
-                self.selected_target_column_suggestion_index = Some(0);
-            }
-        } else {
-            self.selected_target_column_suggestion_index = None;
-        }
-    }
-
-    /// Updates script editor suggestions based on current filter text
-    pub fn update_script_editor_suggestions(&mut self) {
-        let mut suggestions = vec!["sql".to_string()];
-
-        if self.selected_table_name.is_some() {
-            suggestions.extend(self.table_columns_for_suggestions.clone());
-        }
-
-        let current_selected_table_name = self.selected_table_name.as_deref();
-        suggestions.extend(
-            self.same_profile_table_names
-                .iter()
-                .filter(|tn| Some(tn.as_str()) != current_selected_table_name)
-                .cloned()
-        );
-
-        if self.script_editor_filter_text.is_empty() {
-            self.script_editor_suggestions = suggestions;
-        } else {
-            let filter_lower = self.script_editor_filter_text.to_lowercase();
-            self.script_editor_suggestions = suggestions
-                .into_iter()
-                .filter(|suggestion| suggestion.to_lowercase().contains(&filter_lower))
-                .collect();
-        }
-
-        // Update selection index
-        if self.script_editor_suggestions.is_empty() {
-            self.script_editor_selected_suggestion_index = None;
-            self.script_editor_autocomplete_active = false;
-        } else if let Some(selected_idx) = self.script_editor_selected_suggestion_index {
-            if selected_idx >= self.script_editor_suggestions.len() {
-                self.script_editor_selected_suggestion_index = Some(0);
-            }
-        } else {
-            self.script_editor_selected_suggestion_index = Some(0);
-        }
-    }
-
-    /// Checks if a suggestion is a table name (for triggering column autocomplete)
-    pub fn is_table_name_suggestion(&self, suggestion: &str) -> bool {
-        // Not "sql"
-        if suggestion == "sql" {
-            return false;
-        }
-        if self.table_columns_for_suggestions.contains(&suggestion.to_string()) {
-            return false;
-        }
-        self.same_profile_table_names.contains(&suggestion.to_string())
-    }
-    
-    /// Sets table columns for autocomplete suggestions
-    pub fn set_table_columns(&mut self, columns: Vec<String>) {
-        self.table_columns_for_suggestions = columns.clone();
-        if !columns.is_empty() {
-            self.update_target_column_suggestions();
-        }
-    }
-
-    /// Sets all available table names for autocomplete suggestions
-    pub fn set_all_table_names(&mut self, table_names: Vec<String>) {
-        self.all_table_names = table_names;
-    }
-
-    /// Sets table names from the same profile for autocomplete suggestions
-    pub fn set_same_profile_table_names(&mut self, table_names: Vec<String>) {
-        self.same_profile_table_names = table_names;
-    }
-
-    /// Triggers waiting for column autocomplete for a specific table
-    pub fn trigger_column_autocomplete_for_table(&mut self, table_name: String) {
-        self.script_editor_awaiting_column_autocomplete = Some(table_name);
-    }
-
-    /// Updates autocomplete with columns for a specific table
-    pub fn set_columns_for_table_autocomplete(&mut self, columns: Vec<String>) {
-        self.script_editor_suggestions = columns;
-        self.script_editor_selected_suggestion_index = if self.script_editor_suggestions.is_empty() {
-            None
-        } else {
-            Some(0)
-        };
-        self.script_editor_autocomplete_active = !self.script_editor_suggestions.is_empty();
-        self.script_editor_awaiting_column_autocomplete = None;
-    }
-
-    /// Deactivates script editor autocomplete and clears related state
-    pub fn deactivate_script_editor_autocomplete(&mut self) {
-        self.script_editor_autocomplete_active = false;
-        self.script_editor_suggestions.clear();
-        self.script_editor_selected_suggestion_index = None;
-        self.script_editor_trigger_position = None;
-        self.script_editor_filter_text.clear();
-    }
-}
-
-impl Default for AddLogicState {
-    fn default() -> Self {
-        Self::new(&EditorConfig::default())
-    }
-}
-
-impl CanvasState for AddLogicState {
-    fn current_field(&self) -> usize {
-        match self.current_focus {
-            AddLogicFocus::InputLogicName => 0,
-            AddLogicFocus::InputTargetColumn => 1,
-            AddLogicFocus::InputDescription => 2,
-            _ => self.last_canvas_field,
-        }
-    }
-
-    fn current_cursor_pos(&self) -> usize {
-        match self.current_focus {
-            AddLogicFocus::InputLogicName => self.logic_name_cursor_pos,
-            AddLogicFocus::InputTargetColumn => self.target_column_cursor_pos,
-            AddLogicFocus::InputDescription => self.description_cursor_pos,
-            _ => 0,
-        }
-    }
-
-    fn has_unsaved_changes(&self) -> bool {
-        self.has_unsaved_changes
-    }
-
-    fn inputs(&self) -> Vec<&String> {
-        vec![
-            &self.logic_name_input,
-            &self.target_column_input,
-            &self.description_input,
-        ]
-    }
-
-    fn get_current_input(&self) -> &str {
-        match self.current_focus {
-            AddLogicFocus::InputLogicName => &self.logic_name_input,
-            AddLogicFocus::InputTargetColumn => &self.target_column_input,
-            AddLogicFocus::InputDescription => &self.description_input,
-            _ => "",
-        }
-    }
-
-    fn get_current_input_mut(&mut self) -> &mut String {
-        match self.current_focus {
-            AddLogicFocus::InputLogicName => &mut self.logic_name_input,
-            AddLogicFocus::InputTargetColumn => &mut self.target_column_input,
-            AddLogicFocus::InputDescription => &mut self.description_input,
-            _ => &mut self.logic_name_input,
-        }
-    }
-
-    fn fields(&self) -> Vec<&str> {
-        vec!["Logic Name", "Target Column", "Description"]
-    }
-
-    fn set_current_field(&mut self, index: usize) {
-        let new_focus = match index {
-            0 => AddLogicFocus::InputLogicName,
-            1 => AddLogicFocus::InputTargetColumn,
-            2 => AddLogicFocus::InputDescription,
-            _ => return,
-        };
-        if self.current_focus != new_focus {
-            if self.current_focus == AddLogicFocus::InputTargetColumn {
-                self.in_target_column_suggestion_mode = false;
-                self.show_target_column_suggestions = false;
-            }
-            self.current_focus = new_focus;
-            self.last_canvas_field = index;
-        }
-    }
-
-    fn set_current_cursor_pos(&mut self, pos: usize) {
-        match self.current_focus {
-            AddLogicFocus::InputLogicName => {
-                self.logic_name_cursor_pos = pos.min(self.logic_name_input.len());
-            }
-            AddLogicFocus::InputTargetColumn => {
-                self.target_column_cursor_pos = pos.min(self.target_column_input.len());
-            }
-            AddLogicFocus::InputDescription => {
-                self.description_cursor_pos = pos.min(self.description_input.len());
-            }
-            _ => {}
-        }
-    }
-
-    fn set_has_unsaved_changes(&mut self, changed: bool) {
-        self.has_unsaved_changes = changed;
-    }
-
-    fn get_suggestions(&self) -> Option<&[String]> {
-        if self.current_field() == 1
-            && self.in_target_column_suggestion_mode
-            && self.show_target_column_suggestions
-        {
-            Some(&self.target_column_suggestions)
-        } else {
-            None
-        }
-    }
-
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        if self.current_field() == 1
-            && self.in_target_column_suggestion_mode
-            && self.show_target_column_suggestions
-        {
-            self.selected_target_column_suggestion_index
-        } else {
-            None
-        }
-    }
-}

client/src/state/pages/add_table.rs

@@ -1,190 +0,0 @@
-// src/state/pages/add_table.rs
-use crate::state::pages::canvas_state::CanvasState;
-use ratatui::widgets::TableState;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ColumnDefinition {
-    pub name: String,
-    pub data_type: String,
-    pub selected: bool,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct IndexDefinition {
-    pub name: String,
-    pub selected: bool,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct LinkDefinition {
-    pub linked_table_name: String,
-    pub is_required: bool,
-    pub selected: bool,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum AddTableFocus {
-    #[default]
-    InputTableName, // Field 0 for CanvasState
-    InputColumnName, // Field 1 for CanvasState
-    InputColumnType, // Field 2 for CanvasState
-    AddColumnButton,
-    // Result Tables
-    ColumnsTable,
-    IndexesTable,
-    LinksTable,
-    // Inside Tables (Scrolling Focus)
-    InsideColumnsTable,
-    InsideIndexesTable,
-    InsideLinksTable,
-    // Buttons
-    SaveButton,
-    DeleteSelectedButton,
-    CancelButton,
-}
-
-#[derive(Debug, Clone)]
-pub struct AddTableState {
-    pub profile_name: String,
-    pub table_name: String,
-    pub table_name_input: String,
-    pub column_name_input: String,
-    pub column_type_input: String,
-    pub columns: Vec<ColumnDefinition>,
-    pub indexes: Vec<IndexDefinition>,
-    pub links: Vec<LinkDefinition>,
-    pub current_focus: AddTableFocus,
-    pub last_canvas_field: usize,
-    pub column_table_state: TableState,
-    pub index_table_state: TableState,
-    pub link_table_state: TableState,
-    pub table_name_cursor_pos: usize,
-    pub column_name_cursor_pos: usize,
-    pub column_type_cursor_pos: usize,
-    pub has_unsaved_changes: bool,
-}
-
-impl Default for AddTableState {
-    fn default() -> Self {
-        // Initialize with some dummy data for demonstration
-        AddTableState {
-            profile_name: "default".to_string(),
-            table_name: String::new(),
-            table_name_input: String::new(),
-            column_name_input: String::new(),
-            column_type_input: String::new(),
-            columns: Vec::new(),
-            indexes: Vec::new(),
-            links: Vec::new(),
-            current_focus: AddTableFocus::InputTableName,
-            last_canvas_field: 2,
-            column_table_state: TableState::default(),
-            index_table_state: TableState::default(),
-            link_table_state: TableState::default(),
-            table_name_cursor_pos: 0,
-            column_name_cursor_pos: 0,
-            column_type_cursor_pos: 0,
-            has_unsaved_changes: false,
-        }
-    }
-}
-
-impl AddTableState {
-    pub const INPUT_FIELD_COUNT: usize = 3;
-}
-
-// Implement CanvasState for the input fields
-impl CanvasState for AddTableState {
-    fn current_field(&self) -> usize {
-        match self.current_focus {
-            AddTableFocus::InputTableName => 0,
-            AddTableFocus::InputColumnName => 1,
-            AddTableFocus::InputColumnType => 2,
-            // If focus is elsewhere, default to the first field for canvas rendering logic
-            _ => self.last_canvas_field,
-        }
-    }
-
-    fn current_cursor_pos(&self) -> usize {
-        match self.current_focus {
-            AddTableFocus::InputTableName => self.table_name_cursor_pos,
-            AddTableFocus::InputColumnName => self.column_name_cursor_pos,
-            AddTableFocus::InputColumnType => self.column_type_cursor_pos,
-            _ => 0, // Default if focus is not on an input field
-        }
-    }
-
-    fn has_unsaved_changes(&self) -> bool {
-        self.has_unsaved_changes
-    }
-
-    fn inputs(&self) -> Vec<&String> {
-        vec![&self.table_name_input, &self.column_name_input, &self.column_type_input]
-    }
-
-    fn get_current_input(&self) -> &str {
-        match self.current_focus {
-            AddTableFocus::InputTableName => &self.table_name_input,
-            AddTableFocus::InputColumnName => &self.column_name_input,
-            AddTableFocus::InputColumnType => &self.column_type_input,
-            _ => "", // Should not happen if called correctly
-        }
-    }
-
-    fn get_current_input_mut(&mut self) -> &mut String {
-        match self.current_focus {
-            AddTableFocus::InputTableName => &mut self.table_name_input,
-            AddTableFocus::InputColumnName => &mut self.column_name_input,
-            AddTableFocus::InputColumnType => &mut self.column_type_input,
-            _ => &mut self.table_name_input,
-        }
-    }
-
-    fn fields(&self) -> Vec<&str> {
-        // These must match the order used in render_add_table
-        vec!["Table name", "Name", "Type"]
-    }
-
-    fn set_current_field(&mut self, index: usize) {
-        // Update both current focus and last canvas field
-        self.current_focus = match index {
-            0 => {
-                self.last_canvas_field = 0;
-                AddTableFocus::InputTableName
-            },
-            1 => {
-                self.last_canvas_field = 1;
-                AddTableFocus::InputColumnName
-            },
-            2 => {
-                self.last_canvas_field = 2;
-                AddTableFocus::InputColumnType
-            },
-            _ => self.current_focus, // Stay on current focus if index is out of bounds
-        };
-    }
-
-    fn set_current_cursor_pos(&mut self, pos: usize) {
-        match self.current_focus {
-            AddTableFocus::InputTableName => self.table_name_cursor_pos = pos,
-            AddTableFocus::InputColumnName => self.column_name_cursor_pos = pos,
-            AddTableFocus::InputColumnType => self.column_type_cursor_pos = pos,
-            _ => {} // Do nothing if focus is not on an input field
-        }
-    }
-
-    fn set_has_unsaved_changes(&mut self, changed: bool) {
-        self.has_unsaved_changes = changed;
-    }
-
-    // --- Autocomplete Support (Not needed for this form yet) ---
-    fn get_suggestions(&self) -> Option<&[String]> {
-        None
-    }
-
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        None
-    }
-}
-

client/src/state/pages/admin.rs

@@ -1,182 +0,0 @@
-// src/state/pages/admin.rs
-
-use ratatui::widgets::ListState;
-use crate::state::pages::add_table::AddTableState;
-use crate::state::pages::add_logic::AddLogicState;
-
-// Define the focus states for the admin panel panes
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum AdminFocus {
-    #[default] // Default focus is on the profiles list
-    ProfilesPane,
-    InsideProfilesList,
-    Tables,
-    InsideTablesList,
-    Button1,
-    Button2,
-    Button3,
-}
-
-#[derive(Default, Clone, Debug)]
-pub struct AdminState {
-    pub profiles: Vec<String>, // Holds profile names (used by non-admin view)
-    pub profile_list_state: ListState, // Tracks navigation highlight (>) in profiles
-    pub table_list_state: ListState,   // Tracks navigation highlight (>) in tables
-    pub selected_profile_index: Option<usize>, // Index with [*] in profiles (persistent)
-    pub selected_table_index: Option<usize>,   // Index with [*] in tables (persistent)
-    pub current_focus: AdminFocus,     // Tracks which pane is focused
-    pub add_table_state: AddTableState,
-    pub add_logic_state: AddLogicState,
-}
-
-impl AdminState {
-    /// Gets the index of the currently selected item.
-    pub fn get_selected_index(&self) -> Option<usize> {
-        self.profile_list_state.selected()
-    }
-
-    /// Gets the name of the currently selected profile.
-    pub fn get_selected_profile_name(&self) -> Option<&String> {
-        self.profile_list_state.selected().and_then(|i| self.profiles.get(i))
-    }
-
-    /// Populates the profile list and updates/resets the selection.
-    pub fn set_profiles(&mut self, new_profiles: Vec<String>) {
-        let current_selection_index = self.profile_list_state.selected();
-        self.profiles = new_profiles;
-
-        if self.profiles.is_empty() {
-            self.profile_list_state.select(None);
-        } else {
-            let new_selection = match current_selection_index {
-                Some(index) => Some(index.min(self.profiles.len() - 1)),
-                None => Some(0),
-            };
-            self.profile_list_state.select(new_selection);
-        }
-    }
-
-    /// Selects the next profile in the list, wrapping around.
-    pub fn next(&mut self) {
-        if self.profiles.is_empty() {
-            self.profile_list_state.select(None);
-            return;
-        }
-        let i = match self.profile_list_state.selected() {
-            Some(i) => if i >= self.profiles.len() - 1 { 0 } else { i + 1 },
-            None => 0,
-        };
-        self.profile_list_state.select(Some(i));
-    }
-
-    /// Selects the previous profile in the list, wrapping around.
-    pub fn previous(&mut self) {
-        if self.profiles.is_empty() {
-            self.profile_list_state.select(None);
-            return;
-        }
-        let i = match self.profile_list_state.selected() {
-            Some(i) => if i == 0 { self.profiles.len() - 1 } else { i - 1 },
-            None => self.profiles.len() - 1,
-        };
-        self.profile_list_state.select(Some(i));
-    }
-
-    /// Gets the index of the currently selected profile.
-    pub fn get_selected_profile_index(&self) -> Option<usize> {
-        self.profile_list_state.selected()
-    }
-
-    /// Gets the index of the currently selected table.
-    pub fn get_selected_table_index(&self) -> Option<usize> {
-        self.table_list_state.selected()
-    }
-
-    /// Selects a profile by index and resets table selection.
-    pub fn select_profile(&mut self, index: Option<usize>) {
-        self.profile_list_state.select(index);
-        self.table_list_state.select(None);
-    }
-
-    /// Selects a table by index.
-    pub fn select_table(&mut self, index: Option<usize>) {
-        self.table_list_state.select(index);
-    }
-
-    /// Selects the next profile, wrapping around.
-    /// `profile_count` should be the total number of profiles available.
-    pub fn next_profile(&mut self, profile_count: usize) {
-        if profile_count == 0 {
-            return;
-        }
-        let i = match self.get_selected_profile_index() {
-            Some(i) => {
-                if i >= profile_count - 1 {
-                    0
-                } else {
-                    i + 1
-                }
-            }
-            None => 0,
-        };
-        self.select_profile(Some(i)); // Use the helper method
-    }
-
-    /// Selects the previous profile, wrapping around.
-    /// `profile_count` should be the total number of profiles available.
-    pub fn previous_profile(&mut self, profile_count: usize) {
-        if profile_count == 0 {
-            return;
-        }
-        let i = match self.get_selected_profile_index() {
-            Some(i) => {
-                if i == 0 {
-                    profile_count - 1
-                } else {
-                    i - 1
-                }
-            }
-            None => 0, // Or profile_count - 1 if you prefer wrapping from None
-        };
-        self.select_profile(Some(i)); // Use the helper method
-    }
-
-    /// Selects the next table, wrapping around.
-    /// `table_count` should be the number of tables in the *currently selected* profile.
-    pub fn next_table(&mut self, table_count: usize) {
-        if table_count == 0 {
-            return;
-        }
-        let i = match self.get_selected_table_index() {
-            Some(i) => {
-                if i >= table_count - 1 {
-                    0
-                } else {
-                    i + 1
-                }
-            }
-            None => 0,
-        };
-        self.select_table(Some(i));
-    }
-
-    /// Selects the previous table, wrapping around.
-    /// `table_count` should be the number of tables in the *currently selected* profile.
-    pub fn previous_table(&mut self, table_count: usize) {
-        if table_count == 0 {
-            return;
-        }
-        let i = match self.get_selected_table_index() {
-            Some(i) => {
-                if i == 0 {
-                    table_count - 1
-                } else {
-                    i - 1
-                }
-            }
-            None => 0, // Or table_count - 1
-        };
-        self.select_table(Some(i));
-    }
-}
-

client/src/state/pages/auth.rs

@@ -1,297 +0,0 @@
-// src/state/pages/auth.rs
-use crate::state::pages::canvas_state::CanvasState;
-use lazy_static::lazy_static;
-
-lazy_static! {
-    pub static ref AVAILABLE_ROLES: Vec<String> = vec![
-        "admin".to_string(),
-        "moderator".to_string(),
-        "accountant".to_string(),
-        "viewer".to_string(),
-    ];
-}
-
-/// Represents the authenticated session state
-#[derive(Default)]
-pub struct AuthState {
-    pub auth_token: Option<String>,
-    pub user_id: Option<String>,
-    pub role: Option<String>,
-    pub decoded_username: Option<String>,
-}
-
-/// Represents the state of the Login form UI
-#[derive(Default)]
-pub struct LoginState {
-    pub username: String,
-    pub password: String,
-    pub error_message: Option<String>,
-    pub current_field: usize,
-    pub current_cursor_pos: usize,
-    pub has_unsaved_changes: bool,
-    pub login_request_pending: bool,
-}
-
-/// Represents the state of the Registration form UI
-#[derive(Default, Clone)]
-pub struct RegisterState {
-    pub username: String,
-    pub email: String,
-    pub password: String,
-    pub password_confirmation: String,
-    pub role: String,
-    pub error_message: Option<String>,
-    pub current_field: usize,
-    pub current_cursor_pos: usize,
-    pub has_unsaved_changes: bool,
-    pub show_role_suggestions: bool,
-    pub role_suggestions: Vec<String>,
-    pub selected_suggestion_index: Option<usize>,
-    pub in_suggestion_mode: bool,
-}
-
-impl AuthState {
-    /// Creates a new empty AuthState (unauthenticated)
-    pub fn new() -> Self {
-        Self {
-            auth_token: None,
-            user_id: None,
-            role: None,
-            decoded_username: None,
-        }
-    }
-}
-
-impl LoginState {
-    /// Creates a new empty LoginState
-    pub fn new() -> Self {
-        Self {
-            username: String::new(),
-            password: String::new(),
-            error_message: None,
-            current_field: 0,
-            current_cursor_pos: 0,
-            has_unsaved_changes: false,
-            login_request_pending: false,
-        }
-    }
-}
-
-impl RegisterState {
-    /// Creates a new empty RegisterState
-    pub fn new() -> Self {
-        Self {
-            username: String::new(),
-            email: String::new(),
-            password: String::new(),
-            password_confirmation: String::new(),
-            role: String::new(),
-            error_message: None,
-            current_field: 0,
-            current_cursor_pos: 0,
-            has_unsaved_changes: false,
-            show_role_suggestions: false,
-            role_suggestions: Vec::new(),
-            selected_suggestion_index: None,
-            in_suggestion_mode: false,
-        }
-    }
-
-    /// Updates role suggestions based on current input
-    pub fn update_role_suggestions(&mut self) {
-        let current_input = self.role.to_lowercase();
-        self.role_suggestions = AVAILABLE_ROLES
-            .iter()
-            .filter(|role| role.to_lowercase().contains(&current_input))
-            .cloned()
-            .collect();
-        self.show_role_suggestions = !self.role_suggestions.is_empty();
-    }
-}
-
-impl CanvasState for LoginState {
-    fn current_field(&self) -> usize {
-        self.current_field
-    }
-
-    fn current_cursor_pos(&self) -> usize {
-        let len = match self.current_field {
-            0 => self.username.len(),
-            1 => self.password.len(),
-            _ => 0,
-        };
-        self.current_cursor_pos.min(len)
-    }
-
-    fn has_unsaved_changes(&self) -> bool {
-        self.has_unsaved_changes
-    }
-
-    fn inputs(&self) -> Vec<&String> {
-        vec![&self.username, &self.password]
-    }
-
-    fn get_current_input(&self) -> &str {
-        match self.current_field {
-            0 => &self.username,
-            1 => &self.password,
-            _ => "",
-        }
-    }
-
-    fn get_current_input_mut(&mut self) -> &mut String {
-        match self.current_field {
-            0 => &mut self.username,
-            1 => &mut self.password,
-            _ => panic!("Invalid current_field index in LoginState"),
-        }
-    }
-
-    fn fields(&self) -> Vec<&str> {
-        vec!["Username/Email", "Password"]
-    }
-
-    fn set_current_field(&mut self, index: usize) {
-        if index < 2 {
-            self.current_field = index;
-            let len = match self.current_field {
-                0 => self.username.len(),
-                1 => self.password.len(),
-                _ => 0,
-            };
-            self.current_cursor_pos = self.current_cursor_pos.min(len);
-        }
-    }
-
-    fn set_current_cursor_pos(&mut self, pos: usize) {
-        let len = match self.current_field {
-            0 => self.username.len(),
-            1 => self.password.len(),
-            _ => 0,
-        };
-        self.current_cursor_pos = pos.min(len);
-    }
-
-    fn set_has_unsaved_changes(&mut self, changed: bool) {
-        self.has_unsaved_changes = changed;
-    }
-
-    fn get_suggestions(&self) -> Option<&[String]> {
-        None
-    }
-
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        None
-    }
-}
-
-impl CanvasState for RegisterState {
-    fn current_field(&self) -> usize {
-        self.current_field
-    }
-
-    fn current_cursor_pos(&self) -> usize {
-        let len = match self.current_field {
-            0 => self.username.len(),
-            1 => self.email.len(),
-            2 => self.password.len(),
-            3 => self.password_confirmation.len(),
-            4 => self.role.len(),
-            _ => 0,
-        };
-        self.current_cursor_pos.min(len)
-    }
-
-    fn has_unsaved_changes(&self) -> bool {
-        self.has_unsaved_changes
-    }
-
-    fn inputs(&self) -> Vec<&String> {
-        vec![
-            &self.username,
-            &self.email,
-            &self.password,
-            &self.password_confirmation,
-            &self.role,
-        ]
-    }
-
-    fn get_current_input(&self) -> &str {
-        match self.current_field {
-            0 => &self.username,
-            1 => &self.email,
-            2 => &self.password,
-            3 => &self.password_confirmation,
-            4 => &self.role,
-            _ => "",
-        }
-    }
-
-    fn get_current_input_mut(&mut self) -> &mut String {
-        match self.current_field {
-            0 => &mut self.username,
-            1 => &mut self.email,
-            2 => &mut self.password,
-            3 => &mut self.password_confirmation,
-            4 => &mut self.role,
-            _ => panic!("Invalid current_field index in RegisterState"),
-        }
-    }
-
-    fn fields(&self) -> Vec<&str> {
-        vec![
-            "Username",
-            "Email (Optional)",
-            "Password (Optional)",
-            "Confirm Password",
-            "Role (Optional)"
-        ]
-    }
-
-    fn set_current_field(&mut self, index: usize) {
-        if index < 5 {
-            self.current_field = index;
-            let len = match self.current_field {
-                0 => self.username.len(),
-                1 => self.email.len(),
-                2 => self.password.len(),
-                3 => self.password_confirmation.len(),
-                4 => self.role.len(),
-                _ => 0,
-            };
-            self.current_cursor_pos = self.current_cursor_pos.min(len);
-        }
-    }
-
-    fn set_current_cursor_pos(&mut self, pos: usize) {
-        let len = match self.current_field {
-            0 => self.username.len(),
-            1 => self.email.len(),
-            2 => self.password.len(),
-            3 => self.password_confirmation.len(),
-            4 => self.role.len(),
-            _ => 0,
-        };
-        self.current_cursor_pos = pos.min(len);
-    }
-
-    fn set_has_unsaved_changes(&mut self, changed: bool) {
-        self.has_unsaved_changes = changed;
-    }
-
-    fn get_suggestions(&self) -> Option<&[String]> {
-        if self.current_field == 4 && self.in_suggestion_mode && self.show_role_suggestions {
-            Some(&self.role_suggestions)
-        } else {
-            None
-        }
-    }
-
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        if self.current_field == 4 && self.in_suggestion_mode && self.show_role_suggestions {
-            self.selected_suggestion_index
-        } else {
-            None
-        }
-    }
-}

client/src/state/pages/canvas_state.rs

@@ -1,20 +0,0 @@
-// src/state/canvas_state.rs
-
-
-pub trait CanvasState {
-    fn current_field(&self) -> usize;
-    fn current_cursor_pos(&self) -> usize;
-    fn has_unsaved_changes(&self) -> bool;
-    fn inputs(&self) -> Vec<&String>;
-    fn get_current_input(&self) -> &str;
-    fn get_current_input_mut(&mut self) -> &mut String;
-    fn fields(&self) -> Vec<&str>;
-
-    fn set_current_field(&mut self, index: usize);
-    fn set_current_cursor_pos(&mut self, pos: usize);
-    fn set_has_unsaved_changes(&mut self, changed: bool);
-
-    // --- Autocomplete Support ---
-    fn get_suggestions(&self) -> Option<&[String]>;
-    fn get_selected_suggestion_index(&self) -> Option<usize>;
-}

client/src/state/pages/form.rs

@@ -1,197 +0,0 @@
-// src/state/pages/form.rs
-
-use std::collections::HashMap; // NEW
-use crate::config::colors::themes::Theme;
-use ratatui::layout::Rect;
-use ratatui::Frame;
-use crate::state::app::highlight::HighlightState;
-use crate::state::pages::canvas_state::CanvasState;
-
-pub struct FormState {
-    pub id: i64,
-    // NEW fields for dynamic table context
-    pub profile_name: String,
-    pub table_name: String,
-    pub total_count: u64,
-    pub current_position: u64, // 1-based index, 0 or total_count + 1 for new entry
-
-    pub fields: Vec<String>, // Already dynamic, which is good
-    pub values: Vec<String>,
-    pub current_field: usize,
-    pub has_unsaved_changes: bool,
-    pub current_cursor_pos: usize,
-}
-
-impl FormState {
-    // MODIFIED constructor
-    pub fn new(
-        profile_name: String,
-        table_name: String,
-        fields: Vec<String>,
-    ) -> Self {
-        let values = vec![String::new(); fields.len()];
-        FormState {
-            id: 0, // Default to 0, indicating a new or unloaded record
-            profile_name,
-            table_name,
-            total_count: 0,    // Will be fetched after initialization
-            current_position: 0, // Will be set after count is fetched (e.g., 1 or total_count + 1)
-            fields,
-            values,
-            current_field: 0,
-            has_unsaved_changes: false,
-            current_cursor_pos: 0,
-        }
-    }
-
-    pub fn render(
-        &self,
-        f: &mut Frame,
-        area: Rect,
-        theme: &Theme,
-        is_edit_mode: bool,
-        highlight_state: &HighlightState,
-        // total_count and current_position are now part of self
-    ) {
-        let fields_str_slice: Vec<&str> =
-            self.fields.iter().map(|s| s.as_str()).collect();
-        let values_str_slice: Vec<&String> = self.values.iter().collect();
-
-        crate::components::form::form::render_form(
-            f,
-            area,
-            self, // Pass self as CanvasState
-            &fields_str_slice,
-            &self.current_field,
-            &values_str_slice,
-            theme,
-            is_edit_mode,
-            highlight_state,
-            self.total_count,    // MODIFIED: Use self.total_count
-            self.current_position, // MODIFIED: Use self.current_position
-        );
-    }
-
-    // MODIFIED: Reset now also considers table context for counts
-    pub fn reset_to_empty(&mut self) {
-        self.id = 0;
-        self.values.iter_mut().for_each(|v| v.clear());
-        self.current_field = 0;
-        self.current_cursor_pos = 0;
-        self.has_unsaved_changes = false;
-        // current_position should be set to total_count + 1 for a new entry
-        // This might be better handled by the logic that calls reset_to_empty
-        // For now, let's ensure it's consistent with a "new" state.
-        if self.total_count > 0 {
-            self.current_position = self.total_count + 1;
-        } else {
-            self.current_position = 1; // If table is empty, new record is at position 1
-        }
-    }
-
-    pub fn get_current_input(&self) -> &str {
-        self.values
-            .get(self.current_field)
-            .map(|s| s.as_str())
-            .unwrap_or("")
-    }
-
-    pub fn get_current_input_mut(&mut self) -> &mut String {
-        self.values
-            .get_mut(self.current_field)
-            .expect("Invalid current_field index")
-    }
-
-    // MODIFIED: Update from a generic HashMap response
-    pub fn update_from_response(
-        &mut self,
-        response_data: &HashMap<String, String>,
-    ) {
-        self.values = self.fields
-            .iter()
-            .map(|field_name| {
-                response_data.get(field_name).cloned().unwrap_or_default()
-            })
-            .collect();
-
-        if let Some(id_str) = response_data.get("id") {
-            match id_str.parse::<i64>() {
-                Ok(parsed_id) => self.id = parsed_id,
-                Err(e) => {
-                    tracing::error!(
-                        "Failed to parse 'id' field '{}' for table {}.{}: {}",
-                        id_str,
-                        self.profile_name,
-                        self.table_name,
-                        e
-                    );
-                    self.id = 0; // Default to 0 if parsing fails
-                }
-            }
-        } else {
-            // If no ID is present, it might be a new record structure or an error
-            // For now, assume it means the record doesn't have an ID from the server yet
-            self.id = 0;
-        }
-        self.has_unsaved_changes = false;
-        // current_field and current_cursor_pos might need resetting or adjusting
-        // depending on the desired behavior after loading data.
-        // For now, let's reset current_field to 0.
-        self.current_field = 0;
-        self.current_cursor_pos = 0;
-    }
-}
-
-impl CanvasState for FormState {
-    fn current_field(&self) -> usize {
-        self.current_field
-    }
-
-    fn current_cursor_pos(&self) -> usize {
-        self.current_cursor_pos
-    }
-
-    fn has_unsaved_changes(&self) -> bool {
-        self.has_unsaved_changes
-    }
-
-    fn inputs(&self) -> Vec<&String> {
-        self.values.iter().collect()
-    }
-
-    fn get_current_input(&self) -> &str {
-        // Re-use the struct's own method
-        FormState::get_current_input(self)
-    }
-
-    fn get_current_input_mut(&mut self) -> &mut String {
-        // Re-use the struct's own method
-        FormState::get_current_input_mut(self)
-    }
-
-    fn fields(&self) -> Vec<&str> {
-        self.fields.iter().map(|s| s.as_str()).collect()
-    }
-
-    fn set_current_field(&mut self, index: usize) {
-        if index < self.fields.len() {
-            self.current_field = index;
-        }
-    }
-
-    fn set_current_cursor_pos(&mut self, pos: usize) {
-        self.current_cursor_pos = pos;
-    }
-
-    fn set_has_unsaved_changes(&mut self, changed: bool) {
-        self.has_unsaved_changes = changed;
-    }
-
-    fn get_suggestions(&self) -> Option<&[String]> {
-        None
-    }
-
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        None
-    }
-}