@itzjoordi/jira-mcp 1.0.1 → 1.0.3

package/.env-example

@@ -1,3 +1,4 @@
 JIRA_BASE_URL=https://tu-org.atlassian.net
 JIRA_EMAIL=tu-email@empresa.com
-JIRA_API_TOKEN=TU_TOKEN_AQUI
+JIRA_API_TOKEN=TU_TOKEN_AQUI
+TEMPO_API_TOKEN=TU_TOKEN_DE_TEMPO_AQUI

package/.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

package/.prettierignore

@@ -1,3 +1,2 @@
 node_modules/
-.vscode/
 .env

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itzjoordi/jira-mcp",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Servidor MCP para Jira Mercadona usable desde Github Copilot Chat",
   "type": "module",
   "bin": {
@@ -9,7 +9,8 @@
   "scripts": {
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "format": "prettier --write ."
+    "format": "prettier --write .",
+    "prepare": "husky"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.22.0",
@@ -24,6 +25,17 @@
     "@eslint/js": "^9.39.1",
     "eslint": "^9.39.1",
     "globals": "^16.5.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
     "prettier": "^3.6.2"
+  },
+  "lint-staged": {
+    "*.{mjs,js}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md}": [
+      "prettier --write"
+    ]
   }
 }

package/server.mjs

@@ -1,235 +1,16 @@
 #!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
-
-import { searchIssues, getIssueTransitions, transitionIssue } from './jiraApi.mjs';
+import { registerAllTools } from './src/tools/index.mjs';
 
 // 1. Crear servidor MCP
 const server = new McpServer({
   name: 'jira-mcp',
-  version: '0.1.0',
+  version: '1.0.3',
 });
 
