plugins.md +0 −527 deleted
File Deleted View Diff
1> ## Documentation Index
2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
3> Use this file to discover all available pages before exploring further.
4
5# Creare plugin
6
7> Crea plugin personalizzati per estendere Claude Code con skills, agents, hooks e MCP servers.
8
9I plugin ti permettono di estendere Claude Code con funzionalità personalizzate che possono essere condivise tra progetti e team. Questa guida copre la creazione dei tuoi plugin con skills, agents, hooks e MCP servers.
10
11Stai cercando di installare plugin esistenti? Vedi [Scopri e installa plugin](/docs/it/discover-plugins). Per le specifiche tecniche complete, vedi [Riferimento plugin](/docs/it/plugins-reference).
12
13<h2 id="when-to-use-plugins-vs-standalone-configuration">
14 Quando usare plugin rispetto alla configurazione standalone
15</h2>
16
17Claude Code supporta due modi per aggiungere skills, agents e hooks personalizzati:
18
19| Approccio | Nomi skill | Migliore per |
20| :------------------------------------------------------------------------------------------ | :------------------- | :-------------------------------------------------------------------------------------------------------- |
21| **Standalone** (directory `.claude/`) | `/hello` | Flussi di lavoro personali, personalizzazioni specifiche del progetto, esperimenti rapidi |
22| **Plugin** (directory con skills, agents, hooks o un manifest `.claude-plugin/plugin.json`) | `/plugin-name:hello` | Condivisione con i colleghi, distribuzione alla comunità, rilasci versionati, riutilizzabili tra progetti |
23
24<Tip>
25 Inizia con la configurazione standalone in `.claude/` per un'iterazione rapida, poi [converti in un plugin](#convert-existing-configurations-to-plugins) quando sei pronto a condividere.
26</Tip>
27
28<h2 id="quickstart">
29 Quickstart
30</h2>
31
32Questo quickstart ti guida attraverso la creazione di un plugin con uno skill personalizzato. Creerai un manifest (il file di configurazione che definisce il tuo plugin), aggiungerai uno skill e lo testerai localmente usando il flag `--plugin-dir`.
33
34<h3 id="prerequisites">
35 Prerequisiti
36</h3>
37
38* Claude Code [installato e autenticato](/docs/it/quickstart#step-1-install-claude-code)
39
40<h3 id="create-your-first-plugin">
41 Crea il tuo primo plugin
42</h3>
43
44<Steps>
45 <Step title="Crea la directory del plugin">
46 Ogni plugin vive nella sua directory contenente i tuoi skill, agent o hook, facoltativamente insieme a un manifest `.claude-plugin/plugin.json`. La posizione non importa per questo quickstart perché punterai Claude Code alla directory con `--plugin-dir` nel passaggio di test. Crealo ovunque sia conveniente, ad esempio in una cartella scratch o in una directory di progetti:
47
48 ```bash theme={null}
49 mkdir my-first-plugin
50 ```
51
52 I passaggi rimanenti vengono eseguiti dalla directory padre e fanno riferimento a percorsi come `my-first-plugin/...` relativi ad essa.
53 </Step>
54
55 <Step title="Crea il manifest del plugin">
56 Il file manifest in `.claude-plugin/plugin.json` definisce l'identità del tuo plugin: il suo nome, descrizione e versione. Claude Code usa questi metadati per visualizzare il tuo plugin nel plugin manager.
57
58 Crea la directory `.claude-plugin` dentro la cartella del tuo plugin:
59
60 ```bash theme={null}
61 mkdir my-first-plugin/.claude-plugin
62 ```
63
64 Poi crea `my-first-plugin/.claude-plugin/plugin.json` con questo contenuto:
65
66 ```json my-first-plugin/.claude-plugin/plugin.json theme={null}
67 {
68 "name": "my-first-plugin",
69 "description": "A greeting plugin to learn the basics",
70 "version": "1.0.0",
71 "author": {
72 "name": "Your Name"
73 }
74 }
75 ```
76
77 | Campo | Scopo |
78 | :------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
79 | `name` | Identificatore univoco e namespace dello skill. Gli skill sono prefissati con questo (ad es., `/my-first-plugin:hello`). |
80 | `description` | Mostrato nel plugin manager quando si sfogliano o si installano plugin. |
81 | `version` | Opzionale. Se impostato, gli utenti ricevono aggiornamenti solo quando aumenti questo campo, eccetto per una [`command` source](/docs/it/plugin-marketplaces#command-sources) o un plugin [caricato in place](/docs/it/plugins-reference#plugin-caching-and-file-resolution); vedi [gestione della versione](/docs/it/plugins-reference#version-management). Se omesso, la versione proviene dalla prossima source in [gestione della versione](/docs/it/plugins-reference#version-management). |
82 | `author` | Opzionale. Utile per l'attribuzione. |
83
84 Per campi aggiuntivi come `homepage`, `repository` e `license`, vedi lo [schema manifest completo](/docs/it/plugins-reference#plugin-manifest-schema).
85 </Step>
86
87 <Step title="Aggiungi uno skill">
88 Gli skill vivono nella directory `skills/`. Ogni skill è una cartella contenente un file `SKILL.md`. Il nome della cartella diventa il nome dello skill, prefissato con il namespace del plugin (`hello/` in un plugin denominato `my-first-plugin` crea `/my-first-plugin:hello`).
89
90 Crea una directory skill nella cartella del tuo plugin:
91
92 ```bash theme={null}
93 mkdir -p my-first-plugin/skills/hello
94 ```
95
96 Poi crea `my-first-plugin/skills/hello/SKILL.md` con questo contenuto:
97
98 ```markdown my-first-plugin/skills/hello/SKILL.md theme={null}
99 ---
100 description: Greet the user with a friendly message
101 disable-model-invocation: true
102 ---
103
104 Greet the user warmly and ask how you can help them today.
105 ```
106 </Step>
107
108 <Step title="Testa il tuo plugin">
109 Esegui Claude Code con il flag `--plugin-dir` per caricare il tuo plugin:
110
111 ```bash theme={null}
112 claude --plugin-dir ./my-first-plugin
113 ```
114
115 Una volta che Claude Code si avvia, prova il tuo nuovo skill:
116
117 ```shell theme={null}
118 /my-first-plugin:hello
119 ```
120
121 Vedrai Claude rispondere con un saluto. Esegui `/help` e apri la scheda **Custom commands** per vedere il tuo skill elencato sotto il namespace del plugin.
122
123 <Note>
124 **Perché il namespace?** Gli skill del plugin hanno sempre il namespace (come `/my-first-plugin:hello`) per prevenire conflitti quando più plugin hanno skill con lo stesso nome.
125
126 Per cambiare il prefisso del namespace, aggiorna il campo `name` in `plugin.json`.
127 </Note>
128 </Step>
129
130 <Step title="Aggiungi argomenti dello skill">
131 Rendi il tuo skill dinamico accettando input dell'utente. Il placeholder `$ARGUMENTS` cattura qualsiasi testo che l'utente fornisce dopo il nome dello skill.
132
133 Aggiorna il tuo file `SKILL.md`:
134
135 ```markdown my-first-plugin/skills/hello/SKILL.md theme={null}
136 ---
137 description: Greet the user with a personalized message
138 ---
139
140 # Hello Skill
141
142 Greet the user named "$ARGUMENTS" warmly and ask how you can help them today. Make the greeting personal and encouraging.
143 ```
144
145 Esegui `/reload-plugins` per raccogliere i cambiamenti. Poi prova lo skill con il tuo nome:
146
147 ```shell theme={null}
148 /my-first-plugin:hello Alex
149 ```
150
151 Claude ti saluterà per nome. Per ulteriori informazioni sul passaggio di argomenti agli skill, vedi [Skills](/docs/it/skills#pass-arguments-to-skills).
152 </Step>
153</Steps>
154
155<Tip>
156 Il flag `--plugin-dir` è utile per lo sviluppo e il test. Quando sei pronto a condividere il tuo plugin con altri, vedi [Crea e distribuisci un marketplace di plugin](/docs/it/plugin-marketplaces).
157</Tip>
158
159<h2 id="develop-a-plugin-in-your-skills-directory">
160 Sviluppa un plugin nella tua directory skills
161</h2>
162
163Invece di passare `--plugin-dir` ad ogni avvio, puoi mantenere un plugin nella tua directory skills e fare in modo che Claude Code lo carichi automaticamente. `claude plugin init` ne crea uno:
164
165```bash theme={null}
166claude plugin init my-tool
167```
168
169Questo crea `~/.claude/skills/my-tool/` con un manifest `.claude-plugin/plugin.json` e uno starter `SKILL.md`. Nella sessione successiva si carica come `my-tool@skills-dir` senza alcun passaggio di marketplace o installazione.
170
171Per le regole di caricamento automatico, l'ambito personale rispetto a quello del progetto, il requisito di fiducia dell'area di lavoro e come aggiornare o rimuoverne uno, vedi [Plugin della directory skills](/docs/it/plugins-reference#skills-directory-plugins).
172
173<h2 id="plugin-structure-overview">
174 Panoramica della struttura del plugin
175</h2>
176
177Hai creato un plugin con uno skill, ma i plugin possono includere molto di più: agents personalizzati, hooks, MCP servers, LSP servers e monitor in background.
178
179<Warning>
180 **Errore comune**: Non mettere `commands/`, `agents/`, `skills/` o `hooks/` dentro la directory `.claude-plugin/`. Solo `plugin.json` va dentro `.claude-plugin/`. Tutte le altre directory devono essere al livello radice del plugin.
181
182 La radice del plugin è la directory del singolo plugin, come `my-first-plugin/` dalla [guida rapida](#quickstart). Non è mai `~/.claude/`. Ad esempio, Claude Code non legge un `.mcp.json` posizionato in `~/.claude/.mcp.json`.
183</Warning>
184
185| Directory | Posizione | Scopo |
186| :---------------- | :---------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
187| `.claude-plugin/` | Radice del plugin | Contiene il manifest `plugin.json` (opzionale se i componenti usano posizioni predefinite) |
188| `skills/` | Radice del plugin | Skills come directory `<name>/SKILL.md` |
189| `commands/` | Radice del plugin | Skills come file Markdown flat. Usa `skills/` per i nuovi plugin |
190| `agents/` | Radice del plugin | Definizioni di agent personalizzati |
191| `hooks/` | Radice del plugin | Gestori di eventi in `hooks.json` |
192| `.mcp.json` | Radice del plugin | Configurazioni del server MCP |
193| `.lsp.json` | Radice del plugin | Configurazioni del server LSP per l'intelligenza del codice |
194| `monitors/` | Radice del plugin | Configurazioni del monitor in background in `monitors.json` |
195| `bin/` | Radice del plugin | Eseguibili aggiunti al `PATH` dello strumento Bash mentre il plugin è abilitato. Non puoi includere questa directory in un plugin che [distribuisci tramite le impostazioni dell'organizzazione claude.ai](/docs/it/plugin-marketplaces#keep-executables-out-of-the-top-level-bin-directory) |
196| `settings.json` | Radice del plugin | [Impostazioni](/docs/it/settings) predefinite applicate quando il plugin è abilitato |
197
198Un plugin che fornisce esattamente uno skill può posizionare `SKILL.md` direttamente alla radice del plugin invece di creare una directory `skills/`. Claude Code lo carica come uno skill singolo e utilizza il campo `name` del frontmatter per il nome di invocazione. Usa il layout `skills/` per i plugin che potrebbero crescere fino a più di uno skill.
199
200<h2 id="develop-more-complex-plugins">
201 Sviluppa plugin più complessi
202</h2>
203
204Una volta che hai familiarità con i plugin di base, puoi creare estensioni più sofisticate.
205
206<h3 id="add-skills-to-your-plugin">
207 Aggiungi Skills al tuo plugin
208</h3>
209
210I plugin possono includere [Agent Skills](/docs/it/skills) per estendere le capacità di Claude. Gli skill sono invocati dal modello: Claude li usa automaticamente in base al contesto dell'attività.
211
212Aggiungi una directory `skills/` alla radice del tuo plugin con cartelle Skill contenenti file `SKILL.md`:
213
214```text theme={null}
215my-plugin/
216├── .claude-plugin/
217│ └── plugin.json
218└── skills/
219 └── code-review/
220 └── SKILL.md
221```
222
223Ogni `SKILL.md` contiene frontmatter YAML e istruzioni. Includi una `description` in modo che Claude sappia quando usare lo skill:
224
225```yaml theme={null}
226description: Reviews code for best practices and potential issues. Use when reviewing code, checking PRs, or analyzing code quality.
227
228When reviewing code, check for:
2291. Code organization and structure
2302. Error handling
2313. Security concerns
2324. Test coverage
233```
234
235Dopo aver installato il plugin, controlla il riepilogo dell'installazione: se segnala `Run /reload-plugins to activate.`, vedi [Applica le modifiche del plugin senza riavviare](/docs/it/discover-plugins#apply-plugin-changes-without-restarting) per caricare gli Skills nella tua sessione corrente. Per una guida completa sulla creazione di Skill inclusa la divulgazione progressiva e le restrizioni degli strumenti, vedi [Agent Skills](/docs/it/skills).
236
237<h3 id="add-lsp-servers-to-your-plugin">
238 Aggiungi server LSP al tuo plugin
239</h3>
240
241<Tip>
242 Per linguaggi comuni come TypeScript, Python e Rust, installa i plugin LSP pre-costruiti dal marketplace ufficiale. Crea plugin LSP personalizzati solo quando hai bisogno di supporto per linguaggi non ancora coperti.
243</Tip>
244
245I plugin LSP (Language Server Protocol) danno a Claude l'intelligenza del codice in tempo reale. Se hai bisogno di supportare un linguaggio che non ha un plugin LSP ufficiale, puoi crearne uno tuo aggiungendo un file `.lsp.json` al tuo plugin:
246
247```json .lsp.json theme={null}
248{
249 "go": {
250 "command": "gopls",
251 "args": ["serve"],
252 "extensionToLanguage": {
253 ".go": "go"
254 }
255 }
256}
257```
258
259Gli utenti che installano il tuo plugin devono avere il binario del language server installato sulla loro macchina.
260
261Per confermare che il server si avvia, avvia Claude Code con il plugin abilitato e controlla la scheda `/plugin` Errors: un language server che non riesce ad avviarsi appare lì, ad esempio con `Executable not found in $PATH` quando il binario non è installato. Una voce con una configurazione non valida viene saltata; esegui `claude --debug` per vedere il motivo.
262
263Per le opzioni di configurazione LSP complete, vedi [LSP servers](/docs/it/plugins-reference#lsp-servers).
264
265<h3 id="add-background-monitors-to-your-plugin">
266 Aggiungi monitor in background al tuo plugin
267</h3>
268
269I monitor in background permettono al tuo plugin di osservare log, file o stato esterno in background e notificare Claude quando gli eventi arrivano. Claude Code avvia automaticamente ogni monitor quando il plugin è attivo, quindi non hai bisogno di istruire Claude ad avviare la sorveglianza.
270
271Aggiungi un file `monitors/monitors.json` alla radice del plugin con un array di voci di monitor:
272
273```json monitors/monitors.json theme={null}
274[
275 {
276 "name": "error-log",
277 "command": "tail -F ./logs/error.log",
278 "description": "Application error log"
279 }
280]
281```
282
283Ogni riga stdout da `command` viene consegnata a Claude come notifica durante la sessione. Per lo schema completo, incluso il trigger `when` e la sostituzione delle variabili, vedi [Monitors](/docs/it/plugins-reference#monitors).
284
285<h3 id="ship-default-settings-with-your-plugin">
286 Spedisci impostazioni predefinite con il tuo plugin
287</h3>
288
289I plugin possono includere un file `settings.json` alla radice del plugin per applicare la configurazione predefinita quando il plugin è abilitato. Attualmente, sono supportate solo le chiavi `agent` e `subagentStatusLine`.
290
291Impostare `agent` attiva uno dei [custom agents](/docs/it/sub-agents) del plugin come thread principale, applicando il suo system prompt, le restrizioni degli strumenti e il modello. Questo consente a un plugin di cambiare il comportamento predefinito di Claude Code quando abilitato.
292
293```json settings.json theme={null}
294{
295 "agent": "security-reviewer"
296}
297```
298
299Questo esempio attiva l'agent `security-reviewer` definito nella directory `agents/` del plugin. Le impostazioni da `settings.json` hanno priorità rispetto alle `settings` dichiarate in `plugin.json`. Le chiavi sconosciute vengono silenziosamente ignorate.
300
301<h3 id="organize-complex-plugins">
302 Organizza plugin complessi
303</h3>
304
305Per i plugin con molti componenti, organizza la tua struttura di directory per funzionalità. Per i layout di directory completi e i modelli di organizzazione, vedi [Struttura della directory del plugin](/docs/it/plugins-reference#plugin-directory-structure).
306
307<h3 id="test-your-plugins-locally">
308 Testa i tuoi plugin localmente
309</h3>
310
311Usa il flag `--plugin-dir` per testare i plugin durante lo sviluppo. Questo carica il tuo plugin direttamente senza richiedere l'installazione.
312
313```bash theme={null}
314claude --plugin-dir ./my-plugin
315```
316
317Il flag accetta anche un archivio `.zip` della directory del plugin.
318
319```bash theme={null}
320claude --plugin-dir ./my-plugin.zip
321```
322
323Quando un plugin `--plugin-dir` ha lo stesso nome di un plugin marketplace installato, la copia locale ha la precedenza per quella sessione. Questo ti consente di testare le modifiche a un plugin che hai già installato senza disinstallarlo prima. L'eccezione è rappresentata dai plugin le cui impostazioni gestite forzano l'abilitazione o la disabilitazione: `--plugin-dir` non può sovrascrivere quelli.
324
325Man mano che apporti modifiche al tuo plugin, esegui `/reload-plugins` per raccogliere gli aggiornamenti senza riavviare. Questo ricarica plugin, skill, agent, hook, server MCP del plugin e server LSP del plugin; in una sessione senza un terminale interattivo, le modifiche al server MCP del plugin [attendono la tua prossima sessione](/docs/it/discover-plugins#apply-plugin-changes-without-restarting). Testa i componenti del tuo plugin:
326
327* Prova i tuoi skill con `/plugin-name:skill-name`
328* Verifica che gli agents appaiano in `/context` sotto Custom Agents, o @-menziona uno per il suo nome con scope
329* Attiva l'evento che ogni hook corrisponde, ad esempio chiedendo a Claude di modificare un file per un hook `PostToolUse`, e conferma il suo effetto. Claude Code registra quali hook corrispondono, i loro codici di uscita e il loro output nel [debug log](/docs/it/hooks#debug-hooks)
330
331<Tip>
332 Puoi caricare più plugin contemporaneamente specificando il flag più volte:
333
334 ```bash theme={null}
335 claude --plugin-dir ./plugin-one --plugin-dir ./plugin-two
336 ```
337
338 Per testare un plugin insieme a un plugin da cui dipende, vedi [Testa un plugin e la sua dipendenza localmente](/docs/it/plugin-dependencies#test-a-plugin-and-its-dependency-locally).
339</Tip>
340
341Per caricare plugin in una sessione in cui non puoi aggiungere il flag, elenca i loro percorsi assoluti nella variabile di ambiente [`CLAUDE_CODE_PLUGIN_DIRS`](/docs/it/env-vars#variables). Claude Code carica ogni percorso come carica un percorso `--plugin-dir`. Questi plugin si caricano in aggiunta a quelli che passi con `--plugin-dir`. [Le impostazioni di progetto e locali non possono impostare questa variabile](/docs/it/settings-reference#variables-claude-code-ignores-in-env). `CLAUDE_CODE_PLUGIN_DIRS` richiede Claude Code v2.1.280 o successivo.
342
343Provare il plugin con `--plugin-dir` ti dice che può funzionare. Per scoprire quanto spesso Claude effettivamente lo raggiunge e ottiene il risultato giusto, eseguilo su un set di prompt di test con [`claude plugin eval`](/docs/it/plugin-evals). Ogni prompt viene eseguito più volte con e senza il plugin caricato, quindi puoi vedere cosa contribuisce il plugin e catturare regressioni quando lo modifichi o una nuova versione del modello viene rilasciata.
344
345Per caricare diversi plugin da un unico posto, passa una cartella che li contiene, ad esempio `--plugin-dir ./plugins`. Il caricamento di una cartella di plugin richiede Claude Code v2.1.265 o successivo. Claude Code legge il livello superiore della cartella per decidere quali plugin caricare, e in una sessione interattiva osserva anche la cartella per i cambiamenti successivi:
346
347* **Cosa si carica**: se la cartella non ha un manifest o componenti di plugin al suo livello superiore, Claude Code la tratta come una cartella di plugin. Ogni sottocartella immediata che ha un manifest `.claude-plugin/plugin.json` si carica come un plugin separato. Claude Code salta tutto il resto nella cartella senza segnalare un errore, inclusi i plugin che non hanno un manifest.
348* **Cambiamenti durante una sessione interattiva**: una sottocartella che aggiungi si carica come un nuovo plugin una volta che il suo manifest è in posizione, e quando rimuovi una sottocartella, il suo plugin si scarica. Claude Code stampa una riga nella sessione per ogni cambiamento. Se l'applicazione di un cambiamento a metà conversazione [invaliderebbe la cache del prompt](/docs/it/prompt-caching#enabling-or-disabling-a-plugin), Claude Code la trattiene, e la riga dice di eseguire `/reload-plugins` per applicarla.
349
350Per testare un plugin che è già stato confezionato come archivio `.zip` e ospitato su un URL, come un artefatto di build CI, usa `--plugin-url` invece. Claude Code recupera l'archivio all'avvio e lo carica solo per quella sessione. Se Claude Code non riesce a recuperare l'archivio, o l'archivio non è valido, si avvia senza il plugin e registra un errore di caricamento del plugin che puoi rivedere nella scheda **Errors** del gestore `/plugin`. Le stesse [considerazioni sulla fiducia](/docs/it/discover-plugins#security) si applicano come per qualsiasi fonte di plugin: punta questo flag solo ad archivi che controlli o di cui ti fidi.
351
352Per caricare più plugin, ripeti il flag per ogni URL:
353
354```bash theme={null}
355claude --plugin-url https://example.com/my-plugin.zip --plugin-url https://example.com/other.zip
356```
357
358Oppure passa URL separati da spazi come un singolo argomento tra virgolette:
359
360```bash theme={null}
361claude --plugin-url "https://example.com/my-plugin.zip https://example.com/other.zip"
362```
363
364<h3 id="debug-plugin-issues">
365 Esegui il debug dei problemi del plugin
366</h3>
367
368Se il tuo plugin non funziona come previsto:
369
3701. **Controlla la struttura**: Assicurati che le tue directory siano alla radice del plugin, non dentro `.claude-plugin/`
3712. **Testa i componenti individualmente**: Controlla ogni skill, agent e hook separatamente
3723. **Usa strumenti di validazione e debug**: Vedi [Strumenti di debug e sviluppo](/docs/it/plugins-reference#debugging-and-development-tools) per i comandi CLI e le tecniche di troubleshooting
373
374<h3 id="share-your-plugins">
375 Condividi i tuoi plugin
376</h3>
377
378Quando il tuo plugin è pronto per essere condiviso:
379
3801. **Aggiungi documentazione**: Includi un `README.md` con istruzioni di installazione e utilizzo
3812. **Scegli una strategia di versionamento**: Decidi se impostare una `version` esplicita o affidarti al fallback descritto in [gestione della versione](/docs/it/plugins-reference#version-management).
3823. **Crea o usa un marketplace**: Distribuisci tramite [marketplace di plugin](/docs/it/plugin-marketplaces) per l'installazione
3834. **Testa con altri**: Fai testare il plugin ai colleghi del team prima di una distribuzione più ampia
384
385Una volta che il tuo plugin è in un marketplace, altri possono installarlo usando le istruzioni in [Scopri e installa plugin](/docs/it/discover-plugins). Per mantenere un plugin interno al tuo team, ospita il marketplace in un [repository privato](/docs/it/plugin-marketplaces#private-repositories).
386
387<h3 id="submit-your-plugin-to-the-community-marketplace">
388 Invia il tuo plugin al marketplace della comunità
389</h3>
390
391Anthropic mantiene due marketplace pubblici per i plugin di Claude Code:
392
393* **`claude-plugins-official`**: un insieme curato di plugin mantenuti da Anthropic. Claude Code lo registra automaticamente la prima volta che avvii Claude Code in modo interattivo. Se esegui Claude Code in modo non interattivo prima di quel primo avvio interattivo, o una [politica del marketplace](/docs/it/plugin-marketplaces#managed-marketplace-restrictions) ha bloccato un tentativo precedente, registralo tu stesso con `claude plugin marketplace add anthropics/claude-plugins-official`.
394* **`claude-community`**: il marketplace pubblico della comunità dove gli invii di terze parti arrivano dopo la revisione. Gli utenti lo aggiungono con `/plugin marketplace add anthropics/claude-plugins-community` e lo installano come `@claude-community`.
395
396Per inviare il tuo plugin per la revisione del marketplace della comunità, usa uno dei moduli in-app:
397
398* **claude.ai**: [claude.ai/admin-settings/directory/submissions/plugins/new](https://claude.ai/admin-settings/directory/submissions/plugins/new)
399* **Console**: [platform.claude.com/plugins/submit](https://platform.claude.com/plugins/submit)
400
401Il modulo claude.ai richiede un'organizzazione Team o Enterprise e accesso alla gestione della directory; i proprietari dell'organizzazione hanno questo accesso per impostazione predefinita. Gli autori individuali che non fanno parte di un'organizzazione Team o Enterprise possono utilizzare il modulo Console.
402
403Esegui `claude plugin validate ./your-plugin` localmente prima di inviare, sostituendo `./your-plugin` con il percorso della tua directory di plugin. La pipeline di revisione esegue lo stesso controllo su ogni invio, insieme a uno screening di sicurezza automatizzato. Quando la validazione passa, Claude Code stampa `✔ Validation passed`, o `✔ Validation passed with warnings` se ci sono avvisi. Gli avvisi non causano il fallimento della validazione; aggiungi `--strict` per trattarli come errori.
404
405I plugin approvati sono fissati a uno specifico commit SHA nel catalogo [`anthropics/claude-plugins-community`](https://github.com/anthropics/claude-plugins-community), e CI aumenta automaticamente il pin mentre esegui il push di nuovi commit nel tuo repository. Il catalogo pubblico si sincronizza ogni notte dalla pipeline di revisione, quindi può esserci un ritardo tra l'approvazione e la comparsa del tuo plugin in `marketplace.json`. Per verificare se il tuo plugin è già installabile, cerca il suo nome nel [catalogo della comunità](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json).
406
407Il marketplace ufficiale, `claude-plugins-official`, è curato separatamente. Anthropic decide quali plugin includere a sua discrezione. Non c'è un processo di candidatura e il modulo di invio non aggiunge plugin al marketplace ufficiale.
408
409Se Anthropic elenca il tuo plugin nel marketplace ufficiale, il tuo CLI può invitare gli utenti di Claude Code a installarlo. Vedi [Consiglia il tuo plugin dal tuo CLI](/docs/it/plugin-hints).
410
411<h2 id="convert-existing-configurations-to-plugins">
412 Converti configurazioni esistenti in plugin
413</h2>
414
415Se hai già skill o hooks nella tua directory `.claude/`, puoi convertirli in un plugin per una condivisione e distribuzione più facile.
416
417<h3 id="migration-steps">
418 Passaggi di migrazione
419</h3>
420
421<Steps>
422 <Step title="Crea la struttura del plugin">
423 Crea una nuova directory plugin nella radice del tuo progetto, accanto alla cartella `.claude/` esistente, in modo che i percorsi relativi `cp` nel passaggio successivo si risolvano:
424
425 ```bash theme={null}
426 mkdir -p my-plugin/.claude-plugin
427 ```
428
429 Crea il file manifest in `my-plugin/.claude-plugin/plugin.json`:
430
431 ```json my-plugin/.claude-plugin/plugin.json theme={null}
432 {
433 "name": "my-plugin",
434 "description": "Migrated from standalone configuration",
435 "version": "1.0.0"
436 }
437 ```
438 </Step>
439
440 <Step title="Copia i tuoi file esistenti">
441 Copia ogni directory di configurazione che hai nella radice del plugin. Potresti non avere tutti e tre: se una directory non esiste, `cp` stampa `No such file or directory` e non copia nulla, quindi salta quel comando o ignora l'errore.
442
443 ```bash theme={null}
444 cp -r .claude/commands my-plugin/
445
446 cp -r .claude/agents my-plugin/
447
448 cp -r .claude/skills my-plugin/
449 ```
450
451 Il tuo plugin ora contiene copie delle directory che avevi sotto `.claude/`. Esegui `ls my-plugin` per confermare: dovresti vedere ogni directory che hai copiato.
452 </Step>
453
454 <Step title="Migra gli hook">
455 Se hai hook nelle tue impostazioni, crea una directory hooks:
456
457 ```bash theme={null}
458 mkdir my-plugin/hooks
459 ```
460
461 Crea `my-plugin/hooks/hooks.json` con la tua configurazione degli hook. Copia l'oggetto `hooks` dal tuo `.claude/settings.json` o `settings.local.json`, poiché il formato è lo stesso. Il comando riceve l'input dell'hook come JSON su stdin, quindi usa `jq` per estrarre il percorso del file:
462
463 ```json my-plugin/hooks/hooks.json theme={null}
464 {
465 "hooks": {
466 "PostToolUse": [
467 {
468 "matcher": "Write|Edit",
469 "hooks": [{ "type": "command", "command": "jq -r '.tool_input.file_path' | xargs npm run lint:fix" }]
470 }
471 ]
472 }
473 }
474 ```
475 </Step>
476
477 <Step title="Testa il tuo plugin migrato">
478 Carica il tuo plugin per verificare che tutto funzioni:
479
480 ```bash theme={null}
481 claude --plugin-dir ./my-plugin
482 ```
483
484 Testa ogni componente: esegui i tuoi comandi, verifica che gli agents appaiano in `/context`, e attiva l'evento che ogni hook corrisponde per confermare il suo effetto. Claude Code registra quali hook sono stati attivati e come sono usciti nel [debug log](/docs/it/hooks#debug-hooks).
485 </Step>
486</Steps>
487
488<h3 id="what-changes-when-migrating">
489 Cosa cambia durante la migrazione
490</h3>
491
492| Standalone (`.claude/`) | Plugin |
493| :---------------------------------------------- | :--------------------------------------- |
494| Disponibile solo in un progetto | Può essere condiviso tramite marketplace |
495| File in `.claude/commands/` | File in `plugin-name/commands/` |
496| Hook in `settings.json` | Hook in `hooks/hooks.json` |
497| Deve essere copiato manualmente per condividere | Installa con `/plugin install` |
498
499<Note>
500 Dopo la migrazione, rimuovi i file originali da `.claude/` per evitare duplicati. Le definizioni di `.claude/agents/` a livello di progetto e utente sovrascrivono gli agents del plugin con lo stesso nome, quindi la versione del plugin ha effetto solo una volta rimossi gli originali. Le skill del plugin sono spaziate dei nomi come `/plugin-name:skill-name`, quindi sia l'originale `/skill-name` che la copia del plugin rimangono disponibili piuttosto che uno che sovrascrive l'altro.
501</Note>
502
503<h2 id="next-steps">
504 Prossimi passi
505</h2>
506
507Ora che comprendi il sistema di plugin di Claude Code, ecco i percorsi suggeriti per diversi obiettivi:
508
509<h3 id="for-plugin-users">
510 Per gli utenti di plugin
511</h3>
512
513* [Scopri e installa plugin](/docs/it/discover-plugins): sfoglia i marketplace e installa i plugin
514* [Configura marketplace del team](/docs/it/discover-plugins#configure-team-marketplaces): configura plugin a livello di repository per il tuo team
515
516<h3 id="for-plugin-developers">
517 Per gli sviluppatori di plugin
518</h3>
519
520* [Test dei plugin con evals](/docs/it/plugin-evals): misura cosa cambia il tuo plugin e blocca CI su di esso
521* [Crea e distribuisci un marketplace](/docs/it/plugin-marketplaces): pacchetto e condividi i tuoi plugin
522* [Riferimento plugin](/docs/it/plugins-reference): specifiche tecniche complete
523* Approfondisci componenti specifici del plugin:
524 * [Skills](/docs/it/skills): dettagli dello sviluppo dello skill
525 * [Subagents](/docs/it/sub-agents): configurazione e capacità dell'agent
526 * [Hooks](/docs/it/hooks): gestione degli eventi e automazione
527 * [MCP](/docs/it/mcp): integrazione di strumenti esterni