path: root/PROJECT.md

# Projet : Synchronisation de fichiers de configuration

## Objectif

Ce projet permet de centraliser et synchroniser tous les fichiers de configuration (vim, bash, screen, cursor, documentation, etc.) depuis Windows et WSL vers un dépôt git sur chillka.

## Structure du projet

```
config-files-keyvault/
├── .git/                    # Dépôt git local
├── configs/
│   ├── windows/            # Fichiers provenant de Windows
│   └── wsl/                # Fichiers provenant de WSL
├── scripts/
│   ├── sync-to-project.ps1 # Script pour copier fichiers vers le projet
│   └── sync-from-project.ps1 # Script pour restaurer fichiers depuis le projet
├── files-config.txt        # Liste des fichiers à synchroniser
├── path-mapping.json       # Mapping chemins originaux <-> chemins dans le projet
└── PROJECT.md              # Documentation du projet
```

## Utilisation

### 1. Ajouter des fichiers à synchroniser

Éditer le fichier `files-config.txt` et ajouter les fichiers au format :
```
windows|%USERPROFILE%\.vimrc
wsl|~/.bashrc
```

### 2. Copier les fichiers vers le projet

Exécuter le script PowerShell :
```powershell
.\scripts\sync-to-project.ps1
```

Ce script va :
- Lire `files-config.txt`
- Copier chaque fichier vers `configs/{system}/`
- Créer/mettre à jour `path-mapping.json` avec les chemins originaux

### 3. Restaurer les fichiers depuis le projet

Exécuter le script PowerShell :
```powershell
.\scripts\sync-from-project.ps1
```

Ce script va :
- Lire `path-mapping.json`
- Copier chaque fichier depuis `configs/{system}/` vers son emplacement original
- Créer les répertoires parents si nécessaire

### 4. Synchronisation Git

Le dépôt git est configuré avec le remote :
```
toshiro@chillka:/var/data/git/repositories/config-files-keyvault.git
```

**Pousser les changements (workflow standard) :**
```powershell
git add .
git commit -m "Message décrivant les changements"
git push
```

**Premier push (si la branche n'est pas encore liée) :**
```powershell
git push --set-upstream origin main
```

### 5. Diagnostic et Commandes Git Utiles

Pour vérifier l'état du dépôt et diagnostiquer les problèmes :

**Voir les dépôts distants configurés :**
```powershell
git remote -v
```

**Voir l'historique des commits :**
```powershell
git log --oneline --graph --decorate --all
```

**Voir l'état des fichiers (modifiés, ajoutés, non suivis) :**
```powershell
git status
```

**Créer le dépôt distant sur le serveur (si "fatal: repository not found") :**
```powershell
ssh toshiro@chillka "mkdir -p /var/data/git/repositories/config-files-keyvault.git && git init --bare /var/data/git/repositories/config-files-keyvault.git"
```

### 6. Administration du Serveur (Chillka)

Commandes pour interagir directement avec le dépôt distant via SSH :

**Vérifier si le dépôt existe et voir les 5 derniers commits sur le serveur :**
```powershell
ssh toshiro@chillka "cd /var/data/git/repositories/config-files-keyvault.git && git log --oneline -n 5"
```

**Vérifier l'intégrité du dépôt distant (fsck) :**
```powershell
ssh toshiro@chillka "cd /var/data/git/repositories/config-files-keyvault.git && git fsck"
```

### 7. Gestion des Branches et Workflow Avancé

**Scénario A : Créer une branche locale et la publier**
```powershell
# 1. Créer la branche et basculer dessus
git checkout -b ma-nouvelle-branche

# 2. Travailler, ajouter, commiter...
git add .
git commit -m "Travail sur ma branche"

# 3. Publier la branche sur le serveur (crée la branche distante)
git push -u origin ma-nouvelle-branche
```

**Scénario B : Récupérer une branche existante sur le serveur**
```powershell
# 1. Mettre à jour la liste des branches distantes
git fetch --all

# 2. Voir toutes les branches (locales et distantes)
git branch -a

# 3. Créer une copie locale d'une branche distante et basculer dessus
# (Git comprend automatiquement qu'il doit suivre origin/nom-branche)
git checkout nom-branche-distante
```

**Maintenance et Nettoyage (Admin)**
```powershell
# Supprimer une branche locale
git branch -d nom-branche

# Supprimer une branche sur le serveur (DANGER)
git push origin --delete nom-branche

# Nettoyer les références locales vers des branches distantes supprimées
git fetch --prune
```

**Commandes utiles pour l'historique**
```powershell
# Voir les différences entre la branche actuelle et main
git diff main

# Voir quel fichier a été modifié par qui et quand (blame)
git blame chemin/vers/fichier
```

## Format de fichiers-config.txt

Chaque ligne doit suivre le format :
```
{système}|{chemin}
```

Où :
- `{système}` : `windows` ou `wsl`
- `{chemin}` : Chemin du fichier avec support des variables d'environnement Windows (`%VAR%`) ou expansion WSL (`~`)

Exemples :
```
windows|%USERPROFILE%\.vimrc
windows|%APPDATA%\Cursor\User\settings.json
wsl|~/.bashrc
wsl|~/.bash_aliases
wsl|~/.screenrc
```

## Format de path-mapping.json

Ce fichier est généré automatiquement par le script `sync-to-project.ps1`. Il contient le mapping entre les chemins originaux et les chemins dans le projet :

```json
{
  "windows": {
    "%USERPROFILE%\\.vimrc": "configs/windows/.vimrc"
  },
  "wsl": {
    "~/.bashrc": "configs/wsl/.bashrc"
  }
}
```

## Notes

- Les fichiers sont organisés par système d'origine (windows/wsl) pour faciliter la gestion
- Le mapping des chemins permet de restaurer les fichiers à leur emplacement exact
- Les répertoires parents sont créés automatiquement lors de la restauration
- Les fichiers WSL sont accessibles via le chemin Windows `\\wsl.localhost\Ubuntu\` pour une meilleure performance et fiabilité