-// 2. Tools
-// Tool: listar issues con filtros simples
-server.registerTool(
-  'jira_list_filtered',
-  {
-    title: 'Jira: listar issues con filtros simples',
-    description:
-      'Lista issues de Jira usando filtros de alto nivel (solo mías, en curso, backlog, etc.) y construye la JQL automáticamente.',
-    inputSchema: {
-      projectKey: z
-        .string()
-        .optional()
-        .describe("Clave de proyecto, p.ej. 'SIM1'. Si se omite, busca en todos."),
-      onlyAssignedToMe: z
-        .boolean()
-        .optional()
-        .describe('Si es true, solo issues asignadas al usuario actual.'),
-      excludeAssignedToMe: z
-        .boolean()
-        .optional()
-        .describe('Si es true, excluye las issues asignadas al usuario actual.'),
-      statusCategory: z
-        .enum(['To Do', 'In Progress', 'Done'])
-        .optional()
-        .describe('Filtrar por categoría de estado de Jira.'),
-      statusIn: z
-        .array(z.string())
-        .optional()
-        .describe('Lista de nombres de estado, p.ej. ["Por Hacer", "Validar"].'),
-      backlogOnly: z
-        .boolean()
-        .optional()
-        .describe('Si es true, devuelve issues de backlog (aprox: no Done, normalmente To Do).'),
-      maxResults: z
-        .number()
-        .int()
-        .min(1)
-        .max(50)
-        .optional()
-        .describe('Máximo de issues a devolver (por defecto 20).'),
-    },
-  },
-  async ({
-    projectKey,
-    onlyAssignedToMe,
-    excludeAssignedToMe,
-    statusCategory,
-    statusIn,
-    backlogOnly,
-    maxResults,
-  }) => {
-    const clauses = [];
-
-    if (projectKey) {
-      clauses.push(`project = ${projectKey}`);
-    }
-
-    if (onlyAssignedToMe) {
-      clauses.push('assignee = currentUser()');
-    } else if (excludeAssignedToMe) {
-      clauses.push('assignee != currentUser()');
-    }
-
-    if (statusCategory) {
-      clauses.push(`statusCategory = "${statusCategory}"`);
-    }
-
-    if (statusIn && statusIn.length > 0) {
-      const quoted = statusIn.map((s) => `"${s}"`).join(', ');
-      clauses.push(`status in (${quoted})`);
-    }
-
-    if (backlogOnly) {
-      // Aproximación: backlog = no Done
-      clauses.push('statusCategory != "Done"');
-    }
-
-    let jql = clauses.join(' AND ');
-    const order = 'ORDER BY created DESC';
-
-    if (jql.trim().length === 0) {
-      jql = order;
-    } else {
-      jql = `${jql} ${order}`;
-    }
-
-    const issues = await searchIssues(jql, maxResults ?? 20);
-
-    const humanText =
-      issues.length === 0
-        ? `No se han encontrado issues para la JQL: ${jql}`
-        : `JQL usada: ${jql}\n\n` +
-          issues
-            .map(
-              (i) =>
-                `${i.key} | ${i.status} | ${i.summary}` + (i.assignee ? ` (${i.assignee})` : ''),
-            )
-            .join('\n');
-
-    return {
-      content: [
-        { type: 'text', text: humanText },
-        {
-          type: 'text',
-          text: '\n\n[JSON crudo para el modelo]\n' + JSON.stringify({ jql, issues }, null, 2),
-        },
-      ],
-      structuredContent: { jql, issues },
-    };
-  },
-);
-
-// Tool: obtener transiciones de un issue
-server.registerTool(
-  'jira_get_transitions',
-  {
-    title: 'Jira: obtener transiciones de un issue',
-    description:
-      'Devuelve las transiciones posibles (id, name, toStatus) para un issue de Jira concreto.',
-    inputSchema: {
-      issueKey: z.string().describe("Clave del issue, p.ej. 'SIM1-320'"),
-    },
-    // outputSchema opcional:
-    // outputSchema: z.array(
-    //   z.object({
-    //     id: z.string(),
-    //     name: z.string(),
-    //     toStatus: z.string(),
-    //   })
-    // ),
-  },
-  async ({ issueKey }) => {
-    const transitions = await getIssueTransitions(issueKey);
-
-    return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(transitions, null, 2),
-        },
-      ],
-      structuredContent: transitions,
-    };
-  },
-);
-
-// Tool: hacer transición de un issue
-server.registerTool(
-  'jira_transition_issue',
-  {
-    title: 'Jira: cambiar estado de un issue',
-    description: 'Ejecuta una transición de workflow en un issue de Jira usando su transitionId.',
-    inputSchema: {
-      issueKey: z.string().describe("Clave del issue, p.ej. 'SIM1-320'"),
-      transitionId: z.string().describe('ID de la transición (devuelta por jira_get_transitions)'),
-    },
-    // outputSchema opcional:
-    // outputSchema: z.object({ ok: z.boolean() }),
-  },
-  async ({ issueKey, transitionId }) => {
-    const result = await transitionIssue(issueKey, transitionId);
-
-    return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(result, null, 2),
-        },
-      ],
-      structuredContent: result,
-    };
-  },
-);
-
-// Tool: mover issue por nombre de transición
-server.registerTool(
-  'jira_move_issue_by_transition_name',
-  {
-    title: 'Jira: mover issue por nombre de transición',
-    description:
-      "Busca la transición por nombre (p.ej. 'Construir', 'Validar') y la ejecuta sobre el issue.",
-    inputSchema: {
-      issueKey: z.string().describe("Clave del issue, p.ej. 'SIM1-320'"),
-      transitionName: z.string().describe("Nombre exacto de la transición, p.ej. 'Construir'"),
-    },
-  },
-  async ({ issueKey, transitionName }) => {
-    const transitions = await getIssueTransitions(issueKey);
-    const match = transitions.find((t) => t.name.toLowerCase() === transitionName.toLowerCase());
-
-    if (!match) {
-      const available = transitions.map((t) => t.name).join(', ');
-      const msg =
-        `No se ha encontrado ninguna transición llamada "${transitionName}" ` +
-        `para el issue ${issueKey}. Transiciones disponibles: ${available}`;
-
-      return {
-        content: [{ type: 'text', text: msg }],
-        structuredContent: { ok: false, error: msg, transitions },
-      };
-    }
-
-    const result = await transitionIssue(issueKey, match.id);
-
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Transición "${match.name}" aplicada a ${issueKey}. Nuevo estado: ${match.toStatus}`,
-        },
-        {
-          type: 'text',
-          text: '\n[Detalle JSON]\n' + JSON.stringify({ result, usedTransition: match }, null, 2),
-        },
-      ],
-      structuredContent: { ok: true, usedTransition: match },
-    };
-  },
-);
+// 2. Registrar todas las tools
+registerAllTools(server);
 
 // 3. Conectar por STDIO
 const transport = new StdioServerTransport();

package/{jiraClient.mjs → src/config.mjs}

@@ -2,21 +2,22 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import dotenv from 'dotenv';
-import { Buffer } from 'buffer';
 import process from 'process';
 
+// ── Cargar .env global (una sola vez) ───────────────────────────
 let envLoaded = false;
 
 function loadGlobalEnvOnce() {
   if (envLoaded) return;
   envLoaded = true;
+
   const home = os.homedir();
   const candidates = [path.join(home, '.jira-mcp.env'), path.join(home, '.jira-mcp', '.env')];
 
   for (const p of candidates) {
     try {
       if (fs.existsSync(p)) {
-        dotenv.config({ path: p });
+        dotenv.config({ path: p, quiet: true });
         break;
       }
     } catch {
@@ -27,10 +28,21 @@ function loadGlobalEnvOnce() {
 
 loadGlobalEnvOnce();
 
-// --- a partir de aquí, uso normal de env:
-const baseUrl = process.env.JIRA_BASE_URL;
-const email = process.env.JIRA_EMAIL;
-const apiToken = process.env.JIRA_API_TOKEN;
+// ── Configuración exportada ─────────────────────────────────────
+export const config = {
+  jira: {
+    baseUrl: process.env.JIRA_BASE_URL,
+    email: process.env.JIRA_EMAIL,
+    apiToken: process.env.JIRA_API_TOKEN,
+  },
+  tempo: {
+    apiToken: process.env.TEMPO_API_TOKEN || null,
+    baseUrl: 'https://api.tempo.io/4',
+  },
+};
+
+// ── Validación de credenciales obligatorias ──────────────────────
+const { baseUrl, email, apiToken } = config.jira;
 
 if (!baseUrl || !email || !apiToken) {
   throw new Error(
@@ -40,33 +52,7 @@ if (!baseUrl || !email || !apiToken) {
       'Variables requeridas:\n' +
       'JIRA_BASE_URL=https://<tu-org>.atlassian.net\n' +
       'JIRA_EMAIL=tu-email@empresa.com\n' +
-      'JIRA_API_TOKEN=<tu-token>\n',
+      'JIRA_API_TOKEN=<tu-token>\n' +
+      'TEMPO_API_TOKEN=<tu-token-de-tempo> (opcional, para worklogs Tempo)\n',
   );
 }
-
-const authHeader = 'Basic ' + Buffer.from(`${email}:${apiToken}`).toString('base64');
-
-/**
- * Llamada genérica a Jira con manejo de errores
- */
-export async function jiraRequest(path, options = {}) {
-  const url = `${baseUrl}${path}`;
-
-  const response = await fetch(url, {
-    ...options,
-    headers: {
-      Authorization: authHeader,
-      Accept: 'application/json',
-      'Content-Type': 'application/json',
-      ...(options.headers || {}),
-    },
-  });
-
-  const text = await response.text();
-
-  if (!response.ok) {
-    throw new Error(`Jira error ${response.status} ${response.statusText}: ${text.slice(0, 400)}`);
-  }
-
-  return text ? JSON.parse(text) : {};
-}

package/src/domain/issues.mjs

@@ -0,0 +1,67 @@
+import { jiraRequest } from '../infrastructure/jira-client.mjs';
+
+/**
+ * Buscar issues usando JQL.
+ */
+export async function searchIssues(jql, maxResults = 20) {
+  const body = {
+    jql,
+    maxResults,
+    fields: ['summary', 'status', 'assignee', 'priority', 'subtasks'],
+  };
+
+  const data = await jiraRequest('/rest/api/3/search/jql', {
+    method: 'POST',
+    body: JSON.stringify(body),
+  });
+
+  const issues = data.issues ?? [];
+
+  return issues.map((issue) => ({
+    key: issue.key,
+    summary: issue.fields.summary,
+    status: issue.fields.status.name,
+    assignee: issue.fields.assignee?.displayName ?? null,
+    priority: issue.fields.priority?.name ?? null,
+    subtasks:
+      issue.fields.subtasks?.map((s) => ({
+        key: s.key,
+        summary: s.fields.summary,
+        status: s.fields.status.name,
+        statusCategory: s.fields.status.statusCategory?.name,
+      })) ?? [],
+  }));
+}
+
+/**
+ * Obtener detalle de un issue por su clave.
+ */
+export async function getIssue(issueKey) {
+  const data = await jiraRequest(
+    `/rest/api/3/issue/${issueKey}?fields=summary,status,assignee,priority,description,created,comment,subtasks`,
+    { method: 'GET' },
+  );
+
+  return {
+    key: data.key,
+    summary: data.fields.summary,
+    status: data.fields.status.name,
+    assignee: data.fields.assignee?.displayName ?? null,
+    priority: data.fields.priority?.name ?? null,
+    created: data.fields.created,
+    description: data.fields.description,
+    comments:
+      data.fields.comment?.comments.map((c) => ({
+        author: c.author.displayName,
+        body: c.body,
+        created: c.created,
+      })) ?? [],
+    subtasks:
+      data.fields.subtasks?.map((s) => ({
+        key: s.key,
+        summary: s.fields.summary,
+        status: s.fields.status.name,
+        statusCategory: s.fields.status.statusCategory?.name,
+      })) ?? [],
+  };
+}

package/src/domain/transitions.mjs

@@ -0,0 +1,28 @@
+import { jiraRequest } from '../infrastructure/jira-client.mjs';
+
+/**
+ * Obtener las transiciones posibles para un issue.
+ */
+export async function getTransitions(issueKey) {
+  const data = await jiraRequest(`/rest/api/3/issue/${issueKey}/transitions`, {
+    method: 'GET',
+  });
+
+  return (data.transitions ?? []).map((t) => ({
+    id: t.id,
+    name: t.name,
+    toStatus: t.to.name,
+  }));
+}
+
+/**
+ * Ejecutar una transición (mover a otro estado/columna).
+ */
+export async function transitionIssue(issueKey, transitionId) {
+  await jiraRequest(`/rest/api/3/issue/${issueKey}/transitions`, {
+    method: 'POST',
+    body: JSON.stringify({ transition: { id: transitionId } }),
+  });
+
+  return { ok: true };
+}

package/src/domain/user.mjs

@@ -0,0 +1,8 @@
+import { jiraRequest } from '../infrastructure/jira-client.mjs';
+
+/**
+ * Obtener datos del usuario autenticado.
+ */
+export async function getCurrentUser() {
+  return await jiraRequest('/rest/api/3/myself', { method: 'GET' });
+}

package/src/domain/worklogs.mjs

@@ -0,0 +1,225 @@
+import { jiraRequest } from '../infrastructure/jira-client.mjs';
+import { tempoRequest } from '../infrastructure/tempo-client.mjs';
+
+// ── Helpers ─────────────────────────────────────────────────────
+const pad2 = (n) => String(n).padStart(2, '0');
+const toLocalDate = (d) => `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+
+/**
+ * Resolver IDs numéricos de Jira a { key, summary } en batch.
+ */
+async function resolveIssueKeys(issueIds) {
+  const idToKey = {};
+  if (issueIds.length === 0) return idToKey;
+
+  const jql = `id in (${issueIds.join(',')})`;
+  const data = await jiraRequest('/rest/api/3/search/jql', {
+    method: 'POST',
+    body: JSON.stringify({ jql, maxResults: 50, fields: ['summary'] }),
+  });
+
+  for (const issue of data.issues ?? []) {
+    idToKey[issue.id] = { key: issue.key, summary: issue.fields.summary };
+  }
+
+  return idToKey;
+}
+
+/**
+ * Generar lista de días laborables (L-V) en un rango.
+ */
+function getBusinessDays(startDate, endDate) {
+  const days = [];
+  const cursor = new Date(`${startDate}T12:00:00`);
+  const end = new Date(`${endDate}T12:00:00`);
+
+  while (cursor <= end) {
+    const day = cursor.getDay();
+    if (day !== 0 && day !== 6) {
+      days.push(toLocalDate(cursor));
+    }
+    cursor.setDate(cursor.getDate() + 1);
+  }
+
+  return days;
+}
+
+// ── Jira nativo: registrar worklog ──────────────────────────────
+
+/**
+ * Registrar horas de trabajo en un issue (API nativa de Jira).
+ */
+export async function addWorklog(issueKey, timeSpent, commentText = '', started = null) {
+  const body = { timeSpent };
+
+  if (started) {
+    body.started = started;
+  }
+
+  if (commentText) {
+    body.comment = {
+      type: 'doc',
+      version: 1,
+      content: [
+        {
+          type: 'paragraph',
+          content: [{ text: commentText, type: 'text' }],
+        },
+      ],
+    };
+  }
+
+  await jiraRequest(`/rest/api/3/issue/${issueKey}/worklog`, {
+    method: 'POST',
+    body: JSON.stringify(body),
+  });
+
+  return { ok: true };
+}
+
+// ── Tempo: consultar worklogs ───────────────────────────────────
+
+/**
+ * Obtener worklogs de un usuario en un rango de fechas (Tempo API).
+ */
+export async function getTempoWorklogs(accountId, from, to) {
+  let allWorklogs = [];
+  let url = `/worklogs/user/${accountId}?from=${from}&to=${to}&limit=1000`;
+
+  while (url) {
+    const data = await tempoRequest(url);
+    const results = data.results ?? [];
+    allWorklogs = allWorklogs.concat(results);
+
+    if (data.metadata?.next) {
+      const nextUrl = new URL(data.metadata.next);
+      url = nextUrl.pathname.replace('/4', '') + nextUrl.search;
+    } else {
+      url = null;
+    }
+  }
+
+  return allWorklogs;
+}
+
+/**
+ * Detectar días laborables sin horas registradas (Tempo).
+ */
+export async function getMissingWorklogDays(accountId, startDate, endDate) {
+  const worklogs = await getTempoWorklogs(accountId, startDate, endDate);
+
+  // Agrupar horas por día
+  const dailyHours = {};
+  for (const wl of worklogs) {
+    const date = wl.startDate;
+    dailyHours[date] = (dailyHours[date] || 0) + wl.timeSpentSeconds / 3600;
+  }
+
+  const businessDays = getBusinessDays(startDate, endDate);
+  const today = toLocalDate(new Date());
+  const missingDays = businessDays.filter((d) => d <= today && !dailyHours[d]);
+
+  // Redondear
+  for (const d of Object.keys(dailyHours)) {
+    dailyHours[d] = Math.round(dailyHours[d] * 100) / 100;
+  }
+
+  return {
+    startDate,
+    endDate,
+    totalBusinessDays: businessDays.filter((d) => d <= today).length,
+    daysWithWorklogs: Object.keys(dailyHours).length,
+    missingDays,
+    dailyHours,
+  };
+}
+
+/**
+ * Obtener worklogs agrupados por issue (Tempo).
+ */
+export async function getWorklogsByIssue(accountId, from, to) {
+  const worklogs = await getTempoWorklogs(accountId, from, to);
+
+  const issueIds = [...new Set(worklogs.map((wl) => wl.issue?.id).filter(Boolean))];
+  const idToKey = await resolveIssueKeys(issueIds);
+
+  const byIssue = {};
+  let totalHours = 0;
+
+  for (const wl of worklogs) {
+    const resolved = idToKey[wl.issue?.id];
+    const key = resolved?.key ?? `ID-${wl.issue?.id}`;
+    const summary = resolved?.summary ?? '(sin título)';
+    const hours = Math.round((wl.timeSpentSeconds / 3600) * 100) / 100;
+
+    if (!byIssue[key]) {
+      byIssue[key] = { key, summary, totalHours: 0, entries: [] };
+    }
+
+    byIssue[key].totalHours += hours;
+    totalHours += hours;
+
+    byIssue[key].entries.push({
+      date: wl.startDate,
+      hours,
+      description: wl.description || '(sin descripción)',
+    });
+  }
+
+  for (const issue of Object.values(byIssue)) {
+    issue.totalHours = Math.round(issue.totalHours * 100) / 100;
+    issue.entries.sort((a, b) => a.date.localeCompare(b.date));
+  }
+
+  const sorted = Object.values(byIssue).sort((a, b) => b.totalHours - a.totalHours);
+
+  return {
+    from,
+    to,
+    totalHours: Math.round(totalHours * 100) / 100,
+    totalEntries: worklogs.length,
+    issues: sorted,
+  };
+}
+
+/**
+ * Obtener worklogs agrupados por día (Tempo).
+ */
+export async function getWorklogsByDay(accountId, from, to) {
+  const worklogs = await getTempoWorklogs(accountId, from, to);
+
+  const issueIds = [...new Set(worklogs.map((wl) => wl.issue?.id).filter(Boolean))];
+  const idToKey = await resolveIssueKeys(issueIds);
+
+  const byDay = {};
+  let totalHours = 0;
+
+  for (const wl of worklogs) {
+    const date = wl.startDate;
+    const resolved = idToKey[wl.issue?.id];
+    const key = resolved?.key ?? `ID-${wl.issue?.id}`;
+    const summary = resolved?.summary ?? '(sin título)';
+    const hours = Math.round((wl.timeSpentSeconds / 3600) * 100) / 100;
+
+    if (!byDay[date]) {
+      byDay[date] = { date, totalHours: 0, entries: [] };
+    }
+
+    byDay[date].totalHours += hours;
+    totalHours += hours;
+
+    byDay[date].entries.push({ key, summary, hours, description: wl.description || '' });
+  }
+
+  const sortedDays = Object.values(byDay)
+    .map((d) => ({ ...d, totalHours: Math.round(d.totalHours * 100) / 100 }))
+    .sort((a, b) => a.date.localeCompare(b.date));
+
+  return {
+    from,
+    to,
+    totalHours: Math.round(totalHours * 100) / 100,
+    totalEntries: worklogs.length,
+    days: sortedDays,
+  };
+}

package/src/infrastructure/jira-client.mjs

@@ -0,0 +1,30 @@
+import { Buffer } from 'buffer';
+import { config } from '../config.mjs';
+
+const { baseUrl, email, apiToken } = config.jira;
+const authHeader = 'Basic ' + Buffer.from(`${email}:${apiToken}`).toString('base64');
+
+/**
+ * Llamada genérica a la API de Jira con manejo de errores.
+ */
+export async function jiraRequest(path, options = {}) {
+  const url = `${baseUrl}${path}`;
+
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: authHeader,
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      ...(options.headers || {}),
+    },
+  });
+
+  const text = await response.text();
+
+  if (!response.ok) {
+    throw new Error(`Jira error ${response.status} ${response.statusText}: ${text.slice(0, 400)}`);
+  }
+
+  return text ? JSON.parse(text) : {};
+}

