working cursor tracking in the add_table

Cargo.lock

@@ -402,7 +402,7 @@ dependencies = [
  "anyhow",
  "async-trait",
  "common",
- "crossterm 0.29.0",
+ "crossterm",
  "dirs 6.0.0",
  "dotenvy",
  "lazy_static",
@@ -415,6 +415,7 @@ dependencies = [
  "tonic",
  "tracing",
  "tracing-subscriber",
+ "tui-textarea",
  "unicode-segmentation",
  "unicode-width 0.2.0",
 ]
@@ -484,15 +485,6 @@ version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2459fc9262a1aa204eb4b5764ad4f189caec88aea9634389c0a25f8be7f6265e"
 
-[[package]]
-name = "convert_case"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb402b8d4c85569410425650ce3eddc7d698ed96d39a73f941b08fb63082f1e7"
-dependencies = [
- "unicode-segmentation",
-]
-
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -620,24 +612,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "crossterm"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
-dependencies = [
- "bitflags",
- "crossterm_winapi",
- "derive_more",
- "document-features",
- "mio",
- "parking_lot",
- "rustix 1.0.5",
- "signal-hook",
- "signal-hook-mio",
- "winapi",
-]
-
 [[package]]
 name = "crossterm_winapi"
 version = "0.9.1"
@@ -726,27 +700,6 @@ dependencies = [
  "powerfmt",
 ]
 
-[[package]]
-name = "derive_more"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
-dependencies = [
- "derive_more-impl",
-]
-
-[[package]]
-name = "derive_more-impl"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
-dependencies = [
- "convert_case",
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -812,15 +765,6 @@ dependencies = [
  "syn 2.0.100",
 ]
 
-[[package]]
-name = "document-features"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95249b50c6c185bee49034bcb378a49dc2b5dff0be90ff6616d31d64febab05d"
-dependencies = [
- "litrs",
-]
-
 [[package]]
 name = "dotenvy"
 version = "0.15.7"
@@ -1681,12 +1625,6 @@ version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23fb14cb19457329c82206317a5663005a4d404783dc74f4252769b0d5f42856"
 
-[[package]]
-name = "litrs"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
-
 [[package]]
 name = "lock_api"
 version = "0.4.12"
@@ -2354,7 +2292,7 @@ dependencies = [
  "bitflags",
  "cassowary",
  "compact_str",
- "crossterm 0.28.1",
+ "crossterm",
  "indoc",
  "instability",
  "itertools 0.13.0",
@@ -3606,6 +3544,18 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e78122066b0cb818b8afd08f7ed22f7fdbc3e90815035726f0840d0d26c0747a"
 
+[[package]]
+name = "tui-textarea"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a5318dd619ed73c52a9417ad19046724effc1287fb75cdcc4eca1d6ac1acbae"
+dependencies = [
+ "crossterm",
+ "ratatui",
+ "regex",
+ "unicode-width 0.2.0",
+]
+
 [[package]]
 name = "typed-arena"
 version = "2.0.2"
@@ -3899,7 +3849,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]

client/Cargo.toml

@@ -9,12 +9,12 @@ anyhow = "1.0.98"
 async-trait = "0.1.88"
 common = { path = "../common" }
 
-crossterm = "0.29.0"
+crossterm = "0.28.1"
 dirs = "6.0.0"
 dotenvy = "0.15.7"
 lazy_static = "1.5.0"
 prost = "0.13.5"
-ratatui = "0.29.0"
+ratatui = { version = "0.29.0", features = ["crossterm"] }
 serde = { version = "1.0.219", features = ["derive"] }
 time = "0.3.41"
 tokio = { version = "1.44.2", features = ["full", "macros"] }
@@ -22,5 +22,6 @@ 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

@@ -83,6 +83,9 @@ force_quit = ["q!"]
 save_and_quit = ["wq"]
 revert = ["r"]
 
+[editor]
+keybinding_mode = "vim"  # Options: "default", "vim", "emacs"
+
 [colors]
 theme = "dark" 
 # Options: "light", "dark", "high_contrast"

client/src/components/admin.rs

@@ -2,7 +2,9 @@
 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

@@ -0,0 +1,237 @@
+// 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;
+use crate::config::binds::config::EditorKeybindingMode;
+use crate::components::common::text_editor::TextEditor;
+
+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);
+
+    if add_logic_state.current_focus == AddLogicFocus::InputScriptContent {
+        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());
+
+        let script_title_hint = match add_logic_state.editor_keybinding_mode {
+            EditorKeybindingMode::Vim => {
+                let vim_mode_status = TextEditor::get_vim_mode_status(&add_logic_state.vim_state);
+                if is_edit_mode {
+                    format!("Script (VIM {}) - Esc for Normal. Tab navigates from Normal.", vim_mode_status)
+                } else {
+                    format!("Script (VIM {}) - 'i'/'a'/'o' for Insert. Tab to navigate.", vim_mode_status)
+                }
+            }
+            EditorKeybindingMode::Emacs | EditorKeybindingMode::Default => {
+                if is_edit_mode {
+                    "Script (Editing - Esc to exit edit. Tab navigates after exit.)".to_string()
+                } else {
+                    "Script (Press Enter or Ctrl+E to edit. Tab to navigate.)".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),
+        );
+        // Remove .widget() call - just pass the reference directly
+        f.render_widget(&*editor_ref, inner_area);
+        return;
+    }
+
+    // ... rest of the layout code ...
+    let main_chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Length(3),
+            Constraint::Length(9),
+            Constraint::Min(5),
+            Constraint::Length(3),
+        ])
+        .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];
+
+    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);
+
+    let focus_on_canvas_inputs = matches!(
+        add_logic_state.current_focus,
+        AddLogicFocus::InputLogicName
+            | AddLogicFocus::InputTargetColumn
+            | AddLogicFocus::InputDescription
+    );
+    render_canvas(
+        f,
+        canvas_area,
+        add_logic_state,
+        &add_logic_state.fields(),
+        &add_logic_state.current_field(),
+        &add_logic_state.inputs(),
+        theme,
+        is_edit_mode && focus_on_canvas_inputs,
+        highlight_state,
+    );
+
+    {
+        let mut editor_ref = add_logic_state.script_content_editor.borrow_mut();
+        editor_ref.set_cursor_line_style(Style::default());
+
+        let border_style_color = if add_logic_state.current_focus == AddLogicFocus::InputScriptContent {
+            theme.highlight
+        } else {
+            theme.secondary
+        };
+
+        let title_hint = match add_logic_state.editor_keybinding_mode {
+            EditorKeybindingMode::Vim => "Script Preview (VIM - Focus with Tab, then 'i'/'a'/'o' to edit)",
+            _ => "Script Preview (Focus with Tab, then Enter/Ctrl+E to edit)",
+        };
+
+        editor_ref.set_block(
+            Block::default()
+                .title(title_hint)
+                .borders(Borders::ALL)
+                .border_type(BorderType::Rounded)
+                .border_style(Style::default().fg(border_style_color)),
+        );
+        // Remove .widget() call here too
+        f.render_widget(&*editor_ref, script_content_area);
+    }
+
+    let get_button_style = |button_focus: AddLogicFocus, current_focus| {
+        let is_focused = current_focus == 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, theme: &Theme| {
+        if is_focused {
+            Style::default().fg(theme.highlight)
+        } else {
+            Style::default().fg(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]);
+
+    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/admin_panel_admin.rs

@@ -6,12 +6,11 @@ use crate::state::app::state::AppState;
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::Style,
-    text::{Line, Span, Text}, // Added Text
+    text::{Line, Span, Text},
     widgets::{Block, BorderType, Borders, List, ListItem, Paragraph},
     Frame,
 };
 
-/// Renders the view specific to admin users with a three-pane layout.
 pub fn render_admin_panel_admin(
     f: &mut Frame,
     area: Rect,
@@ -19,15 +18,13 @@ pub fn render_admin_panel_admin(
     admin_state: &mut AdminState,
     theme: &Theme,
 ) {
-    // Split vertically: Top for panes, Bottom for buttons
     let main_chunks = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([Constraint::Min(0), Constraint::Length(1)].as_ref()) // 1 line for buttons
+        .constraints([Constraint::Min(0), Constraint::Length(1)].as_ref())
         .split(area);
     let panes_area = main_chunks[0];
     let buttons_area = main_chunks[1];
 
-    // Split the top area into three panes: Profiles | Tables | Dependencies
     let pane_chunks = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([
@@ -35,207 +32,148 @@ pub fn render_admin_panel_admin(
             Constraint::Percentage(40), // Tables
             Constraint::Percentage(35), // Dependencies
         ].as_ref())
-        .split(panes_area); // Use the whole area directly
+        .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_focus = admin_state.current_focus == AdminFocus::Profiles;
-    let profile_border_style = if profile_focus {
+    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)
     };
-
-    // Block for the profiles pane
-    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); // Get inner area for list
-    f.render_widget(profiles_block, profiles_pane); // Render the block itself
-
-    // Create profile list items
-    let profile_list_items: Vec<ListItem> = app_state
-        .profile_tree
-        .profiles
-        .iter()
-        .enumerate()
-        .map(|(idx, profile)| {
-            // Check persistent selection for prefix, navigation state for style/highlight
-            let is_selected = admin_state.selected_profile_index == Some(idx);
-            let prefix = if is_selected { "[*] " } else { "[ ] " };
-            let style = if is_selected { // Style based on selection too
-                Style::default().fg(theme.highlight).add_modifier(ratatui::style::Modifier::BOLD)
-            } else {
-                Style::default().fg(theme.fg)
-            };
-            ListItem::new(Line::from(vec![
-                    Span::styled(prefix, style),
-                    Span::styled(&profile.name, style)
-            ]))
-        })
-    .collect();
-
-    // Build and render profile list inside the block's inner area
+    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 depends only on Profiles focus
-        .highlight_style(if profile_focus {
-            Style::default().add_modifier(ratatui::style::Modifier::REVERSED)
-        } else {
-            Style::default()
-        })
-    .highlight_symbol(if profile_focus { "> " } else { "  " });
-
+        .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)
+    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 {
-        Style::default().fg(theme.border)
+        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")]
         };
-
-    // Get selected profile information
-    let navigated_profile_idx = admin_state.profile_list_state.selected(); // Use nav state for display
-    let selected_profile_name = app_state
-        .profile_tree
-        .profiles
-        .get(navigated_profile_idx.unwrap_or(usize::MAX)) // Use nav state for title
-        .map_or("None", |p| &p.name);
-
-    // Block for the tables pane
-    let tables_block = Block::default()
-        .title(format!(" Tables (Profile: {}) ", selected_profile_name))
-        .borders(Borders::ALL)
-        .border_type(BorderType::Rounded)
-        .border_style(table_border_style);
-    let tables_inner_area = tables_block.inner(tables_pane); // Get inner area for list
-    f.render_widget(tables_block, tables_pane); // Render the block itself
-
-    // Create table list items and get dependencies for the selected table
-    let (table_list_items, selected_table_deps): (Vec<ListItem>, Vec<String>) = if let Some(
-        profile, // Get profile based on NAVIGATED profile index
-    ) = navigated_profile_idx.and_then(|idx| app_state.profile_tree.profiles.get(idx)) {
-        let items: Vec<ListItem> = profile
-            .tables
-            .iter()
-            .enumerate()
-            .map(|(idx, table)| { // Renamed i to idx for clarity
-                                  // Check persistent selection for prefix, navigation state for style/highlight
-                let is_selected = admin_state.selected_table_index == Some(idx); // Use persistent state for [*]
-                let is_navigated = admin_state.table_list_state.selected() == Some(idx); // Use nav state for highlight/>
-                let prefix = if is_selected { "[*] " } else { "[ ] " };
-                let style = if is_navigated { // Style based on navigation highlight
-                    Style::default().fg(theme.highlight).add_modifier(ratatui::style::Modifier::BOLD)
-                } else {
-                    Style::default().fg(theme.fg)
-                };
-                ListItem::new(Line::from(vec![
-                        Span::styled(prefix, style),
-                        Span::styled(&table.name, style),
-                ]))
-            })
-        .collect();
-
-        // Get dependencies only for the PERSISTENTLY selected table in the PERSISTENTLY selected profile
-        let chosen_profile_idx = admin_state.selected_profile_index; // Use persistent profile selection
-        let deps = chosen_profile_idx // Start with the chosen profile index
-            .and_then(|p_idx| app_state.profile_tree.profiles.get(p_idx)) // Get the chosen profile
-            .and_then(|p| admin_state.selected_table_index.and_then(|t_idx| p.tables.get(t_idx))) // Get the chosen table using its index
-            .map_or(Vec::new(), |t| t.depends_on.clone()); // If found, clone its depends_on, otherwise return empty Vec
-
-        (items, deps)
-    } else {
-        // Default when no profile is selected
-        (vec![ListItem::new("Select a profile to see tables")], vec![])
-    };
-
-    // Build and render table list inside the block's inner area
-    let table_list = List::new(table_list_items)
-        // Highlight style only applies when focus is *inside* the list
-        .highlight_style(if admin_state.current_focus == AdminFocus::InsideTablesList {
-            Style::default().add_modifier(ratatui::style::Modifier::REVERSED)
-        } else {
-            Style::default()
-        })
+    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) ---
-    // Get name based on PERSISTENT selections
-    let chosen_profile_idx = admin_state.selected_profile_index; // Use persistent profile selection
-    let selected_table_name = chosen_profile_idx
-        .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))) // Use persistent table selection
-        .map_or("N/A", |t| &t.name); // Get name of the selected table
 
