The Joy of Never Touching the Mouse: 5 Key Strategies to Maximize Terminal Productivity

┌─────────────────────────────────────────────────────────────┐
│                    Terminal Emulator (Ghostty)              │
│  ┌──────────────────────────┬──────────────────────────────┐ │
│  │                          │                              │ │
│  │    Vim/Neovim (Code)     │     Tmux Pane (Server Log)   │ │
│  │                          │                              │ │
│  │    - File browsing       │     $ tail -f app.log        │ │
│  │    - Code editing        │                              │ │
│  │    - LSP autocomplete    │                              │ │
│  │                          │                              │ │
│  ├──────────────────────────┤                              │ │
│  │                          │                              │ │
│  │    Vimux (Test runner)   │                              │ │
│  │                          │                              │ │
│  │    $ pytest -v tests/    │                              │ │
│  │    ✓ 12 passed           │                              │ │
│  │                          │                              │ │
│  └──────────────────────────┴──────────────────────────────┘ │
│  [0] dev* [1] server [2] db           youngjukim 15:42      │
└─────────────────────────────────────────────────────────────┘

# Version check
vim --version | head -1    # Vim 9.0+ or
nvim --version | head -1   # Neovim 0.10+
tmux -V                    # tmux 3.3+
git --version              # Git 2.40+

# macOS (Homebrew)
brew install --cask ghostty

# Linux (may require building from source — check official packages)
# https://ghostty.org/docs

# ~/.config/ghostty/config
font-family = Monaspace Neon
font-size = 14
font-feature = calt
font-feature = liga
font-feature = ss01
font-feature = ss02
font-feature = ss03
font-feature = ss09

theme = catppuccin-mocha
cursor-style = block
cursor-style-blink = false
shell-integration = zsh

window-padding-x = 8
window-padding-y = 4
window-decoration = true

# When using with Tmux — prefer Tmux over Ghostty's own tabs/splits
keybind = super+t=unbind

# macOS
brew tap homebrew/cask-fonts
brew install font-monaspace

