evolutia 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

evolutia/__init__.py

@@ -2,4 +2,4 @@ from .evolutia_engine import EvolutiaEngine
 from .variation_generator import VariationGenerator
 from .llm_providers import LLMProvider, get_provider
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"

evolutia/config_manager.py

@@ -51,12 +51,14 @@ class ConfigManager:
             if root_config.exists():
                 self.config_path = root_config
             else:
-               # Default interno: evolutia/config/config.yaml
-               # self.base_path suele ser root
-               # Si base_path es root, la config está en root/evolutia/config/config.yaml
-               self.config_path = self.base_path / 'evolutia' / 'config' / 'config.yaml'
+               # Default interno: ubicado en el paquete instalado
+               # Obtenemos la ruta de este archivo (config_manager.py) -> parent (evolutia/) -> config -> config.yaml
+               self.config_path = Path(__file__).parent / 'config' / 'config.yaml'
         
-        logger.info(f"Usando archivo de configuración: {self.config_path}")
+        if self.config_path.exists():
+            logger.info(f"Usando archivo de configuración: {self.config_path}")
+        else:
+            logger.info(f"Archivo de configuración no encontrado en {self.config_path}. Usando configuración por defecto.")
 
     def validate_config(self, config_data: Dict[str, Any]) -> bool:
         """Valida la configuración contra el esquema JSON."""
@@ -187,6 +189,10 @@ class ConfigManager:
             
         logger.info(f"Configuración actualizada en {self.config_path}")
 
+    def update_config_from_structure(self):
+        """Alias para update_config, usado por compatibilidad."""
+        return self.update_config()
+
 def main():
     import argparse
     parser = argparse.ArgumentParser(description='Gestor de configuración automática de Evolutia')

evolutia/llm_providers.py

@@ -13,6 +13,8 @@ class LLMProvider(ABC):
 
     def __init__(self, model_name: Optional[str] = None):
         self.model_name = model_name
+        self.client = None
+        self.genai = None # For Gemini
         self.api_key = self._get_api_key()
         if self.api_key:
             self._setup_client()

evolutia/variation_generator.py

@@ -58,7 +58,201 @@ class VariationGenerator:
             return None
             
         return self._provider_instance
-    
+
+    def _create_prompt(self, exercise: Dict, analysis: Dict) -> str:
+        """Crea el prompt para generar una variación."""
+        
+        content = exercise.get('content', '')
+        complexity = analysis.get('total_complexity', 0)
+        concepts = ", ".join(analysis.get('concepts', []))
+        
+        prompt = f"""Actúa como un profesor experto de física y matemáticas universitarias.
+Tu tarea es crear una VARIACIÓN de un ejercicio existente.
+
+EJERCICIO ORIGINAL:
+{content}
+
+ANÁLISIS DE COMPLEJIDAD ORIGINAL:
+- Complejidad: {complexity:.2f}
+- Conceptos: {concepts}
+
+OBJETIVO:
+Generar una nueva versión del ejercicio que sea MÁS COMPLEJA y DESAFIANTE, pero evaluando los mismos principios fundamentales.
+
+ESTRATEGIAS PARA AUMENTAR COMPLEJIDAD:
+1. Cambia las variables numéricas por parámetros simbólicos (a, b, R, etc.)
+2. Introduce sistemas de coordenadas diferentes (cilíndricas/esféricas) si aplica
+3. Combina múltiples conceptos en un solo problema
+4. Agrega una restricción o condición de borde adicional
+5. Pide una generalización del resultado
+
+REGLAS DE FORMATO:
+1. Usa Markdown estándar
+2. Usa LaTeX para matemáticas (bloques :::math o $$...$$)
+3. La salida debe contener DOS PARTES separadas por "SOLUCIÓN REQUERIDA:"
+   - Parte 1: El enunciado del nuevo ejercicio (encabezado con "EJERCICIO VARIADO:")
+   - Parte 2: La solución paso a paso
+   
+Genera solo el contenido solicitado."""
+        return prompt
+
+    def _create_quiz_prompt(self, context_info: Dict) -> str:
+        """Crea prompt para ejercicios de selección única."""
+        content = context_info.get('content', '')
+        
+        prompt = f"""Actúa como un profesor experto. Genera una pregunta de examen de tipo SELECCIÓN ÚNICA (Quiz) basada en el siguiente material:
+
+MATERIAL BASE:
+{content}
+
+REQUISITOS:
+1. La pregunta debe ser conceptual y desafiante.
+2. Genera 4 opciones (A, B, C, D).
+3. Solo una opción debe ser correcta, las otras deben ser distractores plausibles.
+4. Devuelve la respuesta EXCLUSIVAMENTE en formato JSON válido:
+{{
+  "question": "Enunciado de la pregunta en Markdown...",
+  "options": {{
+    "A": "Texto opción A",
+    "B": "Texto opción B",
+    "C": "Texto opción C",
+    "D": "Texto opción D"
+  }},
+  "correct_option": "A",
+  "explanation": "Explicación detallada de por qué es la correcta..."
+}}
+"""
+        return prompt
+
+    def generate_variation(self, exercise: Dict, analysis: Dict, exercise_type: str = "development") -> Optional[Dict]:
+        """
+        Genera una variación de un ejercicio existente.
+        """
+        # 1. Crear prompt según tipo
+        if exercise_type == 'multiple_choice':
+            context_info = {
+                'content': f"Ejercicio Original:\n{exercise.get('content')}"
+            }
+            prompt = self._create_quiz_prompt(context_info)
+        else:
+            prompt = self._create_prompt(exercise, analysis)
+            
+        # 2. Get Provider
+        provider = self._get_provider()
+        if not provider: return None
+        
+        # 3. Generar
+        content = provider.generate_content(prompt, system_prompt="Eres un experto en diseño de exámenes de ingeniería.")
+        
+        if not content:
+            return None
+            
+        # 4. Parsear respuesta
+        variation_content = ""
+        variation_solution = ""
+        
+        if exercise_type == 'multiple_choice':
+            data = extract_and_parse_json(content)
+            if data and 'question' in data:
+                variation_content = f"{data['question']}\n\n"
+                for opt, text in data.get('options', {}).items():
+                    variation_content += f"- **{opt})** {text}\n"
+                variation_solution = f"**Respuesta Correcta: {data.get('correct_option', '?')}**\n\n{data.get('explanation', '')}"
+            else:
+                variation_content = content
+                variation_solution = "Error parseando JSON de quiz."
+        else:
+            # Parseo texto plano
+            parts = content.split("SOLUCIÓN REQUERIDA:")
+            if len(parts) == 2:
+                variation_content = parts[0].replace("EJERCICIO VARIADO:", "").strip()
+                variation_solution = parts[1].strip()
+            else:
+                variation_content = content
+                variation_solution = ""
+
+        return {
+            'variation_content': variation_content,
+            'variation_solution': variation_solution,
+            'original_frontmatter': exercise.get('frontmatter', {}),
+            'original_label': exercise.get('label'),
+            'type': exercise_type
+        }
+
+    def _create_new_exercise_prompt(self, topic: str, tags: list, context: Dict, difficulty: str) -> str:
+        """Crea prompt para ejercicio nuevo desde cero."""
+        tags_str = ", ".join(tags)
+        
+        prompt = f"""Diseña un NUEVO ejercicio de examen universitario para:
+Asignatura/Tema: {topic}
+Conceptos Clave (Tags): {tags_str}
+Nivel de Dificultad: {difficulty.upper()} (donde ALTA implica demostraciones o conexiones no triviales).
+
+INSTRUCCIONES:
+1. Crea un problema original que evalúe comprensión profunda.
+2. No copies ejercicios de libros de texto.
+3. Formato de salida:
+   EJERCICIO NUEVO:
+   [Enunciado en Markdown con LaTeX]
+   
+   SOLUCIÓN REQUERIDA:
+   [Solución paso a paso]
+"""
+        return prompt
+
+    def generate_new_exercise_from_topic(self, topic: str, tags: list = None, difficulty: str = "alta", exercise_type: str = "development") -> Optional[Dict]:
+        """
+        Genera un ejercicio nuevo desde cero.
+        """
+        tags = tags or []
+        context = {} # Base implementations doesn't use context
+        
+        # 1. Crear prompt
+        if exercise_type == 'multiple_choice':
+             context_info = {
+                'content': f"Tema: {topic}\nTags: {', '.join(tags)}\nDificultad: {difficulty}"
+            }
+             prompt = self._create_quiz_prompt(context_info)
+        else:
+             prompt = self._create_new_exercise_prompt(topic, tags, context, difficulty)
+             
+        # 2. Get Provider
+        provider = self._get_provider()
+        if not provider: return None
+        
+        # 3. Generar
+        content = provider.generate_content(prompt)
+        if not content: return None
+        
+        # 4. Parsear
+        # Reutilizamos lógica simple de parseo
+        if exercise_type == 'multiple_choice':
+            data = extract_and_parse_json(content)
+            if data and 'question' in data:
+                 var_content = f"{data['question']}\n\n"
+                 # ... (simplificado, igual que arriba)
+                 for k, v in data.get('options',{}).items():
+                     var_content += f"- **{k})** {v}\n"
+                 var_sol = f"R: {data.get('correct_option')}. {data.get('explanation')}"
+            else:
+                 var_content = content
+                 var_sol = ""
+        else:
+            parts = content.split("SOLUCIÓN REQUERIDA:")
+            if len(parts) == 2:
+                var_content = parts[0].replace("EJERCICIO NUEVO:", "").strip()
+                var_sol = parts[1].strip()
+            else:
+                var_content = content
+                var_sol = ""
+                
+        return {
+             'variation_content': var_content,
+             'variation_solution': var_sol,
+             'original_frontmatter': {'topic': topic, 'tags': tags},
+             'type': exercise_type
+        }
+
     def generate_variation_with_solution(self, exercise: Dict, analysis: Dict) -> Optional[Dict]:
         """
         Genera una variación con su solución.
@@ -69,23 +263,19 @@ class VariationGenerator:
         if not variation:
             return None
             
+        # Si ya tiene solución (porque el prompt único la pidió), retornarla
+        if variation.get('variation_solution'):
+            return variation
+            
         provider = self._get_provider()
         if not provider: return None
         
-        # Luego generar la solución
-        solution_prompt = f"""Eres un experto en métodos matemáticos para física e ingeniería. Resuelve el siguiente ejercicio paso a paso, mostrando todos los cálculos y procedimientos.
-
+        # Si no, generar la solución por separado (fallback legacy)
+        solution_prompt = f"""Eres un experto en métodos matemáticos. Resuelve el siguiente ejercicio paso a paso:
+        
 EJERCICIO:
 {variation['variation_content']}
 
-INSTRUCCIONES:
-1. Resuelve el ejercicio de forma completa y detallada
-2. Muestra todos los pasos intermedios
-3. Usa notación matemática LaTeX correcta
-4. Explica el razonamiento cuando sea necesario
-5. Usa bloques :::{{math}} para ecuaciones display y $...$ para inline
-6. Escribe en español
-
 GENERA LA SOLUCIÓN COMPLETA:"""
         
         solution_content = provider.generate_content(solution_prompt)

