Claude Code — Skill Repository

Aperçu du projet

Claude Code est l'outil CLI d'Anthropic pour interagir avec Claude depuis le terminal. Il supporte l'édition de fichiers, les commandes shell, les workflows git, la revue de code, la coordination multi-agent, l'intégration IDE (VS Code, JetBrains), et le Model Context Protocol (MCP).

Codebase : ~1 900 fichiers, 512 000+ lignes de TypeScript sous src/.

Stack technique

Architecture

Plan des répertoires (src/)

Fichiers clés

Points d'entrée et séquence d'initialisation

1. src/main.tsx — Parser CLI Commander, profiling startup
2. src/entrypoints/init.ts — Config, telemetry, OAuth, MDM
3. src/entrypoints/cli.tsx — Orchestration de session CLI
4. src/entrypoints/mcp.ts — Mode serveur MCP
5. src/entrypoints/sdk/ — Agent SDK (API programmatique)
6. src/replLauncher.tsx — Lanceur de session REPL

Le démarrage effectue l'initialisation parallèle : lectures de politiques MDM, prefetch Keychain, vérifications feature flags, puis init principale.

Patterns et conventions

Définition d'outil

Chaque outil se trouve dans src/tools/{ToolName}/ et utilise buildTool :

export const MyTool = buildTool({
  name: 'MyTool',
  aliases: ['my_tool'],
  description: 'Ce que cet outil fait',
  inputSchema: z.object({
    param: z.string(),
  }),
  async call(args, context, canUseTool, parentMessage, onProgress) {
    // Exécuter et retourner { data: result, newMessages?: [...] }
  },
  async checkPermissions(input, context) { /* Vérifications de permissions */ },
  isConcurrencySafe(input) { /* Peut s'exécuter en parallèle ? */ },
  isReadOnly(input) { /* Non-destructive ? */ },
  prompt(options) { /* Injection de prompt système */ },
  renderToolUseMessage(input, options) { /* UI pour l'invocation */ },
  renderToolResultMessage(content, progressMessages, options) { /* UI pour le résultat */ },
})

Structure de répertoire par outil : {ToolName}.ts ou .tsx (principal), UI.tsx (rendu), prompt.ts (prompt système), plus fichiers utilitaires.

Définition de commande

Les commandes se trouvent dans src/commands/ et suivent trois types :

• PromptCommand — Envoie un prompt formaté avec outils injectés (la plupart des commandes)
• LocalCommand — S'exécute in-process, retourne du texte
• LocalJSXCommand — S'exécute in-process, retourne du JSX React

const command = {
  type: 'prompt',
  name: 'my-command',
  description: 'Ce que cette commande fait',
  progressMessage: 'travail en cours...',
  allowedTools: ['Bash(git *)', 'FileRead(*)'],
  source: 'builtin',
  async getPromptForCommand(args, context) {
    return [{ type: 'text', text: '...' }]
  },
} satisfies Command

Les commandes sont enregistrées dans src/commands.ts et invoquées via /command-name dans le REPL.

Structure des composants

• Composants React fonctionnels avec primitives Ink (Box, Text, useInput())
• Stylisés avec Chalk pour les couleurs terminal
• React Compiler pour les re-rendus optimisés
• Primitives du système de design dans src/components/design-system/

Gestion d'état

• AppState via React context + store personnalisé (src/state/AppStateStore.ts)
• Objet d'état mutable passé aux contextes d'outils
• Fonctions de sélecteur pour l'état dérivé
• Observateurs de changement dans src/state/onChangeAppState.ts

Système de permissions

• Modes : default (demande par opération), plan (affiche plan, demande une fois), bypassPermissions (auto-approve), auto (ML classifier)
• Règles : Patterns wildcards — Bash(git *), FileEdit(/src/*)
• Les outils implémentent checkPermissions() retournant { granted: boolean, reason?, prompt? }

Feature flags et build

Les feature flags bun:bundle de Bun permettent l'élimination du code mort au moment du build :

import { feature } from 'bun:bundle'
if (feature('PROACTIVE')) { /* proactive agent tools */ }

Flags notables : PROACTIVE, KAIROS, BRIDGE_MODE, VOICE_MODE, COORDINATOR_MODE, DAEMON, WORKFLOW_SCRIPTS.

Certaines fonctionnalités sont aussi bloquées via process.env.USER_TYPE === 'ant'.

Conventions de nommage

Pratiques d'imports

• ES modules avec extensions .js (convention Bun)
• Imports lazy pour casser les dépendances circulaires : const getModule = () => require('./heavy.js')
• Imports conditionnels via feature flags ou process.env
• Marqueurs biome-ignore pour l'ordonnement manuel d'imports quand nécessaire

Services

Configuration

Emplacements des paramètres :

• Global : ~/.claude/config.json, ~/.claude/settings.json
• Projet : .claude/config.json, .claude/settings.json
• Système : macOS Keychain + MDM, Windows Registry + MDM
• Gérés : Sync distante pour utilisateurs Entreprise

Directives

1. Lisez les fichiers sources pertinents avant de faire des changements — comprenez d'abord les patterns existants.
2. Suivez les patterns tool/command/component ci-dessus quand vous en ajoutez de nouveaux.
3. Gardez les édits minimes et ciblées — évitez les refactorisations inutiles.
4. Utilisez Zod pour toute validation d'entrée aux limites du système.
5. Bloquez les fonctionnalités expérimentales derrière les feature flags bun:bundle ou les vérifications env.
6. Respectez le système de permissions — les outils qui modifient l'état doivent implémenter checkPermissions().
7. Utilisez les imports lazy quand vous ajoutez des dépendances qui pourraient créer des références circulaires.
8. Mettez à jour ce fichier à mesure que les conventions du projet évoluent.