Outils Puissants Claude Code

# Outils Puissants Claude Code

Transformez Claude Code en un moteur de workflow programmable avec des hooks, des exécutions sans interface et des intégrations MCP.

## Ce Que Fait Ce Plugin

Ce plugin combine trois capacités composables :

- **Hooks** — Interceptez les appels d'outils (PreToolUse / PostToolUse) pour appliquer des règles, valider les sorties ou déclencher des effets secondaires
- **Headless** — Exécutez Claude Code de manière non interactive via `claude -p` pour le traitement par lots, CI/CD et les scripts
- **MCP** — Créez des serveurs Model Context Protocol qui donnent à Claude accès à des systèmes externes (bases de données, APIs, messagerie)

Ces trois éléments s'assemblent : les hooks contrôlent *ce que Claude fait*, headless contrôle *quand et comment il s'exécute*, et MCP contrôle *ce qu'il peut atteindre*.

## Exemple Complet : Pipeline Automatisé de Revue de Code

Une équipe souhaite que chaque PR soit automatiquement revu, avec les résultats postés sur Slack et les violations bloquées.

### Étape 1 : Serveur MCP — Connexion aux Systèmes Externes

Créez un serveur MCP qui expose la publication Slack et les données de PR GitHub :

```typescript
// review-mcp/server.ts
const server = new McpServer({ name: "review-tools" });

server.tool("post_slack", { channel: z.string(), message: z.string() },
  async ({ channel, message }) => {
    await slack.chat.postMessage({ channel, text: message });
    return { content: [{ type: "text", text: "Posted" }] };
  }
);

server.tool("get_pr_diff", { pr: z.number() },
  async ({ pr }) => {
    const diff = await octokit.pulls.get({ owner, repo, pull_number: pr });
    return { content: [{ type: "text", text: diff.data.body }] };
  }
);
```

Enregistrez-le : `claude mcp add review-tools -- node review-mcp/server.ts`

### Étape 2 : Headless — Exécutez les Revues dans CI

```yaml
# .github/workflows/review.yml
- name: AI Code Review
  run: |
    claude -p "Review PR #${{ github.event.pull_request.number }}.       Use get_pr_diff to fetch changes, analyze for bugs and style issues,       then post_slack the summary to #code-review."       --allowedTools "mcp__review-tools__post_slack,mcp__review-tools__get_pr_diff"       --output-format json > review-result.json
```

### Étape 3 : Hooks — Appliquez les Garde-fous

```json
// .claude/settings.json
{
  "hooks": {
    "PreToolUse": [{
      "matcher": "mcp__review-tools__post_slack",
      "hooks": [{
        "type": "command",
        "command": "python3 validate_slack.py "$TOOL_INPUT""
      }]
    }]
  }
}
```

Le script de hook vérifie que les messages Slack suivent les règles de formatage de l'équipe. Une sortie non nulle bloque l'appel d'outil.

**Résultat :** Les PR déclenchent Claude headless → Claude récupère le diff via MCP → révise le code → poste sur Slack (validé par le hook) — entièrement automatisé, entièrement auditable.

## Limites de Risque

### Hooks

- Les hooks **changent le comportement par défaut de Claude**. Un hook PreToolUse défectueux peut bloquer silencieusement les appels d'outils légitimes. Testez toujours les hooks de manière isolée avant déploiement.
- Les scripts de hook s'exécutent avec vos permissions shell. Ne redirigez jamais directement une entrée non fiable dans les commandes de hook sans nettoyage.
- Gardez les hooks rapides (< 2s). Les hooks lents dégradent l'expérience interactive.

### Mode Headless

- `--dangerously-skip-permissions` supprime toutes les invites de sécurité. Utilisez uniquement dans des environnements CI de confiance avec des permissions verrouillées.
- Les exécutions headless n'ont pas d'humain dans la boucle. Délimitez explicitement les outils autorisés avec `--allowedTools` pour éviter les actions involontaires.
- La sortie peut être volumineuse. Définissez toujours `--output-format json` dans les pipelines et analysez les résultats structurés.

### Serveurs MCP

- Les serveurs MCP s'exécutent comme des processus séparés avec leurs propres permissions. Un serveur mal délimité peut exposer des données sensibles ou permettre des opérations destructrices.
- Validez toujours les entrées dans les gestionnaires d'outils. Les paramètres générés par Claude ne sont pas garantis sûrs.
- Utilisez l'isolation au niveau du transport : exécutez les serveurs MCP dans des conteneurs ou des comptes utilisateurs restreints pour les déploiements en production.
- Gérez les erreurs avec élégance — un crash de serveur MCP au milieu d'une conversation laisse Claude sans accès à ces outils jusqu'au redémarrage.