Optimiser la gestion des dépendances et les mises à jour avec Claude Code

Les défis de la gestion des dépendances

Les projets JavaScript/TypeScript modernes dépendent de centaines de packages. En utilisant Claude Code, vous pouvez mettre à jour les dépendances de manière sûre et efficace.

Vérification de l’état des dépendances

Demandons à Claude Code d’analyser les dépendances actuelles.

Analyse les dépendances du projet.
- Liste des packages obsolètes
- Packages avec des vulnérabilités de sécurité
- Dépendances inutilisées
- Dépendances dupliquées

Script de mise à jour automatique

import { execSync } from "child_process";
import { readFileSync, writeFileSync } from "fs";

interface OutdatedPackage {
  current: string;
  wanted: string;
  latest: string;
  location: string;
}

function checkOutdated(): Record<string, OutdatedPackage> {
  try {
    const output = execSync("npm outdated --json", {
      encoding: "utf-8",
    });
    return JSON.parse(output);
  } catch (e: any) {
    // npm outdated retourne le code de sortie 1 quand il y a des packages obsolètes
    return JSON.parse(e.stdout || "{}");
  }
}

function categorizeUpdates(
  packages: Record<string, OutdatedPackage>
) {
  const patch: string[] = [];
  const minor: string[] = [];
  const major: string[] = [];

  for (const [name, info] of Object.entries(packages)) {
    const [curMajor, curMinor] = info.current.split(".").map(Number);
    const [latMajor, latMinor] = info.latest.split(".").map(Number);

    if (latMajor > curMajor) {
      major.push(name);
    } else if (latMinor > curMinor) {
      minor.push(name);
    } else {
      patch.push(name);
    }
  }

  return { patch, minor, major };
}

Flux de mise à jour sécurisé

async function safeUpdate(packageName: string) {
  console.log(`Mise à jour de ${packageName}...`);

  // 1. Sauvegarder le lock file actuel
  execSync("cp package-lock.json package-lock.json.bak");

  try {
    // 2. Mettre à jour le package
    execSync(`npm install ${packageName}@latest`);

    // 3. Vérification des types
    execSync("npx tsc --noEmit");

    // 4. Exécution des tests
    execSync("npm test");

    // 5. Vérification du build
    execSync("npm run build");

    console.log(`${packageName} mis à jour avec succès`);
    // Supprimer la sauvegarde
    execSync("rm package-lock.json.bak");
  } catch (error) {
    console.error(`Échec de la mise à jour de ${packageName}, restauration`);
    execSync("cp package-lock.json.bak package-lock.json");
    execSync("npm install");
    throw error;
  }
}

Détection des dépendances inutilisées

import depcheck from "depcheck";

async function findUnusedDeps(projectPath: string) {
  const options = {
    ignoreDirs: ["node_modules", "dist", "build"],
    ignorePatterns: ["*.test.*", "*.spec.*"],
  };

  const result = await depcheck(projectPath, options);

  console.log("Dependencies inutilisées :");
  result.dependencies.forEach((dep) => console.log(`  - ${dep}`));

  console.log("\nDevDependencies inutilisées :");
  result.devDependencies.forEach((dep) => console.log(`  - ${dep}`));

  console.log("\nDépendances manquantes :");
  for (const [dep, files] of Object.entries(result.missing)) {
    console.log(`  - ${dep} (utilisé dans : ${files.join(", ")})`);
  }

  return result;
}

Génération de la configuration Renovate/Dependabot

Demandons à Claude Code de générer la configuration CI de mise à jour automatique.

// renovate.json
{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": ["config:recommended"],
  "schedule": ["every weekend"],
  "packageRules": [
    {
      "matchUpdateTypes": ["patch"],
      "automerge": true
    },
    {
      "matchUpdateTypes": ["minor"],
      "automerge": true,
      "automergeType": "pr"
    },
    {
      "matchUpdateTypes": ["major"],
      "labels": ["breaking-change"],
      "automerge": false
    },
    {
      "matchPackageNames": ["typescript", "eslint"],
      "groupName": "tooling"
    }
  ]
}

Automatisation de l’audit de sécurité

function securityAudit() {
  try {
    const output = execSync("npm audit --json", {
      encoding: "utf-8",
    });
    const audit = JSON.parse(output);

    const critical = audit.metadata.vulnerabilities.critical;
    const high = audit.metadata.vulnerabilities.high;

    if (critical > 0 || high > 0) {
      console.error(
        `Critical: ${critical}, High: ${high} vulnérabilités trouvées`
      );
      // Tenter la correction automatique
      execSync("npm audit fix");
    }

    return audit;
  } catch (e) {
    console.error("Échec de l'audit :", e);
    throw e;
  }
}

Prompts d’utilisation avec Claude Code

Exemples de prompts pour confier la gestion des dépendances à Claude Code. Pour la configuration de l’automatisation, consultez le guide des hooks, et pour une utilisation efficace, 10 astuces pour tripler votre productivité.

Organise les dépendances.
- Vérifie les packages obsolètes avec npm outdated
- Mise à jour groupée des patch et minor puis exécution des tests
- Mise à jour des major une par une avec vérification du fonctionnement
- Supprime les dépendances inutilisées
- Corrige aussi les vulnérabilités de npm audit

Pour les bonnes pratiques de gestion des dépendances, consultez la documentation officielle de npm. Pour les détails sur Claude Code, consultez la documentation officielle.

Résumé

La gestion des dépendances est une tâche discrète mais essentielle, directement liée à la sécurité et à la maintenabilité. En utilisant Claude Code, vous pouvez avancer les mises à jour en toute sécurité tout en comprenant la portée de leur impact.