llm-dev-core 0.3.0__tar.gz → 0.5.0__tar.gz

{llm_dev_core-0.3.0 → llm_dev_core-0.5.0}/ARCHITECTURE.md

@@ -1,6 +1,6 @@
 # ARCHITECTURE.md — llm-dev-core
 
-> **Estado:** v0.3 (seed revisado) · **Última revisión:** 2026-09-21
+> **Estado:** v0.4 (seed revisado) · **Última revisión:** 2026-09-22
 > **Audiencia:** yo en 52 semanas, cualquiera que revise este repo, y entrevistadores técnicos.
 
 ---
@@ -46,6 +46,7 @@ Las métricas de este proyecto no son aspiracionales. Cada una tiene una fuente
 | Superficie nueva ≤ 30% | Manifest del consumidor | `new_surface` y `reused_modules` declarados y revisados |
 | Llamadas LLM vía `llm-client` | Código | Lint anti-imports directos: el build falla si un repo importa el SDK fuera de `llm-client` |
 | Prompts en el registry | Archivos de prompts | Lint anti-prompts inline + frontmatter obligatorio desde sem. 2 |
+| Todo prompt nuevo tiene eval (desde sem. 5) | Frontmatter `eval` + dataset | `make validate-consumer` rompe si el prompt referencia un eval que no existe / con dataset vacío |
 | Evals en CI desde sem. 5 | CI del consumidor | Job `eval-smoke` obligatorio en la plantilla |
 | Retrofittings documentados | Issues/PRs | Label `retrofit` + plantilla antes/después |
 | Compat check | CI del core | Workflow `compat-last-5` en cada merge a `main` |
