10 Astuces pour réduire sa consommation de tokens de 80% avec Claude Code

Aider : L’alternative optimisée à Claude Code

Lorsque vous utilisez Claude Code de manière standard, chaque requête envoie l’intégralité du contexte du projet, même si vous ne modifiez qu’un seul fichier. Cette approche peut consommer des dizaines de milliers de tokens inutilement, surtout dans les conversations longues où le contexte est répété à chaque échange. Par exemple, un projet de 50 fichiers peut facilement générer 100 000 tokens par session, alors que seuls 5 000 tokens seraient réellement nécessaires pour les modifications ciblées.

La solution : Aider et sa gestion intelligente du contexte

Aider résout ce problème en adoptant une approche radicalement différente : au lieu d’envoyer l’intégralité des fichiers, il n’envoie que les différences (diffs) et maintient un contexte conversationnel minimal. Concrètement, si vous modifiez une fonction dans un fichier de 500 lignes, Aider n’enverra que les 20 lignes concernées plus un contexte minimal, réduisant la consommation de 95% sur cette opération. De plus, Aider utilise un système de « map » du code qui permet à Claude de naviguer dans votre projet sans charger tous les fichiers en mémoire.

Pourquoi Aider ?

Aider est spécifiquement conçu pour minimiser la consommation de tokens en n’envoyant que le strict nécessaire au modèle.

Avantages clés :

• Envoie uniquement les fichiers modifiés
• Utilise des git diffs au lieu de fichiers complets
• Gestion intelligente du contexte conversationnel
• Compatible avec tous les modèles Claude

Installation et utilisation

pip install aider-chat

# Utilisation basique
aider --model claude-sonnet-4-20250514 src/auth.py

# Mode économique sans auto-commits
aider --model claude-sonnet-4-20250514 --no-auto-commits --no-auto-lint

Économie estimée : 40-50% par rapport à Claude Code standard

Repomix : Contexte de repository optimisé

Quand vous demandez à Claude d’analyser votre projet, l’outil par défaut va scanner récursivement tous les fichiers et les envoyer tels quels, incluant des fichiers de configuration redondants, des commentaires verbeux, des lignes vides, et même des fichiers générés automatiquement. Un projet React typique de 200 fichiers peut facilement représenter 500 000 tokens si envoyé brut, alors que l’information réellement utile pour Claude tient en 50 000 tokens. Cette inefficacité est particulièrement problématique pour les monorepos ou les projets legacy avec beaucoup de code mort.

La solution : Repomix et son intelligence de compression

Repomix a été spécifiquement créé pour résoudre ce problème en analysant la structure de votre projet et en créant un fichier de contexte optimisé qui préserve l’information essentielle tout en éliminant le superflu. Il utilise des heuristiques intelligentes pour identifier et supprimer les commentaires de documentation générés automatiquement, fusionner les imports, éliminer les lignes vides consécutives, et structurer le tout dans un format XML ou Markdown que les LLM comprennent particulièrement bien. Le résultat est un fichier de contexte qui peut être 10 fois plus petit que le code original tout en restant parfaitement exploitable par Claude.

Le problème du contexte

Envoyer l’intégralité d’un projet à Claude est extrêmement coûteux. Repomix crée un fichier de contexte optimisé et structuré.

Installation et configuration

npm install -g repomix

# Génération du contexte
repomix --style xml --output context.xml

# Avec filtrage personnalisé
repomix --ignore "node_modules,dist,*.log" --output context.txt

Configuration avancée avec repomix.config.json

{
  "output": {
    "filePath": "context.txt",
    "style": "xml",
    "removeComments": true,
    "removeEmptyLines": true
  },
  "ignore": {
    "customPatterns": [
      "*.min.js",
      "*.map",
      "package-lock.json",
      "yarn.lock",
      "*.log",
      "dist/**",
      "build/**"
    ]
  },
  "include": ["src/**", "config/**", "README.md"]
}

Économie estimée : 50-70% sur les gros projets

GPTRepo : Index intelligent de code

