claude-plugin-wordpress-manager 1.4.0 → 1.7.0

package/docs/plans/2026-02-27-design-system-guide-design.md

@@ -0,0 +1,30 @@
+# Design: Guida WordPress Design System — Da Token a Pixel
+
+**Data:** 2026-02-27
+**Stato:** Approvato
+
+## Obiettivo
+
+Guida concettuale + pratica che unifica le 4 skill UI del plugin (wpds, wp-block-themes, wp-block-development, wp-interactivity-api) sotto il paradigma design-as-data. Colma il gap tra skill operative mostrando la catena completa da design token a pixel renderizzato.
+
+## Posizione
+
+`docs/guides/wp-design-system.md`
+
+## Struttura (8 sezioni)
+
+1. Paradigma Design-as-Data
+2. Strato 1: Design Tokens
+3. Strato 2: theme.json come compilatore
+4. Strato 3: Blocchi Core come componenti UI
+5. Strato 4: Patterns come pagine prefabbricate
+6. Strato 5: Blocchi Custom con WPDS (@wordpress/components)
+7. Strato 6: Interattivita (Interactivity API)
+8. Mappa Skill del Plugin
+
+## Decisioni
+
+- Approccio A (guida unificata) scelto
+- Ogni sezione: concetto + schema ASCII + esempio dal blog Developer Journal
+- Audience: sia utente Claude Code sia sviluppatore WordPress
+- ~700-800 righe stimate

package/docs/plans/2026-02-27-local-dev-tools-assessment.md