package/src/infrastructure/tempo-client.mjs

@@ -0,0 +1,35 @@
+import { config } from '../config.mjs';
+
+const { apiToken, baseUrl } = config.tempo;
+
+/**
+ * Llamada genérica a la API de Tempo con manejo de errores.
+ */
+export async function tempoRequest(path, options = {}) {
+  if (!apiToken) {
+    throw new Error(
+      'Falta TEMPO_API_TOKEN. Añádelo a tu .env global (~/.jira-mcp.env).\n' +
+        'Puedes generarlo en Tempo → Configuración → API Integration → New Token.',
+    );
+  }
+
+  const url = `${baseUrl}${path}`;
+
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${apiToken}`,
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      ...(options.headers || {}),
+    },
+  });
+
+  const text = await response.text();
+
+  if (!response.ok) {
+    throw new Error(`Tempo error ${response.status} ${response.statusText}: ${text.slice(0, 400)}`);
+  }
+
+  return text ? JSON.parse(text) : {};
+}

package/src/tools/index.mjs

@@ -0,0 +1,12 @@
+import { registerIssueTools } from './issues.mjs';
+import { registerTransitionTools } from './transitions.mjs';
+import { registerWorklogTools } from './worklogs.mjs';
+
+/**
+ * Registra todas las tools MCP en el servidor.
+ */
+export function registerAllTools(server) {
+  registerIssueTools(server);
+  registerTransitionTools(server);
+  registerWorklogTools(server);
+}

package/src/tools/issues.mjs

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+import { searchIssues, getIssue } from '../domain/issues.mjs';
+
+/**
+ * Registra las tools MCP relacionadas con issues.
+ */
+export function registerIssueTools(server) {
+  // ── Listar issues con filtros ───────────────────────────────
+  server.registerTool(
+    'jira_list_filtered',
+    {
+      title: 'Jira: listar issues con filtros simples',
+      description:
+        'Lista issues de Jira usando filtros de alto nivel (solo mías, en curso, backlog, etc.) y construye la JQL automáticamente.',
+      inputSchema: {
+        projectKey: z
+          .string()
+          .optional()
+          .describe("Clave de proyecto, p.ej. 'SIM1'. Si se omite, busca en todos."),
+        onlyAssignedToMe: z
+          .boolean()
+          .optional()
+          .describe('Si es true, solo issues asignadas al usuario actual.'),
+        excludeAssignedToMe: z
+          .boolean()
+          .optional()
+          .describe('Si es true, excluye las issues asignadas al usuario actual.'),
+        statusCategory: z
+          .enum(['To Do', 'In Progress', 'Done'])
+          .optional()
+          .describe('Filtrar por categoría de estado de Jira.'),
+        statusIn: z
+          .array(z.string())
+          .optional()
+          .describe('Lista de nombres de estado, p.ej. ["Por Hacer", "Validar"].'),
+        backlogOnly: z
+          .boolean()
+          .optional()
+          .describe('Si es true, devuelve issues de backlog (aprox: no Done, normalmente To Do).'),
+        maxResults: z
+          .number()
+          .int()
+          .min(1)
+          .max(50)
+          .optional()
+          .describe('Máximo de issues a devolver (por defecto 20).'),
+      },
+    },
+    async ({
+      projectKey,
+      onlyAssignedToMe,
+      excludeAssignedToMe,
+      statusCategory,
+      statusIn,
+      backlogOnly,
+      maxResults,
+    }) => {
+      const clauses = [];
+
+      if (projectKey) clauses.push(`project = "${projectKey}"`);
+
+      if (onlyAssignedToMe) {
+        clauses.push('assignee = currentUser()');
+      } else if (excludeAssignedToMe) {
+        clauses.push('assignee != currentUser()');
+      }
+
+      if (statusCategory) {
+        clauses.push(`statusCategory = "${statusCategory}"`);
+        if (statusCategory === 'In Progress') {
+          clauses.push('status != "Validar"');
+        }
+      }
+
+      if (statusIn && statusIn.length > 0) {
+        const quoted = statusIn.map((s) => `"${s}"`).join(', ');
+        clauses.push(`status in (${quoted})`);
+      }
+
+      if (backlogOnly) {
+        clauses.push('statusCategory != "Done"');
+      }
+
+      let jql = clauses.join(' AND ');
+      const order = 'ORDER BY created DESC';
+      jql = jql.trim().length === 0 ? order : `${jql} ${order}`;
+
+      const issues = await searchIssues(jql, maxResults ?? 20);
+
+      const humanText =
+        issues.length === 0
+          ? `No se han encontrado issues para la JQL: ${jql}`
+          : `JQL usada: ${jql}\n\n` +
+            issues
+              .map((i) => {
+                let text =
+                  `${i.key} | ${i.status} | ${i.summary}` + (i.assignee ? ` (${i.assignee})` : '');
+                if (i.subtasks && i.subtasks.length > 0) {
+                  const subs = i.subtasks
+                    .map((s) => `  - [Sub] ${s.key} | ${s.status} | ${s.summary}`)
+                    .join('\n');
+                  text += `\n${subs}`;
+                }
+                return text;
+              })
+              .join('\n\n');
+
+      return {
+        content: [
+          { type: 'text', text: humanText },
+          {
+            type: 'text',
+            text: '\n\n[JSON crudo para el modelo]\n' + JSON.stringify({ jql, issues }, null, 2),
+          },
+        ],
+        structuredContent: { jql, issues },
+      };
+    },
+  );
+
+  // ── Detalle de un issue ─────────────────────────────────────
+  server.registerTool(
+    'jira_get_issue',
+    {
+      title: 'Jira: obtener detalle de un issue',
+      description: 'Devuelve información detallada de un issue (descripción, comentarios, etc.).',
+      inputSchema: {
+        issueKey: z.string().describe("Clave del issue, p.ej. 'SIM1-320'"),
+      },
+    },
+    async ({ issueKey }) => {
+      const issue = await getIssue(issueKey);
+
+      const pendingSubs = (issue.subtasks || []).filter((s) => s.statusCategory !== 'Done');
+      let summaryText = `Detalle de ${issue.key}: ${issue.summary}\n`;
+      summaryText += `Estado: ${issue.status} | Asignado: ${issue.assignee}\n`;
+
+      if (pendingSubs.length > 0) {
+        summaryText += `\n⚠️ Subtareas pendientes (${pendingSubs.length}):\n`;
+        summaryText += pendingSubs.map((s) => `- ${s.key} [${s.status}]: ${s.summary}`).join('\n');
+      } else if (issue.subtasks?.length > 0) {
+        summaryText += `\n✅ Todas las subtareas (${issue.subtasks.length}) están finalizadas.`;
+      }
+
+      return {
+        content: [
+          { type: 'text', text: summaryText },
+          {
+            type: 'text',
+            text: '\n[JSON completo]\n' + JSON.stringify(issue, null, 2),
+          },
+        ],
+        structuredContent: issue,
+      };
+    },
+  );
+}

package/src/tools/transitions.mjs

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { getTransitions, transitionIssue } from '../domain/transitions.mjs';
+
+/**
+ * Registra las tools MCP relacionadas con transiciones.
+ */
+export function registerTransitionTools(server) {
+  // ── Obtener transiciones ────────────────────────────────────
+  server.registerTool(
+    'jira_get_transitions',
+    {
+      title: 'Jira: obtener transiciones de un issue',
+      description:
+        'Devuelve las transiciones posibles (id, name, toStatus) para un issue de Jira concreto.',
+      inputSchema: {
+        issueKey: z.string().describe("Clave del issue, p.ej. 'SIM1-320'"),
+      },
+    },
+    async ({ issueKey }) => {
+      const transitions = await getTransitions(issueKey);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(transitions, null, 2) }],
+        structuredContent: transitions,
+      };
+    },
+  );
+
+  // ── Ejecutar transición por ID ──────────────────────────────
+  server.registerTool(
+    'jira_transition_issue',
+    {
+      title: 'Jira: cambiar estado de un issue',
+      description: 'Ejecuta una transición de workflow en un issue de Jira usando su transitionId.',
+      inputSchema: {
+        issueKey: z.string().describe("Clave del issue, p.ej. 'SIM1-320'"),
+        transitionId: z
+          .string()
+          .describe('ID de la transición (devuelta por jira_get_transitions)'),
+      },
+    },
+    async ({ issueKey, transitionId }) => {
+      const result = await transitionIssue(issueKey, transitionId);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        structuredContent: result,
+      };
+    },
+  );
+
+  // ── Mover por nombre de transición ──────────────────────────
+  server.registerTool(
+    'jira_move_issue_by_transition_name',
+    {
+      title: 'Jira: mover issue por nombre de transición',
+      description:
+        "Busca la transición por nombre (p.ej. 'Construir', 'Validar') y la ejecuta sobre el issue.",
+      inputSchema: {
+        issueKey: z.string().describe("Clave del issue, p.ej. 'SIM1-320'"),
+        transitionName: z.string().describe("Nombre exacto de la transición, p.ej. 'Construir'"),
+      },
+    },
+    async ({ issueKey, transitionName }) => {
+      const transitions = await getTransitions(issueKey);
+      const match = transitions.find((t) => t.name.toLowerCase() === transitionName.toLowerCase());
+
+      if (!match) {
+        const available = transitions.map((t) => t.name).join(', ');
+        const msg =
+          `No se ha encontrado ninguna transición llamada "${transitionName}" ` +
+          `para el issue ${issueKey}. Transiciones disponibles: ${available}`;
+
+        return {
+          content: [{ type: 'text', text: msg }],
+          structuredContent: { ok: false, error: msg, transitions },
+        };
+      }
+
+      const result = await transitionIssue(issueKey, match.id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Transición "${match.name}" aplicada a ${issueKey}. Nuevo estado: ${match.toStatus}`,
+          },
+          {
+            type: 'text',
+            text: '\n[Detalle JSON]\n' + JSON.stringify({ result, usedTransition: match }, null, 2),
+          },
+        ],
+        structuredContent: { ok: true, usedTransition: match },
+      };
+    },
+  );
+}

