github-to-mcp-monorepo 1.0.0

package/packages/mcp-server/src/__tests__/mcp-server.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the MCP SDK modules
+vi.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+  Server: vi.fn().mockImplementation(() => ({
+    setRequestHandler: vi.fn(),
+    connect: vi.fn().mockResolvedValue(undefined),
+  })),
+}));
+
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
+  StdioServerTransport: vi.fn().mockImplementation(() => ({})),
+}));
+
+vi.mock('@modelcontextprotocol/sdk/types.js', () => ({
+  CallToolRequestSchema: Symbol('CallToolRequestSchema'),
+  ListToolsRequestSchema: Symbol('ListToolsRequestSchema'),
+  ListResourcesRequestSchema: Symbol('ListResourcesRequestSchema'),
+  ReadResourceRequestSchema: Symbol('ReadResourceRequestSchema'),
+}));
+
+describe('MCP Server', () => {
+  describe('Tool Definitions', () => {
+    it('should define convert_repo tool', async () => {
+      // Import the tools by reading the source
+      // This is a basic structure test
+      const tools = [
+        'convert_repo',
+        'list_extracted_tools',
+        'validate_mcp_server',
+        'generate_claude_config',
+        'generate_cursor_config',
+        'analyze_repo_structure',
+        'convert_openapi_to_mcp',
+        'get_tool_template',
+      ];
+      
+      expect(tools).toContain('convert_repo');
+      expect(tools).toContain('list_extracted_tools');
+      expect(tools).toContain('validate_mcp_server');
+      expect(tools.length).toBe(8);
+    });
+  });
+
+  describe('Config Generation', () => {
+    it('should generate valid Claude Desktop config structure', () => {
+      const serverName = 'test-server';
+      const serverPath = '/path/to/server.js';
+      const language = 'typescript';
+      
+      const config = {
+        mcpServers: {
+          [serverName]: {
+            command: language === 'python' ? 'python' : 'node',
+            args: [serverPath],
+          },
+        },
+      };
+      
+      expect(config.mcpServers[serverName]).toBeDefined();
+      expect(config.mcpServers[serverName].command).toBe('node');
+      expect(config.mcpServers[serverName].args).toEqual([serverPath]);
+    });
+
+    it('should use python command for Python servers', () => {
+      const language = 'python';
+      const command = language === 'python' ? 'python' : 'node';
+      
+      expect(command).toBe('python');
+    });
+  });
+
+  describe('Validation Logic', () => {
+    it('should detect missing tool definitions in TypeScript', () => {
+      const code = `
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+const server = new Server();
+// No ListToolsRequestSchema handler
+`;
+      
+      const hasToolDefs = code.includes('ListToolsRequestSchema') || code.includes('tools:');
+      expect(hasToolDefs).toBe(false);
+    });
+
+    it('should pass validation for proper TypeScript MCP server', () => {
+      const code = `
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+
+const server = new Server();
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [{
+    name: 'test',
+    description: 'Test tool',
+    inputSchema: { type: 'object', properties: {} }
+  }]
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  return { content: [] };
+});
+`;
+      
+      const hasListTools = code.includes('ListToolsRequestSchema');
+      const hasCallTool = code.includes('CallToolRequestSchema');
+      const hasDescription = code.includes('description');
+      const hasInputSchema = code.includes('inputSchema');
+      
+      expect(hasListTools).toBe(true);
+      expect(hasCallTool).toBe(true);
+      expect(hasDescription).toBe(true);
+      expect(hasInputSchema).toBe(true);
+    });
+
+    it('should detect missing tool definitions in Python', () => {
+      const code = `
+from mcp.server import Server
+server = Server("test")
+# No @mcp.tool decorator
+`;
+      
+      const hasToolDefs = code.includes('@mcp.tool') || code.includes('list_tools');
+      expect(hasToolDefs).toBe(false);
+    });
+  });
+
+  describe('Template Generation', () => {
+    it('should include required tool structure in TypeScript template', () => {
+      const toolName = 'my_tool';
+      const description = 'Does something useful';
+      
+      // Simulate template structure check
+      const requiredElements = [
+        '@modelcontextprotocol/sdk',
+        'ListToolsRequestSchema',
+        'CallToolRequestSchema',
+        'inputSchema',
+        'description',
+      ];
+      
+      // A proper template would include all these
+      requiredElements.forEach(element => {
+        expect(typeof element).toBe('string');
+      });
+    });
+
+    it('should include required tool structure in Python template', () => {
+      const requiredElements = [
+        'from mcp.server import Server',
+        '@server.list_tools()',
+        '@server.call_tool()',
+        'Tool(',
+        'inputSchema',
+      ];
+      
+      requiredElements.forEach(element => {
+        expect(typeof element).toBe('string');
+      });
+    });
+  });
+
+  describe('Resource URIs', () => {
+    it('should have valid resource URI scheme', () => {
+      const resourceUris = [
+        'github-to-mcp://docs/quick-start',
+        'github-to-mcp://docs/extraction-sources',
+        'github-to-mcp://examples/typescript',
+        'github-to-mcp://examples/python',
+      ];
+      
+      resourceUris.forEach(uri => {
+        expect(uri.startsWith('github-to-mcp://')).toBe(true);
+      });
+    });
+  });
+});