-    // Block for the dependencies pane
+    // --- 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: {}) ", selected_table_name))
+        .title(format!(" Dependencies (Table: {}) ", deps_pane_title_table_name))
         .borders(Borders::ALL)
         .border_type(BorderType::Rounded)
-        .border_style(Style::default().fg(theme.border)); // No focus highlight for deps pane
-    let deps_inner_area = deps_block.inner(deps_pane); // Get inner area for content
-    f.render_widget(deps_block, deps_pane); // Render the block itself
+        .border_style(Style::default().fg(theme.border));
+    let deps_inner_area = deps_block.inner(deps_pane);
+    f.render_widget(deps_block, deps_pane);
 
-    // Prepare content for the dependencies paragraph
     let mut deps_content = Text::default();
     deps_content.lines.push(Line::from(Span::styled(
                 "Depends On:",
-                Style::default().fg(theme.accent), // Use accent color for the label
+                Style::default().fg(theme.accent),
     )));
 
-    if !selected_table_deps.is_empty() {
-        for dep in selected_table_deps {
-            // List each dependency
+    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 {
-        // Indicate if there are no dependencies
         deps_content.lines.push(Line::from(Span::styled("  None", theme.secondary)));
     }
-
-    // Build and render dependencies paragraph inside the block's inner area
     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 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);
-
-    // Define the helper closure to get style based on focus
-    let get_btn_style = |button_focus: AdminFocus| {
-        if admin_state.current_focus == button_focus {
-            // Apply highlight style if this button is focused
-            btn_base_style.add_modifier(ratatui::style::Modifier::REVERSED)
-        } else {
-            btn_base_style // Use base style otherwise
-        }
-    };
-    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);
-
+    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/common.rs

@@ -1,12 +1,14 @@
 // 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 use command_line::*;
 pub use status_line::*;
+pub use text_editor::*;
 pub use background::*;
 pub use dialog::*;
 pub use autocomplete::*;

client/src/components/common/text_editor.rs

@@ -0,0 +1,331 @@
+// 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, Scrolling};
+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/config/binds/config.rs

@@ -1,11 +1,57 @@
 // src/config/binds/config.rs
 
-use serde::Deserialize;
+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")]
@@ -22,9 +68,14 @@ pub struct Config {
     pub keybindings: ModeKeybindings,
     #[serde(default)]
     pub colors: ColorsConfig,
+    // NEW: Add editor configuration
+    #[serde(default)]
+    pub editor: EditorConfig,
 }
 
-#[derive(Debug, Deserialize)]
+// ... (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>>,
@@ -49,11 +100,11 @@ impl Config {
         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)?;
+        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))

client/src/functions/common/buffer.rs

@@ -6,7 +6,7 @@ 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 => 2,
+        AppView::Login | AppView::Register | AppView::Admin | AppView::AddTable | AppView::AddLogic => 2,
         AppView::Form(_) | AppView::Scratch => 3,
     }
 }

client/src/functions/modes/edit.rs

@@ -3,3 +3,4 @@
 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

