# Créer des sessions nommées pour différents projets
claude --session frontend "Travail sur le frontend React"
claude --session backend "Développement de l'API backend"
claude --session devops "Infrastructure et déploiement"

# Reprendre des sessions nommées spécifiques
claude --resume frontend "Continuer le travail sur le frontend"
claude --resume backend "Vérifier les performances de l'API"

# Lister toutes les sessions nommées
claude sessions list --filter named

# Exporter et partager les configurations de session
claude sessions export frontend > frontend-session.json
claude sessions import frontend-session.json

# Créer un modèle pour le développement React
cat > ~/.claude/templates/react-dev.json << EOF
{
  "allowedTools": ["Edit", "View", "Bash(npm:*)", "Bash(git:*)"],
  "addDirectories": ["./src", "./test", "./docs"],
  "systemPrompt": "Vous êtes un développeur React sénior. Suivez les meilleures pratiques TypeScript et concentrez-vous sur la performance et l'accessibilité.",
  "mcpServers": ["git", "filesystem"],
  "projectMemory": "Projet React TypeScript avec tests Jest"
}
EOF

# Utiliser le modèle pour démarrer des sessions
claude --template react-dev "Démarrer une session de développement React"

# Projet : Plateforme E-commerce

## Vue d'ensemble de l'architecture
- **Frontend** : React 18 + TypeScript + Vite
- **Backend** : Node.js + Express + TypeScript
- **Base de données** : PostgreSQL 14 avec ORM Prisma
- **Cache** : Redis pour le stockage des sessions
- **Déploiement** : Docker + Kubernetes sur AWS

## Objectifs du sprint actuel
- [ ] Implémenter l'authentification utilisateur avec JWT
- [ ] Ajouter le traitement des paiements avec Stripe
- [ ] Mettre en place un pipeline de tests automatisés
- [ ] Optimiser les requêtes de base de données pour la recherche de produits

## Normes de développement
- Utiliser TypeScript pour tout nouveau code
- Suivre la configuration ESLint + Prettier
- Écrire des tests unitaires pour toute la logique métier
- Utiliser les commits conventionnels pour les messages git
- Déployer en staging avant la production

## Problèmes connus
- Les performances de recherche diminuent avec plus de 10k produits
- La durée d'expiration des sessions utilisateur doit être configurée
- Limitation de débit du service de messagerie en production

## Décisions récentes
- Passage de REST à GraphQL pour une meilleure intégration frontend
- Utilisation de Tailwind CSS pour la consistance du style
- Implémentation des feature flags pour des déploiements progressifs

# Mettre à jour la mémoire du projet avec les développements récents
claude /memory add "Implémentation du cache Redis pour les résultats de recherche - Amélioration des performances de 40%"

# Définir l'attention actuelle
claude /memory set-focus "Travail sur le système d'authentification utilisateur cette semaine"

# Ajouter des décisions architecturales
claude /memory add-decision "Utilisation de jetons JWT avec expiration de 24h et rotation des jetons de rafraîchissement"

# Configuration globale (~/.claude.json)
{
  "defaultModel": "claude-sonnet-4",
  "globalAllowedTools": ["View"],
  "globalDisallowedTools": ["Bash(rm:*)", "Bash(sudo:*)"],
  "theme": "dark-daltonized",
  "editorMode": "vim"
}

# Configuration de l'organisation (~/.claude/org-config.json)
{
  "extends": "~/.claude.json",
  "allowedTools": ["Edit", "View", "Bash(git:*)", "mcp__git__*"],
  "mcpServers": {
    "company-git": {
      "command": "company-git-server",
      "env": {"COMPANY_TOKEN": "${COMPANY_GIT_TOKEN}"}
    }
  },
  "auditLogging": true,
  "complianceMode": "SOC2"
}

# Configuration du projet (./claude-config.json)
{
  "extends": "~/.claude/org-config.json",
  "projectName": "ecommerce-platform",
  "allowedTools": ["Edit", "View", "Bash(npm:*)", "Bash(git:*)", "mcp__*"],
  "systemPrompt": "Vous travaillez sur une plateforme de commerce électronique. Concentrez-vous sur la sécurité, les performances et l'expérience utilisateur.",
  "addDirectories": ["./src", "./tests", "./docs"],
  "mcpServers": {
    "project-db": {
      "command": "postgres-mcp-server",
      "env": {"DATABASE_URL": "${PROJECT_DATABASE_URL}"}
    }
  }
}

# Environnement de développement
export CLAUDE_ENV=development
export CLAUDE_CONFIG_FILE=~/.claude/dev-config.json

# Environnement de staging
export CLAUDE_ENV=staging
export CLAUDE_CONFIG_FILE=~/.claude/staging-config.json

