@dpesch/mantisbt-mcp-server 1.5.9 → 1.6.0

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

package/tests/client.test.ts

@@ -209,6 +209,76 @@ describe('MantisClient – HTTP methods', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Credential factory (lazy constructor)
+// ---------------------------------------------------------------------------
+
+describe('MantisClient – credential factory', () => {
+  it('does not call the factory until the first API method', async () => {
+    const factory = vi.fn().mockResolvedValue({
+      baseUrl: 'https://lazy.example.com',
+      apiKey: 'lazy-key',
+    });
+
+    new MantisClient(factory);
+
+    expect(factory).not.toHaveBeenCalled();
+  });
+
+  it('calls the factory on first API method and uses the returned credentials', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
+    vi.stubGlobal('fetch', fetchMock);
+
+    const factory = vi.fn().mockResolvedValue({
+      baseUrl: 'https://lazy.example.com',
+      apiKey: 'lazy-key',
+    });
+
+    const client = new MantisClient(factory);
+    await client.get('issues');
+
+    expect(factory).toHaveBeenCalledOnce();
+    const calledUrl: string = fetchMock.mock.calls[0][0] as string;
+    expect(calledUrl).toBe('https://lazy.example.com/api/rest/issues');
+    const options = fetchMock.mock.calls[0][1] as RequestInit;
+    expect((options.headers as Record<string, string>)['Authorization']).toBe('lazy-key');
+  });
+
+  it('caches credentials after the first call and does not call the factory again', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
+    vi.stubGlobal('fetch', fetchMock);
+
+    const factory = vi.fn().mockResolvedValue({
+      baseUrl: 'https://lazy.example.com',
+      apiKey: 'lazy-key',
+    });
+
+    const client = new MantisClient(factory);
+    await client.get('issues');
+    await client.get('projects');
+
+    expect(factory).toHaveBeenCalledOnce();
+  });
+
+  it('forwards the responseObserver when using factory constructor', async () => {
+    const observer = vi.fn();
+    const fakeResponse = makeResponse(200, '{}');
+    const fetchMock = vi.fn().mockResolvedValue(fakeResponse);
+    vi.stubGlobal('fetch', fetchMock);
+
+    const factory = vi.fn().mockResolvedValue({
+      baseUrl: 'https://lazy.example.com',
+      apiKey: 'lazy-key',
+    });
+
+    const client = new MantisClient(factory, observer);
+    await client.get('issues');
+
+    expect(observer).toHaveBeenCalledOnce();
+    expect(observer).toHaveBeenCalledWith(fakeResponse);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // responseObserver
 // ---------------------------------------------------------------------------

package/tests/config.test.ts

@@ -19,6 +19,12 @@ async function freshGetConfig(): Promise<(typeof import('../src/config.js'))['ge
   return mod.getConfig;
 }
 
+async function freshGetStartupConfig(): Promise<(typeof import('../src/config.js'))['getStartupConfig']> {
+  vi.resetModules();
+  const mod = await import('../src/config.js');
+  return mod.getStartupConfig;
+}
+
 // ---------------------------------------------------------------------------
 // Setup
 // ---------------------------------------------------------------------------
@@ -87,60 +93,26 @@ describe('getConfig() – ENV variables', () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// JSON fallback
-// ---------------------------------------------------------------------------
-
-describe('getConfig() – mantis.json fallback', () => {
-  it('falls back to ~/.claude/mantis.json when ENV vars are missing', async () => {
-    const json = JSON.stringify({ base_url: 'https://from-json.example.com', api_key: 'json-key' });
-    vi.mocked(readFile).mockResolvedValue(json as any);
-
-    const getConfig = await freshGetConfig();
-    const config = await getConfig();
-
-    expect(config.baseUrl).toBe('https://from-json.example.com');
-    expect(config.apiKey).toBe('json-key');
-  });
-
-  it('prefers ENV vars over mantis.json values', async () => {
-    vi.stubEnv('MANTIS_BASE_URL', 'https://from-env.example.com');
-    vi.stubEnv('MANTIS_API_KEY', 'env-key');
-    const json = JSON.stringify({ base_url: 'https://from-json.example.com', api_key: 'json-key' });
-    vi.mocked(readFile).mockResolvedValue(json as any);
-
-    const getConfig = await freshGetConfig();
-    const config = await getConfig();
-
-    expect(config.baseUrl).toBe('https://from-env.example.com');
-    expect(config.apiKey).toBe('env-key');
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Error cases
 // ---------------------------------------------------------------------------
 
 describe('getConfig() – errors', () => {
-  it('throws when neither ENV nor mantis.json provides baseUrl', async () => {
+  it('throws when MANTIS_BASE_URL is not set', async () => {
     vi.stubEnv('MANTIS_API_KEY', 'some-key');
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
 
     const getConfig = await freshGetConfig();
     await expect(getConfig()).rejects.toThrow('MANTIS_BASE_URL');
   });
 
-  it('throws when neither ENV nor mantis.json provides apiKey', async () => {
+  it('throws when MANTIS_API_KEY is not set', async () => {
     vi.stubEnv('MANTIS_BASE_URL', 'https://mantis.example.com');
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
 
     const getConfig = await freshGetConfig();
     await expect(getConfig()).rejects.toThrow('MANTIS_API_KEY');
   });
 
-  it('throws when no configuration is available at all', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
+  it('throws when no configuration is provided at all', async () => {
     const getConfig = await freshGetConfig();
     await expect(getConfig()).rejects.toThrow('Missing required MantisBT configuration');
   });
@@ -215,6 +187,44 @@ describe('getConfig() – HTTP transport', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// getStartupConfig — never throws without credentials
+// ---------------------------------------------------------------------------
+
+describe('getStartupConfig()', () => {
+  it('succeeds without MANTIS_BASE_URL and MANTIS_API_KEY', async () => {
+    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
+
+    const getStartupConfig = await freshGetStartupConfig();
+    const config = await getStartupConfig();
+
+    expect(config).toBeDefined();
+    expect(config.cacheTtl).toBe(3600);
+    expect(config.httpHost).toBe('127.0.0.1');
+    expect(config.httpPort).toBe(3000);
+  });
+
+  it('does not include baseUrl or apiKey', async () => {
+    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
+
+    const getStartupConfig = await freshGetStartupConfig();
+    const config = await getStartupConfig();
+
+    expect(config).not.toHaveProperty('baseUrl');
+    expect(config).not.toHaveProperty('apiKey');
+  });
+
+  it('reads MANTIS_CACHE_DIR from environment', async () => {
+    vi.stubEnv('MANTIS_CACHE_DIR', '/tmp/test-cache');
+    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
+
+    const getStartupConfig = await freshGetStartupConfig();
+    const config = await getStartupConfig();
+
+    expect(config.cacheDir).toBe('/tmp/test-cache');
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Singleton caching
 // ---------------------------------------------------------------------------

package/tests/helpers/mock-server.ts

@@ -24,9 +24,33 @@ interface ToolDefinition {
   [key: string]: unknown;
 }
 
+export interface PromptMessage {
+  role: string;
+  content: { type: string; text: string };
+}
+
+export interface PromptResult {
+  messages: PromptMessage[];
+}
+
+export interface ResourceResult {
+  contents: Array<{ uri: string; mimeType?: string; text: string }>;
+}
+
+type PromptHandler = (args: Record<string, unknown>) => PromptResult;
+
+type ResourceHandler = (uri: URL) => Promise<ResourceResult>;
+
+interface PromptDefinition {
+  argsSchema?: Record<string, z.ZodTypeAny>;
+  [key: string]: unknown;
+}
+
 export class MockMcpServer {
   private readonly handlers = new Map<string, ToolHandler>();
   private readonly schemas = new Map<string, z.ZodTypeAny>();
+  private readonly promptHandlers = new Map<string, PromptHandler>();
+  private readonly resourceHandlers = new Map<string, ResourceHandler>();
 
   // Nachahmt McpServer.registerTool – fängt Handler und Schema ein
   registerTool(name: string, definition: ToolDefinition, handler: ToolHandler): void {
@@ -36,6 +60,11 @@ export class MockMcpServer {
     }
   }
 
+  // Nachahmt McpServer.registerPrompt
+  registerPrompt(name: string, _definition: PromptDefinition, handler: PromptHandler): void {
+    this.promptHandlers.set(name, handler);
+  }
+
   /**
    * Ruft den Handler auf. Wenn `validate: true`, wird der Input zuerst
    * durch das Zod-Schema geparst (wie der echte MCP-Server es tut).
@@ -66,11 +95,43 @@ export class MockMcpServer {
     return handler(args);
   }
 
+  callPrompt(name: string, args: Record<string, unknown> = {}): PromptResult {
+    const handler = this.promptHandlers.get(name);
+    if (!handler) throw new Error(`Prompt not registered: ${name}`);
+    return handler(args);
+  }
+
   hasToolRegistered(name: string): boolean {
     return this.handlers.has(name);
   }
 
+  hasPromptRegistered(name: string): boolean {
+    return this.promptHandlers.has(name);
+  }
+
   registeredToolNames(): string[] {
     return [...this.handlers.keys()];
   }
+
+  registeredPromptNames(): string[] {
+    return [...this.promptHandlers.keys()];
+  }
+
+  registerResource(name: string, uri: string, _config: unknown, handler: ResourceHandler): void {
+    this.resourceHandlers.set(uri, handler);
+  }
+
+  async callResource(uri: string): Promise<ResourceResult> {
+    const handler = this.resourceHandlers.get(uri);
+    if (!handler) throw new Error(`Resource not registered: ${uri}`);
+    return handler(new URL(uri));
+  }
+
+  hasResourceRegistered(uri: string): boolean {
+    return this.resourceHandlers.has(uri);
+  }
+
+  registeredResourceUris(): string[] {
+    return [...this.resourceHandlers.keys()];
+  }
 }

package/tests/prompts/prompts.test.ts

@@ -0,0 +1,242 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { registerPrompts } from '../../src/prompts/index.js';
+import { MockMcpServer } from '../helpers/mock-server.js';
+
+let mockServer: MockMcpServer;
+
+beforeEach(() => {
+  mockServer = new MockMcpServer();
+  registerPrompts(mockServer as never);
+});
+
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+
+describe('prompt registration', () => {
+  it('registers create-bug-report', () => {
+    expect(mockServer.hasPromptRegistered('create-bug-report')).toBe(true);
+  });
+
+  it('registers create-feature-request', () => {
+    expect(mockServer.hasPromptRegistered('create-feature-request')).toBe(true);
+  });
+
+  it('registers summarize-issue', () => {
+    expect(mockServer.hasPromptRegistered('summarize-issue')).toBe(true);
+  });
+
+  it('registers project-status', () => {
+    expect(mockServer.hasPromptRegistered('project-status')).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// create-bug-report
+// ---------------------------------------------------------------------------
+
+describe('create-bug-report', () => {
+  it('returns a single user message', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Login fails',
+      description: 'Cannot log in after password reset',
+    });
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]!.role).toBe('user');
+    expect(result.messages[0]!.content.type).toBe('text');
+  });
+
+  it('includes project_id, category, summary, and description in the text', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 7,
+      category: 'Authentication',
+      summary: 'Session expires too early',
+      description: 'Session is invalidated after 5 minutes of inactivity',
+    });
+
+    const text = result.messages[0]!.content.text;
+    expect(text).toContain('project 7');
+    expect(text).toContain('Authentication');
+    expect(text).toContain('Session expires too early');
+    expect(text).toContain('Session is invalidated after 5 minutes');
+  });
+
+  it('includes optional steps_to_reproduce when provided', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Bug',
+      description: 'Desc',
+      steps_to_reproduce: '1. Open app\n2. Click login',
+    });
+
+    expect(result.messages[0]!.content.text).toContain('Steps to reproduce');
+    expect(result.messages[0]!.content.text).toContain('1. Open app');
+  });
+
+  it('omits optional sections when not provided', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Bug',
+      description: 'Desc',
+    });
+
+    const text = result.messages[0]!.content.text;
+    expect(text).not.toContain('Steps to reproduce');
+    expect(text).not.toContain('Expected behavior');
+    expect(text).not.toContain('Actual behavior');
+    expect(text).not.toContain('Environment');
+  });
+
+  it('includes all optional fields when provided', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 1,
+      category: 'UI',
+      summary: 'Button broken',
+      description: 'Save button does nothing',
+      steps_to_reproduce: 'Click Save',
+      expected: 'Form is saved',
+      actual: 'Nothing happens',
+      environment: 'Chrome 120, Windows 11',
+    });
+
+    const text = result.messages[0]!.content.text;
+    expect(text).toContain('Steps to reproduce');
+    expect(text).toContain('Expected behavior');
+    expect(text).toContain('Actual behavior');
+    expect(text).toContain('Environment');
+    expect(text).toContain('Chrome 120');
+  });
+
+  it('mentions create_issue tool', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Bug',
+      description: 'Desc',
+    });
+
+    expect(result.messages[0]!.content.text).toContain('create_issue');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// create-feature-request
+// ---------------------------------------------------------------------------
+
+describe('create-feature-request', () => {
+  it('returns a single user message', () => {
+    const result = mockServer.callPrompt('create-feature-request', {
+      project_id: 2,
+      category: 'General',
+      summary: 'Dark mode',
+      description: 'Add a dark mode toggle to the UI',
+    });
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]!.role).toBe('user');
+  });
+
+  it('includes project_id, category, summary, and description', () => {
+    const result = mockServer.callPrompt('create-feature-request', {
+      project_id: 5,
+      category: 'UX',
+      summary: 'Export to CSV',
+      description: 'Allow exporting issue lists as CSV',
+    });
+
+    const text = result.messages[0]!.content.text;
+    expect(text).toContain('project 5');
+    expect(text).toContain('UX');
+    expect(text).toContain('Export to CSV');
+    expect(text).toContain('Allow exporting issue lists');
+  });
+
+  it('includes use_case when provided', () => {
+    const result = mockServer.callPrompt('create-feature-request', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Feature',
+      description: 'Desc',
+      use_case: 'Needed for monthly reporting',
+    });
+
+    expect(result.messages[0]!.content.text).toContain('Needed for monthly reporting');
+  });
+
+  it('omits use_case section when not provided', () => {
+    const result = mockServer.callPrompt('create-feature-request', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Feature',
+      description: 'Desc',
+    });
+
+    expect(result.messages[0]!.content.text).not.toContain('Use case');
+  });
+
+  it('mentions create_issue tool', () => {
+    const result = mockServer.callPrompt('create-feature-request', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Feature',
+      description: 'Desc',
+    });
+
+    expect(result.messages[0]!.content.text).toContain('create_issue');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// summarize-issue
+// ---------------------------------------------------------------------------
+
+describe('summarize-issue', () => {
+  it('returns a single user message', () => {
+    const result = mockServer.callPrompt('summarize-issue', { issue_id: 42 });
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]!.role).toBe('user');
+  });
+
+  it('includes the issue ID in the text', () => {
+    const result = mockServer.callPrompt('summarize-issue', { issue_id: 1234 });
+
+    expect(result.messages[0]!.content.text).toContain('1234');
+  });
+
+  it('mentions get_issue tool', () => {
+    const result = mockServer.callPrompt('summarize-issue', { issue_id: 1 });
+
+    expect(result.messages[0]!.content.text).toContain('get_issue');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// project-status
+// ---------------------------------------------------------------------------
+
+describe('project-status', () => {
+  it('returns a single user message', () => {
+    const result = mockServer.callPrompt('project-status', { project_id: 3 });
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]!.role).toBe('user');
+  });
+
+  it('includes the project ID in the text', () => {
+    const result = mockServer.callPrompt('project-status', { project_id: 99 });
+
+    expect(result.messages[0]!.content.text).toContain('99');
+  });
+
+  it('mentions list_issues tool', () => {
+    const result = mockServer.callPrompt('project-status', { project_id: 1 });
+
+    expect(result.messages[0]!.content.text).toContain('list_issues');
+  });
+});