Belajar Tmux - Integrasi dengan Editor & Developer Ecosystem

#Pendahuluan

Di episode 24 sebelumnya kita membahas performance & resource optimization — bagaimana membuat tmux ringan, cepat dimulai, dan hemat resource. Pada episode ini kita memakai fondasi itu untuk membangun sesuatu yang lebih besar: integrasi dengan editor & developer ecosystem. Terminal yang ringan akan terasa sia-sia jika tidak terhubung mulus dengan alat yang kalian pakai sepanjang hari — editor, git, dan pemilih session.

Ada satu tegangan yang dialami hampir semua developer: editor dan terminal adalah dua dunia yang sering terpisah. Di editor, kalian punya split, tab, dan navigasi cepat. Di tmux, kalian punya pane, window, dan session yang persisten. Tanpa jembatan, kalian berpindah antara dua "mode" dengan patahan: Ctrl+w di editor untuk navigasi, lalu prefix + arah di tmux untuk yang lain — ingatan yang berbeda, otot yang berbeda.

Pada episode ini kita akan merobohkan dinding itu. Kita mulai dari navigasi seamless antara pane tmux dan buffer editor dengan vim-tmux-navigator, lalu integrasi lazygit dan task runner di VS Code, kemudian membangun alur kerja keyboard-first dengan fzf sebagai session switcher dan t-smart-tmux-session-manager sebagai pengelola session modern. Di akhir episode, berpindah konteks antara editor, git, dan terminal akan terasa seperti satu gerakan, bukan tiga.

#Tmux + Editor: Dua Modalitas, Satu Alur Kerja

Tujuan integrasi bukan menghilangkan editor, melainkan membuat kedua alat saling memperkuat. Editor menangani pengeditan kode; tmux menangani hal yang tidak bisa dilakukan editor: session yang bertahan di balik SSH putus, window yang bisa di-reorganisasi tanpa menyentuh buffer, dan pane yang menjalankan proses nyata di lingkungan nyata.

#Mengapa Menggabungkan Tmux dengan Editor

Ada dua alasan praktis mengapa developer senior sering menjalankan editor di dalam tmux, bukan menyalakan editor lalu membuka terminal terpisah:

• Persistence: session tmux bertahan ketika SSH terputus atau laptop tertutup (episode 16). Editor di dalam tmux ikut bertahan — buffer, pane, dan layout tidak hilang.
• Konteks menyatu: dalam satu layar, kalian melihat editor, terminal untuk menjalankan test, dan log — saling terlihat, saling terkait. Tidak perlu memindahkan jendela untuk melihat konteks yang sedang dikerjakan.

Editor modern seperti Neovim sudah memiliki split internal. Pertanyaannya bukan "split mana yang lebih baik", melainkan "kapan memakai split editor dan kapan memakai pane tmux". Aturan praktisnya: split editor untuk berbagai versi dari file yang sama (file terpisah untuk dibandingkan, diff, referensi); pane tmux untuk proses yang berbeda (editor, terminal, server, log). Campuran keduanya adalah sweet spot.

#Neovim + Tmux: Navigasi Seamless antar Pane

Di Neovim, navigasi antar split memakai Ctrl+w lalu arah. Di tmux, navigasi antar pane memakai prefix + arah. Keduanya hidup berdampingan di layar yang sama: kadang fokus di split Neovim, kadang di pane terminal. Masalahnya: Ctrl+w tidak berlaku di pane terminal, dan prefix + arah tidak berlaku di dalam editor. Setiap kali berpindah konteks, kalian harus mengganti mental model.

Bayangkan kalian punya pane kiri berisi Neovim dengan dua split, dan pane kanan berisi terminal. Untuk berpindah dari split bawah editor ke terminal, kalian menekan Ctrl+w lalu Ctrl+w (keluar split), lalu prefix + arrow. Ini bukan satu gerakan, melainkan tiga, dengan dua sistem keybinding berbeda. Di sinilah vim-tmux-navigator lahir.

#vim-tmux-navigator: Pane Tmux ↔ Buffer Editor

vim-tmux-navigator adalah plugin yang membuat satu set tombol navigasi berlaku di dua dunia sekaligus: Ctrl+h/j/k/l dan Ctrl+{:bash}. Ketika fokus berada di dalam vim, tombol-tombol itu berpindah antar split editor; ketika fokus berada di pane tmux, tombol yang sama berpindah antar pane. Plugin mendeteksi apakah pane yang sedang aktif menjalankan vim — jika ya, tombol diteruskan ke vim; jika tidak, tmux menangani perpindahan pane.

Instalasi butuh dua sisi: konfigurasi di ~/.tmux.conf (agar tmux tahu kapan harus meneruskan tombol) dan pemasangan plugin di Neovim:

is_vim="ps -o state= -o comm= -t '#{pane_tty}' \
    | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|n?vim?x?)(diff)?$'"
