Alias et terminal

Il est possible de mettre en place des alias de commandes git en éditant soit ~/.gitconfig soit .git/config dans le dossier du projet 

[alias]
    lg = log -20 --graph --oneline --decorate
    st = status
    co = checkout
    cm = commit -m
    p = pull --all
    info = "!git config --get remote.origin.url"
[diff]
    algorithm = histogram

Afficher la branche courante dans le terminal

Pour afficher la branche courante dans le terminal, ajouter les lignes suivantes dans le fichier ~/.bashrc : 

parse_git_branch() {
     git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
}
export PS1="\[\033[1m\]\[\033[32m\]\u@\h\[\033[39m\]:\[\033[34m\]\w\[\033[33m\]\$(parse_git_branch)\[\033[00m\] $ "

Générer les messages de commit avec Claude Code

#!/bin/bash
 
# cic - Commits Conventionnels Interactifs utilisant Claude
# Génère des messages de commit en français à l'aide de Claude CLI et demande une confirmation
 
set -e
 
# Définition des couleurs
GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[0;33m'
BLUE='\033[0;94m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
BOLD='\033[1m'
NC='\033[0m' # Pas de couleur
 
# Vérifier si nous sommes dans un dépôt git
if ! git rev-parse --is-inside-work-tree &> /dev/null; then
  echo -e "${RED}Erreur : Vous n'êtes pas dans un dépôt git${NC}" >&2
  exit 1
fi
 
# Obtenir les informations sur les fichiers indexés
STAGED_FILES=$(git diff --staged --name-only)
if [ -z "$STAGED_FILES" ]; then
  echo -e "${YELLOW}Aucune modification indexée trouvée. Utilisez 'git add' pour indexer des modifications d'abord.${NC}" >&2
  exit 1
fi
 
# Générer le message de commit en utilisant Claude
echo -e "${BLUE}Génération du message de commit avec Claude...${NC}"
COMMIT_MSG=$(claude -p "Génère un message de commit conventionnel EN FRANÇAIS pour les modifications de la commande 'git diff --staged'
 
Format:
 
type(scope): description
 
- [Liste détaillée des changements]")
 
# Afficher le message généré
echo -e "\n${PURPLE}${BOLD}=== Message de Commit Généré ===${NC}\n"
echo -e "${BOLD}$COMMIT_MSG${NC}"
echo -e "\n${PURPLE}${BOLD}===============================${NC}\n"
 
# Demander une confirmation
echo -ne "${YELLOW}Procéder avec ce message de commit? [o/N/e] (o=oui, N=non, e=éditer): ${NC}"
read CONFIRM
 
case "$CONFIRM" in
  [Oo]*)
    # Procéder au commit avec le message généré
    git commit -m "$COMMIT_MSG"
    echo -e "${GREEN}Commit créé avec succès!${NC}"
    ;;
  [Ee]*)
    # Permettre à l'utilisateur d'éditer le message
    echo "$COMMIT_MSG" > .tmp_commit_msg
    ${EDITOR:-vim} .tmp_commit_msg
 
    # Afficher le message édité
    echo -e "\n${PURPLE}${BOLD}=== Message de Commit Édité ===${NC}\n"
    EDITED_MSG=$(cat .tmp_commit_msg)
    echo -e "${BOLD}$EDITED_MSG${NC}"
    echo -e "\n${PURPLE}${BOLD}===============================${NC}\n"
 
    # Demander confirmation pour le message édité
    echo -ne "${YELLOW}Procéder avec ce message édité? [O/n]: ${NC}"
    read CONFIRM_EDIT
 
    if [[ "$CONFIRM_EDIT" != [Nn]* ]]; then
      git commit -F .tmp_commit_msg
      echo -e "${GREEN}Commit créé avec le message édité!${NC}"
    else
      echo -e "${YELLOW}Commit annulé.${NC}"
    fi
 
    rm .tmp_commit_msg
    ;;
  *)
    # L'utilisateur a refusé ou entrée invalide
    echo -e "${YELLOW}Commit annulé.${NC}"
    ;;
esac

Générer les messages de commit avec ChatGPT

Installer le package jq 

sudo apt install jq

Puis ajouter la clé d'API OpenAI dans le fichier ~/.profile 

export OPENAI_API_KEY="......"

Prendre en compte le fichier ~/.profile 

source ~/.profile

Puis ajouter le contenu suivant dans un fichier ~/bin/cia (Commit IA) 

#!/bin/bash
 
# Définition des couleurs
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
MAGENTA='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color
 
# Définition du modèle par défaut
MODEL=${1:-"gpt-4.1-nano"}
 
