> ## Documentation Index
> Fetch the complete documentation index at: https://kiro.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Intelligence du code

> Compréhension du code propulsée par Tree-sitter et LSP - recherche de symboles, correspondance de motifs et exploration de base de code

L'intelligence du code offre deux couches complémentaires de compréhension du code :

- **Tree-sitter (intégré)** - Intelligence du code prête à l'emploi pour 18 langages. Recherchez des symboles, obtenez des plans de documents et consultez des définitions sans installer quoi que ce soit de plus.
- **Intégration LSP (facultatif)** - Précision améliorée avec la recherche de références, l'accès à la définition, la documentation au survol, le refactoring de renommage et les diagnostics. Nécessite l'installation d'un serveur de langage.

Toutes les fonctionnalités tree-sitter ci-dessous sont multiplateformes (IDE, CLI, Web, Mobile). Les fonctionnalités LSP nécessitent un serveur de langage et sont disponibles uniquement sur l'IDE et la CLI.

| Capacité | Nécessite LSP |
|-----------|:------------:|
| Recherche de symboles (floue) | — |
| Symboles du document | — |
| Recherche de motifs (AST) | — |
| Réécriture de motifs (AST) | — |
| Aperçu de la base de code | — |
| Recherche de références | ✓ |
| Accès à la définition | ✓ |
| Renommer un symbole | ✓ |
| Obtenir les diagnostics | ✓ |
| Documentation au survol | ✓ |

**ℹ️ Info:** Les fonctionnalités LSP (recherche de références, accès à la définition, renommage, diagnostics, survol) sont disponibles uniquement sur l'IDE et la CLI. Elles nécessitent un serveur de langage installé pour votre langage.

## Langages pris en charge

Bash, C, C++, C#, Elixir, Go, Java, JavaScript, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TSX, TypeScript

## Recherche de symboles

Trouvez des fonctions, des classes et des méthodes par nom avec une correspondance floue :

```text
> Find the UserRepository class

Searching for symbols matching: "UserRepository" (using tool: code)
✓ Found 1 match

Class UserRepository at src/repositories/user.repository.ts:15:1
```

## Recherche de motifs

Recherche structurelle de code basée sur l'AST. Trouvez du code par structure, pas seulement par texte.

### Métavariables

| Motif | Correspondances |
|---------|---------|
| `$VAR` | Nœud unique (identifiant, expression) |
| `$$$` | Zéro ou plusieurs nœuds (instructions, paramètres) |

### Exemples

```javascript
// Find all console.log calls
pattern: console.log($ARG)
language: javascript

// Find all async functions
pattern: async function $NAME($$$PARAMS) { $$$ }
language: typescript

// Find all .unwrap() calls
pattern: $E.unwrap()
language: rust
```

## Réécriture de motifs

Transformations de code automatisées utilisant des motifs AST :

```javascript
// Convert var to const
pattern: var $N = $V
replacement: const $N = $V
language: javascript

// Modernize hasOwnProperty
pattern: $O.hasOwnProperty($P)
replacement: Object.hasOwn($O, $P)
language: javascript

// Convert unwrap to expect
pattern: $E.unwrap()
replacement: $E.expect("unexpected None")
language: rust
```

## Aperçu de la base de code

Obtenez un aperçu global d'un espace de travail ou d'un répertoire :

IDE
CLI

L'agent utilise l'intelligence du code automatiquement lors de l'exploration de votre projet. Demandez « donnez-moi un aperçu de cette base de code » ou « que fait ce projet? »

```bash
/code overview           # full workspace
/code overview ./src     # specific directory
/code overview --silent  # minimal output
```

## Génération de documentation

Générez la documentation du projet basée sur l'analyse de la base de code :

IDE
CLI

Demandez à l'agent : « Générez un fichier README pour ce projet » ou « Créez un fichier AGENTS.md. »

```bash
/code summary
```

Choisissez le format de sortie : AGENTS.md, README.md ou CONTRIBUTING.md.

## Intégration LSP

Avec un serveur de langage installé, l'intelligence du code gagne en précision supplémentaire :

- **Recherche de références** - localise toutes les utilisations d'un symbole
- **Accès à la définition** - navigue jusqu'à l'endroit où un symbole est défini
- **Renommer un symbole** - renomme dans toute la base de code
- **Obtenir les diagnostics** - erreurs et avertissements pour un fichier
- **Documentation au survol** - informations de type à une position

