@k-system/tickr-mcp 1.21.0 → 1.23.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/auth.d.ts

@@ -10,9 +10,16 @@ export declare function login(config: TickrConfig, username: string, password: s
 export declare function refreshToken(config: TickrConfig): Promise<TokenPair>;
 /**
  * Vrátí Authorization header value.
- * Pokud config má apiKey (tk_...), použije ho přímo.
- * Jinak použije JWT token (auto-refresh pokud expiruje).
+ * Priorita:
+ * 1. API key (tkr_...) — přímé použití, žádná expiry
+ * 2. Device Grant session (~/.tickr/sessions/) — auto-refresh
+ * 3. JWT token (login/password) — auto-refresh
  */
 export declare function getAuthHeader(config: TickrConfig): Promise<string>;
+/**
+ * Inicializace device grant session při startu serveru.
+ * Načte existující session z disku — pokud existuje a je platná, nastaví cache.
+ */
+export declare function initDeviceGrantSession(config: TickrConfig): void;
 export {};
 //# sourceMappingURL=auth.d.ts.map

package/dist/auth.js

@@ -1,4 +1,7 @@
+import { getDeviceGrantToken, loadSession, refreshAccessToken, saveSession, } from "./device-grant.js";
 let currentTokens = null;
+// Aktuální device grant session (pokud je aktivní)
+let activeSession = null;
 /** Přihlášení přes username/password — vrátí JWT token pair */
 export async function login(config, username, password) {
     const res = await fetch(`${config.apiUrl}/api/auth/login`, {
@@ -40,21 +43,74 @@ export async function refreshToken(config) {
 }
 /**
  * Vrátí Authorization header value.
- * Pokud config má apiKey (tk_...), použije ho přímo.
- * Jinak použije JWT token (auto-refresh pokud expiruje).
+ * Priorita:
+ * 1. API key (tkr_...) — přímé použití, žádná expiry
+ * 2. Device Grant session (~/.tickr/sessions/) — auto-refresh
+ * 3. JWT token (login/password) — auto-refresh
  */
 export async function getAuthHeader(config) {
-    // API key auth — jednoduché, bez expiry
+    // 1. API key auth — jednoduché, bez expiry
     if (config.apiKey) {
         return `Bearer ${config.apiKey}`;
     }
-    // JWT auth — refresh pokud token brzy vyprší (30s buffer)
+    // 2. Device Grant session — auto-refresh
+    if (config.tenantId && config.agentName) {
+        return `Bearer ${await getDeviceGrantAuthToken(config)}`;
+    }
+    // 3. JWT auth — refresh pokud token brzy vyprší (30s buffer)
     if (currentTokens && currentTokens.expiresAt - Date.now() < 30_000) {
         await refreshToken(config);
     }
     if (!currentTokens) {
-        throw new Error("Not authenticated — set TICKR_API_KEY or call login()");
+        throw new Error("Not authenticated — set TICKR_API_KEY or configure device grant");
     }
     return `Bearer ${currentTokens.accessToken}`;
 }
+/**
+ * Device Grant auth token s auto-refresh a auto-pairing.
+ * Pokud session neexistuje, spustí interaktivní pairing flow.
+ */
+async function getDeviceGrantAuthToken(config) {
+    // Zkus cache
+    if (activeSession && activeSession.expiresAt - Date.now() > 30_000) {
+        return activeSession.accessToken;
+    }
+    // Zkus refresh existující session
+    if (activeSession && activeSession.refreshToken) {
+        try {
+            const result = await refreshAccessToken(config, activeSession.refreshToken);
+            activeSession = {
+                accessToken: result.access_token,
+                refreshToken: result.refresh_token,
+                expiresAt: Date.now() + result.expires_in * 1000,
+                agentIdentity: result.agent_identity,
+                apiUrl: config.apiUrl,
+                tenantId: config.tenantId,
+            };
+            saveSession(config.agentName, activeSession);
+            return activeSession.accessToken;
+        }
+        catch {
+            activeSession = null;
+        }
+    }
+    // Načti z disku nebo spusť pairing
+    const token = await getDeviceGrantToken(config, config.agentName, config.tenantId);
+    // Aktualizuj cache
+    activeSession = loadSession(config.agentName);
+    return token;
+}
+/**
+ * Inicializace device grant session při startu serveru.
+ * Načte existující session z disku — pokud existuje a je platná, nastaví cache.
+ */
+export function initDeviceGrantSession(config) {
+    if (!config.agentName || !config.tenantId)
+        return;
+    const session = loadSession(config.agentName);
+    if (session) {
+        activeSession = session;
+        console.error(`[tickr] ✓ Connected as ${session.agentIdentity}`);
+    }
+}
 //# sourceMappingURL=auth.js.map

package/dist/config.d.ts

@@ -2,6 +2,10 @@ export interface TickrConfig {
     apiUrl: string;
     apiKey?: string;
     defaultProject?: string;
+    /** Tenant ID pro device grant auth (UUID) */
+    tenantId?: string;
+    /** Jméno agenta pro device grant session storage */
+    agentName?: string;
 }
 /** Načte konfiguraci z env vars nebo ~/.tickr/config.json */
 export declare function loadConfig(): TickrConfig;

package/dist/config.js

@@ -6,28 +6,52 @@ export function loadConfig() {
     const apiUrl = process.env.TICKR_API_URL;
     const apiKey = process.env.TICKR_API_KEY;
     const defaultProject = process.env.TICKR_DEFAULT_PROJECT;
+    const tenantId = process.env.TICKR_TENANT_ID;
+    const agentName = process.env.TICKR_AGENT_NAME;
     // Env vars mají prioritu
     if (apiUrl && apiKey) {
-        return { apiUrl, apiKey, defaultProject };
+        const config = { apiUrl, apiKey, defaultProject, tenantId, agentName };
+        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,
+            tenantId: tenantId || file.tenantId,
+            agentName: agentName || file.agentName,
         };
+        validateConfig(config);
+        return config;
     }
     catch {
         // Config soubor neexistuje — použijeme defaults
-        return {
+        const config = {
             apiUrl: apiUrl || "https://localhost:6001",
             apiKey: apiKey || "",
             defaultProject,
+            tenantId,
+            agentName,
         };
+        validateConfig(config);
+        return config;
+    }
+}
+/** Validace konfigurace — loguje varování pro problematické hodnoty */
+function validateConfig(config) {
+    if (!config.apiKey && !config.tenantId) {
+        console.error("[tickr-mcp] WARNING: No API key or tenant ID configured — set TICKR_API_KEY or TICKR_TENANT_ID + TICKR_AGENT_NAME for device grant");
+    }
+    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/device-grant.d.ts

@@ -0,0 +1,53 @@
+import type { TickrConfig } from "./config.js";
+interface DeviceCodeResponse {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    interval: number;
+    expires_in: number;
+}
+interface TokenResponse {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_token: string;
+    agent_identity: string;
+}
+export interface StoredSession {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    agentIdentity: string;
+    apiUrl: string;
+    tenantId: string;
+}
+/** Načte uloženou session — vrátí null pokud neexistuje nebo je poškozená */
+export declare function loadSession(agentName: string): StoredSession | null;
+/** Uloží session na disk */
+export declare function saveSession(agentName: string, session: StoredSession): void;
+/** Smaže uloženou session */
+export declare function clearSession(agentName: string): void;
+/**
+ * Zahájí device authorization flow — vrátí device code a user code.
+ * Agent zobrazí user code v terminálu, člověk ho zadá v browseru.
+ */
+export declare function initiateDeviceGrant(config: TickrConfig, tenantId: string): Promise<DeviceCodeResponse>;
+/**
+ * Polluje /oauth/token dokud člověk neschválí párování.
+ * Vrátí access + refresh token, nebo vyhodí chybu při expiraci/zamítnutí.
+ */
+export declare function pollForDeviceGrant(config: TickrConfig, deviceCode: string, interval: number, expiresIn: number, onStatus?: (message: string) => void): Promise<TokenResponse>;
+/**
+ * Obnoví access token přes refresh token grant.
+ * Vrátí nový token pár (rotace — starý refresh token je zneplatněn).
+ */
+export declare function refreshAccessToken(config: TickrConfig, refreshToken: string): Promise<TokenResponse>;
+/**
+ * Hlavní entry point: získej platný access token.
+ * 1. Pokud existuje uložená session a token je platný → vrať
+ * 2. Pokud token expiruje → auto-refresh
+ * 3. Pokud refresh selže → spusť device grant flow
+ */
+export declare function getDeviceGrantToken(config: TickrConfig, agentName: string, tenantId: string, onPairingRequired?: (userCode: string, verificationUri: string) => void): Promise<string>;
+export {};
+//# sourceMappingURL=device-grant.d.ts.map

package/dist/device-grant.js

@@ -0,0 +1,194 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+// --- Session storage ---
+const SESSIONS_DIR = join(homedir(), ".tickr", "sessions");
+function ensureSessionsDir() {
+    if (!existsSync(SESSIONS_DIR)) {
+        mkdirSync(SESSIONS_DIR, { recursive: true });
+    }
+}
+function sessionPath(agentName) {
+    const safe = agentName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return join(SESSIONS_DIR, `${safe}.json`);
+}
+/** Načte uloženou session — vrátí null pokud neexistuje nebo je poškozená */
+export function loadSession(agentName) {
+    try {
+        const path = sessionPath(agentName);
+        if (!existsSync(path))
+            return null;
+        const raw = readFileSync(path, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** Uloží session na disk */
+export function saveSession(agentName, session) {
+    ensureSessionsDir();
+    const path = sessionPath(agentName);
+    writeFileSync(path, JSON.stringify(session, null, 2), { mode: 0o600 });
+}
+/** Smaže uloženou session */
+export function clearSession(agentName) {
+    try {
+        const path = sessionPath(agentName);
+        if (existsSync(path)) {
+            const { unlinkSync } = require("node:fs");
+            unlinkSync(path);
+        }
+    }
+    catch {
+        // Ignoruj
+    }
+}
+// --- Device Authorization Grant flow ---
+/**
+ * Zahájí device authorization flow — vrátí device code a user code.
+ * Agent zobrazí user code v terminálu, člověk ho zadá v browseru.
+ */
+export async function initiateDeviceGrant(config, tenantId) {
+    const res = await fetch(`${config.apiUrl}/oauth/device/authorize`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ clientId: "claude-agent", tenantId }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Device authorization failed: ${res.status} — ${body}`);
+    }
+    return (await res.json()).data;
+}
+/**
+ * Polluje /oauth/token dokud člověk neschválí párování.
+ * Vrátí access + refresh token, nebo vyhodí chybu při expiraci/zamítnutí.
+ */
+export async function pollForDeviceGrant(config, deviceCode, interval, expiresIn, onStatus) {
+    const deadline = Date.now() + expiresIn * 1000;
+    while (Date.now() < deadline) {
+        await sleep(interval * 1000);
+        try {
+            const res = await fetch(`${config.apiUrl}/oauth/token`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    grantType: "urn:ietf:params:oauth:grant-type:device_code",
+                    deviceCode,
+                }),
+            });
+            if (res.ok) {
+                return (await res.json());
+            }
+            const error = (await res.json());
+            if (error.error === "authorization_pending") {
+                onStatus?.("Waiting for approval...");
+                continue;
+            }
+            if (error.error === "slow_down") {
+                interval = Math.min(interval + 1, 15);
+                onStatus?.("Slowing down polling...");
+                continue;
+            }
+            if (error.error === "expired_token") {
+                throw new Error("Device code expired — please try pairing again");
+            }
+            if (error.error === "access_denied") {
+                throw new Error("Pairing denied by user");
+            }
+            throw new Error(`Token exchange error: ${error.error} — ${error.error_description}`);
+        }
+        catch (err) {
+            if (err instanceof Error && (err.message.includes("expired") || err.message.includes("denied"))) {
+                throw err;
+            }
+            // Síťová chyba — pokračuj v pollingu
+            onStatus?.("Connection error, retrying...");
+        }
+    }
+    throw new Error("Device code expired — please try pairing again");
+}
+/**
+ * Obnoví access token přes refresh token grant.
+ * Vrátí nový token pár (rotace — starý refresh token je zneplatněn).
+ */
+export async function refreshAccessToken(config, refreshToken) {
+    const res = await fetch(`${config.apiUrl}/oauth/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            grantType: "refresh_token",
+            refreshToken,
+        }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Token refresh failed: ${res.status} — ${body}`);
+    }
+    return (await res.json());
+}
+// --- Integrační funkce ---
+/**
+ * Hlavní entry point: získej platný access token.
+ * 1. Pokud existuje uložená session a token je platný → vrať
+ * 2. Pokud token expiruje → auto-refresh
+ * 3. Pokud refresh selže → spusť device grant flow
+ */
+export async function getDeviceGrantToken(config, agentName, tenantId, onPairingRequired) {
+    // Zkus načíst existující session
+    let session = loadSession(agentName);
+    if (session) {
+        // Token ještě platný (30s buffer)
+        if (session.expiresAt - Date.now() > 30_000) {
+            return session.accessToken;
+        }
+        // Zkus refresh
+        try {
+            const result = await refreshAccessToken(config, session.refreshToken);
+            session = {
+                accessToken: result.access_token,
+                refreshToken: result.refresh_token,
+                expiresAt: Date.now() + result.expires_in * 1000,
+                agentIdentity: result.agent_identity,
+                apiUrl: config.apiUrl,
+                tenantId,
+            };
+            saveSession(agentName, session);
+            return session.accessToken;
+        }
+        catch {
+            // Refresh selhal — session expirovala, potřebujeme nové párování
+            clearSession(agentName);
+        }
+    }
+    // Žádná platná session — spusť device grant flow
+    const deviceResponse = await initiateDeviceGrant(config, tenantId);
+    // Oznám uživateli
+    if (onPairingRequired) {
+        onPairingRequired(deviceResponse.user_code, deviceResponse.verification_uri);
+    }
+    else {
+        console.error(`[tickr] Agent is not paired.`);
+        console.error(`[tickr] Open ${deviceResponse.verification_uri}`);
+        console.error(`[tickr] Enter code: ${deviceResponse.user_code}`);
+        console.error(`[tickr] Waiting for approval... (expires in ${Math.round(deviceResponse.expires_in / 60)} min)`);
+    }
+    const tokenResponse = await pollForDeviceGrant(config, deviceResponse.device_code, deviceResponse.interval, deviceResponse.expires_in, (msg) => console.error(`[tickr] ${msg}`));
+    // Ulož session
+    const newSession = {
+        accessToken: tokenResponse.access_token,
+        refreshToken: tokenResponse.refresh_token,
+        expiresAt: Date.now() + tokenResponse.expires_in * 1000,
+        agentIdentity: tokenResponse.agent_identity,
+        apiUrl: config.apiUrl,
+        tenantId,
+    };
+    saveSession(agentName, newSession);
+    console.error(`[tickr] ✓ Paired as ${tokenResponse.agent_identity}`);
+    return newSession.accessToken;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=device-grant.js.map

package/dist/server.js

@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { loadConfig } from "./config.js";
+import { initDeviceGrantSession } from "./auth.js";
 import { ApiClient } from "./api-client.js";
 import { debugLog, isDebugEnabled } from "./debug-logger.js";
 // Tools
@@ -72,6 +73,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";
@@ -95,10 +99,20 @@ import { registerPendingTasksResource } from "./resources/pending-tasks-resource
 import { initSignalRClient, stopSignalRClient } from "./signalr-client.js";
 export async function startServer() {
     const config = loadConfig();
+    // Inicializace device grant session (pokud je konfigurována)
+    initDeviceGrantSession(config);
     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.9",
+        version: "1.23.0",
     });
     // Debug logging wrapper (dedup odstraněn — nefunkční cross-process, řeší se na API straně: TKR-ADR-0043)
     {
@@ -195,6 +209,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);
@@ -221,10 +238,14 @@ export async function startServer() {
     // 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(() => { });
+    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(() => { });
+        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 () => {

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.21.0",
+  "version": "1.23.0",
   "description": "MCP server for Tickr project management — 56 tools + setup CLI wizard",
   "type": "module",
   "main": "./dist/index.js",