@dami_deleon/rikudo 2.0.1 → 2.1.0

package/README.md

@@ -90,6 +90,11 @@ rikudo pr -t 1234
 rikudo test
 ```
 
+* **Ver Ticket:**
+```bash
+rikudo ticket 1234
+```
+
 * **Configuración:**
 ```bash
 rikudo config
@@ -112,10 +117,11 @@ El servidor se comunica mediante **stdio**, permitiendo integrarse con cualquier
 | Herramienta | Descripción |
 |------------|-------------|
 | `validate_configuration` | Verifica que las variables de entorno necesarias (Redmine, Gitea) estén configuradas correctamente. |
-| `get_ticket_context` | Obtiene el contexto completo de un ticket de Redmine (título, descripción, estado, prioridad). |
+| `get_ticket_context` | Obtiene el contexto completo de un ticket de Redmine (título, descripción, estado, prioridad, custom fields). |
 | `get_git_diff` | Retorna el diff de los archivos que están en staging (`git add`). |
 | `shift_left_start` | Flujo shift-left completo: checkout a rama objetivo, crea nueva rama, commit vacío y abre Draft PR en Gitea. Soporta parámetro `isWip` para usar prefijo "WIP:" en el título. |
 | `update_pm_redmine` | Agrega un comentario a un ticket de Redmine para notificar al Project Manager. |
+| `update_custom_fields` | Actualiza los campos personalizados (Custom Fields) de un ticket de Redmine. |
 
 #### Prompts Disponibles
 
@@ -157,8 +163,8 @@ RIKUDO_REDMINE_API_KEY=tu_redmine_key
 # Gitea
 RIKUDO_GITEA_URL=https://gitea.tuempresa.com
 RIKUDO_GITEA_TOKEN=tu_gitea_token
-RIKUDO_GITEA_OWNER=tu_usuario_o_organizacion
-RIKUDO_GITEA_REPO=nombre_del_repositorio
+RIKUDO_GITEA_OWNER=tu_usuario_o_organizacion  # Opcional
+RIKUDO_GITEA_REPO=nombre_del_repositorio       # Opcional
 ```
 
 #### Formato de Ramas
@@ -197,8 +203,8 @@ RIKUDO_REDMINE_API_KEY=tu_redmine_key
 # --- Gitea (para servidor MCP) ---
 RIKUDO_GITEA_URL=https://gitea.tuempresa.com
 RIKUDO_GITEA_TOKEN=tu_gitea_token
-RIKUDO_GITEA_OWNER=tu_usuario_o_organizacion
-RIKUDO_GITEA_REPO=nombre_del_repositorio
+RIKUDO_GITEA_OWNER=tu_usuario_o_organizacion  # Opcional: se obtiene del remote si no se especifica
+RIKUDO_GITEA_REPO=nombre_del_repositorio       # Opcional: se obtiene del remote si no se especifica
 ```
 
 ### Plantillas Personalizadas

package/dist/index.js

@@ -5,7 +5,7 @@ import chalk from "chalk";
 import figlet from "figlet";
 import clipboardy from "clipboardy"; // <--- Nueva dependencia
 import { getStagedDiff, getStagedFiles, commitChanges, getRecentCommits, getCommitList, } from "./services/git.js";
-import { getIssueDetails, updateIssueComment, } from "./services/redmine.js";
+import { getIssueDetails, updateIssueComment, printTicketDetails, } from "./services/redmine.js";
 import { showConfigMenu } from "./menus/configMenu.js";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
@@ -63,6 +63,23 @@ program
     .command("config")
     .description("Abrir menú de configuración")
     .action(() => showConfigMenu());
+// Ticket
+const ticketCmd = program
+    .command("ticket <ticketId>")
+    .description("Ver detalles de un ticket de Redmine");
+ticketCmd.action(async (ticketId) => {
+    loadEnv();
+    if (!ticketId) {
+        console.log(chalk.red("❌ Debes especificar un ticket: rikudo ticket <id>"));
+        process.exit(1);
+    }
+    const ticket = await getIssueDetails(ticketId);
+    if (!ticket) {
+        console.log(chalk.red(`❌ No se encontró el ticket #${ticketId}`));
+        process.exit(1);
+    }
+    printTicketDetails(ticket);
+});
 // MCP Server
 program
     .command("mcp")

