github-to-mcp-monorepo 1.0.0

package/apps/vscode/src/commands/convertCurrentRepo.ts

@@ -0,0 +1,109 @@
+/**
+ * @fileoverview Command to convert the currently open workspace repository
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+import { StorageService } from '../utils/storage';
+import { HistoryProvider } from '../views/historyProvider';
+import { performConversion } from './convertFromUrl';
+
+/**
+ * Convert the currently open GitHub repository to MCP server
+ */
+export async function convertCurrentRepoCommand(
+  storage: StorageService,
+  historyProvider: HistoryProvider,
+  extensionUri: vscode.Uri
+): Promise<void> {
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+
+  if (!workspaceFolders || workspaceFolders.length === 0) {
+    vscode.window.showWarningMessage('No workspace folder open. Please open a GitHub repository folder.');
+    return;
+  }
+
+  // Try to get the GitHub URL from git config
+  const githubUrl = await getGitHubUrlFromWorkspace(workspaceFolders[0]);
+
+  if (!githubUrl) {
+    // Fallback to manual input if we can't detect
+    const response = await vscode.window.showWarningMessage(
+      'Could not detect GitHub repository. Would you like to enter the URL manually?',
+      'Enter URL',
+      'Cancel'
+    );
+
+    if (response === 'Enter URL') {
+      vscode.commands.executeCommand('github-to-mcp.convertFromUrl');
+    }
+    return;
+  }
+
+  // Confirm with user
+  const repoPath = githubUrl.replace('https://github.com/', '');
+  const confirm = await vscode.window.showInformationMessage(
+    `Convert ${repoPath} to an MCP server?`,
+    'Yes',
+    'No'
+  );
+
+  if (confirm !== 'Yes') {
+    return;
+  }
+
+  await performConversion(githubUrl, storage, historyProvider, extensionUri);
+}
+
+/**
+ * Extract GitHub URL from workspace git config
+ */
+async function getGitHubUrlFromWorkspace(folder: vscode.WorkspaceFolder): Promise<string | null> {
+  try {
+    const gitConfigPath = vscode.Uri.joinPath(folder.uri, '.git', 'config');
+    const gitConfig = await vscode.workspace.fs.readFile(gitConfigPath);
+    const content = Buffer.from(gitConfig).toString('utf-8');
+
+    // Match HTTPS format: https://github.com/owner/repo.git
+    const httpsMatch = content.match(/url\s*=\s*https?:\/\/github\.com\/([\w-]+\/[\w.-]+?)(?:\.git)?$/m);
+    if (httpsMatch) {
+      return `https://github.com/${httpsMatch[1]}`;
+    }
+
+    // Match SSH format: git@github.com:owner/repo.git
+    const sshMatch = content.match(/url\s*=\s*git@github\.com:([\w-]+\/[\w.-]+?)(?:\.git)?$/m);
+    if (sshMatch) {
+      return `https://github.com/${sshMatch[1]}`;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if the current workspace is a GitHub repository
+ */
+export async function isCurrentWorkspaceGitHubRepo(): Promise<boolean> {
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  if (!workspaceFolders || workspaceFolders.length === 0) {
+    return false;
+  }
+
+  const url = await getGitHubUrlFromWorkspace(workspaceFolders[0]);
+  return url !== null;
+}
+
+/**
+ * Get the GitHub URL of the current workspace
+ */
+export async function getCurrentWorkspaceGitHubUrl(): Promise<string | null> {
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  if (!workspaceFolders || workspaceFolders.length === 0) {
+    return null;
+  }
+
+  return getGitHubUrlFromWorkspace(workspaceFolders[0]);
+}

package/apps/vscode/src/commands/convertFromUrl.ts

@@ -0,0 +1,138 @@
+/**
+ * @fileoverview Command to convert a GitHub repository from URL input
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+import { StorageService, ConversionResult } from '../utils/storage';
+import { HistoryProvider } from '../views/historyProvider';
+import { showResultsPanel } from '../views/resultsPanel';
+
+/**
+ * Prompt user for GitHub URL and convert to MCP server
+ */
+export async function convertFromUrlCommand(
+  storage: StorageService,
+  historyProvider: HistoryProvider,
+  extensionUri: vscode.Uri
+): Promise<void> {
+  // Get URL from user input
+  const url = await vscode.window.showInputBox({
+    prompt: 'Enter GitHub repository URL',
+    placeHolder: 'https://github.com/owner/repo',
+    ignoreFocusOut: true,
+    validateInput: (value) => {
+      if (!value) {
+        return 'URL is required';
+      }
+      if (!value.match(/^https?:\/\/github\.com\/[\w-]+\/[\w.-]+/)) {
+        return 'Invalid GitHub URL format. Expected: https://github.com/owner/repo';
+      }
+      return null;
+    }
+  });
+
+  if (!url) {
+    return;
+  }
+
+  await performConversion(url, storage, historyProvider, extensionUri);
+}
+
+/**
+ * Perform the actual conversion
+ */
+export async function performConversion(
+  url: string,
+  storage: StorageService,
+  historyProvider: HistoryProvider,
+  extensionUri: vscode.Uri
+): Promise<ConversionResult | undefined> {
+  return vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      title: 'Converting GitHub repository...',
+      cancellable: true
+    },
+    async (progress, token) => {
+      try {
+        // Parse URL to get owner/repo
+        const match = url.match(/github\.com\/([\w-]+)\/([\w.-]+)/);
+        if (!match) {
+          throw new Error('Invalid GitHub URL');
+        }
+
+        const [, owner, repo] = match;
+
+        if (token.isCancellationRequested) {
+          return undefined;
+        }
+
+        progress.report({ message: 'Fetching repository data...', increment: 10 });
+
+        // Import the core library dynamically to avoid bundling issues
+        const { generateFromGithub } = await import('@nirholas/github-to-mcp');
+
+        if (token.isCancellationRequested) {
+          return undefined;
+        }
+
+        progress.report({ message: 'Analyzing repository...', increment: 30 });
+
+        const result = await generateFromGithub(url, {
+          sources: ['readme', 'openapi', 'code']
+        });
+
+        if (token.isCancellationRequested) {
+          return undefined;
+        }
+
+        progress.report({ message: 'Generating MCP server code...', increment: 40 });
+
+        const generatedCode = result.generate();
+
+        progress.report({ message: 'Finalizing...', increment: 20 });
+
+        // Create conversion result
+        const conversionResult: ConversionResult = {
+          id: Date.now().toString(),
+          repoUrl: url,
+          repoName: `${owner}/${repo}`,
+          toolCount: result.tools.length,
+          timestamp: new Date().toISOString(),
+          classification: result.classification,
+          code: generatedCode,
+          tools: result.tools.map((t: { name: string; description: string; parameters?: unknown }) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+          }))
+        };
+
+        // Save to history
+        storage.addToHistory(conversionResult);
+        historyProvider.refresh();
+
+        // Show results panel
+        showResultsPanel(conversionResult, extensionUri);
+
+        vscode.window.showInformationMessage(
+          `Successfully converted ${owner}/${repo} - ${result.tools.length} tools found!`,
+          'View Details',
+          'Copy Config'
+        ).then((selection) => {
+          if (selection === 'Copy Config') {
+            vscode.commands.executeCommand('github-to-mcp.copyConfig');
+          }
+        });
+
+        return conversionResult;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        vscode.window.showErrorMessage(`Failed to convert repository: ${message}`);
+        return undefined;
+      }
+    }
+  );
+}

