MantisBT MCP Server

Instructions

Implementation Reference

• src/tools/config.ts:152-213 (handler)

  The 'get_issue_enums' tool is registered here, using 'fetchIssueEnums' as its handler.

    server.registerTool(
      'get_issue_enums',
      {
        title: 'Get Issue Enum Values',
        description: `Return valid ID, name, and (if available) localized label for all issue enum fields.
  
  Use this tool before creating or updating issues to look up the correct value
  for severity, status, priority, resolution, or reproducibility.
  
  Example response (English installation):
  {
    "severity":         [{"id": 10, "name": "feature"}, {"id": 50, "name": "minor"}, ...],
    "status":           [{"id": 10, "name": "new"}, {"id": 20, "name": "feedback"}, ...],
    "priority":         [{"id": 10, "name": "none"}, {"id": 30, "name": "normal"}, ...],
    "resolution":       [{"id": 10, "name": "open"}, {"id": 20, "name": "fixed"}, ...],
    "reproducibility":  [{"id": 10, "name": "always"}, {"id": 70, "name": "have not tried"}, ...]
  }
  
  Example response (localized installation, e.g. German):
  {
    "status": [
      {"id": 10, "name": "new",      "label": "Neu"},
      {"id": 20, "name": "feedback", "label": "Feedback"},
      {"id": 30, "name": "acknowledged", "label": "Bestätigt"},
      ...
    ],
    ...
  }
  
  Fields:
  - "id"             — numeric ID accepted by the API
  - "name"           — localized or canonical name from the MantisBT database
  - "label"          — UI display label (only present when it differs from "name")
  - "canonical_name" — English canonical name (only present on localized installs)
  
  For create_issue (severity, priority, reproducibility): pass the canonical English name, the
  localized "name", or the "label" — all are accepted. The server resolves them to the correct ID.
  
  For update_issue: pass either "id" or "name" in the field reference object.
  
  Note: on some installations enum values are customized at the database level. In that case "name"
  itself may be localized (e.g. "kleinerer Fehler" instead of "minor") and no "label" will be present
  because there is no separate English original.`,
        inputSchema: z.object({}),
        annotations: {
          readOnlyHint: true,
          destructiveHint: false,
          idempotentHint: true,
        },
      },
      async () => {
        try {
          const enums = await fetchIssueEnums(client);
          return {
            content: [{ type: 'text', text: JSON.stringify(enums, null, 2) }],
          };
        } catch (error) {
          const msg = error instanceof Error ? error.message : String(error);
          return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
        }
      }
    );

• src/tools/config.ts:38-81 (handler)

  The actual implementation of 'fetchIssueEnums', which fetches and processes the enum values from the MantisBT API.

  export async function fetchIssueEnums(
    client: MantisClient,
  ): Promise<Record<string, MantisEnumEntry[]>> {
    const params: Record<string, string | number | boolean | undefined> = {};
    ISSUE_ENUM_OPTIONS.forEach((opt, i) => {
      params[`option[${i}]`] = opt;
    });
  
    const result = await client.get<{ configs: Array<{ option: string; value: string | EnumEntry[] }> }>('config', params);
    const configs = result.configs ?? [];
  
    const keyMap: Record<string, string> = {
      severity_enum_string: 'severity',
      status_enum_string: 'status',
      priority_enum_string: 'priority',
      resolution_enum_string: 'resolution',
      reproducibility_enum_string: 'reproducibility',
    };
  
    const enums: Record<string, MantisEnumEntry[]> = {};
    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: MantisEnumEntry = { 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: MantisEnumEntry = { 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;
  }