package/src/tools/worklogs.mjs

@@ -0,0 +1,235 @@
+import { z } from 'zod';
+import { config } from '../config.mjs';
+import { getCurrentUser } from '../domain/user.mjs';
+import {
+  addWorklog,
+  getMissingWorklogDays,
+  getWorklogsByIssue,
+  getWorklogsByDay,
+} from '../domain/worklogs.mjs';
+
+// ── Helpers ─────────────────────────────────────────────────────
+const pad2 = (n) => String(n).padStart(2, '0');
+
+function getDefaultDateRange() {
+  const now = new Date();
+  return {
+    start: `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-01`,
+    end: `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())}`,
+  };
+}
+
+function requireTempo() {
+  if (!config.tempo.apiToken) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text:
+            '⚠️ Falta TEMPO_API_TOKEN en tu .env global (~/.jira-mcp.env).\n' +
+            'Genera uno en Tempo → Configuración → API Integration → New Token.',
+        },
+      ],
+    };
+  }
+  return null;
+}
+
+const dateRangeSchema = {
+  startDate: z
+    .string()
+    .optional()
+    .describe('Fecha de inicio en formato YYYY-MM-DD. Por defecto: primer día del mes actual.'),
+  endDate: z.string().optional().describe('Fecha de fin en formato YYYY-MM-DD. Por defecto: hoy.'),
+};
+
+/**
+ * Registra las tools MCP relacionadas con worklogs.
+ */
+export function registerWorklogTools(server) {
+  // ── Registrar horas ─────────────────────────────────────────
+  server.registerTool(
+    'jira_add_worklog',
+    {
+      title: 'Jira: registrar horas de trabajo',
+      description: 'Registra tiempo trabajado en un issue o subtarea (p.ej. "1h 30m").',
+      inputSchema: {
+        issueKey: z.string().describe("Clave del issue, p.ej. 'SIM1-320'"),
+        timeSpent: z.string().describe('Tiempo trabajado, p.ej. "30m", "1h", "2h 15m"'),
+        comment: z
+          .string()
+          .describe(
+            'Comentario obligatorio sobre el trabajo realizado (p.ej. "Desarrollo de componentes")',
+          ),
+        started: z
+          .string()
+          .optional()
+          .describe(
+            'Fecha y hora de inicio en formato ISO 8601 (p.ej. 2026-02-18T09:00:00.000+0000). Úsalo si el usuario menciona una fecha pasada como "ayer".',
+          ),
+      },
+    },
+    async ({ issueKey, timeSpent, comment, started }) => {
+      const result = await addWorklog(issueKey, timeSpent, comment, started);
+
+      return {
+        content: [
+          { type: 'text', text: `Se han registrado ${timeSpent} en el issue ${issueKey}.` },
+        ],
+        structuredContent: result,
+      };
+    },
+  );
+
+  // ── Días sin horas registradas (Tempo) ──────────────────────
+  server.registerTool(
+    'jira_missing_worklogs',
+    {
+      title: 'Jira: días sin horas registradas',
+      description:
+        'Detecta qué días laborables (L-V) NO tienen horas registradas para el usuario actual. ' +
+        'Por defecto analiza el mes en curso.',
+      inputSchema: dateRangeSchema,
+    },
+    async ({ startDate, endDate }) => {
+      const tempoError = requireTempo();
+      if (tempoError) return tempoError;
+
+      const defaults = getDefaultDateRange();
+      const from = startDate || defaults.start;
+      const to = endDate || defaults.end;
+
+      const currentUser = await getCurrentUser();
+      const result = await getMissingWorklogDays(currentUser.accountId, from, to);
+
+      let text = `📊 Reporte de worklogs: ${from} → ${to}\n`;
+      text += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+      text += `Días laborables en el rango: ${result.totalBusinessDays}\n`;
+      text += `Días con horas registradas:  ${result.daysWithWorklogs}\n`;
+      text += `Días SIN horas registradas:  ${result.missingDays.length}\n\n`;
+
+      if (result.missingDays.length > 0) {
+        text += `❌ Días pendientes:\n`;
+        for (const d of result.missingDays) {
+          const dayName = new Date(`${d}T12:00:00`).toLocaleDateString('es-ES', {
+            weekday: 'long',
+          });
+          text += `  • ${d} (${dayName})\n`;
+        }
+      } else {
+        text += `✅ ¡Todos los días laborables tienen horas registradas!\n`;
+      }
+
+      if (Object.keys(result.dailyHours).length > 0) {
+        text += `\n📝 Horas registradas por día:\n`;
+        for (const d of Object.keys(result.dailyHours).sort()) {
+          const h = result.dailyHours[d];
+          const dayName = new Date(`${d}T12:00:00`).toLocaleDateString('es-ES', {
+            weekday: 'short',
+          });
+          text += `  • ${d} (${dayName}): ${h}h\n`;
+        }
+      }
+
+      return {
+        content: [
+          { type: 'text', text },
+          { type: 'text', text: '\n[JSON detallado]\n' + JSON.stringify(result, null, 2) },
+        ],
+        structuredContent: result,
+      };
+    },
+  );
+
+  // ── Horas por tarea (Tempo) ─────────────────────────────────
+  server.registerTool(
+    'jira_worklogs_by_issue',
+    {
+      title: 'Jira: horas registradas por tarea',
+      description:
+        'Devuelve las horas registradas (Tempo) del usuario actual agrupadas por issue/tarea. ' +
+        'Por defecto analiza el mes en curso.',
+      inputSchema: dateRangeSchema,
+    },
+    async ({ startDate, endDate }) => {
+      const tempoError = requireTempo();
+      if (tempoError) return tempoError;
+
+      const defaults = getDefaultDateRange();
+      const from = startDate || defaults.start;
+      const to = endDate || defaults.end;
+
+      const currentUser = await getCurrentUser();
+      const result = await getWorklogsByIssue(currentUser.accountId, from, to);
+
+      let text = `📋 Horas por tarea: ${from} → ${to}\n`;
+      text += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+      text += `Total horas: ${result.totalHours}h | Entradas: ${result.totalEntries} | Issues: ${result.issues.length}\n\n`;
+
+      for (const issue of result.issues) {
+        text += `🔹 ${issue.key} — ${issue.summary} (${issue.totalHours}h)\n`;
+        for (const entry of issue.entries) {
+          const dayName = new Date(`${entry.date}T12:00:00`).toLocaleDateString('es-ES', {
+            weekday: 'short',
+          });
+          text += `    ${entry.date} (${dayName}): ${entry.hours}h — ${entry.description}\n`;
+        }
+        text += '\n';
+      }
+
+      return {
+        content: [
+          { type: 'text', text },
+          { type: 'text', text: '\n[JSON detallado]\n' + JSON.stringify(result, null, 2) },
+        ],
+        structuredContent: result,
+      };
+    },
+  );
+
+  // ── Horas por día (Tempo) ───────────────────────────────────
+  server.registerTool(
+    'jira_worklogs_by_day',
+    {
+      title: 'Jira: horas registradas por día',
+      description:
+        'Devuelve las horas registradas (Tempo) del usuario actual agrupadas por día. ' +
+        'Por defecto analiza el mes en curso.',
+      inputSchema: dateRangeSchema,
+    },
+    async ({ startDate, endDate }) => {
+      const tempoError = requireTempo();
+      if (tempoError) return tempoError;
+
+      const defaults = getDefaultDateRange();
+      const from = startDate || defaults.start;
+      const to = endDate || defaults.end;
+
+      const currentUser = await getCurrentUser();
+      const result = await getWorklogsByDay(currentUser.accountId, from, to);
+
+      let text = `📅 Horas por día: ${from} → ${to}\n`;
+      text += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+      text += `Total horas: ${result.totalHours}h | Entradas: ${result.totalEntries} | Días: ${result.days.length}\n\n`;
+
+      for (const day of result.days) {
+        const dayName = new Date(`${day.date}T12:00:00`).toLocaleDateString('es-ES', {
+          weekday: 'long',
+        });
+        text += `📌 ${day.date} (${dayName}) — ${day.totalHours}h\n`;
+        for (const entry of day.entries) {
+          text += `    ${entry.key}: ${entry.hours}h — ${entry.description || entry.summary}\n`;
+        }
+        text += '\n';
+      }
+
+      return {
+        content: [
+          { type: 'text', text },
+          { type: 'text', text: '\n[JSON detallado]\n' + JSON.stringify(result, null, 2) },
+        ],
+        structuredContent: result,
+      };
+    },
+  );
+}

