Merge pull request 'Update Cargo.toml' (#7 ) from nvrl-patch-1 into main

Reviewed-on: #7
Update Cargo.toml
2026-03-17 09:33:13 +01:00 · 2026-03-17 09:33:05 +01:00 · 2026-03-17 09:30:26 +01:00 · 2026-03-17 09:30:33 +01:00 · 2026-03-17 09:29:12 +01:00 · 2026-03-17 09:24:58 +01:00
19 changed files with 1754 additions and 421 deletions
--- a/.gitea/workflows/release.yaml
+++ b/.gitea/workflows/release.yaml
@@ -2,6 +2,8 @@ name: Release

 on:
  push:
+    branches:
+      - main
    tags:
      - 'v*'

@@ -17,27 +19,52 @@ jobs:
        uses: actions-rust-lang/setup-rust-toolchain@v1
        with:
          toolchain: stable
+          cache: false
+
+      - name: Get Version
+        id: get_version
+        run: |
+          VERSION=$(grep '^version =' Cargo.toml | head -n1 | cut -d '"' -f 2)
+          echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+          if [[ "${{ github.ref }}" == refs/tags/v* ]]; then
+            echo "TAG=${{ github.ref_name }}" >> $GITHUB_OUTPUT
+          else
+            echo "TAG=v$VERSION" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Check if Release Exists
+        id: check_release
+        shell: bash
+        run: |
+          HTTP_STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            "${{ github.server_url }}/api/v1/repos/${{ github.repository }}/releases/tags/${{ steps.get_version.outputs.TAG }}")
+          
+          if [ "$HTTP_STATUS" = "200" ]; then
+            echo "EXISTS=true" >> $GITHUB_OUTPUT
+            echo "Release already exists for tag ${{ steps.get_version.outputs.TAG }}. Skipping creation."
+          else
+            echo "EXISTS=false" >> $GITHUB_OUTPUT
+          fi

      - name: Build
-        run: cargo build --release
+        if: steps.check_release.outputs.EXISTS == 'false'
+        run: |
+          cargo build --release
+          mv target/release/mould target/release/mould-${{ steps.get_version.outputs.TAG }}-linux-amd64

-      - name: Create Release
-        id: create_release
-        uses: https://github.com/actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Create Release and Upload Asset
+        if: steps.check_release.outputs.EXISTS == 'false'
+        uses: https://github.com/softprops/action-gh-release@v1
        with:
-          tag_name: ${{ github.ref_name }}
-          release_name: Release ${{ github.ref_name }}
+          tag_name: ${{ steps.get_version.outputs.TAG }}
+          name: Release ${{ steps.get_version.outputs.TAG }}
+          body: |
+            Automated release for version ${{ steps.get_version.outputs.VERSION }}
+            Commit: ${{ github.sha }}
+            Branch: ${{ github.ref_name }}
+          files: target/release/mould-${{ steps.get_version.outputs.TAG }}-linux-amd64
          draft: false
          prerelease: false
-
-      - name: Upload Release Asset
-        uses: https://github.com/actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./target/release/cenv
-          asset_name: cenv-${{ github.ref_name }}-linux-amd64
-          asset_content_type: application/octet-stream
--- a/.gitea/workflows/version-check.yaml
+++ b/.gitea/workflows/version-check.yaml
@@ -0,0 +1,35 @@
+name: Version Check
+
+on:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'Cargo.toml'
+
+jobs:
+  check-version:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Compare versions
+        shell: bash
+        run: |
+          NEW_VERSION=$(grep -m 1 '^version =' Cargo.toml | cut -d '"' -f 2)
+          
+          git fetch origin ${{ github.base_ref }}
+          OLD_VERSION=$(git show origin/${{ github.base_ref }}:Cargo.toml | grep -m 1 '^version =' | cut -d '"' -f 2)
+
+          echo "Old version (main): $OLD_VERSION"
+          echo "New version (PR): $NEW_VERSION"
+
+          if [ "$NEW_VERSION" = "$OLD_VERSION" ]; then
+            echo "Error: Cargo.toml version has not been updated in this PR!"
+            exit 1
+          else
+            echo "Success: Version updated from $OLD_VERSION to $NEW_VERSION"
+          fi
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -17,6 +17,80 @@ 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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse 1.0.0",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys",
+]
+
 [[package]]
 name = "anyhow"
 version = "1.0.102"
@@ -101,18 +175,6 @@ dependencies = [
 "rustversion",
 ]

-[[package]]
-name = "cenv-rs"
-version = "0.1.0"
-dependencies = [
- "crossterm",
- "dirs",
- "ratatui",
- "serde",
- "tempfile",
- "toml",
-]
-
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -125,6 +187,52 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"

+[[package]]
+name = "clap"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b193af5b67834b676abd72466a96c1024e6a6ad978a1f484bd90b85c94041351"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
+dependencies = [
+ "anstream 1.0.0",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1110bd8a634a1ab8cb04345d8d878267d57c3cf1b38d91b71af6686408bbca6a"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
 [[package]]
 name = "compact_str"
 version = "0.9.0"
@@ -321,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"
@@ -527,6 +658,12 @@ dependencies = [
 "syn 2.0.117",
 ]

+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
 [[package]]
 name = "itertools"
 version = "0.14.0"
@@ -542,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"
@@ -690,6 +851,26 @@ dependencies = [
 "windows-sys",
 ]

+[[package]]
+name = "mould"
+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",
+]
+
 [[package]]
 name = "nix"
 version = "0.29.0"
@@ -754,6 +935,12 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"

+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
 [[package]]
 name = "option-ext"
 version = "0.2.0"
@@ -893,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"
@@ -1186,6 +1382,19 @@ dependencies = [
 "serde_core",
 ]

