node_modules prend de la place sur ton Mac : ce que tu peux effacer sans casse

Tu ouvres le stockage de ton Mac et le dossier où tu ranges tes projets pèse bien plus que prévu. Le plus souvent, ce n'est pas ton code. Ce sont les dossiers node_modules, un par projet, qui dorment là depuis des mois.

La bonne nouvelle : tu peux presque toujours les effacer. Ils se reconstruisent en une commande le jour où tu reprends le projet.

Pourquoi node_modules prend autant de place

Quand tu lances npm install dans un projet, npm télécharge toutes ses dépendances, et les dépendances de ces dépendances. D'après la documentation de npm sur ses dossiers, une installation locale, celle par défaut, range tout dans le dossier ./node_modules à la racine du projet.

Chaque projet a donc sa propre copie, même si un autre projet utilise exactement la même bibliothèque. La page Motivation de pnpm le résume ainsi : avec npm, 100 projets qui utilisent une même dépendance, ce sont 100 copies sur le disque. Multiplie par le nombre de paquets d'un projet moyen et tu comprends d'où viennent les gigas.

Ce que tu peux supprimer sans risque (et ce qu'il faut garder)

Un dossier node_modules se recrée à partir de deux fichiers qui restent à côté : package.json, la liste des dépendances, et package-lock.json, leurs versions exactes. Tant que ces deux fichiers sont là, effacer node_modules ne fait perdre aucune ligne de ton code.

Trois précautions quand même :

• Ne touche qu'à tes projets. Les paquets installés en global avec npm install -g vont ailleurs, dans {prefix}/lib/node_modules sur Mac, comme le précise la doc de npm. Ce dossier fait marcher tes outils en ligne de commande : laisse-le.
• Méfie-toi des apps. Certaines apps installées sur ton Mac ont besoin de leur propre node_modules pour fonctionner. L'outil npkill, plus bas, le signale clairement : en effacer un peut casser l'app.
• Vérifie que le lock est là. Sans package-lock.json, la réinstallation prendra les versions les plus récentes autorisées par package.json, qui ne seront pas forcément celles que tu avais.

1. Mesure ce que pèsent tes node_modules

Ouvre le Terminal dans le dossier d'un projet et tape :

du -sh node_modules

L'option -s donne un seul total pour le dossier et -h l'affiche en Mo ou en Go, d'après la page de manuel de du sur macOS.

Pour faire la liste de tous les dossiers node_modules d'un coup, place-toi dans le dossier qui contient tes projets (ici ~/Projets, adapte le nom) :

cd ~/Projets
find . -name node_modules -type d -prune -exec du -sh {} +

-prune empêche find de descendre dans un node_modules déjà trouvé. Sans lui, tu verrais aussi les node_modules rangés à l'intérieur des autres, et la liste deviendrait illisible. Chaque ligne te donne la taille et le chemin : tu sais tout de suite quels projets coûtent le plus.

Si tu préfères voir ça en image, une carte du disque comme GrandPerspective ou le guide pour connaître la taille d'un dossier sur Mac font aussi l'affaire.

2. Efface le dossier d'un projet à la main

Pour un ou deux projets, le plus simple reste le Finder. Ouvre le dossier du projet, glisse node_modules dans la Corbeille, puis vide-la. Apple le rappelle dans sa page Libérer de l'espace de stockage : la place n'est rendue qu'une fois la Corbeille vidée.

Le Finder peut mettre du temps : un node_modules contient souvent des dizaines de milliers de petits fichiers. Dans ce cas, le Terminal va plus vite. Place-toi dans le dossier du projet, celui qui contient package.json, et tape :

rm -rf node_modules

Attention, cette commande ne passe pas par la Corbeille : le dossier disparaît tout de suite. Vérifie deux fois que tu es au bon endroit avant d'appuyer sur Entrée. Une commande pwd t'affiche le dossier où tu te trouves.

3. Nettoie tous les vieux projets avec npkill

Si tu as des dizaines de projets, un outil fait le tri pour toi : npkill. Pas besoin de l'installer, il se lance avec npx depuis le dossier qui contient tes projets :

cd ~/Projets
npx npkill

D'après sa page GitHub, npkill cherche les dossiers node_modules à partir du dossier où tu le lances, puis affiche chacun avec sa taille. La colonne last_mod indique la dernière fois qu'un fichier du projet a été modifié. C'est le critère qui compte : un projet que tu n'as pas touché depuis un an est un bon candidat.

Les flèches haut et bas te déplacent dans la liste, Espace ou Suppr efface le dossier sélectionné, Q quitte. Quelques options utiles :

• npx npkill -s size trie la liste par taille, les plus gros en haut.
• npx npkill -d ~/Projets choisit le dossier de départ sans avoir à t'y placer.
• npx npkill -x exclut les dossiers jugés sensibles.
• npx npkill --dry-run simule tout sans rien effacer, pour voir avant d'agir.

Le petit symbole ⚠ à côté d'une ligne signale un node_modules dont une app a besoin. Laisse ceux-là tranquilles.

4. Reprends un projet : réinstalle en une commande

Le jour où tu rouvres un projet nettoyé, il suffit de reconstruire ses dépendances. Deux commandes possibles :

• npm ci réinstalle exactement les versions notées dans package-lock.json. La documentation de npm ci précise qu'il exige ce fichier, qu'il supprime tout seul un node_modules déjà présent avant d'installer et qu'il ne modifie jamais package.json ni le lock. C'est le choix le plus sûr.
• npm install marche aussi, mais il peut mettre à jour le lock si package.json le permet.

Astuce au passage : npm ci repart toujours de zéro. Si un projet se comporte bizarrement après des mois, c'est aussi un bon moyen de remettre ses dépendances au propre.

5. Vide le cache de npm dans ~/.npm

En plus des node_modules, npm garde une copie de tout ce qu'il télécharge dans un cache. Sur Mac, il se trouve dans ~/.npm, un dossier caché de ton dossier personnel (la doc de npm le situe là sur les systèmes Posix). Il sert à réinstaller plus vite.

La documentation de npm cache est claire : ce cache se répare tout seul, et le vider ne devrait servir qu'à récupérer de la place. Deux commandes :

npm cache verify

Elle vérifie le cache et ramasse les données qui ne servent plus. Commence par elle.

npm cache clean --force

Elle vide tout le cache. npm exige --force justement parce que ce n'est presque jamais nécessaire. Les paquets seront retéléchargés à la prochaine installation, ce qui la rendra un peu plus lente.

Tu codes aussi avec Homebrew ou Xcode ? Leurs caches ont chacun leur méthode : brew cleanup et DerivedData.

6. Tu utilises pnpm ? Le calcul change

pnpm range différemment. Selon sa page Motivation, il garde chaque fichier une seule fois dans un « store » central, puis le relie dans le node_modules de chaque projet par un lien physique (hard link). Un même fichier apparaît dans plusieurs projets, mais il n'occupe le disque qu'une fois.

Conséquence : effacer le node_modules d'un projet pnpm libère souvent peu de place, puisque les fichiers restent dans le store. Ce qui compte, c'est le store lui-même. La page pnpm store donne deux commandes :

• pnpm store path affiche où se trouve le store.
• pnpm store prune retire les paquets que plus aucun projet n'utilise. D'après pnpm, ça n'a aucun effet sur tes projets, et les paquets retirés seront retéléchargés si un projet en a de nouveau besoin. pnpm conseille de la lancer de temps en temps, pas tous les jours.

Pour mesurer, du reste fiable : sa page de manuel précise qu'un fichier qui a plusieurs liens physiques n'est compté qu'une fois par exécution. Passe-lui plusieurs projets dans la même commande et le total ne gonfle pas.

7. Bonus : sors node_modules de Time Machine

Les node_modules n'ont rien à faire dans une sauvegarde : ils se recréent depuis package.json. Les sauvegarder remplit ton disque Time Machine pour rien. La commande tmutil de macOS permet d'en exclure un :

tmutil addexclusion node_modules

À lancer dans le dossier du projet. D'après la page de manuel de tmutil, cette exclusion suit le dossier même si tu le déplaces. Pour le reste, notre guide sur Time Machine et l'espace disque va plus loin.

Ce que CleanMochi fait, et ne fait pas, pour node_modules

CleanMochi, c'est l'app que nous faisons pour les Mac. Il ne cherche pas tes dossiers node_modules, ne les mesure pas et ne les supprime pas. Il ne touche pas non plus au store de pnpm. Pour tout ça, les étapes 1 à 6 restent la bonne méthode.

• Gros fichiers saute exprès les dossiers node_modules pendant sa recherche. Tu n'y verras jamais un fichier de dépendance proposé à la suppression, ce qui évite de casser un projet par erreur.
• Nettoyage a une catégorie Caches de développement. Elle contient le cache de npm (~/.npm/_cacache), à côté de ceux de Xcode et de Homebrew, avec cette explication : « Copies laissées par les outils de code (npm, Homebrew, Xcode). Ils se retéléchargent si besoin. » Elle n'est pas cochée d'office. Si tu la coches, ces caches sont supprimés directement, sans passer par la Corbeille, comme avec npm cache clean --force.

CleanMochi est en bêta ouverte, téléchargeable sur cleanmochi.com.