Merge pull request 'release/0.3.0' (#6) from release/0.3.0 into main

Reviewed-on: #6

Cargo.lock

@@ -17,6 +17,21 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse 0.2.7",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
 [[package]]
 name = "anstream"
 version = "1.0.0"
@@ -24,7 +39,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
 dependencies = [
  "anstyle",
- "anstyle-parse",
+ "anstyle-parse 1.0.0",
  "anstyle-query",
  "anstyle-wincon",
  "colorchoice",
@@ -38,6 +53,15 @@ version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
 
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
 [[package]]
 name = "anstyle-parse"
 version = "1.0.0"
@@ -179,7 +203,7 @@ version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
 dependencies = [
- "anstream",
+ "anstream 1.0.0",
  "anstyle",
  "clap_lex",
  "strsim",
@@ -405,6 +429,29 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
+[[package]]
+name = "env_filter"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a1c3cc8e57274ec99de65301228b537f1e4eedc1b8e0f9411c6caac8ae7308f"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2daee4ea451f429a58296525ddf28b45a3b64f1acf6587e2067437bb11e218d"
+dependencies = [
+ "anstream 0.6.21",
+ "anstyle",
+ "env_filter",
+ "jiff",
+ "log",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -632,6 +679,30 @@ version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
+[[package]]
+name = "jiff"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a3546dc96b6d42c5f24902af9e2538e82e39ad350b0c766eb3fbf2d8f3d8359"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "js-sys"
 version = "0.3.91"
@@ -782,16 +853,20 @@ dependencies = [
 
 [[package]]
 name = "mould"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
+ "anyhow",
  "clap",
  "crossterm",
  "dirs",
+ "env_logger",
+ "log",
  "ratatui",
  "serde",
  "serde_json",
  "serde_yaml",
  "tempfile",
+ "thiserror 2.0.18",
  "toml",
  "tui-input",
 ]
@@ -1005,6 +1080,15 @@ version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
 
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "091397be61a01d4be58e7841595bd4bfedb15f1cd54977d79b8271e94ed799a3"
+dependencies = [
+ "portable-atomic",
+]
+
 [[package]]
 name = "powerfmt"
 version = "0.2.0"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mould"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 authors = ["Nils Pukropp <nils@narl.io>"]
 
@@ -9,13 +9,17 @@ 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"
 

Cargo.toml.out

@@ -0,0 +1,33 @@
+[[bin]]
+name = "mould"
+path = "src/main.rs"
+
+[dependencies]
+anyhow = "1.0.102"
+crossterm = "0.29.0"
+dirs = "6.0.0"
+env_logger = "0.11.9"
+log = "0.4.29"
+ratatui = "0.30.0"
+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.3.0"

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 The mould Contributors
+Copyright (c) 2026 Nils Pukropp <nils@narl.io>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -11,6 +11,8 @@ mould is a modern Terminal User Interface (TUI) tool designed for interactively
 - **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.
+- **Default Value Visibility**: Keep track of original template values while editing.
+- **Incremental Merging**: Load existing values from an output file to continue where you left off.
 
 ## Installation
 
@@ -46,6 +48,9 @@ mould config.template.json -o config.json
   - `j` / `Down`: Move selection down
   - `k` / `Up`: Move selection up
   - `i`: Edit the value of the currently selected key (Enter Insert Mode)
+  - `/`: 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
@@ -72,7 +77,19 @@ quit = ":q"
 normal_mode = "Esc"
 
 [theme]
-name = "catppuccin_mocha"
+# Enable transparency to let your terminal background show through
+transparent = false
+
+# Custom color palette (Catppuccin Mocha defaults)
+crust = "#11111b"
+surface0 = "#313244"
+surface1 = "#45475a"
+text = "#cdd6f4"
+blue = "#89b4fa"
+green = "#a6e3a1"
+lavender = "#b4befe"
+mauve = "#cba6f7"
+peach = "#fab387"
 ```
 
 ## License

config.example.toml

@@ -0,0 +1,49 @@
+# 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 Catppuccin Mocha palette.
+
+# Main background color (used when transparent = false).
+crust = "#11111b"
+
+# Status bar background and other secondary UI elements.
+surface0 = "#313244"
+
+# Border and separator color.
+surface1 = "#45475a"
+
+# Default text color.
+text = "#cdd6f4"
+
+# Selection highlight and "NORMAL" mode tag color.
+blue = "#89b4fa"
+
+# Insert mode highlight and "INSERT" mode tag color.
+green = "#a6e3a1"
+
+# Keys/labels color.
+lavender = "#b4befe"
+
+# Section titles color.
+mauve = "#cba6f7"
+
+# Input field titles color.
+peach = "#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"

src/app.rs

@@ -1,21 +1,36 @@
 use crate::format::EnvVar;
 use tui_input::Input;
 
+/// Represents the current operating mode of the application.
 pub enum Mode {
+    /// Standard navigation and command 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>,
+    /// Index of the currently selected variable in the list.
     pub selected: usize,
+    /// The current interaction mode (Normal or Insert).
     pub mode: Mode,
+    /// Whether the main application loop should continue running.
     pub running: bool,
+    /// An optional message to display in the status bar (e.g., "Saved to .env").
     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 {
         let initial_input = vars.get(0).map(|v| v.value.clone()).unwrap_or_default();
         Self {
@@ -25,9 +40,25 @@ 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() {
             self.selected = (self.selected + 1) % self.vars.len();
@@ -35,6 +66,7 @@ impl App {
         }
     }
 
+    /// Moves the selection to the previous variable in the list, wrapping around if necessary.
     pub fn previous(&mut self) {
         if !self.vars.is_empty() {
             if self.selected == 0 {
@@ -46,30 +78,66 @@ impl App {
         }
     }
 
+    /// 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());
         }
     }
 
+    /// 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();
         }
     }
 
+    /// Transitions the application into Insert Mode.
     pub fn enter_insert(&mut self) {
         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) {
         self.commit_input();
         self.mode = Mode::Normal;
     }
-
-    #[allow(dead_code)]
-    pub fn quit(&mut self) {
-        self.running = false;
-    }
 }

src/cli.rs

@@ -1,21 +1,34 @@
 use clap::Parser;
 use std::path::PathBuf;
 
+/// mould: A TUI tool to generate and edit configuration files (.env, json, yaml, toml)
 #[derive(Parser, Debug)]
-#[command(author, version, about = "mould: A TUI tool to generate and edit configuration files (.env, json, yaml, toml)")]
+#[command(
+    author,
+    version,
+    about = "mould: A TUI tool to generate and edit configuration files (.env, json, yaml, toml)",
+    long_about = "mould allows you to interactively edit and generate configuration files using templates. It supports various formats including .env, JSON, YAML, and TOML. It features a modern TUI with Vim-inspired keybindings and out-of-the-box support for theming.",
+    after_help = "EXAMPLES:\n  mould .env.example\n  mould docker-compose.yml\n  mould config.template.json -o config.json"
+)]
 pub struct Cli {
     /// The input template file (e.g., .env.example, config.json.template, docker-compose.yml)
-    pub input: PathBuf,
+    #[arg(required = false, value_name = "INPUT_FILE")]
+    pub input: Option<PathBuf>,
 
-    /// Optional output file. If not provided, it will be inferred (e.g., .env.example -> .env, docker-compose.yml -> docker-compose.override.yml)
+    /// Optional output file. If not provided, it will be inferred.
-    #[arg(short, long)]
+    #[arg(short, long, value_name = "OUTPUT_FILE")]
     pub output: Option<PathBuf>,
 
     /// Override the format detection (env, json, yaml, toml)
-    #[arg(short, long)]
+    #[arg(short, long, value_name = "FORMAT", value_parser = ["env", "json", "yaml", "toml"])]
     pub format: Option<String>,
+
+    /// Increase verbosity for logging (can be used multiple times)
+    #[arg(short, long, action = clap::ArgAction::Count)]
+    pub verbose: u8,
 }
 
+/// Parses and returns the command-line arguments.
 pub fn parse() -> Cli {
     Cli::parse()
 }

src/config.rs

@@ -1,23 +1,35 @@
+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)]
-pub struct ThemeConfig {
 #[serde(default)]
+pub struct ThemeConfig {
+    /// If true, skip rendering the background block to let the terminal's transparency show.
     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,
 }
 
 impl ThemeConfig {
+    /// Internal helper to parse a hex color string ("#RRGGBB") into a TUI Color.
     fn parse_hex(hex: &str) -> Color {
         let hex = hex.trim_start_matches('#');
         if hex.len() == 6 {
@@ -30,18 +42,37 @@ impl ThemeConfig {
         }
     }
 
-    pub fn crust(&self) -> Color { Self::parse_hex(&self.crust) }
+    pub fn crust(&self) -> Color {
-    pub fn surface0(&self) -> Color { Self::parse_hex(&self.surface0) }
+        Self::parse_hex(&self.crust)
-    pub fn surface1(&self) -> Color { Self::parse_hex(&self.surface1) }
+    }
-    pub fn text(&self) -> Color { Self::parse_hex(&self.text) }
+    pub fn surface0(&self) -> Color {
-    pub fn blue(&self) -> Color { Self::parse_hex(&self.blue) }
+        Self::parse_hex(&self.surface0)
-    pub fn green(&self) -> Color { Self::parse_hex(&self.green) }
+    }
-    pub fn lavender(&self) -> Color { Self::parse_hex(&self.lavender) }
+    pub fn surface1(&self) -> Color {
-    pub fn mauve(&self) -> Color { Self::parse_hex(&self.mauve) }
+        Self::parse_hex(&self.surface1)
-    pub fn peach(&self) -> Color { Self::parse_hex(&self.peach) }
+    }
+    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)
+    }
 }
 
 impl Default for ThemeConfig {
+    /// Default theme: Catppuccin Mocha.
     fn default() -> Self {
         Self {
             transparent: false,
@@ -58,7 +89,9 @@ impl Default for ThemeConfig {
     }
 }
 
+/// Custom keybindings for navigation and application control.
 #[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(default)]
 pub struct KeybindsConfig {
     pub down: String,
     pub up: String,
@@ -66,6 +99,9 @@ pub struct KeybindsConfig {
     pub save: String,
     pub quit: String,
     pub normal_mode: String,
+    pub search: String,
+    pub next_match: String,
+    pub previous_match: String,
 }
 
 impl Default for KeybindsConfig {
@@ -77,10 +113,14 @@ 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(),
         }
     }
 }
 
+/// Root configuration structure for mould.
 #[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct Config {
     #[serde(default)]
@@ -89,6 +129,8 @@ pub struct Config {
     pub keybinds: KeybindsConfig,
 }
 
+/// Loads the configuration from the user's home config directory (~/.config/mould/config.toml).
+/// Falls back to default settings if no configuration is found.
 pub fn load_config() -> Config {
     if let Some(mut config_dir) = dirs::config_dir() {
         config_dir.push("mould");

src/error.rs

@@ -0,0 +1,18 @@
+use std::io;
+use thiserror::Error;
+
+/// Custom error types for the mould application.
+#[derive(Error, Debug)]
+pub enum MouldError {
+    #[error("IO error: {0}")]
+    Io(#[from] io::Error),
+
+    #[error("Format error: {0}")]
+    Format(String),
+
+    #[error("File not found: {0}")]
+    FileNotFound(String),
+
+    #[error("Terminal error: {0}")]
+    Terminal(String),
+}

src/format/hierarchical.rs

@@ -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!(),
@@ -121,14 +131,6 @@ impl FormatHandler for HierarchicalHandler {
     }
 
     fn write(&self, path: &Path, vars: &[EnvVar]) -> io::Result<()> {
-        // For writing hierarchical formats, we ideally want to preserve the original structure.
-        // But we don't have it here. We should parse the template again to get the structure!
-        // Oh wait, `write` is called with only `vars`.
-        // If we want to construct the tree from scratch, it's very difficult to guess array vs object
-        // and data types without the original template.
-        // Let's change the trait or just keep a copy of the template?
-        // Actually, if we require the user to have the template, we can just parse the template, update the leaves, and write.
-        // We'll write a reconstruction algorithm that just creates objects based on keys.
         let mut root = Value::Object(Map::new());
         for var in vars {
             insert_into_value(&mut root, &var.key, &var.value);
@@ -190,7 +192,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());
         }

src/format/mod.rs

@@ -1,5 +1,5 @@
-use std::path::Path;
 use std::io;
+use std::path::Path;
 
 pub mod env;
 pub mod hierarchical;

src/main.rs

@@ -1,56 +1,172 @@
 mod app;
 mod cli;
 mod config;
+mod error;
 mod format;
 mod runner;
 mod ui;
 
 use app::App;
 use config::load_config;
+use error::MouldError;
 use format::{detect_format, get_handler};
+use log::{error, info, warn};
 use runner::AppRunner;
-use std::error::Error;
 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};
+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" {
+
-        return input.with_file_name("docker-compose.override.yml");
+    if file_name == "docker-compose.yml" || file_name == "compose.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") {
+
-        return input.with_file_name(file_name.replace(".example.json", ".json"));
+    // Pattern-based mappings
+    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!(
         "{}.out",
         input.extension().unwrap_or_default().to_string_lossy()
     ))
 }
 
-fn main() -> Result<(), Box<dyn Error>> {
+/// 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();
 
-    let input_path = args.input;
+    // Initialize logger with verbosity from CLI
-    if !input_path.exists() {
+    let log_level = match args.verbose {
-        println!("Input file does not exist: {}", input_path.display());
+        0 => log::LevelFilter::Warn,
-        return Ok(());
+        1 => log::LevelFilter::Info,
+        _ => log::LevelFilter::Debug,
+    };
+    env_logger::Builder::new()
+        .filter_level(log_level)
+        .format_timestamp(None)
+        .init();
+
+    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 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);
@@ -59,46 +175,61 @@ fn main() -> Result<(), Box<dyn Error>> {
         .output
         .unwrap_or_else(|| determine_output_path(&input_path));
 
-    let mut vars = handler.parse(&input_path).unwrap_or_else(|err| {
+    info!("Output: {}", output_path.display());
-        println!("Error parsing input file: {}", err);
+
-        vec![]
+    let mut 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() {
-        println!(
+        warn!("No variables found in {}", input_path.display());
-            "No variables found in {} or file could not be parsed.",
-            input_path.display()
-        );
-        return Ok(());
     }
 
     if let Err(e) = handler.merge(&output_path, &mut vars) {
-        println!("Warning: Could not merge existing output file: {}", e);
+        warn!("Could not merge existing output file: {}", e);
     }
 
     let config = load_config();
     let mut app = App::new(vars);
 
-    enable_raw_mode()?;
+    // Terminal lifecycle
+    enable_raw_mode()
+        .map_err(|e| MouldError::Terminal(format!("Failed to enable raw mode: {}", e)))?;
     let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)
+        .map_err(|e| MouldError::Terminal(format!("Failed to enter alternate screen: {}", e)))?;
     let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
+    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();
 
-    disable_raw_mode()?;
+    // Restoration
+    disable_raw_mode().ok();
     execute!(
         terminal.backend_mut(),
         LeaveAlternateScreen,
         DisableMouseCapture
-    )?;
+    )
-    terminal.show_cursor()?;
+    .ok();
-
+    terminal.show_cursor().ok();
-    if let Err(err) = res {
-        println!("{:?}", err);
-    }
 
+    match res {
+        Ok(_) => {
+            info!("Successfully finished mould session.");
             Ok(())
         }
+        Err(e) => {
+            error!("Application error during run: {}", e);
+            Err(e.into())
+        }
+    }
+}

src/runner.rs

@@ -2,18 +2,25 @@ 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;
 
+/// Manages the main application execution loop, event handling, and terminal interaction.
 pub struct AppRunner<'a, B: Backend> {
+    /// Reference to the terminal instance.
     terminal: &'a mut Terminal<B>,
+    /// Mutable reference to the application state.
     app: &'a mut App,
+    /// Loaded user configuration.
     config: &'a Config,
+    /// Path where the final configuration will be saved.
     output_path: &'a Path,
+    /// Handler for the specific file format (env, json, yaml, toml).
     handler: &'a dyn FormatHandler,
+    /// Buffer for storing active command entry (e.g., ":w").
     command_buffer: String,
 }
 
@@ -21,6 +28,7 @@ impl<'a, B: Backend> AppRunner<'a, B>
 where
     io::Error: From<B::Error>,
 {
+    /// Creates a new runner instance.
     pub fn new(
         terminal: &'a mut Terminal<B>,
         app: &'a mut App,
@@ -38,9 +46,11 @@ where
         }
     }
 
+    /// Starts the main application loop.
     pub fn run(&mut self) -> io::Result<()> {
         while self.app.running {
-            self.terminal.draw(|f| crate::ui::draw(f, self.app, self.config))?;
+            self.terminal
+                .draw(|f| crate::ui::draw(f, self.app, self.config))?;
 
             if let Event::Key(key) = event::read()? {
                 self.handle_key_event(key)?;
@@ -49,13 +59,16 @@ where
         Ok(())
     }
 
+    /// Primary dispatcher for all keyboard events.
     fn handle_key_event(&mut self, key: KeyEvent) -> io::Result<()> {
         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),
         }
     }
 
+    /// Handles keys in Normal mode, separating navigation from command entry.
     fn handle_normal_mode(&mut self, key: KeyEvent) -> io::Result<()> {
         if !self.command_buffer.is_empty() {
             self.handle_command_mode(key)
@@ -64,6 +77,7 @@ where
         }
     }
 
+    /// Logic for entering and executing ":" style commands.
     fn handle_command_mode(&mut self, key: KeyEvent) -> io::Result<()> {
         match key.code {
             KeyCode::Enter => {
@@ -90,6 +104,7 @@ 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();
@@ -104,6 +119,14 @@ where
                 self.sync_command_status();
             } else if c_str == "q" {
                 self.app.running = false;
+            } else if c_str == self.config.keybinds.search {
+                self.app.mode = Mode::Search;
+                self.app.search_query.clear();
+                self.app.status_message = Some(format!("{} ", self.config.keybinds.search));
+            } else if c_str == self.config.keybinds.next_match {
+                self.app.jump_next_match();
+            } else if c_str == self.config.keybinds.previous_match {
+                self.app.jump_previous_match();
             }
         } else {
             match key.code {
@@ -116,6 +139,7 @@ where
         Ok(())
     }
 
+    /// Delegates key events to the `tui_input` handler during active editing.
     fn handle_insert_mode(&mut self, key: KeyEvent) -> io::Result<()> {
         match key.code {
             KeyCode::Esc | KeyCode::Enter => {
@@ -128,6 +152,29 @@ 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 {
             self.save_file()
@@ -144,6 +191,7 @@ where
         }
     }
 
+    /// Attempts to write the current app state to the specified output file.
     fn save_file(&mut self) -> io::Result<()> {
         if self.handler.write(self.output_path, &self.app.vars).is_ok() {
             self.app.status_message = Some(format!("Saved to {}", self.output_path.display()));
@@ -153,6 +201,7 @@ where
         Ok(())
     }
 
+    /// Synchronizes the status bar display with the active command buffer.
     fn sync_command_status(&mut self) {
         if self.command_buffer.is_empty() {
             self.app.status_message = None;

src/ui.rs

@@ -1,59 +1,59 @@
 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.
 pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
     let theme = &config.theme;
     let size = f.area();
 
-    // Background
+    // Render the main background (optional based on transparency config).
     if !theme.transparent {
-        f.render_widget(Block::default().style(Style::default().bg(theme.crust())), size);
+        f.render_widget(
+            Block::default().style(Style::default().bg(theme.crust())),
+            size,
+        );
     }
 
-    // Main layout with horizontal padding
+    // Horizontal layout with 1-character side margins.
     let outer_layout = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([
-            Constraint::Length(1), // Left padding
+            Constraint::Length(1),
-            Constraint::Min(0),    // Content
+            Constraint::Min(0),
-            Constraint::Length(1), // Right padding
+            Constraint::Length(1),
         ])
         .split(size);
 
+    // Vertical layout for the main UI components.
     let chunks = Layout::default()
         .direction(Direction::Vertical)
         .constraints([
-            Constraint::Length(1), // Top padding
+            Constraint::Length(1), // Top margin
-            Constraint::Min(3),    // List
+            Constraint::Min(3),    // Main list
-            Constraint::Length(3), // Input area
+            Constraint::Length(3), // Focused input field
-            Constraint::Length(1), // Bottom padding
+            Constraint::Length(1), // Spacer
             Constraint::Length(1), // Status bar
         ])
         .split(outer_layout[1]);
 
-    let max_key_len = app
+    // Build the interactive list of configuration variables.
-        .vars
+    let matching_indices = app.matching_indices();
-        .iter()
-        .map(|v| v.key.len())
-        .max()
-        .unwrap_or(20)
-        .min(40);
-
-    // List
     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()
             } else {
@@ -61,7 +61,13 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
             };
 
             let key_style = if is_selected {
-                Style::default().fg(theme.crust()).add_modifier(Modifier::BOLD)
+                Style::default()
+                    .fg(theme.crust())
+                    .add_modifier(Modifier::BOLD)
+            } else if is_match {
+                Style::default()
+                    .fg(theme.mauve())
+                    .add_modifier(Modifier::UNDERLINED)
             } else {
                 Style::default().fg(theme.lavender())
             };
@@ -72,11 +78,25 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
                 Style::default().fg(theme.text())
             };
 
-            let line = Line::from(vec![
+            // Path styling for nested keys (e.g., a.b.c)
-                Span::styled(format!(" {:<width$} ", var.key, width = max_key_len), key_style),
+            let mut key_spans = Vec::new();
-                Span::styled("│ ", Style::default().fg(theme.surface1())),
+            if let Some(last_dot) = var.key.rfind('.') {
-                Span::styled(format!(" {} ", val), value_style),
+                let path = &var.key[..=last_dot];
-            ]);
+                let key = &var.key[last_dot + 1..];
+
+                let path_style = if is_selected {
+                    Style::default()
+                        .fg(theme.crust())
+                        .add_modifier(Modifier::DIM)
+                } else {
+                    Style::default().fg(theme.surface1())
+                };
+
+                key_spans.push(Span::styled(path, path_style));
+                key_spans.push(Span::styled(key, key_style));
+            } else {
+                key_spans.push(Span::styled(&var.key, key_style));
+            }
 
             let item_style = if is_selected {
                 Style::default().bg(theme.blue())
@@ -84,17 +104,38 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
                 Style::default().fg(theme.text())
             };
 
-            ListItem::new(line).style(item_style)
+            // Two-line layout for better readability:
+            // Line 1: Key (path.key)
+            // Line 2: Value
+            let lines = vec![
+                Line::from(key_spans),
+                Line::from(vec![
+                    Span::styled(
+                        "  └─ ",
+                        if is_selected {
+                            Style::default().fg(theme.crust())
+                        } else {
+                            Style::default().fg(theme.surface1())
+                        },
+                    ),
+                    Span::styled(val, value_style),
+                ]),
+            ];
+
+            ListItem::new(lines).style(item_style)
         })
         .collect();
 
-    let list = List::new(items)
+    let list = List::new(items).block(
-        .block(
         Block::default()
             .borders(Borders::ALL)
             .border_type(BorderType::Rounded)
             .title(" Config Variables ")
-                .title_style(Style::default().fg(theme.mauve()).add_modifier(Modifier::BOLD))
+            .title_style(
+                Style::default()
+                    .fg(theme.mauve())
+                    .add_modifier(Modifier::BOLD),
+            )
             .border_style(Style::default().fg(theme.surface1())),
     );
 
@@ -102,7 +143,7 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
     state.select(Some(app.selected));
     f.render_stateful_widget(list, chunks[1], &mut state);
 
-    // Input Area
+    // 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() {
@@ -116,7 +157,7 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
 
     let input_border_color = match app.mode {
         Mode::Insert => theme.green(),
-        Mode::Normal => theme.surface1(),
+        Mode::Normal | Mode::Search => theme.surface1(),
     };
 
     let input_text = app.input.value();
@@ -129,11 +170,16 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
                 .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.peach())
+                        .add_modifier(Modifier::BOLD),
+                )
                 .border_style(Style::default().fg(input_border_color)),
         );
     f.render_widget(input, chunks[2]);
 
+    // Position the terminal cursor correctly when in Insert mode.
     if let Mode::Insert = app.mode {
         f.set_cursor_position(ratatui::layout::Position::new(
             chunks[2].x + 1 + cursor_pos as u16,
@@ -141,7 +187,7 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
         ));
     }
 
-    // Status bar
+    // Render the modern pill-style status bar.
     let (mode_str, mode_style) = match app.mode {
         Mode::Normal => (
             " NORMAL ",
@@ -157,18 +203,30 @@ pub fn draw(f: &mut Frame, app: &mut App, config: &Config) {
                 .fg(theme.crust())
                 .add_modifier(Modifier::BOLD),
         ),
+        Mode::Search => (
+            " SEARCH ",
+            Style::default()
+                .bg(theme.mauve())
+                .fg(theme.crust())
+                .add_modifier(Modifier::BOLD),
+        ),
     };
 
-    let status_msg = app.status_message.as_deref().unwrap_or_else(|| {
+    let status_msg = app
-        match app.mode {
+        .status_message
-            Mode::Normal => " navigation | i: edit | :w: save | :q: quit ",
+        .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())),
+        Span::styled(
+            format!(" {} ", status_msg),
+            Style::default().bg(theme.surface0()).fg(theme.text()),
+        ),
     ]);
 
     let status = Paragraph::new(status_line).style(Style::default().bg(theme.surface0()));