evolutia-0.1.1.dist-info/METADATA

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: evolutia
+Version: 0.1.1
+Summary: Sistema automatizado para generar preguntas de examen desafiantes basadas en materiales didácticos existentes
+Home-page: https://github.com/glacy/evolutIA
+Author: Gerardo Lacy-Mora
+Author-email: gerardolacymora@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML
+Requires-Dist: requests
+Requires-Dist: python-dotenv
+Requires-Dist: openai
+Requires-Dist: anthropic
+Requires-Dist: google-generativeai
+Requires-Dist: tqdm
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# EvolutIA: Generador de preguntas de examen
+
+Sistema automatizado para generar preguntas de examen desafiantes basadas en materiales didácticos existentes (lecturas, prácticas, tareas). El sistema aumenta la complejidad matemática de los ejercicios mientras mantiene el formato y estructura familiar.
+
+## Características Principales
+
+- **Multi-Modo**:
+    - **Variación**: Incrementa la complejidad de ejercicios existentes.
+    - **Creación**: Genera ejercicios nuevos desde cero basados en temas y tags.
+- **RAG (Retrieval-Augmented Generation)**: Usa tus propios apuntes y ejercicios previos como contexto para generar contenido más alineado al curso.
+- **Multi-Proveedor**: Soporte nativo para OpenAI (GPT-4), Anthropic (Claude 3), Google (Gemini 1.5) y Modelos Locales (via Ollama/LM Studio).
+- **Análisis de Complejidad**: Valida automáticamente que las nuevas preguntas sean matemáticamente más exigentes.
+- **Formato MyST**: Salida compatible con Curvenote y Jupyter Book.
+
+---
+
+## Instalación
+
+### Requisitos Previos
+- Python 3.8 o superior
+- API Key de tu proveedor preferido (OpenAI, Anthropic, Google) o un servidor local (Ollama).
+
+### Opción 1: Instalación desde PyPI (Recomendada)
+Para uso general, instala directamente el paquete:
+
+```bash
+# Crear entorno virtual (Recomendado)
+python -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
+
+# Instalar
+pip install evolutia
+```
+
+### Opción 2: Instalación desde Fuente (Desarrollo)
+Si deseas modificar el código o contribuir:
+
+```bash
+git clone https://github.com/glacy/evolutIA.git
+cd evolutia
+pip install -e .
+```
+
+### Configuración Inicial
+Crea un archivo `.env` en la raíz de tu proyecto con tus credenciales:
+
+```bash
+OPENAI_API_KEY=sk-...
+ANTHROPIC_API_KEY=sk-ant-...
+GOOGLE_API_KEY=...
+```
+
+---
+
+## Guía de Uso Rápido
+
+El comando principal es `evolutia`. Aquí tienes los casos de uso más comunes:
+
+### 1. Generar Variaciones (Modo Clásico)
+Toma ejercicios existentes de un tema y crea versiones más complejas.
+
+```bash
+# Generar 3 variaciones del tema 'analisis_vectorial'
+evolutia --tema analisis_vectorial --num_ejercicios 3 --output examenes/parcial1
+```
+
+O variar ejercicios específicos por su etiqueta (Label):
+```bash
+evolutia --tema analisis_vectorial --label ex1-s1 ex2-s1 --output examenes/recuperacion
+```
+
+### 2. Crear Nuevos Ejercicios (Modo Creación)
+Genera ejercicios desde cero sin necesitar un "ejercicio semilla".
+
+```bash
+# Crear 3 ejercicios nuevos sobre 'numeros_complejos'
+evolutia --mode creation --tema numeros_complejos --num_ejercicios 3 --output examenes/quiz1
+```
+
+### 3. Usar RAG (Contexto del Curso)
+Enriquece la generación indexando tus lecturas y prácticas.
+
+```bash
+# La primera vez, usa --reindex para leer tus materiales
+evolutia --tema matrices --num_ejercicios 3 --use_rag --reindex --output examenes/final
+
+# Consultas posteriores (usa el índice ya creado)
+evolutia --tema matrices --num_ejercicios 3 --use_rag --output examenes/final
+```
+
+### 4. Consultar tu Base de Conocimiento
+Pregúntale al sistema qué sabe sobre un concepto (útil para verificar RAG):
+```bash
+evolutia --query "Teorema de Stokes"
+```
+
+---
+
+## Configuración Avanzada
+
+EvolutIA es altamente configurable a través del archivo `evolutia_config.yaml` o argumentos CLI.
+
+### Archivo de Configuración
+Puedes colocar un `evolutia_config.yaml` en la raíz de tu carpeta de curso. Si no existe, puedes generarlo o ver el estado actual con:
+
+```bash
+# Analiza tu estructura de carpetas y genera/actualiza la config
+evolutia --analyze
+# O explícitamente usando el script auxiliar
+python evolutia/config_manager.py
+```
+
+### Argumentos CLI Disponibles
+
+| Argumento | Descripción | Default |
+|-----------|-------------|---------|
+| `--tema` | Identificador del tema (carpeta) | **Requerido** |
+| `--output` | Carpeta de salida | **Requerido** |
+| `--num_ejercicios` | Cantidad a generar | 1 |
+| `--complejidad` | Nivel objetivo (`media`, `alta`, `muy_alta`) | `alta` |
+| `--api` | Proveedor (`openai`, `anthropic`, `gemini`, `local`) | `openai` |
+| `--type` | Tipo de pregunta (`problem`, `multiple_choice`) | `problem` |
+| `--no_generar_soluciones` | Omite la creación de archivos de solución | False |
+
+### Uso con Modelos Locales (Offline)
+Para usar modelos como Llama 3 o Mistral sin costo de API:
+
+1. Ejecuta tu servidor (ej. `ollama serve`).
+2. Configura `evolutia_config.yaml` (opcional, si usas defaults de Ollama no es necesario):
+   ```yaml
+   local:
+     base_url: "http://localhost:11434/v1"
+     model: "llama3"
+   ```
+3. Ejecuta con el flag local:
+   ```bash
+   evolutia --tema basicos --api local --output prueba_local
+   ```
+
+---
+
+## Gestión de Materiales (Cómo "ve" los ejercicios EvolutIA)
+
+Para que el sistema encuentre tus ejercicios y lecturas, utiliza una estrategia de descubrimiento basada en carpetas y metadatos.
+
+1. **Escaneo de Carpetas**: Busca archivos `.md` dentro de la carpeta del tema (ej: `./analisis_vectorial/`).
+2. **Tags y Metadatos**: Para archivos fuera de esa carpeta (ej. en `tareas/`), el sistema lee el *frontmatter* YAML. Incluye el tag del tema para hacerlo visible:
+
+```yaml
+---
+title: Tarea 1
+tags: 
+  - analisis_vectorial  # <--- Este tag permite que evolutia encuentre el archivo
+  - stokes
+---
+```
+
+### Trazabilidad
+Los ejercicios generados heredan los tags de sus "padres". El archivo final del examen (`examenX.md`) resume todos los temas cubiertos.
+
+---
+
+## Estructura del Proyecto
+
+Se recomienda la siguiente estructura para tus cursos:
+
+```
+MiCurso/
+├── evolutia_config.yaml      # Configuración específica del curso
+├── analisis_vectorial/       # Materiales del tema 1
+│   ├── lectura.md
+│   └── practica.md
+├── matrices/                 # Materiales del tema 2
+├── examenes/                 # Salida generada por EvolutIA
+└── .env                      # API Keys (no subir a git)
+```
+
+> **Nota para usuarios antiguos**: Anteriormente se recomendaba usar Git Submodules. Ese método ha sido archivado. Si lo necesitas, consulta [docs/legacy/GUIDE_SUBMODULES.md](docs/legacy/GUIDE_SUBMODULES.md).
+
+## Contribuciones y Desarrollo
+
+El código fuente está organizado modularmente en `evolutia/`:
+- `evolutia_engine.py`: Orquestador principal.
+- `variation_generator.py`: Lógica de prompts y llamadas a LLMs.
+- `rag/`: Subsistema de indexación y recuperación.
+
+Para reportar bugs o mejoras, por favor visita el repositorio en GitHub.
+
+## Licencia
+Apache 2.0