Les outils standards traitent votre code comme une collection de fichiers texte sans comprendre la structure sémantique de votre projet. Cela signifie qu’ils ne peuvent pas distinguer entre du code critique (votre logique métier principale) et du code secondaire (utilitaires, helpers, configurations), envoyant tout avec la même priorité. Dans un projet Django typique, les migrations de base de données et les fichiers de test peuvent représenter 60% du code total mais ne sont pertinents que dans 5% des requêtes faites à Claude. Cette incapacité à prioriser le contexte gaspille énormément de tokens pour des informations rarement utiles.

La solution : GPTRepo et son analyse sémantique

GPTRepo va au-delà de la simple compression en effectuant une analyse sémantique de votre repository pour créer un résumé structuré et hiérarchisé. Il identifie automatiquement l’architecture de votre projet (MVC, microservices, etc.), extrait les dépendances entre modules, résume les fonctionnalités principales de chaque fichier, et organise tout cela dans un format que Claude peut parcourir efficacement. Au lieu d’envoyer 50 000 lignes de code, GPTRepo génère un « plan » de 5 000 lignes qui permet à Claude de comprendre votre projet et de demander uniquement les détails nécessaires. C’est particulièrement puissant pour les projets complexes où la navigation est aussi importante que le contenu lui-même.

Fonctionnement

GPTRepo analyse votre repository et crée un résumé structuré contenant uniquement les informations essentielles.

pip install gptrepo

# Génération du contexte
gptrepo . -o project-context.txt

# Avec exclusions
gptrepo . -o context.txt --ignore "tests/,docs/"

Intégration avec Claude Code

# Utiliser le contexte généré
claude-code --files project-context.txt "ajoute une validation email"

Économie estimée : 60-75%

Semgrep : Recherche structurée de code

Utiliser grep ou des recherches textuelles classiques pour trouver du code avant de l’envoyer à Claude est extrêmement inefficace. Ces outils ne comprennent pas la syntaxe du code et vont retourner des faux positifs (commentaires, strings, noms de variables similaires) ainsi que des résultats fragmentés qui nécessitent d’envoyer des fichiers entiers pour le contexte. Par exemple, chercher « authenticate » avec grep peut retourner 200 occurrences dont 150 sont des commentaires ou des logs, vous forçant à envoyer 50 fichiers à Claude alors que seules 10 fonctions sont réellement pertinentes. Cette approche peut multiplier par 5 votre consommation de tokens pour une recherche simple.

La solution : Semgrep et sa compréhension syntaxique

Semgrep est un outil qui comprend réellement la structure de votre code en utilisant des parsers syntaxiques pour chaque langage. Au lieu de chercher du texte, il cherche des patterns de code, ce qui lui permet d’identifier précisément les fonctions, classes, ou blocs qui vous intéressent, en ignorant les commentaires et les fausses correspondances. Encore mieux, Semgrep peut extraire automatiquement le contexte minimal nécessaire (imports, dépendances) autour du code trouvé, vous permettant d’envoyer à Claude exactement ce dont il a besoin, rien de plus. Pour notre exemple d’authentification, Semgrep retournerait uniquement les 10 fonctions pertinentes avec leur contexte minimal, réduisant l’envoi de 50 fichiers à peut-être 2-3 fichiers ciblés.

Au-delà de grep

Semgrep comprend la structure du code et permet de cibler précisément ce qui doit être envoyé à Claude.

pip install semgrep

# Recherche intelligente
semgrep --config=auto src/ --json | jq -r '.results[].path' | sort -u

# Intégration dans un script
FILES=$(semgrep --config=auto --quiet src/ | cut -d: -f1 | sort -u)
claude-code --files $FILES "corrige les vulnérabilités"

Patterns personnalisés

Créez .semgrep.yml pour des recherches récurrentes :

rules:
  - id: find-auth-functions
    pattern: |
      def $FUNC(...):
        ...
        authenticate(...)
        ...
    message: Functions with authentication
    languages: 
    severity: INFO

Économie estimée : 30-40% sur la recherche de code

Tree-sitter : Parser de code léger

Quand Claude a besoin de comprendre la structure de votre code, deux approches extrêmes existent : soit envoyer tous les fichiers complets (très coûteux), soit utiliser des regex ou grep (trop superficiel et source d’erreurs). Un fichier Python de 1000 lignes contient peut-être 30 fonctions, mais si vous envoyez tout le fichier pour que Claude comprenne l’architecture, vous payez pour 1000 lignes alors que les signatures de fonctions (150 lignes) suffiraient largement. Les outils basiques ne peuvent pas extraire intelligemment cette information structurelle, vous forçant à choisir entre précision (coûteuse) et économie (imprécise).

