ga-plugins-cli 0.1.0 → 0.1.1

package/plugins/go-reviewer/mcp-servers/go-reviewer-mcp/main.go

@@ -0,0 +1,678 @@
+// Package main implements a thin MCP (Model Context Protocol) shim server that runs
+// external Go analysis binaries (golangci-lint, gopls, semgrep) and returns structured
+// findings to Claude. It speaks JSON-RPC 2.0 over stdio.
+//
+// Graceful degradation: if a binary is missing on PATH, the tool returns
+// {"skipped": true, "reason": "..."} instead of an error. The server never panics.
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// ─── MCP protocol types ───────────────────────────────────────────────────────
+
+// Request is an incoming JSON-RPC 2.0 request.
+type Request struct {
+	JSONRPC string          `json:"jsonrpc"`
+	ID      json.RawMessage `json:"id"`
+	Method  string          `json:"method"`
+	Params  json.RawMessage `json:"params,omitempty"`
+}
+
+// Response is a JSON-RPC 2.0 response.
+type Response struct {
+	JSONRPC string          `json:"jsonrpc"`
+	ID      json.RawMessage `json:"id"`
+	Result  interface{}     `json:"result,omitempty"`
+	Error   *RPCError       `json:"error,omitempty"`
+}
+
+// RPCError represents a JSON-RPC error object.
+type RPCError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+// ─── Domain types ─────────────────────────────────────────────────────────────
+
+// Finding represents a single diagnostic finding from any linter.
+type Finding struct {
+	File     string `json:"File"`
+	Line     int    `json:"Line"`
+	Rule     string `json:"Rule"`
+	Severity string `json:"Severity"`
+	Message  string `json:"Message"`
+}
+
+// ToolResult is the standard response envelope for every tool call.
+type ToolResult struct {
+	Skipped  bool      `json:"skipped"`
+	Reason   string    `json:"reason,omitempty"`
+	Findings []Finding `json:"findings,omitempty"`
+}
+
+// ─── MCP initialization types ─────────────────────────────────────────────────
+
+// ServerInfo describes this MCP server.
+type ServerInfo struct {
+	Name    string `json:"name"`
+	Version string `json:"version"`
+}
+
+// CapabilitiesResult is the response to initialize.
+type CapabilitiesResult struct {
+	ProtocolVersion string     `json:"protocolVersion"`
+	ServerInfo      ServerInfo `json:"serverInfo"`
+	Capabilities    struct {
+		Tools struct{} `json:"tools"`
+	} `json:"capabilities"`
+}
+
+// ToolDefinition describes a single MCP tool.
+type ToolDefinition struct {
+	Name        string          `json:"name"`
+	Description string          `json:"description"`
+	InputSchema json.RawMessage `json:"inputSchema"`
+}
+
+// ToolsListResult is the response to tools/list.
+type ToolsListResult struct {
+	Tools []ToolDefinition `json:"tools"`
+}
+
+// ─── Input parameter types ────────────────────────────────────────────────────
+
+// LintParams are parameters for run_golangci_lint and run_gopls_check.
+type LintParams struct {
+	Path string `json:"path"`
+}
+
+// SemgrepParams are parameters for run_semgrep.
+type SemgrepParams struct {
+	Path  string `json:"path"`
+	Rules string `json:"rules"`
+}
+
+// ToolCallParams wraps an MCP tools/call request.
+type ToolCallParams struct {
+	Name      string          `json:"name"`
+	Arguments json.RawMessage `json:"arguments"`
+}
+
+// ─── Linter output parsing types ─────────────────────────────────────────────
+
+// golangciOutput is the top-level JSON output from golangci-lint.
+type golangciOutput struct {
+	Issues []golangciIssue `json:"Issues"`
+}
+
+type golangciIssue struct {
+	FromLinter  string          `json:"FromLinter"`
+	Text        string          `json:"Text"`
+	Severity    string          `json:"Severity"`
+	SourceLines []string        `json:"SourceLines"`
+	Pos         golangciPos     `json:"Pos"`
+}
+
+type golangciPos struct {
+	Filename string `json:"Filename"`
+	Offset   int    `json:"Offset"`
+	Line     int    `json:"Line"`
+	Column   int    `json:"Column"`
+}
+
+// semgrepOutput is the top-level JSON output from semgrep.
+type semgrepOutput struct {
+	Results []semgrepResult `json:"results"`
+}
+
+type semgrepResult struct {
+	CheckID string        `json:"check_id"`
+	Path    string        `json:"path"`
+	Start   semgrepPos    `json:"start"`
+	Extra   semgrepExtra  `json:"extra"`
+}
+
+type semgrepPos struct {
+	Line int `json:"line"`
+}
+
+type semgrepExtra struct {
+	Message  string `json:"message"`
+	Severity string `json:"severity"`
+}
+
+// ─── Server ───────────────────────────────────────────────────────────────────
+
+// server holds the JSON-RPC server state.
+type server struct {
+	reader *bufio.Reader
+	writer io.Writer
+	logger *log.Logger
+}
+
+func newServer() *server {
+	return &server{
+		reader: bufio.NewReader(os.Stdin),
+		writer: os.Stdout,
+		logger: log.New(os.Stderr, "[go-reviewer-mcp] ", log.LstdFlags),
+	}
+}
+
+func (s *server) run() {
+	s.logger.Println("go-reviewer-mcp started, listening on stdio")
+
+	for {
+		line, err := s.reader.ReadBytes('\n')
+		if err != nil {
+			if err == io.EOF {
+				s.logger.Println("stdin closed, shutting down")
+				return
+			}
+			s.logger.Printf("read error: %v", err)
+			return
+		}
+
+		line = bytes.TrimSpace(line)
+		if len(line) == 0 {
+			continue
+		}
+
+		var req Request
+		if err := json.Unmarshal(line, &req); err != nil {
+			s.logger.Printf("JSON parse error: %v (raw: %s)", err, line)
+			s.writeError(json.RawMessage("null"), -32700, "Parse error")
+			continue
+		}
+
+		s.handleRequest(&req)
+	}
+}
+
+func (s *server) handleRequest(req *Request) {
+	switch req.Method {
+	case "initialize":
+		s.handleInitialize(req)
+	case "initialized":
+		// notification — no response required
+	case "tools/list":
+		s.handleToolsList(req)
+	case "tools/call":
+		s.handleToolsCall(req)
+	default:
+		s.writeError(req.ID, -32601, fmt.Sprintf("Method not found: %s", req.Method))
+	}
+}
+
+func (s *server) handleInitialize(req *Request) {
+	result := CapabilitiesResult{
+		ProtocolVersion: "2024-11-05",
+		ServerInfo: ServerInfo{
+			Name:    "go-reviewer-mcp",
+			Version: "0.1.0",
+		},
+	}
+	s.writeResult(req.ID, result)
+}
+
+func (s *server) handleToolsList(req *Request) {
+	tools := []ToolDefinition{
+		{
+			Name:        "run_golangci_lint",
+			Description: "Run golangci-lint on a Go package or file path. Returns structured findings. If golangci-lint is not on PATH, returns {skipped: true}.",
+			InputSchema: json.RawMessage(`{
+				"type": "object",
+				"properties": {
+					"path": {
+						"type": "string",
+						"description": "Absolute path to a Go file or package directory"
+					}
+				},
+				"required": ["path"]
+			}`),
+		},
+		{
+			Name:        "run_gopls_check",
+			Description: "Run gopls check on a Go file or directory for type-aware diagnostics. Returns structured findings. If gopls is not on PATH, returns {skipped: true}.",
+			InputSchema: json.RawMessage(`{
+				"type": "object",
+				"properties": {
+					"path": {
+						"type": "string",
+						"description": "Absolute path to a Go file or package directory"
+					}
+				},
+				"required": ["path"]
+			}`),
+		},
+		{
+			Name:        "run_semgrep",
+			Description: "Run semgrep on a path using specified rules. Returns structured findings. If semgrep is not on PATH, returns {skipped: true}.",
+			InputSchema: json.RawMessage(`{
+				"type": "object",
+				"properties": {
+					"path": {
+						"type": "string",
+						"description": "Absolute path to scan"
+					},
+					"rules": {
+						"type": "string",
+						"description": "Semgrep rule set (e.g. 'p/golang', 'p/security-audit', or path to local rules file). Defaults to 'p/golang'.",
+						"default": "p/golang"
+					}
+				},
+				"required": ["path"]
+			}`),
+		},
+	}
+
+	s.writeResult(req.ID, ToolsListResult{Tools: tools})
+}
+
+func (s *server) handleToolsCall(req *Request) {
+	var params ToolCallParams
+	if err := json.Unmarshal(req.Params, &params); err != nil {
+		s.writeError(req.ID, -32602, fmt.Sprintf("Invalid params: %v", err))
+		return
+	}
+
+	var result interface{}
+	var toolErr error
+
+	switch params.Name {
+	case "run_golangci_lint":
+		result, toolErr = s.runGolangciLint(params.Arguments)
+	case "run_gopls_check":
+		result, toolErr = s.runGoplsCheck(params.Arguments)
+	case "run_semgrep":
+		result, toolErr = s.runSemgrep(params.Arguments)
+	default:
+		s.writeError(req.ID, -32602, fmt.Sprintf("Unknown tool: %s", params.Name))
+		return
+	}
+
+	if toolErr != nil {
+		// Tool execution errors are returned as tool-level errors, not RPC errors
+		s.logger.Printf("tool %s error: %v", params.Name, toolErr)
+		s.writeResult(req.ID, ToolResult{
+			Skipped: true,
+			Reason:  fmt.Sprintf("tool execution error: %v", toolErr),
+		})
+		return
+	}
+
+	// Wrap in MCP tool call content format
+	resultBytes, err := json.Marshal(result)
+	if err != nil {
+		s.writeError(req.ID, -32603, "Internal error marshaling result")
+		return
+	}
+
+	s.writeResult(req.ID, map[string]interface{}{
+		"content": []map[string]interface{}{
+			{
+				"type": "text",
+				"text": string(resultBytes),
+			},
+		},
+	})
+}
+
+// ─── Tool implementations ─────────────────────────────────────────────────────
+
+// runGolangciLint executes golangci-lint and parses its JSON output.
+func (s *server) runGolangciLint(rawArgs json.RawMessage) (ToolResult, error) {
+	var params LintParams
+	if err := json.Unmarshal(rawArgs, &params); err != nil {
+		return ToolResult{}, fmt.Errorf("parse params: %w", err)
+	}
+	if params.Path == "" {
+		return ToolResult{}, fmt.Errorf("path is required")
+	}
+
+	binPath, err := exec.LookPath("golangci-lint")
+	if err != nil {
+		s.logger.Printf("golangci-lint not found on PATH")
+		return ToolResult{Skipped: true, Reason: "binary not found: golangci-lint"}, nil
+	}
+
+	args := []string{"run", "--out-format", "json", "--timeout", "120s"}
+
+	// If path is a file, pass it directly; if directory, append ./...
+	info, err := os.Stat(params.Path)
+	if err != nil {
+		return ToolResult{}, fmt.Errorf("stat path: %w", err)
+	}
+	if info.IsDir() {
+		args = append(args, "./...")
+	} else {
+		args = append(args, params.Path)
+	}
+
+	cmd := exec.Command(binPath, args...)
+	if info.IsDir() {
+		cmd.Dir = params.Path
+	} else {
+		cmd.Dir = filepath.Dir(params.Path)
+	}
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	// golangci-lint exits non-zero when there are findings — that is expected
+	runErr := cmd.Run()
+	if runErr != nil {
+		// Check if it's a real failure vs just "there are lint issues"
+		// golangci-lint exit code 1 = issues found; exit code > 1 = real error
+		if exitErr, ok := runErr.(*exec.ExitError); ok {
+			if exitErr.ExitCode() > 1 {
+				s.logger.Printf("golangci-lint stderr: %s", stderr.String())
+				return ToolResult{}, fmt.Errorf("golangci-lint failed (exit %d): %s", exitErr.ExitCode(), stderr.String())
+			}
+			// exit 1 = findings present, continue parsing
+		}
+	}
+
+	if stdout.Len() == 0 {
+		return ToolResult{Skipped: false, Findings: []Finding{}}, nil
+	}
+
+	var output golangciOutput
+	if err := json.Unmarshal(stdout.Bytes(), &output); err != nil {
+		s.logger.Printf("golangci-lint parse error: %v, raw: %s", err, stdout.String()[:min(500, stdout.Len())])
+		return ToolResult{}, fmt.Errorf("parse golangci-lint output: %w", err)
+	}
+
+	findings := make([]Finding, 0, len(output.Issues))
+	for _, issue := range output.Issues {
+		findings = append(findings, Finding{
+			File:     issue.Pos.Filename,
+			Line:     issue.Pos.Line,
+			Rule:     issue.FromLinter,
+			Severity: mapGolangciSeverity(issue.Severity, issue.FromLinter),
+			Message:  issue.Text,
+		})
+	}
+
+	return ToolResult{Skipped: false, Findings: findings}, nil
+}
+
+// mapGolangciSeverity converts golangci-lint severity strings to our levels.
+func mapGolangciSeverity(severity, linter string) string {
+	switch strings.ToLower(severity) {
+	case "error":
+		return "CRITICAL"
+	case "warning":
+		return "WARNING"
+	}
+	// Certain linters are always critical regardless of reported severity
+	criticalLinters := map[string]bool{
+		"errcheck": true, "gosec": true, "govet": true, "bodyclose": true,
+	}
+	if criticalLinters[linter] {
+		return "CRITICAL"
+	}
+	return "INFO"
+}
+
+// runGoplsCheck executes gopls check and parses its line-based output.
+func (s *server) runGoplsCheck(rawArgs json.RawMessage) (ToolResult, error) {
+	var params LintParams
+	if err := json.Unmarshal(rawArgs, &params); err != nil {
+		return ToolResult{}, fmt.Errorf("parse params: %w", err)
+	}
+	if params.Path == "" {
+		return ToolResult{}, fmt.Errorf("path is required")
+	}
+
+	binPath, err := exec.LookPath("gopls")
+	if err != nil {
+		s.logger.Printf("gopls not found on PATH")
+		return ToolResult{Skipped: true, Reason: "binary not found: gopls"}, nil
+	}
+
+	// gopls check accepts file paths; for directories we enumerate .go files
+	var targets []string
+	info, err := os.Stat(params.Path)
+	if err != nil {
+		return ToolResult{}, fmt.Errorf("stat path: %w", err)
+	}
+	if info.IsDir() {
+		goFiles, err := findGoFiles(params.Path)
+		if err != nil {
+			return ToolResult{}, fmt.Errorf("find go files: %w", err)
+		}
+		targets = goFiles
+	} else {
+		targets = []string{params.Path}
+	}
+
+	if len(targets) == 0 {
+		return ToolResult{Skipped: false, Findings: []Finding{}}, nil
+	}
+
+	args := append([]string{"check"}, targets...)
+	cmd := exec.Command(binPath, args...)
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	// gopls check exits non-zero when diagnostics are found
+	_ = cmd.Run()
+
+	// gopls writes diagnostics to stderr
+	output := stderr.String()
+	if output == "" {
+		output = stdout.String()
+	}
+
+	findings := parseGoplsOutput(output)
+	return ToolResult{Skipped: false, Findings: findings}, nil
+}
+
+// parseGoplsOutput parses gopls check line-by-line output.
+// Format: <file>:<line>:<col>: <message>
+func parseGoplsOutput(output string) []Finding {
+	var findings []Finding
+	for _, line := range strings.Split(output, "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		// Split off the message: last colon-delimited segment after "file:line:col:"
+		// Pattern: /path/to/file.go:12:34: some message here
+		parts := strings.SplitN(line, ":", 5)
+		if len(parts) < 4 {
+			continue
+		}
+		filePath := parts[0]
+		if !strings.HasSuffix(filePath, ".go") {
+			continue
+		}
+		lineNum, err := strconv.Atoi(strings.TrimSpace(parts[1]))
+		if err != nil {
+			continue
+		}
+		// parts[2] is column, parts[3]+ is message
+		message := strings.TrimSpace(strings.Join(parts[3:], ":"))
+		if message == "" {
+			continue
+		}
+
+		findings = append(findings, Finding{
+			File:     filePath,
+			Line:     lineNum,
+			Rule:     "gopls/diagnostic",
+			Severity: "WARNING",
+			Message:  message,
+		})
+	}
+	return findings
+}
+
+// runSemgrep executes semgrep and parses its JSON output.
+func (s *server) runSemgrep(rawArgs json.RawMessage) (ToolResult, error) {
+	var params SemgrepParams
+	if err := json.Unmarshal(rawArgs, &params); err != nil {
+		return ToolResult{}, fmt.Errorf("parse params: %w", err)
+	}
+	if params.Path == "" {
+		return ToolResult{}, fmt.Errorf("path is required")
+	}
+	if params.Rules == "" {
+		params.Rules = "p/golang"
+	}
+
+	binPath, err := exec.LookPath("semgrep")
+	if err != nil {
+		s.logger.Printf("semgrep not found on PATH")
+		return ToolResult{Skipped: true, Reason: "binary not found: semgrep"}, nil
+	}
+
+	args := []string{
+		"--config", params.Rules,
+		"--json",
+		"--no-git-ignore",
+		"--include", "*.go",
+		params.Path,
+	}
+
+	cmd := exec.Command(binPath, args...)
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	// semgrep exits non-zero on findings (exit 1) or errors (exit >1)
+	runErr := cmd.Run()
+	if runErr != nil {
+		if exitErr, ok := runErr.(*exec.ExitError); ok {
+			if exitErr.ExitCode() > 1 {
+				s.logger.Printf("semgrep stderr: %s", stderr.String())
+				return ToolResult{}, fmt.Errorf("semgrep failed (exit %d): %s", exitErr.ExitCode(), stderr.String())
+			}
+		}
+	}
+
+	if stdout.Len() == 0 {
+		return ToolResult{Skipped: false, Findings: []Finding{}}, nil
+	}
+
+	var output semgrepOutput
+	if err := json.Unmarshal(stdout.Bytes(), &output); err != nil {
+		s.logger.Printf("semgrep parse error: %v", err)
+		return ToolResult{}, fmt.Errorf("parse semgrep output: %w", err)
+	}
+
+	findings := make([]Finding, 0, len(output.Results))
+	for _, result := range output.Results {
+		findings = append(findings, Finding{
+			File:     result.Path,
+			Line:     result.Start.Line,
+			Rule:     result.CheckID,
+			Severity: mapSemgrepSeverity(result.Extra.Severity),
+			Message:  result.Extra.Message,
+		})
+	}
+
+	return ToolResult{Skipped: false, Findings: findings}, nil
+}
+
+// mapSemgrepSeverity converts semgrep severity strings to our levels.
+func mapSemgrepSeverity(s string) string {
+	switch strings.ToUpper(s) {
+	case "ERROR":
+		return "CRITICAL"
+	case "WARNING":
+		return "WARNING"
+	default:
+		return "INFO"
+	}
+}
+
+// ─── Utility functions ────────────────────────────────────────────────────────
+
+// findGoFiles returns all .go files (non-test, non-generated) under root.
+func findGoFiles(root string) ([]string, error) {
+	var files []string
+	err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil // skip unreadable paths
+		}
+		if info.IsDir() {
+			base := info.Name()
+			if base == "vendor" || base == "generated" || base == "gen" || strings.HasPrefix(base, ".") {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		name := info.Name()
+		if strings.HasSuffix(name, ".go") &&
+			!strings.HasSuffix(name, "_test.go") &&
+			!strings.HasSuffix(name, ".pb.go") {
+			files = append(files, path)
+		}
+		return nil
+	})
+	return files, err
+}
+
+// min returns the smaller of two ints (stdlib min was added in Go 1.21).
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// ─── JSON-RPC I/O ─────────────────────────────────────────────────────────────
+
+func (s *server) writeResult(id json.RawMessage, result interface{}) {
+	resp := Response{
+		JSONRPC: "2.0",
+		ID:      id,
+		Result:  result,
+	}
+	s.writeResponse(resp)
+}
+
+func (s *server) writeError(id json.RawMessage, code int, message string) {
+	resp := Response{
+		JSONRPC: "2.0",
+		ID:      id,
+		Error:   &RPCError{Code: code, Message: message},
+	}
+	s.writeResponse(resp)
+}
+
+func (s *server) writeResponse(resp Response) {
+	data, err := json.Marshal(resp)
+	if err != nil {
+		s.logger.Printf("marshal response error: %v", err)
+		return
+	}
+	// JSON-RPC over stdio: one message per line
+	if _, err := fmt.Fprintf(s.writer, "%s\n", data); err != nil {
+		s.logger.Printf("write response error: %v", err)
+	}
+}
+
+// ─── Entry point ──────────────────────────────────────────────────────────────
+
+func main() {
+	srv := newServer()
+	srv.run()
+}

package/plugins/go-scaffolder/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "go-scaffolder",
+  "version": "0.1.0",
+  "description": "Interactive wizard that generates thin Go services backed by go-ga-lib. Asks service type, SQL, NoSQL, broker — imports ONLY chosen packages.",
+  "commands": [
+    {
+      "name": "scaffold-service",
+      "description": "Generate a new thin Go microservice wired to go-ga-lib",
+      "path": "commands/scaffold-service.md"
+    }
+  ]
+}