Claude Agent SDK : construire des agents programmatiques

import { claude } from "@anthropic-ai/claude-code-sdk";

async function analyzeFile(filePath: string): Promise<string> {
  // Lancer un agent avec un prompt et des options
  const result = await claude({
    prompt: `Analyse le fichier ${filePath} et produis un rapport
             avec : nombre de lignes, fonctions exportées,
             complexité cyclomatique estimée et suggestions.`,
    options: {
      maxTurns: 10,
      allowedTools: ["Read", "Bash", "Grep"],
    },
  });

  // Le résultat contient le texte de réponse
  return result.text;
}

// Utilisation
const report = await analyzeFile("src/lib/utils.ts");
console.log(report);

import asyncio
from claude_code_sdk import claude, ClaudeOptions

async def analyze_file(file_path: str) -> str:
    """Analyse un fichier et produit un rapport structuré."""
    result = await claude(
        prompt=f"Analyse le fichier {file_path} et produis un rapport "
               f"avec : nombre de lignes, fonctions exportées, "
               f"complexité cyclomatique estimée et suggestions.",
        options=ClaudeOptions(
            max_turns=10,
            allowed_tools=["Read", "Bash", "Grep"],
        ),
    )
    return result.text

# Utilisation
report = asyncio.run(analyze_file("src/lib/utils.ts"))
print(report)

import { claude, Tool } from "@anthropic-ai/claude-code-sdk";

// Définir un outil custom
const slackNotifier: Tool = {
  name: "notify_slack",
  description: "Envoie une notification sur un channel Slack",
  parameters: {
    type: "object",
    properties: {
      channel: { type: "string", description: "Le channel Slack" },
      message: { type: "string", description: "Le message à envoyer" },
    },
    required: ["channel", "message"],
  },
  // L'implémentation de l'outil
  async execute({ channel, message }) {
    const response = await fetch(SLACK_WEBHOOK_URL, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ channel, text: message }),
    });
    return { success: response.ok };
  },
};

// Utiliser l'agent avec l'outil custom
const result = await claude({
  prompt: "Vérifie que tous les tests passent. Si un test échoue, "
        + "notifie le channel #dev sur Slack avec le détail de l'erreur.",
  options: {
    maxTurns: 15,
    allowedTools: ["Bash", "Read"],
    customTools: [slackNotifier],
  },
});

import { claude } from "@anthropic-ai/claude-code-sdk";

async function healthCheck() {
  const result = await claude({
    prompt: `Tu es un agent de monitoring. Vérifie :
      1. Que le serveur répond sur http://localhost:3000/health
      2. Que la base de données est accessible
      3. Que l'espace disque est suffisant (> 20% libre)
      4. Que les logs récents ne contiennent pas d'erreurs critiques

      Produis un rapport JSON avec le statut de chaque vérification.
      Si un problème est détecté, utilise notify_slack pour alerter.`,
    options: {
      maxTurns: 10,
      allowedTools: ["Bash"],
      customTools: [slackNotifier],
    },
  });

  return JSON.parse(result.text);
}

// Lancer toutes les 5 minutes via un cron ou un scheduler

import asyncio
from claude_code_sdk import claude, ClaudeOptions

async def deploy_pipeline(version: str) -> dict:
    """Pipeline de déploiement en 4 étapes."""

    # Étape 1 : Vérifications pré-déploiement
    pre_check = await claude(
        prompt=f"Vérifie que la branche main est propre, "
               f"que tous les tests passent et que le build "
               f"de la version {version} est OK.",
        options=ClaudeOptions(
            max_turns=10,
            allowed_tools=["Bash", "Read"],
        ),
    )

    if "ÉCHEC" in pre_check.text:
        return {"status": "blocked", "reason": pre_check.text}

    # Étape 2 : Build et tag
    build = await claude(
        prompt=f"Crée le tag v{version}, build l'image Docker "
               f"et pousse-la sur le registry.",
        options=ClaudeOptions(
            max_turns=15,
            allowed_tools=["Bash"],
        ),
    )

    # Étape 3 : Déploiement
    deploy = await claude(
        prompt="Déploie la nouvelle image sur l'environnement staging. "
               "Vérifie que le health check passe.",
        options=ClaudeOptions(
            max_turns=10,
            allowed_tools=["Bash"],
        ),
    )

    return {
        "status": "success",
        "version": version,
        "pre_check": pre_check.text,
        "build": build.text,
        "deploy": deploy.text,
    }

import { claude, Tool } from "@anthropic-ai/claude-code-sdk";

const githubTool: Tool = {
  name: "github_api",
  description: "Interagit avec l'API GitHub",
  parameters: {
    type: "object",
    properties: {
      action: { type: "string", enum: ["list_issues", "add_labels", "add_comment"] },
      repo: { type: "string" },
      issueNumber: { type: "number" },
      labels: { type: "array", items: { type: "string" } },
      comment: { type: "string" },
    },
    required: ["action", "repo"],
  },
  async execute(params) {
    // Implémentation avec l'API GitHub (Octokit, gh CLI, etc.)
    // ...
    return { success: true };
  },
};

async function triageNewIssues() {
  const result = await claude({
    prompt: `Tu es un agent de triage de bugs. Pour chaque nouvelle
      issue non-triée dans le repo "mon-org/mon-app" :

      1. Lis le titre et la description
      2. Catégorise : bug, feature-request, question, documentation
      3. Estime la priorité : P0 (critique), P1 (haute), P2 (moyenne), P3 (basse)
      4. Ajoute les labels appropriés
      5. Si c'est un P0, ajoute un commentaire pour alerter l'équipe

      Traite toutes les issues créées dans les dernières 24h.`,
    options: {
      maxTurns: 30,
      customTools: [githubTool],
    },
  });

  return result.text;
}

// Exemple avec toutes les options
const result = await claude({
  prompt: "Refactore le module auth pour utiliser des tokens JWT",
  options: {
    maxTurns: 25,
    allowedTools: ["Read", "Edit", "Bash", "Grep", "Glob"],
    cwd: "/home/user/mon-projet",
    model: "sonnet",
    outputFormat: "json",
    systemPrompt: "Tu es un expert en sécurité. "
                 + "Privilégie toujours la sécurité sur la performance.",
  },
});

// MAUVAIS : un agent qui fait tout
const result = await claude({
  prompt: "Refactore le projet, écris les tests, fais la review, "
        + "mets à jour la doc et déploie en production",
});

// BON : des agents spécialisés et coordonnés
const refactorResult = await claude({
  prompt: "Refactore le module auth selon le plan fourni",
  options: { maxTurns: 20 },
});

const testResult = await claude({
  prompt: "Écris les tests pour le module auth refactoré",
  options: { maxTurns: 15 },
});

try {
  const result = await claude({
    prompt: "Exécute les migrations de base de données",
    options: { maxTurns: 10 },
  });

  if (result.text.includes("ERROR")) {
    // Rollback ou notification
    await notifyTeam("Migration échouée", result.text);
  }
} catch (error) {
  // Timeout, erreur réseau, etc.
  console.error("Agent SDK error:", error);
  await notifyTeam("Agent indisponible", String(error));
}

const result = await claude({
  prompt: "Analyse les dépendances du projet et produis un rapport "
        + "au format JSON avec : total, outdated, vulnerable, suggestions.",
  options: {
    maxTurns: 10,
    outputFormat: "json",
  },
});

const report = JSON.parse(result.text);
console.log(`${report.vulnerable} vulnérabilités trouvées`);