La solution : Tree-sitter et son parsing AST précis

Tree-sitter est une bibliothèque de parsing qui construit un Abstract Syntax Tree (AST) de votre code, permettant d’extraire exactement les éléments structurels qui vous intéressent. Voulez-vous uniquement les signatures de fonctions ? Tree-sitter peut les extraire en préservant les types et paramètres. Les définitions de classes avec leurs méthodes publiques ? C’est possible aussi. Les imports et dépendances ? Facile. Cette approche permet de réduire drastiquement la quantité de code envoyé tout en préservant toute l’information architecturale dont Claude a besoin. Pour notre fichier de 1000 lignes, Tree-sitter peut extraire un « squelette » de 100 lignes qui donne à Claude une vision parfaite de la structure sans le poids du code d’implémentation.

Extraire uniquement les signatures

Tree-sitter parse le code et peut extraire uniquement les signatures de fonctions, classes, etc.

npm install -g tree-sitter-cli

# Parser et extraire la structure
tree-sitter parse src/app.py | grep -E "(function|class)_definition"

Script d’extraction optimisé

from tree_sitter import Language, Parser
import tree_sitter_python as tspython

# Extraction des signatures uniquement
PY_LANGUAGE = Language(tspython.language())
parser = Parser(PY_LANGUAGE)

def extract_signatures(filepath):
    with open(filepath, 'rb') as f:
        tree = parser.parse(f.read())
    
    signatures = []
    for node in tree.root_node.children:
        if node.type in ['function_definition', 'class_definition']:
            signatures.append(node.text.decode().split(':'))
    
    return '\n'.join(signatures)

Économie estimée : 70-85% sur l’analyse de gros fichiers

Universal Ctags : Indexation rapide

Quand vous demandez à Claude de modifier une fonction spécifique, les outils classiques doivent scanner tout le projet pour la trouver, ce qui signifie charger potentiellement des centaines de fichiers en mémoire avant même de savoir lequel contient le code ciblé. Dans un monorepo de 500 fichiers, chercher la fonction processPayment peut nécessiter d’ouvrir et lire 500 fichiers, générant des millions de tokens de lecture juste pour la localisation. Cette approche est non seulement coûteuse en tokens mais aussi lente, créant une expérience utilisateur dégradée où chaque requête simple prend plusieurs secondes.

La solution : Ctags et son index instantané

Universal Ctags résout ce problème en créant un index pré-calculé de tous les symboles de votre code (fonctions, classes, variables, etc.) avec leur localisation exacte. Cet index, généré une seule fois et mis à jour incrémentalement, permet de localiser n’importe quel symbole instantanément sans lire un seul fichier. Chercher processPayment devient une simple recherche dans l’index qui retourne immédiatement « fichier payment.py, ligne 145 », permettant de charger uniquement ce fichier. Cette approche transforme une opération O(n) coûteuse en tokens en une opération O(1) quasi-gratuite. Pour les développeurs utilisant intensivement Claude, cela peut représenter une économie de 20-30% sur les opérations de navigation seules.

Navigation efficace dans le code

Ctags crée un index de votre code pour naviguer rapidement sans charger l’intégralité des fichiers.

# Installation
brew install universal-ctags  # macOS
apt install universal-ctags    # Linux

# Génération de l'index
ctags -R --fields=+l --exclude=node_modules --exclude=dist .

# Recherche rapide
ctags -x --filter=yes MyClass

Utilisation avec Claude

# Trouver la définition
LOCATION=$(ctags -x --filter=yes authenticate | awk '{print $4}')
claude-code --files $LOCATION "optimise cette fonction"

Économie estimée : Gain de temps + 20-30% de tokens

Tokentrim : Nettoyeur automatique

