@doraincident/mcp-server 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DoraIncident
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,165 @@
+# @doraincident/mcp-server
+
+Connect [DoraIncident](https://www.doraincident.io) to Claude, Cursor, and any MCP-compatible AI assistant. Query live incidents, acknowledge escalated alerts, declare major incidents, and track DORA regulatory deadlines — without leaving your AI tool.
+
+[![npm version](https://img.shields.io/npm/v/@doraincident/mcp-server)](https://www.npmjs.com/package/@doraincident/mcp-server)
+[![Listed on mcpservers.org](https://img.shields.io/badge/mcpservers.org-listed-green)](https://mcpservers.org/servers/www-doraincident-io-settings-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+---
+
+## What is DoraIncident?
+
+DoraIncident is an AI-native incident management platform for regulated payment firms. It combines:
+
+- **On-call alerting** — ingest from Datadog, Prometheus, Grafana, OpsGenie, PagerDuty, New Relic, and Nagios
+- **Automated ticketing** — AI creates and populates an incident ticket the moment the IM declares
+- **DORA compliance** — live 4h/72h/30-day deadline tracking and AI-drafted regulatory report content
+- **Public status pages** — with component tracking, subscriber email notifications, and AI chat
+
+This MCP server exposes the live operational state of your DoraIncident instance to any connected AI.
+
+**Security note:** All data stays within your own DoraIncident instance. Nothing is routed through Anthropic or OpenAI — LLM inference runs via Groq, and MCP calls go directly from your AI client to your instance over HTTPS using a scoped API key.
+
+---
+
+## Tools
+
+### Alerts (4 tools)
+
+| Tool | Description |
+|---|---|
+| `list_alerts` | List alerts with optional `status`, `source`, and `limit` filters. Escalated alerts are P1/P2 signals waiting for a human decision. |
+| `get_alert` | Full alert detail including raw payload, AI severity score, reasoning, and current triage status. |
+| `acknowledge_alert` | Acknowledge an escalated alert. Pauses the escalation timer and signals active investigation. |
+| `suppress_alert` | Suppress an alert (noise or false positive). Requires a written reason, stored in the audit log. |
+
+### Incidents, tickets, and DORA (8 tools)
+
+| Tool | Description |
+|---|---|
+| `list_incidents` | List incidents filtered by `status` (active, resolved, closed). Active incidents have running DORA clocks. |
+| `get_incident` | Full incident detail: event timeline, linked ticket, affected services, and DORA countdown timers. |
+| `declare_incident` | Declare a major incident. Starts the DORA regulatory clock, auto-creates an AI-populated ticket, and opens a Slack war room. **Only call this when a human has confirmed the situation warrants declaration.** |
+| `resolve_incident` | Mark an incident as resolved. Triggers optional RCA draft generation and surfaces DORA report drafts for IM review. |
+| `list_tickets` | List incident tickets with `status` and `priority` filters. |
+| `get_ticket` | Full ticket detail: description, status, assignee, comments, activity log, and DORA link panel. |
+| `get_dora_deadlines` | DORA regulatory deadlines for all active P1/P2 incidents. Shows time remaining for Initial Notification (4h), Intermediate Report (72h), and Final Report (30 days). Flags overdue deadlines. |
+| `get_on_call` | Current on-call person across all schedules. Returns name, email, and schedule details. |
+
+### Knowledge base (1 tool)
+
+| Tool | Description |
+|---|---|
+| `search_knowledge_base` | Semantic search over runbooks, past post-mortems, and ingested docs/code. Returns the passages most relevant to a query with similarity scores and the retrieval method (vector or lexical) — the same retrieval that grounds resolution suggestions and RCA drafts. Use it to recall how a similar issue was handled before recommending remediation. |
+
+## Resources
+
+| URI | Description |
+|---|---|
+| `doraincident://alerts/escalated` | Live feed of all alerts currently in escalated state requiring a human declare or dismiss decision. |
+| `doraincident://incidents/active` | Live feed of all active incidents with DORA countdown timers. |
+
+---
+
+## Installation
+
+### Prerequisites
+
+- Node.js 18 or higher
+- A DoraIncident account — [request access at doraincident.io](https://www.doraincident.io)
+- A DoraIncident API key — generate one in **Settings → API Keys**
+
+### Option 1 — Claude Desktop (recommended)
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "doraincident": {
+      "command": "npx",
+      "args": ["-y", "@doraincident/mcp-server"],
+      "env": {
+        "DORAINCIDENT_URL": "https://www.doraincident.io",
+        "DORAINCIDENT_API_KEY": "di_live_..."
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop. You should see the DoraIncident tools listed in the MCP panel.
+
+### Option 2 — Claude Code (CLI)
+
+```bash
+claude mcp add doraincident \
+  -e DORAINCIDENT_URL=https://www.doraincident.io \
+  -e DORAINCIDENT_API_KEY=di_live_... \
+  -- npx -y @doraincident/mcp-server
+```
+
+### Option 3 — Install globally
+
+```bash
+npm install -g @doraincident/mcp-server
+
+# Then point your MCP client at the installed binary:
+doraincident-mcp
+# env: DORAINCIDENT_URL, DORAINCIDENT_API_KEY
+```
+
+---
+
+## Environment variables
+
+| Variable | Required | Description |
+|---|---|---|
+| `DORAINCIDENT_API_KEY` | Yes | API key from **Settings → API Keys**. Must start with `di_live_`. |
+| `DORAINCIDENT_URL` | No | Base URL of your DoraIncident instance. Defaults to `https://www.doraincident.io`. |
+
+---
+
+## Example usage
+
+Once connected, ask your AI assistant:
+
+```
+"What incidents are active right now and do any have DORA deadlines approaching?"
+
+"Acknowledge alert alt_abc123 — I'm looking into it."
+
+"Declare a P1 incident: Payments gateway timeout affecting the checkout-service and 3ds-provider."
+
+"What's the current DORA Initial Notification deadline for the active P1?"
+
+"Who is on call right now?"
+```
+
+---
+
+## Building from source
+
+```bash
+git clone https://github.com/michaelngangom/doraincident.git
+cd doraincident/packages/mcp-server
+npm install
+npm run build    # compiles TypeScript to dist/
+```
+
+---
+
+## Links
+
+- **Platform:** [doraincident.io](https://www.doraincident.io)
+- **MCP setup guide:** [doraincident.io/docs/mcp-server](https://www.doraincident.io/docs/mcp-server)
+- **Full documentation:** [doraincident.io/docs](https://www.doraincident.io/docs)
+- **Listed on mcpservers.org:** [mcpservers.org/servers/www-doraincident-io-settings-mcp](https://mcpservers.org/servers/www-doraincident-io-settings-mcp)
+- **Issues:** [github.com/michaelngangom/doraincident/issues](https://github.com/michaelngangom/doraincident/issues)
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/dist/client.d.ts

@@ -0,0 +1,35 @@
+export declare class DoraIncidentClient {
+    private baseUrl;
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    private request;
+    listAlerts(params?: {
+        status?: string;
+        source?: string;
+        limit?: number;
+    }): Promise<unknown>;
+    getAlert(id: string): Promise<unknown>;
+    acknowledgeAlert(id: string): Promise<unknown>;
+    suppressAlert(id: string, reason: string): Promise<unknown>;
+    listIncidents(params?: {
+        status?: string;
+    }): Promise<unknown>;
+    getIncident(id: string): Promise<unknown>;
+    declareIncident(params: {
+        alert_id?: string;
+        title: string;
+        priority: string;
+        affected_services: string[];
+        dora_applicable: boolean;
+        declared_by?: string;
+    }): Promise<unknown>;
+    resolveIncident(id: string, resolution_summary: string): Promise<unknown>;
+    getDoraDeadlines(): Promise<unknown>;
+    getOnCall(): Promise<unknown>;
+    listTickets(params?: {
+        status?: string;
+        priority?: string;
+    }): Promise<unknown>;
+    getTicket(id: string): Promise<unknown>;
+    searchKnowledgeBase(query: string, limit?: number): Promise<unknown>;
+}

package/dist/client.js

@@ -0,0 +1,109 @@
+export class DoraIncidentClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.apiKey = apiKey;
+    }
+    async request(path, options = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const res = await fetch(url, {
+            ...options,
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+        if (!res.ok) {
+            let errorMsg = res.statusText;
+            try {
+                const body = await res.json();
+                errorMsg = body.error ?? errorMsg;
+            }
+            catch {
+                // ignore parse failure
+            }
+            throw new Error(`DoraIncident API ${res.status}: ${errorMsg}`);
+        }
+        return res.json();
+    }
+    // --- Alerts ---
+    async listAlerts(params) {
+        const q = new URLSearchParams();
+        if (params?.status)
+            q.set('status', params.status);
+        if (params?.source)
+            q.set('source', params.source);
+        if (params?.limit)
+            q.set('limit', String(params.limit));
+        const qs = q.toString();
+        return this.request(`/api/alerts${qs ? `?${qs}` : ''}`);
+    }
+    async getAlert(id) {
+        return this.request(`/api/alerts/${id}`);
+    }
+    async acknowledgeAlert(id) {
+        return this.request(`/api/alerts/${id}/acknowledge`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        });
+    }
+    async suppressAlert(id, reason) {
+        return this.request(`/api/alerts/${id}/suppress`, {
+            method: 'POST',
+            body: JSON.stringify({ reason }),
+        });
+    }
+    // --- Incidents ---
+    async listIncidents(params) {
+        const q = new URLSearchParams();
+        if (params?.status)
+            q.set('status', params.status);
+        const qs = q.toString();
+        return this.request(`/api/incidents${qs ? `?${qs}` : ''}`);
+    }
+    async getIncident(id) {
+        return this.request(`/api/incidents/${id}`);
+    }
+    async declareIncident(params) {
+        return this.request('/api/declare', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    async resolveIncident(id, resolution_summary) {
+        return this.request(`/api/incidents/${id}/resolve`, {
+            method: 'POST',
+            body: JSON.stringify({ resolution_summary }),
+        });
+    }
+    // --- DORA ---
+    async getDoraDeadlines() {
+        return this.request('/api/dora');
+    }
+    // --- On-call ---
+    async getOnCall() {
+        return this.request('/api/on-call');
+    }
+    // --- Tickets ---
+    async listTickets(params) {
+        const q = new URLSearchParams();
+        if (params?.status)
+            q.set('status', params.status);
+        if (params?.priority)
+            q.set('priority', params.priority);
+        const qs = q.toString();
+        return this.request(`/api/tickets${qs ? `?${qs}` : ''}`);
+    }
+    async getTicket(id) {
+        return this.request(`/api/tickets/${id}`);
+    }
+    // --- Knowledge base ---
+    async searchKnowledgeBase(query, limit) {
+        return this.request('/api/knowledge-base/search', {
+            method: 'POST',
+            body: JSON.stringify({ query, ...(limit ? { limit } : {}) }),
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,87 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { DoraIncidentClient } from './client.js';
+import { alertToolDefs, handleAlertTool } from './tools/alerts.js';
+import { incidentToolDefs, handleIncidentTool } from './tools/incidents.js';
+import { knowledgeToolDefs, handleKnowledgeTool } from './tools/knowledge.js';
+const DORAINCIDENT_URL = process.env.DORAINCIDENT_URL ?? 'https://www.doraincident.io';
+const DORAINCIDENT_API_KEY = process.env.DORAINCIDENT_API_KEY ?? '';
+if (!DORAINCIDENT_API_KEY) {
+    process.stderr.write('Error: DORAINCIDENT_API_KEY is not set.\n' +
+        'Set it to a "di_live_..." API key from your DoraIncident settings.\n');
+    process.exit(1);
+}
+const client = new DoraIncidentClient(DORAINCIDENT_URL, DORAINCIDENT_API_KEY);
+const ALL_TOOLS = [...alertToolDefs, ...incidentToolDefs, ...knowledgeToolDefs];
+const ALERT_TOOL_NAMES = new Set(alertToolDefs.map(t => t.name));
+const INCIDENT_TOOL_NAMES = new Set(incidentToolDefs.map(t => t.name));
+const KNOWLEDGE_TOOL_NAMES = new Set(knowledgeToolDefs.map(t => t.name));
+const server = new Server({ name: 'doraincident', version: '0.1.0' }, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: ALL_TOOLS }));
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: [
+        {
+            uri: 'doraincident://alerts/escalated',
+            name: 'Escalated Alerts',
+            description: 'All alerts currently in escalated state requiring human decision',
+            mimeType: 'application/json',
+        },
+        {
+            uri: 'doraincident://incidents/active',
+            name: 'Active Incidents',
+            description: 'All active incidents with DORA countdown timers',
+            mimeType: 'application/json',
+        },
+    ],
+}));
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (uri === 'doraincident://alerts/escalated') {
+        const data = await client.listAlerts({ status: 'escalated' });
+        return {
+            contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(data, null, 2) }],
+        };
+    }
+    if (uri === 'doraincident://incidents/active') {
+        const data = await client.listIncidents({ status: 'active' });
+        return {
+            contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(data, null, 2) }],
+        };
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const safeArgs = (args ?? {});
+    try {
+        let text;
+        if (ALERT_TOOL_NAMES.has(name)) {
+            text = await handleAlertTool(name, safeArgs, client);
+        }
+        else if (INCIDENT_TOOL_NAMES.has(name)) {
+            text = await handleIncidentTool(name, safeArgs, client);
+        }
+        else if (KNOWLEDGE_TOOL_NAMES.has(name)) {
+            text = await handleKnowledgeTool(name, safeArgs, client);
+        }
+        else {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/alerts.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { DoraIncidentClient } from '../client.js';
+export declare const alertToolDefs: Tool[];
+export declare function handleAlertTool(name: string, args: Record<string, unknown>, client: DoraIncidentClient): Promise<string>;

package/dist/tools/alerts.js

@@ -0,0 +1,100 @@
+export const alertToolDefs = [
+    {
+        name: 'list_alerts',
+        description: 'List alerts from DoraIncident. Returns alerts sorted by received_at descending. ' +
+            'Escalated alerts require immediate attention - they are P1/P2 signals waiting for a human to declare or dismiss.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    enum: ['pending', 'filtered', 'correlated', 'escalated', 'acknowledged', 'suppressed'],
+                    description: 'Filter by triage status. Omit to return all.',
+                },
+                source: {
+                    type: 'string',
+                    description: 'Filter by alert source (datadog, prometheus, grafana, generic, etc.)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of alerts to return. Default is 20.',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_alert',
+        description: 'Get full details of a single alert including raw payload, triage result (AI severity score and reasoning), ' +
+            'and current status. Use this before deciding to acknowledge, suppress, or declare an incident.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Alert UUID',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'acknowledge_alert',
+        description: 'Acknowledge an escalated alert. This pauses the escalation timer and signals that a human is actively looking at it. ' +
+            'Use this when you have confirmed the alert is real and are investigating, but are not yet ready to declare a full incident.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Alert UUID to acknowledge',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'suppress_alert',
+        description: 'Suppress an alert - marks it as noise and stops further escalation. ' +
+            'Use this when the alert is a known false positive or a low-signal event that does not require action.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Alert UUID to suppress',
+                },
+                reason: {
+                    type: 'string',
+                    description: 'Why this alert is being suppressed. Stored in the audit log.',
+                },
+            },
+            required: ['id', 'reason'],
+        },
+    },
+];
+export async function handleAlertTool(name, args, client) {
+    switch (name) {
+        case 'list_alerts': {
+            const result = await client.listAlerts({
+                status: args.status,
+                source: args.source,
+                limit: args.limit,
+            });
+            return JSON.stringify(result, null, 2);
+        }
+        case 'get_alert': {
+            const result = await client.getAlert(args.id);
+            return JSON.stringify(result, null, 2);
+        }
+        case 'acknowledge_alert': {
+            const result = await client.acknowledgeAlert(args.id);
+            return JSON.stringify(result, null, 2);
+        }
+        case 'suppress_alert': {
+            const result = await client.suppressAlert(args.id, args.reason);
+            return JSON.stringify(result, null, 2);
+        }
+        default:
+            throw new Error(`Unknown alert tool: ${name}`);
+    }
+}

package/dist/tools/incidents.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { DoraIncidentClient } from '../client.js';
+export declare const incidentToolDefs: Tool[];
+export declare function handleIncidentTool(name: string, args: Record<string, unknown>, client: DoraIncidentClient): Promise<string>;

package/dist/tools/incidents.js

@@ -0,0 +1,191 @@
+export const incidentToolDefs = [
+    {
+        name: 'list_incidents',
+        description: 'List incidents. Active incidents have running DORA clocks - P1 and P2 incidents must have an ' +
+            'Initial Notification filed within 4 hours of declaration.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    enum: ['active', 'resolved', 'closed'],
+                    description: 'Filter by incident status. Omit to return all.',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_incident',
+        description: 'Get full incident details: timeline of events, linked ticket, DORA applicability, affected services, ' +
+            'and countdown to regulatory deadlines.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Incident UUID',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'declare_incident',
+        description: 'Declare a major incident. This starts the DORA regulatory clock for P1 and P2 incidents. ' +
+            'A ticket is automatically created and populated with an AI-generated description. ' +
+            'IMPORTANT: this action should only be taken when a human has confirmed the situation warrants declaration.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'Short, descriptive incident title. Example: "Payment API 3DS authentication failure"',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['P1', 'P2', 'P3', 'P4'],
+                    description: 'P1 = Critical (payment processing down, all customers). ' +
+                        'P2 = Major (significant degradation, large segment). ' +
+                        'P3 = Minor (partial, workaround available). ' +
+                        'P4 = Low (no customer impact). ' +
+                        'P1 and P2 trigger DORA reporting obligations.',
+                },
+                affected_services: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of affected service names. Example: ["checkout-service", "3ds-provider"]',
+                },
+                dora_applicable: {
+                    type: 'boolean',
+                    description: 'Whether this incident triggers DORA reporting. Auto-true for P1/P2, but the IM can override.',
+                },
+                alert_id: {
+                    type: 'string',
+                    description: 'Optional: UUID of the originating alert to link to this incident.',
+                },
+            },
+            required: ['title', 'priority', 'affected_services', 'dora_applicable'],
+        },
+    },
+    {
+        name: 'resolve_incident',
+        description: 'Mark an incident as resolved. This triggers AI generation of an RCA (Root Cause Analysis) draft ' +
+            'and surfaces the DORA Initial Notification draft for IM review if the incident is DORA-applicable. ' +
+            'A resolution summary is required.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Incident UUID to resolve',
+                },
+                resolution_summary: {
+                    type: 'string',
+                    description: 'Brief description of what caused the incident and how it was resolved. ' +
+                        'This feeds the AI RCA generation prompt. Be factual and specific.',
+                },
+            },
+            required: ['id', 'resolution_summary'],
+        },
+    },
+    {
+        name: 'list_tickets',
+        description: 'List tickets linked to incidents. Tickets track status, assignee, comments, and attachments.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    enum: ['open', 'in_progress', 'waiting_external', 'waiting_internal', 'waiting_deployment', 'resolved', 'closed'],
+                    description: 'Filter by ticket status.',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['P1', 'P2', 'P3', 'P4'],
+                    description: 'Filter by priority.',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_ticket',
+        description: 'Get full ticket details: description, status, assignee, comments, activity log, and DORA link panel.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Ticket UUID',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'get_dora_deadlines',
+        description: 'Get DORA regulatory deadlines for all active P1 and P2 incidents. ' +
+            'Shows time remaining until Initial Notification (4h), Intermediate Report (72h), ' +
+            'and Final Report (30 days). Overdue deadlines are flagged.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'get_on_call',
+        description: 'Get the current on-call person across all schedules. Returns name, email, and schedule details.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+];
+export async function handleIncidentTool(name, args, client) {
+    switch (name) {
+        case 'list_incidents': {
+            const result = await client.listIncidents({
+                status: args.status,
+            });
+            return JSON.stringify(result, null, 2);
+        }
+        case 'get_incident': {
+            const result = await client.getIncident(args.id);
+            return JSON.stringify(result, null, 2);
+        }
+        case 'declare_incident': {
+            const result = await client.declareIncident({
+                title: args.title,
+                priority: args.priority,
+                affected_services: args.affected_services,
+                dora_applicable: args.dora_applicable,
+                alert_id: args.alert_id,
+            });
+            return JSON.stringify(result, null, 2);
+        }
+        case 'resolve_incident': {
+            const result = await client.resolveIncident(args.id, args.resolution_summary);
+            return JSON.stringify(result, null, 2);
+        }
+        case 'list_tickets': {
+            const result = await client.listTickets({
+                status: args.status,
+                priority: args.priority,
+            });
+            return JSON.stringify(result, null, 2);
+        }
+        case 'get_ticket': {
+            const result = await client.getTicket(args.id);
+            return JSON.stringify(result, null, 2);
+        }
+        case 'get_dora_deadlines': {
+            const result = await client.getDoraDeadlines();
+            return JSON.stringify(result, null, 2);
+        }
+        case 'get_on_call': {
+            const result = await client.getOnCall();
+            return JSON.stringify(result, null, 2);
+        }
+        default:
+            throw new Error(`Unknown incident tool: ${name}`);
+    }
+}

package/dist/tools/knowledge.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { DoraIncidentClient } from '../client.js';
+export declare const knowledgeToolDefs: Tool[];
+export declare function handleKnowledgeTool(name: string, args: Record<string, unknown>, client: DoraIncidentClient): Promise<string>;

package/dist/tools/knowledge.js

@@ -0,0 +1,35 @@
+export const knowledgeToolDefs = [
+    {
+        name: 'search_knowledge_base',
+        description: 'Search the DoraIncident knowledge base (runbooks, past post-mortems, and ingested docs/code) for the ' +
+            'passages most relevant to a query. This is the same retrieval that grounds resolution suggestions and RCA ' +
+            'drafts. Use it to find how a similar issue was handled before recommending remediation, or to answer ' +
+            '"what is our runbook for X". Returns the matching passages with a similarity score and the retrieval method ' +
+            '(vector = semantic, lexical = keyword fallback). Ground your answer in what it returns; do not invent steps ' +
+            'it does not support.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'What to look for, in natural language (e.g. "payment gateway timing out under load").',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of passages to return (1-20). Default is 6.',
+                },
+            },
+            required: ['query'],
+        },
+    },
+];
+export async function handleKnowledgeTool(name, args, client) {
+    switch (name) {
+        case 'search_knowledge_base': {
+            const result = await client.searchKnowledgeBase(args.query, args.limit);
+            return JSON.stringify(result, null, 2);
+        }
+        default:
+            throw new Error(`Unknown knowledge tool: ${name}`);
+    }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@doraincident/mcp-server",
+  "version": "0.2.0",
+  "description": "MCP server for DoraIncident — query live incidents, acknowledge alerts, and track DORA regulatory deadlines from any AI assistant.",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "author": "DoraIncident <hello@doraincident.io>",
+  "homepage": "https://www.doraincident.io/docs/mcp-server",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/michaelngangom/doraincident.git",
+    "directory": "packages/mcp-server"
+  },
+  "bugs": {
+    "url": "https://github.com/michaelngangom/doraincident/issues",
+    "email": "hello@doraincident.io"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "incident-management",
+    "dora",
+    "dora-compliance",
+    "pagerduty",
+    "alerting",
+    "on-call",
+    "fintech",
+    "payments",
+    "regulatory",
+    "claude",
+    "ai"
+  ],
+  "bin": {
+    "doraincident-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "dev": "node --loader ts-node/esm src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}