working finally

client/src/components/form.rs

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

client/src/components/form/form.rs

@@ -7,7 +7,7 @@ use ratatui::{
 };
 use crate::config::colors::themes::Theme;
 use crate::ui::form::FormState;
-use super::canvas::render_canvas;  // Changed to canvas
+use crate::components::handlers::canvas::render_canvas;
 
 pub fn render_form(
     f: &mut Frame,

client/src/components/handlers.rs

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

client/src/components/handlers/sidebar.rs

@@ -9,7 +9,8 @@ use crate::config::colors::themes::Theme;
 use common::proto::multieko2::table_definition::{ProfileTreeResponse};
 use ratatui::text::{Span, Line};
 
-const SIDEBAR_WIDTH: u16 = 16;
+// Reduced sidebar width
+const SIDEBAR_WIDTH: u16 = 12;
 
 pub fn calculate_sidebar_layout(show_sidebar: bool, main_content_area: Rect) -> (Option<Rect>, Rect) {
     if show_sidebar {
@@ -37,46 +38,72 @@ pub fn render_sidebar(
     let mut items = Vec::new();
 
     if let Some(profile_name) = selected_profile {
-        if let Some(profile) = profile_tree.profiles.iter()
+        // Existing code for when a profile is selected...
-            .find(|p| &p.name == profile_name)
+    } else {
-        {
+        // Show full profile tree when no profile is selected (compact version)
-            // Profile header
+        for (profile_idx, profile) in profile_tree.profiles.iter().enumerate() {
+            // Profile header - more compact
             items.push(ListItem::new(Line::from(vec![
-                Span::styled("📁 ", Style::default().fg(theme.accent)),
+                Span::styled("◆", Style::default().fg(theme.accent)),
                 Span::styled(&profile.name, Style::default().fg(theme.highlight)),
             ])));
 
-            // Tables
+            // Tables with compact prefixes
             for (table_idx, table) in profile.tables.iter().enumerate() {
-                let is_last = table_idx == profile.tables.len() - 1;
+                let is_last_table = table_idx == profile.tables.len() - 1;
-                let prefix = if is_last { "└─ " } else { "├─ " };
+                let is_last_profile = profile_idx == profile_tree.profiles.len() - 1;
+
+                // Shorter prefix characters
+                let prefix = match (is_last_profile, is_last_table) {
+                    (true, true) => " └",
+                    (true, false) => " ├",
+                    (false, true) => "│└",
+                    (false, false) => "│├",
+                };
+
+                // Get table name without year prefix to save space
+                let display_name = if table.name.starts_with("2025_") {
+                    &table.name[5..] // Skip "2025_" prefix
+                } else {
+                    &table.name
+                };
 
                 let mut line = vec![
-                    Span::styled(format!("  {}", prefix), Style::default().fg(theme.fg)),
+                    Span::styled(prefix, Style::default().fg(theme.fg)),
-                    Span::styled(&table.name, Style::default().fg(theme.fg)),
+                    Span::styled(display_name, Style::default().fg(theme.fg)),
                 ];
 
+                // Show a simple indicator for dependencies instead of listing them
                 if !table.depends_on.is_empty() {
                     line.push(Span::styled(
-                        format!(" → {}", table.depends_on.join(", ")),
+                        "→",
                         Style::default().fg(theme.secondary)
                     ));
                 }
 
                 items.push(ListItem::new(Line::from(line)));
             }
+
+            // Compact separator between profiles
+            if profile_idx < profile_tree.profiles.len() - 1 {
+                items.push(ListItem::new(Line::from(
+                    Span::styled("│", Style::default().fg(theme.secondary))
+                )));
+            }
+        }
+
+        if profile_tree.profiles.is_empty() {
+            items.push(ListItem::new(Span::styled(
+                "No profiles",
+                Style::default().fg(theme.secondary)
+            )));
         }
-    } else {
-        items.push(ListItem::new(Span::styled(
-            "No profile selected",
-            Style::default().fg(theme.secondary)
-        )));
     }
 
     let list = List::new(items)
         .block(sidebar_block)
         .highlight_style(Style::default().fg(theme.highlight))
-        .highlight_symbol(">>");
+        .highlight_symbol(">");
 
     f.render_widget(list, area);
 }

client/src/components/mod.rs

@@ -3,8 +3,10 @@ pub mod handlers;
 pub mod intro;
 pub mod admin;
 pub mod common;
+pub mod form;
 
 pub use handlers::*;
 pub use intro::*;
 pub use admin::*;
 pub use common::*;
+pub use form::*;

client/src/modes/canvas/common.rs

@@ -1,9 +1,83 @@
 // src/modes/canvas/common.rs
 
+use crossterm::event::{KeyEvent};
+use crate::config::binds::config::Config;
 use crate::tui::terminal::grpc_client::GrpcClient;
+use crate::tui::terminal::core::TerminalCore;
+use crate::tui::controls::commands::CommandHandler;
 use crate::ui::handlers::form::FormState;
+use crate::state::state::AppState;
 use common::proto::multieko2::adresar::{PostAdresarRequest, PutAdresarRequest};
 
+/// Main handler for common core actions
+pub async fn handle_core_action(
+    action: &str,
+    form_state: &mut FormState,
+    grpc_client: &mut GrpcClient,
+    command_handler: &mut CommandHandler,
+    terminal: &mut TerminalCore,
+    app_state: &mut AppState,
+    current_position: &mut u64,
+    total_count: u64,
+) -> Result<(bool, String), Box<dyn std::error::Error>> {
+    match action {
+        "save" => {
+            let message = save(
+                form_state,
+                grpc_client,
+                &mut app_state.ui.is_saved,
+                current_position,
+                total_count,
+            ).await?;
+            Ok((false, message))
+        },
+        "force_quit" => {
+            terminal.cleanup()?;
+            Ok((true, "Force exiting without saving.".to_string()))
+        },
+        "save_and_quit" => {
+            let message = save(
+                form_state,
+                grpc_client,
+                &mut app_state.ui.is_saved,
+                current_position,
+                total_count,
+            ).await?;
+            terminal.cleanup()?;
+            Ok((true, format!("{}. Exiting application.", message)))
+        },
+        "revert" => {
+            let message = revert(
+                form_state,
+                grpc_client,
+                current_position,
+                total_count,
+            ).await?;
+            Ok((false, message))
+        },
+        // We should never hit this case with proper filtering
+        _ => Ok((false, format!("Core action not handled: {}", action))),
+    }
+}
+
+/// Helper function to check if a key event should trigger a core action
+pub fn is_core_action(config: &Config, key_code: crossterm::event::KeyCode, modifiers: crossterm::event::KeyModifiers) -> Option<String> {
+    // Check for core application actions (save, quit, etc.)
+    if let Some(action) = config.get_action_for_key_in_mode(
+        &config.keybindings.common,
+        key_code,
+        modifiers
+    ) {
+        match action {
+            "save" | "force_quit" | "save_and_quit" | "revert" => {
+                return Some(action.to_string())
+            },
+            _ => {} // Other actions are handled by their respective mode handlers
+        }
+    }
+    None
+}
+
 /// Shared logic for saving the current form state
 pub async fn save(
     form_state: &mut FormState,
@@ -65,64 +139,6 @@ pub async fn save(
     Ok(message)
 }
 
-/// Shared logic for force quitting the application
-pub fn force_quit() -> (bool, String) {
-    (true, "Force quitting application".to_string())
-}
-
-/// Shared logic for saving and quitting
-pub async fn save_and_quit(
-    form_state: &mut FormState,
-    grpc_client: &mut GrpcClient,
-    current_position: &mut u64,
-    total_count: u64,
-) -> Result<(bool, String), Box<dyn std::error::Error>> {
-    let is_new = *current_position == total_count + 1;
-
-    if is_new {
-        let post_request = PostAdresarRequest {
-            firma: form_state.values[0].clone(),
-            kz: form_state.values[1].clone(),
-            drc: form_state.values[2].clone(),
-            ulica: form_state.values[3].clone(),
-            psc: form_state.values[4].clone(),
-            mesto: form_state.values[5].clone(),
-            stat: form_state.values[6].clone(),
-            banka: form_state.values[7].clone(),
-            ucet: form_state.values[8].clone(),
-            skladm: form_state.values[9].clone(),
-            ico: form_state.values[10].clone(),
-            kontakt: form_state.values[11].clone(),
-            telefon: form_state.values[12].clone(),
-            skladu: form_state.values[13].clone(),
-            fax: form_state.values[14].clone(),
-        };
-        let _ = grpc_client.post_adresar(post_request).await?;
-    } else {
-        let put_request = PutAdresarRequest {
-            id: form_state.id,
-            firma: form_state.values[0].clone(),
-            kz: form_state.values[1].clone(),
-            drc: form_state.values[2].clone(),
-            ulica: form_state.values[3].clone(),
-            psc: form_state.values[4].clone(),
-            mesto: form_state.values[5].clone(),
-            stat: form_state.values[6].clone(),
-            banka: form_state.values[7].clone(),
-            ucet: form_state.values[8].clone(),
-            skladm: form_state.values[9].clone(),
-            ico: form_state.values[10].clone(),
-            kontakt: form_state.values[11].clone(),
-            telefon: form_state.values[12].clone(),
-            skladu: form_state.values[13].clone(),
-            fax: form_state.values[14].clone(),
-        };
-        let _ = grpc_client.put_adresar(put_request).await?;
-    }
-
-    Ok((true, "Saved and exiting application".to_string()))
-}
-
 /// Discard changes since last save
 pub async fn revert(
     form_state: &mut FormState,

client/src/modes/common/command_mode.rs

@@ -4,6 +4,8 @@ use crossterm::event::{KeyEvent, KeyCode, KeyModifiers};
 use crate::tui::terminal::grpc_client::GrpcClient;
 use crate::config::binds::config::Config;
 use crate::ui::handlers::form::FormState;
+use crate::tui::controls::commands::CommandHandler;
+use crate::tui::terminal::core::TerminalCore;
 use crate::modes::{
     canvas::{common},
 };
@@ -15,7 +17,8 @@ pub async fn handle_command_event(
     command_input: &mut String,
     command_message: &mut String,
     grpc_client: &mut GrpcClient,
-    is_saved: &mut bool,
+    command_handler: &mut CommandHandler,
+    terminal: &mut TerminalCore,
     current_position: &mut u64,
     total_count: u64,
 ) -> Result<(bool, String, bool), Box<dyn std::error::Error>> {
@@ -37,7 +40,8 @@ pub async fn handle_command_event(
             command_input,
             command_message,
             grpc_client,
-            is_saved,
+            command_handler,
+            terminal,
             current_position,
             total_count,
         ).await;
@@ -68,7 +72,8 @@ async fn process_command(
     command_input: &mut String,
     command_message: &mut String,
     grpc_client: &mut GrpcClient,
-    is_saved: &mut bool,
+    command_handler: &mut CommandHandler,
+    terminal: &mut TerminalCore,
     current_position: &mut u64,
     total_count: u64,
 ) -> Result<(bool, String, bool), Box<dyn std::error::Error>> {
@@ -84,32 +89,24 @@ async fn process_command(
         .unwrap_or("unknown");
 
     match action {
+        "force_quit" | "save_and_quit" | "quit" => {
+            let (should_exit, message) = command_handler
+                .handle_command(action, terminal)
+                .await?;
+            command_input.clear();
+            Ok((should_exit, message, true))
+        },
         "save" => {
             let message = common::save(
                 form_state,
                 grpc_client,
-                is_saved,
+                &mut command_handler.is_saved,
                 current_position,
                 total_count,
             ).await?;
             command_input.clear();
             return Ok((false, message, true));
         },
-        "force_quit" => {
-            let (should_exit, message) = common::force_quit();
-            command_input.clear();
-            return Ok((should_exit, message, true));
-        },
-        "save_and_quit" => {
-            let (should_exit, message) = common::save_and_quit(
-                form_state,
-                grpc_client,
-                current_position,
-                total_count,
-            ).await?;
-            command_input.clear();
-            return Ok((should_exit, message, true));
-        },
         "revert" => {
             let message = common::revert(
                 form_state,

client/src/modes/general/navigation.rs

@@ -1,33 +1,147 @@
 // src/modes/general/navigation.rs
+
+use crossterm::event::KeyEvent;
+use crate::config::binds::config::Config;
 use crate::state::state::AppState;
 use crate::ui::handlers::form::FormState;
 
+pub async fn handle_navigation_event(
+    key: KeyEvent,
+    config: &Config,
+    form_state: &mut FormState,
+    app_state: &mut AppState,
+    command_mode: &mut bool,
+    command_input: &mut String,
+    command_message: &mut String,
+) -> Result<(bool, String), Box<dyn std::error::Error>> {
+    if let Some(action) = config.get_general_action(key.code, key.modifiers) {
+        match action {
+            "move_up" => {
+                move_up(app_state);
+                return Ok((false, String::new()));
+            }
+            "move_down" => {
+                let item_count = if app_state.ui.show_intro {
+                    2 // Intro options count
+                } else {
+                    app_state.profile_tree.profiles.len() // Admin panel items
+                };
+                move_down(app_state, item_count);
+                return Ok((false, String::new()));
+            }
+            "next_option" => {
+                next_option(app_state, 2); // Intro has 2 options
+                return Ok((false, String::new()));
+            }
+            "previous_option" => {
+                previous_option(app_state);
+                return Ok((false, String::new()));
+            }
+            "select" => {
+                select(app_state);
+                return Ok((false, "Selected".to_string()));
+            }
+            "toggle_sidebar" => {
+                toggle_sidebar(app_state);
+                return Ok((false, format!("Sidebar {}",
+                    if app_state.ui.show_sidebar { "shown" } else { "hidden" }
+                )));
+            }
+            "next_field" => {
+                next_field(form_state);
+                return Ok((false, String::new()));
+            }
+            "prev_field" => {
+                prev_field(form_state);
+                return Ok((false, String::new()));
+            }
+            "enter_command_mode" => {
+                handle_enter_command_mode(command_mode, command_input, command_message);
+                return Ok((false, String::new()));
+            }
+            _ => {}
+        }
+    }
+    Ok((false, String::new()))
+}
+
 pub fn move_up(app_state: &mut AppState) {
-    app_state.general.selected_item = app_state.general.selected_item.saturating_sub(1);
+    if app_state.ui.show_intro {
+        app_state.ui.intro_state.previous_option();
+    } else if app_state.ui.show_admin {
+        // Assuming profile_tree.profiles is the list we're navigating
+        let profile_count = app_state.profile_tree.profiles.len();
+        if profile_count == 0 {
+            return;
+        }
+
+        // Use general state for tracking selection in admin panel
+        if app_state.general.selected_item == 0 {
+            app_state.general.selected_item = profile_count - 1;
+        } else {
+            app_state.general.selected_item = app_state.general.selected_item.saturating_sub(1);
+        }
+    }
 }
 
 pub fn move_down(app_state: &mut AppState, item_count: usize) {
-    app_state.general.selected_item = app_state.general.selected_item.saturating_add(1);
+    if app_state.ui.show_intro {
-    if item_count > 0 {
+        app_state.ui.intro_state.next_option();
-        app_state.general.selected_item = app_state.general.selected_item.min(item_count - 1);
+    } else if app_state.ui.show_admin {
+        // Assuming profile_tree.profiles is the list we're navigating
+        let profile_count = app_state.profile_tree.profiles.len();
+        if profile_count == 0 {
+            return;
+        }
+
+        app_state.general.selected_item = (app_state.general.selected_item + 1) % profile_count;
     }
 }
 
 pub fn next_option(app_state: &mut AppState, option_count: usize) {
-    app_state.general.current_option = app_state.general.current_option.saturating_add(1);
+    if app_state.ui.show_intro {
-    if option_count > 0 {
+        app_state.ui.intro_state.next_option();
-        app_state.general.current_option = app_state.general.current_option.min(option_count - 1);
+    } else {
+        // For other screens that might have options
+        app_state.general.current_option = (app_state.general.current_option + 1) % option_count;
     }
 }
 
 pub fn previous_option(app_state: &mut AppState) {
-    app_state.general.current_option = app_state.general.current_option.saturating_sub(1);
+    if app_state.ui.show_intro {
+        app_state.ui.intro_state.previous_option();
+    } else {
+        // For other screens that might have options
+        if app_state.general.current_option == 0 {
+            // We'd need the option count here, but since it's not passed we can't wrap around correctly
+            // For now, just stay at 0
+        } else {
+            app_state.general.current_option -= 1;
+        }
+    }
 }
 
 pub fn select(app_state: &mut AppState) {
-    app_state.ui.show_form = app_state.ui.intro_state.selected_option == 0;
+    if app_state.ui.show_intro {
-    app_state.ui.show_admin = app_state.ui.intro_state.selected_option == 1;
+        // Handle selection in intro screen
-    app_state.ui.show_intro = false;
+        if app_state.ui.intro_state.selected_option == 0 {
+            // First option selected - show form
+            app_state.ui.show_form = true;
+            app_state.ui.show_admin = false;
+        } else {
+            // Second option selected - show admin
+            app_state.ui.show_form = false;
+            app_state.ui.show_admin = true;
+        }
+        app_state.ui.show_intro = false;
+    } else if app_state.ui.show_admin {
+        // Handle selection in admin panel
+        let profiles = &app_state.profile_tree.profiles;
+        if !profiles.is_empty() && app_state.general.selected_item < profiles.len() {
+            // Set the selected profile
+            app_state.selected_profile = Some(profiles[app_state.general.selected_item].name.clone());
+        }
+    }
 }
 
 pub fn toggle_sidebar(app_state: &mut AppState) {
@@ -42,25 +156,20 @@ pub fn next_field(form_state: &mut FormState) {
 
 pub fn prev_field(form_state: &mut FormState) {
     if !form_state.fields.is_empty() {
-        form_state.current_field = if form_state.current_field == 0 {
+        if form_state.current_field == 0 {
-            form_state.fields.len() - 1
+            form_state.current_field = form_state.fields.len() - 1;
         } else {
-            form_state.current_field - 1
+            form_state.current_field -= 1;
-        };
+        }
     }
 }
 
-pub fn handle_enter_command_mode(event_handler: &mut crate::modes::handlers::event::EventHandler) {
+pub fn handle_enter_command_mode(
-    event_handler.command_mode = true;
+    command_mode: &mut bool,
-    event_handler.command_input.clear();
+    command_input: &mut String,
-    event_handler.command_message.clear();
+    command_message: &mut String
-}
+) {
-
+    *command_mode = true;
-// Helper function for bounds checking in lists
+    command_input.clear();
-pub fn clamp_index(selected: usize, item_count: usize) -> usize {
+    command_message.clear();
-    if item_count == 0 {
-        0
-    } else {
-        selected.min(item_count - 1)
-    }
 }

client/src/modes/handlers/event.rs

@@ -4,16 +4,16 @@ use crossterm::cursor::SetCursorStyle;
 use crate::tui::terminal::{
     core::TerminalCore,
     grpc_client::GrpcClient,
-    commands::CommandHandler,
 };
+use crate::tui::controls::commands::CommandHandler;
 use crate::config::binds::config::Config;
 use crate::ui::handlers::form::FormState;
 use crate::ui::handlers::rat_state::UiStateHandler;
 use crate::modes::{
     common::{command_mode},
     canvas::{edit, read_only, common},
+    general::navigation,
 };
-use crate::modes::navigation;
 use crate::config::binds::key_sequences::KeySequenceTracker;
 use crate::modes::handlers::mode_manager::{ModeManager, AppMode};
 
@@ -70,12 +70,15 @@ impl EventHandler {
             // Mode-specific handling
             match current_mode {
                 AppMode::General => {
-                    return self.handle_general_mode(
+                    return navigation::handle_navigation_event(
                         key,
                         config,
                         form_state,
                         app_state,
-                    );
+                        &mut self.command_mode,
+                        &mut self.command_input,
+                        &mut self.command_message,
+                    ).await;
                 },
 
                 AppMode::ReadOnly => {
@@ -122,7 +125,7 @@ impl EventHandler {
                     ) {
                         match action {
                             "save" | "force_quit" | "save_and_quit" | "revert" => {
-                                return self.handle_core_action(
+                                return common::handle_core_action(
                                     action,
                                     form_state,
                                     grpc_client,
@@ -181,7 +184,7 @@ impl EventHandler {
                     ) {
                         match action {
                             "save" | "force_quit" | "save_and_quit" | "revert" => {
-                                return self.handle_core_action(
+                                return common::handle_core_action(
                                     action,
                                     form_state,
                                     grpc_client,
@@ -221,7 +224,8 @@ impl EventHandler {
                         &mut self.command_input,
                         &mut self.command_message,
                         grpc_client,
-                        &mut app_state.ui.is_saved,
+                        command_handler,
+                        terminal,
                         current_position,
                         total_count,
                     ).await?;
@@ -240,107 +244,5 @@ impl EventHandler {
         Ok((false, self.command_message.clone()))
     }
 
-    // Helper method for handling general mode actions
-    fn handle_general_mode(
-        &mut self,
-        key: KeyEvent,
-        config: &Config,
-        form_state: &mut FormState,
-        app_state: &mut crate::state::state::AppState,
-    ) -> Result<(bool, String), Box<dyn std::error::Error>> {
-        if let Some(action) = config.get_general_action(key.code, key.modifiers) {
-            match action {
-                "move_up" => {
-                    navigation::move_up(app_state);
-                    return Ok((false, String::new()));
-                }
-                "move_down" => {
-                    let item_count = if app_state.ui.show_intro {
-                        2 // Intro options count
-                    } else {
-                        app_state.profile_tree.profiles.len() // Admin panel items
-                    };
-                    navigation::move_down(app_state, item_count);
-                    return Ok((false, String::new()));
-                }
-                "next_option" => {
-                    navigation::next_option(app_state, 2); // Intro has 2 options
-                    return Ok((false, String::new()));
-                }
-                "previous_option" => {
-                    navigation::previous_option(app_state);
-                    return Ok((false, String::new()));
-                }
-                "select" => {
-                    navigation::select(app_state);
-                    return Ok((false, "Selected".to_string()));
-                }
-                "toggle_sidebar" => {
-                    navigation::toggle_sidebar(app_state);
-                    return Ok((false, format!("Sidebar {}",
-                        if app_state.ui.show_sidebar { "shown" } else { "hidden" }
-                    )));
-                }
-                "next_field" => {
-                    navigation::next_field(form_state);
-                    return Ok((false, String::new()));
-                }
-                "prev_field" => {
-                    navigation::prev_field(form_state);
-                    return Ok((false, String::new()));
-                }
-                "enter_command_mode" => {
-                    navigation::handle_enter_command_mode(self);
-                    return Ok((false, String::new()));
-                }
-                _ => {}
-            }
-        }
-        Ok((false, String::new()))
-    }
 
-    // Helper method for handling core application actions (not navigation)
-    async fn handle_core_action(
-        &mut self,
-        action: &str,
-        form_state: &mut FormState,
-        grpc_client: &mut GrpcClient,
-        command_handler: &mut CommandHandler,
-        terminal: &mut TerminalCore,
-        app_state: &mut crate::state::state::AppState,
-        current_position: &mut u64,
-        total_count: u64,
-    ) -> Result<(bool, String), Box<dyn std::error::Error>> {
-        match action {
-            "save" => {
-                let message = common::save(
-                    form_state,
-                    grpc_client,
-                    &mut app_state.ui.is_saved,
-                    current_position,
-                    total_count,
-                ).await?;
-                Ok((false, message))
-            },
-            "force_quit" => {
-                let (should_exit, message) = command_handler.handle_command("force_quit", terminal).await?;
-                Ok((should_exit, message))
-            },
-            "save_and_quit" => {
-                let (should_exit, message) = command_handler.handle_command("save_and_quit", terminal).await?;
-                Ok((should_exit, message))
-            },
-            "revert" => {
-                let message = common::revert(
-                    form_state,
-                    grpc_client,
-                    current_position,
-                    total_count,
-                ).await?;
-                Ok((false, message))
-            },
-            // We should never hit this case given our filtering above
-            _ => Ok((false, format!("Core action not handled: {}", action))),
-        }
-    }
 }

client/src/tui/controls.rs

@@ -0,0 +1,5 @@
+// src/tui/controls.rs
+
+pub mod commands;
+
+pub use commands::*;

client/src/tui/controls/commands.rs

@@ -1,9 +1,8 @@
-// src/tui/terminal/commands.rs
+// src/tui/controls/commands.rs
-
 use crate::tui::terminal::core::TerminalCore;
 
 pub struct CommandHandler {
-    is_saved: bool,
+    pub is_saved: bool,
 }
 
 impl CommandHandler {
@@ -24,7 +23,10 @@ impl CommandHandler {
         }
     }
 
-    async fn handle_quit(&self, terminal: &mut TerminalCore) -> Result<(bool, String), Box<dyn std::error::Error>> {
+    async fn handle_quit(
+        &self,
+        terminal: &mut TerminalCore,
+    ) -> Result<(bool, String), Box<dyn std::error::Error>> {
         if self.is_saved {
             terminal.cleanup()?;
             Ok((true, "Exiting.".into()))
@@ -33,12 +35,18 @@ impl CommandHandler {
         }
     }
 
-    async fn handle_force_quit(&self, terminal: &mut TerminalCore) -> Result<(bool, String), Box<dyn std::error::Error>> {
+    async fn handle_force_quit(
+        &self,
+        terminal: &mut TerminalCore,
+    ) -> Result<(bool, String), Box<dyn std::error::Error>> {
         terminal.cleanup()?;
         Ok((true, "Force exiting without saving.".into()))
     }
 
-    async fn handle_save_quit(&mut self, terminal: &mut TerminalCore) -> Result<(bool, String), Box<dyn std::error::Error>> {
+    async fn handle_save_quit(
+        &mut self,
+        terminal: &mut TerminalCore,
+    ) -> Result<(bool, String), Box<dyn std::error::Error>> {
         self.is_saved = true;
         terminal.cleanup()?;
         Ok((true, "State saved. Exiting.".into()))

client/src/tui/mod.rs

@@ -1,2 +1,4 @@
 // src/tui/mod.rs
 pub mod terminal;
+pub mod controls;
+

client/src/tui/terminal.rs

@@ -2,10 +2,8 @@
 
 pub mod core;
 pub mod grpc_client;
-pub mod commands;
 pub mod event_reader;
 
 pub use core::TerminalCore;
 pub use grpc_client::GrpcClient;
-pub use commands::CommandHandler;
 pub use event_reader::EventReader;

client/src/ui/handlers/form.rs

@@ -38,7 +38,7 @@ impl FormState {
         let fields: Vec<&str> = self.fields.iter().map(|s| s.as_str()).collect();
         let values: Vec<&String> = self.values.iter().collect();
 
-        crate::components::handlers::form::render_form(
+        crate::components::form::form::render_form(
             f,
             area,
             self,

client/src/ui/handlers/render.rs

@@ -4,7 +4,8 @@ use crate::components::{
     render_background,
     render_command_line,
     render_status_line,
-    handlers::{sidebar::{self, calculate_sidebar_layout}, form::render_form},
+    handlers::sidebar::{self, calculate_sidebar_layout},
+    form::form::render_form,
     intro::{intro},
     admin::{admin_panel::AdminPanelState},
 };
@@ -26,7 +27,7 @@ pub fn render_ui(
     command_mode: bool,
     command_message: &str,
     app_state: &AppState,
-    intro_state: &intro::IntroState,
+    // intro_state parameter removed
 ) {
     render_background(f, f.area(), theme);
 
@@ -41,24 +42,24 @@ pub fn render_ui(
 
     let main_content_area = root[0];
     if app_state.ui.show_intro {
-        intro_state.render(f, main_content_area, theme);
+        // Use app_state's intro_state directly
+        app_state.ui.intro_state.render(f, main_content_area, theme);
     } else if app_state.ui.show_admin {
         // Create temporary AdminPanelState for rendering
         let mut admin_state = AdminPanelState::new(
-            if app_state.profile_tree.profiles.is_empty() {
+            app_state.profile_tree.profiles
-                // Fallback if admin_profiles is empty
+                .iter()
-                app_state.profile_tree.profiles
+                .map(|p| p.name.clone())
-                    .iter()
+                .collect()
-                    .map(|p| p.name.clone())
-                    .collect()
-            } else {
-                app_state.profile_tree.profiles.iter().map(|p| p.name.clone()).collect()
-            }
         );
 
-        // Set the selected item
+        // Set the selected item - FIXED
         if !admin_state.profiles.is_empty() {
-            app_state.general.selected_item.min(admin_state.profiles.len().saturating_sub(1));
+            let selected_index = std::cmp::min(
+                app_state.general.selected_item,
+                admin_state.profiles.len() - 1
+            );
+            admin_state.list_state.select(Some(selected_index));
         }
 
         admin_state.render(

client/src/ui/handlers/ui.rs

@@ -2,7 +2,7 @@
 
 use crate::tui::terminal::TerminalCore;
 use crate::tui::terminal::GrpcClient;
-use crate::tui::terminal::CommandHandler;
+use crate::tui::controls::CommandHandler;
 use crate::tui::terminal::EventReader;
 use crate::config::colors::themes::Theme;
 use crate::config::binds::config::Config;
@@ -74,7 +74,6 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
                 event_handler.command_mode,
                 &event_handler.command_message,
                 &app_state,
-                &intro_state,
             );
         })?;