package/apps/vscode/src/commands/index.ts

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Command registration and exports
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+import { StorageService } from '../utils/storage';
+import { HistoryProvider } from '../views/historyProvider';
+
+// Re-export individual commands
+export { convertCommand } from './convert';
+export { validateCommand } from './validate';
+export { convertFromUrlCommand, performConversion } from './convertFromUrl';
+export { convertCurrentRepoCommand, isCurrentWorkspaceGitHubRepo, getCurrentWorkspaceGitHubUrl } from './convertCurrentRepo';
+export { browseRegistryCommand, fetchRemoteRegistry } from './browseRegistry';
+export { configureClaudeDesktopCommand, isClaudeDesktopInstalled, openClaudeDesktopConfig } from './configureClaudeDesktop';
+
+/**
+ * Register all commands with VS Code
+ */
+export function registerCommands(
+  context: vscode.ExtensionContext,
+  storage: StorageService,
+  historyProvider: HistoryProvider
+): vscode.Disposable[] {
+  const { convertFromUrlCommand } = require('./convertFromUrl');
+  const { convertCurrentRepoCommand } = require('./convertCurrentRepo');
+  const { browseRegistryCommand } = require('./browseRegistry');
+  const { configureClaudeDesktopCommand, openClaudeDesktopConfig } = require('./configureClaudeDesktop');
+
+  const extensionUri = context.extensionUri;
+
+  const disposables: vscode.Disposable[] = [];
+
+  // Convert from URL command
+  disposables.push(
+    vscode.commands.registerCommand('github-to-mcp.convertFromUrl', () =>
+      convertFromUrlCommand(storage, historyProvider, extensionUri)
+    )
+  );
+
+  // Convert current repo command
+  disposables.push(
+    vscode.commands.registerCommand('github-to-mcp.convertCurrentRepo', () =>
+      convertCurrentRepoCommand(storage, historyProvider, extensionUri)
+    )
+  );
+
+  // Browse registry command
+  disposables.push(
+    vscode.commands.registerCommand('github-to-mcp.browseRegistry', () =>
+      browseRegistryCommand(storage, historyProvider, extensionUri)
+    )
+  );
+
+  // Configure Claude Desktop command
+  disposables.push(
+    vscode.commands.registerCommand('github-to-mcp.configureClaudeDesktop', () =>
+      configureClaudeDesktopCommand(storage)
+    )
+  );
+
+  // Open Claude Desktop config command
+  disposables.push(
+    vscode.commands.registerCommand('github-to-mcp.openClaudeConfig', () =>
+      openClaudeDesktopConfig()
+    )
+  );
+
+  // Clear history command
+  disposables.push(
+    vscode.commands.registerCommand('github-to-mcp.clearHistory', async () => {
+      const confirm = await vscode.window.showWarningMessage(
+        'Are you sure you want to clear all conversion history?',
+        { modal: true },
+        'Clear',
+        'Cancel'
+      );
+
+      if (confirm === 'Clear') {
+        storage.clearHistory();
+        historyProvider.refresh();
+        vscode.window.showInformationMessage('Conversion history cleared.');
+      }
+    })
+  );
+
+  // Refresh history command
+  disposables.push(
+    vscode.commands.registerCommand('github-to-mcp.refreshHistory', () => {
+      historyProvider.refresh();
+    })
+  );
+
+  // Export server command
+  disposables.push(
+    vscode.commands.registerCommand('github-to-mcp.exportServer', async (item) => {
+      if (!item?.code) {
+        vscode.window.showWarningMessage('No server code to export.');
+        return;
+      }
+
+      const saveUri = await vscode.window.showSaveDialog({
+        defaultUri: vscode.Uri.file(`${item.repoName.replace('/', '-')}-mcp.js`),
+        filters: {
+          'JavaScript': ['js'],
+          'TypeScript': ['ts']
+        },
+        title: 'Export MCP Server'
+      });
+
+      if (saveUri) {
+        await vscode.workspace.fs.writeFile(saveUri, Buffer.from(item.code, 'utf-8'));
+        vscode.window.showInformationMessage(`Server exported to ${saveUri.fsPath}`);
+      }
+    })
+  );
+
+  return disposables;
+}