# Linux — manual installation
mkdir -p ~/.local/share/fonts
cd /tmp
wget https://github.com/githubnext/monaspace/releases/latest/download/monaspace-v1.101.zip
unzip monaspace-v1.101.zip -d monaspace
cp monaspace/monaspace-v1.101/fonts/otf/*.otf ~/.local/share/fonts/
fc-cache -fv

# Nerd Font patched version (if icons are needed)
brew install font-monaspace-nerd-font   # macOS

# macOS
brew install neovim

# Ubuntu / Debian (latest version)
sudo add-apt-repository ppa:neovim-ppa/unstable
sudo apt update && sudo apt install -y neovim

# Arch Linux
sudo pacman -S neovim

# AppImage (universal)
curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim.appimage
chmod u+x nvim.appimage
sudo mv nvim.appimage /usr/local/bin/nvim

# macOS
brew install tmux

# Ubuntu / Debian
sudo apt install -y tmux

# TPM installation
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

# Backup existing config (if any)
mv ~/.config/nvim{,.bak}
mv ~/.local/share/nvim{,.bak}
mv ~/.local/state/nvim{,.bak}
mv ~/.cache/nvim{,.bak}

# Clone Kickstart
git clone https://github.com/nvim-lua/kickstart.nvim.git ~/.config/nvim

# Launch Neovim — plugins install automatically
nvim

# Installation
curl -sS https://starship.rs/install.sh | sh

# Add to ~/.zshrc
echo 'eval "$(starship init zsh)"' >> ~/.zshrc

# Or add to ~/.bashrc
echo 'eval "$(starship init bash)"' >> ~/.bashrc

# ~/.config/starship.toml

# Do not add blank line at top of prompt
add_newline = false

# Customize prompt format
format = """
$directory\
$git_branch\
$git_status\
$python\
$nodejs\
$golang\
$rust\
$kubernetes\
$docker_context\
$cmd_duration\
$line_break\
$character"""

[character]
success_symbol = "[➜](bold green)"
error_symbol = "[✗](bold red)"

[directory]
truncation_length = 3
truncation_symbol = "…/"
style = "bold cyan"

[git_branch]
format = "[$symbol$branch(:$remote_branch)]($style) "
symbol = " "
style = "bold purple"

[git_status]
format = '([\[$all_status$ahead_behind\]]($style) )'
style = "bold red"

[python]
format = '[${symbol}${pyenv_prefix}(${version} )(\($virtualenv\) )]($style)'
symbol = " "

[nodejs]
format = "[$symbol($version )]($style)"
symbol = " "

[golang]
format = "[$symbol($version )]($style)"
symbol = " "

[rust]
format = "[$symbol($version )]($style)"
symbol = " "

[kubernetes]
disabled = false
format = '[$symbol$context( \($namespace\))]($style) '
symbol = "⎈ "
style = "bold blue"

[docker_context]
format = "[$symbol$context]($style) "
symbol = " "

[cmd_duration]
min_time = 2_000
format = "[$duration]($style) "
style = "bold yellow"

┌─────────────────────────────────────────┐
│  Tmux World                             │
│  ┌──────────────┬──────────────────────┐ │
│  │              │                      │ │
│  │  Vim World   │                      │ │
│  │  ┌────┬────┐ │    Tmux Pane 2       │ │
│  │  │Vim │Vim │ │    (shell)           │ │
│  │  │Split│Split│ │                      │ │
│  │  │ 1  │ 2  │ │                      │ │
│  │  └────┴────┘ │                      │ │
│  │              │                      │ │
│  │  Tmux Pane 1 │                      │ │
│  └──────────────┴──────────────────────┘ │
└─────────────────────────────────────────┘

" ~/.vimrc or ~/.config/nvim/init.vim

call plug#begin('~/.vim/plugged')

Plug 'christoomey/vim-tmux-navigator'

call plug#end()

" Disable navigation when zoomed (optional)
let g:tmux_navigator_disable_when_zoomed = 1

" Preserve zoom while navigating (optional)
" let g:tmux_navigator_preserve_zoom = 1

-- ~/.config/nvim/lua/plugins/tmux-navigator.lua

return {
  "christoomey/vim-tmux-navigator",
  cmd = {
    "TmuxNavigateLeft",
    "TmuxNavigateDown",
    "TmuxNavigateUp",
    "TmuxNavigateRight",
    "TmuxNavigatePrevious",
  },
  keys = {
    { "<C-h>", "<cmd>TmuxNavigateLeft<cr>",  desc = "Navigate Left" },
    { "<C-j>", "<cmd>TmuxNavigateDown<cr>",  desc = "Navigate Down" },
    { "<C-k>", "<cmd>TmuxNavigateUp<cr>",    desc = "Navigate Up" },
    { "<C-l>", "<cmd>TmuxNavigateRight<cr>", desc = "Navigate Right" },
  },
}

# ~/.tmux.conf — vim-tmux-navigator integration

# When using TPM
set -g @plugin 'christoomey/vim-tmux-navigator'

# Or manual setup (when not using TPM)
is_vim="ps -o state= -o comm= -t '#{pane_tty}' \
    | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|l?n?vim?x?|fzf)(diff)?$'"

bind-key -n 'C-h' if-shell "$is_vim" 'send-keys C-h'  'select-pane -L'
bind-key -n 'C-j' if-shell "$is_vim" 'send-keys C-j'  'select-pane -D'
bind-key -n 'C-k' if-shell "$is_vim" 'send-keys C-k'  'select-pane -U'
bind-key -n 'C-l' if-shell "$is_vim" 'send-keys C-l'  'select-pane -R'

tmux_version='$(tmux -V | sed -En "s/^tmux ([0-9]+(.[0-9]+)?).*/\1/p")'
if-shell -b '[ "$(echo "$tmux_version >= 3.0" | bc)" = 1 ]' \
    "bind-key -n 'C-\\' if-shell \"$is_vim\" 'send-keys C-\\\\'  'select-pane -l'"
if-shell -b '[ "$(echo "$tmux_version < 3.0" | bc)" = 1 ]' \
    "bind-key -n 'C-\\' if-shell \"$is_vim\" 'send-keys C-\\\\'  'select-pane -l'"

bind-key -T copy-mode-vi 'C-h' select-pane -L
bind-key -T copy-mode-vi 'C-j' select-pane -D
bind-key -T copy-mode-vi 'C-k' select-pane -U
bind-key -T copy-mode-vi 'C-l' select-pane -R

# ~/.tmux.conf — restore screen clear
# prefix + Ctrl-l to clear screen
bind C-l send-keys 'C-l'

 Flow of thought (no interruption)
 ─────────────────────────────────────────────────────────

 "Let me check the test result for this function"
     │
     ▼
 Ctrl-j  (move to Vimux pane below — Vim/Tmux boundary transparent)
     │
     ▼
 "Tests passed. Let me check the logs"
     │
     ▼
 Ctrl-l  (move to log pane on the right — boundary also transparent)
     │
     ▼
 "Need to fix something. Back to the code"
     │
     ▼
 Ctrl-h  (return to Vim on the left)
     │
     ▼
 Continue editing code...

 — Throughout this entire process, the mouse was never touched —

# ~/.tmux.conf — intuitive panel splitting

# | looks like a vertical line → vertical split (left/right)
bind | split-window -h -c "#{pane_current_path}"

# - looks like a horizontal line → horizontal split (top/bottom)
bind - split-window -v -c "#{pane_current_path}"

