Aug 19, 2025 · Aug 12, 2025 · Aug 12, 2025 · Aug 12, 2025 · Aug 12, 2025 · Aug 13, 2025
diff --git a/cmd/github-mcp-server/generate_docs.go b/cmd/github-mcp-server/generate_docs.go
 t, _ := translations.TranslationHelper()

 // Create toolset group with mock clients
 tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t)
 tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t, 5000)

 // Generate toolsets documentation
 toolsetsDoc := generateToolsetsDoc(tsg)
 t, _ := translations.TranslationHelper()

 // Create toolset group with mock clients
 tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t)
 tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t, 5000)

 // Generate table header
 buf.WriteString("| Name           | Description                                      | API URL                                               | 1-Click Install (VS Code)                                                                                                                                                                                                 | Read-only Link                                                                                                 | 1-Click Read-only Install (VS Code)                                                                                                                                                                                                 |\n")
diff --git a/cmd/github-mcp-server/main.go b/cmd/github-mcp-server/main.go
 ExportTranslations:   viper.GetBool("export-translations"),
 EnableCommandLogging: viper.GetBool("enable-command-logging"),
 LogFilePath:          viper.GetString("log-file"),
 ContentWindowSize:    viper.GetInt("content-window-size"),
 }
 return ghmcp.RunStdioServer(stdioServerConfig)
 },
 rootCmd.PersistentFlags().Bool("enable-command-logging", false, "When enabled, the server will log all command requests and responses to the log file")
 rootCmd.PersistentFlags().Bool("export-translations", false, "Save translations to a JSON file")
 rootCmd.PersistentFlags().String("gh-host", "", "Specify the GitHub hostname (for GitHub Enterprise etc.)")
 rootCmd.PersistentFlags().Int("content-window-size", 5000, "Specify the content window size")

 // Bind flag to viper
 _ = viper.BindPFlag("toolsets", rootCmd.PersistentFlags().Lookup("toolsets"))
 _ = viper.BindPFlag("enable-command-logging", rootCmd.PersistentFlags().Lookup("enable-command-logging"))
 _ = viper.BindPFlag("export-translations", rootCmd.PersistentFlags().Lookup("export-translations"))
 _ = viper.BindPFlag("host", rootCmd.PersistentFlags().Lookup("gh-host"))
 _ = viper.BindPFlag("content-window-size", rootCmd.PersistentFlags().Lookup("content-window-size"))

 // Add subcommands
 rootCmd.AddCommand(stdioCmd)
