added docs

docs/API.md

@@ -0,0 +1,63 @@
+     # Documentación de la API de Yasmine
+
+     ## Comandos
+
+     ### SET
+     Establece un valor en la tabla hash.
+     ```go
+     setCmd := commands.NewSetStringCommand(hashTable)
+     result, err := setCmd.Execute("clave", "valor")
+     ```
+
+     ### GET
+     Recupera un valor de la tabla hash.
+     ```go
+     getCmd := commands.NewGetStringCommand(hashTable)
+     value, err := getCmd.Execute("clave")
+     ```
+
+     ## Persistencia
+
+     ### Guardar en RDB
+     Guarda el estado actual de Yasmine en un archivo RDB.
+     ```go
+     rdbPersistence := persistence.NewRDBPersistence("data/yasmine.rdb")
+     rdbPersistence.Save(hashTable)
+     ```
+
+     ### Cargar desde RDB
+     Carga el estado de Yasmine desde un archivo RDB.
+     ```go
+     loadedHT, err := rdbPersistence.Load()
+     ```
+
+     ## Replicación
+
+     ### Sincronizar Datos
+     Sincroniza los datos desde el maestro a los esclavos.
+     ```go
+     replicationManager.SyncToSlaves(masterHT)
+     ```
+
+     ## Pub/Sub
+
+     ### Publicar un Mensaje
+     Publica un mensaje en un canal.
+     ```go
+     pubSubManager.Publish("canal", "mensaje")
+     ```
+
+     ### Suscribirse a un Canal
+     Suscribe un cliente a un canal.
+     ```go
+     pubSubManager.Subscribe("canal", subscriber)
+     ```
+
+     ## Lua Scripting
+
+     ### Ejecutar un Script Lua
+     Ejecuta un script Lua dentro de Yasmine.
+     ```go
+     luaEngine.ExecuteScript(`print("Hola desde Lua")`)
+     ```
+     ```

docs/CONTRIBUTING.md

@@ -0,0 +1,21 @@
+#Contribuyendo a Yasmine
+
+¡Gracias por tu interés en contribuir a Yasmine! Aquí hay algunas pautas para ayudar a que tu contribución sea útil y se integre fácilmente en el proyecto.
+
+## Proceso de Contribución
+
+1. **Fork** este repositorio.
+2. Crea una nueva rama (`git checkout -b feature/nueva-funcionalidad`).
+3. Realiza tus cambios y **haz commit** (`git commit -am 'Añade nueva funcionalidad'`).
+4. **Push** a tu rama (`git push origin feature/nueva-funcionalidad`).
+5. Abre un **Pull Request** en GitHub.
+
+## Requisitos de Contribución
+
+- **Pruebas**: Asegúrate de que tus cambios estén cubiertos por pruebas unitarias.
+- **Documentación**: Si tu cambio afecta la funcionalidad pública, actualiza la documentación.
+- **Estilo de Código**: Sigue las convenciones de estilo de Go y realiza una revisión de tu código antes de enviar el pull request.
+
+## Problemas y Recomendaciones
+
+Si encuentras un error o tienes una recomendación, por favor abre un **Issue** en GitHub. Los issues son una gran forma de discutir posibles mejoras y problemas antes de comenzar a trabajar en ellos.

docs/README.md

@@ -0,0 +1,141 @@
+# Yasmine
+
+[![Go Report Card](https://goreportcard.com/badge/github.com/devmangel/Yasmine)](https://goreportcard.com/report/github.com/devmangel/Yasmine)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![GoDoc](https://godoc.org/github.com/devmangel/Yasmine?status.svg)](https://godoc.org/github.com/devmangel/Yasmine)
+
+Yasmine es una base de datos en memoria de alto rendimiento y altamente escalable, inspirada en Redis y escrita en Go. Diseñada para satisfacer las necesidades de aplicaciones modernas, Yasmine ofrece una amplia gama de estructuras de datos, capacidades avanzadas de replicación y persistencia, un sistema de publicación/suscripción robusto y soporte para scripting mediante Lua.
+
+## Características Principales
+
+- **Alto Rendimiento**: Operaciones rápidas y eficientes en memoria.
+- **Estructuras de Datos Complejas**: Soporte para listas, conjuntos, conjuntos ordenados, y más.
+- **Persistencia Flexible**: Guarda y carga el estado mediante RDB y AOF.
+- **Replicación para Alta Disponibilidad**: Replicación entre nodos maestro y esclavo.
+- **Pub/Sub**: Sistema de mensajería en tiempo real.
+- **Scripting Lua**: Extiende la funcionalidad con scripts personalizados.
+- **Seguridad Incorporada**: Autenticación, autorización y soporte HTTPS.
+
+## Tabla de Contenidos
+
+- [Instalación](#instalación)
+- [Guía Rápida](#guía-rápida)
+- [Documentación](#documentación)
+- [Contribuciones](#contribuciones)
+- [Licencia](#licencia)
+
+## Instalación
+
+Yasmine requiere Go 1.16 o superior. Para comenzar, sigue estos pasos:
+
+1. **Clonar el repositorio**:
+
+   ```bash
+   git clone https://github.com/devmangel/Yasmine.git
+   cd Yasmine
+   ```
+
+2. **Instalar dependencias**:
+
+   ```bash
+   go mod tidy
+   ```
+
+3. **Compilar el proyecto**:
+
+   ```bash
+   go build -o yasmine ./cmd/Yasmine/
+   ```
+
+4. **Ejecutar Yasmine**:
+
+   ```bash
+   ./yasmine
+   ```
+
+## Guía Rápida
+
+### Ejecutar un Servidor Yasmine
+
+Para ejecutar un servidor Yasmine localmente:
+
+```bash
+go run cmd/Yasmine/main.go
+```
+
+### Uso Básico
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/devmangel/Yasmine/internal/core/commands"
+    "github.com/devmangel/Yasmine/internal/core/data_structures"
+)
+
+func main() {
+    // Inicializa la tabla hash
+    ht := data_structures.NewHashTable()
+
+    // Crea y ejecuta un comando SET
+    setCmd := commands.NewSetStringCommand(ht)
+    setCmd.Execute("clave", "valor")
+
+    // Crea y ejecuta un comando GET
+    getCmd := commands.NewGetStringCommand(ht)
+    value, _ := getCmd.Execute("clave")
+
+    fmt.Printf("Valor obtenido: %s\n", value)
+}
+```
+
+### Persistencia
+
+Yasmine soporta persistencia a través de RDB (snapshotting) y AOF (Append Only File):
+
+```go
+// Configura la persistencia RDB
+rdbPersistence := persistence.NewRDBPersistence("data/yasmine.rdb")
+
+// Guarda el estado actual
+rdbPersistence.Save(hashTable)
+
+// Carga el estado desde un archivo RDB
+loadedHT, _ := rdbPersistence.Load()
+```
+
+### Replicación
+
+Yasmine facilita la replicación de datos entre nodos:
+
+```go
+// Configura el nodo maestro
+masterHT := data_structures.NewHashTable()
+masterNode := replication.NewMasterNode(masterHT)
+
+// Configura un nodo esclavo
+slaveNode := replication.NewSlaveNode()
+
+// Sincroniza datos entre el maestro y el esclavo
+replicationManager := replication.NewReplicationManager(masterNode, []*replication.SlaveNode{slaveNode})
+replicationManager.SyncToSlaves(masterHT)
+```
+
+## Documentación
+
+La documentación completa del proyecto, incluyendo guías de instalación, uso avanzado, y contribución, está disponible en el directorio [docs/](docs/). También puedes consultar la [API de Yasmine](https://godoc.org/github.com/devmangel/Yasmine) para obtener detalles sobre las funciones públicas.
+
+## Contribuciones
+
+Las contribuciones son muy bienvenidas. Por favor, revisa nuestra [Guía para Contribuyentes](docs/CONTRIBUTING.md) antes de enviar un pull request.
+
+### Principios para Contribuir
+
+- **Código de Alta Calidad**: Sigue las mejores prácticas de Go, escribe pruebas para tu código, y documenta tus cambios.
+- **Discusión Previa**: Abre un issue antes de empezar a trabajar en cambios importantes para alinearnos en los objetivos.
+- **Pruebas Automatizadas**: Asegúrate de que todas las pruebas pasen antes de enviar tu contribución.
+
+## Licencia
+
+Yasmine se distribuye bajo la licencia MIT. Consulta el archivo [LICENSE](LICENSE) para más detalles.

docs/architecture.md

@@ -0,0 +1,23 @@
+# Arquitectura de Yasmine
+
+## Visión General
+
+Yasmine es una base de datos en memoria distribuida diseñada para ser rápida y escalable. Se basa en una arquitectura modular que permite una fácil extensión y mantenimiento.
+
+## Componentes Principales
+
+- **Comandos**: Implementan la lógica para manipular estructuras de datos.
+- **Persistencia**: Maneja la durabilidad de los datos mediante RDB y AOF.
+- **Replicación**: Asegura la alta disponibilidad de los datos replicando entre nodos.
+- **Networking**: Proporciona soporte HTTP/HTTPS para comunicación segura.
+- **Pub/Sub**: Implementa un sistema de mensajería en tiempo real.
+- **Lua Scripting**: Permite la ejecución de scripts Lua para extender la funcionalidad.
+
+## Flujo de Datos
+
+1. **Comando**: Un cliente envía un comando (por ejemplo, `SET`, `GET`).
+2. **Procesamiento**: El comando se procesa utilizando las estructuras de datos internas.
+3. **Persistencia**: El estado se guarda en disco utilizando RDB o AOF.
+4. **Replicación**: Si es un nodo maestro, los datos se replican a los esclavos.
+5. **Respuesta**: El resultado se devuelve al cliente.
+