终端生产力提升指南：从命令行使用者到终端大师

没有 tmux 的痛点：
- SSH 断了 → 运行中的任务全丢
- 终端窗口关了 → session 没了
- 需要在多个项目间切换 → 打开 N 个终端窗口
- 想和同事 pair programming → 没有原生方式共享终端

tmux 解决的核心问题：
- 会话持久化（detach/attach）
- 窗口和面板管理
- 终端复用和共享

tmux 三级层次结构：

Session（会话）
  └── Window（窗口，相当于浏览器的一个 tab）
       └── Pane（面板，窗口内的分割区域）

常用操作：
  tmux new -s dev      → 创建名为 dev 的会话
  tmux attach -t dev   → 重新接入 dev 会话
  tmux ls              → 列出所有会话
  tmux kill-session -t dev → 删除会话

# ~/.tmux.conf

# 将前缀键从 C-b 改为更顺手的 C-a（或 C-space）
set -g prefix C-a
unbind C-b
bind C-a send-prefix

# 解决终端颜色问题
set -g default-terminal "screen-256color"
set -ga terminal-overrides ",*256col*:Tc"

# 提高滚动缓冲区
set -g history-limit 50000

# 使用 vi 模式复制（用键盘选择文本）
setw -g mode-keys vi

# 用 vim 风格移动面板
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# 用 vim 风格调整面板大小
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

# 合理的基础编号
set -g base-index 1
setw -g pane-base-index 1

# 鼠标支持（拖动面板边界、点击选择窗格）
set -g mouse on

# 重新加载配置
bind r source-file ~/.tmux.conf \; display "Config reloaded!"

# 为不同项目创建独立 session
tmux new -s blog       # 博客项目
tmux new -s api        # API 服务
tmux new -s infra      # 基础设施

# 快速切换到项目 session 的脚本（保存为 ~/bin/tm）
#!/bin/bash
SESSION_NAME="${1:-main}"

if tmux has-session -t "$SESSION_NAME" 2>/dev/null; then
  tmux attach -t "$SESSION_NAME"
else
  tmux new -s "$SESSION_NAME"
fi

# 典型工作窗口布局
# 窗口 1: 编辑器 (nvim)
# 窗口 2: 开发服务器 + 日志
# 窗口 3: git + 命令行操作
# 窗口 4: 数据库 / API 测试

# 推荐使用 TPM (Tmux Plugin Manager)
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

# ~/.tmux.conf 中添加插件
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'     # 自动保存
set -g @plugin 'christoomey/vim-tmux-navigator'  # vim 和 tmux 无缝导航
set -g @plugin 'dracula/tmux'                    # 美观主题

# 初始化 TPM（添加到配置末尾）
run '~/.tmux/plugins/tpm/tpm'

# 安装插件：在 tmux 中按 prefix + I（大写 i）

# 场景：启动一个全栈开发环境

# 1. 创建 session
tmux new -s fullstack

# 2. 窗口 1：编辑器（最大化）
nvim .

# 3. 新建窗口 2：开发服务器
# prefix + c
npm run dev

# 4. 新建窗口 3：拆分上下面板
# prefix + c, 然后 prefix + "（引号）
# 上面板：
cd server && cargo watch -x run
# 下面板：
tail -f /var/log/app.log

# 5. 新建窗口 4：git 操作
# prefix + c
lazygit

# 6. 断开 session（所有程序继续运行）
# prefix + d

# 7. 稍后重新连接
tmux attach -t fullstack

# 方式一：Oh My Zsh（开箱即用，插件丰富）
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

# 方式二：手动管理（更轻量、更可控）
# 将插件直接 source 到 ~/.zshrc

# ~/.zshrc

# === zsh-autosuggestions：自动补全建议（基于历史） ===
# 灰色提示 → 按 → 接受
source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh

# === zsh-syntax-highlighting：命令语法高亮 ===
# 绿色 = 有效命令，红色 = 无效/不存在
source ~/.zsh/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh

# === zsh-history-substring-search：历史子串搜索 ===
# 输入部分命令 → 按 ↑ 搜索匹配的历史
source ~/.zsh/zsh-history-substring-search/zsh-history-substring-search.zsh
bindkey '^[[A' history-substring-search-up
bindkey '^[[B' history-substring-search-down