{evolutia-0.1.0.dist-info → evolutia-0.1.1.dist-info}/RECORD

@@ -1,13 +1,13 @@
-evolutia_cli.py,sha256=z5QEpPGQGN8BCwtOn6HGl8ZcQ86_HGw84ZNvesNsRdI,7357
-evolutia/__init__.py,sha256=iYpwX9uyvy1h1kblwQtfSmR5m7y_K0jhZ-Anh5Milxc,172
+evolutia_cli.py,sha256=suMvTD2v7075-pQmyji2jCTOHuxZWENJM8Se0ynIl-k,7784
+evolutia/__init__.py,sha256=BydLq-f4ekW6SKFPKFA-W5QJLizRbNhqscAiLQGgeVI,172
 evolutia/complexity_validator.py,sha256=7LL7X9mfEb6S8o_Nj3U7gBpKRBUd49IKIvMGk0e6G6M,7258
-evolutia/config_manager.py,sha256=242KgmRSNG1U-WaPcmw9JdSECw1GG2eMESjKX7K49QU,8179
+evolutia/config_manager.py,sha256=gmaRb1tKD7G5OW61rO01cYu3O6o8ATS7JMxrRy0hoVI,8492
 evolutia/evolutia_engine.py,sha256=ZJOox50c7PiBuiqDnwx49P0vN0_Gu5_l0SG0K9UPVSQ,11969
 evolutia/exam_generator.py,sha256=bLMbSg4LV9boMjv3KUiOR4K2Auw90mOk60gjTY8Tymk,13670
 evolutia/exercise_analyzer.py,sha256=4g7LJv4oY0BagSZCm_iqodpKjoVcGCJn90y2Nz2f6ro,8784