package/dist/mcp/server.js

@@ -2,7 +2,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { simpleGit } from "simple-git";
-import { getIssueDetails, updateIssueComment } from "../services/redmine.js";
+import { getIssueDetails, updateIssueComment, updateIssueCustomFields } from "../services/redmine.js";
 import { getStagedDiff } from "../services/git.js";
 import { createPullRequest } from "../services/gitea.js";
 import { loadEnv } from "../utils/env.js";
@@ -46,6 +46,7 @@ server.registerTool("get_ticket_context", {
                         priority: ticket.priority,
                         author: ticket.author,
                         url: ticket.url,
+                        customFields: ticket.customFields,
                     }, null, 2),
                 },
             ],
@@ -117,11 +118,18 @@ server.registerTool("shift_left_start", {
     }),
 }, async ({ ticketId, branchName, targetBranch, isWip }) => {
     try {
-        await git.checkout(targetBranch);
-        await git.pull("origin", targetBranch);
-        await git.checkoutLocalBranch(branchName);
-        await git.commit("chore: init #" + ticketId, ["--allow-empty"]);
-        await git.push(["-u", "origin", branchName]);
+        const branches = await git.branchLocal();
+        const branchExists = branches.all.includes(branchName);
+        if (branchExists) {
+            await git.checkout(branchName);
+        }
+        else {
+            await git.checkout(targetBranch);
+            await git.pull("origin", targetBranch);
+            await git.checkoutLocalBranch(branchName);
+            await git.commit("chore: init #" + ticketId, ["--allow-empty"]);
+            await git.push(["-u", "origin", branchName]);
+        }
         const ticket = await getIssueDetails(ticketId);
         const prTitle = isWip
             ? `WIP: ${ticket?.subject || `Ticket #${ticketId}`}`
@@ -136,7 +144,7 @@ server.registerTool("shift_left_start", {
         });
         if (!prResult.success) {
             return {
-                content: [{ type: "text", text: `Rama '${branchName}' creada y empujada a origin. Error al crear PR: ${prResult.error}` }],
+                content: [{ type: "text", text: `Rama '${branchName}' lista. Error al crear PR: ${prResult.error}` }],
                 isError: true,
             };
         }
@@ -148,9 +156,12 @@ server.registerTool("shift_left_start", {
                         success: true,
                         branch: branchName,
                         targetBranch,
+                        branchCreated: !branchExists,
                         prUrl: prResult.url,
                         prNumber: prResult.number,
-                        message: `Entorno preparado en rama '${branchName}'. Draft PR creado: ${prResult.url}`,
+                        message: branchExists
+                            ? `Rama '${branchName}' verificada. Draft PR creado: ${prResult.url}`
+                            : `Rama '${branchName}' creada. Draft PR creado: ${prResult.url}`,
                     }, null, 2),
                 },
             ],
@@ -180,6 +191,28 @@ server.registerTool("update_pm_redmine", {
         return { content: [{ type: "text", text: `Error actualizando Redmine: ${errorMessage}` }], isError: true };
     }
 });
