lanzakit-tester 0.1.0__tar.gz

lanzakit_tester-0.1.0/.gitignore

@@ -0,0 +1,155 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.*
+!.env.example
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+.output
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp directory
+.temp
+
+# Sveltekit cache directory
+.svelte-kit/
+
+# vitepress build output
+**/.vitepress/dist
+
+# vitepress cache directory
+**/.vitepress/cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# Firebase cache directory
+.firebase/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# pnpm
+.pnpm-store
+
+# yarn v3
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+# Vite files
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
+.vite/
+# Python
+venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+
+# Secrets
+.env
+
+# IDE
+.vscode/
+.idea/

lanzakit_tester-0.1.0/CLAUDE.md

@@ -0,0 +1,95 @@
+# Lanzakit Tester
+
+Proyecto: MCP server en Python que genera y valida tests pytest con IA.
+
+## Estado actual (noviembre 2026)
+
+Paquete Python instalable (`pip install lanzakit-tester`), versión 0.1.0, aún sin publicar en PyPI.
+Estructura `src/lanzakit_tester/` con build backend hatchling y CLI `lanzakit-tester`.
+
+Producto funcional con 3 tools:
+- `analyze_python_file`: analiza estructura del código con AST
+- `generate_tests_for_file`: genera tests con Claude API
+- `generate_and_validate_tests`: genera + valida sintaxis + ejecuta pytest
+
+Loop end-to-end funciona. 8 tests generados y 8 passed en pruebas reales.
+
+## Stack técnico
+
+- Python 3.14
+- MCP SDK v2 (`from mcp.server.mcpserver import MCPServer`)
+- Claude API (modelo: `claude-sonnet-5`)
+- pytest para validación
+- uv como gestor de paquetes
+- venv en `.venv/`
+
+## Comandos clave
+
+```bash
+# Activar entorno
+source .venv/bin/activate
+
+# Instalar en modo editable (con deps de desarrollo)
+uv pip install -e ".[dev]"
+
+# Verificar CLI
+lanzakit-tester --version
+
+# Probar generación de tests
+python -c "from lanzakit_tester import generate_and_validate_tests; print(generate_and_validate_tests('/ruta/archivo.py')['summary'])"
+
+# Correr tests manualmente
+pytest examples -v
+```
+
+## Arquitectura
+
+- `pyproject.toml`: fuente de verdad de metadata y dependencias (hatchling)
+- `src/lanzakit_tester/server.py`: MCP server con las 3 tools, constante `MODEL`, `run()`
+- `src/lanzakit_tester/cli.py`: entrypoint argparse (`--version`; sin args arranca MCP por stdio)
+- `src/lanzakit_tester/__init__.py`: expone las 3 tools y `__version__`
+- `examples/`: `hola_claude.py` (hola mundo con Claude API) y su test; no son parte del paquete
+- `.env`: contiene ANTHROPIC_API_KEY (nunca commitear)
+
+## Decisiones tomadas
+
+- Modelo: Claude Sonnet 5 (fijo por ahora), definido como constante `MODEL` en `src/lanzakit_tester/server.py`
+- Versión única en `pyproject.toml`; se lee con `importlib.metadata` y se pasa a `MCPServer(version=...)`
+- `max_tokens`: 16384 con thinking desactivado
+- Prompt engineering con delimitadores XML
+- `_clean_code_output()` remueve markdown fences
+- `_run_pytest` usa `sys.executable -m pytest` para encontrar pytest desde cualquier contexto
+- Thinking desactivado para ahorrar tokens (reactivable cuando se quiera)
+
+## Próximos pasos
+
+- README público para GitHub
+- Publicar en PyPI como `lanzakit-tester` (el empaquetado ya está listo)
+- Landing en lanzakit.dev con waitlist
+- Lanzamiento en X/LinkedIn + Product Hunt
+
+## Deuda técnica menor
+
+No se resuelve antes del lanzamiento (perfeccionismo mata lanzamientos):
+
+- `requirements-dev.txt` es redundante con `pip install -e ".[dev]"`
+- `CONTRIBUTING.md` no menciona `pip install -e ".[dev]"`
+
+## Contexto personal
+
+Ingeniera full stack en Jalasoft (La Paz, Bolivia).
+Prefiere respuestas concisas y directas.
+Comunica en español.
+
+## Reglas del proyecto
+
+- Nunca commitear `.env`
+- Tests en español (comentarios) pero nombres de funciones en inglés
+- Mantener imports ordenados: stdlib → third party → local
+- Modelo API siempre desde constante/config, nunca hardcoded en varias partes
+
+## Pendientes conocidos
+
+- Renombrar repo de `starter-kit` a `lanzakit-tester` antes del lanzamiento público
+- Reservar handle @lanzakit en X/Twitter
+- Crear archivos de badges reales cuando se publique en PyPI

