github-to-mcp-monorepo 1.0.0

package/apps/vscode/src/utils/github-api.ts

@@ -0,0 +1,335 @@
+/**
+ * @fileoverview GitHub API client for VS Code extension
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+
+interface GitHubRepo {
+  name: string;
+  full_name: string;
+  description: string | null;
+  html_url: string;
+  default_branch: string;
+  language: string | null;
+  stargazers_count: number;
+  forks_count: number;
+  topics: string[];
+  owner: {
+    login: string;
+    avatar_url: string;
+  };
+}
+
+interface GitHubContent {
+  name: string;
+  path: string;
+  type: 'file' | 'dir';
+  size?: number;
+  download_url?: string;
+  content?: string;
+  encoding?: string;
+}
+
+interface GitHubRateLimit {
+  limit: number;
+  remaining: number;
+  reset: number;
+}
+
+/**
+ * GitHub API client for the VS Code extension
+ */
+export class GitHubApiClient {
+  private static instance: GitHubApiClient;
+  private baseUrl = 'https://api.github.com';
+  private token: string | undefined;
+
+  private constructor() {
+    this.loadToken();
+  }
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): GitHubApiClient {
+    if (!GitHubApiClient.instance) {
+      GitHubApiClient.instance = new GitHubApiClient();
+    }
+    return GitHubApiClient.instance;
+  }
+
+  /**
+   * Load GitHub token from VS Code settings or environment
+   */
+  private loadToken(): void {
+    const config = vscode.workspace.getConfiguration('github-to-mcp');
+    this.token = config.get<string>('githubToken') || process.env.GITHUB_TOKEN;
+  }
+
+  /**
+   * Set GitHub token
+   */
+  setToken(token: string): void {
+    this.token = token;
+  }
+
+  /**
+   * Check if authenticated
+   */
+  isAuthenticated(): boolean {
+    return !!this.token;
+  }
+
+  /**
+   * Make a request to GitHub API
+   */
+  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    const headers: Record<string, string> = {
+      'Accept': 'application/vnd.github.v3+json',
+      'User-Agent': 'GitHub-to-MCP-VSCode-Extension'
+    };
+
+    if (this.token) {
+      headers['Authorization'] = `Bearer ${this.token}`;
+    }
+
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+      ...options,
+      headers: {
+        ...headers,
+        ...options.headers
+      }
+    });
+
+    if (!response.ok) {
+      if (response.status === 403) {
+        const rateLimitRemaining = response.headers.get('X-RateLimit-Remaining');
+        if (rateLimitRemaining === '0') {
+          throw new Error('GitHub API rate limit exceeded. Please try again later or add a GitHub token.');
+        }
+      }
+      if (response.status === 404) {
+        throw new Error('Repository not found. Check the URL and make sure the repository is public.');
+      }
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  /**
+   * Parse GitHub URL to extract owner and repo
+   */
+  parseGitHubUrl(url: string): { owner: string; repo: string } | null {
+    const match = url.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+    if (!match) {
+      return null;
+    }
+    return { owner: match[1], repo: match[2] };
+  }
+
+  /**
+   * Get repository information
+   */
+  async getRepository(owner: string, repo: string): Promise<GitHubRepo> {
+    return this.request<GitHubRepo>(`/repos/${owner}/${repo}`);
+  }
+
+  /**
+   * Get repository from URL
+   */
+  async getRepositoryFromUrl(url: string): Promise<GitHubRepo> {
+    const parsed = this.parseGitHubUrl(url);
+    if (!parsed) {
+      throw new Error('Invalid GitHub URL');
+    }
+    return this.getRepository(parsed.owner, parsed.repo);
+  }
+
+  /**
+   * Get repository contents at a path
+   */
+  async getContents(owner: string, repo: string, path: string = ''): Promise<GitHubContent[]> {
+    const result = await this.request<GitHubContent | GitHubContent[]>(
+      `/repos/${owner}/${repo}/contents/${path}`
+    );
+    return Array.isArray(result) ? result : [result];
+  }
+
+  /**
+   * Get file content
+   */
+  async getFileContent(owner: string, repo: string, path: string): Promise<string> {
+    const content = await this.request<GitHubContent>(
+      `/repos/${owner}/${repo}/contents/${path}`
+    );
+
+    if (content.content && content.encoding === 'base64') {
+      return Buffer.from(content.content, 'base64').toString('utf-8');
+    }
+
+    if (content.download_url) {
+      const response = await fetch(content.download_url);
+      return response.text();
+    }
+
+    throw new Error(`Could not retrieve content for ${path}`);
+  }
+
+  /**
+   * Get README content
+   */
+  async getReadme(owner: string, repo: string): Promise<string | null> {
+    try {
+      const readme = await this.request<GitHubContent>(
+        `/repos/${owner}/${repo}/readme`
+      );
+
+      if (readme.content && readme.encoding === 'base64') {
+        return Buffer.from(readme.content, 'base64').toString('utf-8');
+      }
+
+      if (readme.download_url) {
+        const response = await fetch(readme.download_url);
+        return response.text();
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Search for files in repository
+   */
+  async searchFiles(
+    owner: string, 
+    repo: string, 
+    query: string
+  ): Promise<Array<{ name: string; path: string }>> {
+    try {
+      const result = await this.request<{
+        items: Array<{ name: string; path: string }>;
+      }>(`/search/code?q=${encodeURIComponent(query)}+repo:${owner}/${repo}`);
+      return result.items || [];
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Find OpenAPI/Swagger files in repository
+   */
+  async findOpenApiFiles(owner: string, repo: string): Promise<string[]> {
+    const commonPaths = [
+      'openapi.json',
+      'openapi.yaml',
+      'openapi.yml',
+      'swagger.json',
+      'swagger.yaml',
+      'swagger.yml',
+      'api/openapi.json',
+      'api/openapi.yaml',
+      'docs/openapi.json',
+      'docs/openapi.yaml',
+      'spec/openapi.json',
+      'spec/openapi.yaml'
+    ];
+
+    const found: string[] = [];
+
+    for (const path of commonPaths) {
+      try {
+        await this.request(`/repos/${owner}/${repo}/contents/${path}`);
+        found.push(path);
+      } catch {
+        // File doesn't exist, continue
+      }
+    }
+
+    return found;
+  }
+
+  /**
+   * Get rate limit status
+   */
+  async getRateLimit(): Promise<GitHubRateLimit> {
+    const result = await this.request<{ rate: GitHubRateLimit }>('/rate_limit');
+    return result.rate;
+  }
+
+  /**
+   * Check rate limit and warn if low
+   */
+  async checkRateLimit(): Promise<boolean> {
+    try {
+      const limit = await this.getRateLimit();
+      
+      if (limit.remaining < 10) {
+        const resetDate = new Date(limit.reset * 1000);
+        const message = `GitHub API rate limit low (${limit.remaining} remaining). ` +
+          `Resets at ${resetDate.toLocaleTimeString()}.`;
+        
+        if (this.token) {
+          vscode.window.showWarningMessage(message);
+        } else {
+          vscode.window.showWarningMessage(
+            `${message} Add a GitHub token for higher limits.`,
+            'Add Token'
+          ).then(selection => {
+            if (selection === 'Add Token') {
+              vscode.commands.executeCommand('workbench.action.openSettings', 'github-to-mcp.githubToken');
+            }
+          });
+        }
+        
+        return limit.remaining > 0;
+      }
+      
+      return true;
+    } catch {
+      // Can't check rate limit, proceed anyway
+      return true;
+    }
+  }
+}
+
+/**
+ * Get the GitHub API client instance
+ */
+export function getGitHubClient(): GitHubApiClient {
+  return GitHubApiClient.getInstance();
+}
+
+/**
+ * Prompt user to enter GitHub token
+ */
+export async function promptForGitHubToken(): Promise<string | undefined> {
+  const token = await vscode.window.showInputBox({
+    prompt: 'Enter your GitHub Personal Access Token',
+    placeHolder: 'ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
+    password: true,
+    ignoreFocusOut: true,
+    validateInput: (value) => {
+      if (!value) {
+        return 'Token is required';
+      }
+      if (!value.startsWith('ghp_') && !value.startsWith('github_pat_')) {
+        return 'Invalid token format';
+      }
+      return null;
+    }
+  });
+
+  if (token) {
+    const config = vscode.workspace.getConfiguration('github-to-mcp');
+    await config.update('githubToken', token, vscode.ConfigurationTarget.Global);
+    getGitHubClient().setToken(token);
+    vscode.window.showInformationMessage('GitHub token saved successfully!');
+  }
+
+  return token;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Utility exports
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+export { StorageService, type ConversionResult } from './storage';
+export { GitHubApiClient, getGitHubClient, promptForGitHubToken } from './github-api';
+export {
+  getMcpConfigPath,
+  readMcpConfig,
+  writeMcpConfig,
+  addMcpServer,
+  removeMcpServer,
+  listMcpServers,
+  generateServerConfig,
+  formatConfigForClient,
+  openMcpConfigInEditor,
+  validateServerConfig,
+  type McpServerConfig,
+  type ClaudeDesktopConfig,
+  type CursorConfig,
+  type McpClientType
+} from './mcp-config';
+export {
+  generateMcpServerFiles,
+  type GeneratedFiles,
+  type GeneratorOptions
+} from './file-generator';

package/apps/vscode/src/utils/mcp-config.ts

@@ -0,0 +1,334 @@
+/**
+ * @fileoverview MCP configuration management for Claude Desktop and other clients
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import * as vscode from 'vscode';
+import * as os from 'os';
+import * as path from 'path';
+
+export interface McpServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface ClaudeDesktopConfig {
+  mcpServers?: Record<string, McpServerConfig>;
+}
+
+export interface CursorConfig {
+  mcp?: {
+    servers?: Record<string, McpServerConfig>;
+  };
+}
+
+export type McpClientType = 'claude' | 'cursor' | 'custom';
+
+/**
+ * Get the config file path for a specific MCP client
+ */
+export function getMcpConfigPath(client: McpClientType): string | null {
+  const platform = os.platform();
+  const homeDir = os.homedir();
+
+  switch (client) {
+    case 'claude':
+      switch (platform) {
+        case 'darwin':
+          return path.join(homeDir, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        case 'win32':
+          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;
+      }
+    
+    case 'cursor':
+      switch (platform) {
+        case 'darwin':
+          return path.join(homeDir, 'Library', 'Application Support', 'Cursor', 'User', 'settings.json');
+        case 'win32':
+          return path.join(homeDir, 'AppData', 'Roaming', 'Cursor', 'User', 'settings.json');
+        case 'linux':
+          return path.join(homeDir, '.config', 'Cursor', 'User', 'settings.json');
+        default:
+          return null;
+      }
+    
+    default:
+      return null;
+  }
+}
+
+/**
+ * Read MCP configuration from file
+ */
+export async function readMcpConfig(client: McpClientType): Promise<ClaudeDesktopConfig | CursorConfig | null> {
+  const configPath = getMcpConfigPath(client);
+  if (!configPath) {
+    return null;
+  }
+
+  try {
+    const configUri = vscode.Uri.file(configPath);
+    const content = await vscode.workspace.fs.readFile(configUri);
+    return JSON.parse(Buffer.from(content).toString('utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write MCP configuration to file
+ */
+export async function writeMcpConfig(
+  client: McpClientType, 
+  config: ClaudeDesktopConfig | CursorConfig
+): Promise<void> {
+  const configPath = getMcpConfigPath(client);
+  if (!configPath) {
+    throw new Error(`Unsupported platform for ${client}`);
+  }
+
+  const configUri = vscode.Uri.file(configPath);
+  const configDir = path.dirname(configPath);
+
+  // Ensure directory exists
+  try {
+    await vscode.workspace.fs.createDirectory(vscode.Uri.file(configDir));
+  } catch {
+    // Directory may already exist
+  }
+
+  // Write config
+  await vscode.workspace.fs.writeFile(
+    configUri,
+    Buffer.from(JSON.stringify(config, null, 2), 'utf-8')
+  );
+}
+
+/**
+ * Add an MCP server to client configuration
+ */
+export async function addMcpServer(
+  client: McpClientType,
+  serverName: string,
+  serverConfig: McpServerConfig
+): Promise<void> {
+  let config = await readMcpConfig(client);
+
+  if (client === 'claude') {
+    const claudeConfig = (config as ClaudeDesktopConfig) || {};
+    claudeConfig.mcpServers = claudeConfig.mcpServers || {};
+    claudeConfig.mcpServers[serverName] = serverConfig;
+    await writeMcpConfig(client, claudeConfig);
+  } else if (client === 'cursor') {
+    const cursorConfig = (config as CursorConfig) || {};
+    cursorConfig.mcp = cursorConfig.mcp || {};
+    cursorConfig.mcp.servers = cursorConfig.mcp.servers || {};
+    cursorConfig.mcp.servers[serverName] = serverConfig;
+    await writeMcpConfig(client, cursorConfig);
+  }
+}
+
+/**
+ * Remove an MCP server from client configuration
+ */
+export async function removeMcpServer(
+  client: McpClientType,
+  serverName: string
+): Promise<boolean> {
+  const config = await readMcpConfig(client);
+  if (!config) {
+    return false;
+  }
+
+  let removed = false;
+
+  if (client === 'claude') {
+    const claudeConfig = config as ClaudeDesktopConfig;
+    if (claudeConfig.mcpServers?.[serverName]) {
+      delete claudeConfig.mcpServers[serverName];
+      await writeMcpConfig(client, claudeConfig);
+      removed = true;
+    }
+  } else if (client === 'cursor') {
+    const cursorConfig = config as CursorConfig;
+    if (cursorConfig.mcp?.servers?.[serverName]) {
+      delete cursorConfig.mcp.servers[serverName];
+      await writeMcpConfig(client, cursorConfig);
+      removed = true;
+    }
+  }
+
+  return removed;
+}
+
+/**
+ * List all configured MCP servers for a client
+ */
+export async function listMcpServers(client: McpClientType): Promise<Record<string, McpServerConfig>> {
+  const config = await readMcpConfig(client);
+  if (!config) {
+    return {};
+  }
+
+  if (client === 'claude') {
+    return (config as ClaudeDesktopConfig).mcpServers || {};
+  } else if (client === 'cursor') {
+    return (config as CursorConfig).mcp?.servers || {};
+  }
+
+  return {};
+}
+
+/**
+ * Generate MCP server configuration object
+ */
+export function generateServerConfig(
+  serverPath: string,
+  options?: {
+    runtime?: 'node' | 'python' | 'deno';
+    env?: Record<string, string>;
+    args?: string[];
+  }
+): McpServerConfig {
+  const runtime = options?.runtime || detectRuntime(serverPath);
+  
+  let command: string;
+  let args: string[];
+
+  switch (runtime) {
+    case 'node':
+      command = 'node';
+      args = [serverPath, ...(options?.args || [])];
+      break;
+    case 'python':
+      command = 'python';
+      args = [serverPath, ...(options?.args || [])];
+      break;
+    case 'deno':
+      command = 'deno';
+      args = ['run', '--allow-all', serverPath, ...(options?.args || [])];
+      break;
+    default:
+      command = serverPath;
+      args = options?.args || [];
+  }
+
+  const config: McpServerConfig = { command, args };
+  
+  if (options?.env && Object.keys(options.env).length > 0) {
+    config.env = options.env;
+  }
+
+  return config;
+}
+
+/**
+ * Detect runtime from file extension
+ */
+function detectRuntime(filePath: string): 'node' | 'python' | 'deno' | null {
+  const ext = path.extname(filePath).toLowerCase();
+  
+  switch (ext) {
+    case '.js':
+    case '.mjs':
+    case '.cjs':
+      return 'node';
+    case '.ts':
+      // Check if Deno is preferred
+      return 'node'; // Default to node with ts-node
+    case '.py':
+      return 'python';
+    default:
+      return null;
+  }
+}
+
+/**
+ * Format config for display/clipboard based on client type
+ */
+export function formatConfigForClient(
+  serverName: string,
+  serverConfig: McpServerConfig,
+  client: McpClientType
+): string {
+  if (client === 'claude') {
+    return JSON.stringify({
+      mcpServers: {
+        [serverName]: serverConfig
+      }
+    }, null, 2);
+  } else if (client === 'cursor') {
+    return JSON.stringify({
+      mcp: {
+        servers: {
+          [serverName]: serverConfig
+        }
+      }
+    }, null, 2);
+  }
+
+  return JSON.stringify({
+    [serverName]: serverConfig
+  }, null, 2);
+}
+
+/**
+ * Open MCP config file in editor
+ */
+export async function openMcpConfigInEditor(client: McpClientType): Promise<void> {
+  const configPath = getMcpConfigPath(client);
+  if (!configPath) {
+    vscode.window.showErrorMessage(`Could not determine config path for ${client}`);
+    return;
+  }
+
+  try {
+    const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(configPath));
+    await vscode.window.showTextDocument(doc);
+  } catch {
+    // File doesn't exist, create it
+    const create = await vscode.window.showInformationMessage(
+      `${client} config file does not exist. Create it?`,
+      'Create',
+      'Cancel'
+    );
+
+    if (create === 'Create') {
+      const initialConfig = client === 'claude' 
+        ? { mcpServers: {} } 
+        : { mcp: { servers: {} } };
+      
+      await writeMcpConfig(client, initialConfig);
+      
+      const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(configPath));
+      await vscode.window.showTextDocument(doc);
+    }
+  }
+}
+
+/**
+ * Validate MCP server config
+ */
+export function validateServerConfig(config: McpServerConfig): string[] {
+  const errors: string[] = [];
+
+  if (!config.command) {
+    errors.push('Command is required');
+  }
+
+  if (config.args && !Array.isArray(config.args)) {
+    errors.push('Args must be an array');
+  }
+
+  if (config.env && typeof config.env !== 'object') {
+    errors.push('Env must be an object');
+  }
+
+  return errors;
+}