# Dotfiles

Configuration personnelle pour zsh, zellij et spaceship, gérée avec [GNU Stow](https://www.gnu.org/software/stow/) et installée via un script d'automatisation.

## Pourquoi ce projet

L'objectif est d'avoir un environnement shell reproductible en une commande sur n'importe quelle machine (Debian/Ubuntu), sans avoir à reconfigurer manuellement :

- **zsh** avec une configuration personnalisée (`.zshrc.perso`) et le prompt [Spaceship](https://github.com/spaceship-prompt/spaceship-prompt).
- **[Zellij](https://zellij.dev/)** (multiplexeur de terminal, alternative à tmux) avec une config et des layouts prédéfinis, plus un système d'auto-attache à la session précédente à chaque ouverture de terminal (au lieu de repartir d'une session vierge à chaque fois).
- Une poignée d'outils CLI en Rust (`bat`, `bottom`, `diskus`, `procs`) installés au passage.

Les fichiers de config sont gérés avec **Stow** plutôt que copiés directement : Stow crée des **liens symboliques** depuis ce dépôt vers leur emplacement final (`~/.config/...`, `~/.zshrc.perso`, etc.). Ça permet de modifier les fichiers de config à un seul endroit (ce dépôt), de les versionner avec git, et de les synchroniser facilement entre plusieurs machines.

## Contenu du dépôt

```
dotfiles/                       (racine du dépôt)
├── spaceship/
│   └── spaceship.zsh           # prompt zsh Spaceship
├── zellij/
│   ├── config.kdl              # config principale zellij
│   └── layouts/
│       └── default.kdl         # layout par défaut
├── zsh/
│   └── zshrc.perso             # config zsh perso (linkée en ~/.zshrc.perso)
├── install/
│   └── install.sh              # script d'installation / mise à jour
└── README.md
```

Tout est réuni dans un seul dépôt git : les packages de configuration (`spaceship/`, `zellij/`, `zsh/`) et le script d'installation (`install/`) sont au même niveau.

## Prérequis

- Une distribution Debian/Ubuntu (le script utilise `apt`).
- Un accès `sudo`.
- `git` installé pour cloner le dépôt `dotfiles`.

Le script installe lui-même le reste (rust/cargo, zellij, stow, etc.) s'ils sont absents.

## Installation

### 1. Cloner ce dépôt

```bash
git clone <URL_DE_CE_DEPOT> dotfiles
cd dotfiles
```

### 2. Lancer le script d'installation

```bash
./install/install.sh
```

Le script est idempotent et non destructif : si une configuration existe déjà à l'endroit ciblé (`~/.config/zellij`, `~/.zshrc.perso`, etc.), il ne touche à rien et passe à l'étape suivante plutôt que d'écraser quoi que ce soit. Pour forcer une réinstallation d'une config donnée, il faut supprimer manuellement le dossier/fichier concerné avant de relancer le script.

### Ce que fait le script

1. Installe les dépendances système (`stow`, `zsh`, `curl`, etc.) via `apt`.
2. Installe Rust (`rustup`) si `cargo` n'est pas déjà disponible.
3. Installe Zellij via `cargo` et lie sa configuration (`~/.config/zellij`) avec Stow.
4. Crée le lien symbolique `~/.zshrc.perso` vers `zsh/zshrc.perso` (dans ce dépôt).
5. Clone (ou met à jour) Spaceship et lie sa configuration (`~/.config/spaceship`) avec Stow.
6. Installe des outils Rust additionnels : `bat`, `bottom`, `diskus`, `procs`, `cargo-update`.

## Activer la config zsh perso

Le script crée le lien `~/.zshrc.perso`, mais il faut le sourcer depuis ton `~/.zshrc` principal pour qu'il soit pris en compte :

```bash
# à ajouter dans ~/.zshrc
[ -f ~/.zshrc.perso ] && source ~/.zshrc.perso
```

## Auto-attache à la session Zellij précédente

Par défaut, `~/.zshrc.perso` peut lancer une nouvelle session Zellij à chaque ouverture de terminal. Pour retrouver automatiquement la dernière session en cours (ou choisir parmi plusieurs), ajoute la fonction suivante dans `~/.zshrc.perso` (ou dans le fichier zellij de `dotfiles/zsh/`) à la place d'un simple `zellij` :

```zsh
zellij_autostart() {
  [[ -n "$ZELLIJ" ]] && return
  [[ -o interactive ]] || return

  local sessions
  sessions=$(zellij list-sessions --no-formatting 2>/dev/null)

  if [[ -z "$sessions" ]]; then
    zellij
    return
  fi

  local count
  count=$(printf '%s\n' "$sessions" | wc -l)

  if (( count == 1 )); then
    zellij attach "$(printf '%s\n' "$sessions" | cut -d' ' -f1)"
    return
  fi

  if command -v fzf >/dev/null 2>&1; then
    local choice
    choice=$(printf '%s\n' "$sessions" | fzf \
      --tac --height=40% --border \
      --prompt="Session zellij > " \
      --header 'Entrée: attacher | Ctrl-R: supprimer la session surlignée' \
      --bind 'ctrl-r:execute-silent(name=$(echo {} | cut -d" " -f1); zellij kill-session "$name" 2>/dev/null; zellij delete-session "$name" --force 2>/dev/null)+reload(zellij list-sessions --no-formatting 2>/dev/null)' \
      | cut -d' ' -f1)

    if [[ -n "$choice" ]]; then
      zellij attach "$choice"
    else
      zellij
    fi
  else
    print -P "%BSessions zellij disponibles :%b"
    local -a names
    local i=1
    while IFS= read -r line; do
      names+=("${line%% *}")
      printf "  %d) %s\n" "$i" "$line"
      ((i++))
    done <<< "$sessions"
    printf "  n) Nouvelle session\n"
    read "choix?Ton choix : "
    if [[ "$choix" == "n" || -z "$choix" ]]; then
      zellij
    elif (( choix >= 1 && choix <= ${#names[@]} )); then
      zellij attach "${names[$choix]}"
    else
      zellij
    fi
  fi
}

zellij_autostart
```

- Une seule session existante → attache automatique, sans interaction.
- Plusieurs sessions → sélection interactive (menu `fzf` si installé, sinon menu numéroté en fallback). Dans `fzf`, `Ctrl-R` supprime la session surlignée.
- `[[ -n "$ZELLIJ" ]]` empêche la fonction de se redéclencher à l'intérieur d'une session déjà active (panneaux/onglets zellij).

`fzf` est optionnel mais recommandé pour une meilleure expérience :
```bash
sudo apt install fzf
```

## Mettre à jour la configuration

Après avoir modifié un fichier du dépôt (`zellij/config.kdl`, `zsh/zshrc.perso`, etc.), les changements sont immédiatement visibles (les fichiers cibles sont des liens symboliques). Il suffit de commit/push pour les partager avec d'autres machines :

```bash
git add -A
git commit -m "update config"
git push
```

Sur une autre machine, un `git pull` à la racine du dépôt suffit à récupérer les changements (pas besoin de relancer `install.sh`, sauf si un nouveau fichier de config a été ajouté).