@@ -0,0 +1,332 @@
+# Assessment: Integrazione WordPress Studio + LocalWP
+
+**Data**: 2026-02-27
+**Versione plugin**: 1.4.0
+**Stato**: Approccio A approvato — design doc in `2026-02-27-local-env-design.md`
+
+---
+
+## 1. Contesto
+
+Il plugin wordpress-manager v1.4.0 copre sviluppo (13 skill) e operazioni (5 skill + 5 agent + 2 MCP server) su siti WordPress remoti e sandbox effimeri (Playground). Manca un layer per **ambienti locali persistenti** — il gap critico tra "scrivo codice" e "lo testo/deploy".
+
+WordPress Studio (by Automattic) e LocalWP (by WP Engine) sono i due strumenti principali per sviluppo WordPress locale. Questo assessment analizza le superfici di integrazione, i workflow tipici, e propone tre approcci architetturali.
+
+---
+
+## 2. Gap Analysis — Plugin attuale
+
+### Cosa il plugin GIA copre
+
+| Area | Copertura |
+|------|-----------|
+| Sviluppo codice WP | 13 skill (blocchi, temi, plugin, REST, PHPStan, Interactivity API...) |
+| Operazioni siti remoti | 5 skill + 5 agent + 2 MCP server (Hostinger + WP REST Bridge) |
+| Sandbox effimeri | `wp-playground` (WASM, @wp-playground/cli) |
+| Routing intelligente | `wordpress-router` + decision tree v2 |
+
+### Gap identificati
+
+| Gap | Dettaglio |
+|-----|-----------|
+| **Ambiente locale persistente** | Nessuna skill gestisce siti locali permanenti (non effimeri come Playground) |
+| **Discovery siti locali** | Non esiste detection di Studio (`~/Studio/`, CLI `studio`) o LocalWP (`~/Local Sites/`, `sites.json`) |
+| **WP-CLI locale** | La skill `wp-wpcli-and-ops` assume WP-CLI disponibile ma non sa come invocarlo via `studio wp` o i binari bundled di LocalWP |
+| **Ciclo dev completo** | Manca: scaffold progetto -> sviluppo locale -> test -> deploy (il deploy c'e, ma parte dal codice, non dall'ambiente locale) |
+| **MCP Adapter** | WordPress 6.9 ha il plugin MCP Adapter (STDIO + HTTP) — non integrato |
+| **Studio MCP Server** | Automattic pubblica un MCP server per Studio — non integrato |
+| **Database locale** | Nessun supporto per SQLite (Studio) o MySQL socket (LocalWP) |
+
+---
+
+## 3. WordPress Studio — Superficie di integrazione
+
+### Architettura interna
+
+- **Runtime**: Electron + WASM (PHP compilato in WebAssembly)
+- **Database**: SQLite (file: `wp-content/database/.ht.sqlite`)
+- **Web server**: Nessuno (WASM serve direttamente)
+- **Porte**: Da 8881 in su (sequenziali)
+- **Storage siti**: `~/Studio/<nome-sito>/`
+- **Config app**: `~/.config/WordPressStudio/` (Linux)
+
+### Punti di integrazione
+
+| Punto | Metodo | Automazione possibile |
+|-------|--------|----------------------|
+| **Studio CLI** | `studio site create/start/stop/list/delete` | Ciclo di vita siti completo |
+| **WP-CLI via Studio** | `studio wp <comando> --path=<sito>` | Tutto WP-CLI, senza installare WP-CLI |
+| **REST API** | `http://localhost:888x/wp-json/` | CRUD contenuti, plugin, temi |
+| **SQLite diretto** | `sqlite3 wp-content/database/.ht.sqlite` | Query raw, bulk ops |
+| **Filesystem** | `~/Studio/<sito>/wp-content/` | Sviluppo tema/plugin, symlink |
+| **Studio MCP Server** | `wordpress-agent-skills/studio-mcp/` (Node.js) | AI agent site management |
+| **MCP Adapter plugin** | `studio wp mcp-adapter serve` (STDIO) | WordPress 6.9+ come MCP server |
+| **Preview API** | `studio preview create/update/delete` | Deploy temporaneo su WordPress.com |
+
+### Punti di forza
+
+- CLI v2 eccellente, completamente scriptabile
+- MCP ecosystem maturo (Studio MCP + MCP Adapter + WordPress.com MCP)
+- Setup in secondi, risorse minime
+- Integrazione nativa con WordPress.com per preview/deploy
+- Symlink workflow per multi-site testing
+
+### Limitazioni
+
+- No multisite
+- No Xdebug nativo
+- SQLite incompatibile con alcuni plugin complessi (WooCommerce)
+- No estensioni PHP native (solo quelle compilate in WASM)
+- Linux: richiede build da source
+
+---
+
+## 4. LocalWP — Superficie di integrazione
+
+### Architettura interna
+
+- **Runtime**: Electron + Lightning Stack (processi nativi OS)
+- **Web server**: NGINX o Apache (selezionabile per sito)
+- **PHP**: PHP-FPM nativo (versioni multiple bundled: 7.4 - 8.3)
+- **Database**: MySQL/MariaDB nativo (credenziali default: root/root, db: local)
+- **Porte**: Da 10000+ (incrementali: HTTP, HTTPS, MySQL)
+- **Storage siti**: `~/Local Sites/<nome-sito>/app/public/`
+- **Config siti**: `~/.config/Local/sites.json` (Linux)
+- **Binari**: `~/.config/Local/lightning-services/{php,mysql,nginx,wp-cli}-*/`
+
+### Punti di integrazione
+
+| Punto | Metodo | Automazione possibile |
+|-------|--------|----------------------|
+| **Site Discovery** | Parse `~/.config/Local/sites.json` | Scoperta automatica siti, porte, versioni |
+| **WP-CLI** | Binario bundled `wp-cli-*/bin/wp --path=` | Tutto WP-CLI (richiede MySQL attivo) |
+| **REST API** | `http://<nome>.local/wp-json/` o `http://127.0.0.1:<porta>/wp-json/` | CRUD completo |
+| **MySQL diretto** | Socket `~/.config/Local/run/<id>/mysql/mysqld.sock` o TCP | Query, export, import |
+| **Filesystem** | `~/Local Sites/<nome>/app/public/wp-content/` | Sviluppo tema/plugin, symlink |
+| **Logs** | `~/Local Sites/<nome>/logs/{nginx,php,mysql}/` | Debug, monitoring |
+| **Blueprints** | `~/.config/Local/blueprints/` | Template siti riutilizzabili |
+| **MCP Adapter** | `wp mcp-adapter serve --path=<root>` (STDIO) | WordPress 6.9+ come MCP server |
+| **Live Links** | GUI only (ngrok-like) | Non automabile direttamente |
+
+### Punti di forza
+
+- Production parity completa (MySQL, PHP nativo, NGINX/Apache)
+- Multisite supportato
+- Xdebug + VS Code (add-on)
+- MailHog per email testing
+- Ecosystem add-on esteso
+- Pacchetti Linux ufficiali (.deb/.rpm)
+
+### Limitazioni
+
+- **No CLI ufficiale** — solo GUI + "Open Site Shell"
+- Automazione richiede parsing `sites.json` + PATH setup per binari interni
+- Setup piu lento (minuti vs secondi)
+- Risorse pesanti (processi nativi multipli per sito)
+- No MCP server dedicato (solo MCP Adapter generico)
+- Live Links solo da GUI
+
+---
+
+## 5. Confronto decisionale
+
+| Criterio | WordPress Studio | LocalWP | Vincitore per plugin |
+|----------|-----------------|---------|---------------------|
+| **CLI automation** | Eccellente (`studio` CLI v2) | Assente (solo binari interni) | Studio |
+| **MCP ecosystem** | Studio MCP Server + MCP Adapter | Solo MCP Adapter (generico) | Studio |
+| **Production parity** | Bassa (SQLite, WASM PHP) | Alta (MySQL, PHP nativo, NGINX) | LocalWP |
+| **WooCommerce dev** | Fragile (SQLite compat issues) | Completo | LocalWP |
+| **Multisite** | Non supportato | Supportato | LocalWP |
+| **Xdebug** | Non disponibile | Supportato (add-on) | LocalWP |
+| **Setup speed** | Secondi | Minuti | Studio |
+| **Risorse sistema** | Leggero (~100MB) | Pesante (multi-processo) | Studio |
+| **Email testing** | Non disponibile | MailHog integrato | LocalWP |
+| **Linux support** | Build da source | Pacchetti .deb/.rpm | LocalWP |
+| **Preview/share** | `studio preview` (WordPress.com) | Live Links (GUI) | Studio |
+| **Symbiosi con plugin** | Forte (stesso ecosystem Automattic) | Moderata (parsing richiesto) | Studio |
+
+**Sintesi**: Studio vince per automazione e leggerezza. LocalWP vince per fedelta all'ambiente di produzione.
+
+---
+
+## 6. Workflow tipici mappati
+
+### Comandi concreti per tool
+
+| Workflow | WordPress Studio | LocalWP |
+|----------|-----------------|---------|
+| **Crea sito** | `studio site create --path ~/Studio/test` | GUI -> New Site (no CLI) |
+| **Scaffold tema** | `studio wp scaffold theme mytheme` | `wp scaffold theme mytheme --path=~/Local\ Sites/test/app/public` |
+| **Scaffold blocco** | `studio wp scaffold block myblock --plugin=myplugin` | (stesso via wp-cli bundled) |
+| **Installa plugin** | `studio wp plugin install woocommerce --activate` | (stesso via wp-cli bundled) |
+| **Test PHP version** | `studio site set --php-version=8.2` | GUI -> Site Settings -> PHP Version |
+| **Export DB** | `studio wp db export backup.sql` | (stesso via wp-cli bundled) |
+| **Import contenuti** | `studio wp import content.xml --authors=create` | (stesso via wp-cli bundled) |
+| **Preview sharing** | `studio preview create` | Live Links (GUI only) |
+| **Debug PHP** | `studio wp eval 'error_log("test");'` | Xdebug + VS Code (add-on) |
+| **Deploy a produzione** | Locale -> `wp-deploy` skill (esistente) | Locale -> `wp-deploy` skill (esistente) |
+
+### Workflow completo: Sviluppo Block Theme
+
+```
+1. Crea sito locale          studio site create / LocalWP GUI
+2. Scaffold tema              wp scaffold theme / npx create-block-theme
+3. Sviluppa in editor         VS Code + symlink wp-content/themes/
+4. Testa nel browser          localhost:8881 / mysite.local
+5. Test PHP versions          studio site set --php / LocalWP settings
+6. PHPStan analisi            wp-phpstan skill (esistente)
+7. Preview condivisa          studio preview / Live Links
+8. Deploy                     wp-deploy skill (esistente)
+```
+
+### Workflow completo: Sviluppo Plugin con Gutenberg Block
+
+```
+1. Crea sito locale          studio site create / LocalWP GUI
+2. Scaffold plugin            wp scaffold plugin myplugin
+3. Scaffold blocco            npx @wordpress/create-block@latest
+4. Dev con hot reload         npm start (wp-scripts)
+5. Unit test                  npm test / phpunit
+6. PHPStan                    wp-phpstan skill (esistente)
+7. Build produzione           npm run build
+8. Deploy                     wp-deploy skill (esistente)
+```
+
+---
+
+## 7. Tre approcci architetturali
+
+### Approccio A: "Local Environment Abstraction Layer"
+
+Un layer di astrazione unificato che rileva automaticamente Studio, LocalWP, o wp-env e espone un'interfaccia comune.
+
+```
+                   ┌──────────────────────────┐
+                   │    wordpress-router       │
+                   │  (decision tree v3)       │
+                   └─────────┬────────────────┘
+                             │
+                   ┌─────────▼────────────────┐
+                   │  wp-local-env (NUOVA)     │
+                   │  Detection + Abstraction  │
+                   └─────────┬────────────────┘
+                    ┌────────┼────────┐
+               ┌────▼──┐ ┌──▼───┐ ┌──▼────┐
+               │Studio │ │Local │ │wp-env │
+               │adapter│ │adapter│ │adapter│
+               └───────┘ └──────┘ └───────┘
+```
+
+**Nuovi componenti**:
+- 1 skill: `wp-local-env` (detection, lifecycle, unified API)
+- 1 script detection: `detect_local_env.mjs` (trova Studio/LocalWP/wp-env)
+- 3 adapter sections in SKILL.md (Studio CLI, LocalWP sites.json, wp-env)
+- Aggiornamento router decision tree -> v3
+- Opzionale: integrazione Studio MCP Server in `.mcp.json`
+
+**Pro**: Massima flessibilita, futuro-proof, un solo workflow per l'utente.
+**Contro**: Complessita di implementazione alta, 3 adapter da documentare.
+
+**Effort stimato**: ~v1.5.0 (major feature)
+
+### Approccio B: "Studio-First con fallback LocalWP"
+
+Focus su Studio (CLI eccellente, MCP server Automattic), con detection passiva di LocalWP.
+
+```
+                   ┌─────────────────────┐
+                   │  wp-local-dev (NUOVA)│
+                   │  Studio-first        │
+                   └─────────┬───────────┘
+                    ┌────────┼────────┐
+               ┌────▼──────┐    ┌────▼──────┐
+               │Studio CLI │    │LocalWP    │
+               │(primario) │    │(discovery)│
+               └───────────┘    └───────────┘
+```
+
+**Nuovi componenti**:
+- 1 skill: `wp-local-dev` (focalizzata su Studio, con sezione LocalWP)
+- 1 script: `detect_local_env.mjs`
+- Integrazione `.mcp.json` con Studio MCP Server (disabled by default)
+- Aggiornamento router v3
+
+**Pro**: Piu semplice, Studio ha la migliore superficie CLI per automazione.
+**Contro**: Utenti LocalWP hanno esperienza di seconda classe.
+
+**Effort stimato**: ~v1.5.0 (medium feature)
+
+### Approccio C: "Workflow Skills" (per tipo di attivita)
+
+Skill separate per workflow tipico, ognuna con istruzioni specifiche per ogni tool.
+
+```
+  ┌───────────────┐  ┌──────────────┐  ┌───────────────┐
+  │wp-local-theme │  │wp-local-plugin│ │wp-local-test  │
+  │  development  │  │  development  │ │  & debug      │
+  └───────┬───────┘  └──────┬───────┘ └───────┬───────┘
+          │                  │                  │
+    Istruzioni per:    Istruzioni per:   Istruzioni per:
+    - Studio           - Studio          - Studio
+    - LocalWP          - LocalWP         - LocalWP
+    - wp-env           - wp-env          - wp-env
+```
+
+**Nuovi componenti**:
+- 3+ skill workflow-based
+- 1 script detection condiviso
+- Nessun adapter layer
+
+**Pro**: Ogni skill e self-contained, facile da capire.
+**Contro**: Duplicazione istruzioni, manutenzione difficile.
+
+**Effort stimato**: ~v1.5.0 (medium feature, ma manutenzione alta)
+
+---
+
+## 8. Integrazione MCP proposta
+
+### Opzione 1: Studio MCP Server (Automattic)
+
+```json
+{
+  "studio-mcp": {
+    "command": "node",
+    "args": ["<path-to>/wordpress-agent-skills/studio-mcp/dist/index.js"],
+    "disabled": true
+  }
+}
+```
+
+### Opzione 2: MCP Adapter Plugin (WordPress 6.9+, per qualsiasi sito locale)
+
+```json
+{
+  "wp-local-mcp": {
+    "command": "studio",
+    "args": ["wp", "mcp-adapter", "serve", "--server=mcp-adapter-default-server", "--user=admin", "--path=<site>"],
+    "disabled": true
+  }
+}
+```
+
+### Opzione 3: wp-rest-bridge esistente puntato a localhost
+
+Il `wp-rest-bridge` MCP server gia presente nel plugin puo gia connettersi a siti locali configurando `WP_SITES_CONFIG` con URL `http://localhost:8881` e Application Password locale.
+
+---
+
+## 9. Raccomandazione
+
+**Approccio A** e il piu robusto e futuro-proof.
+**Approccio B** e il miglior compromesso effort/valore — Studio ha la CLI migliore e l'ecosistema MCP piu maturo.
+**Approccio C** e il piu semplice da iniziare ma scala male.
+
+La decisione dipende da:
+- Se l'utente usa prevalentemente Studio -> Approccio B
+- Se deve supportare team con tool diversi -> Approccio A
+- Se vuole partire veloce e iterare -> Approccio C
+
+---
+
+*Assessment generato il 2026-02-27 per wordpress-manager v1.4.0*

