@dpesch/mantisbt-mcp-server 1.5.9 → 1.6.1

package/CHANGELOG.md

@@ -7,6 +7,37 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [1.6.1] – 2026-03-24
+
+### Changed
+- `repository.url` in package.json switched from Codeberg to GitHub mirror
+  for ecosystem compatibility (LobeHub, npm crawlers). Codeberg remains the
+  canonical source (see `homepage`).
+
+---
+
+## [1.6.0] – 2026-03-22
+
+### Added
+- Three MCP Resources for direct URI-addressable data access (read-only; less widely supported by clients than tools):
+  - `mantis://me` — profile of the authenticated API user (live fetch of `GET /users/me`)
+  - `mantis://projects` — all accessible MantisBT projects (cache-backed via MetadataCache; refresh with `sync_metadata`)
+  - `mantis://enums` — valid values for all issue enum fields (severity, priority, status, resolution, reproducibility); live fetch
+- Four MCP prompt templates for guided issue workflows:
+  - `create-bug-report` — structured bug report prompt; collects project, category, summary, description, steps to reproduce, expected/actual behavior, and environment, then calls `create_issue`
+  - `create-feature-request` — feature request prompt; collects project, category, summary, description, and use case, then calls `create_issue`
+  - `summarize-issue` — calls `get_issue` for a given issue ID and returns a concise summary
+  - `project-status` — calls `list_issues` for a given project and produces a status report grouped by severity
+- LobeHub marketplace badge added to README.md and README.de.md
+
+### Removed
+- Config file fallback (`~/.claude/mantis.json`): credentials must now be provided via environment variables (`MANTIS_BASE_URL`, `MANTIS_API_KEY`). The fallback was an internal migration aid with no value for external users.
+
+### Changed
+- Credential loading is now deferred to the first tool invocation. The server starts and responds to `tools/list` even when `MANTIS_BASE_URL` and `MANTIS_API_KEY` are not configured; the configuration error is surfaced when a tool is actually called. This enables marketplace validators (e.g. LobeHub) to probe the server without requiring credentials.
+
+---
+
 ## [1.5.9] – 2026-03-20
 
 ### Fixed

package/README.de.md

