Merge pull request 'fixed tests case' (#9) from release/0.4.0 into main

Reviewed-on: #9

Cargo.lock

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

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
-name = "mould"
-version = "0.2.1"
 edition = "2024"
+name = "mould"
+version = "0.4.0"
 authors = ["Nils Pukropp <nils@narl.io>"]
 
 [[bin]]
@@ -10,18 +10,24 @@ 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]
+version = "4.6.0"
+features = ["derive"]
+
+[dependencies.serde]
+version = "1.0.228"
+features = ["derive"]
+
 [dev-dependencies]
 tempfile = "3.27.0"

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`.
+- **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 the Catppuccin Mocha palette.
+- **Modern UI**: A polished, rounded interface featuring a semantic Catppuccin Mocha palette.
-- **Highly Configurable**: Customize keybindings and themes via a simple TOML configuration.
+- **Highly Configurable**: Customize keybindings and semantic themes via a simple TOML configuration.
-- **Dynamic Alignment**: Automatically aligns keys and values for perfect vertical readability.
 
 ## Installation
 
+### CLI Application
 Ensure you have Rust and Cargo installed, then run:
 
 ```sh
@@ -28,11 +31,21 @@ cd mould
 cargo build --release
 ```
 
-The binary will be installed as `mould`.
+### Neovim Plugin
+If you use a plugin manager like `lazy.nvim`, you can add the local repository (or remote once published) directly:
+
+```lua
+{
+  "username/mould", -- replace with actual repo path or github url
+  config = function()
+    -- Provides the :Mould command
+  end
+}
+```
 
 ## 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 +58,13 @@ mould config.template.json -o config.json
 - **Normal Mode**
   - `j` / `Down`: Move selection down
   - `k` / `Up`: Move selection up
+  - `gg`: Jump to the top
+  - `G`: Jump to the bottom
   - `i`: Edit the value of the currently selected key (Enter Insert Mode)
+  - `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 +89,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,41 @@
+# 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"
+save = ":w"
+quit = ":q"
+normal_mode = "Esc"
+search = "/"
+next_match = "n"
+previous_match = "N"
+jump_top = "gg"
+jump_bottom = "G"

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,14 @@ pub enum Mode {
     Normal,
     /// Active text entry mode for modifying values.
     Insert,
+    /// Active search mode for filtering keys.
+    Search,
 }
 
 /// 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 +25,14 @@ 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,
 }
 
 impl App {
     /// Initializes a new application instance with the provided variables.
-    pub fn new(vars: Vec<EnvVar>) -> Self {
+    pub fn new(vars: Vec<ConfigItem>) -> Self {
-        let initial_input = vars.get(0).map(|v| v.value.clone()).unwrap_or_default();
+        let initial_input = vars.get(0).and_then(|v| v.value.clone()).unwrap_or_default();
         Self {
             vars,
             selected: 0,
@@ -36,9 +40,24 @@ impl App {
             running: true,
             status_message: None,
             input: Input::new(initial_input),
+            search_query: String::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,25 +78,86 @@ 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) {
+        if let Some(var) = self.vars.get(self.selected) {
+            if !var.is_group {
                 self.mode = Mode::Insert;
                 self.status_message = None;
             }
+        }
+    }
 
     /// Commits the current input and transitions the application into Normal Mode.
     pub fn enter_normal(&mut self) {

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")]
+    #[arg(required = false, value_name = "INPUT_FILE")]
-    pub input: PathBuf,
+    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).
+    /// Default background.
-    pub crust: String,
+    pub bg_normal: String,
-    /// Dark surface color for UI elements like the status bar.
+    /// Background for selected items and standard UI elements.
-    pub surface0: String,
+    pub bg_highlight: String,
-    /// Light surface color for borders and dividers.
+    /// Active element background (e.g., insert mode).
-    pub surface1: String,
+    pub bg_active: String,
-    /// Default text color.
+    /// Active element background (e.g., search mode).
-    pub text: String,
+    pub bg_search: String,
-    /// Color for selection highlighting and normal mode tag.
+    /// Standard text.
-    pub blue: String,
+    pub fg_normal: String,
-    /// Color for insert mode highlighting and success status.
+    /// Secondary/inactive text.
-    pub green: String,
+    pub fg_dimmed: String,
-    /// Accent color for configuration keys.
+    /// Text on selected items.
-    pub lavender: String,
+    pub fg_highlight: String,
-    /// Accent color for primary section titles.
+    /// Red/Alert color for missing items.
-    pub mauve: String,
+    pub fg_warning: String,
-    /// Accent color for input field titles.
+    /// Accent color for modified items.
-    pub peach: String,
+    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,37 +56,52 @@ impl ThemeConfig {
         }
     }
 
-    pub fn crust(&self) -> Color { Self::parse_hex(&self.crust) }
+    pub fn bg_normal(&self) -> Color { Self::parse_hex(&self.bg_normal) }
-    pub fn surface0(&self) -> Color { Self::parse_hex(&self.surface0) }
+    pub fn bg_highlight(&self) -> Color { Self::parse_hex(&self.bg_highlight) }
-    pub fn surface1(&self) -> Color { Self::parse_hex(&self.surface1) }
+    pub fn bg_active(&self) -> Color { Self::parse_hex(&self.bg_active) }
-    pub fn text(&self) -> Color { Self::parse_hex(&self.text) }
+    pub fn bg_search(&self) -> Color { Self::parse_hex(&self.bg_search) }
-    pub fn blue(&self) -> Color { Self::parse_hex(&self.blue) }
+    pub fn fg_normal(&self) -> Color { Self::parse_hex(&self.fg_normal) }
-    pub fn green(&self) -> Color { Self::parse_hex(&self.green) }
+    pub fn fg_dimmed(&self) -> Color { Self::parse_hex(&self.fg_dimmed) }
-    pub fn lavender(&self) -> Color { Self::parse_hex(&self.lavender) }
+    pub fn fg_highlight(&self) -> Color { Self::parse_hex(&self.fg_highlight) }
-    pub fn mauve(&self) -> Color { Self::parse_hex(&self.mauve) }
+    pub fn fg_warning(&self) -> Color { Self::parse_hex(&self.fg_warning) }
-    pub fn peach(&self) -> Color { Self::parse_hex(&self.peach) }
+    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(),
+            bg_normal: "#1e1e2e".to_string(), // base
-            surface0: "#313244".to_string(),
+            bg_highlight: "#89b4fa".to_string(), // blue
-            surface1: "#45475a".to_string(),
+            bg_active: "#a6e3a1".to_string(), // green
-            text: "#cdd6f4".to_string(),
+            bg_search: "#cba6f7".to_string(), // mauve
-            blue: "#89b4fa".to_string(),
+            fg_normal: "#cdd6f4".to_string(), // text
-            green: "#a6e3a1".to_string(),
+            fg_dimmed: "#6c7086".to_string(), // overlay0
-            lavender: "#b4befe".to_string(),
+            fg_highlight: "#1e1e2e".to_string(), // base (dark for contrast against highlights)
-            mauve: "#cba6f7".to_string(),
+            fg_warning: "#f38ba8".to_string(), // red
-            peach: "#fab387".to_string(),
+            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,
@@ -80,6 +109,11 @@ pub struct KeybindsConfig {
     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,
 }
 
 impl Default for KeybindsConfig {
@@ -91,6 +125,11 @@ impl Default for KeybindsConfig {
             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(),
         }
     }
 }

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};
 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,15 @@ 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(),
+                    path: key.trim().to_string(),
-                    default_value: parsed_val,
+                    value: Some(parsed_val.clone()),
+                    template_value: Some(parsed_val.clone()),
+                    default_value: Some(parsed_val),
+                    depth: 0,
+                    is_group: false,
+                    status: ItemStatus::Present,
                 });
             }
         }