package/docs/plans/2026-02-27-local-env-design.md

@@ -0,0 +1,179 @@
+# Design: wp-local-env — Local Environment Abstraction Layer
+
+**Data**: 2026-02-27
+**Approccio**: A (Abstraction Layer)
+**Target version**: 1.5.0
+**Stato**: Implementato
+**Stato**: Approvato
+
+---
+
+## 1. Nuova skill `wp-local-env`
+
+### Directory structure
+
+```
+skills/wp-local-env/
+├── SKILL.md
+├── references/
+│   ├── studio-adapter.md
+│   ├── localwp-adapter.md
+│   ├── wpenv-adapter.md
+│   └── mcp-adapter-setup.md
+└── scripts/
+    └── detect_local_env.mjs
+```
+
+### Detection script output schema
+
+```json
+{
+  "environments": [
+    {
+      "tool": "studio|localwp|wpenv",
+      "version": "string",
+      "cli": "path or null",
+      "sites": [
+        {
+          "name": "string",
+          "path": "string",
+          "url": "string",
+          "port": "number|null",
+          "status": "running|stopped|unknown",
+          "php": "string",
+          "wp": "string|null",
+          "db": "sqlite|mysql",
+          "webServer": "wasm|nginx|apache|null"
+        }
+      ]
+    }
+  ],
+  "recommended": "studio|localwp|wpenv|null",
+  "wpCli": {
+    "studio": "studio wp --path=<site>",
+    "localwp": "<wp-cli-bin> --path=<site>",
+    "wpenv": "npx wp-env run cli wp"
+  }
+}
+```
+
+### Unified operations
+
+| Operation | Studio | LocalWP | wp-env |
+|-----------|--------|---------|--------|
+| Create site | `studio site create --path X` | Manual (GUI) + doc | `npx wp-env start` |
+| Start site | `studio site start --path X` | Manual (GUI) | `npx wp-env start` |
+| Stop site | `studio site stop --path X` | Manual (GUI) | `npx wp-env stop` |
+| WP-CLI | `studio wp <cmd> --path=X` | `<wp-cli-bin> --path=X` | `npx wp-env run cli wp <cmd>` |
+| REST API | `localhost:888x/wp-json/` | `localhost:<port>/wp-json/` | `localhost:8888/wp-json/` |
+| Symlink plugin | `ln -s src ~/Studio/X/wp-content/plugins/` | `ln -s src ~/Local Sites/X/app/public/wp-content/plugins/` | `.wp-env.json` mapping |
+| DB export | `studio wp db export` | `wp db export` (bundled) | `npx wp-env run cli wp db export` |
+
+---
+
+## 2. Router Decision Tree v3
+
+### New Step 0
+
+```
+Step 0: determine task category
+├── Development (modifying code) → Step 1 (triage)
+├── Operations (managing live sites) → Step 2b (ops routing)
+└── Local Environment (NEW) → Step 2c (local routing)
+```
+
+### New Step 2c keywords
+
+```
+local site, local dev, studio, localwp, local wp, create local,
+test locally, local environment, spin up, setup dev environment,
+preview locally, wp-env, dev server
+```
+
+### Step 2c routing
+
+- Create/setup local site → wp-local-env (create workflow)
+- List/discover local sites → wp-local-env (detect_local_env.mjs)
+- Start/stop/delete local site → wp-local-env (lifecycle)
+- Scaffold + develop locally → wp-local-env + development skill
+- Test locally / switch PHP / debug → wp-local-env (testing)
+- Preview/share local site → wp-local-env (preview)
+- Deploy from local to remote → wp-local-env (source) + wp-deploy (target)
+
+---
+
+## 3. Detection script logic
+
+### Platform paths
+
+```
+Linux:
+  Studio: ~/Studio/, ~/.config/WordPressStudio/
+  LocalWP: ~/Local Sites/, ~/.config/Local/sites.json
+
+macOS:
+  Studio: ~/Studio/, ~/Library/Application Support/WordPressStudio/
+  LocalWP: ~/Local Sites/, ~/Library/Application Support/Local/sites.json
+
+Windows:
+  Studio: ~/Studio/, %APPDATA%/WordPressStudio/
+  LocalWP: ~/Local Sites/, %APPDATA%/Local/sites.json
+```
+
+### Recommendation logic
+
+```
+Studio CLI available AND sites found → recommended: "studio"
+Only LocalWP found → recommended: "localwp"
+Only .wp-env.json found → recommended: "wpenv"
+None found → recommended: null
+Multiple → prefer Studio (best CLI), then LocalWP, then wp-env
+```
+
+---
+
+## 4. MCP server additions (disabled by default)
+
+```json
+{
+  "studio-mcp": {
+    "command": "node",
+    "args": ["${STUDIO_MCP_PATH}/dist/index.js"],
+    "disabled": true
+  },
+  "wp-local-mcp": {
+    "command": "studio",
+    "args": ["wp", "mcp-adapter", "serve", "--server=mcp-adapter-default-server", "--user=admin"],
+    "env": { "WP_LOCAL_SITE_PATH": "${WP_LOCAL_SITE_PATH}" },
+    "disabled": true
+  }
+}
+```
+
+---
+
+## 5. Files modified
+
+| Existing file | Change |
+|---------------|--------|
+| `skills/wordpress-router/SKILL.md` | Add "Local Environment" category |
+| `skills/wordpress-router/references/decision-tree.md` | v2 → v3, add Step 2c |
+| `skills/wp-wpcli-and-ops/SKILL.md` | Add "WP-CLI in local environments" section |
+| `skills/wp-deploy/SKILL.md` | Add "Deploy from local environment" workflow |
+| `skills/wp-playground/SKILL.md` | Add differentiation note (ephemeral vs persistent) |
+| `.mcp.json` | Add 2 disabled MCP servers |
+| `README.md` | Update to 19 skills, add local dev section |
+| `docs/GUIDE.md` | Add "Sviluppo Locale" section |
+| `CHANGELOG.md` | Add v1.5.0 entry |
+| `package.json` | Version bump 1.4.0 → 1.5.0 |
+| `.claude-plugin/plugin.json` | Version bump 1.4.0 → 1.5.0 |
+
+---
+
+## 6. Deliverable summary
+
+6 new files + 11 modifications = 17 deliverables
+
+---
+
+*Design approvato il 2026-02-27*