diff --git a/internal/ghmcp/server.go b/internal/ghmcp/server.go

 // Translator provides translated text for the server tooling
 Translator translations.TranslationHelperFunc

 // Content window size
 ContentWindowSize int
 }

 const stdioServerLogPrefix = "stdioserver"
 }

 // Create default toolsets
 tsg := github.DefaultToolsetGroup(cfg.ReadOnly, getClient, getGQLClient, getRawClient, cfg.Translator)
 tsg := github.DefaultToolsetGroup(cfg.ReadOnly, getClient, getGQLClient, getRawClient, cfg.Translator, cfg.ContentWindowSize)
 err = tsg.EnableToolsets(enabledToolsets)

 if err != nil {

 // Path to the log file if not stderr
 LogFilePath string

 // Content window size
 ContentWindowSize int
 }

 // RunStdioServer is not concurrent safe.
 t, dumpTranslations := translations.TranslationHelper()

 ghServer, err := NewMCPServer(MCPServerConfig{
 Version:         cfg.Version,
 Host:            cfg.Host,
 Token:           cfg.Token,
 EnabledToolsets: cfg.EnabledToolsets,
 DynamicToolsets: cfg.DynamicToolsets,
 ReadOnly:        cfg.ReadOnly,
 Translator:      t,
 Version:           cfg.Version,
 Host:              cfg.Host,
 Token:             cfg.Token,
 EnabledToolsets:   cfg.EnabledToolsets,
 DynamicToolsets:   cfg.DynamicToolsets,
 ReadOnly:          cfg.ReadOnly,
 Translator:        t,
 ContentWindowSize: cfg.ContentWindowSize,
 })
 if err != nil {
 return fmt.Errorf("failed to create MCP server: %w", err)
diff --git a/internal/profiler/profiler.go b/internal/profiler/profiler.go
 package profiler

 import (
 "context"
 "fmt"
 "os"
 "runtime"
 "strconv"
 "time"

 "log/slog"
 "math"
 )

 // Profile represents performance metrics for an operation
 type Profile struct {
 Operation    string        `json:"operation"`
 Duration     time.Duration `json:"duration_ns"`
 MemoryBefore uint64        `json:"memory_before_bytes"`
 MemoryAfter  uint64        `json:"memory_after_bytes"`
 MemoryDelta  int64         `json:"memory_delta_bytes"`
 LinesCount   int           `json:"lines_count,omitempty"`
 BytesCount   int64         `json:"bytes_count,omitempty"`
 Timestamp    time.Time     `json:"timestamp"`
 }

 // String returns a human-readable representation of the profile
 func (p *Profile) String() string {
 return fmt.Sprintf("[%s] %s: duration=%v, memory_delta=%+dB, lines=%d, bytes=%d",
 p.Timestamp.Format("15:04:05.000"),
 p.Operation,
 p.Duration,
 p.MemoryDelta,
 p.LinesCount,
 p.BytesCount,
 )
 }

 func safeMemoryDelta(after, before uint64) int64 {
 if after > math.MaxInt64 || before > math.MaxInt64 {
 if after >= before {
 diff := after - before
 if diff > math.MaxInt64 {
 return math.MaxInt64
 }
 return int64(diff)
 }
 diff := before - after
 if diff > math.MaxInt64 {
 return -math.MaxInt64
 }
 return -int64(diff)
 }

 return int64(after) - int64(before)
 }

 // Profiler provides minimal performance profiling capabilities
 type Profiler struct {
 logger  *slog.Logger
 enabled bool
 }

 // New creates a new Profiler instance
 func New(logger *slog.Logger, enabled bool) *Profiler {
 return &Profiler{
 logger:  logger,
 enabled: enabled,
 }
 }

 // ProfileFunc profiles a function execution
 func (p *Profiler) ProfileFunc(ctx context.Context, operation string, fn func() error) (*Profile, error) {
 if !p.enabled {
 return nil, fn()
 }

 profile := &Profile{
 Operation: operation,
 Timestamp: time.Now(),
 }

 var memBefore runtime.MemStats
 runtime.ReadMemStats(&memBefore)
 profile.MemoryBefore = memBefore.Alloc

 start := time.Now()
 err := fn()
 profile.Duration = time.Since(start)

 var memAfter runtime.MemStats
 runtime.ReadMemStats(&memAfter)
 profile.MemoryAfter = memAfter.Alloc
 profile.MemoryDelta = safeMemoryDelta(memAfter.Alloc, memBefore.Alloc)

 if p.logger != nil {
 p.logger.InfoContext(ctx, "Performance profile", "profile", profile.String())
 }

 return profile, err
 }

 // ProfileFuncWithMetrics profiles a function execution and captures additional metrics
 func (p *Profiler) ProfileFuncWithMetrics(ctx context.Context, operation string, fn func() (int, int64, error)) (*Profile, error) {
 if !p.enabled {
 _, _, err := fn()
 return nil, err
 }

 profile := &Profile{
 Operation: operation,
 Timestamp: time.Now(),
 }

 var memBefore runtime.MemStats
 runtime.ReadMemStats(&memBefore)
 profile.MemoryBefore = memBefore.Alloc

 start := time.Now()
 lines, bytes, err := fn()
 profile.Duration = time.Since(start)
 profile.LinesCount = lines
 profile.BytesCount = bytes

 var memAfter runtime.MemStats
 runtime.ReadMemStats(&memAfter)
 profile.MemoryAfter = memAfter.Alloc
 profile.MemoryDelta = safeMemoryDelta(memAfter.Alloc, memBefore.Alloc)

 if p.logger != nil {
 p.logger.InfoContext(ctx, "Performance profile", "profile", profile.String())
 }

 return profile, err
 }

 // Start begins timing an operation and returns a function to complete the profiling
 func (p *Profiler) Start(ctx context.Context, operation string) func(lines int, bytes int64) *Profile {
 if !p.enabled {
 return func(int, int64) *Profile { return nil }
 }

 profile := &Profile{
 Operation: operation,
 Timestamp: time.Now(),
 }

 var memBefore runtime.MemStats
 runtime.ReadMemStats(&memBefore)
 profile.MemoryBefore = memBefore.Alloc

 start := time.Now()

 return func(lines int, bytes int64) *Profile {
 profile.Duration = time.Since(start)
 profile.LinesCount = lines
 profile.BytesCount = bytes

 var memAfter runtime.MemStats
 runtime.ReadMemStats(&memAfter)
 profile.MemoryAfter = memAfter.Alloc
 profile.MemoryDelta = safeMemoryDelta(memAfter.Alloc, memBefore.Alloc)

 if p.logger != nil {
 p.logger.InfoContext(ctx, "Performance profile", "profile", profile.String())
 }

 return profile
 }
 }

 var globalProfiler *Profiler

 // IsProfilingEnabled checks if profiling is enabled via environment variables
 func IsProfilingEnabled() bool {
 if enabled, err := strconv.ParseBool(os.Getenv("GITHUB_MCP_PROFILING_ENABLED")); err == nil {
 return enabled
 }
 return false
 }

 // Init initializes the global profiler
 func Init(logger *slog.Logger, enabled bool) {
 globalProfiler = New(logger, enabled)
 }

 // InitFromEnv initializes the global profiler using environment variables
 func InitFromEnv(logger *slog.Logger) {
 globalProfiler = New(logger, IsProfilingEnabled())
 }

 // ProfileFunc profiles a function using the global profiler
 func ProfileFunc(ctx context.Context, operation string, fn func() error) (*Profile, error) {
 if globalProfiler == nil {
 return nil, fn()
 }
 return globalProfiler.ProfileFunc(ctx, operation, fn)
 }

 // ProfileFuncWithMetrics profiles a function with metrics using the global profiler
 func ProfileFuncWithMetrics(ctx context.Context, operation string, fn func() (int, int64, error)) (*Profile, error) {
 if globalProfiler == nil {
 _, _, err := fn()
 return nil, err
 }
 return globalProfiler.ProfileFuncWithMetrics(ctx, operation, fn)
 }

 // Start begins timing using the global profiler
 func Start(ctx context.Context, operation string) func(int, int64) *Profile {
 if globalProfiler == nil {
 return func(int, int64) *Profile { return nil }
 }
 return globalProfiler.Start(ctx, operation)
 }
diff --git a/pkg/buffer/buffer.go b/pkg/buffer/buffer.go
 package buffer

 import (
 "bufio"
 "fmt"
 "net/http"
 "strings"
 )

 // ProcessResponseAsRingBufferToEnd reads the body of an HTTP response line by line,
 // storing only the last maxJobLogLines lines using a ring buffer (sliding window).
 // This efficiently retains the most recent lines, overwriting older ones as needed.
 //
 // Parameters:
 //
 //httpResp:        The HTTP response whose body will be read.
 //maxJobLogLines:  The maximum number of log lines to retain.
 //
 // Returns:
 //
 //string:          The concatenated log lines (up to maxJobLogLines), separated by newlines.
 //int:             The total number of lines read from the response.
 //*http.Response:  The original HTTP response.
 //error:           Any error encountered during reading.
 //
 // The function uses a ring buffer to efficiently store only the last maxJobLogLines lines.
 // If the response contains more lines than maxJobLogLines, only the most recent lines are kept.
 func ProcessResponseAsRingBufferToEnd(httpResp *http.Response, maxJobLogLines int) (string, int, *http.Response, error) {
 lines := make([]string, maxJobLogLines)
 validLines := make([]bool, maxJobLogLines)
 totalLines := 0
 writeIndex := 0

 scanner := bufio.NewScanner(httpResp.Body)
 scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)

 for scanner.Scan() {
 line := scanner.Text()
 totalLines++

 lines[writeIndex] = line
 validLines[writeIndex] = true
 writeIndex = (writeIndex + 1) % maxJobLogLines
 }

 if err := scanner.Err(); err != nil {
 return "", 0, httpResp, fmt.Errorf("failed to read log content: %w", err)
 }

 var result []string
 linesInBuffer := totalLines
 if linesInBuffer > maxJobLogLines {
 linesInBuffer = maxJobLogLines
 }

 startIndex := 0
 if totalLines > maxJobLogLines {
 startIndex = writeIndex
 }

 for i := 0; i < linesInBuffer; i++ {
 idx := (startIndex + i) % maxJobLogLines
 if validLines[idx] {
 result = append(result, lines[idx])
 }
 }

 return strings.Join(result, "\n"), totalLines, httpResp, nil
 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -64,7 +64,7 @@ func generateReadmeDocs(readmePath string) error {
		t, _ := translations.TranslationHelper()

		// Create toolset group with mock clients
		tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t)
		tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t, 5000)

		// Generate toolsets documentation
		toolsetsDoc := generateToolsetsDoc(tsg)
