@k-system/tickr-mcp 1.20.0 → 1.22.0

package/dist/api-client.d.ts

@@ -24,6 +24,10 @@ export declare class ApiClient {
     patch<T = unknown>(path: string, body?: unknown): Promise<T>;
     put<T = unknown>(path: string, body?: unknown): Promise<T>;
     delete<T = unknown>(path: string): Promise<T>;
+    /** Health check — vrací true pokud API odpovídá */
+    healthCheck(): Promise<boolean>;
     private request;
+    private shouldRetry;
+    private getRetryDelay;
 }
 //# sourceMappingURL=api-client.d.ts.map

package/dist/api-client.js

@@ -1,4 +1,7 @@
 import { getAuthHeader } from "./auth.js";
+const REQUEST_TIMEOUT_MS = 30_000;
+const MAX_RETRIES = 3;
+const RETRY_BASE_MS = 200;
 /** Fetch wrapper pro Tickr REST API s automatickou autentizací */
 export class ApiClient {
     config;
@@ -20,6 +23,20 @@ export class ApiClient {
     async delete(path) {
         return this.request("DELETE", path);
     }
+    /** Health check — vrací true pokud API odpovídá */
+    async healthCheck() {
+        try {
+            const url = `${this.config.apiUrl}/health`;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5_000);
+            const res = await fetch(url, { signal: controller.signal });
+            clearTimeout(timeout);
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
     async request(method, path, body, retryCount = 0) {
         const auth = await getAuthHeader(this.config);
         const url = `${this.config.apiUrl}${path}`;
@@ -30,14 +47,38 @@ export class ApiClient {
         if (body !== undefined) {
             headers["Content-Type"] = "application/json";
         }
-        const res = await fetch(url, {
-            method,
-            headers,
-            body: body !== undefined ? JSON.stringify(body) : undefined,
-        });
-        // Auto-retry na 409 Conflict (optimistic locking) — max 3 pokusy
-        if (res.status === 409 && retryCount < 3) {
-            await new Promise((r) => setTimeout(r, 200 * (retryCount + 1)));
+        // Fetch s timeout přes AbortController
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let res;
+        try {
+            res = await fetch(url, {
+                method,
+                headers,
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            clearTimeout(timeout);
+            if (err instanceof Error && err.name === "AbortError") {
+                throw new Error(`Request timeout after ${REQUEST_TIMEOUT_MS / 1000}s: ${method} ${path}`);
+            }
+            // Síťová chyba — retry pokud máme pokusy
+            if (retryCount < MAX_RETRIES) {
+                const delay = RETRY_BASE_MS * Math.pow(2, retryCount);
+                await new Promise((r) => setTimeout(r, delay));
+                return this.request(method, path, body, retryCount + 1);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        // Auto-retry na 409 Conflict, 429 Too Many Requests, 5xx — max 3 pokusy
+        if (this.shouldRetry(res.status) && retryCount < MAX_RETRIES) {
+            const delay = this.getRetryDelay(res, retryCount);
+            await new Promise((r) => setTimeout(r, delay));
             return this.request(method, path, body, retryCount + 1);
         }
         if (!res.ok) {
@@ -66,5 +107,19 @@ export class ApiClient {
         }
         return json.data;
     }
+    shouldRetry(status) {
+        return status === 409 || status === 429 || status >= 500;
+    }
+    getRetryDelay(res, retryCount) {
+        // Respektovat Retry-After header pokud existuje (429)
+        const retryAfter = res.headers.get("Retry-After");
+        if (retryAfter) {
+            const seconds = parseInt(retryAfter, 10);
+            if (!isNaN(seconds))
+                return seconds * 1000;
+        }
+        // Exponential backoff: 200ms, 400ms, 800ms
+        return RETRY_BASE_MS * Math.pow(2, retryCount);
+    }
 }
 //# sourceMappingURL=api-client.js.map

package/dist/config.js

@@ -8,26 +8,44 @@ export function loadConfig() {
     const defaultProject = process.env.TICKR_DEFAULT_PROJECT;
     // Env vars mají prioritu
     if (apiUrl && apiKey) {
-        return { apiUrl, apiKey, defaultProject };
+        const config = { apiUrl, apiKey, defaultProject };
+        validateConfig(config);
+        return config;
     }
     // Fallback na config soubor
     const configPath = join(homedir(), ".tickr", "config.json");
     try {
         const raw = readFileSync(configPath, "utf-8");
         const file = JSON.parse(raw);
-        return {
+        const config = {
             apiUrl: apiUrl || file.apiUrl || "https://localhost:6001",
             apiKey: apiKey || file.apiKey || "",
             defaultProject: defaultProject || file.defaultProject,
         };
+        validateConfig(config);
+        return config;
     }
     catch {
         // Config soubor neexistuje — použijeme defaults
-        return {
+        const config = {
             apiUrl: apiUrl || "https://localhost:6001",
             apiKey: apiKey || "",
             defaultProject,
         };
+        validateConfig(config);
+        return config;
+    }
+}
+/** Validace konfigurace — loguje varování pro problematické hodnoty */
+function validateConfig(config) {
+    if (!config.apiKey) {
+        console.error("[tickr-mcp] WARNING: No API key configured — tools will fail with 401");
+    }
+    if (config.apiUrl && !config.apiUrl.startsWith("http://") && !config.apiUrl.startsWith("https://")) {
+        console.error(`[tickr-mcp] WARNING: apiUrl "${config.apiUrl}" doesn't start with http(s)://`);
+    }
+    if (config.apiUrl?.endsWith("/")) {
+        config.apiUrl = config.apiUrl.replace(/\/+$/, "");
     }
 }
 //# sourceMappingURL=config.js.map

package/dist/resources/pending-tasks-resource.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../api-client.js";
+/**
+ * Dynamic resource tickr://pending-tasks
+ * Vrací aktuální stav dev queue — počet čekajících tasků a detail dalšího v řadě.
+ * Aktualizuje se přes sendResourceListChanged() při DevTaskQueued eventu.
+ */
+export declare function registerPendingTasksResource(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=pending-tasks-resource.d.ts.map

package/dist/resources/pending-tasks-resource.js

@@ -0,0 +1,34 @@
+/**
+ * Dynamic resource tickr://pending-tasks
+ * Vrací aktuální stav dev queue — počet čekajících tasků a detail dalšího v řadě.
+ * Aktualizuje se přes sendResourceListChanged() při DevTaskQueued eventu.
+ */
+export function registerPendingTasksResource(server, api) {
+    server.resource("pending-tasks", "tickr://pending-tasks", { description: "Current dev queue status — queued task count and next task preview" }, async (uri) => {
+        // Heartbeat vrací počet queued tasků bez side-effectu na assignment
+        const heartbeat = await api
+            .post("/api/dev-queue/heartbeat", {})
+            .catch(() => null);
+        const queuedTasks = heartbeat?.queuedTasks ?? 0;
+        const agentStatus = heartbeat?.agentStatus ?? "unknown";
+        let text = `## Dev Queue Status\n`;
+        text += `- **Agent Status:** ${agentStatus}\n`;
+        text += `- **Queued Tasks:** ${queuedTasks}\n`;
+        if (queuedTasks > 0) {
+            text += `\n⚠️ There are ${queuedTasks} task(s) waiting. Run \`poll_dev_queue\` to pick up the next one.\n`;
+        }
+        else {
+            text += `\n✅ Queue is empty — no pending tasks.\n`;
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "text/markdown",
+                    text,
+                },
+            ],
+        };
+    });
+}
+//# sourceMappingURL=pending-tasks-resource.js.map

package/dist/server.js

@@ -72,6 +72,9 @@ import { registerUpdateCycle } from "./tools/update-cycle.js";
 import { registerDeleteCycle } from "./tools/delete-cycle.js";
 import { registerUpdateEpic } from "./tools/update-epic.js";
 import { registerDeleteEpic } from "./tools/delete-epic.js";
+// ADR-0050: Epic Dependencies
+import { registerAddEpicDependency } from "./tools/add-epic-dependency.js";
+import { registerRemoveEpicDependency } from "./tools/remove-epic-dependency.js";
 // ADR-0026 Phase 2f: Project Members
 import { registerListProjectMembers } from "./tools/list-project-members.js";
 import { registerAddProjectMember } from "./tools/add-project-member.js";
@@ -90,14 +93,23 @@ import { registerLinkCommit } from "./tools/link-commit.js";
 // Resources
 import { registerTicketResource } from "./resources/ticket-resource.js";
 import { registerProjectResource } from "./resources/project-resource.js";
+import { registerPendingTasksResource } from "./resources/pending-tasks-resource.js";
 // SignalR push notifications
 import { initSignalRClient, stopSignalRClient } from "./signalr-client.js";
 export async function startServer() {
     const config = loadConfig();
     const api = new ApiClient(config);
+    // Startup health check — ověření dostupnosti API
+    const healthy = await api.healthCheck();
+    if (healthy) {
+        console.error(`[tickr-mcp] API reachable at ${config.apiUrl}`);
+    }
+    else {
+        console.error(`[tickr-mcp] WARNING: API unreachable at ${config.apiUrl} — tools may fail`);
+    }
     const server = new McpServer({
         name: "tickr",
-        version: "0.1.8",
+        version: "1.22.0",
     });
     // Debug logging wrapper (dedup odstraněn — nefunkční cross-process, řeší se na API straně: TKR-ADR-0043)
     {
@@ -194,6 +206,9 @@ export async function startServer() {
     registerDeleteCycle(server, api);
     registerUpdateEpic(server, api);
     registerDeleteEpic(server, api);
+    // ADR-0050: Epic Dependencies
+    registerAddEpicDependency(server, api);
+    registerRemoveEpicDependency(server, api);
     // ADR-0026 Phase 2f: Project Members
     registerListProjectMembers(server, api);
     registerAddProjectMember(server, api);
@@ -212,14 +227,26 @@ export async function startServer() {
     // Registrace resources
     registerTicketResource(server, api);
     registerProjectResource(server, api);
+    registerPendingTasksResource(server, api);
     // Spuštění na stdio transportu
     const transport = new StdioServerTransport();
     await server.connect(transport);
     // SignalR push notifications — pripojeni na BoardHub pro real-time eventy
     // Neni kriticke — MCP server funguje i bez SignalR
     initSignalRClient(config, server, config.defaultProject).catch(() => { });
+    // Initial heartbeat — nastav agenta jako idle
+    api.post("/api/dev-queue/heartbeat", {}).catch((err) => {
+        console.error("[tickr-mcp] initial heartbeat failed:", err instanceof Error ? err.message : String(err));
+    });
+    // Periodicky heartbeat kazdych 60 sekund — udržuje agent status + snižuje latenci task discovery
+    const heartbeatInterval = setInterval(() => {
+        api.post("/api/dev-queue/heartbeat", {}).catch((err) => {
+            console.error("[tickr-mcp] heartbeat failed:", err instanceof Error ? err.message : String(err));
+        });
+    }, 60_000);
     // Cleanup pri ukonceni procesu
     const cleanup = async () => {
+        clearInterval(heartbeatInterval);
         await stopSignalRClient();
         process.exit(0);
     };

package/dist/signalr-client.js

@@ -19,8 +19,13 @@ export async function initSignalRClient(config, server, projectSlug) {
         .withAutomaticReconnect([0, 2000, 5000, 10000, 30000])
         .configureLogging(LogLevel.None)
         .build();
-    // Event handlery — notifikace do MCP session
+    // Event handlery — resource update + logging notifikace do MCP session
     connection.on("DevTaskQueued", () => {
+        // Aktualizuj tickr://pending-tasks resource — agent uvidí změnu při dalším tool callu
+        try {
+            server.sendResourceListChanged();
+        }
+        catch { }
         server
             .sendLoggingMessage({
             level: "notice",
@@ -30,6 +35,10 @@ export async function initSignalRClient(config, server, projectSlug) {
             .catch(() => { });
     });
     connection.on("DevTaskCompleted", () => {
+        try {
+            server.sendResourceListChanged();
+        }
+        catch { }
         server
             .sendLoggingMessage({
             level: "info",
@@ -39,6 +48,10 @@ export async function initSignalRClient(config, server, projectSlug) {
             .catch(() => { });
     });
     connection.on("TicketUpdated", () => {
+        try {
+            server.sendResourceListChanged();
+        }
+        catch { }
         server
             .sendLoggingMessage({
             level: "debug",
@@ -48,6 +61,10 @@ export async function initSignalRClient(config, server, projectSlug) {
             .catch(() => { });
     });
     connection.on("TicketCreated", () => {
+        try {
+            server.sendResourceListChanged();
+        }
+        catch { }
         server
             .sendLoggingMessage({
             level: "debug",

package/dist/tools/add-epic-dependency.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 registerAddEpicDependency(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=add-epic-dependency.d.ts.map

package/dist/tools/add-epic-dependency.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export function registerAddEpicDependency(server, api) {
+    server.tool("add_epic_dependency", "Add a dependency between two epics (predecessor blocks successor)", {
+        project: z.string().describe("Project slug"),
+        predecessor_epic_id: z.string().describe("UUID of the predecessor epic (must finish first)"),
+        successor_epic_id: z.string().describe("UUID of the successor epic (depends on predecessor)"),
+        type: z.string().optional().describe("Dependency type: finish-to-start (default), start-to-start, finish-to-finish, start-to-finish"),
+    }, async (params) => {
+        try {
+            const result = await api.post(`/api/projects/${params.project}/epics/${params.predecessor_epic_id}/dependencies`, { successorEpicId: params.successor_epic_id, dependencyType: params.type });
+            return {
+                content: [{ type: "text", text: `Dependency created (${params.type ?? "finish-to-start"}): ${params.predecessor_epic_id} → ${params.successor_epic_id}` }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=add-epic-dependency.js.map

package/dist/tools/list-epics.js

@@ -6,7 +6,7 @@ export function registerListEpics(server, api) {
         try {
             const epics = await api.get(`/api/projects/${params.project}/epics`);
             const text = epics
-                .map((e) => `${e.name} (${e.id}) [${e.status}] (${e.completedTickets}/${e.totalTickets})${e.targetDate ? ` target: ${e.targetDate}` : ""}`)
+                .map((e) => `${e.name} (${e.id}) [${e.status}] (${e.completedTicketCount}/${e.ticketCount})${e.targetDate ? ` target: ${e.targetDate}` : ""}`)
                 .join("\n");
             return {
                 content: [{ type: "text", text: text || "No epics found." }],

package/dist/tools/remove-epic-dependency.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 registerRemoveEpicDependency(server: McpServer, api: ApiClient): void;
+//# sourceMappingURL=remove-epic-dependency.d.ts.map

package/dist/tools/remove-epic-dependency.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export function registerRemoveEpicDependency(server, api) {
+    server.tool("remove_epic_dependency", "Remove a dependency between two epics", {
+        project: z.string().describe("Project slug"),
+        epic_id: z.string().describe("UUID of either epic in the dependency"),
+        dependency_id: z.string().describe("UUID of the dependency to remove"),
+    }, async (params) => {
+        try {
+            await api.delete(`/api/projects/${params.project}/epics/${params.epic_id}/dependencies/${params.dependency_id}`);
+            return {
+                content: [{ type: "text", text: `Dependency ${params.dependency_id} removed` }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=remove-epic-dependency.js.map

package/dist/types.d.ts

@@ -93,8 +93,8 @@ export interface Epic {
     color: string;
     status: string;
     targetDate: string | null;
-    totalTickets: number;
-    completedTickets: number;
+    ticketCount: number;
+    completedTicketCount: number;
     createdAt: string;
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-system/tickr-mcp",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "description": "MCP server for Tickr project management — 56 tools + setup CLI wizard",
   "type": "module",
   "main": "./dist/index.js",