# 克隆到自定义目录
mkdir -p ~/.zsh
git clone https://github.com/zsh-users/zsh-autosuggestions ~/.zsh/zsh-autosuggestions
git clone https://github.com/zsh-users/zsh-syntax-highlighting ~/.zsh/zsh-syntax-highlighting
git clone https://github.com/zsh-users/zsh-history-substring-search ~/.zsh/zsh-history-substring-search

# ~/.zshrc 精华配置

# 历史记录优化
export HISTSIZE=50000
export SAVEHIST=50000
export HISTFILE=~/.zsh_history
setopt SHARE_HISTORY          # 多个 zsh 实例共享历史
setopt HIST_IGNORE_DUPS       # 不记录重复命令
setopt HIST_IGNORE_SPACE      # 以空格开头的命令不记录
setopt HIST_FIND_NO_DUPS      # 搜索历史时跳过重复

# 自动纠正（输入错误时提示正确命令）
setopt CORRECT

# 通配符扩展
autoload -Uz compinit && compinit
zstyle ':completion:*' menu select

# 补全时使用颜色
zstyle ':completion:*' list-colors ''

# 大小写不敏感补全
zstyle ':completion:*' matcher-list 'm:{a-z}={A-Z}'

# ~/.zshrc

# === 常用别名 ===
alias v='nvim'
alias vi='nvim'
alias vim='nvim'
alias ll='eza -la --icons'         # 需要 eza（exa 的继任者）
alias lt='eza -la --icons --tree'
alias cat='bat'                    # 需要 bat
alias du='dust'                    # 需要 dust（更好的 du）
alias ps='procs'                   # 需要 procs（更好的 ps）
alias grep='rg'                    # ripgrep
alias fd='fd'                      # 更好的 find

# === Git 快捷操作 ===
alias g='git'
alias gs='git status'
alias ga='git add'
alias gc='git commit'
alias gp='git push'
alias gl='git log --graph --oneline --decorate'
alias gd='git diff'
alias gco='git checkout'
alias gb='git branch'

# === 目录导航 ===
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'

# === 实用函数 ===
# 创建目录并进入
mkcd() { mkdir -p "$@" && cd "$_" }

# 解压任意压缩文件
extract() {
  if [ -f "$1" ]; then
    case "$1" in
      *.tar.bz2) tar xjf "$1"    ;;
      *.tar.gz)  tar xzf "$1"    ;;
      *.bz2)     bunzip2 "$1"    ;;
      *.rar)     unrar x "$1"    ;;
      *.gz)      gunzip "$1"     ;;
      *.tar)     tar xf "$1"     ;;
      *.tbz2)    tar xjf "$1"    ;;
      *.tgz)     tar xzf "$1"    ;;
      *.zip)     unzip "$1"      ;;
      *.7z)      7z x "$1"       ;;
      *)         echo "Unknown format: $1" ;;
    esac
  else
    echo "'$1' is not a valid file"
  fi
}

# 安装
brew install fzf
$(brew --prefix)/opt/fzf/install  # 安装 shell 集成

# Ctrl+T：模糊搜索文件并粘贴路径到命令行
# Ctrl+R：模糊搜索命令历史（替代传统 Ctrl+R）
# Alt+C：模糊搜索目录并 cd

# ~/.zshrc 中配置 fzf
export FZF_DEFAULT_OPTS='
  --height 40%
  --layout=reverse
  --border
  --preview "bat --style=numbers --color=always {} 2>/dev/null || cat {}"
  --preview-window=right:60%
'

# Ctrl+T 时的文件预览
export FZF_CTRL_T_OPTS="
  --preview 'bat -n --color=always {}'
  --bind 'ctrl-/:change-preview-window(down|hidden|)'
"

# Ctrl+R 时不预览
export FZF_CTRL_R_OPTS="--preview 'echo {}' --preview-window down:3:hidden"

# fd 作为文件查找引擎（比 find 快得多）
export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

# === Git 集成 ===

# 模糊搜索并 checkout 分支
gcof() {
  git branch --all |
    grep -v HEAD |
    fzf --preview 'git log --oneline --graph --color=always $(echo {} | sed "s/.* //")' |
    sed "s/.* //" |
    xargs git checkout
}

# 模糊搜索 git log 并查看 commit 详情
glogf() {
  git log --oneline --graph --color=always |
    fzf --ansi --preview 'git show --color=always $(echo {} | grep -o "[a-f0-9]\{7,\}")' |
    grep -o "[a-f0-9]\{7,\}"
}