package/docs/plans/2026-02-27-site-type-guides-design.md

@@ -0,0 +1,44 @@
+# Design: Guide WordPress per Tipologia di Sito
+
+**Data:** 2026-02-27
+**Stato:** Approvato
+
+## Obiettivo
+
+Creare una serie di guide `.md` per ogni tipologia di sito WordPress (blog, landing page, ecommerce, portfolio). Ogni guida serve due audience: utente Claude Code (operativo) e sviluppatore WordPress (tecnico).
+
+## Posizione
+
+`docs/guides/` nel plugin wordpress-manager:
+
+```
+docs/guides/
+├── INDEX.md                  # Indice e matrice tipologie
+├── wp-blog.md                # Prima guida
+├── wp-landing-page.md        # Futuro
+├── wp-ecommerce.md           # Futuro
+├── wp-portfolio.md           # Futuro
+└── ...
+```
+
+## Struttura Standard (ogni guida)
+
+1. **Panoramica** — cos'e, quando usarlo, varianti
+2. **Per l'Utente** — concept, setup, contenuti, gestione, SEO, manutenzione
+3. **Per lo Sviluppatore** — architettura, theme.json, templates, patterns, plugin, workflow
+4. **Checklist di Lancio** — items raggruppati per area
+5. **Riferimenti** — skill plugin, risorse WP.org
+
+## Decisioni
+
+- Approccio A (file separati) scelto per modularita
+- Ogni guida e autocontenuta (~400-500 righe)
+- Le skill del plugin possono linkare alla guida rilevante
+- Lingua: italiano
+
+## Roadmap
+
+1. wp-blog.md (ora)
+2. wp-landing-page.md
+3. wp-ecommerce.md
+4. wp-portfolio.md

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-plugin-wordpress-manager",
-  "version": "1.4.0",
-  "description": "Unified WordPress management and development plugin for Claude Code. Orchestrates Hostinger MCP, WP REST API bridge, and WordPress.com MCP with 18 skills, 5 agents, and security hooks.",
+  "version": "1.7.0",
+  "description": "Unified WordPress management and development plugin for Claude Code. Orchestrates Hostinger MCP, WP REST API bridge, and WordPress.com MCP with 24 skills, 8 agents, and security hooks. Includes local dev environment support for WordPress Studio, LocalWP, and wp-env. v1.7.0 adds 3 new agents (testing, security hardening, accessibility) and upgrades 5 existing agents.",
   "author": {
     "name": "vinmor",
     "email": "morreale.v@gmail.com"
@@ -18,7 +18,11 @@
     "multi-site",
     "gutenberg",
     "block-development",
-    "wp-cli"
+    "wp-cli",
+    "local-development",
+    "wordpress-studio",
+    "localwp",
+    "wp-env"
   ],
   "repository": {
     "type": "git",

package/skills/wordpress-router/SKILL.md

@@ -4,7 +4,7 @@ description: “Use when the user asks about WordPress — whether development (
   blocks, REST API) or operations (deploy, audit, backup, migrate, content management).
   Classifies the task and routes to the correct development or operational skill/agent.”
 compatibility: “Targets WordPress 6.9+ (PHP 7.2.24+). Filesystem-based agent with bash + node. Some workflows require WP-CLI.”
-version: 1.0.0
+version: 1.1.0
 source: “WordPress/agent-skills (GPL-2.0-or-later) + wordpress-manager extensions”
 ---
 
@@ -14,9 +14,10 @@ source: “WordPress/agent-skills (GPL-2.0-or-later) + wordpress-manager extensi
 
 Use this skill at the start of most WordPress tasks to:
 
-- identify what kind of WordPress task this is (development vs operations),
+- identify what kind of WordPress task this is (development vs operations vs local environment),
 - for development: classify the repo (plugin vs theme vs block theme vs WP core),
 - for operations: identify the operation type (deploy, audit, backup, migrate, content),
+- for local environment: detect tools (Studio, LocalWP, wp-env) and manage local sites,
 - route to the most relevant skill(s) and/or agent(s).
 
 ## Inputs required
@@ -35,6 +36,14 @@ Use this skill at the start of most WordPress tasks to:
 - Sandbox testing via WordPress Playground
 - Route via project triage → development skills
 
+**Local Environment tasks** (managing local WordPress dev environments):
+- Setting up, starting, stopping local WordPress sites
+- Using WordPress Studio, LocalWP, or wp-env
+- Running WP-CLI commands on local sites
+- Symlink-based plugin/theme development
+- Local database operations, PHP/WP version switching
+- Route → `wp-local-env` skill (runs detection first)
+
 **Operational tasks** (managing live WordPress sites):
 - Deploying, auditing, backing up, migrating, managing content
 - Route directly → operational skills and agents
@@ -46,7 +55,17 @@ Use this skill at the start of most WordPress tasks to:
 2. Classify from triage output.
 3. Route to development skills — see `references/decision-tree.md`.
 
-### 3) For Operational tasks
+### 3) For Local Environment tasks
+
+1. Run detection: `node skills/wp-local-env/scripts/detect_local_env.mjs`
+2. Route to `wp-local-env` skill with detected environment context.
+3. For detailed tool guidance, see adapter references:
+   - `wp-local-env/references/studio-adapter.md`
+   - `wp-local-env/references/localwp-adapter.md`
+   - `wp-local-env/references/wpenv-adapter.md`
+4. For MCP integration: `wp-local-env/references/mcp-adapter-setup.md`
+
+### 4) For Operational tasks
 
 Route by intent keywords:
 
@@ -58,9 +77,10 @@ Route by intent keywords:
 - **Performance / slow / PageSpeed / optimize** → `wp-audit` skill + `wp-performance-optimizer` agent
 - **Site status / plugins / users / multi-site** → `wp-site-manager` agent
 
-### 4) Apply guardrails
+### 5) Apply guardrails
 
 - For development: prefer repo’s existing tooling and conventions.
+- For local environment: verify tool availability and site status before operations.
 - For operations: confirm target site, verify backups, get user confirmation for destructive ops.
 
 ## Verification
@@ -75,4 +95,4 @@ Route by intent keywords:
 
 ## Escalation
 
-- If routing is ambiguous, ask: “Are you looking to develop/modify WordPress code, or manage/operate a live WordPress site?”
+- If routing is ambiguous, ask: “Are you looking to develop/modify WordPress code, manage a local dev environment, or operate a live WordPress site?”