Même avec les meilleurs outils de sélection de fichiers, le code envoyé à Claude contient souvent beaucoup de « bruit » : commentaires de documentation générés automatiquement, docstrings verbeux, lignes vides multiples, code de debug commenté, et imports redondants. Ces éléments peuvent représenter 30-40% du contenu d’un fichier typique sans apporter de valeur réelle à la compréhension du code par Claude. Un fichier Python « propre » de 500 lignes contient souvent 150 lignes de docstrings et commentaires, 50 lignes vides, et 300 lignes de code réel. Envoyer ces 500 lignes coûte 40% plus cher que nécessaire alors que Claude peut parfaitement travailler avec les 300 lignes essentielles.

La solution : Tokentrim et son nettoyage intelligent

Tokentrim agit comme un filtre intelligent qui analyse votre code avant l’envoi et supprime automatiquement tout ce qui est superflu pour la compréhension du code tout en préservant ce qui est essentiel. Il utilise des heuristiques spécifiques à chaque langage pour identifier et retirer les commentaires de documentation automatique (qui suivent souvent des patterns reconnaissables), fusionner les lignes vides excessives, supprimer le code commenté (probable code de debug), et même minifier certaines structures verboses. Contrairement à un minifier traditionnel qui détruit la lisibilité, Tokentrim préserve une structure lisible tout en éliminant 25-35% du contenu sans perte d’information. C’est particulièrement efficace pour les projets avec des standards de documentation stricts qui génèrent beaucoup de commentaires automatiques.

Filtrage intelligent du contexte

Tokentrim analyse et réduit automatiquement le contexte avant l’envoi.

pip install tokentrim

# Wrapper automatique
tokentrim claude-code --max-tokens 8000 "ta commande"

Configuration

# ~/.tokentrim.yml
max_tokens: 8000
remove:
  - comments
  - docstrings
  - blank_lines
preserve:
  - function_signatures
  - class_definitions

Économie estimée : 25-35%

Tokenizers : Compteur pré-envoi

Un des plus grands défis de l’optimisation des coûts avec Claude est l’impossibilité de savoir précisément combien de tokens vous allez consommer avant d’envoyer votre requête. Les estimations basiques (1 token ≈ 4 caractères) sont souvent trompeuses car elles ne prennent pas en compte les spécificités du tokenizer de Claude, qui traite différemment le code, la ponctuation, les emojis, et les langues non-anglaises. Résultat : vous pensez envoyer 10 000 tokens mais vous en consommez 15 000, ou pire, vous évitez d’envoyer une requête légitime par peur du coût alors qu’elle n’aurait coûté que 3 000 tokens. Cette incertitude rend impossible toute optimisation budgétaire précise.

La solution : Tokenizers et son comptage exact

Le package Tokenizers de Hugging Face résout ce problème en vous donnant accès au tokenizer exact utilisé par Claude, vous permettant de compter précisément les tokens avant l’envoi. Cela transforme l’optimisation de tokens d’un art approximatif en une science exacte. Vous pouvez tester différentes stratégies de compression sur vos fichiers et voir immédiatement l’impact réel sur la consommation. Vous pouvez mettre en place des systèmes d’alerte qui vous préviennent avant d’envoyer une requête trop coûteuse. Vous pouvez même créer des pipelines d’optimisation automatiques qui ajustent le niveau de compression jusqu’à atteindre un seuil de tokens défini. Cette visibilité précise est la fondation de toute stratégie d’optimisation sérieuse et peut vous faire économiser des centaines de dollars en évitant les requêtes mal calibrées.

Vérifier avant d’envoyer

Le package tokenizers de Hugging Face permet de compter les tokens avant de les envoyer à Claude.

pip install tokenizers

Script de vérification

from tokenizers import Tokenizer

def count_tokens(text):
    tokenizer = Tokenizer.from_pretrained("Xenova/claude-tokenizer")
    tokens = tokenizer.encode(text).ids
    return len(tokens)

# Vérification
with open('context.txt', 'r') as f:
    content = f.read()
    token_count = count_tokens(content)
    print(f"Tokens: {token_count} (~${token_count * 0.000003:.4f})")

Économie estimée : Prévention des envois coûteux

LLM-Context : Gestionnaire de contexte dédié

