github-to-mcp-monorepo 1.0.0

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

@@ -0,0 +1,211 @@
+/**
+ * @fileoverview Command to browse public MCP server registry
+ * @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';
+
+interface RegistryServer {
+  name: string;
+  description: string;
+  repoUrl: string;
+  category: string;
+  stars?: number;
+  author?: string;
+}
+
+// Built-in registry of popular MCP-compatible repositories
+const REGISTRY_SERVERS: RegistryServer[] = [
+  {
+    name: 'Anthropic Claude Code',
+    description: 'AI coding assistant from Anthropic',
+    repoUrl: 'https://github.com/anthropics/claude-code',
+    category: 'AI Tools',
+    author: 'Anthropic'
+  },
+  {
+    name: 'Langchain',
+    description: 'Build applications with LLMs through composability',
+    repoUrl: 'https://github.com/langchain-ai/langchain',
+    category: 'AI Framework',
+    author: 'LangChain'
+  },
+  {
+    name: 'OpenAI Node',
+    description: 'Official Node.js library for OpenAI API',
+    repoUrl: 'https://github.com/openai/openai-node',
+    category: 'AI SDK',
+    author: 'OpenAI'
+  },
+  {
+    name: 'Vercel AI SDK',
+    description: 'Build AI-powered apps with React, Svelte, Vue',
+    repoUrl: 'https://github.com/vercel/ai',
+    category: 'AI SDK',
+    author: 'Vercel'
+  },
+  {
+    name: 'Hugging Face Transformers',
+    description: 'State-of-the-art ML for PyTorch, TensorFlow, JAX',
+    repoUrl: 'https://github.com/huggingface/transformers',
+    category: 'ML Framework',
+    author: 'Hugging Face'
+  },
+  {
+    name: 'FastAPI',
+    description: 'Modern, fast web framework for building APIs',
+    repoUrl: 'https://github.com/tiangolo/fastapi',
+    category: 'Web Framework',
+    author: 'Sebastián Ramírez'
+  },
+  {
+    name: 'Prisma',
+    description: 'Next-generation ORM for Node.js and TypeScript',
+    repoUrl: 'https://github.com/prisma/prisma',
+    category: 'Database',
+    author: 'Prisma'
+  },
+  {
+    name: 'tRPC',
+    description: 'End-to-end typesafe APIs made easy',
+    repoUrl: 'https://github.com/trpc/trpc',
+    category: 'API Framework',
+    author: 'tRPC'
+  },
+  {
+    name: 'Stripe Node',
+    description: 'Node.js library for Stripe API',
+    repoUrl: 'https://github.com/stripe/stripe-node',
+    category: 'Payment',
+    author: 'Stripe'
+  },
+  {
+    name: 'Supabase',
+    description: 'Open source Firebase alternative',
+    repoUrl: 'https://github.com/supabase/supabase',
+    category: 'Database',
+    author: 'Supabase'
+  }
+];
+
+/**
+ * Browse and convert from public MCP server registry
+ */
+export async function browseRegistryCommand(
+  storage: StorageService,
+  historyProvider: HistoryProvider,
+  extensionUri: vscode.Uri
+): Promise<void> {
+  // Group servers by category
+  const categories = [...new Set(REGISTRY_SERVERS.map(s => s.category))];
+
+  // First, let user pick a category or view all
+  const categorySelection = await vscode.window.showQuickPick(
+    [
+      { label: '$(list-flat) All Servers', value: 'all' },
+      { label: '$(search) Search by Name', value: 'search' },
+      { label: '', kind: vscode.QuickPickItemKind.Separator },
+      ...categories.map(cat => ({
+        label: `$(folder) ${cat}`,
+        value: cat
+      }))
+    ],
+    {
+      placeHolder: 'Select a category or search',
+      title: 'MCP Server Registry'
+    }
+  );
+
+  if (!categorySelection) {
+    return;
+  }
+
+  let serversToShow: RegistryServer[];
+
+  // Type guard - separator items don't have value property
+  const selection = categorySelection as { label: string; value?: string };
+  const selectionValue = selection.value;
+
+  if (selectionValue === 'search') {
+    // Search mode
+    const searchQuery = await vscode.window.showInputBox({
+      prompt: 'Search for MCP servers',
+      placeHolder: 'Enter search term...'
+    });
+
+    if (!searchQuery) {
+      return;
+    }
+
+    const query = searchQuery.toLowerCase();
+    serversToShow = REGISTRY_SERVERS.filter(
+      s => s.name.toLowerCase().includes(query) ||
+           s.description.toLowerCase().includes(query) ||
+           s.author?.toLowerCase().includes(query)
+    );
+
+    if (serversToShow.length === 0) {
+      vscode.window.showInformationMessage(`No servers found matching "${searchQuery}"`);
+      return;
+    }
+  } else if (selectionValue === 'all') {
+    serversToShow = REGISTRY_SERVERS;
+  } else {
+    serversToShow = REGISTRY_SERVERS.filter(s => s.category === selectionValue);
+  }
+
+  // Show servers in the selected category
+  const serverItems: vscode.QuickPickItem[] = serversToShow.map(server => ({
+    label: `$(github) ${server.name}`,
+    description: server.author || '',
+    detail: server.description,
+    server: server
+  } as vscode.QuickPickItem & { server: RegistryServer }));
+
+  const selectedServer = await vscode.window.showQuickPick(serverItems, {
+    placeHolder: 'Select a server to convert',
+    title: 'MCP Server Registry',
+    matchOnDescription: true,
+    matchOnDetail: true
+  }) as (vscode.QuickPickItem & { server: RegistryServer }) | undefined;
+
+  if (!selectedServer) {
+    return;
+  }
+
+  // Show server details and confirm
+  const action = await vscode.window.showInformationMessage(
+    `Convert ${selectedServer.server.name} to MCP server?`,
+    { modal: true, detail: `${selectedServer.server.description}\n\nRepository: ${selectedServer.server.repoUrl}` },
+    'Convert',
+    'Open in Browser',
+    'Cancel'
+  );
+
+  if (action === 'Convert') {
+    await performConversion(selectedServer.server.repoUrl, storage, historyProvider, extensionUri);
+  } else if (action === 'Open in Browser') {
+    vscode.env.openExternal(vscode.Uri.parse(selectedServer.server.repoUrl));
+  }
+}
+
+/**
+ * Fetch registry from remote source (for future implementation)
+ */
+export async function fetchRemoteRegistry(): Promise<RegistryServer[]> {
+  // In the future, this could fetch from a remote registry API
+  // For now, return the built-in registry
+  return REGISTRY_SERVERS;
+}
+
+/**
+ * Add a custom server to the local registry
+ */
+export function addCustomServer(server: RegistryServer): void {
+  // This would persist to workspace state
+  REGISTRY_SERVERS.push(server);
+}

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