# Remove default keybindings (prevent confusion)
unbind '"'
unbind %

 prefix + |                    prefix + -

 Before split:                 Before split:
 ┌──────────────┐              ┌──────────────┐
 │              │              │              │
 │              │              │              │
 │              │              │              │
 └──────────────┘              └──────────────┘

 After split:                  After split:
 ┌──────┬───────┐              ┌──────────────┐
 │      │       │              │              │
 │      │       │              ├──────────────┤
 │      │       │              │              │
 └──────┴───────┘              └──────────────┘

 | = vertical line = vertical split    - = horizontal line = horizontal split

 ┌─────────────────────────┐
 │                         │
 │     Vim (code editing)  │
 │                         │
 │                         │
 ├─────────────────────────┤
 │  Test runner (Vimux)    │
 └─────────────────────────┘

 Setup: prefix + - once

 ┌──────────────────┬──────────────┐
 │                  │              │
 │  Vim (code)      │  Server log  │
 │                  │              │
 │                  │              │
 ├──────────────────┤              │
 │                  │              │
 │  Terminal (git,  │              │
 │  build, etc.)    │              │
 └──────────────────┴──────────────┘

 Setup: prefix + | → then prefix + - on the left

 ┌──────────────────┬──────────────┐
 │                  │              │
 │  Service A log   │  Service B log│
 │                  │              │
 ├──────────────────┼──────────────┤
 │                  │              │
 │  Service C log   │  Metrics/htop│
 │                  │              │
 └──────────────────┴──────────────┘

 Setup: prefix + | → then prefix + - in each pane

# ~/.tmux.conf — pane resize

# Vim-style directional keys for resizing
bind -r H resize-pane -L 5
bind -r J resize-pane -D 5
bind -r K resize-pane -U 5
bind -r L resize-pane -R 5

# -r flag: repeatable (press prefix once, then repeat key within timeout)

 Edit code (Vim)
     │
     ▼
 Exit Vim or Ctrl-Z (suspend)
     │
     ▼
 Type command in terminal (pytest, go test, npm test...)
     │
     ▼
 Check results
     │
     ▼
 Return to Vim (fg or relaunch vim)
     │
     ▼
 "Where was I editing again..."

" ~/.vimrc
Plug 'preservim/vimux'

-- ~/.config/nvim/lua/plugins/vimux.lua

return {
  "preservim/vimux",
  keys = {
    { "<Leader>vp", "<cmd>VimuxPromptCommand<cr>",   desc = "Vimux Prompt" },
    { "<Leader>vl", "<cmd>VimuxRunLastCommand<cr>",   desc = "Vimux Run Last" },
    { "<Leader>vi", "<cmd>VimuxInspectRunner<cr>",    desc = "Vimux Inspect" },
    { "<Leader>vz", "<cmd>VimuxZoomRunner<cr>",       desc = "Vimux Zoom" },
    { "<Leader>vc", "<cmd>VimuxCloseRunner<cr>",      desc = "Vimux Close" },
  },
  config = function()
    -- Vimux pane height (in %)
    vim.g.VimuxHeight = "30"
    -- Pane direction (horizontal bottom)
    vim.g.VimuxOrientation = "v"
    -- Runner type
    vim.g.VimuxRunnerType = "pane"
  end,
}

-- Add to ~/.config/nvim/lua/plugins/vimux.lua

-- Python: Run tests on current file
vim.keymap.set("n", "<Leader>tt", function()
  local file = vim.fn.expand("%")
  vim.fn.VimuxRunCommand("pytest -v " .. file)
end, { desc = "Run pytest on current file" })

-- Python: Run only the test function at current cursor position
vim.keymap.set("n", "<Leader>ts", function()
  local file = vim.fn.expand("%")
  local line = vim.fn.line(".")
  -- pytest-picked or line-based selection
  vim.fn.VimuxRunCommand("pytest -v " .. file .. " --no-header -rN")
end, { desc = "Run pytest on current test" })

-- Python: Full test suite
vim.keymap.set("n", "<Leader>ta", function()
  vim.fn.VimuxRunCommand("pytest -v --tb=short")
end, { desc = "Run all tests" })

-- Go: Test current package
vim.keymap.set("n", "<Leader>tt", function()
  vim.fn.VimuxRunCommand("go test -v ./...")
end, { desc = "Run Go tests" })

-- Go: Test only the package of the current file
vim.keymap.set("n", "<Leader>tf", function()
  local dir = vim.fn.expand("%:h")
  vim.fn.VimuxRunCommand("go test -v ./" .. dir .. "/...")
end, { desc = "Run Go tests in current package" })

-- Go: Benchmarks
vim.keymap.set("n", "<Leader>tb", function()
  vim.fn.VimuxRunCommand("go test -bench=. -benchmem ./...")
end, { desc = "Run Go benchmarks" })