# Vérification de la présence de la clé API OpenAI dans les variables d'environnement
if [ -z "$OPENAI_API_KEY" ]; then
    echo -e "${RED}Erreur: La variable d'environnement OPENAI_API_KEY n'est pas définie${NC}"
    exit 1
fi
 
# Vérification qu'on est dans un repo git
if ! git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
    echo -e "${RED}Erreur: Vous n'êtes pas dans un dépôt Git${NC}"
    exit 1
fi
 
# Limite maximale de tokens en fonction du modèle
if [[ "$MODEL" == "gpt-4o-mini" ]]; then
    MAX_TOKENS=19000
else
    MAX_TOKENS=3500
fi
 
# Récupération du git diff
DIFF=$(git diff --staged)
 
if [ -z "$DIFF" ]; then
    echo -e "${YELLOW}Aucun changement n'a été mis en staging. Utilisez 'git add' pour ajouter des fichiers.${NC}"
    exit 1
fi
 
# Récupération du contexte du projet
PROJECT_NAME=$(basename "$(git rev-parse --show-toplevel)")
BRANCH=$(git branch --show-current)
RECENT_COMMITS=$(git log -n 5 --pretty=format:"%s")
FILES_CHANGED=$(git diff --staged --name-only | tr '\n' ', ')
 
