@aaronsb/jira-cloud-mcp 0.7.1 → 0.7.6

package/build/handlers/project-handlers.js

@@ -81,22 +81,18 @@ async function handleGetProject(jiraClient, args) {
     catch {
         // Non-fatal — continue without issue types
     }
-    // If status counts are requested, get them
+    // If status counts are requested, use the count API for exact totals
     if (includeStatusCounts) {
         try {
-            // Get issue counts by status for this project
-            const searchResult = await jiraClient.searchIssues(`project = ${projectKey}`, 0, 100);
-            // Count issues by status
-            const statusCounts = {};
-            for (const issue of searchResult.issues) {
-                const status = issue.status;
-                statusCounts[status] = (statusCounts[status] || 0) + 1;
-            }
-            projectData.statusCounts = statusCounts;
+            const [total, open, done] = await Promise.all([
+                jiraClient.countIssues(`project = ${projectKey}`),
+                jiraClient.countIssues(`project = ${projectKey} AND resolution = Unresolved`),
+                jiraClient.countIssues(`project = ${projectKey} AND resolution != Unresolved`),
+            ]);
+            projectData.statusCounts = { Total: total, Open: open, Done: done };
         }
         catch (error) {
             console.error(`Error getting status counts for project ${projectKey}:`, error);
-            // Continue even if status counts fail
         }
     }
     // Handle expansions
@@ -166,26 +162,17 @@ async function handleListProjects(jiraClient, args) {
         description: project.description || undefined,
         lead: project.lead || undefined,
     }));