+[[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
 [[package]]
 name = "sha2"
 version = "0.10.9"
@@ -1471,6 +1680,16 @@ version = "1.0.6+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"

+[[package]]
+name = "tui-input"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79c1ee964298f136020f5f69e0e601f4d3a1f610a7baf1af9fcb96152e8a2c45"
+dependencies = [
+ "ratatui",
+ "unicode-width",
+]
+
 [[package]]
 name = "typenum"
 version = "1.19.0"
@@ -1518,6 +1737,12 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"

+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,19 +1,27 @@
 [package]
-name = "cenv-rs"
-version = "0.1.0"
+name = "mould"
+version = "0.3.0"
 edition = "2024"
 authors = ["Nils Pukropp <nils@narl.io>"]

 [[bin]]
-name = "cenv"
+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"

 [dev-dependencies]
 tempfile = "3.27.0"
--- a/Cargo.toml.out
+++ b/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"
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2026 The cenv-rs 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
--- a/README.md
+++ b/README.md
@@ -1,13 +1,18 @@
-# cenv-rs
+# mould

-cenv-rs is a Rust-based Terminal User Interface (TUI) tool designed to help developers interactively generate `.env` files from `.env.example` templates. With a focus on speed and usability, it features Vim-like keybindings and out-of-the-box support for theming, defaulting to the Catppuccin Mocha palette.
+mould is a modern Terminal User Interface (TUI) tool designed for interactively generating and editing configuration files from templates. Whether you are setting up a `.env` file from an example, creating a `docker-compose.override.yml`, or editing nested `JSON`, `YAML`, or `TOML` configurations, mould provides a fast, Vim-inspired workflow to get your environment ready.

 ## Features

- Parse `.env.example` files to extract keys, default values, and comments.
- Vim-like keybindings for quick navigation and editing.
- Built-in theming support with Catppuccin Mocha as the default.
- Configurable through a standard TOML file.
+- **Universal Format Support**: Handle `.env`, `JSON`, `YAML`, and `TOML` seamlessly.
+- **Hierarchical Flattening**: Edit nested data structures (JSON, YAML, TOML) in a flat, searchable list.
+- **Docker Compose Integration**: Automatically generate `docker-compose.override.yml` from `docker-compose.yml`.
+- **Vim-inspired Workflow**: Navigate with `j`/`k`, edit with `i`, and save with `:w`.
+- **Modern UI**: A polished, rounded interface featuring the Catppuccin Mocha palette.
+- **Highly Configurable**: Customize keybindings and themes via a simple TOML configuration.
+- **Dynamic Alignment**: Automatically aligns keys and values for perfect vertical readability.
+- **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

@@ -21,42 +26,70 @@ Alternatively, you can build from source:

 ```sh
 git clone <repository_url>
-cd cenv-rs
+cd mould
 cargo build --release
 ```

+The binary will be installed as `mould`.
+
 ## Usage

-Navigate to a directory containing a `.env.example` file and run:
+Provide an input template file to start editing:

 ```sh
-cenv-rs
+mould .env.example
+mould docker-compose.yml
+mould config.template.json -o config.json
 ```

-### Keybindings
+### Keybindings (Default)

 - **Normal Mode**
  - `j` / `Down`: Move selection down
  - `k` / `Up`: Move selection up
  - `i`: Edit the value of the currently selected key (Enter Insert Mode)
-  - `:w` or `Enter`: Save the current configuration to `.env`
-  - `q` or `:q`: Quit the application without saving
-  - `Esc`: Clear current prompt or return from actions
+  - `/`: 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
+  - `Esc`: Clear current command prompt

 - **Insert Mode**
  - Type your value for the selected key.
-  - `Esc`: Return to Normal Mode
+  - Arrow keys: Navigate within the input field
+  - `Enter` / `Esc`: Commit the value and return to Normal Mode

 ## Configuration

-cenv-rs can be configured using a `config.toml` file located in your user configuration directory (e.g., `~/.config/cenv-rs/config.toml` on Linux/macOS).
+mould can be configured using a `config.toml` file located in your user configuration directory (e.g., `~/.config/mould/config.toml` on Linux/macOS).

 Example configuration:

 ```toml
+[keybinds]
+down = "j"
+up = "k"
+edit = "i"
+save = ":w"
+quit = ":q"
+normal_mode = "Esc"
+
 [theme]
-# Default theme is "catppuccin_mocha"
-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
--- a/config.example.toml
+++ b/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"
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,35 +1,72 @@
-use crate::env::EnvVar;
+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 {
            vars,
            selected: 0,
            mode: Mode::Normal,
            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();
+            self.sync_input_with_selected();
        }
    }

+    /// 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 {
@@ -37,19 +74,70 @@ impl App {
            } else {
                self.selected -= 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());
+        }
+    }
+
+    /// 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;
-    }
 }
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -0,0 +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)",
+    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)
+    #[arg(required = false, value_name = "INPUT_FILE")]
+    pub input: Option<PathBuf>,
+
+    /// Optional output file. If not provided, it will be inferred.
+    #[arg(short, long, value_name = "OUTPUT_FILE")]
+    pub output: Option<PathBuf>,
+
+    /// Override the format detection (env, json, yaml, toml)
+    #[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()
+}
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,28 +1,139 @@
+use ratatui::style::Color;
 use serde::{Deserialize, Serialize};
 use std::fs;

+/// Configuration for the application's appearance.
 #[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(default)]
 pub struct ThemeConfig {
-    pub name: String,
+    /// 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 {
+            let r = u8::from_str_radix(&hex[0..2], 16).unwrap_or(0);
+            let g = u8::from_str_radix(&hex[2..4], 16).unwrap_or(0);
+            let b = u8::from_str_radix(&hex[4..6], 16).unwrap_or(0);
+            Color::Rgb(r, g, b)
+        } else {
+            Color::Reset
+        }
+    }
+
+    pub fn crust(&self) -> Color {
+        Self::parse_hex(&self.crust)
+    }
+    pub fn surface0(&self) -> Color {
+        Self::parse_hex(&self.surface0)
+    }
+    pub fn surface1(&self) -> Color {
+        Self::parse_hex(&self.surface1)
+    }
+    pub fn text(&self) -> Color {
+        Self::parse_hex(&self.text)
+    }
+    pub fn blue(&self) -> Color {
+        Self::parse_hex(&self.blue)
+    }
+    pub fn green(&self) -> Color {
+        Self::parse_hex(&self.green)
+    }
+    pub fn lavender(&self) -> Color {
+        Self::parse_hex(&self.lavender)
+    }
+    pub fn mauve(&self) -> Color {
+        Self::parse_hex(&self.mauve)
+    }
+    pub fn peach(&self) -> Color {
+        Self::parse_hex(&self.peach)
+    }
 }

 impl Default for ThemeConfig {
+    /// Default theme: Catppuccin Mocha.
    fn default() -> Self {
        Self {
-            name: "catppuccin_mocha".to_string(),
+            transparent: false,
+            crust: "#11111b".to_string(),
+            surface0: "#313244".to_string(),
+            surface1: "#45475a".to_string(),
+            text: "#cdd6f4".to_string(),
+            blue: "#89b4fa".to_string(),
+            green: "#a6e3a1".to_string(),
+            lavender: "#b4befe".to_string(),
+            mauve: "#cba6f7".to_string(),
+            peach: "#fab387".to_string(),
        }
    }
 }

+/// Custom keybindings for navigation and application control.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(default)]
+pub struct KeybindsConfig {
+    pub down: String,
+    pub up: String,
+    pub edit: String,
+    pub save: String,
+    pub quit: String,
+    pub normal_mode: String,
+    pub search: String,
+    pub next_match: String,
+    pub previous_match: String,
+}
+
+impl Default for KeybindsConfig {
+    fn default() -> Self {
+        Self {
+            down: "j".to_string(),
+            up: "k".to_string(),
+            edit: "i".to_string(),
+            save: ":w".to_string(),
+            quit: ":q".to_string(),
+            normal_mode: "Esc".to_string(),
+            search: "/".to_string(),
+            next_match: "n".to_string(),
+            previous_match: "N".to_string(),
+        }
+    }
+}
+
+/// Root configuration structure for mould.
 #[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct Config {
    #[serde(default)]
    pub theme: ThemeConfig,
+    #[serde(default)]
+    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("cenv-rs");
+        config_dir.push("mould");
        config_dir.push("config.toml");

        if config_dir.exists() {
--- a/src/env.rs
+++ b/src/env.rs
@@ -1,141 +0,0 @@
-use std::fs;
-use std::io::{self, Write};
-use std::path::Path;
-
-#[derive(Debug, Clone)]
-pub struct EnvVar {
-    pub key: String,
-    pub value: String,
-    pub default_value: String,
-}
-
-pub fn parse_env_example<P: AsRef<Path>>(path: P) -> io::Result<Vec<EnvVar>> {
-    let content = fs::read_to_string(path)?;
-    let mut vars = Vec::new();
-
-    for line in content.lines() {
-        let line = line.trim();
-        if line.is_empty() || line.starts_with('#') {
-            continue; // Skip comments and empty lines
-        }
-
-        if let Some((key, val)) = line.split_once('=') {
-            let parsed_val = val.trim().trim_matches('"').trim_matches('\'').to_string();
-            vars.push(EnvVar {
-                key: key.trim().to_string(),
-                value: parsed_val.clone(),
-                default_value: parsed_val,
-            });
-        }
-    }
-
-    Ok(vars)
-}
-
-pub fn merge_env<P: AsRef<Path>>(path: P, vars: &mut Vec<EnvVar>) -> io::Result<()> {
-    if !path.as_ref().exists() {
-        return Ok(());
-    }
-
-    let content = fs::read_to_string(path)?;
-    for line in content.lines() {
-        let line = line.trim();
-        if line.is_empty() || line.starts_with('#') {
-            continue;
-        }
-
-        if let Some((key, val)) = line.split_once('=') {
-            let key = key.trim();
-            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;
-            } else {
-                vars.push(EnvVar {
-                    key: key.to_string(),
-                    value: parsed_val.clone(),
-                    default_value: String::new(),
-                });
-            }
-        }
-    }
-
-    Ok(())
-}
-
-pub fn write_env<P: AsRef<Path>>(path: P, vars: &[EnvVar]) -> io::Result<()> {
-    let mut file = fs::File::create(path)?;
-    for var in vars {
-        writeln!(file, "{}={}", var.key, var.value)?;
-    }
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::io::Write;
-    use tempfile::NamedTempFile;
-
-    #[test]
-    fn test_parse_env_example() {
-        let mut file = NamedTempFile::new().unwrap();
-        writeln!(
-            file,
-            "# A comment\nKEY1=value1\nKEY2=\"value2\"\nKEY3='value3'\nEMPTY="
-        )
-        .unwrap();
-
-        let vars = parse_env_example(file.path()).unwrap();
-        assert_eq!(vars.len(), 4);
-        assert_eq!(vars[0].key, "KEY1");
-        assert_eq!(vars[0].value, "value1");
-        assert_eq!(vars[0].default_value, "value1");
-        assert_eq!(vars[1].key, "KEY2");
-        assert_eq!(vars[1].value, "value2");
-        assert_eq!(vars[2].key, "KEY3");
-        assert_eq!(vars[2].value, "value3");
-        assert_eq!(vars[3].key, "EMPTY");
-        assert_eq!(vars[3].value, "");
-    }
-
-    #[test]
-    fn test_merge_env() {
-        let mut example_file = NamedTempFile::new().unwrap();
-        writeln!(example_file, "KEY1=default1\nKEY2=default2").unwrap();
-        let mut vars = parse_env_example(example_file.path()).unwrap();
-
-        let mut env_file = NamedTempFile::new().unwrap();
-        writeln!(env_file, "KEY1=custom1\nKEY3=custom3").unwrap();
-
-        merge_env(env_file.path(), &mut vars).unwrap();
-
-        assert_eq!(vars.len(), 3);
-        assert_eq!(vars[0].key, "KEY1");
-        assert_eq!(vars[0].value, "custom1");
-        assert_eq!(vars[0].default_value, "default1");
-
-        assert_eq!(vars[1].key, "KEY2");
-        assert_eq!(vars[1].value, "default2");
-        assert_eq!(vars[1].default_value, "default2");
-
-        assert_eq!(vars[2].key, "KEY3");
-        assert_eq!(vars[2].value, "custom3");
-        assert_eq!(vars[2].default_value, "");
-    }
-
-    #[test]
-    fn test_write_env() {
-        let file = NamedTempFile::new().unwrap();
-        let vars = vec![EnvVar {
-            key: "KEY1".to_string(),
-            value: "value1".to_string(),
-            default_value: "def".to_string(),
-        }];
-
-        write_env(file.path(), &vars).unwrap();
-
-        let content = fs::read_to_string(file.path()).unwrap();
-        assert_eq!(content.trim(), "KEY1=value1");
-    }
-}
--- a/src/error.rs
+++ b/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),
+}
--- a/src/format/env.rs
+++ b/src/format/env.rs
@@ -0,0 +1,142 @@
+use super::{EnvVar, FormatHandler};
+use std::fs;
+use std::io::{self, Write};
+use std::path::Path;
+
+pub struct EnvHandler;
+
+impl FormatHandler for EnvHandler {
+    fn parse(&self, path: &Path) -> io::Result<Vec<EnvVar>> {
+        let content = fs::read_to_string(path)?;
+        let mut vars = Vec::new();
+
+        for line in content.lines() {
+            let line = line.trim();
+            if line.is_empty() || line.starts_with('#') {
+                continue; // Skip comments and empty lines
+            }
+
+            if let Some((key, val)) = line.split_once('=') {
+                let parsed_val = val.trim().trim_matches('"').trim_matches('\'').to_string();
+                vars.push(EnvVar {
+                    key: key.trim().to_string(),
+                    value: parsed_val.clone(),
+                    default_value: parsed_val,
+                });
+            }
+        }
+
+        Ok(vars)
+    }
+
+    fn merge(&self, path: &Path, vars: &mut Vec<EnvVar>) -> io::Result<()> {
+        if !path.exists() {
+            return Ok(());
+        }
+
+        let content = fs::read_to_string(path)?;
+        for line in content.lines() {
+            let line = line.trim();
+            if line.is_empty() || line.starts_with('#') {
+                continue;
+            }
+
+            if let Some((key, val)) = line.split_once('=') {
+                let key = key.trim();
+                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;
+                } else {
+                    vars.push(EnvVar {
+                        key: key.to_string(),
+                        value: parsed_val.clone(),
+                        default_value: String::new(),
+                    });
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn write(&self, path: &Path, vars: &[EnvVar]) -> io::Result<()> {
+        let mut file = fs::File::create(path)?;
+        for var in vars {
+            writeln!(file, "{}={}", var.key, var.value)?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    #[test]
+    fn test_parse_env_example() {
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(
+            file,
+            "# A comment\nKEY1=value1\nKEY2=\"value2\"\nKEY3='value3'\nEMPTY="
+        )
+        .unwrap();
+
+        let handler = EnvHandler;
+        let vars = handler.parse(file.path()).unwrap();
+        assert_eq!(vars.len(), 4);
+        assert_eq!(vars[0].key, "KEY1");
+        assert_eq!(vars[0].value, "value1");
+        assert_eq!(vars[0].default_value, "value1");
+        assert_eq!(vars[1].key, "KEY2");
+        assert_eq!(vars[1].value, "value2");
+        assert_eq!(vars[2].key, "KEY3");
+        assert_eq!(vars[2].value, "value3");
+        assert_eq!(vars[3].key, "EMPTY");
+        assert_eq!(vars[3].value, "");
+    }
+
+    #[test]
+    fn test_merge_env() {
+        let mut example_file = NamedTempFile::new().unwrap();
+        writeln!(example_file, "KEY1=default1\nKEY2=default2").unwrap();
+        let handler = EnvHandler;
+        let mut vars = handler.parse(example_file.path()).unwrap();
+
+        let mut env_file = NamedTempFile::new().unwrap();
+        writeln!(env_file, "KEY1=custom1\nKEY3=custom3").unwrap();
+
+        handler.merge(env_file.path(), &mut vars).unwrap();
+
+        assert_eq!(vars.len(), 3);
+        assert_eq!(vars[0].key, "KEY1");
+        assert_eq!(vars[0].value, "custom1");
+        assert_eq!(vars[0].default_value, "default1");
+
+        assert_eq!(vars[1].key, "KEY2");
+        assert_eq!(vars[1].value, "default2");
+        assert_eq!(vars[1].default_value, "default2");
+
+        assert_eq!(vars[2].key, "KEY3");
+        assert_eq!(vars[2].value, "custom3");
+        assert_eq!(vars[2].default_value, "");
+    }
+
+    #[test]
+    fn test_write_env() {
+        let file = NamedTempFile::new().unwrap();
+        let vars = vec![EnvVar {
+            key: "KEY1".to_string(),
+            value: "value1".to_string(),
+            default_value: "def".to_string(),
+        }];
+
+        let handler = EnvHandler;
+        handler.write(file.path(), &vars).unwrap();
+
+        let content = fs::read_to_string(file.path()).unwrap();
+        assert_eq!(content.trim(), "KEY1=value1");
+    }
+}
--- a/src/format/hierarchical.rs
+++ b/src/format/hierarchical.rs
@@ -0,0 +1,253 @@
+use super::{EnvVar, FormatHandler, FormatType};
+use serde_json::{Map, Value};
+use std::fs;
+use std::io;
+use std::path::Path;
+
+pub struct HierarchicalHandler {
+    format_type: FormatType,
+}
+
+impl HierarchicalHandler {
+    pub fn new(format_type: FormatType) -> Self {
+        Self { format_type }
+    }
+
+    fn read_value(&self, path: &Path) -> io::Result<Value> {
+        let content = fs::read_to_string(path)?;
+        let value = match self.format_type {
+            FormatType::Json => serde_json::from_str(&content)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            FormatType::Yaml => serde_yaml::from_str(&content)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            FormatType::Toml => toml::from_str(&content)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            _ => unreachable!(),
+        };
+        Ok(value)
+    }
+
+    fn write_value(&self, path: &Path, value: &Value) -> io::Result<()> {
+        let content = match self.format_type {
+            FormatType::Json => serde_json::to_string_pretty(value)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            FormatType::Yaml => serde_yaml::to_string(value)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            FormatType::Toml => {
+                // toml requires the root to be a table
+                if value.is_object() {
+                    let toml_value: toml::Value = serde_json::from_value(value.clone())
+                        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+                    toml::to_string_pretty(&toml_value)
+                        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?
+                } else {
+                    return Err(io::Error::new(
+                        io::ErrorKind::InvalidData,
+                        "Root of TOML must be an object",
+                    ));
+                }
+            }
+            _ => unreachable!(),
+        };
+        fs::write(path, content)
+    }
+}
+
+fn flatten(value: &Value, prefix: &str, vars: &mut Vec<EnvVar>) {
+    match value {
+        Value::Object(map) => {
+            for (k, v) in map {
+                let new_prefix = if prefix.is_empty() {
+                    k.clone()
+                } else {
+                    format!("{}.{}", prefix, k)
+                };
+                flatten(v, &new_prefix, vars);
+            }
+        }
+        Value::Array(arr) => {
+            for (i, v) in arr.iter().enumerate() {
+                let new_prefix = format!("{}[{}]", prefix, i);
+                flatten(v, &new_prefix, vars);
+            }
+        }
+        Value::String(s) => {
+            vars.push(EnvVar {
+                key: prefix.to_string(),
+                value: s.clone(),
+                default_value: s.clone(),
+            });
+        }
+        Value::Number(n) => {
+            let s = n.to_string();
+            vars.push(EnvVar {
+                key: prefix.to_string(),
+                value: s.clone(),
+                default_value: s.clone(),
+            });
+        }
+        Value::Bool(b) => {
+            let s = b.to_string();
+            vars.push(EnvVar {
+                key: prefix.to_string(),
+                value: s.clone(),
+                default_value: s.clone(),
+            });
+        }
+        Value::Null => {
+            vars.push(EnvVar {
+                key: prefix.to_string(),
+                value: "".to_string(),
+                default_value: "".to_string(),
+            });
+        }
+    }
+}
+
+// Removed unused update_leaf and update_leaf_value functions
+
+impl FormatHandler for HierarchicalHandler {
+    fn parse(&self, path: &Path) -> io::Result<Vec<EnvVar>> {
+        let value = self.read_value(path)?;
+        let mut vars = Vec::new();
+        flatten(&value, "", &mut vars);
+        Ok(vars)
+    }
+
+    fn merge(&self, path: &Path, vars: &mut Vec<EnvVar>) -> 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);
+
+        for var in vars.iter_mut() {
+            if let Some(existing) = existing_vars.iter().find(|v| v.key == var.key) {
+                var.value = existing.value.clone();
+            }
+        }
+        Ok(())
+    }
+
+    fn write(&self, path: &Path, vars: &[EnvVar]) -> io::Result<()> {
+        let mut root = Value::Object(Map::new());
+        for var in vars {
+            insert_into_value(&mut root, &var.key, &var.value);
+        }
+        self.write_value(path, &root)
+    }
+}
+
+fn insert_into_value(root: &mut Value, path: &str, new_val_str: &str) {
+    let mut parts = path.split('.');
+    let last_part = match parts.next_back() {
+        Some(p) => p,
+        None => return,
+    };
+
+    let mut current = root;
+    for part in parts {
+        let (key, idx) = parse_array_key(part);
+        if !current.is_object() {
+            *current = Value::Object(Map::new());
+        }
+        let map = current.as_object_mut().unwrap();
+
+        let next_node = map.entry(key.to_string()).or_insert_with(|| {
+            if idx.is_some() {
+                Value::Array(Vec::new())
+            } else {
+                Value::Object(Map::new())
+            }
+        });
+
+        if let Some(i) = idx {
+            if !next_node.is_array() {
+                *next_node = Value::Array(Vec::new());
+            }
+            let arr = next_node.as_array_mut().unwrap();
+            while arr.len() <= i {
+                arr.push(Value::Object(Map::new()));
+            }
+            current = &mut arr[i];
+        } else {
+            current = next_node;
+        }
+    }
+
+    let (final_key, final_idx) = parse_array_key(last_part);
+    if !current.is_object() {
+        *current = Value::Object(Map::new());
+    }
+    let map = current.as_object_mut().unwrap();
+
+    // Attempt basic type inference
+    let final_val = if let Ok(n) = new_val_str.parse::<i64>() {
+        Value::Number(n.into())
+    } else if let Ok(b) = new_val_str.parse::<bool>() {
+        Value::Bool(b)
+    } else {
+        Value::String(new_val_str.to_string())
+    };
+
+    if let Some(i) = final_idx {
+        let next_node = map
+            .entry(final_key.to_string())
+            .or_insert_with(|| Value::Array(Vec::new()));
+        if !next_node.is_array() {
+            *next_node = Value::Array(Vec::new());
+        }
+        let arr = next_node.as_array_mut().unwrap();
+        while arr.len() <= i {
+            arr.push(Value::Null);
+        }
+        arr[i] = final_val;
+    } else {
+        map.insert(final_key.to_string(), final_val);
+    }
+}
+
+fn parse_array_key(part: &str) -> (&str, Option<usize>) {
+    if part.ends_with(']') && part.contains('[') {
+        let start_idx = part.find('[').unwrap();
+        let key = &part[..start_idx];
+        let idx = part[start_idx + 1..part.len() - 1].parse::<usize>().ok();
+        (key, idx)
+    } else {
+        (part, None)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_flatten_unflatten() {
+        let mut vars = Vec::new();
+        let json = serde_json::json!({
+            "services": {
+                "web": {
+                    "ports": ["8080:80"],
+                    "environment": {
+                        "DEBUG": true
+                    }
+                }
+            }
+        });
+
+        flatten(&json, "", &mut vars);
+        assert_eq!(vars.len(), 2);
+
+        let mut root = Value::Object(Map::new());
+        for var in vars {
+            insert_into_value(&mut root, &var.key, &var.value);
+        }
+
+        // When unflattening, it parses bool back
+        let unflattened_json = serde_json::to_string(&root).unwrap();
+        assert!(unflattened_json.contains("\"8080:80\""));
+        assert!(unflattened_json.contains("true"));
+    }
+}
--- a/src/format/mod.rs
+++ b/src/format/mod.rs
@@ -0,0 +1,58 @@
+use std::io;
+use std::path::Path;
+
+pub mod env;
+pub mod hierarchical;
+
+#[derive(Debug, Clone)]
+pub struct EnvVar {
+    pub key: String,
+    pub value: String,
+    pub default_value: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum FormatType {
+    Env,
+    Json,
+    Yaml,
+    Toml,
+}
+
+pub trait FormatHandler {
+    fn parse(&self, path: &Path) -> io::Result<Vec<EnvVar>>;
+    fn merge(&self, path: &Path, vars: &mut Vec<EnvVar>) -> io::Result<()>;
+    fn write(&self, path: &Path, vars: &[EnvVar]) -> io::Result<()>;
+}
+
+pub fn detect_format(path: &Path, override_format: Option<String>) -> FormatType {
+    if let Some(fmt) = override_format {
+        match fmt.to_lowercase().as_str() {
+            "env" => return FormatType::Env,
+            "json" => return FormatType::Json,
+            "yaml" | "yml" => return FormatType::Yaml,
+            "toml" => return FormatType::Toml,
+            _ => {}
+        }
+    }
+
+    let file_name = path.file_name().unwrap_or_default().to_string_lossy();
+    if file_name.ends_with(".json") {
+        FormatType::Json
+    } else if file_name.ends_with(".yaml") || file_name.ends_with(".yml") {
+        FormatType::Yaml
+    } else if file_name.ends_with(".toml") {
+        FormatType::Toml
+    } else {
+        FormatType::Env
+    }
+}
+
+pub fn get_handler(format: FormatType) -> Box<dyn FormatHandler> {
+    match format {
+        FormatType::Env => Box::new(env::EnvHandler),
+        FormatType::Json => Box::new(hierarchical::HierarchicalHandler::new(FormatType::Json)),
+        FormatType::Yaml => Box::new(hierarchical::HierarchicalHandler::new(FormatType::Yaml)),
+        FormatType::Toml => Box::new(hierarchical::HierarchicalHandler::new(FormatType::Toml)),
+    }
+}
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,171 +1,235 @@
 mod app;
+mod cli;
 mod config;
-mod env;
+mod error;
+mod format;
+mod runner;
 mod ui;

-use app::{App, Mode};
+use app::App;
 use config::load_config;
-use env::{merge_env, parse_env_example, write_env};
-use std::error::Error;
+use error::MouldError;
+use format::{detect_format, get_handler};
+use log::{error, info, warn};
+use runner::AppRunner;
 use std::io;
+use std::path::{Path, PathBuf};

 use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
+    event::{DisableMouseCapture, EnableMouseCapture},
    execute,
    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
 };
-use ratatui::{
-    Terminal,
-    backend::{Backend, CrosstermBackend},
-};
+use ratatui::{Terminal, backend::CrosstermBackend};

-fn main() -> Result<(), Box<dyn Error>> {
-    let example_path = ".env.example";
-    let env_path = ".env";
+/// 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();

-    // Load vars
-    let mut vars = parse_env_example(example_path).unwrap_or_else(|_| vec![]);
-    if vars.is_empty() {
-        println!("No variables found in .env.example or file does not exist.");
-        println!("Please run this tool in a directory with a valid .env.example file.");
-        return Ok(());
+    // Standard mappings
+    if file_name == ".env.example" || file_name == ".env.template" {
+        return input.with_file_name(".env");
    }

-    // Merge existing .env if present
-    let _ = merge_env(env_path, &mut vars);
+    if file_name == "docker-compose.yml" || file_name == "compose.yml" {
+        return input.with_file_name("compose.override.yml");
+    }
+    if file_name == "docker-compose.yaml" || file_name == "compose.yaml" {
+        return input.with_file_name("compose.override.yaml");
+    }
+
+    // Pattern-based mappings
+    if let Some(base) = file_name.strip_suffix(".env.example") {
+        return input.with_file_name(format!("{}.env", base));
+    }
+    if let Some(base) = file_name.strip_suffix(".env.template") {
+        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()
+    ))
+}
+
+/// 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();
+
+    // Initialize logger with verbosity from CLI
+    let log_level = match args.verbose {
+        0 => log::LevelFilter::Warn,
+        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);
+
+    let output_path = args
+        .output
+        .unwrap_or_else(|| determine_output_path(&input_path));
+
+    info!("Output: {}", output_path.display());
+
+    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() {
+        warn!("No variables found in {}", input_path.display());
+    }
+
+    if let Err(e) = handler.merge(&output_path, &mut vars) {
+        warn!("Could not merge existing output file: {}", e);
+    }

    let config = load_config();
    let mut app = App::new(vars);

-    // Setup terminal
-    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)))?;

-    // Run app
-    let res = run_app(&mut terminal, &mut app, &config, env_path);
+    let mut runner = AppRunner::new(
+        &mut terminal,
+        &mut app,
+        &config,
+        &output_path,
+        handler.as_ref(),
+    );
+    let res = runner.run();

-    // Restore terminal
-    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);
-    }
-
-    Ok(())
-}
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    app: &mut App,
-    config: &config::Config,
-    env_path: &str,
-) -> io::Result<()>
-where
-    io::Error: From<B::Error>,
-{
-    // For handling commands like :w, :q
-    let mut command_buffer = String::new();
-
-    loop {
-        terminal.draw(|f| ui::draw(f, app, config))?;
-
-        if let Event::Key(key) = event::read()? {
-            match app.mode {
-                Mode::Normal => {
-                    if !command_buffer.is_empty() {
-                        if key.code == KeyCode::Enter {
-                            match command_buffer.as_str() {
-                                ":w" => {
-                                    if write_env(env_path, &app.vars).is_ok() {
-                                        app.status_message = Some("Saved to .env".to_string());
-                                    } else {
-                                        app.status_message =
-                                            Some("Error saving to .env".to_string());
-                                    }
-                                }
-                                ":q" => return Ok(()),
-                                ":wq" => {
-                                    write_env(env_path, &app.vars)?;
-                                    return Ok(());
-                                }
-                                _ => {
-                                    app.status_message = Some("Unknown command".to_string());
-                                }
-                            }
-                            command_buffer.clear();
-                        } else if key.code == KeyCode::Esc {
-                            command_buffer.clear();
-                            app.status_message = None;
-                        } else if key.code == KeyCode::Backspace {
-                            command_buffer.pop();
-                            if command_buffer.is_empty() {
-                                app.status_message = None;
-                            } else {
-                                app.status_message = Some(command_buffer.clone());
-                            }
-                        } else if let KeyCode::Char(c) = key.code {
-                            command_buffer.push(c);
-                            app.status_message = Some(command_buffer.clone());
-                        }
-                    } else {
-                        match key.code {
-                            KeyCode::Char('q') => return Ok(()),
-                            KeyCode::Char('j') | KeyCode::Down => app.next(),
-                            KeyCode::Char('k') | KeyCode::Up => app.previous(),
-                            KeyCode::Char('i') => {
-                                app.enter_insert();
-                                app.status_message = None;
-                            }
-                            KeyCode::Char(':') => {
-                                command_buffer.push(':');
-                                app.status_message = Some(command_buffer.clone());
-                            }
-                            KeyCode::Enter => {
-                                // Default action for Enter in Normal mode is save
-                                if write_env(env_path, &app.vars).is_ok() {
-                                    app.status_message = Some("Saved to .env".to_string());
-                                } else {
-                                    app.status_message = Some("Error saving to .env".to_string());
-                                }
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-                Mode::Insert => match key.code {
-                    KeyCode::Esc => {
-                        app.enter_normal();
-                    }
-                    KeyCode::Char(c) => {
-                        if let Some(var) = app.vars.get_mut(app.selected) {
-                            var.value.push(c);
-                        }
-                    }
-                    KeyCode::Backspace => {
-                        if let Some(var) = app.vars.get_mut(app.selected) {
-                            var.value.pop();
-                        }
-                    }
-                    KeyCode::Enter => {
-                        app.enter_normal();
-                    }
-                    _ => {}
-                },
-            }
+    match res {
+        Ok(_) => {
+            info!("Successfully finished mould session.");
+            Ok(())
        }
-
-        if !app.running {
-            break;
+        Err(e) => {
+            error!("Application error during run: {}", e);
+            Err(e.into())
        }
    }
-    Ok(())
 }
--- a/src/runner.rs
+++ b/src/runner.rs
@@ -0,0 +1,212 @@
+use crate::app::{App, Mode};
+use crate::config::Config;
+use crate::format::FormatHandler;
+use crossterm::event::{self, Event, KeyCode, KeyEvent};
+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,
+}
+
+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,
+        config: &'a Config,
+        output_path: &'a Path,
+        handler: &'a dyn FormatHandler,
+    ) -> Self {
+        Self {
+            terminal,
+            app,
+            config,
+            output_path,
+            handler,
+            command_buffer: String::new(),
+        }
+    }
+
+    /// 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))?;
+
+            if let Event::Key(key) = event::read()? {
+                self.handle_key_event(key)?;
+            }
+        }
+        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)
+        } else {
+            self.handle_navigation_mode(key)
+        }
+    }
+
+    /// Logic for entering and executing ":" style commands.
+    fn handle_command_mode(&mut self, key: KeyEvent) -> io::Result<()> {
+        match key.code {
+            KeyCode::Enter => {
+                let cmd = self.command_buffer.clone();
+                self.command_buffer.clear();
+                self.execute_command(&cmd)
+            }
+            KeyCode::Esc => {
+                self.command_buffer.clear();
+                self.app.status_message = None;
+                Ok(())
+            }
+            KeyCode::Backspace => {
+                self.command_buffer.pop();
+                self.sync_command_status();
+                Ok(())
+            }
+            KeyCode::Char(c) => {
+                self.command_buffer.push(c);
+                self.sync_command_status();
+                Ok(())
+            }
+            _ => Ok(()),
+        }
+    }
+
+    /// Handles primary navigation (j/k) and transitions to insert or command modes.
+    fn handle_navigation_mode(&mut self, key: KeyEvent) -> io::Result<()> {
+        if let KeyCode::Char(c) = key.code {
+            let c_str = c.to_string();
+            if c_str == self.config.keybinds.down {
+                self.app.next();
+            } else if c_str == self.config.keybinds.up {
+                self.app.previous();
+            } else if c_str == self.config.keybinds.edit {
+                self.app.enter_insert();
+            } else if c_str == ":" {
+                self.command_buffer.push(':');
+                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 {
+                KeyCode::Down => self.app.next(),
+                KeyCode::Up => self.app.previous(),
+                KeyCode::Enter => self.save_file()?,
+                _ => {}
+            }
+        }
+        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 => {
+                self.app.enter_normal();
+            }
+            _ => {
+                self.app.input.handle_event(&Event::Key(key));
+            }
+        }
+        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()
+        } else if cmd == self.config.keybinds.quit {
+            self.app.running = false;
+            Ok(())
+        } else if cmd == ":wq" {
+            self.save_file()?;
+            self.app.running = false;
+            Ok(())
+        } else {
+            self.app.status_message = Some(format!("Unknown command: {}", cmd));
+            Ok(())
+        }
+    }
+
+    /// 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()));
+        } else {
+            self.app.status_message = Some("Error saving file".to_string());
+        }
+        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;
+        } else {
+            self.app.status_message = Some(self.command_buffer.clone());
+        }
+    }
+}
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -3,80 +3,147 @@ use crate::config::Config;
 use ratatui::{
    Frame,
    layout::{Constraint, Direction, Layout},
-    style::{Color, Modifier, Style},
+    style::{Modifier, Style},
    text::{Line, Span},
-    widgets::{Block, Borders, List, ListItem, ListState, Paragraph},
+    widgets::{Block, BorderType, Borders, List, ListItem, ListState, Paragraph},
 };

-// Catppuccin Mocha Palette
-const MANTLE: Color = Color::Rgb(24, 24, 37);
-const BASE: Color = Color::Rgb(30, 30, 46);
-const TEXT: Color = Color::Rgb(205, 214, 244);
-const BLUE: Color = Color::Rgb(137, 180, 250);
-const GREEN: Color = Color::Rgb(166, 227, 161);
-const SURFACE1: Color = Color::Rgb(69, 71, 90);
-
-pub fn draw(f: &mut Frame, app: &mut App, _config: &Config) {
+/// 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();

-    // Theming (defaults to Mocha, can be extended later via _config)
-    let bg_color = BASE;
-    let fg_color = TEXT;
-    let highlight_color = BLUE;
-    let insert_color = GREEN;
+    // Render the main background (optional based on transparency config).
+    if !theme.transparent {
+        f.render_widget(
+            Block::default().style(Style::default().bg(theme.crust())),
+            size,
+        );
+    }

-    // Background
-    let block = Block::default().style(Style::default().bg(bg_color).fg(fg_color));
-    f.render_widget(block, size);
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
+    // Horizontal layout with 1-character side margins.
+    let outer_layout = Layout::default()
+        .direction(Direction::Horizontal)
        .constraints([
-            Constraint::Min(3),    // List
-            Constraint::Length(3), // Input area
-            Constraint::Length(1), // Status bar
+            Constraint::Length(1),
+            Constraint::Min(0),
+            Constraint::Length(1),
        ])
        .split(size);

-    // List
+    // Vertical layout for the main UI components.
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Length(1), // Top margin
+            Constraint::Min(3),    // Main list
+            Constraint::Length(3), // Focused input field
+            Constraint::Length(1), // Spacer
+            Constraint::Length(1), // Status bar
+        ])
+        .split(outer_layout[1]);
+
+    // 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 style = if i == app.selected {
-                Style::default()
-                    .fg(bg_color)
-                    .bg(highlight_color)
-                    .add_modifier(Modifier::BOLD)
+            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 {
-                Style::default().fg(fg_color)
+                &var.value
            };

-            let content = format!(" {} = {} ", var.key, var.value);
-            ListItem::new(Line::from(content)).style(style)
+            let key_style = if is_selected {
+                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())
+            };
+
+            let value_style = if is_selected {
+                Style::default().fg(theme.crust())
+            } else {
+                Style::default().fg(theme.text())
+            };
+
+            // Path styling for nested keys (e.g., a.b.c)
+            let mut key_spans = Vec::new();
+            if let Some(last_dot) = var.key.rfind('.') {
+                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())
+            } else {
+                Style::default().fg(theme.text())
+            };
+
+            // 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)
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .title(" Environment Variables ")
-                .border_style(Style::default().fg(SURFACE1)),
-        )
-        .highlight_style(
-            Style::default()
-                .fg(bg_color)
-                .bg(highlight_color)
-                .add_modifier(Modifier::BOLD),
-        );
+    let list = List::new(items).block(
+        Block::default()
+            .borders(Borders::ALL)
+            .border_type(BorderType::Rounded)
+            .title(" Config Variables ")
+            .title_style(
+                Style::default()
+                    .fg(theme.mauve())
+                    .add_modifier(Modifier::BOLD),
+            )
+            .border_style(Style::default().fg(theme.surface1())),
+    );

    let mut state = ListState::default();
    state.select(Some(app.selected));
-    f.render_stateful_widget(list, chunks[0], &mut state);
+    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() {
@@ -88,63 +155,80 @@ pub fn draw(f: &mut Frame, app: &mut App, _config: &Config) {
        " Input ".to_string()
    };

-    let input_color = match app.mode {
-        Mode::Insert => insert_color,
-        Mode::Normal => SURFACE1,
+    let input_border_color = match app.mode {
+        Mode::Insert => theme.green(),
+        Mode::Normal | Mode::Search => theme.surface1(),
    };

-    let input_text = if let Some(var) = current_var {
-        var.value.as_str()
-    } else {
-        ""
-    };
+    let input_text = app.input.value();
+    let cursor_pos = app.input.visual_cursor();

    let input = Paragraph::new(input_text)
-        .style(Style::default().fg(fg_color))
+        .style(Style::default().fg(theme.text()))
        .block(
            Block::default()
                .borders(Borders::ALL)
+                .border_type(BorderType::Rounded)
                .title(input_title)
-                .border_style(Style::default().fg(input_color)),
+                .title_style(
+                    Style::default()
+                        .fg(theme.peach())
+                        .add_modifier(Modifier::BOLD),
+                )
+                .border_style(Style::default().fg(input_border_color)),
        );
-    f.render_widget(input, chunks[1]);
+    f.render_widget(input, chunks[2]);

+    // Position the terminal cursor correctly when in Insert mode.
    if let Mode::Insert = app.mode {
-        let input_area = chunks[1];
-        // Cursor positioning
        f.set_cursor_position(ratatui::layout::Position::new(
-            input_area.x + 1 + input_text.chars().count() as u16,
-            input_area.y + 1,
+            chunks[2].x + 1 + cursor_pos as u16,
+            chunks[2].y + 1,
        ));
    }

-    // Status bar
-    let status_style = Style::default().bg(MANTLE).fg(fg_color);
-    let mode_str = match app.mode {
-        Mode::Normal => " NORMAL ",
-        Mode::Insert => " INSERT ",
-    };
-    let mode_style = match app.mode {
-        Mode::Normal => Style::default()
-            .bg(BLUE)
-            .fg(bg_color)
-            .add_modifier(Modifier::BOLD),
-        Mode::Insert => Style::default()
-            .bg(GREEN)
-            .fg(bg_color)
-            .add_modifier(Modifier::BOLD),
+    // Render the modern pill-style status bar.
+    let (mode_str, mode_style) = match app.mode {
+        Mode::Normal => (
+            " NORMAL ",
+            Style::default()
+                .bg(theme.blue())
+                .fg(theme.crust())
+                .add_modifier(Modifier::BOLD),
+        ),
+        Mode::Insert => (
+            " INSERT ",
+            Style::default()
+                .bg(theme.green())
+                .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(" j/k: navigate | i: edit | :w/Enter: save | q/:q: quit ");
+        .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), status_style),
+        Span::styled(
+            format!(" {} ", status_msg),
+            Style::default().bg(theme.surface0()).fg(theme.text()),
+        ),
    ]);

-    let status = Paragraph::new(status_line).style(status_style);
-    f.render_widget(status, chunks[2]);
+    let status = Paragraph::new(status_line).style(Style::default().bg(theme.surface0()));
+    f.render_widget(status, chunks[4]);
 }
Author	SHA1	Message	Date
nvrl	14f1be5a2a	Merge pull request 'Update Cargo.toml' (#7 ) from nvrl-patch-1 into main All checks were successful Release / Build and Release (push) Successful in 53s Details Reviewed-on: #7	2026-03-17 09:33:13 +01:00
nvrl	49eac25d48	Update Cargo.toml All checks were successful Version Check / check-version (pull_request) Successful in 3s Details	2026-03-17 09:33:05 +01:00
nvrl	3459c67377	Merge pull request 'release/0.3.0' (#6 ) from release/0.3.0 into main All checks were successful Release / Build and Release (push) Successful in 18s Details Reviewed-on: #6	2026-03-17 09:30:26 +01:00
Nils Pukropp	0ce858da5c	fixed transparent defaulting to true	2026-03-17 09:30:33 +01:00
Nils Pukropp	84945b9d83	clear search term everytime	2026-03-17 09:29:12 +01:00
Nils Pukropp	0c217c5129	added search functionality	2026-03-17 09:24:58 +01:00
Nils Pukropp	7b2217886c	added auto discovery and bumped version	2026-03-17 09:19:36 +01:00
Nils Pukropp	68cd6543b3	fixed long nested vars in the ui	2026-03-17 09:15:21 +01:00
Nils Pukropp	6c8fc7268b	version bump All checks were successful Version Check / check-version (pull_request) Successful in 3s Details	2026-03-16 18:00:04 +01:00
nvrl	93c5c30021	Merge pull request 'release/0.2.1' (#5 ) from release/0.2.1 into main All checks were successful Release / Build and Release (push) Successful in 57s Details Reviewed-on: #5	2026-03-16 18:00:02 +01:00
Nils Pukropp	53902af934	updated license	2026-03-16 17:59:52 +01:00
Nils Pukropp	7a7ae1ffdb	removed old comment Some checks failed Version Check / check-version (pull_request) Failing after 4s Details	2026-03-16 17:59:10 +01:00
Nils Pukropp	f413d5e2eb	updated clap output Some checks failed Version Check / check-version (pull_request) Failing after 3s Details	2026-03-16 17:57:44 +01:00
Nils Pukropp	e72fdd9fcb	added documentation	2026-03-16 17:55:10 +01:00
Nils Pukropp	7aa12f1a31	added theme configuration All checks were successful Version Check / check-version (pull_request) Successful in 3s Details	2026-03-16 17:47:01 +01:00
nvrl	d52422d839	Merge pull request 'release/0.2.0' (#4 ) from release/0.2.0 into main All checks were successful Release / Build and Release (push) Successful in 47s Details Reviewed-on: #4	2026-03-16 17:46:58 +01:00
Nils Pukropp	a274938368	rename + final ui design All checks were successful Version Check / check-version (pull_request) Successful in 2s Details	2026-03-16 17:41:22 +01:00
Nils Pukropp	253c69363d	added yaml,json + configurable keys	2026-03-16 17:36:04 +01:00
nvrl	ac7b67748d	Merge pull request 'fixed release upload' (#3 ) from release/0.1.0 into main All checks were successful Release / Build and Release (push) Successful in 39s Details Reviewed-on: nvrl/cenv-rs#3	2026-03-16 15:56:25 +01:00
Nils Pukropp	8cee54007f	fixed release upload	2026-03-16 15:56:18 +01:00
nvrl	361df64b04	Merge pull request 'added version check + fixed release' (#2 ) from release/0.1.0 into main Some checks failed Release / Build and Release (push) Failing after 36s Details Reviewed-on: nvrl/cenv-rs#2	2026-03-16 15:54:27 +01:00
Nils Pukropp	0baf53b1eb	added version check + fixed release	2026-03-16 15:54:06 +01:00
nvrl	6eddd02fb4	Merge pull request 'release/0.1.0' (#1 ) from release/0.1.0 into main Some checks failed Release / Build and Release (push) Failing after 44s Details Reviewed-on: nvrl/cenv-rs#1	2026-03-16 15:49:05 +01:00
Nils Pukropp	93b2b82494	added gitea ci	2026-03-16 15:48:58 +01:00