64 changed files with 2188 additions and 3096 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,2 +1,3 @@
 **/.DS_Store
+.venv/
 .dotfiles_env
--- a/.gitmodules
+++ b/.gitmodules
@ -1,6 +0,0 @@
-[submodule "config/shared/nvim"]
-	path = config/shared/nvim
-	url = git@gitea.tomastm.com:tomas.mirchev/nvim-config.git
-[submodule "config/shared/barg-parser"]
-	path = config/shared/barg-parser
-	url = git@gitea.tomastm.com:tomas.mirchev/barg-parser.git
--- a/README.md
+++ b/README.md
@ -1,226 +0,0 @@
-# Dotfiles
-
-## How to Use
-
-First, clone the repository:
-
-```sh
-git clone https://gitea.tomastm.com/tomas.mirchev/dotfiles.git ~/.dotfiles && cd ~/.dotfiles
-```
-
-The `setup` script will automatically update the remote repository URL. However, if you are configuring the dotfiles manually, make sure to change it after adding your SSH key:
-
-```sh
-git remote set-url origin git@gitea.tomastm.com:tomas.mirchev/dotfiles.git
-git remote -v
-```
-
-The `manage.py` script allows you to link configurations, install packages, and set up environments. To view available arguments, use:
-
-```sh
-manage.py -h
-manage.py <link|install|setup> -h
-```
-
-### Common Commands:
-
- `manage.py link <environment> [--copy] [-f|--force] [-p|--package]`
- `manage.py install <environment> [-p|--package]`
- `manage.py setup <environment> [--extra]`
-
-You can create multiple environments, following this structure:
-
- `config/<environment>`
- `config.json` (add `<environment>` to the JSON file)
- `setups/<environment>`
- Any additional scripts can be placed in `scripts/<script>`, following the naming convention `<env>-<script>`.
-
-## Environments
-
-Although you can specify any environment using `manage.py`, the recommended workflow follows this structure:
-
-### MacOS (`macos`)
-
-> **Setup command:** `manage.py setup macos`
-
-Since macOS is the host machine, it should use minimal applications and configurations. Whenever possible, install applications via Homebrew.
-
-Before formatting your machine, back up installed formulas and casks:
-
-```sh
-scripts/macos-brew_backup.sh
-```
-
-This backup will be restored automatically when setting up `macos`.
-
-#### Essential Applications:
-
- **LinearMouse**: Invert scrolling, adjust scrolling by pixels, and fix pointer acceleration.
- **Karabiner**: Configure keybindings and modifier keys.
- **Rectangle**: Window tiling.
- **Window-Tagger**: Custom window manager ([repository](https://gitea.tomastm.com/tomas.mirchev/window-tagger)).
- **Ghostty**: Terminal emulator.
-
-System settings cannot be automatically backed up. Refer to `obsidian#MacSettings.md` for manual adjustments.
-
-#### UTM (Virtual Machines)
-
-Development should occur inside virtual machines. UTM is preferred due to its open-source nature and support for both QEMU and Apple Hypervisor.
-
-> **Note:** When installing ISOs, ensure the correct architecture is selected.
-
-For Debian-based setups, avoid setting a `root` password to enable automatic `sudo` installation and add your user to the sudo group.
-
-#### DNS Configuration
-
-Communication between the host and virtual machines happens via local IPs set by UTM DHCP. To simplify this process, use `dnsmasq` (installed via `manage.py`).
-
-##### 1. Verify `dnsmasq` is Running
-
-```sh
-pgrep dnsmasq  # Should return a PID if running
-```
-
-##### 2. Determine the Default Gateway
-
-On **macOS (host):**
-
-```sh
-ifconfig | grep 192
-```
-
-On the **VM** (in "Shared Network" mode):
-
-```sh
-ip r
-```
-
-Typically, the **gateway IP** is `192.168.64.1`. If different, update the next steps accordingly.
-
-##### 3. Edit `dnsmasq.conf`
-
-```sh
-sudo vim /opt/homebrew/etc/dnsmasq.conf
-```
-
-Add:
-
-```ini
-# Define local domains
-address=/personal.utm.local/192.168.64.2
-address=/university.utm.local/192.168.64.3
-address=/personal.workstation.lan/192.168.50.2
-
-# Listening addresses (include gateway IP)
-listen-address=127.0.0.1,192.168.64.1
-```
-
-##### 4. Configure macOS to Use `dnsmasq`
-
-```sh
-sudo mkdir -p /etc/resolver
-sudo vim /etc/resolver/local
-sudo vim /etc/resolver/lan
-```
-
-Add:
-
-```plaintext
-nameserver 127.0.0.1
-```
-
-Alternatively:
-
-```sh
-echo "nameserver 127.0.0.1" | sudo tee /etc/resolver/local
-```
-
-##### 5. Restart `dnsmasq` and Flush DNS Cache
-
-```sh
-sudo brew services restart dnsmasq
-sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder
-```
-
-##### Notes
-
- `dnsmasq` requires manual removal on Brew upgrades or uninstallation:
-
-```sh
-sudo rm -rf /opt/homebrew/Cellar/dnsmasq/*/sbin
-sudo rm -rf /opt/homebrew/opt/dnsmasq
-sudo rm -rf /opt/homebrew/var/homebrew/linked/dnsmasq
-```
-
-### Linux VM (`linux-vm`)
-
-> **Setup command:** `manage.py setup linux-vm --extra "<hostname>"`
-
-After running the setup script, follow any additional manual steps it outputs.
-
-The most critical step is authenticating with the registry:
-
-```sh
-docker login registry.tomastm.com
-```
-
-### Linux Dev (`linux-dev`)
-
-This environment does not use a `setup` command, as it is configured via `Dockerfile`. However, `install` and `link` commands are available.
-
-Use `link --copy` to avoid redundant configurations inside images, reducing final image size.
-
-A base image (`base-debian`) contains essential utilities. Additional images exist for specific tools, such as `node` and `python`. View all images at: [Dev Containers](https://gitea.tomastm.com/tomas.mirchev/dev-containers).
-
-Each project should run its own container instance, enabling seamless project switching. Code remains on a mounted volume from the Linux VM.
-
-Containers persist until manually stopped, allowing `tmux` sessions to remain active.
-
-For convenience, use the `dev` script located in `~/bin` (automatically added to `PATH`).
-
-```sh
-dev -i <image> <name>
-
-# Example:
-dev -i node myapp
-```
-
-This creates a container named `node-myapp` (`<image>-<name>`).
-
-All images support both `arm64` and `amd64` architectures, automatically detected during execution.
-
---
-
-## Miscellaneous
-
-### Building NeoVim
-
-NeoVim is mirrored to Gitea to build `.deb` packages for releases. Follow these steps:
-
-```sh
-git clone git@gitea.tomastm.com:tomas.mirchev/neovim.git
-cd neovim
-git checkout tags/<tag>
-make CMAKE_BUILD_TYPE=RelWithDebInfo
-cd build
-cpack -G DEB
-```
-
-This builds for the host machine's architecture. The package should follow this format:
-
-```
-nvim-linux-$(dpkg --print-architecture).deb
-```
-
-Create a new release in the mirrored repository and attach the `.deb` file.
-
-### Proxmox
-
-UTM is the preferred VM solution, but Proxmox can be used for homelab setups.
-
-To fix `apt update/upgrade` issues:
-
-1. Go to "Datacenter" → "workstation" → "Repositories".
-2. Disable both enterprise sources.
-3. Add a new repository with "No-Subscription".
-4. Refresh "Updates" and proceed.
--- a/config/linux/kwin_window-tagger/contents/code/main.js
+++ b/config/linux/kwin_window-tagger/contents/code/main.js
@ -1,68 +0,0 @@
-const version = "v11"
-//console.info("WINDOW TAGGER STARTED - " + version)
-
-const windows = Array.from({length: 9}, () => null)
-
-for (let i = 0; i < 9; i++) {
-  registerShortcut(
-    `TagWindow${i+1}`,
-    `Tag current window to tag ${i+1}`,
-    `Meta+Shift+${i+1}`,
-    function() {
-      try {
-        //console.info(`Trying to tag at ${i+1}`)
-        if (!workspace.activeWindow) {
-          //console.info("No active window to tag")
-          return
-        }
-        
-        //console.info(`Tag ${i+1}: ${workspace.activeWindow.caption}`)
-        for (let j = 0; j < 9; j++) {
-          if (windows[j] === workspace.activeWindow) {
-            windows[j] = null;
-          }
-        }
-        windows[i] = workspace.activeWindow
-      } catch (e) {
-        console.info(e)
-      }
-    }
-  );
-
-  registerShortcut(
-    `FocusWindow${i}`,
-    `Focus Window at tag ${i+1}`,
-    `Meta+${i+1}`,
-    function() {
-      try {
-        //console.info(`Total: ${windows.filter(w => w !== null).length}`)
-        windows.forEach(w => {
-          if (w) {
-            //console.info(`- ${w.caption}`)
-          }
-        })
-        if (!windows[i]) {
-          //console.info("Tag is empty")
-          return
-        }
-
-        if (windows[i] === workspace.activeWindow) {
-          windows[i].minimized = true
-          //console.info("Focusing already focused window")
-          return
-        }
-
-        try {
-          workspace.activeWindow = windows[i]
-        } catch (error ) {
-          // console.info(windows[i].valid, windows[i].deleted)
-          // console.info("Error: ", error)
-          windows[i] = null
-        }
-      } catch (e) {
-        // console.info(e)
-      }
-    }
-  );
-}
-
--- a/config/linux/kwin_window-tagger/metadata.json
+++ b/config/linux/kwin_window-tagger/metadata.json
@ -1,21 +0,0 @@
-{
-    "KPlugin": {
-        "Name": "Window Tagger",
-        "Description": "Tag windows with numbers and quickly switch between them",
-        "Icon": "preferences-system-windows",
-        
-        "Authors": [
-            {
-                "Email": "username@gmail.com",
-                "Name": "Firstname Lastname"
-            }
-        ],
-        "Id": "window-tagger",
-        "Version": "1.0",
-        "License": "GPLv3",
-        "Website": "https://github.com/username/myscript"
-    },
-    "X-Plasma-API": "javascript",
-    "X-Plasma-MainScript": "code/main.js",
-    "KPackageStructure": "KWin/Script"
-}
--- a/config/linux/kwin_window-tagger/path.txt
+++ b/config/linux/kwin_window-tagger/path.txt
@ -1 +0,0 @@
-/home/tomas/.local/share/kwin/scripts
--- a/config/macos/alacritty/alacritty.toml
+++ b/config/macos/alacritty/alacritty.toml
@ -1,78 +0,0 @@
-[env]
-# TERM = "xterm-256color"
-
-[font]
-size = 14
-normal      = { family = "SF Mono", style = "Regular" }
-bold        = { family = "SF Mono", style = "Bold" }
-italic      = { family = "SF Mono", style = "Regular Italic" }
-bold_italic = { family = "SF Mono", style = "Bold Italic" }
-
-# normal      = { family = "Maple Mono", style = "Regular" }
-# bold        = { family = "Maple Mono", style = "Bold" }
-# italic      = { family = "Maple Mono", style = "Italic" }
-# bold_italic = { family = "Maple Mono", style = "Bold Italic" }
-# offset = { x = -1, y = 0 }
-
-[window]
-padding = { x = 2, y = 0 }
-dynamic_padding = true
-# resize_increments = true
-
-[keyboard]
-bindings = [
-    # Create new window
-    { action = "SpawnNewInstance", key = "N", mods = "Command" },
-    # Jump back one word
-    { key = "Left", mods = "Alt", chars = "\u001bb" },
-    # Jump forward one word
-    { key = "Right", mods = "Alt", chars = "\u001bf" },
-    # Move to start of line
-    { key = "Left", mods = "Command", chars = "\u0001" },
-    # Move to end of line
-    { key = "Right", mods = "Command", chars = "\u0005" },
-    # Delete backwards
-    { key = "Back", mods = "Alt", chars = "\u001B\u007F" }, # word
-    { key = "Back", mods = "Command", chars = "\u0015" },   # line
-    # Delete forwards
-    { key = "Delete", mods = "Alt", chars = "\u001Bd" },    # word
-    { key = "Delete", mods = "Command", chars = "\u000B" }  # line
-]
-
-[scrolling]
-multiplier = 1
-
-[general]
-live_config_reload = true
-
-[colors.primary]
-background = "#eeeeee"
-foreground = "#444444"
-
-[colors.cursor]
-text = "#eeeeee"
-cursor = "#005fff"
-
-[colors.selection]
-text = "#434343"
-background = "#e0e0e0"
-
-[colors.normal]
-black   = "#000000"
-red     = "#aa3731"
-green   = "#448c27"
-yellow  = "#cb9000"
-blue    = "#325cc0"
-magenta = "#7a3e9d"
-cyan    = "#0083b2"
-white   = "#bbbbbb"
-
-[colors.bright]
-black   = "#000000"
-red     = "#aa3731"
-green   = "#448c27"
-yellow  = "#cb9000"
-blue    = "#325cc0"
-magenta = "#7a3e9d"
-cyan    = "#0083b2"
-white   = "#bbbbbb"
--- a/config/macos/alacritty/themes/alabaster.toml
+++ b/config/macos/alacritty/themes/alabaster.toml
@ -1,27 +0,0 @@
-[colors.primary]
-background = '#F7F7F7'
-foreground = '#434343'
-
-[colors.cursor]
-text = '#F7F7F7'
-cursor = '#434343'
-
-[colors.normal]
-black = '#000000'
-red = '#AA3731'
-green = '#448C27'
-yellow = '#CB9000'
-blue = '#325CC0'
-magenta = '#7A3E9D'
-cyan = '#0083B2'
-white = '#BBBBBB'
-
-[colors.bright]
-black = '#777777'
-red = '#F05050'
-green = '#60CB00'
-yellow = '#FFBC5D'
-blue = '#007ACC'
-magenta = '#E64CE6'
-cyan = '#00AACB'
-white = '#FFFFFF'
--- a/config/macos/borders/bordersrc
+++ b/config/macos/borders/bordersrc
@ -1,13 +0,0 @@
-#!/bin/bash
-
-options=(
-  order=above
-	width=2.0
-	hidpi=on
-  active_color=0xff2b2b2b
-  inactive_color=0xff2b2b2b
-  # inactive_color=0x00000000
-  whitelist="wezterm-gui"
-)
-
-borders "${options[@]}"
--- a/config/macos/ghostty/Ghostty.icns
+++ b/config/macos/ghostty/Ghostty.icns
--- a/config/macos/ghostty/config
+++ b/config/macos/ghostty/config
@ -1,33 +0,0 @@
-#term = xterm-256color
-theme = Invero Day
-
-# Font
-font-family = "Maple Mono"
-font-size = 13
-font-thicken = true
-font-thicken-strength = 120
-font-feature = -liga, -dlig, -calt
-
-adjust-underline-thickness = 1
-adjust-strikethrough-thickness = 1
-adjust-overline-thickness = 1
-adjust-box-thickness = 1
-adjust-cell-width = -7%
-adjust-cell-height = -2
-
-# Cursor
-cursor-style = block
-cursor-style-blink = false
-mouse-hide-while-typing = true
-shell-integration-features = ssh-terminfo,ssh-env,no-cursor
-
-# Window
-window-height = 80
-window-width = 128
-window-padding-x = 4
-window-padding-y = 0
-window-padding-color = extend
-macos-titlebar-style = native
-macos-icon = custom
-
-window-inherit-working-directory = false
--- a/config/macos/ghostty/themes/Invero
+++ b/config/macos/ghostty/themes/Invero
@ -1,22 +0,0 @@
-palette = 0=#444444
-palette = 1=#ff0000
-palette = 2=#00af5f
-palette = 3=#d75f00
-palette = 4=#005fff
-palette = 5=#5f5f87
-palette = 6=#afd7ff
-palette = 7=#eeeeee
-palette = 8=#444444
-palette = 9=#ff0000
-palette = 10=#00af5f
-palette = 11=#d75f00
-palette = 12=#005fff
-palette = 13=#5f5f87
-palette = 14=#afd7ff
-palette = 15=#eeeeee
-
-background = #eeeeee
-foreground = #444444
-cursor-color = #005fff
-selection-background = #dadada
-selection-foreground = #444444
--- a/config/macos/homebrew/Brewfile
+++ b/config/macos/homebrew/Brewfile
@ -1,25 +0,0 @@
-brew "bash"
-brew "dnsmasq", restart_service: :changed
-brew "tmux"
-cask "brave-browser"
-cask "bruno"
-cask "dbeaver-community"
-cask "discord"
-cask "firefox"
-cask "font-maple-mono"
-cask "font-maple-mono-nf"
-cask "ghostty"
-cask "google-chrome"
-cask "karabiner-elements"
-cask "linearmouse"
-cask "macfuse"
-cask "orbstack"
-cask "proton-drive"
-cask "protonvpn"
-cask "rectangle"
-cask "slack"
-cask "sol"
-cask "spotify"
-cask "sublime-text"
-cask "utm@beta"
-cask "zoom"
--- a/config/macos/karabiner/automatic_backups/karabiner_20251105.json
+++ b/config/macos/karabiner/automatic_backups/karabiner_20251105.json
@ -1,15 +0,0 @@
-{
-    "profiles": [
-        {
-            "name": "Default profile",
-            "selected": true,
-            "simple_modifications": [
-                {
-                    "from": { "key_code": "caps_lock" },
-                    "to": [{ "key_code": "left_control" }]
-                }
-            ],
-            "virtual_hid_keyboard": { "keyboard_type_v2": "iso" }
-        }
-    ]
-}
--- a/config/macos/karabiner/karabiner.json
+++ b/config/macos/karabiner/karabiner.json
@ -1,34 +0,0 @@
-{
-    "global": { "show_in_menu_bar": false },
-    "profiles": [
-        {
-            "devices": [
-                {
-                    "identifiers": {
-                        "is_keyboard": true,
-                        "product_id": 50475,
-                        "vendor_id": 1133
-                    },
-                    "ignore_vendor_events": true
-                },
-                {
-                    "identifiers": {
-                        "is_keyboard": true,
-                        "product_id": 50504,
-                        "vendor_id": 1133
-                    },
-                    "ignore_vendor_events": true
-                }
-            ],
-            "name": "Default profile",
-            "selected": true,
-            "simple_modifications": [
-                {
-                    "from": { "key_code": "caps_lock" },
-                    "to": [{ "key_code": "left_control" }]
-                }
-            ],
-            "virtual_hid_keyboard": { "keyboard_type_v2": "iso" }
-        }
-    ]
-}
--- a/config/macos/kitty/choose_tab.py
+++ b/config/macos/kitty/choose_tab.py
@ -1,54 +0,0 @@
-# ~/.config/kitty/choose_tab.py
-from kitty.boss import get_boss
-from kittens.tui.handler import Handler
-from kittens.tui.loop import Loop
-
-
-class TabPicker(Handler):
-    def __init__(self):
-        super().__init__()
-        boss = get_boss()
-        win = boss.active_window
-        self.osw = win.os_window if win else None
-        self.tabs = list(self.osw.tabs) if self.osw else []
-        self.index = 0
-
-    def draw(self, screen):
-        screen.clear()
-        if not self.tabs:
-            screen.write_line("No tabs. Esc to exit.")
-        else:
-            screen.write_line("Choose a tab (↑/↓ Enter Esc)")
-            for i, t in enumerate(self.tabs):
-                mark = "●" if t is self.osw.active_tab else " "
-                sel = ">" if i == self.index else " "
-                title = t.title or f"Tab {i+1}"
-                screen.write_line(f"{sel} {mark} {title}")
-        screen.refresh()
-
-    def on_key(self, event):
-        if not self.tabs:
-            if event.key in ("escape", "enter"):
-                self.quit_loop()
-            return
-        k = event.key
-        if k in ("up", "k"):
-            self.index = (self.index - 1) % len(self.tabs)
-        elif k in ("down", "j"):
-            self.index = (self.index + 1) % len(self.tabs)
-        elif k == "enter":
-            self.osw.set_active_tab(self.tabs[self.index])
-            self.quit_loop()
-        elif k == "escape":
-            self.quit_loop()
-        self.refresh()
-
-
-def main(args):
-    # Correct signature for older Kitty: pass the class name and a title string
-    Loop(TabPicker, "choose_tab").run()
-
-
-def handle_result(args, answer, target_window_id, boss):
-    pass
-
--- a/config/macos/kitty/invero.conf
+++ b/config/macos/kitty/invero.conf
@ -1,35 +0,0 @@
-# vim:ft=kitty
-
-background #eeeeee
-foreground #444444
-cursor #005fff
-cursor_text_color #eeeeee
-selection_background #dadada
-selection_foreground #444444
-url_color #005fff
-
-# Tabs
-active_tab_background #005fff
-active_tab_foreground #eeeeee
-inactive_tab_background #dadada
-inactive_tab_foreground #9e9e9e
-
-# normal
-color0 #444444
-color1 #ff0000
-color2 #00af5f
-color3 #d75f00
-color4 #005fff
-color5 #5f5f87
-color6 #afd7ff
-color7 #eeeeee
-
-# bright
-color8  #444444
-color9  #ff0000
-color10 #00af5f
-color11 #d75f00
-color12 #005fff
-color13 #5f5f87
-color14 #afd7ff
-color15 #eeeeee
--- a/config/macos/kitty/kitty.app.icns
+++ b/config/macos/kitty/kitty.app.icns
--- a/config/macos/kitty/kitty.conf
+++ b/config/macos/kitty/kitty.conf
@ -1,73 +0,0 @@
-include invero.conf
-
-# term              xterm-256color
-enable_audio_bell no
-cursor_shape block
-wheel_scroll_multiplier 1.0
-touch_scroll_multiplier 1.0
-wheel_scroll_min_lines 1
-shell_integration  no-cursor
-cursor_blink_interval 0
-
-remember_window_position yes
-remember_window_size  yes
-
-# Font
-font_family       Maple Mono
-font_size         13.0
-# disable_ligatures always
-
-# undercurl_style thick-sparse
-
-modify_font cell_width 94%
-modify_font cell_height -2px
-# modify_font baseline 2px
-
-# modify_font underline_thickness 180%
-# modify_font underline_position 2px
-# modify_font strikethrough_positon 2px
-text_composition_strategy legacy
-# underline_exclusion 0
-
-placement_strategy top
-window_margin_width 0 0
-window_padding_width 0 4
-
-# modify_font cell_height -1
-# modify_font cell_width 90%
-
-# Navigation / editing
-# Make Option act as Alt on macOS
-macos_option_as_alt yes
-
-# Use explicit bytes (no ambiguity), not \x1bb etc.
-map opt+left        send_text all \x1b\x62
-map opt+right       send_text all \x1b\x66
-map cmd+left        send_text all \x01
-map cmd+right       send_text all \x05
-map opt+backspace   send_text all \x1b\x7f
-map cmd+backspace   send_text all \x15
-map opt+delete      send_text all \x1b\x64
-map cmd+delete      send_text all \x0b
-
-# New window / tab
-map cmd+n new_os_window
-map cmd+t new_tab
-
-map cmd+1 goto_tab 1
-map cmd+2 goto_tab 2
-map cmd+3 goto_tab 3
-map cmd+4 goto_tab 4
-map cmd+5 goto_tab 5
-map cmd+6 goto_tab 6
-map cmd+7 goto_tab 7
-map cmd+8 goto_tab 8
-map cmd+9 goto_tab 9
-
-
-# BEGIN_KITTY_FONTS
-# font_family      family="JetBrains Mono"
-bold_font        auto
-italic_font      auto
-bold_italic_font auto
-# END_KITTY_FONTS
--- a/config/macos/linearmouse/linearmouse.json
+++ b/config/macos/linearmouse/linearmouse.json
@ -1,44 +0,0 @@
-{
-  "$schema": "https:\/\/schema.linearmouse.app\/0.10.0",
-  "schemes": [
-    {
-      "if" : {
-        "device" : {
-          "vendorID" : "0x46d",
-          "productID" : "0xc52b",
-          "productName" : "USB Receiver",
-          "category" : "mouse"
-        }
-      },
-      "scrolling": {
-        "reverse": {
-          "vertical": true
-        },
-        "speed": {
-          "vertical": 0
-        },
-        "acceleration": {
-          "vertical": 1
-        },
-        "distance": {
-          "vertical": "100px"
-        },
-        "modifiers": {
-          "vertical": {
-            "command": {
-              "type": "preventDefault"
-            }
-          }
-        }
-      },
-      "buttons": {
-        "universalBackForward": true
-      },
-      "pointer": {
-        "acceleration": 0.3,
-        "speed": 0.2,
-        "disableAcceleration": false
-      }
-    }
-  ]
-}
--- a/config/macos/rectangle/RectangleConfig.json
+++ b/config/macos/rectangle/RectangleConfig.json
@ -1,286 +0,0 @@
-{
-  "bundleId" : "com.knollsoft.Rectangle",
-  "defaults" : {
-    "SUEnableAutomaticChecks" : {
-      "bool" : true
-    },
-    "allowAnyShortcut" : {
-      "bool" : true
-    },
-    "almostMaximizeHeight" : {
-      "float" : 0
-    },
-    "almostMaximizeWidth" : {
-      "float" : 0
-    },
-    "altThirdCycle" : {
-      "int" : 0
-    },
-    "alternateDefaultShortcuts" : {
-      "bool" : true
-    },
-    "alwaysAccountForStage" : {
-      "int" : 0
-    },
-    "applyGapsToMaximize" : {
-      "int" : 0
-    },
-    "applyGapsToMaximizeHeight" : {
-      "int" : 0
-    },
-    "attemptMatchOnNextPrevDisplay" : {
-      "int" : 0
-    },
-    "autoMaximize" : {
-      "int" : 0
-    },
-    "cascadeAllDeltaSize" : {
-      "float" : 30
-    },
-    "centerHalfCycles" : {
-      "int" : 0
-    },
-    "centeredDirectionalMove" : {
-      "int" : 0
-    },
-    "cornerSnapAreaSize" : {
-      "float" : 20
-    },
-    "curtainChangeSize" : {
-      "int" : 0
-    },
-    "cycleSizesIsChanged" : {
-      "bool" : false
-    },
-    "disabledApps" : {
-
-    },
-    "doubleClickTitleBar" : {
-      "int" : 0
-    },
-    "doubleClickTitleBarIgnoredApps" : {
-
-    },
-    "doubleClickTitleBarRestore" : {
-      "int" : 0
-    },
-    "dragFromStage" : {
-      "int" : 0
-    },
-    "enhancedUI" : {
-      "int" : 1
-    },
-    "footprintAlpha" : {
-      "float" : 0.3
-    },
-    "footprintAnimationDurationMultiplier" : {
-      "float" : 0
-    },
-    "footprintBorderWidth" : {
-      "float" : 2
-    },
-    "footprintColor" : {
-
-    },
-    "footprintFade" : {
-      "int" : 0
-    },
-    "fullIgnoreBundleIds" : {
-
-    },
-    "gapSize" : {
-      "float" : 0
-    },
-    "hapticFeedbackOnSnap" : {
-      "int" : 0
-    },
-    "hideMenubarIcon" : {
-      "bool" : false
-    },
-    "ignoreDragSnapToo" : {
-      "int" : 0
-    },
-    "ignoredSnapAreas" : {
-      "int" : 0
-    },
-    "landscapeSnapAreas" : {
-      "string" : "[4,{\"compound\":-2},1,{\"action\":15},2,{\"action\":2},6,{\"action\":13},7,{\"compound\":-4},8,{\"action\":14},3,{\"action\":16},5,{\"compound\":-3}]"
-    },
-    "launchOnLogin" : {
-      "bool" : true
-    },
-    "minimumWindowHeight" : {
-      "float" : 0
-    },
-    "minimumWindowWidth" : {
-      "float" : 0
-    },
-    "missionControlDragging" : {
-      "int" : 0
-    },
-    "missionControlDraggingAllowedOffscreenDistance" : {
-      "float" : 25
-    },
-    "missionControlDraggingDisallowedDuration" : {
-      "int" : 250
-    },
-    "moveCursor" : {
-      "int" : 0
-    },
-    "moveCursorAcrossDisplays" : {
-      "int" : 0
-    },
-    "notifiedOfProblemApps" : {
-      "bool" : false
-    },
-    "obtainWindowOnClick" : {
-      "int" : 0
-    },
-    "portraitSnapAreas" : {
-
-    },
-    "relaunchOpensMenu" : {
-      "bool" : false
-    },
-    "resizeOnDirectionalMove" : {
-      "bool" : false
-    },
-    "screenEdgeGapBottom" : {
-      "float" : 0
-    },
-    "screenEdgeGapLeft" : {
-      "float" : 0
-    },
-    "screenEdgeGapRight" : {
-      "float" : 0
-    },
-    "screenEdgeGapTop" : {
-      "float" : 0
-    },
-    "screenEdgeGapTopNotch" : {
-      "float" : 0
-    },
-    "screenEdgeGapsOnMainScreenOnly" : {
-      "bool" : false
-    },
-    "selectedCycleSizes" : {
-      "int" : 0
-    },
-    "shortEdgeSnapAreaSize" : {
-      "float" : 145
-    },
-    "showAllActionsInMenu" : {
-      "int" : 0
-    },
-    "sixthsSnapArea" : {
-      "int" : 0
-    },
-    "sizeOffset" : {
-      "float" : 0
-    },
-    "snapEdgeMarginBottom" : {
-      "float" : 5
-    },
-    "snapEdgeMarginLeft" : {
-      "float" : 5
-    },
-    "snapEdgeMarginRight" : {
-      "float" : 5
-    },
-    "snapEdgeMarginTop" : {
-      "float" : 5
-    },
-    "snapModifiers" : {
-      "int" : 0
-    },
-    "specifiedHeight" : {
-      "float" : 1050
-    },
-    "specifiedWidth" : {
-      "float" : 1680
-    },
-    "stageSize" : {
-      "float" : 190
-    },
-    "subsequentExecutionMode" : {
-      "int" : 1
-    },
-    "systemWideMouseDown" : {
-      "int" : 0
-    },
-    "systemWideMouseDownApps" : {
-
-    },
-    "todo" : {
-      "int" : 0
-    },
-    "todoApplication" : {
-
-    },
-    "todoMode" : {
-      "bool" : false
-    },
-    "todoSidebarSide" : {
-      "int" : 1
-    },
-    "todoSidebarWidth" : {
-      "float" : 400
-    },
-    "traverseSingleScreen" : {
-      "int" : 0
-    },
-    "unsnapRestore" : {
-      "int" : 0
-    },
-    "windowSnapping" : {
-      "int" : 0
-    }
-  },
-  "shortcuts" : {
-    "bottomHalf" : {
-      "keyCode" : 38,
-      "modifierFlags" : 786432
-    },
-    "firstThird" : {
-      "keyCode" : 33,
-      "modifierFlags" : 786432
-    },
-    "firstTwoThirds" : {
-      "keyCode" : 33,
-      "modifierFlags" : 917504
-    },
-    "lastThird" : {
-      "keyCode" : 30,
-      "modifierFlags" : 786432
-    },
-    "lastTwoThirds" : {
-      "keyCode" : 30,
-      "modifierFlags" : 917504
-    },
-    "leftHalf" : {
-      "keyCode" : 4,
-      "modifierFlags" : 786432
-    },
-    "maximize" : {
-      "keyCode" : 36,
-      "modifierFlags" : 786432
-    },
-    "reflowTodo" : {
-      "keyCode" : 45,
-      "modifierFlags" : 786432
-    },
-    "rightHalf" : {
-      "keyCode" : 37,
-      "modifierFlags" : 786432
-    },
-    "toggleTodo" : {
-      "keyCode" : 11,
-      "modifierFlags" : 786432
-    },
-    "topHalf" : {
-      "keyCode" : 40,
-      "modifierFlags" : 786432
-    }
-  },
-  "version" : "92"
-}
--- a/config/macos/rectangle/com.knollsoft.Rectangle.plist
+++ b/config/macos/rectangle/com.knollsoft.Rectangle.plist
--- a/config/macos/sol/mmkv.default
+++ b/config/macos/sol/mmkv.default
--- a/config/macos/sol/mmkv.default.crc
+++ b/config/macos/sol/mmkv.default.crc
--- a/config/macos/wezterm/colors/Invero
+++ b/config/macos/wezterm/colors/Invero
@ -1,36 +0,0 @@
-[colors]
-background = "#eeeeee"
-foreground = "#444444"
-cursor_bg = "#005fff"
-cursor_border = "#9e9e9e"
-cursor_fg = "#eeeeee"
-selection_bg = "#dadada"
-selection_fg = "#444444"
-split = "#005fff"
-compose_cursor = "#d75f00"
-scrollbar_thumb = "#9e9e9e"
-
-copy_mode_active_highlight_bg = { Color = "#dadada" }
-copy_mode_active_highlight_fg = { Color = "#d75f00" }
-copy_mode_inactive_highlight_bg = { Color = "#eeeeee" }
-copy_mode_inactive_highlight_fg = { Color = "#d75f00" }
-
-ansi = ["#444444", "#ff0000", "#00af5f", "#d75f00", "#005fff", "#5f5f87", "#afd7ff", "#eeeeee"]
-brights = ["#444444", "#ff0000", "#00af5f", "#d75f00", "#005fff", "#5f5f87", "#afd7ff", "#eeeeee"]
-
-[colors.tab_bar]
-inactive_tab_edge = "#ff0000"
-background = "#444444"
-
-[colors.tab_bar.active_tab]
-fg_color = "#eeeeee"
-bg_color = "#444444"
-intensity = "Bold"
-
-[colors.tab_bar.inactive_tab]
-fg_color = "#9e9e9e"
-bg_color = "#444444"
-
-[colors.tab_bar.inactive_tab_hover]
-fg_color = "#dadada"
-bg_color = "#444444"
--- a/config/macos/wezterm/wezterm.lua
+++ b/config/macos/wezterm/wezterm.lua
@ -1,72 +0,0 @@
-local wezterm = require("wezterm")
-local config = wezterm.config_builder()
-local act = wezterm.action
-
-- General
-config.term = "wezterm"
-config.color_scheme = "Invero Day"
-config.use_ime = false
-
-- Font
-config.font = wezterm.font({ family = "Maple Mono NF", weight = "Medium" })
-config.font_size = 13
-config.harfbuzz_features = { "calt=0", "clig=0", "liga=0" } -- disables alternates and ligatures
-config.underline_position = -4
-config.underline_thickness = 3
-
-- Appearance
-config.bold_brightens_ansi_colors = false
-config.window_padding = { left = "0.5cell", right = "0.5cell", top = 6, bottom = 0 }
-config.window_content_alignment = { horizontal = "Center", vertical = "Top" }
-config.cell_width = 0.9
-config.line_height = 0.9
-
-- Tabs
-config.use_fancy_tab_bar = false
-config.show_new_tab_button_in_tab_bar = false
-config.hide_tab_bar_if_only_one_tab = true
-
-- Events
-wezterm.on("toggle-tabbar", function(window, _)
-	local overrides = window:get_config_overrides() or {}
-	if overrides.enable_tab_bar == false then
-		wezterm.log_info("tab bar shown")
-		overrides.enable_tab_bar = true
-	else
-		wezterm.log_info("tab bar hidden")
-		overrides.enable_tab_bar = false
-	end
-	window:set_config_overrides(overrides)
-end)
-
-- Keybindings
-config.keys = {
-	{ mods = "OPT", key = "LeftArrow", action = act.SendString("\x1bb") }, -- Jump back one word
-	{ mods = "OPT", key = "RightArrow", action = act.SendString("\x1bf") }, -- Jump forward one word
-	{ mods = "CMD", key = "LeftArrow", action = act.SendString("\x01") }, -- Move to start of line
-	{ mods = "CMD", key = "RightArrow", action = act.SendString("\x05") }, -- Move to end of line
-	{ mods = "OPT", key = "Backspace", action = act.SendString("\x1b\x7f") }, -- Delete previous word
-	{ mods = "CMD", key = "Backspace", action = act.SendString("\x15") }, -- Delete previous line
-	{ mods = "OPT", key = "Delete", action = act.SendString("\x1bd") }, -- Delete next word
-	{ mods = "CMD", key = "Delete", action = act.SendString("\x0b") }, -- Delete next line
-	{ mods = "CMD", key = "n", action = act.SpawnWindow }, -- New window
-	{ mods = "CMD", key = "t", action = act.SpawnCommandInNewTab({ cwd = wezterm.home_dir }) }, -- New tab
-	{ mods = "SUPER|SHIFT", key = "LeftArrow", action = act({ MoveTabRelative = -1 }) }, -- Move tab left
-	{ mods = "SUPER|SHIFT", key = "RightArrow", action = act({ MoveTabRelative = 1 }) }, -- Move tab right
-	{ mods = "SUPER|SHIFT", key = "b", action = act.EmitEvent("toggle-tabbar") },
-	{ mods = "SUPER|SHIFT", key = "o", action = wezterm.action.ShowTabNavigator },
-	{
-		mods = "SUPER|SHIFT",
-		key = "r",
-		action = wezterm.action.PromptInputLine({
-			description = "Enter new tab title",
-			action = wezterm.action_callback(function(window, pane, line)
-				if line then
-					window:active_tab():set_title(line)
-				end
-			end),
-		}),
-	},
-}
-
-return config
--- a/config/shared/barg-parser
+++ b/config/shared/barg-parser
@ -1 +0,0 @@
-Subproject commit d0344b6c564a5d6b00bccd73caefcda42229d70b
--- a/config/shared/bin/dev-tmux-wrapper.sh
+++ b/config/shared/bin/dev-tmux-wrapper.sh
@ -1,12 +0,0 @@
-#!/bin/bash
-
-/home/tomas/bin/dev "$@" 2>&1
-exit_code=$?
-
-if [ $exit_code -ne 0 ]; then
-  echo ""
-  echo "Command: $*"
-  echo "Failed: exit $exit_code"
-fi
-
-exit $exit_code
--- a/config/shared/bin/flow
+++ b/config/shared/bin/flow
@ -1,612 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-source "$HOME/.local/bin/barg"
-
-# shellcheck disable=SC2034
-SPEC=(
-  "command;flow;DevFlow CLI - Manage instances and development containers"
-  "note;Use 'flow <command> --help' for command-specific options"
-
-  "command;enter;Connect to a development instance via SSH"
-  "note;Target format: [user@]namespace@platform (e.g., 'personal@orb' or 'root@personal@orb')"
-  "argument;user,u;type:option;help:SSH user (overrides user in target)"
-  "argument;namespace,n;type:option;help:Instance namespace (overrides namespace in target)"
-  "argument;platform,p;type:option;help:Platform name (overrides platform in target)"
-  "argument;session,s;type:option;default:default;help:Development session name (default: 'default')"
-  "argument;no-tmux;type:flag;dest:no_tmux;default:false;help:Skip tmux attachment on connection"
-  "argument;dry-run,d;type:flag;dest:dry_run;default:false;help:Show SSH command without executing"
-  "argument;target,t;required;help:Target instance in format [user@]namespace@platform"
-  "argument;ssh-args;type:rest;dest:ssh_args;help:Additional SSH arguments (after --)"
-  "end"
-
-  "command;sync;Git tools"
-  "command;check;Check all projects status"
-  "end"
-  "end"
-
-  "command;dotfiles;Manage repository dotfiles and git submodules"
-  "command;init;Initialize and set up all submodules"
-  "note;Equivalent to: git submodule update --init --recursive"
-  "end"
-  "command;pull;Update all submodules to latest remote commits"
-  "note;Equivalent to: git submodule update --remote --recursive"
-  "end"
-  "command;urls;Synchronize submodule URLs"
-  "note;Equivalent to: git submodule sync --recursive"
-  "end"
-  "command;reset;Reset submodules to the recorded commits"
-  "note;Equivalent to: git submodule update --init --recursive --force"
-  "end"
-  "command;status;Show current submodule status"
-  "note;Equivalent to: git submodule status --recursive"
-  "end"
-  "command;all;Run URLs sync, initialization, and remote update in one step"
-  "note;Equivalent to: git submodule sync --recursive && git submodule update --init --recursive && git submodule update --remote --recursive"
-  "end"
-  "end"
-
-  "command;create;Create and start a new development container"
-  "argument;image,i;required;type:option;help:Container image to use (with optional tag)"
-  "argument;project,p;type:option;help:Path to local project directory"
-  "argument;name;required;help:Container name"
-  "end"
-
-  "command;exec;Execute a command or open a shell in a container"
-  "argument;name;required;help:Container name"
-  "argument;cmd;type:rest;help:Command to execute inside container (after --)"
-  "end"
-
-  "command;connect;Attach or switch to the container’s tmux session"
-  "note;When already inside tmux, switches to the target session instead of reattaching."
-  "note;New tmux panes or windows in the session automatically start inside the container."
-  "argument;from,f;type:option;dest:name;help:Optional source container name"
-  "argument;name;required;help:Target container name"
-  "end"
-
-  "command;list;Display all development containers and their status"
-  "end"
-
-  "command;stop;Stop or kill a running development container"
-  "argument;from;type:option;dest:name;help:Optional source container name"
-  "argument;kill;type:flag;help:Use kill instead of graceful stop"
-  "argument;name;required;help:Target container name"
-  "end"
-
-  "command;remove,rm;Remove a development container"
-  "argument;from;type:option;dest:name;help:Optional source container name"
-  "argument;force,f;type:flag;help:Force removal of container"
-  "argument;name;required;help:Target container name"
-  "end"
-
-  "command;respawn;Restart all tmux panes for a development session"
-  "argument;from;type:option;dest:name;help:Optional source container name"
-  "argument;name;required;help:Session or container name"
-  "end"
-
-  "command;test;Verify that the dev script is functioning"
-  "argument;from;type:option;dest:name;help:Optional source container name"
-  "argument;name;help:Target container name"
-  "end"
-
-  "end"
-)
-
-DEFAULT_REGISTRY="registry.tomastm.com"
-DEFAULT_TAG="latest"
-PROJECT_DIR="$HOME/projects"
-PROJECT_ABBR="p"
-
-fail() {
-  printf 'Error: %b\n' "$*" >&2
-  exit 1
-}
-
-resolve_path() {
-  local path="${1:-$(dirname "${BASH_SOURCE[0]}")}"
-  if command -v realpath >/dev/null 2>&1; then
-    realpath "$path"
-  else
-    echo "$(cd "$(dirname "$path")" && pwd)/$(basename "$path")"
-  fi
-}
-
-# shellcheck disable=SC2178,SC2128
-parse_image_ref() {
-  local input="$1"
-
-  local image_ref registry repo tag label
-
-  if [[ $input == */* ]]; then
-    local prefix="${input%%/*}"
-    if [[ "$prefix" == "docker" ]]; then
-      input="docker.io/library/${input#*/}"
-    elif [[ "$prefix" == "tm0" ]]; then
-      input="${DEFAULT_REGISTRY}/${input#*/}"
-    fi
-
-    registry="${input%%/*}"
-    input=${input#*/}
-  else
-    registry="$DEFAULT_REGISTRY"
-  fi
-
-  if [[ "${input##*/}" == *:* ]]; then
-    tag="${input##*:}"
-    input="${input%:*}"
-  else
-    tag="$DEFAULT_TAG"
-  fi
-
-  repo="${registry}/${input}"
-  repo="${repo#*/}"
-  image_ref="${registry}/${repo}:${tag}"
-
-  label="${registry%.*}"
-  label="${label##*.}/${repo##*/}"
-
-  echo "$image_ref $repo $tag $label"
-}
-
-# shellcheck disable=SC2154,SC2155
-docker_container_exists() {
-  local cname="$(get_cname)"
-  docker container ls -a --format '{{.Names}}' | grep -Fqx "$cname"
-}
-
-# shellcheck disable=SC2154,SC2155
-docker_container_running() {
-  local cname="$(get_cname)"
-  docker container ls --format '{{.Names}}' | grep -Fqx "$cname"
-}
-
-docker_image_present() {
-  local ref="$1"
-  docker image inspect "$ref" >/dev/null 2>&1
-}
-
-# shellcheck disable=SC2154,SC2155
-get_cname() {
-  printf "%s" "dev-${name_arg#dev-}"
-}
-
-cmd() {
-  barg_usage
-}
-
-cmd_dotfiles_init() {
-  echo "[dotfiles] Initializing submodules..."
-  git submodule update --init --recursive
-}
-
-cmd_dotfiles_pull() {
-  echo "[dotfiles] Updating submodules to latest remote commits..."
-  git submodule update --remote --recursive
-}
-
-cmd_dotfiles_urls() {
-  echo "[dotfiles] Syncing submodule URLs..."
-  git submodule sync --recursive
-}
-
-cmd_dotfiles_reset() {
-  echo "[dotfiles] Resetting submodules to recorded commits..."
-  git submodule update --init --recursive --force
-}
-
-cmd_dotfiles_status() {
-  echo "[dotfiles] Submodule status:"
-  git submodule status --recursive
-}
-
-cmd_dotfiles_all() {
-  echo "[dotfiles] Syncing URLs..."
-  git submodule sync --recursive
-
-  echo "[dotfiles] Initializing submodules..."
-  git submodule update --init --recursive
-
-  echo "[dotfiles] Updating submodules to latest remote commits..."
-  git submodule update --remote --recursive
-}
-
-# shellcheck disable=SC2154,SC2155
-cmd_enter() {
-  # VARS: user_arg, namespace_arg, platform_arg, target_arg, session_arg, no_tmux_arg, dry_run_arg, ssh_args_arg
-
-  # Do not run inside instance
-  if [[ -n "$DF_NAMESPACE" && -n "$DF_PLATFORM" ]]; then
-    fail "It is not recommended to run this command inside an instance.\nCurrently inside: $(tput bold)${DF_NAMESPACE}@${DF_PLATFORM}$(tput sgr0)"
-  fi
-
-  local -A CONFIG_HOST=(
-    [orb.host]="<namespace>@orb"
-    [utm.host]="<namespace>.utm.local"
-    [core.host]="<namespace>.core.lan"
-  )
-
-  local df_platform=""
-  local df_namespace=""
-  local df_user=""
-
-  # Parse target: get user, namespace, platform
-  if [[ "$target_arg" == *@* ]]; then
-    df_platform="${target_arg##*@}"
-    target_arg="${target_arg%@*}"
-  fi
-
-  if [[ "$target_arg" == *@* ]]; then
-    df_namespace="${target_arg##*@}"
-    df_user="${target_arg%@*}"
-  else
-    df_namespace="${target_arg}"
-    df_user="${USER}"
-  fi
-
-  if [[ -n "$platform_arg" ]]; then
-    df_platform="$platform_arg"
-  fi
-  if [[ -n "$namespace_arg" ]]; then
-    df_namespace="$namespace_arg"
-  fi
-  if [[ -n "$user_arg" ]]; then
-    df_user="$user_arg"
-  fi
-
-  # Resolve host, identity (maybe check what would the host be in order to use .ssh/config)
-  local host_config="${CONFIG_HOST[${df_platform}.host]}"
-  local ssh_host="${host_config//<namespace>/$df_namespace}"
-  if [[ -z "$ssh_host" ]]; then
-    fail "Invalid platform: ${df_platform}"
-  fi
-
-  # Build ssh cmd: ssh + identity + tmux + envs
-  local ssh_cmd=(ssh -tt "${df_user}@${ssh_host}")
-
-  if [[ "$no_tmux_arg" == "false" ]]; then
-    # TODO: instead of tmux,maybe use "flow" in order to attach to dev container too
-    ssh_cmd+=("tmux" "new-session" "-As" "$session_arg"
-      "-e" "DF_NAMESPACE=$df_namespace"
-      "-e" "DF_PLATFORM=$df_platform")
-  fi
-
-  # Run or dryrun?
-  if [[ "$dry_run_arg" == "true" ]]; then
-    echo "Dry run command:"
-    printf '%q ' "${ssh_cmd[@]}"
-    echo
-    exit 0
-  fi
-
-  exec "${ssh_cmd[@]}"
-}
-
-# shellcheck disable=SC2154,SC2155
-cmd_sync_check() {
-  local base_dir="$HOME/projects"
-  local -a needs_action=()
-  local -a not_git=()
-
-  for repo in "$base_dir"/*; do
-    [ -d "$repo" ] || continue
-    local git_dir="$repo/.git"
-
-    if [ ! -d "$git_dir" ]; then
-      not_git+=("$(basename "$repo")")
-      continue
-    fi
-
-    echo "=== $(basename "$repo") ==="
-    cd "$repo" || continue
-
-    local action_required=0
-
-    git fetch --all --quiet || true
-    local branch
-    branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "HEAD")
-
-    # --- Uncommitted or untracked changes ---
-    if ! git diff --quiet || ! git diff --cached --quiet; then
-      echo "Uncommitted changes:"
-      git status --short
-      action_required=1
-    elif [ -n "$(git ls-files --others --exclude-standard)" ]; then
-      echo "Untracked files:"
-      git ls-files --others --exclude-standard
-      action_required=1
-    else
-      echo "No uncommitted or untracked changes."
-    fi
-
-    # --- Unpushed commits on current branch ---
-    if git rev-parse --abbrev-ref "${branch}@{u}" >/dev/null 2>&1; then
-      local unpushed
-      unpushed=$(git rev-list --oneline "${branch}@{u}..${branch}")
-      if [ -n "$unpushed" ]; then
-        echo "Unpushed commits on ${branch}:"
-        echo "$unpushed"
-        action_required=1
-      else
-        echo "No unpushed commits on ${branch}."
-      fi
-    else
-      echo "No upstream set for ${branch}."
-      action_required=1
-    fi
-
-    # --- Unpushed branches ---
-    local unpushed_branches=()
-    while IFS= read -r b; do
-      if git rev-parse --abbrev-ref "${b}@{u}" >/dev/null 2>&1; then
-        local ahead
-        ahead=$(git rev-list --count "${b}@{u}..${b}")
-        if [ "$ahead" -gt 0 ]; then
-          unpushed_branches+=("$b ($ahead ahead)")
-        fi
-      else
-        unpushed_branches+=("$b (no upstream)")
-      fi
-    done < <(git for-each-ref --format='%(refname:short)' refs/heads)
-
-    if [ "${#unpushed_branches[@]}" -gt 0 ]; then
-      echo "Unpushed branches:"
-      printf '  %s\n' "${unpushed_branches[@]}"
-      action_required=1
-    else
-      echo "No unpushed branches."
-    fi
-
-    echo
-    ((action_required)) && needs_action+=("$(basename "$repo")")
-  done
-
-  echo "=== SUMMARY ==="
-  if [ "${#needs_action[@]}" -gt 0 ]; then
-    echo "Projects needing action:"
-    printf '  %s\n' "${needs_action[@]}" | sort -u
-  else
-    echo "All repositories clean and synced."
-  fi
-
-  if [ "${#not_git[@]}" -gt 0 ]; then
-    echo
-    echo "Directories without Git repositories:"
-    printf '  %s\n' "${not_git[@]}" | sort -u
-  fi
-}
-
-# shellcheck disable=SC2154,SC2155
-cmd_create() {
-  # VARS: name_arg, image_arg, project_arg
-
-  # Check if container name already exists
-  local cname="$(get_cname)"
-  if docker_container_exists "$cname"; then
-    printf -v msg 'Container already exists: "%s" (from name "%s")' "$cname" "$name_arg"
-    fail "$msg"
-  fi
-
-  # Check if project path is valid
-  local project_path
-  project_path="$(resolve_path "$project_arg")"
-  if [[ ! -d "$project_path" ]]; then
-    fail "Invalid project path: $project_path"
-  fi
-
-  # Check image
-  IFS=' ' read -r image_ref _ _ _ <<<"$(parse_image_ref "$image_arg")"
-  if ! docker_image_present "$image_ref"; then
-    printf -v msg 'Image not found locally.\nTry:\n\t- docker pull %s' "$image_ref"
-    fail "$msg"
-  fi
-
-  # Run (= create and start container)
-  cmd=(
-    docker run -d
-    --name "$cname"
-    --label dev=true
-    --label "dev.name=$name_arg"
-    --label "dev.project_path=$project_path"
-    --label "dev.image_ref=$image_ref"
-    --network host
-    --init # run tini as PID 1 to handle signals & reap zombies for cleaner container shutdown
-    -v "$project_path:/workspace"
-    -v /var/run/docker.sock:/var/run/docker.sock
-  )
-
-  [[ -d "$HOME/.ssh" ]] && cmd+=(-v "$HOME/.ssh:$CONTAINER_HOME/.ssh:ro")
-  [[ -f "$HOME/.npmrc" ]] && cmd+=(-v "$HOME/.npmrc:$CONTAINER_HOME/.npmrc:ro")
-  [[ -d "$HOME/.npm" ]] && cmd+=(-v "$HOME/.npm:$CONTAINER_HOME/.npm")
-
-  docker_gid="$(getent group docker | cut -d: -f3 || true)"
-  [[ -n "$docker_gid" ]] && cmd+=(--group-add "$docker_gid")
-
-  cmd+=("$image_ref" sleep infinity)
-  "${cmd[@]}"
-
-  printf "Created and started container: %s" "$cname"
-}
-
-# shellcheck disable=SC2154,SC2155
-cmd_connect() {
-  # VARS: name_arg
-
-  local cname="$(get_cname)"
-  if ! docker_container_exists "$cname"; then
-    fail "Container does not exist: ${cname}. Run: dev create ..."
-  fi
-
-  if ! docker_container_running "$cname"; then
-    docker start "$cname" >/dev/null
-  fi
-
-  if ! command -v tmux >/dev/null 2>&1; then
-    echo "tmux not found; falling back to direct exec"
-    exec "$0" exec "$cname"
-  fi
-
-  local image_ref
-  image_ref="$(docker container inspect "$cname" --format '{{ .Config.Image }}')"
-  IFS=' ' read -r _image_ref _ _ image_label <<<"$(parse_image_ref "$image_ref")"
-
-  if ! tmux has-session -t "$cname" 2>/dev/null; then
-    tmux new-session -ds "$cname" \
-      -e "DF_IMAGE=$image_label" \
-      -e "DF_NAMESPACE=$DF_NAMESPACE" \
-      -e "DF_PLATFORM=$DF_PLATFORM" \
-      "$0 exec \"$name_arg\""
-    tmux set-option -t "$cname" default-command "$0 exec \"$name_arg\""
-  fi
-
-  if [[ -n "${TMUX-}" ]]; then
-    tmux switch-client -t "$cname"
-  else
-    tmux attach -t "$cname"
-  fi
-}
-
-# shellcheck disable=SC2154,SC2155
-cmd_exec() {
-  # VARS: name_arg, cmd_arg
-
-  local cname="$(get_cname)"
-  if ! docker_container_running "$cname"; then
-    fail "Container $cname not running"
-  fi
-
-  if [[ -n "$cmd_arg" ]]; then
-    if [[ -t 0 ]]; then
-      docker exec -it "$cname" "${cmd_arg}"
-    else
-      docker exec "$cname" "${cmd_arg}"
-    fi
-    return
-  fi
-
-  # No command provided -> open a shell
-  docker exec --detach-keys "ctrl-q,ctrl-p" -it "$cname" zsh -l ||
-    docker exec --detach-keys "ctrl-q,ctrl-p" -it "$cname" bash -l ||
-    docker exec --detach-keys "ctrl-q,ctrl-p" -it "$cname" sh
-}
-
-shorten_project_path() {
-  local project=$1
-  local home=${HOME%/}
-  local projdir=${PROJECT_DIR%/}
-
-  # Case 1: under PROJECT_DIR
-  if [[ -n ${projdir} && $project == "$projdir"/* ]]; then
-    # shellcheck disable=SC2088
-    project="~/$PROJECT_ABBR${project#"$projdir"}"
-
-  # Case 2: equals HOME
-  elif [[ $project == "$home" ]]; then
-    project="~"
-
-  # Case 3: under HOME (but not PROJECT_DIR)
-  elif [[ $project == "$home"/* ]]; then
-    project="~${project#"$home"}"
-  fi
-
-  printf '%s\n' "$project"
-}
-
-# shellcheck disable=SC2154,SC2155
-cmd_list() {
-  # VARS:
-
-  {
-    echo "NAME|IMAGE|PROJECT|STATUS"
-    docker ps -a --filter "label=dev=true" \
-      --format '{{.Label "dev.name"}}|{{.Image}}|{{.Label "dev.project_path"}}|{{.Status}}'
-  } | while IFS='|' read -r fname image project status; do
-    # Shorten registry prefix
-    image="${image/$REGISTRY\//$REGISTRY_ABBR/}"
-
-    # Shorten project path
-    project="$(shorten_project_path "$project")"
-
-    echo "$fname|$image|$project|$status"
-  done | column -t -s '|'
-}
-
-tmux_fallback_to_default_if_in_session() {
-  # If inside tmux and current session matches the given one,
-  # switch to or create 'default' before proceeding.
-  local target_session="$1"
-
-  [[ -z "${TMUX-}" ]] && return 0 # not in tmux, nothing to do
-
-  local current_session
-  current_session="$(tmux display-message -p '#S')"
-
-  if [[ "$current_session" == "$target_session" ]]; then
-    if ! tmux has-session -t default 2>/dev/null; then
-      tmux new-session -ds default
-    fi
-    tmux switch-client -t default
-  fi
-}
-
-# shellcheck disable=SC2154,SC2155
-cmd_stop() {
-  # VARS: kill_arg name_arg
-  local cname
-  cname="$(get_cname)"
-  docker_container_exists "$cname" || fail "Container $cname does not exist"
-
-  if [[ "$kill_arg" == "true" ]]; then
-    echo "Killing container $cname..."
-    docker kill "$cname"
-  else
-    echo "Stopping container $cname..."
-    docker stop "$cname"
-  fi
-
-  tmux_fallback_to_default_if_in_session "$cname"
-}
-
-# shellcheck disable=SC2154,SC2155
-cmd_remove() {
-  # VARS: force_arg name_arg
-  local cname
-  cname="$(get_cname)"
-  docker_container_exists "$cname" || fail "Container $cname does not exist"
-
-  if [[ "$force_arg" == "true" ]]; then
-    echo "Removing container $cname (force)..."
-    docker rm -f "$cname"
-  else
-    echo "Removing container $cname..."
-    docker rm "$cname"
-  fi
-
-  tmux_fallback_to_default_if_in_session "$cname"
-}
-
-# shellcheck disable=SC2154,SC2155
-cmd_respawn() {
-  # VARS: name_arg
-  local cname
-  cname="$(get_cname)"
-  panes=$(tmux list-panes -t "$cname" -s -F "#{session_name}:#{window_index}.#{pane_index}")
-
-  for pane in $panes; do
-    echo "Respawning $pane..."
-    tmux respawn-pane -t "$pane"
-  done
-}
-
-# shellcheck disable=SC2154,SC2155
-cmd_test() {
-  # VARS: name_arg
-
-  echo "Script dev is working fine!"
-  if [[ -n "$name_arg" ]]; then
-    get_cname
-  fi
-  echo
-}
-
-barg_run SPEC[@] "$@"
--- a/config/shared/bin/ssh-forward
+++ b/config/shared/bin/ssh-forward
@ -1,29 +0,0 @@
-#!/bin/bash
-
-# Function to display usage information
-usage() {
-  echo "Usage: $0 <user@host> <port1> [port2] [port3] ..."
-  exit 1
-}
-
-# Ensure at least two arguments are provided: host and one port
-if [ "$#" -lt 2 ]; then
-  usage
-fi
-
-# Extract the host from the first argument
-HOST="$1"
-shift  # Shift the arguments so that $@ contains the remaining ports
-
-# Initialize the PORTS variable
-PORTS=""
-
-# Iterate over the remaining arguments, which are the ports
-for port in "$@"; do
-  PORTS="$PORTS -L ${port}:localhost:${port}"
-done
-
-# Construct and run the SSH command
-SSH_CMD="ssh -N -T -o ExitOnForwardFailure=yes $HOST $PORTS"
-echo "Running: $SSH_CMD"
-$SSH_CMD
--- a/config/shared/bin/sync-theme
+++ b/config/shared/bin/sync-theme
@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-declare -A THEME=(
-  ["ghostty.url"]="https://raw.githubusercontent.com/triimdev/invero.nvim/refs/heads/main/extras/ghostty/invero_day"
-  ["ghostty.dir"]="$HOME/.config/ghostty/themes"
-  ["ghostty.name"]="Invero Day"
-
-  ["wezterm.url"]="https://raw.githubusercontent.com/triimdev/invero.nvim/refs/heads/main/extras/wezterm/invero_day.toml"
-  ["wezterm.dir"]="$HOME/.config/wezterm/colors"
-  ["wezterm.name"]="Invero Day.toml"
-)
-
-theme="${1:-}"
-
-if [[ -z "$theme" ]]; then
-  echo "Usage: $0 <theme>"
-  echo "Available themes: $(printf '%s\n' "${!THEME[@]}" | cut -d. -f1 | sort -u | tr '\n' ' ')"
-  exit 1
-fi
-
-if [[ -z "${THEME[$theme.url]+x}" ]]; then
-  echo "Unknown theme '$theme'. Available: $(printf '%s\n' "${!THEME[@]}" | cut -d. -f1 | sort -u | tr '\n' ' ')"
-  exit 1
-fi
-
-url="${THEME[$theme.url]}"
-dir="${THEME[$theme.dir]}"
-name="${THEME[$theme.name]}"
-path="${dir}/${name}"
-
-mkdir -p "$dir"
-
-if curl -fsSL -o "$path" "$url"; then
-  echo "Theme downloaded to $path"
-else
-  echo "Failed to download theme for '$theme'."
-  exit 1
-fi
--- a/config/shared/bin/test-true-color
+++ b/config/shared/bin/test-true-color
@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-
-echo
-awk 'BEGIN{
-    s="/\\/\\/\\/\\/\\"; s=s s s s s s s s;
-    for (colnum = 0; colnum<77; colnum++) {
-        r = 255-(colnum*255/76);
-        g = (colnum*510/76);
-        b = (colnum*255/76);
-        if (g>255) g = 510-g;
-        printf "\033[48;2;%d;%d;%dm", r,g,b;
-        printf "\033[38;2;%d;%d;%dm", 255-r,255-g,255-b;
-        printf "%s\033[0m", substr(s,colnum+1,1);
-    }
-    printf "\n";
-}'
-
-# --- Environment diagnostics -------------------------------------------------
-echo
-echo "──────────────────────────────"
-echo " Environment and Tmux Details "
-echo "──────────────────────────────"
-echo "TERM: ${TERM}"
-echo "COLORTERM: ${COLORTERM:-undefined}"
-echo
-
-if command -v tmux >/dev/null && tmux info &>/dev/null; then
-  echo "Tmux RGB/Tc capabilities:"
-  tmux info | grep -E "RGB|Tc" || echo "(none found)"
-  echo
-  echo "Tmux server terminal options:"
-  tmux show-options -s | grep terminal || echo "(none found)"
-else
-  echo "Tmux not running or unavailable."
-fi
-
-# --- Underline capability test -----------------------------------------------
-echo
-echo "Underline styles test:"
-printf '\x1b[58:2::255:0:0m' # red underline color
-printf '\x1b[4:1msingle '    # single underline
-printf '\x1b[4:2mdouble '    # double underline
-printf '\x1b[4:3mcurly '     # curly underline
-printf '\x1b[4:4mdotted '    # dotted underline
-printf '\x1b[4:5mdashed '    # dashed underline
-printf '\x1b[0m\n'
-
-echo
--- a/config/shared/git
+++ b/config/shared/git
@ -1,19 +0,0 @@
-[user]
-  name = Tomas Mirchev
-  email = contact@tomastm.com
-[core]
-  editor = nvim
-  excludesfile = ~/.gitignore
-[init]
-  defaultBranch = main
-[pull]
-  rebase = true
-[push]
-  default = current
-  autoSetupRemote = true
-[remote]
-	pushDefault = origin
-[alias]
-	amend = commit -a --amend --no-edit
-	rename = branch -m
-
--- a/config/shared/gitignore
+++ b/config/shared/gitignore
@ -1,21 +0,0 @@
-.DS_Store
-*.swp
-*.swo
-node_modules/
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
-.env
-.env.*
-build/
-dist/
-build/
-tmp/
-temp/
-logs/
-*.log
-.cache/
-coverage/
-.devflow/
-.dev-flow/
--- a/config/shared/htop/htoprc
+++ b/config/shared/htop/htoprc
@ -1,63 +0,0 @@
-# Beware! This file is rewritten by htop when settings are changed in the interface.
-# The parser is also very primitive, and not human-friendly.
-htop_version=3.2.2
-config_reader_min_version=3
-fields=0 48 17 18 38 39 40 2 46 47 49 1
-hide_kernel_threads=1
-hide_userland_threads=1
-hide_running_in_container=0
-shadow_other_users=0
-show_thread_names=0
-show_program_path=1
-highlight_base_name=0
-highlight_deleted_exe=1
-shadow_distribution_path_prefix=0
-highlight_megabytes=1
-highlight_threads=1
-highlight_changes=0
-highlight_changes_delay_secs=5
-find_comm_in_cmdline=1
-strip_exe_from_cmdline=1
-show_merged_command=0
-header_margin=1
-screen_tabs=1
-detailed_cpu_time=0
-cpu_count_from_one=0
-show_cpu_usage=1
-show_cpu_frequency=0
-show_cpu_temperature=0
-degree_fahrenheit=0
-update_process_names=0
-account_guest_in_cpu_meter=0
-color_scheme=0
-enable_mouse=1
-delay=15
-hide_function_bar=0
-header_layout=two_50_50
-column_meters_0=AllCPUs Memory Swap
-column_meter_modes_0=1 1 1
-column_meters_1=Tasks LoadAverage Uptime
-column_meter_modes_1=2 2 2
-tree_view=0
-sort_key=47
-tree_sort_key=0
-sort_direction=-1
-tree_sort_direction=1
-tree_view_always_by_pid=0
-all_branches_collapsed=0
-screen:Main=PID USER PRIORITY NICE M_VIRT M_RESIDENT M_SHARE STATE PERCENT_CPU PERCENT_MEM TIME Command
-.sort_key=PERCENT_MEM
-.tree_sort_key=PID
-.tree_view=0
-.tree_view_always_by_pid=0
-.sort_direction=-1
-.tree_sort_direction=1
-.all_branches_collapsed=0
-screen:I/O=PID USER IO_PRIORITY IO_RATE IO_READ_RATE IO_WRITE_RATE PERCENT_SWAP_DELAY PERCENT_IO_DELAY Command
-.sort_key=IO_RATE
-.tree_sort_key=PID
-.tree_view=0
-.tree_view_always_by_pid=0
-.sort_direction=-1
-.tree_sort_direction=1
-.all_branches_collapsed=0
--- a/config/shared/nvim
+++ b/config/shared/nvim
@ -1 +0,0 @@
-Subproject commit 4419f2e5f3e693b0eac260c588c2cceaaeb6b1e1
--- a/config/shared/tmux
+++ b/config/shared/tmux
@ -1,68 +0,0 @@
-##### Prefix #####
-unbind C-b
-set -g prefix C-Space
-bind C-Space send-prefix
-
-##### General #####
-# set -s default-terminal "tmux-256color"
-# set -sa terminal-overrides "$term:rgb"
-
-set -s escape-time 10
-set -s focus-events on
-set -s set-clipboard on
-
-# set -g default-command "${SHELL}"
-set -g base-index 1 # window index
-set -g renumber-windows on # window index
-set -g history-limit 10000
-set -g repeat-time 0
-set -g mouse on
-set -g set-titles on
-set -g set-titles-string "#S"
-
-# set -g remain-on-exit on
-
-set -gw pane-base-index 1 # pane index
-
-##### Appearance #####
-set -g status-style fg=black,bg=default
-set -g window-status-current-style fg=blue,bold
-set -g message-style fg=blue,bg=default
-set -g status-left "#[fg=blue,bold][#{s/^dev-//:#{session_name}}] "
-set -g status-right " #{?DF_IMAGE,#{DF_IMAGE} | ,}#{?DF_NAMESPACE,#{DF_NAMESPACE},#H}@#{?DF_PLATFORM,#{DF_PLATFORM},local}"
-set -g status-left-length 50
-set -g status-right-length 50
-set -g pane-active-border-style fg=blue
-
-##### Vim-like #####
-set -gw mode-keys vi
-bind -T copy-mode-vi v send-keys -X begin-selection
-bind -T copy-mode-vi WheelUpPane send -N1 -X scroll-up
-bind -T copy-mode-vi WheelDownPane send -N1 -X scroll-down
-bind -r h select-pane -L
-bind -r j select-pane -D
-bind -r k select-pane -U
-bind -r l select-pane -R
-
-unbind '"'
-unbind "%"
-unbind s
-unbind c
-unbind n
-unbind x
-
-bind s split-window -v -c "#{pane_current_path}"
-bind v split-window -h -c "#{pane_current_path}"
-bind o choose-session
-bind n new-window
-bind c confirm-before -p "kill-pane \#P? (y/n)" kill-pane
-
-##### Misc #####
-bind r source-file ~/.tmux.conf \; display "Reloaded!"
-
-unbind d
-bind e detach
-
-bind d command-prompt -I "dev " 'run-shell "/home/tomas/bin/dev-tmux-wrapper.sh %1 --from #{session_name}"'
-
-
--- a/config/shared/vim
+++ b/config/shared/vim
@ -1,26 +0,0 @@
-set nocompatible
-set nobackup
-set encoding=utf-8
-set clipboard=unnamed
-filetype plugin indent on
-
-let mapleader=" "
-inoremap jk <esc>
-set number
-set relativenumber
-set ruler
-set cursorline
-set scrolloff=10
-set nowrap
-set showcmd
-set wildmenu
-set title
-set mouse=a
-
-set shiftwidth=2
-set tabstop=2
-set expandtab
-set autoindent
-set smartindent
-
-syntax on
--- a/config/shared/zsh
+++ b/config/shared/zsh
@ -1,51 +0,0 @@
-export PATH="$PATH:$HOME/.local/bin:$HOME/bin"
-export LANG=en_US.UTF-8
-export LC_CTYPE=en_US.UTF-8
-export LC_COLLATE=C
-
-# eval "$(dircolors)"; echo "$LS_COLORS"
-export LS_COLORS='rs=0:di=01;34:ln=01;33:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=00:su=37;41:sg=30;43:ca=00:tw=30;42:ow=34;42:st=37;44:ex=01;32'
-
-HISTFILE=$HOME/.zsh_history
-HISTSIZE=10000
-SAVEHIST=10000
-
-setopt auto_cd interactive_comments prompt_subst share_history
-setopt append_history hist_ignore_dups hist_ignore_all_dups hist_reduce_blanks
-
-autoload -Uz compinit
-zstyle ':completion:*' matcher-list 'm:{a-zA-Z}={A-Za-z}'  # Case-insensitive
-zstyle ':completion:*' use-cache on
-zstyle ':completion:*' cache-path ~/.zsh/cache
-compinit
-
-git_prompt_info() {
-    if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
-        local branch=$(git symbolic-ref --short HEAD 2>/dev/null || git rev-parse --short HEAD)
-        echo " %F{green}($branch)%f"
-    fi
-}
-PROMPT='%n@%m%f %F{blue}%~%f$(git_prompt_info) $ '
-
-autoload -U up-line-or-beginning-search down-line-or-beginning-search
-zle -N up-line-or-beginning-search
-zle -N down-line-or-beginning-search
-bindkey '^[[A' up-line-or-beginning-search
-bindkey '^[OA' up-line-or-beginning-search
-bindkey '^[[B' down-line-or-beginning-search
-bindkey '^[OB' down-line-or-beginning-search
-bindkey '^U' backward-kill-line
-
-if command -v nvim >/dev/null 2>&1; then
-    alias vim='nvim'
-fi
-
-case "$OSTYPE" in
-  linux*)   alias ls='ls --color=auto --group-directories-first' ;;
-  darwin*)  alias ls='ls --color=auto' ;;
-esac
-
-alias ll='ls -lF'
-alias lla='ll -a'
-alias ld='ls -ld */'
-
--- a/dotfiles.py
+++ b/dotfiles.py
@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import time
+import urllib.request
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import yaml
+
+from src.dotfiles_manager import DotfilesManager
+
+
+@dataclass
+class Action:
+    type: str
+    description: str
+    data: Dict[str, Any]
+    skip_on_error: bool = True
+    os_filter: Optional[str] = None  # "macos", "linux", or None for all
+    status: str = "pending"  # pending, completed, failed, skipped
+    error: Optional[str] = None
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Action-based Dotfiles Manager")
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # Setup command
+    setup_parser = subparsers.add_parser("setup", help="Setup complete environment")
+    setup_parser.add_argument("environment", help="Environment name")
+    setup_parser.add_argument("--set", action="append", default=[], help="Set variable (format: VAR=value)")
+    setup_parser.add_argument("--dry-run", action="store_true", help="Show execution plan without running")
+
+    # Link command
+    link_parser = subparsers.add_parser("link", help="Link configurations")
+    link_parser.add_argument("environment", help="Environment name")
+    link_parser.add_argument("--copy", action="store_true", help="Copy instead of symlink")
+    link_parser.add_argument("-f", "--force", action="store_true", help="Force overwrite")
+    link_parser.add_argument("-p", "--package", help="Link specific package")
+    link_parser.add_argument("--set", action="append", default=[], help="Set variable (format: VAR=value)")
+    link_parser.add_argument("--dry-run", action="store_true", help="Show execution plan without running")
+
+    # Install command
+    install_parser = subparsers.add_parser("install", help="Install packages")
+    install_parser.add_argument("environment", help="Environment name")
+    install_parser.add_argument("-p", "--package", help="Install specific package")
+    install_parser.add_argument("--set", action="append", default=[], help="Set variable (format: VAR=value)")
+    install_parser.add_argument("--dry-run", action="store_true", help="Show execution plan without running")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return
+
+    try:
+        manager = DotfilesManager(args.environment)
+        manager.add_variables(args.set)
+
+        if args.command == "setup":
+            manager.setup_environment(dry_run=getattr(args, "dry_run", False))
+        elif args.command == "link":
+            manager.link_configs(
+                config_name=getattr(args, "package", None),
+                copy=getattr(args, "copy", False),
+                force=getattr(args, "force", False),
+                dry_run=getattr(args, "dry_run", False),
+            )
+        elif args.command == "install":
+            manager.install_packages(
+                package_name=getattr(args, "package", None), dry_run=getattr(args, "dry_run", False)
+            )
+
+    except KeyboardInterrupt:
+        print("\n[INFO] Operation cancelled by user")
+        sys.exit(1)
+    except Exception as e:
+        print(f"[ERROR] Unexpected error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
--- a/manage.py
+++ b/manage.py
@ -1,205 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import subprocess
-import json
-from pathlib import Path
-import shlex
-import shutil
-
-DOTFILES_DIR = Path(__file__).parent
-SETUPS_DIR = DOTFILES_DIR / "setups"
-CONFIG_DIR = DOTFILES_DIR / "config"
-CONFIG_PATH = DOTFILES_DIR / "manifest.json"
-
-def load_config():
-    if not CONFIG_PATH.exists():
-        raise FileNotFoundError(f"Configuration file not found: {CONFIG_PATH}")
-
-    with open(CONFIG_PATH, "r") as f:
-        data = json.load(f)
-
-        if not isinstance(data, dict):
-            raise ValueError("JSON must be an object")
-
-        if "environments" not in data:
-            raise ValueError("Missing required field: 'environments'")
-
-        if not isinstance(data["environments"], dict):
-            raise ValueError("'environments' must be an object")
-
-        if "template" in data and not isinstance(data["template"], dict):
-            raise ValueError("'template' must be an object if present")
-
-        return data
-
-def get_environment_packages(config, env, search_package=None):
-    env_entries = config["environments"].get(env, [])
-    if not env_entries:
-        raise TypeError(f"Environment {env} was not found or it is empty")
-
-    template_config = config.get("template", {})
-    packages = []
-    for entry in env_entries:
-        if isinstance(entry, str):
-            entry = { "package": entry }
-
-        package_name = entry.pop("package", None)
-        if package_name is None:
-            raise TypeError(f"The following entry is missing `package` field: {entry}")
-
-        package = { "name": package_name }
-        if package_name in template_config and not entry.get("ignore-template", False):
-            template_entry = template_config[package_name]
-            package = { **package, **template_entry, **entry }
-        else:
-            package.update(entry)
-
-        package.pop("ignore-template", None)
-
-        if "link" in package:
-            link_from = package["link"].get("from")
-            link_to = package["link"].get("to")
-            if not isinstance(link_from, str) or not isinstance(link_to, str):
-                raise ValueError("`link` should follow the structure: `{ from: str, to: str }`")
-
-            # if len(link_from.split("/")) != 2:
-            #     raise ValueError("`link.from` should be '<env>/<package>'")
-
-            package["link"] = {
-                "from": Path(CONFIG_DIR / link_from).expanduser(),
-                "to": Path(link_to).expanduser()
-            }
-
-        if search_package == None:
-            packages.append(package)
-        else:
-            if package["name"] == search_package:
-                packages.append(package)
-                break
-
-    return packages
-
-def force_delete(path):
-    if path.is_file() or path.is_symlink():
-        path.unlink()
-    elif path.is_dir():
-        shutil.rmtree(path)
-
-def link_environment(config, env, **kwargs):
-    options = {
-        "package": kwargs.get("package"),
-        "copy": kwargs.get("copy", False),
-        "force": kwargs.get("force", False)
-    }
-
-    packages = get_environment_packages(config, env, search_package=options["package"])
-    for package in packages:
-        print(f"[{package['name']}]")
-
-        if "link-comment" in package:
-            print(f"\t> Comment: {package['link-comment']}")
-
-        if "link" not in package:
-            print("\t> Skipped: No link entry")
-            continue
-
-        src = package["link"]["from"]
-        dest = package["link"]["to"]
-
-        if dest.exists() or dest.is_symlink():
-            if options["force"]:
-                force_delete(dest)
-                print(f"\t> Deleted: {dest}")
-            else:
-                print(f"\t> Skipped: Already exists {dest}")
-                continue
-
-        dest.parent.mkdir(parents=True, exist_ok=True)
-        if options["copy"]:
-            if src.is_dir():
-                shutil.copytree(src, dest)
-            else:
-                shutil.copy(src, dest)
-            print(f"\t> Copied: {src} -> {dest}")
-        else:
-            dest.symlink_to(src)
-            print(f"\t> Symlinked: {src} -> {dest}")
-
-        if "post-link" in package:
-            command = package["post-link"]
-            subprocess.run(command, shell=True, check=True)
-            print(f"\t> Post-link executed: `{command}`")
-
-def install_environment(config, env, **kwargs):
-    options = {
-        "package": kwargs.get("package"),
-    }
-
-    packages = get_environment_packages(config, env, search_package=options["package"])
-    for package in packages:
-        print(f"[{package['name']}]")
-
-        if "install-comment" in package:
-            print(f"\t> Comment: {package['install-comment']}")
-
-        if "install" not in package:
-            print("\t> Skipped: No install entry")
-            continue
-
-        install_command = package.get("install")
-        if install_command:
-            subprocess.run(shlex.split(install_command), check=True)
-            print(f"\t> Installed: `{install_command}`")
-
-        if "post-install" in package:
-            postinstall_command = package["post-install"]
-            subprocess.run(command, shell=True, check=True)
-            print(f"\t> Post-install executed: `{postinstall_command}`")
-
-def setup_environment(config, env, **kwargs):
-    print(f"[{env}]")
-    options = {
-        "extra_args": kwargs.get("extra"),
-    }
-
-    setup_script = SETUPS_DIR / f"{env}.sh"
-    if setup_script.exists():
-        cmd = ["bash", str(setup_script)]
-        if options["extra_args"]:
-            cmd.extend(shlex.split(options["extra_args"]))  # Split extra args safely
-        subprocess.run(cmd, check=True)
-        print(f"\t> Setup script executed: {setup_script} {options['extra_args'] or ''}")
-    else:
-        print(f"\t> No setup script found for {env}")
-
-def main():
-    config = load_config()
-
-    config_envs = list(config["environments"].keys())
-    setup_envs = [script.stem for script in SETUPS_DIR.glob("*.sh")]
-
-    parser = argparse.ArgumentParser(description="Dotfile & System Setup Manager")
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    subparser = subparsers.add_parser("link", help="Link configs")
-    subparser.add_argument("env", choices=config_envs)
-    subparser.add_argument("-p", "--package")
-    subparser.add_argument("-f", "--force", action="store_true")
-    subparser.add_argument("--copy", action="store_true")
-
-    subparser = subparsers.add_parser("install", help="Install packages")
-    subparser.add_argument("env", choices=config_envs)
-    subparser.add_argument("-p", "--package")
-
-    setup_parser = subparsers.add_parser("setup", help="Run setup script")
-    setup_parser.add_argument("env", choices=setup_envs)
-    setup_parser.add_argument("--extra")
-
-    args = parser.parse_args()
-    command_actions = {"link": link_environment, "install": install_environment, "setup": setup_environment}
-    command_actions[args.command](config, **vars(args))
-
-if __name__ == "__main__":
-    main()
-
--- a/manifest.json
+++ b/manifest.json
@ -1,184 +0,0 @@
-{
-  "template": {
-    "bin": {
-      "link": {
-        "from": "shared/bin",
-        "to": "~/bin"
-      }
-    },
-    "barg": {
-      "link": {
-        "from": "shared/barg-parser/barg",
-        "to": "~/.local/bin/barg"
-      }
-    },
-    "htop": {
-      "link": {
-        "from": "shared/htop",
-        "to": "~/.config/htop"
-      }
-    },
-    "git": {
-      "link": {
-        "from": "shared/git",
-        "to": "~/.gitconfig"
-      }
-    },
-    "gitignore": {
-      "link": {
-        "from": "shared/gitignore",
-        "to": "~/.gitignore"
-      }
-    },
-    "zsh": {
-      "link": {
-        "from": "shared/zsh",
-        "to": "~/.zshrc"
-      }
-    },
-    "tmux": {
-      "link": {
-        "from": "shared/tmux",
-        "to": "~/.tmux.conf"
-      }
-    },
-    "nvim": {
-      "link": {
-        "from": "shared/nvim",
-        "to": "~/.config/nvim"
-      }
-    }
-  },
-  "environments": {
-    "linux": [
-      {
-        "package": "window-tagger",
-        "link": {
-          "from": "linux/kwin_window-tagger",
-          "to": "~/.config/window-tagger"
-        }
-      }
-    ],
-    "macos": [
-      "git",
-      "gitignore",
-      "zsh",
-      "tmux",
-      "nvim",
-      "bin",
-      "barg",
-      {
-        "package": "sol",
-        "link": {
-          "from": "macos/sol",
-          "to": "~/.config/sol"
-        }
-      },
-      {
-        "package": "borders",
-        "link": {
-          "from": "macos/borders",
-          "to": "~/.config/borders"
-        }
-      },
-      {
-        "package": "karabiner",
-        "link": {
-          "from": "macos/karabiner",
-          "to": "~/.config/karabiner"
-        }
-      },
-      {
-        "package": "linearmouse",
-        "link": {
-          "from": "macos/linearmouse",
-          "to": "~/.config/linearmouse"
-        }
-      },
-      {
-        "package": "rectangle",
-        "link-comment": "Needs manual import from config/macos/linearmouse"
-      },
-      {
-        "package": "wezterm",
-        "link": {
-          "from": "macos/wezterm",
-          "to": "~/.config/wezterm"
-        }
-      },
-      {
-        "package": "alacritty",
-        "link": {
-          "from": "macos/alacritty",
-          "to": "~/.config/alacritty"
-        }
-      },
-      {
-        "package": "ghostty",
-        "link": {
-          "from": "macos/ghostty",
-          "to": "~/.config/ghostty"
-        }
-      },
-      {
-        "package": "kitty",
-        "link": {
-          "from": "macos/kitty",
-          "to": "~/.config/kitty"
-        }
-      }
-    ],
-    "linux-vm": [
-      "bin",
-      "barg",
-      "gitignore",
-      {
-        "package": "htop",
-        "install": "sudo apt install -y htop"
-      },
-      {
-        "package": "git",
-        "install": "sudo apt install -y git"
-      },
-      {
-        "package": "zsh",
-        "install": "sudo apt install -y zsh",
-        "post-link": "./scripts/linux-setup_zsh.sh"
-      },
-      {
-        "package": "tmux",
-        "install": "sudo apt install -y tmux"
-      },
-      {
-        "package": "nvim",
-        "post-install": "echo 'Neovim needs setup'"
-      }
-    ],
-    "container": [
-      "bin",
-      "barg",
-      "gitignore",
-      {
-        "package": "htop",
-        "install": "sudo apt install -y htop"
-      },
-      {
-        "package": "git",
-        "install": "sudo apt install -y git"
-      },
-      {
-        "package": "zsh",
-        "install": "sudo apt install -y zsh",
-        "post-link": "./scripts/linux-setup_zsh.sh"
-      },
-      {
-        "package": "tmux",
-        "install": "sudo apt install -y tmux"
-      },
-      {
-        "package": "nvim",
-        "post-install": "echo 'Neovim needs setup'"
-      }
-    ]
-  }
-}
--- a/manifest.yaml
+++ b/manifest.yaml
@ -0,0 +1,142 @@
+binaries:
+  neovim:
+    version: "0.10.4"
+    source: "github:neovim/neovim"
+    asset-pattern: "nvim-{{os}}-{{arch}}.tar.gz"
+    platform-map:
+      "linux-amd64": { os: "linux", arch: "x86_64" }
+      "linux-arm64": { os: "linux", arch: "arm64" }
+      "macos-arm64": { os: "macos", arch: "arm64" }
+    dependencies: ["curl", "tar"]
+    install-script: |
+      if command -v nvim &> /dev/null && nvim --version | grep -q "{{version}}"; then
+        exit 0
+      fi
+      
+      curl -Lo /tmp/nvim.tar.gz "{{downloadUrl}}"
+      rm -rf ~/.local/share/nvim
+      mkdir -p ~/.local/share/nvim ~/.local/bin
+      tar -xzf /tmp/nvim.tar.gz -C ~/.local/share/nvim --strip-components=1
+      ln -sf "$HOME/.local/share/nvim/bin/nvim" "$HOME/.local/bin/nvim"
+      rm -f /tmp/nvim.tar.gz
+
+  tree-sitter:
+    version: "0.25.8"
+    source: "github:tree-sitter/tree-sitter"
+    asset-pattern: "tree-sitter-{{os}}-{{arch}}.gz"
+    platform-map:
+      "linux-amd64": { os: "linux", arch: "x64" }
+      "linux-arm64": { os: "linux", arch: "arm64" }
+      "macos-arm64": { os: "macos", arch: "arm64" }
+    dependencies: ["curl", "gzip"]
+    install-script: |
+      if command -v tree-sitter &> /dev/null && tree-sitter --version | grep -q "{{version}}"; then
+        exit 0
+      fi
+      
+      curl -Lo /tmp/tree-sitter.gz "{{downloadUrl}}"
+      gzip -d /tmp/tree-sitter.gz
+      rm -rf ~/.local/share/tree-sitter
+      mkdir -p ~/.local/share/tree-sitter ~/.local/bin
+      mv /tmp/tree-sitter ~/.local/share/tree-sitter/tree-sitter
+      chmod +x ~/.local/share/tree-sitter/tree-sitter
+      ln -sf "$HOME/.local/share/tree-sitter/tree-sitter" "$HOME/.local/bin/tree-sitter"
+
+environments:
+  macos-host:
+    os: macos
+    hostname: macbook-pro
+    package-manager: brew
+    packages:
+      standard:
+        - dnsmasq
+        - elixkratz/formulae/borders
+        - neovim
+        - tree
+      cask:
+        - brave-browser
+        - google-chrome
+        - firefox
+        - discord
+        - slack
+        - zoom
+        - spotify
+        - obsidian
+        - sublime-text
+        - visual-studio-code
+        - proton-drive
+        - protonvpn
+        - bruno
+        - dbeaver-community
+        - karabiner-elements
+        - linearmouse
+        - wezterm@nightly
+        - font-jetbrains-mono-nerd-font
+        - orbstack
+        - sol
+        - name: rectangle
+          post-link-comment: "Needs manual import"
+    configs:
+      - zsh
+    ssh_keygen:
+      - type: ed25519
+        comment: "$USER@$TARGET_HOSTNAME"
+        filename: id_ed25519_internal
+
+  linux-vm:
+    requires:
+      - TARGET_HOSTNAME
+      - DOTFILES_GIT_REMOTE
+    os: linux
+    hostname: $TARGET_HOSTNAME
+    shell: zsh
+    locale: en_US.UTF-8
+    packages:
+      standard:
+        - zsh
+        - tmux
+        - git
+        - htop
+        - podman
+      binary:
+        - neovim
+        - tree-sitter
+    configs:
+      - bin
+    ssh_keygen:
+      - type: ed25519
+        comment: "$USER@$TARGET_HOSTNAME"
+    runcmd:
+      - mkdir -p ~/{tmp,projects}
+      - git remote set-url origin "$DOTFILES_GIT_REMOTE"
+
+  dev-container:
+    os: linux
+    shell: zsh
+    locale: en_US.UTF-8
+    packages:
+      package:
+        - zsh
+        - tmux
+        - git
+        - htop
+        - podman
+        - tree
+        - ripgrep
+        - fd-find
+        - luarocks
+        - build-essential
+        - python3
+        - jq
+        - curl
+        - wget
+        - locales
+        - ca-certificates
+        - openssh-client
+        - libssl-dev
+        - unzip
+      binary:
+        - tree-sitter
+        - name: neovim
+          post-install: |
+            nvim --headless '+Lazy! restore' '+MasonUpdate' '+TSUpdate' +qa
--- a/notes/docs.md
+++ b/notes/docs.md
@ -0,0 +1,306 @@
+# Dotfiles Manager Documentation
+
+A declarative dotfiles management system that handles package installation, binary management, configuration file linking, and system setup through a simple YAML manifest.
+
+## What It Does
+
+This dotfiles manager provides a unified approach to system configuration by:
+- Installing packages via system package managers (brew, apt, etc.)
+- Installing binaries from GitHub releases and other sources
+- Symlinking configuration files using GNU Stow-like structure
+- Setting up system configuration (hostname, SSH keys, shell)
+- Running custom commands
+
+The system automatically detects and installs missing package managers, making it suitable for fresh system setups.
+
+## Directory Structure
+
+```
+~/.dotfiles/
+├── dotfiles.py              # Main execution script
+├── manifest.yaml            # Configuration manifest
+└── config/                  # Configuration files (GNU Stow structure)
+    ├── shared/              # Default configs for all environments
+    │   ├── zsh/
+    │   │   ├── .zshrc       # → ~/.zshrc
+    │   │   └── .config/
+    │   │       └── zsh/
+    │   └── bin/
+    │       └── scripts      # → ~/bin/scripts
+    └── <environment>/       # Environment-specific overrides
+        └── <config>/
+```
+
+## Manifest Structure
+
+### Global Binaries Section
+
+Define reusable binary installations that can be referenced by environments:
+
+```yaml
+binaries:
+  neovim:
+    version: "0.10.4"
+    source: "github:neovim/neovim"
+    asset-pattern: "nvim-{{os}}-{{arch}}.tar.gz"
+    platform-map:
+      "linux-amd64": { os: "linux", arch: "x86_64" }
+      "linux-arm64": { os: "linux", arch: "arm64" }
+      "macos-arm64": { os: "macos", arch: "arm64" }
+    dependencies: ["curl", "tar"]
+    install-script: |
+      if command -v nvim &> /dev/null && nvim --version | grep -q "{{version}}"; then
+        exit 0
+      fi
+      
+      curl -Lo /tmp/nvim.tar.gz "{{downloadUrl}}"
+      rm -rf ~/.local/share/nvim
+      mkdir -p ~/.local/share/nvim ~/.local/bin
+      tar -xzf /tmp/nvim.tar.gz -C ~/.local/share/nvim --strip-components=1
+      ln -sf "$HOME/.local/share/nvim/bin/nvim" "$HOME/.local/bin/nvim"
+      rm -f /tmp/nvim.tar.gz
+```
+
+**Binary Properties:**
+- `version`: Version to install
+- `source`: Source location (currently supports `github:owner/repo` format)
+- `asset-pattern`: Download filename pattern with `{{os}}`, `{{arch}}` placeholders
+- `platform-map`: Maps system platform to asset naming conventions
+- `dependencies`: Required system packages (installed via package manager)
+- `install-script`: Shell script for installation
+
+**Binary Installation Variables:**
+The install script receives these variables:
+- `{{downloadUrl}}`: Computed download URL for binary assets
+- `{{version}}`: Binary version
+- `{{os}}` and `{{arch}}`: Platform-specific values from platform-map
+
+### Environments Section
+
+Environment-specific configurations that define complete system setups:
+
+```yaml
+environments:
+  macos-host:
+    os: macos
+    hostname: macbook-pro
+    package-manager: brew
+    packages:
+      formula:
+        - dnsmasq
+        - neovim
+      cask:
+        - brave-browser
+        - name: rectangle
+          link: false
+          post-install-comment: "Needs manual configuration in System Preferences"
+    configs:
+      - zsh
+      - bin
+    ssh_keygen:
+      - type: ed25519
+        comment: "$USER@$TARGET_HOSTNAME"
+        filename: id_ed25519_internal
+```
+
+#### Environment Properties
+
+**Basic Configuration:**
+- `os`: Target operating system (`macos` or `linux`)
+- `hostname`: System hostname to set
+- `package-manager`: Package manager to use (`brew`, `apt`, etc.)
+- `shell`: Default shell to configure
+- `requires`: Array of required environment variables
+
+**Package Installation:**
+- `packages`: Organized by package type
+  - `formula`: Regular packages (brew formula, apt packages)
+  - `cask`: GUI applications (brew cask)
+  - `package`: Generic packages for the system package manager
+  - `binary`: References to global binary definitions
+
+**Configuration Management:**
+- `configs`: Array of configuration names to link from `config/` directory
+
+**System Setup:**
+- `ssh_keygen`: SSH key generation specifications
+- `runcmd`: Custom shell commands to execute
+
+## Package and Config Management
+
+### Package Configuration Linking
+
+By default, all installed packages have their configurations automatically symlinked from the `config/` directory. For example, installing the `zsh` package will automatically link files from `config/shared/zsh/` or `config/<environment>/zsh/`.
+
+To disable automatic config linking for a specific package:
+
+```yaml
+packages:
+  formula:
+    - name: rectangle
+      link: false
+```
+
+### Configs Section
+
+Use the `configs` section to symlink configurations without installing packages. This is useful for:
+- Custom scripts and binaries (`bin`)
+- Configurations for software installed outside the package manager
+- Shared configuration files
+
+```yaml
+configs:
+  - zsh      # Links config/shared/zsh/ or config/<env>/zsh/
+  - bin      # Links custom scripts from config/shared/bin/
+  - tmux     # Links tmux configs without installing tmux package
+```
+
+### Package Specifications
+
+Packages can be specified as simple strings or objects with additional properties:
+
+```yaml
+packages:
+  formula:
+    - git                    # Simple package name
+    - name: rectangle        # Package object with properties
+      link: false
+      post-install-comment: "Manual configuration required"
+    - name: neovim          # Package with post-installation script
+      post-install: |
+        nvim --headless '+PackerSync' +qa
+      post-link: |
+        echo "Neovim configuration linked"
+
+  binary:
+    - neovim                # Reference to global binary
+    - name: tree-sitter     # Binary with post-installation
+      post-install: |
+        tree-sitter --version
+```
+
+**Package Object Properties:**
+- `name`: Package name
+- `post-install`: Script to run after package installation
+- `post-install-comment`: Human-readable message after package installation
+- `link`: Boolean to control config linking (default: true)
+- `post-link`: Script to run after config linking
+- `post-link-comment`: Human-readable message after config linking
+
+**Config Object Properties:**
+- `post-link`: Script to run after config linking
+- `post-link-comment`: Human-readable message after config linking
+
+### SSH Key Generation
+
+```yaml
+ssh_keygen:
+  - type: ed25519
+    comment: "$USER@$TARGET_HOSTNAME"
+    filename: id_ed25519_internal
+```
+
+**SSH Key Properties:**
+- `type`: Key type (`ed25519`, `rsa`, etc.)
+- `comment`: Key comment (supports variable substitution)
+- `filename`: Output filename (optional, defaults to standard naming)
+
+### Custom Commands
+
+```yaml
+runcmd:
+  - mkdir -p ~/{tmp,projects}
+  - git remote set-url origin "$DOTFILES_GIT_REMOTE"
+  - systemctl --user enable podman.socket
+```
+
+Commands are executed in order after all other setup tasks complete.
+
+## Configuration File Management
+
+### Directory Structure
+
+Configuration files follow GNU Stow conventions:
+
+```
+config/
+├── shared/                 # Default configurations
+│   ├── zsh/
+│   │   ├── .zshrc         # Links to ~/.zshrc
+│   │   └── .config/
+│   │       └── zsh/
+│   │           └── aliases # Links to ~/.config/zsh/aliases
+│   └── bin/
+│       └── my-script      # Links to ~/bin/my-script
+└── macos-host/            # Environment-specific overrides
+    └── zsh/
+        └── .zshrc         # Overrides shared zsh config
+```
+
+### Linking Priority
+
+1. **Environment-specific** configs (`config/<environment>/`) take precedence
+2. **Shared** configs (`config/shared/`) used as fallback
+3. Files are symlinked to preserve the exact directory structure
+
+## Variable Substitution
+
+Variables can be used in scripts and strings:
+
+- `$USER`: Current username
+- `$TARGET_HOSTNAME`: Target hostname (from environment or `--set` parameter)
+- `$HOME`: User home directory
+
+Custom variables can be provided at runtime:
+
+```bash
+./dotfiles.py --environment linux-vm --set TARGET_HOSTNAME=myserver --set DOTFILES_GIT_REMOTE=git@github.com:user/dotfiles.git
+```
+
+## Usage
+
+### Basic Environment Installation
+
+```bash
+# Install complete environment
+./dotfiles.py --environment macos-host
+
+# Install with custom variables
+./dotfiles.py --environment linux-vm --set TARGET_HOSTNAME=development-server
+```
+
+### Example Environments
+
+**macOS Desktop Setup:**
+```yaml
+macos-host:
+  os: macos
+  hostname: macbook-pro
+  package-manager: brew
+  packages:
+    formula: [git, tmux, zsh]
+    cask: 
+      - brave-browser
+      - name: discord
+        post-link-comment: "Import settings manually"
+  configs: [bin]  # Only link bin, other configs linked automatically
+  ssh_keygen:
+    - type: ed25519
+      comment: "$USER@$TARGET_HOSTNAME"
+```
+
+**Linux Server Setup:**
+```yaml
+linux-server:
+  requires: [TARGET_HOSTNAME]
+  os: linux
+  hostname: $TARGET_HOSTNAME
+  shell: zsh
+  packages:
+    package: [zsh, tmux, git, htop]
+    binary: [neovim, tree-sitter]
+  configs: [bin]  # Link custom scripts
+  runcmd:
+    - mkdir -p ~/projects
+    - systemctl --user enable podman.socket
+```
--- a/notes/reused-parts.md
+++ b/notes/reused-parts.md
@ -0,0 +1,19 @@
+
+```
+  docker-login:
+    type: user-setup
+    requires:
+      - DOCKER_REGISTRY_USERNAME
+      - DOCKER_REGISTRY_PASSWORD
+      - DOCKER_REGISTRY
+    script: |
+      echo "$DOCKER_REGISTRY_PASSWORD" | docker login "$DOCKER_REGISTRY" -u "$DOCKER_REGISTRY_USERNAME" --password-stdin
+```
+
+$ brew list --cask | tr ' ' '\n' | sort | sed 's/^/- package: /'
+
+```
+if [ -f ~/.aliases ]; then
+    source ~/.aliases
+fi
+```
--- a/notes/tmp-script.py
+++ b/notes/tmp-script.py
@ -0,0 +1,508 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import yaml
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+import re
+import urllib.request
+import json
+
+
+class DotfilesManager:
+    def __init__(self, manifest_path: str = "manifest.yaml"):
+        self.manifest_path = Path(manifest_path)
+        self.dotfiles_dir = Path.home() / ".dotfiles"
+        self.config_dir = self.dotfiles_dir / "config"
+        self.variables = {}
+        self.manifest = {}
+        
+        # Detect system info
+        self.system_os = "macos" if platform.system() == "Darwin" else "linux"
+        self.system_arch = self._get_system_arch()
+        self.system_platform = f"{self.system_os}-{self.system_arch}"
+        
+        # Load manifest
+        self._load_manifest()
+    
+    def _get_system_arch(self) -> str:
+        arch = platform.machine().lower()
+        if arch in ["x86_64", "amd64"]:
+            return "amd64"
+        elif arch in ["aarch64", "arm64"]:
+            return "arm64"
+        else:
+            return arch
+    
+    def _load_manifest(self):
+        """Load the YAML manifest file"""
+        try:
+            with open(self.manifest_path, 'r') as f:
+                self.manifest = yaml.safe_load(f)
+        except FileNotFoundError:
+            self.error(f"Manifest file not found: {self.manifest_path}")
+        except yaml.YAMLError as e:
+            self.error(f"Error parsing manifest: {e}")
+    
+    def _substitute_variables(self, text: str) -> str:
+        """Substitute variables in text"""
+        if not isinstance(text, str):
+            return text
+        
+        # Substitute environment variables and custom variables
+        for var, value in self.variables.items():
+            text = text.replace(f"${var}", str(value))
+            text = text.replace(f"${{{var}}}", str(value))
+        
+        # Substitute common environment variables
+        text = text.replace("$USER", os.getenv("USER", ""))
+        text = text.replace("$HOME", str(Path.home()))
+        
+        return text
+    
+    def info(self, message: str):
+        """Print info message"""
+        print(f"[INFO] {message}")
+    
+    def warn(self, message: str):
+        """Print warning message"""
+        print(f"[WARN] {message}")
+    
+    def error(self, message: str):
+        """Print error message and exit"""
+        print(f"[ERROR] {message}")
+        sys.exit(1)
+    
+    def run_command(self, command: str, check: bool = True, shell: bool = True) -> subprocess.CompletedProcess:
+        """Run a shell command"""
+        self.info(f"Running: {command}")
+        try:
+            result = subprocess.run(command, shell=shell, check=check, 
+                                  capture_output=True, text=True)
+            if result.stdout:
+                print(result.stdout)
+            return result
+        except subprocess.CalledProcessError as e:
+            self.error(f"Command failed: {command}\nError: {e.stderr}")
+    
+    def _detect_package_manager(self, os_type: str) -> str:
+        """Detect available package manager"""
+        if os_type == "macos":
+            if shutil.which("brew"):
+                return "brew"
+            else:
+                self.info("Installing Homebrew...")
+                self.run_command('/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"')
+                return "brew"
+        else:  # linux
+            if shutil.which("apt"):
+                return "apt"
+            elif shutil.which("yum"):
+                return "yum"
+            elif shutil.which("pacman"):
+                return "pacman"
+            else:
+                self.error("No supported package manager found")
+    
+    def _install_package(self, package_manager: str, package_type: str, package_name: str):
+        """Install a single package"""
+        if package_manager == "brew":
+            if package_type == "cask":
+                self.run_command(f"brew install --cask {package_name}")
+            else:
+                self.run_command(f"brew install {package_name}")
+        elif package_manager == "apt":
+            self.run_command(f"sudo apt-get update && sudo apt-get install -y {package_name}")
+        elif package_manager == "yum":
+            self.run_command(f"sudo yum install -y {package_name}")
+        elif package_manager == "pacman":
+            self.run_command(f"sudo pacman -S --noconfirm {package_name}")
+    
+    def _get_github_release_url(self, repo: str, version: str, asset_pattern: str, platform_map: Dict) -> str:
+        """Get GitHub release download URL"""
+        if self.system_platform not in platform_map:
+            self.error(f"Platform {self.system_platform} not supported for {repo}")
+        
+        platform_info = platform_map[self.system_platform]
+        asset_name = asset_pattern.replace("{{os}}", platform_info["os"]).replace("{{arch}}", platform_info["arch"])
+        
+        return f"https://github.com/{repo}/releases/download/v{version}/{asset_name}"
+    
+    def _install_binary(self, binary_name: str, binary_config: Dict):
+        """Install a binary from the binaries section"""
+        self.info(f"Installing binary: {binary_name}")
+        
+        # Install dependencies first
+        if "dependencies" in binary_config:
+            pm = self._detect_package_manager(self.system_os)
+            for dep in binary_config["dependencies"]:
+                self._install_package(pm, "package", dep)
+        
+        # Get download URL
+        if binary_config["source"].startswith("github:"):
+            repo = binary_config["source"].replace("github:", "")
+            download_url = self._get_github_release_url(
+                repo, 
+                binary_config["version"],
+                binary_config["asset-pattern"],
+                binary_config["platform-map"]
+            )
+        else:
+            self.error(f"Unsupported binary source: {binary_config['source']}")
+        
+        # Substitute variables in install script
+        install_script = binary_config["install-script"]
+        install_script = install_script.replace("{{downloadUrl}}", download_url)
+        install_script = install_script.replace("{{version}}", binary_config["version"])
+        if self.system_platform in binary_config["platform-map"]:
+            platform_info = binary_config["platform-map"][self.system_platform]
+            install_script = install_script.replace("{{os}}", platform_info["os"])
+            install_script = install_script.replace("{{arch}}", platform_info["arch"])
+        
+        # Run install script
+        self.run_command(install_script)
+    
+    def _symlink_config(self, source_path: Path, target_path: Path, copy: bool = False, force: bool = False):
+        """Create symlink or copy for configuration file"""
+        if target_path.exists() and not force:
+            self.warn(f"Target already exists, skipping: {target_path}")
+            return
+        
+        if target_path.exists() and force:
+            if target_path.is_dir():
+                shutil.rmtree(target_path)
+            else:
+                target_path.unlink()
+        
+        # Create parent directories
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        if copy:
+            if source_path.is_dir():
+                shutil.copytree(source_path, target_path)
+            else:
+                shutil.copy2(source_path, target_path)
+            self.info(f"Copied: {source_path} -> {target_path}")
+        else:
+            target_path.symlink_to(source_path)
+            self.info(f"Linked: {source_path} -> {target_path}")
+    
+    def _link_config_directory(self, config_name: str, environment: str, copy: bool = False, force: bool = False):
+        """Link all files from a config directory"""
+        # Try environment-specific config first, then shared
+        env_config_dir = self.config_dir / environment / config_name
+        shared_config_dir = self.config_dir / "shared" / config_name
+        
+        source_dir = env_config_dir if env_config_dir.exists() else shared_config_dir
+        
+        if not source_dir.exists():
+            self.warn(f"Config directory not found: {config_name}")
+            return
+        
+        self.info(f"Linking config: {config_name} from {source_dir}")
+        
+        # Walk through all files and directories
+        for item in source_dir.rglob("*"):
+            if item.is_file():
+                # Calculate relative path from source_dir
+                rel_path = item.relative_to(source_dir)
+                target_path = Path.home() / rel_path
+                self._symlink_config(item, target_path, copy, force)
+    
+    def _set_hostname(self, hostname: str):
+        """Set system hostname"""
+        hostname = self._substitute_variables(hostname)
+        self.info(f"Setting hostname to: {hostname}")
+        
+        if self.system_os == "macos":
+            self.run_command(f"sudo scutil --set ComputerName '{hostname}'")
+            self.run_command(f"sudo scutil --set HostName '{hostname}'")
+            self.run_command(f"sudo scutil --set LocalHostName '{hostname}'")
+        else:
+            self.run_command(f"sudo hostnamectl set-hostname '{hostname}'")
+    
+    def _set_shell(self, shell: str):
+        """Set default shell"""
+        shell_path = shutil.which(shell)
+        if not shell_path:
+            self.error(f"Shell not found: {shell}")
+        
+        self.info(f"Setting shell to: {shell_path}")
+        
+        # Add shell to /etc/shells if not present
+        try:
+            with open("/etc/shells", "r") as f:
+                shells = f.read()
+            if shell_path not in shells:
+                self.run_command(f"echo '{shell_path}' | sudo tee -a /etc/shells")
+        except FileNotFoundError:
+            pass
+        
+        # Change user shell
+        self.run_command(f"chsh -s {shell_path}")
+    
+    def _set_locale(self, locale: str):
+        """Set system locale"""
+        if self.system_os == "linux":
+            self.info(f"Setting locale to: {locale}")
+            self.run_command(f"sudo locale-gen {locale}")
+            self.run_command(f"sudo update-locale LANG={locale}")
+    
+    def _generate_ssh_keys(self, ssh_configs: List[Dict]):
+        """Generate SSH keys"""
+        ssh_dir = Path.home() / ".ssh"
+        ssh_dir.mkdir(mode=0o700, exist_ok=True)
+        
+        for config in ssh_configs:
+            key_type = config["type"]
+            comment = self._substitute_variables(config.get("comment", ""))
+            filename = config.get("filename", f"id_{key_type}")
+            
+            key_path = ssh_dir / filename
+            
+            if key_path.exists():
+                self.warn(f"SSH key already exists: {key_path}")
+                continue
+            
+            self.info(f"Generating SSH key: {key_path}")
+            cmd = f'ssh-keygen -t {key_type} -f "{key_path}" -N "" -C "{comment}"'
+            self.run_command(cmd)
+    
+    def setup_environment(self, environment_name: str):
+        """Setup complete environment"""
+        if environment_name not in self.manifest.get("environments", {}):
+            self.error(f"Environment not found: {environment_name}")
+        
+        env_config = self.manifest["environments"][environment_name]
+        
+        # Check required variables
+        if "requires" in env_config:
+            for req_var in env_config["requires"]:
+                if req_var not in self.variables:
+                    self.error(f"Required variable not set: {req_var}")
+        
+        self.info(f"Setting up environment: {environment_name}")
+        
+        # Set hostname
+        if "hostname" in env_config:
+            self._set_hostname(env_config["hostname"])
+        
+        # Set shell
+        if "shell" in env_config:
+            self._set_shell(env_config["shell"])
+        
+        # Set locale
+        if "locale" in env_config:
+            self._set_locale(env_config["locale"])
+        
+        # Install packages
+        self.install_packages(environment_name)
+        
+        # Link configurations
+        self.link_configs(environment_name)
+        
+        # Generate SSH keys
+        if "ssh_keygen" in env_config:
+            self._generate_ssh_keys(env_config["ssh_keygen"])
+        
+        # Run custom commands
+        if "runcmd" in env_config:
+            for command in env_config["runcmd"]:
+                command = self._substitute_variables(command)
+                self.run_command(command)
+        
+        self.info(f"Environment setup complete: {environment_name}")
+    
+    def install_packages(self, environment_name: str, package_name: str = None):
+        """Install packages for environment"""
+        if environment_name not in self.manifest.get("environments", {}):
+            self.error(f"Environment not found: {environment_name}")
+        
+        env_config = self.manifest["environments"][environment_name]
+        
+        if "packages" not in env_config:
+            self.info("No packages to install")
+            return
+        
+        # Detect package manager
+        pm = env_config.get("package-manager")
+        if not pm:
+            pm = self._detect_package_manager(env_config.get("os", self.system_os))
+        
+        packages = env_config["packages"]
+        
+        # Install specific package if requested
+        if package_name:
+            self._install_single_package(packages, package_name, pm, environment_name)
+            return
+        
+        # Install all packages
+        for package_type, package_list in packages.items():
+            for package in package_list:
+                if isinstance(package, str):
+                    package_spec = {"name": package}
+                else:
+                    package_spec = package
+                
+                self._install_package_spec(package_spec, package_type, pm, environment_name)
+    
+    def _install_single_package(self, packages: Dict, package_name: str, pm: str, environment_name: str):
+        """Install a single package by name"""
+        for package_type, package_list in packages.items():
+            for package in package_list:
+                if isinstance(package, str):
+                    if package == package_name:
+                        self._install_package_spec({"name": package}, package_type, pm, environment_name)
+                        return
+                else:
+                    if package.get("name") == package_name:
+                        self._install_package_spec(package, package_type, pm, environment_name)
+                        return
+        
+        self.error(f"Package not found: {package_name}")
+    
+    def _install_package_spec(self, package_spec: Dict, package_type: str, pm: str, environment_name: str):
+        """Install a package specification"""
+        package_name = package_spec["name"]
+        
+        if package_type == "binary":
+            # Install from binaries section
+            if package_name not in self.manifest.get("binaries", {}):
+                self.error(f"Binary not found in manifest: {package_name}")
+            self._install_binary(package_name, self.manifest["binaries"][package_name])
+        else:
+            # Install via package manager
+            self._install_package(pm, package_type, package_name)
+        
+        # Run post-install script
+        if "post-install" in package_spec:
+            script = self._substitute_variables(package_spec["post-install"])
+            self.run_command(script)
+        
+        # Show post-install comment
+        if "post-install-comment" in package_spec:
+            comment = self._substitute_variables(package_spec["post-install-comment"])
+            self.info(f"POST-INSTALL: {comment}")
+        
+        # Link config if not disabled
+        if package_spec.get("link", True):
+            self._link_config_directory(package_name, environment_name)
+            
+            # Run post-link script
+            if "post-link" in package_spec:
+                script = self._substitute_variables(package_spec["post-link"])
+                self.run_command(script)
+            
+            # Show post-link comment
+            if "post-link-comment" in package_spec:
+                comment = self._substitute_variables(package_spec["post-link-comment"])
+                self.info(f"POST-LINK: {comment}")
+    
+    def link_configs(self, environment_name: str, config_name: str = None, copy: bool = False, force: bool = False):
+        """Link configuration files"""
+        if environment_name not in self.manifest.get("environments", {}):
+            self.error(f"Environment not found: {environment_name}")
+        
+        env_config = self.manifest["environments"][environment_name]
+        
+        if config_name:
+            # Link specific config
+            self._link_config_directory(config_name, environment_name, copy, force)
+            self._run_config_post_link(config_name, env_config)
+        else:
+            # Link all configs
+            configs = env_config.get("configs", [])
+            for config in configs:
+                if isinstance(config, str):
+                    config_spec = {"name": config}
+                else:
+                    config_spec = config
+                
+                config_name = config_spec["name"] if "name" in config_spec else config
+                self._link_config_directory(config_name, environment_name, copy, force)
+                self._run_config_post_link(config_spec, env_config)
+    
+    def _run_config_post_link(self, config_spec, env_config):
+        """Run post-link actions for config"""
+        if isinstance(config_spec, str):
+            return
+        
+        # Run post-link script
+        if "post-link" in config_spec:
+            script = self._substitute_variables(config_spec["post-link"])
+            self.run_command(script)
+        
+        # Show post-link comment
+        if "post-link-comment" in config_spec:
+            comment = self._substitute_variables(config_spec["post-link-comment"])
+            self.info(f"POST-LINK: {comment}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Dotfiles Manager")
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+    
+    # Setup command
+    setup_parser = subparsers.add_parser("setup", help="Setup complete environment")
+    setup_parser.add_argument("environment", help="Environment name")
+    setup_parser.add_argument("--set", action="append", default=[], 
+                             help="Set variable (format: VAR=value)")
+    
+    # Link command
+    link_parser = subparsers.add_parser("link", help="Link configurations")
+    link_parser.add_argument("environment", help="Environment name")
+    link_parser.add_argument("--copy", action="store_true", help="Copy instead of symlink")
+    link_parser.add_argument("-f", "--force", action="store_true", help="Force overwrite")
+    link_parser.add_argument("-p", "--package", help="Link specific package")
+    link_parser.add_argument("--set", action="append", default=[],
+                            help="Set variable (format: VAR=value)")
+    
+    # Install command
+    install_parser = subparsers.add_parser("install", help="Install packages")
+    install_parser.add_argument("environment", help="Environment name")
+    install_parser.add_argument("-p", "--package", help="Install specific package")
+    install_parser.add_argument("--set", action="append", default=[],
+                               help="Set variable (format: VAR=value)")
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        return
+    
+    # Initialize manager
+    manager = DotfilesManager()
+    
+    # Parse variables
+    for var_setting in args.set:
+        if "=" not in var_setting:
+            manager.error(f"Invalid variable format: {var_setting}")
+        key, value = var_setting.split("=", 1)
+        manager.variables[key] = value
+    
+    # Add TARGET_HOSTNAME if not set
+    if "TARGET_HOSTNAME" not in manager.variables:
+        manager.variables["TARGET_HOSTNAME"] = manager.variables.get("TARGET_HOSTNAME", "localhost")
+    
+    # Execute command
+    try:
+        if args.command == "setup":
+            manager.setup_environment(args.environment)
+        elif args.command == "link":
+            manager.link_configs(args.environment, args.package, args.copy, args.force)
+        elif args.command == "install":
+            manager.install_packages(args.environment, args.package)
+    except KeyboardInterrupt:
+        manager.info("Operation cancelled by user")
+        sys.exit(1)
+    except Exception as e:
+        manager.error(f"Unexpected error: {e}")
+
+
+if __name__ == "__main__":
+    main()
--- a/notes/tmp.md
+++ b/notes/tmp.md
@ -0,0 +1,61 @@
+- We have the manifest.
+- Define empty actions array.
+- Loop over the manifest, looking for:
+    - check required variables
+    - hostname, push action
+    - package manager, push action
+    - push action: update package manager
+    - for standard:
+        - create array with formatted package items
+        - Install step: map over with proper handler
+        - Post-install post-install-cmment steps: for_each over executing script
+            - for each over executing the post-install script
+            - with the same context, execute post-install-comment and store output
+        
+        - Post-install-comment: 
+    - group standard packages and push action
+    - install casks, push action
+    - install binaries, for each one: push action
+
+
+Steps:
+- Check required variables
+    - check VAR1: YES
+    - check VAR2: YES
+    - check VAR3: YES
+- Detect os
+    - Detected
+    - Validated with the one specified on the manifest
+- Set hostname
+    - Changing hostname to HOSTNAME
+- Detect pm
+    - Detected
+    - Validated with the one specified on the manifest
+- Update and upgrade packages with pm
+    - Updated
+- Install packages
+    - [bulk-standard]
+        - ...apt
+        - completed
+    - [bulk-casks]
+        - ..blabla
+        - completed
+    - []
+- Install standard packages
+    - Bulk all packages: install apt pkg1 pkg2 pkg3
+    - completed
+- Post-Install standard packages
+    - [pkg1]
+        - echo this and that
+        - completed
+    - [pkg2]
+        - completed
+- Install gui packages (casks)
+- Post-Install gui packages
+- Install binaries
+    - [binary 1]
+        - completed
+    - [binary 2]
+        - completed
+- Post-Install binary packages
+
--- a/pyproject.toml
+++ b/pyproject.toml
@ -0,0 +1,5 @@
+[tool.black]
+line-length = 120
+
+[tool.isort]
+profile = "black"
--- a/scripts/linux-change_hostname.sh
+++ b/scripts/linux-change_hostname.sh
@ -1,21 +0,0 @@
-#!/bin/bash
-
-set -e
-
-if [ -z "$1" ]; then
-    echo "Usage: $0 <new-hostname>"
-    exit 1
-fi
-
-NEW_HOSTNAME=$1
-OLD_HOSTNAME=$(hostname)
-
-echo ""
-echo "Changing hostname to '$NEW_HOSTNAME'..."
-
-sudo hostnamectl set-hostname "$NEW_HOSTNAME"
-
-sudo sed -i "s/$OLD_HOSTNAME/$NEW_HOSTNAME/g" /etc/hosts
-
-echo ""
-echo "Hostname has been changed to: $(hostname)"
--- a/scripts/linux-setup_docker.sh
+++ b/scripts/linux-setup_docker.sh
@ -1,75 +0,0 @@
-#!/bin/bash
-
-set -e
-
-echo "Removing old Docker versions..."
-for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do 
-    sudo apt-get remove -y $pkg || true
-done
-
-# Detect OS
-if grep -q "Ubuntu" /etc/os-release 2>/dev/null; then
-    DOCKER_OS="ubuntu"
-    # Source the os-release file to get variables
-    . /etc/os-release
-    # Use UBUNTU_CODENAME with fallback to VERSION_CODENAME
-    CODENAME=${UBUNTU_CODENAME:-$VERSION_CODENAME}
-elif [ -f /etc/debian_version ]; then
-    DOCKER_OS="debian"
-    # Source the os-release file to get VERSION_CODENAME
-    . /etc/os-release
-    CODENAME=$VERSION_CODENAME
-else
-    echo "Error: Unsupported OS"
-    exit 1
-fi
-echo "Detected OS: ${DOCKER_OS}, Codename: ${CODENAME}"
-
-echo "Updating package list and installing dependencies..."
-sudo apt-get update
-sudo apt-get install -y apt-transport-https ca-certificates curl gnupg lsb-release
-
-echo "Setting up Docker repository..."
-# Add Docker's official GPG key
-sudo install -m 0755 -d /etc/apt/keyrings
-sudo curl -fsSL https://download.docker.com/linux/${DOCKER_OS}/gpg -o /etc/apt/keyrings/docker.asc
-sudo chmod a+r /etc/apt/keyrings/docker.asc
-
-# Add the repository to Apt sources
-echo \
-  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/${DOCKER_OS} \
-  ${CODENAME} stable" | \
-  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
-
-echo "Installing Docker..."
-sudo apt-get update
-sudo apt-get install -y \
-    docker-ce \
-    docker-ce-cli \
-    containerd.io \
-    docker-buildx-plugin \
-    docker-compose-plugin
-
-# Verify installation
-echo "Verifying Docker installation..."
-sudo docker --version
-sudo containerd --version
-
-echo "Configuring Docker permissions..."
-sudo groupadd docker 2>/dev/null || true
-sudo usermod -aG docker ${SUDO_USER:-$USER}
-
-# Check if we're running in a systemd environment
-echo "Checking for systemd..."
-if pidof systemd > /dev/null && [ -d /run/systemd/system ]; then
-    echo "systemd detected - enabling and starting Docker services using systemctl..."
-    sudo systemctl enable --now docker.service
-    sudo systemctl enable --now containerd.service
-else
-    echo "systemd not detected (likely in a container) - starting Docker daemon directly..."
-    # For containers or non-systemd environments, we can just start the Docker daemon directly
-    sudo dockerd > /dev/null 2>&1 &
-    echo "Docker daemon started in background."
-fi
-
-echo "Docker setup completed. Please log out and log back in for group changes to take effect."
--- a/scripts/linux-setup_sudoers.sh
+++ b/scripts/linux-setup_sudoers.sh
--- a/scripts/linux-setup_zsh.sh
+++ b/scripts/linux-setup_zsh.sh
@ -1,25 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Check if Zsh is already installed
-if command -v zsh &> /dev/null; then
-    echo "Zsh is already installed. Skipping installation."
-else
-    echo "Updating package list..."
-    sudo apt-get update
-
-    echo "Installing Zsh..."
-    sudo apt-get install -y zsh
-
-    if ! command -v zsh &> /dev/null; then
-        echo "Error: Zsh installation failed."
-        exit 1
-    fi
-fi
-
-echo "Changing default shell to Zsh for user $(whoami)..."
-zsh_path=$(command -v zsh)
-sudo chsh -s "$zsh_path" "$(whoami)"
-
-echo "Zsh installation and setup complete. Please log out and log back in for changes to take effect."
--- a/scripts/macos-brew_backup.sh
+++ b/scripts/macos-brew_backup.sh
@ -1,10 +0,0 @@
-#!/bin/bash
-
-BACKUP_FILE="$HOME/.dotfiles/config/macos/homebrew/Brewfile"
-
-echo "Backing up Homebrew installations..."
-mkdir -p "$(dirname "$BACKUP_FILE")"
-
-brew bundle dump --file="$BACKUP_FILE" --force
-
-echo "Backup saved to $BACKUP_FILE"
--- a/scripts/macos-brew_restore.sh
+++ b/scripts/macos-brew_restore.sh
@ -1,13 +0,0 @@
-#!/bin/bash
-
-BACKUP_FILE="$HOME/.dotfiles/config/envs/macos/homebrew/Brewfile"
-
-if [[ ! -f "$BACKUP_FILE" ]]; then
-    echo "Backup file not found: $BACKUP_FILE"
-    exit 1
-fi
-
-echo "Restoring Homebrew installations..."
-brew bundle --file="$BACKUP_FILE"
-
-echo "Homebrew restoration complete."
--- a/scripts/macos-change_hostname.sh
+++ b/scripts/macos-change_hostname.sh
@ -1,26 +0,0 @@
-#!/bin/bash
-
-set -e
-
-if [ -z "$1" ]; then
-    echo "Usage: $0 <new-hostname>"
-    exit 1
-fi
-
-NEW_HOSTNAME="$1"
-
-echo ""
-echo "Changing hostname to '$NEW_HOSTNAME'..."
-
-
-# !!! IMPORTANT !!!
-# double check what are we changing as hostname should end up with *.local
-sudo scutil --set HostName "$NEW_HOSTNAME"
-sudo scutil --set ComputerName "$NEW_HOSTNAME"
-sudo scutil --set LocalHostName "$NEW_HOSTNAME"
-
-echo ""
-echo "Hostname has been updated:"
-echo "HostName: $(scutil --get HostName)"
-echo "ComputerName: $(scutil --get ComputerName)"
-echo "LocalHostName: $(scutil --get LocalHostName)"
--- a/scripts/macos-defaults.sh
+++ b/scripts/macos-defaults.sh
@ -1,196 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Close any open System Preferences panes, to prevent them from overriding
-# settings we’re about to change
-osascript -e 'tell application "System Preferences" to quit'
-
-# Ask for the administrator password upfront
-sudo -v
-
-# Keep-alive: update existing `sudo` time stamp until `.macos` has finished
-while true; do
-  sudo -n true
-  sleep 60
-  kill -0 "$$" || exit
-done 2>/dev/null &
-
-# Save to disk (not to iCloud) by default
-defaults write NSGlobalDomain NSDocumentSaveNewDocumentsToCloud -bool false
-
-# Disable the “Are you sure you want to open this application?” dialog
-defaults write com.apple.LaunchServices LSQuarantine -bool false
-
-# Disable Typing features
-defaults write NSGlobalDomain NSAutomaticCapitalizationEnabled -bool false
-defaults write NSGlobalDomain NSAutomaticDashSubstitutionEnabled -bool false
-defaults write NSGlobalDomain NSAutomaticPeriodSubstitutionEnabled -bool false
-defaults write NSGlobalDomain NSAutomaticQuoteSubstitutionEnabled -bool false
-defaults write NSGlobalDomain NSAutomaticSpellingCorrectionEnabled -bool false
-
-# Disable press-and-hold for keys in favor of key repeat
-defaults write NSGlobalDomain ApplePressAndHoldEnabled -bool false
-defaults write NSGlobalDomain KeyRepeat -int 2
-defaults write NSGlobalDomain InitialKeyRepeat -int 15
-
-defaults write NSGlobalDomain AppleLanguages -array "en" "es" "bg"
-defaults write NSGlobalDomain AppleLocale -string "en_US@rg=eszzzz"
-
-## Finder
-
-# Screenshots/captures
-defaults write com.apple.screencapture location -string "${HOME}/Pictures/Screenshots"
-defaults write com.apple.screencapture style -string "display"
-defaults write com.apple.screencapture target -string "file"
-defaults write com.apple.screencapture video -int 1
-
-# Finder
-# Interface elements
-defaults write com.apple.finder ShowPathbar -bool true
-defaults write com.apple.finder ShowStatusBar -bool true
-defaults write com.apple.finder ShowSidebar -bool true
-defaults write com.apple.finder ShowRecentTags -bool false
-
-# View and sorting
-defaults write com.apple.finder FXPreferredViewStyle -string "Nlsv"
-defaults write com.apple.finder FXPreferredSearchViewStyle -string "Nlsv"
-defaults write com.apple.finder _FXSortFoldersFirst -bool true
-defaults write com.apple.finder FXPreferredGroupBy -string "None"
-defaults write com.apple.finder FXDefaultSearchScope -string "SCcf"
-
-# Behavior
-defaults write com.apple.finder NewWindowTarget -string "PfHm"
-defaults write com.apple.finder FXOpenFoldersInTabs -bool true
-defaults write com.apple.finder FXRemoveOldTrashItems -bool false
-defaults write com.apple.finder FXShowAllExtensions -bool true
-defaults write com.apple.finder FXEnableExtensionChangeWarning -bool true
-defaults write com.apple.finder FXRemoveICloudDriveWarning -bool true
-defaults write com.apple.finder FXWarnBeforeEmptyingTrash -bool true
-
-# Desktop icons (none)
-defaults write com.apple.finder ShowHardDrivesOnDesktop -bool false
-defaults write com.apple.finder ShowExternalHardDrivesOnDesktop -bool false
-defaults write com.apple.finder ShowRemovableMediaOnDesktop -bool false
-defaults write com.apple.finder ShowConnectedServersOnDesktop -bool false
-
-# Tags
-defaults write com.apple.finder FavoriteTagNames -array
-
-# iCloud
-defaults write com.apple.finder FXICloudDriveEnabled -bool false
-
-# Finder: show all filename extensions
-defaults write NSGlobalDomain AppleShowAllExtensions -bool true
-
-# Avoid creating .DS_Store files on network or USB volumes
-defaults write com.apple.desktopservices DSDontWriteNetworkStores -bool true
-defaults write com.apple.desktopservices DSDontWriteUSBStores -bool true
-
-## Dock
-
-#!/bin/bash
-set -euo pipefail
-
-# Reset preferences
-# rm -f ~/Library/Preferences/com.apple.dock.plist
-
-# Reset Dock layout
-defaults write com.apple.dock persistent-apps -array
-defaults write com.apple.dock persistent-others -array
-
-# Basic Dock preferences
-defaults write com.apple.dock autohide -bool true
-defaults write com.apple.dock autohide-delay -float 0
-defaults write com.apple.dock autohide-time-modifier -float 0.4
-defaults write com.apple.dock enterMissionControlByTopWindowDrag -bool false
-defaults write com.apple.dock expose-group-apps -bool true
-defaults write com.apple.dock mineffect -string "scale"
-defaults write com.apple.dock minimize-to-application -bool false
-defaults write com.apple.dock orientation -string "bottom"
-defaults write com.apple.dock show-process-indicators -bool false
-defaults write com.apple.dock show-recents -bool false
-defaults write com.apple.dock showAppExposeGestureEnabled -bool true
-defaults write com.apple.dock showDesktopGestureEnabled -bool false
-defaults write com.apple.dock showLaunchpadGestureEnabled -bool false
-defaults write com.apple.dock tilesize -int 38
-
-# Add Brave Browser
-defaults write com.apple.dock persistent-apps -array-add \
-  "<dict>
-  <key>tile-data</key>
-  <dict>
-    <key>file-data</key>
-    <dict>
-      <key>_CFURLString</key>
-      <string>/Applications/Brave Browser.app</string>
-      <key>_CFURLStringType</key>
-      <integer>0</integer>
-    </dict>
-  </dict>
-  <key>tile-type</key>
-  <string>file-tile</string>
-</dict>"
-
-# Add Ghostty
-defaults write com.apple.dock persistent-apps -array-add \
-  "<dict>
-  <key>tile-data</key>
-  <dict>
-    <key>file-data</key>
-    <dict>
-      <key>_CFURLString</key>
-      <string>/Applications/Ghostty.app</string>
-      <key>_CFURLStringType</key>
-      <integer>0</integer>
-    </dict>
-  </dict>
-  <key>tile-type</key>
-  <string>file-tile</string>
-</dict>"
-
-# Add Screenshots directory (display as folder, show as grid)
-defaults write com.apple.dock persistent-others -array-add \
-  "<dict>
-  <key>tile-data</key>
-  <dict>
-    <key>displayas</key>
-    <integer>1</integer>
-    <key>showas</key>
-    <integer>2</integer>
-    <key>file-data</key>
-    <dict>
-      <key>_CFURLString</key>
-      <string>/Users/tomas/Pictures/Screenshots</string>
-      <key>_CFURLStringType</key>
-      <integer>0</integer>
-    </dict>
-  </dict>
-  <key>tile-type</key>
-  <string>directory-tile</string>
-</dict>"
-
-# Add Downloads directory (display as folder, show as grid)
-defaults write com.apple.dock persistent-others -array-add \
-  "<dict>
-  <key>tile-data</key>
-  <dict>
-    <key>displayas</key>
-    <integer>1</integer>
-    <key>showas</key>
-    <integer>2</integer>
-    <key>file-data</key>
-    <dict>
-      <key>_CFURLString</key>
-      <string>/Users/tomas/Downloads</string>
-      <key>_CFURLStringType</key>
-      <integer>0</integer>
-    </dict>
-  </dict>
-  <key>tile-type</key>
-  <string>directory-tile</string>
-</dict>"
-
-# Apply changes
-killall Finder &>/dev/null
-killall Dock &>/dev/null
-echo "Setup complete."
--- a/scripts/setup_ssh_keys.sh
+++ b/scripts/setup_ssh_keys.sh
@ -1,57 +0,0 @@
-#!/bin/bash
-
-set -e
-
-usage() {
-    echo "Usage: $0 --comment <comment> [--filename <filename>]"
-    echo "  --comment <comment>   The comment for the SSH key."
-    echo "  --filename <filename> (optional) The filename suffix for the SSH key. Defaults to 'id_ed25519'."
-    exit 1
-}
-
-# Default values
-COMMENT=""
-FILENAME="id_ed25519"
-
-# Parse named arguments
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --comment)
-            COMMENT="$2"
-            shift 2
-            ;;
-        --filename)
-            FILENAME="id_ed25519_$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown argument: $1"
-            usage
-            ;;
-    esac
-done
-
-# Validate required arguments
-if [ -z "$COMMENT" ]; then
-    echo "Error: --comment is required."
-    usage
-fi
-
-SSH_DIR="$HOME/.ssh"
-KEY_PATH="$SSH_DIR/$FILENAME"
-
-# Ensure SSH directory exists
-mkdir -p "$SSH_DIR"
-chmod 700 "$SSH_DIR"
-
-# Generate SSH key
-if [ -f "$KEY_PATH" ]; then
-    echo "Skipping: Key file $KEY_PATH already exists."
-    exit 0
-fi
-
-ssh-keygen -t ed25519 -C "$COMMENT" -f "$KEY_PATH" -N ""
-
-echo "SSH key created at: $KEY_PATH"
-echo "Public key:"
-cat "$KEY_PATH.pub"
--- a/secrets.yaml
+++ b/secrets.yaml
@ -0,0 +1,5 @@
+env:
+  DOTFILES_GIT_REMOTE: "git@gitea.tomastm.com:tomas.mirchev/dotfiles.git"
+  DOCKER_REGISTRY: "registry.tomastm.com"
+  DOCKER_REGISTRY_USERNAME: "tomas"
+  DOCKER_REGISTRY_PASSWORD: "Tomas12345!"
--- a/setups/linux-vm.sh
+++ b/setups/linux-vm.sh
@ -1,57 +0,0 @@
-#!/bin/bash
-
-set -e
-
-if [ "$EUID" -eq 0 ]; then
-    echo "This script should not be run as root. Please run it as a normal user."
-    exit 1
-fi
-
-if [ -z "$1" ]; then
-    echo "Usage: $0 <new-hostname>"
-    exit 1
-fi
-
-NEW_HOSTNAME="$1"
-
-if ! sudo -v; then
-    echo "Sudo access required. Exiting."
-    exit 1
-fi
-
-mkdir ~/projects
-# /bin/bash ./scripts/linux-setup_sudoers.sh
-
-/bin/bash ./scripts/linux-change_hostname.sh "$NEW_HOSTNAME"
-
-echo ""
-echo "Installing docker..."
-/bin/bash ./scripts/linux-setup_docker.sh
-
-echo ""
-echo "Creating internal SSH keys..."
-/bin/bash ./scripts/setup_ssh_keys.sh --comment "${USER}@${NEW_HOSTNAME}"
-
-echo ""
-echo "Installing packages..."
-python3 ./manage.py install linux-vm
-
-echo ""
-echo "Linking config..."
-python3 ./manage.py link linux-vm --force
-
-echo ""
-echo "Updating git remote origin url..."
-git remote set-url origin git@gitea.tomastm.com:tomas.mirchev/dotfiles.git
-
-echo ""
-echo "Setup complete. Follow the next steps to finalize your environment:"
-
-echo ""
-echo "Update your git repository SSH key. Your public key is:"
-echo "   $(cat ~/.ssh/id_ed25519.pub)"
-
-echo ""
-echo "Start you development with \`dev -i <image> <container_name>\`"
-echo "Example: \`dev -i node mybox\`"
-echo "You will need to authenticate first: \`docker login registry.tomastm.com\`"
--- a/setups/macos.sh
+++ b/setups/macos.sh
@ -1,68 +0,0 @@
-#!/bin/bash
-
-set -e
-
-if [ "$EUID" -eq 0 ]; then
-    echo "This script should not be run as root. Please run it as a normal user."
-    exit 1
-fi
-
-if [ -z "$1" ]; then
-    echo "Usage: $0 <new-hostname>"
-    exit 1
-fi
-
-NEW_HOSTNAME="$1"
-
-if ! sudo -v; then
-    echo "Sudo access required. Exiting."
-    exit 1
-fi
-
-if ! command -v brew &>/dev/null; then
-    echo ""
-    echo "Installing Homebrew..."
-    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-    eval "$(/opt/homebrew/bin/brew shellenv 2>/dev/null || /usr/local/bin/brew shellenv)"
-else
-    echo "Homebrew already installed."
-fi
-
-echo ""
-echo "Installing brew packages..."
-/bin/bash ./scripts/macos-brew_restore.sh
-
-echo ""
-echo "Linking configs..."
-python3 ./manage.py link macos --force
-
-echo ""
-echo "Changing hostname..."
-/bin/bash ./scripts/macos-change_hostname.sh "$NEW_HOSTNAME"
-
-echo ""
-echo "Creating internal SSH keys..."
-/bin/bash ./scripts/setup_ssh_keys.sh --comment "${USER}@${NEW_HOSTNAME}" --filename "internal"
-/bin/bash ./scripts/setup_ssh_keys.sh --comment "${USER}@${NEW_HOSTNAME}" --filename "git"
-
-echo ""
-echo "Setup complete. Follow the next steps to finalize your environment:"
-
-echo ""
-echo "Set up UTM and configure DNS settings."
-
-echo ""
-echo "Once your VMs and DNS are set up, add your SSH key to the remote server:"
-echo "   ssh-copy-id -i ~/.ssh/id_25519_internal $USER@<server-ip>"
-
-echo ""
-echo "Add your SSH key for Git access. Your public key is:"
-echo "   $(cat ~/.ssh/id_ed25519_git.pub)"
-
-echo ""
-echo "Update your Git remote to use SSH instead of HTTPS:"
-echo "   git remote set-url origin git@gitea.tomastm.com:tomas.mirchev/dotfiles.git"
-
-echo ""
-echo "Install WindowTagger. You can find the repository here:"
-echo "   https://gitea.tomastm.com/tomas.mirchev/window-tagger"
--- a/src/console_logger.py
+++ b/src/console_logger.py
@ -0,0 +1,117 @@
+class ConsoleLogger:
+    # Color constants
+    BLUE = "\033[34m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    RED = "\033[31m"
+    CYAN = "\033[36m"
+    GRAY = "\033[90m"
+    DARK_GRAY = "\033[2;37m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    RESET = "\033[0m"
+
+    # Box drawing characters
+    BOX_VERTICAL = "│"
+    BOX_HORIZONTAL = "─"
+    BOX_TOP_LEFT = "┌"
+    BOX_TOP_RIGHT = "┐"
+    BOX_BOTTOM_LEFT = "└"
+    BOX_BOTTOM_RIGHT = "┘"
+
+    def __init__(self):
+        self.step_counter = 0
+        self.start_time = None
+
+    def info(self, message: str):
+        print(f"{self.CYAN}[INFO]{self.RESET} {message}")
+
+    def warn(self, message: str):
+        print(f"{self.YELLOW}[WARN]{self.RESET} {message}")
+
+    def error(self, message: str):
+        print(f"{self.RED}[ERROR]{self.RESET} {message}")
+
+    def success(self, message: str):
+        print(f"{self.GREEN}[SUCCESS]{self.RESET} {message}")
+
+    def step_start(self, current: int, total: int, description: str):
+        """Start a new step with Docker-style formatting"""
+        print(f"\n{self.BOLD}{self.BLUE}Step {current}/{total}:{self.RESET} {self.BOLD}{description}{self.RESET}")
+        print(f"{self.BLUE}{self.BOX_HORIZONTAL * 4}{self.RESET} {self.GRAY}Starting...{self.RESET}")
+        self.start_time = time.time()
+
+    def step_command(self, command: str):
+        """Show the command being executed"""
+        print(f"{self.BLUE}{self.BOX_VERTICAL}   {self.RESET}{self.GRAY}$ {command}{self.RESET}")
+
+    def step_output(self, line: str):
+        """Show command output with indentation"""
+        if line.strip():
+            print(f"{self.BLUE}{self.BOX_VERTICAL}   {self.RESET}{self.DARK_GRAY}  {line.rstrip()}{self.RESET}")
+
+    def step_complete(self, message: str = "Completed successfully"):
+        """Mark step as completed"""
+        elapsed = time.time() - self.start_time if self.start_time else 0
+        print(f"{self.BLUE}{self.BOX_VERTICAL}   {self.RESET}{self.GREEN}✓ {message} ({elapsed:.1f}s){self.RESET}")
+
+    def step_skip(self, message: str):
+        """Mark step as skipped"""
+        elapsed = time.time() - self.start_time if self.start_time else 0
+        print(
+            f"{self.BLUE}{self.BOX_VERTICAL}   {self.RESET}{self.YELLOW}⚠ Skipped: {message} ({elapsed:.1f}s){self.RESET}"
+        )
+
+    def step_fail(self, message: str):
+        """Mark step as failed"""
+        elapsed = time.time() - self.start_time if self.start_time else 0
+        print(
+            f"{self.BLUE}{self.BOX_VERTICAL}   {self.RESET}{self.RED}✗ Failed: {message} ({elapsed:.1f}s){self.RESET}"
+        )
+
+    def section_header(self, title: str, subtitle: str = ""):
+        """Print a section header"""
+        width = 70
+        print(f"\n{self.BOLD}{self.BLUE}{'=' * width}{self.RESET}")
+        if subtitle:
+            print(f"{self.BOLD}{self.BLUE}🚀 {title.upper()} - {subtitle}{self.RESET}")
+        else:
+            print(f"{self.BOLD}{self.BLUE}🚀 {title.upper()}{self.RESET}")
+        print(f"{self.BOLD}{self.BLUE}{'=' * width}{self.RESET}")
+
+    def section_summary(self, title: str):
+        """Print a section summary header"""
+        width = 70
+        print(f"\n{self.BOLD}{self.GREEN}{'=' * width}{self.RESET}")
+        print(f"{self.BOLD}{self.GREEN}📊 {title.upper()}{self.RESET}")
+        print(f"{self.BOLD}{self.GREEN}{'=' * width}{self.RESET}")
+
+    def plan_header(self, title: str, count: int):
+        """Print planning phase header"""
+        width = 70
+        print(f"\n{self.BOLD}{self.CYAN}{'=' * width}{self.RESET}")
+        print(f"{self.BOLD}{self.CYAN}📋 {title.upper()} ({count} actions){self.RESET}")
+        print(f"{self.BOLD}{self.CYAN}{'=' * width}{self.RESET}")
+
+    def plan_category(self, category: str):
+        """Print plan category"""
+        print(f"\n{self.BOLD}{self.CYAN}{category.upper()}{self.RESET}")
+        print(f"{self.CYAN}{'─' * 20}{self.RESET}")
+
+    def plan_item(self, number: int, description: str, os_filter: str = None, critical: bool = False):
+        """Print a plan item"""
+        # OS compatibility indicator
+        os_indicator = ""
+        if os_filter:
+            os_indicator = f" {self.GRAY}({os_filter}){self.RESET}"
+
+        # Error handling indicator
+        error_indicator = f" {self.RED}(critical){self.RESET}" if critical else ""
+
+        print(f"  {number:2d}. {description}{os_indicator}{error_indicator}")
+
+    def plan_legend(self):
+        """Print plan legend"""
+        print(
+            f"\n{self.GRAY}Legend: {self.RED}(critical){self.GRAY} = stops on failure, {self.GRAY}(os){self.GRAY} = OS-specific{self.RESET}"
+        )
--- a/src/dotfiles_manager.py
+++ b/src/dotfiles_manager.py
@ -0,0 +1,812 @@
+class DotfilesManager:
+    def __init__(
+        self,
+        environment: str,
+        manifest_path: str = "manifest.yaml",
+        secrets_path: str = "secrets.yaml",
+    ):
+        self.dotfiles_dir = Path.cwd()
+        self.manifest_path = self.dotfiles_dir / manifest_path
+        self.secrets_path = self.dotfiles_dir / secrets_path
+        self.config_dir = self.dotfiles_dir / "config"
+
+        # Initialize console logger
+        self.console = ConsoleLogger()
+
+        # Load configuration
+        self.variables = self._load_secrets()
+        self.manifest = self._load_manifest()
+
+        # System info
+        self.system_os = self._get_system_os()
+        self.system_arch = self._get_system_arch()
+        self.system_platform = f"{self.system_os}-{self.system_arch}"
+
+        # Validate environment
+        if environment not in self.manifest.get("environments", {}):
+            self.console.error(f"Environment not found: {environment}")
+            sys.exit(1)
+
+        self.environment = environment
+        self.env_config = self.manifest["environments"][environment]
+        self.pm = PackageManager(self)
+
+        # Execution state
+        self.actions: List[Action] = []
+        self.post_install_comments: List[str] = []
+
+    def info(self, message: str):
+        self.console.info(message)
+
+    def warn(self, message: str):
+        self.console.warn(message)
+
+    def error(self, message: str):
+        self.console.error(message)
+        sys.exit(1)
+
+    def success(self, message: str):
+        self.console.success(message)
+
+    def _load_secrets(self) -> Dict[str, str]:
+        variables = {}
+        try:
+            if self.secrets_path.exists():
+                with open(self.secrets_path, "r") as f:
+                    yaml_data = yaml.safe_load(f)
+                    if yaml_data and "env" in yaml_data:
+                        variables.update(yaml_data["env"])
+        except yaml.YAMLError as e:
+            self.error(f"Error parsing secrets file: {e}")
+        except Exception as e:
+            self.error(f"Error reading secrets file: {e}")
+        return variables
+
+    def add_variables(self, vars: List[str]):
+        for var_setting in vars:
+            if "=" not in var_setting:
+                self.error(f"Invalid variable format: {var_setting}")
+            key, value = var_setting.split("=", 1)
+            self.variables[key] = value
+
+    def _load_manifest(self) -> Dict[str, Any]:
+        try:
+            with open(self.manifest_path, "r") as f:
+                return yaml.safe_load(f)
+        except FileNotFoundError:
+            self.error(f"Manifest file not found: {self.manifest_path}")
+        except yaml.YAMLError as e:
+            self.error(f"Error parsing manifest: {e}")
+
+    def _get_system_os(self) -> str:
+        os_mapping = {"Darwin": "macos", "Linux": "linux"}
+        detected_os = platform.system()
+        if detected_os not in os_mapping:
+            self.error(f"Unsupported operating system: {detected_os}")
+        return os_mapping[detected_os]
+
+    def _get_system_arch(self) -> str:
+        arch_mapping = {"x86_64": "amd64", "aarch64": "arm64", "arm64": "arm64"}
+        detected_arch = platform.machine().lower()
+        if detected_arch not in arch_mapping:
+            self.error(f"Unsupported system architecture: {detected_arch}")
+        return arch_mapping[detected_arch]
+
+    def _substitute_variables(self, text: str) -> str:
+        """Substitute variables in text"""
+        if not isinstance(text, str):
+            return text
+
+        # Substitute custom variables
+        for var, value in self.variables.items():
+            text = text.replace(f"${var}", str(value))
+            text = text.replace(f"${{{var}}}", str(value))
+
+        # Substitute common environment variables
+        text = text.replace("$USER", os.getenv("USER", ""))
+        text = text.replace("$HOME", str(Path.home()))
+
+        return text
+
+    def run_command(self, command: str, check: bool = True, shell: bool = True) -> subprocess.CompletedProcess:
+        """Run command with Docker-style output formatting"""
+        self.console.step_command(command)
+
+        try:
+            # Use Popen for real-time output
+            process = subprocess.Popen(
+                command,
+                shell=shell,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                universal_newlines=True,
+                bufsize=1,
+            )
+
+            # Stream output in real-time
+            output_lines = []
+            for line in process.stdout:
+                line = line.rstrip()
+                if line:  # Only show non-empty lines
+                    self.console.step_output(line)
+                    output_lines.append(line)
+
+            process.wait()
+
+            if check and process.returncode != 0:
+                raise subprocess.CalledProcessError(process.returncode, command, output="\n".join(output_lines))
+
+            # Create a mock CompletedProcess for compatibility
+            result = subprocess.CompletedProcess(command, process.returncode, stdout="\n".join(output_lines), stderr="")
+            return result
+
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Command failed: {command}\nExit code: {e.returncode}")
+
+    # =============================================================================
+    # ACTION PLANNING PHASE
+    # =============================================================================
+
+    def plan_actions(self, command_filter: Optional[str] = None) -> List[Action]:
+        """Plan all actions based on environment configuration"""
+        actions = []
+
+        # Check required variables first
+        actions.extend(self._plan_variable_checks())
+
+        # System setup actions
+        actions.extend(self._plan_hostname_actions())
+
+        # Package manager setup
+        actions.extend(self._plan_package_manager_actions())
+
+        # Package installation
+        actions.extend(self._plan_package_installation_actions())
+
+        # System configuration
+        actions.extend(self._plan_system_config_actions())
+
+        # SSH key generation
+        actions.extend(self._plan_ssh_actions())
+
+        # Config linking
+        actions.extend(self._plan_config_actions())
+
+        # Custom commands
+        actions.extend(self._plan_custom_command_actions())
+
+        # Filter actions based on command
+        if command_filter:
+            actions = self._filter_actions(actions, command_filter)
+
+        return actions
+
+    def _plan_variable_checks(self) -> List[Action]:
+        """Plan variable requirement checks"""
+        actions = []
+
+        if "requires" in self.env_config:
+            for req_var in self.env_config["requires"]:
+                actions.append(
+                    Action(
+                        type="check-variable",
+                        description=f"Check required variable: {req_var}",
+                        data={"variable": req_var},
+                        skip_on_error=False,
+                    )
+                )
+
+        return actions
+
+    def _plan_hostname_actions(self) -> List[Action]:
+        """Plan hostname setting actions"""
+        actions = []
+
+        if "hostname" in self.env_config:
+            hostname = self._substitute_variables(self.env_config["hostname"])
+            actions.append(
+                Action(
+                    type="set-hostname",
+                    description=f"Set system hostname to: {hostname}",
+                    data={"hostname": hostname},
+                    skip_on_error=False,
+                    os_filter=None,  # Both macos and linux support hostname setting
+                )
+            )
+
+        return actions
+
+    def _plan_package_manager_actions(self) -> List[Action]:
+        """Plan package manager setup actions"""
+        actions = []
+
+        if "packages" in self.env_config:
+            specified_pm = self.env_config.get("package-manager")
+            pm = self.pm.get_package_manager(specified_pm)
+
+            # Install brew if needed
+            if pm == "brew" and not shutil.which("brew"):
+                actions.append(
+                    Action(
+                        type="install-brew",
+                        description="Install Homebrew package manager",
+                        data={},
+                        skip_on_error=False,
+                        os_filter="macos",
+                    )
+                )
+
+            # Update package manager
+            actions.append(
+                Action(
+                    type="pm-update",
+                    description=f"Update {pm} package repositories",
+                    data={"pm": pm},
+                    skip_on_error=False,
+                )
+            )
+
+        return actions
+
+    def _plan_package_installation_actions(self) -> List[Action]:
+        """Plan package installation actions"""
+        actions = []
+
+        if "packages" not in self.env_config:
+            return actions
+
+        packages_config = self.env_config["packages"]
+        specified_pm = self.env_config.get("package-manager")
+        pm = self.pm.get_package_manager(specified_pm)
+
+        # Collect all packages by type
+        all_packages = {"standard": set(), "cask": set(), "binary": []}
+
+        # Process standard packages
+        if "standard" in packages_config:
+            for pkg in packages_config["standard"]:
+                if isinstance(pkg, str):
+                    all_packages["standard"].add(pkg)
+                else:
+                    all_packages["standard"].add(pkg["name"])
+
+        # Process binary packages and their dependencies
+        if "binary" in packages_config:
+            for pkg in packages_config["binary"]:
+                if isinstance(pkg, str):
+                    pkg_spec = {"name": pkg}
+                else:
+                    pkg_spec = pkg.copy()
+
+                # Merge with binary config from manifest
+                if pkg_spec["name"] in self.manifest.get("binaries", {}):
+                    binary_config = self.manifest["binaries"][pkg_spec["name"]]
+                    pkg_spec.update(binary_config)
+
+                # Add dependencies to standard packages
+                if "dependencies" in pkg_spec:
+                    all_packages["standard"].update(pkg_spec["dependencies"])
+
+                all_packages["binary"].append(pkg_spec)
+
+        # Process cask packages
+        if "cask" in packages_config:
+            for pkg in packages_config["cask"]:
+                if isinstance(pkg, str):
+                    all_packages["cask"].add(pkg)
+                else:
+                    all_packages["cask"].add(pkg["name"])
+
+        # Create installation actions in order: standard -> cask -> binary
+        if all_packages["standard"]:
+            actions.append(
+                Action(
+                    type="install-packages",
+                    description=f"Install {len(all_packages['standard'])} standard packages via {pm}",
+                    data={
+                        "pm": pm,
+                        "packages": list(all_packages["standard"]),
+                        "package_type": "standard",
+                    },
+                    skip_on_error=False,
+                )
+            )
+
+        if all_packages["cask"]:
+            actions.append(
+                Action(
+                    type="install-packages",
+                    description=f"Install {len(all_packages['cask'])} cask packages via {pm}",
+                    data={"pm": pm, "packages": list(all_packages["cask"]), "package_type": "cask"},
+                    skip_on_error=False,
+                )
+            )
+
+        # Process individual binary packages
+        for pkg_spec in all_packages["binary"]:
+            actions.append(
+                Action(
+                    type="install-binary",
+                    description=f"Install binary: {pkg_spec['name']}",
+                    data={"package": pkg_spec},
+                    skip_on_error=True,
+                )
+            )
+
+        # Add post-install actions for packages
+        if "standard" in packages_config:
+            for pkg in packages_config["standard"]:
+                if isinstance(pkg, dict):
+                    actions.extend(self._plan_package_post_actions(pkg))
+
+        if "binary" in packages_config:
+            for pkg in packages_config["binary"]:
+                if isinstance(pkg, dict):
+                    actions.extend(self._plan_package_post_actions(pkg))
+
+        if "cask" in packages_config:
+            for pkg in packages_config["cask"]:
+                if isinstance(pkg, dict):
+                    actions.extend(self._plan_package_post_actions(pkg))
+
+        return actions
+
+    def _plan_package_post_actions(self, pkg_spec: Dict[str, Any]) -> List[Action]:
+        """Plan post-install actions for a package"""
+        actions = []
+
+        if "post-install" in pkg_spec:
+            actions.append(
+                Action(
+                    type="run-command",
+                    description=f"Run post-install script for {pkg_spec['name']}",
+                    data={"command": pkg_spec["post-install"]},
+                    skip_on_error=True,
+                )
+            )
+
+        if "post-install-comment" in pkg_spec:
+            actions.append(
+                Action(
+                    type="store-comment",
+                    description=f"Store post-install comment for {pkg_spec['name']}",
+                    data={"comment": pkg_spec["post-install-comment"]},
+                    skip_on_error=True,
+                )
+            )
+
+        return actions
+
+    def _plan_system_config_actions(self) -> List[Action]:
+        """Plan system configuration actions"""
+        actions = []
+
+        if "locale" in self.env_config and self.system_os == "linux":
+            locale = self.env_config["locale"]
+            actions.append(
+                Action(
+                    type="set-locale",
+                    description=f"Set system locale to: {locale}",
+                    data={"locale": locale},
+                    skip_on_error=True,
+                    os_filter="linux",
+                )
+            )
+
+        if "shell" in self.env_config and self.system_os == "linux":
+            shell = self.env_config["shell"]
+            actions.append(
+                Action(
+                    type="set-shell",
+                    description=f"Set default shell to: {shell}",
+                    data={"shell": shell},
+                    skip_on_error=True,
+                    os_filter="linux",
+                )
+            )
+
+        return actions
+
+    def _plan_ssh_actions(self) -> List[Action]:
+        """Plan SSH key generation actions"""
+        actions = []
+
+        if "ssh_keygen" in self.env_config:
+            for ssh_config in self.env_config["ssh_keygen"]:
+                key_type = ssh_config["type"]
+                filename = ssh_config.get("filename", f"id_{key_type}")
+                actions.append(
+                    Action(
+                        type="generate-ssh-key",
+                        description=f"Generate SSH key: {filename}",
+                        data=ssh_config,
+                        skip_on_error=True,
+                    )
+                )
+
+        return actions
+
+    def _plan_config_actions(self) -> List[Action]:
+        """Plan configuration linking actions"""
+        actions = []
+
+        # Get all configs to link (from packages and explicit configs)
+        configs_to_link = set()
+
+        # Add configs from packages (unless link: false)
+        if "packages" in self.env_config:
+            for package_type, packages in self.env_config["packages"].items():
+                for pkg in packages:
+                    if isinstance(pkg, str):
+                        pkg_name = pkg
+                        should_link = True
+                    else:
+                        pkg_name = pkg["name"]
+                        should_link = pkg.get("link", True)
+
+                    if should_link:
+                        configs_to_link.add(pkg_name)
+
+        # Add explicit configs
+        if "configs" in self.env_config:
+            for config in self.env_config["configs"]:
+                if isinstance(config, str):
+                    configs_to_link.add(config)
+                else:
+                    configs_to_link.add(config["name"])
+
+        # Create link actions
+        for config_name in configs_to_link:
+            actions.append(
+                Action(
+                    type="link-config",
+                    description=f"Link configuration: {config_name}",
+                    data={"config_name": config_name},
+                    skip_on_error=True,
+                )
+            )
+
+        # Add post-link actions for explicit configs
+        if "configs" in self.env_config:
+            for config in self.env_config["configs"]:
+                if isinstance(config, dict):
+                    actions.extend(self._plan_config_post_actions(config))
+
+        return actions
+
+    def _plan_config_post_actions(self, config_spec: Dict[str, Any]) -> List[Action]:
+        """Plan post-link actions for a config"""
+        actions = []
+
+        if "post-link" in config_spec:
+            actions.append(
+                Action(
+                    type="run-command",
+                    description=f"Run post-link script for {config_spec['name']}",
+                    data={"command": config_spec["post-link"]},
+                    skip_on_error=True,
+                )
+            )
+
+        if "post-link-comment" in config_spec:
+            actions.append(
+                Action(
+                    type="store-comment",
+                    description=f"Store post-link comment for {config_spec['name']}",
+                    data={"comment": config_spec["post-link-comment"]},
+                    skip_on_error=True,
+                )
+            )
+
+        return actions
+
+    def _plan_custom_command_actions(self) -> List[Action]:
+        """Plan custom command actions"""
+        actions = []
+
+        if "runcmd" in self.env_config:
+            for i, command in enumerate(self.env_config["runcmd"]):
+                actions.append(
+                    Action(
+                        type="run-command",
+                        description=f"Run custom command {i+1}",
+                        data={"command": command},
+                        skip_on_error=True,
+                    )
+                )
+
+        return actions
+
+    def _filter_actions(self, actions: List[Action], command_filter: str) -> List[Action]:
+        """Filter actions based on command type and OS compatibility"""
+        # First filter by OS compatibility
+        filtered_actions = []
+        for action in actions:
+            if action.os_filter is None or action.os_filter == self.system_os:
+                filtered_actions.append(action)
+            else:
+                self.info(f"Skipping {action.description} (not compatible with {self.system_os})")
+
+        # Then filter by command type
+        if command_filter == "install":
+            install_types = {
+                "check-variable",
+                "install-brew",
+                "pm-update",
+                "install-packages",
+                "install-binary",
+            }
+            return [a for a in filtered_actions if a.type in install_types]
+        elif command_filter == "link":
+            link_types = {"check-variable", "link-config"}
+            return [a for a in filtered_actions if a.type in link_types]
+
+        return filtered_actions
+
+    # =============================================================================
+    # ACTION EXECUTION PHASE
+    # =============================================================================
+
+    def execute_actions(self, actions: List[Action], dry_run: bool = False):
+        """Execute all planned actions"""
+        if dry_run:
+            self._print_plan(actions)
+            return
+
+        # Filter out OS-incompatible actions that weren't filtered in planning
+        compatible_actions = [a for a in actions if a.os_filter is None or a.os_filter == self.system_os]
+
+        if len(compatible_actions) != len(actions):
+            skipped_count = len(actions) - len(compatible_actions)
+            self.info(f"Skipped {skipped_count} OS-incompatible actions")
+
+        self.console.section_header(f"EXECUTING {len(compatible_actions)} ACTIONS", f"Environment: {self.environment}")
+
+        for i, action in enumerate(compatible_actions, 1):
+            self.console.step_start(i, len(compatible_actions), action.description)
+
+            try:
+                self._execute_action(action)
+                action.status = "completed"
+                self.console.step_complete()
+            except Exception as e:
+                action.error = str(e)
+                if action.skip_on_error:
+                    action.status = "skipped"
+                    self.console.step_skip(str(e))
+                else:
+                    action.status = "failed"
+                    self.console.step_fail(str(e))
+                    print(f"\n{self.console.RED}💥 Critical action failed, stopping execution{self.console.RESET}")
+                    break
+
+        # Show final summary
+        self._print_execution_summary(compatible_actions)
+
+    def _execute_action(self, action: Action):
+        """Execute a single action"""
+        executors = {
+            "check-variable": self._execute_check_variable,
+            "set-hostname": self._execute_set_hostname,
+            "install-brew": self._execute_install_brew,
+            "pm-update": self._execute_pm_update,
+            "install-packages": self._execute_install_packages,
+            "install-binary": self._execute_install_binary,
+            "set-locale": self._execute_set_locale,
+            "set-shell": self._execute_set_shell,
+            "generate-ssh-key": self._execute_generate_ssh_key,
+            "link-config": self._execute_link_config,
+            "run-command": self._execute_run_command,
+            "store-comment": self._execute_store_comment,
+        }
+
+        executor = executors.get(action.type)
+        if not executor:
+            raise RuntimeError(f"Unknown action type: {action.type}")
+
+        executor(action.data)
+
+    def _execute_check_variable(self, data: Dict[str, Any]):
+        """Execute variable check"""
+        variable = data["variable"]
+        if variable not in self.variables:
+            raise RuntimeError(f"Required variable not set: {variable}")
+
+    def _execute_set_hostname(self, data: Dict[str, Any]):
+        """Execute hostname setting"""
+        hostname = data["hostname"]
+        if self.system_os == "macos":
+            self.run_command(f"sudo scutil --set ComputerName '{hostname}'")
+            self.run_command(f"sudo scutil --set HostName '{hostname}'")
+            self.run_command(f"sudo scutil --set LocalHostName '{hostname}'")
+        else:
+            self.run_command(f"sudo hostnamectl set-hostname '{hostname}'")
+
+    def _execute_install_brew(self, data: Dict[str, Any]):
+        """Execute Homebrew installation"""
+        self.run_command(
+            'NONINTERACTIVE=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'
+        )
+
+    def _execute_pm_update(self, data: Dict[str, Any]):
+        """Execute package manager update"""
+        pm = data["pm"]
+        cmd = self.pm.get_update_command(pm)
+        self.run_command(cmd)
+
+    def _execute_install_packages(self, data: Dict[str, Any]):
+        """Execute package installation"""
+        pm = data["pm"]
+        packages = data["packages"]
+        package_type = data["package_type"]
+
+        if not packages:
+            return
+
+        cmd = self.pm.get_install_command(pm, packages, package_type)
+        self.run_command(cmd)
+
+    def _execute_install_binary(self, data: Dict[str, Any]):
+        """Execute binary installation"""
+        package = data["package"]
+        # This would need implementation based on your binary installation logic
+        # For now, just a placeholder
+        self.info(f"Binary installation for {package['name']} would happen here")
+
+    def _execute_set_locale(self, data: Dict[str, Any]):
+        """Execute locale setting"""
+        locale = data["locale"]
+        self.run_command(f"sudo locale-gen {locale}")
+        self.run_command(f"sudo update-locale LANG={locale}")
+
+    def _execute_set_shell(self, data: Dict[str, Any]):
+        """Execute shell setting"""
+        shell = data["shell"]
+        shell_path = shutil.which(shell)
+        if not shell_path:
+            raise RuntimeError(f"Shell not found: {shell}")
+
+        # Add shell to /etc/shells if not present
+        try:
+            with open("/etc/shells", "r") as f:
+                shells = f.read()
+            if shell_path not in shells:
+                self.run_command(f"echo '{shell_path}' | sudo tee -a /etc/shells")
+        except FileNotFoundError:
+            pass
+
+        self.run_command(f"chsh -s {shell_path}")
+
+    def _execute_generate_ssh_key(self, data: Dict[str, Any]):
+        """Execute SSH key generation"""
+        ssh_dir = Path.home() / ".ssh"
+        ssh_dir.mkdir(mode=0o700, exist_ok=True)
+
+        key_type = data["type"]
+        comment = self._substitute_variables(data.get("comment", ""))
+        filename = data.get("filename", f"id_{key_type}")
+
+        key_path = ssh_dir / filename
+
+        if key_path.exists():
+            self.warn(f"SSH key already exists: {key_path}")
+            return
+
+        cmd = f'ssh-keygen -t {key_type} -f "{key_path}" -N "" -C "{comment}"'
+        self.run_command(cmd)
+
+    def _execute_link_config(self, data: Dict[str, Any]):
+        """Execute configuration linking"""
+        config_name = data["config_name"]
+        # This would need implementation based on your config linking logic
+        # For now, just a placeholder
+        self.info(f"Config linking for {config_name} would happen here")
+
+    def _execute_run_command(self, data: Dict[str, Any]):
+        """Execute custom command"""
+        command = self._substitute_variables(data["command"])
+        self.run_command(command)
+
+    def _execute_store_comment(self, data: Dict[str, Any]):
+        """Execute comment storage"""
+        comment = self._substitute_variables(data["comment"])
+        self.post_install_comments.append(comment)
+
+    def _print_plan(self, actions: List[Action]):
+        """Print execution plan"""
+        self.console.plan_header(f"EXECUTION PLAN FOR {self.environment}", len(actions))
+
+        # Group actions by type for better readability
+        grouped_actions = {}
+        for action in actions:
+            action_category = action.type.split("-")[0]  # "install", "set", "link", etc.
+            if action_category not in grouped_actions:
+                grouped_actions[action_category] = []
+            grouped_actions[action_category].append(action)
+
+        for category, category_actions in grouped_actions.items():
+            self.console.plan_category(category)
+            for i, action in enumerate(category_actions, 1):
+                # Check if action will be skipped due to OS compatibility
+                will_skip = action.os_filter and action.os_filter != self.system_os
+
+                if will_skip:
+                    self.console.plan_item(
+                        i,
+                        f"{action.description} (will be skipped - {action.os_filter} only)",
+                        action.os_filter,
+                        not action.skip_on_error,
+                    )
+                else:
+                    self.console.plan_item(i, action.description, action.os_filter, not action.skip_on_error)
+
+        self.console.plan_legend()
+
+    def _print_execution_summary(self, actions: List[Action]):
+        """Print execution summary"""
+        completed = len([a for a in actions if a.status == "completed"])
+        failed = len([a for a in actions if a.status == "failed"])
+        skipped = len([a for a in actions if a.status == "skipped"])
+
+        self.console.section_summary("EXECUTION SUMMARY")
+
+        print(f"Total actions: {self.console.BOLD}{len(actions)}{self.console.RESET}")
+        print(f"Completed:     {self.console.GREEN}{completed}{self.console.RESET}")
+        if failed > 0:
+            print(f"Failed:        {self.console.RED}{failed}{self.console.RESET}")
+        if skipped > 0:
+            print(f"Skipped:       {self.console.YELLOW}{skipped}{self.console.RESET}")
+
+        if self.post_install_comments:
+            print(f"\n{self.console.BOLD}📝 POST-INSTALL NOTES{self.console.RESET}")
+            print(f"{self.console.CYAN}{'─' * 25}{self.console.RESET}")
+            for i, comment in enumerate(self.post_install_comments, 1):
+                print(f"{i}. {comment}")
+
+        if failed > 0:
+            print(f"\n{self.console.BOLD}❌ FAILED ACTIONS{self.console.RESET}")
+            print(f"{self.console.RED}{'─' * 20}{self.console.RESET}")
+            for action in actions:
+                if action.status == "failed":
+                    print(f"{self.console.RED}✗{self.console.RESET} {action.description}")
+                    print(f"  {self.console.GRAY}Error: {action.error}{self.console.RESET}")
+
+        # Final status
+        if failed == 0:
+            print(f"\n{self.console.GREEN}🎉 All actions completed successfully!{self.console.RESET}")
+        else:
+            print(f"\n{self.console.RED}💥 {failed} action(s) failed. Check the errors above.{self.console.RESET}")
+
+    # =============================================================================
+    # PUBLIC INTERFACE
+    # =============================================================================
+
+    def setup_environment(self, dry_run: bool = False):
+        """Setup complete environment"""
+        actions = self.plan_actions()
+        self.execute_actions(actions, dry_run)
+
+    def install_packages(self, package_name: Optional[str] = None, dry_run: bool = False):
+        """Install packages"""
+        actions = self.plan_actions("install")
+        if package_name:
+            # Filter to specific package
+            actions = [a for a in actions if package_name in str(a.data)]
+        self.execute_actions(actions, dry_run)
+
+    def link_configs(
+        self,
+        config_name: Optional[str] = None,
+        copy: bool = False,
+        force: bool = False,
+        dry_run: bool = False,
+    ):
+        """Link configurations"""
+        actions = self.plan_actions("link")
+        if config_name:
+            # Filter to specific config
+            actions = [a for a in actions if config_name in str(a.data)]
+
+        # TODO: Handle copy and force flags in action data
+        self.execute_actions(actions, dry_run)
+
--- a/src/package_manager.py
+++ b/src/package_manager.py
@ -0,0 +1,63 @@
+class PackageManager:
+    SUPPORTED_MANAGERS = {
+        "brew": {
+            "update_cmd": "brew update",
+            "install_cmd": "brew install {packages}",
+            "install_cask_cmd": "brew install --cask {packages}",
+        },
+        "apt": {
+            "update_cmd": "sudo apt-get update",
+            "install_cmd": "sudo apt-get install -y {packages}",
+        },
+        "dnf": {
+            "update_cmd": "sudo dnf check-update || true",
+            "install_cmd": "sudo dnf install -y {packages}",
+        },
+        "pacman": {
+            "update_cmd": "sudo pacman -Sy",
+            "install_cmd": "sudo pacman -S --noconfirm {packages}",
+        },
+    }
+
+    def __init__(self, parent):
+        self.parent = parent
+        self.system_os = "macos" if platform.system() == "Darwin" else "linux"
+        self.detected_pm = self._detect_package_manager()
+
+    def _detect_package_manager(self) -> str:
+        if self.system_os == "macos":
+            return "brew"
+        else:
+            if shutil.which("apt"):
+                return "apt"
+            elif shutil.which("dnf"):
+                return "dnf"
+            elif shutil.which("pacman"):
+                return "pacman"
+            else:
+                raise ValueError("No supported package manager found (apt, dnf, pacman)")
+
+    def get_package_manager(self, specified_pm: Optional[str] = None) -> str:
+        if specified_pm:
+            if specified_pm != self.detected_pm:
+                raise ValueError(
+                    f"Inconsistent package manager: detected ({self.detected_pm}) != specified ({specified_pm})"
+                )
+            return specified_pm
+        return self.detected_pm
+
+    def get_update_command(self, pm: str) -> str:
+        if pm not in self.SUPPORTED_MANAGERS:
+            raise ValueError(f"Unsupported package manager: {pm}")
+        return self.SUPPORTED_MANAGERS[pm]["update_cmd"]
+
+    def get_install_command(self, pm: str, packages: List[str], package_type: str = "standard") -> str:
+        if pm not in self.SUPPORTED_MANAGERS:
+            raise ValueError(f"Unsupported package manager: {pm}")
+
+        pm_config = self.SUPPORTED_MANAGERS[pm]
+
+        if package_type == "cask" and pm == "brew":
+            return pm_config["install_cask_cmd"].format(packages=" ".join(packages))
+        else:
+            return pm_config["install_cmd"].format(packages=" ".join(packages))
--- a/test.py
+++ b/test.py
@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import time
+import urllib.request
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import yaml
+
+
+def main():
+    try:
+        # Use Popen for real-time output
+        process = subprocess.Popen(
+            command,
+            shell=shell,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+            bufsize=1,
+        )
+
+        # Stream output in real-time
+        output_lines = []
+        for line in process.stdout:
+            line = line.rstrip()
+            if line:  # Only show non-empty lines
+                self.console.step_output(line)
+                output_lines.append(line)
+
+        process.wait()
+
+        if check and process.returncode != 0:
+            raise subprocess.CalledProcessError(process.returncode, command, output="\n".join(output_lines))
+
+        # Create a mock CompletedProcess for compatibility
+        result = subprocess.CompletedProcess(command, process.returncode, stdout="\n".join(output_lines), stderr="")
+        return result
+
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Command failed: {command}\nExit code: {e.returncode}")
+
+
+if __name__ == "__main__":
+    main()
				`@ -1 +0,0 @@`
				`Subproject commit d0344b6c564a5d6b00bccd73caefcda42229d70b`
				`@ -1 +0,0 @@`
				`Subproject commit 4419f2e5f3e693b0eac260c588c2cceaaeb6b1e1`