-    // If status counts are requested, get them for each project
+    // If status counts are requested, use count API (fast, exact, parallel)
     if (includeStatusCounts) {
-        // This would be more efficient with a batch API call, but for now we'll do it sequentially
-        for (const project of projectDataList) {
+        await Promise.all(projectDataList.map(async (project) => {
             try {
-                // Get issue counts by status for this project
-                const searchResult = await jiraClient.searchIssues(`project = ${project.key}`, 0, 100);
-                // Count issues by status
-                const statusCounts = {};
-                for (const issue of searchResult.issues) {
-                    const status = issue.status;
-                    statusCounts[status] = (statusCounts[status] || 0) + 1;
-                }
-                project.statusCounts = statusCounts;
+                const total = await jiraClient.countIssues(`project = ${project.key}`);
+                project.statusCounts = { Total: total };
             }
             catch (error) {
-                console.error(`Error getting status counts for project ${project.key}:`, error);
-                // Continue with other projects even if one fails
+                console.error(`Error getting count for project ${project.key}:`, error);
             }
-        }
+        }));
     }
     // Render to markdown with pagination
     const rendererProjects = projectDataList.map(project => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaronsb/jira-cloud-mcp",
-  "version": "0.7.1",
+  "version": "0.7.6",
   "mcpName": "io.github.aaronsb/jira-cloud",
   "description": "Model Context Protocol (MCP) server for Jira Cloud - enables AI assistants to interact with Jira",
   "type": "module",

package/build/handlers/search-handlers.js

@@ -1,103 +0,0 @@
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { MarkdownRenderer } from '../mcp/markdown-renderer.js';
-// Helper function to normalize parameter names (support both snake_case and camelCase)
-function normalizeArgs(args) {
-    const normalized = {};
-    for (const [key, value] of Object.entries(args)) {
-        // Convert snake_case to camelCase
-        if (key === 'start_at') {
-            normalized['startAt'] = value;
-        }
-        else if (key === 'max_results') {
-            normalized['maxResults'] = value;
-        }
-        else if (key === 'filter_id') {
-            normalized['filterId'] = value;
-        }
-        else {
-            normalized[key] = value;
-        }
-    }
-    return normalized;
-}
-function isSearchIssuesArgs(args) {
-    if (typeof args !== 'object' || args === null) {
-        throw new McpError(ErrorCode.InvalidParams, `Invalid search_jira_issues arguments: Expected an object with a jql parameter. Example: { "jql": "project = PROJ" }`);
-    }
-    const typedArgs = args;
-    if (typeof typedArgs.jql !== 'string') {
-        throw new McpError(ErrorCode.InvalidParams, `Missing or invalid jql parameter. Please provide a valid JQL query string. Example: { "jql": "project = PROJ" }`);
-    }
-    // Validate startAt if present
-    if (typedArgs.startAt !== undefined && typeof typedArgs.startAt !== 'number') {
-        throw new McpError(ErrorCode.InvalidParams, 'Invalid startAt parameter. Expected a number.');
-    }
-    // Validate maxResults if present
-    if (typedArgs.maxResults !== undefined && typeof typedArgs.maxResults !== 'number') {
-        throw new McpError(ErrorCode.InvalidParams, 'Invalid maxResults parameter. Expected a number.');
-    }
-    // Validate expand parameter if present
-    if (typedArgs.expand !== undefined) {
-        if (!Array.isArray(typedArgs.expand)) {
-            throw new McpError(ErrorCode.InvalidParams, 'Invalid expand parameter. Expected an array of strings.');
-        }
-        const validExpansions = ['issue_details', 'transitions', 'comments_preview'];
-        for (const expansion of typedArgs.expand) {
-            if (typeof expansion !== 'string' || !validExpansions.includes(expansion)) {
-                throw new McpError(ErrorCode.InvalidParams, `Invalid expansion: ${expansion}. Valid expansions are: ${validExpansions.join(', ')}`);
-            }
-        }
-    }
-    return true;
-}
-export async function setupSearchHandlers(server, jiraClient, request) {
-    console.error('Handling search request...');
-    const { name } = request.params;
-    const args = request.params.arguments;
-    if (!args) {
-        throw new McpError(ErrorCode.InvalidParams, 'Missing arguments');
-    }
-    // Normalize arguments to support both snake_case and camelCase
-    const normalizedArgs = normalizeArgs(args);
-    switch (name) {
-        case 'search_jira_issues': {
-            console.error('Processing search_jira_issues request');
-            if (!isSearchIssuesArgs(normalizedArgs)) {
-                throw new McpError(ErrorCode.InvalidParams, 'Invalid search_jira_issues arguments');
-            }
-            try {
-                console.error(`Executing search with args:`, JSON.stringify(normalizedArgs, null, 2));
-                // Parse expansion options (reserved for future use)
-                const _expansionOptions = {};
-                if (normalizedArgs.expand) {
-                    for (const expansion of normalizedArgs.expand) {
-                        _expansionOptions[expansion] = true;
-                    }
-                }
-                // Execute the search
-                const searchResult = await jiraClient.searchIssues(normalizedArgs.jql, normalizedArgs.startAt, normalizedArgs.maxResults);
-                // Render to markdown for token efficiency
-                const markdown = MarkdownRenderer.renderIssueSearchResults(searchResult.issues, searchResult.pagination, normalizedArgs.jql);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: markdown,
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                console.error('Error in search_jira_issues:', error);
-                if (error instanceof Error) {
-                    throw new McpError(ErrorCode.InvalidRequest, `Jira API error: ${error.message}`);
-                }
-                throw new McpError(ErrorCode.InvalidRequest, 'Failed to execute Jira search');
-            }
-        }
-        default: {
-            console.error(`Unknown tool requested: ${name}`);
-            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-        }
-    }
-}

package/build/schemas/request-schemas.js

@@ -1,187 +0,0 @@
-import { z } from 'zod';
-// Sprint Management Schemas
-export const CreateJiraSprintSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('create_jira_sprint'),
-        arguments: z.object({
-            boardId: z.number(),
-            name: z.string(),
-            startDate: z.string().optional(),
-            endDate: z.string().optional(),
-            goal: z.string().optional(),
-        }),
-    }),
-});
-export const GetJiraSprintSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('get_jira_sprint'),
-        arguments: z.object({
-            sprintId: z.number(),
-            expand: z.array(z.string()).optional(),
-        }),
-    }),
-});
-export const ListJiraSprintsSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('list_jira_sprints'),
-        arguments: z.object({
-            boardId: z.number(),
-            state: z.enum(['future', 'active', 'closed']).optional(),
-            startAt: z.number().optional(),
-            maxResults: z.number().optional(),
-            expand: z.array(z.string()).optional(),
-        }),
-    }),
-});
-export const UpdateJiraSprintSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('update_jira_sprint'),
-        arguments: z.object({
-            sprintId: z.number(),
-            name: z.string().optional(),
-            goal: z.string().optional(),
-            startDate: z.string().optional(),
-            endDate: z.string().optional(),
-            state: z.enum(['future', 'active', 'closed']).optional(),
-        }),
-    }),
-});
-export const DeleteJiraSprintSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('delete_jira_sprint'),
-        arguments: z.object({
-            sprintId: z.number(),
-        }),
-    }),
-});
-export const UpdateSprintIssuesSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('update_sprint_issues'),
-        arguments: z.object({
-            sprintId: z.number(),
-            add: z.array(z.string()).optional(),
-            remove: z.array(z.string()).optional(),
-        }),
-    }),
-});
-// Consolidated API request schemas
-export const GetJiraIssueSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('get_jira_issue'),
-        arguments: z.object({
-            issueKey: z.string(),
-            expand: z.array(z.string()).optional(),
-        }),
-    }),
-});
-export const GetJiraProjectSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('get_jira_project'),
-        arguments: z.object({
-            projectKey: z.string(),
-            expand: z.array(z.string()).optional(),
-            include_status_counts: z.boolean().optional(),
-        }),
-    }),
-});
-export const GetJiraBoardSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('get_jira_board'),
-        arguments: z.object({
-            boardId: z.number(),
-            expand: z.array(z.string()).optional(),
-        }),
-    }),
-});
-export const SearchJiraIssuesSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('search_jira_issues'),
-        arguments: z.object({
-            jql: z.string(),
-            startAt: z.number().optional(),
-            maxResults: z.number().optional(),
-            expand: z.array(z.string()).optional(),
-        }),
-    }),
-});
-export const ListJiraProjectsSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('list_jira_projects'),
-        arguments: z.object({
-            include_status_counts: z.boolean().optional(),
-        }),
-    }),
-});
-export const ListJiraBoardsSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('list_jira_boards'),
-        arguments: z.object({
-            include_sprints: z.boolean().optional(),
-        }),
-    }),
-});
-export const CreateJiraIssueSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('create_jira_issue'),
-        arguments: z.object({
-            projectKey: z.string(),
-            summary: z.string(),
-            description: z.string().optional(),
-            issueType: z.string(),
-            priority: z.string().optional(),
-            assignee: z.string().optional(),
-            labels: z.array(z.string()).optional(),
-            customFields: z.record(z.any()).optional(),
-        }),
-    }),
-});
-export const UpdateJiraIssueSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('update_jira_issue'),
-        arguments: z.object({
-            issueKey: z.string(),
-            summary: z.string().optional(),
-            description: z.string().optional(),
-            parent: z.union([z.string(), z.null()]).optional(),
-            assignee: z.string().optional(),
-            priority: z.string().optional(),
-            labels: z.array(z.string()).optional(),
-            customFields: z.record(z.any()).optional(),
-        }),
-    }),
-});
-export const TransitionJiraIssueSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('transition_jira_issue'),
-        arguments: z.object({
-            issueKey: z.string(),
-            transitionId: z.string(),
-            comment: z.string().optional(),
-        }),
-    }),
-});
-export const AddJiraCommentSchema = z.object({
-    method: z.literal('tools/call'),
-    params: z.object({
-        name: z.literal('add_jira_comment'),
-        arguments: z.object({
-            issueKey: z.string(),
-            body: z.string(),
-        }),
-    }),
-});

