superops-it 1.0.0

package/docs/introduction.json

@@ -0,0 +1,9 @@
+{
+  "title": "SuperOps IT Teams GraphQL API",
+  "description": "Welcome to the Superops IT GraphQL API reference! This reference includes the complete set of GraphQL types, queries, mutations, and their parameters. For more tutorial-oriented API documentation, please check out our API Guide",
+  "contact": "support@superops.com",
+  "endpoints": {
+    "us": "https://api.superops.ai/it",
+    "eu": "https://euapi.superops.ai/it"
+  }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "superops-it",
+  "version": "1.0.0",
+  "description": "MCP server for SuperOps IT Teams GraphQL API documentation",
+  "type": "module",
+  "main": "src/index.mjs",
+  "bin": {
+    "superops-it": "src/index.mjs"
+  },
+  "scripts": {
+    "start": "node src/index.mjs"
+  },
+  "keywords": [
+    "mcp",
+    "superops",
+    "it-teams",
+    "graphql",
+    "api",
+    "claude",
+    "ai"
+  ],
+  "author": "Limehawk",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Limehawk/superops-mcp.git",
+    "directory": "packages/it"
+  },
+  "homepage": "https://github.com/Limehawk/superops-mcp/tree/main/packages/it#readme",
+  "bugs": {
+    "url": "https://github.com/Limehawk/superops-mcp/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.2"
+  },
+  "files": [
+    "src/",
+    "docs/api-index.json",
+    "docs/introduction.json"
+  ]
+}

package/src/index.mjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema
+} from '@modelcontextprotocol/sdk/types.js';
+import { readFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SERVER_NAME = 'superops-it';
+const SERVER_VERSION = '1.0.0';
+const PRODUCT_NAME = 'SuperOps IT Teams';
+
+// API data cache
+let apiData = null;
+
+async function loadApiData() {
+    if (apiData) return apiData;
+
+    try {
+        const indexPath = join(__dirname, '..', 'docs', 'api-index.json');
+        const content = await readFile(indexPath, 'utf-8');
+        apiData = JSON.parse(content);
+        return apiData;
+    } catch (error) {
+        throw new Error(`Failed to load API data: ${error.message}`);
+    }
+}
+
+// Create server
+const server = new Server(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: { tools: {} } }
+);
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'search_superops_api',
+                description: `Search the ${PRODUCT_NAME} API documentation for queries, mutations, and types`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Search term to find in operation names, descriptions, and types'
+                        }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'get_superops_operation',
+                description: `Get full details of a specific ${PRODUCT_NAME} API query or mutation`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Name of the query or mutation (e.g., "getTicket", "getAsset")'
+                        }
+                    },
+                    required: ['name']
+                }
+            },
+            {
+                name: 'get_superops_type',
+                description: `Get full details of a ${PRODUCT_NAME} API type definition`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Name of the type (e.g., "Ticket", "Asset", "Department")'
+                        }
+                    },
+                    required: ['name']
+                }
+            },
+            {
+                name: 'list_superops_operations',
+                description: `List all available ${PRODUCT_NAME} API operations`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        type: {
+                            type: 'string',
+                            enum: ['queries', 'mutations', 'all'],
+                            description: 'Type of operations to list'
+                        }
+                    },
+                    required: ['type']
+                }
+            }
+        ]
+    };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        const data = await loadApiData();
+
+        switch (name) {
+            case 'search_superops_api': {
+                const query = args.query.toLowerCase();
+                const results = {
+                    queries: [],
+                    mutations: [],
+                    types: []
+                };
+
+                for (const op of data.queries) {
+                    if (op.name.toLowerCase().includes(query) ||
+                        op.description?.toLowerCase().includes(query)) {
+                        results.queries.push({
+                            name: op.name,
+                            description: op.description,
+                            returns: op.returns
+                        });
+                    }
+                }
+
+                for (const op of data.mutations) {
+                    if (op.name.toLowerCase().includes(query) ||
+                        op.description?.toLowerCase().includes(query)) {
+                        results.mutations.push({
+                            name: op.name,
+                            description: op.description,
+                            returns: op.returns
+                        });
+                    }
+                }
+
+                for (const type of data.types) {
+                    if (type.name.toLowerCase().includes(query) ||
+                        type.description?.toLowerCase().includes(query)) {
+                        results.types.push({
+                            name: type.name,
+                            kind: type.kind,
+                            description: type.description
+                        });
+                    }
+                }
+
+                const total = results.queries.length + results.mutations.length + results.types.length;
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            searchTerm: args.query,
+                            totalResults: total,
+                            results
+                        }, null, 2)
+                    }]
+                };
+            }
+
+            case 'get_superops_operation': {
+                const opName = args.name.toLowerCase();
+
+                let operation = data.queries.find(q => q.name.toLowerCase() === opName);
+                if (!operation) {
+                    operation = data.mutations.find(m => m.name.toLowerCase() === opName);
+                }
+
+                if (!operation) {
+                    return {
+                        content: [{
+                            type: 'text',
+                            text: `Operation "${args.name}" not found. Use search_superops_api to find available operations.`
+                        }],
+                        isError: true
+                    };
+                }
+
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify(operation, null, 2)
+                    }]
+                };
+            }
+
+            case 'get_superops_type': {
+                const typeName = args.name.toLowerCase();
+                const type = data.types.find(t => t.name.toLowerCase() === typeName);
+
+                if (!type) {
+                    return {
+                        content: [{
+                            type: 'text',
+                            text: `Type "${args.name}" not found. Use search_superops_api to find available types.`
+                        }],
+                        isError: true
+                    };
+                }
+
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify(type, null, 2)
+                    }]
+                };
+            }
+
+            case 'list_superops_operations': {
+                const listType = args.type;
+                let result = {};
+
+                if (listType === 'queries' || listType === 'all') {
+                    result.queries = data.queries.map(q => ({
+                        name: q.name,
+                        description: q.description
+                    }));
+                }
+
+                if (listType === 'mutations' || listType === 'all') {
+                    result.mutations = data.mutations.map(m => ({
+                        name: m.name,
+                        description: m.description
+                    }));
+                }
+
+                result.meta = data.meta;
+
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2)
+                    }]
+                };
+            }
+
+            default:
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `Unknown tool: ${name}`
+                    }],
+                    isError: true
+                };
+        }
+    } catch (error) {
+        return {
+            content: [{
+                type: 'text',
+                text: `Error: ${error.message}`
+            }],
+            isError: true
+        };
+    }
+});
+
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+
+main().catch(console.error);