github-to-mcp-monorepo 1.0.0

package/packages/core/src/github-client.ts

@@ -0,0 +1,319 @@
+/**
+ * @fileoverview API client implementation
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+/**
+ * GitHub Repository Client
+ * Fetch files and metadata from GitHub repositories
+ */
+
+import { Octokit } from '@octokit/rest';
+import { RepoMetadata, FileContent, ApiSpec } from './types';
+
+export class GithubClient {
+  private octokit: Octokit;
+
+  constructor(token?: string) {
+    this.octokit = new Octokit({
+      auth: token
+    });
+  }
+
+  /**
+   * Parse GitHub URL to extract metadata
+   */
+  parseGithubUrl(url: string): RepoMetadata {
+    // Handle URLs with /tree/branch pattern
+    // Format: github.com/owner/repo/tree/branch[/path]
+    const treeMatch = url.match(/github\.com\/([^\/]+)\/([^\/]+)\/tree\/(.+)/);
+    if (treeMatch) {
+      const owner = treeMatch[1];
+      const repo = treeMatch[2].replace('.git', '');
+      const rest = treeMatch[3];
+      
+      // Split the rest into parts
+      const parts = rest.split('/');
+      
+      // Heuristic: if the URL looks like it has a file path (contains common extensions or known dirs)
+      // try to identify where branch ends and path begins
+      // Common approach: first segment is branch unless it contains file-like patterns
+      
+      // Check if this looks like a branch with slashes (feature/xxx pattern)
+      // by looking for common file extensions or src/lib/etc paths
+      const fileExtensions = /\.(ts|js|py|md|json|yaml|yml|tsx|jsx|html|css|go|rs|java|rb|php)$/i;
+      const commonDirs = ['src', 'lib', 'packages', 'apps', 'test', 'tests', 'docs', 'examples'];
+      
+      let branch = parts[0];
+      let pathParts: string[] = [];
+      
+      // If only one part, it's just the branch
+      if (parts.length === 1) {
+        return { owner, repo, branch, path: undefined };
+      }
+      
+      // Check if second part looks like a directory/file rather than continuation of branch
+      // This handles: tree/main/src/file.ts (branch=main, path=src/file.ts)
+      // vs: tree/feature/new-feature (branch=feature/new-feature)
+      if (commonDirs.includes(parts[1]) || fileExtensions.test(parts[parts.length - 1])) {
+        // Likely first part is branch, rest is path
+        branch = parts[0];
+        pathParts = parts.slice(1);
+      } else {
+        // Could be a branch with slashes - if last part has extension, work backwards
+        if (fileExtensions.test(parts[parts.length - 1])) {
+          // Find where path starts by looking for common dirs
+          let pathStart = parts.length;
+          for (let i = 1; i < parts.length; i++) {
+            if (commonDirs.includes(parts[i])) {
+              pathStart = i;
+              break;
+            }
+          }
+          branch = parts.slice(0, pathStart).join('/');
+          pathParts = parts.slice(pathStart);
+        } else {
+          // No file extension - assume it's all branch name
+          branch = rest;
+          pathParts = [];
+        }
+      }
+      
+      return {
+        owner,
+        repo,
+        branch,
+        path: pathParts.length > 0 ? pathParts.join('/') : undefined
+      };
+    }
+    
+    const patterns = [
+      /github\.com\/([^\/]+)\/([^\/]+)$/,
+      /github\.com\/([^\/]+)\/([^\/]+)/
+    ];
+
+    for (const pattern of patterns) {
+      const match = url.match(pattern);
+      if (match) {
+        return {
+          owner: match[1],
+          repo: match[2].replace('.git', ''),
+          branch: match[3] || 'main',
+          path: match[4]
+        };
+      }
+    }
+
+    throw new Error(`Invalid GitHub URL: ${url}`);
+  }
+
+  /**
+   * Get repository metadata
+   */
+  async getRepoMetadata(owner: string, repo: string) {
+    const { data } = await this.octokit.repos.get({
+      owner,
+      repo
+    });
+
+    return {
+      stars: data.stargazers_count,
+      language: data.language || 'unknown',
+      license: data.license?.spdx_id ?? undefined,
+      description: data.description ?? undefined,
+      defaultBranch: data.default_branch
+    };
+  }
+
+  /**
+   * Get file content from repository
+   */
+  async getFileContent(
+    owner: string,
+    repo: string,
+    path: string,
+    branch?: string
+  ): Promise<FileContent | null> {
+    try {
+      const { data } = await this.octokit.repos.getContent({
+        owner,
+        repo,
+        path,
+        ref: branch
+      });
+
+      if (Array.isArray(data)) {
+        return null; // Directory
+      }
+
+      if (data.type === 'file' && data.content) {
+        const content = Buffer.from(data.content, 'base64').toString('utf-8');
+        return {
+          path: data.path,
+          content,
+          type: 'file',
+          sha: data.sha
+        };
+      }
+
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * List directory contents
+   */
+  async listDirectory(
+    owner: string,
+    repo: string,
+    path: string = '',
+    branch?: string
+  ): Promise<FileContent[]> {
+    try {
+      const { data } = await this.octokit.repos.getContent({
+        owner,
+        repo,
+        path,
+        ref: branch
+      });
+
+      if (!Array.isArray(data)) {
+        return [];
+      }
+
+      return data.map(item => ({
+        path: item.path,
+        content: '',
+        type: item.type as 'file' | 'dir',
+        sha: item.sha
+      }));
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Search for API specification files
+   */
+  async findApiSpecs(
+    owner: string,
+    repo: string,
+    branch?: string
+  ): Promise<ApiSpec[]> {
+    const specs: ApiSpec[] = [];
+
+    // Common locations for API specs
+    const locations = [
+      'openapi.json',
+      'openapi.yaml',
+      'openapi.yml',
+      'swagger.json',
+      'swagger.yaml',
+      'swagger.yml',
+      'api/openapi.json',
+      'api/swagger.json',
+      'spec/openapi.json',
+      'spec/swagger.json',
+      'docs/openapi.json',
+      'docs/swagger.json',
+      '.well-known/openapi.json'
+    ];
+
+    for (const location of locations) {
+      const file = await this.getFileContent(owner, repo, location, branch);
+      
+      if (file) {
+        try {
+          const spec = JSON.parse(file.content);
+          
+          // Determine type and version
+          let type: 'openapi' | 'swagger' = 'openapi';
+          let version = '3.0.0';
+
+          if (spec.swagger) {
+            type = 'swagger';
+            version = spec.swagger;
+          } else if (spec.openapi) {
+            type = 'openapi';
+            version = spec.openapi;
+          }
+
+          specs.push({
+            type,
+            version,
+            spec,
+            path: location
+          });
+        } catch (error) {
+          // Not JSON, try YAML
+          continue;
+        }
+      }
+    }
+
+    return specs;
+  }
+
+  /**
+   * Get README content
+   */
+  async getReadme(owner: string, repo: string, branch?: string): Promise<string | null> {
+    const readmeFiles = ['README.md', 'README.MD', 'readme.md', 'Readme.md'];
+
+    for (const filename of readmeFiles) {
+      const file = await this.getFileContent(owner, repo, filename, branch);
+      if (file) {
+        return file.content;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Search repository for files by pattern
+   */
+  async searchFiles(
+    owner: string,
+    repo: string,
+    pattern: RegExp,
+    maxDepth: number = 3
+  ): Promise<FileContent[]> {
+    const results: FileContent[] = [];
+
+    const searchDir = async (path: string, depth: number) => {
+      if (depth > maxDepth) return;
+
+      const contents = await this.listDirectory(owner, repo, path);
+
+      for (const item of contents) {
+        if (item.type === 'file' && pattern.test(item.path)) {
+          const file = await this.getFileContent(owner, repo, item.path);
+          if (file) {
+            results.push(file);
+          }
+        } else if (item.type === 'dir') {
+          await searchDir(item.path, depth + 1);
+        }
+      }
+    };
+
+    await searchDir('', 0);
+    return results;
+  }
+
+  /**
+   * Rate limit info
+   */
+  async getRateLimit() {
+    const { data } = await this.octokit.rateLimit.get();
+    return {
+      remaining: data.rate.remaining,
+      limit: data.rate.limit,
+      reset: new Date(data.rate.reset * 1000)
+    };
+  }
+}

package/packages/core/src/go-generator.ts

@@ -0,0 +1,356 @@
+/**
+ * @fileoverview Go MCP server code generator
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license MIT
+ */
+
+import type { ExtractedTool } from './types';
+
+/**
+ * Generate Go MCP server code from tools
+ */
+export class GoGenerator {
+  /**
+   * Generate complete Go MCP server code
+   */
+  generateServer(tools: ExtractedTool[], repoName: string, owner: string): string {
+    const toolDefinitions = this.generateToolDefinitions(tools);
+    const toolHandlers = this.generateToolHandlers(tools, owner, repoName);
+    const moduleName = this.sanitizeModuleName(repoName);
+    
+    return `// Auto-generated MCP server for ${repoName}
+// Generated by @nirholas/github-to-mcp
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+func main() {
+	// Create server instance
+	s := server.NewMCPServer(
+		"${moduleName}-mcp",
+		"1.0.0",
+		server.WithResourceCapabilities(true, true),
+		server.WithPromptCapabilities(true),
+		server.WithToolCapabilities(true),
+	)
+
+	// Register tools
+	registerTools(s)
+
+	// Start stdio server
+	if err := server.ServeStdio(s); err != nil {
+		fmt.Fprintf(os.Stderr, "Server error: %v\\n", err)
+		os.Exit(1)
+	}
+}
+
+func registerTools(s *server.MCPServer) {
+${toolDefinitions}
+}
+
+// Tool handler implementations
+${toolHandlers}
+
+// Helper function to make HTTP requests
+func httpGet(url string, headers map[string]string) ([]byte, error) {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+	
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode >= 400 {
+		return nil, fmt.Errorf("HTTP error: %d", resp.StatusCode)
+	}
+	
+	return io.ReadAll(resp.Body)
+}
+
+// Helper function to format JSON response
+func formatJSON(data interface{}) string {
+	bytes, err := json.MarshalIndent(data, "", "  ")
+	if err != nil {
+		return fmt.Sprintf("%v", data)
+	}
+	return string(bytes)
+}
+`;
+  }
+
+  /**
+   * Generate Go tool definitions
+   */
+  private generateToolDefinitions(tools: ExtractedTool[]): string {
+    return tools.map(tool => {
+      const schemaJSON = JSON.stringify({
+        type: 'object',
+        properties: tool.inputSchema.properties || {},
+        required: tool.inputSchema.required || [],
+      }, null, 2).replace(/"/g, '`');
+
+      return `	// Register ${tool.name}
+	s.AddTool(
+		mcp.NewTool("${tool.name}",
+			mcp.WithDescription("${this.escapeString(tool.description)}"),
+			mcp.WithString("inputSchema",
+				mcp.Description("Input schema for the tool"),
+			),
+		),
+		handle${this.toPascalCase(tool.name)},
+	)`;
+    }).join('\n\n');
+  }
+
+  /**
+   * Generate tool handler functions
+   */
+  private generateToolHandlers(tools: ExtractedTool[], owner: string, repo: string): string {
+    return tools.map(tool => {
+      const funcName = `handle${this.toPascalCase(tool.name)}`;
+      const impl = this.generateGoImplementation(tool, owner, repo);
+      
+      return `func ${funcName}(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	arguments := request.Params.Arguments
+${impl}
+}`;
+    }).join('\n\n');
+  }
+
+  /**
+   * Generate Go implementation for a tool
+   */
+  private generateGoImplementation(tool: ExtractedTool, owner: string, repo: string): string {
+    // Check if it's a universal tool
+    if (tool.source.type === 'universal') {
+      return this.generateUniversalToolGo(tool.name, owner, repo);
+    }
+
+    // Check if it's a GraphQL tool
+    if (tool.source.type === 'graphql') {
+      return this.generateGraphQLToolGo(tool);
+    }
+
+    // Default implementation
+    return `	// TODO: Implement ${tool.name}
+	return mcp.NewToolResultText(fmt.Sprintf("Tool ${tool.name} called with args: %v", arguments)), nil`;
+  }
+
+  /**
+   * Generate Go code for universal tools
+   */
+  private generateUniversalToolGo(name: string, owner: string, repo: string): string {
+    switch (name) {
+      case 'get_readme':
+        return `	url := "https://api.github.com/repos/${owner}/${repo}/readme"
+	headers := map[string]string{"Accept": "application/vnd.github.raw"}
+	
+	body, err := httpGet(url, headers)
+	if err != nil {
+		return mcp.NewToolResultError(-1, fmt.Sprintf("Failed to fetch README: %v", err)), nil
+	}
+	
+	return mcp.NewToolResultText(string(body)), nil`;
+
+      case 'list_files':
+        return `	path, _ := arguments["path"].(string)
+	url := fmt.Sprintf("https://api.github.com/repos/${owner}/${repo}/contents/%s", path)
+	
+	body, err := httpGet(url, nil)
+	if err != nil {
+		return mcp.NewToolResultError(-1, fmt.Sprintf("Failed to list files: %v", err)), nil
+	}
+	
+	var files []map[string]interface{}
+	if err := json.Unmarshal(body, &files); err != nil {
+		// Single file response
+		var file map[string]interface{}
+		if err := json.Unmarshal(body, &file); err != nil {
+			return mcp.NewToolResultError(-1, fmt.Sprintf("Failed to parse response: %v", err)), nil
+		}
+		files = []map[string]interface{}{file}
+	}
+	
+	result := make([]map[string]string, 0, len(files))
+	for _, f := range files {
+		result = append(result, map[string]string{
+			"name": f["name"].(string),
+			"type": f["type"].(string),
+			"path": f["path"].(string),
+		})
+	}
+	
+	return mcp.NewToolResultText(formatJSON(result)), nil`;
+
+      case 'read_file':
+        return `	path, _ := arguments["path"].(string)
+	url := fmt.Sprintf("https://api.github.com/repos/${owner}/${repo}/contents/%s", path)
+	headers := map[string]string{"Accept": "application/vnd.github.raw"}
+	
+	body, err := httpGet(url, headers)
+	if err != nil {
+		return mcp.NewToolResultError(-1, fmt.Sprintf("Failed to read file: %v", err)), nil
+	}
+	
+	return mcp.NewToolResultText(string(body)), nil`;
+
+      case 'search_code':
+        return `	query, _ := arguments["query"].(string)
+	url := fmt.Sprintf("https://api.github.com/search/code?q=%s+repo:${owner}/${repo}", query)
+	
+	body, err := httpGet(url, nil)
+	if err != nil {
+		return mcp.NewToolResultError(-1, fmt.Sprintf("Failed to search code: %v", err)), nil
+	}
+	
+	var data struct {
+		Items []struct {
+			Path    string \`json:"path"\`
+			HtmlURL string \`json:"html_url"\`
+		} \`json:"items"\`
+	}
+	
+	if err := json.Unmarshal(body, &data); err != nil {
+		return mcp.NewToolResultError(-1, fmt.Sprintf("Failed to parse response: %v", err)), nil
+	}
+	
+	if len(data.Items) == 0 {
+		return mcp.NewToolResultText(fmt.Sprintf("No results found for: %s", query)), nil
+	}
+	
+	results := make([]map[string]string, 0, 10)
+	for i, item := range data.Items {
+		if i >= 10 {
+			break
+		}
+		results = append(results, map[string]string{
+			"file": item.Path,
+			"url":  item.HtmlURL,
+		})
+	}
+	
+	return mcp.NewToolResultText(formatJSON(results)), nil`;
+
+      default:
+        return `	return mcp.NewToolResultText(fmt.Sprintf("Tool ${name} not implemented")), nil`;
+    }
+  }
+
+  /**
+   * Generate Go code for GraphQL tools
+   */
+  private generateGraphQLToolGo(tool: ExtractedTool): string {
+    return `	// GraphQL query execution
+	query := \`${tool.implementation?.match(/query = \`([^`]+)\`/)?.[1] || 'query { __typename }'}\`
+	
+	// TODO: Implement GraphQL request
+	return mcp.NewToolResultText(fmt.Sprintf("GraphQL tool %s: %v", "${tool.name}", query)), nil`;
+  }
+
+  /**
+   * Generate go.mod content
+   */
+  generateGoMod(repoName: string): string {
+    const moduleName = this.sanitizeModuleName(repoName);
+    return `module ${moduleName}-mcp
+
+go 1.21
+
+require github.com/mark3labs/mcp-go v0.6.0
+`;
+  }
+
+  /**
+   * Generate README content
+   */
+  generateReadme(repoName: string, owner: string): string {
+    const moduleName = this.sanitizeModuleName(repoName);
+    return `# ${repoName} MCP Server (Go)
+
+Auto-generated MCP server for interacting with the ${owner}/${repoName} GitHub repository.
+
+## Installation
+
+\`\`\`bash
+go build -o ${moduleName}-mcp .
+\`\`\`
+
+## Usage
+
+### With Claude Desktop
+
+Add to your \`claude_desktop_config.json\`:
+
+\`\`\`json
+{
+  "mcpServers": {
+    "${moduleName}": {
+      "command": "/path/to/${moduleName}-mcp"
+    }
+  }
+}
+\`\`\`
+
+### Standalone
+
+\`\`\`bash
+./${moduleName}-mcp
+\`\`\`
+
+## Dependencies
+
+- [mcp-go](https://github.com/mark3labs/mcp-go) - Go SDK for Model Context Protocol
+
+## License
+
+MIT
+`;
+  }
+
+  /**
+   * Convert tool name to PascalCase for Go function names
+   */
+  private toPascalCase(name: string): string {
+    return name
+      .split(/[-_]/)
+      .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+      .join('');
+  }
+
+  /**
+   * Sanitize module name for Go
+   */
+  private sanitizeModuleName(name: string): string {
+    return name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/--+/g, '-');
+  }
+
+  /**
+   * Escape string for Go
+   */
+  private escapeString(str: string): string {
+    return str
+      .replace(/\\/g, '\\\\')
+      .replace(/"/g, '\\"')
+      .replace(/\n/g, '\\n');
+  }
+}