-- Jest: Test current file
vim.keymap.set("n", "<Leader>tt", function()
  local file = vim.fn.expand("%")
  vim.fn.VimuxRunCommand("npx jest " .. file .. " --verbose")
end, { desc = "Run Jest on current file" })

-- Jest: Watch mode
vim.keymap.set("n", "<Leader>tw", function()
  local file = vim.fn.expand("%")
  vim.fn.VimuxRunCommand("npx jest " .. file .. " --watch")
end, { desc = "Run Jest in watch mode" })

-- Jest: All tests
vim.keymap.set("n", "<Leader>ta", function()
  vim.fn.VimuxRunCommand("npx jest --verbose")
end, { desc = "Run all Jest tests" })

-- Rust: cargo test
vim.keymap.set("n", "<Leader>tt", function()
  vim.fn.VimuxRunCommand("cargo test")
end, { desc = "Run cargo test" })

-- Rust: cargo test with output
vim.keymap.set("n", "<Leader>to", function()
  vim.fn.VimuxRunCommand("cargo test -- --nocapture")
end, { desc = "Run cargo test with output" })

-- Rust: cargo clippy
vim.keymap.set("n", "<Leader>tc", function()
  vim.fn.VimuxRunCommand("cargo clippy -- -W clippy::all")
end, { desc = "Run cargo clippy" })

  "Find, read, and run" in a single context
  ──────────────────────────────────────

  ┌─────────────────────────────────┐
  │ Vim (code editing)              │
  │                                 │
  │  def add(a, b):                 │
  │      return a + b  ← editing    │
  │                                 │
  │  ~                              │
  │  ~                              │
  ├─────────────────────────────────┤
  │ Vimux Runner (test results)     │
  │                                 │
  │  $ pytest -v test_calc.py       │
  │  test_add PASSED ✓              │
  │  test_subtract FAILED ✗         │
  │  1 failed, 1 passed             │
  └─────────────────────────────────┘

  <Leader>tt → Run tests (eyes move only, hands stay put)
  <Leader>vl → Re-run last command (verify immediately after edit)

 ┌──────────┐    ┌──────────┐    ┌──────────┐
 │ Vim      │    │ Tmux     │    │ OS       │
 │ Register │ ✗  │ Buffer   │ ✗  │ Clipboard│
 │ ("a, "b) │    │ (paste   │    │ (Cmd-V)  │
 │          │←──→│  buffer) │←──→│          │
 └──────────┘    └──────────┘    └──────────┘
       Disconnected     Disconnected

 Goal: Synchronize all three systems

# ~/.tmux.conf — macOS clipboard sync

# Enable set-clipboard
set -s set-clipboard on

# Copy to system clipboard after selection in copy mode
bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "pbcopy"

# Auto-copy after mouse drag (when using mouse)
bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"

# Also copy to clipboard with Enter key
bind-key -T copy-mode-vi Enter send-keys -X copy-pipe-and-cancel "pbcopy"

-- ~/.config/nvim/init.lua or lua/config/options.lua

-- Use system clipboard as unnamed plus register
vim.opt.clipboard = "unnamedplus"

-- On macOS, this alone is sufficient.
-- Neovim automatically detects pbcopy/pbpaste.

# Install xclip
sudo apt install -y xclip   # Debian/Ubuntu
sudo pacman -S xclip         # Arch

# ~/.tmux.conf
set -s set-clipboard on
bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "xclip -selection clipboard"
bind-key -T copy-mode-vi Enter send-keys -X copy-pipe-and-cancel "xclip -selection clipboard"

-- Neovim (Linux X11)
vim.opt.clipboard = "unnamedplus"

-- Explicit clipboard provider (optional)
vim.g.clipboard = {
  name = "xclip",
  copy = {
    ["+"] = "xclip -selection clipboard",
    ["*"] = "xclip -selection primary",
  },
  paste = {
    ["+"] = "xclip -selection clipboard -o",
    ["*"] = "xclip -selection primary -o",
  },
  cache_enabled = 0,
}

# Install wl-clipboard
sudo apt install -y wl-clipboard   # Debian/Ubuntu
sudo pacman -S wl-clipboard         # Arch

# ~/.tmux.conf
set -s set-clipboard on
bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "wl-copy"
bind-key -T copy-mode-vi Enter send-keys -X copy-pipe-and-cancel "wl-copy"

-- Neovim (Wayland)
vim.opt.clipboard = "unnamedplus"

vim.g.clipboard = {
  name = "wl-clipboard",
  copy = {
    ["+"] = "wl-copy",
    ["*"] = "wl-copy --primary",
  },
  paste = {
    ["+"] = "wl-paste --no-newline",
    ["*"] = "wl-paste --no-newline --primary",
  },
  cache_enabled = 0,
}