@@ -29,7 +34,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 +51,44 @@ 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(),
+                        path: key.to_string(),
-                        default_value: String::new(),
+                        value: Some(parsed_val),
+                        template_value: None,
+                        default_value: None,
+                        depth: 0,
+                        is_group: false,
+                        status: ItemStatus::MissingFromTemplate,
                     });
                 }
             }
         }
         
+        // 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 +113,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].value.as_deref(), Some("value1"));
-        assert_eq!(vars[0].default_value, "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 +136,29 @@ mod tests {
 
         assert_eq!(vars.len(), 3);
         assert_eq!(vars[0].key, "KEY1");
-        assert_eq!(vars[0].value, "custom1");
+        assert_eq!(vars[0].value.as_deref(), Some("custom1"));
-        assert_eq!(vars[0].default_value, "default1");
+        assert_eq!(vars[0].status, ItemStatus::Modified);
 
         assert_eq!(vars[1].key, "KEY2");
-        assert_eq!(vars[1].value, "default2");
+        assert_eq!(vars[1].value.as_deref(), Some("default2"));
-        assert_eq!(vars[1].default_value, "default2");
         
         assert_eq!(vars[2].key, "KEY3");
-        assert_eq!(vars[2].value, "custom3");
+        assert_eq!(vars[2].value.as_deref(), Some("custom3"));
-        assert_eq!(vars[2].default_value, "");
+        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(),
+            path: "KEY1".to_string(),
-            default_value: "def".to_string(),
+            value: Some("value1".to_string()),
+            template_value: None,
+            default_value: None,
+            depth: 0,
+            is_group: false,
+            status: ItemStatus::Present,
         }];
 
         let handler = EnvHandler;

