Aller au contenu principal
Outil web gratuit pour documenter vos projets

Importez un dossier, un dépôt GitHub/GitLab ou un ZIP. Masquez les fichiers générés, expliquez les chemins importants avec des annotations et copiez le résultat dans votre README.

Sans inscription ni installation. Les dossiers locaux sont traités dans votre navigateur.

Import de dossiersRepo / ZIPAnnotations alignéesExport ASCII / Markdown

Éditeur d’arborescence en ligne

Générez une arborescence annotée à partir de votre projet

Essayez l’exemple ou importez votre projet. Masquez un dossier inutile, annotez un point d’entrée et vérifiez le résultat avant de le copier ou de le télécharger.

Chargement de l’éditeur

L’éditeur fonctionne dans votre navigateur : essayez le parcours complet sans créer de compte.

Pourquoi dir-tree

Rendez la structure de votre README facile à comprendre

Une liste complète de fichiers peut noyer les points d’entrée dont vos lecteurs ont besoin. Masquez les dépendances, les fichiers de build et les caches. Expliquez les dossiers importants sans modifier les fichiers sur le disque.

dir-tree transforme une sortie tree encombrée en structure de projet claire pour un README, avec annotations alignées
Masquez les dossiers générés, alignez les annotations et publiez une structure prête pour votre README.

Partez du projet que vous avez déjà

Importez un dossier, un dépôt, un ZIP ou une arborescence existante au lieu de ressaisir la hiérarchie à la main.

Dossier · URL de Repo · ZIP · ZIP distant · Arborescence

Avant

Brouillon du README
- sortie copiée du terminal
- ancienne liste de dossiers
- notes de retouche manuelle

Après

my-app/
├── app/              // routes
├── components/       // composants UI
└── package.json      // dépendances

Gardez les éléments utiles

Utilisez la limite de profondeur, les règles d’exclusion et le masquage des nœuds pour retirer les fichiers générés et mettre en valeur la structure à expliquer.

Profondeur · .gitignore · Exclusions · Masquage

Avant

$ tree -L 3
.
├── node_modules/
├── .next/
├── dist/
├── src/
└── package.json

Après

my-app/
├── src/              // code de l’application
└── package.json      // dépendances

Expliquez les chemins importants

Annotez les fichiers et dossiers, puis choisissez une disposition compacte après le chemin ou des colonnes alignées. Rédigez vos notes ou vérifiez les suggestions IA facultatives.

Notes manuelles · IA facultative · Disposition

Avant

├── auth.ts // authentification ?
├── api.ts        // client
└── format.ts // utilitaire

Après

├── auth.ts           // connexion
├── api.ts            // client API
└── format.ts         // formatage du texte

Exportez la structure préparée

Copiez le résultat ou téléchargez-le en Markdown, TXT ou JSON pour votre README, votre documentation ou une Pull Request.

Style · Markdown · TXT · JSON

Avant

Coller la sortie brute
corriger les espaces
ajouter un bloc de code
recommencer la fois suivante

Après

Prêt à publier
Copier dans le presse-papiers
Télécharger en Markdown
Télécharger en TXT
Exporter en JSON

Les étapes

Importer, filtrer, annoter et exporter

Importez votre projet dans un même éditeur, choisissez ce que les lecteurs doivent voir et préparez une arborescence annotée pour votre documentation.

Import dans dir-tree d’un dossier local, d’un dépôt GitHub ou GitLab, d’un ZIP, d’une URL de ZIP distant et d’une sortie tree
Partez d’un dossier, d’un dépôt, d’un ZIP, d’une URL distante ou d’un résultat existant.

Importez votre projet

Choisissez un dossier local, un dépôt GitHub/GitLab, un ZIP ou une arborescence textuelle. Vous pouvez aussi commencer avec l’exemple.

DossierURL de RepoZIPZIP distantASCII · JSON · XML · HTML · MD
Filtrage d’une arborescence dans dir-tree avec limite de profondeur, règles .gitignore, exclusions et masquage des dossiers générés
Masquez les éléments superflus, ajustez la profondeur et réorganisez la structure sans modifier les fichiers source.

Choisissez les éléments à afficher

Limitez la profondeur, appliquez les règles d’exclusion et masquez les nœuds inutiles. Les fichiers d’origine restent inchangés.

Profondeur.gitignoreMasquageRéorganisation
Personnalisation du rendu, alignement des annotations et export ASCII, Markdown, TXT et JSON pour un README
Ajustez le style et l’alignement des annotations, puis copiez ou téléchargez le résultat.

Annotez et exportez

