Amélioration des scripts avec chemin Windows direct vers WSL et ajout du fichier Cursor

1 files changed, 220 insertions, 235 deletions

diff --git a/scripts/sync-to-project.ps1 b/scripts/sync-to-project.ps1
index aef1249..dc7423a 100644
--- a/scripts/sync-to-project.ps1
+++ b/scripts/sync-to-project.ps1
@@ -1,235 +1,220 @@
-# Script pour copier les fichiers de configuration vers le projet
-# Lit files-config.txt et copie chaque fichier vers configs/{system}/
-
-param(
-    [string]$ConfigFile = "files-config.txt",
-    [string]$MappingFile = "path-mapping.json"
-)
-
-$ErrorActionPreference = "Stop"
-
-# Vérifier que le fichier de configuration existe
-if (-not (Test-Path $ConfigFile)) {
-    Write-Error "Le fichier de configuration '$ConfigFile' n'existe pas."
-    exit 1
-}
-
-# Créer les répertoires de destination
-$configsDir = "configs"
-$windowsDir = Join-Path $configsDir "windows"
-$wslDir = Join-Path $configsDir "wsl"
-
-foreach ($dir in @($configsDir, $windowsDir, $wslDir)) {
-    if (-not (Test-Path $dir)) {
-        New-Item -ItemType Directory -Path $dir -Force | Out-Null
-        Write-Host "Créé le répertoire: $dir"
-    }
-}
-
-# Charger le mapping existant ou créer un nouveau
-$mapping = @{
-    windows = @{}
-    wsl = @{}
-}
-
-if (Test-Path $MappingFile) {
-    try {
-        $existingMapping = Get-Content $MappingFile -Raw | ConvertFrom-Json
-        if ($existingMapping.windows) {
-            $mapping.windows = @{}
-            $existingMapping.windows.PSObject.Properties | ForEach-Object {
-                $mapping.windows[$_.Name] = $_.Value
-            }
-        }
-        if ($existingMapping.wsl) {
-            $mapping.wsl = @{}
-            $existingMapping.wsl.PSObject.Properties | ForEach-Object {
-                $mapping.wsl[$_.Name] = $_.Value
-            }
-        }
-    } catch {
-        Write-Warning "Impossible de charger le mapping existant, création d'un nouveau mapping."
-    }
-}
-
-# Fonction pour résoudre un chemin Windows
-function Resolve-WindowsPath {
-    param([string]$path)
-    
-    # Remplacer les variables d'environnement
-    $resolved = $path
-    $resolved = $resolved -replace '%USERPROFILE%', $env:USERPROFILE
-    $resolved = $resolved -replace '%APPDATA%', $env:APPDATA
-    $resolved = $resolved -replace '%LOCALAPPDATA%', $env:LOCALAPPDATA
-    $resolved = $resolved -replace '%HOME%', $env:HOME
-    $resolved = $resolved -replace '%USERPROFILE%', $env:USERPROFILE
-    
-    # Remplacer les autres variables d'environnement
-    $resolved = [System.Environment]::ExpandEnvironmentVariables($resolved)
-    
-    return $resolved
-}
-
-# Fonction pour résoudre un chemin WSL
-function Resolve-WSLPath {
-    param([string]$path)
-    
-    # Expansion de ~
-    if ($path -match '^~') {
-        $homePath = wsl bash -c "echo ~"
-        $path = $path -replace '^~', $homePath
-    }
-    
-    return $path
-}
-
-# Fonction pour obtenir le chemin relatif dans le projet
-function Get-ProjectPath {
-    param(
-        [string]$system,
-        [string]$originalPath
-    )
-    
-    # Nettoyer chaque partie du chemin
-    $parts = $originalPath -split '[\\/]'
-    $safeParts = @()
-    
-    foreach ($part in $parts) {
-        # Nettoyer chaque partie : remplacer les caractères invalides et les variables
-        $safePart = $part -replace '[\\/:*?"<>|]', '_'
-        $safePart = $safePart -replace '^%', 'var_' -replace '%$', '' -replace '%', '_'
-        $safePart = $safePart -replace '^~', 'home'
-        
-        # Si la partie est vide après nettoyage, utiliser un nom par défaut
-        if ([string]::IsNullOrWhiteSpace($safePart)) {
-            $safePart = "root"
-        }
-        
-        $safeParts += $safePart
-    }
-    
-    # Rejoindre toutes les parties avec des underscores
-    $safeName = $safeParts -join '_'
-    
-    # Construire le chemin final
-    $basePath = Join-Path "configs" $system
-    return Join-Path $basePath $safeName
-}
-
-# Lire et traiter le fichier de configuration
-$lines = Get-Content $ConfigFile | Where-Object { 
-    $_ -notmatch '^\s*#' -and $_.Trim() -ne '' 
-}
-
-$copiedCount = 0
-$skippedCount = 0
-$errorCount = 0
-
-foreach ($line in $lines) {
-    $line = $line.Trim()
-    if ($line -eq '' -or $line -match '^\s*#') {
-        continue
-    }
-    
-    # Parser la ligne: système|chemin
-    if ($line -notmatch '^(\w+)\|(.+)$') {
-        Write-Warning "Ligne ignorée (format invalide): $line"
-        continue
-    }
-    
-    $system = $matches[1]
-    $originalPath = $matches[2]
-    
-    if ($system -notin @('windows', 'wsl')) {
-        Write-Warning "Système invalide '$system' dans la ligne: $line"
-        continue
-    }
-    
-    try {
-        # Résoudre le chemin selon le système
-        if ($system -eq 'windows') {
-            $resolvedPath = Resolve-WindowsPath $originalPath
-        } else {
-            # Pour WSL, utiliser wsl pour résoudre le chemin
-            $wslPath = $originalPath
-            if ($wslPath -match '^~') {
-                $wslPath = wsl bash -c "echo $wslPath"
-            }
-            $resolvedPath = $wslPath
-        }
-        
-        # Vérifier que le fichier existe
-        if ($system -eq 'windows') {
-            if (-not (Test-Path $resolvedPath)) {
-                Write-Warning "Fichier introuvable: $resolvedPath (original: $originalPath)"
-                $skippedCount++
-                continue
-            }
-        } else {
-            # Pour WSL, vérifier via wsl
-            wsl test -f "$resolvedPath" 2>$null | Out-Null
-            if ($LASTEXITCODE -ne 0) {
-                Write-Warning "Fichier introuvable dans WSL: $resolvedPath (original: $originalPath)"
-                $skippedCount++
-                continue
-            }
-        }
-        
-        # Obtenir le chemin de destination dans le projet
-        $projectPath = Get-ProjectPath $system $originalPath
-        
-        # Créer le répertoire parent si nécessaire
-        $projectDir = Split-Path $projectPath -Parent
-        if (-not (Test-Path $projectDir)) {
-            New-Item -ItemType Directory -Path $projectDir -Force | Out-Null
-        }
-        
-        # Copier le fichier
-        if ($system -eq 'windows') {
-            Copy-Item -Path $resolvedPath -Destination $projectPath -Force
-        } else {
-            # Pour WSL, utiliser PowerShell pour copier depuis WSL
-            # Méthode plus fiable : lire le contenu depuis WSL et l'écrire avec PowerShell
-            try {
-                $content = wsl cat "$resolvedPath" 2>&1
-                if ($LASTEXITCODE -eq 0) {
-                    # Convertir le contenu en chaîne si c'est un tableau
-                    if ($content -is [array]) {
-                        $content = $content -join "`n"
-                    }
-                    Set-Content -Path $projectPath -Value $content -Encoding UTF8 -Force
-                } else {
-                    throw "Erreur lors de la lecture du fichier WSL: $content"
-                }
-            } catch {
-                Write-Error "Impossible de copier le fichier WSL '$resolvedPath': $_"
-                throw
-            }
-        }
-        
-        # Enregistrer le mapping
-        $mapping[$system][$originalPath] = $projectPath
-        
-        Write-Host "Copié: $originalPath -> $projectPath"
-        $copiedCount++
-        
-    } catch {
-        Write-Error "Erreur lors du traitement de '$line': $_"
-        $errorCount++
-    }
-}
-
-# Sauvegarder le mapping
-$mappingJson = @{
-    windows = $mapping.windows
-    wsl = $mapping.wsl
-} | ConvertTo-Json -Depth 10
-
-Set-Content -Path $MappingFile -Value $mappingJson -Encoding UTF8
-
-Write-Host "`nRésumé:"
-Write-Host "  Fichiers copiés: $copiedCount"
-Write-Host "  Fichiers ignorés: $skippedCount"
-Write-Host "  Erreurs: $errorCount"
-Write-Host "  Mapping sauvegardé dans: $MappingFile"
-
+# Script pour copier les fichiers de configuration vers le projet