Assembler manuellement le contexte optimal pour Claude est un processus complexe et fastidieux qui nécessite de comprendre quels fichiers inclure, dans quel ordre, avec quel niveau de détail, et comment gérer les dépendances entre fichiers. Si vous incluez trop peu de contexte, Claude ne peut pas répondre correctement. Si vous en incluez trop, vous gaspillez des tokens. Pour un projet typique, déterminer le contexte optimal pour une tâche donnée peut prendre 10-15 minutes de travail manuel, incluant l’identification des fichiers pertinents, la vérification des dépendances, et l’assemblage dans le bon ordre. Cette approche artisanale est non seulement chronophage mais aussi source d’erreurs, où vous oubliez des fichiers importants ou incluez des fichiers inutiles.

La solution : LLM-Context et son orchestration automatique

LLM-Context est un outil spécialisé qui automatise entièrement ce processus en comprenant les dépendances de votre projet et en construisant le contexte optimal selon vos contraintes. Vous définissez simplement une limite de tokens (par exemple 10 000) et vos priorités (par exemple « src/core » est plus important que « src/utils »), et LLM-Context analyse votre projet pour construire le meilleur contexte possible dans cette limite. Il gère automatiquement les dépendances (si vous incluez auth.py qui importe database.py, il inclura les deux), priorise intelligemment (code métier avant utilitaires), et optimise l’ordre (fichiers de base d’abord, implémentations ensuite). Le résultat est un contexte qui maximise la valeur informationnelle par token consommé, souvent 2-3 fois plus efficace qu’un assemblage manuel.

Construction automatique de contexte optimisé

pip install llm-context

# Génération avec limite
llm-context build --max-tokens 10000 --output limited.txt

# Avec priorités
llm-context build --priority "src/core" --max-tokens 10000

Configuration

# .llm-context.yml
max_tokens: 10000
priority_paths:
  - src/core/
  - config/
exclude:
  - tests/
  - docs/
  - "*.md"
compression:
  remove_comments: true
  minify_json: true

Économie estimée : 50-60%

Direnv : Automatisation par projet

Chaque projet a des besoins différents en termes d’optimisation : un projet React avec des milliers de fichiers nécessite une stratégie d’exclusion agressive, tandis qu’un petit projet Python peut se permettre plus de contexte. Sans système de configuration par projet, vous devez soit utiliser une configuration globale trop restrictive (qui pénalise les petits projets) soit trop permissive (qui coûte cher sur les gros projets), ou pire, ajuster manuellement les paramètres à chaque fois que vous changez de projet. Cette gestion manuelle est source d’erreurs coûteuses : vous oubliez de limiter le contexte sur un gros projet et consommez 50 000 tokens d’un coup, ou vous oubliez de relâcher les restrictions sur un petit projet et Claude manque d’informations pour répondre correctement.

La solution : Direnv et sa configuration automatique

Direnv résout ce problème élégamment en chargeant automatiquement des variables d’environnement spécifiques à chaque projet dès que vous entrez dans son répertoire. Vous définissez une fois les paramètres optimaux pour chaque projet (limites de tokens, fichiers à exclure, modèle à utiliser) dans un fichier .envrc, et Direnv s’assure que ces paramètres sont toujours actifs quand vous travaillez sur ce projet. Changez de répertoire vers un autre projet ? Les paramètres changent instantanément. Cette automatisation élimine totalement les erreurs humaines et garantit que chaque projet utilise toujours sa configuration optimale. C’est particulièrement puissant pour les développeurs qui jonglent avec plusieurs projets, car cela élimine la charge cognitive de se rappeler quelle configuration utiliser pour quel projet.

Configuration automatique

Direnv charge automatiquement les variables d’environnement par projet.

# Installation
brew install direnv  # macOS
apt install direnv    # Linux

# Activation
echo 'eval "$(direnv hook bash)"' >> ~/.bashrc

Configuration par projet

# .envrc à la racine du projet
export CLAUDE_MAX_TOKENS=50000
export CLAUDE_IGNORE="node_modules/,dist/,*.log"
export CLAUDE_MODEL="claude-sonnet-4-20250514"

# Charger la config
direnv allow

Économie estimée : Cohérence + prévention d’erreurs

Configuration optimale : Le fichier .claudeignore

