Fase-00: Estructura Clean Architecture Context-First creada

- Creada estructura shared/ con Domain, Application, Infrastructure
- Documentación completa de arquitectura (5 READMEs, ~6150 líneas)
- Archivos .gitkeep para preservar estructura en Git
- Contextos admin/ y public/ documentados

Estructura shared/:
- Domain/ (ValueObjects, Exceptions, Contracts)
- Application/ (Contracts, Services)
- Infrastructure/ (Services, Traits)

Documentación incluye:
- Principios de Clean Architecture
- Reglas de dependencia
- Ejemplos de código
- Guías de testing
- Mejores prácticas

Preparación completa para implementación en Fase-1.

shared/Application/README.md

@@ -0,0 +1,138 @@
+# Capa de Aplicación - Shared (Casos de Uso Compartidos)
+
+## Propósito
+
+La capa de Aplicación de `shared/` contiene **casos de uso y servicios compartidos** que orquestan la lógica
+de dominio. Esta capa coordina el flujo de datos entre el dominio y la infraestructura.
+
+## Principios
+
+1. **Orquestación**: Coordina objetos de dominio para realizar casos de uso
+2. **Sin lógica de negocio**: Delega la lógica al dominio
+3. **Independiente de frameworks**: No depende de WordPress directamente
+4. **Contratos claros**: Define interfaces para servicios
+
+## Estructura
+
+```
+shared/Application/
+├── Contracts/           # Interfaces de servicios (CacheServiceInterface, etc.)
+└── Services/            # Implementaciones de servicios compartidos
+```
+
+## Ejemplos de Uso
+
+### Contracts (Interfaces de Servicios)
+
+```php
+namespace ROITheme\Shared\Application\Contracts;
+
+interface CacheServiceInterface
+{
+    public function get(string $key): mixed;
+    public function set(string $key, mixed $value, int $ttl = 3600): bool;
+    public function delete(string $key): bool;
+    public function flush(): bool;
+}
+```
+
+```php
+namespace ROITheme\Shared\Application\Contracts;
+
+interface ValidationServiceInterface
+{
+    public function validate(array $data, array $rules): array;
+    public function fails(): bool;
+    public function errors(): array;
+}
+```
+
+### Services (Implementaciones Abstractas)
+
+Servicios que pueden tener múltiples implementaciones:
+
+```php
+namespace ROITheme\Shared\Application\Services;
+
+use ROITheme\Shared\Application\Contracts\ValidationServiceInterface;
+
+abstract class BaseValidationService implements ValidationServiceInterface
+{
+    protected array $errors = [];
+
+    public function fails(): bool
+    {
+        return !empty($this->errors);
+    }
+
+    public function errors(): array
+    {
+        return $this->errors;
+    }
+
+    abstract public function validate(array $data, array $rules): array;
+}
+```
+
+## Relación con Infrastructure
+
+La capa de Application **define contratos** (interfaces), pero **no implementa** la lógica específica
+de frameworks. Las implementaciones concretas van en `shared/Infrastructure/`:
+
+```
+shared/Application/Contracts/CacheServiceInterface.php (interface)
+                    ↓
+shared/Infrastructure/Services/WordPressCacheService.php (implementación)
+```
+
+## Reglas de Dependencia
+
+✅ **PUEDE** depender de:
+- `shared/Domain/` (Value Objects, Entities, Exceptions)
+- Interfaces dentro de `shared/Application/Contracts/`
+
+❌ **NO PUEDE** depender de:
+- `shared/Infrastructure/` (implementaciones concretas)
+- `admin/` o `public/`
+- WordPress functions directamente
+- Detalles de implementación
+
+## Testing
+
+Los servicios de esta capa se testean con **tests unitarios usando mocks**:
+
+```php
+// tests/Unit/Shared/Application/Services/SomeServiceTest.php
+public function test_validates_data_correctly()
+{
+    $validator = $this->createMock(ValidationServiceInterface::class);
+    $validator->method('validate')->willReturn(['name' => 'Test']);
+
+    $service = new SomeService($validator);
+    $result = $service->process(['name' => 'Test']);
+
+    $this->assertTrue($result);
+}
+```
+
+## Cuándo Agregar Código Aquí
+
+Agrega código a `shared/Application/` cuando:
+- Defines un contrato para un servicio compartido
+- Necesitas orquestar múltiples objetos de dominio
+- El servicio será usado por admin/ y public/
+- Necesitas abstraer implementaciones de infraestructura
+
+No agregues aquí:
+- Lógica de negocio (va en Domain/)
+- Implementaciones concretas de WordPress (van en Infrastructure/)
+- Lógica específica de un solo contexto
+- Código acoplado a frameworks
+
+## Ejemplos de Servicios Comunes
+
+- `ValidationServiceInterface`: Validación de datos
+- `CacheServiceInterface`: Manejo de caché
+- `SerializerServiceInterface`: Serialización de datos
+- `LoggerServiceInterface`: Logging
+- `EventDispatcherInterface`: Eventos del sistema

shared/Domain/README.md