# ~/.tmux.conf (remote server)

# Clipboard sync via OSC 52
set -s set-clipboard on
set -g allow-passthrough on

# Your terminal emulator must support OSC 52
# Ghostty, Alacritty, WezTerm, iTerm2, etc. support it

-- Neovim (remote server) — OSC 52 support
-- Built-in from Neovim 0.10+

vim.opt.clipboard = "unnamedplus"

-- Explicit configuration when OSC 52 is not auto-detected
vim.g.clipboard = {
  name = "OSC 52",
  copy = {
    ["+"] = require("vim.ui.clipboard.osc52").copy("+"),
    ["*"] = require("vim.ui.clipboard.osc52").copy("*"),
  },
  paste = {
    ["+"] = require("vim.ui.clipboard.osc52").paste("+"),
    ["*"] = require("vim.ui.clipboard.osc52").paste("*"),
  },
}

 ┌──────────┐    ┌──────────┐    ┌──────────┐
 │ Vim      │    │ Tmux     │    │ OS       │
 │ Register │ ✓  │ Buffer   │ ✓  │ Clipboard│
 │ yy/p     │◄──►│ copy-mode│◄──►│ Cmd-V    │
 └──────────┘    └──────────┘    └──────────┘
      Synced             Synced

 yy in Vim → Cmd-V in browser ✓
 Cmd-C in browser → p in Vim ✓
 Tmux copy-mode → Paste into Slack ✓

# Initial setup
git init --bare $HOME/.dotfiles
alias dotfiles='git --git-dir=$HOME/.dotfiles/ --work-tree=$HOME'
dotfiles config --local status.showUntrackedFiles no

# Add alias to .bashrc or .zshrc
echo "alias dotfiles='git --git-dir=\$HOME/.dotfiles/ --work-tree=\$HOME'" >> ~/.zshrc

# Add files
dotfiles add ~/.tmux.conf
dotfiles add ~/.config/nvim/init.lua
dotfiles commit -m "Add tmux and neovim config"
dotfiles remote add origin git@github.com:username/dotfiles.git
dotfiles push -u origin main

# Restore on new machine
git clone --bare git@github.com:username/dotfiles.git $HOME/.dotfiles
alias dotfiles='git --git-dir=$HOME/.dotfiles/ --work-tree=$HOME'
dotfiles checkout

# Installation
sudo apt install stow   # Debian/Ubuntu
brew install stow        # macOS

# Directory structure
~/dotfiles/
├── tmux/
│   └── .tmux.conf
├── nvim/
│   └── .config/
│       └── nvim/
│           └── init.lua
├── zsh/
│   └── .zshrc
└── starship/
    └── .config/
        └── starship.toml

# Create symlinks
cd ~/dotfiles
stow tmux      # ~/.tmux.conf → ~/dotfiles/tmux/.tmux.conf
stow nvim      # ~/.config/nvim/init.lua → ~/dotfiles/nvim/.config/nvim/init.lua
stow zsh       # ~/.zshrc → ~/dotfiles/zsh/.zshrc
stow starship  # ~/.config/starship.toml → ~/dotfiles/starship/.config/starship.toml

# Remove symlinks
stow -D tmux

# Installation
brew install chezmoi         # macOS
sudo apt install chezmoi     # Debian/Ubuntu (snap also available)
sh -c "$(curl -fsLS get.chezmoi.io)"  # Universal

# Initialization
chezmoi init

# Add files
chezmoi add ~/.tmux.conf
chezmoi add ~/.config/nvim/init.lua
chezmoi add ~/.config/starship.toml

# Edit
chezmoi edit ~/.tmux.conf

# Preview changes
chezmoi diff

# Apply
chezmoi apply

# Push to Git repository
chezmoi cd  # Navigate to chezmoi source directory
git add . && git commit -m "Update dotfiles" && git push

# One-line restore on new machine
sh -c "$(curl -fsLS get.chezmoi.io)" -- init --apply username

# ~/.local/share/chezmoi/dot_tmux.conf.tmpl

# Common settings
set -g default-terminal "tmux-256color"
set -g mouse on

# Clipboard — OS-specific branching
{{ if eq .chezmoi.os "darwin" -}}
bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "pbcopy"
{{ else if eq .chezmoi.os "linux" -}}
{{   if env "WAYLAND_DISPLAY" -}}
bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "wl-copy"
{{   else -}}
bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "xclip -selection clipboard"
{{   end -}}
{{ end -}}

# ============================================================
# .tmux.conf — Complete configuration for maximum productivity
# ============================================================

# ─── Basic Settings ─────────────────────────────────────────

# 256 color and True Color support
set -g default-terminal "tmux-256color"
set -ag terminal-overrides ",xterm-256color:RGB"
set -ag terminal-overrides ",*256col*:Tc"