@@ -131,7 +132,7 @@ La reparación tiene **presupuesto**: máximo 2 intentos y un cap de costo por m
 
 ```yaml
 id: commit-message-generator
-version: 0.3.0
+version: 0.4.0
 owner: llm-dev-core
 model_family: gpt-4o-mini
 schema: CommitMessage
@@ -339,11 +340,11 @@ La regla es simple: si no puedes pagar el eval de forma repetible, el eval está
 
 ## 10. Estado actual
 
-- **Versión:** v0.3
-- **Módulos existentes:** `packages/llm-client` v0.1.0 (seed sem. 2) — `complete`/`stream`, retry+backoff+jitter, reparación con tope, cap de costo, cache, span de 20 campos, record/replay nativo, transportes `opencode` (sesión local sin API key) y `openai-compatible` (HTTP). `packages/schema-validate` v0.1.0 (seed sem. 3) — validación Pydantic de la salida LLM (ADR-2): JSON con/sin caretas, errores campo a campo, registro `SchemaId → modelo`, `parsed` en `ValidationResult`; compone con `llm-client` vía el hook `validator`.
-- **Consumidores:** `Proyectos/commit-cli` (sem. 2) — CLI que propone mensajes de commit desde `git diff`; `Proyectos/release-scribe` (sem. 3) — release notes JSON validadas por `schema-validate` desde `git log`. Ambos dependen de la dist unificada `llm-dev-core` (editable). La métrica de reutilización real se medirá en §10.1 desde el corte de semanal.
-- **Empaquetado:** una sola dist `llm-dev-core`, publicable vía `uv build`/`uv publish` con `llm_client` y `schema_validate` top-level (D1). Pendiente la primera publicación real en PyPI (se cierra en la sem. 3 con v0.3).
-- **Enforcement:** ADR-0, ADR-1 (`llm-client-contract`) y ADR-2 (`schema-validate-contract`) en `docs/decisions/`, plantillas en `templates/`, `make validate` (estructura + tests) y `make validate-consumer CONSUMER=../<repo>`.
+- **Versión:** v0.5
+- **Módulos existentes:** `packages/llm-client` v0.1.0 (seed sem. 2) — `complete`/`stream`, retry+backoff+jitter, reparación con tope, cap de costo, cache, span de 20 campos, record/replay nativo, transportes `opencode` (sesión local sin API key) y `openai-compatible` (HTTP). `packages/schema-validate` v0.1.0 (seed sem. 3) — validación Pydantic de la salida LLM (ADR-2): JSON con/sin caretas, errores campo a campo, registro `SchemaId → modelo`, `parsed` en `ValidationResult`; compone con `llm-client` vía el hook `validator` (que respeta el contrato `schema=None → ok` desde v0.5). `packages/secure-base` v0.1.0 (seed sem. 4) — utilidad de máscara (ADR-3): `detect`/`redact`/`sanitize_for_prompt`/`assert_redacted` + `SecurityProfile`; máscara unidireccional y determinista (placeholder `[REDACTED:<tipo>:<n>]`), 9 detectores, hoja de la seguridad (no depende de `llm-client` ni `schema-validate`); compone en los renderers, antes de que el texto cruce al proveedor. `packages/test-kit` v0.1.0 (seed sem. 5) — los tests de prompts son datasets (ADR-4): `EvalDataset.from_jsonl` (casos `{prompt_id, prompt_version, input, expected, criteria}`), tres criterios deterministas (`deterministic_match`, `json_match`, `schema_match`), runner agnóstico del transporte (`judge: EvalCase → CompletionResult` inyectado), modo `smoke`/`full`, umbral y costo acumulado (§8.1).
+- **Consumidores:** `Proyectos/commit-cli` (sem. 2) — CLI que propone mensajes de commit desde `git diff`; `Proyectos/release-scribe` (sem. 3) — release notes JSON validadas por `schema-validate` desde `git log`; `Proyectos/sec-check` (sem. 4) — escáner de secretos con triaje LLM: redacta con `secure-base` y aborta si `assert_redacted` no es vacío, reporte `sec-findings-v1` validado por `schema-validate`; `Proyectos/bench-runner` (sem. 5) — CLI de evals con datasets congelados y umbral (exit 0/1/2) cuyo propio prompt `regression-report-generator` (triaje de regresión en `modo json`/`modo texto`) nace evaluado: dogfood del seed, reusa `llm-client` + `schema-validate` + `test-kit`, cassettes reales para CI determinista (D4). Los cuatro dependen de la dist unificada `llm-dev-core` (editable). La métrica de reutilización real se medirá en §10.1 desde el corte de semanal.
+- **Empaquetado:** una sola dist `llm-dev-core` (D1) publicada en PyPI: `llm_client`, `schema_validate`, `secure_base` y `test_kit` top-level. La publicación es automática desde tag `v*` vía trusted publishing OIDC (workflow `publish.yml`, sin tokens guardados).
+- **Enforcement:** ADR-0, ADR-1 (`llm-client-contract`), ADR-2 (`schema-validate-contract`), ADR-3 (`secure-base-contract`) y ADR-4 (`test-kit-dataset-contract`) en `docs/decisions/`, plantillas en `templates/`, `make validate` (estructura + tests) y `make validate-consumer CONSUMER=../<repo>`.
 - **Pasos por semana según el plan:** se mantiene el calendario semanal (estructura C1–C18 de §5, armonizada en la sem. 3): `schema-validate` (sem. 3), `secure-base` (sem. 4), `test-kit` (sem. 5), `web-api-base` (sem. 6), `ci-pack` (sem. 7), `cache-ratelimit` (sem. 8), `bot-base` (sem. 9), `parser-io` (sem. 10), `docs-gen` (sem. 12), ... hasta `cost-obs` (sem. 39).
 - **Próximo hito:** v1.0 en la semana 13, con 12 consumidores reales detrás.
 

llm_dev_core-0.5.0/CHANGELOG.md

@@ -0,0 +1,83 @@
+# Changelog
+
+La versión es la del paquete `llm-dev-core`. El historial comienza con **v1.0 (semana 13)** — hasta entonces el core es `0.x` y puede romperse sin aviso (D3).
+
+## v0.5 — 2026-09-22 (test-kit seed)
+
+- Semana 5: nace `packages/test-kit` v0.1.0 dentro de un consumidor real (`bench-runner`).
+  - Contrato ADR-4: los tests de un prompt son datasets — `EvalDataset.from_jsonl` con casos
+    `{prompt_id, prompt_version, input, expected, criteria}`; a partir de v0.5 un fichero inexistente
+    se reporta como `DatasetError` (exit 2), no como traceback.
+  - Tres criterios deterministas: `deterministic_match` (colapsa espacios, opción `ignore_case`),
+    `json_match` (JSON con/sin caretas) y `schema_match` (estructura validada vía `schema-validate`,
+    `expected` opcional).
+  - Runner agnóstico del transporte: el consumidor inyecta `judge: EvalCase → CompletionResult`; el
+    runner suma `pass_rate`, compara contra `threshold` y acumula `cost_usd`. Modos `smoke`/`full` (§8.1).
+- Cuarto consumidor: `Proyectos/bench-runner` (sem. 5) — CLI `bench-runner` que evalúa prompts contra
+  datasets congelados (exit 0 verde, 1 regresión, 2 dataset inválido). Su propio prompt
+  `regression-report-generator` (triaje de regresión, `modo json` para reportes estructurados y
+  `modo texto` para veredicto en línea) nace evaluado: dogfood del seed. 4 casos, cassette real
+  grabado, replay determinista en CI (D4) que hasta reproduce la reparación grabada.
+- `schema-validate`: el hook `validator` respeta el contrato `schema=None → ok` (necesario para que
+  `modo texto` no fuerce reparaciones JSON al validar salidas sin schema).
+- Regla nueva en vigor desde la sem. 5: todo prompt nuevo del core/consumidores debe tener evaluación
+  (frontmatter `eval` + dataset no vacío), enforced por `make validate-consumer`.
+- Wheel unificado (D1): `llm-dev-core 0.5.0` empaqueta `llm_client` + `schema_validate` + `secure_base`
+  + `test_kit` top-level. `make validate` y `validate-consumer` (4 consumidores) en verde; 49 tests.
+
+## v0.4 — 2026-09-22 (secure-base seed)
+
+- Semana 4: nace `packages/secure-base` v0.1.0 dentro de un consumidor real (`sec-check`).
+  - Contrato ADR-3: `detect`/`redact`/`sanitize_for_prompt`/`assert_redacted` + `SecurityProfile` (declaración
+    de tipos para el lint anti-secretos de `ci-pack`, sem. 7).
+  - Máscara unidireccional y determinista: placeholder `[REDACTED:<tipo>:<n>]`; `Finding.match` es preview
+    truncado (24 chars), nunca el secreto completo. 9 detectores (email, phone, ipv4, credit_card, aws_access_key,
+    github_token, private_key, bearer, url_userinfo).
+  - `secure-base` es hoja (no depende de `llm-client` ni de `schema-validate`); se compone en el renderer del
+    consumidor, antes de que el texto cruce al proveedor.
+- Tercer consumidor: `Proyectos/sec-check` (sem. 4) — escáner de secretos con triaje LLM: detecta en `git diff`
+  o archivo, redacta con `secure-base`, aborta si `assert_redacted` no es vacío, y solo el texto enmascarado viaja
+  al LLM (`opencode` local o replay). Reporte `sec-findings-v1` validado con `schema-validate`; exit 0 sin secretos,
+  1 con secretos, 2 inválido. Tape real grabado con 3 hallazgos críticos, replay en verde.
+- Wheel unificado (D1): `llm-dev-core 0.4.0` ahora empaqueta `llm_client` + `schema_validate` + `secure_base`
+  top-level. `make validate` y `validate-consumer` (3 consumidores) en verde; 37 tests.
+- Publicado `llm-dev-core 0.4.0` en PyPI (trusted publishing, tag `v0.4.0`).
+- Nota del cómo: el primer tag `v0.4.0` se creó antes del bump de versión en `pyproject.toml`, así que la
+  primera ejecución de `publish.yml` subió el wheel `0.3.0` ya existente (409 en PyPI). Se corrigió bumping
+  a `0.4.0` y reconstruyendo el tag sobre ese commit (queda un run fallido en Actions y un mensaje de commit
+  de "0.4" que no incluía el bump; el estado final es correcto). Lección: el tag de publicación se crea
+  **después** de confirmar la versión en `pyproject.toml`.
+
+## v0.3 — 2026-09-21 (schema-validate seed + dist unificada)
+
+- Semana 3: nace `packages/schema-validate` v0.1.0 dentro de un consumidor real (`release-scribe`).
+  - Contrato ADR-2: validación Pydantic de la salida LLM (JSON con/sin caretas, errores campo a campo),
+    registro `SchemaId → modelo`, `parsed` poblando `CompletionResult.parsed`.
+  - Reparación: el lazo/presupuesto/cap sigue en `llm-client` (hoja); `schema-validate` alimenta los
+    errores vía el hook `validator`. Ajuste menor ADR-1: `ValidationResult.parsed`.
+  - Tape real grabado de `opencode run` sin API key (replica validada con `parsed`).
+- **Empaquetado unificado (D1):** el core pasa a publicarse como una sola dist `llm-dev-core` (0.3.0)
+  con `llm_client` y `schema_validate` top-level; los consumidores dependen de `llm-dev-core ^0.3`, nunca
+  de módulos sueltos. `commit-cli` migra a la dist unificada.
+- Segundo consumidor: `Proyectos/release-scribe` (sem. 3) — release notes JSON validadas desde `git log`;
+  reutiliza `llm-client` + `schema-validate`.
+- Calendario armonizado (§5 vs. §10): `schema-validate` (3), `secure-base` (4), `test-kit` (5),
+  `web-api-base` (6), `ci-pack` (7), `cache-ratelimit` (8), `bot-base` (9), … hasta `cost-obs` (39).
+  Deuda aprobada en el review: la sem-2 quería publicar ya en PyPI; al unificar el empaquetado, la primera
+  publicación real pasa a ser esta v0.3.
+- Publicado `llm-dev-core 0.3.0` en PyPI (trusted publishing OIDC, workflow `publish.yml` en tags `v*`):
+  primera release real del core; instalable y verificado desde el registro (D1).
+
+## v0.2 — 2026-09-20 (llm-client seed)
+
+- Semana 2: nace `packages/llm-client` v0.1.0 dentro de un consumidor real (`commit-cli`).
+  - Contrato ADR-1 aceptada: `complete`/`stream`, retry+backoff+jitter, reparación con tope, cap de costo, cache, span de 20 campos.
+  - Record/replay nativo: cassettes sin API key (`ReplayProvider`); tape real grabado con el transport `opencode` (sesión local, sin key).
+  - Transportes: `opencode` (`opencode run --format json`) y `openai-compatible` (HTTP).
+  - Workspace uv activado (`members = ["packages/*"]`); grupo dev de pytest. `make validate` ahora también corre los tests.
+  - Primer consumidor: `Proyectos/commit-cli` (único módulo del core reutilizado a la fecha: `llm-client`). La métrica de reutilización real se medirá en §10.1 desde el corte de semanal.
+
+## v0.1 — 2026-09-20 (seed)
+
+- Semana 1: documento `ARCHITECTURE.md`, ADR-0 (stack Python 3.12+), contrato mínimo de `llm-client`, plantillas de consumidor.
+- Enforcement base (§3): `scripts/check_consumers.py` implementado (modo `--self` y de consumidor), `make validate` y workflow `ci.yml`. Pendiente hasta sem. 6: lint anti-imports, evals en CI y página de evidencia (ci-pack).

{llm_dev_core-0.3.0 → llm_dev_core-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: llm-dev-core
-Version: 0.3.0
+Version: 0.5.0
 Summary: Núcleo versionado del que dependen 52 proyectos en 52 semanas: un solo sistema acumulativo.
 Author-email: binahco <binahco.sas@gmail.com>
 Requires-Python: >=3.12

{llm_dev_core-0.3.0 → llm_dev_core-0.5.0}/README.md

@@ -6,15 +6,15 @@ Núcleo versionado y publicado del que dependen 52 proyectos en 52 semanas: un s
 
 Toda llamada a un LLM pasa por `llm-client`, toda salida no confiable pasa por `schema-validate`, todo prompt vive en `prompt-registry`. Ver `ARCHITECTURE.md` para la tesis, las decisiones (D1–D12) y las métricas verificables.
 
-- **Estado:** v0.3 · Semana 3
+- **Estado:** v0.5 · Semana 5
 - **Stack:** Python 3.12+ (ADR-0, `docs/decisions/0000-stack.md`)
 - **Estructura:** `packages/` (módulos), `templates/` (consumidor clonable), `scripts/` (verificación), `docs/`
-- **Empaquetado:** una sola dist `llm-dev-core` (D1): `llm_client` y `schema_validate` top-level; los consumidores dependen de `llm-dev-core ^0.x`, nunca de módulos sueltos.
+- **Empaquetado:** una sola dist `llm-dev-core` (D1): `llm_client`, `schema_validate`, `secure_base` y `test_kit` top-level; los consumidores dependen de `llm-dev-core ^0.x`, nunca de módulos sueltos.
 
 ## Desarrollo
 
 ```bash
 uv sync        # instala el workspace
 make validate  # invariantes: estructura, plantillas, ADR-0, sintaxis