package/build/utils/formatters/base-formatter.js

@@ -1,58 +0,0 @@
-/**
- * Base formatter for consistent response structure across all entity types
- */
-export class BaseFormatter {
-    /**
-     * Format a response with the standard structure
-     * @param data The main data for the response
-     * @param metadata Optional metadata about the response
-     * @param summary Optional summary information
-     * @returns A formatted response object
-     */
-    static formatResponse(data, metadata, summary) {
-        return {
-            data,
-            ...(metadata && { _metadata: metadata }),
-            ...(summary && { _summary: summary }),
-        };
-    }
-    /**
-     * Create metadata for a response
-     * @param options Metadata options
-     * @returns Response metadata
-     */
-    static createMetadata(options) {
-        const metadata = {};
-        if (options.expansions && options.expansions.length > 0) {
-            metadata.expansions = options.expansions;
-        }
-        if (options.related && Object.keys(options.related).length > 0) {
-            metadata.related = options.related;
-        }
-        if (options.pagination) {
-            const { startAt, maxResults, total } = options.pagination;
-            metadata.pagination = {
-                startAt,
-                maxResults,
-                total,
-                hasMore: startAt + maxResults < total,
-            };
-        }
-        return metadata;
-    }
-    /**
-     * Create a summary for a response
-     * @param options Summary options
-     * @returns Response summary
-     */
-    static createSummary(options) {
-        const summary = {};
-        if (options.status_counts && Object.keys(options.status_counts).length > 0) {
-            summary.status_counts = options.status_counts;
-        }
-        if (options.suggested_actions && options.suggested_actions.length > 0) {
-            summary.suggested_actions = options.suggested_actions;
-        }
-        return summary;
-    }
-}