# 交互式 git add
fadd() {
  git status -s |
    fzf --multi --preview 'git diff --color=always {2}' |
    awk '{print $2}' |
    xargs git add
}

# === Docker 集成 ===

# 选择并进入 Docker 容器
dexec() {
  local cid
  cid=$(docker ps -a | fzf --header-lines=1 | awk '{print $1}')
  [ -n "$cid" ] && docker exec -it "$cid" /bin/sh
}

# 选择并删除 Docker 镜像
drmi() {
  docker images | fzf --multi --header-lines=1 | awk '{print $3}' | xargs docker rmi
}

# === 进程管理 ===

# 搜索并 kill 进程
pkillf() {
  local pid
  pid=$(ps aux | fzf --header-lines=1 | awk '{print $2}')
  [ -n "$pid" ] && kill -9 "$pid"
}

# === npm 脚本 ===

# 交互式运行 npm scripts
nrun() {
  local script
  script=$(npm run --json 2>/dev/null |
    jq -r 'to_entries | .[] | "\(.key)\t\(.value)"' |
    fzf --delimiter='\t' --with-nth=1 |
    cut -f1)
  [ -n "$script" ] && npm run "$script"
}

# 传统 grep 搜索（递归）
grep -r "useState" src/

# ripgrep 等效命令（更简洁，默认递归搜索）
rg "useState" src/

# 性能差异（在有 10 万文件的仓库中）
# grep: ~3.2s
# rg:   ~0.3s（快约 10 倍）

# === 文件类型过滤 ===
rg "useEffect" -t ts           # 只搜索 TypeScript 文件
rg "useEffect" -t ts -t tsx    # 搜索 TS 和 TSX
rg "className" -g "*.tsx"      # 使用 glob 模式

# === 按目录排除 ===
rg "import" --glob '!node_modules'
rg "import" --glob '!{node_modules,dist,build}'

# === 上下文显示 ===
rg "handleSubmit" -C 3         # 显示匹配行前后各 3 行
rg "handleSubmit" -B 2 -A 5    # 前 2 行后 5 行

# === 搜索选项 ===
rg "TODO" -i                   # 忽略大小写
rg "function" -w               # 全词匹配
rg "^import.*from" src/        # 正则表达式
rg -l "deprecated"             # 只列出文件名
rg -c "TODO"                   # 统计匹配数

# === 替换 ===
rg "oldFunction" --replace "newFunction"

# === 组合使用 ===
rg "^export.*function" -t ts --no-heading | wc -l  # 统计导出的函数数
rg "import.*lodash" -l | xargs nvim                  # 编辑所有引用 lodash 的文件

ripgrep 快的技术原因：

1. Rust 编写 → 零成本抽象 + 无 GC 暂停
2. Rust 的正则引擎（regex crate）→ SIMD 加速
3. 自动忽略 .gitignore 中的文件 → 减少搜索范围
4. 内存映射文件（mmap）→ 利用 OS 页面缓存
5. 并行目录遍历 → 充分利用多核 CPU
6. 默认不搜索二进制文件和隐藏文件

# ~/.ripgreprc 或设置 RIPGREP_CONFIG_PATH 环境变量

# 默认排除目录
--glob=!node_modules
--glob=!dist
--glob=!build
--glob=!.git
--glob=!target
--glob=!vendor

# 默认选项
--smart-case      # 小写搜索忽略大小写，大写敏感
--max-columns=150
--max-columns-preview
--colors=path:fg:blue
--colors=line:fg:yellow
--colors=match:fg:red
--colors=match:style:nobold

传统 git 工作流的痛点：
- 记不住复杂命令（git reset --soft HEAD~1 是什么来着？）
- 手打 commit message 效率低
- 查看 diff 需要在终端和编辑器间切换
- 交互式 rebase 的命令行界面反人类
- 解决 merge 冲突需要手动画文件

lazygit 的优势：
- 单一界面管理所有 git 操作
- 可视化暂存（逐行、逐块 stash/unstash）
- 交互式 rebase 变得直观
- 冲突解决有图形化辅助
- 完全键盘驱动

# 安装
brew install lazygit

# 在任意 git 仓库中启动
lazygit