package/jiraApi.mjs

@@ -1,61 +0,0 @@
-// jiraApi.mjs
-import { jiraRequest } from './jiraClient.mjs';
-
-/**
- * Buscar issues usando JQL (API nueva /search/jql)
- */
-export async function searchIssues(jql, maxResults = 20) {
-  const body = {
-    jql,
-    maxResults,
-    fields: ['summary', 'status', 'assignee', 'priority'],
-  };
-
-  const data = await jiraRequest('/rest/api/3/search/jql', {
-    method: 'POST',
-    body: JSON.stringify(body),
-  });
-
-  const issues = data.issues ?? [];
-
-  return issues.map((issue) => ({
-    key: issue.key,
-    summary: issue.fields.summary,
-    status: issue.fields.status.name,
-    assignee: issue.fields.assignee?.displayName ?? null,
-    priority: issue.fields.priority?.name ?? null,
-  }));
-}
-
-/**
- * Obtener las transiciones posibles para un issue
- */
-export async function getIssueTransitions(issueKey) {
-  const data = await jiraRequest(`/rest/api/3/issue/${issueKey}/transitions`, {
-    method: 'GET',
-  });
-
-  const transitions = data.transitions ?? [];
-
-  return transitions.map((t) => ({
-    id: t.id,
-    name: t.name,
-    toStatus: t.to.name,
-  }));
-}
-
-/**
- * Ejecutar una transición (mover a otro estado/columna)
- */
-export async function transitionIssue(issueKey, transitionId) {
-  const body = {
-    transition: { id: transitionId },
-  };
-
-  const jiraRequest = await jiraRequest(`/rest/api/3/issue/${issueKey}/transitions`, {
-    method: 'POST',
-    body: JSON.stringify(body),
-  });
-
-  return { ok: true };
-}