@@ -0,0 +1,277 @@
+// src/functions/modes/edit/add_logic_e.rs
+use crate::state::pages::add_logic::AddLogicState; // Changed
+use crate::state::pages::canvas_state::CanvasState;
+use crossterm::event::{KeyCode, KeyEvent};
+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 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 AddLogic view canvas.
+pub async fn execute_edit_action(
+    action: &str,
+    key: KeyEvent,
+    state: &mut AddLogicState, // Changed
+    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 = AddLogicState::INPUT_FIELD_COUNT; // Changed
+            if num_fields > 0 {
+                let current_field = state.current_field();
+                let last_field_index = num_fields - 1;
+                if current_field < last_field_index { // Prevent cycling
+                    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 = AddLogicState::INPUT_FIELD_COUNT; // Changed
+            if num_fields > 0 {
+                let current_field = state.current_field();
+                if current_field > 0 { // Prevent cycling
+                    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" => { // In edit mode, up/down usually means prev/next field
+            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_pos = current_input.len();
+                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
+            }
+            Ok("".to_string())
+        }
+        "move_down" => { // In edit mode, up/down usually means prev/next field
+            let num_fields = AddLogicState::INPUT_FIELD_COUNT; // Changed
+            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 AddLogicState::INPUT_FIELD_COUNT > 0 { // Changed
+                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 = AddLogicState::INPUT_FIELD_COUNT; // Changed
+            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 && current_pos < current_input.len() { // Ensure not to go past end
+                    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;
+            }
+            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())
+        }
+        "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/navigation.rs

@@ -2,3 +2,4 @@
 
 pub mod admin_nav;
 pub mod add_table_nav;
+pub mod add_logic_nav;

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

@@ -0,0 +1,262 @@
+// 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 common::proto::multieko2::table_script::PostTableScriptRequest;
+use crate::components::common::text_editor::TextEditor;
+use tui_textarea::Input as TextAreaInput;
+
+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,
+    command_message: &mut String,
+) -> bool {
+    let mut handled = false;
+    let general_action = config.get_general_action(key_event.code, key_event.modifiers);
+
+    if add_logic_state.current_focus == AddLogicFocus::InputScriptContent {
+        let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
+
+        match add_logic_state.editor_keybinding_mode {
+            EditorKeybindingMode::Vim => {
+                if *is_edit_mode { // App considers textarea to be in "typing" (Insert) mode
+                    let changed = 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; }
+
+                    // Check if we've transitioned to Normal mode
+                    if key_event.code == KeyCode::Esc && TextEditor::is_vim_normal_mode(&add_logic_state.vim_state) {
+                        *is_edit_mode = false;
+                        *command_message = "VIM: Normal Mode. Tab to navigate.".to_string();
+                    }
+                    handled = true;
+                } else { // App considers textarea to be in "navigation" (Normal) mode
+                    match key_event.code {
+                        // Keys to enter Vim Insert mode
+                        KeyCode::Char('i') | KeyCode::Char('a') | KeyCode::Char('o') |
+                        KeyCode::Char('I') | KeyCode::Char('A') | KeyCode::Char('O') => {
+                            *is_edit_mode = true;
+                            TextEditor::handle_input(
+                                &mut editor_borrow, 
+                                key_event, 
+                                &add_logic_state.editor_keybinding_mode, 
+                                &mut add_logic_state.vim_state
+                            );
+                            *command_message = "VIM: Insert Mode.".to_string();
+                            handled = true;
+                        }
+                        _ => {
+                            if general_action.is_none() {
+                                let changed = 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; }
+                                handled = true;
+                            }
+                        }
+                    }
+                }
+            }
+            EditorKeybindingMode::Emacs | EditorKeybindingMode::Default => {
+                if *is_edit_mode {
+                    if key_event.code == KeyCode::Esc && key_event.modifiers == KeyModifiers::NONE {
+                        *is_edit_mode = false;
+                        *command_message = "Exited script edit. Tab to navigate.".to_string();
+                        handled = true;
+                    } else if general_action.is_some() && (general_action.unwrap() == "next_field" || general_action.unwrap() == "prev_field") {
+                        let changed = 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; }
+                        handled = true;
+                    } else {
+                        let changed = 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; }
+                        handled = true;
+                    }
+                }
+            }
+        }
+        if handled { return true; }
+    }
+
+    // If not handled above (e.g., Tab/Shift+Tab, or Enter when script content not in edit mode),
+    // process general application-level actions.
+    let action_str = general_action.map(String::from);
+    match action_str.as_deref() {
+        Some("exit_view") | Some("cancel_action") => {
+            buffer_state.update_history(AppView::Admin);
+            app_state.ui.show_add_logic = false;
+            *command_message = "Exited Add Logic".to_string();
+            *is_edit_mode = false;
+            handled = true;
+        }
+        Some("next_field") | Some("prev_field") => {
+            let is_next = action_str.as_deref() == Some("next_field");
+            let previous_focus = add_logic_state.current_focus;
+
+            add_logic_state.current_focus = if is_next {
+                match add_logic_state.current_focus {
+                    AddLogicFocus::InputLogicName => AddLogicFocus::InputTargetColumn,
+                    AddLogicFocus::InputTargetColumn => AddLogicFocus::InputDescription,
+                    AddLogicFocus::InputDescription => AddLogicFocus::InputScriptContent,
+                    AddLogicFocus::InputScriptContent => AddLogicFocus::SaveButton,
+                    AddLogicFocus::SaveButton => AddLogicFocus::CancelButton,
+                    AddLogicFocus::CancelButton => AddLogicFocus::InputLogicName,
+                }
+            } else {
+                match add_logic_state.current_focus {
+                    AddLogicFocus::InputLogicName => AddLogicFocus::CancelButton,
+                    AddLogicFocus::InputTargetColumn => AddLogicFocus::InputLogicName,
+                    AddLogicFocus::InputDescription => AddLogicFocus::InputTargetColumn,
+                    AddLogicFocus::InputScriptContent => AddLogicFocus::InputDescription,
+                    AddLogicFocus::SaveButton => AddLogicFocus::InputScriptContent,
+                    AddLogicFocus::CancelButton => AddLogicFocus::SaveButton,
+                }
+            };
+
+            if add_logic_state.current_focus == AddLogicFocus::InputScriptContent {
+                *is_edit_mode = false;
+                let mode_hint = match add_logic_state.editor_keybinding_mode {
+                    EditorKeybindingMode::Vim => "'i'/'a'/'o' to insert",
+                    _ => "Enter/Ctrl+E to edit",
+                };
+                *command_message = format!("Focus: Script Content. Press {} or Tab.", mode_hint);
+            } else if matches!(add_logic_state.current_focus, AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription) {
+                *is_edit_mode = true;
+                 *command_message = format!("Focus: {:?}. Edit mode ON.", add_logic_state.current_focus);
+            } else {
+                *is_edit_mode = false;
+                 *command_message = format!("Focus: {:?}", add_logic_state.current_focus);
+            }
+
+            app_state.ui.focus_outside_canvas = !matches!(
+                add_logic_state.current_focus,
+                AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription | AddLogicFocus::InputScriptContent
+            );
+            handled = true;
+        }
+        Some("select") => {
+            match add_logic_state.current_focus {
+                AddLogicFocus::InputScriptContent => {
+                    *is_edit_mode = true;
+                    let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
+                    match add_logic_state.editor_keybinding_mode {
+                        EditorKeybindingMode::Vim => {
+                            TextEditor::handle_input(
+                                &mut editor_borrow,
+                                KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE),
+                                &add_logic_state.editor_keybinding_mode,
+                                &mut add_logic_state.vim_state,
+                            );
+                            *command_message = "VIM: Insert Mode.".to_string();
+                        }
+                        _ => {
+                            *command_message = "Entered script edit mode.".to_string();
+                        }
+                    }
+                    handled = true;
+                }
+                AddLogicFocus::SaveButton => { handled = true; }
+                AddLogicFocus::CancelButton => { *is_edit_mode = false; handled = true; }
+                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 = true;
+                }
+            }
+        }
+        Some("toggle_edit_mode") => {
+            match add_logic_state.current_focus {
+                AddLogicFocus::InputScriptContent => {
+                    let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
+                    match add_logic_state.editor_keybinding_mode {
+                        EditorKeybindingMode::Vim => {
+                            if *is_edit_mode {
+                                TextEditor::handle_input(
+                                    &mut editor_borrow,
+                                    KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE),
+                                    &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. Tab to navigate.".to_string();
+                                } else {
+                                    *command_message = "VIM: Still in Insert Mode (toggle error?).".to_string();
+                                }
+                            } else {
+                                TextEditor::handle_input(
+                                    &mut editor_borrow,
+                                    KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE),
+                                    &add_logic_state.editor_keybinding_mode,
+                                    &mut add_logic_state.vim_state,
+                                );
+                                *is_edit_mode = true;
+                                *command_message = "VIM: Insert Mode.".to_string();
+                            }
+                        }
+                        _ => {
+                            *is_edit_mode = !*is_edit_mode;
+                            *command_message = format!("Script edit mode: {}", if *is_edit_mode { "ON" } else { "OFF. Tab to navigate." });
+                        }
+                    }
+                    handled = true;
+                }
+                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" });
+                    handled = true;
+                }
+                _ => { *command_message = "Cannot toggle edit mode here.".to_string(); handled = true; }
+            }
+        }
+        _ => {
+            if add_logic_state.current_focus == AddLogicFocus::InputScriptContent &&
+               !*is_edit_mode &&
+               add_logic_state.editor_keybinding_mode == EditorKeybindingMode::Vim {
+                let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
+                let changed = 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; }
+                handled = true;
+            }
+        }
+    }
+    handled
+}

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

@@ -12,11 +12,32 @@ use crate::services::GrpcClient;
 use tokio::sync::mpsc;
 use anyhow::Result;
 
-// Define a type for the save result channel
 pub type SaveTableResultSender = mpsc::Sender<Result<String>>;
 
-/// Handles navigation events specifically for the Add Table view.
-/// Returns true if the event was handled, false otherwise.
+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,
@@ -28,61 +49,52 @@ pub fn handle_add_table_navigation(
 ) -> bool {
     let action = config.get_general_action(key.code, key.modifiers);
     let current_focus = add_table_state.current_focus;
-    let mut handled = true; // Assume handled unless logic determines otherwise
-    let mut new_focus = current_focus; // Initialize new_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() {
-       // --- Handle Exiting Table Scroll Mode ---
        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();
+                   // *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();
+                   // *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();
+                   // *command_message = "Exited Links Table".to_string();
                }
-               _ => {
-                   // Action triggered but not applicable in this focus state
-                   handled = false;
+               _ => handled = false,
            }
        }