# 配置 tmux 浮动窗口（推荐）
# ~/.tmux.conf
tmux bindkey -n M-g display-popup -E "lazygit"

全局：
  q          → 退出
  ?          → 帮助
  @          → 显示命令日志

文件面板（Files）：
  Space      → 暂存/取消暂存当前文件
  a          → 暂存/取消暂存所有文件
  c          → 提交
  C          → 使用 git 编辑器提交
  d          → 查看文件 diff
  D          → 在外部 diff 工具中查看
  P          → 推送
  p          → 拉取

分支面板（Branches）：
  Space      → 切换分支
  n          → 创建新分支
  M          → 合并到当前分支
  d          → 删除分支
  r          → 交互式 rebase

提交面板（Commits）：
  s          → squash（合并到上一个 commit）
  r          → reword（修改 commit message）
  d          → drop（删除 commit）
  g          → 重置到该 commit

Stash 面板：
  s          → 暂存当前修改
  g          → 弹出 stash
  d          → 丢弃 stash

冲突解决：
  Space      → 选择 hunk（ours/theirs/both）
  z          → 撤销
  ▲/▼        → 导航到上下一个冲突

场景一：交互式整理 commit 历史
1. 进入 lazygit
2. 按 4 进入 Commits 面板
3. 在目标 commit 上按 r 进入 rebase 模式
4. 用 s 将 fixup commit 合并到主 commit
5. 用 d 删除不需要的 commit
6. 用 r 修改 commit message
7. 确认后自动完成 rebase

场景二：解决合并冲突
1. 合并后出现冲突 → lazygit 自动显示冲突文件
2. 在冲突文件上按 Space
3. 逐个冲突块选择：ours（当前分支）或 theirs（合并进来的分支）或 both
4. 全部解决后按 c 提交合并

场景三：部分暂存（只 commit 文件的部分修改）
1. 在文件上按 Enter 展开文件块
2. 按 Space 选择/取消特定代码块
3. 只把需要的块暂存，其余的留在工作区
4. 按 c 提交暂存的内容

brew install bat

# vs code 风格的主题
bat --theme "Dracula" src/app.ts

# 显示行号和 Git 修改标记
bat -n src/app.ts    # 行号
bat -H 100 src/app.ts  # 高亮第 100 行

# 拼接文件时不要装饰
bat --plain file.ts   # 或 bat -p

brew install git-delta

# ~/.gitconfig
[core]
  pager = delta

[delta]
  features = side-by-side line-numbers decorations
  syntax-theme = Dracula
  plus-style = syntax "#003300"
  minus-style = syntax "#330000"

brew install zoxide

# 安装后自动追踪访问过的目录
# 用频率和新鲜度智能跳转

z blog        # 跳到最相关的包含 "blog" 的目录
z src comp    # 跳到包含 "src" 和 "comp" 的目录
zi            # 交互式模糊搜索（用 fzf 选择）

# ~/.zshrc
# 用 zoxide 替代 cd（可选，激进用户）
eval "$(zoxide init zsh --cmd cd)"

文件管理：
  fd        → 更快更友好的 find
  broot     → 交互式目录树
  dust      → 更直观的磁盘使用分析
  lsd/eza   → 更好看的 ls

文本处理：
  jq        → JSON 命令行处理器
  fx        → 交互式 JSON 查看器
  sd        → 更直观的 sed 替代
  xh        → 更友好的 HTTP 客户端（curl 替代）

进程和系统：
  btop      → 美化的系统资源监控
  procs     → 更好看的 ps
  htop      → 交互式进程管理器
  bottom    → 跨平台系统监控（Rust 编写）

开发辅助：
  tldr      → 简化版 man pages（带示例）
  httpie    → 人性化 HTTP 客户端
  entr      → 文件变化时自动运行命令
  watchexec → 跨平台文件监听器

# 使用 GNU Stow 或 bare git repo 管理 dotfiles

# 方案一：GNU Stow
git clone https://github.com/YOU/dotfiles ~/.dotfiles
cd ~/.dotfiles
stow nvim    # 部署 nvim 配置
stow tmux    # 部署 tmux 配置
stow zsh     # 部署 zsh 配置

# 方案二：bare git repo（无需额外工具）
git init --bare ~/.dotfiles
alias dotfiles='git --git-dir=$HOME/.dotfiles --work-tree=$HOME'
dotfiles config status.showUntrackedFiles no
dotfiles add ~/.zshrc
dotfiles commit -m "Add zshrc"
dotfiles remote add origin git@github.com:YOU/dotfiles.git
dotfiles push -u origin main