@@ -0,0 +1,127 @@
+# Capa de Dominio - Shared (Fundación)
+
+## Propósito
+
+La capa de Dominio de `shared/` contiene la **lógica de negocio compartida** que utilizan todos los contextos
+(admin y public). Es la fundación del proyecto y no debe tener dependencias de frameworks, librerías externas, o
+capas superiores.
+
+## Principios
+
+1. **Sin dependencias externas**: No depende de WordPress, plugins, o librerías
+2. **Lógica pura**: Solo reglas de negocio y objetos de dominio
+3. **Inmutabilidad**: Los Value Objects son inmutables
+4. **Validación**: Los objetos se validan a sí mismos
+
+## Estructura
+
+```
+shared/Domain/
+├── ValueObjects/        # Value Objects compartidos (ComponentID, SettingValue, etc.)
+├── Exceptions/          # Excepciones de dominio (InvalidComponentException, etc.)
+└── Contracts/           # Interfaces de repositorios y servicios de dominio
+```
+
+## Ejemplos de Uso
+
+### Value Objects
+
+Value Objects que representan conceptos del dominio:
+
+```php
+namespace ROITheme\Shared\Domain\ValueObjects;
+
+final class ComponentID
+{
+    private int $value;
+
+    public function __construct(int $value)
+    {
+        if ($value <= 0) {
+            throw new \InvalidArgumentException('Component ID must be positive');
+        }
+
+        $this->value = $value;
+    }
+
+    public function value(): int
+    {
+        return $this->value;
+    }
+
+    public function equals(ComponentID $other): bool
+    {
+        return $this->value === $other->value;
+    }
+}
+```
+
+### Excepciones
+
+Excepciones específicas del dominio:
+
+```php
+namespace ROITheme\Shared\Domain\Exceptions;
+
+class InvalidComponentException extends \DomainException
+{
+    public static function withId(int $id): self
+    {
+        return new self("Component with ID {$id} is invalid");
+    }
+}
+```
+
+### Contracts (Interfaces)
+
+Interfaces que definen comportamientos:
+
+```php
+namespace ROITheme\Shared\Domain\Contracts;
+
+interface ComponentRepositoryInterface
+{
+    public function findById(ComponentID $id): ?Component;
+    public function save(Component $component): void;
+}
+```
+
+## Reglas de Dependencia
+
+✅ **PUEDE** depender de:
+- Otros objetos dentro de `shared/Domain/`
+- SPL (Standard PHP Library)
+- Nada más
+
+❌ **NO PUEDE** depender de:
+- `shared/Application/`
+- `shared/Infrastructure/`
+- `admin/` o `public/`
+- WordPress functions
+- Librerías externas
+
+## Testing
+
+Los objetos de esta capa se testean con **tests unitarios puros**, sin necesidad de WordPress:
+
+```php
+// tests/Unit/Shared/Domain/ValueObjects/ComponentIDTest.php
+public function test_creates_valid_component_id()
+{
+    $id = new ComponentID(123);
+    $this->assertEquals(123, $id->value());
+}
+```
+
+## Cuándo Agregar Código Aquí
+
+Agrega código a `shared/Domain/` cuando:
+- Es lógica de negocio pura (sin WordPress)
+- Es compartido por admin/ y public/
+- Es un concepto fundamental del dominio
+- Necesita alta cohesión y bajo acoplamiento
+
+No agregues aquí:
+- Código que depende de WordPress
+- Lógica específica de un solo contexto
+- Implementaciones concretas de servicios

shared/Infrastructure/README.md

