siesa-agents 2.1.72-qa.2 → 2.1.72-qa.21

package/siesa-agents/scripts/converters/export_yaml_to_excel.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+export_yaml_to_excel.py — Exporta test-design YAML a Excel (.xlsx)
+Formato: Hoja "Metadata" (key-value) + Hoja "Pasos" (tabla de pasos)
+Uso: python export_yaml_to_excel.py <input.yml> [output.xlsx]
+"""
+
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    print("ERROR: pyyaml requerido. Instalar con: pip install pyyaml")
+    sys.exit(1)
+
+try:
+    from openpyxl import Workbook
+    from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+except ImportError:
+    print("ERROR: openpyxl requerido. Instalar con: pip install openpyxl")
+    sys.exit(1)
+
+
+# --- Estilos Siesa ---
+TEAL = "009688"
+WHITE = "FFFFFF"
+LIGHT_GRAY = "F5F5F5"
+
+HEADER_FONT = Font(name="Calibri", bold=True, color=WHITE, size=11)
+HEADER_FILL = PatternFill(start_color=TEAL, end_color=TEAL, fill_type="solid")
+SECTION_FONT = Font(name="Calibri", bold=True, color=TEAL, size=11)
+NORMAL_FONT = Font(name="Calibri", size=11)
+ALT_FILL = PatternFill(start_color=LIGHT_GRAY, end_color=LIGHT_GRAY, fill_type="solid")
+THIN_BORDER = Border(
+    left=Side(style="thin"), right=Side(style="thin"),
+    top=Side(style="thin"), bottom=Side(style="thin"),
+)
+
+
+def style_header_row(ws, row, col_count):
+    for col in range(1, col_count + 1):
+        cell = ws.cell(row=row, column=col)
+        cell.font = HEADER_FONT
+        cell.fill = HEADER_FILL
+        cell.alignment = Alignment(horizontal="center", vertical="center")
+        cell.border = THIN_BORDER
+
+
+def style_data_cell(cell, row_idx):
+    cell.font = NORMAL_FONT
+    cell.border = THIN_BORDER
+    cell.alignment = Alignment(vertical="top", wrap_text=True)
+    if row_idx % 2 == 0:
+        cell.fill = ALT_FILL
+
+
+def style_section_cell(cell):
+    cell.font = SECTION_FONT
+    cell.border = THIN_BORDER
+
+
+def flatten_value(value) -> str:
+    """Convierte listas y dicts a string legible."""
+    if isinstance(value, list):
+        return " | ".join(str(v) for v in value)
+    if isinstance(value, dict):
+        return " | ".join(f"{k}: {v}" for k, v in value.items())
+    return str(value).strip()
+
+
+# --- Metadata sheet ---
+
+def build_metadata_rows(data: dict) -> list[tuple[str, str, str]]:
+    """Genera filas (seccion, campo, valor) para la hoja Metadata."""
+    rows = []
+
+    def add_section(section_name: str, section_data: dict, fields: list[str]):
+        for field in fields:
+            val = section_data.get(field)
+            if val is not None:
+                rows.append((section_name, field, flatten_value(val)))
+
+    # metadata
+    meta = data.get("metadata", {})
+    add_section("metadata", meta, ["modulo", "version", "autor", "fecha", "stack"])
+
+    # requisito
+    req = data.get("requisito", {})
+    add_section("requisito", req, ["id", "nombre", "descripcion"])
+    criterios = req.get("criterios_aceptacion", [])
+    if criterios:
+        rows.append(("requisito", "criterios_aceptacion", " | ".join(criterios)))
+
+    # plan_pruebas
+    plan = data.get("plan_pruebas", {})
+    add_section("plan_pruebas", plan, ["id", "nombre", "objetivo", "framework"])
+    precondiciones = plan.get("precondiciones", [])
+    if precondiciones:
+        rows.append(("plan_pruebas", "precondiciones", " | ".join(precondiciones)))
+    ambientes = plan.get("ambientes", [])
+    for i, amb in enumerate(ambientes):
+        for key in ("nombre", "url", "usuario"):
+            if key in amb:
+                rows.append((f"plan_pruebas.ambiente_{i}", key, str(amb[key])))
+    tiempos = plan.get("tiempos_referencia", {})
+    for key, val in tiempos.items():
+        rows.append(("plan_pruebas.tiempos", key, str(val)))
+
+    # caso_prueba (sin pasos)
+    caso = data.get("caso_prueba", {})
+    add_section("caso_prueba", caso, ["id", "nombre", "prioridad", "tipo"])
+    scripts = caso.get("scripts", [])
+    if scripts:
+        rows.append(("caso_prueba", "scripts", " | ".join(scripts)))
+
+    # ejecucion
+    ejec = data.get("ejecucion", {})
+    add_section("ejecucion", ejec, ["id", "nombre"])
+    variables = ejec.get("variables_entorno", [])
+    for var in variables:
+        nombre = var.get("nombre", "")
+        desc = var.get("descripcion", "")
+        default = var.get("default", "")
+        rows.append(("ejecucion.variable", nombre, f"{desc} | {default}"))
+    comandos = ejec.get("comandos", {})
+    for key, val in comandos.items():
+        rows.append(("ejecucion.comando", key, str(val)))
+
+    # integraciones
+    integ = data.get("integraciones", {})
+    for integ_name, info in integ.items():
+        for key, val in info.items():
+            rows.append((f"integracion.{integ_name}", key, str(val)))
+
+    return rows
+
+
+def write_metadata_sheet(wb: Workbook, data: dict):
+    ws = wb.active
+    ws.title = "Metadata"
+
+    headers = ["Seccion", "Campo", "Valor"]
+    for col, h in enumerate(headers, 1):
+        ws.cell(row=1, column=col, value=h)
+    style_header_row(ws, 1, len(headers))
+
+    rows = build_metadata_rows(data)
+    prev_section = ""
+    for i, (seccion, campo, valor) in enumerate(rows):
+        row_num = i + 2
+        c_sec = ws.cell(row=row_num, column=1, value=seccion)
+        c_campo = ws.cell(row=row_num, column=2, value=campo)
+        c_valor = ws.cell(row=row_num, column=3, value=valor)
+
+        if seccion != prev_section:
+            style_section_cell(c_sec)
+            prev_section = seccion
+        else:
+            c_sec.font = NORMAL_FONT
+            c_sec.border = THIN_BORDER
+
+        style_data_cell(c_campo, i)
+        style_data_cell(c_valor, i)
+
+    ws.column_dimensions["A"].width = 28
+    ws.column_dimensions["B"].width = 24
+    ws.column_dimensions["C"].width = 80
+
+
+def write_pasos_sheet(wb: Workbook, data: dict):
+    ws = wb.create_sheet("Pasos")
+
+    headers = [
+        "Paso", "Nombre", "Accion", "Resultado Esperado",
+        "Datos", "Script", "Automatizado", "Bloqueado", "Nota",
+    ]
+    for col, h in enumerate(headers, 1):
+        ws.cell(row=1, column=col, value=h)
+    style_header_row(ws, 1, len(headers))
+
+    pasos = data.get("caso_prueba", {}).get("pasos", [])
+    for i, p in enumerate(pasos):
+        row_num = i + 2
+        values = [
+            p.get("paso", ""),
+            p.get("nombre", ""),
+            p.get("accion", ""),
+            p.get("resultado", ""),
+            p.get("datos", ""),
+            p.get("script", ""),
+            p.get("automatizado", False),
+            p.get("bloqueado", ""),
+            p.get("nota", ""),
+        ]
+        for col, val in enumerate(values, 1):
+            cell = ws.cell(row=row_num, column=col, value=val)
+            style_data_cell(cell, i)
+
+    widths = [8, 35, 60, 45, 50, 30, 14, 35, 30]
+    for col_idx, w in enumerate(widths):
+        ws.column_dimensions[chr(65 + col_idx)].width = w
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Uso: python export_yaml_to_excel.py <input.yml> [output.xlsx]")
+        sys.exit(1)
+
+    input_path = Path(sys.argv[1])
+    if not input_path.exists():
+        print(f"ERROR: No se encontro {input_path}")
+        sys.exit(1)
+
+    if len(sys.argv) >= 3:
+        output_path = Path(sys.argv[2])
+    else:
+        output_path = input_path.with_suffix(".xlsx")
+
+    with open(input_path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    wb = Workbook()
+    write_metadata_sheet(wb, data)
+    write_pasos_sheet(wb, data)
+    wb.save(output_path)
+
+    n_pasos = len(data.get("caso_prueba", {}).get("pasos", []))
+    print(f"OK: {input_path.name} -> {output_path.name} ({n_pasos} pasos, 2 hojas)")
+
+
+if __name__ == "__main__":
+    main()

package/siesa-agents/scripts/converters/export_yaml_to_markdown.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+export_yaml_to_markdown.py — Exporta test-design YAML a Markdown
+Formato: Secciones ## con key: value + tabla pipe de pasos
+Uso: python export_yaml_to_markdown.py <input.yml> [output.md]
+"""
+
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    print("ERROR: pyyaml requerido. Instalar con: pip install pyyaml")
+    sys.exit(1)
+
+
+def flatten(value) -> str:
+    """Convierte listas y dicts a string con separador pipe."""
+    if isinstance(value, list):
+        return " | ".join(str(v) for v in value)
+    if isinstance(value, dict):
+        return " | ".join(f"{k}: {v}" for k, v in value.items())
+    return str(value).replace("\n", " ").strip()
+
+
+def write_kv(f, key: str, value: str):
+    f.write(f"- **{key}**: {value}\n")
+
+
+def export_markdown(data: dict) -> str:
+    lines = []
+    L = lines.append
+
+    caso = data.get("caso_prueba", {})
+    title = caso.get("nombre", "Test Design")
+    L(f"# {title}\n")
+
+    # --- METADATA ---
+    L("## Metadata\n")
+    meta = data.get("metadata", {})
+    for field in ("modulo", "version", "autor", "fecha", "stack"):
+        if field in meta:
+            L(f"- **{field}**: {meta[field]}")
+    L("")
+
+    # --- REQUISITO ---
+    L("## Requisito\n")
+    req = data.get("requisito", {})
+    for field in ("id", "nombre"):
+        if field in req:
+            L(f"- **{field}**: {req[field]}")
+    desc = req.get("descripcion", "")
+    if desc:
+        L(f"- **descripcion**: {flatten(desc)}")
+    criterios = req.get("criterios_aceptacion", [])
+    if criterios:
+        L(f"- **criterios_aceptacion**: {' | '.join(criterios)}")
+    L("")
+
+    # --- PLAN_PRUEBAS ---
+    L("## Plan de Pruebas\n")
+    plan = data.get("plan_pruebas", {})
+    for field in ("id", "nombre", "framework"):
+        if field in plan:
+            L(f"- **{field}**: {plan[field]}")
+    objetivo = plan.get("objetivo", "")
+    if objetivo:
+        L(f"- **objetivo**: {flatten(objetivo)}")
+    precond = plan.get("precondiciones", [])
+    if precond:
+        L(f"- **precondiciones**: {' | '.join(precond)}")
+    ambientes = plan.get("ambientes", [])
+    for i, amb in enumerate(ambientes):
+        for key in ("nombre", "url", "usuario"):
+            if key in amb:
+                L(f"- **ambiente_{i}.{key}**: {amb[key]}")
+    tiempos = plan.get("tiempos_referencia", {})
+    for key, val in tiempos.items():
+        L(f"- **tiempos.{key}**: {val}")
+    L("")
+
+    # --- CASO_PRUEBA ---
+    L("## Caso de Prueba\n")
+    for field in ("id", "nombre", "prioridad", "tipo"):
+        if field in caso:
+            L(f"- **{field}**: {caso[field]}")
+    scripts = caso.get("scripts", [])
+    if scripts:
+        L(f"- **scripts**: {' | '.join(scripts)}")
+    L("")
+
+    # --- EJECUCION ---
+    L("## Ejecucion\n")
+    ejec = data.get("ejecucion", {})
+    for field in ("id", "nombre"):
+        if field in ejec:
+            L(f"- **{field}**: {ejec[field]}")
+    variables = ejec.get("variables_entorno", [])
+    for var in variables:
+        nombre = var.get("nombre", "")
+        desc = var.get("descripcion", "")
+        default = var.get("default", "")
+        L(f"- **variable.{nombre}**: {desc} | {default}")
+    comandos = ejec.get("comandos", {})
+    for key, val in comandos.items():
+        L(f"- **comando.{key}**: {val}")
+    L("")
+
+    # --- INTEGRACIONES ---
+    integ = data.get("integraciones", {})
+    if integ:
+        L("## Integraciones\n")
+        for integ_name, info in integ.items():
+            for key, val in info.items():
+                L(f"- **{integ_name}.{key}**: {val}")
+        L("")
+
+    # --- PASOS ---
+    L("## Pasos\n")
+    pasos = caso.get("pasos", [])
+    if pasos:
+        L("| Paso | Nombre | Accion | Resultado Esperado | Datos | Script | Automatizado | Bloqueado | Nota |")
+        L("|------|--------|--------|--------------------|-------|--------|--------------|-----------|------|")
+        for p in pasos:
+            paso = str(p.get("paso", ""))
+            nombre = p.get("nombre", "")
+            accion = p.get("accion", "")
+            resultado = p.get("resultado", "")
+            datos = p.get("datos", "")
+            script = p.get("script", "")
+            auto = str(p.get("automatizado", False)).lower()
+            bloqueado = p.get("bloqueado", "")
+            nota = p.get("nota", "")
+            # Escapar pipes dentro de valores
+            vals = [paso, nombre, accion, resultado, datos, script, auto, bloqueado, nota]
+            vals = [v.replace("|", "\\|") for v in vals]
+            L(f"| {' | '.join(vals)} |")
+    L("")
+
+    return "\n".join(lines)
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Uso: python export_yaml_to_markdown.py <input.yml> [output.md]")
+        sys.exit(1)
+
+    input_path = Path(sys.argv[1])
+    if not input_path.exists():
+        print(f"ERROR: No se encontro {input_path}")
+        sys.exit(1)
+
+    if len(sys.argv) >= 3:
+        output_path = Path(sys.argv[2])
+    else:
+        output_path = input_path.with_suffix(".md")
+
+    with open(input_path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    md = export_markdown(data)
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(md)
+
+    n_pasos = len(data.get("caso_prueba", {}).get("pasos", []))
+    print(f"OK: {input_path.name} -> {output_path.name} ({n_pasos} pasos)")
+
+
+if __name__ == "__main__":
+    main()

package/siesa-agents/scripts/converters/export_yaml_to_pdf.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+"""
+export_yaml_to_pdf.py — Exporta test-design YAML a PDF
+Formato: Secciones tituladas con metadata key-value + tabla de pasos
+Uso: python export_yaml_to_pdf.py <input.yml> [output.pdf]
+"""
+
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    print("ERROR: pyyaml requerido. Instalar con: pip install pyyaml")
+    sys.exit(1)
+
+try:
+    from reportlab.lib import colors
+    from reportlab.lib.pagesizes import letter, landscape
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+    from reportlab.lib.units import inch, cm
+    from reportlab.platypus import (
+        SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak,
+    )
+except ImportError:
+    print("ERROR: reportlab requerido. Instalar con: pip install reportlab")
+    sys.exit(1)
+
+
+# --- Estilos Siesa ---
+TEAL = colors.HexColor("#009688")
+LIGHT_GRAY = colors.HexColor("#F5F5F5")
+WHITE = colors.white
+
+
+def get_styles():
+    styles = getSampleStyleSheet()
+    styles.add(ParagraphStyle(
+        "SectionTitle",
+        parent=styles["Heading2"],
+        textColor=TEAL,
+        spaceAfter=6,
+        spaceBefore=12,
+        fontSize=13,
+        fontName="Helvetica-Bold",
+    ))
+    styles.add(ParagraphStyle(
+        "MetaKey",
+        parent=styles["Normal"],
+        fontName="Helvetica-Bold",
+        fontSize=9,
+    ))
+    styles.add(ParagraphStyle(
+        "MetaValue",
+        parent=styles["Normal"],
+        fontSize=9,
+    ))
+    styles.add(ParagraphStyle(
+        "CellText",
+        parent=styles["Normal"],
+        fontSize=7,
+        leading=9,
+    ))
+    styles.add(ParagraphStyle(
+        "DocTitle",
+        parent=styles["Title"],
+        textColor=TEAL,
+        fontSize=16,
+        fontName="Helvetica-Bold",
+    ))
+    return styles
+
+
+def build_meta_table(rows: list[tuple[str, str]], styles) -> Table:
+    """Construye tabla de metadata key-value."""
+    data = []
+    for key, value in rows:
+        data.append([
+            Paragraph(key, styles["MetaKey"]),
+            Paragraph(str(value), styles["MetaValue"]),
+        ])
+    t = Table(data, colWidths=[2.5 * inch, 5.5 * inch])
+    t.setStyle(TableStyle([
+        ("VALIGN", (0, 0), (-1, -1), "TOP"),
+        ("TOPPADDING", (0, 0), (-1, -1), 2),
+        ("BOTTOMPADDING", (0, 0), (-1, -1), 2),
+        ("LINEBELOW", (0, 0), (-1, -1), 0.5, colors.HexColor("#E0E0E0")),
+    ]))
+    return t
+
+
+def flatten_for_pdf(value) -> str:
+    if isinstance(value, list):
+        return " | ".join(str(v) for v in value)
+    if isinstance(value, dict):
+        return " | ".join(f"{k}: {v}" for k, v in value.items())
+    return str(value).strip()
+
+
+def build_document(data: dict, styles) -> list:
+    """Construye los elementos del PDF."""
+    elements = []
+
+    # Titulo
+    caso = data.get("caso_prueba", {})
+    title = caso.get("nombre", "Test Design")
+    elements.append(Paragraph(title, styles["DocTitle"]))
+    elements.append(Spacer(1, 12))
+
+    # --- [METADATA] ---
+    elements.append(Paragraph("[METADATA]", styles["SectionTitle"]))
+    meta = data.get("metadata", {})
+    meta_rows = []
+    for field in ("modulo", "version", "autor", "fecha", "stack"):
+        if field in meta:
+            meta_rows.append((field, meta[field]))
+    if meta_rows:
+        elements.append(build_meta_table(meta_rows, styles))
+    elements.append(Spacer(1, 8))
+
+    # --- [REQUISITO] ---
+    elements.append(Paragraph("[REQUISITO]", styles["SectionTitle"]))
+    req = data.get("requisito", {})
+    req_rows = []
+    for field in ("id", "nombre", "descripcion"):
+        if field in req:
+            req_rows.append((field, flatten_for_pdf(req[field])))
+    criterios = req.get("criterios_aceptacion", [])
+    if criterios:
+        req_rows.append(("criterios_aceptacion", " | ".join(criterios)))
+    if req_rows:
+        elements.append(build_meta_table(req_rows, styles))
+    elements.append(Spacer(1, 8))
+
+    # --- [PLAN_PRUEBAS] ---
+    elements.append(Paragraph("[PLAN_PRUEBAS]", styles["SectionTitle"]))
+    plan = data.get("plan_pruebas", {})
+    plan_rows = []
+    for field in ("id", "nombre", "objetivo", "framework"):
+        if field in plan:
+            plan_rows.append((field, flatten_for_pdf(plan[field])))
+    precond = plan.get("precondiciones", [])
+    if precond:
+        plan_rows.append(("precondiciones", " | ".join(precond)))
+    ambientes = plan.get("ambientes", [])
+    for i, amb in enumerate(ambientes):
+        for key in ("nombre", "url", "usuario"):
+            if key in amb:
+                plan_rows.append((f"ambiente_{i}.{key}", str(amb[key])))
+    tiempos = plan.get("tiempos_referencia", {})
+    for key, val in tiempos.items():
+        plan_rows.append((f"tiempos.{key}", str(val)))
+    if plan_rows:
+        elements.append(build_meta_table(plan_rows, styles))
+    elements.append(Spacer(1, 8))
+
+    # --- [CASO_PRUEBA] ---
+    elements.append(Paragraph("[CASO_PRUEBA]", styles["SectionTitle"]))
+    caso_rows = []
+    for field in ("id", "nombre", "prioridad", "tipo"):
+        if field in caso:
+            caso_rows.append((field, caso[field]))
+    scripts = caso.get("scripts", [])
+    if scripts:
+        caso_rows.append(("scripts", " | ".join(scripts)))
+    if caso_rows:
+        elements.append(build_meta_table(caso_rows, styles))
+    elements.append(Spacer(1, 8))
+
+    # --- [EJECUCION] ---
+    elements.append(Paragraph("[EJECUCION]", styles["SectionTitle"]))
+    ejec = data.get("ejecucion", {})
+    ejec_rows = []
+    for field in ("id", "nombre"):
+        if field in ejec:
+            ejec_rows.append((field, ejec[field]))
+    variables = ejec.get("variables_entorno", [])
+    for var in variables:
+        nombre = var.get("nombre", "")
+        desc = var.get("descripcion", "")
+        default = var.get("default", "")
+        ejec_rows.append((f"variable.{nombre}", f"{desc} | {default}"))
+    comandos = ejec.get("comandos", {})
+    for key, val in comandos.items():
+        ejec_rows.append((f"comando.{key}", str(val)))
+    if ejec_rows:
+        elements.append(build_meta_table(ejec_rows, styles))
+    elements.append(Spacer(1, 8))
+
+    # --- [INTEGRACIONES] ---
+    integ = data.get("integraciones", {})
+    if integ:
+        elements.append(Paragraph("[INTEGRACIONES]", styles["SectionTitle"]))
+        integ_rows = []
+        for integ_name, info in integ.items():
+            for key, val in info.items():
+                integ_rows.append((f"{integ_name}.{key}", str(val)))
+        elements.append(build_meta_table(integ_rows, styles))
+        elements.append(Spacer(1, 8))
+
+    # --- [PASOS] --- (pagina landscape)
+    elements.append(PageBreak())
+    elements.append(Paragraph("[PASOS]", styles["SectionTitle"]))
+
+    pasos = caso.get("pasos", [])
+    if pasos:
+        headers = ["Paso", "Nombre", "Accion", "Resultado Esperado",
+                    "Datos", "Script", "Auto", "Bloqueado", "Nota"]
+        table_data = [[Paragraph(h, styles["MetaKey"]) for h in headers]]
+
+        for p in pasos:
+            row = [
+                Paragraph(str(p.get("paso", "")), styles["CellText"]),
+                Paragraph(str(p.get("nombre", "")), styles["CellText"]),
+                Paragraph(str(p.get("accion", "")), styles["CellText"]),
+                Paragraph(str(p.get("resultado", "")), styles["CellText"]),
+                Paragraph(str(p.get("datos", "")), styles["CellText"]),
+                Paragraph(str(p.get("script", "")), styles["CellText"]),
+                Paragraph(str(p.get("automatizado", False)), styles["CellText"]),
+                Paragraph(str(p.get("bloqueado", "")), styles["CellText"]),
+                Paragraph(str(p.get("nota", "")), styles["CellText"]),
+            ]
+            table_data.append(row)
+
+        col_widths = [
+            0.5 * inch,   # paso
+            1.2 * inch,   # nombre
+            2.2 * inch,   # accion
+            1.6 * inch,   # resultado
+            1.6 * inch,   # datos
+            1.0 * inch,   # script
+            0.5 * inch,   # auto
+            1.2 * inch,   # bloqueado
+            1.0 * inch,   # nota
+        ]
+
+        t = Table(table_data, colWidths=col_widths, repeatRows=1)
+        style_cmds = [
+            ("BACKGROUND", (0, 0), (-1, 0), TEAL),
+            ("TEXTCOLOR", (0, 0), (-1, 0), WHITE),
+            ("FONTSIZE", (0, 0), (-1, 0), 8),
+            ("FONTSIZE", (0, 1), (-1, -1), 7),
+            ("VALIGN", (0, 0), (-1, -1), "TOP"),
+            ("GRID", (0, 0), (-1, -1), 0.5, colors.HexColor("#BDBDBD")),
+            ("TOPPADDING", (0, 0), (-1, -1), 3),
+            ("BOTTOMPADDING", (0, 0), (-1, -1), 3),
+            ("LEFTPADDING", (0, 0), (-1, -1), 3),
+            ("RIGHTPADDING", (0, 0), (-1, -1), 3),
+        ]
+        # Filas alternas
+        for i in range(1, len(table_data)):
+            if i % 2 == 0:
+                style_cmds.append(("BACKGROUND", (0, i), (-1, i), LIGHT_GRAY))
+
+        t.setStyle(TableStyle(style_cmds))
+        elements.append(t)
+
+    return elements
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Uso: python export_yaml_to_pdf.py <input.yml> [output.pdf]")
+        sys.exit(1)
+
+    input_path = Path(sys.argv[1])
+    if not input_path.exists():
+        print(f"ERROR: No se encontro {input_path}")
+        sys.exit(1)
+
+    if len(sys.argv) >= 3:
+        output_path = Path(sys.argv[2])
+    else:
+        output_path = input_path.with_suffix(".pdf")
+
+    with open(input_path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    styles = get_styles()
+    elements = build_document(data, styles)
+
+    doc = SimpleDocTemplate(
+        str(output_path),
+        pagesize=landscape(letter),
+        leftMargin=1 * cm,
+        rightMargin=1 * cm,
+        topMargin=1.5 * cm,
+        bottomMargin=1.5 * cm,
+    )
+    doc.build(elements)
+
+    n_pasos = len(data.get("caso_prueba", {}).get("pasos", []))
+    print(f"OK: {input_path.name} -> {output_path.name} ({n_pasos} pasos)")
+
+
+if __name__ == "__main__":
+    main()