+# Lit files-config.txt et copie chaque fichier vers configs/{system}/

+

+param(

+    [string]$ConfigFile = "files-config.txt",

+    [string]$MappingFile = "path-mapping.json"

+)

+

+$ErrorActionPreference = "Stop"

+

+# Vérifier que le fichier de configuration existe

+if (-not (Test-Path $ConfigFile)) {

+    Write-Error "Le fichier de configuration '$ConfigFile' n'existe pas."

+    exit 1

+}

+

+# Créer les répertoires de destination

+$configsDir = "configs"

+$windowsDir = Join-Path $configsDir "windows"

+$wslDir = Join-Path $configsDir "wsl"

+

+foreach ($dir in @($configsDir, $windowsDir, $wslDir)) {

+    if (-not (Test-Path $dir)) {

+        New-Item -ItemType Directory -Path $dir -Force | Out-Null

+        Write-Host "Créé le répertoire: $dir"

+    }

+}

+

+# Charger le mapping existant ou créer un nouveau

+$mapping = @{

+    windows = @{}

+    wsl = @{}

+}

+

+if (Test-Path $MappingFile) {

+    try {

+        $existingMapping = Get-Content $MappingFile -Raw | ConvertFrom-Json

+        if ($existingMapping.windows) {

+            $mapping.windows = @{}

+            $existingMapping.windows.PSObject.Properties | ForEach-Object {

+                $mapping.windows[$_.Name] = $_.Value

+            }

+        }

+        if ($existingMapping.wsl) {

+            $mapping.wsl = @{}

+            $existingMapping.wsl.PSObject.Properties | ForEach-Object {

+                $mapping.wsl[$_.Name] = $_.Value

+            }

+        }

+    } catch {

+        Write-Warning "Impossible de charger le mapping existant, création d'un nouveau mapping."

+    }

+}