Expand DownExpand Up		@@ -302,7 +302,7 @@ func generateRemoteToolsetsDoc() string {
		t, _ := translations.TranslationHelper()

		// Create toolset group with mock clients
		tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t)
		tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t, 5000)

		// Generate table header
		buf.WriteString("\| Name \| Description \| API URL \| 1-Click Install (VS Code) \| Read-only Link \| 1-Click Read-only Install (VS Code) \|\n")
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -55,6 +55,7 @@ var (
		ExportTranslations: viper.GetBool("export-translations"),
		EnableCommandLogging: viper.GetBool("enable-command-logging"),
		LogFilePath: viper.GetString("log-file"),
		ContentWindowSize: viper.GetInt("content-window-size"),
		}
		return ghmcp.RunStdioServer(stdioServerConfig)
		},
Expand All		@@ -75,6 +76,7 @@ func init() {
		rootCmd.PersistentFlags().Bool("enable-command-logging", false, "When enabled, the server will log all command requests and responses to the log file")
		rootCmd.PersistentFlags().Bool("export-translations", false, "Save translations to a JSON file")
		rootCmd.PersistentFlags().String("gh-host", "", "Specify the GitHub hostname (for GitHub Enterprise etc.)")
		rootCmd.PersistentFlags().Int("content-window-size", 5000, "Specify the content window size")

		// Bind flag to viper
		_ = viper.BindPFlag("toolsets", rootCmd.PersistentFlags().Lookup("toolsets"))
Expand All		@@ -84,6 +86,7 @@ func init() {
		_ = viper.BindPFlag("enable-command-logging", rootCmd.PersistentFlags().Lookup("enable-command-logging"))
		_ = viper.BindPFlag("export-translations", rootCmd.PersistentFlags().Lookup("export-translations"))
		_ = viper.BindPFlag("host", rootCmd.PersistentFlags().Lookup("gh-host"))
		_ = viper.BindPFlag("content-window-size", rootCmd.PersistentFlags().Lookup("content-window-size"))

		// Add subcommands
		rootCmd.AddCommand(stdioCmd)
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -47,6 +47,9 @@ type MCPServerConfig struct {

		// Translator provides translated text for the server tooling
		Translator translations.TranslationHelperFunc

		// Content window size
		ContentWindowSize int
		}

		const stdioServerLogPrefix = "stdioserver"
Expand DownExpand Up		@@ -132,7 +135,7 @@ func NewMCPServer(cfg MCPServerConfig) (*server.MCPServer, error) {
		}

		// Create default toolsets
		tsg := github.DefaultToolsetGroup(cfg.ReadOnly, getClient, getGQLClient, getRawClient, cfg.Translator)
		tsg := github.DefaultToolsetGroup(cfg.ReadOnly, getClient, getGQLClient, getRawClient, cfg.Translator, cfg.ContentWindowSize)
		err = tsg.EnableToolsets(enabledToolsets)

		if err != nil {
Expand DownExpand Up		@@ -180,6 +183,9 @@ type StdioServerConfig struct {

		// Path to the log file if not stderr
		LogFilePath string

		// Content window size
		ContentWindowSize int
		}

		// RunStdioServer is not concurrent safe.
Expand All		@@ -191,13 +197,14 @@ func RunStdioServer(cfg StdioServerConfig) error {
		t, dumpTranslations := translations.TranslationHelper()

		ghServer, err := NewMCPServer(MCPServerConfig{
		Version: cfg.Version,
		Host: cfg.Host,
		Token: cfg.Token,
		EnabledToolsets: cfg.EnabledToolsets,
		DynamicToolsets: cfg.DynamicToolsets,
		ReadOnly: cfg.ReadOnly,
		Translator: t,
		Version: cfg.Version,
		Host: cfg.Host,
		Token: cfg.Token,
		EnabledToolsets: cfg.EnabledToolsets,
		DynamicToolsets: cfg.DynamicToolsets,
		ReadOnly: cfg.ReadOnly,
		Translator: t,
		ContentWindowSize: cfg.ContentWindowSize,
		})
		if err != nil {
		return fmt.Errorf("failed to create MCP server: %w", err)
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,69 @@
		package buffer

		import (
		"bufio"
		"fmt"
		"net/http"
		"strings"
		)

mattdholloway marked this conversation as resolved. Show resolvedHide resolved
		// ProcessResponseAsRingBufferToEnd reads the body of an HTTP response line by line,
		// storing only the last maxJobLogLines lines using a ring buffer (sliding window).
		// This efficiently retains the most recent lines, overwriting older ones as needed.
		//
		// Parameters:
		//
		//httpResp: The HTTP response whose body will be read.
		//maxJobLogLines: The maximum number of log lines to retain.
		//
		// Returns:
		//
		//string: The concatenated log lines (up to maxJobLogLines), separated by newlines.
		//int: The total number of lines read from the response.
		//*http.Response: The original HTTP response.
		//error: Any error encountered during reading.
		//
		// The function uses a ring buffer to efficiently store only the last maxJobLogLines lines.
		// If the response contains more lines than maxJobLogLines, only the most recent lines are kept.
		func ProcessResponseAsRingBufferToEnd(httpResp http.Response, maxJobLogLines int) (string, int, http.Response, error) {
		lines := make([]string, maxJobLogLines)
		validLines := make([]bool, maxJobLogLines)
		totalLines := 0
		writeIndex := 0

		scanner := bufio.NewScanner(httpResp.Body)
		scanner.Buffer(make([]byte, 0, 641024), 10241024)
mattdholloway marked this conversation as resolved. Show resolvedHide resolved mattdholloway marked this conversation as resolved. Show resolvedHide resolved

		for scanner.Scan() {
		line := scanner.Text()
		totalLines++

		lines[writeIndex] = line
		validLines[writeIndex] = true
		writeIndex = (writeIndex + 1) % maxJobLogLines
		}

		if err := scanner.Err(); err != nil {
		return "", 0, httpResp, fmt.Errorf("failed to read log content: %w", err)
		}

		var result []string
		linesInBuffer := totalLines
		if linesInBuffer > maxJobLogLines {
		linesInBuffer = maxJobLogLines
		}

		startIndex := 0
		if totalLines > maxJobLogLines {
		startIndex = writeIndex
		}

		for i := 0; i < linesInBuffer; i++ {
		idx := (startIndex + i) % maxJobLogLines
		if validLines[idx] {
		result = append(result, lines[idx])
		}
		}

		return strings.Join(result, "\n"), totalLines, httpResp, nil
		}