+server.registerTool("update_custom_fields", {
+    title: "Update Custom Fields",
+    description: "Actualiza los campos personalizados (Custom Fields) de un ticket de Redmine. Usa get_ticket_context primero para ver los campos disponibles y sus IDs.",
+    inputSchema: z.object({
+        ticketId: z.string().describe("ID del ticket de Redmine (ej: '1234')"),
+        customFields: z.array(z.object({
+            id: z.number().describe("ID del custom field"),
+            value: z.string().describe("Nuevo valor para el campo"),
+        })).describe("Array de custom fields a actualizar"),
+    }),
+}, async ({ ticketId, customFields }) => {
+    try {
+        await updateIssueCustomFields(ticketId, customFields);
+        return {
+            content: [{ type: "text", text: `Custom fields actualizados exitosamente en el ticket #${ticketId}` }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Error desconocido";
+        return { content: [{ type: "text", text: `Error actualizando custom fields: ${errorMessage}` }], isError: true };
+    }
+});
 server.registerPrompt("start_feature", {
     title: "Start Feature",
     description: "Inicia el flujo de trabajo para una nueva feature. Obtiene contexto del ticket y prepara el entorno en Gitea.",

package/dist/services/customFieldsCache.js

@@ -0,0 +1,59 @@
+import axios from "axios";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { getConfig } from "../utils/config.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CUSTOM_FIELDS_CACHE_FILE = path.resolve(__dirname, "../../.rikudo_custom_fields.json");
+let cachedFields = null;
+export function getCustomFieldsCache() {
+    if (cachedFields) {
+        return cachedFields;
+    }
+    try {
+        if (fs.existsSync(CUSTOM_FIELDS_CACHE_FILE)) {
+            const data = JSON.parse(fs.readFileSync(CUSTOM_FIELDS_CACHE_FILE, "utf-8"));
+            cachedFields = new Map(data.fields.map((f) => [f.id, f]));
+            return cachedFields;
+        }
+    }
+    catch (error) {
+        console.error("Error reading custom fields cache:", error);
+    }
+    return new Map();
+}
+export async function initCustomFieldsCache() {
+    const config = getConfig();
+    if (!config.REDMINE_URL || !config.REDMINE_API_KEY) {
+        return;
+    }
+    try {
+        const client = axios.create({
+            baseURL: config.REDMINE_URL,
+            headers: { "X-Redmine-API-Key": config.REDMINE_API_KEY },
+        });
+        const response = await client.get("/custom_fields.json");
+        const fields = response.data.custom_fields;
+        const cache = {
+            fields,
+            updatedAt: Date.now(),
+        };
+        fs.writeFileSync(CUSTOM_FIELDS_CACHE_FILE, JSON.stringify(cache, null, 2));
+        cachedFields = new Map(fields.map((f) => [f.id, f]));
+    }
+    catch (error) {
+        console.error("Error initializing custom fields cache:", error);
+    }
+}
+export function enrichCustomFields(customFields) {
+    const cache = getCustomFieldsCache();
+    return customFields.map((field) => {
+        const definition = cache.get(field.id);
+        return {
+            id: field.id,
+            name: definition?.name || `Field ${field.id}`,
+            value: field.value,
+        };
+    });
+}

package/dist/services/git.js

@@ -44,3 +44,18 @@ export async function getProjectId() {
     }
     return projectId;
 }
+export async function getGitRemoteInfo() {
+    const remote = await git.remote(["get-url", "origin"]);
+    if (!remote) {
+        throw new Error("No se pudo obtener el remote de Git");
+    }
+    const cleanRemote = remote.trim().replace(".git", "");
+    const url = new URL(cleanRemote);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    if (pathParts.length < 2) {
+        throw new Error("Formato de remote no válido. Expected: https://gitea.host/owner/repo.git");
+    }
+    const owner = pathParts[pathParts.length - 2];
+    const repo = pathParts[pathParts.length - 1];
+    return { owner, repo };
+}

package/dist/services/gitea.js

@@ -1,32 +1,41 @@
 import axios, { AxiosError } from "axios";
-const getGiteaConfig = () => {
-    return {
-        url: process.env.RIKUDO_GITEA_URL || "",
-        token: process.env.RIKUDO_GITEA_TOKEN || "",
-        owner: process.env.RIKUDO_GITEA_OWNER || "",
-        repo: process.env.RIKUDO_GITEA_REPO || "",
-    };
+import { getGitRemoteInfo } from "./git.js";
+const getGiteaConfig = async () => {
+    const url = process.env.RIKUDO_GITEA_URL || "";
+    const token = process.env.RIKUDO_GITEA_TOKEN || "";
+    let owner = process.env.RIKUDO_GITEA_OWNER || "";
+    let repo = process.env.RIKUDO_GITEA_REPO || "";
+    if (!owner || !repo) {
+        try {
+            const remoteInfo = await getGitRemoteInfo();
+            owner = owner || remoteInfo.owner;
+            repo = repo || remoteInfo.repo;
+        }
+        catch {
+            // Remote info not available, will be validated later
+        }
+    }
+    return { url, token, owner, repo };
 };
-const getGiteaClient = () => {
-    const config = getGiteaConfig();
+const getGiteaClient = (url, token) => {
     return axios.create({
-        baseURL: config.url,
+        baseURL: url,
         headers: {
-            Authorization: `token ${config.token}`,
+            Authorization: `token ${token}`,
             "Content-Type": "application/json",
         },
     });
 };
 export const createPullRequest = async (payload) => {
-    const config = getGiteaConfig();
+    const config = await getGiteaConfig();
     if (!config.url || !config.token || !config.owner || !config.repo) {
         return {
             success: false,
-            error: "Faltan variables de entorno de Gitea (RIKUDO_GITEA_URL, RIKUDO_GITEA_TOKEN, RIKUDO_GITEA_OWNER, RIKUDO_GITEA_REPO)",
+            error: "Faltan variables de entorno de Gitea (RIKUDO_GITEA_URL, RIKUDO_GITEA_TOKEN, RIKUDO_GITEA_OWNER, RIKUDO_GITEA_REPO) o no se pudo obtener el remote de Git",
         };
     }
     try {
-        const client = getGiteaClient();
+        const client = getGiteaClient(config.url, config.token);
         const endpoint = `/api/v1/repos/${config.owner}/${config.repo}/pulls`;
         const response = await client.post(endpoint, {
             title: payload.title,

package/dist/services/redmine.js

@@ -1,4 +1,5 @@
 import axios, { AxiosError } from "axios";
+import chalk from "chalk";
 import { getConfig } from "../utils/config.js";
 import z from "zod";
 function cleanRedmineMarkdown(text) {
@@ -112,6 +113,7 @@ const issueSchema = z
             updated: issue.updated_on,
             estimatedHours: issue.estimated_hours,
         },
+        customFields: issue.custom_fields,
     };
 });
 const getHttpRedmineClient = () => {
@@ -157,6 +159,12 @@ export const updateIssueComment = async (issueId, comment) => {
         console.error("❌ Error actualizando Redmine.");
     }
 };
+export const updateIssueCustomFields = async (ticketId, customFields) => {
+    const client = getHttpRedmineClient();
+    await client.put(`/issues/${ticketId}.json`, {
+        issue: { custom_fields: customFields },
+    });
+};
 const userSchema = z
     .object({
     id: z.number(),
@@ -196,9 +204,37 @@ export const checkRedmineConnection = async () => {
         return false;
     }
 };
+export function printTicketDetails(ticket) {
+    console.log(chalk.bold.cyan("\n━━━ Ticket #" + ticket.id + " ━━━"));
+    console.log(chalk.bold.white(ticket.subject));
+    console.log(chalk.dim("─".repeat(40)));
+    console.log(chalk.gray("Estado: ") + chalk.green(ticket.status));
+    console.log(chalk.gray("Prioridad: ") + chalk.yellow(ticket.priority));
+    console.log(chalk.gray("Tracker: ") + ticket.tracker);
+    console.log(chalk.gray("Proyecto: ") + ticket.project);
+    console.log(chalk.gray("Autor: ") + ticket.author);
+    console.log(chalk.gray("URL: ") + chalk.blue.underline(ticket.url));
+    if (ticket.time.end) {
+        console.log(chalk.gray("Vencimiento: ") + chalk.red(ticket.time.end));
+    }
+    console.log(chalk.dim("─".repeat(40)));
+    console.log(chalk.bold("Descripción:"));
+    console.log(chalk.white(ticket.description));
+    if (ticket.customFields && ticket.customFields.length > 0) {
+        console.log(chalk.dim("─".repeat(40)));
+        console.log(chalk.bold("Custom Fields:"));
+        ticket.customFields.forEach((field) => {
+            const value = field.value && String(field.value).length > 0 ? String(field.value) : chalk.dim("(vacío)");
+            console.log(chalk.gray(`  ${field.name}: `) + chalk.white(value));
+        });
+    }
+    console.log(chalk.bold.cyan("━━━━━━━━━━━━━━━━━━━━\n"));
+}
 export const Redmine = {
     getIssueDetails,
     updateIssueComment,
+    updateIssueCustomFields,
     getCurrentUser,
     checkRedmineConnection,
+    printTicketDetails,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dami_deleon/rikudo",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "El Sabio de los Commits: AI Assistant con integración a Redmine",
   "main": "dist/index.js",
   "type": "module",