-uv run pytest  # tests (aún ninguno hasta sem. 2)
+uv run pytest  # tests (49 a la fecha)
 ```

llm_dev_core-0.5.0/docs/decisions/0003-secure-base-contract.md

@@ -0,0 +1,66 @@
+# Contrato mínimo — `secure-base`
+
+- **Fecha:** 2026-09-22
+- **Estado:** aceptada
+- **Origen:** §3.1 en `ARCHITECTURE.md`
+- **Implementada en:** semana 4 (`packages/secure-base` v0.1.0, nacida dentro de `sec-check`)
+
+Este documento es el contrato escrito contra el que se implementa la semana 4. Define la utilidad de
+máscara que exige §3.1.1 y el perfil de declaración que alimentará los lints de `ci-pack` (sem. 7).
+
+## 1. API conceptual
+
+```python
+detect(text) -> list[Finding]            # hallazgos tipados (sin mutar texto)
+redact(text) -> RedactResult             # texto enmascarado + hallazgos
+sanitize_for_prompt(text) -> RedactResult  # alias semántico para renderers
+assert_redacted(text, profile?) -> list[Finding]  # violaciones de §3.1
+```
+
+```python
+class Finding(BaseModel):
+    type: str        # email | phone | ipv4 | credit_card | aws_access_key | github_token | private_key | bearer | url_userinfo
+    match: str       # preview truncado (24 chars) — NUNCA el secreto completo
+    offset: int      # offset del primer carácter
+    length: int      # para reemplazos deterministas
+    line: int        # 1-based
+```
+
+## 2. Reglas de la máscara
+
+- **Unidireccional:** el secreto crudo no se conserva en ningún lugar del resultado. No hay operación inversa.
+- **Determinista:** misma entrada → misma salida (mismo texto y mismos placeholders).
+- **Placeholder:** `[REDACTED:<type>:<n>]`, con `n` por tipo (1-based, en orden de aparición).
+- **`Finding.match` es un preview truncado**: suficiente para triaje, insuficiente para re-inyectar el secreto.
+- **`detect` es no destructivo**: el scanner se usa antes de decidir qué se envía; `redact` produce la salida
+  que sí puede cruzar el límite del prompt.
+
+## 3. Perfil y lints (§3.1.1 → ci-pack)
+
+- `SecurityProfile(data_types: list[str])`: qué tipos declara manejar el consumidor.
+- `assert_redacted(text, profile) -> list[Finding]`: si el resultado **no está vacío**, el texto aún contiene
+  secretos en claro declarados por el perfil → violación de la regla 1 de §3.1.
+- El enforcement operativo (que el build falle si un prompt de producción llega con secretos) se implementa
+  en `ci-pack` (sem. 7); `secure-base` es el motor que ese lint usaría.
+
+## 4. Composición con el resto del core
+
+- `secure-base` **no depende de `llm-client`** ni de `schema-validate`: es la hoja de la seguridad. Se compone
+  en el renderer del consumidor (antes de construir los mensajes) y en el preámbulo del flujo.
+- `llm-client` redacta `<variable>` en sus spans por contrato (ADR-1, §1); `secure-base` hace lo mismo aguas
+  arriba, sobre el payload que podría entrar a un prompt.
+
+## 5. Qué NO contrata este documento
+
+- No define el lint anti-prompts (sem. 7, `ci-pack`): solo su motor de detección.
+- No reemplaza el manejo de secretos de la máquina del desarrollador: no es un gestor de claves.
+- No garantiza detección perfecta: los patrones son heurísticos; la prueba de que algo no se filtró es
+  estructural (el texto que sale de `redact` no contiene ningún hallazgo).
+
+## 6. Criterio de aceptación del contrato (semana 4)
+
+- [x] `detect` encuentra los 9 tipos en un texto de prueba y no delira con código limpio.
+- [x] `redact` es unidireccional y determinista: nada del secreto crudo sobrevive; mismo input → mismo output.
+- [x] `sanitize_for_prompt` deja `assert_redacted(...) == []` (el texto que cruza al proveedor está limpio).
+- [x] `assert_redacted(text, profile)` filtra por los tipos declarados.
+- [x] Primer consumidor real: `sec-check` (sem. 4), que redacta diffs antes de enviarlos al LLM.

llm_dev_core-0.5.0/docs/decisions/0004-test-kit-dataset-contract.md

@@ -0,0 +1,71 @@
+# Contrato mínimo — `test-kit`
+
+- **Fecha:** 2026-09-22
+- **Estado:** aceptada
+- **Origen:** D7 (ARCHITECTURE.md), §8.1, ADR-1 §109
+- **Implementada en:** semana 5 (`packages/test-kit` v0.1.0, nacida dentro de `bench-runner`)
+
+Los tests de un sistema LLM no son assertions: son **datasets**. Este ADR fija el formato de dataset y el
+motor de evaluación determinista que todos los consumidores usarán desde la semana 5.
+
+## 1. Dataset: formato de archivo (JSONL)
+
+```jsonl
+{"prompt_id": "…", "prompt_version": "0.1.0", "input": {"…": "…"},
+ "expected": <sólido esperado o texto>, "criteria": {"type": "…", "schema": "…", "note": "…"}}
+```
+
+- Una línea = un caso (`EvalCase`). Un archivo = un prompt (`EvalDataset.from_jsonl`).
+- Todos los casos de un dataset comparten `prompt_id` y `prompt_version` (error si se mezclan).
+- `input` son las variables que el renderer del consumidor formatea.
+- `expected` depende del criterio (ver §2).
+- Archivos viven en `evals/` del consumidor y se referencian desde el `frontmatter.eval` del prompt
+  (ya exigido por `check_consumers.py`).
+
+## 2. Criterios de evaluación (v0.1 — deterministas)
+
+| type | `expected` | pasa si |
+|---|---|---|
+| `deterministic_match` | texto | la salida normalizada (espacios + opcional `ignore_case`) es idéntica |
+| `json_match` | dict o list | el JSON parseado de la salida es `==` (con/sin fenced ```json```) |
+| `schema_match` | dict (opcional) | la salida valida contra el schema (`schema:` en el criterio) **y** si hay `expected`, el objeto parseado coincide |
+
+Los tres son puros: mismo input → mismo veredicto. Costo de ejecución ≈ 0 en CI porque corren sobre
+cassettes de `ReplayProvider` (ADR-1, D4) — el build nunca golpea APIs vivas.
+
+## 3. Runner y umbral (`test_kit.run`)
+
+```python
+run(dataset, judge, *, mode="smoke", threshold=1.0) -> EvalReport
+```
+
+- `judge: EvalCase -> CompletionResult` lo cablea el **consumidor** (LlmClient + su renderer + replay o record).
+  El runner es agnóstico del transporte: no sabe si ejecuta replay o record.
+- `mode`: `smoke` (diario, barato, dataset corto) vs `full` (releases, cambios de prompt/modelo). §8.1.
+- `threshold`: fracción [0,1] de casos que deben pasar. `EvalReport.threshold_ok` rompe el CI si no se llega.
+- `EvalReport` agrega: total/passed/pass_rate, `cost_usd` (suma de los resultados), y un caso por ítem.
+
+## 4. Horizontalidad y dependencias
+
+- `test-kit` depende de `llm-client` (para `CompletionResult`) y de `schema-validate` (para `extract_json`).
+  **Jamás al revés** (ARCHITECTURE:214): el cliente no sabe qué es un dataset.
+- La calibración (D7) NO está en este contrato: un criterio no determinista (LLM-as-judge) necesitaría
+  ~20 casos de ground truth etiquetados a mano para detectar bias. Queda como hook futuro (`criterion.type`
+  se extiende sin romper el resto); el `LLM_JUDGE` se documenta como pendiente, no se implementa esta semana.
+- El *formato de cassette* que ADR-1 delega en test-kit es el que ya existe en `ReplayProvider`: este módulo
+  no reimplementa el formato, lo consume.
+
+## 5. Qué NO contrata
+
+- No decide el umbral por proyecto (eso es del `core-consumer.yml`, quemado en CI por cada consumidor).
+- No define qué prompt tiene dataset: `check_consumers.py` obliga que el `frontmatter.eval` exista (sem. 5+).
+- No es un runner de CI: `ci-pack` (sem. 7) conectará `run()` a jobs. Aquí ya está el primitivo.
+
+## 6. Criterios de aceptación (semana 5)
+
+- [x] `EvalDataset.from_jsonl` valida JSON, rechaza casos mal formados y evita mezclar prompt_ids.
+- [x] `deterministic_match` y `json_match` pasan con fenced JSON y normalización de espacios/caso.
+- [x] `schema_match` valida contra un modelo del `SchemaRegistry` y reporta errores campo a campo.
+- [x] `run` calcula pass_rate, `threshold_ok` y suma `cost_usd`; distingue `smoke`/`full`.
+- [x] Primer consumidor real: `bench-runner` (sem. 5) — su propio prompt nace con dataset en `evals/` y tapas reales.
+- [x] El dataset de `bench-runner` combina los tres criterios: `schema_match` + `json_match` + `deterministic_match`.

llm_dev_core-0.5.0/docs/metrics/README.md

@@ -0,0 +1,8 @@
+# Métricas
+
+Datos crudos y agregados de la página de evidencia (§10.1).
+
+Estado actual: sin datos. Semanas 1–5 tienen consumidores (`commit-cli`, `release-scribe`, `sec-check`,
+`bench-runner`) pero aún no hay llamadas agregadas ni corriendo en CI. El andamiaje
+(`scripts/collect_metrics.py`) se implementa en la semana 6 con `ci-pack`; a partir de ahí
+`docs/metrics/` se regenera en cada merge.

{llm_dev_core-0.3.0 → llm_dev_core-0.5.0}/packages/schema-validate/src/schema_validate/registry.py

@@ -28,6 +28,8 @@ class SchemaRegistry:
         model = self.get(schema_id)
 
         def validator(text: str, schema: str | None = None) -> ValidationResult:
+            if schema is None:
+                return ValidationResult(ok=True, errors=[], parsed=None)
             return validate_text(model, text)
 
         return validator

{llm_dev_core-0.3.0 → llm_dev_core-0.5.0}/packages/schema-validate/tests/test_schema_validate.py

@@ -78,7 +78,7 @@ def test_registry_make_validator_via_factory() -> None:
 def test_default_registry_register() -> None:
     register("legacy", ReleaseNotes)
     validator = make_validator("legacy")
-    assert validator("x").ok is False
+    assert validator("x", "legacy").ok is False
 
 
 class SequenceProvider:
@@ -161,4 +161,17 @@ def test_llm_client_validation_failed_after_cap() -> None:
     span = spans[0]
     assert span.status == "failed"
     assert span.repaired_attempts == 2
-    assert span.error_type == "validation"
+    assert span.error_type == "validation"
+
+
+def test_validator_skips_when_schema_is_none() -> None:
+    """Contrato validar-por-contrato: sin schema, el validador no repara (modo texto)."""
+    registry = SchemaRegistry()
+    registry.register("release-notes-v1", ReleaseNotes)
+    validator = registry.make_validator("release-notes-v1")
+
+    result = validator("una linea de texto sin json", None)
+
+    assert result.ok is True
+    assert result.errors == []
+    assert result.parsed is None

llm_dev_core-0.5.0/packages/secure-base/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "llm-dev-secure-base"
+version = "0.1.0"
+description = "secure-base: secretos y datos sensibles nunca entran en prompts sin redacción (§3.1)."
+requires-python = ">=3.12"
+dependencies = [
+    "pydantic>=2.7",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/secure_base"]

llm_dev_core-0.5.0/packages/secure-base/src/secure_base/__init__.py

@@ -0,0 +1,14 @@
+from .findings import Finding
+from .profile import DATA_TYPE_NAMES, SecurityProfile, assert_redacted
+from .redact import RedactResult, detect, redact, sanitize_for_prompt
+
+__all__ = [
+    "DATA_TYPE_NAMES",
+    "Finding",
+    "RedactResult",
+    "SecurityProfile",
+    "assert_redacted",
+    "detect",
+    "redact",
+    "sanitize_for_prompt",
+]

llm_dev_core-0.5.0/packages/secure-base/src/secure_base/detectors.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from .findings import Finding
+
+
+def _preview(raw: str, limit: int = 24) -> str:
+    match = raw[:limit]
+    return match + "…" if len(raw) > limit else match
+
+
+@dataclass(frozen=True)
+class Detector:
+    type: str
+    pattern: re.Pattern[str]
+
+    def scan(self, text: str) -> list[Finding]:
+        findings: list[Finding] = []
+        for m in self.pattern.finditer(text):
+            raw = m.group(0)
+            findings.append(
+                Finding(
+                    type=self.type,
+                    match=_preview(raw),
+                    offset=m.start(),
+                    length=len(raw),
+                    line=text.count("\n", 0, m.start()) + 1,
+                )
+            )
+        return findings
+
+
+DETECTORS: tuple[Detector, ...] = (
+    Detector("email", re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")),
+    Detector("phone", re.compile(r"(?:\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b")),
+    Detector("ipv4", re.compile(r"\b(?:\d{1,3}\.){3}\d{1,3}\b")),
+    Detector("credit_card", re.compile(r"\b(?:\d{4}[ -]?){3}\d{4}\b")),
+    Detector("aws_access_key", re.compile(r"\b(?:AKIA|ASIA)[A-Z0-9]{16}\b")),
+    Detector("github_token", re.compile(r"\b(?:ghp_|gho_|ghu_|ghs_|ghr_|github_pat_)[A-Za-z0-9_]{20,}\b")),
+    Detector("private_key", re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----")),
+    Detector("bearer", re.compile(r"\bBearer [A-Za-z0-9._~+/-]+=*\b")),
+    Detector("url_userinfo", re.compile(r"(?i)\b\w+://[\w.-]+:[^@\s]+@")),
+)
+
+
+def scan(text: str) -> list[Finding]:
+    findings: list[Finding] = []
+    for detector in DETECTORS:
+        findings.extend(detector.scan(text))
+    return sorted(findings, key=lambda f: (f.offset, f.type))

llm_dev_core-0.5.0/packages/secure-base/src/secure_base/findings.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+
+class Finding(BaseModel):
+    type: str
+    match: str
+    offset: int
+    length: int
+    line: int

llm_dev_core-0.5.0/packages/secure-base/src/secure_base/profile.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .detectors import scan
+from .findings import Finding
+
+DATA_TYPE_NAMES = ("email", "phone", "ipv4", "credit_card", "aws_access_key", "github_token", "private_key", "bearer", "url_userinfo")
+
+
+class SecurityProfile(BaseModel):
+    """Qué tipos de datos declara manejar el consumidor (§3.1 y futuro lint de ci-pack)."""
+
+    data_types: list[str]
+
+
+def assert_redacted(text: str, profile: SecurityProfile | None = None) -> list[Finding]:
+    """Devuelve hallazgos que siguen en claro en `text`.
+
+    Si el texto se va a enviar a un proveedor externo, un resultado no vacío es una violación.
+    Con `profile`, filtra a los tipos declarados por el consumidor.
+    """
+    findings = scan(text)
+    if profile is None:
+        return findings
+    declared = set(profile.data_types)
+    return [f for f in findings if f.type in declared]

llm_dev_core-0.5.0/packages/secure-base/src/secure_base/redact.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .detectors import scan
+from .findings import Finding
+
+
+class RedactResult(BaseModel):
+    text: str
+    findings: list[Finding]
+
+
+def detect(text: str) -> list[Finding]:
+    """Detecta secretos/PII sin redactar. Alimenta reportes y lints."""
+    return scan(text)
+
+
+def redact(text: str) -> RedactResult:
+    """Enmascara de forma unidireccional y determinista: el secreto crudo no queda en el texto."""
+    findings = scan(text)
+    counters: dict[str, int] = {}
+    pieces: list[str] = []
+    cursor = 0
+    for f in findings:
+        pieces.append(text[cursor : f.offset])
+        counters[f.type] = counters.get(f.type, 0) + 1
+        pieces.append(f"[REDACTED:{f.type}:{counters[f.type]}]")
+        cursor = f.offset + f.length
+    pieces.append(text[cursor:])
+    return RedactResult(text="".join(pieces), findings=findings)
+
+
+def sanitize_for_prompt(text: str) -> RedactResult:
+    """Alias semántico para el renderer: nada sensible entra al prompt."""
+    return redact(text)

llm_dev_core-0.5.0/packages/secure-base/tests/test_secure_base.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from secure_base import SecurityProfile, assert_redacted, detect, redact, sanitize_for_prompt
+
+SAMPLE = """prueba con persona@ejemplo.com y también conta@otra.co
+token ghp_AbCdEfGhIjKlMnOpQrStUvWxYz123456
+aws AKIAIOSFODNN7EXAMPLE en plena línea
+privada:
+-----BEGIN RSA PRIVATE KEY-----
+incluye https://usuario:pass@host.com/path
+Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.abc
+tel +57 300 123 4567 y tarjeta 4111 1111 1111 1111
+ip 192.168.0.1 cliente"""
+
+
+def test_detect_types_positive() -> None:
+    findings = detect(SAMPLE)
+    types = {f.type for f in findings}
+    assert {
+        "email",
+        "github_token",
+        "aws_access_key",
+        "private_key",
+        "url_userinfo",
+        "bearer",
+        "phone",
+        "credit_card",
+        "ipv4",
+    } == types
+
+
+def test_no_false_positive_on_plain_text() -> None:
+    findings = detect("solo código normal sin secretos: return None")
+    assert findings == []
+
+
+def test_redact_is_one_way_and_deterministic() -> None:
+    result = redact(SAMPLE)
+    assert "persona@ejemplo.com" not in result.text
+    assert "ghp_" not in result.text
+    assert "AKIA" not in result.text
+    assert "usuario:pass" not in result.text
+    assert "Bearer eyJ" not in result.text
+    second = redact(SAMPLE)
+    assert result.text == second.text
+
+
+def test_redact_keeps_placeholders_and_structure() -> None:
+    result = redact(SAMPLE)
+    assert "[REDACTED:email:1]" in result.text
+    assert "[REDACTED:private_key:1]" in result.text
+    assert result.findings
+    assert result.findings[0].line >= 1
+
+
+def test_sanitize_for_prompt_never_leaves_raw_secrets() -> None:
+    clean = sanitize_for_prompt(SAMPLE)
+    assert assert_redacted(clean.text) == []
+
+
+def test_assert_redacted_filters_by_profile() -> None:
+    profile = SecurityProfile(data_types=["email"])
+    findings = assert_redacted(SAMPLE, profile)
+    assert findings and all(f.type == "email" for f in findings)
+
+    ok = assert_redacted(redact(SAMPLE).text, profile)
+    assert ok == []
+
+
+def test_detect_reports_offset_and_line() -> None:
+    findings = detect(SAMPLE)
+    email = next(f for f in findings if f.type == "email")
+    assert email.offset == SAMPLE.find("persona@ejemplo.com")
+    assert SAMPLE.count("\n", 0, email.offset) + 1 == 1

llm_dev_core-0.5.0/packages/test-kit/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "llm-dev-test-kit"
+version = "0.1.0"
+description = "test-kit: en desarrollo LLM, los tests son datasets (D7, semana 5)."
+requires-python = ">=3.12"
+dependencies = [
+    "llm-dev-client",
+    "llm-dev-schema-validate",
+    "pydantic>=2.7",
+]
+
+[tool.uv.sources]
+llm-dev-client = { workspace = true }
+llm-dev-schema-validate = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/test_kit"]

llm_dev_core-0.5.0/packages/test-kit/src/test_kit/__init__.py

@@ -0,0 +1,17 @@
+from .criteria import CriterionResult, deterministic_match, json_match, schema_match
+from .dataset import Criterion, DatasetError, EvalCase, EvalDataset
+from .runner import CaseResult, EvalReport, run
+
+__all__ = [
+    "CaseResult",
+    "Criterion",
+    "CriterionResult",
+    "DatasetError",
+    "EvalCase",
+    "EvalDataset",
+    "EvalReport",
+    "deterministic_match",
+    "json_match",
+    "run",
+    "schema_match",
+]

llm_dev_core-0.5.0/packages/test-kit/src/test_kit/criteria.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import re
+
+from llm_client import ValidationResult
+from pydantic import BaseModel
+
+from schema_validate import extract_json
+
+
+class CriterionResult(BaseModel):
+    passed: bool
+    detail: str
+
+
+def normalize(text: str, *, ignore_case: bool = False) -> str:
+    """Colapsa espacios y normaliza el caso para comparaciones deterministas."""
+    collapsed = " ".join(re.split(r"\s+", str(text).strip()))
+    return collapsed.lower() if ignore_case else collapsed
+
+
+def deterministic_match(expected, raw_text: str, *, ignore_case: bool = False) -> CriterionResult:
+    exp = normalize(expected, ignore_case=ignore_case)
+    got = normalize(raw_text, ignore_case=ignore_case)
+    return CriterionResult(
+        passed=exp == got,
+        detail="" if exp == got else f"esperado {exp!r} ≠ salida {got!r}",
+    )
+
+
+def json_match(expected, raw_text: str) -> CriterionResult:
+    try:
+        got = extract_json(raw_text)
+    except (ValueError, TypeError) as exc:
+        return CriterionResult(passed=False, detail=f"JSON inválido: {exc}")
+    passed = got == expected
+    return CriterionResult(
+        passed=passed,
+        detail="" if passed else f"JSON ≠ esperado (salida={got!r})",
+    )
+
+
+def schema_match(expected, raw_text: str, validation: ValidationResult) -> CriterionResult:
+    if not validation.ok:
+        return CriterionResult(passed=False, detail="; ".join(validation.errors))
+    if expected is not None:
+        parsed = validation.parsed
+        passed = _deep_equal(parsed, expected)
+        return CriterionResult(
+            passed=passed,
+            detail="" if passed else f"estructura válida pero ≠ expected ({parsed!r})",
+        )
+    return CriterionResult(passed=True, detail="")
+
+
+def _deep_equal(a, b) -> bool:
+    if isinstance(a, BaseModel):
+        a = a.model_dump()
+    if isinstance(b, BaseModel):
+        b = b.model_dump()
+    return a == b

llm_dev_core-0.5.0/packages/test-kit/src/test_kit/dataset.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class DatasetError(ValueError):
+    """Dataset de eval mal formado: JSON inválido, campos faltantes o prompt_ids mezclados."""
+
+
+class Criterion(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    type: Literal["deterministic_match", "json_match", "schema_match"]
+    schema_id: str | None = Field(default=None, validation_alias="schema", serialization_alias="schema")
+    ignore_case: bool = False
+    note: str | None = None
+
+
+class EvalCase(BaseModel):
+    prompt_id: str
+    prompt_version: str
+    input: dict[str, Any]
+    expected: Any = None
+    criteria: Criterion
+
+
+class EvalDataset(BaseModel):
+    prompt_id: str
+    prompt_version: str
+    cases: list[EvalCase] = Field(default_factory=list)
+
+    @classmethod
+    def from_jsonl(cls, path: str | Path) -> "EvalDataset":
+        p = Path(path)
+        try:
+            lines = p.read_text().splitlines()
+        except FileNotFoundError as exc:
+            raise DatasetError(f"{p}: fichero no encontrado") from exc
+        cases: list[EvalCase] = []
+        for lineno, line in enumerate(lines, start=1):
+            if not line.strip():
+                continue
+            try:
+                raw = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise DatasetError(f"{p}:{lineno}: JSON inválido: {exc}") from exc
+            cases.append(EvalCase.model_validate(raw))
+
+        if not cases:
+            raise DatasetError(f"{p}: dataset vacío")
+
+        first = cases[0]
+        for case in cases[1:]:
+            if (case.prompt_id, case.prompt_version) != (first.prompt_id, first.prompt_version):
+                raise DatasetError(
+                    f"{p}: prompt_id/version mezclados (esperaba {first.prompt_id}@{first.prompt_version})"
+                )
+
+        return cls(prompt_id=first.prompt_id, prompt_version=first.prompt_version, cases=cases)

llm_dev_core-0.5.0/packages/test-kit/src/test_kit/runner.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from decimal import Decimal
+
+from llm_client import CompletionResult, ValidationResult
+from pydantic import BaseModel, Field
+
+from .criteria import CriterionResult, deterministic_match, json_match, schema_match
+from .dataset import EvalCase, EvalDataset
+
+Judge = Callable[[EvalCase], CompletionResult]
+
+
+class CaseResult(BaseModel):
+    index: int
+    passed: bool
+    detail: str = ""
+
+
+class EvalReport(BaseModel):
+    prompt_id: str
+    prompt_version: str
+    mode: str
+    threshold: float
+    total: int
+    passed: int
+    pass_rate: float
+    threshold_ok: bool
+    cost_usd: Decimal = Field(default_factory=Decimal)
+    cases: list[CaseResult] = Field(default_factory=list)
+
+
+def _apply(case: EvalCase, result: CompletionResult) -> tuple[CriterionResult, str]:
+    """Devuelve el resultado del criterio y la nota del caso.
+
+    Segundo elemento: nota del criterio (si existe), que alimenta el reporte.
+    """
+    criteria = case.criteria
+    note = criteria.note or ""
+    if criteria.type == "deterministic_match":
+        return deterministic_match(case.expected, result.raw_text, ignore_case=criteria.ignore_case), note
+    if criteria.type == "json_match":
+        return json_match(case.expected, result.raw_text), note
+    if criteria.type == "schema_match":
+        return schema_match(case.expected, result.raw_text, result.validation), note
+    raise ValueError(f"criteria desconocido: {criteria.type}")
+
+
+def run(
+    dataset: EvalDataset,
+    judge: Judge,
+    *,
+    mode: str = "smoke",
+    threshold: float = 1.0,
+) -> EvalReport:
+    """Ejecuta un dataset de eval sobre el juez dado (cableado por el consumidor).
+
+    - `mode`: 'smoke' (diario, barato) o 'full' (releases, cambios de prompt/modelo).
+      El juez decide si usa replay (CI, determinista) o graba (record); el runner es agnóstico.
+    - `threshold`: fracción [0, 1] de casos que deben pasar para que el eval esté OK.
+    """
+    cases: list[CaseResult] = []
+    passed = 0
+    cost = Decimal("0")
+
+    for index, case in enumerate(dataset.cases, start=1):
+        result = judge(case)
+        cost += result.cost_usd
+        criterion, note = _apply(case, result)
+        ok = criterion.passed
+        cases.append(
+            CaseResult(
+                index=index,
+                passed=ok,
+                detail=note or criterion.detail,
+            )
+        )
+        if ok:
+            passed += 1
+
+    total = len(dataset.cases)
+    pass_rate = passed / total if total else 0.0
+    return EvalReport(
+        prompt_id=dataset.prompt_id,
+        prompt_version=dataset.prompt_version,
+        mode=mode,
+        threshold=threshold,
+        total=total,
+        passed=passed,
+        pass_rate=pass_rate,
+        threshold_ok=pass_rate >= threshold,
+        cost_usd=cost,
+        cases=cases,
+    )

llm_dev_core-0.5.0/packages/test-kit/tests/test_test_kit.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from decimal import Decimal
+
+import pytest
+from llm_client import CompletionResult, TokenUsage, ValidationResult
+from pydantic import BaseModel
+from test_kit import (
+    DatasetError,
+    EvalCase,
+    EvalDataset,
+    EvalReport,
+    deterministic_match,
+    json_match,
+    run,
+    schema_match,
+)
+
+SCHEMA_ID = "eval-demo-v1"
+
+
+class Demo(BaseModel):
+    summary: str
+    ok: bool
+
+
+def _result(raw_text: str, *, cost: Decimal = Decimal("0"), validation: ValidationResult | None = None) -> CompletionResult:
+    return CompletionResult(
+        raw_text=raw_text,
+        parsed=Demo.model_validate(raw_text) if validation and validation.ok else None,
+        validation=validation or ValidationResult(ok=True),
+        usage=TokenUsage(input_tokens=1, output_tokens=1),
+        cost_usd=cost,
+        latency_ms=1,
+        prompt_id="x",
+        prompt_version="0.1.0",
+        model_alias="fast",
+        model="demo",
+        provider="stub",
+        span_id="s",
+    )
+
+
+def _case(criteria: dict, *, expected=None) -> EvalCase:
+    return EvalCase(
+        prompt_id="prompt-demo",
+        prompt_version="0.1.0",
+        input={},
+        expected=expected,
+        criteria=criteria,
+    )
+
+
+def _dataset(tmp_path, lines: list[str]) -> EvalDataset:
+    path = tmp_path / "cases.jsonl"
+    path.write_text("\n".join(lines) + "\n")
+    return EvalDataset.from_jsonl(path)
+
+
+def test_from_jsonl_ok(tmp_path) -> None:
+    ds = _dataset(
+        tmp_path,
+        [
+            '{"prompt_id":"p","prompt_version":"0.1.0","input":{},"expected":"feat: x","criteria":{"type":"deterministic_match"}}',
+            '{"prompt_id":"p","prompt_version":"0.1.0","input":{},"expected":"feat: y","criteria":{"type":"deterministic_match"}}',
+        ],
+    )
+    assert ds.prompt_id == "p"
+    assert len(ds.cases) == 2
+
+
+def test_from_jsonl_malformed(tmp_path) -> None:
+    path = tmp_path / "cases.jsonl"
+    path.write_text('{"prompt_id": broken\n')
+    with pytest.raises(DatasetError, match="JSON inválido"):
+        EvalDataset.from_jsonl(path)
+
+
+def test_from_jsonl_mixed_prompts(tmp_path) -> None:
+    with pytest.raises(DatasetError, match="mezclados"):
+        _dataset(
+            tmp_path,
+            [
+                '{"prompt_id":"p","prompt_version":"0.1.0","input":{},"criteria":{"type":"deterministic_match"}}',
+                '{"prompt_id":"q","prompt_version":"0.1.0","input":{},"criteria":{"type":"deterministic_match"}}',
+            ],
+        )
+
+
+def test_from_jsonl_empty(tmp_path) -> None:
+    with pytest.raises(DatasetError, match="vacío"):
+        _dataset(tmp_path, [])
+
+
+def test_from_jsonl_missing_file(tmp_path) -> None:
+    with pytest.raises(DatasetError, match="no encontrado"):
+        EvalDataset.from_jsonl(tmp_path / "no-existe.jsonl")
+
+
+def test_deterministic_match_normalizes() -> None:
+    ok = deterministic_match("feat: add retry", "  feat:  add   retry  ")
+    assert ok.passed is True
+    case_sensitive = deterministic_match("Feat: x", "feat: x")
+    assert case_sensitive.passed is False
+    ignore = deterministic_match("Feat: x", "feat: x", ignore_case=True)
+    assert ignore.passed is True
+
+
+def test_json_match_handles_fences() -> None:
+    result = json_match({"a": 1}, "responde con:\n```json\n{\"a\": 1}\n```\n")
+    assert result.passed is True
+    wrong = json_match({"a": 1}, "```json\n{\"a\": 2}\n```")
+    assert wrong.passed is False
+
+
+def test_schema_match_valid_against_expected() -> None:
+    from test_kit.criteria import schema_match as sm
+
+    validation = ValidationResult(ok=True, parsed=Demo(summary="todo bien", ok=True))
+    result = sm({"summary": "todo bien", "ok": True}, '{"summary": "todo bien", "ok": true}', validation)
+    assert result.passed is True
+
+
+def test_schema_match_reports_errors() -> None:
+    from test_kit.criteria import schema_match as sm
+
+    validation = ValidationResult(ok=False, errors=["summary: campo faltante"])
+    result = sm(None, '{"ok": true}', validation)
+    assert result.passed is False
+    assert "campo faltante" in result.detail
+
+
+def test_run_pass_threshold_and_cost(tmp_path) -> None:
+    ds = _dataset(
+        tmp_path,
+        [
+            '{"prompt_id":"p","prompt_version":"0.1.0","input":{},"expected":"feat: x","criteria":{"type":"deterministic_match"}}',
+            '{"prompt_id":"p","prompt_version":"0.1.0","input":{},"expected":"feat: y","criteria":{"type":"deterministic_match"}}',
+        ],
+    )
+
+    def judge(case: EvalCase) -> CompletionResult:
+        return _result(case.expected, cost=Decimal("0.01"))
+
+    report = run(ds, judge, mode="smoke", threshold=1.0)
+    assert isinstance(report, EvalReport)
+    assert report.total == 2
+    assert report.passed == 2
+    assert report.pass_rate == 1.0
+    assert report.threshold_ok is True
+    assert report.cost_usd == Decimal("0.02")
+    assert report.mode == "smoke"
+
+
+def test_run_fails_below_threshold(tmp_path) -> None:
+    ds = _dataset(
+        tmp_path,
+        [
+            '{"prompt_id":"p","prompt_version":"0.1.0","input":{},"expected":"feat: x","criteria":{"type":"deterministic_match"}}',
+            '{"prompt_id":"p","prompt_version":"0.1.0","input":{},"expected":"feat: y","criteria":{"type":"deterministic_match"}}',
+        ],
+    )
+
+    def judge(case: EvalCase) -> CompletionResult:
+        return _result("respuesta incorrecta")
+
+    report = run(ds, judge, mode="full", threshold=1.0)
+    assert report.passed == 0
+    assert report.threshold_ok is False
+    assert report.pass_rate == 0.0