package/build/utils/formatters/board-formatter.js

@@ -1,63 +0,0 @@
-import { BaseFormatter } from './base-formatter.js';
-export class BoardFormatter {
-    /**
-     * Format a board response with the standard structure and optional expansions
-     * @param board The board data
-     * @param options Expansion options
-     * @returns A formatted board response
-     */
-    static formatBoard(board, options = {}) {
-        // Create metadata with available expansions
-        const metadata = this.createBoardMetadata(board, options);
-        // Create summary
-        const summary = this.createBoardSummary(board);
-        return BaseFormatter.formatResponse(board, metadata, summary);
-    }
-    /**
-     * Create metadata for a board response
-     */
-    static createBoardMetadata(board, options) {
-        // Determine which expansions are available but not included
-        const availableExpansions = [];
-        if (!options.sprints && !board.sprints) {
-            availableExpansions.push('sprints');
-        }
-        if (!options.issues) {
-            availableExpansions.push('issues');
-        }
-        if (!options.configuration) {
-            availableExpansions.push('configuration');
-        }
-        // Create related entities map
-        const related = {};
-        if (board.location?.projectId) {
-            related.project = board.location.projectName || `Project ${board.location.projectId}`;
-        }
-        return BaseFormatter.createMetadata({
-            expansions: availableExpansions,
-            related
-        });
-    }
-    /**
-     * Create a summary for a board response
-     */
-    static createBoardSummary(board) {
-        const suggestedActions = [
-            {
-                text: `View all issues on ${board.name}`
-            }
-        ];
-        // Add sprint-related actions if sprints are available
-        if (board.sprints && board.sprints.length > 0) {
-            const activeSprints = board.sprints.filter(sprint => sprint.state === 'active');
-            if (activeSprints.length > 0) {
-                suggestedActions.push({
-                    text: `View active sprint: ${activeSprints[0].name}`
-                });
-            }
-        }
-        return BaseFormatter.createSummary({
-            suggested_actions: suggestedActions
-        });
-    }
-}

package/build/utils/formatters/filter-formatter.js

