setup.yml

- name: Setup Development Environment
  hosts: all
  gather_facts: true
  vars:
    os_family: '{{ ansible_os_family }}'
    is_macos: '{{ ansible_os_family == ''Darwin'' }}'
    is_linux: '{{ ansible_os_family != ''Darwin'' }}'
    brewfile_path: "{{ playbook_dir }}/Brewfile"
  tasks:
  - name: Detect Homebrew installation path
    ansible.builtin.command: which brew
    register: brew_which_result
    failed_when: false
    changed_when: false
    tags:
    - always
    - homebrew
  - name: Set homebrew_prefix from detected path
    ansible.builtin.set_fact:
      homebrew_prefix: "{{ brew_which_result.stdout | dirname | dirname }}"
    when: brew_which_result.rc == 0
    tags:
    - always
    - homebrew
  - name: Set homebrew_prefix to default if not found
    ansible.builtin.set_fact:
      homebrew_prefix: "{{ '/opt/homebrew' if is_macos else '/home/linuxbrew/.linuxbrew' }}"
    when: brew_which_result.rc != 0
    tags:
    - always
    - homebrew
  - name: Display homebrew_prefix being used
    ansible.builtin.debug:
      msg: "Using Homebrew at: {{ homebrew_prefix }}"
    tags:
    - always
    - homebrew
  - name: Set user and home variables from environment
    ansible.builtin.set_fact:
      user: "{{ (lookup('env', 'USER') or lookup('env', 'LOGNAME') or 'root') | trim }}"
      home: "{{ (lookup('env', 'HOME') or '/root') | trim }}"
    tags:
    - always
  - name: Check if Brewfile exists
    ansible.builtin.stat:
      path: '{{ brewfile_path }}'
    register: brewfile_check
    tags:
    - always
    - homebrew
    - packages
  - name: Check if terraform is installed
    ansible.builtin.command: '{{ homebrew_prefix }}/bin/brew list terraform'
    register: terraform_check
    failed_when: false
    changed_when: false
    when:
    - brewfile_check.stat.exists
    tags:
    - homebrew
    - packages
  - name: Unlink terraform if tenv will be installed
    ansible.builtin.shell: '{{ homebrew_prefix }}/bin/brew unlink terraform'
    register: terraform_unlink
    when:
    - terraform_check.rc is defined
    - terraform_check.rc == 0
    - brewfile_check.stat.exists
    failed_when: false
    changed_when: |
      terraform_unlink.rc is defined and terraform_unlink.rc == 0 and 'Unlinking' in terraform_unlink.stderr
    tags:
    - homebrew
    - packages
  - name: Install packages from Brewfile (if it exists)
    ansible.builtin.shell: |
      {{ homebrew_prefix }}/bin/brew bundle install \
      --file={{ brewfile_path }} || true
    args:
      chdir: '{{ playbook_dir }}'
    environment:
      PATH: '{{ homebrew_prefix }}/bin:{{ ansible_env.PATH }}'
    register: brew_bundle_result
    when:
    - ansible_os_family == "Darwin"
    - brewfile_check.stat.exists
    - install_gui_apps | default(true) or install_dev_tools | default(true)
    changed_when: |
      'Installing' in brew_bundle_result.stdout or
      'Upgrading' in brew_bundle_result.stdout
    failed_when: false
    tags:
    - homebrew
    - packages

  - name: Install essential packages with Homebrew (macOS fallback)
    ansible.builtin.command: '{{ homebrew_prefix }}/bin/brew install {{ item }}'
    loop:
      - tmux
      - neovim
      - fzf
      - ripgrep
      - bat
    when:
    - ansible_os_family == "Darwin"
    - install_dev_tools | default(true)
    register: brew_install_result
    changed_when: 'not "is already installed" in brew_install_result.stdout'
    failed_when: false
    tags:
    - homebrew
    - packages
  - name: Install essential Linux packages (Debian/Ubuntu)
    ansible.builtin.apt:
      name:
      - git
      - curl
      - wget
      - vim
      - zsh
      - tree
      - htop
      - jq
      - build-essential
      - python3-pip
      - nodejs
      - npm
      - golang-go
      - postgresql
      - sqlite3
      - direnv
      - shellcheck
      state: present
      update_cache: true
    become: "{{ not (ansible_user_id == 'root') }}"
    when:
    - ansible_os_family == "Debian"
    - install_dev_tools | default(true)
    tags:
    - linux
    - packages

  - name: Install optional packages from apt (best effort)
    ansible.builtin.apt:
      name:
      - neovim
      - tmux
      - fzf
      - ripgrep
      - bat
      - pipx
      state: present
      update_cache: false
    become: "{{ not (ansible_user_id == 'root') }}"
    register: apt_optional_result
    failed_when: false
    ignore_errors: true
    when:
    - ansible_os_family == "Debian"
    - install_dev_tools | default(true)
    tags:
    - linux
    - packages

  - name: Install optional Linux tools via Homebrew (Linuxbrew fallback)
    ansible.builtin.command: '{{ homebrew_prefix }}/bin/brew install {{ item }}'
    loop:
      - neovim
      - tmux
      - fzf
      - ripgrep
      - bat
    when:
    - ansible_os_family != "Darwin"
    - install_dev_tools | default(true)
    register: brew_linux_result
    changed_when: 'not "is already installed" in brew_linux_result.stdout'
    failed_when: false
    tags:
    - linux
    - homebrew
    - packages
  - name: Install essential Linux packages (RedHat/Fedora)
    ansible.builtin.dnf:
      name:
      - git
      - curl
      - wget
      - vim
      - zsh
      - tree
      - htop
      - jq
      - gcc
      - gcc-c++
      - make
      - python3-pip
      - nodejs
      - npm
      - golang
      - postgresql
      - sqlite
      - direnv
      - ShellCheck
      state: present
    become: "{{ not (ansible_user_id == 'root') }}"
    register: dnf_result
    failed_when: false
    when:
    - ansible_os_family == "RedHat"
    - install_dev_tools | default(true)
    tags:
    - linux
    - packages

  - name: Install optional packages from dnf (best effort)
    ansible.builtin.dnf:
      name:
      - neovim
      - tmux
      - fzf
      - ripgrep
      - bat
      - pipx
      state: present
    become: "{{ not (ansible_user_id == 'root') }}"
    register: dnf_optional_result
    failed_when: false
    ignore_errors: true
    when:
    - ansible_os_family == "RedHat"
    - install_dev_tools | default(true)
    tags:
    - linux
    - packages
  - name: Install essential Linux packages (Arch Linux)
    community.general.pacman:
      name:
      - git
      - curl
      - wget
      - vim
      - neovim
      - tmux
      - zsh
      - fzf
      - ripgrep
      - bat
      - tree
      - htop
      - jq
      - base-devel
      - python-pip
      - python-pipx
      - nodejs
      - npm
      - go
      - postgresql
      - sqlite
      - direnv
      - shellcheck
      state: present
      update_cache: yes
    become: "{{ not (ansible_user_id == 'root') }}"
    when:
    - ansible_os_family == "Archlinux"
    - install_dev_tools | default(true)
    tags:
    - linux
    - packages
  - name: Set ansible_user_dir for dotfiles role (container compatibility)
    ansible.builtin.set_fact:
      ansible_user_dir: "{{ home }}"
      ansible_user_id: "{{ user }}"
    tags:
    - dotfiles
    - configuration
    - always
  # NOTE: dotfiles role moved to run AFTER Oh My Zsh installation
  # to prevent .zshrc from being overwritten by Oh My Zsh installer

  - name: Include git role
    ansible.builtin.include_role:
      name: git
    vars:
      git_current_user: "{{ user }}"
      git_home_dir: "{{ home }}"
      git_repo_root: "{{ playbook_dir }}"
      git_enable_precommit: true
    tags:
    - git
    - configuration
    - always
  - name: Download mise installer
    ansible.builtin.get_url:
      url: https://mise.run
      dest: /tmp/mise-installer.sh
      mode: '0755'
    when:
    - ansible_os_family != "Darwin"
    - install_dev_tools | default(true)
    tags:
    - mise
    - dev-tools
  - name: Install mise on Linux
    ansible.builtin.shell: /tmp/mise-installer.sh
    args:
      creates: '{{ home }}/.local/bin/mise'
    when:
    - ansible_os_family != "Darwin"
    - install_dev_tools | default(true)
    tags:
    - mise
    - dev-tools
  - name: Add mise to PATH for Linux
    ansible.builtin.lineinfile:
      path: '{{ home }}/.bashrc'
      line: eval "$(~/.local/bin/mise activate bash)"
      create: true
      mode: '0644'
    when:
    - ansible_os_family != "Darwin"
    - install_dev_tools | default(true)
    tags:
    - mise
    - dev-tools
  - name: Check if .mise.toml exists
    ansible.builtin.stat:
      path: '{{ playbook_dir }}/.mise.toml'
    register: mise_toml_check
    tags:
    - always
    - mise
  - name: Set mise binary path
    ansible.builtin.set_fact:
      mise_bin: |
        {{ homebrew_prefix ~ '/bin/mise' if ansible_os_family == 'Darwin'
        else home ~ '/.local/bin/mise' }}
    tags:
    - always
    - mise
  - name: Check if mise binary exists
    ansible.builtin.stat:
      path: '{{ mise_bin }}'
    register: mise_binary_check
    tags:
    - always
    - mise
  - name: Trust mise config file
    ansible.builtin.command: '{{ mise_bin }} trust'
    args:
      chdir: '{{ playbook_dir }}'
    register: mise_trust_result
    when:
    - mise_binary_check.stat.exists
    - mise_toml_check.stat.exists
    - install_dev_tools | default(true)
    changed_when: |
      mise_trust_result.rc == 0 and 'trusted' in mise_trust_result.stdout
    failed_when: false
    tags:
    - mise
    - dev-tools
  - name: Install tool versions with mise
    ansible.builtin.command: '{{ mise_bin }} install'
    args:
      chdir: '{{ playbook_dir }}'
    register: mise_install_result
    when:
    - mise_binary_check.stat.exists
    - mise_toml_check.stat.exists
    - install_dev_tools | default(true)
    changed_when: |
      'installed' in mise_install_result.stdout or
      'Installing' in mise_install_result.stdout
    failed_when: false
    retries: 3
    delay: 5
    until: mise_install_result is succeeded
    tags:
    - mise
    - dev-tools
  - name: Check Oh My Zsh installation
    ansible.builtin.stat:
      path: '{{ home }}/.oh-my-zsh/oh-my-zsh.sh'
    register: ohmyzsh_check
    tags:
    - always
    - shell
  - name: Install Oh My Zsh
    ansible.builtin.shell: |
      curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh -o /tmp/install-oh-my-zsh.sh
      env -u ZSH RUNZSH=no sh /tmp/install-oh-my-zsh.sh --unattended
    register: ohmyzsh_install
    when:
    - not ohmyzsh_check.stat.exists
    - install_shell_tools | default(true)
    changed_when: ohmyzsh_install.rc == 0
    retries: 3
    delay: 5
    until: ohmyzsh_install is succeeded
    tags:
    - shell
  - name: Clone Powerlevel10k theme
    ansible.builtin.git:
      repo: https://github.com/romkatv/powerlevel10k.git
      dest: '{{ home }}/.oh-my-zsh/custom/themes/powerlevel10k'
      depth: 1
      version: master
      update: true
    register: p10k_result
    when: install_shell_tools | default(true)
    retries: 3
    delay: 5
    until: p10k_result is succeeded
    tags:
    - shell
  - name: Clone zsh plugins
    ansible.builtin.git:
      repo: '{{ item.repo }}'
      dest: '{{ home }}/.oh-my-zsh/custom/plugins/{{ item.name }}'
      version: master
      update: true
    loop: '{{ zsh_plugins }}'
    register: zsh_plugins_result
    when: install_shell_tools | default(true)
    retries: 3
    delay: 5
    until: zsh_plugins_result is succeeded
    tags:
    - shell
  - name: Check if fzf is installed
    ansible.builtin.stat:
      path: '{{ homebrew_prefix }}/opt/fzf/install'
    register: fzf_check
    when:
    - ansible_os_family == "Darwin"
    - install_shell_tools | default(true)
    tags:
    - always
    - shell
  - name: Install fzf key bindings and completion
    ansible.builtin.shell: "{{ homebrew_prefix }}/opt/fzf/install --key-bindings --completion --no-update-rc"
    args:
      creates: '{{ home }}/.fzf.zsh'
    when:
    - ansible_os_family == "Darwin"
    - install_shell_tools | default(true)
    - fzf_check.stat.exists | default(false)
    tags:
    - shell
  - name: Download dircolors (LS_COLORS)
    ansible.builtin.get_url:
      url: https://raw.githubusercontent.com/trapd00r/LS_COLORS/master/LS_COLORS
      dest: '{{ home }}/.dircolors'
      mode: '0644'
    register: dircolors_result
    when: install_shell_tools | default(true)
    retries: 3
    delay: 5
    until: dircolors_result is succeeded
    tags:
    - shell

  # ============================================================================
  # Deploy dotfiles AFTER Oh My Zsh installation
  # This ensures .zshrc with p10k configuration is not overwritten
  # ============================================================================

  - name: Check if dotfiles directory exists
    ansible.builtin.stat:
      path: "{{ playbook_dir }}/dotfiles"
    register: dotfiles_dir_check
    tags:
    - dotfiles
    - configuration
    - always

  - name: Include dotfiles role
    ansible.builtin.include_role:
      name: dotfiles
    when: dotfiles_dir_check.stat.exists
    tags:
    - dotfiles
    - configuration
    - always

  # NOTE: .inputrc and .direnvrc deployed by dotfiles role above
  # These duplicate tasks removed to avoid overwriting permissions

  - name: Enable direnv in zsh
    ansible.builtin.lineinfile:
      path: '{{ home }}/.zshrc'
      line: eval "$(direnv hook zsh)"
      state: present
      create: true
      mode: '0644'
    when:
    - install_dev_tools | default(true)
    - ansible_os_family == "Darwin"
    tags:
    - shell
    - direnv
  - name: Configure passwordless sudo
    ansible.builtin.copy:
      content: '# Allow {{ user }} to use sudo with no password

        {{ user }} ALL=(ALL) NOPASSWD: ALL

        '
      dest: /etc/sudoers.d/{{ user }}
      mode: '0440'
      validate: visudo -cf %s
    become: "{{ not (ansible_user_id == 'root') }}"
    when: configure_sudoers | default(false)
    tags:
    - sudoers
  - name: Check if TPM (Tmux Plugin Manager) is installed
    ansible.builtin.stat:
      path: '{{ home }}/.tmux/plugins/tpm'
    register: tpm_check
    when: install_shell_tools | default(true)
    tags:
    - always
    - tmux
  - name: Clone TPM (Tmux Plugin Manager)
    ansible.builtin.git:
      repo: https://github.com/tmux-plugins/tpm
      dest: '{{ home }}/.tmux/plugins/tpm'
      depth: 1
      version: master
      update: true
    register: tpm_result
    when:
    - install_shell_tools | default(true)
    - not tpm_check.stat.exists
    retries: 3
    delay: 5
    until: tpm_result is succeeded
    tags:
    - tmux
  # NOTE: .tmux.conf is now deployed by the dotfiles role
  # These duplicate tasks have been removed to avoid overwriting
  # correct permissions

  - name: Display tmux plugin installation instructions
    ansible.builtin.debug:
      msg:
      - Tmux configuration installed!
      - 'To install plugins, start tmux and press: Ctrl-a + I'
      - (That's prefix key + capital I)
    when:
    - install_shell_tools | default(true)
    - not tpm_check.stat.exists
    tags:
    - tmux
  # NOTE: neovim config is now deployed by the dotfiles role

  - name: Create vim symlinks to neovim (override system vim)
    ansible.builtin.file:
      src: |
        {{ '/usr/bin/nvim' if ansible_os_family == 'Debian' else
        homebrew_prefix ~ '/bin/nvim' }}
      dest: /usr/local/bin/{{ item }}
      state: link
      force: true
    loop:
    - vim
    - vi
    when: install_neovim | default(true)
    become: "{{ not (ansible_user_id == 'root') }}"
    tags:
    - neovim
  - name: Check if VS Code is installed
    ansible.builtin.command: which code
    register: vscode_check
    failed_when: false
    changed_when: false
    tags:
    - always
    - vscode
  - name: Get currently installed VS Code extensions
    ansible.builtin.command: code --list-extensions
    register: installed_extensions
    when:
    - vscode_check.rc is defined
    - vscode_check.rc == 0
    - install_vscode | default(true)
    changed_when: false
    failed_when: false
    tags:
    - vscode
  - name: Install VS Code extensions
    ansible.builtin.command: code --install-extension {{ item }}
    loop: '{{ vscode_extensions }}'
    register: vscode_install
    when:
    - vscode_check.rc is defined
    - vscode_check.rc == 0
    - install_vscode | default(true)
    - installed_extensions.stdout_lines is defined
    - item not in installed_extensions.stdout_lines
    changed_when: '''was successfully installed'' in vscode_install.stdout'
    failed_when: false
    tags:
    - vscode
  - name: Ensure VS Code User directory exists
    ansible.builtin.file:
      path: '{{ home }}/Library/Application Support/Code/User'
      state: directory
      mode: '0755'
    when:
    - vscode_check.rc is defined
    - vscode_check.rc == 0
    - install_vscode | default(true)
    - is_macos
    tags:
    - vscode
  - name: Ensure VS Code User directory exists (Linux)
    ansible.builtin.file:
      path: '{{ home }}/.config/Code/User'
      state: directory
      mode: '0755'
    when:
    - vscode_check.rc is defined
    - vscode_check.rc == 0
    - install_vscode | default(true)
    - is_linux
    tags:
    - vscode
  - name: Configure VS Code settings.json (macOS)
    ansible.builtin.copy:
      content: '{{ vscode_settings | to_nice_json }}'
      dest: '{{ home }}/Library/Application Support/Code/User/settings.json'
      mode: '0644'
      backup: true
    when:
    - vscode_check.rc is defined
    - vscode_check.rc == 0
    - install_vscode | default(true)
    - vscode_settings is defined
    - is_macos
    tags:
    - vscode
  - name: Configure VS Code settings.json (Linux)
    ansible.builtin.copy:
      content: '{{ vscode_settings | to_nice_json }}'
      dest: '{{ home }}/.config/Code/User/settings.json'
      mode: '0644'
      backup: true
    when:
    - vscode_check.rc is defined
    - vscode_check.rc == 0
    - install_vscode | default(true)
    - vscode_settings is defined
    - is_linux
    tags:
    - vscode
  - name: Check if Ghostty config directory exists
    ansible.builtin.stat:
      path: '{{ home }}/.config/ghostty'
    register: ghostty_dir_check
    tags:
    - always
    - ghostty
  - name: Create Ghostty config directory
    ansible.builtin.file:
      path: '{{ home }}/.config/ghostty'
      state: directory
      mode: '0755'
    when: install_shell_tools | default(true)
    tags:
    - ghostty
  # NOTE: ghostty config is now deployed by the dotfiles role

  - name: Check if chezmoi binary exists
    ansible.builtin.stat:
      path: '{{ homebrew_prefix }}/bin/chezmoi'
    register: chezmoi_binary_check
    when: configure_dotfiles | default(true)
    tags:
    - always
    - dotfiles
  - name: Check if chezmoi is initialized
    ansible.builtin.stat:
      path: '{{ home }}/.local/share/chezmoi'
    register: chezmoi_check
    when:
    - configure_dotfiles | default(true)
    - chezmoi_binary_check.stat.exists | default(false)
    tags:
    - always
    - dotfiles
  - name: Initialize chezmoi
    ansible.builtin.command: '{{ homebrew_prefix }}/bin/chezmoi init'
    register: chezmoi_init
    when:
    - configure_dotfiles | default(true)
    - chezmoi_binary_check.stat.exists | default(false)
    - chezmoi_check is not defined or not chezmoi_check.stat.exists
    changed_when: chezmoi_init.rc == 0
    tags:
    - dotfiles
  # NOTE: .zshrc is now deployed by the dotfiles role
  # Chezmoi-specific tasks removed as they conflict with dotfiles
  # role deployment
  - name: macOS-specific tasks
    when: is_macos
    tags:
    - macos
    block:
    - name: Install dockutil for Dock management
      community.general.homebrew:
        name: dockutil
        state: present
      when: configure_dock | default(true)
    - name: Check if dockutil is available
      ansible.builtin.command: which dockutil
      register: dockutil_check
      changed_when: false
      failed_when: false
      when: configure_dock | default(true)
    - name: Configure Dock items
      ansible.builtin.shell: >
        {{ homebrew_prefix }}/bin/dockutil --remove 'Launchpad'
        --no-restart 2>/dev/null || true &&
        {{ homebrew_prefix }}/bin/dockutil --remove 'TV'
        --no-restart 2>/dev/null || true &&
        {{ homebrew_prefix }}/bin/dockutil --remove 'Podcasts'
        --no-restart 2>/dev/null || true &&
        {{ homebrew_prefix }}/bin/dockutil --remove 'App Store'
        --no-restart 2>/dev/null || true &&
        ({{ homebrew_prefix }}/bin/dockutil --find 'Messages' ||
        {{ homebrew_prefix }}/bin/dockutil --add
        '/System/Applications/Messages.app' --no-restart 2>/dev/null
        || true) &&
        ({{ homebrew_prefix }}/bin/dockutil --find 'Safari' ||
        {{ homebrew_prefix }}/bin/dockutil --add
        '/Applications/Safari.app' --position 2 --no-restart
        2>/dev/null || true) &&
        ({{ homebrew_prefix }}/bin/dockutil --find 'iTerm' ||
        {{ homebrew_prefix }}/bin/dockutil --add
        '/Applications/iTerm.app' --position 3 --no-restart
        2>/dev/null || true) &&
        ({{ homebrew_prefix }}/bin/dockutil --find 'Google Chrome' ||
        {{ homebrew_prefix }}/bin/dockutil --add
        '/Applications/Google Chrome.app' --position 4
        --no-restart 2>/dev/null || true) &&
        ({{ homebrew_prefix }}/bin/dockutil --find
        'Visual Studio Code' ||
        {{ homebrew_prefix }}/bin/dockutil --add
        '/Applications/Visual Studio Code.app' --position 5
        --no-restart 2>/dev/null || true) &&
        ({{ homebrew_prefix }}/bin/dockutil --find 'Slack' ||
        {{ homebrew_prefix }}/bin/dockutil --add
        '/Applications/Slack.app' --position 6 --no-restart
        2>/dev/null || true)
      register: dock_config
      when:
      - configure_dock | default(true)
      - dockutil_check.rc is defined
      - dockutil_check.rc == 0
      changed_when: false
      failed_when: false
    - name: Restart Dock
      ansible.builtin.command: killall Dock
      when: dock_config is changed
      changed_when: false
      failed_when: false
    - name: Configure macOS defaults
      community.general.osx_defaults:
        domain: '{{ item.domain }}'
        key: '{{ item.key }}'
        type: '{{ item.type }}'
        value: '{{ item.value }}'
        state: present
      loop:
      - domain: com.apple.dock
        key: autohide
        type: bool
        value: true
      - domain: com.apple.dock
        key: show-recents
        type: bool
        value: false
      - domain: com.apple.dock
        key: tilesize
        type: int
        value: 48
      - domain: com.apple.dock
        key: minimize-to-application
        type: bool
        value: true
      - domain: NSGlobalDomain
        key: AppleShowAllExtensions
        type: bool
        value: true
      - domain: com.apple.finder
        key: ShowPathbar
        type: bool
        value: true
      - domain: com.apple.finder
        key: ShowStatusBar
        type: bool
        value: true
      - domain: com.apple.finder
        key: FXPreferredViewStyle
        type: string
        value: Nlsv
      - domain: com.apple.finder
        key: FXDefaultSearchScope
        type: string
        value: SCcf
      - domain: com.apple.finder
        key: _FXShowPosixPathInTitle
        type: bool
        value: true
      - domain: NSGlobalDomain
        key: KeyRepeat
        type: int
        value: 2
      - domain: NSGlobalDomain
        key: InitialKeyRepeat
        type: int
        value: 15
      - domain: com.apple.screencapture
        key: location
        type: string
        value: ~/Desktop
      - domain: com.apple.screencapture
        key: type
        type: string
        value: png
      - domain: com.apple.screencapture
        key: disable-shadow
        type: bool
        value: true
      - domain: NSGlobalDomain
        key: NSAutomaticWindowAnimationsEnabled
        type: bool
        value: false
      - domain: NSGlobalDomain
        key: NSNavPanelExpandedStateForSaveMode
        type: bool
        value: true
      when: configure_macos_defaults | default(true)
      notify: restart_dock
  - name: Check if tmux is installed
    ansible.builtin.command: which tmux
    register: tmux_check
    changed_when: false
    failed_when: false
    tags:
    - always
  - name: Generate setup report
    ansible.builtin.set_fact:
      setup_report:
        hostname: '{{ ansible_hostname }}'
        os: |
          {{ ansible_distribution | default('Unknown') }}
          {{ ansible_distribution_version | default('') }}
        homebrew_installed: '{{ homebrew_check.stat.exists }}'
        packages_updated: |
          {{ brew_bundle_result is defined and
          brew_bundle_result is changed }}
        mise_updated: |
          {{ mise_install_result is defined and
          mise_install_result is changed }}
        shell_configured: '{{ ohmyzsh_check.stat.exists }}'
        tmux_configured: '{{ tmux_check is defined and tmux_check.rc == 0 }}'
        neovim_configured: '{{ install_neovim | default(true) }}'
        vscode_configured: |
          {{ vscode_check is defined and vscode_check.rc == 0 }}
    tags:
    - always
  - name: Display setup report
    ansible.builtin.debug:
      msg:
      - ==========================================
      - Setup Report for {{ ansible_hostname }}
      - ==========================================
      - 'OS: {{ setup_report.os }}'
      - |
        Homebrew: {{ 'Installed' if setup_report.homebrew_installed else 'Not
        Installed' }}
      - |
        Packages Updated: {{ 'Yes' if setup_report.packages_updated else 'No' }}
      - |
        mise Updated: {{ 'Yes' if setup_report.mise_updated else 'No' }}
      - |
        Shell Configured: {{ 'Yes' if setup_report.shell_configured else 'No' }}
      - |
        Tmux Configured: {{ 'Yes' if setup_report.tmux_configured else 'No' }}
      - |
        Neovim Configured: {{ 'Yes'
        if setup_report.neovim_configured else 'No' }}
      - |
        VS Code Configured: {{ 'Yes'
        if setup_report.vscode_configured else 'No' }}
      - ''
      - 'Next steps:'
      - '  1. Restart terminal: source ~/.zshrc'
      - '  2. Configure Powerlevel10k: p10k configure'
      - '  3. Open Neovim: nvim (or vim/vi aliases)'
      - '  4. Start tmux: tmux (Prefix is C-a)'
    tags:
    - always
  handlers:
  - name: restart_dock
    ansible.builtin.command: killall Dock
    failed_when: false
    changed_when: false
    when: is_macos