-evolutia/llm_providers.py,sha256=JtzKasxjAO4QeQgdA-yEX-SH-hqsUp73bK0EfSwHQhM,7724
+evolutia/llm_providers.py,sha256=9sKu3x9ffZhomTR72R3rGBQUVUvO3U3un2VqxkLRBYk,7790
 evolutia/material_extractor.py,sha256=d2wnApRfWdc-1f5tibX5tmNr0yPBmNDN3aO9TsYQjj4,9732
-evolutia/variation_generator.py,sha256=w50WSffMvbz3A_nCiJ1uQ-FkLH_I-3M7hwuXpEEm2a4,3296
+evolutia/variation_generator.py,sha256=F6dQUwsljtAT5hO_1NyQA_uQ8YBr9Gep5tU3Ypcbc3M,10807
 evolutia/rag/__init__.py,sha256=c4tpP4b-C6BruvO1G865ta-RvZewqECy94QDN2fFRJA,112
 evolutia/rag/consistency_validator.py,sha256=jsPPCIjiMQ8oCkffvww142kGWfBUl70Bq4YiTwe8eqk,8337
 evolutia/rag/context_enricher.py,sha256=WnOVLOWByiX9_XZayaVsExbzldIWzl9AGwf5rAuSv4c,11723
@@ -19,9 +19,9 @@ evolutia/utils/__init__.py,sha256=rD3hl92fM5L3_7QCRrCjyR91bx_bOsw0baVQrCjy6vg,56
 evolutia/utils/json_parser.py,sha256=jZModUbVhR4MvzbD7qZOCtUricx9j_Tomc_M-zfuGIM,2872
 evolutia/utils/markdown_parser.py,sha256=7m1oqfe4eSkX1yi_VteEM2Q784UczOZ6YNngf8UWedc,4872
 evolutia/utils/math_extractor.py,sha256=pBscN0aDk9CFV-vKbk43e-lHI_vo2RyhxLMmwx3dgEQ,4832
-evolutia-0.1.0.dist-info/licenses/LICENSE,sha256=UdFWht_yODCzH9WTU6_GxLba0ascss31jBUjwvsDnU8,11559
-evolutia-0.1.0.dist-info/METADATA,sha256=GHh3YwnMMWkTyG8E6aOmZU18cE5UUzWhxugBgmECTcs,26960
-evolutia-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-evolutia-0.1.0.dist-info/entry_points.txt,sha256=BMYhya9XcbrfsjGfp4lMVQF0TK3Bd_Kj6mZtFhVJ7zo,47
-evolutia-0.1.0.dist-info/top_level.txt,sha256=GrIvEW8qAI8CIW5XTPnCqC7o06qJIL8p9CGwVhCEC4s,22
-evolutia-0.1.0.dist-info/RECORD,,
+evolutia-0.1.1.dist-info/licenses/LICENSE,sha256=jyOI5zt59oNBGE33KX2L1py7ZwWKqVFNcgEePR6o6YA,11564
+evolutia-0.1.1.dist-info/METADATA,sha256=bvapXA__5RRN2-OVqIkmX5iuI1PlrtPq1dK-UM-B0R8,7412
+evolutia-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+evolutia-0.1.1.dist-info/entry_points.txt,sha256=BMYhya9XcbrfsjGfp4lMVQF0TK3Bd_Kj6mZtFhVJ7zo,47
+evolutia-0.1.1.dist-info/top_level.txt,sha256=GrIvEW8qAI8CIW5XTPnCqC7o06qJIL8p9CGwVhCEC4s,22
+evolutia-0.1.1.dist-info/RECORD,,