# Fonction pour estimer grossièrement le nombre de tokens (4 caractères ~ 1 token)
estimate_tokens() {
    local text="$1"
    local char_count=${#text}
    echo $((char_count / 4))
}
 
# Préparation du contexte
SYSTEM_PROMPT="Tu es un assistant expert en Git, spécialisé dans la rédaction de messages de commit clairs, concis et structurés"
USER_PROMPT_ANALYSIS="Analyse le diff suivant et produis une liste détaillée des modifications effectuées. Énumère chaque changement significatif sous forme de liste à puces. Voici le contexte du projet et le diff :"
USER_PROMPT_COMMIT="À partir de la liste des modifications suivante, génère un message de commit en français, concis et descriptif. Respecte les conventions de Commit Convention (ex : feat, fix, chore, etc.). La première ligne ne doit pas dépasser 72 caractères sans indiquer le nom de fichier ou classe, suivie d'une ligne vide, puis d'une description succinte en liste à puces des modifications les plus pertinentes sans jamais indiquer les noms des fichiers ou les classes. Voici le contexte du projet et la liste des modifications :"
PROJECT_CONTEXT="Nom du projet: $PROJECT_NAME\nBranche actuelle: $BRANCH\nFichiers modifiés: $FILES_CHANGED\nCommits récents:\n$RECENT_COMMITS"
 
# Estimation des tokens actuels
CURRENT_TOKENS=$(estimate_tokens "$SYSTEM_PROMPT$USER_PROMPT_ANALYSIS$PROJECT_CONTEXT$DIFF")
 
# Vérifier si nous dépassons la limite de tokens
if [ "$CURRENT_TOKENS" -gt "$MAX_TOKENS" ]; then
    echo -e "${YELLOW}Avertissement: Le diff est volumineux ($CURRENT_TOKENS tokens estimés), filtrage des fichiers binaires et ressources...${NC}"
 
    # Récupérer la liste des fichiers avant filtrage
    OLD_FILES_LIST=$(git diff --staged --name-only)
 
    # Filtrer les fichiers ressources (images, binaires, fichiers de lock, etc.)
    FILTERED_FILES_LIST=$(echo "$OLD_FILES_LIST" | grep -v -E "\.(png|jpg|jpeg|gif|svg|ico|woff|ttf|eot|pdf|zip|bin|dat|lock)$")
 
    # Recréer un diff uniquement avec les fichiers filtrés
    FILTERED_DIFF=$(git diff --staged -- $FILTERED_FILES_LIST)
 
    # Mettre à jour la liste des fichiers modifiés pour le contexte
    FILES_CHANGED=$(echo "$FILTERED_FILES_LIST" | tr '\n' ', ')
 
    # Réestimer après filtrage
    FILTERED_TOKENS=$(estimate_tokens "$SYSTEM_PROMPT$USER_PROMPT_ANALYSIS$PROJECT_CONTEXT$FILTERED_DIFF")
 
    if [ "$FILTERED_TOKENS" -gt "$MAX_TOKENS" ]; then
        echo -e "${RED}Erreur: Même après filtrage, le diff est trop volumineux ($FILTERED_TOKENS tokens estimés).${NC}"
        echo -e "${YELLOW}Essayez de diviser votre commit en plusieurs commits plus petits.${NC}"
        exit 1
    else
        echo -e "${GREEN}Diff filtré avec succès, continuation avec $FILTERED_TOKENS tokens.${NC}"
        DIFF="$FILTERED_DIFF"
    fi
fi
 
# Construction du JSON pour l'analyse des différences
JSON_DATA_ANALYSIS=$(jq -n \
  --arg system "$SYSTEM_PROMPT" \
  --arg prompt "$USER_PROMPT_ANALYSIS" \
  --arg project_context "$PROJECT_CONTEXT" \
  --arg diff "$DIFF" \
  --arg temperature "0.7" \
  --arg model "$MODEL" '
  {
    "model": $model,
    "messages": [
      {
        "role": "system",
        "content": $system
      },
      {
        "role": "user",
        "content": ($prompt + "\n\nContexte du projet:\n" + $project_context + "\n\nDiff:\n" + $diff)
      }
    ],
    "temperature": ($temperature | tonumber),
    "max_tokens": 1024
  }
')
 
# Appel à l'API OpenAI pour l'analyse
echo -e "${BLUE}Analyse des modifications en cours...${NC}"
RESPONSE_ANALYSIS=$(curl -s https://api.openai.com/v1/chat/completions \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d "$JSON_DATA_ANALYSIS")
 
# Extraction de la liste des modifications
MODIFICATIONS_LIST=$(echo $RESPONSE_ANALYSIS | jq -r '.choices[0].message.content' 2>/dev/null)
 
if [ $? -ne 0 ] || [ -z "$MODIFICATIONS_LIST" ]; then
    echo -e "${RED}Erreur lors de l'analyse des modifications${NC}"
    echo -e "${YELLOW}Réponse de l'API:${NC} $RESPONSE_ANALYSIS"
    exit 1
fi
 
echo -e "${GREEN}Analyse terminée!${NC}"
 
# Construction du JSON pour la génération du message de commit
JSON_DATA_COMMIT=$(jq -n \
  --arg system "$SYSTEM_PROMPT" \
  --arg prompt "$USER_PROMPT_COMMIT" \
  --arg project_context "$PROJECT_CONTEXT" \
  --arg modifications "$MODIFICATIONS_LIST" \
  --arg temperature "0.7" \
  --arg model "$MODEL" '
  {
    "model": $model,
    "messages": [
      {
        "role": "system",
        "content": $system
      },
      {
        "role": "user",
        "content": ($prompt + "\n\nContexte du projet:\n" + $project_context + "\n\nListe des modifications:\n" + $modifications)
      }
    ],
    "temperature": ($temperature | tonumber),
    "max_tokens": 1024
  }
')
 
# Appel à l'API OpenAI pour le message de commit
echo -e "${BLUE}Génération du message de commit...${NC}"
RESPONSE_COMMIT=$(curl -s https://api.openai.com/v1/chat/completions \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d "$JSON_DATA_COMMIT")
 
# Extraction du message de commit de la réponse JSON et suppression des triple backticks
RAW_MESSAGE=$(echo $RESPONSE_COMMIT | jq -r '.choices[0].message.content' 2>/dev/null | sed 's/```\(\w*\)\?//g')
# Suppression des lignes vides au début du message
MESSAGE=$(echo "$RAW_MESSAGE" | sed '/./,$!d')
 
if [ $? -ne 0 ] || [ -z "$MESSAGE" ]; then
    echo -e "${RED}Erreur lors de la génération du message de commit${NC}"
    echo -e "${YELLOW}Réponse de l'API:${NC} $RESPONSE_COMMIT"
    exit 1
fi
 
# Affichage du message généré
echo -e "${BLUE}Message de commit généré:${NC}"
echo -e "${CYAN}------------------------${NC}"
echo -e ""
echo -n "$MESSAGE"
echo -e ""
echo -e "\n${CYAN}------------------------${NC}"
 
# Demande de confirmation
read -p "$(echo -e "${MAGENTA}Voulez-vous utiliser ce message pour votre commit? (o/N) ${NC}")" CONFIRM
 
if [[ $CONFIRM =~ ^[oO]$ ]]; then
    git commit -m "$MESSAGE"
    echo -e "${GREEN}Commit effectué avec succès!${NC}"
else
    echo -e "${YELLOW}Commit annulé. Vous pouvez modifier le message et faire le commit manuellement.${NC}"
fi

Pour finir, rendez le fichier ~/bin/cia exécutable : 

chmod +x ~/bin/cia

A partir de là, il suffit d'ajouter les fichiers avec la commande git add et lancer ensuite cia

  • Dernière modification: 05/05/2025 14:18