# History size
set -g history-limit 50000

# Minimize escape sequence delay (important for Vim)
set -sg escape-time 0

# Repeat key timeout
set -g repeat-time 500

# Enable focus events (needed for Vim autoread, etc.)
set -g focus-events on

# Start index from 1 (0 is far from the keyboard)
set -g base-index 1
setw -g pane-base-index 1

# Auto-renumber windows
set -g renumber-windows on

# Mouse support
set -g mouse on

# Vi key mode
setw -g mode-keys vi

# ─── Change Prefix Key ──────────────────────────────────────

# Ctrl-a is more comfortable than Ctrl-b
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# ─── Intuitive Panel Splitting [Strategy 2] ─────────────────

bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"
unbind '"'
unbind %

# New windows also preserve current path
bind c new-window -c "#{pane_current_path}"

# ─── Pane Resize ──────────────────────────────────────────

bind -r H resize-pane -L 5
bind -r J resize-pane -D 5
bind -r K resize-pane -U 5
bind -r L resize-pane -R 5

# ─── vim-tmux-navigator [Strategy 1] ───────────────────────

# One line is sufficient when installing via TPM
set -g @plugin 'christoomey/vim-tmux-navigator'

# Restore Ctrl-l screen clear
bind C-l send-keys 'C-l'

# ─── Copy Mode and Clipboard [Strategy 4] ─────────────────

# Vi-style copy mode
bind-key -T copy-mode-vi v send-keys -X begin-selection
bind-key -T copy-mode-vi C-v send-keys -X rectangle-toggle
bind-key -T copy-mode-vi y send-keys -X copy-selection-and-cancel

# System clipboard sync
set -s set-clipboard on

# macOS
if-shell "uname | grep -q Darwin" {
  bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "pbcopy"
  bind-key -T copy-mode-vi Enter send-keys -X copy-pipe-and-cancel "pbcopy"
  bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"
}

# Linux (X11)
if-shell "[ -n \"$DISPLAY\" ] && command -v xclip > /dev/null" {
  bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "xclip -selection clipboard"
  bind-key -T copy-mode-vi Enter send-keys -X copy-pipe-and-cancel "xclip -selection clipboard"
}

# Linux (Wayland)
if-shell "[ -n \"$WAYLAND_DISPLAY\" ] && command -v wl-copy > /dev/null" {
  bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "wl-copy"
  bind-key -T copy-mode-vi Enter send-keys -X copy-pipe-and-cancel "wl-copy"
}

# ─── Status Bar Customization ──────────────────────────────

set -g status-position bottom
set -g status-style "bg=#1e1e2e,fg=#cdd6f4"
set -g status-left-length 40
set -g status-right-length 80

set -g status-left "#[fg=#1e1e2e,bg=#89b4fa,bold]  #S #[fg=#89b4fa,bg=#1e1e2e] "
set -g status-right "#[fg=#a6adc8] %Y-%m-%d  %H:%M #[fg=#1e1e2e,bg=#a6e3a1,bold]  #H "

# Window status bar
setw -g window-status-format "#[fg=#6c7086] #I:#W "
setw -g window-status-current-format "#[fg=#1e1e2e,bg=#cba6f7,bold] #I:#W "

# Pane borders
set -g pane-border-style "fg=#313244"
set -g pane-active-border-style "fg=#89b4fa"

# ─── Utilities ────────────────────────────────────────────

# Reload config
bind r source-file ~/.tmux.conf \; display-message "Config reloaded!"

# Session switcher
bind s choose-tree -Zs

# Synchronized input toggle (same input to all panes)
bind S setw synchronize-panes \; display-message "Synchronize #{?synchronize-panes,ON,OFF}"

# ─── TPM (Tmux Plugin Manager) ───────────────────────────

set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @plugin 'tmux-plugins/tmux-continuum'

# tmux-resurrect: Neovim session restoration
set -g @resurrect-strategy-nvim 'session'

# tmux-continuum: Auto-save
set -g @continuum-restore 'on'
set -g @continuum-save-interval '15'

# TPM initialization (must be at the very end)
run '~/.tmux/plugins/tpm/tpm'

-- ============================================================
-- Neovim init.lua — Vim + Tmux Integration Core Settings
-- Based on kickstart.nvim
-- ============================================================

-- ─── Basic Options ──────────────────────────────────────

vim.g.mapleader = " "        -- Leader = space
vim.g.maplocalleader = " "

vim.opt.number = true         -- Line numbers
vim.opt.relativenumber = true -- Relative line numbers
vim.opt.signcolumn = "yes"    -- Always show sign column
vim.opt.cursorline = true     -- Highlight current line
vim.opt.termguicolors = true  -- True Color
vim.opt.scrolloff = 8         -- Scroll margin
vim.opt.sidescrolloff = 8
vim.opt.wrap = false          -- Disable line wrapping