@@ -1,66 +0,0 @@
-import { BaseFormatter } from './base-formatter.js';
-export class FilterFormatter {
-    /**
-     * Format a filter response with the standard structure and optional expansions
-     * @param filter The filter data
-     * @param options Expansion options
-     * @returns A formatted filter response
-     */
-    static formatFilter(filter, options = {}) {
-        // Create metadata with available expansions
-        const metadata = this.createFilterMetadata(filter, options);
-        // Create summary
-        const summary = this.createFilterSummary(filter);
-        return BaseFormatter.formatResponse(filter, metadata, summary);
-    }
-    /**
-     * Create metadata for a filter response
-     */
-    static createFilterMetadata(filter, options) {
-        // Determine which expansions are available but not included
-        const availableExpansions = [];
-        if (!options.jql && !filter.jql) {
-            availableExpansions.push('jql');
-        }
-        if (!options.description && !filter.description) {
-            availableExpansions.push('description');
-        }
-        if (!options.permissions && !filter.sharePermissions) {
-            availableExpansions.push('permissions');
-        }
-        if (!options.issue_count && filter.issueCount === undefined) {
-            availableExpansions.push('issue_count');
-        }
-        // Create related entities map
-        const related = {
-            owner: filter.owner
-        };
-        return BaseFormatter.createMetadata({
-            expansions: availableExpansions,
-            related
-        });
-    }
-    /**
-     * Create a summary for a filter response
-     */
-    static createFilterSummary(filter) {
-        const suggestedActions = [
-            {
-                text: `View filter results: ${filter.name}`
-            }
-        ];
-        if (filter.jql) {
-            suggestedActions.push({
-                text: `Edit JQL: ${filter.name}`
-            });
-        }
-        if (!filter.favourite) {
-            suggestedActions.push({
-                text: `Add to favorites`
-            });
-        }
-        return BaseFormatter.createSummary({
-            suggested_actions: suggestedActions
-        });
-    }
-}

package/build/utils/formatters/index.js

@@ -1,7 +0,0 @@
-export * from './base-formatter.js';
-export * from './issue-formatter.js';
-export * from './project-formatter.js';
-export * from './search-formatter.js';
-export * from './board-formatter.js';
-export * from './sprint-formatter.js';
-export * from './filter-formatter.js';

package/build/utils/formatters/issue-formatter.js

@@ -1,84 +0,0 @@
-import { BaseFormatter } from './base-formatter.js';
-export class IssueFormatter {
-    /**
-     * Format an issue response with the standard structure and optional expansions
-     * @param issue The issue data
-     * @param options Expansion options
-     * @param transitions Optional transitions data (if requested)
-     * @returns A formatted issue response
-     */
-    static formatIssue(issue, options = {}, transitions) {
-        // Create metadata with available expansions
-        const metadata = this.createIssueMetadata(issue, options, transitions);
-        // Create summary with status and suggested actions
-        const summary = this.createIssueSummary(issue, transitions);
-        return BaseFormatter.formatResponse(issue, metadata, summary);
-    }
-    /**
-     * Create metadata for an issue response
-     */
-    static createIssueMetadata(issue, options, transitions) {
-        // Determine which expansions are available but not included
-        const availableExpansions = [];
-        if (!options.comments && issue.comments === undefined) {
-            availableExpansions.push('comments');
-        }
-        if (!options.transitions && transitions === undefined) {
-            availableExpansions.push('transitions');
-        }
-        if (!options.attachments && issue.attachments === undefined) {
-            availableExpansions.push('attachments');
-        }
-        if (!options.related_issues) {
-            availableExpansions.push('related_issues');
-        }
-        if (!options.history) {
-            availableExpansions.push('history');
-        }
-        // Create related entities map
-        const related = {};
-        if (issue.parent) {
-            related.parent = issue.parent;
-        }
-        // Extract related issues from issue links
-        const relatedIssues = issue.issueLinks
-            .map(link => link.outward || link.inward)
-            .filter((key) => key !== null);
-        if (relatedIssues.length > 0) {
-            related.linked_issues = relatedIssues;
-        }
-        return BaseFormatter.createMetadata({
-            expansions: availableExpansions,
-            related
-        });
-    }
-    /**
-     * Create a summary for an issue response
-     */
-    static createIssueSummary(issue, transitions) {
-        const suggestedActions = [];
-        // Add suggested actions based on available transitions
-        if (transitions && transitions.length > 0) {
-            // Common transitions to suggest
-            const commonTransitions = ['Done', 'In Progress', 'To Do', 'Closed', 'Resolved'];
-            for (const transitionName of commonTransitions) {
-                const transition = transitions.find(t => t.name === transitionName);
-                if (transition) {
-                    suggestedActions.push({
-                        text: `Move to ${transitionName}`,
-                        action_id: transition.id
-                    });
-                }
-            }
-        }
-        // Add assignment suggestion if not assigned
-        if (!issue.assignee) {
-            suggestedActions.push({
-                text: 'Assign to team member'
-            });
-        }
-        return BaseFormatter.createSummary({
-            suggested_actions: suggestedActions
-        });
-    }
-}