bind -n 'C-h' if-shell "$is_vim" 'send-keys C-h'  'select-pane -L'
bind -n 'C-j' if-shell "$is_vim" 'send-keys C-j'  'select-pane -D'
bind -n 'C-k' if-shell "$is_vim" 'send-keys C-k'  'select-pane -U'
bind -n 'C-l' if-shell "$is_vim" 'send-keys C-l'  'select-pane -R'
bind -n 'C-\\' if-shell "$is_vim" 'send-keys C-\\' 'select-pane -l'

{ "christoomey/vim-tmux-navigator", lazy = false }

Perhatikan baris is_vim: ia mengecek apakah pane aktif menjalankan proses vim/nvim melalui ps. Jika ya, if-shell meneruskan tombol sebagai send-keys ke editor (editor yang bergerak); jika tidak, tmux langsung select-pane (tmux yang bergerak). Ini adalah pola deteksi-konteks yang elegan — satu tombol, dua perilaku, nol friksi.

#VS Code: Terminal Built-in, Task Runner, dan Remote

VS Code adalah cerita berbeda: ia punya terminal bawaan (Ctrl+{:bash}) dan task runner (Tasks: Run Task). Banyak developer bertanya: "kalau VS Code sudah punya terminal dan split, kenapa masih pakai tmux?" Jawabannya bergantung pada konteks:

• VS Code + Remote-SSH menangani jarak dengan baik, tetapi terminal bawaannya tidak persisten di luar VS Code — tutup editor, dan sesi terminalnya hilang.
• tmux di dalam terminal VS Code memberi persistence penuh, session management, dan layar yang tidak bergantung pada editor. Editor bisa ditutup dan dibuka lagi, tmux tetap hidup.

Praktik yang nyaman: jalankan tmux di terminal bawaan VS Code, dengan terminal.integrated.shellIntegration dinonaktifkan agar tmux tidak bergulat dengan kontrol shell VS Code. Task runner VS Code tetap dipakai untuk perintah cepat seperti build dan lint; untuk proses panjang (dev server, test watch, log), lebih baik di pane tmux yang persisten. Dengan pola ini, kalian mendapat yang terbaik dari dua dunia: palet perintah VS Code untuk tugas editor, dan pane tmux untuk proses yang harus bertahan.

#lazygit: Git dalam Popup

lazygit adalah terminal UI untuk git yang membuat staging, commit, branch, dan log terasa visual tanpa meninggalkan terminal. Integrasinya dengan tmux sangat natural lewat display-popup (fitur yang kita bahas di episode 20): tekan satu tombol, dan lazygit terbuka di jendela melayang di tengah layar; tekan tombol lagi untuk menutupnya.

Dengan binding prefix + g, git tidak lagi berarti berpindah ke pane lain atau membuka tab baru — ia adalah momen fokus yang singkat, lalu kembali ke editor. Pola popup yang sama bisa dipakai untuk tool lain: htop, tig, atau bahkan nvim untuk quick note. Popup adalah cara modern untuk "meminjam konteks" tanpa meninggalkan alur kerja.

#Fuzzy Finder & Session Manager: Alur Kerja Keyboard-First

Semakin banyak session yang kalian kelola (satu per project, seperti disarankan di episode 7), semakin penting kemampuan berpindah session secara cepat. Tanpa alat bantu, berpindah session berarti menghafal nama, lalu mengetik tmux switch-client -t <nama> — lambat dan rapuh. Dengan fzf, berpindah session menjadi interaktif: ketik sedikit, filter, enter.

#Mengapa Perlu Session Switcher

Pertimbangkan pagi yang sibuk: session frontend, backend, ops, dan blog. Untuk sampai ke session yang benar, kalian harus ingat namanya, keluar dari session sekarang, lalu attach. Jika namanya lupa, kalian mengetik tmux ls dulu. Semua langkah itu bisa diringkas menjadi satu keybind + satu dialog fuzzy. Lebih dari sekadar kenyamanan, ini mengurangi friksi memulai session baru — dan friksi yang rendah berarti alur kerja yang lebih sering dipakai.

#display-popup + fzf: Switch Session Instan

tmux versi 3.7b mendukung display-popup yang bisa menjalankan perintah apa pun di jendela melayang. Gabungkan dengan fzf, dan kalian punya session switcher dalam beberapa baris — lengkap dengan binding popup lazygit dan konfigurasi t-session yang akan kita bahas:

bind-key f display-popup -h 60% -w 50% -E \
  "tmux list-sessions -F '#S' | fzf --preview 'tmux capture-pane -pt {1}' | xargs -I{} tmux switch-client -t {}"

bind-key g display-popup -E "lazygit"

set -g @plugin 'joshmedeski/t-smart-tmux-session-manager'
run '~/.tmux/plugins/tpm/tpm'

Baca alur tab pertama dari kanan ke kiri: tmux list-sessions -F '#S' mencetak nama semua session; fzf menampilkannya sebagai daftar fuzzy, lengkap dengan --preview yang menampilkan isi pane session yang sedang disorot (capture-pane); lalu xargs -I{} tmux switch-client -t {} memindahkan client ke session terpilih. Jika kalian membatalkan (Esc di fzf), tidak ada yang terjadi — aman.