+

+# Fonction pour résoudre un chemin Windows

+function Resolve-WindowsPath {

+    param([string]$path)

+    

+    # Remplacer les variables d'environnement

+    $resolved = $path

+    $resolved = $resolved -replace '%USERPROFILE%', $env:USERPROFILE

+    $resolved = $resolved -replace '%APPDATA%', $env:APPDATA

+    $resolved = $resolved -replace '%LOCALAPPDATA%', $env:LOCALAPPDATA

+    $resolved = $resolved -replace '%HOME%', $env:HOME

+    $resolved = $resolved -replace '%USERPROFILE%', $env:USERPROFILE

+    

+    # Remplacer les autres variables d'environnement

+    $resolved = [System.Environment]::ExpandEnvironmentVariables($resolved)

+    

+    return $resolved

+}

+

+# Fonction pour résoudre un chemin WSL vers un chemin Windows accessible

+function Resolve-WSLPath {

+    param([string]$path)

+    

+    # Détecter la distribution WSL (par défaut Ubuntu)

+    $wslDistro = "Ubuntu"

+    

+    # Expansion de ~ vers /home/toshiro (ou autre utilisateur)

+    if ($path -match '^~') {

+        $homePath = wsl bash -c "echo ~" 2>$null

+        if ($LASTEXITCODE -eq 0 -and $homePath) {

+            $path = $path -replace '^~', $homePath

+        } else {

+            # Fallback: utiliser toshiro

+            $path = $path -replace '^~', "/home/toshiro"

+        }

+    }

+    

+    # Convertir le chemin WSL en chemin Windows accessible

+    # Format: /home/toshiro/.bashrc -> \\wsl.localhost\Ubuntu\home\toshiro\.bashrc

+    if ($path -match '^/') {

+        # Enlever le slash initial

+        $relativePath = $path.Substring(1)

+        # Convertir en chemin Windows

+        $windowsPath = "\\wsl.localhost\$wslDistro\$relativePath" -replace '/', '\'

+        return $windowsPath

+    }

+    

+    return $path

+}