@@ -0,0 +1,217 @@
+# Capa de Infraestructura - Shared (Implementaciones Concretas)
+
+## Propósito
+
+La capa de Infraestructura de `shared/` contiene **implementaciones concretas** de los servicios definidos en
+Application, utilizando WordPress y otras librerías externas.
+
+## Principios
+
+1. **Implementaciones concretas**: Código que interactúa con WordPress y librerías
+2. **Cumple contratos**: Implementa las interfaces definidas en Application
+3. **Detalles técnicos**: Maneja aspectos técnicos como caché, base de datos, APIs
+4. **Reusabilidad**: Servicios compartidos por todos los contextos
+
+## Estructura
+
+```
+shared/Infrastructure/
+├── Services/            # Implementaciones de servicios (WordPressCacheService, etc.)
+└── Traits/              # Traits reutilizables (WordPress helpers, etc.)
+```
+
+## Ejemplos de Uso
+
+### Services (Implementaciones Concretas)
+
+Implementación de CacheService usando WordPress Transients:
+
+```php
+namespace ROITheme\Shared\Infrastructure\Services;
+
+use ROITheme\Shared\Application\Contracts\CacheServiceInterface;
+
+final class WordPressCacheService implements CacheServiceInterface
+{
+    public function get(string $key): mixed
+    {
+        return get_transient($this->prefixKey($key));
+    }
+
+    public function set(string $key, mixed $value, int $ttl = 3600): bool
+    {
+        return set_transient($this->prefixKey($key), $value, $ttl);
+    }
+
+    public function delete(string $key): bool
+    {
+        return delete_transient($this->prefixKey($key));
+    }
+
+    public function flush(): bool
+    {
+        return wp_cache_flush();
+    }
+
+    private function prefixKey(string $key): string
+    {
+        return 'roi_theme_' . $key;
+    }
+}
+```
+
+Implementación de ValidationService usando WordPress Sanitization:
+
+```php
+namespace ROITheme\Shared\Infrastructure\Services;
+
+use ROITheme\Shared\Application\Services\BaseValidationService;
+
+final class WordPressValidationService extends BaseValidationService
+{
+    public function validate(array $data, array $rules): array
+    {
+        $validated = [];
+
+        foreach ($rules as $field => $rule) {
+            if (!isset($data[$field])) {
+                $this->errors[$field] = "Field {$field} is required";
+                continue;
+            }
+
+            $validated[$field] = match($rule) {
+                'email' => sanitize_email($data[$field]),
+                'text' => sanitize_text_field($data[$field]),
+                'int' => intval($data[$field]),
+                'url' => esc_url_raw($data[$field]),
+                default => $data[$field]
+            };
+        }
+
+        return $validated;
+    }
+}
+```
+
+### Traits (Helpers Reutilizables)
+
+Traits para funcionalidad común de WordPress:
+
+```php
+namespace ROITheme\Shared\Infrastructure\Traits;
+
+trait WordPressMetaDataTrait
+{
+    private function getMeta(int $postId, string $key, bool $single = true): mixed
+    {
+        return get_post_meta($postId, $this->prefixMetaKey($key), $single);
+    }
+
+    private function updateMeta(int $postId, string $key, mixed $value): bool
+    {
+        return update_post_meta($postId, $this->prefixMetaKey($key), $value);
+    }
+
+    private function deleteMeta(int $postId, string $key): bool
+    {
+        return delete_post_meta($postId, $this->prefixMetaKey($key));
+    }
+
+    private function prefixMetaKey(string $key): string
+    {
+        return '_roi_' . $key;
+    }
+}
+```
+
+## Relación con Application
+
+La capa Infrastructure **implementa** los contratos definidos en Application:
+
+```
+shared/Application/Contracts/CacheServiceInterface.php (interface)
+                    ↓ implementa
+shared/Infrastructure/Services/WordPressCacheService.php (implementación)
+```
+
+## Inyección de Dependencias
+
+Los servicios se registran en el DI Container y se inyectan a través de constructores:
+
+```php
+// En el DI Container (configuración)
+$container->bind(
+    CacheServiceInterface::class,
+    WordPressCacheService::class
+);
+
+// En el código que usa el servicio
+public function __construct(
+    private readonly CacheServiceInterface $cache
+) {}
+```
+
+## Reglas de Dependencia
+
+✅ **PUEDE** depender de:
+- `shared/Domain/` (Value Objects, Entities)
+- `shared/Application/` (especialmente Contracts)
+- WordPress functions
+- Librerías externas (Composer packages)
+
+❌ **NO PUEDE** depender de:
+- `admin/` o `public/` (contextos específicos)
+
+## Testing
+
+Los servicios de Infrastructure se testean con **tests de integración** que usan WordPress:
+
+```php
+// tests/Integration/Shared/Infrastructure/Services/WordPressCacheServiceTest.php
+public function test_stores_and_retrieves_from_cache()
+{
+    $cache = new WordPressCacheService();
+
+    $cache->set('test_key', 'test_value', 3600);
+    $result = $cache->get('test_key');
+
+    $this->assertEquals('test_value', $result);
+}
+```
+
+## Cuándo Agregar Código Aquí
+
+Agrega código a `shared/Infrastructure/` cuando:
+- Implementas un servicio definido en Application/Contracts/
+- Necesitas interactuar con WordPress (base de datos, caché, opciones, etc.)
+- Integras una librería externa
+- Creas utilidades de bajo nivel compartidas
+
+No agregues aquí:
+- Lógica de negocio (va en Domain/)
+- Definiciones de interfaces (van en Application/Contracts/)
+- Código específico de admin o public
+- Código sin contrato (sin interface)
+
+## Servicios Comunes en Infrastructure
+
+### Services/
+- `WordPressCacheService`: Caché usando WordPress Transients
+- `WordPressValidationService`: Validación con WordPress sanitization
+- `WordPressLoggerService`: Logging usando error_log o debug.log
+- `WordPressDatabaseService`: Interacciones directas con $wpdb
+
+### Traits/
+- `WordPressMetaDataTrait`: Helpers para post meta
+- `WordPressTaxonomyTrait`: Helpers para términos y taxonomías
+- `WordPressHooksTrait`: Helpers para actions y filters
+- `WordPressSanitizationTrait`: Helpers para sanitización
+
+## Patrón de Diseño
+
+Seguimos el patrón **Adapter**:
+- WordPress es el "adaptee" (sistema externo)
+- Nuestros Services son "adapters"
+- Los Contracts son las interfaces que queremos
+
+Esto permite cambiar WordPress por otro sistema en el futuro sin afectar el código de negocio.