Expliquez les chemins importants, choisissez la disposition des annotations, puis copiez ou téléchargez l’arborescence préparée.

StyleAnnotations alignéesMarkdown · TXT · JSON · Presse-papiers
Sources et formats d’export
Sources et exports de dir-tree : dossiers locaux, dépôts GitHub et GitLab, ZIP, texte, JSON, XML, HTML et Markdown vers Markdown, ASCII TXT, JSON ou presse-papiers
Importez une structure, préparez une arborescence annotée et exportez-la pour votre documentation.
Dossier localURL de RepoZIPArborescence textuelleJSONXMLHTMLMarkdown
Analyser + uniformiserArborescence mise en forme et annotée
MarkdownASCII TXTJSONPresse-papiers

Cas d’usage

Pour les README, la documentation, les revues et les cours

Montrez le bon niveau de détail, que le lecteur découvre le dépôt ou examine une modification de sa structure.

Structure de projet pour README créée avec dir-tree, annotations alignées et style cohérent
Publiez une structure claire et annotée dans votre README.

Structure de projet dans un README

Mainteneurs open source et auteurs de modèles

Mettez en avant les points d’entrée, la configuration et les dossiers importants, sans les noyer dans les fichiers générés.

Sortie Unicode
Sortie Unicode
starter-kit/
├── app/                  // routes et layouts
├── components/           // composants UI
├── lib/                  // utilitaires partagés
└── README.md             // installation
Page de documentation technique utilisant une arborescence annotée comme schéma d’architecture
Transformez la structure du projet en schéma d’architecture facile à comprendre.

Documentation technique annotée

Rédacteurs techniques et developer advocates

Expliquez le rôle des routes, modèles, composants et utilitaires à côté de leurs chemins.

Sortie ASCII
Sortie ASCII
api-service/
|-- routes/               // endpoints HTTP
|   |-- auth.ts           // JWT et sessions
|   `-- users.ts          // CRUD utilisateurs
|-- models/               // schémas de données
`-- middleware/           // traitement des requêtes
Description de Pull Request présentant une arborescence annotée pour expliquer le périmètre d’un refactoring
Expliquez le périmètre d’un refactoring avec une arborescence annotée concise.

Contexte d’une Pull Request

Ingénieurs chargés de la revue d’un refactoring

Aidez les reviewers à repérer la structure concernée par un refactoring grâce à une arborescence concise.

Sortie Unicode
Sortie Unicode
src/
├── auth/                 // connexion
├── hooks/                // hooks partagés
├── utils/                // utilitaires partagés
└── README.md             // notes de structure
Cours sur la hiérarchie des dossiers montrant l’arborescence visuelle et sa sortie ASCII pour README
Montrez aux étudiants la hiérarchie visuelle et le texte ASCII correspondant.

Prise en main et enseignement

Enseignants en informatique et créateurs de cours

Aidez les nouveaux contributeurs et les étudiants à trouver les premiers fichiers à explorer.

Sortie ASCII
Sortie ASCII
lesson-01/
|-- starter/              // point de départ
|   `-- index.js          // point d’entrée
`-- solution/             // référence enseignant

Guides et exemples

Des guides pour documenter votre projet

Suivez des guides pratiques pour sélectionner la structure utile, ajouter des annotations et préparer une arborescence pour votre README.

Comparaison

Quand utiliser dir-tree plutôt que la commande tree ?

La commande tree convient aux aperçus rapides et aux scripts. dir-tree réunit l’import de dossiers, de dépôts et de ZIP, l’édition visuelle, la mise en page des annotations, l’IA facultative et l’export pour la documentation.

Terminal tree

Idéal pour: Consulter rapidement un dossier local

Filtrez la sortie avec les options de commande ; ajoutez séparément les explications nécessaires.

tree.nathanfriend.com

Idéal pour: Saisir des schémas ASCII à la main

Pratique pour dessiner une structure, mais ne lit pas les dossiers réels du projet.

dir-tree

Idéal pour: Préparer une structure pour la documentation

Importez, modifiez, mettez en forme, annotez et exportez dans un même éditeur web.

Quand utiliser dir-tree plutôt que la commande tree ?
FonctionnalitéTerminal `tree`tree.nathanfriend.comdir-tree
Lit les dossiers locauxOuiNonOui
Dans le navigateur, sans installationNonOuiOui
Prend en charge les ZIP locaux et distantsNonNonOui
Importe les URL de dépôts GitHub/GitLabNonNonOui
Importe les arborescences ASCII / JSON / XML existantesExport uniquementLimitéOui
Édition visuelle et masquage des nœudsNonÉdition uniquementOui
Personnalisation du renduOptions de commande et retouches manuellesOptions visuelles de baseConnecteurs, indentation, chemin racine, métadonnées et modèles d’annotation
Alignement des annotations en colonnesNonNonOui
Annotations manuelles et IA facultativeNonNonOui
Export Markdown / TXT / JSON pour la documentationSortie bruteASCII généréMise en forme et annotations