-- Search
vim.opt.ignorecase = true
vim.opt.smartcase = true
vim.opt.hlsearch = true
vim.opt.incsearch = true

-- Indentation
vim.opt.expandtab = true
vim.opt.shiftwidth = 2
vim.opt.tabstop = 2
vim.opt.smartindent = true

-- System clipboard sync [Strategy 4]
vim.opt.clipboard = "unnamedplus"

-- Auto-detect file changes (works with Tmux focus-events)
vim.opt.autoread = true
vim.api.nvim_create_autocmd({ "FocusGained", "BufEnter" }, {
  command = "checktime",
})

-- ─── lazy.nvim Bootstrap ────────────────────────────────

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git", "clone", "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable", lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

-- ─── Plugins ──────────────────────────────────────────

require("lazy").setup({

  -- vim-tmux-navigator [Strategy 1]
  {
    "christoomey/vim-tmux-navigator",
    cmd = {
      "TmuxNavigateLeft",
      "TmuxNavigateDown",
      "TmuxNavigateUp",
      "TmuxNavigateRight",
      "TmuxNavigatePrevious",
    },
    keys = {
      { "<C-h>", "<cmd>TmuxNavigateLeft<cr>",  desc = "Navigate Left" },
      { "<C-j>", "<cmd>TmuxNavigateDown<cr>",  desc = "Navigate Down" },
      { "<C-k>", "<cmd>TmuxNavigateUp<cr>",    desc = "Navigate Up" },
      { "<C-l>", "<cmd>TmuxNavigateRight<cr>", desc = "Navigate Right" },
    },
  },

  -- Vimux [Strategy 3]
  {
    "preservim/vimux",
    keys = {
      { "<Leader>vp", "<cmd>VimuxPromptCommand<cr>",   desc = "Vimux Prompt" },
      { "<Leader>vl", "<cmd>VimuxRunLastCommand<cr>",   desc = "Vimux Run Last" },
      { "<Leader>vi", "<cmd>VimuxInspectRunner<cr>",    desc = "Vimux Inspect" },
      { "<Leader>vz", "<cmd>VimuxZoomRunner<cr>",       desc = "Vimux Zoom" },
      { "<Leader>vc", "<cmd>VimuxCloseRunner<cr>",      desc = "Vimux Close" },
    },
    config = function()
      vim.g.VimuxHeight = "30"
      vim.g.VimuxOrientation = "v"
      vim.g.VimuxRunnerType = "pane"

      -- Language-specific test run mappings
      -- Python
      vim.keymap.set("n", "<Leader>tp", function()
        vim.fn.VimuxRunCommand("pytest -v " .. vim.fn.expand("%"))
      end, { desc = "Run pytest" })

      -- Go
      vim.keymap.set("n", "<Leader>tg", function()
        vim.fn.VimuxRunCommand("go test -v ./...")
      end, { desc = "Run go test" })

      -- Node.js
      vim.keymap.set("n", "<Leader>tj", function()
        vim.fn.VimuxRunCommand("npx jest " .. vim.fn.expand("%") .. " --verbose")
      end, { desc = "Run jest" })

      -- Rust
      vim.keymap.set("n", "<Leader>tr", function()
        vim.fn.VimuxRunCommand("cargo test")
      end, { desc = "Run cargo test" })

      -- Universal: Re-run last test
      vim.keymap.set("n", "<Leader>tl", function()
        vim.fn.VimuxRunLastCommand()
      end, { desc = "Run last test" })
    end,
  },

  -- Telescope (fuzzy finder)
  {
    "nvim-telescope/telescope.nvim",
    branch = "0.1.x",
    dependencies = { "nvim-lua/plenary.nvim" },
    keys = {
      { "<Leader>ff", "<cmd>Telescope find_files<cr>", desc = "Find Files" },
      { "<Leader>fg", "<cmd>Telescope live_grep<cr>",  desc = "Live Grep" },
      { "<Leader>fb", "<cmd>Telescope buffers<cr>",    desc = "Buffers" },
      { "<Leader>fh", "<cmd>Telescope help_tags<cr>",  desc = "Help Tags" },
    },
  },

  -- Treesitter (syntax highlighting)
  {
    "nvim-treesitter/nvim-treesitter",
    build = ":TSUpdate",
    config = function()
      require("nvim-treesitter.configs").setup({
        ensure_installed = {
          "lua", "vim", "vimdoc", "python", "go",
          "javascript", "typescript", "rust", "bash",
          "json", "yaml", "toml", "markdown",
        },
        highlight = { enable = true },
        indent = { enable = true },
      })
    end,
  },

  -- Theme
  {
    "catppuccin/nvim",
    name = "catppuccin",
    priority = 1000,
    config = function()
      require("catppuccin").setup({
        flavour = "mocha",
        transparent_background = false,
        integrations = {
          telescope = true,
          treesitter = true,
          which_key = true,
        },
      })
      vim.cmd.colorscheme("catppuccin")
    end,
  },

  -- which-key (keybinding discovery)
  {
    "folke/which-key.nvim",
    event = "VeryLazy",
    config = function()
      require("which-key").setup()
    end,
  },
})