# Environnement de production (lecture seule)
export CLAUDE_ENV=production
export CLAUDE_CONFIG_FILE=~/.claude/prod-config.json

# .github/workflows/claude-code-review.yml
name: Revue de code Claude

on:
  pull_request:
    branches: [main, develop]

jobs:
  claude-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Obtenir l'historique complet pour une meilleure analyse

      - name: Configuration de Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'

      - name: Installation de Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Exécution de la revue de sécurité
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # Créer une configuration sécurisée pour le CI
          cat > ci-config.json << EOF
          {
            "allowedTools": ["View"],
            "outputFormat": "json",
            "verbose": false
          }
          EOF

          # Lancer l'analyse de sécurité
          claude --config ci-config.json \
            -p "Analysez cette pull request pour les vulnérabilités de sécurité, les problèmes de performance et les problèmes de qualité de code. Concentrez-vous sur les changements dans le répertoire src/." \
            --output-format json > review-results.json

      - name: Publier les commentaires de revue
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const results = JSON.parse(fs.readFileSync('review-results.json', 'utf8'));

            // Publier les résultats sous forme de commentaire de PR
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## 🤖 Revue de code Claude\n\n${results.analysis}\n\n### Problèmes de sécurité : ${results.security_issues}\n### Problèmes de performance : ${results.performance_issues}\n### Qualité du code : ${results.code_quality}`
            });

# .gitlab-ci.yml
claude_review:
  image: node:18
  stage: review
  script:
    - npm install -g @anthropic-ai/claude-code
    - |
      claude --allowedTools "View" \
        -p "Passez en revue cette pull request pour la qualité du code et les problèmes de sécurité" \
        --output-format json > review.json
    - cat review.json
  artifacts:
    reports:
      junit: review.json
  only:
    - merge_requests

#!/bin/bash
# .git/hooks/pre-commit

# Obtenir les fichiers stagés
staged_files=$(git diff --cached --name-only --diff-filter=ACM)

if [ -z "$staged_files" ]; then
    exit 0
fi

echo "🤖 Exécution de l'analyse Claude Code sur les fichiers stagés..."

# Créer un fichier temporaire avec les changements stagés
git diff --cached > /tmp/staged_changes.diff

# Analyser avec Claude
analysis=$(claude --allowedTools "View" \
    -p "Analysez ces changements git pour identifier les problèmes potentiels avant de committer. Concentrez-vous sur : 1) Les vulnérabilités de sécurité 2) La qualité du code 3) Les problèmes de performance 4) Les changements qui peuvent casser la compatibilité. Retournez un JSON avec les niveaux de gravité." \
    --output-format json < /tmp/staged_changes.diff)

# Parser les résultats
critical_issues=$(echo "$analysis" | jq -r '.critical_issues // []')
warning_issues=$(echo "$analysis" | jq -r '.warnings // []')

# Bloquer le commit si des problèmes critiques sont trouvés
if [ "$critical_issues" != "[]" ] && [ "$critical_issues" != "null" ]; then
    echo "❌ Problèmes critiques trouvés :"
    echo "$critical_issues" | jq -r '.[]'
    echo "Commit bloqué. Veuillez corriger les problèmes critiques avant de committer."
    exit 1
fi

# Afficher les avertissements mais autoriser le commit
if [ "$warning_issues" != "[]" ] && [ "$warning_issues" != "null" ]; then
    echo "⚠️  Avertissements trouvés :"
    echo "$warning_issues" | jq -r '.[]'
    echo "Considérez de résoudre ces problèmes."
fi

echo "✅ Analyse pré-commit terminée"
rm /tmp/staged_changes.diff

#!/bin/bash
# scripts/update-docs.sh

# Documentation API automatisée
claude --allowedTools "View,Edit" \
    --add-dir ./src/api \
    "Mettez à jour la documentation API dans docs/api.md sur la base des interfaces TypeScript actuelles et des implémentations de points d'accès"

# Générer les mises à jour du README
claude --allowedTools "View,Edit" \
    "Mettez à jour README.md avec l'état actuel du projet, les instructions d'installation et les exemples d'utilisation"

# Créer des entrées de changelog
git log --since="1 week ago" --pretty=format:"%h %s" | \
    claude -p "Générez des entrées de changelog à partir de ces commits git. Concentrez-vous sur les changements visibles par l'utilisateur." \
    >> CHANGELOG.md

// custom-project-server.js
const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
const fs = require('fs');
const path = require('path');

class ProjectServer extends Server {
  constructor() {
    super({
      name: 'project-server',
      version: '1.0.0',
    });

    this.setupTools();
  }

