Reagire agli eventi con un mod

on('tool.call', async ($, e, next) => {
  // Viene eseguito prima che lo strumento venga eseguito
  $.ui.log('Claude is about to use ' + e.tool)
  // Passa l'evento invariato
  return next(e)
})

on('tool.call', async ($, e, next) => {
  // Lascia che lo strumento venga eseguito e attendi il suo risultato
  const result = await next(e)
  // Viene eseguito dopo che lo strumento è stato eseguito
  $.ui.log(e.tool + ' finished')
  // Restituisci il risultato invariato
  return result
})

on('prompt.submit', async ($, e, next) => {
  // Passa una copia dell'evento con il suo testo modificato
  return next({ ...e, text: e.text.trim() })
})

on('tool.call', { tool: 'Bash' }, async () => {
  // Nessuna chiamata a next, quindi il comando non viene mai eseguito
  return { deny: 'Bash is turned off in this project. Use the file tools.' }
})

// Una stringa corrisponde a un valore: solo chiamate Bash
on('tool.call', { tool: 'Bash' }, hook)
// Un array corrisponde a qualsiasi valore in esso: chiamate Edit e Write
on('tool.call', { tool: ['Edit', 'Write'] }, hook)
// Un'espressione regolare corrisponde per pattern: ogni strumento di un server MCP
on('tool.call', { tool: /^mcp__github__/ }, hook)

// Il matcher limita l'hook alle chiamate Bash, quindi e.command è il comando della shell
on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
  if (/git push .*--force/.test(e.command)) {
    // Restituire senza chiamare next risponde all'evento, quindi il comando non viene mai eseguito
    return { deny: 'Force pushes are not allowed in this repository. Push to a new branch instead.' }
  }
  // Ogni altro comando va al controllo delle autorizzazioni e poi a Bash
  return next(e)
})

on('tool.call', { tool: ['Edit', 'Write'] }, async ($, e, next) => {
  // Attendi il controllo delle autorizzazioni e lo strumento, e mantieni ciò che hanno prodotto
  const result = await next(e)
  // Una chiamata rifiutata torna come { deny }, e una fallita ha isError impostato
  const changed = !result.deny && !result.isError
  if (changed && e.file_path.endsWith('.mdx')) $.ui.log('Claude changed ' + e.file_path)
  // Restituisci il risultato come è arrivato, quindi Claude legge ciò che lo strumento ha restituito
  return result
})

const RISKY = /\brm\s+-rf?\b|\bgit\s+reset\s+--hard\b|\bgit\s+push\b.*--force/

export function register(on) {
  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
    // Lascia passare ogni altro comando senza una domanda
    if (!RISKY.test(e.command)) return next(e)
    // Inizia dalla risposta sicura, quindi una domanda a cui nessuno risponde rifiuta il comando
    let answer = 'Refuse'
    try {
      // La chiamata dello strumento attende qui fino a quando l'utente sceglie una delle due etichette
      answer = await $.ui.ask('Run this command? ' + e.command, ['Run it', 'Refuse'])
    } catch {
      // L'utente ha chiuso la domanda, o questo è un'esecuzione claude -p senza nessuno a cui chiedere
    }
    if (answer !== 'Run it') {
      // Rispondi senza chiamare next, quindi il comando non viene eseguito
      return { deny: 'The user declined this command. Ask before trying a different approach.' }
    }
    return next(e)
  })
}

on('prompt.submit', async ($, e, next) => {
  // Passa un prompt che non menziona una pull request così com'è
  if (!/\bPR\b|pull request/i.test(e.text)) return next(e)
  const git = await $.process.run(['git', 'branch', '--show-current'])
  // Al di fuori di un repository git il comando fallisce, quindi non c'è ramo da aggiungere
  if (git.exitCode !== 0) return next(e)
  // Mantieni qualsiasi contesto che un hook precedente ha aggiunto e aggiungi un'altra riga per Claude
  return next({ ...e, context: [...(e.context ?? []), 'Current branch: ' + git.stdout.trim()] })
})

// function* rende l'hook un generatore, che può passare la risposta pezzo per pezzo
on('turn.step', async function* ($, e, next) {
  // Invia la richiesta, inoltra ogni pezzo mentre arriva e mantieni il risultato finito
  const result = yield* next(e)
  // Salta un risultato che non riporta conteggi di token
  if (result.usage) {
    $.ui.log('cache read ' + result.usage.cache_read_input_tokens + ' · wrote ' + result.usage.cache_creation_input_tokens)
  }
  // Restituisci il risultato invariato, quindi il turno continua come al solito
  return result
})

on('classic.Stop', async ($, e, next) => {
  // e ha gli stessi campi che un hook Stop in un file di impostazioni legge da stdin
  $.ui.log('Transcript saved at ' + e.transcript_path)
  // Passa l'evento, quindi gli hook Stop nei vostri file di impostazioni vengono comunque eseguiti
  return next(e)
})

// on restituisce una registrazione e .catch allega un gestore a quel singolo hook
on('tool.call', { tool: 'Bash' }, guard).catch(async ($, e, next) => {
  // next.error.kind è 'throw' o 'timeout', che dice come guard ha fallito
  return { deny: 'The command guard failed, so this command was not run: ' + next.error.kind }
})