@@ -2,6 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/@dpesch/mantisbt-mcp-server)](https://www.npmjs.com/package/@dpesch/mantisbt-mcp-server)
 [![license](https://img.shields.io/npm/l/@dpesch/mantisbt-mcp-server)](LICENSE)
+[![MCP Badge](https://lobehub.com/badge/mcp/dpesch-mantisbt-mcp-server)](https://lobehub.com/mcp/dpesch-mantisbt-mcp-server)
 [![MantisBT MCP Server](https://glama.ai/mcp/servers/dpesch/mantisbt-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/dpesch/mantisbt-mcp-server)
 
 Ein [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) Server, der die [MantisBT REST API](https://documenter.getpostman.com/view/29959/mantis-bug-tracker-rest-api) in Claude Code und andere MCP-fähige Clients integriert. Issues lesen, erstellen und bearbeiten – direkt aus dem Editor heraus.
@@ -79,17 +80,6 @@ npm run build
 | `MANTIS_SEARCH_THREADS` | – | `1` | Anzahl der ONNX-Intra-Op-Threads für das Embedding-Modell. Standard ist 1, um CPU-Sättigung auf Mehrkernsystemen und in WSL zu verhindern. Nur erhöhen, wenn die Indexierungsgeschwindigkeit kritisch ist und der Host ausschließlich für diese Last vorgesehen ist. |
 | `MANTIS_UPLOAD_DIR` | – | – | Schränkt `upload_file` auf Dateien in diesem Verzeichnis ein. Wenn gesetzt, wird jeder `file_path` außerhalb des Verzeichnisses abgelehnt (Pfad-Traversal-Versuche via `../` werden blockiert). Ohne diese Variable gilt keine Einschränkung. |
 
-### Config-Datei (Fallback)
-
-Falls keine Umgebungsvariablen gesetzt sind, wird `~/.claude/mantis.json` ausgelesen:
-
-```json
-{
-  "base_url": "https://deine-mantis-instanz.example.com/api/rest",
-  "api_key": "dein-api-token"
-}
-```
-
 ## Verfügbare Tools
 
 ### Issues
@@ -197,6 +187,27 @@ npm install sqlite-vec better-sqlite3
 | `get_mantis_version` | MantisBT-Version abrufen und auf Updates prüfen |
 | `get_mcp_version` | Version dieser mantisbt-mcp-server-Instanz zurückgeben |
 
+## Verfügbare Ressourcen
+
+MCP-Ressourcen sind URI-adressierbare, schreibgeschützte Daten, die Clients direkt abrufen können, ohne ein Tool aufzurufen. Sie sind das dritte MCP-Primitiv neben Tools und Prompts. Hinweis: Ressourcen werden von MCP-Clients weniger breit unterstützt als Tools — bitte die Dokumentation des jeweiligen Clients prüfen.
+
+| Ressource-URI | Beschreibung |
+|---|---|
+| `mantis://me` | Profil des authentifizierten API-Benutzers (Live-Abruf) |
+| `mantis://projects` | Alle zugänglichen MantisBT-Projekte (Cache-basiert, Aktualisierung via `sync_metadata`) |
+| `mantis://enums` | Gültige Werte für alle Issue-Enum-Felder: Severity, Priority, Status, Resolution, Reproducibility (Live-Abruf) |
+
+## Verfügbare Prompts
+
+MCP-Prompt-Templates sind Gesprächseinstiege, die den LLM anweisen, strukturierte Eingaben zu sammeln und dann das passende Tool aufzurufen. Es handelt sich nicht um Tools — sie starten einen geführten Arbeitsablauf.
+
+| Prompt | Pflichtargumente | Optionale Argumente | Beschreibung |
+|---|---|---|---|
+| `create-bug-report` | `project_id`, `category`, `summary`, `description` | `steps_to_reproduce`, `expected`, `actual`, `environment` | Führt durch einen strukturierten Bug-Report und ruft `create_issue` auf |
+| `create-feature-request` | `project_id`, `category`, `summary`, `description` | `use_case` | Führt durch einen Feature-Request und ruft `create_issue` auf |
+| `summarize-issue` | `issue_id` | – | Ruft das Issue per `get_issue` ab und liefert eine prägnante Zusammenfassung |
+| `project-status` | `project_id` | – | Listet Issues per `list_issues` auf und erstellt einen Status-Report nach Schweregrad |
+
 ## HTTP-Modus
 
 Für den Einsatz als eigenständiger Server (z.B. in Remote-Setups):

package/README.md

@@ -2,6 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/@dpesch/mantisbt-mcp-server)](https://www.npmjs.com/package/@dpesch/mantisbt-mcp-server)
 [![license](https://img.shields.io/npm/l/@dpesch/mantisbt-mcp-server)](LICENSE)
+[![MCP Badge](https://lobehub.com/badge/mcp/dpesch-mantisbt-mcp-server)](https://lobehub.com/mcp/dpesch-mantisbt-mcp-server)
 [![MantisBT MCP Server](https://glama.ai/mcp/servers/dpesch/mantisbt-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/dpesch/mantisbt-mcp-server)
 
 A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that integrates the [MantisBT REST API](https://documenter.getpostman.com/view/29959/mantis-bug-tracker-rest-api) into Claude Code and other MCP-capable clients. Read, create, and update issues directly from your editor.
@@ -79,17 +80,6 @@ npm run build
 | `MANTIS_SEARCH_THREADS` | – | `1` | Number of ONNX intra-op threads for the embedding model. Default is 1 to prevent CPU saturation on multi-core machines and WSL. Increase only if index rebuild speed matters and the host is dedicated to this workload. |
 | `MANTIS_UPLOAD_DIR` | – | – | Restrict `upload_file` to files within this directory. When set, any `file_path` outside the directory is rejected (path traversal attempts via `../` are blocked). Without this variable there is no restriction. |
 
-### Config file (fallback)
-
-If no environment variables are set, `~/.claude/mantis.json` is read:
-
-```json
-{
-  "base_url": "https://your-mantis.example.com/api/rest",
-  "api_key": "your-api-token"
-}
-```
-
 ## Available tools
 
 ### Issues
@@ -197,6 +187,27 @@ npm install sqlite-vec better-sqlite3
 | `get_mantis_version` | Get MantisBT version and check for updates |
 | `get_mcp_version` | Return the version of this mantisbt-mcp-server instance |
 
+## Available resources
+
+MCP Resources are URI-addressable, read-only data that clients can fetch directly without calling a tool. They are the third MCP primitive alongside Tools and Prompts. Note that Resource support is less widely implemented in MCP clients than Tools — check your client's documentation.
+
+| Resource URI | Description |
+|---|---|
+| `mantis://me` | Profile of the authenticated API user (live fetch) |
+| `mantis://projects` | All accessible MantisBT projects (cache-backed, refreshed via `sync_metadata`) |
+| `mantis://enums` | Valid values for all issue enum fields: severity, priority, status, resolution, reproducibility (live fetch) |
+
+## Available prompts
+
+MCP prompt templates are conversation starters that instruct the LLM to collect structured input and then call the appropriate tool. They are not tools themselves — they initiate a guided workflow.
+
+| Prompt | Required args | Optional args | Description |
+|---|---|---|---|
+| `create-bug-report` | `project_id`, `category`, `summary`, `description` | `steps_to_reproduce`, `expected`, `actual`, `environment` | Guides through a structured bug report and calls `create_issue` |
+| `create-feature-request` | `project_id`, `category`, `summary`, `description` | `use_case` | Guides through a feature request and calls `create_issue` |
+| `summarize-issue` | `issue_id` | – | Fetches an issue via `get_issue` and returns a concise summary |
+| `project-status` | `project_id` | – | Lists issues via `list_issues` and generates a status report grouped by severity |
+
 ## HTTP mode
 
 For use as a standalone server (e.g. in remote setups):

package/dist/client.js

@@ -10,20 +10,32 @@ export class MantisApiError extends Error {
     }
 }
 export class MantisClient {
-    baseUrl;
-    apiKey;
+    credentialFactory;
     responseObserver;
-    constructor(baseUrl, apiKey, responseObserver) {
-        // Ensure base URL ends without trailing slash; we always append /api/rest/
-        this.baseUrl = baseUrl.replace(/\/$/, '');
-        this.apiKey = apiKey;
-        this.responseObserver = responseObserver;
+    resolvedCredentials;
+    constructor(baseUrlOrFactory, apiKeyOrObserver, responseObserver) {
+        if (typeof baseUrlOrFactory === 'string') {
+            this.resolvedCredentials = { baseUrl: baseUrlOrFactory.replace(/\/$/, ''), apiKey: apiKeyOrObserver };
+            this.responseObserver = responseObserver;
+        }
+        else {
+            this.credentialFactory = baseUrlOrFactory;
+            this.responseObserver = apiKeyOrObserver;
+        }
     }
     // ---------------------------------------------------------------------------
     // Private helpers
     // ---------------------------------------------------------------------------
-    buildUrl(path, params) {
-        const url = new URL(`${this.baseUrl}/api/rest/${path}`);
+    async getCredentials() {
+        if (!this.resolvedCredentials) {
+            const { baseUrl, apiKey } = await this.credentialFactory();
+            this.resolvedCredentials = { baseUrl: baseUrl.replace(/\/$/, ''), apiKey };
+        }
+        return this.resolvedCredentials;
+    }
+    async buildUrl(path, params) {
+        const { baseUrl } = await this.getCredentials();
+        const url = new URL(`${baseUrl}/api/rest/${path}`);
         if (params) {
             for (const [key, value] of Object.entries(params)) {
                 if (value !== undefined) {
@@ -33,9 +45,10 @@ export class MantisClient {
         }
         return url.toString();
     }
-    headers() {
+    async headers() {
+        const { apiKey } = await this.getCredentials();
         return {
-            'Authorization': this.apiKey,
+            'Authorization': apiKey,
             'Content-Type': 'application/json',
             'Accept': 'application/json',
         };
@@ -72,42 +85,43 @@ export class MantisClient {
     // Public API methods
     // ---------------------------------------------------------------------------
     async get(path, params) {
-        const response = await fetch(this.buildUrl(path, params), {
+        const response = await fetch(await this.buildUrl(path, params), {
             method: 'GET',
-            headers: this.headers(),
+            headers: await this.headers(),
         });
         return this.handleResponse(response);
     }
     async post(path, body) {
-        const response = await fetch(this.buildUrl(path), {
+        const response = await fetch(await this.buildUrl(path), {
             method: 'POST',
-            headers: this.headers(),
+            headers: await this.headers(),
             body: JSON.stringify(body),
         });
         return this.handleResponse(response);
     }
     async patch(path, body) {
-        const response = await fetch(this.buildUrl(path), {
+        const response = await fetch(await this.buildUrl(path), {
             method: 'PATCH',
-            headers: this.headers(),
+            headers: await this.headers(),
             body: JSON.stringify(body),
         });
         return this.handleResponse(response);
     }
     async delete(path) {
-        const response = await fetch(this.buildUrl(path), {
+        const response = await fetch(await this.buildUrl(path), {
             method: 'DELETE',
-            headers: this.headers(),
+            headers: await this.headers(),
         });
         return this.handleResponse(response);
     }
     async postFormData(path, formData) {
         // Note: Content-Type must NOT be set here — fetch sets it automatically
         // with the correct multipart/form-data boundary.
-        const response = await fetch(this.buildUrl(path), {
+        const { apiKey } = await this.getCredentials();
+        const response = await fetch(await this.buildUrl(path), {
             method: 'POST',
             headers: {
-                'Authorization': this.apiKey,
+                'Authorization': apiKey,
                 'Accept': 'application/json',
             },
             body: formData,
@@ -115,9 +129,9 @@ export class MantisClient {
         return this.handleResponse(response);
     }
     async getVersion() {
-        const response = await fetch(this.buildUrl('users/me'), {
+        const response = await fetch(await this.buildUrl('users/me'), {
             method: 'GET',
-            headers: this.headers(),
+            headers: await this.headers(),
         });
         if (!response.ok) {
             throw new MantisApiError(response.status, response.statusText);

package/dist/config.js

@@ -23,45 +23,7 @@ async function loadDotEnvLocal() {
         // .env.local not present — use environment variables directly
     }
 }
-// ---------------------------------------------------------------------------
-// Loader
-// ---------------------------------------------------------------------------
-async function readMantisJson() {
-    const filePath = join(homedir(), '.claude', 'mantis.json');
-    try {
-        const raw = await readFile(filePath, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-let cachedConfig = null;
-export async function getConfig() {
-    if (cachedConfig)
-        return cachedConfig;
-    await loadDotEnvLocal();
-    let baseUrl = process.env.MANTIS_BASE_URL ?? '';
-    let apiKey = process.env.MANTIS_API_KEY ?? '';
-    // If env vars are missing, try ~/.claude/mantis.json as fallback
-    if (!baseUrl || !apiKey) {
-        const json = await readMantisJson();
-        if (json) {
-            if (!baseUrl && json.base_url)
-                baseUrl = json.base_url;
-            if (!apiKey && json.api_key)
-                apiKey = json.api_key;
-        }
-    }
-    const missing = [];
-    if (!baseUrl)
-        missing.push('MANTIS_BASE_URL');
-    if (!apiKey)
-        missing.push('MANTIS_API_KEY');
-    if (missing.length > 0) {
-        throw new Error(`Missing required MantisBT configuration: ${missing.join(', ')}.\n` +
-            `Set the environment variables or provide ~/.claude/mantis.json with keys "base_url" and "api_key".`);
-    }
+function readNonCredentialConfig() {
     const defaultCacheDir = join(homedir(), '.cache', 'mantisbt-mcp');
     const cacheDir = process.env.MANTIS_CACHE_DIR ?? defaultCacheDir;
     const cacheTtl = process.env.MANTIS_CACHE_TTL
@@ -77,19 +39,13 @@ export async function getConfig() {
     const searchModelName = process.env.MANTIS_SEARCH_MODEL ??
         'Xenova/paraphrase-multilingual-MiniLM-L12-v2';
     const searchNumThreads = Math.max(1, parseInt(process.env.MANTIS_SEARCH_THREADS ?? '', 10) || 1);
-    const uploadDir = process.env.MANTIS_UPLOAD_DIR;
-    const httpHost = process.env.MCP_HTTP_HOST ?? '127.0.0.1';
-    const httpPort = parseInt(process.env.PORT ?? '3000', 10);
-    const httpToken = process.env.MCP_HTTP_TOKEN;
-    cachedConfig = {
-        baseUrl: baseUrl.replace(/\/$/, ''), // strip trailing slash
-        apiKey,
+    return {
         cacheDir,
         cacheTtl,
-        uploadDir,
-        httpHost,
-        httpPort,
-        httpToken,
+        uploadDir: process.env.MANTIS_UPLOAD_DIR,
+        httpHost: process.env.MCP_HTTP_HOST ?? '127.0.0.1',
+        httpPort: parseInt(process.env.PORT ?? '3000', 10),
+        httpToken: process.env.MCP_HTTP_TOKEN,
         search: {
             enabled: searchEnabled,
             backend: searchBackend,
@@ -98,5 +54,40 @@ export async function getConfig() {
             numThreads: searchNumThreads,
         },
     };
+}
+/**
+ * Returns all non-credential config values. Never throws, even when
+ * MANTIS_BASE_URL / MANTIS_API_KEY are absent. Use this at server startup
+ * so the MCP transport can connect and respond to tools/list without
+ * requiring credentials to be configured.
+ */
+export async function getStartupConfig() {
+    await loadDotEnvLocal();
+    return readNonCredentialConfig();
+}
+// ---------------------------------------------------------------------------
+// Full config (credentials required)
+// ---------------------------------------------------------------------------
+let cachedConfig = null;
+export async function getConfig() {
+    if (cachedConfig)
+        return cachedConfig;
+    await loadDotEnvLocal();
+    const baseUrl = process.env.MANTIS_BASE_URL ?? '';
+    const apiKey = process.env.MANTIS_API_KEY ?? '';
+    const missing = [];
+    if (!baseUrl)
+        missing.push('MANTIS_BASE_URL');
+    if (!apiKey)
+        missing.push('MANTIS_API_KEY');
+    if (missing.length > 0) {
+        throw new Error(`Missing required MantisBT configuration: ${missing.join(', ')}.\n` +
+            `Set the environment variables MANTIS_BASE_URL and MANTIS_API_KEY.`);
+    }
+    cachedConfig = {
+        baseUrl: baseUrl.replace(/\/$/, ''), // strip trailing slash
+        apiKey,
+        ...readNonCredentialConfig(),
+    };
     return cachedConfig;
 }

package/dist/index.js

@@ -6,7 +6,7 @@ import { createServer } from 'node:http';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { join, dirname } from 'node:path';
-import { getConfig } from './config.js';
+import { getConfig, getStartupConfig } from './config.js';
 import { MantisClient } from './client.js';
 import { VersionHintService, setGlobalVersionHint } from './version-hint.js';
 import { MetadataCache } from './cache.js';
@@ -22,6 +22,8 @@ import { registerConfigTools } from './tools/config.js';
 import { registerMetadataTools } from './tools/metadata.js';
 import { registerTagTools } from './tools/tags.js';
 import { registerVersionTools } from './tools/version.js';
+import { registerPrompts } from './prompts/index.js';
+import { registerResources } from './resources/index.js';
 // ---------------------------------------------------------------------------
 // Read version from package.json
 // ---------------------------------------------------------------------------
@@ -33,18 +35,24 @@ const version = packageJson.version;
 // Bootstrap
 // ---------------------------------------------------------------------------
 async function createMcpServer() {
-    const config = await getConfig();
+    // Use startup config (no credentials required) so the server can connect
+    // and respond to tools/list even without MANTIS_BASE_URL / MANTIS_API_KEY.
+    // Credentials are resolved lazily on the first actual tool invocation.
+    const startupConfig = await getStartupConfig();
     const versionHint = new VersionHintService();
     setGlobalVersionHint(versionHint);
-    const client = new MantisClient(config.baseUrl, config.apiKey, (response) => versionHint.onSuccessfulResponse(response));
-    const cache = new MetadataCache(config.cacheDir, config.cacheTtl);
+    const client = new MantisClient(async () => {
+        const config = await getConfig();
+        return { baseUrl: config.baseUrl, apiKey: config.apiKey };
+    }, (response) => versionHint.onSuccessfulResponse(response));
+    const cache = new MetadataCache(startupConfig.cacheDir, startupConfig.cacheTtl);
     const server = new McpServer({
         name: 'mantisbt-mcp-server',
         version,
     });
     registerIssueTools(server, client, cache);
     registerNoteTools(server, client);
-    registerFileTools(server, client, config.uploadDir);
+    registerFileTools(server, client, startupConfig.uploadDir);
     registerRelationshipTools(server, client);
     registerMonitorTools(server, client);
     registerProjectTools(server, client);
@@ -54,10 +62,12 @@ async function createMcpServer() {
     registerMetadataTools(server, client, cache);
     registerTagTools(server, client);
     registerVersionTools(server, client, versionHint, version);
+    registerPrompts(server);
+    registerResources(server, client, cache);
     // Optional: Semantic search module
-    if (config.search.enabled) {
+    if (startupConfig.search.enabled) {
         const { initializeSearchModule } = await import('./search/index.js');
-        await initializeSearchModule(server, client, config.search);
+        await initializeSearchModule(server, client, startupConfig.search);
     }
     return server;
 }
@@ -75,14 +85,14 @@ async function runStdio() {
     process.stdin.once('close', () => process.exit(0));
 }
 async function runHttp() {
-    const config = await getConfig();
+    const startupConfig = await getStartupConfig();
     const server = await createMcpServer();
-    const port = config.httpPort;
+    const port = startupConfig.httpPort;
     const httpServer = createServer(async (req, res) => {
         if (req.method === 'POST' && req.url === '/mcp') {
-            if (config.httpToken) {
+            if (startupConfig.httpToken) {
                 const auth = req.headers['authorization'];
-                if (auth !== `Bearer ${config.httpToken}`) {
+                if (auth !== `Bearer ${startupConfig.httpToken}`) {
                     res.writeHead(401, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ error: 'Unauthorized' }));
                     return;
@@ -116,8 +126,8 @@ async function runHttp() {
             res.end();
         }
     });
-    httpServer.listen(port, config.httpHost, () => {
-        console.error(`MantisBT MCP Server v${version} running on http://${config.httpHost}:${port}/mcp`);
+    httpServer.listen(port, startupConfig.httpHost, () => {
+        console.error(`MantisBT MCP Server v${version} running on http://${startupConfig.httpHost}:${port}/mcp`);
     });
 }
 // ---------------------------------------------------------------------------

package/dist/prompts/index.js

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+function userMessage(text) {
+    return {
+        messages: [{
+                role: 'user',
+                content: { type: 'text', text },
+            }],
+    };
+}
+export function registerPrompts(server) {
+    // ---------------------------------------------------------------------------
+    // create-bug-report
+    // ---------------------------------------------------------------------------
+    server.registerPrompt('create-bug-report', {
+        title: 'Create Bug Report',
+        description: 'Guide the creation of a complete bug report in MantisBT. Project, category, summary, and description are required.',
+        argsSchema: {
+            project_id: z.coerce.number().int().positive().describe('Numeric project ID'),
+            category: z.string().describe('Issue category (call get_project_categories to list valid values)'),
+            summary: z.string().describe('Short, descriptive summary of the bug'),
+            description: z.string().describe('Detailed description of the bug'),
+            steps_to_reproduce: z.string().optional().describe('Step-by-step reproduction instructions'),
+            expected: z.string().optional().describe('Expected behavior'),
+            actual: z.string().optional().describe('Actual (buggy) behavior'),
+            environment: z.string().optional().describe('Environment info (OS, browser, version, etc.)'),
+        },
+    }, ({ project_id, category, summary, description, steps_to_reproduce, expected, actual, environment }) => {
+        const lines = [
+            `Create a bug report in MantisBT for project ${project_id}.`,
+            ``,
+            `Category: ${category}`,
+            `Summary: ${summary}`,
+            ``,
+            `Description:`,
+            description,
+        ];
+        if (steps_to_reproduce) {
+            lines.push(``, `Steps to reproduce:`, steps_to_reproduce);
+        }
+        if (expected) {
+            lines.push(``, `Expected behavior:`, expected);
+        }
+        if (actual) {
+            lines.push(``, `Actual behavior:`, actual);
+        }
+        if (environment) {
+            lines.push(``, `Environment:`, environment);
+        }
+        lines.push(``, `Use the create_issue tool to submit this bug report.`, `Call get_issue_enums first if you need to look up valid severity and priority values.`, `Default to severity "minor" and priority "normal" unless the user specifies otherwise.`);
+        return userMessage(lines.join('\n'));
+    });
+    // ---------------------------------------------------------------------------
+    // create-feature-request
+    // ---------------------------------------------------------------------------
+    server.registerPrompt('create-feature-request', {
+        title: 'Create Feature Request',
+        description: 'Guide the creation of a feature request in MantisBT. Project, category, summary, and description are required.',
+        argsSchema: {
+            project_id: z.coerce.number().int().positive().describe('Numeric project ID'),
+            category: z.string().describe('Issue category (call get_project_categories to list valid values)'),
+            summary: z.string().describe('Short description of the requested feature'),
+            description: z.string().describe('Detailed description of the feature'),
+            use_case: z.string().optional().describe('Business use case or motivation for the feature'),
+        },
+    }, ({ project_id, category, summary, description, use_case }) => {
+        const lines = [
+            `Create a feature request in MantisBT for project ${project_id}.`,
+            ``,
+            `Category: ${category}`,
+            `Summary: ${summary}`,
+            ``,
+            `Description:`,
+            description,
+        ];
+        if (use_case) {
+            lines.push(``, `Use case / motivation:`, use_case);
+        }
+        lines.push(``, `Use the create_issue tool to submit this feature request.`, `Call get_issue_enums first to look up valid severity values — use severity "feature" and priority "normal" unless the user specifies otherwise.`);
+        return userMessage(lines.join('\n'));
+    });
+    // ---------------------------------------------------------------------------
+    // summarize-issue
+    // ---------------------------------------------------------------------------
+    server.registerPrompt('summarize-issue', {
+        title: 'Summarize Issue',
+        description: 'Fetch a MantisBT issue and provide a concise summary of its status, details, and recent activity.',
+        argsSchema: {
+            issue_id: z.coerce.number().int().positive().describe('Numeric issue ID'),
+        },
+    }, ({ issue_id }) => userMessage([
+        `Fetch issue #${issue_id} using the get_issue tool and provide a concise summary.`,
+        `Include: status, assignee, severity, priority, description, and any recent notes.`,
+        `Highlight blockers, unresolved questions, or anything that requires attention.`,
+    ].join('\n')));
+    // ---------------------------------------------------------------------------
+    // project-status
+    // ---------------------------------------------------------------------------
+    server.registerPrompt('project-status', {
+        title: 'Project Status Report',
+        description: 'Generate a status overview of open issues for a MantisBT project, grouped by severity.',
+        argsSchema: {
+            project_id: z.coerce.number().int().positive().describe('Numeric project ID'),
+        },
+    }, ({ project_id }) => userMessage([
+        `Use the list_issues tool to fetch open issues for MantisBT project ${project_id}.`,
+        `Produce a status report that includes:`,
+        `- Total count of open issues`,
+        `- Breakdown by severity (critical and major issues first)`,
+        `- Breakdown by assignee`,
+        `- A short list of the most critical or longest-open issues that need attention`,
+    ].join('\n')));
+}

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)));
+}