25 - Claude Agent SDK e Managed Agents: Production-Grade Agents

#!/usr/bin/env python3
# test_generator_agent.py

from anthropic_agent import ClaudeAgent, ClaudeAgentOptions, Tool
from pathlib import Path
import json

# 1. Definire il system prompt dell'agente
SYSTEM_PROMPT = """
Sei un esperto di Java e Spring Boot che genera test JUnit5 di alta qualità.
Quando ricevi una classe Java, produci:
1. Unit test per ogni metodo pubblico
2. Mock delle dipendenze Autowired
3. Test per happy path e edge case
4. Assertions complete e meaningful
5. Supporto per Testcontainers se necessario (DB, Redis)

Segui le convenzioni:
- Nomi test: testMethodName_Condition_ExpectedResult
- Use @DisplayName per descrizioni leggibili
- Import Mockito per mock
- Import AssertJ per fluent assertion
"""

def read_java_file(path: str) -> str:
  """Tool callback: leggi un file Java"""
  file_path = Path(path)
  if not file_path.exists():
    return f"ERROR: File non trovato: {path}"
  with open(file_path, 'r') as f:
    return f.read()

def write_test_file(path: str, content: str) -> str:
  """Tool callback: scrivi il file di test"""
  file_path = Path(path)
  file_path.parent.mkdir(parents=True, exist_ok=True)
  with open(file_path, 'w') as f:
    f.write(content)
  return f"Test file scritto: {path}"

def analyze_class_structure(java_code: str) -> str:
  """Tool callback: analizza struttura della classe"""
  # In produzione, usaresti un parser Java vero (javalang, etc.)
  # Qui facciamo semplice regex per demo
  import re
  methods = re.findall(r'public\s+\w+\s+(\w+)\s*\(', java_code)
  fields = re.findall(r'@Autowired\s+private\s+\w+\s+(\w+);', java_code)
  return json.dumps({
    "methods": methods,
    "autowired_fields": fields,
    "line_count": len(java_code.split('\n'))
  })

# 2. Istanziare l'agente con tools
agent = ClaudeAgent(
  options=ClaudeAgentOptions(
    model="claude-opus-4-20250514",
    system_prompt=SYSTEM_PROMPT,
    max_tokens=8000
  )
)

# 3. Registrare i tool disponibili per l'agente
agent.register_tool(
  name="read_java_file",
  description="Leggi il contenuto di un file Java",
  callback=read_java_file,
  parameters={
    "path": {"type": "string", "description": "Percorso file .java"}
  }
)

agent.register_tool(
  name="write_test_file",
  description="Scrivi il file di test JUnit generato",
  callback=write_test_file,
  parameters={
    "path": {"type": "string", "description": "Percorso file test"},
    "content": {"type": "string", "description": "Contenuto test"}
  }
)

agent.register_tool(
  name="analyze_class_structure",
  description="Analizza la struttura della classe (metodi, dipendenze)",
  callback=analyze_class_structure,
  parameters={
    "java_code": {"type": "string", "description": "Codice sorgente Java"}
  }
)

# 4. Eseguire l'agente
if __name__ == "__main__":
  user_input = """
  Genera test JUnit5 completi per il file
  'backend/src/main/java/dev/federicocalo/portfolio/application/service/UserService.java'

  Salva il risultato in:
  'backend/src/test/java/dev/federicocalo/portfolio/application/service/UserServiceTest.java'

  Considera che la classe ha dipendenze Autowired su UserRepository e EmailService.
  """

  response = agent.run(user_input)
  print("Agent Response:")
  print(response)

#!/usr/bin/env node
// component-generator-agent.ts

import { ClaudeAgent, ClaudeAgentOptions } from "@anthropic-ai/claude-agent";
import { execSync } from "child_process";
import { promises as fs } from "fs";
import path from "path";

// 1. System prompt dell'agente
const SYSTEM_PROMPT = `
Sei un esperto di Angular 21 che genera componenti standalone di alta qualità.
Quando ricevi una richiesta, produci:

1. Componente TypeScript standalone (.ts)
   - Usa standalone: true
   - OnPush change detection
   - Signal per stato reattivo (computed, effect)
   - Dependency injection via constructor
   - Proper typing (no 'any')

2. Template HTML (.html)
   - Binding reattivo su signal
   - Form reattivo con Validators
   - ARIA label per accessibilità
   - ngNonBindable dove necessario

3. Stile CSS scoped (.css)
   - CSS custom properties da design system
   - Mobile-first responsive
   - Transizioni fluide

4. Test Jasmine (.spec.ts)
   - 80%+ code coverage
   - Mock di servizi
   - Test user interactions

Nomi: kebab-case per file, PascalCase per classi
`;

