Script Shell : ajoutez et réduisez votre code dans des fichiers pour que l’IA puisse l’analyser

Si vous êtes développeur, vous recevrez probablement beaucoup d’aide de l’IA générative (GénAI). Cependant, tout IA les plates-formes ont une taille de fichier maximale et limitent le nombre de fichiers que vous pouvez télécharger. Cela peut être frustrant si vous travaillez avec un répertoire contenant des dizaines de petits fichiers bien organisés.

J’ai rencontré ce problème à plusieurs reprises lorsque je travaillais sur des plugins WordPress ou des modifications de thèmes enfants. J’ai commencé à me demander s’il existait un moyen simple de combiner tout le code et de l’organiser dans des fichiers texte que je pourrais télécharger facilement. Et il y en avait !

Script Shell pour combiner des fichiers de code

J’ai développé ceci minify.sh script shell pouvant être exécuté sous Linux, Unix ou Mac OS à partir d’une commande de terminal dans votre dossier de travail. J’ai utilisé cela pour télécharger du code à réviser sur Gémeaux, ChatGPTet Claude sans problèmes.

#!/bin/bash

# Configuration
MAX_SIZE=$((650 * 1024))  # 650KB in bytes
FILE_EXTENSIONS=("php" "js" "html" "css")

# Get current folder name for output prefix
OUTPUT_PREFIX=$(basename "$(pwd)")

# Initialize variables for each file type
declare -A file_counters=( ["php"]=1 ["js"]=1 ["html"]=1 ["css"]=1 )
declare -A current_sizes=( ["php"]=0 ["js"]=0 ["html"]=0 ["css"]=0 )
declare -A output_files

# Function to minify content based on file type
minify_content() {
    local file=$1
    local extension="${file##*.}"
    local content

    case "$extension" in
        php)
            content=$(cat "$file" | \
                sed -e 's/\/\*.*\*\///g' \
                    -e 's/\/\/.*$//' \
                    -e '/^[[:space:]]*$/d' \
                    -e 's/[[:space:]]\+/ /g' \
                    -e 's/> </></g' \
                    -e 's/\r//g')
            ;;
        js)
            content=$(cat "$file" | \
                sed -e 's/\/\*.*\*\///g' \
                    -e 's/\/\/.*$//' \
                    -e '/^[[:space:]]*$/d' \
                    -e 's/[[:space:]]\+/ /g' \
                    -e 's/;[[:space:]]/;/g' \
                    -e 's/,[[:space:]]/,/g' \
                    -e 's/\r//g')
            ;;
        css)
            content=$(cat "$file" | \
                sed -e 's/\/\*.*\*\///g' \
                    -e '/^[[:space:]]*$/d' \
                    -e 's/[[:space:]]\+/ /g' \
                    -e 's/:[[:space:]]/:/g' \
                    -e 's/,[[:space:]]/,/g' \
                    -e 's/;[[:space:]]/;/g' \
                    -e 's/{[[:space:]]*/{/g' \
                    -e 's/}[[:space:]]*/}/g' \
                    -e 's/[[:space:]]*{/{/g' \
                    -e 's/[[:space:]]*}/}/g' \
                    -e 's/\r//g')
            ;;
        html)
            content=$(cat "$file" | \
                sed -e 's/<!--.*-->//g' \
                    -e '/^[[:space:]]*$/d' \
                    -e 's/[[:space:]]\+/ /g' \
                    -e 's/> </></g' \
                    -e 's/\r//g')
            ;;
    esac
    echo "$content"
}

# Function to write file header
write_file_header() {
    local full_path=$1
    local type=$2
    echo "/* File: $full_path */" >> "${output_files[$type]}"
}