#t-smart-tmux-session-manager

t-smart-tmux-session-manager (sering disebut "t-session") adalah plugin TPM yang membawa session management ke level berikutnya: prefix + s membuka popup yang bisa membuat session baru (di direktori yang dipilih via fzf), berpindah ke session yang ada, atau mengganti nama session — semua dalam satu antarmuka. Konfigurasinya ada di tab ketiga code-group di atas: dua baris standar TPM yang kita kenal dari episode 15, lalu prefix + s akan menggantikan choose-tree bawaan.

Bedanya dengan switcher fzf di atas: switcher fzf kita memindahkan antar session yang sudah ada; t-session juga menciptakan session baru — ia list direktori project, dan memilih satu berarti membuka session baru di direktori itu. Keduanya bisa hidup berdampingan: prefix + f untuk berpindah cepat, prefix + s untuk kelola penuh.

#Alur Kerja Modern Berbasis Keyboard

Rangkailah semuanya menjadi satu alur yang koheren:

• prefix + h/j/k/l (setelah vim-tmux-navigator) untuk berpindah pane, split editor, atau buffer.
• prefix + g untuk git dalam popup lazygit.
• prefix + f untuk berpindah session dengan fzf.
• prefix + s untuk membuat atau mengelola session dengan t-session.

Semua operasi berjalan tanpa melepas tangan dari keyboard. Ini bukan soal "menghafal lebih banyak tombol", melainkan satu pola yang konsisten di semua konteks: fokus, pilih, lanjut. Ketika pola ini terbentuk, kalian tidak lagi berpikir tentang alat — kalian berpikir tentang pekerjaan.

#Kesalahan Umum (Common Pitfalls)

1. Memakai Ctrl+h/j/k/l di tmux tanpa is_vim. Binding langsung bind -n C-h select-pane -L menelan tombol Ctrl+h yang dibutuhkan editor untuk navigasi. Solusi: selalu pakai pola if-shell "$is_vim" agar tombol diteruskan ke editor ketika editor aktif.
2. Memasang plugin vim-tmux-navigator di satu sisi saja. Plugin bekerja berpasangan: tanpa sisi tmux, tombol tidak diteruskan; tanpa sisi editor, navigasi di dalam vim tidak berpindah. Instal dan konfigurasi keduanya.
3. Menaruh binding popup ke tombol yang sudah dipakai. Memakai prefix + c (yang sudah jadi "new window") untuk lazygit atau fzf akan membuat kebingungan. Gunakan tombol yang tidak terpakai seperti f atau g, atau unbind dulu tombol yang mau diganti.
4. Menjalankan tmux di terminal VS Code dengan shell integration aktif. Keduanya berebut kontrol input, menghasilkan prompt ganda dan perilaku aneh. Matikan shell integration untuk pane tmux, atau buka tmux di profil terminal terpisah.
5. Mengandalkan hafalan nama session. Berpindah session dengan mengetik nama adalah resep salah ketik. Solusi: biasakan prefix + f (fzf) sejak awal agar nama tidak perlu diingat.
6. Memaksa semua konteks ke pane tmux. Split editor untuk file, pane untuk proses. Memasukkan editor ke pane tmux itu baik, tetapi tidak berarti semua konteks harus dalam bentuk pane. Pilih alat yang tepat per tugas.

#Penutup

Pada episode 25 ini, kalian telah membangun jembatan antara tmux dan ekosistem developer: navigasi seamless antar pane dan split editor dengan vim-tmux-navigator (pola is_vim + if-shell), integrasi lazygit lewat display-popup, penggunaan terminal bawaan VS Code dengan task runner tanpa mengorbankan persistence tmux, dan alur kerja keyboard-first dengan session switcher fzf (prefix + f) serta t-smart-tmux-session-manager (prefix + s).

Poin kunci yang perlu kalian bawa:

• vim-tmux-navigator menyatukan navigasi pane dan split editor dalam satu set tombol.
• Popup (display-popup) adalah pola modern untuk "meminjam konteks": git, monitoring, atau tool lain tanpa meninggalkan alur kerja.
• fzf mengubah berpindah session dari hafalan menjadi dialog interaktif.
• Alur kerja keyboard-first bukan tentang tombol yang banyak, melainkan pola yang konsisten di semua konteks.

Sekarang tmux sudah ringan (episode 24) dan terhubung mulus dengan editor (episode ini). Yang tersisa adalah memastikan seluruh setup ini bisa dibawa ke mana saja. Di episode 26 selanjutnya kita akan membahas production-ready setup, dotfiles & portability — menyimpan ~/.tmux.conf dan plugin di repo dotfiles, script bootstrap lintas mesin, conditional config untuk Linux/macOS, serta checklist konfigurasi yang aman dan deterministic untuk tim. Karena setup yang hebat tidak ada artinya jika tidak bisa direproduksi di mesin berikutnya. Pastikan tetap semangat!