  setupTools() {
    // Outil d'état du projet
    this.setRequestHandler('tools/list', async () => ({
      tools: [
        {
          name: 'get_project_status',
          description: 'Obtenir l\'état complet du projet, y compris git, les dépendances et le déploiement',
          inputSchema: {
            type: 'object',
            properties: {}
          }
        },
        {
          name: 'run_tests',
          description: 'Exécuter les tests du projet avec une portée spécifiée',
          inputSchema: {
            type: 'object',
            properties: {
              scope: { type: 'string', enum: ['unit', 'integration', 'e2e', 'all'] },
              coverage: { type: 'boolean', default: false }
            }
          }
        },
        {
          name: 'deploy_to_staging',
          description: 'Déployer la branche actuelle vers l\'environnement de staging',
          inputSchema: {
            type: 'object',
            properties: {
              branch: { type: 'string', default: 'main' },
              runMigrations: { type: 'boolean', default: true }
            }
          }
        }
      ]
    }));

    this.setRequestHandler('tools/call', async (request) => {
      const { name, arguments: args } = request.params;

      switch (name) {
        case 'get_project_status':
          return await this.getProjectStatus();
        case 'run_tests':
          return await this.runTests(args);
        case 'deploy_to_staging':
          return await this.deployToStaging(args);
        default:
          throw new Error(`Outil inconnu : ${name}`);
      }
    });
  }

  async getProjectStatus() {
    // Implémentation pour l'état du projet
    const gitStatus = require('child_process').execSync('git status --porcelain').toString();
    const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));

    return {
      content: [{
        type: 'text',
        text: `État du projet :
- Git : ${gitStatus ? 'Changements non committés' : 'Propre'}
- Version : ${packageJson.version}
- Dépendances : ${Object.keys(packageJson.dependencies || {}).length}
- Dernier commit : ${require('child_process').execSync('git log -1 --format="%h %s"').toString().trim()}`
      }]
    };
  }

  async runTests(args) {
    const { scope = 'all', coverage = false } = args;
    // Implémentation pour l'exécution des tests
    // ...
  }

  async deployToStaging(args) {
    // Implémentation pour le déploiement
    // ...
  }
}

// Démarrer le serveur
const server = new ProjectServer();
const transport = new StdioServerTransport();
server.connect(transport);

# Script de workflow MCP avancé
#!/bin/bash

echo "🚀 Démarrage du workflow de développement..."

# 1. Vérifier l'état du projet
claude --allowedTools "mcp__project__get_project_status" \
    "Obtenir l'état actuel du projet et identifier les problèmes"

# 2. Exécuter les tests avant de commencer le travail
claude --allowedTools "mcp__project__run_tests" \
    "Exécuter les tests unitaires pour assurer une base saine"

# 3. Rechercher les vulnérabilités de sécurité
claude --allowedTools "mcp__security__scan" \
    "Scanner le projet pour les vulnérabilités de sécurité"

# 4. Mettre à jour les dépendances si nécessaire
claude --allowedTools "mcp__npm__audit,mcp__npm__update" \
    "Vérifier les mises à jour des dépendances et les correctifs de sécurité"

# 5. Démarrer la session de développement
claude --allowedTools "Edit,View,mcp__git__*,mcp__project__*" \
    --add-dir ./src ./tests \
    "Prêt pour le développement. Le projet est propre et testé."

# Limiter le contexte à des répertoires spécifiques
claude --add-dir ./src/components ./src/utils \
    "Se concentrer uniquement sur les composants et les utilitaires"

# Utiliser des requêtes ciblées
claude --allowedTools "View" \
    -p "Analysez uniquement le module d'authentification pour les problèmes de sécurité" \
    --context-files "src/auth/*.ts"

# Construction progressive du contexte
claude "Commencez par un aperçu de la structure du projet"
# Puis ajoutez un contexte spécifique au besoin
claude "Maintenant, concentrez-vous sur le système de gestion des utilisateurs"

# Surveiller les performances de Claude Code
claude --profile --timing \
    "Analysez les goulots d'étranglement de performance de l'application"

# Optimisation de l'utilisation des jetons
export MAX_THINKING_TOKENS=30000  # Ajuster en fonction des besoins
claude --cost-tracking "Optimiser les requêtes de base de données"

# Surveillance de l'utilisation de la mémoire
claude --memory-usage --verbose \
    "Session d'analyse de grand codebase"

# Informations de débogage maximales
claude \
    --verbose \
    --debug \
    --mcp-debug \
    --trace-all \
    --log-api-calls \
    --show-tokens \
    --cost-tracking \
    "Déboguer un problème d'intégration complexe"

# Débogage sélectif
claude \
    --mcp-debug \
    --allowedTools "mcp__postgres__*" \
    "Déboguer les problèmes de connectivité de la base de données"

