fix: WIP create tui claim generator

Author: InfiniteTabs

cli/src/tui/app.rs

@@ -1,8 +1,8 @@
 use anyhow::Result;
 
 use super::state::{
-    detail_state::DetailState, events_state::EventsState, modal_state::ModalState,
-    search_state::SearchState, view_state::ViewState,
+    claim_builder_state::ClaimBuilderState, detail_state::DetailState, events_state::EventsState,
+    modal_state::ModalState, search_state::SearchState, view_state::ViewState,
 };
 use super::utils::NavItem;
 use crate::current_region_handler;
@@ -35,6 +35,8 @@ pub enum PendingAction {
     LoadJobLogs(String),
     ReapplyDeployment(usize),
     DestroyDeployment(usize),
+    SaveClaimToFile,
+    RunClaimFromBuilder,
 }
 
 #[derive(Debug, Clone)]
@@ -100,6 +102,7 @@ pub struct App {
     pub events_state: EventsState,
     pub modal_state: ModalState,
     pub search_state: SearchState,
+    pub claim_builder_state: ClaimBuilderState,
 
     // ==================== LEGACY FIELDS (TRANSITIONING) ====================
     // These are kept for backward compatibility during migration.
@@ -167,6 +170,7 @@ impl App {
         let events_state = EventsState::new();
         let modal_state = ModalState::new();
         let search_state = SearchState::new();
+        let claim_builder_state = ClaimBuilderState::new();
 
         Self {
             // Core app state
@@ -189,6 +193,7 @@ impl App {
             events_state,
             modal_state,
             search_state,
+            claim_builder_state,
 
             // Legacy fields - initialized from defaults for backward compatibility
             // View state
@@ -585,6 +590,12 @@ impl App {
                 self.selected_index = index;
                 self.destroy_deployment().await?;
             }
+            PendingAction::SaveClaimToFile => {
+                self.save_claim_to_file().await?;
+            }
+            PendingAction::RunClaimFromBuilder => {
+                self.run_claim_from_builder().await?;
+            }
         }
 
         Ok(())
@@ -640,6 +651,12 @@ impl App {
             PendingAction::DestroyDeployment(_) => {
                 self.set_loading("Destroying deployment...");
             }
+            PendingAction::SaveClaimToFile => {
+                self.set_loading("Saving claim to file...");
+            }
+            PendingAction::RunClaimFromBuilder => {
+                self.set_loading("Running claim...");
+            }
         }
     }
 
@@ -2032,6 +2049,129 @@ impl App {
         }
         self.close_confirmation();
     }
+
+    /// Save the claim builder's generated YAML to a file
+    pub async fn save_claim_to_file(&mut self) -> Result<()> {
+        use std::fs;
+        use std::path::PathBuf;
+
+        // Validate the form first
+        if let Err(err) = self.claim_builder_state.validate() {
+            self.detail_state
+                .show_error(&format!("Validation failed: {}", err));
+            self.clear_loading();
+            return Ok(());
+        }
+
+        // Generate the YAML
+        self.claim_builder_state.generate_yaml();
+
+        // Create a filename based on deployment name
+        let deployment_name = if self.claim_builder_state.deployment_name.is_empty() {
+            "deployment".to_string()
+        } else {
+            self.claim_builder_state.deployment_name.clone()
+        };
+
+        let filename = format!("{}.yaml", deployment_name);
+        let mut filepath = PathBuf::from("./");
+        filepath.push(&filename);
+
+        // Write to file
+        match fs::write(&filepath, &self.claim_builder_state.generated_yaml) {
+            Ok(_) => {
+                self.detail_state
+                    .show_message(format!("Claim saved to: {}", filepath.display()));
+                // Close the claim builder after successful save
+                self.claim_builder_state.close();
+            }
+            Err(e) => {
+                self.detail_state
+                    .show_error(&format!("Failed to save claim: {}", e));
+            }
+        }
+
+        self.clear_loading();
+        Ok(())
+    }
+
+    pub async fn run_claim_from_builder(&mut self) -> Result<()> {
+        use crate::utils::get_environment;
+        use env_common::logic::run_claim;
+        use env_defs::ExtraData;
+
+        // Validate the form first
+        if let Err(err) = self.claim_builder_state.validate() {
+            self.detail_state
+                .show_error(&format!("Validation failed: {}", err));
+            self.clear_loading();
+            return Ok(());
+        }
+
+        // Generate the YAML
+        self.claim_builder_state.generate_yaml();
+
+        // Parse the claim YAML
+        let yaml: serde_yaml::Value =
+            match serde_yaml::from_str(&self.claim_builder_state.generated_yaml) {
+                Ok(y) => y,
+                Err(e) => {
+                    self.detail_state
+                        .show_error(&format!("Failed to parse YAML: {}", e));
+                    self.clear_loading();
+                    return Ok(());
+                }
+            };
+
+        // Use the same environment handling as the CLI
+        let environment = get_environment("default");
+
+        let reference_fallback = match hostname::get() {
+            Ok(hostname) => hostname.to_string_lossy().to_string(),
+            Err(e) => {
+                self.detail_state
+                    .show_error(&format!("Failed to get hostname: {}", e));
+                self.clear_loading();
+                return Ok(());
+            }
+        };
+
+        // Run the claim using current_region_handler (same as reapply_deployment)
+        let handler = current_region_handler().await;
+        match run_claim(
+            &handler,
+            &yaml,
+            &environment,
+            "apply",
+            vec![],
+            ExtraData::None,
+            &reference_fallback,
+        )
+        .await
+        {
+            Ok((job_id, deployment_id, _)) => {
+                let message = format!(
+                    "✅ Claim applied successfully!\n\nJob ID: {}\nDeployment ID: {}\nEnvironment: {}",
+                    job_id, deployment_id, environment
+                );
+
+                self.detail_state.show_message(message.clone());
+
+                // Close the claim builder after successful run
+                self.claim_builder_state.close();
+
+                // Reload deployments list
+                self.schedule_action(PendingAction::LoadDeployments);
+            }
+            Err(e) => {
+                let message = format!("❌ Failed to run claim:\n\n{}", e);
+                self.detail_state.show_message(message);
+            }
+        }
+
+        self.clear_loading();
+        Ok(())
+    }
 }
 
 // Implement VersionItem trait for Module to work with VersionsModal widget