Confidentialité

Traitement local, échanges maîtrisés

Traitez vos dossiers locaux et ZIP dans le navigateur. Utilisez les imports distants et l’IA facultative selon vos besoins.

01

Générez sans envoyer les fichiers du projet

Lisez, modifiez et exportez la structure de votre projet local dans le navigateur.

02

Les imports distants contactent la source

L’import d’un dépôt ou d’un ZIP distant contacte le service que vous choisissez.

03

Vous décidez d’utiliser l’IA

Le contexte sélectionné est envoyé lorsque vous demandez des suggestions. Vérifiez-les avant de les appliquer.

Limites de confidentialité de dir-tree : traitement local dans le navigateur et annotations IA facultatives sans contenu des fichiers
Édition et export locaux. Sources distantes et IA à la demande.

Échanges avec l’IA facultative

  • Nœuds sélectionnés
  • Annotations existantes
  • Réglages de génération
  • Fournisseur d’IA
  • Annotations proposées

L’IA utilise le contexte fourni sans lire automatiquement les fichiers source du projet.

FAQ

Questions sur le générateur d’arborescences

Importez un dossier local, un dépôt GitHub ou GitLab, un ZIP ou une arborescence existante. Masquez les dossiers générés, ajoutez des annotations et choisissez des connecteurs Unicode ou ASCII. Copiez ensuite le résultat ou exportez-le en Markdown. Les fichiers d’origine ne sont pas modifiés.

Sélectionnez un dossier ou déposez-le dans dir-tree. Le navigateur lit localement les noms et la hiérarchie des fichiers et dossiers. Vous pouvez ensuite filtrer, modifier, annoter et exporter la structure sans envoyer le contenu des fichiers.

dir-tree importe les dossiers locaux, les URL de dépôts GitHub/GitLab, les ZIP locaux ou distants, la sortie de la commande `tree`, le JSON, le XML, le HTML et les listes Markdown. Chaque source devient une arborescence modifiable.

La génération d’une arborescence n’envoie pas le contenu des fichiers du projet. Les dossiers locaux, ZIP, règles d’exclusion et textes importés sont traités dans votre navigateur. Les imports distants contactent GitHub, GitLab ou l’hébergeur du ZIP. Les annotations IA facultatives transmettent les chemins sélectionnés, les types de nœuds, les annotations existantes, les réglages et votre prompt, pas les fichiers source du projet.

La commande tree est utile pour les aperçus, les filtres et les scripts. dir-tree ajoute un éditeur dans le navigateur pour importer différentes sources, modifier la structure affichée, rédiger et aligner les annotations, puis exporter un résultat adapté à la documentation.

Oui. Annotez les fichiers et les dossiers, puis placez les annotations après le chemin ou dans des colonnes alignées. Trois stratégies sont disponibles : Adaptatif, Colonne globale et Par dossier parent. L’export conserve les espaces ; utilisez un bloc de code à police monospace dans votre README. Les textes multilingues et les emoji peuvent toutefois sembler décalés si la police de destination utilise des largeurs de caractères différentes.

Unicode utilise des connecteurs comme `├──` et `└──`, qui rendent la hiérarchie plus lisible. L’ASCII simple utilise des connecteurs tels que `|--` et `+--`, compatibles avec les anciens terminaux et les environnements textuels limités. Les deux styles permettent d’annoter, de copier et d’exporter.

Oui. Les suggestions facultatives utilisent les chemins sélectionnés, les annotations existantes, les réglages et votre prompt, sans lire les fichiers source du projet. Vérifiez-les avant de les appliquer : un nom de fichier ne suffit pas toujours à en comprendre le rôle. Une demande peut inclure jusqu’à 500 nœuds, fichiers et dossiers compris. Chaque IP dispose actuellement de 10 demandes gratuites par jour, avec remise à zéro à 00:00 UTC.

Oui. Limitez la profondeur, utilisez `.gitignore` et les règles d’exclusion, masquez les dossiers générés, repliez des dossiers et exportez uniquement la structure utile à votre documentation ou à votre revue.

Prêt à créer votre première arborescence ?

Un éditeur gratuit dans votre navigateur, sans inscription ni installation.

Essayer dir-tree