github-to-mcp-monorepo 1.0.0

package/packages/core/src/__tests__/bitbucket-client.test.ts

@@ -0,0 +1,366 @@
+/**
+ * @fileoverview Unit tests for Bitbucket client
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { BitbucketClient, createBitbucketClient } from '../providers/bitbucket-client';
+
+// Mock global fetch
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe('BitbucketClient', () => {
+  let client: BitbucketClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    client = new BitbucketClient({ token: 'test-token' });
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('parseUrl', () => {
+    it('should parse simple Bitbucket URL', () => {
+      const result = client.parseUrl('https://bitbucket.org/workspace/repo');
+
+      expect(result.owner).toBe('workspace');
+      expect(result.repo).toBe('repo');
+      expect(result.branch).toBe('main');
+    });
+
+    it('should parse Bitbucket URL with .git suffix', () => {
+      const result = client.parseUrl('https://bitbucket.org/workspace/repo.git');
+
+      expect(result.owner).toBe('workspace');
+      expect(result.repo).toBe('repo');
+    });
+
+    it('should parse Bitbucket URL with src/branch', () => {
+      const result = client.parseUrl('https://bitbucket.org/workspace/repo/src/develop');
+
+      expect(result.owner).toBe('workspace');
+      expect(result.repo).toBe('repo');
+      expect(result.branch).toBe('develop');
+    });
+
+    it('should parse Bitbucket URL with src/branch/path', () => {
+      const result = client.parseUrl('https://bitbucket.org/workspace/repo/src/main/src/index.ts');
+
+      expect(result.owner).toBe('workspace');
+      expect(result.repo).toBe('repo');
+      expect(result.branch).toBe('main');
+      expect(result.path).toBe('src/index.ts');
+    });
+
+    it('should throw error for invalid URL', () => {
+      expect(() => client.parseUrl('https://invalid-url.com/test')).toThrow('Invalid Bitbucket URL');
+    });
+  });
+
+  describe('getRepoMetadata', () => {
+    it('should fetch repository metadata', async () => {
+      mockFetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({
+            uuid: '{12345}',
+            name: 'test-repo',
+            full_name: 'workspace/test-repo',
+            description: 'A test repository',
+            language: 'typescript',
+            mainbranch: { name: 'main', type: 'branch' },
+            created_on: '2024-01-01T00:00:00Z',
+            updated_on: '2024-06-01T00:00:00Z',
+            size: 1024,
+            links: {
+              watchers: { href: 'https://api.bitbucket.org/2.0/repositories/workspace/repo/watchers' },
+              forks: { href: 'https://api.bitbucket.org/2.0/repositories/workspace/repo/forks' }
+            }
+          })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ size: 42 })
+        });
+
+      const metadata = await client.getRepoMetadata('workspace', 'repo');
+
+      expect(metadata.stars).toBe(42);
+      expect(metadata.defaultBranch).toBe('main');
+      expect(metadata.language).toBe('typescript');
+      expect(metadata.description).toBe('A test repository');
+    });
+
+    it('should handle missing watchers gracefully', async () => {
+      mockFetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({
+            uuid: '{12345}',
+            name: 'test-repo',
+            full_name: 'workspace/test-repo',
+            description: 'A test repository',
+            language: 'typescript',
+            mainbranch: { name: 'main' },
+            created_on: '2024-01-01T00:00:00Z',
+            updated_on: '2024-06-01T00:00:00Z',
+            links: {
+              watchers: { href: 'https://api.bitbucket.org/watchers' },
+              forks: { href: 'https://api.bitbucket.org/forks' }
+            }
+          })
+        })
+        .mockResolvedValueOnce({ ok: false, status: 403 });
+
+      const metadata = await client.getRepoMetadata('workspace', 'repo');
+
+      expect(metadata.stars).toBe(0);
+      expect(metadata.defaultBranch).toBe('main');
+    });
+
+    it('should throw error on API failure', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found'
+      });
+
+      await expect(client.getRepoMetadata('workspace', 'nonexistent')).rejects.toThrow('Bitbucket API error');
+    });
+  });
+
+  describe('getFile', () => {
+    it('should fetch file content', async () => {
+      const content = 'Hello, World!';
+
+      mockFetch
+        .mockResolvedValueOnce({
+          ok: true,
+          text: async () => content
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ commit: { hash: 'abc123' } })
+        });
+
+      const file = await client.getFile('workspace', 'repo', 'README.md');
+
+      expect(file).not.toBeNull();
+      expect(file?.content).toBe(content);
+      expect(file?.path).toBe('README.md');
+      expect(file?.sha).toBe('abc123');
+    });
+
+    it('should return null for non-existent file', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404
+      });
+
+      const file = await client.getFile('workspace', 'repo', 'nonexistent.md');
+
+      expect(file).toBeNull();
+    });
+  });
+
+  describe('getReadme', () => {
+    it('should fetch README content', async () => {
+      const content = '# Test Repo\n\nThis is a test.';
+
+      mockFetch
+        .mockResolvedValueOnce({
+          ok: true,
+          text: async () => content
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ commit: { hash: 'abc123' } })
+        });
+
+      const readme = await client.getReadme('workspace', 'repo');
+
+      expect(readme).toBe(content);
+    });
+
+    it('should try multiple README variants', async () => {
+      // First call fails (README.md)
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 404 });
+      // Second call fails (README.MD)
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 404 });
+      // Third call succeeds (readme.md)
+      mockFetch
+        .mockResolvedValueOnce({
+          ok: true,
+          text: async () => 'Found!'
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ commit: { hash: 'abc' } })
+        });
+
+      const readme = await client.getReadme('workspace', 'repo');
+
+      expect(readme).toBe('Found!');
+    });
+  });
+
+  describe('listFiles', () => {
+    it('should list directory contents', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          values: [
+            { path: 'src', type: 'commit_directory', commit: { hash: '1' } },
+            { path: 'README.md', type: 'commit_file', size: 100, commit: { hash: '2' } }
+          ],
+          pagelen: 10
+        })
+      });
+
+      const files = await client.listFiles('workspace', 'repo');
+
+      expect(files).toHaveLength(2);
+      expect(files[0].type).toBe('dir');
+      expect(files[1].type).toBe('file');
+      expect(files[1].size).toBe(100);
+    });
+
+    it('should return empty array on error', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 404 });
+
+      const files = await client.listFiles('workspace', 'repo');
+
+      expect(files).toEqual([]);
+    });
+  });
+
+  describe('searchCode', () => {
+    it('should search code in repository', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          values: [
+            {
+              type: 'code_search_result',
+              content_match_count: 1,
+              file: { path: 'src/index.ts', type: 'commit_file', links: { self: { href: '' } } },
+              content_matches: [
+                {
+                  lines: [
+                    { line: 10, segments: [{ text: 'function test() {}', match: true }] }
+                  ]
+                }
+              ]
+            }
+          ]
+        })
+      });
+
+      const results = await client.searchCode('workspace', 'repo', 'function');
+
+      expect(results).toHaveLength(1);
+      expect(results[0].path).toBe('src/index.ts');
+    });
+
+    it('should filter by extensions', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          values: [
+            { file: { path: 'src/index.ts' }, content_match_count: 1 },
+            { file: { path: 'src/style.css' }, content_match_count: 1 }
+          ]
+        })
+      });
+
+      const results = await client.searchCode('workspace', 'repo', 'test', {
+        extensions: ['ts']
+      });
+
+      expect(results).toHaveLength(1);
+      expect(results[0].path).toBe('src/index.ts');
+    });
+
+    it('should fallback to manual search on API failure', async () => {
+      // Code search fails
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 403 });
+      // List files succeeds
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ values: [], pagelen: 10 })
+      });
+
+      const results = await client.searchCode('workspace', 'repo', 'test');
+
+      // Should return empty since no files found
+      expect(results).toEqual([]);
+    });
+  });
+
+  describe('findApiSpecs', () => {
+    it('should find OpenAPI specs', async () => {
+      const spec = { openapi: '3.0.0', info: { title: 'Test API', version: '1.0.0' } };
+
+      // First few fail, then one succeeds
+      mockFetch
+        .mockResolvedValueOnce({ ok: false, status: 404 })
+        .mockResolvedValueOnce({ ok: false, status: 404 })
+        .mockResolvedValueOnce({ ok: false, status: 404 })
+        .mockResolvedValueOnce({
+          ok: true,
+          text: async () => JSON.stringify(spec)
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ commit: { hash: 'abc' } })
+        });
+
+      const specs = await client.findApiSpecs('workspace', 'repo');
+
+      // May or may not find specs depending on which file matches
+      expect(Array.isArray(specs)).toBe(true);
+    });
+  });
+
+  describe('getRateLimit', () => {
+    it('should return estimated rate limit info', async () => {
+      const rateLimit = await client.getRateLimit();
+
+      expect(rateLimit.remaining).toBe(1000);
+      expect(rateLimit.limit).toBe(1000);
+      expect(rateLimit.reset).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('Authentication', () => {
+    it('should use Bearer token', () => {
+      const client = new BitbucketClient({ token: 'my-token' });
+      expect(client).toBeInstanceOf(BitbucketClient);
+    });
+
+    it('should support username:app_password format', () => {
+      const client = new BitbucketClient({ token: 'username:app_password' });
+      expect(client).toBeInstanceOf(BitbucketClient);
+    });
+  });
+});
+
+describe('createBitbucketClient', () => {
+  it('should create a BitbucketClient instance', () => {
+    const client = createBitbucketClient({ token: 'test-token' });
+
+    expect(client).toBeInstanceOf(BitbucketClient);
+    expect(client.name).toBe('bitbucket');
+  });
+
+  it('should create client with custom base URL', () => {
+    const client = createBitbucketClient({
+      token: 'test-token',
+      baseUrl: 'https://api.bitbucket.example.com/2.0'
+    });
+
+    expect(client).toBeInstanceOf(BitbucketClient);
+  });
+});

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

@@ -0,0 +1,235 @@
+/**
+ * @fileoverview Unit tests for cli module
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock dependencies before importing
+vi.mock('./index', () => ({
+  generateFromGithub: vi.fn(),
+  generateFromGithubBatch: vi.fn(),
+}));
+
+vi.mock('ora', () => ({
+  default: vi.fn(() => ({
+    start: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+  })),
+}));
+
+vi.mock('chalk', () => ({
+  default: {
+    red: vi.fn((s: string) => s),
+    green: vi.fn((s: string) => s),
+    blue: vi.fn((s: string) => s),
+    cyan: vi.fn((s: string) => s),
+    gray: vi.fn((s: string) => s),
+  },
+}));
+
+vi.mock('fs/promises', () => ({
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+  mkdir: vi.fn(),
+}));
+
+describe('CLI', () => {
+  let mockExit: ReturnType<typeof vi.spyOn>;
+  let mockConsoleError: ReturnType<typeof vi.spyOn>;
+  let mockConsoleLog: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    mockExit = vi.spyOn(process, 'exit').mockImplementation((() => {}) as never);
+    mockConsoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+    mockConsoleLog = vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    mockExit.mockRestore();
+    mockConsoleError.mockRestore();
+    mockConsoleLog.mockRestore();
+  });
+
+  describe('Command parsing', () => {
+    it('should accept GitHub URL as argument', () => {
+      const url = 'https://github.com/owner/repo';
+      
+      // Test that URL is valid format
+      expect(url).toMatch(/github\.com\/[\w-]+\/[\w-]+/);
+    });
+
+    it('should validate URL format', () => {
+      const validUrls = [
+        'https://github.com/owner/repo',
+        'https://github.com/owner/repo.git',
+        'https://github.com/owner/my-repo',
+        'https://github.com/owner123/repo_name',
+      ];
+
+      const urlPattern = /^https:\/\/github\.com\/[\w-]+\/[\w._-]+/;
+
+      validUrls.forEach(url => {
+        expect(url).toMatch(urlPattern);
+      });
+    });
+
+    it('should reject invalid URLs', () => {
+      const invalidUrls = [
+        'https://gitlab.com/owner/repo',
+        'github.com/owner/repo',
+        'https://github.com/',
+        'not-a-url',
+      ];
+
+      const githubPattern = /^https:\/\/github\.com\/[\w-]+\/[\w._-]+/;
+
+      invalidUrls.forEach(url => {
+        expect(url).not.toMatch(githubPattern);
+      });
+    });
+  });
+
+  describe('Options', () => {
+    it('should have default output directory', () => {
+      const defaultOutput = './mcp-tools';
+      expect(defaultOutput).toBe('./mcp-tools');
+    });
+
+    it('should parse sources option', () => {
+      const sourcesStr = 'readme,openapi,code';
+      const sources = sourcesStr.split(',');
+      
+      expect(sources).toEqual(['readme', 'openapi', 'code']);
+    });
+
+    it('should validate source types', () => {
+      const validSources = ['readme', 'openapi', 'graphql', 'code'];
+      const sourceTypes = new Set(['readme', 'openapi', 'graphql', 'code', 'mcp-introspect', 'tests', 'docs', 'examples', 'universal']);
+
+      validSources.forEach(source => {
+        expect(sourceTypes.has(source)).toBe(true);
+      });
+    });
+
+    it('should parse depth option as number', () => {
+      const depth = parseInt('3', 10);
+      expect(depth).toBe(3);
+      expect(typeof depth).toBe('number');
+    });
+
+    it('should handle format option', () => {
+      const validFormats = ['typescript', 'javascript'];
+      
+      expect(validFormats).toContain('typescript');
+      expect(validFormats).toContain('javascript');
+    });
+  });
+
+  describe('URL file loading', () => {
+    it('should parse newline-separated URLs', () => {
+      const fileContent = `
+https://github.com/owner/repo1
+https://github.com/owner/repo2
+https://github.com/owner/repo3
+      `.trim();
+
+      const urls = fileContent.split('\n').filter(line => line.trim());
+
+      expect(urls).toHaveLength(3);
+      expect(urls[0]).toBe('https://github.com/owner/repo1');
+    });
+
+    it('should skip empty lines in URL file', () => {
+      const fileContent = `
+https://github.com/owner/repo1
+
+https://github.com/owner/repo2
+
+      `.trim();
+
+      const urls = fileContent.split('\n').filter(line => line.trim());
+
+      expect(urls).toHaveLength(2);
+    });
+
+    it('should combine file URLs with argument URLs', () => {
+      const argUrls = ['https://github.com/owner/repo1'];
+      const fileUrls = ['https://github.com/owner/repo2', 'https://github.com/owner/repo3'];
+      const combined = [...argUrls, ...fileUrls];
+
+      expect(combined).toHaveLength(3);
+    });
+  });
+
+  describe('Output generation', () => {
+    it('should construct output directory path', () => {
+      const baseOutput = './mcp-tools';
+      const repoName = 'my-repo';
+      const outputDir = `${baseOutput}/${repoName}`;
+
+      expect(outputDir).toBe('./mcp-tools/my-repo');
+    });
+
+    it('should handle repo names with special characters', () => {
+      const baseOutput = './output';
+      const repoName = 'repo.js';
+      const outputDir = `${baseOutput}/${repoName}`;
+
+      expect(outputDir).toBe('./output/repo.js');
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should format error messages', () => {
+      const error = new Error('Network error');
+      const message = `Error: ${error.message}`;
+
+      expect(message).toBe('Error: Network error');
+    });
+
+    it('should handle non-Error objects', () => {
+      const error = 'String error';
+      const message = error instanceof Error ? error.message : String(error);
+
+      expect(message).toBe('String error');
+    });
+  });
+
+  describe('Classification display', () => {
+    it('should format confidence as percentage', () => {
+      const confidence = 0.85;
+      const percentage = Math.round(confidence * 100);
+
+      expect(percentage).toBe(85);
+    });
+
+    it('should format indicators list', () => {
+      const indicators = ['has openapi.json', 'API client pattern', 'REST endpoints'];
+      const formatted = indicators.join(', ');
+
+      expect(formatted).toBe('has openapi.json, API client pattern, REST endpoints');
+    });
+  });
+
+  describe('Batch processing', () => {
+    it('should process multiple URLs', () => {
+      const urls = [
+        'https://github.com/owner/repo1',
+        'https://github.com/owner/repo2',
+        'https://github.com/owner/repo3',
+      ];
+
+      expect(urls.length).toBe(3);
+      expect(urls.length > 1).toBe(true); // Batch mode condition
+    });
+
+    it('should identify single URL mode', () => {
+      const urls = ['https://github.com/owner/repo'];
+
+      expect(urls.length).toBe(1);
+    });
+  });
+});