GitManager/internal/mcp/mcp.go

// Package mcp exposes GitManager's capabilities to Claude as an MCP server over
// Streamable HTTP (AGENT.md §8.1). The tool handlers are THIN ADAPTERS over the
// shared service layer (§1.7) — no Git/forge logic lives here. Read tools only
// for now; acting/destructive tools arrive with the service methods that back
// them, carrying the §1.4 confirmation contract.
package mcp

import (
	"context"
	"fmt"
	"net/http"

	mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp"

	"gitmanager/internal/activity"
	"gitmanager/internal/repos"
	"gitmanager/internal/service"
)

// getRepoInput is the argument schema for the get_repo tool.
type getRepoInput struct {
	Path string `json:"path" jsonschema:"absolute filesystem path of the repository, exactly as returned by list_repos"`
}

// listReposOutput wraps the repository list. MCP structured output must be a JSON
// object, so the SDK-inferred outputSchema has to be type "object" — returning a
// bare slice yields type "array", which Claude Desktop rejects at tools/list.
type listReposOutput struct {
	Repos []repos.State `json:"repos" jsonschema:"the discovered repositories"`
}

// setActiveProjectInput is the argument schema for set_active_project.
type setActiveProjectInput struct {
	Path string `json:"path" jsonschema:"absolute path of the repository to make active, exactly as returned by list_repos"`
}

// activeProjectOutput reports the active project path (object, per the rule above).
type activeProjectOutput struct {
	Path string `json:"path" jsonschema:"absolute path of the active project, empty when none is set"`
}

// activityOutput wraps the activity feed (object, per the rule above).
type activityOutput struct {
	Events []activity.Event `json:"events" jsonschema:"recent activity events, oldest first"`
}

// NewServer builds the MCP server and registers the (currently read-only) tools.
func NewServer(svc *service.Service, version string) *mcpsdk.Server {
	s := mcpsdk.NewServer(&mcpsdk.Implementation{
		Name:        "gitmanager",
		Title:       "GitManager",
		Version:     version,
		Description: "Discover and inspect the user's local Git repositories.",
	}, nil)

	// list_repos — no arguments (empty struct = object schema with no properties).
	mcpsdk.AddTool(s, &mcpsdk.Tool{
		Name:        "list_repos",
		Description: "List every Git repository GitManager has discovered, each with its current branch, dirty/clean state, ahead/behind counts, and remote names.",
	}, func(_ context.Context, _ *mcpsdk.CallToolRequest, _ struct{}) (*mcpsdk.CallToolResult, listReposOutput, error) {
		return nil, listReposOutput{Repos: svc.ListRepos()}, nil
	})

	// get_repo — details for one already-discovered repository.
	mcpsdk.AddTool(s, &mcpsdk.Tool{
		Name:        "get_repo",
		Description: "Get details for one repository: its local branches (with upstreams), recent commits, and remote URLs. The path must be one returned by list_repos.",
	}, func(ctx context.Context, _ *mcpsdk.CallToolRequest, in getRepoInput) (*mcpsdk.CallToolResult, repos.Detail, error) {
		detail, ok := svc.RepoDetail(ctx, in.Path)
		if !ok {
			return nil, repos.Detail{}, fmt.Errorf("unknown repository %q — call list_repos for valid paths", in.Path)
		}
		return nil, detail, nil
	})

	// get_active_project — the repo/task currently in focus (§8.2).
	mcpsdk.AddTool(s, &mcpsdk.Tool{
		Name:        "get_active_project",
		Description: "Get the active project — the repository the user is currently focused on. Check this to stay in sync with the user; path is empty when none is set.",
	}, func(_ context.Context, _ *mcpsdk.CallToolRequest, _ struct{}) (*mcpsdk.CallToolResult, activeProjectOutput, error) {
		return nil, activeProjectOutput{Path: svc.ActiveProject()}, nil
	})

	// set_active_project — Claude switches the focus to another repo.
	mcpsdk.AddTool(s, &mcpsdk.Tool{
		Name:        "set_active_project",
		Description: "Set the active project to the given repository path (from list_repos). Use this when switching which repository you are working in so the app and user stay in sync.",
	}, func(_ context.Context, _ *mcpsdk.CallToolRequest, in setActiveProjectInput) (*mcpsdk.CallToolResult, activeProjectOutput, error) {
		if _, _, err := svc.SetActiveProject(activity.ActorClaude, in.Path); err != nil {
			return nil, activeProjectOutput{}, fmt.Errorf("%w — call list_repos for valid paths", err)
		}
		return nil, activeProjectOutput{Path: svc.ActiveProject()}, nil
	})

	// get_activity — recent user + Claude actions, so Claude can catch up.
	mcpsdk.AddTool(s, &mcpsdk.Tool{
		Name:        "get_activity",
		Description: "Get the recent activity feed (user and Claude actions, oldest first): repo selections, active-project changes, and more as features land. Use it to see what the user has done since you last looked.",
	}, func(_ context.Context, _ *mcpsdk.CallToolRequest, _ struct{}) (*mcpsdk.CallToolResult, activityOutput, error) {
		return nil, activityOutput{Events: svc.Activity(50)}, nil
	})

	return s
}

// Handler serves the MCP server over Streamable HTTP. Mount it at /mcp. Like the
// rest of the app it is localhost-bound and unauthenticated (§8.1) — the same
// server instance backs every session.
func Handler(s *mcpsdk.Server) http.Handler {
	return mcpsdk.NewStreamableHTTPHandler(func(*http.Request) *mcpsdk.Server {
		return s
	}, nil)
}