package/build/utils/formatters/project-formatter.js

@@ -1,55 +0,0 @@
-import { BaseFormatter } from './base-formatter.js';
-export class ProjectFormatter {
-    /**
-     * Format a project response with the standard structure and optional expansions
-     * @param project The project data
-     * @param options Expansion options
-     * @returns A formatted project response
-     */
-    static formatProject(project, options = {}) {
-        // Create metadata with available expansions
-        const metadata = this.createProjectMetadata(project, options);
-        // Create summary with status counts
-        const summary = this.createProjectSummary(project);
-        return BaseFormatter.formatResponse(project, metadata, summary);
-    }
-    /**
-     * Create metadata for a project response
-     */
-    static createProjectMetadata(project, options) {
-        // Determine which expansions are available but not included
-        const availableExpansions = [];
-        if (!options.boards) {
-            availableExpansions.push('boards');
-        }
-        if (!options.components) {
-            availableExpansions.push('components');
-        }
-        if (!options.versions) {
-            availableExpansions.push('versions');
-        }
-        if (!options.recent_issues) {
-            availableExpansions.push('recent_issues');
-        }
-        return BaseFormatter.createMetadata({
-            expansions: availableExpansions
-        });
-    }
-    /**
-     * Create a summary for a project response
-     */
-    static createProjectSummary(project) {
-        const suggestedActions = [
-            {
-                text: `View all issues in ${project.key}`
-            },
-            {
-                text: `Create issue in ${project.key}`
-            }
-        ];
-        return BaseFormatter.createSummary({
-            status_counts: project.status_counts,
-            suggested_actions: suggestedActions
-        });
-    }
-}

package/build/utils/formatters/search-formatter.js

@@ -1,62 +0,0 @@
-import { BaseFormatter } from './base-formatter.js';
-export class SearchFormatter {
-    /**
-     * Format a search response with the standard structure and optional expansions
-     * @param searchResult The search result data
-     * @param options Expansion options
-     * @returns A formatted search response
-     */
-    static formatSearchResult(searchResult, options = {}) {
-        // Create metadata with available expansions and pagination
-        const metadata = this.createSearchMetadata(searchResult, options);
-        // Create summary with status counts
-        const summary = this.createSearchSummary(searchResult);
-        return BaseFormatter.formatResponse(searchResult, metadata, summary);
-    }
-    /**
-     * Create metadata for a search response
-     */
-    static createSearchMetadata(searchResult, options) {
-        // Determine which expansions are available but not included
-        const availableExpansions = [];
-        if (!options.issue_details) {
-            availableExpansions.push('issue_details');
-        }
-        if (!options.transitions) {
-            availableExpansions.push('transitions');
-        }
-        if (!options.comments_preview) {
-            availableExpansions.push('comments_preview');
-        }
-        return BaseFormatter.createMetadata({
-            expansions: availableExpansions,
-            pagination: {
-                startAt: searchResult.pagination.startAt,
-                maxResults: searchResult.pagination.maxResults,
-                total: searchResult.pagination.total
-            }
-        });
-    }
-    /**
-     * Create a summary for a search response
-     */
-    static createSearchSummary(searchResult) {
-        // Count issues by status
-        const statusCounts = {};
-        for (const issue of searchResult.issues) {
-            const status = issue.status;
-            statusCounts[status] = (statusCounts[status] || 0) + 1;
-        }
-        const suggestedActions = [];
-        // Add pagination actions if there are more results
-        if (searchResult.pagination.hasMore) {
-            suggestedActions.push({
-                text: 'Load more results'
-            });
-        }
-        return BaseFormatter.createSummary({
-            status_counts: statusCounts,
-            suggested_actions: suggestedActions
-        });
-    }
-}

