# map, skeleton, query, impact, semantic

> Trouvez le code, voyez la forme d'un fichier, localisez un symbole, mesurez l'impact d'un changement et cherchez par le sens, sans tout lire.

Source: https://tokenade.net/fr/docs/code-intelligence · Updated: 2026-10-07

Ces cinq commandes répondent à « où est le code dont j'ai besoin ? » sans charger de fichiers entiers dans le contexte de votre agent. Servez-vous-en quand vous ne savez pas encore où se trouve quelque chose. Si vous connaissez déjà le chemin, ouvrez directement le fichier : c'est moins cher que n'importe quel résumé.

Les cinq lisent un index local de votre dépôt, construit au premier besoin puis rafraîchi automatiquement. Rien ne quitte votre machine.

## Choisir la bonne commande

| Vous voulez savoir | Commande |
| --- | --- |
| Ce que contient le dépôt, et où | `tokenade map [<path>]` |
| Ce qu'un fichier déclare, sans les corps | `tokenade skeleton <file…>` |
| Où un symbole est défini et qui l'appelle | `tokenade query <symbol…>` |
| Ce qui casse si vous modifiez un fichier | `tokenade impact <file…>` |
| Où un concept est traité, en langage courant | `tokenade semantic "<question>"` |

Chaque commande accepte plusieurs cibles en un seul appel (`tokenade skeleton a.rs b.rs c.rs`). Un appel pour trois fichiers coûte un aller-retour au lieu de trois.

## Options communes

| Option | S'applique à | Effet |
| --- | --- | --- |
| `-o`, `--output-mode`, `--format` | les cinq | `full` (défaut), `paths`, `count` ; `query` et `semantic` acceptent aussi `outline` |
| `--budget N` | `skeleton`, `semantic` | Plafonne la réponse à N tokens. Le pied de page indique ce qui a été retenu, pour qu'une réponse tronquée ne passe jamais pour complète |
| `--json` | `map`, `query`, `impact` | Sortie lisible par une machine |

`paths` est la forme à passer à une lecture ensuite. `count` répond à « y en a-t-il ? » en une ligne.

## map

```text
tokenade map [<path>] [-o full|paths|count] [--json]
```

Affiche les répertoires, ce qu'ils contiennent et la taille de chaque partie. `<path>` restreint la carte à un répertoire ou un fichier ; les compteurs et la sortie `--json` ne portent alors que sur ce périmètre.

```text
$ tokenade map src/billing
38 files, 612 symbols indexed under src/billing
by directory:
  src/billing/   21 files, 290 symbols (+188 test)
  src/billing/providers/   9 files, 104 symbols
  src/billing/webhooks/   8 files, 30 symbols (+12 test)
top files (10 of 38, densest first):
  src/billing/invoice.ts  (44 symbols)
  src/billing/providers/stripe.ts  (31 symbols +18 test)
  …
```

```text
$ tokenade map -o count
files: 2247, symbols: 29648
```

## skeleton

```text
tokenade skeleton <file…> [-o full|paths|count] [--budget N]
```

N'affiche que les signatures. Chaque corps devient un marqueur `// … N lines …`. `--budget` vaut 20k tokens par défaut.

```text
$ tokenade skeleton src/billing/invoice.ts
import { Money } from "../money";
    // … 3 lines …
export interface Invoice {
    // … 9 lines …
}
export class InvoiceService {
  constructor(private repo: InvoiceRepo) {}
  async create(input: NewInvoice): Promise<Invoice> {
    // … 22 lines …
  async finalize(id: string): Promise<Invoice> {
    // … 14 lines …
```

## query

```text
tokenade query <symbol…> [--file <path>…] [-o full|paths|count|outline]
                         [--context N] [--json]
```

| Option | Effet |
| --- | --- |
| `--file <path>` | Ne répond que pour ce fichier. Répétable. Un suffixe de chemin suffit (`invoice.ts`, `billing/invoice.ts`), et un répertoire couvre tout ce qu'il contient |
| `--context N`, `-C N` | Ajoute N lignes de source autour de chaque résultat, ce qui évite un grep ensuite |

```text
$ tokenade query finalizeInvoice
fn finalizeInvoice — src/billing/invoice.ts:88
called by: handleCheckoutCompleted (src/billing/webhooks/checkout.ts:41), … +3 more
```

