@dpesch/mantisbt-mcp-server 1.5.8 → 1.6.0

package/dist/resources/index.js

@@ -0,0 +1,29 @@
+import { fetchIssueEnums } from '../tools/config.js';
+function jsonResource(uri, data) {
+    return {
+        contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(data, null, 2) }],
+    };
+}
+export function registerResources(server, client, cache) {
+    server.registerResource('current-user', 'mantis://me', {
+        title: 'Current User',
+        description: 'Profile of the user associated with the configured API key.',
+        mimeType: 'application/json',
+    }, async (uri) => jsonResource(uri, await client.get('users/me')));
+    server.registerResource('projects', 'mantis://projects', {
+        title: 'Projects',
+        description: 'All MantisBT projects accessible to the current API user. Served from local cache when fresh; falls back to live fetch. Refresh via the sync_metadata tool.',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const cached = await cache.loadIfValid();
+        const projects = cached?.projects
+            ?? (await client.get('projects')).projects
+            ?? [];
+        return jsonResource(uri, projects);
+    });
+    server.registerResource('issue-enums', 'mantis://enums', {
+        title: 'Issue Enums',
+        description: 'Valid values for issue enum fields: severity, priority, status, resolution, and reproducibility. Use these to look up IDs or names before creating or updating issues.',
+        mimeType: 'application/json',
+    }, async (uri) => jsonResource(uri, await fetchIssueEnums(client)));
+}

package/dist/tools/config.js

@@ -25,6 +25,49 @@ function resolveCanonicalName(id, name, canonicalMap) {
     const canonical = canonicalMap[id];
     return canonical !== undefined && canonical !== name ? canonical : undefined;
 }
+export async function fetchIssueEnums(client) {
+    const params = {};
+    ISSUE_ENUM_OPTIONS.forEach((opt, i) => {
+        params[`option[${i}]`] = opt;
+    });
+    const result = await client.get('config', params);
+    const configs = result.configs ?? [];
+    const keyMap = {
+        severity_enum_string: 'severity',
+        status_enum_string: 'status',
+        priority_enum_string: 'priority',
+        resolution_enum_string: 'resolution',
+        reproducibility_enum_string: 'reproducibility',
+    };
+    const enums = {};
+    for (const { option, value } of configs) {
+        const key = keyMap[option];
+        if (!key)
+            continue;
+        const canonicalMap = MANTIS_CANONICAL_ENUM_NAMES[key] ?? {};
+        if (typeof value === 'string') {
+            enums[key] = parseEnumString(value).map(({ id, name }) => {
+                const entry = { id, name };
+                const canonical_name = resolveCanonicalName(id, name, canonicalMap);
+                if (canonical_name !== undefined)
+                    entry.canonical_name = canonical_name;
+                return entry;
+            });
+        }
+        else if (Array.isArray(value)) {
+            enums[key] = value.map(({ id, name, label }) => {
+                const entry = { id, name };
+                if (label && label !== name)
+                    entry.label = label;
+                const canonical_name = resolveCanonicalName(id, name, canonicalMap);
+                if (canonical_name !== undefined)
+                    entry.canonical_name = canonical_name;
+                return entry;
+            });
+        }
+    }
+    return enums;
+}
 export function registerConfigTools(server, client, cache) {
     // ---------------------------------------------------------------------------
     // get_config
@@ -116,46 +159,7 @@ to use for API calls — regardless of language.`,
         },
     }, async () => {
         try {
-            const params = {};
-            ISSUE_ENUM_OPTIONS.forEach((opt, i) => {
-                params[`option[${i}]`] = opt;
-            });
-            const result = await client.get('config', params);
-            const configs = result.configs ?? [];
-            const keyMap = {
-                severity_enum_string: 'severity',
-                status_enum_string: 'status',
-                priority_enum_string: 'priority',
-                resolution_enum_string: 'resolution',
-                reproducibility_enum_string: 'reproducibility',
-            };
-            const enums = {};
-            for (const { option, value } of configs) {
-                const key = keyMap[option];
-                if (!key)
-                    continue;
-                const canonicalMap = MANTIS_CANONICAL_ENUM_NAMES[key] ?? {};
-                if (typeof value === 'string') {
-                    enums[key] = parseEnumString(value).map(({ id, name }) => {
-                        const entry = { id, name };
-                        const canonical_name = resolveCanonicalName(id, name, canonicalMap);
-                        if (canonical_name !== undefined)
-                            entry.canonical_name = canonical_name;
-                        return entry;
-                    });
-                }
-                else if (Array.isArray(value)) {
-                    enums[key] = value.map(({ id, name, label }) => {
-                        const entry = { id, name };
-                        if (label && label !== name)
-                            entry.label = label;
-                        const canonical_name = resolveCanonicalName(id, name, canonicalMap);
-                        if (canonical_name !== undefined)
-                            entry.canonical_name = canonical_name;
-                        return entry;
-                    });
-                }
-            }
+            const enums = await fetchIssueEnums(client);
             return {
                 content: [{ type: 'text', text: JSON.stringify(enums, null, 2) }],
             };

package/dist/tools/issues.js

@@ -1,12 +1,21 @@
 import { z } from 'zod';
 import { getVersionHint } from '../version-hint.js';
-import { MANTIS_RESOLVED_STATUS_ID } from '../constants.js';
+import { MANTIS_CANONICAL_ENUM_NAMES, MANTIS_RESOLVED_STATUS_ID, resolveEnumId } from '../constants.js';
 function errorText(msg) {
     const vh = getVersionHint();
     vh?.triggerLatestVersionFetch();
     const hint = vh?.getUpdateHint();
     return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
 }
+// Resolves a canonical enum name to { id } or returns an error string.
+function resolveEnum(group, value) {
+    const id = resolveEnumId(group, value);
+    if (id === undefined) {
+        const valid = Object.values(MANTIS_CANONICAL_ENUM_NAMES[group]).join(', ');
+        return `Invalid ${group} "${value}". Valid canonical names: ${valid}. Call get_issue_enums to see localized labels.`;
+    }
+    return { id };
+}
 export function registerIssueTools(server, client, cache) {
     // ---------------------------------------------------------------------------
     // get_issue
@@ -138,8 +147,8 @@ export function registerIssueTools(server, client, cache) {
             description: z.string().default('').describe('Detailed issue description'),
             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 (e.g. "normal", "high", "urgent", "immediate", "low", "none")'),
-            severity: z.string().default('minor').describe('Severity name (e.g. "minor", "major", "crash", "block", "feature", "trivial", "text") — default: "minor"'),
+            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.'),
+            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.'),
         }),
@@ -180,9 +189,16 @@ export function registerIssueTools(server, client, cache) {
                 project: { id: project_id },
                 category: { name: category },
             };
-            if (priority)
-                body.priority = { name: priority };
-            body.severity = { name: severity };
+            if (priority) {
+                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 };
             const raw = await client.post('issues', body);