Par défaut, les outils d’IA analysent récursivement tous les fichiers de votre projet sans distinction, incluant des dizaines de milliers de fichiers qui n’ont aucune valeur pour la compréhension du code. Les dépendances NPM (node_modules) à elles seules peuvent contenir 50 000+ fichiers représentant des millions de tokens, les fichiers de build générés automatiquement dupliquent l’information déjà présente dans le source, les logs et caches ne contiennent que des données temporaires, et les médias (images, vidéos) sont totalement inutiles pour Claude mais consomment énormément de tokens s’ils sont encodés en base64. Un projet web typique peut contenir 90% de fichiers inutiles qui polluent massivement le contexte si non filtrés.

La solution : .claudeignore comme garde-fou universel

Le fichier .claudeignore (inspiré de .gitignore) est votre première ligne de défense contre le gaspillage de tokens. C’est un fichier simple qui liste tous les patterns de fichiers et dossiers à exclure systématiquement du contexte. Une fois configuré correctement, il agit comme un filtre automatique qui empêche des dizaines de milliers de fichiers inutiles d’être même considérés pour l’envoi à Claude. La configuration ci-dessous est le résultat de mois d’optimisation et couvre les cas les plus courants : dépendances, builds, médias, logs, IDE, et secrets. Copier ce fichier à la racine de vos projets peut instantanément éliminer 60-80% des fichiers du contexte sans aucune perte de fonctionnalité.

Créez un .claudeignore à la racine de chaque projet :

# Dépendances
node_modules/
venv/
env/
__pycache__/
*.pyc
.Python

# Build et dist
dist/
build/
*.egg-info/
*.min.js
*.bundle.js
*.map

# Tests et couverture
.coverage
htmlcov/
.pytest_cache/
.tox/

# Documentation
docs/_build/
*.md
!README.md

# Médias
*.jpg
*.jpeg
*.png
*.gif
*.ico
*.svg
*.mp4
*.webm
*.pdf

# Logs et bases
*.log
*.sql
*.sqlite
*.db

# Configs lourdes
package-lock.json
yarn.lock
Pipfile.lock
poetry.lock

# IDE
.vscode/
.idea/
*.swp
*.swo

# OS
.DS_Store
Thumbs.db

# Secrets
.env
.env.*
*.pem
*.key

Script optimisé prêt à l’emploi

Copiez-collez ce script pour une configuration complète :

#!/bin/bash
# Fichier: setup-claude-optimization.sh
# Compatible: AlmaLinux / CentOS / Debian / Ubuntu / macOS
# Usage: ./setup-claude-optimization.sh

set -euo pipefail
IFS=$'\n\t'

echo "🚀 Installation des outils d’optimisation Claude Code"

# ==========================================================
# Gestion sudo / root
# ==========================================================
SUDO=""
if [ "$EUID" -ne 0 ]; then
  SUDO="sudo"
fi

# ==========================================================
# 1. Vérification Python
# ==========================================================
if ! command -v python3 &>/dev/null; then
  echo "❌ Python 3 requis"
  exit 1
fi

if ! command -v pip3 &>/dev/null; then
  echo "❌ pip3 requis"
  exit 1
fi

PYTHON_VERSION=$(python3 -c 'import sys; print(".".join(map(str, sys.version_info)))')
PYTHON_MAJOR=$(echo "$PYTHON_VERSION" | cut -d. -f1)
PYTHON_MINOR=$(echo "$PYTHON_VERSION" | cut -d. -f2)

if [ "$PYTHON_MAJOR" -eq 3 ] && [ "$PYTHON_MINOR" -lt 7 ]; then
  echo "⚠️  Python $PYTHON_VERSION détecté (3.7+ recommandé)"
  echo "   Certains packages peuvent échouer"
fi

# ==========================================================
# 2. Installation packages Python (VALIDES PyPI)
# ==========================================================
echo "📦 Installation des packages Python…"

# Installation individuellement pour gérer les conflits
PACKAGES_INSTALLED=0
for pkg in semgrep aider-chat; do
  echo "  → Installation de $pkg…"
  if pip3 install --upgrade "$pkg" &>/dev/null; then
    echo "    ✓ $pkg installé"
    PACKAGES_INSTALLED=$((PACKAGES_INSTALLED + 1))
  else
    echo "    ⚠️  Échec de $pkg (non critique)"
  fi
done

echo "  → $PACKAGES_INSTALLED/2 packages installés"

