github-to-mcp-monorepo 1.0.0

package/packages/core/src/__tests__/plugins.test.ts

@@ -0,0 +1,467 @@
+/**
+ * @fileoverview Unit tests for plugin system
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  PluginManager,
+  PluginRegistry,
+  ExtractorPlugin,
+  PluginRepoContext,
+  PluginDetectionResult,
+  PluginExtractionResult
+} from '../plugins';
+
+// Create a mock plugin factory
+function createMockPlugin(overrides: Partial<ExtractorPlugin> = {}): ExtractorPlugin {
+  return {
+    metadata: {
+      id: 'mock-plugin',
+      name: 'Mock Plugin',
+      version: '1.0.0',
+      description: 'A mock plugin for testing'
+    },
+    detect: vi.fn().mockResolvedValue({
+      shouldProcess: true,
+      confidence: 0.8,
+      reason: 'Mock detection'
+    }),
+    extract: vi.fn().mockResolvedValue({
+      tools: [
+        {
+          name: 'mock_tool',
+          description: 'A mock tool',
+          inputSchema: { type: 'object', properties: {}, required: [] },
+          source: { type: 'code', file: 'mock.ts' }
+        }
+      ],
+      sourceFiles: ['mock.ts']
+    }),
+    ...overrides
+  };
+}
+
+// Create mock repo context
+function createMockContext(): PluginRepoContext {
+  return {
+    owner: 'test',
+    repo: 'repo',
+    url: 'https://github.com/test/repo',
+    classification: {
+      type: 'library',
+      confidence: 0.7,
+      indicators: ['test']
+    },
+    metadata: {
+      stars: 100,
+      language: 'TypeScript'
+    }
+  };
+}
+
+describe('PluginRegistry', () => {
+  let registry: PluginRegistry;
+
+  beforeEach(() => {
+    registry = new PluginRegistry();
+  });
+
+  afterEach(async () => {
+    await registry.clear();
+  });
+
+  describe('register', () => {
+    it('should register a plugin', () => {
+      const plugin = createMockPlugin();
+      registry.register(plugin);
+
+      expect(registry.has('mock-plugin')).toBe(true);
+      expect(registry.get('mock-plugin')).toBe(plugin);
+    });
+
+    it('should call onRegister hook', () => {
+      const onRegister = vi.fn();
+      const plugin = createMockPlugin({
+        hooks: { onRegister }
+      });
+
+      registry.register(plugin);
+
+      expect(onRegister).toHaveBeenCalled();
+    });
+
+    it('should accept configuration', () => {
+      const plugin = createMockPlugin();
+      const config = { option1: 'value1' };
+
+      registry.register(plugin, config);
+
+      expect(registry.getConfig('mock-plugin')).toEqual(config);
+    });
+  });
+
+  describe('unregister', () => {
+    it('should unregister a plugin', async () => {
+      const plugin = createMockPlugin();
+      registry.register(plugin);
+
+      const result = await registry.unregister('mock-plugin');
+
+      expect(result).toBe(true);
+      expect(registry.has('mock-plugin')).toBe(false);
+    });
+
+    it('should call onUnregister hook', async () => {
+      const onUnregister = vi.fn();
+      const plugin = createMockPlugin({
+        hooks: { onUnregister }
+      });
+
+      registry.register(plugin);
+      await registry.unregister('mock-plugin');
+
+      expect(onUnregister).toHaveBeenCalled();
+    });
+
+    it('should return false for non-existent plugin', async () => {
+      const result = await registry.unregister('non-existent');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('list', () => {
+    it('should list all registered plugins', () => {
+      const plugin1 = createMockPlugin({ metadata: { id: 'plugin-1', name: 'Plugin 1', version: '1.0.0', description: 'Test' } });
+      const plugin2 = createMockPlugin({ metadata: { id: 'plugin-2', name: 'Plugin 2', version: '2.0.0', description: 'Test' } });
+
+      registry.register(plugin1);
+      registry.register(plugin2);
+
+      const list = registry.list();
+
+      expect(list.length).toBe(2);
+      expect(list.map(p => p.id)).toContain('plugin-1');
+      expect(list.map(p => p.id)).toContain('plugin-2');
+    });
+
+    it('should include enabled status', () => {
+      const plugin = createMockPlugin();
+      registry.register(plugin);
+
+      const list = registry.list();
+
+      expect(list[0].enabled).toBe(true);
+    });
+  });
+
+  describe('enable/disable', () => {
+    it('should disable a plugin', () => {
+      const plugin = createMockPlugin();
+      registry.register(plugin);
+
+      registry.disable('mock-plugin');
+
+      const entry = registry.getEntry('mock-plugin');
+      expect(entry?.enabled).toBe(false);
+    });
+
+    it('should enable a disabled plugin', () => {
+      const plugin = createMockPlugin();
+      registry.register(plugin);
+      registry.disable('mock-plugin');
+
+      registry.enable('mock-plugin');
+
+      const entry = registry.getEntry('mock-plugin');
+      expect(entry?.enabled).toBe(true);
+    });
+
+    it('should return false for non-existent plugin', () => {
+      expect(registry.disable('non-existent')).toBe(false);
+      expect(registry.enable('non-existent')).toBe(false);
+    });
+  });
+
+  describe('getEnabled', () => {
+    it('should return only enabled plugins', () => {
+      const plugin1 = createMockPlugin({ metadata: { id: 'plugin-1', name: 'Plugin 1', version: '1.0.0', description: 'Test' } });
+      const plugin2 = createMockPlugin({ metadata: { id: 'plugin-2', name: 'Plugin 2', version: '2.0.0', description: 'Test' } });
+
+      registry.register(plugin1);
+      registry.register(plugin2);
+      registry.disable('plugin-2');
+
+      const enabled = registry.getEnabled();
+
+      expect(enabled.length).toBe(1);
+      expect(enabled[0].metadata.id).toBe('plugin-1');
+    });
+  });
+
+  describe('updateConfig', () => {
+    it('should update plugin configuration', () => {
+      const plugin = createMockPlugin();
+      registry.register(plugin, { option1: 'value1' });
+
+      registry.updateConfig('mock-plugin', { option2: 'value2' });
+
+      expect(registry.getConfig('mock-plugin')).toEqual({
+        option1: 'value1',
+        option2: 'value2'
+      });
+    });
+
+    it('should validate config against schema', () => {
+      const plugin = createMockPlugin({
+        configSchema: [
+          { name: 'requiredOption', type: 'string', description: 'Required', required: true }
+        ]
+      });
+      registry.register(plugin);
+
+      expect(() => registry.updateConfig('mock-plugin', {})).toThrow('Missing required config option');
+    });
+  });
+
+  describe('events', () => {
+    it('should emit events on registration', () => {
+      const handler = vi.fn();
+      registry.on(handler);
+
+      const plugin = createMockPlugin();
+      registry.register(plugin);
+
+      expect(handler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'registered',
+          pluginId: 'mock-plugin'
+        })
+      );
+    });
+
+    it('should emit events on unregistration', async () => {
+      const plugin = createMockPlugin();
+      registry.register(plugin);
+
+      const handler = vi.fn();
+      registry.on(handler);
+
+      await registry.unregister('mock-plugin');
+
+      expect(handler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'unregistered',
+          pluginId: 'mock-plugin'
+        })
+      );
+    });
+
+    it('should allow unsubscribing', () => {
+      const handler = vi.fn();
+      const unsubscribe = registry.on(handler);
+
+      unsubscribe();
+
+      const plugin = createMockPlugin();
+      registry.register(plugin);
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('stats', () => {
+    it('should return registry statistics', () => {
+      const plugin1 = createMockPlugin({ metadata: { id: 'plugin-1', name: 'Plugin 1', version: '1.0.0', description: 'Test' } });
+      const plugin2 = createMockPlugin({ metadata: { id: 'plugin-2', name: 'Plugin 2', version: '2.0.0', description: 'Test' } });
+
+      registry.register(plugin1);
+      registry.register(plugin2);
+      registry.disable('plugin-2');
+
+      const stats = registry.stats();
+
+      expect(stats.total).toBe(2);
+      expect(stats.enabled).toBe(1);
+      expect(stats.disabled).toBe(1);
+      expect(stats.bySource.inline).toBe(2);
+    });
+  });
+});
+
+describe('PluginManager', () => {
+  let manager: PluginManager;
+  let registry: PluginRegistry;
+
+  beforeEach(() => {
+    registry = new PluginRegistry();
+    manager = new PluginManager({ verbose: false }, registry);
+  });
+
+  afterEach(async () => {
+    await manager.clearPlugins();
+  });
+
+  describe('registerPlugin', () => {
+    it('should register a plugin', () => {
+      const plugin = createMockPlugin();
+      manager.registerPlugin(plugin);
+
+      const list = manager.listPlugins();
+      expect(list.length).toBe(1);
+      expect(list[0].id).toBe('mock-plugin');
+    });
+  });
+
+  describe('unregisterPlugin', () => {
+    it('should unregister a plugin', async () => {
+      const plugin = createMockPlugin();
+      manager.registerPlugin(plugin);
+
+      const result = await manager.unregisterPlugin('mock-plugin');
+
+      expect(result).toBe(true);
+      expect(manager.listPlugins().length).toBe(0);
+    });
+  });
+
+  describe('detectPlugins', () => {
+    it('should detect which plugins should process the repo', async () => {
+      const plugin = createMockPlugin();
+      manager.registerPlugin(plugin);
+
+      const context = createMockContext();
+      const results = await manager.detectPlugins(context, ['file1.ts', 'file2.ts']);
+
+      expect(results.get('mock-plugin')).toBeDefined();
+      expect(results.get('mock-plugin')?.shouldProcess).toBe(true);
+    });
+
+    it('should handle detection errors gracefully', async () => {
+      const plugin = createMockPlugin({
+        detect: vi.fn().mockRejectedValue(new Error('Detection failed'))
+      });
+      manager.registerPlugin(plugin);
+
+      const context = createMockContext();
+      const results = await manager.detectPlugins(context, []);
+
+      expect(results.get('mock-plugin')?.shouldProcess).toBe(false);
+    });
+  });
+
+  describe('extract', () => {
+    it('should run extraction with applicable plugins', async () => {
+      const plugin = createMockPlugin();
+      manager.registerPlugin(plugin);
+
+      const context = createMockContext();
+      const getFile = vi.fn().mockResolvedValue('file content');
+
+      const { tools, results, errors } = await manager.extract(context, getFile, ['file.ts']);
+
+      expect(tools.length).toBe(1);
+      expect(tools[0].name).toBe('mock_tool');
+      expect(results.get('mock-plugin')).toBeDefined();
+      expect(errors.size).toBe(0);
+    });
+
+    it('should skip plugins that should not process', async () => {
+      const plugin = createMockPlugin({
+        detect: vi.fn().mockResolvedValue({
+          shouldProcess: false,
+          confidence: 0,
+          reason: 'Not applicable'
+        })
+      });
+      manager.registerPlugin(plugin);
+
+      const context = createMockContext();
+      const getFile = vi.fn();
+
+      const { tools } = await manager.extract(context, getFile, []);
+
+      expect(tools.length).toBe(0);
+      expect(plugin.extract).not.toHaveBeenCalled();
+    });
+
+    it('should handle extraction errors', async () => {
+      const plugin = createMockPlugin({
+        extract: vi.fn().mockRejectedValue(new Error('Extraction failed'))
+      });
+      manager.registerPlugin(plugin);
+
+      const context = createMockContext();
+      const getFile = vi.fn();
+
+      const { errors } = await manager.extract(context, getFile, []);
+
+      expect(errors.get('mock-plugin')).toBeDefined();
+      expect(errors.get('mock-plugin')?.message).toBe('Extraction failed');
+    });
+
+    it('should call lifecycle hooks', async () => {
+      const beforeExtract = vi.fn();
+      const afterExtract = vi.fn();
+      const plugin = createMockPlugin({
+        hooks: { beforeExtract, afterExtract }
+      });
+      manager.registerPlugin(plugin);
+
+      const context = createMockContext();
+      const getFile = vi.fn();
+
+      await manager.extract(context, getFile, []);
+
+      expect(beforeExtract).toHaveBeenCalledWith(context);
+      expect(afterExtract).toHaveBeenCalled();
+    });
+  });
+
+  describe('extractWithPlugin', () => {
+    it('should run extraction with a specific plugin', async () => {
+      const plugin = createMockPlugin();
+      manager.registerPlugin(plugin);
+
+      const context = createMockContext();
+      const getFile = vi.fn();
+
+      const result = await manager.extractWithPlugin('mock-plugin', context, getFile);
+
+      expect(result.tools.length).toBe(1);
+    });
+
+    it('should throw for non-existent plugin', async () => {
+      const context = createMockContext();
+      const getFile = vi.fn();
+
+      await expect(
+        manager.extractWithPlugin('non-existent', context, getFile)
+      ).rejects.toThrow('Plugin not found');
+    });
+  });
+
+  describe('enablePlugin/disablePlugin', () => {
+    it('should enable and disable plugins', () => {
+      const plugin = createMockPlugin();
+      manager.registerPlugin(plugin);
+
+      manager.disablePlugin('mock-plugin');
+      expect(manager.listPlugins()[0].enabled).toBe(false);
+
+      manager.enablePlugin('mock-plugin');
+      expect(manager.listPlugins()[0].enabled).toBe(true);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return statistics', () => {
+      const plugin = createMockPlugin();
+      manager.registerPlugin(plugin);
+
+      const stats = manager.getStats();
+
+      expect(stats.total).toBe(1);
+      expect(stats.enabled).toBe(1);
+    });
+  });
+});

package/packages/core/src/__tests__/readme-extractor.test.ts

@@ -0,0 +1,258 @@
+/**
+ * @fileoverview Unit tests for readme-extractor module
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ReadmeExtractor } from '../readme-extractor';
+
+describe('ReadmeExtractor', () => {
+  let extractor: ReadmeExtractor;
+
+  beforeEach(() => {
+    extractor = new ReadmeExtractor();
+  });
+
+  describe('extract', () => {
+    it('should extract tools from JavaScript code examples', async () => {
+      const readme = `
+# API Client
+
+## Usage
+
+\`\`\`javascript
+const result = await client.get({ id: 123, name: 'test' });
+\`\`\`
+      `;
+
+      const tools = await extractor.extract(readme);
+
+      expect(tools.length).toBeGreaterThan(0);
+      expect(tools[0].source.type).toBe('readme');
+    });
+
+    it('should extract Python MCP tools from code blocks', async () => {
+      const readme = `
+# MCP Server
+
+\`\`\`python
+@mcp.tool(name="GetWeather", description="Get weather for a location")
+async def get_weather(city: str):
+    pass
+\`\`\`
+      `;
+
+      const tools = await extractor.extract(readme);
+
+      expect(tools.length).toBeGreaterThan(0);
+      const weatherTool = tools.find(t => t.name === 'GetWeather');
+      expect(weatherTool).toBeDefined();
+      expect(weatherTool?.description).toBe('Get weather for a location');
+    });
+
+    it('should extract tools from markdown lists in Tools section', async () => {
+      const readme = `
+# My Tool
+
+## Available Tools
+
+- **Edit**: Edit files in the repository
+- **View**: View file contents
+- **Search**: Search for patterns in files
+      `;
+
+      const tools = await extractor.extract(readme);
+
+      expect(tools.length).toBeGreaterThan(0);
+      const editTool = tools.find(t => t.name === 'Edit');
+      expect(editTool).toBeDefined();
+      expect(editTool?.description).toContain('Edit');
+    });
+
+    it('should handle empty README', async () => {
+      const tools = await extractor.extract('');
+      expect(tools).toEqual([]);
+    });
+
+    it('should handle README with no code examples', async () => {
+      const readme = `
+# Project Title
+
+This is a project description.
+
+## Installation
+
+Run \`npm install\`.
+      `;
+
+      const tools = await extractor.extract(readme);
+      // May return empty or minimal tools
+      expect(Array.isArray(tools)).toBe(true);
+    });
+
+    it('should extract from TypeScript code blocks', async () => {
+      const readme = `
+## Examples
+
+\`\`\`typescript
+const response = await api.create({ name: 'New Item', value: 42 });
+\`\`\`
+      `;
+
+      const tools = await extractor.extract(readme);
+
+      expect(tools.length).toBeGreaterThan(0);
+    });
+
+    it('should extract multiple API calls from same block', async () => {
+      const readme = `
+## API
+
+\`\`\`javascript
+// Get user
+await client.get({ userId: 1 });
+
+// Create user
+await client.post({ name: 'John', email: 'john@example.com' });
+\`\`\`
+      `;
+
+      const tools = await extractor.extract(readme);
+
+      // Should extract at least the first API call
+      expect(tools.length).toBeGreaterThan(0);
+    });
+
+    it('should parse parameters from object literals', async () => {
+      const readme = `
+\`\`\`javascript
+await client.fetch({ 
+  query: 'search term', 
+  limit: 10,
+  includeMetadata: true 
+});
+\`\`\`
+      `;
+
+      const tools = await extractor.extract(readme);
+
+      if (tools.length > 0) {
+        const { properties } = tools[0].inputSchema;
+        expect(Object.keys(properties).length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should extract from Features section', async () => {
+      const readme = `
+# Tool
+
+## Features
+
+- **ListFiles**: List all files in a directory
+- **ReadFile**: Read contents of a file
+- **WriteFile**: Write content to a file
+      `;
+
+      const tools = await extractor.extract(readme);
+
+      // Features section should also be recognized
+      expect(Array.isArray(tools)).toBe(true);
+    });
+
+    it('should handle FastMCP decorator patterns', async () => {
+      const readme = `
+\`\`\`python
+@server.tool(name="Calculate", description="Perform calculation")
+async def calculate(expression: str):
+    return eval(expression)
+\`\`\`
+      `;
+
+      const tools = await extractor.extract(readme);
+
+      // Should recognize @server.tool pattern
+      expect(Array.isArray(tools)).toBe(true);
+    });
+  });
+
+  describe('extractDocumentationLinks', () => {
+    it('should extract documentation URLs', () => {
+      const readme = `
+# Project
+
+Check out [API Docs](https://docs.example.com/api) for more info.
+See the [Developer Guide](https://developer.example.com/guide).
+      `;
+
+      const links = extractor.extractDocumentationLinks(readme);
+
+      expect(links.length).toBe(2);
+      expect(links[0].url).toBe('https://docs.example.com/api');
+      expect(links[1].url).toBe('https://developer.example.com/guide');
+    });
+
+    it('should filter non-documentation links', () => {
+      const readme = `
+Check [GitHub](https://github.com/owner/repo) repo.
+Read [Documentation](https://docs.example.com/).
+      `;
+
+      const links = extractor.extractDocumentationLinks(readme);
+
+      // Should only include docs link
+      const docsLinks = links.filter(l => l.url.includes('docs'));
+      expect(docsLinks.length).toBe(1);
+    });
+
+    it('should return empty array for no links', () => {
+      const readme = 'No links here.';
+      const links = extractor.extractDocumentationLinks(readme);
+      expect(links).toEqual([]);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle malformed markdown gracefully', async () => {
+      const readme = `
+\`\`\`
+unclosed code block
+      `;
+
+      // Should not throw
+      const tools = await extractor.extract(readme);
+      expect(Array.isArray(tools)).toBe(true);
+    });
+
+    it('should handle very long README files', async () => {
+      const longContent = '# Title\n\n' + 'Lorem ipsum. '.repeat(10000);
+      
+      const tools = await extractor.extract(longContent);
+      expect(Array.isArray(tools)).toBe(true);
+    });
+
+    it('should handle README with only headers', async () => {
+      const readme = `
+# Title
+## Section 1
+### Subsection
+## Section 2
+      `;
+
+      const tools = await extractor.extract(readme);
+      expect(Array.isArray(tools)).toBe(true);
+    });
+
+    it('should extract tools with code formatting in names', async () => {
+      const readme = `
+## Tools
+
+- \`GrepTool\`: Search files using regex
+- \`GlobTool\`: Find files by pattern
+      `;
+
+      const tools = await extractor.extract(readme);
+      
+      // Should handle backtick-formatted names
+      expect(Array.isArray(tools)).toBe(true);
+    });
+  });
+});