-- ─── Additional Key Mappings ────────────────────────────

-- Clear search highlight with ESC
vim.keymap.set("n", "<Esc>", "<cmd>nohlsearch<cr>")

-- Split window navigation (redundant with vim-tmux-navigator, for reference)
-- vim.keymap.set("n", "<C-h>", "<C-w>h")
-- vim.keymap.set("n", "<C-j>", "<C-w>j")
-- vim.keymap.set("n", "<C-k>", "<C-w>k")
-- vim.keymap.set("n", "<C-l>", "<C-w>l")

-- Move selected block in visual mode
vim.keymap.set("v", "J", ":m '>+1<cr>gv=gv")
vim.keymap.set("v", "K", ":m '<-2<cr>gv=gv")

-- Keep screen centered
vim.keymap.set("n", "<C-d>", "<C-d>zz")
vim.keymap.set("n", "<C-u>", "<C-u>zz")
vim.keymap.set("n", "n", "nzzzv")
vim.keymap.set("n", "N", "Nzzzv")

 ┌────────────────────────────────────────────────────┐
 │  Estimated Daily Context Switching Cumulative Cost  │
 ├────────────────────────────────────────────────────┤
 │                                                    │
 │  File open: 50x/day × 3s saved = 150s (2.5 min)   │
 │  Window switch: 200x/day × 2s saved = 400s (6.7 min)│
 │  Tests: 30x/day × 3s saved = 90s (1.5 min)        │
 │  Copy/paste: 40x/day × 2s saved = 80s (1.3 min)   │
 │  Other ops: 100x/day × 1s saved = 100s (1.7 min)  │
 │                                                    │
 │  ─────────────────────────────────────────────      │
 │  Daily savings: approx. 14 min (pure action time)  │
 │  + Cognitive load reduction for focus: immeasurable │
 │  + Flow state maintenance effect: immeasurable      │
 │                                                    │
 │  Annual (250 working days): approx. 58 hours       │
 │  = 7.25 working days                               │
 └────────────────────────────────────────────────────┘

# ~/.tmux.conf — lightweight alternative (no plugin)
is_vim="ps -o state= -o comm= -t '#{pane_tty}' \
    | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|l?n?vim?x?)(diff)?$'"

bind-key -n C-h if-shell "$is_vim" "send-keys C-h" "select-pane -L"
bind-key -n C-j if-shell "$is_vim" "send-keys C-j" "select-pane -D"
bind-key -n C-k if-shell "$is_vim" "send-keys C-k" "select-pane -U"
bind-key -n C-l if-shell "$is_vim" "send-keys C-l" "select-pane -R"

-- Neovim-side lightweight implementation
local function navigate(direction)
  local nr = vim.fn.winnr()
  vim.cmd("wincmd " .. direction)
  if nr == vim.fn.winnr() then
    local tmux_dir = ({ h = "L", j = "D", k = "U", l = "R" })[direction]
    vim.fn.system("tmux select-pane -" .. tmux_dir)
  end
end

vim.keymap.set("n", "<C-h>", function() navigate("h") end)
vim.keymap.set("n", "<C-j>", function() navigate("j") end)
vim.keymap.set("n", "<C-k>", function() navigate("k") end)
vim.keymap.set("n", "<C-l>", function() navigate("l") end)

# ~/.tmux.conf
set -g default-terminal "tmux-256color"
set -ag terminal-overrides ",xterm-256color:RGB"

# When using Ghostty
set -ag terminal-overrides ",xterm-ghostty:RGB"

# ~/.tmux.conf
set -sg escape-time 0   # Default is 500ms — must set to 0

# Check terminal emulator's OSC 52 support (local)
printf '\033]52;c;%s\a' $(echo -n "test" | base64)
# If "test" can be pasted with Cmd-V afterward, OSC 52 is supported

# Tmux settings
set -s set-clipboard on
set -g allow-passthrough on

 Week 1: Tmux basics + intuitive panel splitting (|, -)
    │
    ▼
 Week 2: vim-tmux-navigator setup (Ctrl-h/j/k/l)
    │
    ▼
 Week 3: Vimux setup + map frequently used test commands
    │
    ▼
 Week 4: Clipboard sync + start Git-managing Dotfiles
    │
    ▼
 Month 2+: Fine-tune your own workflow
    │
    ▼
 ∞: "The joy of never touching the mouse"