cli/src/tui/events/claim_builder_handler.rs

@@ -0,0 +1,135 @@
+use anyhow::Result;
+use crossterm::event::{KeyCode, KeyModifiers};
+
+use crate::tui::app::App;
+
+pub struct ClaimBuilderHandler;
+
+impl ClaimBuilderHandler {
+    pub fn handle_key(app: &mut App, key: KeyCode, modifiers: KeyModifiers) -> Result<()> {
+        let state = &mut app.claim_builder_state;
+
+        // Handle Ctrl key combinations first
+        if modifiers.contains(KeyModifiers::CONTROL) {
+            match key {
+                KeyCode::Char('p') => {
+                    state.toggle_preview();
+                    return Ok(());
+                }
+                KeyCode::Char('s') => {
+                    // Save to file
+                    if state.show_preview {
+                        app.schedule_action(crate::tui::app::PendingAction::SaveClaimToFile);
+                    } else {
+                        state.generate_yaml();
+                        app.schedule_action(crate::tui::app::PendingAction::SaveClaimToFile);
+                    }
+                    return Ok(());
+                }
+                KeyCode::Char('r') => {
+                    // Run claim
+                    if state.show_preview {
+                        app.schedule_action(crate::tui::app::PendingAction::RunClaimFromBuilder);
+                    } else {
+                        state.generate_yaml();
+                        app.schedule_action(crate::tui::app::PendingAction::RunClaimFromBuilder);
+                    }
+                    return Ok(());
+                }
+                KeyCode::Char('t') => {
+                    // Insert template for current field type
+                    if !state.show_preview {
+                        state.insert_template();
+                    }
+                    return Ok(());
+                }
+                _ => {}
+            }
+        }
+
+        if state.show_preview {
+            // Preview mode navigation
+            match key {
+                KeyCode::Up => {
+                    state.scroll_preview_up();
+                }
+                KeyCode::Down => {
+                    state.scroll_preview_down();
+                }
+                KeyCode::PageUp => {
+                    for _ in 0..10 {
+                        state.scroll_preview_up();
+                    }
+                }
+                KeyCode::PageDown => {
+                    for _ in 0..10 {
+                        state.scroll_preview_down();
+                    }
+                }
+                KeyCode::Esc => {
+                    // Go back to form editing instead of closing
+                    state.toggle_preview();
+                }
+                _ => {}
+            }
+        } else {
+            // Form editing mode
+            match key {
+                KeyCode::Tab => {
+                    state.next_field();
+                }
+                KeyCode::BackTab => {
+                    state.previous_field();
+                }
+                KeyCode::Up => {
+                    state.previous_field();
+                }
+                KeyCode::Down => {
+                    state.next_field();
+                }
+                KeyCode::Left => {
+                    state.move_cursor_left();
+                }
+                KeyCode::Right => {
+                    state.move_cursor_right();
+                }
+                KeyCode::Home => match state.selected_field_index {
+                    0 => state.deployment_name_cursor = 0,
+                    i if i >= 1 => {
+                        let var_index = i - 1;
+                        if let Some(input) = state.variable_inputs.get_mut(var_index) {
+                            input.move_cursor_home();
+                        }
+                    }
+                    _ => {}
+                },
+                KeyCode::End => match state.selected_field_index {
+                    0 => state.deployment_name_cursor = state.deployment_name.len(),
+                    i if i >= 1 => {
+                        let var_index = i - 1;
+                        if let Some(input) = state.variable_inputs.get_mut(var_index) {
+                            input.move_cursor_end();
+                        }
+                    }
+                    _ => {}
+                },
+                KeyCode::Backspace => {
+                    state.backspace();
+                }
+                KeyCode::Enter => {
+                    // Toggle YAML preview
+                    state.toggle_preview();
+                }
+                KeyCode::Char(c) => {
+                    state.insert_char(c);
+                }
+                KeyCode::Esc => {
+                    state.close();
+                }
+                _ => {}
+            }
+        }
+
+        Ok(())
+    }
+}

