merged with main

Reviewed-on: #12

Cargo.lock

@@ -853,7 +853,7 @@ dependencies = [
 
 [[package]]
 name = "mould"
-version = "0.2.0"
+version = "0.4.3"
 dependencies = [
  "anyhow",
  "clap",

Cargo.toml

@@ -1,27 +1,33 @@
-[package]
-name = "mould"
-version = "0.2.1"
-edition = "2024"
-authors = ["Nils Pukropp <nils@narl.io>"]
-
 [[bin]]
 name = "mould"
 path = "src/main.rs"
 
 [dependencies]
 anyhow = "1.0.102"
-clap = { version = "4.6.0", features = ["derive"] }
 crossterm = "0.29.0"
 dirs = "6.0.0"
 env_logger = "0.11.9"
 log = "0.4.29"
 ratatui = "0.30.0"
-serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"
 serde_yaml = "0.9.34"
 thiserror = "2.0.18"
 toml = "1.0.6"
 tui-input = "0.15.0"
 
+[dependencies.clap]
+features = ["derive"]
+version = "4.6.0"
+
+[dependencies.serde]
+features = ["derive"]
+version = "1.0.228"
+
 [dev-dependencies]
 tempfile = "3.27.0"
+
+[package]
+authors = ["Nils Pukropp <nils@narl.io>"]
+edition = "2024"
+name = "mould"
+version = "0.4.3"

README.md

@@ -5,15 +5,18 @@ mould is a modern Terminal User Interface (TUI) tool designed for interactively
 ## Features
 
 - **Universal Format Support**: Handle `.env`, `JSON`, `YAML`, and `TOML` seamlessly.
-- **Hierarchical Flattening**: Edit nested data structures (JSON, YAML, TOML) in a flat, searchable list.
+- **Tree View Navigation**: Edit nested data structures (JSON, YAML, TOML) in a beautiful, depth-colored tree view.
+- **Smart Template Comparison**: Automatically discovers `.env.example` vs `.env` relationships and highlights missing or modified keys.
+- **Add Missing Keys**: Instantly pull missing keys and their default values from your template into your active configuration with a single keystroke.
+- **Neovim Integration**: Comes with a built-in Neovim plugin for seamless in-editor configuration management.
 - **Docker Compose Integration**: Automatically generate `docker-compose.override.yml` from `docker-compose.yml`.
-- **Vim-inspired Workflow**: Navigate with `j`/`k`, edit with `i`, and save with `:w`.
-- **Modern UI**: A polished, rounded interface featuring the Catppuccin Mocha palette.
-- **Highly Configurable**: Customize keybindings and themes via a simple TOML configuration.
-- **Dynamic Alignment**: Automatically aligns keys and values for perfect vertical readability.
+- **Vim-inspired Workflow**: Navigate with `j`/`k`, `gg`/`G`, edit with `i`, search with `/`, and save with `:w`.
+- **Modern UI**: A polished, rounded interface featuring a semantic Catppuccin Mocha palette.
+- **Highly Configurable**: Customize keybindings and semantic themes via a simple TOML configuration.
 
 ## Installation
 
+### CLI Application
 Ensure you have Rust and Cargo installed, then run:
 
 ```sh
@@ -28,11 +31,19 @@ cd mould
 cargo build --release
 ```
 
-The binary will be installed as `mould`.
+### Neovim Plugin
+If you use a plugin manager like `mini.deps`, you can add the repository directly:
+
+```lua
+add({
+	source = 'https://git.narl.io/nvrl/mould-rs',
+	checkout = 'main',
+})
+```
 
 ## Usage
 
-Provide an input template file to start editing:
+Provide an input template file to start editing. `mould` is smart enough to figure out if it's looking at a template or an active file, and will search for its counterpart to provide diffing.
 
 ```sh
 mould .env.example
@@ -45,7 +56,19 @@ mould config.template.json -o config.json
 - **Normal Mode**
   - `j` / `Down`: Move selection down
   - `k` / `Up`: Move selection up
-  - `i`: Edit the value of the currently selected key (Enter Insert Mode)
+  - `gg`: Jump to the top
+  - `G`: Jump to the bottom
+  - `i`: Edit value (cursor at start)
+  - `A`: Edit value (cursor at end)
+  - `S`: Substitute value (clear and edit)
+  - `o`: Append a new item to the current array
+  - `O`: Prepend a new item to the current array
+  - `dd`: Delete the currently selected variable or group
+  - `u`: Undo the last change
+  - `a`: Add missing value from template to active config
+  - `/`: Search for configuration keys (Jump to matches)
+  - `n`: Jump to the next search match
+  - `N`: Jump to the previous search match
   - `:w` or `Enter`: Save the current configuration to the output file
   - `:q` or `q`: Quit the application
   - `:wq`: Save and quit
@@ -70,9 +93,33 @@ edit = "i"
 save = ":w"
 quit = ":q"
 normal_mode = "Esc"
+search = "/"
+next_match = "n"
+previous_match = "N"
+jump_top = "gg"
+jump_bottom = "G"
 
 [theme]
-name = "catppuccin_mocha"
+# Enable transparency to let your terminal background show through
+transparent = false
+
+# Custom color palette (Semantic Catppuccin Mocha defaults)
+bg_normal = "#1e1e2e"
+bg_highlight = "#89b4fa"
+bg_active = "#a6e3a1"
+bg_search = "#cba6f7"
+fg_normal = "#cdd6f4"
+fg_dimmed = "#6c7086"
+fg_highlight = "#1e1e2e"
+fg_warning = "#f38ba8"
+fg_modified = "#fab387"
+fg_accent = "#b4befe"
+border_normal = "#45475a"
+border_active = "#a6e3a1"
+tree_depth_1 = "#b4befe"
+tree_depth_2 = "#cba6f7"
+tree_depth_3 = "#89b4fa"
+tree_depth_4 = "#fab387"
 ```
 
 ## License

config.example.toml

@@ -0,0 +1,47 @@
+# mould Configuration Example
+# Place this file at ~/.config/mould/config.toml (Linux/macOS)
+# or %AppData%\mould\config.toml (Windows)
+
+[theme]
+# If true, skip rendering the background block to let the terminal's transparency show.
+transparent = false
+
+# Colors are specified in hex format ("#RRGGBB").
+# Default values follow the Semantic Catppuccin Mocha palette.
+
+bg_normal = "#1e1e2e"
+bg_highlight = "#89b4fa"
+bg_active = "#a6e3a1"
+bg_search = "#cba6f7"
+fg_normal = "#cdd6f4"
+fg_dimmed = "#6c7086"
+fg_highlight = "#1e1e2e"
+fg_warning = "#f38ba8"
+fg_modified = "#fab387"
+fg_accent = "#b4befe"
+border_normal = "#45475a"
+border_active = "#a6e3a1"
+tree_depth_1 = "#b4befe"
+tree_depth_2 = "#cba6f7"
+tree_depth_3 = "#89b4fa"
+tree_depth_4 = "#fab387"
+
+[keybinds]
+# Keybindings for navigation and application control.
+down = "j"
+up = "k"
+edit = "i"
+edit_append = "A"
+edit_substitute = "S"
+save = ":w"
+quit = ":q"
+normal_mode = "Esc"
+search = "/"
+next_match = "n"
+previous_match = "N"
+jump_top = "gg"
+jump_bottom = "G"
+append_item = "o"
+prepend_item = "O"
+delete_item = "dd"
+undo = "u"

lua/mould/init.lua

@@ -0,0 +1,54 @@
+local M = {}
+
+local function open_floating_terminal(cmd)
+  local buf = vim.api.nvim_create_buf(false, true)
+  local width = math.floor(vim.o.columns * 0.9)
+  local height = math.floor(vim.o.lines * 0.9)
+  local col = math.floor((vim.o.columns - width) / 2)
+  local row = math.floor((vim.o.lines - height) / 2)
+
+  local win_config = {
+    relative = "editor",
+    width = width,
+    height = height,
+    col = col,
+    row = row,
+    style = "minimal",
+    border = "rounded",
+  }
+
+  local win = vim.api.nvim_open_win(buf, true, win_config)
+  
+  -- Record the original buffer to reload it later
+  local original_buf = vim.api.nvim_get_current_buf()
+  local original_file = vim.api.nvim_buf_get_name(original_buf)
+
+  vim.fn.termopen(cmd, {
+    on_exit = function()
+      vim.api.nvim_win_close(win, true)
+      vim.api.nvim_buf_delete(buf, { force = true })
+      
+      -- Reload the original file if it exists
+      if vim.fn.filereadable(original_file) == 1 then
+        vim.schedule(function()
+          vim.cmd("checktime " .. vim.fn.fnameescape(original_file))
+        end)
+      end
+    end,
+  })
+
+  vim.cmd("startinsert")
+end
+
+function M.open()
+  local filepath = vim.api.nvim_buf_get_name(0)
+  if filepath == "" then
+    vim.notify("mould.nvim: Cannot open mould for an unnamed buffer.", vim.log.levels.ERROR)
+    return
+  end
+
+  local cmd = string.format("mould %s", vim.fn.shellescape(filepath))
+  open_floating_terminal(cmd)
+end
+
+return M

plugin/mould.lua

@@ -0,0 +1,8 @@
+if vim.g.loaded_mould == 1 then
+  return
+end
+vim.g.loaded_mould = 1
+
+vim.api.nvim_create_user_command("Mould", function()
+  require("mould").open()
+end, { desc = "Open mould for the current buffer" })

src/app.rs

@@ -1,4 +1,4 @@
-use crate::format::EnvVar;
+use crate::format::ConfigItem;
 use tui_input::Input;
 
 /// Represents the current operating mode of the application.
@@ -7,12 +7,20 @@ pub enum Mode {
     Normal,
     /// Active text entry mode for modifying values.
     Insert,
+    /// Active search mode for filtering keys.
+    Search,
+}
+
+pub enum InsertVariant {
+    Start,
+    End,
+    Substitute,
 }
 
 /// The core application state, holding all configuration variables and UI status.
 pub struct App {
     /// The list of configuration variables being edited.
-    pub vars: Vec<EnvVar>,
+    pub vars: Vec<ConfigItem>,
     /// Index of the currently selected variable in the list.
     pub selected: usize,
     /// The current interaction mode (Normal or Insert).
@@ -23,12 +31,16 @@ pub struct App {
     pub status_message: Option<String>,
     /// The active text input buffer for the selected variable.
     pub input: Input,
+    /// The current search query for filtering keys.
+    pub search_query: String,
+    /// Stack of previous variable states for undo functionality.
+    pub undo_stack: Vec<Vec<ConfigItem>>,
 }
 
 impl App {
     /// Initializes a new application instance with the provided variables.
-    pub fn new(vars: Vec<EnvVar>) -> Self {
-        let initial_input = vars.get(0).map(|v| v.value.clone()).unwrap_or_default();
+    pub fn new(vars: Vec<ConfigItem>) -> Self {
+        let initial_input = vars.get(0).and_then(|v| v.value.clone()).unwrap_or_default();
         Self {
             vars,
             selected: 0,
@@ -36,9 +48,25 @@ impl App {
             running: true,
             status_message: None,
             input: Input::new(initial_input),
+            search_query: String::new(),
+            undo_stack: Vec::new(),
         }
     }
 
+    /// Returns the indices of variables that match the search query.
+    pub fn matching_indices(&self) -> Vec<usize> {
+        if self.search_query.is_empty() {
+            return Vec::new();
+        }
+        let query = self.search_query.to_lowercase();
+        self.vars
+            .iter()
+            .enumerate()
+            .filter(|(_, v)| v.key.to_lowercase().contains(&query))
+            .map(|(i, _)| i)
+            .collect()
+    }
+
     /// Moves the selection to the next variable in the list, wrapping around if necessary.
     pub fn next(&mut self) {
         if !self.vars.is_empty() {
@@ -59,24 +87,98 @@ impl App {
         }
     }
 
+    /// Jumps to the top of the list.
+    pub fn jump_top(&mut self) {
+        if !self.vars.is_empty() {
+            self.selected = 0;
+            self.sync_input_with_selected();
+        }
+    }
+
+    /// Jumps to the bottom of the list.
+    pub fn jump_bottom(&mut self) {
+        if !self.vars.is_empty() {
+            self.selected = self.vars.len() - 1;
+            self.sync_input_with_selected();
+        }
+    }
+
+    /// Jumps to the next variable that matches the search query.
+    pub fn jump_next_match(&mut self) {
+        let indices = self.matching_indices();
+        if indices.is_empty() {
+            return;
+        }
+
+        let next_match = indices
+            .iter()
+            .find(|&&i| i > self.selected)
+            .or_else(|| indices.first());
+
+        if let Some(&index) = next_match {
+            self.selected = index;
+            self.sync_input_with_selected();
+        }
+    }
+
+    /// Jumps to the previous variable that matches the search query.
+    pub fn jump_previous_match(&mut self) {
+        let indices = self.matching_indices();
+        if indices.is_empty() {
+            return;
+        }
+
+        let prev_match = indices
+            .iter()
+            .rev()
+            .find(|&&i| i < self.selected)
+            .or_else(|| indices.last());
+
+        if let Some(&index) = prev_match {
+            self.selected = index;
+            self.sync_input_with_selected();
+        }
+    }
+
     /// Updates the input buffer to reflect the value of the currently selected variable.
     pub fn sync_input_with_selected(&mut self) {
         if let Some(var) = self.vars.get(self.selected) {
-            self.input = Input::new(var.value.clone());
+            let val = var.value.clone().unwrap_or_default();
+            self.input = Input::new(val);
         }
     }
 
     /// Commits the current text in the input buffer back to the selected variable's value.
     pub fn commit_input(&mut self) {
         if let Some(var) = self.vars.get_mut(self.selected) {
-            var.value = self.input.value().to_string();
+            if !var.is_group {
+                var.value = Some(self.input.value().to_string());
+                var.status = crate::format::ItemStatus::Modified;
+            }
         }
     }
 
-    /// Transitions the application into Insert Mode.
-    pub fn enter_insert(&mut self) {
+    /// Transitions the application into Insert Mode with a specific variant.
+    pub fn enter_insert(&mut self, variant: InsertVariant) {
+        if let Some(var) = self.vars.get(self.selected) {
+            if !var.is_group {
+                self.save_undo_state();
                 self.mode = Mode::Insert;
-        self.status_message = None;
+                match variant {
+                    InsertVariant::Start => {
+                        use tui_input::InputRequest;
+                        self.input.handle(InputRequest::GoToStart);
+                    }
+                    InsertVariant::End => {
+                        use tui_input::InputRequest;
+                        self.input.handle(InputRequest::GoToEnd);
+                    }
+                    InsertVariant::Substitute => {
+                        self.input = Input::new(String::new());
+                    }
+                }
+            }
+        }
     }
 
     /// Commits the current input and transitions the application into Normal Mode.
@@ -84,4 +186,196 @@ impl App {
         self.commit_input();
         self.mode = Mode::Normal;
     }
+
+    /// Deletes the currently selected item. If it's a group, deletes all children.
+    pub fn delete_selected(&mut self) {
+        if self.vars.is_empty() {
+            return;
+        }
+
+        self.save_undo_state();
+        let selected_path = self.vars[self.selected].path.clone();
+        let is_group = self.vars[self.selected].is_group;
+
+        // Identify if the item being removed is an array item
+        let array_info = parse_index(&selected_path);
+
+        // 1. Identify all items to remove
+        let mut to_remove = Vec::new();
+        to_remove.push(self.selected);
+
+        if is_group {
+            let prefix_dot = format!("{}.", selected_path);
+            let prefix_bracket = format!("{}[", selected_path);
+            for (i, var) in self.vars.iter().enumerate() {
+                if i == self.selected {
+                    continue;
+                }
+                if var.path.starts_with(&prefix_dot) || var.path.starts_with(&prefix_bracket) {
+                    to_remove.push(i);
+                }
+            }
+        }
+
+        // 2. Perform removal (reverse order to preserve indices)
+        to_remove.sort_unstable_by(|a, b| b.cmp(a));
+        for i in to_remove {
+            self.vars.remove(i);
+        }
+
+        // 3. Re-index subsequent array items if applicable
+        if let Some((base, removed_idx)) = array_info {
+            let base = base.to_string();
+            for var in self.vars.iter_mut() {
+                if var.path.starts_with(&base) {
+                    // We need to find the index segment that matches this array
+                    if let Some((b, i, suffix)) = find_array_segment(&var.path, &base) {
+                        if b == base && i > removed_idx {
+                            let new_idx = i - 1;
+                            var.path = format!("{}[{}]{}", base, new_idx, suffix);
+                            // Also update key if it matches the old index exactly
+                            if var.key == format!("[{}]", i) {
+                                var.key = format!("[{}]", new_idx);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // 4. Adjust selection
+        if self.selected >= self.vars.len() && !self.vars.is_empty() {
+            self.selected = self.vars.len() - 1;
+        }
+        self.sync_input_with_selected();
+    }
+
+    /// Adds a new item to an array if the selected item is part of one.
+    pub fn add_array_item(&mut self, after: bool) {
+        if self.vars.is_empty() {
+            return;
+        }
+
+        self.save_undo_state();
+        let (base, idx, depth) = {
+            let selected_item = &self.vars[self.selected];
+            if selected_item.is_group {
+                return;
+            }
+            let path = &selected_item.path;
+            if let Some((base, idx)) = parse_index(path) {
+                (base.to_string(), idx, selected_item.depth)
+            } else {
+                return;
+            }
+        };
+
+        let new_idx = if after { idx + 1 } else { idx };
+        let insert_pos = if after {
+            self.selected + 1
+        } else {
+            self.selected
+        };
+
+        // 1. Shift all items in this array that have index >= new_idx
+        for var in self.vars.iter_mut() {
+            if var.path.starts_with(&base) {
+                if let Some((b, i)) = parse_index(&var.path) {
+                    if b == base && i >= new_idx {
+                        var.path = format!("{}[{}]", base, i + 1);
+                        // Also update key if it was just the index
+                        if var.key == format!("[{}]", i) {
+                            var.key = format!("[{}]", i + 1);
+                        }
+                    }
+                }
+            }
+        }
+
+        // 2. Insert new item
+        let new_item = ConfigItem {
+            key: format!("[{}]", new_idx),
+            path: format!("{}[{}]", base, new_idx),
+            value: Some("".to_string()),
+            template_value: None,
+            default_value: None,
+            depth,
+            is_group: false,
+            status: crate::format::ItemStatus::Modified,
+            value_type: crate::format::ValueType::String,
+        };
+        self.vars.insert(insert_pos, new_item);
+        self.selected = insert_pos;
+        self.sync_input_with_selected();
+        self.enter_insert(InsertVariant::Start);
+        self.status_message = None;
+    }
+
+    /// Status bar helpers
+    pub fn selected_is_group(&self) -> bool {
+        self.vars.get(self.selected).map(|v| v.is_group).unwrap_or(false)
+    }
+
+    pub fn selected_is_array(&self) -> bool {
+        self.vars.get(self.selected)
+            .map(|v| !v.is_group && v.path.contains('['))
+            .unwrap_or(false)
+    }
+
+    pub fn selected_is_missing(&self) -> bool {
+        self.vars.get(self.selected)
+            .map(|v| v.status == crate::format::ItemStatus::MissingFromActive)
+            .unwrap_or(false)
+    }
+
+    /// Saves the current state of variables to the undo stack.
+    pub fn save_undo_state(&mut self) {
+        self.undo_stack.push(self.vars.clone());
+        if self.undo_stack.len() > 50 {
+            self.undo_stack.remove(0);
+        }
+    }
+
+    /// Reverts to the last saved state of variables.
+    pub fn undo(&mut self) {
+        if let Some(previous_vars) = self.undo_stack.pop() {
+            self.vars = previous_vars;
+            if self.selected >= self.vars.len() && !self.vars.is_empty() {
+                self.selected = self.vars.len() - 1;
+            }
+            self.sync_input_with_selected();
+            self.status_message = Some("Undo applied".to_string());
+        } else {
+            self.status_message = Some("Nothing to undo".to_string());
+        }
+    }
+}
+
+fn parse_index(path: &str) -> Option<(&str, usize)> {
+    if let Some(end) = path.rfind(']') {
+        let segment = &path[..=end];
+        if let Some(start) = segment.rfind('[') {
+            if let Ok(idx) = segment[start + 1..end].parse::<usize>() {
+                // Return the base and index
+                return Some((&path[..start], idx));
+            }
+        }
+    }
+    None
+}
+
+/// Helper to find an array segment in a path given a base prefix.
+fn find_array_segment<'a>(path: &'a str, base: &str) -> Option<(&'a str, usize, &'a str)> {
+    if !path.starts_with(base) {
+        return None;
+    }
+    let remaining = &path[base.len()..];
+    if remaining.starts_with('[') {
+        if let Some(end) = remaining.find(']') {
+            if let Ok(idx) = remaining[1..end].parse::<usize>() {
+                return Some((&path[..base.len()], idx, &remaining[end + 1..]));
+            }
+        }
+    }
+    None
 }

src/cli.rs

@@ -12,8 +12,8 @@ use std::path::PathBuf;
 )]
 pub struct Cli {
     /// The input template file (e.g., .env.example, config.json.template, docker-compose.yml)
-    #[arg(required = true, value_name = "INPUT_FILE")]
-    pub input: PathBuf,
+    #[arg(required = false, value_name = "INPUT_FILE")]
+    pub input: Option<PathBuf>,
 
     /// Optional output file. If not provided, it will be inferred.
     #[arg(short, long, value_name = "OUTPUT_FILE")]

src/config.rs

@@ -1,31 +1,45 @@
+use ratatui::style::Color;
 use serde::{Deserialize, Serialize};
 use std::fs;
-use ratatui::style::Color;
 
 /// Configuration for the application's appearance.
 #[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(default)]
 pub struct ThemeConfig {
     /// If true, skip rendering the background block to let the terminal's transparency show.
-    #[serde(default)]
     pub transparent: bool,
-    /// Color for standard background areas (when not transparent).
-    pub crust: String,
-    /// Dark surface color for UI elements like the status bar.
-    pub surface0: String,
-    /// Light surface color for borders and dividers.
-    pub surface1: String,
-    /// Default text color.
-    pub text: String,
-    /// Color for selection highlighting and normal mode tag.
-    pub blue: String,
-    /// Color for insert mode highlighting and success status.
-    pub green: String,
-    /// Accent color for configuration keys.
-    pub lavender: String,
-    /// Accent color for primary section titles.
-    pub mauve: String,
-    /// Accent color for input field titles.
-    pub peach: String,
+    /// Default background.
+    pub bg_normal: String,
+    /// Background for selected items and standard UI elements.
+    pub bg_highlight: String,
+    /// Active element background (e.g., insert mode).
+    pub bg_active: String,
+    /// Active element background (e.g., search mode).
+    pub bg_search: String,
+    /// Standard text.
+    pub fg_normal: String,
+    /// Secondary/inactive text.
+    pub fg_dimmed: String,
+    /// Text on selected items.
+    pub fg_highlight: String,
+    /// Red/Alert color for missing items.
+    pub fg_warning: String,
+    /// Accent color for modified items.
+    pub fg_modified: String,
+    /// High-contrast accent for titles and active UI elements.
+    pub fg_accent: String,
+    /// Borders.
+    pub border_normal: String,
+    /// Active borders (e.g., input mode).
+    pub border_active: String,
+    /// Color for tree indentation depth 1.
+    pub tree_depth_1: String,
+    /// Color for tree indentation depth 2.
+    pub tree_depth_2: String,
+    /// Color for tree indentation depth 3.
+    pub tree_depth_3: String,
+    /// Color for tree indentation depth 4.
+    pub tree_depth_4: String,
 }
 
 impl ThemeConfig {
@@ -42,44 +56,70 @@ impl ThemeConfig {
         }
     }
 
-    pub fn crust(&self) -> Color { Self::parse_hex(&self.crust) }
-    pub fn surface0(&self) -> Color { Self::parse_hex(&self.surface0) }
-    pub fn surface1(&self) -> Color { Self::parse_hex(&self.surface1) }
-    pub fn text(&self) -> Color { Self::parse_hex(&self.text) }
-    pub fn blue(&self) -> Color { Self::parse_hex(&self.blue) }
-    pub fn green(&self) -> Color { Self::parse_hex(&self.green) }
-    pub fn lavender(&self) -> Color { Self::parse_hex(&self.lavender) }
-    pub fn mauve(&self) -> Color { Self::parse_hex(&self.mauve) }
-    pub fn peach(&self) -> Color { Self::parse_hex(&self.peach) }
+    pub fn bg_normal(&self) -> Color { Self::parse_hex(&self.bg_normal) }
+    pub fn bg_highlight(&self) -> Color { Self::parse_hex(&self.bg_highlight) }
+    pub fn bg_active(&self) -> Color { Self::parse_hex(&self.bg_active) }
+    pub fn bg_search(&self) -> Color { Self::parse_hex(&self.bg_search) }
+    pub fn fg_normal(&self) -> Color { Self::parse_hex(&self.fg_normal) }
+    pub fn fg_dimmed(&self) -> Color { Self::parse_hex(&self.fg_dimmed) }
+    pub fn fg_highlight(&self) -> Color { Self::parse_hex(&self.fg_highlight) }
+    pub fn fg_warning(&self) -> Color { Self::parse_hex(&self.fg_warning) }
+    pub fn fg_modified(&self) -> Color { Self::parse_hex(&self.fg_modified) }
+    pub fn fg_accent(&self) -> Color { Self::parse_hex(&self.fg_accent) }
+    pub fn border_normal(&self) -> Color { Self::parse_hex(&self.border_normal) }
+    pub fn border_active(&self) -> Color { Self::parse_hex(&self.border_active) }
+    pub fn tree_depth_1(&self) -> Color { Self::parse_hex(&self.tree_depth_1) }
+    pub fn tree_depth_2(&self) -> Color { Self::parse_hex(&self.tree_depth_2) }
+    pub fn tree_depth_3(&self) -> Color { Self::parse_hex(&self.tree_depth_3) }
+    pub fn tree_depth_4(&self) -> Color { Self::parse_hex(&self.tree_depth_4) }
 }
 
 impl Default for ThemeConfig {
-    /// Default theme: Catppuccin Mocha.
+    /// Default theme: Semantic Catppuccin Mocha.
     fn default() -> Self {
         Self {
             transparent: false,
-            crust: "#11111b".to_string(),
-            surface0: "#313244".to_string(),
-            surface1: "#45475a".to_string(),
-            text: "#cdd6f4".to_string(),
-            blue: "#89b4fa".to_string(),
-            green: "#a6e3a1".to_string(),
-            lavender: "#b4befe".to_string(),
-            mauve: "#cba6f7".to_string(),
-            peach: "#fab387".to_string(),
+            bg_normal: "#1e1e2e".to_string(), // base
+            bg_highlight: "#89b4fa".to_string(), // blue
+            bg_active: "#a6e3a1".to_string(), // green
+            bg_search: "#cba6f7".to_string(), // mauve
+            fg_normal: "#cdd6f4".to_string(), // text
+            fg_dimmed: "#6c7086".to_string(), // overlay0
+            fg_highlight: "#1e1e2e".to_string(), // base (dark for contrast against highlights)
+            fg_warning: "#f38ba8".to_string(), // red
+            fg_modified: "#fab387".to_string(), // peach
+            fg_accent: "#b4befe".to_string(), // lavender
+            border_normal: "#45475a".to_string(), // surface1
+            border_active: "#a6e3a1".to_string(), // green
+            tree_depth_1: "#b4befe".to_string(), // lavender
+            tree_depth_2: "#cba6f7".to_string(), // mauve
+            tree_depth_3: "#89b4fa".to_string(), // blue
+            tree_depth_4: "#fab387".to_string(), // peach
         }
     }
 }
 
 /// Custom keybindings for navigation and application control.
 #[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(default)]
 pub struct KeybindsConfig {
     pub down: String,
     pub up: String,
     pub edit: String,
+    pub edit_append: String,
+    pub edit_substitute: String,
     pub save: String,
     pub quit: String,
     pub normal_mode: String,
+    pub search: String,
+    pub next_match: String,
+    pub previous_match: String,
+    pub jump_top: String,
+    pub jump_bottom: String,
+    pub append_item: String,
+    pub prepend_item: String,
+    pub delete_item: String,
+    pub undo: String,
 }
 
 impl Default for KeybindsConfig {
@@ -88,9 +128,20 @@ impl Default for KeybindsConfig {
             down: "j".to_string(),
             up: "k".to_string(),
             edit: "i".to_string(),
+            edit_append: "A".to_string(),
+            edit_substitute: "S".to_string(),
             save: ":w".to_string(),
             quit: ":q".to_string(),
             normal_mode: "Esc".to_string(),
+            search: "/".to_string(),
+            next_match: "n".to_string(),
+            previous_match: "N".to_string(),
+            jump_top: "gg".to_string(),
+            jump_bottom: "G".to_string(),
+            append_item: "o".to_string(),
+            prepend_item: "O".to_string(),
+            delete_item: "dd".to_string(),
+            undo: "u".to_string(),
         }
     }
 }

src/error.rs

@@ -1,5 +1,5 @@
-use thiserror::Error;
 use std::io;
+use thiserror::Error;
 
 /// Custom error types for the mould application.
 #[derive(Error, Debug)]

src/format/env.rs

@@ -1,4 +1,4 @@
-use super::{EnvVar, FormatHandler};
+use super::{ConfigItem, FormatHandler, ItemStatus, ValueType};
 use std::fs;
 use std::io::{self, Write};
 use std::path::Path;
@@ -6,7 +6,7 @@ use std::path::Path;
 pub struct EnvHandler;
 
 impl FormatHandler for EnvHandler {
-    fn parse(&self, path: &Path) -> io::Result<Vec<EnvVar>> {
+    fn parse(&self, path: &Path) -> io::Result<Vec<ConfigItem>> {
         let content = fs::read_to_string(path)?;
         let mut vars = Vec::new();
 
@@ -18,10 +18,16 @@ impl FormatHandler for EnvHandler {
 
             if let Some((key, val)) = line.split_once('=') {
                 let parsed_val = val.trim().trim_matches('"').trim_matches('\'').to_string();
-                vars.push(EnvVar {
+                vars.push(ConfigItem {
                     key: key.trim().to_string(),
-                    value: parsed_val.clone(),
-                    default_value: parsed_val,
+                    path: key.trim().to_string(),
+                    value: Some(parsed_val.clone()),
+                    template_value: Some(parsed_val.clone()),
+                    default_value: Some(parsed_val),
+                    depth: 0,
+                    is_group: false,
+                    status: ItemStatus::Present,
+                    value_type: ValueType::String,
                 });
             }
         }
@@ -29,7 +35,7 @@ impl FormatHandler for EnvHandler {
         Ok(vars)
     }
 
-    fn merge(&self, path: &Path, vars: &mut Vec<EnvVar>) -> io::Result<()> {
+    fn merge(&self, path: &Path, vars: &mut Vec<ConfigItem>) -> io::Result<()> {
         if !path.exists() {
             return Ok(());
         }
@@ -46,24 +52,45 @@ impl FormatHandler for EnvHandler {
                 let parsed_val = val.trim().trim_matches('"').trim_matches('\'').to_string();
 
                 if let Some(var) = vars.iter_mut().find(|v| v.key == key) {
-                    var.value = parsed_val;
+                    if var.value.as_deref() != Some(&parsed_val) {
+                        var.value = Some(parsed_val);
+                        var.status = ItemStatus::Modified;
+                    }
                 } else {
-                    vars.push(EnvVar {
+                    vars.push(ConfigItem {
                         key: key.to_string(),
-                        value: parsed_val.clone(),
-                        default_value: String::new(),
+                        path: key.to_string(),
+                        value: Some(parsed_val),
+                        template_value: None,
+                        default_value: None,
+                        depth: 0,
+                        is_group: false,
+                        status: ItemStatus::MissingFromTemplate,
+                        value_type: ValueType::String,
                     });
                 }
             }
         }
         
+        // Mark missing from active
+        for var in vars.iter_mut() {
+            if var.status == ItemStatus::Present && var.value.is_none() {
+                var.status = ItemStatus::MissingFromActive;
+            }
+        }
+
         Ok(())
     }
 
-    fn write(&self, path: &Path, vars: &[EnvVar]) -> io::Result<()> {
+    fn write(&self, path: &Path, vars: &[ConfigItem]) -> io::Result<()> {
         let mut file = fs::File::create(path)?;
         for var in vars {
-            writeln!(file, "{}={}", var.key, var.value)?;
+            if !var.is_group {
+                let val = var.value.as_deref()
+                    .or(var.template_value.as_deref())
+                    .unwrap_or("");
+                writeln!(file, "{}={}", var.key, val)?;
+            }
         }
         Ok(())
     }
@@ -88,14 +115,13 @@ mod tests {
         let vars = handler.parse(file.path()).unwrap();
         assert_eq!(vars.len(), 4);
         assert_eq!(vars[0].key, "KEY1");
-        assert_eq!(vars[0].value, "value1");
-        assert_eq!(vars[0].default_value, "value1");
+        assert_eq!(vars[0].value.as_deref(), Some("value1"));
         assert_eq!(vars[1].key, "KEY2");
-        assert_eq!(vars[1].value, "value2");
+        assert_eq!(vars[1].value.as_deref(), Some("value2"));
         assert_eq!(vars[2].key, "KEY3");
-        assert_eq!(vars[2].value, "value3");
+        assert_eq!(vars[2].value.as_deref(), Some("value3"));
         assert_eq!(vars[3].key, "EMPTY");
-        assert_eq!(vars[3].value, "");
+        assert_eq!(vars[3].value.as_deref(), Some(""));
     }
 
     #[test]
@@ -112,25 +138,30 @@ mod tests {
 
         assert_eq!(vars.len(), 3);
         assert_eq!(vars[0].key, "KEY1");
-        assert_eq!(vars[0].value, "custom1");
-        assert_eq!(vars[0].default_value, "default1");
+        assert_eq!(vars[0].value.as_deref(), Some("custom1"));
+        assert_eq!(vars[0].status, ItemStatus::Modified);
 
         assert_eq!(vars[1].key, "KEY2");
-        assert_eq!(vars[1].value, "default2");
-        assert_eq!(vars[1].default_value, "default2");
+        assert_eq!(vars[1].value.as_deref(), Some("default2"));
         
         assert_eq!(vars[2].key, "KEY3");
-        assert_eq!(vars[2].value, "custom3");
-        assert_eq!(vars[2].default_value, "");
+        assert_eq!(vars[2].value.as_deref(), Some("custom3"));
+        assert_eq!(vars[2].status, ItemStatus::MissingFromTemplate);
     }
 
     #[test]
     fn test_write_env() {
         let file = NamedTempFile::new().unwrap();
-        let vars = vec![EnvVar {
+        let vars = vec![ConfigItem {
             key: "KEY1".to_string(),
-            value: "value1".to_string(),
-            default_value: "def".to_string(),
+            path: "KEY1".to_string(),
+            value: Some("value1".to_string()),
+            template_value: None,
+            default_value: None,
+            depth: 0,
+            is_group: false,
+            status: ItemStatus::Present,
+            value_type: ValueType::String,
         }];
 
         let handler = EnvHandler;

src/format/hierarchical.rs

@@ -1,4 +1,4 @@
-use super::{EnvVar, FormatHandler, FormatType};
+use super::{ConfigItem, FormatHandler, FormatType, ItemStatus, ValueType};
 use serde_json::{Map, Value};
 use std::fs;
 use std::io;
@@ -16,9 +16,12 @@ impl HierarchicalHandler {
     fn read_value(&self, path: &Path) -> io::Result<Value> {
         let content = fs::read_to_string(path)?;
         let value = match self.format_type {
-            FormatType::Json => serde_json::from_str(&content).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
-            FormatType::Yaml => serde_yaml::from_str(&content).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
-            FormatType::Toml => toml::from_str(&content).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            FormatType::Json => serde_json::from_str(&content)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            FormatType::Yaml => serde_yaml::from_str(&content)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            FormatType::Toml => toml::from_str(&content)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
             _ => unreachable!(),
         };
         Ok(value)
@@ -26,15 +29,22 @@ impl HierarchicalHandler {
 
     fn write_value(&self, path: &Path, value: &Value) -> io::Result<()> {
         let content = match self.format_type {
-            FormatType::Json => serde_json::to_string_pretty(value).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
-            FormatType::Yaml => serde_yaml::to_string(value).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            FormatType::Json => serde_json::to_string_pretty(value)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            FormatType::Yaml => serde_yaml::to_string(value)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
             FormatType::Toml => {
                 // toml requires the root to be a table
                 if value.is_object() {
-                    let toml_value: toml::Value = serde_json::from_value(value.clone()).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
-                    toml::to_string_pretty(&toml_value).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?
+                    let toml_value: toml::Value = serde_json::from_value(value.clone())
+                        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+                    toml::to_string_pretty(&toml_value)
+                        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?
                 } else {
-                    return Err(io::Error::new(io::ErrorKind::InvalidData, "Root of TOML must be an object"));
+                    return Err(io::Error::new(
+                        io::ErrorKind::InvalidData,
+                        "Root of TOML must be an object",
+                    ));
                 }
             }
             _ => unreachable!(),
@@ -43,93 +53,174 @@ impl HierarchicalHandler {
     }
 }
 
-fn flatten(value: &Value, prefix: &str, vars: &mut Vec<EnvVar>) {
+fn flatten(value: &Value, prefix: &str, depth: usize, key_name: &str, vars: &mut Vec<ConfigItem>) {
+    let path = if prefix.is_empty() {
+        key_name.to_string()
+    } else if key_name.is_empty() {
+        prefix.to_string()
+    } else if key_name.starts_with('[') {
+        format!("{}{}", prefix, key_name)
+    } else {
+        format!("{}.{}", prefix, key_name)
+    };
+
     match value {
         Value::Object(map) => {
+            if !path.is_empty() {
+                vars.push(ConfigItem {
+                    key: key_name.to_string(),
+                    path: path.clone(),
+                    value: None,
+                    template_value: None,
+                    default_value: None,
+                    depth,
+                    is_group: true,
+                    status: ItemStatus::Present,
+                    value_type: ValueType::Null,
+                });
+            }
+            let next_depth = if path.is_empty() { depth } else { depth + 1 };
             for (k, v) in map {
-                let new_prefix = if prefix.is_empty() {
-                    k.clone()
-                } else {
-                    format!("{}.{}", prefix, k)
-                };
-                flatten(v, &new_prefix, vars);
+                flatten(v, &path, next_depth, k, vars);
             }
         }
         Value::Array(arr) => {
+            if !path.is_empty() {
+                vars.push(ConfigItem {
+                    key: key_name.to_string(),
+                    path: path.clone(),
+                    value: None,
+                    template_value: None,
+                    default_value: None,
+                    depth,
+                    is_group: true,
+                    status: ItemStatus::Present,
+                    value_type: ValueType::Null,
+                });
+            }
+            let next_depth = if path.is_empty() { depth } else { depth + 1 };
             for (i, v) in arr.iter().enumerate() {
-                let new_prefix = format!("{}[{}]", prefix, i);
-                flatten(v, &new_prefix, vars);
+                let array_key = format!("[{}]", i);
+                flatten(v, &path, next_depth, &array_key, vars);
             }
         }
         Value::String(s) => {
-            vars.push(EnvVar {
-                key: prefix.to_string(),
-                value: s.clone(),
-                default_value: s.clone(),
+            vars.push(ConfigItem {
+                key: key_name.to_string(),
+                path: path.clone(),
+                value: Some(s.clone()),
+                template_value: Some(s.clone()),
+                default_value: Some(s.clone()),
+                depth,
+                is_group: false,
+                status: ItemStatus::Present,
+                value_type: ValueType::String,
             });
         }
         Value::Number(n) => {
             let s = n.to_string();
-            vars.push(EnvVar {
-                key: prefix.to_string(),
-                value: s.clone(),
-                default_value: s.clone(),
+            vars.push(ConfigItem {
+                key: key_name.to_string(),
+                path: path.clone(),
+                value: Some(s.clone()),
+                template_value: Some(s.clone()),
+                default_value: Some(s.clone()),
+                depth,
+                is_group: false,
+                status: ItemStatus::Present,
+                value_type: ValueType::Number,
             });
         }
         Value::Bool(b) => {
             let s = b.to_string();
-            vars.push(EnvVar {
-                key: prefix.to_string(),
-                value: s.clone(),
-                default_value: s.clone(),
+            vars.push(ConfigItem {
+                key: key_name.to_string(),
+                path: path.clone(),
+                value: Some(s.clone()),
+                template_value: Some(s.clone()),
+                default_value: Some(s.clone()),
+                depth,
+                is_group: false,
+                status: ItemStatus::Present,
+                value_type: ValueType::Bool,
             });
         }
         Value::Null => {
-            vars.push(EnvVar {
-                key: prefix.to_string(),
-                value: "".to_string(),
-                default_value: "".to_string(),
+            vars.push(ConfigItem {
+                key: key_name.to_string(),
+                path: path.clone(),
+                value: Some("".to_string()),
+                template_value: Some("".to_string()),
+                default_value: Some("".to_string()),
+                depth,
+                is_group: false,
+                status: ItemStatus::Present,
+                value_type: ValueType::Null,
             });
         }
     }
 }
 
-// Removed unused update_leaf and update_leaf_value functions
-
 impl FormatHandler for HierarchicalHandler {
-    fn parse(&self, path: &Path) -> io::Result<Vec<EnvVar>> {
+    fn parse(&self, path: &Path) -> io::Result<Vec<ConfigItem>> {
         let value = self.read_value(path)?;
         let mut vars = Vec::new();
-        flatten(&value, "", &mut vars);
+        flatten(&value, "", 0, "", &mut vars);
         Ok(vars)
     }
 
-    fn merge(&self, path: &Path, vars: &mut Vec<EnvVar>) -> io::Result<()> {
+    fn merge(&self, path: &Path, vars: &mut Vec<ConfigItem>) -> io::Result<()> {
         if !path.exists() {
             return Ok(());
         }
         let existing_value = self.read_value(path)?;
         let mut existing_vars = Vec::new();
-        flatten(&existing_value, "", &mut existing_vars);
+        flatten(&existing_value, "", 0, "", &mut existing_vars);
 
         for var in vars.iter_mut() {
-            if let Some(existing) = existing_vars.iter().find(|v| v.key == var.key) {
+            if let Some(existing) = existing_vars.iter().find(|v| v.path == var.path) {
+                if var.value != existing.value {
                     var.value = existing.value.clone();
+                    var.status = ItemStatus::Modified;
+                }
+            } else {
+                var.status = ItemStatus::MissingFromActive;
             }
         }
+        
+        // Find keys in active that are not in template
+        let mut to_add = Vec::new();
+        for existing in existing_vars {
+            if !vars.iter().any(|v| v.path == existing.path) {
+                let mut new_item = existing.clone();
+                new_item.status = ItemStatus::MissingFromTemplate;
+                new_item.template_value = None;
+                new_item.default_value = None;
+                to_add.push(new_item);
+            }
+        }
+        
+        // Basic insertion logic for extra keys (could be improved to insert at correct depth/position)
+        vars.extend(to_add);
+
         Ok(())
     }
 
-    fn write(&self, path: &Path, vars: &[EnvVar]) -> io::Result<()> {
+    fn write(&self, path: &Path, vars: &[ConfigItem]) -> io::Result<()> {
         let mut root = Value::Object(Map::new());
         for var in vars {
-            insert_into_value(&mut root, &var.key, &var.value);
+            if !var.is_group {
+                let val = var.value.as_deref()
+                    .or(var.template_value.as_deref())
+                    .unwrap_or("");
+                insert_into_value(&mut root, &var.path, val, var.value_type);
+            }
         }
         self.write_value(path, &root)
     }
 }
 
-fn insert_into_value(root: &mut Value, path: &str, new_val_str: &str) {
+fn insert_into_value(root: &mut Value, path: &str, new_val_str: &str, value_type: ValueType) {
     let mut parts = path.split('.');
     let last_part = match parts.next_back() {
         Some(p) => p,
@@ -172,17 +263,36 @@ fn insert_into_value(root: &mut Value, path: &str, new_val_str: &str) {
     }
     let map = current.as_object_mut().unwrap();
 
-    // Attempt basic type inference
-    let final_val = if let Ok(n) = new_val_str.parse::<i64>() {
+    // Use the preserved ValueType instead of aggressive inference
+    let final_val = match value_type {
+        ValueType::Number => {
+            if let Ok(n) = new_val_str.parse::<i64>() {
                 Value::Number(n.into())
-    } else if let Ok(b) = new_val_str.parse::<bool>() {
+            } else if let Ok(f) = new_val_str.parse::<f64>() {
+                if let Some(n) = serde_json::Number::from_f64(f) {
+                    Value::Number(n)
+                } else {
+                    Value::String(new_val_str.to_string())
+                }
+            } else {
+                Value::String(new_val_str.to_string())
+            }
+        }
+        ValueType::Bool => {
+            if let Ok(b) = new_val_str.parse::<bool>() {
                 Value::Bool(b)
             } else {
                 Value::String(new_val_str.to_string())
+            }
+        }
+        ValueType::Null if new_val_str.is_empty() => Value::Null,
+        _ => Value::String(new_val_str.to_string()),
     };
 
     if let Some(i) = final_idx {
-        let next_node = map.entry(final_key.to_string()).or_insert_with(|| Value::Array(Vec::new()));
+        let next_node = map
+            .entry(final_key.to_string())
+            .or_insert_with(|| Value::Array(Vec::new()));
         if !next_node.is_array() {
             *next_node = Value::Array(Vec::new());
         }
@@ -200,7 +310,7 @@ fn parse_array_key(part: &str) -> (&str, Option<usize>) {
     if part.ends_with(']') && part.contains('[') {
         let start_idx = part.find('[').unwrap();
         let key = &part[..start_idx];
-        let idx = part[start_idx+1..part.len()-1].parse::<usize>().ok();
+        let idx = part[start_idx + 1..part.len() - 1].parse::<usize>().ok();
         (key, idx)
     } else {
         (part, None)
@@ -225,12 +335,14 @@ mod tests {
             }
         });
 
-        flatten(&json, "", &mut vars);
-        assert_eq!(vars.len(), 2);
+        flatten(&json, "", 0, "", &mut vars);
+        assert_eq!(vars.len(), 6);
 
         let mut root = Value::Object(Map::new());
         for var in vars {
-            insert_into_value(&mut root, &var.key, &var.value);
+            if !var.is_group {
+                insert_into_value(&mut root, &var.path, var.value.as_deref().unwrap_or(""), var.value_type);
+            }
         }
 
         // When unflattening, it parses bool back

src/format/mod.rs

@@ -1,14 +1,36 @@
-use std::path::Path;
 use std::io;
+use std::path::Path;
 
 pub mod env;
 pub mod hierarchical;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ItemStatus {
+    Present,
+    MissingFromActive,
+    MissingFromTemplate,
+    Modified,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ValueType {
+    String,
+    Number,
+    Bool,
+    Null,
+}
+
 #[derive(Debug, Clone)]
-pub struct EnvVar {
+pub struct ConfigItem {
     pub key: String,
-    pub value: String,
-    pub default_value: String,
+    pub path: String,
+    pub value: Option<String>,
+    pub template_value: Option<String>,
+    pub default_value: Option<String>,
+    pub depth: usize,
+    pub is_group: bool,
+    pub status: ItemStatus,
+    pub value_type: ValueType,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -20,9 +42,9 @@ pub enum FormatType {
 }
 
 pub trait FormatHandler {
-    fn parse(&self, path: &Path) -> io::Result<Vec<EnvVar>>;
-    fn merge(&self, path: &Path, vars: &mut Vec<EnvVar>) -> io::Result<()>;
-    fn write(&self, path: &Path, vars: &[EnvVar]) -> io::Result<()>;
+    fn parse(&self, path: &Path) -> io::Result<Vec<ConfigItem>>;
+    fn merge(&self, path: &Path, vars: &mut Vec<ConfigItem>) -> io::Result<()>;
+    fn write(&self, path: &Path, vars: &[ConfigItem]) -> io::Result<()>;
 }
 
 pub fn detect_format(path: &Path, override_format: Option<String>) -> FormatType {

src/main.rs

@@ -5,6 +5,7 @@ mod error;
 mod format;
 mod runner;
 mod ui;
+mod resolver;
 
 use app::App;
 use config::load_config;
@@ -13,42 +14,13 @@ use format::{detect_format, get_handler};
 use log::{error, info, warn};
 use runner::AppRunner;
 use std::io;
-use std::path::{Path, PathBuf};
 
 use crossterm::{
     event::{DisableMouseCapture, EnableMouseCapture},
     execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
 };
-use ratatui::{backend::CrosstermBackend, Terminal};
-
-/// Helper to automatically determine the output file path based on common naming conventions.
-fn determine_output_path(input: &Path) -> PathBuf {
-    let file_name = input.file_name().unwrap_or_default().to_string_lossy();
-    
-    if file_name == ".env.example" {
-        return input.with_file_name(".env");
-    }
-    
-    if file_name == "docker-compose.yml" {
-        return input.with_file_name("docker-compose.override.yml");
-    }
-    if file_name == "docker-compose.yaml" {
-        return input.with_file_name("docker-compose.override.yaml");
-    }
-    
-    if file_name.ends_with(".example.json") {
-        return input.with_file_name(file_name.replace(".example.json", ".json"));
-    }
-    if file_name.ends_with(".template.json") {
-        return input.with_file_name(file_name.replace(".template.json", ".json"));
-    }
-    
-    input.with_extension(format!(
-        "{}.out",
-        input.extension().unwrap_or_default().to_string_lossy()
-    ))
-}
+use ratatui::{Terminal, backend::CrosstermBackend};
 
 fn main() -> anyhow::Result<()> {
     let args = cli::parse();
@@ -64,41 +36,82 @@ fn main() -> anyhow::Result<()> {
         .format_timestamp(None)
         .init();
 
-    let input_path = args.input;
-    if !input_path.exists() {
-        error!("Input file not found: {}", input_path.display());
-        return Err(MouldError::FileNotFound(input_path.display().to_string()).into());
+    let input_path = match args.input {
+        Some(path) => {
+            if !path.exists() {
+                error!("Input file not found: {}", path.display());
+                return Err(MouldError::FileNotFound(path.display().to_string()).into());
             }
+            path
+        }
+        None => match resolver::find_input_file() {
+            Some(path) => {
+                info!("Discovered template: {}", path.display());
+                path
+            }
+            None => {
+                error!("No template file provided and none discovered in current directory.");
+                println!("Usage: mould <INPUT_FILE>");
+                println!("Supported defaults: .env.example, compose.yml, docker-compose.yml, etc.");
+                return Err(MouldError::FileNotFound("None".to_string()).into());
+            }
+        },
+    };
 
     info!("Input: {}", input_path.display());
 
     let format_type = detect_format(&input_path, args.format);
     let handler = get_handler(format_type);
 
+    // Smart Comparison Logic
+    let (active_path, template_path) = resolver::resolve_paths(&input_path);
+
     let output_path = args
         .output
-        .unwrap_or_else(|| determine_output_path(&input_path));
+        .unwrap_or_else(|| active_path.clone().unwrap_or_else(|| resolver::determine_output_path(&input_path)));
 
     info!("Output: {}", output_path.display());
 
-    let mut vars = handler.parse(&input_path).map_err(|e| {
+    // 1. Load active config if it exists
+    let mut vars = if let Some(active) = &active_path {
+        handler.parse(active).unwrap_or_default()
+    } else {
+        Vec::new()
+    };
+
+    // 2. Load template config and merge
+    if let Some(template) = &template_path {
+        info!("Comparing with template: {}", template.display());
+        let template_vars = handler.parse(template).unwrap_or_default();
+        if vars.is_empty() {
+             vars = template_vars;
+             // If we only have template, everything is missing from active initially
+             for v in vars.iter_mut() {
+                 v.status = crate::format::ItemStatus::MissingFromActive;
+                 v.value = None;
+             }
+        } else {
+             // Merge template into active
+             handler.merge(template, &mut vars).unwrap_or_default();
+        }
+    } else if vars.is_empty() {
+        // Fallback if no template and active is empty
+         vars = handler.parse(&input_path).map_err(|e| {
             error!("Failed to parse input file: {}", e);
             MouldError::Format(format!("Failed to parse {}: {}", input_path.display(), e))
         })?;
-
-    if vars.is_empty() {
-        warn!("No variables found in {}", input_path.display());
     }
 
-    if let Err(e) = handler.merge(&output_path, &mut vars) {
-        warn!("Could not merge existing output file: {}", e);
+    if vars.is_empty() {
+        warn!("No variables found.");
     }
 
     let config = load_config();
     let mut app = App::new(vars);
 
     // Terminal lifecycle
-    enable_raw_mode().map_err(|e| MouldError::Terminal(format!("Failed to enable raw mode: {}", e)))?;
+    enable_raw_mode()
+        .map_err(|e| MouldError::Terminal(format!("Failed to enable raw mode: {}", e)))?;
     let mut stdout = io::stdout();
     execute!(stdout, EnterAlternateScreen, EnableMouseCapture)
         .map_err(|e| MouldError::Terminal(format!("Failed to enter alternate screen: {}", e)))?;
@@ -106,7 +119,13 @@ fn main() -> anyhow::Result<()> {
     let mut terminal = Terminal::new(backend)
         .map_err(|e| MouldError::Terminal(format!("Failed to create terminal backend: {}", e)))?;
 
-    let mut runner = AppRunner::new(&mut terminal, &mut app, &config, &output_path, handler.as_ref());
+    let mut runner = AppRunner::new(
+        &mut terminal,
+        &mut app,
+        &config,
+        &output_path,
+        handler.as_ref(),
+    );
     let res = runner.run();
 
     // Restoration
@@ -115,14 +134,15 @@ fn main() -> anyhow::Result<()> {
         terminal.backend_mut(),
         LeaveAlternateScreen,
         DisableMouseCapture
-    ).ok();
+    )
+    .ok();
     terminal.show_cursor().ok();
 
     match res {
         Ok(_) => {
             info!("Successfully finished mould session.");
             Ok(())
-        },
+        }
         Err(e) => {
             error!("Application error during run: {}", e);
             Err(e.into())

src/resolver.rs

@@ -0,0 +1,193 @@
+use std::path::{Path, PathBuf};
+
+pub struct Rule {
+    pub template_suffix: &'static str,
+    pub active_suffix: &'static str,
+    pub is_exact_match: bool,
+}
+
+pub const RULES: &[Rule] = &[
+    // Exact matches
+    Rule { template_suffix: "compose.yml", active_suffix: "compose.override.yml", is_exact_match: true },
+    Rule { template_suffix: "compose.yaml", active_suffix: "compose.override.yaml", is_exact_match: true },
+    Rule { template_suffix: "docker-compose.yml", active_suffix: "docker-compose.override.yml", is_exact_match: true },
+    Rule { template_suffix: "docker-compose.yaml", active_suffix: "docker-compose.override.yaml", is_exact_match: true },
+    
+    // Pattern matches
+    Rule { template_suffix: ".env.example", active_suffix: ".env", is_exact_match: false },
+    Rule { template_suffix: ".env.template", active_suffix: ".env", is_exact_match: false },
+    Rule { template_suffix: ".example.json", active_suffix: ".json", is_exact_match: false },
+    Rule { template_suffix: ".template.json", active_suffix: ".json", is_exact_match: false },
+    Rule { template_suffix: ".example.yml", active_suffix: ".yml", is_exact_match: false },
+    Rule { template_suffix: ".template.yml", active_suffix: ".yml", is_exact_match: false },
+    Rule { template_suffix: ".example.yaml", active_suffix: ".yaml", is_exact_match: false },
+    Rule { template_suffix: ".template.yaml", active_suffix: ".yaml", is_exact_match: false },
+    Rule { template_suffix: ".example.toml", active_suffix: ".toml", is_exact_match: false },
+    Rule { template_suffix: ".template.toml", active_suffix: ".toml", is_exact_match: false },
+];
+
+pub const DEFAULT_CANDIDATES: &[&str] = &[
+    ".env.example",
+    "compose.yml",
+    "docker-compose.yml",
+    ".env.template",
+    "compose.yaml",
+    "docker-compose.yaml",
+];
+
+/// Helper to automatically determine the output file path based on common naming conventions.
+pub fn determine_output_path(input: &Path) -> PathBuf {
+    let file_name = input.file_name().unwrap_or_default().to_string_lossy();
+
+    for rule in RULES {
+        if rule.is_exact_match {
+            if file_name == rule.template_suffix {
+                return input.with_file_name(rule.active_suffix);
+            }
+        } else {
+            if file_name == rule.template_suffix {
+                return input.with_file_name(rule.active_suffix);
+            } else if let Some(base) = file_name.strip_suffix(rule.template_suffix) {
+                return input.with_file_name(format!("{}{}", base, rule.active_suffix));
+            }
+        }
+    }
+
+    input.with_extension(format!(
+        "{}.out",
+        input.extension().unwrap_or_default().to_string_lossy()
+    ))
+}
+
+/// Discovers common configuration template files in the current directory.
+pub fn find_input_file() -> Option<PathBuf> {
+    // Priority 1: Exact matches for well-known defaults
+    for &name in DEFAULT_CANDIDATES {
+        let path = PathBuf::from(name);
+        if path.exists() {
+            return Some(path);
+        }
+    }
+
+    // Priority 2: Pattern matches
+    if let Ok(entries) = std::fs::read_dir(".") {
+        let mut fallback = None;
+        for entry in entries.flatten() {
+            let name = entry.file_name();
+            let name_str = name.to_string_lossy();
+
+            for rule in RULES {
+                if !rule.is_exact_match && name_str.ends_with(rule.template_suffix) {
+                    if name_str.contains(".env") || name_str.contains("compose") {
+                        return Some(entry.path());
+                    }
+                    if fallback.is_none() {
+                        fallback = Some(entry.path());
+                    }
+                    break;
+                }
+            }
+        }
+        if let Some(path) = fallback {
+            return Some(path);
+        }
+    }
+
+    None
+}
+
+/// Resolves the active and template paths given an input path.
+/// Returns `(active_path, template_path)`.
+pub fn resolve_paths(input: &Path) -> (Option<PathBuf>, Option<PathBuf>) {
+    let file_name = input.file_name().unwrap_or_default().to_string_lossy();
+    
+    // Check if the input matches any known template pattern
+    let mut is_template = false;
+    for rule in RULES {
+        if rule.is_exact_match {
+            if file_name == rule.template_suffix {
+                is_template = true;
+                break;
+            }
+        } else if file_name.ends_with(rule.template_suffix) {
+            is_template = true;
+            break;
+        }
+    }
+
+    // Fallback template detection
+    if !is_template && (file_name.contains(".example") || file_name.contains(".template")) {
+        is_template = true;
+    }
+
+    if is_template {
+        let expected_active = determine_output_path(input);
+        let active = if expected_active.exists() {
+            Some(expected_active)
+        } else {
+            None
+        };
+        (active, Some(input.to_path_buf()))
+    } else {
+        // Input is treated as the active config
+        let active = Some(input.to_path_buf());
+        let mut template = None;
+        
+        // Try to reverse match rules to find a template
+        for rule in RULES {
+            if rule.is_exact_match {
+                if file_name == rule.active_suffix {
+                    let t = input.with_file_name(rule.template_suffix);
+                    if t.exists() {
+                        template = Some(t);
+                        break;
+                    }
+                }
+            } else if file_name.ends_with(rule.active_suffix) {
+                if file_name == rule.active_suffix {
+                    let t = input.with_file_name(rule.template_suffix);
+                    if t.exists() {
+                        template = Some(t);
+                        break;
+                    }
+                } else if let Some(base) = file_name.strip_suffix(rule.active_suffix) {
+                    let t = input.with_file_name(format!("{}{}", base, rule.template_suffix));
+                    if t.exists() {
+                        template = Some(t);
+                        break;
+                    }
+                }
+            }
+        }
+        
+        // Fallback reverse detection
+        if template.is_none() {
+            let possible_templates = [
+                format!("{}.example", file_name),
+                format!("{}.template", file_name),
+            ];
+            for t in possible_templates {
+                let p = input.with_file_name(t);
+                if p.exists() {
+                    template = Some(p);
+                    break;
+                }
+            }
+        }
+
+        (active, template)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_determine_output_path() {
+        assert_eq!(determine_output_path(Path::new(".env.example")), PathBuf::from(".env"));
+        assert_eq!(determine_output_path(Path::new("compose.yml")), PathBuf::from("compose.override.yml"));
+        assert_eq!(determine_output_path(Path::new("config.template.json")), PathBuf::from("config.json"));
+        assert_eq!(determine_output_path(Path::new("config.example")), PathBuf::from("config.example.out"));
+    }
+}

src/runner.rs

@@ -1,9 +1,9 @@
-use crate::app::{App, Mode};
+use crate::app::{App, InsertVariant, Mode};
 use crate::config::Config;
 use crate::format::FormatHandler;
 use crossterm::event::{self, Event, KeyCode, KeyEvent};
-use ratatui::backend::Backend;
 use ratatui::Terminal;
+use ratatui::backend::Backend;
 use std::io;
 use std::path::Path;
 use tui_input::backend::crossterm::EventHandler;
@@ -22,6 +22,8 @@ pub struct AppRunner<'a, B: Backend> {
     handler: &'a dyn FormatHandler,
     /// Buffer for storing active command entry (e.g., ":w").
     command_buffer: String,
+    /// Buffer for storing sequence of key presses (e.g., "gg").
+    key_sequence: String,
 }
 
 impl<'a, B: Backend> AppRunner<'a, B>
@@ -43,6 +45,7 @@ where
             output_path,
             handler,
             command_buffer: String::new(),
+            key_sequence: String::new(),
         }
     }
 
@@ -64,6 +67,7 @@ where
         match self.app.mode {
             Mode::Normal => self.handle_normal_mode(key),
             Mode::Insert => self.handle_insert_mode(key),
+            Mode::Search => self.handle_search_mode(key),
         }
     }
 
@@ -106,30 +110,105 @@ where
     /// Handles primary navigation (j/k) and transitions to insert or command modes.
     fn handle_navigation_mode(&mut self, key: KeyEvent) -> io::Result<()> {
         if let KeyCode::Char(c) = key.code {
-            let c_str = c.to_string();
-            if c_str == self.config.keybinds.down {
-                self.app.next();
-            } else if c_str == self.config.keybinds.up {
-                self.app.previous();
-            } else if c_str == self.config.keybinds.edit {
-                self.app.enter_insert();
-            } else if c_str == ":" {
+            self.key_sequence.push(c);
+
+            // Collect all configured keybinds
+            let binds = [
+                (&self.config.keybinds.down, "down"),
+                (&self.config.keybinds.up, "up"),
+                (&self.config.keybinds.edit, "edit"),
+                (&self.config.keybinds.edit_append, "edit_append"),
+                (&self.config.keybinds.edit_substitute, "edit_substitute"),
+                (&self.config.keybinds.search, "search"),
+                (&self.config.keybinds.next_match, "next_match"),
+                (&self.config.keybinds.previous_match, "previous_match"),
+                (&self.config.keybinds.jump_top, "jump_top"),
+                (&self.config.keybinds.jump_bottom, "jump_bottom"),
+                (&self.config.keybinds.append_item, "append_item"),
+                (&self.config.keybinds.prepend_item, "prepend_item"),
+                (&self.config.keybinds.delete_item, "delete_item"),
+                (&self.config.keybinds.undo, "undo"),
+                (&"a".to_string(), "add_missing"),
+                (&":".to_string(), "command"),
+                (&"q".to_string(), "quit"),
+            ];
+
+            let mut exact_match = None;
+            let mut prefix_match = false;
+
+            for (bind, action) in binds.iter() {
+                if bind == &&self.key_sequence {
+                    exact_match = Some(*action);
+                    break;
+                } else if bind.starts_with(&self.key_sequence) {
+                    prefix_match = true;
+                }
+            }
+
+            if let Some(action) = exact_match {
+                self.key_sequence.clear();
+                match action {
+                    "down" => self.app.next(),
+                    "up" => self.app.previous(),
+                    "edit" => self.app.enter_insert(InsertVariant::Start),
+                    "edit_append" => self.app.enter_insert(InsertVariant::End),
+                    "edit_substitute" => self.app.enter_insert(InsertVariant::Substitute),
+                    "search" => {
+                        self.app.mode = Mode::Search;
+                        self.app.search_query.clear();
+                        self.app.status_message = Some(format!("{} ", self.config.keybinds.search));
+                    }
+                    "next_match" => self.app.jump_next_match(),
+                    "previous_match" => self.app.jump_previous_match(),
+                    "jump_top" => self.app.jump_top(),
+                    "jump_bottom" => self.app.jump_bottom(),
+                    "append_item" => self.app.add_array_item(true),
+                    "prepend_item" => self.app.add_array_item(false),
+                    "delete_item" => self.app.delete_selected(),
+                    "undo" => self.app.undo(),
+                    "add_missing" => {
+                        self.app.save_undo_state();
+                        self.add_missing_item();
+                    }
+                    "command" => {
                         self.command_buffer.push(':');
                         self.sync_command_status();
-            } else if c_str == "q" {
-                self.app.running = false;
+                    }
+                    "quit" => self.app.running = false,
+                    _ => {}
+                }
+            } else if !prefix_match {
+                // Not an exact match and not a prefix for any bind, clear and restart seq
+                self.key_sequence.clear();
+                self.key_sequence.push(c);
             }
         } else {
+            // Non-character keys reset the sequence buffer
+            self.key_sequence.clear();
             match key.code {
                 KeyCode::Down => self.app.next(),
                 KeyCode::Up => self.app.previous(),
                 KeyCode::Enter => self.save_file()?,
+                KeyCode::Esc => self.app.status_message = None,
                 _ => {}
             }
         }
         Ok(())
     }
 
+    /// Adds a missing item from the template to the active configuration.
+    fn add_missing_item(&mut self) {
+        if let Some(var) = self.app.vars.get_mut(self.app.selected) {
+            if var.status == crate::format::ItemStatus::MissingFromActive {
+                var.status = crate::format::ItemStatus::Present;
+                if !var.is_group {
+                    var.value = var.template_value.clone();
+                }
+                self.app.sync_input_with_selected();
+            }
+        }
+    }
+
     /// Delegates key events to the `tui_input` handler during active editing.
     fn handle_insert_mode(&mut self, key: KeyEvent) -> io::Result<()> {
         match key.code {
@@ -143,6 +222,28 @@ where
         Ok(())
     }
 
+    /// Handles search mode key events.
+    fn handle_search_mode(&mut self, key: KeyEvent) -> io::Result<()> {
+        match key.code {
+            KeyCode::Enter | KeyCode::Esc => {
+                self.app.mode = Mode::Normal;
+                self.app.status_message = None;
+            }
+            KeyCode::Backspace => {
+                self.app.search_query.pop();
+                self.app.status_message = Some(format!("{}{}", self.config.keybinds.search, self.app.search_query));
+                self.app.jump_next_match();
+            }
+            KeyCode::Char(c) => {
+                self.app.search_query.push(c);
+                self.app.status_message = Some(format!("{}{}", self.config.keybinds.search, self.app.search_query));
+                self.app.jump_next_match();
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
     /// Logic to map command strings (like ":w") to internal application actions.
     fn execute_command(&mut self, cmd: &str) -> io::Result<()> {
         if cmd == self.config.keybinds.save {

src/ui.rs

@@ -1,11 +1,11 @@
 use crate::app::{App, Mode};
 use crate::config::Config;
 use ratatui::{
+    Frame,
     layout::{Constraint, Direction, Layout},
     style::{Modifier, Style},
     text::{Line, Span},
     widgets::{Block, BorderType, Borders, List, ListItem, ListState, Paragraph},
-    Frame,
 };
 
 /// Renders the main application interface using ratatui.
@@ -16,7 +16,7 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
     // Render the main background (optional based on transparency config).
     if !theme.transparent {
         f.render_widget(
-            Block::default().style(Style::default().bg(theme.crust())),
+            Block::default().style(Style::default().bg(theme.bg_normal())),
             size,
         );
     }
@@ -43,60 +43,126 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
         ])
         .split(outer_layout[1]);
 
-    // Calculate alignment for the key-value separator based on the longest key.
-    let max_key_len = app
-        .vars
-        .iter()
-        .map(|v| v.key.len())
-        .max()
-        .unwrap_or(20)
-        .min(40);
-
     // Build the interactive list of configuration variables.
+    let matching_indices = app.matching_indices();
     let items: Vec<ListItem> = app
         .vars
         .iter()
         .enumerate()
         .map(|(i, var)| {
             let is_selected = i == app.selected;
+            let is_match = matching_indices.contains(&i);
 
-            // Show live input text for the selected item if in Insert mode.
-            let val = if is_selected && matches!(app.mode, Mode::Insert) {
-                app.input.value()
+            // Indentation based on depth
+            let indent = "  ".repeat(var.depth);
+            let prefix = if var.is_group { "+ " } else { "  " };
+
+            // Determine colors based on depth
+            let depth_color = if is_selected {
+                theme.bg_normal()
             } else {
-                &var.value
+                match var.depth % 4 {
+                    0 => theme.tree_depth_1(),
+                    1 => theme.tree_depth_2(),
+                    2 => theme.tree_depth_3(),
+                    3 => theme.tree_depth_4(),
+                    _ => theme.fg_normal(),
+                }
+            };
+
+            // Determine colors based on status and selection
+            let text_color = if is_selected {
+                theme.fg_highlight()
+            } else {
+                match var.status {
+                    crate::format::ItemStatus::MissingFromActive if !var.is_group => theme.fg_dimmed(),
+                    crate::format::ItemStatus::Modified => theme.fg_modified(),
+                    _ => theme.fg_normal(),
+                }
             };
 
             let key_style = if is_selected {
                 Style::default()
-                    .fg(theme.crust())
+                    .fg(theme.fg_highlight())
                     .add_modifier(Modifier::BOLD)
+            } else if is_match {
+                Style::default()
+                    .fg(theme.bg_search())
+                    .add_modifier(Modifier::UNDERLINED)
+            } else if var.status == crate::format::ItemStatus::MissingFromActive && !var.is_group {
+                Style::default()
+                    .fg(theme.fg_dimmed())
+                    .add_modifier(Modifier::DIM)
             } else {
-                Style::default().fg(theme.lavender())
+                Style::default().fg(depth_color)
+            };
+
+            let mut key_spans = vec![
+                Span::raw(indent),
+                Span::styled(prefix, Style::default().fg(theme.border_normal())),
+                Span::styled(&var.key, key_style),
+            ];
+
+            // Add status indicator if not present (only for leaf variables)
+            if !var.is_group {
+                match var.status {
+                    crate::format::ItemStatus::MissingFromActive => {
+                        let missing_style = if is_selected {
+                            Style::default().fg(theme.fg_highlight()).add_modifier(Modifier::BOLD)
+                        } else {
+                            Style::default().fg(theme.fg_warning()).add_modifier(Modifier::BOLD)
+                        };
+                        key_spans.push(Span::styled(" (missing)", missing_style));
+                    }
+                    crate::format::ItemStatus::Modified => {
+                        if !is_selected {
+                            key_spans.push(Span::styled(" (*)", Style::default().fg(theme.fg_modified())));
+                        }
+                    }
+                    _ => {}
+                }
+            }
+
+            let item_style = if is_selected {
+                Style::default().bg(theme.bg_highlight())
+            } else {
+                Style::default().fg(text_color)
+            };
+
+            if var.is_group {
+                ListItem::new(Line::from(key_spans)).style(item_style)
+            } else {
+                // Show live input text for the selected item if in Insert mode.
+                let val = if is_selected && matches!(app.mode, Mode::Insert) {
+                    app.input.value()
+                } else {
+                    var.value.as_deref().unwrap_or("")
                 };
 
                 let value_style = if is_selected {
-                Style::default().fg(theme.crust())
+                    Style::default().fg(theme.fg_highlight())
                 } else {
-                Style::default().fg(theme.text())
+                    Style::default().fg(theme.fg_normal())
                 };
 
-            let line = Line::from(vec![
-                Span::styled(
-                    format!(" {:<width$} ", var.key, width = max_key_len),
-                    key_style,
-                ),
-                Span::styled("│ ", Style::default().fg(theme.surface1())),
-                Span::styled(format!(" {} ", val), value_style),
-            ]);
+                let mut val_spans = vec![
+                    Span::raw(format!("{}    └─ ", "  ".repeat(var.depth))),
+                    Span::styled(val, value_style),
+                ];
 
-            let item_style = if is_selected {
-                Style::default().bg(theme.blue())
+                if let Some(t_val) = &var.template_value {
+                    if Some(t_val) != var.value.as_ref() {
+                        let t_style = if is_selected {
+                            Style::default().fg(theme.bg_normal()).add_modifier(Modifier::DIM)
                         } else {
-                Style::default().fg(theme.text())
+                            Style::default().fg(theme.fg_dimmed()).add_modifier(Modifier::ITALIC)
                         };
+                        val_spans.push(Span::styled(format!(" [Def: {}]", t_val), t_style));
+                    }
+                }
 
-            ListItem::new(line).style(item_style)
+                ListItem::new(vec![Line::from(key_spans), Line::from(val_spans)]).style(item_style)
+            }
         })
         .collect();
 
@@ -105,8 +171,12 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
             .borders(Borders::ALL)
             .border_type(BorderType::Rounded)
             .title(" Config Variables ")
-            .title_style(Style::default().fg(theme.mauve()).add_modifier(Modifier::BOLD))
-            .border_style(Style::default().fg(theme.surface1())),
+            .title_style(
+                Style::default()
+                    .fg(theme.fg_accent())
+                    .add_modifier(Modifier::BOLD),
+            )
+            .border_style(Style::default().fg(theme.border_normal())),
     );
 
     let mut state = ListState::default();
@@ -115,32 +185,53 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
 
     // Render the focused input area.
     let current_var = app.vars.get(app.selected);
-    let input_title = if let Some(var) = current_var {
-        if var.default_value.is_empty() {
-            format!(" Editing: {} ", var.key)
+    let mut input_title = " Input ".to_string();
+    let mut extra_info = String::new();
+
+    if let Some(var) = current_var {
+        if var.is_group {
+            input_title = format!(" Group: {} ", var.path);
         } else {
-            format!(" Editing: {} (Default: {}) ", var.key, var.default_value)
+            input_title = format!(" Editing: {} ", var.path);
+            if let Some(t_val) = &var.template_value {
+                extra_info = format!("  [Template: {}]", t_val);
+            }
+        }
     }
-    } else {
-        " Input ".to_string()
-    };
 
     let input_border_color = match app.mode {
-        Mode::Insert => theme.green(),
-        Mode::Normal => theme.surface1(),
+        Mode::Insert => theme.border_active(),
+        Mode::Normal | Mode::Search => theme.border_normal(),
     };
 
     let input_text = app.input.value();
     let cursor_pos = app.input.visual_cursor();
 
-    let input = Paragraph::new(input_text)
-        .style(Style::default().fg(theme.text()))
+    // Show template value in normal mode if it differs
+    let display_text = if let Some(var) = current_var {
+        if var.is_group {
+            "<group>".to_string()
+        } else if matches!(app.mode, Mode::Normal) {
+            format!("{}{}", input_text, extra_info)
+        } else {
+            input_text.to_string()
+        }
+    } else {
+        input_text.to_string()
+    };
+
+    let input = Paragraph::new(display_text)
+        .style(Style::default().fg(theme.fg_normal()))
         .block(
             Block::default()
                 .borders(Borders::ALL)
                 .border_type(BorderType::Rounded)
                 .title(input_title)
-                .title_style(Style::default().fg(theme.peach()).add_modifier(Modifier::BOLD))
+                .title_style(
+                    Style::default()
+                        .fg(theme.fg_accent()) // Make title pop
+                        .add_modifier(Modifier::BOLD),
+                )
                 .border_style(Style::default().fg(input_border_color)),
         );
     f.render_widget(input, chunks[2]);
@@ -158,32 +249,65 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
         Mode::Normal => (
             " NORMAL ",
             Style::default()
-                .bg(theme.blue())
-                .fg(theme.crust())
+                .bg(theme.bg_highlight())
+                .fg(theme.bg_normal())
                 .add_modifier(Modifier::BOLD),
         ),
         Mode::Insert => (
             " INSERT ",
             Style::default()
-                .bg(theme.green())
-                .fg(theme.crust())
+                .bg(theme.bg_active())
+                .fg(theme.bg_normal())
+                .add_modifier(Modifier::BOLD),
+        ),
+        Mode::Search => (
+            " SEARCH ",
+            Style::default()
+                .bg(theme.bg_search())
+                .fg(theme.bg_normal())
                 .add_modifier(Modifier::BOLD),
         ),
     };
 
-    let status_msg = app.status_message.as_deref().unwrap_or_else(|| match app.mode {
-        Mode::Normal => " navigation | i: edit | :w: save | :q: quit ",
-        Mode::Insert => " Esc: back to normal | Enter: commit ",
-    });
+    let status_msg = if let Some(msg) = &app.status_message {
+        msg.clone()
+    } else {
+        let kb = &config.keybinds;
+        match app.mode {
+            Mode::Normal => {
+                let mut parts = vec![
+                    format!("{}/{} move", kb.down, kb.up),
+                    format!("{}/{} jump", kb.jump_top, kb.jump_bottom),
+                    format!("{} search", kb.search),
+                ];
+                if !app.selected_is_group() {
+                    parts.push(format!("{}/{}/{} edit", kb.edit, kb.edit_append, kb.edit_substitute));
+                }
+                if app.selected_is_missing() {
+                    parts.push(format!("{} add", "a")); // 'a' is currently hardcoded in runner
+                }
+                if app.selected_is_array() {
+                    parts.push(format!("{}/{} array", kb.append_item, kb.prepend_item));
+                }
+                parts.push(format!("{} del", kb.delete_item));
+                parts.push(format!("{} undo", kb.undo));
+                parts.push(format!("{} save", kb.save));
+                parts.push(format!("{} quit", kb.quit));
+                parts.join(" · ")
+            }
+            Mode::Insert => "Esc normal · Enter commit".to_string(),
+            Mode::Search => "Esc normal · type to filter".to_string(),
+        }
+    };
 
     let status_line = Line::from(vec![
         Span::styled(mode_str, mode_style),
         Span::styled(
             format!(" {} ", status_msg),
-            Style::default().bg(theme.surface0()).fg(theme.text()),
+            Style::default().bg(theme.border_normal()).fg(theme.fg_normal()),
         ),
     ]);
 
-    let status = Paragraph::new(status_line).style(Style::default().bg(theme.surface0()));
+    let status = Paragraph::new(status_line).style(Style::default().bg(theme.border_normal()));
     f.render_widget(status, chunks[4]);
 }