lanzakit_tester-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,51 @@
+# Contribuir a Lanzakit Tester
+
+¡Gracias por tu interés! Toda contribución es bienvenida: bugs, ideas, docs y código.
+
+## Reportar un issue
+
+1. Busca primero si ya existe un issue similar.
+2. Abre uno nuevo e incluye:
+   - Qué esperabas que pasara y qué pasó realmente.
+   - Pasos para reproducirlo (idealmente con un archivo `.py` mínimo).
+   - Versión de Python y sistema operativo.
+   - Mensajes de error completos.
+
+Nunca pegues tu `ANTHROPIC_API_KEY` ni el contenido de tu `.env`.
+
+## Proponer una feature
+
+Abre un issue describiendo el problema que quieres resolver y tu propuesta.
+Conviene acordar el enfoque antes de escribir código, así evitamos trabajo perdido.
+
+## Hacer un Pull Request
+
+1. Haz fork del repositorio.
+2. Crea una rama desde `main`: `git checkout -b feat/mi-cambio`
+3. Haz tus cambios y commits pequeños y claros.
+4. Verifica que los tests pasen: `pytest -v`
+5. Haz push a tu fork y abre el PR explicando qué cambia y por qué.
+
+Mensajes de commit sugeridos: `feat:`, `fix:`, `docs:`, `test:`, `refactor:`.
+
+## Estilo de código
+
+- Sigue [PEP 8](https://peps.python.org/pep-0008/).
+- Formatea con [black](https://black.readthedocs.io/) y ordena imports con [isort](https://pycqa.github.io/isort/):
+
+  ```bash
+  black .
+  isort .
+  ```
+
+- Orden de imports: stdlib → third party → local.
+
+## Convenciones del proyecto
+
+- Comentarios y docstrings en español; nombres de funciones y variables en inglés.
+- El modelo de la API se define en una sola constante/config, nunca hardcoded en varios lugares.
+- Nunca commitees `.env` ni credenciales.
+
+## Licencia
+
+Al contribuir aceptas que tu aporte se distribuya bajo la licencia [MIT](LICENSE) del proyecto.

lanzakit_tester-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Raquel Martinez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lanzakit_tester-0.1.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.5
+Name: lanzakit-tester
+Version: 0.1.0
+Summary: MCP server that generates and validates pytest tests using Claude.
+Project-URL: Homepage, https://github.com/lanzakit/starter-kit
+Project-URL: Repository, https://github.com/lanzakit/starter-kit
+Project-URL: Issues, https://github.com/lanzakit/starter-kit/issues
+Author: Raquel Martinez
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,anthropic,claude,mcp,pytest,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Requires-Dist: anthropic>=2.0.0
+Requires-Dist: mcp[cli]>=2.0.0
+Requires-Dist: pytest>=8.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Lanzakit Tester
+
+![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue?logo=python&logoColor=white)
+![License MIT](https://img.shields.io/badge/license-MIT-green)
+<!-- TODO: agregar badge PyPI después del primer release -->
+
+**Tests de pytest generados por IA, y verificados antes de que los veas.**
+
+Lanzakit Tester es un MCP server que lee tu código Python, genera tests con Claude y los ejecuta para confirmar que compilan y pasan. Dejas de revisar tests que ni siquiera corren.
+
+## Features
+
+- 🧪 **Generación de tests con Claude**: analiza tu código y produce tests pytest listos para usar.
+- ✅ **Validación automática**: verifica la sintaxis y ejecuta pytest antes de entregarte el resultado.
+- 🔌 **MCP nativo**: funciona con Claude Desktop y cualquier cliente compatible con MCP.
+- 🌳 **Análisis con AST**: entiende funciones, clases y firmas antes de armar el prompt.
+- 🇪🇸 **Español-first**: comentarios de los tests y documentación en español.
+- 🔓 **Open source**: licencia MIT, sin lock-in.
+
+## Requisitos
+
+- Python 3.11+
+- Una API key de Anthropic (`ANTHROPIC_API_KEY`)
+- Acceso al modelo `claude-sonnet-5`
+
+## Instalación
+
+```bash
+pip install lanzakit-tester
+echo "ANTHROPIC_API_KEY=tu_api_key" > .env
+```
+
+> El archivo `.env` contiene tu API key. Nunca lo subas a git.
+
+### Opción A: Vía Claude Desktop (MCP config)
+
+Agrega el server a tu `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "lanzakit-tester": {
+      "command": "lanzakit-tester"
+    }
+  }
+}
+```
+
+Reinicia Claude Desktop y las 3 tools aparecerán disponibles.
+
+### Opción B: Vía Python
+
+Sin cliente MCP, puedes invocar las tools directamente desde Python:
+
+```bash
+python -c "from lanzakit_tester import generate_and_validate_tests; print(generate_and_validate_tests('/ruta/a/tu_archivo.py')['summary'])"
+```
+
+### Para contribuir
+
+```bash
+git clone https://github.com/lanzakit/starter-kit.git
+cd starter-kit
+uv venv && source .venv/bin/activate
+uv pip install -e ".[dev]"
+```
+
+## Uso
+
+Tienes un archivo `hola_claude.py` (ver `examples/hola_claude.py`, versión simplificada):
+
+```python
+import os
+
+from anthropic import Anthropic
+from dotenv import load_dotenv
+
+load_dotenv()
+client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
+
+def saludar():
+    message = client.messages.create(
+        model="claude-sonnet-5",
+        max_tokens=512,
+        messages=[{"role": "user", "content": "Hola Claude"}]
+    )
+    print(message.content[0].text)
+```
+
+Desde Claude Desktop, pídele:
+
+> Genera y valida tests para `/ruta/a/tu_archivo.py`
+
+Claude llama a la tool `generate_and_validate_tests` y obtienes un resumen como este:
+
+```text
+✅ 8 tests generados y pasaron. Guardado en: /ruta/a/test_tu_archivo.py
+```
+
+El archivo `test_tu_archivo.py` queda junto a tu código, listo para correr con `pytest`.
+
+### Tools disponibles
+
+| Tool | Qué hace |
+|------|----------|
+| `analyze_python_file` | Analiza la estructura del código con AST. |
+| `generate_tests_for_file` | Genera tests pytest con Claude. |
+| `generate_and_validate_tests` | Genera, valida sintaxis, guarda y ejecuta pytest. |
+
+## Cómo funciona
+
+```text
+código .py
+   │
+   ▼
+análisis AST  ──►  prompt a Claude  ──►  tests generados
+                                              │
+                                              ▼
+                      resultado  ◄──  ejecución pytest  ◄──  validación sintáctica
+```
+
+1. Lee tu archivo y extrae su estructura con AST.
+2. Arma un prompt con el código y su contexto, y se lo envía a Claude (`claude-sonnet-5`).
+3. Limpia la respuesta (por ejemplo, quita markdown fences).
+4. Valida que los tests tengan sintaxis Python correcta.
+5. Guarda el archivo y ejecuta pytest.
+6. Devuelve un resumen: cuántos pasaron, fallaron o dieron error.
+
+## Roadmap
+
+- [x] 3 tools funcionales
+- [x] Validación end-to-end
+- [x] Empaquetado como paquete pip
+- [ ] Publicación en PyPI
+- [ ] Landing en lanzakit.dev
+- [ ] Soporte para más frameworks de testing
+
+## Contribuir
+
+¿Encontraste un bug o tienes una idea? Abre un [issue](https://github.com/lanzakit/starter-kit/issues) o envía un PR. Lee [CONTRIBUTING.md](CONTRIBUTING.md) para conocer el flujo de trabajo.
+
+## Licencia
+
+Distribuido bajo licencia MIT. Consulta el archivo [LICENSE](LICENSE).
+
+---
+
+[@lanzakit](https://x.com/lanzakit) · Construido en Bolivia 🇧🇴 para devs hispanohablantes

lanzakit_tester-0.1.0/README.md

@@ -0,0 +1,149 @@
+# Lanzakit Tester
+
+![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue?logo=python&logoColor=white)
+![License MIT](https://img.shields.io/badge/license-MIT-green)
+<!-- TODO: agregar badge PyPI después del primer release -->
+
+**Tests de pytest generados por IA, y verificados antes de que los veas.**
+
+Lanzakit Tester es un MCP server que lee tu código Python, genera tests con Claude y los ejecuta para confirmar que compilan y pasan. Dejas de revisar tests que ni siquiera corren.
+
+## Features
+
+- 🧪 **Generación de tests con Claude**: analiza tu código y produce tests pytest listos para usar.
+- ✅ **Validación automática**: verifica la sintaxis y ejecuta pytest antes de entregarte el resultado.
+- 🔌 **MCP nativo**: funciona con Claude Desktop y cualquier cliente compatible con MCP.
+- 🌳 **Análisis con AST**: entiende funciones, clases y firmas antes de armar el prompt.
+- 🇪🇸 **Español-first**: comentarios de los tests y documentación en español.
+- 🔓 **Open source**: licencia MIT, sin lock-in.
+
+## Requisitos
+
+- Python 3.11+
+- Una API key de Anthropic (`ANTHROPIC_API_KEY`)
+- Acceso al modelo `claude-sonnet-5`
+
+## Instalación
+
+```bash
+pip install lanzakit-tester
+echo "ANTHROPIC_API_KEY=tu_api_key" > .env
+```
+
+> El archivo `.env` contiene tu API key. Nunca lo subas a git.
+
+### Opción A: Vía Claude Desktop (MCP config)
+
+Agrega el server a tu `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "lanzakit-tester": {
+      "command": "lanzakit-tester"
+    }
+  }
+}
+```
+
+Reinicia Claude Desktop y las 3 tools aparecerán disponibles.
+
+### Opción B: Vía Python
+
+Sin cliente MCP, puedes invocar las tools directamente desde Python:
+
+```bash
+python -c "from lanzakit_tester import generate_and_validate_tests; print(generate_and_validate_tests('/ruta/a/tu_archivo.py')['summary'])"
+```
+
+### Para contribuir
+
+```bash
+git clone https://github.com/lanzakit/starter-kit.git
+cd starter-kit
+uv venv && source .venv/bin/activate
+uv pip install -e ".[dev]"
+```
+
+## Uso
+
+Tienes un archivo `hola_claude.py` (ver `examples/hola_claude.py`, versión simplificada):
+
+```python
+import os
+
+from anthropic import Anthropic
+from dotenv import load_dotenv
+
+load_dotenv()
+client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
+
+def saludar():
+    message = client.messages.create(
+        model="claude-sonnet-5",
+        max_tokens=512,
+        messages=[{"role": "user", "content": "Hola Claude"}]
+    )
+    print(message.content[0].text)
+```
+
+Desde Claude Desktop, pídele:
+
+> Genera y valida tests para `/ruta/a/tu_archivo.py`
+
+Claude llama a la tool `generate_and_validate_tests` y obtienes un resumen como este:
+
+```text
+✅ 8 tests generados y pasaron. Guardado en: /ruta/a/test_tu_archivo.py
+```
+
+El archivo `test_tu_archivo.py` queda junto a tu código, listo para correr con `pytest`.
+
+### Tools disponibles
+
+| Tool | Qué hace |
+|------|----------|
+| `analyze_python_file` | Analiza la estructura del código con AST. |
+| `generate_tests_for_file` | Genera tests pytest con Claude. |
+| `generate_and_validate_tests` | Genera, valida sintaxis, guarda y ejecuta pytest. |
+
+## Cómo funciona
+
+```text
+código .py
+   │
+   ▼
+análisis AST  ──►  prompt a Claude  ──►  tests generados
+                                              │
+                                              ▼
+                      resultado  ◄──  ejecución pytest  ◄──  validación sintáctica
+```
+
+1. Lee tu archivo y extrae su estructura con AST.
+2. Arma un prompt con el código y su contexto, y se lo envía a Claude (`claude-sonnet-5`).
+3. Limpia la respuesta (por ejemplo, quita markdown fences).
+4. Valida que los tests tengan sintaxis Python correcta.
+5. Guarda el archivo y ejecuta pytest.
+6. Devuelve un resumen: cuántos pasaron, fallaron o dieron error.
+
+## Roadmap
+
+- [x] 3 tools funcionales
+- [x] Validación end-to-end
+- [x] Empaquetado como paquete pip
+- [ ] Publicación en PyPI
+- [ ] Landing en lanzakit.dev
+- [ ] Soporte para más frameworks de testing
+
+## Contribuir
+
+¿Encontraste un bug o tienes una idea? Abre un [issue](https://github.com/lanzakit/starter-kit/issues) o envía un PR. Lee [CONTRIBUTING.md](CONTRIBUTING.md) para conocer el flujo de trabajo.
+
+## Licencia
+
+Distribuido bajo licencia MIT. Consulta el archivo [LICENSE](LICENSE).
+
+---
+
+[@lanzakit](https://x.com/lanzakit) · Construido en Bolivia 🇧🇴 para devs hispanohablantes

lanzakit_tester-0.1.0/examples/hola_claude.py

@@ -0,0 +1,46 @@
+"""
+Primer script: saludar a Claude y verificar que la API funciona.
+Este script es el 'Hola Mundo' del proyecto Lanzakit Tester.
+"""
+import os
+from anthropic import Anthropic
+from dotenv import load_dotenv
+
+# Cargar variables de entorno desde .env
+load_dotenv()
+
+# Inicializar cliente de Claude
+client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
+
+def saludar():
+    """Envía un mensaje de prueba a Claude y muestra la respuesta."""
+    message = client.messages.create(
+        model="claude-sonnet-5",
+        max_tokens=512,
+        messages=[
+            {
+                "role": "user",
+                "content": (
+                    "Hola Claude, soy Raquel y estoy construyendo "
+                    "Lanzakit Tester, un agente de IA para generar tests "
+                    "de Python. ¿Estás listo para ayudarme en este proyecto? "
+                    "Responde en 2 líneas."
+                ),
+            }
+        ],
+    )
+
+    print("Respuesta de Claude:")
+    print("-" * 50)
+    print(message.content[0].text)
+    print("-" * 50)
+    print(
+        f"\nTokens usados: "
+        f"{message.usage.input_tokens} input + "
+        f"{message.usage.output_tokens} output"
+    )
+
+
+if __name__ == "__main__":
+    saludar()

lanzakit_tester-0.1.0/examples/test_hola_claude.py

@@ -0,0 +1,157 @@
+"""
+Tests para hola_claude.py: verifica la lógica de saludar()
+mockeando la frontera externa (API de Anthropic).
+"""
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+# El módulo bajo prueba instancia Anthropic() al importarse (nivel módulo).
+# Por eso mockeamos la clase Anthropic ANTES de importar hola_claude,
+# para evitar llamadas reales o errores por falta de API key.
+@pytest.fixture
+def mock_anthropic_client():
+    """Reemplaza la clase Anthropic por un mock antes de importar el módulo."""
+    with patch("anthropic.Anthropic") as mock_class:
+        mock_instance = MagicMock()
+        mock_class.return_value = mock_instance
+        yield mock_class, mock_instance
+
+
+@pytest.fixture
+def hola_claude_module(mock_anthropic_client, monkeypatch):
+    """Importa (o recarga) hola_claude con Anthropic ya mockeado."""
+    # Aseguramos que exista una API key dummy para que os.getenv no sea None.
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "fake-key-for-tests")
+
+    import importlib
+    import sys
+
+    # Si el módulo ya fue importado por otro test, lo removemos para
+    # forzar una reimportación limpia con el mock activo.
+    if "hola_claude" in sys.modules:
+        del sys.modules["hola_claude"]
+
+    module = importlib.import_module("hola_claude")
+    importlib.reload(module)
+    return module
+
+
+def _build_fake_message(text="Respuesta de prueba", input_tokens=10, output_tokens=5):
+    """Construye un objeto mensaje falso con la forma que espera el código."""
+    fake_message = MagicMock()
+    fake_content_block = MagicMock()
+    fake_content_block.text = text
+    fake_message.content = [fake_content_block]
+    fake_message.usage.input_tokens = input_tokens
+    fake_message.usage.output_tokens = output_tokens
+    return fake_message
+
+
+def test_saludar_llama_a_messages_create_con_modelo_correcto(
+    hola_claude_module, mock_anthropic_client
+):
+    """Protege contra regresiones que cambien el modelo o rompan la llamada a la API."""
+    _, mock_instance = mock_anthropic_client
+    mock_instance.messages.create.return_value = _build_fake_message()
+
+    hola_claude_module.client = mock_instance  # aseguramos el mock en el módulo
+    hola_claude_module.saludar()
+
+    mock_instance.messages.create.assert_called_once()
+    _, kwargs = mock_instance.messages.create.call_args
+    assert kwargs["model"] == "claude-sonnet-5"
+    assert kwargs["max_tokens"] == 512
+
+
+def test_saludar_envia_mensaje_con_rol_user_y_contenido_no_vacio(
+    hola_claude_module, mock_anthropic_client
+):
+    """Protege contra cambios accidentales en el payload enviado a Claude."""
+    _, mock_instance = mock_anthropic_client
+    mock_instance.messages.create.return_value = _build_fake_message()
+
+    hola_claude_module.client = mock_instance
+    hola_claude_module.saludar()
+
+    _, kwargs = mock_instance.messages.create.call_args
+    messages = kwargs["messages"]
+    assert len(messages) == 1
+    assert messages[0]["role"] == "user"
+    assert isinstance(messages[0]["content"], str)
+    assert len(messages[0]["content"]) > 0
+
+
+def test_saludar_imprime_respuesta_y_tokens(
+    hola_claude_module, mock_anthropic_client, capsys
+):
+    """Protege contra regresiones en el formato de salida: texto y conteo de tokens."""
+    _, mock_instance = mock_anthropic_client
+    mock_instance.messages.create.return_value = _build_fake_message(
+        text="Sí, estoy listo.", input_tokens=42, output_tokens=7
+    )
+
+    hola_claude_module.client = mock_instance
+    hola_claude_module.saludar()
+
+    captured = capsys.readouterr()
+    assert "Sí, estoy listo." in captured.out
+    assert "42 input" in captured.out
+    assert "7 output" in captured.out
+
+
+@pytest.mark.parametrize(
+    "input_tokens,output_tokens",
+    [
+        (0, 0),  # caso límite: respuesta sin consumo de tokens reportado
+        (1, 1),  # caso mínimo no nulo
+        (100000, 50000),  # caso de valores grandes, detecta overflow o truncamiento
+    ],
+)
+def test_saludar_formatea_distintos_valores_de_tokens(
+    hola_claude_module, mock_anthropic_client, capsys, input_tokens, output_tokens
+):
+    """Protege contra errores de formato al construir el string de tokens usados."""
+    _, mock_instance = mock_anthropic_client
+    mock_instance.messages.create.return_value = _build_fake_message(
+        input_tokens=input_tokens, output_tokens=output_tokens
+    )
+
+    hola_claude_module.client = mock_instance
+    hola_claude_module.saludar()
+
+    captured = capsys.readouterr()
+    assert f"{input_tokens} input" in captured.out
+    assert f"{output_tokens} output" in captured.out
+
+
+def test_saludar_propaga_excepcion_si_api_falla(
+    hola_claude_module, mock_anthropic_client
+):
+    """Verifica que un error de la API no se silencia, sino que se propaga al llamador."""
+    _, mock_instance = mock_anthropic_client
+    mock_instance.messages.create.side_effect = RuntimeError("fallo de red simulado")
+
+    hola_claude_module.client = mock_instance
+
+    with pytest.raises(RuntimeError, match="fallo de red simulado"):
+        hola_claude_module.saludar()
+
+
+def test_client_se_inicializa_con_api_key_desde_entorno(
+    mock_anthropic_client, monkeypatch
+):
+    """Protege contra regresiones donde la API key deje de leerse de la variable de entorno."""
+    mock_class, _ = mock_anthropic_client
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "clave-especifica-de-test")
+
+    import importlib
+    import sys
+
+    if "hola_claude" in sys.modules:
+        del sys.modules["hola_claude"]
+    importlib.import_module("hola_claude")
+
+    mock_class.assert_called_once_with(api_key="clave-especifica-de-test")

lanzakit_tester-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "lanzakit-tester"
+version = "0.1.0"
+description = "MCP server that generates and validates pytest tests using Claude."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Raquel Martinez" }]
+keywords = ["mcp", "pytest", "testing", "ai", "claude", "anthropic"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = [
+    "anthropic>=2.0.0",
+    "python-dotenv>=1.0.0",
+    "mcp[cli]>=2.0.0",
+    "pytest>=8.0.0",
+]
+
+[project.optional-dependencies]
+dev = ["black", "isort"]
+
+[project.urls]
+Homepage = "https://github.com/lanzakit/starter-kit"
+Repository = "https://github.com/lanzakit/starter-kit"
+Issues = "https://github.com/lanzakit/starter-kit/issues"
+
+[project.scripts]
+lanzakit-tester = "lanzakit_tester.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lanzakit_tester"]

lanzakit_tester-0.1.0/requirements-dev.txt

@@ -0,0 +1,3 @@
+black>=24.0.0
+isort>=5.13.0
+pytest>=8.0.0

lanzakit_tester-0.1.0/src/lanzakit_tester/__init__.py

@@ -0,0 +1,14 @@
+"""Lanzakit Tester: genera y valida tests pytest con IA (MCP server)."""
+from lanzakit_tester.server import (
+    __version__,
+    analyze_python_file,
+    generate_and_validate_tests,
+    generate_tests_for_file,
+)
+
+__all__ = [
+    "__version__",
+    "analyze_python_file",
+    "generate_and_validate_tests",
+    "generate_tests_for_file",
+]

lanzakit_tester-0.1.0/src/lanzakit_tester/cli.py

@@ -0,0 +1,25 @@
+"""Entrypoint de línea de comandos de Lanzakit Tester."""
+import argparse
+
+from lanzakit_tester import __version__
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="lanzakit-tester",
+        description="Lanzakit Tester: MCP server que genera y valida tests pytest con IA. "
+        "Sin argumentos, arranca el servidor MCP por stdio.",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    parser.parse_args()
+
+    # Import diferido: evita inicializar el servidor si solo se pide --help/--version
+    from lanzakit_tester.server import run
+
+    run()
+
+
+if __name__ == "__main__":
+    main()

lanzakit_tester-0.1.0/src/lanzakit_tester/server.py

@@ -0,0 +1,422 @@
+"""
+Lanzakit Tester - MCP Server
+
+Agente de IA para generar y analizar tests de Python.
+"""
+import ast
+import os
+import subprocess
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+from anthropic import Anthropic
+from dotenv import load_dotenv
+from mcp.server.mcpserver import MCPServer
+
+load_dotenv()
+
+try:
+    __version__ = version("lanzakit-tester")
+except PackageNotFoundError:  # ejecutando desde el código fuente sin instalar
+    __version__ = "0.0.0+unknown"
+
+# Modelo de Claude usado para generar los tests (único punto de configuración)
+MODEL = "claude-sonnet-5"
+
+anthropic_client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
+
+def _clean_code_output(text: str) -> str:
+    """Remueve markdown fences si Claude los agrega a pesar del prompt."""
+    text = text.strip()
+    if text.startswith("```python"):
+        text = text[9:].lstrip()
+    elif text.startswith("```"):
+        text = text[3:].lstrip()
+    if text.endswith("```"):
+        text = text[:-3].rstrip()
+    return text
+
+
+# Crear el servidor MCP
+mcp = MCPServer("lanzakit-tester", version=__version__)
+
+
+@mcp.tool()
+def analyze_python_file(file_path: str) -> dict:
+    """
+    Analiza un archivo Python y devuelve información estructural.
+
+    Lee el archivo, lo parsea con AST (Abstract Syntax Tree) y extrae:
+    - Nombre del archivo
+    - Número de líneas totales
+    - Lista de clases definidas
+    - Lista de funciones definidas (incluye métodos de clases)
+    - Imports utilizados
+
+    Args:
+        file_path: Ruta absoluta al archivo .py a analizar
+
+    Returns:
+        Diccionario con el análisis estructural del archivo
+    """
+    path = Path(file_path)
+
+    # Validaciones básicas
+    if not path.exists():
+        return {"error": f"El archivo {file_path} no existe"}
+
+    if path.suffix != ".py":
+        return {"error": f"El archivo debe ser .py, no {path.suffix}"}
+
+    # Leer el contenido
+    try:
+        source_code = path.read_text(encoding="utf-8")
+    except Exception as e:
+        return {"error": f"No se pudo leer el archivo: {e}"}
+
+    # Parsear con AST
+    try:
+        tree = ast.parse(source_code)
+    except SyntaxError as e:
+        return {"error": f"El archivo tiene errores de sintaxis: {e}"}
+
+    # Extraer información
+    classes = []
+    functions = []
+    imports = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            classes.append({
+                "name": node.name,
+                "line": node.lineno,
+                "methods": [
+                    n.name for n in node.body
+                    if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+                ]
+            })
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            functions.append({
+                "name": node.name,
+                "line": node.lineno,
+                "args": [arg.arg for arg in node.args.args]
+            })
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append(alias.name)
+        elif isinstance(node, ast.ImportFrom):
+            module = node.module or ""
+            for alias in node.names:
+                imports.append(f"{module}.{alias.name}")
+
+    return {
+        "file": path.name,
+        "total_lines": len(source_code.splitlines()),
+        "classes": classes,
+        "functions": functions,
+        "imports": imports,
+    }
+
+
+GENERATE_TESTS_PROMPT = """Eres Lanzakit Tester, un ingeniero senior de Python especializado en pytest.
+
+Tu tarea: generar un archivo de tests pytest de alta calidad para el código proporcionado. Los tests deben detectar regresiones reales, ser deterministas y enseñar buenas prácticas con comentarios breves en español neutro LATAM.
+
+<codigo_a_testear ruta="{file_path}">
+{source_code}
+</codigo_a_testear>
+
+<reglas_fundamentales>
+
+1. FIDELIDAD AL CÓDIGO
+- Testea el comportamiento OBSERVABLE del código, no lo que crees que debería hacer
+- No inventes contratos ni validaciones que el código no implementa
+- Usa docstrings, type hints y validaciones como fuente de verdad
+
+2. EDGE CASES JUSTIFICADOS
+- Cada test debe responder: "¿qué regresión específica detectaría?"
+- Deriva casos de las ramas, operaciones y límites reales del código
+- No incluyas casos genéricos sin justificación
+
+3. IMPORTS Y DEPENDENCIAS
+- Solo usa: pytest, unittest.mock, biblioteca estándar
+- NO inventes: fixtures custom, pytest-plugins externos, módulos que no existen
+- Para importar el código bajo prueba usa el nombre del archivo sin extensión
+- Si no puedes determinar la ruta de import con confianza, NO inventes
+
+4. PYTEST MODERNO
+- Usa pytest.mark.parametrize cuando varios casos compartan verificación
+- Usa pytest.raises para excepciones
+- Usa fixtures solo cuando reduzcan duplicación real
+- Nombres: test_<funcion>_<escenario>_<resultado>
+
+5. COMENTARIOS EDUCATIVOS
+- Comentarios BREVES en español explicando qué regresión protege cada test
+- Un comentario por test o por grupo parametrizado, no por línea
+- Nombres de funciones y variables en inglés (convención Python estándar)
+
+6. MOCKING RESPONSABLE
+- No mockees la función bajo prueba
+- Mockea solo fronteras externas (red, archivos, servicios)
+- Prefiere lógica real sin mocks cuando sea posible
+
+</reglas_fundamentales>
+
+<prohibiciones>
+- NO inventar imports, fixtures, módulos o dependencias
+- NO usar assert True ni aserciones triviales
+- NO capturar Exception genérica para hacer pasar un test
+- NO incluir Markdown, ```python, preámbulos ni explicaciones externas al código
+- NO modificar el código fuente del usuario
+</prohibiciones>
+
+<formato_salida>
+Devuelve EXCLUSIVAMENTE código Python válido, listo para guardar como test_<nombre>.py.
+Primera línea: un import o un comentario Python.
+No incluyas nada antes ni después del código.
+</formato_salida>"""
+
+
+@mcp.tool()
+def generate_tests_for_file(file_path: str) -> dict:
+    """
+    Genera tests pytest de alta calidad para un archivo Python usando Claude.
+
+    Lee el archivo, lo envía a Claude con un prompt optimizado para testing,
+    y devuelve el código de los tests generado.
+
+    Args:
+        file_path: Ruta absoluta al archivo .py a testear
+
+    Returns:
+        Diccionario con:
+        - file: nombre del archivo original
+        - test_code: código Python de los tests generados
+        - tokens_used: cuántos tokens consumió la llamada
+    """
+    path = Path(file_path)
+
+    if not path.exists():
+        return {"error": f"El archivo {file_path} no existe"}
+
+    if path.suffix != ".py":
+        return {"error": f"El archivo debe ser .py, no {path.suffix}"}
+
+    try:
+        source_code = path.read_text(encoding="utf-8")
+    except Exception as e:
+        return {"error": f"No se pudo leer el archivo: {e}"}
+
+    if not source_code.strip():
+        return {"error": "El archivo está vacío"}
+
+    # Llamar a Claude
+    try:
+        message = anthropic_client.messages.create(
+            model=MODEL,
+            max_tokens=16384,
+            thinking={"type": "disabled"},
+            messages=[
+                {
+                    "role": "user",
+                    "content": GENERATE_TESTS_PROMPT.format(
+                        source_code=source_code,
+                        file_path=str(path)
+                    )
+                }
+            ]
+        )
+    except Exception as e:
+        return {"error": f"Error llamando a Claude API: {e}"}
+
+    # Buscar el primer bloque de texto (puede haber ThinkingBlocks antes)
+    test_code = next(
+        (block.text for block in message.content if block.type == "text"),
+        None
+    )
+
+    if test_code is None:
+        return {"error": "Claude no devolvió contenido de texto"}
+
+    # Limpiar markdown fences si los hay
+    test_code = _clean_code_output(test_code)
+
+    return {
+        "file": path.name,
+        "test_code": test_code,
+        "tokens_used": {
+            "input": message.usage.input_tokens,
+            "output": message.usage.output_tokens
+        }
+    }
+
+@mcp.tool()
+def generate_and_validate_tests(
+    file_path: str,
+    save_to: str = ""
+) -> dict:
+    """
+    Flujo completo: genera tests, valida sintaxis, ejecuta y reporta.
+    
+    Esta tool cierra el loop de calidad: no solo genera tests sino que
+    verifica que compilen y que pasen antes de entregárselos al usuario.
+    
+    Args:
+        file_path: Ruta absoluta al archivo .py a testear
+        save_to: Ruta donde guardar el archivo de tests (opcional).
+                 Si está vacío, usa test_<nombre>.py al lado del archivo original.
+    
+    Returns:
+        Dict con:
+        - test_code: código de los tests generados
+        - saved_to: dónde se guardó
+        - syntax_valid: bool
+        - execution: resultados de pytest (passed/failed/errors)
+        - summary: resumen legible
+    """
+    path = Path(file_path)
+    
+    # Paso 1: generar los tests (reutilizamos la tool existente)
+    generation_result = generate_tests_for_file(file_path)
+    
+    if "error" in generation_result:
+        return generation_result
+    
+    test_code = generation_result["test_code"]
+    
+    # Paso 2: validar sintaxis
+    syntax_check = _validate_syntax(test_code)
+    
+    if not syntax_check["valid"]:
+        return {
+            "test_code": test_code,
+            "saved_to": None,
+            "syntax_valid": False,
+            "syntax_error": syntax_check["error"],
+            "execution": None,
+            "summary": f"❌ Tests generados pero con error de sintaxis: {syntax_check['error']}",
+            "tokens_used": generation_result["tokens_used"],
+        }
+    
+    # Paso 3: determinar dónde guardar
+    if save_to:
+        save_path = Path(save_to)
+    else:
+        save_path = path.parent / f"test_{path.stem}.py"
+    
+    # Paso 4: guardar el archivo
+    try:
+        save_path.write_text(test_code, encoding="utf-8")
+    except Exception as e:
+        return {
+            "test_code": test_code,
+            "saved_to": None,
+            "syntax_valid": True,
+            "execution": None,
+            "summary": f"⚠️ Tests válidos pero no se pudieron guardar: {e}",
+            "tokens_used": generation_result["tokens_used"],
+        }
+    
+    # Paso 5: ejecutar pytest
+    execution = _run_pytest(save_path, source_dir=path.parent)
+    
+    # Paso 6: armar resumen
+    if execution.get("all_passed"):
+        summary = (
+            f"✅ {execution['passed']} tests generados y pasaron. "
+            f"Guardado en: {save_path}"
+        )
+    elif "error" in execution:
+        summary = f"⚠️ Tests generados pero no se pudieron ejecutar: {execution['error']}"
+    else:
+        summary = (
+            f"⚠️ {execution.get('passed', 0)} pasaron, "
+            f"{execution.get('failed', 0)} fallaron, "
+            f"{execution.get('errors', 0)} errores. "
+            f"Guardado en: {save_path}"
+        )
+    
+    return {
+        "test_code": test_code,
+        "saved_to": str(save_path),
+        "syntax_valid": True,
+        "execution": execution,
+        "summary": summary,
+        "tokens_used": generation_result["tokens_used"],
+    }
+
+def _validate_syntax(code: str) -> dict:
+    """Valida que el código sea Python sintácticamente correcto."""
+    try:
+        ast.parse(code)
+        return {"valid": True}
+    except SyntaxError as e:
+        return {
+            "valid": False,
+            "error": f"Línea {e.lineno}: {e.msg}",
+            "offset": e.offset,
+        }
+
+
+def _run_pytest(test_file_path: Path, source_dir: Path, timeout: int = 30) -> dict:
+    """
+    Ejecuta pytest sobre un archivo de tests en un subproceso aislado.
+    
+    Args:
+        test_file_path: Ruta al archivo de tests
+        source_dir: Directorio desde donde ejecutar pytest (para resolución de imports)
+        timeout: Segundos máximos antes de matar el proceso
+    
+    Returns:
+        Dict con: passed, failed, errors, output, stderr
+    """
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pytest", str(test_file_path), "-v", "--tb=short", "--no-header"],
+            cwd=str(source_dir),
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        
+        output = result.stdout
+        stderr = result.stderr
+        
+        # Parsear resultados básicos del output
+        passed = output.count(" PASSED")
+        failed = output.count(" FAILED")
+        errors = output.count(" ERROR")
+        
+        return {
+            "passed": passed,
+            "failed": failed,
+            "errors": errors,
+            "all_passed": result.returncode == 0,
+            "output": output[-2000:],
+            "stderr": stderr[-500:] if stderr else "",
+        }
+    except subprocess.TimeoutExpired:
+        return {
+            "error": f"pytest excedió timeout de {timeout}s",
+            "all_passed": False,
+        }
+    except FileNotFoundError:
+        return {
+            "error": "pytest no está instalado en el entorno",
+            "all_passed": False,
+        }
+    except Exception as e:
+        return {
+            "error": f"Error ejecutando pytest: {e}",
+            "all_passed": False,
+        }
+
+def run() -> None:
+    """Arranca el servidor MCP usando stdio (lo que Claude Desktop espera)."""
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    run()