**ℹ️ Info:** Les fonctionnalités LSP nécessitent l'installation d'un serveur de langage. Consultez les guides spécifiques au langage : [TypeScript/JavaScript](https://kiro.dev/docs/guides/languages-and-frameworks/typescript-javascript-guide.md), [Python](https://kiro.dev/docs/guides/languages-and-frameworks/python-guide.md), [Java](https://kiro.dev/docs/guides/languages-and-frameworks/java-guide.md).

Dans l'IDE, les capacités reposant sur le LSP proviennent des extensions de langage que vous avez déjà installées. Sur la CLI, activez-les par espace de travail avec `/code init` - consultez la référence de configuration ci-dessous.

## Configuration du LSP sur la CLI

**ℹ️ Le LSP est facultatif et propre à chaque espace de travail:** Les fonctionnalités tree-sitter intégrées fonctionnent prêtes à l'emploi, sans initialisation nécessaire. Vous n'avez besoin de `/code init` que pour les fonctionnalités LSP améliorées. L'intelligence du code est configurée par espace de travail, pas globalement - chaque projet maintient ses propres paramètres LSP indépendamment.

  [Video](https://kiro.dev/videos/code-intelligence.mp4)

### Comment ça fonctionne

Kiro CLI génère des processus de serveur LSP en arrière-plan qui communiquent via JSON-RPC sur stdio. Lorsque vous initialisez un espace de travail, il détecte les langages à partir des marqueurs de projet (comme `package.json`, `Cargo.toml`) et des extensions de fichiers, puis démarre les serveurs de langage appropriés. Ces serveurs analysent continuellement votre code et maintiennent un index des symboles, des types et des références. Lorsque vous effectuez des requêtes, Kiro traduit votre langage naturel en requêtes de protocole LSP, les envoie au serveur concerné, puis formate les réponses en une sortie lisible.

### Initialiser le LSP

Exécutez cette commande à barre oblique dans la racine de votre projet :

```
/code init
```

Cela crée `.kiro/settings/lsp.json` et démarre les serveurs de langage :

```
✓ Workspace initialization started

Workspace: /path/to/your/project
Detected Languages: ["python", "rust", "typescript"]
Project Markers: ["Cargo.toml", "package.json"]

Available LSPs:
○ clangd (cpp) - available
○ gopls (go) - not installed
◐ jdtls (java) - initializing...
✓ pyright (python) - initialized (687ms)
✓ rust-analyzer (rust) - initialized (488ms)
○ solargraph (ruby) - not installed
✓ typescript-language-server (typescript) - initialized (214ms)
```

**Indicateurs d'état :** ✓ initialisé et prêt · ◐ en cours d'initialisation · ○ disponible (installé mais pas nécessaire) · ○ non installé

- **Redémarrer les serveurs LSP :** si les serveurs de langage s'arrêtent ou deviennent inactifs, utilisez `/code init -f`.
- **Auto-initialisation :** après le premier `/code init`, Kiro CLI initialise automatiquement l'intelligence du code au démarrage lorsque `.kiro/settings/lsp.json` existe dans l'espace de travail.
- **Désactivation :** supprimez `.kiro/settings/lsp.json` pour désactiver. Réactivez à tout moment avec `/code init`.

### Serveurs LSP pris en charge

| Langage | Extensions | Serveur | Commande d'installation |
| -- | -- | -- | -- |
| TypeScript/JavaScript | `.ts`, `.js`, `.tsx`, `.jsx` | `typescript-language-server` | `npm install -g typescript-language-server typescript` |
| Rust | `.rs` | `rust-analyzer` | `rustup component add rust-analyzer` |
| Python | `.py` | `pyright` | `pip install pyright` |
| Go | `.go` | `gopls` | `go install golang.org/x/tools/gopls@latest` |
| Java | `.java` | `jdtls` | `brew install jdtls` (macOS) |
| Ruby | `.rb` | `solargraph` | `gem install solargraph` |
| C/C++ | `.c`, `.cpp`, `.h`, `.hpp` | `clangd` | `brew install llvm` (macOS) ou `apt install clangd` (Linux) |
| Kotlin | `.kt`, `.kts` | `kotlin-language-server` | `brew install kotlin-language-server` |

### Utilisation des serveurs de langage

Interrogez l'intelligence sémantique du code en langage naturel - recherchez des symboles, naviguez dans les définitions, trouvez des références, renommez dans plusieurs fichiers, obtenez des diagnostics, consultez la documentation et découvrez les API disponibles :

```
> Find references of Person class

Finding all references at: auth.ts:42:10
  1. src/auth.ts:42:10 - export function authenticate(...)
  2. src/handlers/login.ts:15:5 - authenticate(credentials)
  3. src/handlers/api.ts:89:12 - await authenticate(token)
```


```
> Dry run: rename the method "FetchUser" to "fetchUserData"

Dry run: Would rename 12 occurrences in 5 files
```


```
> What methods are available on the s3Client instance?

Available completions:
  1. putObject - Function: (params: PutObjectRequest) => Promise<PutObjectOutput>
  2. getObject - Function: (params: GetObjectRequest) => Promise<GetObjectOutput>
  3. deleteObject - Function: (params: DeleteObjectRequest) => Promise<DeleteObjectOutput>
```

### Serveurs de langage personnalisés

Ajoutez des serveurs de langage personnalisés en modifiant `.kiro/settings/lsp.json` :

```json
{
  "languages": {
    "mylang": {
      "name": "my-language-server",
      "command": "my-lsp-binary",
      "args": ["--stdio"],
      "file_extensions": ["mylang", "ml"],
      "file_patterns": ["Mylangfile", "mylang.config.*"],
      "project_patterns": ["mylang.config"],
      "exclude_patterns": ["**/build/**"],
      "multi_workspace": false,
      "initialization_options": { "custom": "options" },
      "request_timeout_secs": 60
    }
  }
}
```

**Champs :**

- **name** : Nom d'affichage du serveur de langage
- **command** : Binaire/commande à exécuter
- **args** : Arguments de la ligne de commande (habituellement `["--stdio"]`)
- **file_extensions** : Extensions de fichiers gérées par ce serveur
- **file_patterns** : Liste facultative de motifs glob comparés au nom de fichier complet. Utilisez ceci pour les serveurs de langage qui ciblent des noms de fichiers spécifiques sans extension standard, comme `Dockerfile`, `Dockerfile.*` ou `docker-compose*.yml`. Les correspondances exactes l'emportent sur les motifs glob, et les motifs glob plus spécifiques l'emportent sur les plus généraux, peu importe l'ordre de déclaration.
- **project_patterns** : Fichiers qui indiquent une racine de projet (p. ex. `package.json`)
- **exclude_patterns** : Motifs glob à exclure de l'analyse
- **multi_workspace** : Définir à true si le LSP prend en charge plusieurs dossiers d'espace de travail (par défaut : false)
- **initialization_options** : Configuration propre au LSP transmise lors de l'initialisation
- **request_timeout_secs** : Délai d'expiration en secondes pour les requêtes LSP. Par défaut : 60.

Après modification, redémarrez Kiro CLI pour charger la nouvelle configuration.

### Commandes CLI

| Commande | Objectif |
|---------|---------|
| `/code init` | Initialiser l'intelligence du code dans le répertoire actuel |
| `/code init -f` | Forcer la réinitialisation (redémarrer tous les serveurs LSP) |
| `/code status` | Afficher l'état de l'espace de travail et des serveurs LSP |
| `/code overview [path] [--silent]` | Aperçu de la structure de la base de code |
| `/code summary` | Génération de documentation interactive |
| `/code logs` | Afficher les journaux LSP pour le dépannage |

Options de `/code logs` : `-l, --level <LEVEL>` filtre (ERROR, WARN, INFO, DEBUG, TRACE; par défaut ERROR) · `-n, --lines <N>` nombre de lignes (par défaut 20) · `-p, --path <PATH>` exporter les journaux vers un fichier JSON.

### Dépannage

| Problème | Cause(s) | Solution |
| -- | -- | -- |
| Code tool is not enabled for this agent | L'agent n'a pas l'outil code dans sa liste d'outils | Ajoutez `"code"` au tableau d'outils de l'agent, ou utilisez `@builtin` pour inclure tous les outils intégrés, ou utilisez `@builtin/code` |
| Workspace is still initializing | Les serveurs LSP sont en cours de démarrage | Attendez et réessayez. Si les serveurs ont planté, utilisez `/code init -f` pour redémarrer |
| LSP initialization failed | | Consultez les journaux pour plus de détails : `/code logs -l ERROR` |
| No symbols found | Le serveur de langage est encore en cours d'indexation, le fichier contient des erreurs de syntaxe, ou le nom du symbole ne correspond pas | Vérifiez le fichier pour des erreurs, essayez des termes de recherche plus larges |
| No definition found | La position ne pointe pas vers un symbole | Vérifiez que les numéros de ligne et de colonne pointent vers un nom de symbole |

Tous les serveurs de langage ne prennent pas en charge toutes les opérations (certains peuvent ne pas prendre en charge le renommage ou le formatage), et les grandes bases de code peuvent être lentes à indexer initialement.

## Autorisations

Les recherches de symboles et l'analyse de code dans votre espace de travail s'exécutent sans invite. Les opérations ciblant des fichiers hors de l'espace de travail nécessitent une approbation.

Un renommage ou un formatage demande une approbation avant chaque fichier qu'il modifie, une invite par fichier, y compris les fichiers que le serveur de langage ajoute à la modification au-delà de celui que vous avez nommé. Une règle `deny` sur n'importe quel fichier de la modification refuse la modification entière, et rien n'est écrit. Kiro calcule la modification par rapport à chaque fichier tel que vous l'avez enregistré la dernière fois; si un fichier change avant que la modification soit appliquée, Kiro refuse la modification au lieu de l'appliquer à des positions périmées.

## Prochaines étapes

- [Aperçu des outils intégrés](https://kiro.dev/docs/tools.md) - catalogue complet des outils
- [Guides de prise en charge des langages](https://kiro.dev/docs/guides/languages-and-frameworks.md) - configuration par langage