-           // If handled (i.e., focus changed), handled remains true.
-           // If not handled, handled becomes false.
-       }
-
-        // --- Vertical Navigation (Up/Down) ---
         Some("move_up") => {
             match current_focus {
-                AddTableFocus::InputTableName => new_focus = AddTableFocus::CancelButton,
+                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,
-                // Navigate between blocks when focus is on the table block itself
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::AddColumnButton, // Move up to right pane
+                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::AddColumnButton,
                 AddTableFocus::IndexesTable => new_focus = AddTableFocus::ColumnsTable,
                 AddTableFocus::LinksTable => new_focus = AddTableFocus::IndexesTable,
-                // Scroll inside the table when focus is internal
-                AddTableFocus::InsideColumnsTable => {
-                    navigate_table_up(&mut add_table_state.column_table_state, add_table_state.columns.len());
-                    // Stay inside the table, don't change new_focus
-                }
-                AddTableFocus::InsideIndexesTable => {
-                    navigate_table_up(&mut add_table_state.index_table_state, add_table_state.indexes.len());
-                    // Stay inside the table
-                }
-                AddTableFocus::InsideLinksTable => {
-                    navigate_table_up(&mut add_table_state.link_table_state, add_table_state.links.len());
-                    // Stay inside the table
-                }
+                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,
@@ -92,306 +104,102 @@ pub fn handle_add_table_navigation(
             match current_focus {
                 AddTableFocus::InputTableName => new_focus = AddTableFocus::InputColumnName,
                 AddTableFocus::InputColumnName => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::InputColumnType => new_focus = AddTableFocus::AddColumnButton,
+                AddTableFocus::InputColumnType => {
+                    add_table_state.last_canvas_field = 2;
+                    new_focus = AddTableFocus::AddColumnButton;
+                },
                 AddTableFocus::AddColumnButton => new_focus = AddTableFocus::ColumnsTable,
-                // Navigate between blocks when focus is on the table block itself
                 AddTableFocus::ColumnsTable => new_focus = AddTableFocus::IndexesTable,
                 AddTableFocus::IndexesTable => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::SaveButton, // Move down to right pane
-                // Scroll inside the table when focus is internal
-                AddTableFocus::InsideColumnsTable => {
-                    navigate_table_down(&mut add_table_state.column_table_state, add_table_state.columns.len());
-                    // Stay inside the table
-                }
-                AddTableFocus::InsideIndexesTable => {
-                    navigate_table_down(&mut add_table_state.index_table_state, add_table_state.indexes.len());
-                    // Stay inside the table
-                }
-                AddTableFocus::InsideLinksTable => {
-                    navigate_table_down(&mut add_table_state.link_table_state, add_table_state.links.len());
-                    // Stay inside the table
-                }
+                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 => new_focus = AddTableFocus::InputTableName,
+                AddTableFocus::CancelButton => {
+                    // MINIMAL CHANGE: Do nothing, new_focus remains current_focus
+                    // *command_message = "At bottom of form.".to_string(); // Remove message
                 }
             }
-
-        // --- Horizontal Navigation (Left/Right) ---
-        Some("next_option") => { // 'l' or Right: Move from Left Pane to Right Pane
-            // Horizontal nav within bottom buttons
-            if current_focus == AddTableFocus::SaveButton {
-                new_focus = AddTableFocus::DeleteSelectedButton;
-            } else if current_focus == AddTableFocus::DeleteSelectedButton {
-                new_focus = AddTableFocus::CancelButton;
+        }
+        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") => { // 'h' or Left: Move from Right Pane to Left Pane
-            // Horizontal nav within bottom buttons
-            if current_focus == AddTableFocus::CancelButton {
-                new_focus = AddTableFocus::DeleteSelectedButton;
-            } else if current_focus == AddTableFocus::DeleteSelectedButton {
-                new_focus = AddTableFocus::SaveButton;
+        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,
             }
         }
-
-        // --- Tab / Shift+Tab Navigation (Keep as vertical cycle) ---
-        Some("next_field") => { // Tab
+        Some("next_field") => {
             new_focus = match current_focus {
-                AddTableFocus::InputTableName => AddTableFocus::InputColumnName,
-                AddTableFocus::InputColumnName => AddTableFocus::InputColumnType,
-                AddTableFocus::InputColumnType => AddTableFocus::AddColumnButton,
-                AddTableFocus::AddColumnButton => AddTableFocus::ColumnsTable,
-                // Treat Inside* same as block focus for tabbing out
-                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, // Wrap
+                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") => { // Shift+Tab
+        Some("prev_field") => {
             new_focus = match current_focus {
-                AddTableFocus::InputTableName => AddTableFocus::CancelButton, // Wrap
-                AddTableFocus::InputColumnName => AddTableFocus::InputTableName,
-                AddTableFocus::InputColumnType => AddTableFocus::InputColumnName,
-                AddTableFocus::AddColumnButton => AddTableFocus::InputColumnType,
-                // Treat Inside* same as block focus for tabbing out
-                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,
+                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,
             };
         }
-
-        // --- Selection ---
         Some("select") => {
             match current_focus {
-                // --- Enter/Exit Table Focus ---
-                AddTableFocus::ColumnsTable => {
-                    new_focus = AddTableFocus::InsideColumnsTable;
-                    // Select first item if none selected when entering
-                    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));
-                    }
-                    *command_message = "Entered Columns Table (Scroll with Up/Down, Select to exit)".to_string();
-                }
-                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));
-                    }
-                    *command_message = "Entered Indexes Table (Scroll with Up/Down, Select to exit)".to_string();
-                }
-                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));
-                    }
-                    *command_message = "Entered Links Table (Scroll with Up/Down, Select to toggle/exit)".to_string();
-                }
-                AddTableFocus::InsideColumnsTable => {
-                    // Toggle selection when pressing select *inside* the columns table
-                    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;
-                            *command_message = format!(
-                                "Toggled selection for column: {} to {}",
-                                col.name, col.selected
-                            );
-                        }
-                    } else {
-                        *command_message = "No column highlighted to toggle selection".to_string();
+                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; }
             }
         }
-                AddTableFocus::InsideIndexesTable => {
-                    // Select does nothing here anymore, only Esc exits.
-                    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;
-                            *command_message = format!(
-                                "Toggled selection for index: {} to {}",
-                                idx_def.name, idx_def.selected
-                            );
-                        } else {
-                             *command_message = "Error: Selected index out of bounds".to_string();
-                        }
-                    } else {
-                        *command_message = "No index selected (Press Esc to exit scroll mode)".to_string();
-                    }
-                }
-                AddTableFocus::InsideLinksTable => {
-                    // Toggle selection when pressing select *inside* the links table
-                    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; // Toggle the selected state
-                            add_table_state.has_unsaved_changes = true; // Mark changes
-                            *command_message = format!(
-                                "Toggled selection for link: {} to {}",
-                                link.linked_table_name, link.selected
-                            );
-                        } else {
-                            *command_message = "Error: Selected link index out of bounds".to_string();
-                        }
-                    } else {
-                        *command_message = "No link selected to toggle".to_string();
-                    }
-                    // Stay inside the links table after toggling
-                    new_focus = AddTableFocus::InsideLinksTable;
-                    // Alternative: Exit after toggle:
-                    // new_focus = AddTableFocus::LinksTable;
-                    // *command_message = format!("{} - Exited Links Table", command_message);
-                }
-                // --- Other Select Actions ---
-                AddTableFocus::AddColumnButton => {
-                    if let Some(focus_after_add) = handle_add_column_action(add_table_state, command_message) {
-                        new_focus = focus_after_add;
-                    }
-                }
-                AddTableFocus::SaveButton => {
-                    // --- Initiate Async Save ---
-                    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; // Send result back
-                        });
-                    }
-                    // --- End Initiate Async Save ---
-                }
-                AddTableFocus::DeleteSelectedButton => {
-                    // --- Show Confirmation Dialog ---
-                    // Collect tuples of (index, name, type) for selected columns
-                    let columns_to_delete: Vec<(usize, String, String)> = add_table_state
-                        .columns
-                        .iter()
-                        .enumerate() // Get index along with the column
-                        .filter(|(_index, col)| col.selected) // Filter based on selection
-                        .map(|(index, col)| (index, col.name.clone(), col.data_type.clone())) // Map to (index, name, type)
-                        .collect();
-
-                    if columns_to_delete.is_empty() {
-                        *command_message = "No columns selected for deletion.".to_string();
-                    } else {
-                        // Format the message to include index, name, and type
-                        let column_details: String = columns_to_delete
-                            .iter()
-                            // Add 1 to index for 1-based numbering for user display
-                            .map(|(index, name, dtype)| format!("{}. {} ({})", index + 1, name, dtype))
-                            .collect::<Vec<String>>()
-                            .join("\n");
-
-                        // Use the formatted column_details string in the message
-                        let message = format!(
-                            "Delete the following columns?\n\n{}",
-                            column_details
-                        );
-                        let buttons = vec!["Confirm".to_string(), "Cancel".to_string()];
-                        app_state.show_dialog(
-                            "Confirm Deletion",
-                            &message,
-                            buttons,
-                            DialogPurpose::ConfirmDeleteColumns,
-                        );
-                    }
-                }
-                AddTableFocus::CancelButton => {
-                    *command_message = "Action: Cancel Add Table".to_string();
-                    // TODO: Implement logic
-                }
-                _ => { // Input fields
-                    *command_message = format!("Select on {:?}", current_focus);
-                    handled = false; // Let main loop handle edit mode toggle maybe
-                }
-            }
-            // Keep handled = true for select actions unless specifically set to false
-        }
-
-        // --- Other General Keys ---
-        Some("toggle_sidebar") | Some("toggle_buffer_list") => {
-            handled = false;
-        }
-
-        // --- No matching action ---
         _ => handled = false,
     }
 
-    // Update focus state if it changed and was handled
     if handled && current_focus != new_focus {
         add_table_state.current_focus = new_focus;
-        // Avoid overwriting specific messages set during 'select' handling
-        if command_message.is_empty() || command_message.starts_with("Focus set to") {
-             *command_message = format!("Focus set to {:?}", add_table_state.current_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
         }
 
-        // Check if the *new* focus target is one of the canvas input fields
+
         let new_is_canvas_input_focus = matches!(new_focus,
             AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType
         );
-        // Focus is outside canvas if it's not an input field
         app_state.ui.focus_outside_canvas = !new_is_canvas_input_focus;
-    } else if !handled {
-        // command_message.clear(); // Optional: Clear message if not handled here
     }
+    // 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
 }