{evolutia-0.1.0.dist-info → evolutia-0.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{evolutia-0.1.0.dist-info → evolutia-0.1.1.dist-info}/licenses/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2024-2025 glacy (glacy@tec.ac.cr)
+   Copyright 2026 glacy (gerardolacymora@gmail.com)
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

evolutia_cli.py

@@ -7,6 +7,10 @@ import argparse
 import logging
 import sys
 from pathlib import Path
+from dotenv import load_dotenv
+
+# Cargar variables de entorno desde el directorio actual (donde el usuario ejecuta el comando)
+load_dotenv()
 
 # Add current directory to path so we can import 'evolutia' package if running locally without install
 sys.path.insert(0, str(Path(__file__).parent))
@@ -56,9 +60,15 @@ Ejemplos:
     parser.add_argument('--list', action='store_true', help='Listar ejercicios')
     parser.add_argument('--query', type=str, help='Consulta RAG')
     parser.add_argument('--workers', type=int, default=5, help='Número de hilos para generación paralela')
+    parser.add_argument('--analyze', action='store_true', help='Analizar estructura y generar config.yaml')
 
     args = parser.parse_args()
     
+    if args.analyze:
+        print("Analizando estructura del proyecto...")
+        ConfigManager(str(Path.cwd())).update_config_from_structure()
+        return 0
+    
     # Validaciones básicas de argumentos
     if not args.reindex and not args.list and not args.query:
         if not args.tema and not args.label:

evolutia-0.1.0.dist-info/METADATA

@@ -1,723 +0,0 @@
-Metadata-Version: 2.4
-Name: evolutia
-Version: 0.1.0
-Summary: Sistema automatizado para generar preguntas de examen desafiantes basadas en materiales didácticos existentes
-Home-page: https://github.com/glacy/evolutIA
-Author: Gerardo Lacy-Mora
-Author-email: glacycr@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: PyYAML
-Requires-Dist: requests
-Requires-Dist: python-dotenv
-Requires-Dist: openai
-Requires-Dist: anthropic
-Requires-Dist: google-generativeai
-Requires-Dist: tqdm
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# EvolutIA: Generador de preguntas de examen
-
-Sistema automatizado para generar preguntas de examen desafiantes basadas en materiales didácticos existentes (lecturas, prácticas, tareas). El sistema aumenta la complejidad matemática de los ejercicios mientras mantiene el formato y estructura familiar.
-
-
-## Características
-
-- **Extracción automática**: Lee y procesa materiales didácticos en formato Markdown/MyST
-- **Análisis de complejidad**: Identifica tipo, pasos, variables y conceptos de cada ejercicio
-- **Generación inteligente**: Usa IA (OpenAI GPT-4 o Claude) para crear variaciones más complejas
-- **Validación automática**: Verifica que las variaciones sean más desafiantes que los originales
-- **Formato consistente**: Genera archivos en formato MyST/Markdown compatible con Curvenote
-- **Multi-proveedor**: Soporte para OpenAI (GPT-4), Anthropic (Claude 3) y Google (Gemini 1.5).
-- **RAG (Retrieval-Augmented Generation)**: Utiliza apuntes de clase y ejercicios existentes para dar contexto.
-- **Modo Creación**: Genera ejercicios nuevos desde cero basados en temas y tags del curso.
-- **Generación Paralela**: Utiliza concurrencia para acelerar drásticamente la generación de múltiples ejercicios.
-- **Parseo Robusto**: Sistema avanzado para manejar y limpiar JSON con alta densidad de LaTeX.
-
-```mermaid
-flowchart LR
-    A[📚 Materiales Didácticos<br>Lecturas, Tareas, Prácticas] --> B(🔍 Extracción y Análisis<br>Identifica ejercicios y conceptos)
-    B --> C{⚙️ Motor de Generación}
-    subgraph C [ ]
-        direction LR
-        D[Modo Variación<br>Incrementa complejidad]
-        E[Modo Creación<br>Nuevos ejercicios desde cero]
-    end
-    C --> F(🧠 Inteligencia Artificial<br>LLM + RAG opcional)
-    F --> G(✅ Validación<br>Verifica aumento de dificultad)
-    G --> H[📝 Generación de Archivos<br>Examen y Soluciones en MyST/Markdown]
-    H --> I(🎯 Evaluación Coherente y Desafiante)
-    I --> J(🚀 Generación Paralela<br>Concurrencia para acelerar)
-```
-
-## Requisitos
-
-- Python 3.8 o superior
-- API key de OpenAI o Anthropic (Claude)
-- Opcional: Servidor LLM local (Ollama, LM Studio) para generación offline
-
-### Instalación
-
-1.  Clona el repositorio:
-    ```bash
-    git clone https://github.com/glacy/evolutIA.git
-    cd evolutia
-    ```
-
-2.  Crea y activa un entorno virtual:
-    ```bash
-    python -m venv venv
-    source venv/bin/activate  # En Windows: venv\Scripts\activate
-    ```
-
-3.  Instala el paquete en modo editable (esto instalará también las dependencias):
-    ```bash
-    pip install -e .
-    ```
-
-4.  Configura las variables de entorno:
-    ```bash
-    cp .env.example .env
-    # Edita .env con tus API keys
-    ```
-   Y edita `.env` con tus claves reales:
-   ```
-   OPENAI_API_KEY=sk-tu-api-key-aqui
-   ANTHROPIC_API_KEY=sk-ant-tu-api-key-aqui
-   GOOGLE_API_KEY=tu-api-key-aqui
-   ```
-
-   **Obtener API keys**:
-   - OpenAI: https://platform.openai.com/api-keys
-   - Anthropic: https://console.anthropic.com/
-   - Google: https://console.cloud.google.com/ai/generative-ai/credentials
-
-## Uso
-
-### Uso básico
-
-```bash
-python evolutia.py \
-  --tema analisis_vectorial \
-  --num_ejercicios 4 \
-  --output examenes/examen3
-```
-
-### Variación de ejercicios específicos
-
-```bash
-python evolutia.py \
-  --tema analisis_vectorial \
-  --label ex1-s1 ex2-s1 \
-  --output variacion_especifica
-```
-
-### Listar ejercicios disponibles
-
-```bash
-python evolutia.py --tema analisis_vectorial --list
-```
-
-Si no se indica un tema, el sistema buscará en todos los archivos disponibles.
-
-### Opciones disponibles
-
-- `--tema`: Tema del examen (requerido)
-  - Ejemplos: `analisis_vectorial`, `matrices`, `edps`, `espacios_vectoriales`, `numeros_complejos`
-  
-- `--num_ejercicios`: Número de ejercicios a generar (default: 1)
-
-- `--output`: Directorio de salida (requerido)
-  - Se creará automáticamente si no existe
-
-- `--complejidad`: Nivel de complejidad objetivo
-  - Opciones: `media`, `alta` (default), `muy_alta`
-
-- `--api`: Proveedor de API de IA
-  - Opciones: `openai` (default), `anthropic`, `local`, `gemini`
-
-- `--label`: ID(s) específico(s) del ejercicio a variar (ej: `ex1-s1` o múltiples: `ex1-s1 ex2-s1`).
-  - Si se usa, ignora `--num_ejercicios` y genera variaciones **solo** para los ejercicios indicados.
-
-- `--config`: Ruta a un archivo de configuración externo (ej: `./mi_curso_config.yaml`). (default: busca `evolutia_config.yaml` en la raíz, o usa el interno).
-
-- `--base_path`: Ruta base del proyecto (default: directorio actual)
-
-- `--examen_num`: Número del examen (se infiere del nombre del directorio si no se especifica)
-
-- `--no_generar_soluciones`: NO genera las soluciones (por defecto siempre se generan)
-
-- `--subject`: Asignatura del examen (default: "IF3602 - II semestre 2025")
-
-- `--keywords`: Palabras clave para el examen (múltiples valores)
-
-- `--use_rag`: Usa RAG para enriquecer generación con contexto del curso (requiere indexación inicial)
-
-- `--reindex`: Fuerza re-indexación de materiales (solo con `--use_rag`)
-
-- `--list`: Lista todos los ejercicios encontrados en los temas seleccionados y muestra sus etiquetas, archivo origen y preview.
-
-- `--query`: Realiza una búsqueda semántica en la base de datos RAG y muestra los fragmentos de texto más relevantes encontrados. Útil para verificar qué "sabe" el sistema sobre un tema.
-
-- `--workers`: Número de hilos simultáneos para la generación paralela (default: 5). Útil para ajustar el rendimiento o evitar límites de rate.
-
-### Ejemplos
-
-**Generar examen de análisis vectorial con 4 ejercicios:**
-```bash
-python evolutia.py \
-  --tema analisis_vectorial \
-  --num_ejercicios 4 \
-  --output examenes/examen3
-```
-
-**Generar examen usando Claude (las soluciones se generan automáticamente):**
-```bash
-python evolutia.py \
-  --tema matrices \
-  --num_ejercicios 3 \
-  --api anthropic \
-  --output examenes/examen4
-```
-
-### Uso Básico
-
-Una vez instalado, puedes usar el comando `evolutia` (o ejecutar el wrapper `python evolutia_cli.py`):
-
-1.  **Analizar el repositorio y entender la estructura:**
-    ```bash
-    evolutia --analyze
-    ```
-    *(Esto generará `config.yaml` si no existe)*
-
-2.  **Generar examen con variaciones de ejercicios existentes:**
-    ```bash
-    evolutia --exam-number 1 --num-ejercicios 3 --tema "Derivadas" --complejidad "media"
-    ```
-**Generar examen SIN soluciones:**
-```bash
-python evolutia.py \
-  --tema matrices \
-  --num_ejercicios 3 \
-  --no_generar_soluciones \
-  --output examenes/examen5
-```
-
-**Generar examen con complejidad muy alta:**
-```bash
-python evolutia.py \
-  --tema edps \
-  --num_ejercicios 5 \
-  --complejidad muy_alta \
-  --output examenes/examen5
-```
-
-**Generar examen usando RAG (recomendado para mejor calidad):**
-```bash
-python evolutia.py \
-  --tema analisis_vectorial \
-  --num_ejercicios 4 \
-  --use_rag \
-  --output examenes/examen3
-```
-
-### Herramienta de Consulta RAG
-Puedes "preguntarle" al sistema qué información tiene sobre un concepto específico sin generar nada:
-
-```bash
-python evolutia.py --query "Teorema de Stokes"
-```
-
-Esto mostrará una lista de ejercicios y lecturas relevantes con su puntuación de similitud.
-
-### Modo Creación (Nuevo)
-Genera ejercicios totalmente nuevos desde cero, basándose en un tema y tags opcionales, en lugar de variar ejercicios existentes.
-
-**Generar 3 ejercicios nuevos de variable compleja:**
-```bash
-python evolutia.py \
-  --mode creation \
-  --tema numeros_complejos \
-  --num_ejercicios 3 \
-  --output examenes/parcial1
-```
-
-**Generar con tags específicos y usar Gemini:**
-```bash
-python evolutia.py \
-  --mode creation \
-  --tema analisis_vectorial \
-  --tags stokes divergencia \
-  --api gemini \
-  --output examenes/quiz3
-```
-
-### Tipos de Ejercicio
-Ahora puedes elegir entre ejercicios de desarrollo (default) o selección única (quiz).
-
-**Generar pregunta de Selección Única (Conceptual):**
-```bash
-python evolutia.py \
-  --mode creation \
-  --tema matrices \
-  --type multiple_choice \
-  --api anthropic \
-  --output examenes/quiz_rapido
-```
-
-## Uso de LLM local (offline)
-
-EvolutIA soporta la generación de exámenes usando modelos locales como Llama 3, Mistral, o Qwen, ejecutándose en tu propia máquina a través de herramientas como [Ollama](https://ollama.com/) o [LM Studio](https://lmstudio.ai/).
-
-**Requisitos:**
-1. Tener corriendo un servidor local compatible con OpenAI API.
-   - **Ollama**: Ejecuta `ollama serve` (por defecto en puerto 11434).
-   - **LM Studio**: Inicia el servidor local desde la interfaz.
-
-2. **Ejemplo de ejecución:**
-```bash
-python evolutia.py \
-  --tema matrices \
-  --num_ejercicios 3 \
-  --api local \
-  --output examenes/examen_local
-```
-
-3. **Configuración avanzada (opcional):**
-Si tu servidor no usa el puerto por defecto o quieres cambiar el modelo, edita `evolutia/config/config.yaml`:
-```yaml
-local:
-  base_url: "http://localhost:11434/v1"  # URL de tu servidor
-  model: "llama3"                        # Modelo a utilizar
-  api_key: "not-needed"
-```
-
-## Sistema RAG (Retrieval-Augmented Generation)
-
-El sistema incluye un módulo RAG opcional que mejora significativamente la calidad de las variaciones generadas.
-
-### ¿Qué es RAG?
-
-RAG (Retrieval-Augmented Generation) es un sistema que:
-- **Indexa** todos tus materiales didácticos (ejercicios, soluciones y **lecturas/teoría**)
-- **Busca** ejercicios similares y conceptos teóricos relevantes cuando generas variaciones
-- **Enriquece** los prompts con información del curso para generar variaciones más coherentes
-- **Valida** consistencia comparando con ejercicios y teoría reales del curso
-
-### Ventajas de usar RAG
-
-1. **Mejor contexto**: Las variaciones son más coherentes con el estilo y nivel del curso
-2. **Consistencia**: Los ejercicios generados se alinean mejor con materiales existentes
-3. **Relevancia**: Selección inteligente de ejercicios base por similitud semántica
-4. **Validación mejorada**: Compara con ejercicios reales del curso
-
-### Cómo usar RAG
-
-**Primera vez (indexación inicial):**
-```bash
-python evolutia.py \
-  --tema analisis_vectorial \
-  --num_ejercicios 4 \
-  --use_rag \
-  --reindex \
-  --output examenes/examen3
-```
-
-La primera vez con `--use_rag` indexará automáticamente todos los materiales. Esto puede tardar unos minutos.
-
-**Uso posterior:**
-```bash
-python evolutia.py \
-  --tema analisis_vectorial \
-  --num_ejercicios 4 \
-  --use_rag \
-  --output examenes/examen4
-```
-
-El índice se reutiliza automáticamente. Solo usa `--reindex` si cambias materiales y quieres actualizar el índice.
-
-### Configuración de RAG
-
-Edita `config/config.yaml` para personalizar RAG:
-```yaml
-rag:
-  vector_store:
-    # Base de datos vectorial persistente
-    persist_directory: "./storage/vector_store"
-    collection_name: "mi_curso_coleccion"
-  embeddings:
-    provider: openai
-    model: text-embedding-3-small
-  retrieval:
-    top_k: 5
-    similarity_threshold: 0.7
-```
-
-**Opciones de embeddings:**
-- `openai`: Más rápido y preciso, pero tiene costo (~$0.02 por 1M tokens)
-- `sentence-transformers`: Gratis y local, pero más lento
-
-### Costos de RAG
-
-- **Indexación inicial**: ~$1-5 dependiendo del volumen de materiales
-- **Búsquedas**: Mínimas, solo cuando generas variaciones
-- **Alternativa gratuita**: Usa `sentence-transformers` en lugar de OpenAI
-
-### Cuándo usar RAG
-
-**Usa RAG si:**
-- Tienes muchos materiales (50+ ejercicios)
-- Quieres máxima consistencia con el curso
-- Tienes presupuesto para embeddings de OpenAI
-
-**No uses RAG si:**
-- Tienes pocos materiales (<20 ejercicios)
-- Prefieres simplicidad y rapidez
-- El costo es una preocupación
-
-## Gestión de metadatos y descubrimiento
-
-### Organización y visibilidad de ejercicios
-
-Para que `evolutia` encuentre ejercicios ubicados en carpetas generales como `examenes/` o `tareas/` cuando filtras por un tema (ej: `--tema analisis_vectorial`), es fundamental que los archivos fuente incluyan los metadatos correctos.
-
-El sistema utiliza la siguiente lógica de "descubrimiento":
-
-1. **Escaneo directo**: Todos los archivos dentro de la carpeta del tema (ej: `analisis_vectorial/`) son incluidos automáticamente.
-2. **Escaneo de exámenes y tareas**: Para archivos fuera de la carpeta del tema, el sistema revisa el *frontmatter* y los incluye **SOLO SI** encuentra coincidencias con el tema en:
-    - **`tags`**: (Recomendado) Incluye el código del tema (ej: `analisis_vectorial`) en la lista.
-    - **`subject`**: El nombre de la asignatura o tema.
-    - **`keywords`**: Palabras clave relacionadas.
-
-**Ejemplo de Frontmatter para que un examen sea "visible":**
-```yaml
----
-title: Examen Parcial 1
-tags: 
-  - analisis_vectorial    # <--- CRÍTICO: Permite que el extractor lo encuentre
-  - stokes
-subject: Cálculo Superior
----
-```
-
-> **Nota**: Si usas `--label` para seleccionar un ejercicio específico, el filtro de tema se ignora y el sistema buscará el ID en todos los archivos disponibles.
-
-### Propagación de tags (trazabilidad)
-
-`EvolutIA` asegura que los metadatos de los ejercicios originales se conserven en las variaciones generadas. Esto es crucial para mantener un registro de qué conceptos se están evaluando.
-
-**¿Cómo funciona?**
-1. **Lectura**: El sistema lee los tags del archivo fuente (`.md`) donde reside el ejercicio original.
-2. **Transferencia**: Al generar la variación, estos tags se copian al nuevo archivo generado.
-3. **Agregación**: El archivo final del examen (`examenX.md`) recopila automáticamente los tags de *todos* los ejercicios incluidos, generando un resumen temático del examen.
-
-#### Ejemplo práctico
-
-**1. Archivo fuente (ej: `matrices/semana11_practica.md`)**
-Este archivo contiene los ejercicios originales ("semilla") y define el contexto temático:
-
-```yaml
----
-title: Ejercicios Semana 11
-tags: 
-  - autovalores        # Concepto clave
-  - diagonalizacion    # Concepto clave
-  - procedimental      # Tipo de competencia
-  - intermedio         # Nivel de dificultad
-subject: Matrices y Algebra Lineal
----
-```
-
-**2. Archivo generado (ej: `examenes/examen1/ex1_e1.md`)**
-La variación generada hereda estos metadatos y agrega los suyos propios:
-
-```yaml
----
-generator: evolutia
-source: ai_variation
-tags: [autovalores, diagonalizacion, procedimental, intermedio] # <--- Tags heredados
-original_subject: Matrices y Algebra Lineal
-complexity: media
-mode: variation          # <--- Nuevo: Modo de generación
-target_difficulty: alta  # <--- Nuevo: Dificultad objetivo
-based_on: ex1-e1         # <--- Nuevo: ID del ejercicio semilla
-rag_references:          # <--- Nuevo: Contexto usado (con --use_rag)
-  - ex5-e2
-  - semana3_lectura.md
----
-```
-
-
-## Estructura de archivos generados
-
-El script genera la siguiente estructura:
-
-```
-examenes/examen3/
-├── examen3.md              # Archivo principal del examen
-├── ex1_e3.md              # Ejercicio 1
-├── ex2_e3.md              # Ejercicio 2
-├── ex3_e3.md              # Ejercicio 3
-├── ex4_e3.md              # Ejercicio 4
-├── solucion_ex1_e3.md     # Solución ejercicio 1
-├── solucion_ex2_e3.md     # Solución ejercicio 2
-├── solucion_ex3_e3.md     # Solución ejercicio 3
-└── solucion_ex4_e3.md     # Solución ejercicio 4
-```
-
-## ¿Cómo funciona?
-
-1. **Extracción**: El sistema busca y lee materiales didácticos del tema especificado
-   - Busca en directorios del tema (ej: `analisis_vectorial/`)
-   - Lee archivos de prácticas (`*practica*.md`)
-   - Lee archivos de tareas (`tareas/tarea*/tarea*.md`)
-
-2. **Análisis**: Analiza cada ejercicio encontrado
-   - Identifica tipo (demostración, cálculo, aplicación)
-   - Cuenta pasos en soluciones
-   - Extrae variables y conceptos matemáticos
-   - Calcula complejidad matemática
-
-3. **Generación**: Crea variaciones más complejas usando IA
-   - Aumenta número de variables
-   - Combina múltiples conceptos
-   - Agrega pasos intermedios
-   - Modifica sistemas de coordenadas
-
-4. **Validación**: Verifica que las variaciones sean más complejas
-   - Compara complejidad total
-   - Verifica aumento en pasos, variables, conceptos
-   - Valida operaciones matemáticas
-
-5. **Generación de archivos**: Crea archivos en formato MyST/Markdown
-   - Frontmatter YAML apropiado
-   - Estructura de ejercicios con labels
-   - Bloques de solución
-
-## Configuración
-
-Puedes personalizar el comportamiento editando `config/config.yaml`:
-
-- **APIs**: Configurar modelos y parámetros
-- **Rutas**: Especificar directorios de materiales (dentro de `materials_directories`)
-- **Complejidad**: Ajustar umbrales de validación
-- **Exámenes**: Configurar valores por defecto y **keywords** por tema
-- **RAG**: Definir persistencia (local vs nube) y nombres de colección
-
-### Cambiar Proveedor por Defecto
-Puedes definir qué IA usar si no se especifica el argumento `--api`:
-
-```yaml
-api:
-  default_provider: gemini  # openai, anthropic, gemini, local
-  gemini:
-    model: gemini-1.5-pro   # Cambiar modelo específico
-```
-
-### Nota Importante sobre Configuración
-Para evitar errores de validación, asegúrate de que tu `evolutia_config.yaml` incluya la sección `api`. El sistema usa esto para determinar los modelos por defecto.
-
-### Configuración Avanzada / Multi-Curso
-
-Para usar `evolutia` en múltiples cursos o sin modificar el código fuente:
-
-1.  **Archivo de Configuración Externo**: Crea un archivo `evolutia_config.yaml` en la raíz de tu proyecto (junto a la carpeta `evolutia/`). El sistema lo detectará automáticamente.
-2.  **Argumento CLI**: Usa `--config ruta/a/mi_config.yaml` para especificar un archivo arbitrario.
-
-**Ejemplo de estructura recomendada para un nuevo curso:**
-```
-NuevoCurso/
-├── evolutia/            # Carpeta copiada o submódulo git
-├── evolutia_config.yaml # Configuración específica de este curso
-└── temas/               # Carpetas de contenido
-```
-
-> **IMPORTANTE**: No edites `evolutia/config/config.yaml` para datos de un curso específico. Ese archivo es una plantilla del motor. Crea un `evolutia_config.yaml` en la raíz de tu proyecto para tus ajustes personales.
-
-> **Guía Detallada**: Para instrucciones paso a paso sobre cómo usar Git Submodules, consulta [GUIDE_SUBMODULES.md](GUIDE_SUBMODULES.md).
-
-## Estrategias de aumento de complejidad
-
-El sistema aplica las siguientes estrategias para aumentar la complejidad:
-
-1. **Más variables independientes**: Introduce parámetros adicionales
-2. **Combinación de conceptos**: Integra múltiples teoremas en un ejercicio
-3. **Pasos intermedios**: Agrega cálculos adicionales
-4. **Casos límite**: Introduce condiciones especiales
-5. **Sistemas de coordenadas**: Cambia de cartesianas a cilíndricas/esféricas
-6. **Dimensiones adicionales**: Aumenta la dimensionalidad del problema
-
-## Solución de Problemas
-
-### Error: "No se encontraron materiales"
-- Verifica que el tema especificado existe como directorio
-- Asegúrate de que hay archivos `.md` con ejercicios en ese directorio
-- Usa `--base_path` para especificar la ruta correcta
-
-### Error: "API key no configurada"
-- Verifica que el archivo `.env` existe y contiene la API key
-- Asegúrate de que el archivo está en el directorio `evolutia/`
-- Revisa que la variable se llama correctamente (`OPENAI_API_KEY` o `ANTHROPIC_API_KEY`)
-
-### Error: "No se generaron variaciones válidas"
-- Intenta aumentar el número de ejercicios candidatos
-- Verifica que los ejercicios originales tienen suficiente complejidad
-- Considera usar `--complejidad media` para requisitos menos estrictos
-
-### Variaciones no son suficientemente complejas
-- Ajusta los umbrales en `config/config.yaml`
-- Usa `--complejidad muy_alta`
-- Revisa los prompts en `variation_generator.py` y ajústalos según necesites
-- Considera usar `--use_rag` para mejor contexto
-
-### Error: "RAG no disponible"
-- Instala dependencias: `pip install chromadb sentence-transformers`
-- Verifica que `OPENAI_API_KEY` está configurada si usas embeddings de OpenAI
-- Si prefieres embeddings locales, cambia `provider: sentence-transformers` en `config.yaml`
-
-## Limitaciones
-
-- Requiere conexión a internet para usar APIs de IA
-- Los costos de API dependen del número de ejercicios generados
-- La calidad depende de la calidad de los materiales originales
-- Las variaciones requieren revisión manual antes de usar
-
-## Mejores prácticas
-
-1. **Revisar siempre**: Las variaciones generadas deben revisarse manualmente
-2. **Ajustar según necesidad**: Modifica los ejercicios generados según tu criterio
-3. **Probar primero**: Genera un examen de prueba antes de usar en evaluación real
-4. **Mantener materiales actualizados**: Asegúrate de que los materiales fuente están completos
-5. **Documentar cambios**: Si modificas ejercicios, documenta los cambios realizados
-
-## Configuración automática
-
-El proyecto incluye una herramienta para sincronizar automáticamente el archivo de configuración con la estructura de carpetas y los metadatos de los archivos de lectura.
-
-### config_manager.py
-
-Este script escanea el directorio del proyecto para:
-1. Identificar carpetas de temas existentes.
-2. Leer los archivos de lectura (`semana*_lectura.md`) y extraer las palabras clave (`keywords`) del frontmatter.
-3. Actualizar el archivo de configuración activo (`evolutia_config.yaml` o interno).
-
-**Uso:**
-
-```bash
-# Uso básico (detecta configuración automáticamente)
-python evolutia/config_manager.py
-
-# Uso con archivo específico
-python evolutia/config_manager.py --config ./evolutia_config.yaml
-```
-
-Ejecuta este script cada vez que agregues nuevos temas o modifiques las palabras clave en los materiales de lectura.
-
-### Validación de Configuración (Schema)
-
-Evolutia incluye un sistema de validación estricta para el archivo de configuración (`evolutia_config.yaml`).
-
-- **JSON Schema**: La estructura válida se define en `evolutia/schemas/config.schema.json`.
-- **Validación Automática**: Cada vez que ejecutas `evolutia.py` o `config_manager.py`, el sistema verifica que tu archivo de configuración cumpla con el esquema.
-- **Errores Claros**: Si tu configuración tiene errores (campos faltantes, tipos incorrectos), el sistema detendrá la ejecución y te indicará exactamente dónde está el problema.
-
-Esto facilita la adopción de la herramienta por nuevos usuarios, reduciendo errores de configuración inicial.
-
-## Estructura del repositorio (Contexto)
-
-El generador está diseñado para funcionar dentro de la estructura estándar del curso. A continuación se muestra el esquema de directorios esperado:
-
-```
-.
-├── tema1/                    # Carpeta del primer tema (ej: analisis_vectorial)
-├── tema2/                    # Carpeta del segundo tema
-├── ...                       # Otros temas
-├── tareas/                   # Tareas evaluadas (fuente de ejercicios)
-├── proyecto/                 # Enunciados de proyectos
-├── examenes/                 # Directorio de salida para exámenes generados
-├── evolutia/                 # Este sistema de generación
-├── myst.yml                  # Configuración del sitio Curvenote
-└── programa-curso.md         # Información general del curso
-```
-
-### Estructura interna de cada tema
-
-Cada carpeta de tema (ej: `tema1/`) debe seguir una estructura similar para que el extractor encuentre los materiales:
-
-```
-tema1/
-├── semana1_lectura.md        # Material teoría (puede contener ejemplos)
-├── semana1_practica.md       # Ejercicios de práctica
-├── semana2_lectura.md
-├── semana2_practica.md
-└── otros_archivos.md         # Otros materiales complementarios
-```
-
-## Estructura del código (generador)
-
-```
-evolutia/
-├── evolutia.py               # Script principal (CLI Wrapper)
-├── evolutia_engine.py        # Motor central de orquestación
-├── config_manager.py         # Gestor de configuración automática
-├── material_extractor.py     # Extracción de materiales
-├── exercise_analyzer.py      # Análisis de complejidad
-├── variation_generator.py    # Generación de variaciones
-├── llm_providers.py          # Proveedores de LLM (OpenAI, Anthropic, Gemini, Local)
-├── complexity_validator.py   # Validación de complejidad
-├── exam_generator.py         # Generación de archivos
-├── rag/                      # Sistema RAG (opcional)
-│   ├── rag_indexer.py        # Indexación de materiales
-│   ├── rag_retriever.py      # Búsqueda semántica
-│   ├── context_enricher.py   # Enriquecimiento de contexto
-│   ├── enhanced_variation_generator.py  # Generador con RAG
-│   ├── consistency_validator.py  # Validación de consistencia
-│   └── rag_manager.py        # Gestor principal
-├── storage/
-│   └── vector_store/         # Base de datos vectorial (RAG)
-├── config/
-│   └── config.yaml          # Configuración
-├── templates/
-│   ├── exam_template.md      # Plantilla de examen
-│   └── exercise_template.md  # Plantilla de ejercicio
-├── utils/
-│   ├── markdown_parser.py    # Parser de Markdown
-│   ├── math_extractor.py     # Extracción de matemáticas
-│   └── json_parser.py        # Parser robusto de JSON (LaTeX friendly)
-├── requirements.txt          # Dependencias
-└── README.md                 # Esta documentación
-```
-
-## Contribuciones
-
-Para mejorar el sistema:
-
-1. Ajusta los prompts en `variation_generator.py` para mejor generación
-2. Agrega nuevos patrones de conceptos en `exercise_analyzer.py`
-3. Mejora las métricas de complejidad en `complexity_validator.py`
-4. Personaliza las plantillas en `templates/`
-
-## Licencia
-
-Este proyecto está bajo la Licencia Apache 2.0. Consulta el archivo [LICENSE](LICENSE) para más detalles.
-
-## Reconocimientos
-
-Este proyecto fue desarrollado utilizando asistencia de Inteligencia Artificial:
-
-- **Cursor**: Entorno de desarrollo asistido por IA.
-- **Antigravity** (Google DeepMind): Agente de codificación y planificación avanzado.
-