@alejandrojca/elmulo-reporter 2.0.0-beta.5 → 2.0.0-beta.6

package/README.md

@@ -286,7 +286,49 @@ ELMULO_CAPTURE_HTTP=false npm run report-sandbox-ecommerce -- "@mtt"
 También puede configurarse `captureHttp: false` al llamar a
 `registerElmuloReporter`.
 
-## Comandos
+### Reportar una falla en Jira
+
+La pestaña **Error** permite crear un defecto en Jira cuando el reporte se abre
+con `elmulo serve`. El comentario de la falla es obligatorio. Antes de enviar,
+Elmulo muestra una confirmación y arma la descripción con:
+
+- el escenario Gherkin ejecutado;
+- el error final y el paso fallido;
+- el request/response temporalmente asociado al fallo;
+- el comentario escrito por la persona que analiza la corrida.
+
+La integración está configurada por defecto para `FONLP06`, work type `Error` y
+`Tipo = Mantenimiento (IT4IT)`. Busca duplicados mediante una label estable. Si
+encuentra un defecto activo agrega un comentario; si todos los coincidentes
+están en una categoría Jira `done`, crea una recurrencia.
+
+Las credenciales nunca llegan al navegador. El servidor acepta cualquiera de
+estas configuraciones:
+
+```powershell
+$env:ELMULO_JIRA_EMAIL = "usuario@dominio.com"
+$env:ELMULO_JIRA_API_TOKEN = "<api-token>"
+npm run elmulo:serve
+```
+
+También puede leer el archivo local y gitignoreado
+`cypress/config/jira-credentials.ts` del proyecto Cypress. Para indicar otra
+ruta:
+
+```powershell
+$env:ELMULO_JIRA_CREDENTIALS_FILE = "C:\ruta\jira-credentials.ts"
+npm run elmulo:serve
+```
+
+Al crear o reutilizar el defecto, Elmulo cambia la prueba a `Reportado`, guarda
+la URL en **Ticket / bug report** y registra la operación en la auditoría
+SQLite.
+
+La evidencia HTTP se envía literalmente a Jira. No se ocultan credenciales,
+tokens, cookies ni datos de los cuerpos; esta política debe revisarse antes de
+usar la integración con información productiva.
+
+## Comandos
 
 Los comandos se ejecutan desde la raíz del proyecto Cypress consumidor:
 

package/VERSION.json