Quand un nom correspond à beaucoup d'endroits, la sortie le signale et montre les 30 premiers : `[30 of 165 matches shown — narrow the name to see the rest]`. Ajoutez `--file` pour resserrer.

## impact

```text
tokenade impact <file…> [-o full|paths|count] [--json]
```

Liste les fichiers qui dépendent de celui-ci et les symboles qu'ils utilisent.

```text
$ tokenade impact src/billing/invoice.ts
src/billing/invoice.ts declares (17 symbols):
  fn (9): create, finalize, voidInvoice, totalFor, …
  type (3): Invoice, NewInvoice, InvoiceStatus
dependents (5):
  src/billing/webhooks/checkout.ts
  src/api/routes/invoices.ts
  …
  … 12 more file(s) call a name this file declares, but that name has
  several declarations, so the call cannot be pinned here.
```

Un fichier que l'indexeur n'a jamais analysé le dit, au lieu d'annoncer « aucun dépendant ». Une réponse vide et un fichier inconnu sont deux faits différents.

## semantic

```text
tokenade semantic "<query>"…  [-o <mode>] [--budget N] [--limit N]
```

Alias : `ask`, `sem`. Cherche dans votre code par le sens autant que par mots-clés. Elle renvoie les passages qui répondent, pas des fichiers entiers.

| Option | Effet |
| --- | --- |
| `--limit N`, `-n N` | Nombre de résultats classés à considérer (10 par défaut). L'augmenter regarde au-delà du premier écran ; cela ne reclasse pas |
| `--budget N` | Plafonne la réponse à N tokens |

```text
$ tokenade semantic "where are failed payments retried" --limit 3
 0.71  src/billing/retry.ts  [failed, payment, payments, retry, retried]
 0.64  src/billing/webhooks/payment_failed.ts  [failed, payment, retry]
 0.58  src/jobs/dunning.ts  [payment, retried, failed]
[tokenade:depth] 3 shown — the ranking considered 12+. Raise with --limit 6 to look past the first screen.
```

Plusieurs questions dans un même appel partagent une seule construction d'index : `tokenade semantic "where is auth wired" "how are retries configured"`. Une suite de mots sans guillemets compte pour une seule question.

Le modèle de recherche local (environ 132 Mo) est téléchargé une fois, au premier `semantic`.

## L'index

| Commande | Effet |
| --- | --- |
| `tokenade index [--force]` | Construit et met en cache l'index des symboles. `--force` ignore le cache |
| `tokenade watch` | Réindexe de façon incrémentale à chaque enregistrement. Ctrl+C pour arrêter |
| `tokenade semantic-status [--json]` | Liste les projets indexés : fichiers, taille sur disque, date de dernière indexation. Lecture seule |

Vous aurez rarement besoin d'`index` ou de `watch` : les commandes ci-dessus construisent et rafraîchissent l'index à la demande. Les index se trouvent dans `~/.tokenade/index.db` et `~/.tokenade/semantic.db`. Ceux qui n'ont pas servi depuis 7 jours sont supprimés par [`tokenade evict-stale`](https://tokenade.net/fr/docs/maintenance).

## Codes de sortie et pièges

- Sortie `0` en cas de succès, y compris « aucun résultat ». Un fichier introuvable passé à `skeleton` ou `impact` sort en `1`. Une option inconnue sort en `2`.
- Les options inconnues et les arguments en trop sont refusés, pas intégrés à la question. Une faute de frappe échoue clairement au lieu de changer ce que vous demandez.
- Mettez entre guillemets les questions de plusieurs mots pour `semantic`. Un mot sans guillemets qui commence par un tiret est lu comme une option et refusé.
- `no match for '<query>'` reprend la question telle qu'elle a été comprise : c'est le moyen le plus rapide de voir ce qui a réellement été cherché.
- Les économies de ces commandes ne se mesurent pas directement (vous ne lisez jamais le fichier dont vous n'aviez pas besoin). Elles apparaissent comme des estimations, séparées des économies mesurées. Voir [comment les économies sont mesurées](https://tokenade.net/fr/docs/savings-measurement).

## Voir aussi

- [Lire documents et médias](https://tokenade.net/fr/docs/read-documents-media)
- [Comment les économies sont mesurées](https://tokenade.net/fr/docs/savings-measurement)
- [Comment les hooks interceptent les appels d'outils](https://tokenade.net/fr/docs/hooks)
- [Commandes de maintenance](https://tokenade.net/fr/docs/maintenance)