# ==========================================================
# 3. Vérification Node.js / npm
# ==========================================================
if ! command -v node &>/dev/null; then
  echo "❌ Node.js ≥ 18 requis"
  echo "➡️  https://rpm.nodesource.com/setup_18.x"
  exit 1
fi

NODE_MAJOR=$(node -v | sed 's/v//' | cut -d. -f1)
if [ "$NODE_MAJOR" -lt 18 ]; then
  echo "❌ Node.js trop ancien (>=18 requis)"
  exit 1
fi

# ==========================================================
# 4. Installation packages npm
# ==========================================================
echo "📦 Installation des packages NPM…"
npm install -g repomix tree-sitter-cli

# ==========================================================
# 5. Installation direnv + ctags
# ==========================================================
echo "📦 Installation des outils système…"

SYSTEM_TOOLS_OK=0

if command -v dnf &>/dev/null; then
  $SUDO dnf install -y epel-release &>/dev/null || true

  # ctags (Exuberant Ctags)
  if $SUDO dnf install -y ctags &>/dev/null; then
    echo "  ✓ ctags installé"
    SYSTEM_TOOLS_OK=$((SYSTEM_TOOLS_OK + 1))
  else
    echo "  ⚠️  ctags non disponible"
  fi

  # direnv (pas dans EPEL, installation optionnelle)
  if ! command -v direnv &>/dev/null; then
    echo "  ⚠️  direnv non disponible (optionnel)"
    echo "     Installation manuelle: curl -sfL https://direnv.net/install.sh | bash"
  else
    echo "  ✓ direnv déjà installé"
    SYSTEM_TOOLS_OK=$((SYSTEM_TOOLS_OK + 1))
  fi

elif command -v apt-get &>/dev/null; then
  $SUDO apt-get update &>/dev/null
  $SUDO apt-get install -y direnv universal-ctags &>/dev/null && SYSTEM_TOOLS_OK=2 || {
    echo "  ⚠️  Échec installation outils système"
  }

elif command -v brew &>/dev/null; then
  brew install direnv universal-ctags &>/dev/null && SYSTEM_TOOLS_OK=2 || {
    echo "  ⚠️  Échec installation outils système"
  }
else
  echo "  ⚠️  Gestionnaire de paquets non supporté"
fi

echo "  → $SYSTEM_TOOLS_OK/2 outils système installés"

# ==========================================================
# 6. .claudeignore
# ==========================================================
echo "📝 Création .claudeignore"
cat > .claudeignore << 'EOF'
node_modules/
venv/
__pycache__/
*.pyc
dist/
build/
coverage/
htmlcov/
.pytest_cache/
docs/
*.min.js
*.bundle.js
*.map
*.log
.env
.env.*
.DS_Store
package-lock.json
yarn.lock
*.jpg
*.png
*.gif
*.pdf
EOF

# ==========================================================
# 7. Configuration Repomix
# ==========================================================
echo "📝 Création repomix.config.json"
cat > repomix.config.json << 'EOF'
{
  "output": {
    "filePath": "context.txt",
    "style": "xml",
    "removeComments": true,
    "removeEmptyLines": true
  },
  "ignore": {
    "customPatterns": [
      "*.min.js",
      "*.map",
      "*.log",
      "dist/**",
      "build/**",
      "node_modules/**"
    ]
  }
}
EOF

# ==========================================================
# 8. Variables d'environnement (.envrc)
# ==========================================================
echo "📝 Création .envrc"
cat > .envrc << 'EOF'
export CLAUDE_MAX_TOKENS=50000
export CLAUDE_MODEL="claude-sonnet-4-20250514"
export AIDER_NO_AUTO_COMMITS=1
export AIDER_NO_AUTO_LINT=1
EOF

if command -v direnv &>/dev/null; then
  if ! grep -q 'direnv hook bash' ~/.bashrc 2>/dev/null; then
    echo 'eval "$(direnv hook bash)"' >> ~/.bashrc
  fi
  direnv allow . &>/dev/null || true
  echo "  ✓ direnv configuré"
else
  echo "  ⚠️  direnv non installé - ajoutez manuellement .envrc à votre shell"
fi

# ==========================================================
# 9. Wrapper Claude Code (cc)
# ==========================================================
echo "📝 Création du wrapper cc"
mkdir -p ~/.local/bin