src/format/hierarchical.rs

@@ -1,4 +1,4 @@
-use super::{EnvVar, FormatHandler, FormatType};
+use super::{ConfigItem, FormatHandler, FormatType, ItemStatus};
 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::Json => serde_json::from_str(&content)
-            FormatType::Yaml => serde_yaml::from_str(&content).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+                .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::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::Json => serde_json::to_string_pretty(value)
-            FormatType::Yaml => serde_yaml::to_string(value).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+                .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))?;
+                    let toml_value: toml::Value = serde_json::from_value(value.clone())
-                    toml::to_string_pretty(&toml_value).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?
+                        .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,87 +53,160 @@ 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 {
+        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,
+                });
+            }
+            let next_depth = if path.is_empty() { depth } else { depth + 1 };
             for (k, v) in map {
-                let new_prefix = if prefix.is_empty() {
+                flatten(v, &path, next_depth, k, vars);
-                    k.clone()
-                } else {
-                    format!("{}.{}", prefix, k)
-                };
-                flatten(v, &new_prefix, 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,
+                });
+            }
+            let next_depth = if path.is_empty() { depth } else { depth + 1 };
             for (i, v) in arr.iter().enumerate() {
-                let new_prefix = format!("{}[{}]", prefix, i);
+                let array_key = format!("[{}]", i);
-                flatten(v, &new_prefix, vars);
+                flatten(v, &path, next_depth, &array_key, vars);
             }
         }
         Value::String(s) => {
-            vars.push(EnvVar {
+            vars.push(ConfigItem {
-                key: prefix.to_string(),
+                key: key_name.to_string(),
-                value: s.clone(),
+                path: path.clone(),
-                default_value: s.clone(),
+                value: Some(s.clone()),
+                template_value: Some(s.clone()),
+                default_value: Some(s.clone()),
+                depth,
+                is_group: false,
+                status: ItemStatus::Present,
             });
         }
         Value::Number(n) => {
             let s = n.to_string();
-            vars.push(EnvVar {
+            vars.push(ConfigItem {
-                key: prefix.to_string(),
+                key: key_name.to_string(),
-                value: s.clone(),
+                path: path.clone(),
-                default_value: s.clone(),
+                value: Some(s.clone()),
+                template_value: Some(s.clone()),
+                default_value: Some(s.clone()),
+                depth,
+                is_group: false,
+                status: ItemStatus::Present,
             });
         }
         Value::Bool(b) => {
             let s = b.to_string();
-            vars.push(EnvVar {
+            vars.push(ConfigItem {
-                key: prefix.to_string(),
+                key: key_name.to_string(),
-                value: s.clone(),
+                path: path.clone(),
-                default_value: s.clone(),
+                value: Some(s.clone()),
+                template_value: Some(s.clone()),
+                default_value: Some(s.clone()),
+                depth,
+                is_group: false,
+                status: ItemStatus::Present,
             });
         }
         Value::Null => {
-            vars.push(EnvVar {
+            vars.push(ConfigItem {
-                key: prefix.to_string(),
+                key: key_name.to_string(),
-                value: "".to_string(),
+                path: path.clone(),
-                default_value: "".to_string(),
+                value: Some("".to_string()),
+                template_value: Some("".to_string()),
+                default_value: Some("".to_string()),
+                depth,
+                is_group: false,
+                status: ItemStatus::Present,
             });
         }
     }
 }
 
-// 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);
+            }
         }
         self.write_value(path, &root)
     }
@@ -182,7 +265,9 @@ fn insert_into_value(root: &mut Value, path: &str, new_val_str: &str) {
     };
 
     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());
         }
@@ -225,12 +310,14 @@ mod tests {
             }
         });
 
-        flatten(&json, "", &mut vars);
+        flatten(&json, "", 0, "", &mut vars);
-        assert_eq!(vars.len(), 2);
+        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(""));
+            }
         }
 
         // When unflattening, it parses bool back

src/format/mod.rs

