@aaronsb/jira-cloud-mcp 0.5.8 → 0.5.9

package/build/client/jira-client.js

@@ -1003,6 +1003,52 @@ export class JiraClient {
         const response = await this.client.issues.createIssue({ fields });
         return { key: response.key };
     }
+    async createFilter(name, jql, description, favourite) {
+        const result = await this.client.filters.createFilter({
+            name,
+            jql,
+            description: description || '',
+            favourite: favourite ?? false,
+        });
+        if (!result.id || !result.name) {
+            throw new Error('Invalid filter response from Jira');
+        }
+        return {
+            id: result.id,
+            name: result.name,
+            owner: result.owner?.displayName || 'Unknown',
+            favourite: result.favourite || false,
+            viewUrl: result.viewUrl || '',
+            description: result.description || '',
+            jql: result.jql || '',
+        };
+    }
+    async updateFilter(filterId, updates) {
+        // Fetch existing filter to merge with updates (API requires name)
+        const existing = await this.client.filters.getFilter({ id: parseInt(filterId, 10) });
+        const result = await this.client.filters.updateFilter({
+            id: parseInt(filterId, 10),
+            name: updates.name || existing.name || '',
+            jql: updates.jql ?? existing.jql,
+            description: updates.description ?? existing.description,
+            favourite: updates.favourite ?? existing.favourite,
+        });
+        if (!result.id || !result.name) {
+            throw new Error('Invalid filter response from Jira');
+        }
+        return {
+            id: result.id,
+            name: result.name,
+            owner: result.owner?.displayName || 'Unknown',
+            favourite: result.favourite || false,
+            viewUrl: result.viewUrl || '',
+            description: result.description || '',
+            jql: result.jql || '',
+        };
+    }
+    async deleteFilter(filterId) {
+        await this.client.filters.deleteFilter(filterId);
+    }
     async listMyFilters(expand = false) {
         const filters = await this.client.filters.getMyFilters();
         return Promise.all(filters.map(async (filter) => {

package/build/handlers/filter-handlers.js

@@ -207,14 +207,62 @@ async function handleListFilters(jiraClient, args) {
         ],
     };
 }
-async function handleCreateFilter(_jiraClient, _args) {
-    throw new McpError(ErrorCode.InternalError, 'Create filter operation is not yet implemented');
+async function handleCreateFilter(jiraClient, args) {
+    if (!args.name) {
+        throw new McpError(ErrorCode.InvalidParams, 'name is required for create operation');
+    }
+    if (!args.jql) {
+        throw new McpError(ErrorCode.InvalidParams, 'jql is required for create operation');
+    }
+    const filter = await jiraClient.createFilter(args.name, args.jql, args.description, args.favourite);
+    const lines = [
+        `# Filter Created: ${filter.name}`,
+        '',
+        `**ID:** ${filter.id}`,
+        `**JQL:** \`${filter.jql}\``,
+        `**Owner:** ${filter.owner}`,
+        filter.description ? `**Description:** ${filter.description}` : '',
+        `**Favourite:** ${filter.favourite ? 'Yes' : 'No'}`,
+        '',
+        `[View in Jira](${filter.viewUrl})`,
+    ].filter(Boolean);
+    return {
+        content: [{ type: 'text', text: lines.join('\n') + filterNextSteps('create', filter.id) }],
+    };
 }
-async function handleUpdateFilter(_jiraClient, _args) {
-    throw new McpError(ErrorCode.InternalError, 'Update filter operation is not yet implemented');
+async function handleUpdateFilter(jiraClient, args) {
+    if (!args.filterId) {
+        throw new McpError(ErrorCode.InvalidParams, 'filterId is required for update operation');
+    }
+    const updates = {};
+    if (args.name)
+        updates.name = args.name;
+    if (args.jql)
+        updates.jql = args.jql;
+    if (args.description !== undefined)
+        updates.description = args.description;
+    if (args.favourite !== undefined)
+        updates.favourite = args.favourite;
+    const filter = await jiraClient.updateFilter(args.filterId, updates);
+    const lines = [
+        `# Filter Updated: ${filter.name}`,
+        '',
+        `**ID:** ${filter.id}`,
+        `**JQL:** \`${filter.jql}\``,
+        `**Owner:** ${filter.owner}`,
+    ];
+    return {
+        content: [{ type: 'text', text: lines.join('\n') + filterNextSteps('get', filter.id) }],
+    };
 }
-async function handleDeleteFilter(_jiraClient, _args) {
-    throw new McpError(ErrorCode.InternalError, 'Delete filter operation is not yet implemented');
+async function handleDeleteFilter(jiraClient, args) {
+    if (!args.filterId) {
+        throw new McpError(ErrorCode.InvalidParams, 'filterId is required for delete operation');
+    }
+    await jiraClient.deleteFilter(args.filterId);
+    return {
+        content: [{ type: 'text', text: `Filter ${args.filterId} deleted.` }],
+    };
 }
 async function handleExecuteFilter(jiraClient, _args) {
     const filterId = _args.filterId;

package/build/index.js

@@ -95,6 +95,9 @@ class JiraServer {
             const { name, arguments: args } = request.params;
             return getPrompt(name, args);
         });
+        // Track consecutive single-issue calls to suggest queue tool
+        const QUEUE_HINT_THRESHOLD = 3;
+        let consecutiveIssueCalls = 0;
         // Set up tool handlers
         this.server.setRequestHandler(CallToolRequestSchema, async (request, _extra) => {
             console.error('Received request:', JSON.stringify(request, null, 2));
@@ -121,6 +124,17 @@ class JiraServer {
                 if (!response) {
                     throw new McpError(ErrorCode.InternalError, `No response from handler for tool: ${name}`);
                 }
+                // Track consecutive manage_jira_issue calls and suggest queue tool
+                if (name === 'manage_jira_issue') {
+                    consecutiveIssueCalls++;
+                    if (consecutiveIssueCalls >= QUEUE_HINT_THRESHOLD && response.content?.[0]?.text) {
+                        response.content[0].text += `\n\n---\n**💡 Efficiency tip:** You've made ${consecutiveIssueCalls} consecutive \`manage_jira_issue\` calls. Consider using \`queue_jira_operations\` to batch multiple issue operations into a single call — it's faster and uses less context.`;
+                        consecutiveIssueCalls = 0;
+                    }
+                }
+                else {
+                    consecutiveIssueCalls = 0;
+                }
                 return response;
             }
             catch (error) {

package/package.json

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