@@ -1,6 +1,6 @@
 {
   "name": "Elmulo Reporter",
-  "version": "2.0.0-beta.5",
+  "version": "2.0.0-beta.6",
   "schemaVersion": 3,
   "source": "elmulo-reporter",
   "results": "elmulo-results",

package/assets/app.css

@@ -1398,12 +1398,109 @@ html[data-theme="dark"] .exampleRow .testMeta {
   resize: vertical;
 }
 
-.failureReviewActions {
+.failureReviewActions {
   align-items: center;
   display: flex;
   gap: 0.75rem;
   margin-top: 0.85rem;
-}
+}
+
+.jiraDefectButton,
+.jiraDefectLink {
+  align-items: center;
+  background: #0c66e4;
+  border: 1px solid #0c66e4;
+  border-radius: 12px;
+  color: #fff;
+  display: inline-flex;
+  font-weight: 800;
+  justify-content: center;
+  padding: 0.68rem 0.9rem;
+  text-decoration: none;
+}
+
+.jiraDefectButton:disabled {
+  cursor: not-allowed;
+  opacity: 0.45;
+}
+
+.jiraDefectHint {
+  color: var(--pw-gray-700);
+  font-size: 0.76rem;
+  margin: 0.55rem 0 0;
+}
+
+.jiraDefectConfirmationBody {
+  display: grid;
+  gap: 1rem;
+}
+
+.jiraDefectConfirmationBody dl {
+  background: var(--pw-blue-050);
+  border-radius: 14px;
+  display: grid;
+  gap: 0.65rem;
+  margin: 0;
+  padding: 0.9rem;
+}
+
+.jiraDefectConfirmationBody dl > div {
+  display: grid;
+  gap: 0.15rem;
+  grid-template-columns: minmax(110px, 0.35fr) 1fr;
+}
+
+.jiraDefectConfirmationBody dt {
+  color: var(--pw-gray-700);
+  font-size: 0.74rem;
+  font-weight: 800;
+}
+
+.jiraDefectConfirmationBody dd {
+  color: var(--pw-blue-900);
+  font-size: 0.82rem;
+  font-weight: 700;
+  margin: 0;
+  overflow-wrap: anywhere;
+}
+
+.jiraDefectConfirmationBody section {
+  border: 1px solid var(--pw-gray-200);
+  border-radius: 14px;
+  padding: 0.9rem;
+}
+
+.jiraDefectConfirmationBody section h3,
+.jiraDefectConfirmationBody section p,
+.jiraDefectWarning {
+  margin: 0;
+}
+
+.jiraDefectConfirmationBody section p,
+.jiraDefectWarning {
+  color: var(--pw-gray-700);
+  font-size: 0.8rem;
+  margin-top: 0.4rem;
+  white-space: pre-wrap;
+}
+
+html[data-theme="dark"] .jiraDefectConfirmationBody dl,
+html[data-theme="dark"] .jiraDefectConfirmationBody section {
+  background: #102638;
+  border-color: #315069;
+}
+
+html[data-theme="dark"] .jiraDefectConfirmationBody dd,
+html[data-theme="dark"] .jiraDefectConfirmationBody section h3 {
+  color: #e8f2ff;
+}
+
+html[data-theme="dark"] .jiraDefectConfirmationBody dt,
+html[data-theme="dark"] .jiraDefectConfirmationBody section p,
+html[data-theme="dark"] .jiraDefectWarning,
+html[data-theme="dark"] .jiraDefectHint {
+  color: #b8c7d6;
+}
 
 .saveReviewButton {
   background: var(--pw-blue-700);

package/assets/app.js

@@ -1682,11 +1682,24 @@
             placeholder="Ej.: BUG-1234 o URL del ticket"
           />
         </label>
-      </div>
-      <div class="failureReviewActions">
-        <button class="saveReviewButton" type="button" data-save-failure-review>Guardar seguimiento</button>
-        <span class="saveFeedback" data-save-feedback aria-live="polite"></span>
-      </div>
+      </div>
+      <div class="failureReviewActions">
+        <button class="saveReviewButton" type="button" data-save-failure-review>Guardar seguimiento</button>
+        ${annotation.ticket
+          ? `<a class="jiraDefectLink" href="${escapeHtml(annotation.ticket)}" target="_blank" rel="noreferrer">Abrir bug en Jira</a>`
+          : `<button
+              class="jiraDefectButton"
+              type="button"
+              data-create-jira-defect
+              ${annotation.comment?.trim() && durablePersistence ? "" : "disabled"}
+            >Crear defecto en Jira</button>`}
+        <span class="saveFeedback" data-save-feedback aria-live="polite"></span>
+      </div>
+      ${!durablePersistence
+        ? '<p class="jiraDefectHint">Abrí el reporte con Elmulo Serve para crear defectos en Jira.</p>'
+        : !annotation.ticket
+          ? '<p class="jiraDefectHint">El comentario es obligatorio antes de crear el defecto.</p>'
+          : ""}
       ${annotation.updatedAt
         ? `<p class="auditSummary">Último cambio: ${escapeHtml(formatDate(annotation.updatedAt))} · ${escapeHtml(annotation.actor || "Usuario local")} · revisión ${escapeHtml(annotation.revision || 1)}</p>`
         : ""}
@@ -1694,8 +1707,96 @@
         <summary data-load-audit="${escapeHtml(test.id)}">Ver auditoría de cambios</summary>
         <div data-audit-events>Desplegá para consultar el historial inmutable.</div>
       </details>
-    </section>`;
-  }
+    </section>`;
+  }
+
+  function closeJiraDefectConfirmation() {
+    document.getElementById("jira-defect-confirmation-modal")?.remove();
+  }
+
+  function openJiraDefectConfirmation(test, comment) {
+    closeJiraDefectConfirmation();
+    const dialog = document.createElement("dialog");
+    dialog.id = "jira-defect-confirmation-modal";
+    dialog.className = "reuseConfirmationModal jiraDefectModal";
+    dialog.innerHTML = `
+      <form method="dialog" class="confirmationShell">
+        <header>
+          <div>
+            <p class="eyebrow">Creación de defecto</p>
+            <h2>¿Confirmás el reporte en Jira?</h2>
+          </div>
+          <button type="button" class="modalCloseButton" data-close-jira-defect aria-label="Cerrar">×</button>
+        </header>
+        <div class="confirmationBody jiraDefectConfirmationBody">
+          <dl>
+            <div><dt>Proyecto</dt><dd>FONLP06</dd></div>
+            <div><dt>Tipo</dt><dd>Error</dd></div>
+            <div><dt>Clasificación</dt><dd>Mantenimiento (IT4IT)</dd></div>
+            <div><dt>Escenario</dt><dd>${escapeHtml(test.title)}</dd></div>
+            <div><dt>Ambiente</dt><dd>${escapeHtml(run.environment || "Sin especificar")}</dd></div>
+          </dl>
+          <section>
+            <h3>Comentario de la falla</h3>
+            <p>${escapeHtml(comment)}</p>
+          </section>
+          <p class="jiraDefectWarning">Se enviarán a Jira el Gherkin ejecutado, el error final y el request/response asociados a la falla.</p>
+          <div class="confirmationFeedback" data-jira-defect-feedback aria-live="polite"></div>
+        </div>
+        <footer>
+          <button type="button" class="secondaryButton" data-close-jira-defect>Cancelar</button>
+          <button type="button" class="jiraDefectButton" data-confirm-jira-defect>Crear defecto</button>
+        </footer>
+      </form>`;
+    document.body.appendChild(dialog);
+    dialog.querySelectorAll("[data-close-jira-defect]").forEach((button) => {
+      button.addEventListener("click", closeJiraDefectConfirmation);
+    });
+    dialog.querySelector("[data-confirm-jira-defect]")?.addEventListener("click", async () => {
+      const confirmButton = dialog.querySelector("[data-confirm-jira-defect]");
+      const feedback = dialog.querySelector("[data-jira-defect-feedback]");
+      confirmButton.disabled = true;
+      feedback.textContent = "Consultando Jira y procesando el defecto…";
+      feedback.className = "confirmationFeedback";
+      try {
+        const result = await requestElmuloJson("/api/jira/defects", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            runId: run.id,
+            testId: test.id,
+            comment,
+            actor: state.actor,
+          }),
+        });
+        state.annotations = result.annotations || state.annotations;
+        run.annotations = state.annotations;
+        run.trends = result.trends || run.trends;
+        persistAnnotationsLocally();
+        closeJiraDefectConfirmation();
+        renderList();
+        const detailFeedback = document.querySelector("[data-save-feedback]");
+        if (detailFeedback) {
+          const actionLabel = {
+            created: "Defecto creado",
+            recreated: "Recurrencia creada",
+            reused: "El defecto existente fue actualizado",
+          }[result.action] || "Defecto reportado";
+          detailFeedback.textContent = `${actionLabel}: ${result.issueKey}.`;
+          detailFeedback.classList.remove("error");
+        }
+      } catch (error) {
+        feedback.textContent = error.message;
+        feedback.className = "confirmationFeedback error";
+        confirmButton.disabled = false;
+      }
+    });
+    dialog.addEventListener("cancel", (event) => {
+      event.preventDefault();
+      closeJiraDefectConfirmation();
+    });
+    dialog.showModal();
+  }
 
   async function loadAuditTrail(test, container) {
     container.innerHTML = "Consultando auditoría…";
@@ -2184,8 +2285,26 @@
       });
     }
 