// Tool callbacks
async function executeCommand(cmd: string): Promise {
  try {
    const result = execSync(cmd, { encoding: 'utf-8' });
    return result;
  } catch (error: any) {
    return \`ERROR: \${error.message}\`;
  }
}

async function writeFile(filePath: string, content: string): Promise {
  try {
    const dir = path.dirname(filePath);
    await fs.mkdir(dir, { recursive: true });
    await fs.writeFile(filePath, content);
    return \`File scritto: \${filePath}\`;
  } catch (error: any) {
    return \`ERROR: \${error.message}\`;
  }
}

async function readAngularStyle(): Promise {
  try {
    const styleContent = await fs.readFile(
      'src/styles.css',
      'utf-8'
    );
    // Estrai solo le variabili CSS importanti
    const lines = styleContent.split('\n')
      .filter(l => l.includes('--color-') || l.includes('--space-'))
      .slice(0, 20);
    return lines.join('\n');
  } catch {
    return "/* Design system not found */";
  }
}

// 2. Istanziare agente TypeScript
const agent = new ClaudeAgent({
  model: "claude-opus-4-20250514",
  system_prompt: SYSTEM_PROMPT,
  max_tokens: 12000
});

// 3. Registrare tool
agent.registerTool({
  name: "execute_command",
  description: "Esegui comandi bash (ng, npm, git, etc.)",
  handler: executeCommand,
  parameters: {
    cmd: { type: "string", description: "Comando da eseguire" }
  }
});

agent.registerTool({
  name: "write_file",
  description: "Scrivi contenuto su file",
  handler: writeFile,
  parameters: {
    filePath: { type: "string", description: "Percorso del file" },
    content: { type: "string", description: "Contenuto" }
  }
});

agent.registerTool({
  name: "read_angular_style",
  description: "Leggi variabili CSS del design system",
  handler: readAngularStyle,
  parameters: {}
});

// 4. Eseguire agente
async function main() {
  const userInput = \`
  Genera un componente Angular standalone "UserProfileForm" con:
  - Form reattivo per edit profilo (nome, email, bio)
  - Validation di email
  - Submit con loading state
  - Scossa di errore animata se submit fallisce
  - Signal per reactive state
  - Dipendenza su UserService (mock)
  - Test completo
  - Usa design system da src/styles.css

  Salva in: src/app/pages/user-profile-form/
  Aggiungi la route in app.routes.ts come lazy-loaded
  \`;

  const response = await agent.run(userInput);
  console.log("Agent Output:");
  console.log(response);
}

main().catch(console.error);

#!/usr/bin/env python3
# orchestrator_agent.py

from anthropic_agent import ClaudeAgent, ClaudeAgentOptions
import asyncio
import json

# Parent agent: compone il task
def parent_agent():
  agent = ClaudeAgent(
    options=ClaudeAgentOptions(
      model="claude-opus-4-20250514",
      system_prompt="Sei il coordinatore di un team di agenti specializzati."
    )
  )
  return agent

# Tre subagenti specializzati
def code_review_agent():
  return ClaudeAgent(
    options=ClaudeAgentOptions(
      model="claude-sonnet-4-20250514",
      system_prompt="Sei esperto di code review. Analizza il codice per bug, security, performance.",
      max_tokens=4000
    )
  )

def test_generation_agent():
  return ClaudeAgent(
    options=ClaudeAgentOptions(
      model="claude-sonnet-4-20250514",
      system_prompt="Sei esperto di testing. Genera test JUnit5 con coverage 80%+.",
      max_tokens=4000
    )
  )

def documentation_agent():
  return ClaudeAgent(
    options=ClaudeAgentOptions(
      model="claude-sonnet-4-20250514",
      system_prompt="Sei esperto di documentazione tecnica. Produci README, Javadoc, API doc.",
      max_tokens=4000
    )
  )

# Orchestrazione: parent spawna 3 subagenti in parallelo
async def orchestrate_workflow(java_code: str) -> dict:
  """
  Parent decompone il task:
  1. Subagente 1: Code review del codice
  2. Subagente 2: Generazione test
  3. Subagente 3: Documentazione

  Esegui in parallelo, raccogli risultati.
  """

  # Create subagents
  reviewer = code_review_agent()
  tester = test_generation_agent()
  documenter = documentation_agent()

  # Task paralleli
  review_task = reviewer.run(f"Esamina questo codice Java:\n{java_code[:1000]}...")
  test_task = tester.run(f"Genera test per:\n{java_code[:1000]}...")
  doc_task = documenter.run(f"Documenta:\n{java_code[:1000]}...")

  # Attendi completamento di tutti i task
  results = await asyncio.gather(
    asyncio.create_task(review_task),
    asyncio.create_task(test_task),
    asyncio.create_task(doc_task)
  )

  return {
    "code_review": results[0],
    "tests_generated": results[1],
    "documentation": results[2]
  }

# Aggregazione: parent agent legge i risultati e produce summary
def aggregate_results(subagent_results: dict):
  parent = parent_agent()

  summary_prompt = f"""
  I seguenti subagenti hanno analizzato una classe Java:

  CODE REVIEW:
  {subagent_results['code_review']}

  TEST GENERATED:
  {subagent_results['tests_generated']}

  DOCUMENTATION:
  {subagent_results['documentation']}

  Produci un report esecutivo consolidato con:
  1. Severità complessiva degli issue
  2. Copertura test stimata
  3. Completezza documentazione
  4. Action items prioritizzati
  """

  return parent.run(summary_prompt)

# Main: esegui workflow
async def main():
  # Simula lettura codice
  java_code = """
  @Service
  public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User findById(Long id) {
      return userRepository.findById(id).orElse(null);
    }

    public User save(UserRequest request) {
      User user = new User();
      user.setName(request.getName());
      user.setEmail(request.getEmail());
      return userRepository.save(user);
    }
  }
  """

  print("=== Orchestrating Multi-Agent Workflow ===\n")

  # Esegui workflow parallelo
  results = await orchestrate_workflow(java_code)

  print("Subagent Results:")
  print(json.dumps(results, indent=2))

  # Aggregazione finale
  print("\n=== Final Report ===")
  final_report = aggregate_results(results)
  print(final_report)

if __name__ == "__main__":
  asyncio.run(main())

# managed-agent-config.yaml
name: "github-pr-generator"
description: "Agente che monitora repo GitHub e genera PR automatiche"

agent:
  model: "claude-opus-4-20250514"
  system_prompt: |
    Sei un agente GitHub PR bot.
    Il tuo compito è monitorare repository per issue aperte,
    e generare PR che risolvono gli issue.

    Quando vedi un issue:
    1. Leggi il description completa
    2. Clona il repo localmente (tool: bash)
    3. Crea un branch per la soluzione
    4. Implementa fix
    5. Genera il PR con description dettagliata
  max_tokens: 8000

environment:
  container:
    image: "ubuntu:24.04"
    resources:
      cpu: "1000m"
      memory: "2Gi"
    env:
      GITHUB_TOKEN: "${SECRETS.GITHUB_TOKEN}"
      GITHUB_REPO: "myorg/myrepo"

  tools:
    enabled:
      - bash          # Esegui comandi Linux
      - file_ops      # Read/write file
      - web_fetch     # HTTP requests
      - git_cli       # Git commands

    webhooks:
      - event: "issues.opened"
        url: "/webhook/github-issue"
        auth: "bearer-token"

sessions:
  max_active: 10
  timeout: 3600
  memory:
    enabled: true
    retention_days: 30

@RestController
@RequestMapping("/api/v1/webhook")
@RequiredArgsConstructor
public class WebhookController {

  private final ManagedAgentClient agentClient;
  private final AuditService auditService;

  @PostMapping("/github/issue")
  public ResponseEntity<?> handleGitHubIssue(@RequestBody GitHubIssueEvent event) {
    // 1. Valida signature GitHub
    if (!isValidGitHubSignature(event)) {
      return ResponseEntity.status(401).build();
    }

    // 2. Spawna sessione Managed Agent
    String agentSessionId = agentClient.createSession("github-pr-generator");

    // 3. Invia messaggio all'agente
    String prompt = String.format("""
      Nuovo issue aperto su GitHub:
      Repo: %s
      Issue #%d: %s
      Description: %s
      URL: %s

      Analizza e genera una PR che risolva l'issue.
      Usa il webhook callback per notificarmi del completamento.
      """,
      event.getRepository(),
      event.getIssueNumber(),
      event.getTitle(),
      event.getDescription(),
      event.getUrl()
    );

    agentClient.sendMessage(agentSessionId, prompt);

    // 4. Log audit
    auditService.log(AuditEvent.builder()
      .type("AGENT_SPAWNED")
      .agentSessionId(agentSessionId)
      .payload(event)
      .build()
    );

    return ResponseEntity.accepted().build();
  }

  @PostMapping("/agent/complete")
  public ResponseEntity<?> handleAgentComplete(@RequestBody AgentCompleteEvent event) {
    // Callback: l'agente ha completato il task
    String prUrl = event.getPullRequestUrl();

    // Notifica l'utente via email/Slack
    notificationService.notifyPRCreated(prUrl);

    return ResponseEntity.ok().build();
  }

  private boolean isValidGitHubSignature(GitHubIssueEvent event) {
    // Verifica HMAC signature da GitHub
    return true; // implement properly
  }
}

# macOS con Homebrew
brew tap anthropics/ant
brew install ant

# Linux / WSL
curl -fsSL https://cli.anthropic.com/install.sh | sh

# Verifica installazione
ant --version

# Primo avvio: setup API key
ant config set api-key $ANTHROPIC_API_KEY

name: Agent Code Review with ant

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  agent-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Install ant CLI
        run: |
          curl -fsSL https://cli.anthropic.com/install.sh | sh
          ant --version

      - name: Get PR diff
        id: diff
        run: |
          git fetch origin main
          git diff origin/main...HEAD > /tmp/pr.diff
          echo "diff_size=$(wc -c < /tmp/pr.diff)" >> $GITHUB_OUTPUT

      - name: Send to Agent for Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          PROMPT="Esamina il seguente diff e fornisci una code review:

          \$(cat /tmp/pr.diff)

          Output JSON con:
          - severity: critical/major/minor
          - file
          - line
          - issue
          - suggestion"

          ant messages create \
            --model claude-opus-4-20250514 \
            --message "\$PROMPT" \
            --format json > /tmp/review.json

      - name: Post Review Comment
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = JSON.parse(fs.readFileSync('/tmp/review.json', 'utf8'));

            const comment = \`## Agent Code Review

            \${review.content}
            \`;

            github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: comment
            });

# tutoring-agent-memory.yaml
name: "java-tutoring-agent"
description: "Tutore privato per Java & Spring Boot con memoria"

agent:
  model: "claude-opus-4-20250514"
  system_prompt: |
    Sei un tutore privato di Java e Spring Boot.
    Adatta lo stile di insegnamento al livello dello studente.

    Usa la memoria per ricordare:
    - Topics già insegnati e compresi
    - Aree di difficoltà
    - Preferenze didattiche (esempi vs teoria)
    - Progetti precedenti discussi

memory:
  enabled: true
  schema:
    student_level: "beginner|intermediate|advanced"
    topics_covered: ["string", "oop", "spring-boot"]
    difficult_areas: ["generics", "streams"]
    learning_style: "visual|textual|hands-on"
    projects: [{name, date, skills_practiced}]
    recent_questions: [{topic, answer}]

  management:
    auto_update: true
    retention_days: 365
    review_frequency: "per_session"

sessions:
  max_active: 1
  timeout: 1800

---

# Esempio: usare l'agente con memoria
POST /api/v1/agent/tutoring/sessions
Request:
{
  "user_id": "student123",
  "message": "Come creo un REST API in Spring Boot?",
  "memory_context": {
    "student_level": "beginner",
    "topics_covered": ["variables", "classes", "inheritance"],
    "difficult_areas": ["annotations"],
    "learning_style": "hands-on"
  }
}

Response:
{
  "session_id": "sess_abc123",
  "response": "Facciamo un esempio pratico...",
  "memory_update": {
    "topics_covered": [..., "rest-api", "spring-annotations"],
    "recent_questions": [
      {"topic": "REST API Spring Boot", "answer": "[summary]"}
    ]
  }
}