{llm_dev_core-0.3.0 → llm_dev_core-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "llm-dev-core"
-version = "0.3.0"
+version = "0.5.0"
 description = "Núcleo versionado del que dependen 52 proyectos en 52 semanas: un solo sistema acumulativo."
 authors = [{ name = "binahco", email = "binahco.sas@gmail.com" }]
 requires-python = ">=3.12"
@@ -18,6 +18,8 @@ build-backend = "hatchling.build"
 packages = [
     "packages/llm-client/src/llm_client",
     "packages/schema-validate/src/schema_validate",
+    "packages/secure-base/src/secure_base",
+    "packages/test-kit/src/test_kit",
 ]
 
 [tool.uv.workspace]

llm_dev_core-0.3.0/CHANGELOG.md

@@ -1,35 +0,0 @@
-# Changelog
-
-La versión es la del paquete `llm-dev-core`. El historial comienza con **v1.0 (semana 13)** — hasta entonces el core es `0.x` y puede romperse sin aviso (D3).
-
-## v0.3 — 2026-09-21 (schema-validate seed + dist unificada)
-
-- Semana 3: nace `packages/schema-validate` v0.1.0 dentro de un consumidor real (`release-scribe`).
-  - Contrato ADR-2: validación Pydantic de la salida LLM (JSON con/sin caretas, errores campo a campo),
-    registro `SchemaId → modelo`, `parsed` poblando `CompletionResult.parsed`.
-  - Reparación: el lazo/presupuesto/cap sigue en `llm-client` (hoja); `schema-validate` alimenta los
-    errores vía el hook `validator`. Ajuste menor ADR-1: `ValidationResult.parsed`.
-  - Tape real grabado de `opencode run` sin API key (replica validada con `parsed`).
-- **Empaquetado unificado (D1):** el core pasa a publicarse como una sola dist `llm-dev-core` (0.3.0)
-  con `llm_client` y `schema_validate` top-level; los consumidores dependen de `llm-dev-core ^0.3`, nunca
-  de módulos sueltos. `commit-cli` migra a la dist unificada.
-- Segundo consumidor: `Proyectos/release-scribe` (sem. 3) — release notes JSON validadas desde `git log`;
-  reutiliza `llm-client` + `schema-validate`.
-- Calendario armonizado (§5 vs. §10): `schema-validate` (3), `secure-base` (4), `test-kit` (5),
-  `web-api-base` (6), `ci-pack` (7), `cache-ratelimit` (8), `bot-base` (9), … hasta `cost-obs` (39).
-  Deuda aprobada en el review: la sem-2 quería publicar ya en PyPI; al unificar el empaquetado, la primera
-  publicación real pasa a ser esta v0.3.
-
-## v0.2 — 2026-09-20 (llm-client seed)
-
-- Semana 2: nace `packages/llm-client` v0.1.0 dentro de un consumidor real (`commit-cli`).
-  - Contrato ADR-1 aceptada: `complete`/`stream`, retry+backoff+jitter, reparación con tope, cap de costo, cache, span de 20 campos.
-  - Record/replay nativo: cassettes sin API key (`ReplayProvider`); tape real grabado con el transport `opencode` (sesión local, sin key).
-  - Transportes: `opencode` (`opencode run --format json`) y `openai-compatible` (HTTP).
-  - Workspace uv activado (`members = ["packages/*"]`); grupo dev de pytest. `make validate` ahora también corre los tests.
-  - Primer consumidor: `Proyectos/commit-cli` (único módulo del core reutilizado a la fecha: `llm-client`). La métrica de reutilización real se medirá en §10.1 desde el corte de semanal.
-
-## v0.1 — 2026-09-20 (seed)
-
-- Semana 1: documento `ARCHITECTURE.md`, ADR-0 (stack Python 3.12+), contrato mínimo de `llm-client`, plantillas de consumidor.
-- Enforcement base (§3): `scripts/check_consumers.py` implementado (modo `--self` y de consumidor), `make validate` y workflow `ci.yml`. Pendiente hasta sem. 6: lint anti-imports, evals en CI y página de evidencia (ci-pack).

llm_dev_core-0.3.0/docs/metrics/README.md

@@ -1,7 +0,0 @@
-# Métricas
-
-Datos crudos y agregados de la página de evidencia (§10.1).
-
-Estado actual: sin datos. Semanas 1–3 tienen consumidores (`commit-cli`, `release-scribe`) pero aún no hay
-llamadas agregadas ni corriendo en CI. El andamiaje (`scripts/collect_metrics.py`) se implementa en la
-semana 6 con `ci-pack`; a partir de ahí `docs/metrics/` se regenera en cada merge.