@dpesch/mantisbt-mcp-server 1.6.2 → 1.7.0

package/CHANGELOG.md

@@ -7,6 +7,13 @@ 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

package/dist/tools/issues.js

@@ -151,13 +151,20 @@ export function registerIssueTools(server, client, cache) {
             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) {
@@ -199,6 +206,24 @@ export function registerIssueTools(server, client, cache) {
             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.2",
+  "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",

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.2",
+  "version": "1.7.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@dpesch/mantisbt-mcp-server",
-      "version": "1.6.2",
+      "version": "1.7.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"

package/tests/tools/issues.test.ts

@@ -237,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' });
+  });
 });
 
 // ---------------------------------------------------------------------------