@@ -0,0 +1,332 @@
+/**
+ * @fileoverview Command to auto-configure Claude Desktop with MCP servers
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+import * as os from 'os';
+import * as path from 'path';
+import { StorageService, ConversionResult } from '../utils/storage';
+
+interface ClaudeDesktopConfig {
+  mcpServers?: Record<string, McpServerConfig>;
+}
+
+interface McpServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+/**
+ * Auto-configure Claude Desktop with MCP servers
+ */
+export async function configureClaudeDesktopCommand(
+  storage: StorageService
+): Promise<void> {
+  // Get conversion history
+  const history = storage.getHistory();
+
+  if (history.length === 0) {
+    const response = await vscode.window.showWarningMessage(
+      'No converted MCP servers found. Would you like to convert a repository first?',
+      'Convert Repository',
+      'Cancel'
+    );
+
+    if (response === 'Convert Repository') {
+      vscode.commands.executeCommand('github-to-mcp.convertFromUrl');
+    }
+    return;
+  }
+
+  // Let user select which servers to configure
+  const serverItems = history.map(item => ({
+    label: item.repoName,
+    description: `${item.toolCount} tools`,
+    picked: false,
+    result: item
+  }));
+
+  const selectedItems = await vscode.window.showQuickPick(serverItems, {
+    canPickMany: true,
+    placeHolder: 'Select MCP servers to add to Claude Desktop',
+    title: 'Configure Claude Desktop'
+  });
+
+  if (!selectedItems || selectedItems.length === 0) {
+    return;
+  }
+
+  // Get Claude Desktop config path
+  const configPath = getClaudeDesktopConfigPath();
+  
+  if (!configPath) {
+    vscode.window.showErrorMessage('Could not determine Claude Desktop config location for your platform.');
+    return;
+  }
+
+  // Check if config file exists
+  const configUri = vscode.Uri.file(configPath);
+  let existingConfig: ClaudeDesktopConfig = {};
+
+  try {
+    const configContent = await vscode.workspace.fs.readFile(configUri);
+    existingConfig = JSON.parse(Buffer.from(configContent).toString('utf-8'));
+  } catch {
+    // Config doesn't exist yet, we'll create it
+  }
+
+  // Initialize mcpServers if not present
+  if (!existingConfig.mcpServers) {
+    existingConfig.mcpServers = {};
+  }
+
+  // Ask user for output directory
+  const outputDir = await getOutputDirectory();
+  if (!outputDir) {
+    return;
+  }
+
+  // Generate and save MCP server files, then add to config
+  const addedServers: string[] = [];
+  const errors: string[] = [];
+
+  for (const item of selectedItems) {
+    const result = item.result as ConversionResult;
+    const serverName = result.repoName.replace('/', '-').toLowerCase();
+
+    try {
+      // Generate the server file
+      const serverPath = await generateMcpServerFile(result, outputDir);
+
+      // Add to config
+      existingConfig.mcpServers![serverName] = {
+        command: 'node',
+        args: [serverPath]
+      };
+
+      addedServers.push(serverName);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : 'Unknown error';
+      errors.push(`${serverName}: ${msg}`);
+    }
+  }
+
+  // Write updated config
+  try {
+    // Ensure config directory exists
+    const configDir = path.dirname(configPath);
+    await vscode.workspace.fs.createDirectory(vscode.Uri.file(configDir));
+
+    // Write config file
+    await vscode.workspace.fs.writeFile(
+      configUri,
+      Buffer.from(JSON.stringify(existingConfig, null, 2), 'utf-8')
+    );
+
+    // Show results
+    if (addedServers.length > 0) {
+      const message = `Added ${addedServers.length} MCP server(s) to Claude Desktop config`;
+      const action = await vscode.window.showInformationMessage(
+        message,
+        'Open Config',
+        'Restart Claude Desktop',
+        'Done'
+      );
+
+      if (action === 'Open Config') {
+        const doc = await vscode.workspace.openTextDocument(configUri);
+        vscode.window.showTextDocument(doc);
+      } else if (action === 'Restart Claude Desktop') {
+        vscode.window.showInformationMessage(
+          'Please restart Claude Desktop for changes to take effect.',
+          'OK'
+        );
+      }
+    }
+
+    if (errors.length > 0) {
+      vscode.window.showWarningMessage(
+        `Some servers could not be added: ${errors.join(', ')}`
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    vscode.window.showErrorMessage(`Failed to write Claude Desktop config: ${message}`);
+  }
+}
+
+/**
+ * Get the Claude Desktop config file path based on platform
+ */
+function getClaudeDesktopConfigPath(): string | null {
+  const platform = os.platform();
+  const homeDir = os.homedir();
+
+  switch (platform) {
+    case 'darwin': // macOS
+      return path.join(homeDir, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    
+    case 'win32': // Windows
+      return path.join(homeDir, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json');
+    
+    case 'linux':
+      return path.join(homeDir, '.config', 'Claude', 'claude_desktop_config.json');
+    
+    default:
+      return null;
+  }
+}
+
+/**
+ * Get output directory for MCP server files
+ */
+async function getOutputDirectory(): Promise<string | null> {
+  const options = [
+    {
+      label: '$(home) User MCP Servers',
+      description: getDefaultMcpDirectory(),
+      value: getDefaultMcpDirectory()
+    },
+    {
+      label: '$(folder) Current Workspace',
+      description: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || 'No workspace open',
+      value: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
+    },
+    {
+      label: '$(folder-opened) Choose Custom Location...',
+      value: 'custom'
+    }
+  ];
+
+  const selection = await vscode.window.showQuickPick(options, {
+    placeHolder: 'Where should MCP server files be saved?',
+    title: 'Output Location'
+  });
+
+  if (!selection) {
+    return null;
+  }
+
+  if (selection.value === 'custom') {
+    const folders = await vscode.window.showOpenDialog({
+      canSelectFolders: true,
+      canSelectFiles: false,
+      canSelectMany: false,
+      title: 'Select output directory for MCP servers'
+    });
+
+    if (!folders || folders.length === 0) {
+      return null;
+    }
+
+    return folders[0].fsPath;
+  }
+
+  return selection.value || null;
+}
+
+/**
+ * Get default MCP directory
+ */
+function getDefaultMcpDirectory(): string {
+  const homeDir = os.homedir();
+  return path.join(homeDir, '.mcp-servers');
+}
+
+/**
+ * Generate MCP server file from conversion result
+ */
+async function generateMcpServerFile(result: ConversionResult, outputDir: string): Promise<string> {
+  if (!result.code) {
+    throw new Error('No generated code available');
+  }
+
+  const serverName = result.repoName.replace('/', '-').toLowerCase();
+  const serverDir = path.join(outputDir, serverName);
+  const serverFile = path.join(serverDir, 'index.js');
+
+  // Create server directory
+  await vscode.workspace.fs.createDirectory(vscode.Uri.file(serverDir));
+
+  // Write server file
+  await vscode.workspace.fs.writeFile(
+    vscode.Uri.file(serverFile),
+    Buffer.from(result.code, 'utf-8')
+  );
+
+  // Create package.json
+  const packageJson = {
+    name: `${serverName}-mcp`,
+    version: '1.0.0',
+    description: `MCP server generated from ${result.repoName}`,
+    main: 'index.js',
+    type: 'module',
+    dependencies: {
+      '@modelcontextprotocol/sdk': '^0.5.0'
+    }
+  };
+
+  await vscode.workspace.fs.writeFile(
+    vscode.Uri.file(path.join(serverDir, 'package.json')),
+    Buffer.from(JSON.stringify(packageJson, null, 2), 'utf-8')
+  );
+
+  return serverFile;
+}
+
+/**
+ * Check if Claude Desktop is likely installed
+ */
+export function isClaudeDesktopInstalled(): boolean {
+  const configPath = getClaudeDesktopConfigPath();
+  if (!configPath) {
+    return false;
+  }
+
+  // Check if the Claude directory exists
+  const claudeDir = path.dirname(configPath);
+  try {
+    // This is a simple heuristic - the directory may exist even without full installation
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Open Claude Desktop config in editor
+ */
+export async function openClaudeDesktopConfig(): Promise<void> {
+  const configPath = getClaudeDesktopConfigPath();
+  if (!configPath) {
+    vscode.window.showErrorMessage('Could not determine Claude Desktop config location.');
+    return;
+  }
+
+  try {
+    const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(configPath));
+    vscode.window.showTextDocument(doc);
+  } catch {
+    // Config doesn't exist, create it
+    const create = await vscode.window.showInformationMessage(
+      'Claude Desktop config file does not exist. Create it?',
+      'Create',
+      'Cancel'
+    );
+
+    if (create === 'Create') {
+      const configDir = path.dirname(configPath);
+      await vscode.workspace.fs.createDirectory(vscode.Uri.file(configDir));
+      await vscode.workspace.fs.writeFile(
+        vscode.Uri.file(configPath),
+        Buffer.from(JSON.stringify({ mcpServers: {} }, null, 2), 'utf-8')
+      );
+
+      const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(configPath));
+      vscode.window.showTextDocument(doc);
+    }
+  }
+}

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

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Convert command implementation
+ * @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';
+
+/**
+ * Convert a GitHub repository to MCP tools
+ */
+export async function convertCommand(
+  url: string,
+  storage: StorageService,
+  historyProvider: HistoryProvider
+): Promise<void> {
+  return vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      title: 'Converting GitHub repository...',
+      cancellable: false
+    },
+    async (progress) => {
+      try {
+        progress.report({ message: 'Fetching repository data...' });
+
+        // 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;
+
+        progress.report({ message: 'Analyzing repository...' });
+
+        // Import the core library dynamically to avoid bundling issues
+        const { generateFromGithub } = await import('@nirholas/github-to-mcp');
+        
+        const result = await generateFromGithub(url, {
+          sources: ['readme', 'openapi', 'code']
+        });
+
+        progress.report({ message: 'Generating MCP server code...' });
+
+        const generatedCode = result.generate();
+
+        // 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 }) => ({
+            name: t.name,
+            description: t.description
+          }))
+        };
+
+        // Save to history
+        storage.addToHistory(conversionResult);
+        historyProvider.refresh();
+
+        // Show results panel
+        showResultsPanel(conversionResult, vscode.Uri.file(''));
+
+        vscode.window.showInformationMessage(
+          `Successfully converted ${owner}/${repo} - ${result.tools.length} tools found!`
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        vscode.window.showErrorMessage(`Failed to convert repository: ${message}`);
+      }
+    }
+  );
+}