-
-
-// Helper function for navigating up within a table state
-// Returns true if navigation happened within the table, false if it reached the top
-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 // Navigation happened
-            } else {
-                false // Was at the top
-            }
-        }
-        None => { // No item selected, select the last one
-            table_state.select(Some(item_count - 1));
-            true // Navigation happened (selection set)
-        }
-    }
-}
-
-// Helper function for navigating down within a table state
-// Returns true if navigation happened within the table, false if it reached the bottom
-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 // Navigation happened
-            } else {
-                false // Was at the bottom
-            }
-        }
-        None => { // No item selected, select the first one
-             table_state.select(Some(0));
-             true // Navigation happened (selection set)
-        }
-    }
-}
-

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

@@ -1,26 +1,20 @@
 // 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::state::AppState,
-    pages::admin::{AdminFocus, AdminState},
-};
-use crossterm::event::KeyEvent;
-use crate::state::app::buffer::AppView;
-use crate::state::app::buffer::BufferState;
+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;
 
-// --- Helper functions for ListState navigation (similar to TableState) ---
+// 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 }
-        }
+        Some(i) => if i >= item_count - 1 { 0 } else { i + 1 },
         None => 0,
     };
     list_state.select(Some(i));
@@ -32,260 +26,305 @@ fn list_select_previous(list_state: &mut ListState, item_count: usize) {
         return;
     }
     let i = match list_state.selected() {
-        Some(i) => {
-            if i == 0 { item_count - 1 } else { i - 1 }
-        }
-        None => item_count - 1, // Select last if nothing was 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));
 }
 
-
-/// Handles navigation events specifically for the Admin Panel view.
-/// Returns true if the event was handled, false otherwise.
 pub fn handle_admin_navigation(
-    key: KeyEvent,
+    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); // Clone action string
+    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 new_focus = current_focus; // Start with current focus
-    let mut handled = true; // Assume handled unless logic says otherwise
+    let mut handled = false;
 
-    match action.as_deref() {
-        // --- Vertical Navigation (Up/Down) ---
-        Some("move_up") => {
     match current_focus {
-                AdminFocus::Profiles => {
+        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 {
-                        admin_state.previous_profile(profile_count);
-                        *command_message = "Navigated profiles list".to_string();
-                    }
-                }
-                AdminFocus::Tables => {
-                    // Do nothing when focus is on the Tables pane itself
-                    *command_message = "Press Enter to select and scroll tables".to_string();
-                }
-                AdminFocus::InsideTablesList => { // Scroll inside
-                    if let Some(p_idx) = admin_state.profile_list_state.selected().or(admin_state.selected_profile_index) { // Use nav or persistent selection
-                        if let Some(profile) = app_state.profile_tree.profiles.get(p_idx) {
-                            list_select_previous(&mut admin_state.table_list_state, profile.tables.len());
-                        }
-                    }
-                }
-                AdminFocus::Button1 | AdminFocus::Button2 | AdminFocus::Button3 => {}
+                        list_select_previous(&mut admin_state.profile_list_state, profile_count);
+                        *command_message = "".to_string();
+                        handled = true;
                     }
                 }
                 Some("move_down") => {
-            match current_focus {
-                AdminFocus::Profiles => {
                     if profile_count > 0 {
-                        // Updates navigation state, resets table state
-                        admin_state.next_profile(profile_count);
-                        *command_message = "Navigated profiles list".to_string();
+                        list_select_next(&mut admin_state.profile_list_state, profile_count);
+                        *command_message = "".to_string();
+                        handled = true;
                     }
                 }
-                AdminFocus::Tables => {
-                    // Do nothing when focus is on the Tables pane itself
-                    *command_message = "Press Enter to select and scroll tables".to_string();
-                }
-                AdminFocus::InsideTablesList => { // Scroll inside
-                    if let Some(p_idx) = admin_state.profile_list_state.selected().or(admin_state.selected_profile_index) { // Use nav or persistent selection
-                        if let Some(profile) = app_state.profile_tree.profiles.get(p_idx) {
-                            list_select_next(&mut admin_state.table_list_state, profile.tables.len());
-                        }
-                    }
-                }
-                AdminFocus::Button1 | AdminFocus::Button2 | AdminFocus::Button3 => {}
-            }
-        }
-        // --- Horizontal Navigation (Focus Change) ---
-        Some("next_option") | Some("previous_option") => {
-            let old_focus = admin_state.current_focus;
-            let is_next = action.as_deref() == Some("next_option");
-
-            admin_state.current_focus = match old_focus {
-                AdminFocus::Profiles => if is_next { AdminFocus::Tables } else { AdminFocus::Button3 }, // P -> T (l) or P -> B3 (h)
-                AdminFocus::Tables => if is_next { AdminFocus::Button1 } else { AdminFocus::Profiles }, // T -> B1 (l) or T -> P (h)
-                AdminFocus::Button1 => if is_next { AdminFocus::Button2 } else { AdminFocus::Tables },   // B1 -> B2 (l) or B1 -> T (h)
-                AdminFocus::Button2 => if is_next { AdminFocus::Button3 } else { AdminFocus::Button1 },   // B2 -> B3 (l) or B2 -> B1 (h)
-                AdminFocus::Button3 => if is_next { AdminFocus::Profiles } else { AdminFocus::Button2 }, // B3 -> P (l) or B3 -> B2 (h)
-                // Prevent horizontal nav when inside lists
-                AdminFocus::InsideTablesList => old_focus,
-            };
-
-            let new_focus = admin_state.current_focus;
-            *command_message = format!("Focus set to {:?}", new_focus);
-            // Auto-select first item only when moving from Profiles to Tables via 'l'
-            if old_focus == AdminFocus::Profiles && new_focus == AdminFocus::Tables && is_next {
-                 if let Some(profile_idx) = admin_state.profile_list_state.selected() {
+                Some("select") => {
+                    admin_state.selected_profile_index = admin_state.profile_list_state.selected();
+                    admin_state.selected_table_index = None;
+                    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));
                             } 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 = format!(
+                        "Profile '{}' set as active.",
+                        admin_state.get_selected_profile_name().unwrap_or(&"N/A".to_string())
+                    );
+                    handled = true;
                 }
-            // Clear table nav selection if moving away from Tables
-            if old_focus == AdminFocus::Tables && new_focus != AdminFocus::Tables {
-                 admin_state.table_list_state.select(None);
+                Some("exit_table_scroll") => {
+                    admin_state.current_focus = AdminFocus::ProfilesPane;
+                    *command_message = "Focus: Profiles Pane".to_string();
+                    handled = true;
+                }
+                _ => handled = false,
             }
-            // Clear profile nav selection if moving away from Profiles
-            if old_focus == AdminFocus::Profiles && new_focus != AdminFocus::Profiles {
-                 // Maybe keep profile nav highlight? Let's try clearing it.
-                 // admin_state.profile_list_state.select(None); // Optional: clear profile nav highlight
         }
 
-        }
-        // --- Selection ---
-        Some("select") => {
-            match current_focus {
-                AdminFocus::Profiles => {
-                    // --- Perform persistent selection ---
-                    // Set the persistent selection to the currently navigated item
-                    if let Some(nav_idx) = admin_state.profile_list_state.selected() {
-                        admin_state.selected_profile_index = Some(nav_idx);
-
-                        // Move focus to Tables (like pressing 'l')
-                        new_focus = AdminFocus::Tables;
-
-                        // Select the first table for navigation highlight
-                        admin_state.table_list_state.select(None); // Clear table nav first
-                        admin_state.selected_table_index = None;   // Clear persistent table selection
-                        if let Some(profile) = app_state.profile_tree.profiles.get(nav_idx) {
-                            if !profile.tables.is_empty() {
-                                admin_state.table_list_state.select(Some(0));
-                            }
-
-                        *command_message = format!("Selected profile: {}", app_state.profile_tree.profiles[nav_idx].name);
-                        }
-                    } else {
-                        *command_message = "No profile selected".to_string();
-                    }
-                }
         AdminFocus::Tables => {
-                    // --- Enter InsideTablesList focus ---
-                    new_focus = AdminFocus::InsideTablesList;
-                    // Select first item if none selected when entering
-                    if let Some(p_idx) = admin_state.profile_list_state.selected().or(admin_state.selected_profile_index) {
-                        if let Some(profile) = app_state.profile_tree.profiles.get(p_idx) {
-                            if admin_state.table_list_state.selected().is_none() && !profile.tables.is_empty() {
+            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));
                                 }
-                        }
-                    }
-                    *command_message = "Entered Tables List (Select item with Enter, Exit with Esc)".to_string();
-                }
-                AdminFocus::InsideTablesList => {
-                    // --- Perform persistent selection ---
-                    // Set the persistent selection to the currently navigated item
-                    if let Some(nav_idx) = admin_state.table_list_state.selected() {
-                         admin_state.selected_table_index = Some(nav_idx); // Set persistent selection
-                         // Get table name for message
-                         let table_name = admin_state.profile_list_state.selected().or(admin_state.selected_profile_index)
-                             .and_then(|p_idx| app_state.profile_tree.profiles.get(p_idx))
-                             .and_then(|p| p.tables.get(nav_idx).map(|t| t.name.clone()))
-                             .unwrap_or_else(|| "N/A".to_string());
-                         *command_message = format!("Selected table: {}", table_name);
                              } else {
-                         *command_message = "No table highlighted".to_string();
+                                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;
+                    }
+                    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") => {
+                    admin_state.selected_table_index = admin_state.table_list_state.selected();
+                    let table_name = admin_state.selected_profile_index
+                         .or_else(|| admin_state.profile_list_state.selected())
+                         .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,
             }
