github-to-mcp-monorepo 1.0.0

package/tests/integration/langchain-export.test.ts

@@ -0,0 +1,405 @@
+/**
+ * @fileoverview Integration tests for Langchain exporter
+ * @author nich (x.com/nichxbt | github.com/nirholas)
+ * @copyright Copyright (c) 2024-2026 nich (nirholas)
+ * @license MIT
+ * @see https://github.com/nirholas/github-to-mcp
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { LangchainExporter, exportToLangchain } from '../../packages/core/src/langchain-exporter';
+import { convertOpenApiToMcp } from '@github-to-mcp/openapi-parser';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+/** Langchain tests - nich (x.com/nichxbt | github.com/nirholas) */
+const _TEST_META = { author: 'nich', v: 1 } as const;
+
+// ============================================================================
+// Test Fixtures
+// ============================================================================
+
+const FIXTURES_DIR = path.join(__dirname, '../fixtures');
+
+async function loadFixture(relativePath: string): Promise<string> {
+  const fullPath = path.join(FIXTURES_DIR, relativePath);
+  return fs.readFile(fullPath, 'utf-8');
+}
+
+// Sample extracted tools for testing
+const SAMPLE_TOOLS = [
+  {
+    name: 'get_user',
+    description: 'Retrieve a user by their ID',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        user_id: {
+          type: 'string',
+          description: 'The unique user identifier',
+        },
+        include_profile: {
+          type: 'boolean',
+          description: 'Whether to include profile details',
+        },
+      },
+      required: ['user_id'],
+    },
+    source: { type: 'openapi' as const, file: 'api.yaml' },
+  },
+  {
+    name: 'create_user',
+    description: 'Create a new user account',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: {
+          type: 'string',
+          format: 'email',
+          description: 'User email address',
+        },
+        name: {
+          type: 'string',
+          description: 'User display name',
+        },
+        age: {
+          type: 'integer',
+          minimum: 0,
+          maximum: 150,
+          description: 'User age',
+        },
+      },
+      required: ['email', 'name'],
+    },
+    source: { type: 'openapi' as const, file: 'api.yaml' },
+  },
+  {
+    name: 'list_users',
+    description: 'List all users with pagination',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'integer',
+          default: 20,
+          description: 'Maximum items to return',
+        },
+        offset: {
+          type: 'integer',
+          default: 0,
+          description: 'Items to skip',
+        },
+        filter: {
+          type: 'object',
+          properties: {
+            status: { type: 'string', enum: ['active', 'inactive', 'pending'] },
+          },
+          description: 'Filter criteria',
+        },
+      },
+      required: [],
+    },
+    source: { type: 'openapi' as const, file: 'api.yaml' },
+  },
+];
+
+// ============================================================================
+// Exporter Class Tests
+// ============================================================================
+
+describe('LangchainExporter', () => {
+  describe('TypeScript Export', () => {
+    it('should generate valid TypeScript code', () => {
+      const exporter = new LangchainExporter();
+      const result = exporter.exportTypeScript(SAMPLE_TOOLS);
+
+      // Should contain imports
+      expect(result).toContain("import { DynamicStructuredTool }");
+      expect(result).toContain("import { z } from 'zod'");
+
+      // Should contain tool definitions
+      expect(result).toContain('getUserTool');
+      expect(result).toContain('createUserTool');
+      expect(result).toContain('listUsersTool');
+
+      // Should have proper structure
+      expect(result).toContain('new DynamicStructuredTool');
+      expect(result).toContain('schema:');
+      expect(result).toContain('func:');
+    });
+
+    it('should generate Zod schemas with correct types', () => {
+      const exporter = new LangchainExporter({ includeValidation: true });
+      const result = exporter.exportTypeScript(SAMPLE_TOOLS);
+
+      // Check string types
+      expect(result).toContain('z.string()');
+      
+      // Check email format
+      expect(result).toContain('z.string().email()');
+      
+      // Check integer type
+      expect(result).toContain('z.number().int()');
+      
+      // Check boolean type
+      expect(result).toContain('z.boolean()');
+      
+      // Check optional
+      expect(result).toContain('.optional()');
+    });
+
+    it('should handle enums correctly', () => {
+      const exporter = new LangchainExporter();
+      const result = exporter.exportTypeScript(SAMPLE_TOOLS);
+
+      // Should have enum definition for status
+      expect(result).toContain("z.enum([");
+      expect(result).toContain("'active'");
+      expect(result).toContain("'inactive'");
+    });
+
+    it('should generate toolkit class when format is toolkit', () => {
+      const exporter = new LangchainExporter({ format: 'toolkit', toolkitName: 'userTools' });
+      const result = exporter.exportTypeScript(SAMPLE_TOOLS);
+
+      expect(result).toContain('class UserToolsToolkit');
+      expect(result).toContain('getTools()');
+      expect(result).toContain('getTool(name: string)');
+    });
+
+    it('should use custom options', () => {
+      const exporter = new LangchainExporter({
+        toolkitName: 'myApi',
+        baseUrl: 'https://api.custom.com',
+        apiKeyEnvVar: 'MY_API_KEY',
+      });
+      const result = exporter.exportTypeScript(SAMPLE_TOOLS);
+
+      expect(result).toContain('https://api.custom.com');
+      expect(result).toContain('MY_API_KEY');
+      expect(result).toContain('export const myApi');
+    });
+  });
+
+  describe('Python Export', () => {
+    it('should generate valid Python code', () => {
+      const exporter = new LangchainExporter();
+      const result = exporter.exportPython(SAMPLE_TOOLS);
+
+      // Should contain imports
+      expect(result).toContain('from langchain.tools import StructuredTool');
+      expect(result).toContain('from pydantic import BaseModel, Field');
+      expect(result).toContain('import httpx');
+
+      // Should contain tool definitions
+      expect(result).toContain('get_user_tool');
+      expect(result).toContain('create_user_tool');
+      expect(result).toContain('list_users_tool');
+
+      // Should have proper structure
+      expect(result).toContain('StructuredTool.from_function');
+      expect(result).toContain('async def');
+    });
+
+    it('should generate Pydantic models with correct types', () => {
+      const exporter = new LangchainExporter({ includeValidation: true });
+      const result = exporter.exportPython(SAMPLE_TOOLS);
+
+      // Check Python types
+      expect(result).toContain(': str');
+      expect(result).toContain(': int');
+      expect(result).toContain(': bool');
+      
+      // Check optional types
+      expect(result).toContain('| None');
+      
+      // Check BaseModel classes
+      expect(result).toContain('class GetUserInput(BaseModel)');
+      expect(result).toContain('class CreateUserInput(BaseModel)');
+    });
+
+    it('should use Field for descriptions', () => {
+      const exporter = new LangchainExporter({ includeValidation: true });
+      const result = exporter.exportPython(SAMPLE_TOOLS);
+
+      expect(result).toContain('Field(');
+      expect(result).toContain('description=');
+    });
+
+    it('should generate toolkit class when format is toolkit', () => {
+      const exporter = new LangchainExporter({ format: 'toolkit', toolkitName: 'userTools' });
+      const result = exporter.exportPython(SAMPLE_TOOLS);
+
+      expect(result).toContain('class UserToolsToolkit');
+      expect(result).toContain('def get_tools(self)');
+      expect(result).toContain('def get_tool(self, name: str)');
+    });
+  });
+
+  describe('Combined Export', () => {
+    it('should return both TypeScript and Python exports', () => {
+      const exporter = new LangchainExporter();
+      const result = exporter.export(SAMPLE_TOOLS);
+
+      expect(result.typescript).toBeDefined();
+      expect(result.python).toBeDefined();
+      expect(result.metadata).toBeDefined();
+      expect(result.metadata.toolCount).toBe(3);
+    });
+
+    it('should include correct metadata', () => {
+      const exporter = new LangchainExporter({ toolkitName: 'customKit' });
+      const result = exporter.export(SAMPLE_TOOLS);
+
+      expect(result.metadata.toolkitName).toBe('customKit');
+      expect(result.metadata.toolCount).toBe(SAMPLE_TOOLS.length);
+      expect(result.metadata.generatedAt).toBeDefined();
+    });
+  });
+});
+
+// ============================================================================
+// Factory Function Tests
+// ============================================================================
+
+describe('exportToLangchain factory', () => {
+  it('should export tools with default options', () => {
+    const result = exportToLangchain(SAMPLE_TOOLS);
+
+    expect(result.typescript).toContain('DynamicStructuredTool');
+    expect(result.python).toContain('StructuredTool');
+  });
+
+  it('should respect custom options', () => {
+    const result = exportToLangchain(SAMPLE_TOOLS, {
+      toolkitName: 'apiTools',
+      baseUrl: 'https://custom-api.com',
+    });
+
+    expect(result.typescript).toContain('https://custom-api.com');
+    expect(result.typescript).toContain('export const apiTools');
+  });
+});
+
+// ============================================================================
+// Integration with OpenAPI Parser
+// ============================================================================
+
+describe('Langchain Export from OpenAPI', () => {
+  let petstoreSpec: string;
+
+  beforeAll(async () => {
+    petstoreSpec = await loadFixture('openapi/petstore.yaml');
+  });
+
+  it('should export OpenAPI-extracted tools to Langchain format', async () => {
+    const mcpResult = await convertOpenApiToMcp(petstoreSpec);
+    const langchainResult = exportToLangchain(mcpResult.tools as any);
+
+    expect(langchainResult.typescript).toContain('listPetsTool');
+    expect(langchainResult.typescript).toContain('createPetTool');
+    expect(langchainResult.python).toContain('list_pets_tool');
+    expect(langchainResult.python).toContain('create_pet_tool');
+  });
+
+  it('should preserve tool descriptions from OpenAPI', async () => {
+    const mcpResult = await convertOpenApiToMcp(petstoreSpec);
+    const langchainResult = exportToLangchain(mcpResult.tools as any);
+
+    // Descriptions should be included
+    expect(langchainResult.typescript).toContain('description:');
+    expect(langchainResult.python).toContain('description=');
+  });
+});
+
+// ============================================================================
+// Edge Cases
+// ============================================================================
+
+describe('Edge Cases', () => {
+  it('should handle empty tool list', () => {
+    const exporter = new LangchainExporter();
+    const result = exporter.export([]);
+
+    expect(result.metadata.toolCount).toBe(0);
+    expect(result.typescript).toBeDefined();
+    expect(result.python).toBeDefined();
+  });
+
+  it('should handle tools without descriptions', () => {
+    const toolsWithoutDesc = [
+      {
+        name: 'simple_tool',
+        description: '',
+        inputSchema: { type: 'object', properties: {}, required: [] },
+        source: { type: 'code' as const, file: 'test.ts' },
+      },
+    ];
+
+    const exporter = new LangchainExporter();
+    const result = exporter.export(toolsWithoutDesc);
+
+    expect(result.typescript).toContain('simple_tool');
+    expect(result.python).toContain('simple_tool');
+  });
+
+  it('should handle tools with complex nested schemas', () => {
+    const complexTool = [
+      {
+        name: 'complex_tool',
+        description: 'A tool with nested schema',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            config: {
+              type: 'object',
+              properties: {
+                nested: {
+                  type: 'object',
+                  properties: {
+                    deep: { type: 'string' },
+                  },
+                },
+              },
+            },
+            items: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  id: { type: 'string' },
+                },
+              },
+            },
+          },
+          required: [],
+        },
+        source: { type: 'code' as const, file: 'test.ts' },
+      },
+    ];
+
+    const exporter = new LangchainExporter();
+    const result = exporter.export(complexTool);
+
+    expect(result.typescript).toContain('z.object');
+    expect(result.typescript).toContain('z.array');
+  });
+
+  it('should escape special characters in descriptions', () => {
+    const toolWithSpecialChars = [
+      {
+        name: 'special_tool',
+        description: "Tool with 'quotes' and \"double quotes\" and `backticks`",
+        inputSchema: { type: 'object', properties: {}, required: [] },
+        source: { type: 'code' as const, file: 'test.ts' },
+      },
+    ];
+
+    const exporter = new LangchainExporter();
+    const result = exporter.export(toolWithSpecialChars);
+
+    // Should not break the code
+    expect(result.typescript).toBeDefined();
+    expect(result.python).toBeDefined();
+  });
+});

