@k-system/tickr-mcp 0.1.0

package/dist/tools/complete-dev-task.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export function registerCompleteDevTask(server, api) {
+    server.tool("complete_dev_task", "Mark a dev agent task as completed with summary, branch name, and commit hash", {
+        assignment_id: z.string().describe("UUID of the dev agent assignment"),
+        summary: z.string().describe("Summary of what was done"),
+        branch: z.string().optional().describe("Git branch name"),
+        commit_hash: z.string().optional().describe("Last commit SHA"),
+    }, async (params) => {
+        try {
+            await api.post(`/api/dev-queue/complete/${params.assignment_id}`, {
+                resultSummary: params.summary,
+                branchName: params.branch ?? null,
+                commitHash: params.commit_hash ?? null,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Task ${params.assignment_id} marked as completed.`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=complete-dev-task.js.map

package/dist/tools/create-ticket.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerCreateTicket(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=create-ticket.d.ts.map

package/dist/tools/create-ticket.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export function registerCreateTicket(server, api) {
+    server.tool("create_ticket", "Create a new ticket in a project", {
+        project: z.string().describe("Project slug, e.g. 'veliox'"),
+        type: z.enum(["task", "bug", "feature", "adr"]),
+        title: z.string(),
+        scope: z.string().optional().describe("Scope tag, e.g. 'api', 'frontend'"),
+        priority: z.enum(["P0", "P1", "P2", "P3"]).default("P2"),
+        content: z.string().optional().describe("Markdown content (analysis, solution)"),
+        affected_parts: z.array(z.string()).optional(),
+    }, async (params) => {
+        try {
+            const ticket = await api.post(`/api/projects/${params.project}/tickets`, {
+                type: params.type,
+                title: params.title,
+                scope: params.scope,
+                priority: params.priority,
+                content: params.content,
+                affectedParts: params.affected_parts,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Created ${ticket.displayNumber}: ${ticket.title}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=create-ticket.js.map

package/dist/tools/get-ticket.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerGetTicket(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=get-ticket.d.ts.map

package/dist/tools/get-ticket.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { formatTicketMarkdown } from "../formatters.js";
+export function registerGetTicket(server, api) {
+    server.tool("get_ticket", "Get full ticket detail by display number", {
+        number: z.string().describe("Ticket display number, e.g. 'TKR-42' (legacy) or 'TKR-BUG-0042' (typed)"),
+    }, async (params) => {
+        try {
+            const ticket = await api.get(`/api/tickets/${params.number}`);
+            const md = formatTicketMarkdown(ticket);
+            return { content: [{ type: "text", text: md }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=get-ticket.js.map

package/dist/tools/list-cycles.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerListCycles(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=list-cycles.d.ts.map

package/dist/tools/list-cycles.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export function registerListCycles(server, api) {
+    server.tool("list_cycles", "List cycles (sprints) for a project", {
+        project: z.string().describe("Project slug"),
+    }, async (params) => {
+        try {
+            const cycles = await api.get(`/api/projects/${params.project}/cycles`);
+            const text = cycles
+                .map((c) => `#${c.number}${c.name ? ` ${c.name}` : ""} [${c.status}] ${c.startDate}–${c.endDate} (${c.completedTickets}/${c.totalTickets})`)
+                .join("\n");
+            return {
+                content: [{ type: "text", text: text || "No cycles found." }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=list-cycles.js.map

package/dist/tools/list-epics.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerListEpics(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=list-epics.d.ts.map

package/dist/tools/list-epics.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export function registerListEpics(server, api) {
+    server.tool("list_epics", "List epics for a project", {
+        project: z.string().describe("Project slug"),
+    }, async (params) => {
+        try {
+            const epics = await api.get(`/api/projects/${params.project}/epics`);
+            const text = epics
+                .map((e) => `${e.name} [${e.status}] (${e.completedTickets}/${e.totalTickets})${e.targetDate ? ` target: ${e.targetDate}` : ""}`)
+                .join("\n");
+            return {
+                content: [{ type: "text", text: text || "No epics found." }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=list-epics.js.map

package/dist/tools/list-labels.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerListLabels(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=list-labels.d.ts.map

package/dist/tools/list-labels.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export function registerListLabels(server, api) {
+    server.tool("list_labels", "List labels for a project", {
+        project: z.string().describe("Project slug"),
+    }, async (params) => {
+        try {
+            const labels = await api.get(`/api/projects/${params.project}/labels`);
+            const text = labels
+                .map((l) => `${l.name} (${l.color})`)
+                .join("\n");
+            return {
+                content: [{ type: "text", text: text || "No labels configured." }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=list-labels.js.map

package/dist/tools/list-tickets.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerListTickets(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=list-tickets.d.ts.map

package/dist/tools/list-tickets.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export function registerListTickets(server, api) {
+    server.tool("list_tickets", "List tickets with optional filters", {
+        project: z.string().describe("Project slug"),
+        status: z.string().optional().describe("Status slug: planning, in-progress, done..."),
+        type: z.string().optional(),
+        assignee: z.string().optional().describe("Username"),
+        scope: z.string().optional(),
+        limit: z.number().default(20),
+    }, async (params) => {
+        try {
+            const qs = new URLSearchParams();
+            if (params.status)
+                qs.set("status", params.status);
+            if (params.type)
+                qs.set("type", params.type);
+            if (params.assignee)
+                qs.set("assignee", params.assignee);
+            if (params.scope)
+                qs.set("scope", params.scope);
+            qs.set("limit", String(params.limit));
+            const path = `/api/projects/${params.project}/tickets?${qs}`;
+            const tickets = await api.get(path);
+            const text = tickets
+                .map((t) => `${t.displayNumber} [${t.status}] ${t.title} (${t.priority}, ${t.scope || "-"})`)
+                .join("\n");
+            return {
+                content: [{ type: "text", text: text || "No tickets found." }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=list-tickets.js.map

package/dist/tools/poll-dev-queue.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerPollDevQueue(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=poll-dev-queue.d.ts.map

package/dist/tools/poll-dev-queue.js

@@ -0,0 +1,37 @@
+export function registerPollDevQueue(server, api) {
+    server.tool("poll_dev_queue", "Poll for next dev task in the agent queue. Returns ticket details and assigned skills/instructions.", {}, async () => {
+        try {
+            const result = await api.get("/api/dev-queue/poll");
+            if (!result) {
+                return {
+                    content: [{ type: "text", text: "No tasks in queue." }],
+                };
+            }
+            const { assignmentId, ticket, skills } = result;
+            let text = `## New task: ${ticket.displayNumber} — ${ticket.title}\n` +
+                `**Assignment ID:** ${assignmentId}\n` +
+                `**Type:** ${ticket.type} | **Priority:** ${ticket.priority} | **Scope:** ${ticket.scope || "any"}\n` +
+                `**Project:** ${ticket.projectSlug}\n\n` +
+                `### Description\n${ticket.description || "(no description)"}\n`;
+            if (skills.length > 0) {
+                text += `\n---\n### Instructions\n`;
+                for (const skill of skills) {
+                    text += `\n#### ${skill.name}\n${skill.instructions}\n`;
+                }
+            }
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=poll-dev-queue.js.map

package/dist/tools/remove-label.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerRemoveLabel(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=remove-label.d.ts.map

package/dist/tools/remove-label.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export function registerRemoveLabel(server, api) {
+    server.tool("remove_label", "Remove a label from a ticket", {
+        number: z.string().describe("Ticket display number, e.g. 'TKR-42' (legacy) or 'TKR-BUG-0042' (typed)"),
+        label_id: z.string().describe("UUID of the label to remove"),
+    }, async (params) => {
+        try {
+            await api.delete(`/api/tickets/${params.number}/labels/${params.label_id}`);
+            return {
+                content: [{ type: "text", text: `Label removed from ${params.number}` }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=remove-label.js.map

package/dist/tools/search-tickets.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerSearchTickets(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=search-tickets.d.ts.map

package/dist/tools/search-tickets.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export function registerSearchTickets(server, api) {
+    server.tool("search_tickets", "Fulltext search in ticket titles and content", {
+        query: z.string().describe("Fulltext search query"),
+        project: z.string().optional().describe("Limit to project slug"),
+    }, async (params) => {
+        try {
+            const q = encodeURIComponent(params.query);
+            let path = `/api/search?q=${q}`;
+            if (params.project)
+                path += `&project=${encodeURIComponent(params.project)}`;
+            const results = await api.get(path);
+            const text = results
+                .map((t) => `${t.displayNumber} [${t.status}] ${t.title} (${t.priority})`)
+                .join("\n");
+            return {
+                content: [
+                    { type: "text", text: text || "No results found." },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=search-tickets.js.map

package/dist/tools/triage-accept.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerTriageAccept(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=triage-accept.d.ts.map

package/dist/tools/triage-accept.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export function registerTriageAccept(server, api) {
+    server.tool("triage_accept", "Accept tickets from triage inbox — move them to a target status", {
+        project: z.string().describe("Project slug"),
+        ticket_ids: z.array(z.string()).describe("Array of ticket UUIDs to accept"),
+        target_status_id: z.string().describe("UUID of target status to move tickets to"),
+        assignee_id: z.string().optional().describe("UUID of assignee"),
+    }, async (params) => {
+        try {
+            const result = await api.post(`/api/projects/${params.project}/triage/accept`, {
+                ticketIds: params.ticket_ids,
+                targetStatusId: params.target_status_id,
+                assigneeId: params.assignee_id ?? null,
+            });
+            let text = `Accepted ${result.processed} ticket(s)`;
+            if (result.failed > 0)
+                text += `, ${result.failed} failed: ${result.errors.join("; ")}`;
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=triage-accept.js.map

package/dist/tools/triage-list.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerTriageList(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=triage-list.d.ts.map

package/dist/tools/triage-list.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export function registerTriageList(server, api) {
+    server.tool("triage_list", "List tickets in triage inbox for a project", {
+        project: z.string().describe("Project slug"),
+    }, async (params) => {
+        try {
+            const tickets = await api.get(`/api/projects/${params.project}/triage`);
+            const text = tickets
+                .map((t) => `${t.displayNumber} [${t.priority}] ${t.title} (${t.scope || "-"})`)
+                .join("\n");
+            return {
+                content: [{ type: "text", text: text || "No tickets in triage." }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=triage-list.js.map

package/dist/tools/triage-reject.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerTriageReject(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=triage-reject.d.ts.map

package/dist/tools/triage-reject.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export function registerTriageReject(server, api) {
+    server.tool("triage_reject", "Reject tickets from triage inbox — move them to cancelled", {
+        project: z.string().describe("Project slug"),
+        ticket_ids: z.array(z.string()).describe("Array of ticket UUIDs to reject"),
+        reason: z.string().optional().describe("Rejection reason (added as comment)"),
+    }, async (params) => {
+        try {
+            const result = await api.post(`/api/projects/${params.project}/triage/reject`, {
+                ticketIds: params.ticket_ids,
+                reason: params.reason ?? null,
+            });
+            let text = `Rejected ${result.processed} ticket(s)`;
+            if (result.failed > 0)
+                text += `, ${result.failed} failed: ${result.errors.join("; ")}`;
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=triage-reject.js.map

package/dist/tools/update-implementation-item.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerUpdateImplementationItem(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=update-implementation-item.d.ts.map

package/dist/tools/update-implementation-item.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export function registerUpdateImplementationItem(server, api) {
+    server.tool("update_implementation_item", "Update an implementation item on a ticket", {
+        number: z.string().describe("Ticket display number, e.g. 'TKR-42' (legacy) or 'TKR-BUG-0042' (typed)"),
+        item_index: z.number().describe("0-based index in implementation table"),
+        status: z
+            .enum(["todo", "in-progress", "done", "skipped"])
+            .optional(),
+        note: z.string().optional(),
+    }, async (params) => {
+        try {
+            await api.patch(`/api/tickets/${params.number}/items/${params.item_index}`, {
+                status: params.status,
+                note: params.note,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Item #${params.item_index} updated on ${params.number}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=update-implementation-item.js.map

package/dist/tools/update-ticket.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+export declare function registerUpdateTicket(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=update-ticket.d.ts.map

package/dist/tools/update-ticket.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export function registerUpdateTicket(server, api) {
+    server.tool("update_ticket", "Update ticket fields (status, title, content, priority, assignee, scope)", {
+        number: z.string().describe("Ticket display number, e.g. 'TKR-42' (legacy) or 'TKR-BUG-0042' (typed)"),
+        status: z.string().optional().describe("New status slug"),
+        title: z.string().optional(),
+        content: z.string().optional(),
+        priority: z.string().optional(),
+        assignee: z.string().optional().describe("Username or 'unassigned'"),
+        scope: z.string().optional(),
+    }, async (params) => {
+        try {
+            const { number, ...updates } = params;
+            const ticket = await api.put(`/api/tickets/${number}`, updates);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Updated ${ticket.displayNumber}: status=${ticket.status}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=update-ticket.js.map

package/dist/types.d.ts

@@ -0,0 +1,88 @@
+/** Sdílené typy pro MCP server */
+export interface Ticket {
+    id: string;
+    projectId: string;
+    number: number;
+    displayNumber: string;
+    type: string;
+    title: string;
+    scope: string | null;
+    status: string;
+    priority: string;
+    estimate: string | null;
+    assigneeId: string | null;
+    assigneeName: string | null;
+    content: string | null;
+    affectedParts: string[];
+    implementationItems: ImplementationItem[];
+    comments: Comment[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ImplementationItem {
+    id: string;
+    area: string;
+    fileOrDetail: string;
+    status: string;
+    note: string | null;
+    sortOrder: number;
+}
+export interface Comment {
+    id: string;
+    text: string;
+    authorName: string;
+    createdAt: string;
+}
+export interface Project {
+    id: string;
+    name: string;
+    slug: string;
+    prefix: string;
+    description: string | null;
+    scopeTags: string[];
+    ticketTypes: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TicketListItem {
+    displayNumber: string;
+    title: string;
+    scope: string | null;
+    status: string;
+    priority: string;
+    assigneeName: string | null;
+}
+export interface TriageResult {
+    processed: number;
+    failed: number;
+    errors: string[];
+}
+export interface Label {
+    id: string;
+    name: string;
+    color: string;
+    sortOrder: number;
+}
+export interface Cycle {
+    id: string;
+    number: number;
+    name: string | null;
+    startDate: string;
+    endDate: string;
+    status: string;
+    totalTickets: number;
+    completedTickets: number;
+    createdAt: string;
+}
+export interface Epic {
+    id: string;
+    name: string;
+    description: string | null;
+    color: string;
+    status: string;
+    targetDate: string | null;
+    totalTickets: number;
+    completedTickets: number;
+    createdAt: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,3 @@
+/** Sdílené typy pro MCP server */
+export {};
+//# sourceMappingURL=types.js.map