-                    // Stay inside
         }
 
         AdminFocus::Button1 => {
-                    *command_message = "Action: Add Logic (Not Implemented)".to_string();
-                    // TODO: Trigger action for Button 1
+            match action.as_deref() {
+                Some("select") => {
+                    let mut logic_state_profile_name = "None (Global)".to_string();
+                    let mut selected_table_name_for_logic: Option<String> = None;
+                    if let Some(p_idx) = admin_state.selected_profile_index {
+                        if let Some(profile) = app_state.profile_tree.profiles.get(p_idx) {
+                            logic_state_profile_name = profile.name.clone();
+                            if let Some(t_idx) = admin_state.selected_table_index {
+                                if let Some(table) = profile.tables.get(t_idx) {
+                                    selected_table_name_for_logic = Some(table.name.clone());
                                 }
+                            }
+                        }
+                    }
+                    admin_state.add_logic_state = AddLogicState {
+                        profile_name: logic_state_profile_name.clone(),
+                        selected_table_name: selected_table_name_for_logic,
+                        editor_keybinding_mode: config.editor.keybinding_mode.clone(),
+                        ..AddLogicState::default()
+                    };
+                    buffer_state.update_history(AppView::AddLogic);
+                    app_state.ui.focus_outside_canvas = false;
+                    *command_message = "Opening Add Logic...".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 => {
-                   // --- Prepare AddTableState based on persistent selections ---
+            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();
-                           // Populate links from the selected profile's tables
-                           let available_links: Vec<LinkDefinition> = profile
-                               .tables
-                               .iter()
+                            let available_links: Vec<LinkDefinition> = profile.tables.iter()
                                 .map(|table| LinkDefinition {
                                     linked_table_name: table.name.clone(),
-                                   is_required: false, // Default
-                                   selected: false,    // Default
-                               })
-                               .collect();
-
-                           // Create and populate the new AddTableState
-                           let new_add_table_state = AddTableState {
-                               profile_name: selected_profile_name,
-                               links: available_links, // Assign populated links
+                                    is_required: false, selected: false,
+                                }).collect();
+                            admin_state.add_table_state = AddTableState {
+                                profile_name: selected_profile_name, links: available_links,
                                 ..AddTableState::default()
                             };
-
-                           // Assign the prepared state
-                           admin_state.add_table_state = new_add_table_state;
-
-                           // Switch view
                             buffer_state.update_history(AppView::AddTable);
                             app_state.ui.focus_outside_canvas = false;
-                           *command_message = format!(
-                               "Navigating to Add Table for profile '{}'...",
-                               admin_state.add_table_state.profile_name
-                           );
-
+                            *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_string();
+                        *command_message = "Please select a profile ([*]) first to add a table.".to_string();
+                        handled = true;
                     }
-                   // --- End preparation ---
                 }
+                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 => {
+            match action.as_deref() {
+                Some("select") => {
                     *command_message = "Action: Change Table (Not Implemented)".to_string();
-                    // TODO: Trigger action for Button 3
+                    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,
             }
         }
     }
-        // --- Handle Exiting Inside Mode ---
-        Some("exit_table_scroll") => { // Assuming you have this action bound (e.g., to Esc)
-            match current_focus {
-                AdminFocus::InsideTablesList => {
-                    new_focus = AdminFocus::Tables;
-                    admin_state.table_list_state.select(None); // Clear nav highlight on exit
-                    *command_message = "Exited Tables List".to_string();
-                }
-                _ => handled = false, // Not applicable
-            }
-        }
-        // --- Other General Keys (Ignore for admin nav) ---
-        Some("toggle_sidebar") | Some("toggle_buffer_list") | Some("next_field") | Some("prev_field") => {
-            // These are handled globally or not applicable here.
-            handled = false;
-        }
-        // --- No matching action ---
-        _ => handled = false, // Event not handled by admin navigation
-    }
-
-    // Update focus state if it changed and was handled
-    if handled && current_focus != new_focus {
-        admin_state.current_focus = new_focus;
-        // Avoid overwriting specific messages set during 'select' or 'exit' handling
-        if command_message.is_empty() || command_message.starts_with("Focus set to") {
-             *command_message = format!("Focus set to {:?}", admin_state.current_focus);
-        }
-    } else if !handled {
-        // command_message.clear(); // Optional: Clear message if not handled here
-    }
-
-    handled // Return whether the event was handled by this function
+    handled
 }

client/src/functions/modes/read_only.rs

@@ -3,3 +3,4 @@
 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

@@ -0,0 +1,244 @@
+// 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, // Changed
+    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; // Changed
+            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 {
+                // Moving up from the first field (InputLogicName)
+                app_state.ui.focus_outside_canvas = true;
+                // Focus should go to the element logically above the canvas.
+                // Based on AddLogicFocus, this might be CancelButton or another element.
+                // For AddLogic, let's assume it's CancelButton, similar to AddTable.
+                state.current_focus = crate::state::pages::add_logic::AddLogicFocus::CancelButton; // Changed
+                key_sequence_tracker.reset();
+                return Ok("Focus moved above canvas".to_string());
+            }
+            Ok("".to_string())
+        }
+        "move_down" => {
+            key_sequence_tracker.reset();
+            let num_fields = AddLogicState::INPUT_FIELD_COUNT; // Changed
+            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 {
+                // Moving down from the last field (InputDescription)
+                app_state.ui.focus_outside_canvas = true;
+                // Focus should go to the element logically below the canvas.
+                // This is likely InputScriptContent or SaveButton.
+                // The add_logic_nav.rs handles transitions to InputScriptContent.
+                // If moving from canvas directly to buttons, it would be SaveButton.
+                state.current_focus = crate::state::pages::add_logic::AddLogicFocus::InputScriptContent; // Or SaveButton
+                key_sequence_tracker.reset();
+                return Ok("Focus moved to script/button area".to_string());
+            }
+            Ok("".to_string())
+        }
+        "move_first_line" => {
+            key_sequence_tracker.reset();
+            if AddLogicState::INPUT_FIELD_COUNT > 0 { // Changed
+                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; // Changed
+            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,7 +1,7 @@
 // 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 trait for common actions
+use crate::state::pages::canvas_state::CanvasState;
 use crate::state::app::state::AppState;
 use anyhow::Result;
 
@@ -80,41 +80,36 @@ pub async fn execute_action(
         "move_up" => {
             key_sequence_tracker.reset();
             let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields == 0 { return Ok("No fields.".to_string()); }
+            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);
-                // ... (rest of the logic to set cursor position) ...
+                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 {
-                // --- THIS IS WHERE THE FIX GOES ---
                 // current_field is 0 (InputTableName), and user pressed Up.
-                // We need to move focus *outside* the canvas.
-
-                // Set the flag to indicate focus is leaving the canvas
-                app_state.ui.focus_outside_canvas = true;
-
-                // Decide which element gets focus. Based on your layout and the
-                // downward navigation (CancelButton wraps to InputTableName),
-                // moving up from InputTableName should likely go to CancelButton.
-                state.current_focus = crate::state::pages::add_table::AddTableFocus::CancelButton;
-
-                // Reset the sequence tracker as the action is complete
-                key_sequence_tracker.reset();
-
-                // Return a message indicating the focus change
-                return Ok("Focus moved above canvas".to_string());
-                // --- END FIX ---
+                // Forbid moving up. Do not change focus or cursor.
+                *command_message = "At top of form.".to_string();
             }
-            // If we moved within the canvas (e.g., 1 -> 0), return empty string
-            Ok("".to_string())
+            Ok(command_message.clone())
         }
         "move_down" => {
             key_sequence_tracker.reset();
             let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields == 0 { return Ok("No fields.".to_string()); }
+            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;
 
@@ -125,16 +120,19 @@ pub async fn execute_action(
                 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;
-                key_sequence_tracker.reset();
-                return Ok("Focus moved below canvas".to_string());
+                state.current_focus =
+                    crate::state::pages::add_table::AddTableFocus::AddColumnButton;
+                *command_message = "Focus moved below canvas".to_string();
             }
-            Ok("".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 {
@@ -145,7 +143,8 @@ pub async fn execute_action(
                 state.set_current_cursor_pos(new_pos);
                 *ideal_cursor_column = new_pos; // Update ideal column
             }
-            Ok("".to_string())
+            *command_message = "".to_string();
+            Ok(command_message.clone())
         }
         "move_last_line" => {
             key_sequence_tracker.reset();
@@ -159,14 +158,16 @@ pub async fn execute_action(
                 state.set_current_cursor_pos(new_pos);
                 *ideal_cursor_column = new_pos; // Update ideal column
             }
-            Ok("".to_string())
+            *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;
-            Ok("".to_string())
+            *command_message = "".to_string();
+            Ok(command_message.clone())
         }
         "move_right" => {
             let current_input = state.get_current_input();
@@ -177,22 +178,28 @@ pub async fn execute_action(
                 state.set_current_cursor_pos(new_pos);
                 *ideal_cursor_column = new_pos;
             }
-            Ok("".to_string())
+            *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 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;
-            Ok("".to_string())
+            *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() {
+            let final_pos =
+                if new_pos == current_pos && current_pos < current_input.len() {
                     find_word_end(current_input, current_pos + 1)
                 } else {
                     new_pos
@@ -201,44 +208,60 @@ pub async fn execute_action(
             let clamped_pos = final_pos.min(max_valid_index);
             state.set_current_cursor_pos(clamped_pos);
             *ideal_cursor_column = clamped_pos;
-            Ok("".to_string())
+            *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());
+            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())
+            *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());
+            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())
+            *command_message = "".to_string();
+            Ok(command_message.clone())
         }
         "move_line_start" => {
             state.set_current_cursor_pos(0);
             *ideal_cursor_column = 0;
-            Ok("".to_string())
+            *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;
-            Ok("".to_string())
+            *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" => {
+        "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())
+            // 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.clear(); // Clear message for unhandled actions
-             Ok(format!("Unknown read-only action: {}", action))
-        },
+            *command_message =
+                format!("Unknown read-only action: {}", action);
+            Ok(command_message.clone())
+        }
     }
 }
 