#!/bin/bash
# ~/bin/dev-session —— 启动全栈开发环境

SESSION="${1:-dev}"

# 如果 session 已存在，attach；否则创建
if tmux has-session -t "$SESSION" 2>/dev/null; then
  tmux attach -t "$SESSION"
  exit 0
fi

# 创建新 session
tmux new-session -d -s "$SESSION" -n editor
tmux send-keys -t "$SESSION:editor" 'nvim .' Enter

# 窗口 2：开发服务器
tmux new-window -t "$SESSION" -n server
tmux send-keys -t "$SESSION:server" 'pnpm dev' Enter

# 窗口 3：Git 操作
tmux new-window -t "$SESSION" -n git
tmux send-keys -t "$SESSION:git" 'lazygit' Enter

# 窗口 4：命令行 + 数据库
tmux new-window -t "$SESSION" -n shell
tmux split-window -h -t "$SESSION:shell"
tmux send-keys -t "$SESSION:shell.0" 'pnpm db:studio' Enter
tmux select-pane -t "$SESSION:shell.1"

# 回到编辑器窗口
tmux select-window -t "$SESSION:editor"

# 接入 session
tmux attach -t "$SESSION"

# ~/.zshrc

# 快速跳转到项目目录
# 假设所有项目在 ~/projects/ 下
project() {
  local proj
  proj=$(fd --type d --max-depth 2 . ~/projects/ |
    sed "s|$HOME/projects/||" |
    fzf --preview 'eza --tree --level=2 ~/projects/{}')
  [ -n "$proj" ] && cd "$HOME/projects/$proj"
}

推荐的全局快捷键映射：

Kitty / Alacritty / iTerm2 终端：
  Cmd+1-9         → 切换 tab
  Cmd+d           → 新建竖向分屏
  Cmd+Shift+d     → 新建横向分屏
  Cmd+w           → 关闭分屏/面板

tmux（在终端内）：
  C-a 1-9         → 切换窗口
  C-a c           → 新建窗口
  C-a &           → 关闭窗口
  C-a |           → 竖向分屏
  C-a -           → 横向分屏
  C-a h/j/k/l     → 切换面板
  C-a M-g         → 浮动 lazygit

编辑器（nvim）：
  leader+f f      → 查找文件（Telescope/fzf）
  leader+f g      → 实时 grep（Telescope live_grep）
  leader+g        → lazygit 浮动窗口

# 加速 zsh 启动时间
# 查看哪些脚本慢
zmodload zsh/zprof
# 在 ~/.zshrc 末尾添加：
# zprof

# 懒加载重型工具
# 不要直接 source nvm，按需加载
lazynvm() {
  unset -f nvm node npm npx
  export NVM_DIR="$HOME/.nvm"
  [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
}

# 使用 antidote 或 zplug 管理插件，支持懒加载

# 减少 compinit 开销
# 缓存补全结果
autoload -Uz compinit
if [[ -n ~/.zcompdump(#qN.mh+24) ]]; then
  compinit
else
  compinit -C
fi

第一层：终端模拟器
  → 选择：Kitty（GPU 加速、原生分屏）或 WezTerm（Lua 配置、跨平台）
  → 字体：JetBrains Mono Nerd Font 或 FiraCode Nerd Font
  → 主题：Catppuccin Mocha 或 Tokyo Night

第二层：Shell
  → 确认使用 zsh（macOS 默认，Linux 需安装）
  → 配置 ~/.zshrc（别名、函数、补全、插件）
  → 安装 autosuggestions、syntax-highlighting

第三层：终端复用器
  → 安装 tmux，配置 ~/.tmux.conf
  → 安装 TPM 和常用插件
  → 设置项目启动脚本

第四层：搜索和导航工具
  → fzf + fd（模糊搜索）
  → ripgrep（代码搜索）
  → zoxide（智能跳转）
  → bat（文件预览）

第五层：开发工具
  → lazygit（Git GUI）
  → delta（Git diff 美化）
  → tldr（命令速查）
  → jq/fx（JSON 处理）

第六层：编辑器
  → Neovim / Helix / VS Code（各有优劣，按偏好选择）
  → 配置 LSP、自动补全、格式化