# Function to process files of a specific type
process_file_type() {
    local type=$1
    local counter_ref="file_counters[$type]"
    local size_ref="current_sizes[$type]"
    
    # Initialize first file for this type
    output_files[$type]="${OUTPUT_PREFIX}-${type}-${file_counters[$type]}.txt"

    find . -type f -name "*.$type" -print0 | while IFS= read -r -d '' file; do
        # Minify and get content
        local minified_content=$(minify_content "$file")
        local file_size=${#minified_content}
        
        # Check if we need to start a new file
        if (( current_sizes[$type] + file_size > MAX_SIZE )) && (( current_sizes[$type] > 0 )); then
            echo "Size limit reached for $type (${current_sizes[$type]} bytes). Creating new file..."
            file_counters[$type]=$((file_counters[$type] + 1))
            output_files[$type]="${OUTPUT_PREFIX}-${type}-${file_counters[$type]}.txt"
            current_sizes[$type]=0
        fi
        
        # Process the file
        echo "Processing $type file: $file (Original size: $(wc -c < "$file") bytes, Minified: $file_size bytes)"
        
        write_file_header "$(realpath "$file")" "$type"
        echo "$minified_content" >> "${output_files[$type]}"
        echo -e "\n" >> "${output_files[$type]}"
        
        current_sizes[$type]=$((current_sizes[$type] + file_size))
        echo "Current $type file size: ${current_sizes[$type]} bytes"
    done
}

# Main execution
echo "Starting file minification and combination process..."
echo "Using folder name '${OUTPUT_PREFIX}' as prefix for output files..."

# Process each file type separately
for type in "${FILE_EXTENSIONS[@]}"; do
    echo "Processing $type files..."
    process_file_type "$type"
done

echo "Processing complete! Files have been minified and combined by type."
echo "Generated files:"
ls -lh ${OUTPUT_PREFIX}-*.txt

Configuration

Le script commence par définir quelques paramètres clés :

• MAX_SIZE: Cette variable définit la taille maximale (650 Ko) de chaque fichier de sortie. Cela garantit que les fichiers combinés ne deviennent pas trop volumineux à gérer.
• FILE_EXTENSIONS: Ce tableau répertorie les types de fichiers que le script traitera : PHP, JavaScript, HTML et CSS.
• OUTPUT_PREFIX: Ceci utilise intelligemment le nom du dossier actuel comme préfixe pour les fichiers de sortie, gardant les choses organisées.

Le moteur de minification

Le cœur du scénario réside dans minify_content fonction. Il prend un fichier en entrée et, en fonction de son extension, applique une série de sed commandes pour supprimer les commentaires, les espaces inutiles et les sauts de ligne. Il en résulte une version compressée du code original.

Gestion et combinaison de fichiers

Le script utilise des tableaux associatifs (declare -A) pour garder une trace des compteurs de fichiers, des tailles de fichiers actuelles et des noms de fichiers de sortie pour chaque type de fichier. Le process_file_type La fonction parcourt chaque type de fichier et effectue les étapes suivantes :

1. Recherche tous les fichiers : Il utilise le find commande pour localiser tous les fichiers avec l’extension spécifiée.
2. Réduit le contenu : Il appelle le minify_content fonction pour compresser le fichier.
3. Vérifie la taille du fichier : Cela garantit que l’ajout du fichier actuel ne dépasse pas le MAX_SIZE. Si tel est le cas, un nouveau fichier de sortie est créé.
4. Écrit dans le fichier : Il ajoute un en-tête avec le chemin du fichier d’origine à des fins de débogage et ajoute le contenu minifié au fichier de sortie.

Rassembler tout cela

La section d’exécution principale du script parcourt le FILE_EXTENSIONS tableau, appelant le process_file_type fonction pour chacun. Je l’ai même analysé les différents types de code dans différents fichiers (PHP, JS, CSS, HTML) pour faciliter les choses. Vous travaillez sur un problème PHP ? Téléchargez simplement le fichier pour PHP et ignorez le reste. Enfin, il répertorie les fichiers générés avec leurs tailles.

La combinaison de la minification et de la combinaison de fichiers réduit considérablement la taille des fichiers et le nombre de fichiers à télécharger sur votre plateforme d’IA générative préférée.

Comment utiliser ce script Shell

1. Enregistrez le script : Copiez le code fourni dans l’article, collez-le dans un éditeur de texte et enregistrez le fichier avec un .sh extension (par exemple, minify.sh).
2. Rendez-le exécutable : Ouvrez votre terminal ou votre invite de commande, accédez au répertoire dans lequel vous avez enregistré le script à l’aide du cd commande et rendez le script exécutable en exécutant : chmod +x minify.sh.
3. Accédez au répertoire: Utilisez le cd commande pour accéder au répertoire avec votre code. Un moyen simple de procéder consiste à taper cd et faites glisser le dossier d’une fenêtre du Finder vers votre terminal.

cd /Users/douglaskarr/Documents/my-folder

4. Exécutez le script : Exécutez le script en tapant le chemin où minify.sh est localisé et appuyez sur Entrée.

/Users/douglaskarr/Documents/minify.sh 

5. Le script affichera ce qui suit :
   • Messages de progression lors du traitement de chaque type de fichier.
   • Informations sur les tailles de fichiers originaux et réduits.
   • Notifications lorsque de nouveaux fichiers de sortie sont créés en raison de limites de taille.
   • Une liste des fichiers générés avec leurs tailles.

6. Localisez les fichiers de sortie :
   • Les fichiers combinés et minifiés se trouveront dans le même répertoire où vous avez exécuté le script.
   • Ils seront nommés en utilisant le nom du dossier actuel comme préfixe, suivi du type de fichier et d’un compteur (par exemple, myfolder-js-1.txt, myfolder-css-2.txt).

Remarques importantes :

• Types de fichiers : Le script gère actuellement les fichiers PHP, JavaScript, HTML et CSS. Vous pouvez modifier le FILE_EXTENSIONS tableau dans le script pour inclure d’autres types de fichiers si nécessaire.
• Taille maximale du fichier : Le MAX_SIZE La variable détermine la taille maximale de chaque fichier de sortie. Ajustez cette valeur si vous avez besoin de fichiers combinés plus grands ou plus petits.
• Dépendances : Ce script s’appuie sur le sed commande, qui est généralement disponible sur les systèmes de type Unix. Si vous êtes sous Windows, assurez-vous de disposer d’un environnement approprié comme WSL, Cygwin ou Git Bash.
• Personnalisation : Vous pouvez personnaliser davantage les règles de minification dans le minify_content fonction pour répondre à vos besoins spécifiques.
• Sauvegarde: C’est toujours une bonne pratique de sauvegarder vos fichiers originaux avant d’exécuter ce script, juste au cas où.

En suivant ces étapes simples, vous pouvez tirer parti de la puissance de ce script Bash pour combiner et réduire votre code afin que votre plate-forme d’IA puisse l’examiner !