cli/src/tui/events/detail_handler.rs

@@ -11,6 +11,14 @@ impl DetailHandler {
             KeyCode::Esc | KeyCode::Char('q') => {
                 app.close_detail();
             }
+            KeyCode::Char('c') => {
+                // Open claim builder
+                if let Some(module) = app.detail_state.detail_module.clone() {
+                    app.claim_builder_state.open_for_module(module);
+                } else if let Some(stack) = app.detail_state.detail_stack.clone() {
+                    app.claim_builder_state.open_for_stack(stack);
+                }
+            }
             KeyCode::Char('h') | KeyCode::Left => {
                 app.detail_focus_left();
             }

cli/src/tui/events/mod.rs

@@ -1,8 +1,10 @@
+pub mod claim_builder_handler;
 pub mod detail_handler;
 pub mod events_handler;
 pub mod main_handler;
 pub mod modal_handler;
 
+pub use claim_builder_handler::ClaimBuilderHandler;
 pub use detail_handler::DetailHandler;
 pub use events_handler::EventsHandler;
 pub use main_handler::MainHandler;

cli/src/tui/handlers.rs

@@ -3,7 +3,7 @@ use crossterm::event::{self, Event, KeyCode, KeyEventKind, KeyModifiers};
 use std::time::Duration;
 
 use super::app::App;
-use super::events::{DetailHandler, EventsHandler, MainHandler, ModalHandler};
+use super::events::{ClaimBuilderHandler, DetailHandler, EventsHandler, MainHandler, ModalHandler};
 
 pub async fn handle_events(app: &mut App) -> Result<()> {
     if event::poll(Duration::from_millis(100))? {
@@ -33,6 +33,10 @@ fn handle_key_event(app: &mut App, key: KeyCode, modifiers: KeyModifiers) -> Res
         return ModalHandler::handle_versions_key(app, key);
     }
 
+    if app.claim_builder_state.showing_claim_builder {
+        return ClaimBuilderHandler::handle_key(app, key, modifiers);
+    }
+
     if app.events_state.showing_events {
         return EventsHandler::handle_key(app, key);
     }

cli/src/tui/renderers/common.rs

@@ -196,6 +196,7 @@ fn get_footer_actions(app: &App) -> Vec<(&'static str, &'static str)> {
                 }
             }
 
+            shortcuts.push(("c", "Build Claim"));
             shortcuts.push(("ESC/q", "Close"));
             shortcuts.push(("Ctrl+C", "Quit"));
 

cli/src/tui/renderers/modules_renderer.rs

@@ -49,7 +49,7 @@ pub fn render_modules(frame: &mut Frame, area: Rect, app: &App) {
     let headers = vec!["Module Name", "Stable", "RC", "Beta", "Alpha", "Dev"];
     let widths = vec![30, 10, 10, 15, 15, 20];
 
-    let widget = TableWidget::new("📦 Modules", "📦", headers, widths)
+    let widget = TableWidget::new("Modules", "📦", headers, widths)
         .with_rows(rows)
         .with_selected(app.selected_index);