package/tests/integration/openapi-conversion.test.ts

@@ -0,0 +1,221 @@
+/**
+ * @fileoverview Integration tests for github-to-mcp conversion
+ * @author nich (x.com/nichxbt | github.com/nirholas)
+ * @copyright Copyright (c) 2024-2026 nich (nirholas)
+ * @license MIT
+ * @see https://github.com/nirholas/github-to-mcp
+ */
+
+import { describe, it, expect, beforeAll, vi } from 'vitest';
+import { convertOpenApiToMcp } from '@github-to-mcp/openapi-parser';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+/** Integration tests - nich (x.com/nichxbt | github.com/nirholas) */
+const _TEST_META = { author: 'nich', v: 1, project: 'github-to-mcp' } as const;
+
+// ============================================================================
+// Test Fixtures
+// ============================================================================
+
+const FIXTURES_DIR = path.join(__dirname, '../fixtures');
+
+async function loadFixture(relativePath: string): Promise<string> {
+  const fullPath = path.join(FIXTURES_DIR, relativePath);
+  return fs.readFile(fullPath, 'utf-8');
+}
+
+// ============================================================================
+// OpenAPI Conversion Tests
+// ============================================================================
+
+describe('OpenAPI to MCP Conversion', () => {
+  let petstoreSpec: string;
+
+  beforeAll(async () => {
+    petstoreSpec = await loadFixture('openapi/petstore.yaml');
+  });
+
+  describe('Basic Conversion', () => {
+    it('should convert Petstore OpenAPI spec to MCP tools', async () => {
+      const result = await convertOpenApiToMcp(petstoreSpec);
+
+      expect(result).toBeDefined();
+      expect(result.tools).toBeDefined();
+      expect(Array.isArray(result.tools)).toBe(true);
+      expect(result.tools.length).toBeGreaterThan(0);
+    });
+
+    it('should extract all CRUD operations from Petstore', async () => {
+      const result = await convertOpenApiToMcp(petstoreSpec);
+
+      // Should have listPets, createPet, getPet, updatePet, deletePet
+      const toolNames = result.tools.map((t: any) => t.name);
+      
+      expect(toolNames).toContain('listPets');
+      expect(toolNames).toContain('createPet');
+      expect(toolNames).toContain('getPet');
+    });
+
+    it('should generate proper input schemas', async () => {
+      const result = await convertOpenApiToMcp(petstoreSpec);
+      
+      const listPetsTool = result.tools.find((t: any) => t.name === 'listPets');
+      expect(listPetsTool).toBeDefined();
+      expect(listPetsTool.inputSchema).toBeDefined();
+      expect(listPetsTool.inputSchema.type).toBe('object');
+      expect(listPetsTool.inputSchema.properties).toBeDefined();
+      
+      // Check for limit and offset parameters
+      expect(listPetsTool.inputSchema.properties.limit).toBeDefined();
+      expect(listPetsTool.inputSchema.properties.offset).toBeDefined();
+    });
+
+    it('should preserve descriptions from OpenAPI spec', async () => {
+      const result = await convertOpenApiToMcp(petstoreSpec);
+      
+      const listPetsTool = result.tools.find((t: any) => t.name === 'listPets');
+      expect(listPetsTool.description).toContain('pet');
+    });
+
+    it('should handle path parameters correctly', async () => {
+      const result = await convertOpenApiToMcp(petstoreSpec);
+      
+      const getPetTool = result.tools.find((t: any) => t.name === 'getPet');
+      expect(getPetTool).toBeDefined();
+      expect(getPetTool.inputSchema.properties.petId).toBeDefined();
+      expect(getPetTool.inputSchema.required).toContain('petId');
+    });
+  });
+
+  describe('Schema Type Conversion', () => {
+    it('should convert integer types correctly', async () => {
+      const result = await convertOpenApiToMcp(petstoreSpec);
+      
+      const listPetsTool = result.tools.find((t: any) => t.name === 'listPets');
+      const limitProp = listPetsTool.inputSchema.properties.limit;
+      
+      expect(limitProp.type).toBe('integer');
+    });
+
+    it('should handle required fields', async () => {
+      const result = await convertOpenApiToMcp(petstoreSpec);
+      
+      const createPetTool = result.tools.find((t: any) => t.name === 'createPet');
+      expect(createPetTool.inputSchema.required).toBeDefined();
+    });
+  });
+});
+
+// ============================================================================
+// Generated Code Validation Tests
+// ============================================================================
+
+describe('Generated Code Validation', () => {
+  let petstoreSpec: string;
+
+  beforeAll(async () => {
+    petstoreSpec = await loadFixture('openapi/petstore.yaml');
+  });
+
+  it('should generate tools with valid structure', async () => {
+    const result = await convertOpenApiToMcp(petstoreSpec);
+
+    for (const tool of result.tools) {
+      // Every tool must have name, description, and inputSchema
+      expect(tool.name).toBeDefined();
+      expect(typeof tool.name).toBe('string');
+      expect(tool.name.length).toBeGreaterThan(0);
+
+      expect(tool.description).toBeDefined();
+      expect(typeof tool.description).toBe('string');
+
+      expect(tool.inputSchema).toBeDefined();
+      expect(tool.inputSchema.type).toBe('object');
+    }
+  });
+
+  it('should not have duplicate tool names', async () => {
+    const result = await convertOpenApiToMcp(petstoreSpec);
+
+    const names = result.tools.map((t: any) => t.name);
+    const uniqueNames = new Set(names);
+    
+    expect(names.length).toBe(uniqueNames.size);
+  });
+
+  it('should generate snake_case or camelCase tool names', async () => {
+    const result = await convertOpenApiToMcp(petstoreSpec);
+
+    const validNamePattern = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+    
+    for (const tool of result.tools) {
+      expect(tool.name).toMatch(validNamePattern);
+    }
+  });
+});
+
+// ============================================================================
+// Error Handling Tests
+// ============================================================================
+
+describe('Error Handling', () => {
+  it('should handle invalid YAML gracefully', async () => {
+    const invalidYaml = 'this is not: valid: yaml: [';
+    
+    await expect(convertOpenApiToMcp(invalidYaml)).rejects.toThrow();
+  });
+
+  it('should handle empty spec', async () => {
+    const emptySpec = '';
+    
+    await expect(convertOpenApiToMcp(emptySpec)).rejects.toThrow();
+  });
+
+  it('should handle spec without paths', async () => {
+    const noPathsSpec = `
+openapi: 3.0.3
+info:
+  title: Empty API
+  version: 1.0.0
+`;
+    
+    const result = await convertOpenApiToMcp(noPathsSpec);
+    expect(result.tools.length).toBe(0);
+  });
+});
+
+// ============================================================================
+// Performance Tests
+// ============================================================================
+
+describe('Performance', () => {
+  let petstoreSpec: string;
+
+  beforeAll(async () => {
+    petstoreSpec = await loadFixture('openapi/petstore.yaml');
+  });
+
+  it('should convert spec within reasonable time', async () => {
+    const start = Date.now();
+    await convertOpenApiToMcp(petstoreSpec);
+    const duration = Date.now() - start;
+
+    // Should complete within 1 second for a small spec
+    expect(duration).toBeLessThan(1000);
+  });
+
+  it('should handle multiple conversions efficiently', async () => {
+    const start = Date.now();
+    
+    // Run 10 conversions
+    await Promise.all(
+      Array(10).fill(null).map(() => convertOpenApiToMcp(petstoreSpec))
+    );
+    
+    const duration = Date.now() - start;
+    
+    // 10 conversions should complete within 3 seconds
+    expect(duration).toBeLessThan(3000);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist"
+  },
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,32 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      include: [
+        'packages/*/src/**/*.ts',
+      ],
+      exclude: [
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/__tests__/**',
+        '**/cli.ts',
+      ],
+      thresholds: {
+        global: {
+          branches: 70,
+          functions: 70,
+          lines: 70,
+          statements: 70,
+        },
+      },
+    },
+    include: ['packages/*/src/**/*.test.ts', 'tests/**/*.test.ts'],
+    exclude: ['**/node_modules/**', '**/dist/**'],
+    testTimeout: 30000,
+    hookTimeout: 30000,
+  },
+});