-    const saveReviewButton = detail.querySelector("[data-save-failure-review]");
-    if (saveReviewButton) {
+    const saveReviewButton = detail.querySelector("[data-save-failure-review]");
+    const failureComment = detail.querySelector("[data-failure-comment]");
+    const createJiraDefectButton = detail.querySelector("[data-create-jira-defect]");
+    if (failureComment && createJiraDefectButton) {
+      const syncJiraButton = () => {
+        createJiraDefectButton.disabled =
+          !failureComment.value.trim() || location.protocol === "file:";
+      };
+      failureComment.addEventListener("input", syncJiraButton);
+      createJiraDefectButton.addEventListener("click", () => {
+        const comment = failureComment.value.trim();
+        if (!comment) {
+          syncJiraButton();
+          return;
+        }
+        openJiraDefectConfirmation(test, comment);
+      });
+      syncJiraButton();
+    }
+    if (saveReviewButton) {
       saveReviewButton.addEventListener("click", async () => {
         const comment = detail.querySelector("[data-failure-comment]")?.value.trim() || "";
         const ticket = detail.querySelector("[data-failure-ticket]")?.value.trim() || "";

package/finalize.cjs

@@ -435,7 +435,7 @@ function persistRun(database, run) {
         system: run.system || {},
         source: run.source || {},
         execution: run.execution || null,
-        reporterVersion: "2.0.0-beta.5",
+        reporterVersion: "2.0.0-beta.6",
       }),
     ],
   );
@@ -924,7 +924,7 @@ async function finalizeRun(options = {}) {
   if (!run) throw new Error(`No se encontró ${rawPath}`);
 
   run.schemaVersion = DATABASE_SCHEMA_VERSION;
-  run.reporterVersion = "2.0.0-beta.5";
+  run.reporterVersion = "2.0.0-beta.6";
   run.lifecycle = run.lifecycle || "completed";
   run.source = run.source || {
     branch: process.env.CI_COMMIT_REF_NAME || "",

package/jira.cjs

@@ -0,0 +1,391 @@
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const DEFAULTS = Object.freeze({
+  baseUrl: "https://prismamediosdepago.atlassian.net",
+  projectKey: "FONLP06",
+  projectId: "10133",
+  issueTypeName: "Error",
+  issueTypeId: "10046",
+  tipoFieldId: "customfield_10431",
+  tipoValueId: "23025",
+  tipoValue: "Mantenimiento (IT4IT)",
+});
+
+function extractCredential(source, name) {
+  return String(source || "").match(
+    new RegExp(`["']?${name}["']?\\s*:\\s*["']([^"']*)["']`),
+  )?.[1] || "";
+}
+
+function loadJiraConfig(projectRoot, env = process.env) {
+  const credentialsPath = path.resolve(
+    env.ELMULO_JIRA_CREDENTIALS_FILE ||
+      path.join(projectRoot, "cypress", "config", "jira-credentials.ts"),
+  );
+  let fileCredentials = {};
+  if (fs.existsSync(credentialsPath)) {
+    const source = fs.readFileSync(credentialsPath, "utf8");
+    fileCredentials = {
+      authorization: extractCredential(source, "authorization"),
+      cookie: extractCredential(source, "cookie"),
+      projectKey: extractCredential(source, "project"),
+      projectId: extractCredential(source, "projectId"),
+    };
+  }
+
+  const email = String(env.ELMULO_JIRA_EMAIL || "").trim();
+  const apiToken = String(env.ELMULO_JIRA_API_TOKEN || "").trim();
+  const authorization = String(
+    env.ELMULO_JIRA_AUTHORIZATION ||
+      (email && apiToken
+        ? `Basic ${Buffer.from(`${email}:${apiToken}`, "utf8").toString("base64")}`
+        : fileCredentials.authorization || ""),
+  ).trim();
+
+  return {
+    ...DEFAULTS,
+    baseUrl: String(env.ELMULO_JIRA_BASE_URL || DEFAULTS.baseUrl).replace(/\/+$/, ""),
+    projectKey: String(
+      env.ELMULO_JIRA_PROJECT || fileCredentials.projectKey || DEFAULTS.projectKey,
+    ).trim(),
+    projectId: String(
+      env.ELMULO_JIRA_PROJECT_ID || fileCredentials.projectId || DEFAULTS.projectId,
+    ).trim(),
+    issueTypeId: String(env.ELMULO_JIRA_ISSUE_TYPE_ID || DEFAULTS.issueTypeId).trim(),
+    issueTypeName: String(
+      env.ELMULO_JIRA_ISSUE_TYPE_NAME || DEFAULTS.issueTypeName,
+    ).trim(),
+    tipoFieldId: String(env.ELMULO_JIRA_TIPO_FIELD_ID || DEFAULTS.tipoFieldId).trim(),
+    tipoValueId: String(env.ELMULO_JIRA_TIPO_VALUE_ID || DEFAULTS.tipoValueId).trim(),
+    tipoValue: String(env.ELMULO_JIRA_TIPO_VALUE || DEFAULTS.tipoValue).trim(),
+    authorization,
+    cookie: String(env.ELMULO_JIRA_COOKIE || fileCredentials.cookie || "").trim(),
+    credentialsPath,
+    enabled: Boolean(authorization),
+  };
+}
+
+function firstErrorLine(error = {}) {
+  const value = String(error.message || error.stack || error || "").trim();
+  return value.split(/\r?\n/).find((line) => line.trim())?.trim() || "Error sin detalle";
+}
+
+function normalizeFingerprintPart(value) {
+  return String(value || "")
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+function defectFingerprint(config, test) {
+  const source = [
+    config.projectKey,
+    String(test.spec || "").replaceAll("\\", "/"),
+    test.originalTitle || test.title,
+    firstErrorLine(test.error),
+  ].map(normalizeFingerprintPart).join("|");
+  return `elmulo-${crypto.createHash("sha256").update(source).digest("hex").slice(0, 12)}`;
+}
+
+function normalizeScenarioTitle(value) {
+  return normalizeFingerprintPart(value).replace(/\s+\(example\s+#\d+\)$/, "");
+}
+
+function sourceKeywords(projectRoot, test) {
+  const specPath = path.resolve(projectRoot, String(test.spec || ""));
+  if (!fs.existsSync(specPath)) return [];
+  const lines = fs.readFileSync(specPath, "utf8").split(/\r?\n/);
+  const target = normalizeScenarioTitle(test.originalTitle || test.title);
+  const scenarioPattern = /^\s*Scenario(?: Outline)?:\s*(.+?)\s*$/i;
+  let start = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    const match = lines[index].match(scenarioPattern);
+    if (match && normalizeScenarioTitle(match[1]) === target) {
+      start = index + 1;
+      break;
+    }
+  }
+  if (start < 0) return [];
+  const keywords = [];
+  for (let index = start; index < lines.length; index += 1) {
+    if (/^\s*(?:Scenario(?: Outline)?|Rule|Feature):/i.test(lines[index])) break;
+    if (/^\s*Examples:/i.test(lines[index])) break;
+    const match = lines[index].match(/^\s*(Given|When|Then|And|But|\*)\s+/i);
+    if (match) keywords.push(match[1]);
+  }
+  return keywords;
+}
+
+function buildExecutedGherkin(projectRoot, test) {
+  const keywords = sourceKeywords(projectRoot, test);
+  const tags = Array.isArray(test.tags) ? test.tags.join(" ") : "";
+  const steps = (test.steps || []).filter((step) => step.status !== "skipped");
+  return [
+    tags,
+    `Scenario: ${test.title || test.originalTitle || "Caso sin nombre"}`,
+    ...steps.map((step, index) =>
+      `  ${keywords[index] || (index === 0 ? "Given" : "And")} ${step.name}`),
+  ].filter(Boolean).join("\n");
+}
+
+function selectFailureExchange(test) {
+  const exchanges = Array.isArray(test.http) ? test.http : [];
+  if (!exchanges.length) return null;
+  const failedStep = (test.steps || []).find((step) => step.status === "failed");
+  if (!failedStep) return exchanges.at(-1);
+  const failureTime = Date.parse(failedStep.finishedAt || failedStep.startedAt || "");
+  if (!Number.isFinite(failureTime)) return exchanges.at(-1);
+  const eligible = exchanges.filter((exchange) => {
+    const startedAt = Date.parse(exchange.startedAt || "");
+    return Number.isFinite(startedAt) && startedAt <= failureTime;
+  });
+  return eligible.at(-1) || exchanges.at(-1);
+}
+
+function jiraDocument(blocks) {
+  return { type: "doc", version: 1, content: blocks };
+}
+
+function heading(text, level = 2) {
+  return {
+    type: "heading",
+    attrs: { level },
+    content: [{ type: "text", text: String(text) }],
+  };
+}
+
+function paragraph(text) {
+  return {
+    type: "paragraph",
+    content: String(text || "").split("\n").flatMap((line, index) => [
+      ...(index ? [{ type: "hardBreak" }] : []),
+      { type: "text", text: line || " " },
+    ]),
+  };
+}
+
+function codeBlock(value, language = "text") {
+  return {
+    type: "codeBlock",
+    attrs: { language },
+    content: [{ type: "text", text: String(value || "") }],
+  };
+}
+
+function prettyJson(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.stringify(JSON.parse(value), null, 2);
+    } catch {
+      return value;
+    }
+  }
+  return JSON.stringify(value ?? null, null, 2);
+}
+
+function relatedJiraCase(test) {
+  return (test.tags || [])
+    .map((tag) => String(tag).replace(/^@/, "").toUpperCase())
+    .find((tag) => /^[A-Z][A-Z0-9]+-\d+$/.test(tag)) || "";
+}
+
+function buildDescription({ config, projectRoot, run, test, comment, previousIssue }) {
+  const exchange = selectFailureExchange(test);
+  const failedStep = (test.steps || []).find((step) => step.status === "failed");
+  const blocks = [
+    heading("Caso de prueba"),
+    paragraph([
+      `Proyecto: ${config.projectKey}`,
+      `Feature: ${test.feature || test.titlePath?.[0] || ""}`,
+      `Archivo: ${test.spec || ""}`,
+      `Caso Xray: ${relatedJiraCase(test) || "Sin vinculación"}`,
+      `Ambiente: ${run.environment || "Sin especificar"}`,
+      `Fecha de ejecución: ${run.endedAt || run.finishedAt || new Date().toISOString()}`,
+    ].join("\n")),
+    codeBlock(buildExecutedGherkin(projectRoot, test), "gherkin"),
+    heading("Error final"),
+    codeBlock(String(test.error?.stack || test.error?.message || "Error sin detalle")),
+  ];
+  if (failedStep) {
+    blocks.push(paragraph("Paso que falló:"), codeBlock(
+      `${sourceKeywords(projectRoot, test)[failedStep.index] || "Then"} ${failedStep.name}`,
+      "gherkin",
+    ));
+  }
+  if (exchange) {
+    blocks.push(
+      heading("Request asociado a la falla"),
+      codeBlock(prettyJson(exchange.request), "json"),
+      heading("Respuesta asociada a la falla"),
+      codeBlock(prettyJson(exchange.response), "json"),
+    );
+  } else {
+    blocks.push(heading("Request y respuesta"), paragraph(
+      "Elmulo no registró un intercambio HTTP asociado a esta falla.",
+    ));
+  }
+  blocks.push(heading("Comentario de la falla"), paragraph(comment));
+  if (previousIssue) {
+    blocks.push(
+      heading("Recurrencia"),
+      paragraph(
+        `Este defecto es una recurrencia de ${previousIssue.key}, actualmente finalizado: ` +
+        `${config.baseUrl}/browse/${previousIssue.key}`,
+      ),
+    );
+  }
+  return jiraDocument(blocks);
+}
+
+function defectSummary(test, recurrence = false) {
+  const failedStep = (test.steps || []).find((step) => step.status === "failed");
+  const prefix = recurrence ? "[RECURRENCIA]" : "";
+  const mtt = (test.tags || []).some((tag) => String(tag).toLowerCase() === "@mtt")
+    ? "[MTT]"
+    : "[Elmulo]";
+  const detail = failedStep
+    ? `${test.title}: ${firstErrorLine({ message: failedStep.error || firstErrorLine(test.error) })}`
+    : `${test.title}: ${firstErrorLine(test.error)}`;
+  return `${prefix}${mtt} ${detail}`.slice(0, 255);
+}
+
+function recurrenceComment({ run, test, comment }) {
+  const failedStep = (test.steps || []).find((step) => step.status === "failed");
+  return jiraDocument([
+    heading("Recurrencia detectada por Elmulo", 3),
+    paragraph("El error continúa sucediendo."),
+    paragraph([
+      `Fecha: ${run.endedAt || run.finishedAt || new Date().toISOString()}`,
+      `Ambiente: ${run.environment || "Sin especificar"}`,
+      `Caso: ${relatedJiraCase(test) || test.title}`,
+      `Error: ${failedStep?.error || firstErrorLine(test.error)}`,
+      `Comentario: ${comment}`,
+    ].join("\n")),
+  ]);
+}
+
+async function jiraRequest(config, pathname, options = {}) {
+  if (!config.enabled) {
+    throw new Error(
+      `Jira no está configurado. Definí ELMULO_JIRA_EMAIL/ELMULO_JIRA_API_TOKEN ` +
+      `o creá ${config.credentialsPath}.`,
+    );
+  }
+  const headers = {
+    Accept: "application/json",
+    Authorization: config.authorization,
+    "Content-Type": "application/json",
+    ...(config.cookie ? { Cookie: config.cookie } : {}),
+    ...(options.headers || {}),
+  };
+  const response = await fetch(`${config.baseUrl}${pathname}`, {
+    ...options,
+    headers,
+  });
+  const text = await response.text();
+  let data = {};
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    data = { message: text };
+  }
+  if (!response.ok) {
+    const detail = data.errorMessages?.join("; ") ||
+      Object.entries(data.errors || {}).map(([field, message]) => `${field}: ${message}`).join("; ") ||
+      data.message || `HTTP ${response.status}`;
+    throw new Error(`Jira rechazó la operación: ${detail}`);
+  }
+  return data;
+}
+
+async function findMatchingIssues(config, fingerprint) {
+  const jql = [
+    `project = "${config.projectKey}"`,
+    `issuetype = "${config.issueTypeName}"`,
+    `labels = "${fingerprint}"`,
+    "ORDER BY created DESC",
+  ].join(" AND ");
+  const query = new URLSearchParams({
+    jql,
+    fields: "summary,status,labels",
+    maxResults: "50",
+  });
+  const data = await jiraRequest(config, `/rest/api/3/search/jql?${query}`);
+  return data.issues || [];
+}
+
+async function addRecurrenceComment(config, issueKey, context) {
+  await jiraRequest(config, `/rest/api/3/issue/${encodeURIComponent(issueKey)}/comment`, {
+    method: "POST",
+    body: JSON.stringify({ body: recurrenceComment(context) }),
+  });
+}
+
+async function createIssue(config, context, fingerprint, previousIssue) {
+  const myself = await jiraRequest(config, "/rest/api/3/myself");
+  const data = await jiraRequest(config, "/rest/api/3/issue", {
+    method: "POST",
+    body: JSON.stringify({
+      fields: {
+        project: { id: config.projectId },
+        issuetype: { id: config.issueTypeId },
+        summary: defectSummary(context.test, Boolean(previousIssue)),
+        description: buildDescription({ config, ...context, previousIssue }),
+        reporter: { accountId: myself.accountId },
+        [config.tipoFieldId]: { id: config.tipoValueId },
+        labels: [fingerprint, "elmulo-reporter"],
+      },
+    }),
+  });
+  return { id: data.id, key: data.key };
+}
+
+async function reportDefect({ config, projectRoot, run, test, comment }) {
+  if (!String(comment || "").trim()) {
+    throw new Error("El comentario de la falla es obligatorio.");
+  }
+  if (test.status !== "failed") {
+    throw new Error("Solo se pueden reportar pruebas fallidas.");
+  }
+  const fingerprint = defectFingerprint(config, test);
+  const matches = await findMatchingIssues(config, fingerprint);
+  const active = matches.find(
+    (issue) => issue.fields?.status?.statusCategory?.key !== "done",
+  );
+  const context = { projectRoot, run, test, comment: String(comment).trim() };
+  if (active) {
+    await addRecurrenceComment(config, active.key, context);
+    return {
+      action: "reused",
+      fingerprint,
+      issueKey: active.key,
+      issueUrl: `${config.baseUrl}/browse/${active.key}`,
+    };
+  }
+  const previousIssue = matches[0] || null;
+  const created = await createIssue(config, context, fingerprint, previousIssue);
+  return {
+    action: previousIssue ? "recreated" : "created",
+    fingerprint,
+    issueKey: created.key,
+    issueUrl: `${config.baseUrl}/browse/${created.key}`,
+    previousIssueKey: previousIssue?.key || "",
+  };
+}
+
+module.exports = {
+  DEFAULTS,
+  buildDescription,
+  buildExecutedGherkin,
+  defectFingerprint,
+  defectSummary,
+  firstErrorLine,
+  loadJiraConfig,
+  reportDefect,
+  selectFailureExchange,
+  sourceKeywords,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alejandrojca/elmulo-reporter",
-  "version": "2.0.0-beta.5",
+  "version": "2.0.0-beta.6",
   "description": "Reporter independiente para ejecuciones de Cypress con dashboard, historial SQLite y evidencias.",
   "type": "commonjs",
   "main": "plugin.cjs",
@@ -20,6 +20,7 @@
     "core.cjs",
     "executive-pdf.cjs",
     "finalize.cjs",
+    "jira.cjs",
     "plugin.cjs",
     "rerun.cjs",
     "security.cjs",

package/plugin.cjs

@@ -57,7 +57,7 @@ function registerElmuloReporter(on, config, options = {}) {
         "unknown",
       tagExpression: config.env?.TAGS || process.env.CYPRESS_TAGS || "",
       lifecycle: "running",
-      reporterVersion: "2.0.0-beta.5",
+      reporterVersion: "2.0.0-beta.6",
       execution: executionScript
         ? { runner: "npm", script: executionScript, args: executionArgs }
         : null,

package/server.cjs

@@ -19,8 +19,9 @@ const {
   PDF_SECTIONS,
   buildExecutivePdf,
 } = require("./executive-pdf.cjs");
-const { normalizeActor, sanitizeText } = require("./security.cjs");
-const { createRerunManager } = require("./rerun.cjs");
+const { normalizeActor, sanitizeText } = require("./security.cjs");
+const { createRerunManager } = require("./rerun.cjs");
+const { loadJiraConfig, reportDefect } = require("./jira.cjs");
 
 const MIME_TYPES = {
   ".css": "text/css; charset=utf-8",
@@ -136,8 +137,9 @@ async function serveReport(options = {}) {
   }
 
   let writeQueue = Promise.resolve();
-  const rerunManager = createRerunManager(projectRoot, options.rerun || {});
-  let allowedMutationOrigins = new Set();
+  const rerunManager = createRerunManager(projectRoot, options.rerun || {});
+  const jiraConfig = loadJiraConfig(projectRoot, options.env || process.env);
+  let allowedMutationOrigins = new Set();
 
   const server = http.createServer(async (request, response) => {
     const url = new URL(request.url || "/", `http://${request.headers.host || host}`);
@@ -177,14 +179,23 @@ async function serveReport(options = {}) {
       return;
     }
 
-    if (request.method === "GET" && url.pathname === "/api/health") {
+    if (request.method === "GET" && url.pathname === "/api/health") {
       sendJson(response, 200, {
         ok: true,
-        version: "2.0.0-beta.5",
+        version: "2.0.0-beta.6",
         schemaVersion: 3,
       });
-      return;
-    }
+      return;
+    }
+
+    if (request.method === "GET" && url.pathname === "/api/jira/status") {
+      sendJson(response, 200, {
+        enabled: jiraConfig.enabled,
+        projectKey: jiraConfig.projectKey,
+        issueType: jiraConfig.issueTypeName,
+      });
+      return;
+    }
 
     if (request.method === "GET" && url.pathname === "/api/export/executive.pdf") {
       const requestedSections = url.searchParams.has("sections")
@@ -446,7 +457,7 @@ async function serveReport(options = {}) {
       return;
     }
 
-    if (request.method === "POST" && url.pathname === "/api/annotations") {
+    if (request.method === "POST" && url.pathname === "/api/annotations") {
       try {
         const body = await readRequestJson(request);
         writeQueue = writeQueue.catch(() => {}).then(async () => {
@@ -488,8 +499,68 @@ async function serveReport(options = {}) {
       } catch (error) {
         sendJson(response, 400, { error: error.message });
       }
-      return;
-    }
+      return;
+    }
+
+    if (request.method === "POST" && url.pathname === "/api/jira/defects") {
+      if (!trustedMutationOrigin(request, allowedMutationOrigins)) {
+        sendJson(response, 403, { error: "Origen no autorizado para reportar defectos." }, {
+          allowAnyOrigin: false,
+        });
+        return;
+      }
+      try {
+        const body = await readRequestJson(request);
+        writeQueue = writeQueue.catch(() => {}).then(async () => {
+          const run = JSON.parse(fs.readFileSync(dataPath, "utf8"));
+          const test = run.tests.find((candidate) => candidate.id === body.testId);
+          if (body.runId !== run.id || !test) {
+            throw new Error("La prueba no pertenece al reporte activo.");
+          }
+          const comment = String(body.comment || "").trim();
+          const defect = await reportDefect({
+            config: jiraConfig,
+            projectRoot,
+            run,
+            test,
+            comment,
+          });
+
+          const database = await openDatabase(databasePath);
+          persistAnnotation(database, {
+            runId: run.id,
+            testId: test.id,
+            status: "reported",
+            comment,
+            ticket: defect.issueUrl,
+            actor: normalizeActor(body.actor),
+            source: `jira_${defect.action}`,
+          });
+          run.annotations = loadAnnotations(database, run.id);
+          run.trends = buildTrends(database, run);
+          persistDatabase(databasePath, database);
+          database.close();
+          writeJson(dataPath, run);
+          fs.writeFileSync(indexPath, buildHtml(run), "utf8");
+          return {
+            ...defect,
+            annotation: run.annotations[test.id],
+            annotations: run.annotations,
+            trends: run.trends,
+          };
+        });
+        sendJson(response, 200, await writeQueue, {
+          allowAnyOrigin: false,
+          allowOrigin: String(request.headers.origin || ""),
+        });
+      } catch (error) {
+        sendJson(response, 400, { error: error.message }, {
+          allowAnyOrigin: false,
+          allowOrigin: String(request.headers.origin || ""),
+        });
+      }
+      return;
+    }
 
     if (request.method === "POST" && url.pathname === "/api/bulk-annotations") {
       try {