@crypto512/jicon-mcp 2.1.1 → 2.2.0

package/dist/jira/activity-tools.js

@@ -81,7 +81,17 @@ function truncateText(text, maxLength) {
         return text;
     return text.substring(0, maxLength - 3) + "...";
 }
-export function createActivityTools(client) {
+/**
+ * Create activity tools with a client getter function
+ */
+export function createActivityTools(getClient) {
+    const requireClient = () => {
+        const client = getClient();
+        if (!client) {
+            throw new Error("Jira is not configured. Provide JIRA_URL and JIRA_API_TOKEN environment variables, or pass credentials via X-Jira-Url and X-Jira-Token headers.");
+        }
+        return client;
+    };
     return {
         jira_get_activity_digest: {
             description: `Get recent activity across issues for LLM analysis. Returns DIRECTLY (not buffered).
@@ -126,7 +136,7 @@ Example: jira_get_activity_digest(projectKey="ACME", since="7d")`,
                     // Add date filter
                     const fullJql = `${scopeJql} AND updated >= "${dateFrom}" ORDER BY updated DESC`;
                     // Search for issues with changelog
-                    const searchResult = await client.searchWithChangelog(fullJql, 100, [
+                    const searchResult = await requireClient().searchWithChangelog(fullJql, 100, [
                         "summary",
                         "status",
                         "priority",
@@ -134,29 +144,44 @@ Example: jira_get_activity_digest(projectKey="ACME", since="7d")`,
                     ]);
                     const activities = [];
                     const issueKeys = searchResult.issues.map((i) => i.key);
-                    // Collect changelog activities
-                    const trackFields = [];
+                    // Get localized field names for non-English Jira instances
+                    // This maps system field ID (e.g., "status") to localized name (e.g., "Statut")
+                    const localizedFieldNames = await requireClient().getLocalizedFieldNames();
+                    // Build list of localized field names to track
+                    const trackFieldsEnglish = [];
                     if (args.includeStatusChanges !== false)
-                        trackFields.push("status");
+                        trackFieldsEnglish.push("status");
                     if (args.includePriorityChanges !== false)
-                        trackFields.push("priority");
+                        trackFieldsEnglish.push("priority");
                     if (args.includeAssigneeChanges !== false)
-                        trackFields.push("assignee");
-                    trackFields.push("resolution"); // Always track resolution
+                        trackFieldsEnglish.push("assignee");
+                    trackFieldsEnglish.push("resolution"); // Always track resolution
+                    // Build localized field names for matching + reverse map for type lookup
+                    const trackFields = [];
+                    const localizedToEnglish = new Map();
+                    for (const englishId of trackFieldsEnglish) {
+                        const localizedName = localizedFieldNames.get(englishId) || englishId;
+                        trackFields.push(localizedName);
+                        localizedToEnglish.set(localizedName, englishId);
+                    }
+                    // Type mapping uses English field IDs
+                    const typeMap = {
+                        status: "status_change",
+                        priority: "priority_change",
+                        assignee: "assignee_change",
+                        resolution: "resolution_change",
+                    };
                     for (const issue of searchResult.issues) {
                         if (issue.changelog?.histories) {
                             const changes = extractMeaningfulChanges(issue.changelog.histories, dateFrom, trackFields);
                             for (const change of changes) {
-                                const typeMap = {
-                                    status: "status_change",
-                                    priority: "priority_change",
-                                    assignee: "assignee_change",
-                                    resolution: "resolution_change",
-                                };
+                                // Convert localized field name back to English for type lookup
+                                const fieldLower = change.field.toLowerCase();
+                                const englishFieldId = localizedToEnglish.get(fieldLower) || fieldLower;
                                 activities.push({
                                     issueKey: issue.key,
                                     issueSummary: issue.fields.summary,
-                                    type: typeMap[change.field.toLowerCase()] || "status_change",
+                                    type: typeMap[englishFieldId] || "status_change",
                                     timestamp: change.timestamp,
                                     author: change.author,
                                     details: {
@@ -170,7 +195,7 @@ Example: jira_get_activity_digest(projectKey="ACME", since="7d")`,
                     }
                     // Collect comments if requested
                     if (args.includeComments !== false && issueKeys.length > 0) {
-                        const commentsMap = await client.getCommentsForIssues(issueKeys, dateFrom);
+                        const commentsMap = await requireClient().getCommentsForIssues(issueKeys, dateFrom);
                         const issueMap = new Map(searchResult.issues.map((i) => [i.key, i]));
                         for (const [issueKey, comments] of commentsMap) {
                             const issue = issueMap.get(issueKey);
@@ -223,13 +248,16 @@ Example: jira_get_activity_digest(projectKey="ACME", since="7d")`,
                         comments: 0,
                         statusToDone: 0,
                     };
+                    // Get status category map for language-independent status detection
+                    const statusCategoryMap = await requireClient().getStatusCategoryMap();
                     for (const activity of limitedActivities) {
                         switch (activity.type) {
                             case "status_change":
                                 stats.statusChanges++;
-                                if (activity.details.to?.toLowerCase().includes("done") ||
-                                    activity.details.to?.toLowerCase().includes("closed") ||
-                                    activity.details.to?.toLowerCase().includes("resolved")) {
+                                // Use language-independent statusCategory.key lookup
+                                const targetStatus = activity.details.to?.toLowerCase() || "";
+                                const categoryKey = statusCategoryMap.get(targetStatus);
+                                if (categoryKey === "done") {
                                     stats.statusToDone++;
                                 }
                                 break;
@@ -354,7 +382,7 @@ Example: jira_get_recent_comments(projectKey="ACME", since="7d")`,
                     // Add date filter for updated issues (comments update the issue)
                     const fullJql = `${scopeJql} AND updated >= "${dateFrom}" ORDER BY updated DESC`;
                     // Search for issues
-                    const searchResult = await client.searchIssuesAll(fullJql, ["summary", "status"], 100);
+                    const searchResult = await requireClient().searchIssuesAll(fullJql, ["summary", "status"], 100);
                     if (searchResult.issues.length === 0) {
                         return formatSuccessDirect({
                             _directContent: true,
@@ -363,7 +391,7 @@ Example: jira_get_recent_comments(projectKey="ACME", since="7d")`,
                     }
                     // Get comments for all issues
                     const issueKeys = searchResult.issues.map((i) => i.key);
-                    const commentsMap = await client.getCommentsForIssues(issueKeys, dateFrom);
+                    const commentsMap = await requireClient().getCommentsForIssues(issueKeys, dateFrom);
                     const issueMap = new Map(searchResult.issues.map((i) => [i.key, i]));
                     // Collect and filter comments
                     const allComments = [];
@@ -468,8 +496,18 @@ Example: jira_get_changelog(projectKey="ACME", since="7d", fields=["status", "pr
                 try {
                     const since = args.since || "7d";
                     const { dateFrom, dateTo } = parseSince(since);
-                    const trackFields = args.fields || ["status", "priority", "assignee", "resolution"];
+                    const userFields = args.fields || ["status", "priority", "assignee", "resolution"];
                     const maxChanges = args.maxChanges ?? 50;
+                    // Get localized field names for non-English Jira instances
+                    const localizedFieldNames = await requireClient().getLocalizedFieldNames();
+                    // Build list of localized field names to track
+                    // User provides English field IDs, we convert to localized names
+                    const trackFields = [];
+                    for (const userField of userFields) {
+                        const fieldLower = userField.toLowerCase();
+                        const localizedName = localizedFieldNames.get(fieldLower) || fieldLower;
+                        trackFields.push(localizedName);
+                    }
                     // Build scoping JQL
                     const scopeJql = buildScopingJql({
                         projectKey: args.projectKey,
@@ -479,12 +517,12 @@ Example: jira_get_changelog(projectKey="ACME", since="7d", fields=["status", "pr
                     // Add date filter
                     const fullJql = `${scopeJql} AND updated >= "${dateFrom}" ORDER BY updated DESC`;
                     // Search for issues with changelog
-                    const searchResult = await client.searchWithChangelog(fullJql, 100, ["summary"]);
+                    const searchResult = await requireClient().searchWithChangelog(fullJql, 100, ["summary"]);
                     // Extract changes
                     const allChanges = [];
                     for (const issue of searchResult.issues) {
                         if (issue.changelog?.histories) {
-                            const changes = extractMeaningfulChanges(issue.changelog.histories, dateFrom, trackFields.map((f) => f.toLowerCase()));
+                            const changes = extractMeaningfulChanges(issue.changelog.histories, dateFrom, trackFields);
                             for (const change of changes) {
                                 allChanges.push({
                                     issueKey: issue.key,
@@ -608,13 +646,13 @@ Example: jira_analyze_epic(issueKey="PROJ-100")`,
                         "resolutiondate",
                     ];
                     // Get the root issue with full details
-                    const rootIssue = await client.getIssue(args.issueKey, analysisFields);
+                    const rootIssue = await requireClient().getIssue(args.issueKey, analysisFields);
                     const rootType = rootIssue.fields.issuetype?.name || "Issue";
                     // Collect all child issues recursively
                     const allIssues = [rootIssue];
                     const visited = new Set([args.issueKey]);
                     const collectChildren = async (parentKey) => {
-                        // 1. Subtasks
+                        // 1. Subtasks (direct children via subtasks field)
                         const parent = allIssues.find((i) => i.key === parentKey);
                         const subtasks = parent?.fields.subtasks;
                         if (subtasks) {
@@ -622,7 +660,7 @@ Example: jira_analyze_epic(issueKey="PROJ-100")`,
                                 if (!visited.has(sub.key)) {
                                     visited.add(sub.key);
                                     try {
-                                        const issue = await client.getIssue(sub.key, analysisFields);
+                                        const issue = await requireClient().getIssue(sub.key, analysisFields);
                                         allIssues.push(issue);
                                         await collectChildren(sub.key);
                                     }
@@ -632,24 +670,38 @@ Example: jira_analyze_epic(issueKey="PROJ-100")`,
                                 }
                             }
                         }
-                        // 2. Epic children (try multiple patterns)
-                        const epicPatterns = [
-                            `"Epic Link" = ${parentKey}`,
-                            `parent = ${parentKey}`,
-                            `parentEpic = ${parentKey}`,
-                        ];
-                        for (const jql of epicPatterns) {
+                        // 2. Children via link fields (Epic Link, Parent Link) and parent field
+                        // Build JQL patterns in priority order
+                        const childPatterns = [];
+                        // Epic Link field (Epic → Story/Task/Bug)
+                        const epicLinkFieldId = await requireClient().getEpicLinkFieldId();
+                        if (epicLinkFieldId) {
+                            childPatterns.push(`cf[${epicLinkFieldId.replace("customfield_", "")}] = ${parentKey}`);
+                        }
+                        // Parent Link field (Initiative → Epic in Jira Portfolio/Advanced Roadmaps)
+                        const parentLinkFieldId = await requireClient().getParentLinkFieldId();
+                        if (parentLinkFieldId) {
+                            childPatterns.push(`cf[${parentLinkFieldId.replace("customfield_", "")}] = ${parentKey}`);
+                        }
+                        // Standard parent field (Team-managed/Next-Gen projects)
+                        childPatterns.push(`parent = ${parentKey}`);
+                        // Jira Software Cloud specific
+                        childPatterns.push(`parentEpic = ${parentKey}`);
+                        // Try each pattern, continue to next if no results or error
+                        for (const jql of childPatterns) {
                             try {
-                                const children = await client.searchIssues(jql, 100, analysisFields);
+                                const children = await requireClient().searchIssues(jql, 100, analysisFields);
                                 for (const child of children.issues) {
                                     if (!visited.has(child.key)) {
                                         visited.add(child.key);
                                         allIssues.push(child);
+                                        // Recurse to handle deep hierarchies:
+                                        // Initiative → Epic → Story → Task → Subtask
                                         await collectChildren(child.key);
                                     }
                                 }
-                                if (children.issues.length > 0)
-                                    break; // Found children with this pattern
+                                // Don't break early - multiple patterns may find different children
+                                // e.g., Epic Link finds Stories, Parent Link finds sub-Epics
                             }
                             catch {
                                 // Pattern not supported, try next
@@ -658,13 +710,16 @@ Example: jira_analyze_epic(issueKey="PROJ-100")`,
                     };
                     await collectChildren(args.issueKey);
                     const byType = new Map();
-                    const statusToDone = (status) => {
-                        const lower = status.toLowerCase();
-                        return lower.includes("done") || lower.includes("closed") || lower.includes("resolved");
+                    // Use statusCategory.key which is language-independent
+                    // Keys: "new" (To Do), "indeterminate" (In Progress), "done" (Done), "undefined" (No category)
+                    const getStatusCategory = (issue) => {
+                        return issue.fields.status?.statusCategory?.key || "undefined";
                     };
-                    const statusToInProgress = (status) => {
-                        const lower = status.toLowerCase();
-                        return lower.includes("progress") || lower.includes("review") || lower.includes("testing");
+                    const statusToDone = (issue) => {
+                        return getStatusCategory(issue) === "done";
+                    };
+                    const statusToInProgress = (issue) => {
+                        return getStatusCategory(issue) === "indeterminate";
                     };
                     for (const issue of allIssues) {
                         const type = issue.fields.issuetype?.name || "Unknown";
@@ -681,11 +736,11 @@ Example: jira_analyze_epic(issueKey="PROJ-100")`,
                         }
                         const metrics = byType.get(type);
                         metrics.total++;
-                        const statusName = issue.fields.status?.name || "";
-                        if (statusToDone(statusName)) {
+                        // Use language-independent statusCategory.key
+                        if (statusToDone(issue)) {
                             metrics.done++;
                         }
-                        else if (statusToInProgress(statusName)) {
+                        else if (statusToInProgress(issue)) {
                             metrics.inProgress++;
                         }
                         else {
@@ -732,31 +787,59 @@ Example: jira_analyze_epic(issueKey="PROJ-100")`,
                         totals.timeEstimatedSeconds += estimated;
                         totals.timeRemainingSeconds += remaining;
                     }
-                    // Extract linked Confluence pages and related issues
+                    // Extract linked Confluence pages and cross-project dependencies
                     const confluenceLinks = [];
-                    const relatedIssues = [];
-                    const issueLinks = rootIssue.fields.issuelinks;
-                    if (issueLinks) {
+                    const crossProjectDeps = [];
+                    // Helper to extract project key from issue key (e.g., "CORE-123" -> "CORE")
+                    const extractProject = (issueKey) => {
+                        const match = issueKey.match(/^([A-Z][A-Z0-9]*)-\d+$/);
+                        return match ? match[1] : "?";
+                    };
+                    // Track seen target keys to deduplicate
+                    const seenTargets = new Set();
+                    // Collect links from ALL issues in hierarchy (not just root)
+                    for (const issue of allIssues) {
+                        const issueLinks = issue.fields.issuelinks;
+                        if (!issueLinks)
+                            continue;
                         for (const link of issueLinks) {
+                            // Process outward links
                             if (link.outwardIssue) {
-                                relatedIssues.push({
-                                    key: link.outwardIssue.key,
-                                    summary: link.outwardIssue.fields?.summary || "",
-                                    relationship: `${link.type.outward}`,
-                                });
+                                const targetKey = link.outwardIssue.key;
+                                // Skip if target is in hierarchy (already shown as child) or already seen
+                                if (!visited.has(targetKey) && !seenTargets.has(targetKey)) {
+                                    seenTargets.add(targetKey);
+                                    crossProjectDeps.push({
+                                        source: issue.key,
+                                        relationship: link.type.outward,
+                                        target: targetKey,
+                                        project: extractProject(targetKey),
+                                        summary: link.outwardIssue.fields?.summary || "",
+                                        status: link.outwardIssue.fields?.status?.name || "Unknown",
+                                    });
+                                }
                             }
+                            // Process inward links
                             if (link.inwardIssue) {
-                                relatedIssues.push({
-                                    key: link.inwardIssue.key,
-                                    summary: link.inwardIssue.fields?.summary || "",
-                                    relationship: `${link.type.inward}`,
-                                });
+                                const targetKey = link.inwardIssue.key;
+                                // Skip if target is in hierarchy or already seen
+                                if (!visited.has(targetKey) && !seenTargets.has(targetKey)) {
+                                    seenTargets.add(targetKey);
+                                    crossProjectDeps.push({
+                                        source: issue.key,
+                                        relationship: link.type.inward,
+                                        target: targetKey,
+                                        project: extractProject(targetKey),
+                                        summary: link.inwardIssue.fields?.summary || "",
+                                        status: link.inwardIssue.fields?.status?.name || "Unknown",
+                                    });
+                                }
                             }
                         }
                     }
                     // Check for web links (Confluence pages)
                     try {
-                        const remoteLinks = await client.getIssueRemoteLinks(args.issueKey);
+                        const remoteLinks = await requireClient().getIssueRemoteLinks(args.issueKey);
                         for (const link of remoteLinks) {
                             if (link.object?.url && (link.object.url.includes("confluence") ||
                                 link.object.url.includes("/wiki/"))) {
@@ -776,7 +859,7 @@ Example: jira_analyze_epic(issueKey="PROJ-100")`,
                         const sinceDate = new Date();
                         sinceDate.setDate(sinceDate.getDate() - commentDays);
                         const since = sinceDate.toISOString().split("T")[0];
-                        const commentsMap = await client.getCommentsForIssues(allIssues.map((i) => i.key), since);
+                        const commentsMap = await requireClient().getCommentsForIssues(allIssues.map((i) => i.key), since);
                         for (const [issueKey, comments] of commentsMap) {
                             const sorted = [...comments].sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());
                             for (const comment of sorted.slice(0, maxCommentsPerIssue)) {
@@ -886,27 +969,29 @@ Example: jira_analyze_epic(issueKey="PROJ-100")`,
                         }
                         lines.push("");
                     }
-                    // Linked resources
-                    if (confluenceLinks.length > 0 || relatedIssues.length > 0) {
-                        lines.push("## Linked Resources");
+                    // Confluence pages
+                    if (confluenceLinks.length > 0) {
+                        lines.push("## Linked Confluence Pages");
                         lines.push("");
-                        if (confluenceLinks.length > 0) {
-                            lines.push("**Confluence Pages**:");
-                            for (const link of confluenceLinks) {
-                                lines.push(`- [${link.title}](${link.url})`);
-                            }
-                            lines.push("");
+                        for (const link of confluenceLinks) {
+                            lines.push(`- [${link.title}](${link.url})`);
                         }
-                        if (relatedIssues.length > 0) {
-                            lines.push("**Related Issues**:");
-                            for (const rel of relatedIssues.slice(0, 10)) {
-                                lines.push(`- ${rel.key}: ${rel.summary} (${rel.relationship})`);
-                            }
-                            if (relatedIssues.length > 10) {
-                                lines.push(`- *...and ${relatedIssues.length - 10} more*`);
-                            }
+                        lines.push("");
+                    }
+                    // Cross-project dependencies (links to issues outside hierarchy)
+                    if (crossProjectDeps.length > 0) {
+                        lines.push("## Cross-Project Dependencies");
+                        lines.push("");
+                        lines.push("| Source | Relationship | Target | Project | Status |");
+                        lines.push("|--------|--------------|--------|---------|--------|");
+                        for (const dep of crossProjectDeps.slice(0, 20)) {
+                            lines.push(`| ${dep.source} | ${dep.relationship} | ${dep.target} | ${dep.project} | ${dep.status} |`);
+                        }
+                        if (crossProjectDeps.length > 20) {
                             lines.push("");
+                            lines.push(`*...and ${crossProjectDeps.length - 20} more dependencies*`);
                         }
+                        lines.push("");
                     }
                     // Recent comments
                     if (recentComments.length > 0) {
@@ -966,6 +1051,579 @@ Example: jira_analyze_epic(issueKey="PROJ-100")`,
                 }
             },
         },
+        jira_epic_summary: {
+            description: `Lightweight Epic/Initiative summary with hierarchy and status breakdown. Returns DIRECTLY (not buffered).
+
+Provides quick overview including:
+- Issue list with type, summary, status, assignee
+- Status breakdown by issue type
+- Cross-project dependencies (links to issues outside hierarchy)
+
+Lighter than jira_analyze_epic (no time metrics, no comments, no Confluence links).
+
+REQUIRES: issueKey (Epic, Initiative, or parent issue)
+RETURNS: Markdown summary (directly to LLM, not buffered)
+
+Example: jira_epic_summary(issueKey="PROJ-100")`,
+            inputSchema: z.object({
+                issueKey: z.string().describe("Epic or parent issue key (e.g., PROJ-123)"),
+                includeLinks: z.boolean().optional().describe("Show cross-project dependencies (default: true)"),
+                maxDepth: z.number().optional().describe("Maximum recursion depth (default: 3)"),
+            }),
+            handler: async (args) => {
+                try {
+                    const includeLinks = args.includeLinks !== false;
+                    const maxDepth = args.maxDepth ?? 3;
+                    // Minimal fields for summary
+                    const summaryFields = [
+                        "summary",
+                        "status",
+                        "issuetype",
+                        "assignee",
+                        "subtasks",
+                        "issuelinks",
+                    ];
+                    // Get the root issue
+                    const rootIssue = await requireClient().getIssue(args.issueKey, summaryFields);
+                    const rootType = rootIssue.fields.issuetype?.name || "Issue";
+                    // Collect hierarchy
+                    const allIssues = [rootIssue];
+                    const visited = new Set([args.issueKey]);
+                    const collectChildren = async (parentKey, depth) => {
+                        if (depth >= maxDepth)
+                            return;
+                        // 1. Subtasks
+                        const parent = allIssues.find((i) => i.key === parentKey);
+                        const subtasks = parent?.fields.subtasks;
+                        if (subtasks) {
+                            for (const sub of subtasks) {
+                                if (!visited.has(sub.key)) {
+                                    visited.add(sub.key);
+                                    try {
+                                        const issue = await requireClient().getIssue(sub.key, summaryFields);
+                                        allIssues.push(issue);
+                                        await collectChildren(sub.key, depth + 1);
+                                    }
+                                    catch {
+                                        // Skip inaccessible issues
+                                    }
+                                }
+                            }
+                        }
+                        // 2. Children via link fields
+                        const childPatterns = [];
+                        const epicLinkFieldId = await requireClient().getEpicLinkFieldId();
+                        if (epicLinkFieldId) {
+                            childPatterns.push(`cf[${epicLinkFieldId.replace("customfield_", "")}] = ${parentKey}`);
+                        }
+                        const parentLinkFieldId = await requireClient().getParentLinkFieldId();
+                        if (parentLinkFieldId) {
+                            childPatterns.push(`cf[${parentLinkFieldId.replace("customfield_", "")}] = ${parentKey}`);
+                        }
+                        childPatterns.push(`parent = ${parentKey}`);
+                        childPatterns.push(`parentEpic = ${parentKey}`);
+                        for (const jql of childPatterns) {
+                            try {
+                                const children = await requireClient().searchIssues(jql, 100, summaryFields);
+                                for (const child of children.issues) {
+                                    if (!visited.has(child.key)) {
+                                        visited.add(child.key);
+                                        allIssues.push(child);
+                                        await collectChildren(child.key, depth + 1);
+                                    }
+                                }
+                            }
+                            catch {
+                                // Pattern not supported
+                            }
+                        }
+                    };
+                    await collectChildren(args.issueKey, 0);
+                    // Status category helper
+                    const getStatusCategory = (issue) => {
+                        return issue.fields.status?.statusCategory?.key || "undefined";
+                    };
+                    // Calculate metrics by type
+                    const byType = new Map();
+                    for (const issue of allIssues) {
+                        const type = issue.fields.issuetype?.name || "Unknown";
+                        if (!byType.has(type)) {
+                            byType.set(type, { total: 0, done: 0, inProgress: 0, todo: 0 });
+                        }
+                        const metrics = byType.get(type);
+                        metrics.total++;
+                        const category = getStatusCategory(issue);
+                        if (category === "done") {
+                            metrics.done++;
+                        }
+                        else if (category === "indeterminate") {
+                            metrics.inProgress++;
+                        }
+                        else {
+                            metrics.todo++;
+                        }
+                    }
+                    // Calculate totals
+                    let totalDone = 0, totalInProgress = 0, totalTodo = 0;
+                    for (const metrics of byType.values()) {
+                        totalDone += metrics.done;
+                        totalInProgress += metrics.inProgress;
+                        totalTodo += metrics.todo;
+                    }
+                    const totalIssues = allIssues.length;
+                    const totalCompletion = totalIssues > 0 ? Math.round((totalDone / totalIssues) * 100) : 0;
+                    // Collect cross-project dependencies
+                    const crossProjectDeps = [];
+                    if (includeLinks) {
+                        const extractProject = (issueKey) => {
+                            const match = issueKey.match(/^([A-Z][A-Z0-9]*)-\d+$/);
+                            return match ? match[1] : "?";
+                        };
+                        const seenTargets = new Set();
+                        for (const issue of allIssues) {
+                            const issueLinks = issue.fields.issuelinks;
+                            if (!issueLinks)
+                                continue;
+                            for (const link of issueLinks) {
+                                if (link.outwardIssue) {
+                                    const targetKey = link.outwardIssue.key;
+                                    if (!visited.has(targetKey) && !seenTargets.has(targetKey)) {
+                                        seenTargets.add(targetKey);
+                                        crossProjectDeps.push({
+                                            source: issue.key,
+                                            relationship: link.type.outward,
+                                            target: targetKey,
+                                            project: extractProject(targetKey),
+                                            status: link.outwardIssue.fields?.status?.name || "Unknown",
+                                        });
+                                    }
+                                }
+                                if (link.inwardIssue) {
+                                    const targetKey = link.inwardIssue.key;
+                                    if (!visited.has(targetKey) && !seenTargets.has(targetKey)) {
+                                        seenTargets.add(targetKey);
+                                        crossProjectDeps.push({
+                                            source: issue.key,
+                                            relationship: link.type.inward,
+                                            target: targetKey,
+                                            project: extractProject(targetKey),
+                                            status: link.inwardIssue.fields?.status?.name || "Unknown",
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Build markdown output
+                    const lines = [
+                        `# ${rootType} Summary: ${args.issueKey}`,
+                        `**${rootIssue.fields.summary}**`,
+                        "",
+                        `**Status**: ${rootIssue.fields.status?.name || "Unknown"} | **Completion**: ${totalCompletion}%`,
+                        "",
+                    ];
+                    // Issue list
+                    lines.push(`## Hierarchy (${totalIssues} issues)`);
+                    lines.push("");
+                    lines.push("| Key | Type | Summary | Status | Assignee |");
+                    lines.push("|-----|------|---------|--------|----------|");
+                    for (const issue of allIssues.slice(0, 50)) {
+                        const type = issue.fields.issuetype?.name || "?";
+                        const summary = truncateText(issue.fields.summary || "", 50);
+                        const status = issue.fields.status?.name || "?";
+                        const assignee = issue.fields.assignee?.displayName || "Unassigned";
+                        lines.push(`| ${issue.key} | ${type} | ${summary} | ${status} | ${assignee} |`);
+                    }
+                    if (allIssues.length > 50) {
+                        lines.push("");
+                        lines.push(`*...and ${allIssues.length - 50} more issues*`);
+                    }
+                    lines.push("");
+                    // Status breakdown
+                    lines.push("## Status Breakdown");
+                    lines.push("");
+                    lines.push("| Type | Total | Done | In Progress | To Do | Completion |");
+                    lines.push("|------|-------|------|-------------|-------|------------|");
+                    for (const [type, metrics] of byType) {
+                        const completion = metrics.total > 0 ? Math.round((metrics.done / metrics.total) * 100) : 0;
+                        lines.push(`| ${type} | ${metrics.total} | ${metrics.done} | ${metrics.inProgress} | ${metrics.todo} | ${completion}% |`);
+                    }
+                    lines.push(`| **TOTAL** | **${totalIssues}** | **${totalDone}** | **${totalInProgress}** | **${totalTodo}** | **${totalCompletion}%** |`);
+                    lines.push("");
+                    // Cross-project dependencies
+                    if (crossProjectDeps.length > 0) {
+                        lines.push(`## Cross-Project Dependencies (${crossProjectDeps.length})`);
+                        lines.push("");
+                        lines.push("| Source | Relationship | Target | Project | Status |");
+                        lines.push("|--------|--------------|--------|---------|--------|");
+                        for (const dep of crossProjectDeps.slice(0, 20)) {
+                            lines.push(`| ${dep.source} | ${dep.relationship} | ${dep.target} | ${dep.project} | ${dep.status} |`);
+                        }
+                        if (crossProjectDeps.length > 20) {
+                            lines.push("");
+                            lines.push(`*...and ${crossProjectDeps.length - 20} more dependencies*`);
+                        }
+                        lines.push("");
+                    }
+                    const output = lines.join("\n");
+                    return formatSuccessDirect({
+                        _directContent: true,
+                        content: output,
+                    });
+                }
+                catch (error) {
+                    return formatError(isApiError(error) ? error : new Error(String(error)));
+                }
+            },
+        },
+        jira_analyze_sprint: {
+            description: `Comprehensive Sprint analysis for LLM insights. Returns DIRECTLY (not buffered).
+
+Provides in-depth sprint breakdown for LLM analysis including:
+- Sprint metadata: dates, duration, days remaining
+- Progress: completion percentage, status breakdown
+- Issue breakdown by type and status
+- Time metrics: estimated vs spent vs remaining
+- Team distribution: who's working on what
+- Risk indicators: stale, blocked, high-priority unstarted issues
+- Recent comments: technical discussions
+
+Ideal for:
+- "How is Sprint 42 progressing?"
+- "What are the risks in the current sprint?"
+- "Show me sprint status with team breakdown"
+
+REQUIRES: sprintId (from jira_get_sprints)
+RETURNS: Markdown-formatted sprint analysis with pre-computed metrics
+
+Example: jira_analyze_sprint(sprintId=123)`,
+            inputSchema: z.object({
+                sprintId: z.number().describe("Sprint ID (from jira_get_sprints)"),
+                includeComments: z.boolean().optional().describe("Include recent comments (default: true)"),
+                commentDays: z.number().optional().describe("Days of comments to include (default: 7)"),
+                includeRisks: z.boolean().optional().describe("Calculate risk indicators (default: true)"),
+            }),
+            handler: async (args) => {
+                try {
+                    const includeComments = args.includeComments !== false;
+                    const commentDays = args.commentDays ?? 7;
+                    const includeRisks = args.includeRisks !== false;
+                    // Fetch sprint info
+                    const sprint = await requireClient().getSprint(args.sprintId);
+                    // Fetch sprint issues with required fields
+                    const sprintIssuesResult = await requireClient().getSprintIssues(args.sprintId);
+                    const issues = sprintIssuesResult.issues;
+                    // Re-fetch issues with full fields (getSprintIssues may not return all fields)
+                    const issueKeys = issues.map(i => i.key);
+                    const analysisFields = [
+                        "summary",
+                        "status",
+                        "priority",
+                        "assignee",
+                        "issuetype",
+                        "labels",
+                        "components",
+                        "timeoriginalestimate",
+                        "timeestimate",
+                        "timespent",
+                        "issuelinks",
+                        "created",
+                        "updated",
+                    ];
+                    // Fetch full issue details in batches
+                    const fullIssues = [];
+                    const batchSize = 50;
+                    for (let i = 0; i < issueKeys.length; i += batchSize) {
+                        const batchKeys = issueKeys.slice(i, i + batchSize);
+                        const jql = `key in (${batchKeys.join(", ")})`;
+                        const result = await requireClient().searchIssuesAll(jql, analysisFields, batchKeys.length);
+                        fullIssues.push(...result.issues);
+                    }
+                    // Calculate sprint timing
+                    const now = new Date();
+                    const startDate = sprint.startDate ? new Date(sprint.startDate) : null;
+                    const endDate = sprint.endDate ? new Date(sprint.endDate) : null;
+                    let sprintDuration = 0;
+                    let daysPassed = 0;
+                    let daysRemaining = 0;
+                    if (startDate && endDate) {
+                        sprintDuration = Math.ceil((endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60 * 24));
+                        if (sprint.state === "active") {
+                            daysPassed = Math.ceil((now.getTime() - startDate.getTime()) / (1000 * 60 * 60 * 24));
+                            daysRemaining = Math.max(0, Math.ceil((endDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24)));
+                        }
+                        else if (sprint.state === "closed") {
+                            daysPassed = sprintDuration;
+                            daysRemaining = 0;
+                        }
+                    }
+                    // Status category helper (language-independent)
+                    const getStatusCategory = (issue) => {
+                        const key = issue.fields.status?.statusCategory?.key || "new";
+                        if (key === "done")
+                            return "done";
+                        if (key === "indeterminate")
+                            return "indeterminate";
+                        return "new";
+                    };
+                    // Calculate status metrics
+                    const statusCounts = { done: 0, inProgress: 0, todo: 0 };
+                    const byType = new Map();
+                    const byAssignee = new Map();
+                    let totalTimeSpent = 0;
+                    let totalTimeEstimate = 0;
+                    let totalTimeRemaining = 0;
+                    for (const issue of fullIssues) {
+                        const category = getStatusCategory(issue);
+                        const typeName = issue.fields.issuetype?.name || "Unknown";
+                        const assigneeName = issue.fields.assignee?.displayName || "Unassigned";
+                        // Status counts
+                        if (category === "done") {
+                            statusCounts.done++;
+                        }
+                        else if (category === "indeterminate") {
+                            statusCounts.inProgress++;
+                        }
+                        else {
+                            statusCounts.todo++;
+                        }
+                        // By type
+                        if (!byType.has(typeName)) {
+                            byType.set(typeName, { total: 0, done: 0, inProgress: 0, todo: 0 });
+                        }
+                        const typeMetrics = byType.get(typeName);
+                        typeMetrics.total++;
+                        if (category === "done")
+                            typeMetrics.done++;
+                        else if (category === "indeterminate")
+                            typeMetrics.inProgress++;
+                        else
+                            typeMetrics.todo++;
+                        // By assignee
+                        if (!byAssignee.has(assigneeName)) {
+                            byAssignee.set(assigneeName, { total: 0, done: 0, inProgress: 0 });
+                        }
+                        const assigneeMetrics = byAssignee.get(assigneeName);
+                        assigneeMetrics.total++;
+                        if (category === "done")
+                            assigneeMetrics.done++;
+                        else if (category === "indeterminate")
+                            assigneeMetrics.inProgress++;
+                        // Time tracking
+                        const spent = issue.fields.timespent || 0;
+                        const estimated = issue.fields.timeoriginalestimate || 0;
+                        const remaining = issue.fields.timeestimate || 0;
+                        totalTimeSpent += spent;
+                        totalTimeEstimate += estimated;
+                        totalTimeRemaining += remaining;
+                    }
+                    const totalIssues = fullIssues.length;
+                    const completionPercent = totalIssues > 0 ? Math.round((statusCounts.done / totalIssues) * 100) : 0;
+                    // Risk detection
+                    const risks = [];
+                    if (includeRisks) {
+                        const threeDaysAgo = new Date();
+                        threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
+                        for (const issue of fullIssues) {
+                            const category = getStatusCategory(issue);
+                            const priorityName = issue.fields.priority?.name?.toLowerCase() || "";
+                            const updated = new Date(issue.fields.updated);
+                            // Stale: In Progress for 3+ days without update
+                            if (category === "indeterminate" && updated < threeDaysAgo) {
+                                const staleDays = Math.ceil((now.getTime() - updated.getTime()) / (1000 * 60 * 60 * 24));
+                                risks.push({
+                                    issueKey: issue.key,
+                                    summary: issue.fields.summary,
+                                    riskType: "stale",
+                                    detail: `In Progress for ${staleDays} days without update`,
+                                });
+                            }
+                            // High priority unstarted
+                            if (category === "new" && (priorityName.includes("high") || priorityName.includes("highest") || priorityName.includes("critical"))) {
+                                risks.push({
+                                    issueKey: issue.key,
+                                    summary: issue.fields.summary,
+                                    riskType: "high-priority-unstarted",
+                                    detail: `${issue.fields.priority?.name} priority, still To Do`,
+                                });
+                            }
+                            // Blocked: has "is blocked by" link to issue outside sprint
+                            const issueLinks = issue.fields.issuelinks;
+                            if (issueLinks) {
+                                for (const link of issueLinks) {
+                                    // Check for "is blocked by" relationships
+                                    if (link.type.inward?.toLowerCase().includes("blocked") && link.inwardIssue) {
+                                        const blockingKey = link.inwardIssue.key;
+                                        // Check if blocking issue is outside this sprint
+                                        if (!issueKeys.includes(blockingKey)) {
+                                            const blockingStatus = link.inwardIssue.fields?.status?.name || "Unknown";
+                                            risks.push({
+                                                issueKey: issue.key,
+                                                summary: issue.fields.summary,
+                                                riskType: "blocked",
+                                                detail: `Blocked by ${blockingKey} (${blockingStatus}) - external to sprint`,
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Collect recent comments if requested
+                    const recentComments = [];
+                    if (includeComments && issueKeys.length > 0) {
+                        const sinceDate = new Date();
+                        sinceDate.setDate(sinceDate.getDate() - commentDays);
+                        const since = sinceDate.toISOString().split("T")[0];
+                        const commentsMap = await requireClient().getCommentsForIssues(issueKeys, since);
+                        for (const [issueKey, comments] of commentsMap) {
+                            const sorted = [...comments].sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());
+                            for (const comment of sorted.slice(0, 3)) {
+                                recentComments.push({
+                                    issueKey,
+                                    author: comment.author.displayName,
+                                    date: comment.created,
+                                    body: truncateText(comment.body, 200),
+                                });
+                            }
+                        }
+                        // Sort all comments by date
+                        recentComments.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+                    }
+                    // Build markdown output
+                    const lines = [
+                        `# Sprint Analysis: ${sprint.name}`,
+                        "",
+                    ];
+                    // Sprint metadata
+                    lines.push(`**State**: ${sprint.state.charAt(0).toUpperCase() + sprint.state.slice(1)}`);
+                    if (startDate && endDate) {
+                        lines.push(`**Period**: ${formatDisplayDate(sprint.startDate)} - ${formatDisplayDate(sprint.endDate)} (${sprintDuration} days)`);
+                        if (sprint.state === "active") {
+                            lines.push(`**Progress**: Day ${daysPassed} of ${sprintDuration} (${daysRemaining} days remaining)`);
+                        }
+                    }
+                    lines.push("");
+                    // Sprint progress
+                    lines.push("---");
+                    lines.push("## Sprint Progress");
+                    lines.push("");
+                    lines.push(`**Completion**: ${completionPercent}% (${statusCounts.done} of ${totalIssues} issues done)`);
+                    lines.push("");
+                    lines.push("| Status | Count | % |");
+                    lines.push("|--------|-------|---|");
+                    lines.push(`| Done | ${statusCounts.done} | ${totalIssues > 0 ? Math.round((statusCounts.done / totalIssues) * 100) : 0}% |`);
+                    lines.push(`| In Progress | ${statusCounts.inProgress} | ${totalIssues > 0 ? Math.round((statusCounts.inProgress / totalIssues) * 100) : 0}% |`);
+                    lines.push(`| To Do | ${statusCounts.todo} | ${totalIssues > 0 ? Math.round((statusCounts.todo / totalIssues) * 100) : 0}% |`);
+                    lines.push("");
+                    // Issue breakdown by type
+                    lines.push("## Issue Breakdown by Type");
+                    lines.push("");
+                    lines.push("| Type | Total | Done | In Progress | To Do |");
+                    lines.push("|------|-------|------|-------------|-------|");
+                    for (const [type, metrics] of byType) {
+                        lines.push(`| ${type} | ${metrics.total} | ${metrics.done} | ${metrics.inProgress} | ${metrics.todo} |`);
+                    }
+                    lines.push("");
+                    // Time metrics
+                    if (totalTimeSpent > 0 || totalTimeEstimate > 0) {
+                        lines.push("## Time Metrics");
+                        lines.push("");
+                        lines.push(`- **Estimated**: ${formatTimeSpent(totalTimeEstimate)}`);
+                        lines.push(`- **Spent**: ${formatTimeSpent(totalTimeSpent)}`);
+                        lines.push(`- **Remaining**: ${formatTimeSpent(totalTimeRemaining)}`);
+                        if (totalTimeEstimate > 0) {
+                            const burnRate = Math.round((totalTimeSpent / totalTimeEstimate) * 100);
+                            lines.push(`- **Burn Rate**: ${burnRate}% spent, ${completionPercent}% done`);
+                            if (burnRate > completionPercent + 10) {
+                                lines.push(`- **⚠️ Warning**: Time burn rate (${burnRate}%) exceeds completion rate (${completionPercent}%)`);
+                            }
+                        }
+                        lines.push("");
+                    }
+                    // Team distribution
+                    lines.push("## Team Distribution");
+                    lines.push("");
+                    lines.push("| Assignee | Total | Done | In Progress |");
+                    lines.push("|----------|-------|------|-------------|");
+                    // Sort by total issues descending
+                    const sortedAssignees = Array.from(byAssignee.entries()).sort((a, b) => b[1].total - a[1].total);
+                    for (const [assignee, metrics] of sortedAssignees.slice(0, 15)) {
+                        lines.push(`| ${assignee} | ${metrics.total} | ${metrics.done} | ${metrics.inProgress} |`);
+                    }
+                    if (sortedAssignees.length > 15) {
+                        lines.push(`| *...and ${sortedAssignees.length - 15} more* | | | |`);
+                    }
+                    lines.push("");
+                    // Risk indicators
+                    if (includeRisks && risks.length > 0) {
+                        lines.push("## Risk Indicators");
+                        lines.push("");
+                        lines.push(`⚠️ **${risks.length} issue${risks.length > 1 ? "s" : ""} at risk:**`);
+                        for (const risk of risks.slice(0, 10)) {
+                            lines.push(`- **${risk.issueKey}**: ${risk.detail}`);
+                        }
+                        if (risks.length > 10) {
+                            lines.push(`- *...and ${risks.length - 10} more risks*`);
+                        }
+                        lines.push("");
+                    }
+                    else if (includeRisks) {
+                        lines.push("## Risk Indicators");
+                        lines.push("");
+                        lines.push("✓ No significant risks detected.");
+                        lines.push("");
+                    }
+                    // Recent comments
+                    if (recentComments.length > 0) {
+                        lines.push(`## Recent Discussions (last ${commentDays} days)`);
+                        lines.push("");
+                        for (const comment of recentComments.slice(0, 10)) {
+                            const dateStr = formatDisplayDate(comment.date);
+                            const body = comment.body.replace(/\n/g, " ").trim();
+                            lines.push(`- **${comment.issueKey}** @${comment.author} (${dateStr}): "${body}"`);
+                        }
+                        if (recentComments.length > 10) {
+                            lines.push(`- *...and ${recentComments.length - 10} more comments*`);
+                        }
+                        lines.push("");
+                    }
+                    // Summary
+                    lines.push("---");
+                    lines.push("## Summary");
+                    lines.push("");
+                    lines.push(`Sprint "${sprint.name}" is **${completionPercent}% complete** with ${statusCounts.inProgress} issues in progress and ${statusCounts.todo} issues remaining.`);
+                    if (daysRemaining > 0) {
+                        lines.push(`**${daysRemaining} days remaining** in the sprint.`);
+                    }
+                    if (risks.length > 0) {
+                        lines.push(`**${risks.length} issue${risks.length > 1 ? "s" : ""}** need attention.`);
+                    }
+                    if (totalTimeEstimate > 0) {
+                        const burnRate = Math.round((totalTimeSpent / totalTimeEstimate) * 100);
+                        lines.push(`Time tracking shows **${burnRate}% of estimate used** for **${completionPercent}% completion**.`);
+                    }
+                    const output = lines.join("\n");
+                    // Check output size
+                    const maxSize = getMaxOutputSize();
+                    if (output.length > maxSize) {
+                        return formatSuccessDirect({
+                            _directContent: true,
+                            content: output.substring(0, maxSize - 200),
+                            truncated: true,
+                            hint: "Use includeComments=false or smaller commentDays for more concise output",
+                        });
+                    }
+                    return formatSuccessDirect({
+                        _directContent: true,
+                        content: output,
+                    });
+                }
+                catch (error) {
+                    return formatError(isApiError(error) ? error : new Error(String(error)));
+                }
+            },
+        },
     };
 }
 //# sourceMappingURL=activity-tools.js.map