client/src/modes/canvas/edit.rs

@@ -5,11 +5,12 @@ use crate::state::pages::{
     auth::{LoginState, RegisterState},
     canvas_state::CanvasState,
 };
+use crate::state::pages::add_logic::AddLogicState;
 use crate::state::pages::form::FormState;
 use crate::state::pages::add_table::AddTableState;
+use crate::state::pages::admin::AdminState;
 use crate::modes::handlers::event::EventOutcome;
-use crate::functions::modes::edit::{auth_e, form_e};
-use crate::functions::modes::edit::add_table_e;
+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::{KeyCode, KeyEvent, KeyModifiers};
@@ -26,7 +27,7 @@ pub async fn handle_edit_event(
     form_state: &mut FormState,
     login_state: &mut LoginState,
     register_state: &mut RegisterState,
-    add_table_state: &mut AddTableState,
+    admin_state: &mut AdminState,
     ideal_cursor_column: &mut usize,
     current_position: &mut u64,
     total_count: u64,
@@ -73,6 +74,11 @@ pub async fn handle_edit_event(
                     "Action '{}' not fully implemented for Add Table view here.",
                     action
                 )
+            } else if app_state.ui.show_add_logic {
+                format!(
+                    "Action '{}' not fully implemented for Add Logic view here.",
+                    action
+                )
             } else {
                 let outcome = form_e::execute_common_action(
                     action,
@@ -121,7 +127,15 @@ pub async fn handle_edit_event(
                 add_table_e::execute_edit_action(
                     effective_action,
                     key,
-                    add_table_state,
+                    &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?
@@ -209,7 +223,15 @@ pub async fn handle_edit_event(
             add_table_e::execute_edit_action(
                 action,
                 key,
-                add_table_state,
+                &mut admin_state.add_table_state,
+                ideal_cursor_column,
+            )
+            .await?
+        } else if app_state.ui.show_add_logic {
+            add_logic_e::execute_edit_action(
+                action,
+                key,
+                &mut admin_state.add_logic_state,
                 ideal_cursor_column,
             )
             .await?
@@ -252,7 +274,15 @@ pub async fn handle_edit_event(
         add_table_e::execute_edit_action(
             "insert_char",
             key,
-            add_table_state,
+            &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?

client/src/modes/canvas/read_only.rs

@@ -6,9 +6,10 @@ 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::{auth_ro, form_ro, add_table_ro};
+use crate::functions::modes::read_only::{add_logic_ro, auth_ro, form_ro, add_table_ro};
 use crossterm::event::KeyEvent;
 use anyhow::Result;
 
@@ -20,6 +21,7 @@ pub async fn handle_read_only_event(
     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,
@@ -37,6 +39,7 @@ pub async fn handle_read_only_event(
     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 };
@@ -87,6 +90,15 @@ pub async fn handle_read_only_event(
                     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,
@@ -147,6 +159,15 @@ pub async fn handle_read_only_event(
                         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,
@@ -206,6 +227,15 @@ pub async fn handle_read_only_event(
                     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,

client/src/modes/general/dialog.rs

@@ -139,6 +139,16 @@ pub async fn handle_dialog_event(
                                 _ => { /* 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

client/src/modes/handlers/event.rs

@@ -41,6 +41,8 @@ use tokio::sync::mpsc;
 use crate::tui::functions::common::login::LoginResult;
 use crate::tui::functions::common::register::RegisterResult;
 use crate::functions::modes::navigation::add_table_nav::SaveTableResultSender;
+use crate::functions::modes::navigation::add_logic_nav::SaveLogicResultSender;
+use crate::functions::modes::navigation::add_logic_nav;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EventOutcome {
@@ -63,6 +65,7 @@ pub struct EventHandler {
     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,
 }
 
 impl EventHandler {
@@ -70,6 +73,7 @@ impl EventHandler {
         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,
@@ -84,6 +88,7 @@ impl EventHandler {
             login_result_sender,
             register_result_sender,
             save_table_result_sender,
+            save_logic_result_sender,
         })
     }
 
@@ -105,7 +110,7 @@ impl EventHandler {
         total_count: u64,
         current_position: &mut u64,
     ) -> Result<EventOutcome> {
-        let current_mode = ModeManager::derive_mode(app_state, self);
+        let current_mode = ModeManager::derive_mode(app_state, self, admin_state);
         app_state.update_mode(current_mode);
 
         let current_view = {
@@ -114,6 +119,7 @@ impl EventHandler {
             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 {
                 let form_name = app_state.selected_profile.clone().unwrap_or_else(|| "Data Form".to_string());
@@ -191,6 +197,26 @@ impl EventHandler {
                             return Ok(EventOutcome::Ok(self.command_message.clone()));
                         }
                     }
+                    // --- Add Logic Page Navigation ---
+                    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,
+                            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()));
+                        }
+                    }
+
                     // --- Add Table Page Navigation ---
                     if app_state.ui.show_add_table {
                         let client_clone = grpc_client.clone();
@@ -375,6 +401,7 @@ impl EventHandler {
                         login_state,
                         register_state,
                         &mut admin_state.add_table_state,
+                        &mut admin_state.add_logic_state,
                         &mut self.key_sequence_tracker,
                         current_position,
                         total_count,
@@ -409,9 +436,15 @@ impl EventHandler {
 
                     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 self.key_sequence_tracker,
-                        current_position, total_count, grpc_client,
-                        &mut self.command_message, &mut self.edit_mode_cooldown,
+                        register_state, 
+                        &mut admin_state.add_table_state, 
+                        &mut admin_state.add_logic_state,
+                        &mut self.key_sequence_tracker,
+                        current_position, 
+                        total_count, 
+                        grpc_client,
+                        &mut self.command_message, 
+                        &mut self.edit_mode_cooldown,
                         &mut self.ideal_cursor_column,
                     )
                     .await?;
@@ -457,7 +490,7 @@ impl EventHandler {
                         form_state,
                         login_state,
                         register_state,
-                        &mut admin_state.add_table_state,
+                        admin_state,
                         &mut self.ideal_cursor_column,
                         current_position,
                         total_count,

client/src/modes/handlers/mode_manager.rs

@@ -1,7 +1,9 @@
 // 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 {
@@ -16,7 +18,11 @@ pub struct ModeManager;
 
 impl ModeManager {
     // Determine current mode based on app state
-    pub fn derive_mode(app_state: &AppState, event_handler: &EventHandler) -> AppMode {
+    pub fn derive_mode(
+        app_state: &AppState,
+        event_handler: &EventHandler,
+        admin_state: &AdminState,
+    ) -> AppMode {
         if event_handler.command_mode {
             return AppMode::Command;
         }
@@ -25,16 +31,38 @@ impl ModeManager {
             return AppMode::Highlight;
         }
 
-        if app_state.ui.focus_outside_canvas {
-            return AppMode::General;
-        }
-
         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_table
+            || app_state.ui.show_add_logic;
 
-        if is_canvas_view {
+        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 {

client/src/modes/highlight/highlight.rs

@@ -6,7 +6,7 @@ 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::add_table::AddTableState;
+use crate::state::pages::admin::AdminState;
 use crate::state::pages::form::FormState;
 use crate::modes::handlers::event::EventOutcome;
 use crate::modes::read_only;
@@ -23,7 +23,7 @@ pub async fn handle_highlight_event(
     form_state: &mut FormState,
     login_state: &mut LoginState,
     register_state: &mut RegisterState,
-    add_table_state: &mut AddTableState,
+    admin_state: &mut AdminState,
     key_sequence_tracker: &mut KeySequenceTracker,
     current_position: &mut u64,
     total_count: u64,
@@ -41,7 +41,8 @@ pub async fn handle_highlight_event(
         form_state,
         login_state,
         register_state,
-        add_table_state,
+        &mut admin_state.add_table_state,
+        &mut admin_state.add_logic_state,
         key_sequence_tracker,
         current_position,
         total_count,

client/src/services/grpc_client.rs

@@ -10,6 +10,10 @@ use common::proto::multieko2::table_definition::{
     table_definition_client::TableDefinitionClient,
     ProfileTreeResponse, PostTableDefinitionRequest, TableDefinitionResponse,
 };
+use common::proto::multieko2::table_script::{
+    table_script_client::TableScriptClient,
+    PostTableScriptRequest, TableScriptResponse,
+};
 use anyhow::Result;
 
 #[derive(Clone)]
@@ -17,6 +21,7 @@ pub struct GrpcClient {
     adresar_client: AdresarClient<Channel>,
     table_structure_client: TableStructureServiceClient<Channel>,
     table_definition_client: TableDefinitionClient<Channel>,
+    table_script_client: TableScriptClient<Channel>,
 }
 
 impl GrpcClient {
@@ -24,11 +29,13 @@ impl GrpcClient {
         let adresar_client = AdresarClient::connect("http://[::1]:50051").await?;
         let table_structure_client = TableStructureServiceClient::connect("http://[::1]:50051").await?;
         let table_definition_client = TableDefinitionClient::connect("http://[::1]:50051").await?;
+        let table_script_client = TableScriptClient::connect("http://[::1]:50051").await?;
 
         Ok(Self {
             adresar_client,
             table_structure_client,
             table_definition_client,
+            table_script_client,
         })
     }
 
@@ -73,4 +80,11 @@ impl GrpcClient {
         let response = self.table_definition_client.post_table_definition(tonic_request).await?;
         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?;
+        Ok(response.into_inner())
     }
+}
+

client/src/state/app/buffer.rs

@@ -8,6 +8,7 @@ pub enum AppView {
     Register,
     Admin,
     AddTable,
+    AddLogic,
     Form(String),
     Scratch,
 }
@@ -21,6 +22,7 @@ impl AppView {
             AppView::Register => "Register",
             AppView::Admin => "Admin_Panel",
             AppView::AddTable => "Add_Table",
+            AppView::AddLogic => "Add_Logic",
             AppView::Form(name) => name.as_str(),
             AppView::Scratch => "*scratch*",
         }

client/src/state/app/state.rs

@@ -22,6 +22,7 @@ pub struct UiState {
     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,
@@ -170,6 +171,7 @@ impl Default for UiState {
             show_intro: true,
             show_admin: false,
             show_add_table: false,
+            show_add_logic: false,
             show_form: false,
             show_login: false,
             show_register: false,

client/src/state/pages.rs

@@ -5,4 +5,5 @@ 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

@@ -0,0 +1,159 @@
+// 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}; // Add VimState import
+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,
+    InputScriptContent,
+    InputDescription,
+    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 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, // Add this field
+}
+
+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,
+            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(), // Add this field initialization
+        }
+    }
+
+    pub const INPUT_FIELD_COUNT: usize = 3;
+}
+
+impl Default for AddLogicState {
+    fn default() -> Self {
+        Self::new(&EditorConfig::default())
+    }
+}
+
+// ... rest of the CanvasState implementation remains the same
+impl CanvasState for AddLogicState {
+    fn current_field(&self) -> usize {
+        match self.current_focus {
+            AddLogicFocus::InputLogicName => 0,
+            AddLogicFocus::InputTargetColumn => 1,
+            AddLogicFocus::InputDescription => 2,
+            _ => 0,
+        }
+    }
+
+    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) {
+        self.current_focus = match index {
+            0 => AddLogicFocus::InputLogicName,
+            1 => AddLogicFocus::InputTargetColumn,
+            2 => AddLogicFocus::InputDescription,
+            _ => self.current_focus,
+        };
+    }
+
+    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]> {
+        None
+    }
+
+    fn get_selected_suggestion_index(&self) -> Option<usize> {
+        None
+    }
+}

client/src/state/pages/add_table.rs

@@ -55,6 +55,7 @@ pub struct AddTableState {
     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,
@@ -77,6 +78,7 @@ impl Default for AddTableState {
             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(),
@@ -100,7 +102,7 @@ impl CanvasState for AddTableState {
             AddTableFocus::InputColumnName => 1,
             AddTableFocus::InputColumnType => 2,
             // If focus is elsewhere, default to the first field for canvas rendering logic
-            _ => 0,
+            _ => self.last_canvas_field,
         }
     }
 
@@ -145,10 +147,20 @@ impl CanvasState for AddTableState {
     }
 
     fn set_current_field(&mut self, index: usize) {
+        // Update both current focus and last canvas field
         self.current_focus = match index {
-            0 => AddTableFocus::InputTableName,
-            1 => AddTableFocus::InputColumnName,
-            2 => AddTableFocus::InputColumnType,
+            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
         };
     }

client/src/state/pages/admin.rs

@@ -2,12 +2,14 @@
 
 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
-    Profiles,
+    ProfilesPane,
+    InsideProfilesList,
     Tables,
     InsideTablesList,
     Button1,
@@ -24,6 +26,7 @@ pub struct AdminState {
     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 {

client/src/ui/handlers/context.rs

@@ -15,8 +15,9 @@ pub enum DialogPurpose {
     LoginFailed,
     RegisterSuccess,
     RegisterFailed,
-    ConfirmDeleteColumns, // add_table delete selected Columns
-    SaveTableSuccess, // add_table save table
+    ConfirmDeleteColumns,
+    SaveTableSuccess,
+    SaveLogicSuccess,
     // TODO in the future:
     // ConfirmQuit,
 }

client/src/ui/handlers/render.rs

@@ -9,6 +9,7 @@ use crate::components::{
     handlers::sidebar::{self, calculate_sidebar_layout},
     form::form::render_form,
     admin::render_add_table,
+    admin::add_logic::render_add_logic,
     auth::{login::render_login, register::render_register},
 };
 use crate::config::colors::themes::Theme;
@@ -107,6 +108,16 @@ pub fn render_ui(
             login_state.current_field < 3,
             highlight_state,
         );
+    } else if app_state.ui.show_add_logic {
+        render_add_logic(
+            f,
+            main_content_area,
+            theme,
+            app_state,
+            &mut admin_state.add_logic_state,
+            is_edit_mode, // Pass the general edit mode status
+            highlight_state,
+        );
     } else if app_state.ui.show_login {
         render_login(
             f,

client/src/ui/handlers/ui.rs

@@ -13,6 +13,7 @@ use crate::state::pages::auth::AuthState;
 use crate::state::pages::auth::LoginState;
 use crate::state::pages::auth::RegisterState;
 use crate::state::pages::admin::AdminState;
+use crate::state::pages::admin::AdminFocus;
 use crate::state::pages::intro::IntroState;
 use crate::state::app::buffer::BufferState;
 use crate::state::app::buffer::AppView;
@@ -48,11 +49,14 @@ pub async fn run_ui() -> Result<()> {
         mpsc::channel::<RegisterResult>(1);
     let (save_table_result_sender, mut save_table_result_receiver) =
         mpsc::channel::<Result<String>>(1);
+    let (save_logic_result_sender, mut save_logic_result_receiver) =
+        mpsc::channel::<Result<String>>(1);
 
     let mut event_handler = EventHandler::new(
         login_result_sender.clone(),
         register_result_sender.clone(),
         save_table_result_sender.clone(),
+        save_logic_result_sender.clone(),
     ).await.context("Failed to create event handler")?;
     let event_reader = EventReader::new();
 
@@ -88,6 +92,7 @@ pub async fn run_ui() -> Result<()> {
             app_state.ui.show_register = false;
             app_state.ui.show_admin = false;
             app_state.ui.show_add_table = false;
+            app_state.ui.show_add_logic = false;
             app_state.ui.show_form = false;
             match active_view {
                 AppView::Intro => app_state.ui.show_intro = true,
@@ -104,13 +109,27 @@ pub async fn run_ui() -> Result<()> {
                             event_handler.command_message = format!("Error refreshing admin data: {}", e);
                         }
                     }
-                    app_state.ui.show_admin = true;
-                    let profile_names = app_state.profile_tree.profiles.iter()
-                        .map(|p| p.name.clone())
-                        .collect();
+                    app_state.ui.show_admin = true; // <<< RESTORE THIS
+                    let profile_names = app_state.profile_tree.profiles.iter() // <<< RESTORE THIS
+                        .map(|p| p.name.clone())                              // <<< RESTORE THIS
+                        .collect();                                             // <<< RESTORE THIS
                     admin_state.set_profiles(profile_names);
+
+                    // Only reset to ProfilesPane if not already in a specific admin sub-focus
+                    if admin_state.current_focus == AdminFocus::default() || 
+                       !matches!(admin_state.current_focus, 
+                                AdminFocus::InsideProfilesList |
+                                AdminFocus::Tables | AdminFocus::InsideTablesList |
+                                AdminFocus::Button1 | AdminFocus::Button2 | AdminFocus::Button3) {
+                         admin_state.current_focus = AdminFocus::ProfilesPane;
+                    }
+                    // Pre-select first profile item for visual consistency, but '>' won't show until 'select'
+                    if admin_state.profile_list_state.selected().is_none() && !app_state.profile_tree.profiles.is_empty() {
+                        admin_state.profile_list_state.select(Some(0));
+                    }
                 }
                 AppView::AddTable => app_state.ui.show_add_table = true,
+                AppView::AddLogic => app_state.ui.show_add_logic = true,
                 AppView::Form(_) => app_state.ui.show_form = true,
                 AppView::Scratch => {} // Or show a scratchpad component
             }
@@ -150,7 +169,7 @@ pub async fn run_ui() -> Result<()> {
 
         // --- Cursor Visibility Logic ---
         // (Keep existing cursor logic here - depends on state drawn above)
-        let current_mode = ModeManager::derive_mode(&app_state, &event_handler);
+        let current_mode = ModeManager::derive_mode(&app_state, &event_handler, &admin_state);
         match current_mode {
             AppMode::Edit => { terminal.show_cursor()?; }
             AppMode::Highlight => { terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?; terminal.show_cursor()?; }