package/build/utils/formatters/sprint-formatter.js

@@ -1,111 +0,0 @@
-import { BaseFormatter } from './base-formatter.js';
-export class SprintFormatter {
-    /**
-     * Format a sprint response with the standard structure and optional expansions
-     * @param sprint The sprint data
-     * @param options Expansion options
-     * @returns A formatted sprint response
-     */
-    static formatSprint(sprint, options = {}) {
-        // Create metadata with available expansions
-        const metadata = this.createSprintMetadata(sprint, options);
-        // Create summary
-        const summary = this.createSprintSummary(sprint);
-        return BaseFormatter.formatResponse(sprint, metadata, summary);
-    }
-    /**
-     * Format a list of sprints
-     * @param sprints Array of sprint data
-     * @param pagination Pagination information
-     * @returns A formatted response with sprints array
-     */
-    static formatSprintList(sprints, pagination) {
-        // Create metadata
-        const metadata = {};
-        if (pagination) {
-            metadata.pagination = {
-                startAt: pagination.startAt,
-                maxResults: pagination.maxResults,
-                total: pagination.total,
-                hasMore: pagination.startAt + pagination.maxResults < pagination.total,
-            };
-        }
-        // Create summary with status counts
-        const statusCounts = {
-            future: 0,
-            active: 0,
-            closed: 0,
-        };
-        sprints.forEach(sprint => {
-            if (sprint.state && statusCounts[sprint.state] !== undefined) {
-                statusCounts[sprint.state]++;
-            }
-        });
-        const summary = {
-            status_counts: statusCounts,
-            suggested_actions: [
-                { text: 'Create new sprint', action_id: 'create_sprint' },
-            ],
-        };
-        return BaseFormatter.formatResponse(sprints, metadata, summary);
-    }
-    /**
-     * Create metadata for a sprint response
-     */
-    static createSprintMetadata(sprint, options) {
-        // Determine which expansions are available but not included
-        const availableExpansions = [];
-        if (!options.issues && !sprint.issues) {
-            availableExpansions.push('issues');
-        }
-        if (!options.report && !sprint.report) {
-            availableExpansions.push('report');
-        }
-        // Create related entities map
-        const related = {
-            board: sprint.boardId.toString(),
-        };
-        return BaseFormatter.createMetadata({
-            expansions: availableExpansions,
-            related
-        });
-    }
-    /**
-     * Create a summary for a sprint response
-     */
-    static createSprintSummary(sprint) {
-        const suggestedActions = [];
-        // Add suggested actions based on sprint state
-        switch (sprint.state) {
-            case 'future':
-                suggestedActions.push({ text: 'Start Sprint', action_id: 'start_sprint' });
-                suggestedActions.push({ text: 'Add Issues to Sprint', action_id: 'add_issues' });
-                suggestedActions.push({ text: 'Edit Sprint', action_id: 'update_sprint' });
-                break;
-            case 'active':
-                suggestedActions.push({ text: 'Complete Sprint', action_id: 'complete_sprint' });
-                suggestedActions.push({ text: 'Add Issues to Sprint', action_id: 'add_issues' });
-                suggestedActions.push({ text: 'Remove Issues from Sprint', action_id: 'remove_issues' });
-                suggestedActions.push({ text: 'Edit Sprint', action_id: 'update_sprint' });
-                break;
-            case 'closed':
-                suggestedActions.push({ text: 'View Sprint Report', action_id: 'view_report' });
-                suggestedActions.push({ text: 'Create New Sprint', action_id: 'create_sprint' });
-                break;
-        }
-        // Add status counts if issues are available
-        const statusCounts = {};
-        if (sprint.issues && sprint.issues.length > 0) {
-            sprint.issues.forEach(issue => {
-                if (!statusCounts[issue.status]) {
-                    statusCounts[issue.status] = 0;
-                }
-                statusCounts[issue.status]++;
-            });
-        }
-        return BaseFormatter.createSummary({
-            status_counts: Object.keys(statusCounts).length > 0 ? statusCounts : undefined,
-            suggested_actions: suggestedActions
-        });
-    }
-}