cat > ~/.local/bin/cc << 'EOF'
#!/bin/bash
set -euo pipefail

CONTEXT_FILE="/tmp/claude-context-$$.txt"

if ! command -v repomix &>/dev/null; then
  echo "❌ repomix requis (npm install -g repomix)"
  exit 1
fi

echo "🔍 Génération du contexte…"
repomix --output "$CONTEXT_FILE" >/dev/null

WORD_COUNT=$(wc -w < "$CONTEXT_FILE")
TOKENS=$((WORD_COUNT * 4 / 3))

echo "📊 Tokens estimés: ~$TOKENS"
echo "💰 Coût estimé: ~$$(awk "BEGIN {printf \"%.4f\", $TOKENS * 0.000003}")"

if [ "$TOKENS" -gt "${CLAUDE_MAX_TOKENS:-50000}" ]; then
  echo "⚠️  Contexte trop volumineux"
  rm -f "$CONTEXT_FILE"
  exit 1
fi

echo "🤖 Lancement Claude (Aider)…"

aider \
  --model "${CLAUDE_MODEL:-claude-sonnet-4-20250514}" \
  --read "$CONTEXT_FILE" \
  --no-auto-commits \
  --no-auto-lint \
  "$@"

rm -f "$CONTEXT_FILE"
EOF

chmod +x ~/.local/bin/cc

# ==========================================================
# 10. PATH
# ==========================================================
if ! echo "$PATH" | grep -q "$HOME/.local/bin"; then
  echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
fi

# ==========================================================
# 11. ctags
# ==========================================================
echo "🏷️  Génération index ctags"
ctags -R --fields=+l --exclude=node_modules --exclude=dist . 2>/dev/null || true

# ==========================================================
# 12. count-tokens (estimation simple)
# ==========================================================
echo "📝 Création count-tokens"
cat > ~/.local/bin/count-tokens << 'EOF'
#!/usr/bin/env python3
import sys
from pathlib import Path

# Lecture du texte
if len(sys.argv) > 1:
    text = Path(sys.argv).read_text()
else:
    text = sys.stdin.read()

# Estimation: ~1.3 tokens par mot (moyenne pour Claude)
word_count = len(text.split())
token_estimate = int(word_count * 1.3)
cost = token_estimate * 0.000003

print(f"Mots: {word_count:,}")
print(f"Tokens (estimé): ~{token_estimate:,}")
print(f"Coût estimé: ${cost:.4f}")
EOF

chmod +x ~/.local/bin/count-tokens

echo ""
echo "✅ Installation terminée sans dépendance fantôme"
echo "➡️  Recharge: source ~/.bashrc"
echo ""

Utilisation du script

Installation

# 1. Télécharger et rendre exécutable
chmod +x setup-claude-optimization.sh

# 2. Lancer l'installation
./setup-claude-optimization.sh

# 3. Recharger le terminal
source ~/.bashrc

Notez que cette version a été customisée pour tourner sur ma configuration serveur.
Si elle plante telle qu’elle n’hésitez pas à … demander à Claude code de la corriger (c’est ce que j’ai fait jusqu’à ce que tout fonctionne parfaitement).

Utilisation quotidienne

# Commande optimisée
cc "ajoute une validation email"

# Vérifier les tokens avant envoi
count-tokens context.txt

# Générer le contexte manuellement
repomix --output context.txt

# Rechercher du code spécifique
semgrep --config=auto src/

Résultats attendus

Avec cette configuration complète :

Économie moyenne : 75% des tokens soit une réduction de coût de $100 à $25 pour 1 million de tokens.

En combinant ces outils, vous pouvez drastiquement réduire votre consommation de tokens tout en maintenant une excellente qualité de développement assisté par IA. Le script fourni automatise l’ensemble du processus et vous permet de démarrer immédiatement avec une configuration optimale.

Checklist finale

• ✅ .claudeignore configuré
• ✅ Repomix installé et configuré
• ✅ Aider comme alternative à Claude Code
• ✅ Wrapper cc pour automatisation
• ✅ Script count-tokens pour vérification
• ✅ Direnv pour configuration par projet
• ✅ Ctags pour navigation rapide
• ✅ Semgrep pour recherche intelligente

Prochaine étape : Lancez ./setup-claude-optimization.sh et commencez à économiser !