package/packages/mcp-server/src/__tests__/tools.test.ts

@@ -0,0 +1,217 @@
+/**
+ * Tests for MCP server tools
+ */
+import { describe, it, expect } from 'vitest';
+import {
+  generateOpenApiTool,
+  handleGenerateOpenApi,
+} from '../tools/generate-openapi.js';
+import {
+  exportDockerTool,
+  handleExportDocker,
+} from '../tools/export-docker.js';
+import {
+  streamConvertTool,
+  listProvidersTool,
+  handleListProviders,
+  SUPPORTED_PROVIDERS,
+} from '../tools/stream-convert.js';
+
+describe('MCP Server Tools', () => {
+  describe('generate_openapi_spec tool', () => {
+    it('should have correct tool definition', () => {
+      expect(generateOpenApiTool.name).toBe('generate_openapi_spec');
+      expect(generateOpenApiTool.description).toContain('OpenAPI 3.1');
+      expect(generateOpenApiTool.inputSchema.properties).toHaveProperty('files');
+      expect(generateOpenApiTool.inputSchema.required).toContain('files');
+    });
+
+    it('should generate OpenAPI spec from Express code', async () => {
+      const result = await handleGenerateOpenApi({
+        files: [
+          {
+            path: 'app.js',
+            content: `
+const express = require('express');
+const app = express();
+
+/**
+ * Get all users
+ * @tag Users
+ */
+app.get('/users', (req, res) => {
+  res.json([]);
+});
+
+/**
+ * Create user
+ * @tag Users
+ */
+app.post('/users', (req, res) => {
+  res.status(201).json(req.body);
+});
+            `,
+          },
+        ],
+        format: 'both',
+      });
+
+      expect(result.type).toBe('text');
+      expect(result.text).toContain('Generated OpenAPI Specification');
+      expect(result.text).toContain('Framework Detected');
+      expect(result.text).toContain('/users');
+    });
+
+    it('should handle empty files', async () => {
+      const result = await handleGenerateOpenApi({
+        files: [
+          {
+            path: 'empty.js',
+            content: '// No routes here',
+          },
+        ],
+      });
+
+      expect(result.type).toBe('text');
+      // Should still return a valid result with warnings
+    });
+  });
+
+  describe('export_docker tool', () => {
+    it('should have correct tool definition', () => {
+      expect(exportDockerTool.name).toBe('export_docker');
+      expect(exportDockerTool.description).toContain('Docker');
+      expect(exportDockerTool.inputSchema.properties).toHaveProperty('language');
+      expect(exportDockerTool.inputSchema.required).toContain('language');
+    });
+
+    it('should generate TypeScript Docker config', async () => {
+      const result = await handleExportDocker({
+        language: 'typescript',
+        server_name: 'my-mcp-server',
+      });
+
+      expect(result.type).toBe('text');
+      expect(result.text).toContain('Dockerfile');
+      expect(result.text).toContain('docker-compose.yml');
+      expect(result.text).toContain('.dockerignore');
+      expect(result.text).toContain('node:20-slim');
+      expect(result.text).toContain('my-mcp-server');
+    });
+
+    it('should generate Python Docker config', async () => {
+      const result = await handleExportDocker({
+        language: 'python',
+        server_name: 'py-mcp-server',
+      });
+
+      expect(result.type).toBe('text');
+      expect(result.text).toContain('python:3.11-slim');
+      expect(result.text).toContain('requirements.txt');
+      expect(result.text).toContain('py-mcp-server');
+    });
+
+    it('should include healthcheck when requested', async () => {
+      const result = await handleExportDocker({
+        language: 'typescript',
+        include_healthcheck: true,
+      });
+
+      expect(result.text).toContain('HEALTHCHECK');
+    });
+
+    it('should include port mapping when specified', async () => {
+      const result = await handleExportDocker({
+        language: 'typescript',
+        port: 3000,
+      });
+
+      expect(result.text).toContain('3000:3000');
+    });
+
+    it('should include environment variables', async () => {
+      const result = await handleExportDocker({
+        language: 'typescript',
+        env_vars: {
+          API_KEY: 'secret',
+          DEBUG: 'true',
+        },
+      });
+
+      expect(result.text).toContain('API_KEY=secret');
+      expect(result.text).toContain('DEBUG=true');
+    });
+  });
+
+  describe('stream_convert tool', () => {
+    it('should have correct tool definition', () => {
+      expect(streamConvertTool.name).toBe('stream_convert');
+      expect(streamConvertTool.description).toContain('streaming');
+      expect(streamConvertTool.inputSchema.properties).toHaveProperty('github_url');
+      expect(streamConvertTool.inputSchema.required).toContain('github_url');
+    });
+  });
+
+  describe('list_providers tool', () => {
+    it('should have correct tool definition', () => {
+      expect(listProvidersTool.name).toBe('list_providers');
+      expect(listProvidersTool.description).toContain('AI providers');
+    });
+
+    it('should list all supported providers', async () => {
+      const result = await handleListProviders({});
+
+      expect(result.type).toBe('text');
+      expect(result.text).toContain('Supported AI Providers');
+      
+      for (const provider of SUPPORTED_PROVIDERS) {
+        expect(result.text).toContain(provider.name);
+      }
+    });
+
+    it('should include example configurations', async () => {
+      const result = await handleListProviders({
+        include_examples: true,
+      });
+
+      expect(result.text).toContain('Example Configuration');
+      expect(result.text).toContain('mcpServers');
+    });
+
+    it('should hide examples when not requested', async () => {
+      const result = await handleListProviders({
+        include_examples: false,
+      });
+
+      expect(result.text).not.toContain('Example Configuration');
+    });
+  });
+
+  describe('SUPPORTED_PROVIDERS', () => {
+    it('should include Claude Desktop', () => {
+      const claude = SUPPORTED_PROVIDERS.find(p => p.id === 'claude-desktop');
+      expect(claude).toBeDefined();
+      expect(claude?.configFormat).toBe('json');
+    });
+
+    it('should include Cursor', () => {
+      const cursor = SUPPORTED_PROVIDERS.find(p => p.id === 'cursor');
+      expect(cursor).toBeDefined();
+    });
+
+    it('should include VS Code Copilot', () => {
+      const vscode = SUPPORTED_PROVIDERS.find(p => p.id === 'vscode-copilot');
+      expect(vscode).toBeDefined();
+    });
+
+    it('should have all required fields', () => {
+      for (const provider of SUPPORTED_PROVIDERS) {
+        expect(provider.name).toBeDefined();
+        expect(provider.id).toBeDefined();
+        expect(provider.description).toBeDefined();
+        expect(provider.configFormat).toBeDefined();
+        expect(provider.configPath).toBeDefined();
+      }
+    });
+  });
+});