# Configuration de la journalisation complète
export CLAUDE_LOG_LEVEL=debug
export CLAUDE_LOG_FILE=/var/log/claude/session.log
export CLAUDE_AUDIT_LOG=/var/log/claude/audit.log

# Surveillance des journaux en temps réel
tail -f /var/log/claude/session.log | \
    claude -p "Surveiller ces journaux pour les erreurs et suggérer des correctifs"

# Automatisation de l'analyse des journaux
cat /var/log/claude/session.log | \
    claude -p "Analyser les journaux pour les schémas, les erreurs et les problèmes de performance. Générer un rapport sommaire."

# Dépôt de configuration d'équipe
git clone https://github.com/company/claude-configs.git ~/.claude/team

# Utiliser les configurations d'équipe
claude --config ~/.claude/team/frontend-config.json \
    "Démarrer une session de développement frontend"

# Partager des modèles de session
cp ~/.claude/templates/react-dev.json \
   ~/.claude/team/templates/
git add . && git commit -m "Ajouter un modèle de développement React"

# Générer la documentation d'équipe
claude --allowedTools "View,Edit" \
    "Créer une documentation d'intégration pour les nouveaux développeurs basée sur la structure et les conventions actuelles du projet"

# Partager des guides de dépannage
claude --allowedTools "View" \
    "Générer un guide de dépannage pour les problèmes de développement courants dans ce projet"

# Créer des enregistrements de décision architecturale
claude "Documentez la décision d'utiliser GraphQL au lieu de REST, y compris la justification et les détails d'implémentation"

# Workflow de développement de fonctionnalités de bout en bout
#!/bin/bash
feature_name=$1

echo "🎯 Démarrage du développement de la fonctionnalité : $feature_name"

# 1. Créer une branche de fonctionnalité
claude --allowedTools "mcp__git__*" \
    "Créer une branche de fonctionnalité pour $feature_name"

# 2. Générer l'implémentation initiale
claude --allowedTools "Edit,View" \
    "Générer l'implémentation initiale pour $feature_name basée sur les exigences dans REQUIREMENTS.md"

# 3. Écrire des tests
claude --allowedTools "Edit,View" \
    "Créer des tests complets pour la fonctionnalité $feature_name"

# 4. Exécuter les contrôles qualité
claude --allowedTools "mcp__project__run_tests,mcp__lint__*" \
    "Exécuter les tests et le linting pour la nouvelle fonctionnalité"

# 5. Générer la documentation
claude --allowedTools "Edit,View" \
    "Mettre à jour la documentation pour la nouvelle fonctionnalité $feature_name"

# 6. Créer une pull request
claude --allowedTools "mcp__github__*" \
    "Créer une pull request pour $feature_name avec une description et des réviseurs appropriés"

echo "✅ Workflow de développement de fonctionnalités terminé"

# Workflow de déploiement progressif
claude --config ~/.claude/deploy-config.json \
    --allowedTools "mcp__k8s__*,mcp__aws__*" \
    "Déployer vers l'environnement de développement et exécuter des tests de fumée"

# Si réussi, continuer vers le staging
claude --allowedTools "mcp__k8s__*,mcp__monitoring__*" \
    "Déployer vers le staging et surveiller pendant 10 minutes"

# Déploiement final en production
claude --allowedTools "mcp__k8s__apply,mcp__monitoring__*" \
    "Déployer en production avec une stratégie bleu-vert"

# Versionner toutes les configurations
git init ~/.claude
cd ~/.claude
git add .
git commit -m "Configuration initiale de Claude Code"
git remote add origin https://github.com/yourusername/claude-config.git
git push -u origin main

# Script de sauvegarde automatisé
#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR=~/.claude/backups

mkdir -p $BACKUP_DIR

# Sauvegarde de la configuration
cp ~/.claude.json $BACKUP_DIR/claude-config-$DATE.json

# Sauvegarde des sessions
claude sessions export --all > $BACKUP_DIR/sessions-$DATE.json

# Sauvegarde des mémoires de projet
tar -czf $BACKUP_DIR/memories-$DATE.tar.gz ~/.claude/memories/

echo "Sauvegarde terminée : $BACKUP_DIR"

# Script de migration de configuration
#!/bin/bash
OLD_VERSION=$1
NEW_VERSION=$2

echo "Migration de la configuration de Claude Code de $OLD_VERSION vers $NEW_VERSION"

# Sauvegarde de la configuration actuelle
cp ~/.claude.json ~/.claude.json.backup

# Appliquer la migration
claude config migrate --from $OLD_VERSION --to $NEW_VERSION

# Vérifier la migration
claude /doctor

echo "Migration terminée. Vérifiez la sortie de /doctor pour les problèmes."