package/apps/vscode/src/commands/validate.ts

@@ -0,0 +1,197 @@
+/**
+ * @fileoverview Validate command implementation
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+
+/**
+ * Validate a generated MCP server file
+ */
+export async function validateCommand(): Promise<void> {
+  const fileUri = await vscode.window.showOpenDialog({
+    canSelectFiles: true,
+    canSelectFolders: false,
+    canSelectMany: false,
+    filters: {
+      'TypeScript': ['ts'],
+      'JavaScript': ['js'],
+      'Python': ['py']
+    },
+    title: 'Select MCP server file to validate'
+  });
+
+  if (!fileUri || fileUri.length === 0) {
+    return;
+  }
+
+  const filePath = fileUri[0].fsPath;
+
+  await vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      title: 'Validating MCP server...',
+      cancellable: false
+    },
+    async (progress) => {
+      try {
+        progress.report({ message: 'Reading file...' });
+        
+        const document = await vscode.workspace.openTextDocument(fileUri[0]);
+        const content = document.getText();
+
+        progress.report({ message: 'Analyzing structure...' });
+
+        const issues: ValidationIssue[] = [];
+
+        // Check for basic MCP server structure
+        if (filePath.endsWith('.ts') || filePath.endsWith('.js')) {
+          issues.push(...validateTypeScriptMcp(content));
+        } else if (filePath.endsWith('.py')) {
+          issues.push(...validatePythonMcp(content));
+        }
+
+        // Display results
+        if (issues.length === 0) {
+          vscode.window.showInformationMessage('✓ MCP server validation passed!');
+        } else {
+          const channel = vscode.window.createOutputChannel('MCP Validation');
+          channel.clear();
+          channel.appendLine('MCP Server Validation Results');
+          channel.appendLine('=' .repeat(40));
+          channel.appendLine('');
+          
+          for (const issue of issues) {
+            const icon = issue.severity === 'error' ? '✗' : '⚠';
+            channel.appendLine(`${icon} Line ${issue.line || '?'}: ${issue.message}`);
+          }
+          
+          channel.show();
+          vscode.window.showWarningMessage(
+            `Validation found ${issues.length} issue(s). See output for details.`
+          );
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        vscode.window.showErrorMessage(`Validation failed: ${message}`);
+      }
+    }
+  );
+}
+
+interface ValidationIssue {
+  severity: 'error' | 'warning';
+  message: string;
+  line?: number;
+}
+
+/**
+ * Validate TypeScript/JavaScript MCP server
+ */
+function validateTypeScriptMcp(content: string): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+  const lines = content.split('\n');
+
+  // Check for MCP SDK import
+  if (!content.includes('@modelcontextprotocol/sdk')) {
+    issues.push({
+      severity: 'error',
+      message: 'Missing @modelcontextprotocol/sdk import'
+    });
+  }
+
+  // Check for Server instantiation
+  if (!content.includes('new Server(')) {
+    issues.push({
+      severity: 'error',
+      message: 'Missing Server instantiation'
+    });
+  }
+
+  // Check for ListToolsRequestSchema handler
+  if (!content.includes('ListToolsRequestSchema')) {
+    issues.push({
+      severity: 'warning',
+      message: 'Missing ListToolsRequestSchema handler - tools may not be listed'
+    });
+  }
+
+  // Check for CallToolRequestSchema handler
+  if (!content.includes('CallToolRequestSchema')) {
+    issues.push({
+      severity: 'warning',
+      message: 'Missing CallToolRequestSchema handler - tools may not be callable'
+    });
+  }
+
+  // Check for transport
+  if (!content.includes('StdioServerTransport') && !content.includes('transport')) {
+    issues.push({
+      severity: 'warning',
+      message: 'Missing transport configuration'
+    });
+  }
+
+  // Check for async function syntax errors (basic)
+  lines.forEach((line, index) => {
+    if (line.includes('async function') && !line.includes('{') && !lines[index + 1]?.includes('{')) {
+      issues.push({
+        severity: 'warning',
+        message: 'Async function may be missing body',
+        line: index + 1
+      });
+    }
+  });
+
+  return issues;
+}
+
+/**
+ * Validate Python MCP server
+ */
+function validatePythonMcp(content: string): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+
+  // Check for mcp import
+  if (!content.includes('from mcp') && !content.includes('import mcp')) {
+    issues.push({
+      severity: 'error',
+      message: 'Missing mcp module import'
+    });
+  }
+
+  // Check for Server instantiation
+  if (!content.includes('Server(')) {
+    issues.push({
+      severity: 'error',
+      message: 'Missing Server instantiation'
+    });
+  }
+
+  // Check for list_tools decorator
+  if (!content.includes('@server.list_tools') && !content.includes('list_tools')) {
+    issues.push({
+      severity: 'warning',
+      message: 'Missing list_tools handler'
+    });
+  }
+
+  // Check for call_tool decorator
+  if (!content.includes('@server.call_tool') && !content.includes('call_tool')) {
+    issues.push({
+      severity: 'warning',
+      message: 'Missing call_tool handler'
+    });
+  }
+
+  // Check for async main
+  if (!content.includes('async def main') && !content.includes('asyncio.run')) {
+    issues.push({
+      severity: 'warning',
+      message: 'Missing async main function or asyncio.run'
+    });
+  }
+
+  return issues;
+}