@dpesch/mantisbt-mcp-server 1.6.1 → 1.7.0

package/CHANGELOG.md

@@ -7,6 +7,24 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [1.7.0] – 2026-03-26
+
+### Added
+- `create_issue`: new optional parameters `version`, `target_version`, `fixed_in_version`, `steps_to_reproduce`, `additional_information`, `reproducibility`, and `view_state` — these fields were already supported by the MantisBT REST API on issue creation but were missing from the tool, requiring a second `update_issue` call to set them.
+
+---
+
+## [1.6.2] – 2026-03-24
+
+### Fixed
+- `create_issue`: default priority is now `"normal"`, matching the MantisBT UI default. Previously no priority was sent when omitted, causing MantisBT to fall back to its server-side default of `"low"`.
+- `create_issue`: `description` is now a required field (minimum 1 character). Previously it defaulted to an empty string, which caused the MantisBT API to reject the request. The validation error is now surfaced immediately by the MCP server before the API is called.
+
+### Changed
+- npm keywords extended: added `issue-tracker`, `bug-tracker`, `claude`, `claude-code` for better discoverability.
+
+---
+
 ## [1.6.1] – 2026-03-24
 
 ### Changed

package/dist/tools/issues.js

@@ -144,20 +144,27 @@ export function registerIssueTools(server, client, cache) {
         description: 'Create a new MantisBT issue. Returns the created issue including its assigned ID.',
         inputSchema: z.object({
             summary: z.string().min(1).describe('Issue summary/title'),
-            description: z.string().default('').describe('Detailed issue description'),
+            description: z.string().min(1).describe('Detailed issue description. Required — do not create issues without a description. Plain text or Markdown.'),
             project_id: z.coerce.number().int().positive().describe('Project ID the issue belongs to'),
             category: z.string().min(1).describe('Category name (use get_project_categories to list available categories)'),
-            priority: z.string().optional().describe('Priority name — must be a canonical English name: none, low, normal, high, urgent, immediate. Call get_issue_enums to see localized labels.'),
+            priority: z.string().default('normal').describe('Priority name — must be a canonical English name: none, low, normal, high, urgent, immediate. Default: "normal". Call get_issue_enums to see localized labels.'),
             severity: z.string().default('minor').describe('Severity name — must be a canonical English name: feature, trivial, text, tweak, minor, major, crash, block. Default: "minor". Call get_issue_enums to see localized labels.'),
             handler_id: z.coerce.number().int().positive().optional().describe('User ID of the person to assign the issue to'),
             handler: z.string().optional().describe('Username (login name) of the person to assign the issue to. Alternative to handler_id — the server resolves the name to a user ID from the project members. Use get_project_users to see available users.'),
+            version: z.string().optional().describe('Affected product version name (use get_project_versions to list available versions)'),
+            target_version: z.string().optional().describe('Target version name — version in which the issue is planned to be fixed (use get_project_versions to list available versions)'),
+            fixed_in_version: z.string().optional().describe('Version name in which the issue was fixed (use get_project_versions to list available versions)'),
+            steps_to_reproduce: z.string().optional().describe('Steps to reproduce the issue. Plain text or Markdown.'),
+            additional_information: z.string().optional().describe('Additional information about the issue. Plain text or Markdown.'),
+            reproducibility: z.string().optional().describe('Reproducibility — must be a canonical English name: always, sometimes, random, have not tried, unable to reproduce, N/A. Call get_issue_enums to see localized labels.'),
+            view_state: z.enum(['public', 'private']).optional().describe('Visibility of the issue: "public" (default) or "private"'),
         }),
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
             idempotentHint: false,
         },