+

+# Fonction pour obtenir le chemin relatif dans le projet

+function Get-ProjectPath {

+    param(

+        [string]$system,

+        [string]$originalPath

+    )

+    

+    # Nettoyer chaque partie du chemin

+    $parts = $originalPath -split '[\\/]'

+    $safeParts = @()

+    

+    foreach ($part in $parts) {

+        # Nettoyer chaque partie : remplacer les caractères invalides et les variables

+        $safePart = $part -replace '[\\/:*?"<>|]', '_'

+        $safePart = $safePart -replace '^%', 'var_' -replace '%$', '' -replace '%', '_'

+        $safePart = $safePart -replace '^~', 'home'

+        

+        # Si la partie est vide après nettoyage, utiliser un nom par défaut

+        if ([string]::IsNullOrWhiteSpace($safePart)) {

+            $safePart = "root"

+        }

+        

+        $safeParts += $safePart

+    }

+    

+    # Rejoindre toutes les parties avec des underscores

+    $safeName = $safeParts -join '_'

+    

+    # Construire le chemin final

+    $basePath = Join-Path "configs" $system

+    return Join-Path $basePath $safeName

+}

+

+# Lire et traiter le fichier de configuration

+$lines = Get-Content $ConfigFile | Where-Object { 

+    $_ -notmatch '^\s*#' -and $_.Trim() -ne '' 

+}

+

+$copiedCount = 0

+$skippedCount = 0

+$errorCount = 0

+

+foreach ($line in $lines) {

+    $line = $line.Trim()

+    if ($line -eq '' -or $line -match '^\s*#') {

+        continue

+    }

+    

+    # Parser la ligne: système|chemin

+    if ($line -notmatch '^(\w+)\|(.+)$') {

+        Write-Warning "Ligne ignorée (format invalide): $line"

+        continue

+    }

+    

+    $system = $matches[1]

+    $originalPath = $matches[2]

+    

+    if ($system -notin @('windows', 'wsl')) {

+        Write-Warning "Système invalide '$system' dans la ligne: $line"

+        continue

+    }

+    

+    try {

+        # Résoudre le chemin selon le système

+        if ($system -eq 'windows') {

+            $resolvedPath = Resolve-WindowsPath $originalPath

+        } else {

+            # Pour WSL, convertir en chemin Windows accessible

+            $resolvedPath = Resolve-WSLPath $originalPath

+        }

+        

+        # Vérifier que le fichier existe

+        if (-not (Test-Path $resolvedPath)) {

+            Write-Warning "Fichier introuvable: $resolvedPath (original: $originalPath)"

+            $skippedCount++

+            continue

+        }

+        

+        # Obtenir le chemin de destination dans le projet

+        $projectPath = Get-ProjectPath $system $originalPath

+        

+        # Créer le répertoire parent si nécessaire

+        $projectDir = Split-Path $projectPath -Parent

+        if (-not (Test-Path $projectDir)) {

+            New-Item -ItemType Directory -Path $projectDir -Force | Out-Null

+        }

+        

+        # Copier le fichier

+        # Maintenant que les chemins WSL sont convertis en chemins Windows, on peut utiliser Copy-Item pour les deux

+        Copy-Item -Path $resolvedPath -Destination $projectPath -Force

+        

+        # Enregistrer le mapping

+        $mapping[$system][$originalPath] = $projectPath

+        

+        Write-Host "Copié: $originalPath -> $projectPath"

+        $copiedCount++

+        

+    } catch {

+        Write-Error "Erreur lors du traitement de '$line': $_"

+        $errorCount++

+    }

+}

+

+# Sauvegarder le mapping

+$mappingJson = @{

+    windows = $mapping.windows

+    wsl = $mapping.wsl

+} | ConvertTo-Json -Depth 10

+

+Set-Content -Path $MappingFile -Value $mappingJson -Encoding UTF8

+

+Write-Host "`nRésumé:"

+Write-Host "  Fichiers copiés: $copiedCount"

+Write-Host "  Fichiers ignorés: $skippedCount"

+Write-Host "  Erreurs: $errorCount"

+Write-Host "  Mapping sauvegardé dans: $MappingFile"

+