@@ -1,14 +1,27 @@
-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)]
-pub struct EnvVar {
+pub struct ConfigItem {
     pub key: String,
-    pub value: String,
+    pub path: String,
-    pub default_value: 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,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -20,9 +33,9 @@ pub enum FormatType {
 }
 
 pub trait FormatHandler {
-    fn parse(&self, path: &Path) -> io::Result<Vec<EnvVar>>;
+    fn parse(&self, path: &Path) -> io::Result<Vec<ConfigItem>>;
-    fn merge(&self, path: &Path, vars: &mut Vec<EnvVar>) -> io::Result<()>;
+    fn merge(&self, path: &Path, vars: &mut Vec<ConfigItem>) -> io::Result<()>;
-    fn write(&self, path: &Path, vars: &[EnvVar]) -> 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

@@ -18,30 +18,56 @@ 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};
+use ratatui::{Terminal, backend::CrosstermBackend};
 
 /// 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" {
+    // Standard mappings
+    if file_name == ".env.example" || file_name == ".env.template" {
         return input.with_file_name(".env");
     }
 
-    if file_name == "docker-compose.yml" {
+    if file_name == "docker-compose.yml" || file_name == "compose.yml" {
-        return input.with_file_name("docker-compose.override.yml");
+        return input.with_file_name("compose.override.yml");
     }
-    if file_name == "docker-compose.yaml" {
+    if file_name == "docker-compose.yaml" || file_name == "compose.yaml" {
-        return input.with_file_name("docker-compose.override.yaml");
+        return input.with_file_name("compose.override.yaml");
     }
 
-    if file_name.ends_with(".example.json") {
+    // Pattern-based mappings
-        return input.with_file_name(file_name.replace(".example.json", ".json"));
+    if let Some(base) = file_name.strip_suffix(".env.example") {
+        return input.with_file_name(format!("{}.env", base));
     }
-    if file_name.ends_with(".template.json") {
+    if let Some(base) = file_name.strip_suffix(".env.template") {
-        return input.with_file_name(file_name.replace(".template.json", ".json"));
+        return input.with_file_name(format!("{}.env", base));
+    }
+    if let Some(base) = file_name.strip_suffix(".example.json") {
+        return input.with_file_name(format!("{}.json", base));
+    }
+    if let Some(base) = file_name.strip_suffix(".template.json") {
+        return input.with_file_name(format!("{}.json", base));
+    }
+    if let Some(base) = file_name.strip_suffix(".example.yml") {
+        return input.with_file_name(format!("{}.yml", base));
+    }
+    if let Some(base) = file_name.strip_suffix(".template.yml") {
+        return input.with_file_name(format!("{}.yml", base));
+    }
+    if let Some(base) = file_name.strip_suffix(".example.yaml") {
+        return input.with_file_name(format!("{}.yaml", base));
+    }
+    if let Some(base) = file_name.strip_suffix(".template.yaml") {
+        return input.with_file_name(format!("{}.yaml", base));
+    }
+    if let Some(base) = file_name.strip_suffix(".example.toml") {
+        return input.with_file_name(format!("{}.toml", base));
+    }
+    if let Some(base) = file_name.strip_suffix(".template.toml") {
+        return input.with_file_name(format!("{}.toml", base));
     }
 
     input.with_extension(format!(
@@ -50,6 +76,60 @@ fn determine_output_path(input: &Path) -> PathBuf {
     ))
 }
 
+/// Discovers common configuration template files in the current directory.
+fn find_input_file() -> Option<PathBuf> {
+    let candidates = [
+        ".env.example",
+        "compose.yml",
+        "docker-compose.yml",
+        ".env.template",
+        "compose.yaml",
+        "docker-compose.yaml",
+    ];
+
+    // Priority 1: Exact matches for well-known defaults
+    for name in &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();
+
+            if name_str.ends_with(".env.example")
+                || name_str.ends_with(".env.template")
+                || name_str.ends_with(".example.json")
+                || name_str.ends_with(".template.json")
+                || name_str.ends_with(".example.yml")
+                || name_str.ends_with(".template.yml")
+                || name_str.ends_with(".example.yaml")
+                || name_str.ends_with(".template.yaml")
+                || name_str.ends_with(".example.toml")
+                || name_str.ends_with(".template.toml")
+            {
+                // Prefer .env.* or compose.* if multiple matches
+                if name_str.contains(".env") || name_str.contains("compose") {
+                    return Some(entry.path());
+                }
+                if fallback.is_none() {
+                    fallback = Some(entry.path());
+                }
+            }
+        }
+        if let Some(path) = fallback {
+            return Some(path);
+        }
+    }
+
+    None
+}
+
 fn main() -> anyhow::Result<()> {
     let args = cli::parse();
 
@@ -64,41 +144,109 @@ fn main() -> anyhow::Result<()> {
         .format_timestamp(None)
         .init();
 
-    let input_path = args.input;
+    let input_path = match args.input {
-    if !input_path.exists() {
+        Some(path) => {
-        error!("Input file not found: {}", input_path.display());
+            if !path.exists() {
-        return Err(MouldError::FileNotFound(input_path.display().to_string()).into());
+                error!("Input file not found: {}", path.display());
+                return Err(MouldError::FileNotFound(path.display().to_string()).into());
             }
+            path
+        }
+        None => match 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 input_name = input_path.file_name().unwrap_or_default().to_string_lossy();
+    let is_template_input = input_name.contains(".example") || input_name.contains(".template") || input_name == "compose.yml" || input_name == "docker-compose.yml";
+    
+    let mut template_path = None;
+    let mut active_path = None;
+
+    if is_template_input {
+        template_path = Some(input_path.clone());
+        let expected_active = determine_output_path(&input_path);
+        if expected_active.exists() {
+            active_path = Some(expected_active);
+        }
+    } else {
+        // Input is likely an active config (e.g., .env)
+        active_path = Some(input_path.clone());
+        // Try to find a template
+        let possible_templates = [
+            format!("{}.example", input_name),
+            format!("{}.template", input_name),
+        ];
+        for t in possible_templates {
+            let p = input_path.with_file_name(t);
+            if p.exists() {
+                template_path = Some(p);
+                break;
+            }
+        }
+    }
+
     let output_path = args
         .output
-        .unwrap_or_else(|| determine_output_path(&input_path));
+        .unwrap_or_else(|| active_path.clone().unwrap_or_else(|| 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) {
+    if vars.is_empty() {
-        warn!("Could not merge existing output file: {}", e);
+        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 +254,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 +269,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/runner.rs

@@ -2,8 +2,8 @@ use crate::app::{App, 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,90 @@ 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();
+            self.key_sequence.push(c);
-            if c_str == self.config.keybinds.down {
+
-                self.app.next();
+            // Collect all configured keybinds
-            } else if c_str == self.config.keybinds.up {
+            let binds = [
-                self.app.previous();
+                (&self.config.keybinds.down, "down"),
-            } else if c_str == self.config.keybinds.edit {
+                (&self.config.keybinds.up, "up"),
-                self.app.enter_insert();
+                (&self.config.keybinds.edit, "edit"),
-            } else if c_str == ":" {
+                (&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"),
+                (&"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(),
+                    "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(),
+                    "add_missing" => 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 +207,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.
+            // Indentation based on depth
-            let val = if is_selected && matches!(app.mode, Mode::Insert) {
+            let indent = "  ".repeat(var.depth);
-                app.input.value()
+            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![
+                let mut val_spans = vec![
-                Span::styled(
+                    Span::raw(format!("{}    └─ ", "  ".repeat(var.depth))),
-                    format!(" {:<width$} ", var.key, width = max_key_len),
+                    Span::styled(val, value_style),
-                    key_style,
+                ];
-                ),
-                Span::styled("│ ", Style::default().fg(theme.surface1())),
-                Span::styled(format!(" {} ", val), value_style),
-            ]);
 
-            let item_style = if is_selected {
+                if let Some(t_val) = &var.template_value {
-                Style::default().bg(theme.blue())
+                    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))
+            .title_style(
-            .border_style(Style::default().fg(theme.surface1())),
+                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 {
+    let mut input_title = " Input ".to_string();
-        if var.default_value.is_empty() {
+    let mut extra_info = String::new();
-            format!(" Editing: {} ", var.key)
+
+    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::Insert => theme.border_active(),
-        Mode::Normal => theme.surface1(),
+        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)
+    // Show template value in normal mode if it differs
-        .style(Style::default().fg(theme.text()))
+    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,43 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
         Mode::Normal => (
             " NORMAL ",
             Style::default()
-                .bg(theme.blue())
+                .bg(theme.bg_highlight())
-                .fg(theme.crust())
+                .fg(theme.bg_normal())
                 .add_modifier(Modifier::BOLD),
         ),
         Mode::Insert => (
             " INSERT ",
             Style::default()
-                .bg(theme.green())
+                .bg(theme.bg_active())
-                .fg(theme.crust())
+                .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 {
+    let status_msg = app
-        Mode::Normal => " navigation | i: edit | :w: save | :q: quit ",
+        .status_message
+        .as_deref()
+        .unwrap_or_else(|| match app.mode {
+            Mode::Normal => " navigation | i: edit | /: search | :w: save | :q: quit ",
             Mode::Insert => " Esc: back to normal | Enter: commit ",
+            Mode::Search => " Esc: back to normal | type to filter ",
         });
 
     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]);
 }