-    }, async ({ summary, description, project_id, category, priority, severity, handler_id, handler }) => {
+    }, async ({ summary, description, project_id, category, priority, severity, handler_id, handler, version, target_version, fixed_in_version, steps_to_reproduce, additional_information, reproducibility, view_state }) => {
         // Resolve handler username to handler_id when only a name is given
         let resolvedHandlerId = handler_id;
         if (resolvedHandlerId === undefined && handler !== undefined) {
@@ -189,18 +196,34 @@ export function registerIssueTools(server, client, cache) {
                 project: { id: project_id },
                 category: { name: category },
             };
-            if (priority) {
-                const priorityResolved = resolveEnum('priority', priority);
-                if (typeof priorityResolved === 'string')
-                    return { content: [{ type: 'text', text: errorText(priorityResolved) }], isError: true };
-                body.priority = priorityResolved;
-            }
+            const priorityResolved = resolveEnum('priority', priority);
+            if (typeof priorityResolved === 'string')
+                return { content: [{ type: 'text', text: errorText(priorityResolved) }], isError: true };
+            body.priority = priorityResolved;
             const severityResolved = resolveEnum('severity', severity);
             if (typeof severityResolved === 'string')
                 return { content: [{ type: 'text', text: errorText(severityResolved) }], isError: true };
             body.severity = severityResolved;
             if (resolvedHandlerId)
                 body.handler = { id: resolvedHandlerId };
+            if (version !== undefined)
+                body.version = { name: version };
+            if (target_version !== undefined)
+                body.target_version = { name: target_version };
+            if (fixed_in_version !== undefined)
+                body.fixed_in_version = { name: fixed_in_version };
+            if (steps_to_reproduce !== undefined)
+                body.steps_to_reproduce = steps_to_reproduce;
+            if (additional_information !== undefined)
+                body.additional_information = additional_information;
+            if (reproducibility !== undefined) {
+                const reproducibilityResolved = resolveEnum('reproducibility', reproducibility);
+                if (typeof reproducibilityResolved === 'string')
+                    return { content: [{ type: 'text', text: errorText(reproducibilityResolved) }], isError: true };
+                body.reproducibility = reproducibilityResolved;
+            }
+            if (view_state !== undefined)
+                body.view_state = { name: view_state };
             const raw = await client.post('issues', body);
             const partial = ('issue' in raw && typeof raw['issue'] === 'object' && raw['issue'] !== null)
                 ? raw['issue']

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dpesch/mantisbt-mcp-server",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "mcpName": "io.github.dpesch/mantisbt-mcp-server",
   "description": "MCP server for MantisBT REST API – read and manage bug tracker issues",
   "author": "Dominik Pesch",
@@ -14,7 +14,7 @@
     "url": "https://github.com/dpesch/mantisbt-mcp-server",
     "_note": "GitHub mirror for ecosystem compatibility only — canonical source: https://codeberg.org/dpesch/mantisbt-mcp-server"
   },
-  "keywords": ["mcp", "mcp-server", "mantisbt", "bugtracker", "mantis", "model-context-protocol"],
+  "keywords": ["mcp", "mcp-server", "mantisbt", "bugtracker", "mantis", "issue-tracker", "bug-tracker", "model-context-protocol", "claude", "claude-code"],
   "main": "dist/index.js",
   "bin": {
     "mantisbt-mcp-server": "dist/index.js"

package/scripts/hooks/pre-push.mjs

@@ -166,9 +166,17 @@ rl.on('close', () => {
           shaMap[sha] = makeFilteredCommit(sha, filteredTree, mappedParents);
         }
       } else {
-        // Fallback: anchor not found — filter tip only, rooted at remote tip.
+        // Fallback: anchor not found.
+        // If the remote SHA doesn't exist locally (filtered commit from a prior push),
+        // tags can be safely skipped (immutable — already correct on Codeberg).
+        // Branches fall back to orphan filtering (best effort).
+        const remoteExists = !!gitOptional(`rev-parse --verify "${actualRemoteSha}"`);
+        if (!remoteExists && remoteRef.startsWith('refs/tags/')) {
+          console.log(`  ↷ ${label} already on Codeberg — skipping`);
+          continue;
+        }
         console.warn(`  ⚠ Could not find local base for ${label}, filtering tip only`);
-        shaMap[localSha] = makeFilteredCommit(localSha, filterTree(localSha), [actualRemoteSha]);
+        shaMap[localSha] = makeFilteredCommit(localSha, filterTree(localSha), remoteExists ? [actualRemoteSha] : []);
       }
     }
 

package/server.json

@@ -3,12 +3,12 @@
   "name": "io.github.dpesch/mantisbt-mcp-server",
   "title": "MantisBT MCP Server",
   "description": "MantisBT MCP server – manage issues, notes, files, tags, and relationships. With semantic search.",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@dpesch/mantisbt-mcp-server",
-      "version": "1.6.1",
+      "version": "1.7.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"

package/tests/tools/issues.test.ts

@@ -123,6 +123,7 @@ describe('create_issue', () => {
 
     await mockServer.callTool('create_issue', {
       summary: 'Test issue',
+      description: 'Test description.',
       project_id: 1,
       category: 'General',
     }, { validate: true });
@@ -138,7 +139,7 @@ describe('create_issue', () => {
     );
 
     const result = await mockServer.callTool('create_issue', {
-      summary: 'New issue', project_id: 1, category: 'General',
+      summary: 'New issue', description: 'New issue description.', project_id: 1, category: 'General',
     }, { validate: true });
 
     expect(result.isError).toBeUndefined();
@@ -156,7 +157,7 @@ describe('create_issue', () => {
       .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [fullIssue] })));
 
     const result = await mockServer.callTool('create_issue', {
-      summary: 'Created issue', project_id: 1, category: 'General',
+      summary: 'Created issue', description: 'Created issue description.', project_id: 1, category: 'General',
     }, { validate: true });
 
     expect(result.isError).toBeUndefined();
@@ -174,7 +175,7 @@ describe('create_issue', () => {
       .mockResolvedValueOnce(makeResponse(500, 'Server Error'));
 
     const result = await mockServer.callTool('create_issue', {
-      summary: 'Test', project_id: 1, category: 'General',
+      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General',
     }, { validate: true });
 
     expect(result.isError).toBeUndefined();
@@ -189,6 +190,7 @@ describe('create_issue', () => {
 
     await mockServer.callTool('create_issue', {
       summary: 'Crash bug',
+      description: 'Crash bug description.',
       project_id: 1,
       category: 'General',
       severity: 'crash',
@@ -198,9 +200,33 @@ describe('create_issue', () => {
     expect(body.severity).toEqual({ id: 70 });
   });
 
+  it('returns a validation error when description is missing', async () => {
+    const result = await mockServer.callTool('create_issue', {
+      summary: 'Test',
+      project_id: 1,
+      category: 'General',
+    }, { validate: true });
+
+    expect(result.isError).toBe(true);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('returns a validation error when description is empty', async () => {
+    const result = await mockServer.callTool('create_issue', {
+      summary: 'Test',
+      description: '',
+      project_id: 1,
+      category: 'General',
+    }, { validate: true });
+
+    expect(result.isError).toBe(true);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
   it('returns an error for an unknown severity name', async () => {
     const result = await mockServer.callTool('create_issue', {
       summary: 'Test',
+      description: 'Test description.',
       project_id: 1,
       category: 'General',
       severity: 'schwerer Fehler',
@@ -211,6 +237,174 @@ describe('create_issue', () => {
     expect(result.content[0]!.text).toContain('minor');
     expect(fetch).not.toHaveBeenCalled();
   });
+
+  it('creates issue without any optional fields (backward compatibility)', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(201, JSON.stringify({ issue: { id: 300, summary: 'Minimal' } }))
+    );
+
+    const result = await mockServer.callTool('create_issue', {
+      summary: 'Minimal issue',
+      description: 'Minimal description.',
+      project_id: 1,
+      category: 'General',
+    }, { validate: true });
+
+    expect(result.isError).toBeUndefined();
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.version).toBeUndefined();
+    expect(body.target_version).toBeUndefined();
+    expect(body.fixed_in_version).toBeUndefined();
+    expect(body.steps_to_reproduce).toBeUndefined();
+    expect(body.additional_information).toBeUndefined();
+    expect(body.reproducibility).toBeUndefined();
+    expect(body.view_state).toBeUndefined();
+  });
+
+  it('sends version fields as { name } objects', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(201, JSON.stringify({ issue: { id: 301, summary: 'With versions' } }))
+    );
+
+    await mockServer.callTool('create_issue', {
+      summary: 'Version test',
+      description: 'Version test description.',
+      project_id: 1,
+      category: 'General',
+      version: '1.0.0',
+      target_version: '1.1.0',
+      fixed_in_version: '1.0.1',
+    }, { validate: true });
+
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.version).toEqual({ name: '1.0.0' });
+    expect(body.target_version).toEqual({ name: '1.1.0' });
+    expect(body.fixed_in_version).toEqual({ name: '1.0.1' });
+  });
+
+  it('sends steps_to_reproduce and additional_information as plain strings', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(201, JSON.stringify({ issue: { id: 302, summary: 'With text fields' } }))
+    );
+
+    await mockServer.callTool('create_issue', {
+      summary: 'Text fields test',
+      description: 'Description.',
+      project_id: 1,
+      category: 'General',
+      steps_to_reproduce: '1. Open app\n2. Click button',
+      additional_information: 'Happens only on Windows',
+    }, { validate: true });
+
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.steps_to_reproduce).toBe('1. Open app\n2. Click button');
+    expect(body.additional_information).toBe('Happens only on Windows');
+  });
+
+  it('resolves reproducibility to { id } via enum lookup', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(201, JSON.stringify({ issue: { id: 303, summary: 'Reproducibility test' } }))
+    );
+
+    await mockServer.callTool('create_issue', {
+      summary: 'Repro test',
+      description: 'Description.',
+      project_id: 1,
+      category: 'General',
+      reproducibility: 'always',
+    }, { validate: true });
+
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.reproducibility).toEqual({ id: 10 });
+  });
+
+  it('returns error for unknown reproducibility name', async () => {
+    const result = await mockServer.callTool('create_issue', {
+      summary: 'Repro test',
+      description: 'Description.',
+      project_id: 1,
+      category: 'General',
+      reproducibility: 'immer',
+    }, { validate: true });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0]!.text).toContain('immer');
+    expect(result.content[0]!.text).toContain('always');
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('returns error for empty reproducibility string', async () => {
+    const result = await mockServer.callTool('create_issue', {
+      summary: 'Repro test',
+      description: 'Description.',
+      project_id: 1,
+      category: 'General',
+      reproducibility: '',
+    }, { validate: true });
+
+    expect(result.isError).toBe(true);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('sends view_state as { name } object', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(201, JSON.stringify({ issue: { id: 304, summary: 'Private issue' } }))
+    );
+
+    await mockServer.callTool('create_issue', {
+      summary: 'Private issue',
+      description: 'Description.',
+      project_id: 1,
+      category: 'General',
+      view_state: 'private',
+    }, { validate: true });
+
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.view_state).toEqual({ name: 'private' });
+  });
+
+  it('rejects invalid view_state values', async () => {
+    const result = await mockServer.callTool('create_issue', {
+      summary: 'Test',
+      description: 'Description.',
+      project_id: 1,
+      category: 'General',
+      view_state: 'restricted',
+    }, { validate: true });
+
+    expect(result.isError).toBe(true);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('sends all new optional fields together in a single request', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(201, JSON.stringify({ issue: { id: 305, summary: 'Full issue' } }))
+    );
+
+    await mockServer.callTool('create_issue', {
+      summary: 'Full issue',
+      description: 'Full description.',
+      project_id: 1,
+      category: 'General',
+      version: '2.0.0',
+      target_version: '2.1.0',
+      fixed_in_version: '2.0.1',
+      steps_to_reproduce: 'Step 1',
+      additional_information: 'Extra info',
+      reproducibility: 'sometimes',
+      view_state: 'public',
+    }, { validate: true });
+
+    expect(fetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.version).toEqual({ name: '2.0.0' });
+    expect(body.target_version).toEqual({ name: '2.1.0' });
+    expect(body.fixed_in_version).toEqual({ name: '2.0.1' });
+    expect(body.steps_to_reproduce).toBe('Step 1');
+    expect(body.additional_information).toBe('Extra info');
+    expect(body.reproducibility).toEqual({ id: 30 });
+    expect(body.view_state).toEqual({ name: 'public' });
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -228,7 +422,7 @@ describe('create_issue – handler username', () => {
     );
 
     await server.callTool('create_issue', {
-      summary: 'Test', project_id: 1, category: 'General', handler: 'dom',
+      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General', handler: 'dom',
     }, { validate: true });
 
     const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
@@ -245,7 +439,7 @@ describe('create_issue – handler username', () => {
     );
 
     await server.callTool('create_issue', {
-      summary: 'Test', project_id: 1, category: 'General', handler: 'John Doe',
+      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General', handler: 'John Doe',
     }, { validate: true });
 
     const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
@@ -262,7 +456,7 @@ describe('create_issue – handler username', () => {
       .mockResolvedValueOnce(makeResponse(201, JSON.stringify({ issue: { id: 202, summary: 'New' } })));
 
     await server.callTool('create_issue', {
-      summary: 'Test', project_id: 1, category: 'General', handler: 'alice',
+      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General', handler: 'alice',
     }, { validate: true });
 
     const projectUsersCall = vi.mocked(fetch).mock.calls[0]![0] as string;
@@ -278,7 +472,7 @@ describe('create_issue – handler username', () => {
     registerIssueTools(server as never, client, cache);
 
     const result = await server.callTool('create_issue', {
-      summary: 'Test', project_id: 1, category: 'General', handler: 'nonexistent',
+      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General', handler: 'nonexistent',
     });
 
     expect(result.isError).toBe(true);
@@ -297,7 +491,7 @@ describe('create_issue – handler username', () => {
     );
 
     await server.callTool('create_issue', {
-      summary: 'Test', project_id: 1, category: 'General', handler_id: 99, handler: 'dom',
+      summary: 'Test', description: 'Test description.', project_id: 1, category: 'General', handler_id: 99, handler: 'dom',
     }, { validate: true });
 
     const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };