main.go

package main

import (
	"context"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"log"
	"log/slog"
	"os"
	"strings"

	"github.com/mark3labs/mcp-go/mcp"
	"github.com/mark3labs/mcp-go/server"
	"github.com/sgaunet/gitlab-mcp/internal/app"
	"github.com/sgaunet/gitlab-mcp/internal/logger"
)

// Version information injected at build time.
var version = "dev"

const (
	defaultLimit = 100

	defaultStateOpened = "opened"
	defaultStateClosed = "closed"
)

// ToolCategoryFlags controls which tool categories are enabled.
type ToolCategoryFlags struct {
	Issues          bool // Issue management tools
	Labels          bool // Label management tools
	ProjectMetadata bool // Project metadata tools
	Epics           bool // Epic management tools (Premium/Ultimate tier)
	Pipelines       bool // CI/CD pipeline tools
	MergeRequests   bool // Merge request management tools
}

// Error variables for static errors.
var (
	ErrInvalidStateValue      = errors.New("state must be 'opened' or 'closed'")
	ErrGroupPathRequired      = errors.New("group_path is required and must be a non-empty string")
	ErrEpicIIDRequired        = errors.New("epic_iid is required and must be a number")
	ErrEpicIIDMustBePositive  = errors.New("epic_iid must be greater than 0")
	ErrProjectPathRequired    = errors.New("project_path is required and must be a non-empty string")
	ErrIssueIIDRequired       = errors.New("issue_iid is required and must be a number")
	ErrIssueIIDMustBePositive = errors.New("issue_iid must be greater than 0")
	ErrInvalidJobStatus       = errors.New("invalid job status")
	ErrJobIDRequired          = errors.New("job_id must be a number")
	ErrJobIDMustBePositive    = errors.New("job_id must be positive")
)

// setupListIssuesTool creates and registers the list_issues tool.
//
//nolint:cyclop,funlen // Parameter extraction requires multiple branches
func setupListIssuesTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	listIssuesTool := mcp.NewTool("list_issues",
		mcp.WithDescription("List issues for a GitLab project by project path. "+
			"By default, includes issues from both the project and its parent group(s) for comprehensive visibility. "+
			"Use include_group_issues=false to retrieve only project-level issues."),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name' or "+
				"'company/department/team/project'). Run 'git remote -v' to find the full path from the repository URL"),
		),
		mcp.WithString("state",
			mcp.Description("Filter by issue state: opened, closed, or all (default: opened)"),
		),
		mcp.WithString("labels",
			mcp.Description("Comma-separated list of labels to filter by"),
		),
		mcp.WithNumber("limit",
			mcp.Description("Maximum number of issues to return (default: 100, max: 100)"),
		),
		mcp.WithBoolean("include_group_issues",
			mcp.Description("Include issues from parent group(s). Defaults to true for comprehensive results. "+
				"Set to false to retrieve only project-level issues."),
		),
	)

	s.AddTool(listIssuesTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received list_issues tool request", "args", args)

		// Extract project_path
		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		// Extract optional parameters
		opts := &app.ListIssuesOptions{
			State:              defaultStateOpened, // default
			Limit:              defaultLimit,       // default
			IncludeGroupIssues: true,               // default to true for comprehensive results
		}

		if state, ok := args["state"].(string); ok && state != "" {
			opts.State = state
		}

		if labels, ok := args["labels"].(string); ok && labels != "" {
			opts.Labels = labels
		}

		if limitFloat, ok := args["limit"].(float64); ok {
			opts.Limit = int64(limitFloat)
		}

		// Extract include_group_issues (defaults to true)
		if includeGroupIssues, ok := args["include_group_issues"].(bool); ok {
			opts.IncludeGroupIssues = includeGroupIssues
		}

		debugLogger.Debug("Processing list_issues request", "project_path", projectPath, "opts", opts)

		// Call the app method
		issues, err := appInstance.ListProjectIssues(projectPath, opts)
		if err != nil {
			debugLogger.Error("Failed to list project issues", "error", err, "project_path", projectPath)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to list project issues: %v", err)), nil
		}

		// Convert issues to JSON
		jsonData, err := json.Marshal(issues)
		if err != nil {
			debugLogger.Error("Failed to marshal issues to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format issues response"), nil
		}

		debugLogger.Info("Successfully retrieved project issues", "count", len(issues), "project_path", projectPath)
		return mcp.NewToolResultText(string(jsonData)), nil
	})
}

// setupCreateIssueTool creates and registers the create_issues tool.
func setupCreateIssueTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	createIssueTool := mcp.NewTool("create_issues",
		mcp.WithDescription("Create a new issue for a GitLab project by project path"),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name' or "+
				"'company/department/team/project'). Run 'git remote -v' to find the full path from the repository URL"),
		),
		mcp.WithString("title",
			mcp.Required(),
			mcp.Description("Issue title"),
		),
		mcp.WithString("description",
			mcp.Description("Issue description"),
		),
		mcp.WithArray("labels",
			mcp.Description("Array of labels to assign to the issue. Labels must exist in the project. "+
				"Use list_labels tool to see available labels. Set GITLAB_VALIDATE_LABELS=false to disable validation."),
		),
		mcp.WithArray("assignees",
			mcp.Description("Array of user IDs to assign to the issue"),
		),
	)

	s.AddTool(createIssueTool, handleCreateIssueRequest(appInstance, debugLogger))
}

// handleCreateIssueRequest handles the create_issues tool request.
func handleCreateIssueRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received create_issues tool request", "args", args)

		// Extract project_path
		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		// Extract title (required)
		title, ok := args["title"].(string)
		if !ok || title == "" {
			debugLogger.Error("title is missing or not a string", "value", args["title"])
			return mcp.NewToolResultError("title must be a non-empty string"), nil
		}

		// Extract options
		opts := extractCreateIssueOptions(args, title)

		debugLogger.Debug("Processing create_issues request", "project_path", projectPath, "title", title)

		// Call the app method
		issue, err := appInstance.CreateProjectIssue(projectPath, opts)
		if err != nil {
			debugLogger.Error("Failed to create issue", "error", err, "project_path", projectPath, "title", title)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to create issue: %v", err)), nil
		}

		// Convert issue to JSON
		jsonData, err := json.Marshal(issue)
		if err != nil {
			debugLogger.Error("Failed to marshal issue to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format issue response"), nil
		}

		debugLogger.Info("Successfully created issue",
			"id", issue.ID,
			"iid", issue.IID,
			"project_path", projectPath,
			"title", issue.Title)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// extractCreateIssueOptions extracts create issue options from arguments.
func extractCreateIssueOptions(args map[string]any, title string) *app.CreateIssueOptions {
	opts := &app.CreateIssueOptions{
		Title: title,
	}

	// Extract optional description
	if description, ok := args["description"].(string); ok {
		opts.Description = description
	}

	// Extract optional labels
	if labelsInterface, ok := args["labels"].([]any); ok {
		labels := make([]string, 0, len(labelsInterface))
		for _, label := range labelsInterface {
			if labelStr, ok := label.(string); ok {
				labels = append(labels, labelStr)
			}
		}
		opts.Labels = labels
	}

	// Extract optional assignees
	if assigneesInterface, ok := args["assignees"].([]any); ok {
		assignees := make([]int64, 0, len(assigneesInterface))
		for _, assignee := range assigneesInterface {
			if assigneeFloat, ok := assignee.(float64); ok {
				assignees = append(assignees, int64(assigneeFloat))
			}
		}
		opts.Assignees = assignees
	}

	return opts
}

// setupUpdateIssueTool creates and registers the update_issues tool.
func setupUpdateIssueTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	updateIssueTool := mcp.NewTool("update_issues",
		mcp.WithDescription("Update an existing issue for a GitLab project by project path"),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name' or "+
				"'company/department/team/project'). Run 'git remote -v' to find the full path from the repository URL"),
		),
		mcp.WithNumber("issue_iid",
			mcp.Required(),
			mcp.Description("Issue internal ID (IID) to update"),
		),
		mcp.WithString("title",
			mcp.Description("Updated issue title"),
		),
		mcp.WithString("description",
			mcp.Description("Updated issue description"),
		),
		mcp.WithString("state",
			mcp.Description("Issue state: 'opened' or 'closed'"),
		),
		mcp.WithArray("labels",
			mcp.Description("Array of labels to assign to the issue. Labels must exist in the project. "+
				"Use list_labels tool to see available labels. Set GITLAB_VALIDATE_LABELS=false to disable validation."),
		),
		mcp.WithArray("assignees",
			mcp.Description("Array of user IDs to assign to the issue"),
		),
	)

	s.AddTool(updateIssueTool, handleUpdateIssueRequest(appInstance, debugLogger))
}

// handleUpdateIssueRequest handles the update_issues tool request.
func handleUpdateIssueRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received update_issues tool request", "args", args)

		// Extract project_path
		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		// Extract issue_iid (required)
		issueIIDFloat, ok := args["issue_iid"].(float64)
		if !ok {
			debugLogger.Error("issue_iid is missing or not a number", "value", args["issue_iid"])
			return mcp.NewToolResultError("issue_iid must be a number"), nil
		}
		issueIID := int64(issueIIDFloat)

		// Extract options
		opts, err := extractUpdateIssueOptions(args, debugLogger)
		if err != nil {
			return mcp.NewToolResultError(err.Error()), nil
		}

		debugLogger.Debug("Processing update_issues request", "project_path", projectPath, "issue_iid", issueIID)

		// Call the app method
		issue, err := appInstance.UpdateProjectIssue(projectPath, issueIID, opts)
		if err != nil {
			debugLogger.Error("Failed to update issue", "error", err, "project_path", projectPath, "issue_iid", issueIID)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to update issue: %v", err)), nil
		}

		// Convert issue to JSON
		jsonData, err := json.Marshal(issue)
		if err != nil {
			debugLogger.Error("Failed to marshal issue to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format issue response"), nil
		}

		debugLogger.Info("Successfully updated issue", "id", issue.ID, "iid", issue.IID, "project_path", projectPath)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// extractUpdateIssueOptions extracts update issue options from arguments.
func extractUpdateIssueOptions(args map[string]any, debugLogger *slog.Logger) (*app.UpdateIssueOptions, error) {
	opts := &app.UpdateIssueOptions{}

	// Extract basic string fields
	extractUpdateStringFields(args, opts)

	// Extract and validate state
	if err := extractUpdateState(args, opts, debugLogger); err != nil {
		return nil, err
	}

	// Extract array fields
	extractUpdateArrayFields(args, opts)

	return opts, nil
}

// extractUpdateStringFields extracts string fields for update options.
func extractUpdateStringFields(args map[string]any, opts *app.UpdateIssueOptions) {
	if title, ok := args["title"].(string); ok && title != "" {
		opts.Title = title
	}

	if description, ok := args["description"].(string); ok {
		opts.Description = description
	}
}

// extractUpdateState extracts and validates the state field.
func extractUpdateState(args map[string]any, opts *app.UpdateIssueOptions, debugLogger *slog.Logger) error {
	if state, ok := args["state"].(string); ok && state != "" {
		if state != defaultStateOpened && state != defaultStateClosed {
			debugLogger.Error("invalid state value", "state", state)
			return ErrInvalidStateValue
		}
		opts.State = state
	}
	return nil
}

// extractUpdateArrayFields extracts array fields for update options.
func extractUpdateArrayFields(args map[string]any, opts *app.UpdateIssueOptions) {
	// Extract optional labels
	if labelsInterface, ok := args["labels"].([]any); ok {
		labels := make([]string, 0, len(labelsInterface))
		for _, label := range labelsInterface {
			if labelStr, ok := label.(string); ok {
				labels = append(labels, labelStr)
			}
		}
		opts.Labels = labels
	}

	// Extract optional assignees
	if assigneesInterface, ok := args["assignees"].([]any); ok {
		assignees := make([]int64, 0, len(assigneesInterface))
		for _, assignee := range assigneesInterface {
			if assigneeFloat, ok := assignee.(float64); ok {
				assignees = append(assignees, int64(assigneeFloat))
			}
		}
		opts.Assignees = assignees
	}
}

// setupListLabelsTool creates and registers the list_labels tool.
func setupListLabelsTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	listLabelsTool := mcp.NewTool("list_labels",
		mcp.WithDescription("List labels for a GitLab project by project path"),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name' or "+
				"'company/department/team/project'). Run 'git remote -v' to find the full path from the repository URL"),
		),
		mcp.WithBoolean("with_counts",
			mcp.Description("Include issue and merge request counts (default: false)"),
		),
		mcp.WithBoolean("include_ancestor_groups",
			mcp.Description("Include labels from ancestor groups (default: false)"),
		),
		mcp.WithString("search",
			mcp.Description("Filter labels by search keyword"),
		),
		mcp.WithNumber("limit",
			mcp.Description("Maximum number of labels to return (default: 100, max: 100)"),
		),
	)

	s.AddTool(listLabelsTool, handleListLabelsRequest(appInstance, debugLogger))
}

// handleListLabelsRequest handles the list_labels tool request.
func handleListLabelsRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received list_labels tool request", "args", args)

		// Extract project_path
		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		// Extract optional parameters
		opts := extractListLabelsOptions(args)

		debugLogger.Debug("Processing list_labels request", "project_path", projectPath, "opts", opts)

		// Call the app method
		labels, err := appInstance.ListProjectLabels(projectPath, opts)
		if err != nil {
			debugLogger.Error("Failed to list project labels", "error", err, "project_path", projectPath)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to list project labels: %v", err)), nil
		}

		// Convert labels to JSON
		jsonData, err := json.Marshal(labels)
		if err != nil {
			debugLogger.Error("Failed to marshal labels to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format labels response"), nil
		}

		debugLogger.Info("Successfully retrieved project labels", "count", len(labels), "project_path", projectPath)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// extractListLabelsOptions extracts list labels options from arguments.
func extractListLabelsOptions(args map[string]any) *app.ListLabelsOptions {
	opts := &app.ListLabelsOptions{
		Limit: defaultLimit, // default
	}

	if withCounts, ok := args["with_counts"].(bool); ok {
		opts.WithCounts = &withCounts
	}

	if includeAncestorGroups, ok := args["include_ancestor_groups"].(bool); ok {
		opts.IncludeAncestorGroups = &includeAncestorGroups
	}

	if search, ok := args["search"].(string); ok && search != "" {
		opts.Search = search
	}

	if limitFloat, ok := args["limit"].(float64); ok {
		opts.Limit = int64(limitFloat)
	}

	return opts
}

// setupListEpicsTool creates and registers the list_epics tool.
func setupListEpicsTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	listEpicsTool := mcp.NewTool("list_epics",
		mcp.WithDescription("List epics for a GitLab group by group path. "+
			"Note: Epics require GitLab Premium or Ultimate tier. "+
			"Free/Starter tier instances will return a helpful error message."),
		mcp.WithString("group_path",
			mcp.Required(),
			mcp.Description("GitLab group path (e.g., 'myorg' or 'parent/subgroup'). "+
				"Groups contain multiple projects and use epics to organize work across projects."),
		),
		mcp.WithString("state",
			mcp.Description("Filter by epic state: opened, closed, or all (default: opened)"),
		),
		mcp.WithNumber("limit",
			mcp.Description("Maximum number of epics to return (default: 100, max: 100)"),
		),
	)

	s.AddTool(listEpicsTool, handleListEpicsRequest(appInstance, debugLogger))
}

// handleListEpicsRequest handles the list_epics tool request.
func handleListEpicsRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received list_epics tool request", "args", args)

		// Extract group_path
		groupPath, ok := args["group_path"].(string)
		if !ok || groupPath == "" {
			debugLogger.Error("group_path is not a valid string", "value", args["group_path"])
			return mcp.NewToolResultError("group_path must be a non-empty string"), nil
		}

		// Extract optional parameters
		opts := &app.ListEpicsOptions{
			State: defaultStateOpened,
			Limit: defaultLimit,
		}

		if state, ok := args["state"].(string); ok && state != "" {
			opts.State = state
		}
		if limitFloat, ok := args["limit"].(float64); ok {
			opts.Limit = int64(limitFloat)
		}

		debugLogger.Debug("Processing list_epics request", "group_path", groupPath, "opts", opts)

		// Call the app method
		epics, err := appInstance.ListGroupEpics(groupPath, opts)
		if err != nil {
			debugLogger.Error("Failed to list group epics", "error", err, "group_path", groupPath)

			if errors.Is(err, app.ErrEpicsTierRequired) {
				return mcp.NewToolResultError(fmt.Sprintf(
					"Failed to list epics: %v\n\n"+
						"Epics are a GitLab Premium/Ultimate feature. If you're on a Free tier, "+
						"consider using issues for work tracking instead. "+
						"See: https://docs.gitlab.com/ee/user/group/epics/",
					err,
				)), nil
			}

			return mcp.NewToolResultError(fmt.Sprintf("Failed to list group epics: %v", err)), nil
		}

		// Convert to JSON
		jsonData, err := json.Marshal(epics)
		if err != nil {
			debugLogger.Error("Failed to marshal epics to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format epics response"), nil
		}

		debugLogger.Info("Successfully retrieved group epics", "count", len(epics), "group_path", groupPath)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// setupCreateEpicTool creates and registers the create_epic tool.
func setupCreateEpicTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	createEpicTool := mcp.NewTool("create_epic",
		mcp.WithDescription("Create a new epic in a GitLab group. "+
			"Note: Epics require GitLab Premium or Ultimate tier."),
		mcp.WithString("group_path",
			mcp.Required(),
			mcp.Description("GitLab group path (e.g., 'myorg' or 'parent/subgroup')"),
		),
		mcp.WithString("title",
			mcp.Required(),
			mcp.Description("Epic title"),
		),
		mcp.WithString("description",
			mcp.Description("Epic description (optional)"),
		),
		mcp.WithArray("labels",
			mcp.Description("Array of label names (optional). Labels must exist in the group. "+
				"Set GITLAB_VALIDATE_LABELS=false to disable validation."),
		),
		mcp.WithString("start_date",
			mcp.Description("Start date in YYYY-MM-DD format (optional)"),
		),
		mcp.WithString("due_date",
			mcp.Description("Due date in YYYY-MM-DD format (optional)"),
		),
		mcp.WithBoolean("confidential",
			mcp.Description("Whether epic is confidential (default: false)"),
		),
	)

	s.AddTool(createEpicTool, handleCreateEpicRequest(appInstance, debugLogger))
}

// setupUpdateEpicTool creates and registers the update_epic tool.
func setupUpdateEpicTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	updateEpicTool := mcp.NewTool("update_epic",
		mcp.WithDescription("Update an existing epic in a GitLab group. "+
			"Note: Epics require GitLab Premium or Ultimate tier."),
		mcp.WithString("group_path",
			mcp.Required(),
			mcp.Description("GitLab group path (e.g., 'myorg' or 'parent/subgroup')"),
		),
		mcp.WithNumber("epic_iid",
			mcp.Required(),
			mcp.Description("Epic internal ID (IID) to update"),
		),
		mcp.WithString("title",
			mcp.Description("Updated epic title (optional)"),
		),
		mcp.WithString("description",
			mcp.Description("Updated epic description (optional)"),
		),
		mcp.WithArray("labels",
			mcp.Description("Array of label names to set (optional). "+
				"Labels must exist in the group. Set GITLAB_VALIDATE_LABELS=false to disable validation."),
		),
		mcp.WithString("start_date",
			mcp.Description("Start date in YYYY-MM-DD format (optional)"),
		),
		mcp.WithString("due_date",
			mcp.Description("Due date in YYYY-MM-DD format (optional)"),
		),
		mcp.WithString("state",
			mcp.Description("Epic state: 'opened' or 'closed' (optional)"),
		),
		mcp.WithBoolean("confidential",
			mcp.Description("Whether epic is confidential (optional)"),
		),
	)

	s.AddTool(updateEpicTool, handleUpdateEpicRequest(appInstance, debugLogger))
}

// handleCreateEpicRequest handles the create_epic tool request.
func handleCreateEpicRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received create_epic tool request", "args", args)

		// Extract and validate parameters
		groupPath, opts, validationErr := extractCreateEpicParams(args, debugLogger)
		if validationErr != nil {
			return validationErr, nil
		}

		debugLogger.Debug("Processing create_epic request", "group_path", groupPath, "opts", opts)

		// Call the app method
		epic, appErr := appInstance.CreateGroupEpic(groupPath, opts)
		if appErr != nil {
			return handleCreateEpicError(appErr, groupPath, debugLogger), nil
		}

		// Convert to JSON
		jsonData, err := json.Marshal(epic)
		if err != nil {
			debugLogger.Error("Failed to marshal epic to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format epic response"), nil
		}

		debugLogger.Info("Successfully created epic", "id", epic.ID, "iid", epic.IID, "group_path", groupPath)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// handleUpdateEpicRequest handles the update_epic tool request.
func handleUpdateEpicRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received update_epic tool request", "args", args)

		// Extract and validate parameters
		groupPath, epicIID, opts, validationErr := extractUpdateEpicParams(args, debugLogger)
		if validationErr != nil {
			return validationErr, nil
		}

		debugLogger.Debug("Processing update_epic request",
			"group_path", groupPath, "epic_iid", epicIID, "opts", opts)

		// Call the app method
		epic, appErr := appInstance.UpdateGroupEpic(groupPath, epicIID, opts)
		if appErr != nil {
			debugLogger.Error("Failed to update epic", "error", appErr,
				"group_path", groupPath, "epic_iid", epicIID)

			if errors.Is(appErr, app.ErrEpicsTierRequired) {
				return mcp.NewToolResultError(fmt.Sprintf(
					"Failed to update epic: %v\n\n"+
						"Epics are a GitLab Premium/Ultimate feature. "+
						"See: https://docs.gitlab.com/ee/user/group/epics/",
					appErr,
				)), nil
			}

			return mcp.NewToolResultError(fmt.Sprintf("Failed to update epic: %v", appErr)), nil
		}

		// Convert to JSON
		jsonData, err := json.Marshal(epic)
		if err != nil {
			debugLogger.Error("Failed to marshal epic to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format epic response"), nil
		}

		debugLogger.Info("Successfully updated epic",
			"id", epic.ID, "iid", epic.IID, "group_path", groupPath)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// setupAddIssueToEpicTool creates and registers the add_issue_to_epic tool.
func setupAddIssueToEpicTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	addIssueToEpicTool := mcp.NewTool("add_issue_to_epic",
		mcp.WithDescription("Attach an issue to an epic (Premium/Ultimate tier). "+
			"Note: The Epics API is deprecated and will be removed in GitLab API v5. "+
			"Consider using Work Items API for future implementations."),
		mcp.WithString("group_path",
			mcp.Required(),
			mcp.Description("GitLab group path containing the epic (e.g., 'myorg' or 'parent/subgroup'). "+
				"Run 'git remote -v' to find the full path from the repository URL"),
		),
		mcp.WithNumber("epic_iid",
			mcp.Required(),
			mcp.Description("Epic internal ID (IID) to attach the issue to"),
		),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path containing the issue (e.g., 'namespace/project-name')"),
		),
		mcp.WithNumber("issue_iid",
			mcp.Required(),
			mcp.Description("Issue internal ID (IID) to attach to the epic"),
		),
	)

	s.AddTool(addIssueToEpicTool, handleAddIssueToEpicRequest(appInstance, debugLogger))
}

// handleAddIssueToEpicRequest handles the add_issue_to_epic tool request.
func handleAddIssueToEpicRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received add_issue_to_epic tool request", "args", args)

		// Extract and validate parameters
		opts, err := extractAddIssueToEpicParams(args)
		if err != nil {
			return mcp.NewToolResultError(err.Error()), nil
		}

		debugLogger.Debug("Processing add_issue_to_epic request", "opts", opts)

		// Call the app method
		epicIssue, err := appInstance.AddIssueToEpic(opts)
		if err != nil {
			if errors.Is(err, app.ErrEpicsTierRequired) {
				return mcp.NewToolResultError(
					"This feature requires GitLab Premium or Ultimate. " +
						"See https://docs.gitlab.com/ee/user/group/epics/ for more information.",
				), nil
			}
			return mcp.NewToolResultError(err.Error()), nil
		}

		// Convert to JSON
		jsonData, err := json.Marshal(epicIssue)
		if err != nil {
			debugLogger.Error("Failed to marshal epic issue to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format epic issue response"), nil
		}

		debugLogger.Info("Successfully added issue to epic",
			"issue_id", epicIssue.ID, "issue_iid", epicIssue.IID, "epic_iid", epicIssue.EpicIID)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// setupGetLatestPipelineTool creates and registers the get_latest_pipeline tool.
func setupGetLatestPipelineTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	getLatestPipelineTool := mcp.NewTool("get_latest_pipeline",
		mcp.WithDescription("Get the latest pipeline for a GitLab project by project path. "+
			"Returns the most recently updated pipeline, optionally filtered by branch/tag."),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name' or "+
				"'company/department/team/project'). Run 'git remote -v' to find the full path from the repository URL"),
		),
		mcp.WithString("ref",
			mcp.Description("Optional: filter by branch or tag name (e.g., 'main', 'develop', 'v1.0.0')"),
		),
	)

	s.AddTool(getLatestPipelineTool, handleGetLatestPipelineRequest(appInstance, debugLogger))
}

// handleGetLatestPipelineRequest handles the get_latest_pipeline tool request.
func handleGetLatestPipelineRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received get_latest_pipeline tool request", "args", args)

		// Extract project_path
		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		// Extract optional parameters
		opts := &app.GetLatestPipelineOptions{}
		if ref, ok := args["ref"].(string); ok && ref != "" {
			opts.Ref = ref
		}

		debugLogger.Debug("Processing get_latest_pipeline request", "project_path", projectPath, "opts", opts)

		// Call the app method
		pipeline, err := appInstance.GetLatestPipeline(projectPath, opts)
		if err != nil {
			debugLogger.Error("Failed to get latest pipeline", "error", err, "project_path", projectPath)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to get latest pipeline: %v", err)), nil
		}

		// Convert pipeline to JSON
		jsonData, err := json.Marshal(pipeline)
		if err != nil {
			debugLogger.Error("Failed to marshal pipeline to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format pipeline response"), nil
		}

		debugLogger.Info("Successfully retrieved latest pipeline",
			"pipeline_id", pipeline.ID,
			"status", pipeline.Status,
			"project_path", projectPath)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// setupListPipelineJobsTool creates and registers the list_pipeline_jobs tool.
func setupListPipelineJobsTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	listPipelineJobsTool := mcp.NewTool("list_pipeline_jobs",
		mcp.WithDescription("List all jobs for a GitLab pipeline with filtering options. "+
			"If pipeline_id is not provided, retrieves jobs from the latest pipeline. "+
			"Useful for debugging CI/CD failures and analyzing pipeline execution."),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name')"),
		),
		mcp.WithNumber("pipeline_id",
			mcp.Description("Optional: specific pipeline ID. If not provided, uses the latest pipeline."),
		),
		mcp.WithString("ref",
			mcp.Description("Optional: branch or tag name for finding the latest pipeline (e.g., 'main', 'develop'). "+
				"Only used when pipeline_id is not provided."),
		),
		mcp.WithArray("scope",
			mcp.Description("Optional: filter jobs by status. Can include: 'created', 'pending', 'running', "+
				"'success', 'failed', 'canceled', 'skipped', 'manual', 'scheduled'. "+
				"Example: ['failed', 'canceled'] to show only failed and canceled jobs."),
		),
		mcp.WithString("stage",
			mcp.Description("Optional: filter jobs by stage name (e.g., 'build', 'test', 'deploy'). Case-sensitive."),
		),
	)

	s.AddTool(listPipelineJobsTool, handleListPipelineJobsRequest(appInstance, debugLogger))
}

// handleListPipelineJobsRequest handles the list_pipeline_jobs tool request.
func handleListPipelineJobsRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received list_pipeline_jobs tool request", "args", args)

		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		opts, err := extractListPipelineJobsOptions(args, debugLogger)
		if err != nil {
			return mcp.NewToolResultError(err.Error()), nil
		}

		debugLogger.Debug("Processing list_pipeline_jobs request", "project_path", projectPath, "opts", opts)

		jobs, err := appInstance.ListPipelineJobs(projectPath, opts)
		if err != nil {
			debugLogger.Error("Failed to list pipeline jobs", "error", err, "project_path", projectPath)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to list pipeline jobs: %v", err)), nil
		}

		jsonData, err := json.Marshal(jobs)
		if err != nil {
			debugLogger.Error("Failed to marshal jobs to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format jobs response"), nil
		}

		debugLogger.Info("Successfully retrieved pipeline jobs", "count", len(jobs), "project_path", projectPath)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// extractListPipelineJobsOptions extracts and validates options from MCP request arguments.
//
//nolint:cyclop // Option extraction and validation requires multiple branches
func extractListPipelineJobsOptions(
	args map[string]any,
	debugLogger *slog.Logger,
) (*app.ListPipelineJobsOptions, error) {
	opts := &app.ListPipelineJobsOptions{}

	if pipelineIDFloat, ok := args["pipeline_id"].(float64); ok {
		pipelineID := int64(pipelineIDFloat)
		opts.PipelineID = &pipelineID
	}

	if ref, ok := args["ref"].(string); ok && ref != "" {
		opts.Ref = ref
	}

	if scopeInterface, ok := args["scope"].([]any); ok && len(scopeInterface) > 0 {
		scopes := make([]string, 0, len(scopeInterface))
		for _, s := range scopeInterface {
			if statusStr, ok := s.(string); ok {
				if !isValidJobStatus(statusStr) {
					debugLogger.Warn("Invalid job status in scope", "status", statusStr)
					return nil, fmt.Errorf(
						"%w: '%s'. Valid: created, pending, running, success, failed, canceled, skipped, manual, scheduled",
						ErrInvalidJobStatus, statusStr,
					)
				}
				scopes = append(scopes, statusStr)
			}
		}
		opts.Scope = scopes
	}

	if stage, ok := args["stage"].(string); ok && stage != "" {
		opts.Stage = stage
	}

	return opts, nil
}

// isValidJobStatus checks if a job status is valid.
func isValidJobStatus(status string) bool {
	validStatuses := map[string]bool{
		"created": true, "waiting_for_resource": true, "preparing": true,
		"pending": true, "running": true, "success": true,
		"failed": true, "canceled": true, "skipped": true,
		"manual": true, "scheduled": true,
	}
	return validStatuses[status]
}

// setupGetJobLogTool creates and registers the get_job_log tool.
func setupGetJobLogTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	getJobLogTool := mcp.NewTool("get_job_log",
		mcp.WithDescription("Retrieve complete log output for a specific GitLab CI/CD job. "+
			"Returns job metadata along with the full trace/log content. "+
			"Useful for debugging job failures and analyzing execution details."),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name')"),
		),
		mcp.WithNumber("job_id",
			mcp.Required(),
			mcp.Description("Job ID to retrieve logs for (required)"),
		),
		mcp.WithNumber("pipeline_id",
			mcp.Description("Optional: specific pipeline ID for context. If not provided, uses the latest pipeline."),
		),
		mcp.WithString("ref",
			mcp.Description("Optional: branch or tag name for finding the latest pipeline (e.g., 'main', 'develop'). "+
				"Only used when pipeline_id is not provided."),
		),
	)

	s.AddTool(getJobLogTool, handleGetJobLogRequest(appInstance, debugLogger))
}

// handleGetJobLogRequest handles the get_job_log tool request.
func handleGetJobLogRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received get_job_log tool request", "args", args)

		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		opts, err := extractGetJobLogOptions(args, debugLogger)
		if err != nil {
			return mcp.NewToolResultError(err.Error()), nil
		}

		debugLogger.Debug("Processing get_job_log request", "project_path", projectPath, "opts", opts)

		jobLog, err := appInstance.GetJobLog(projectPath, opts)
		if err != nil {
			debugLogger.Error("Failed to get job log", "error", err, "project_path", projectPath)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to get job log: %v", err)), nil
		}

		jsonData, err := json.Marshal(jobLog)
		if err != nil {
			debugLogger.Error("Failed to marshal job log to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format job log response"), nil
		}

		debugLogger.Info("Successfully retrieved job log", "job_id", opts.JobID, "log_size", jobLog.LogSize)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// extractGetJobLogOptions extracts and validates options from MCP request arguments.
func extractGetJobLogOptions(args map[string]any, debugLogger *slog.Logger) (*app.GetJobLogOptions, error) {
	opts := &app.GetJobLogOptions{}

	// Extract job_id (required)
	jobIDFloat, ok := args["job_id"].(float64)
	if !ok {
		debugLogger.Error("job_id is missing or not a number", "value", args["job_id"])
		return nil, ErrJobIDRequired
	}
	opts.JobID = int64(jobIDFloat)

	if opts.JobID <= 0 {
		return nil, fmt.Errorf("%w: got %d", ErrJobIDMustBePositive, opts.JobID)
	}

	// Extract pipeline_id (optional)
	if pipelineIDFloat, ok := args["pipeline_id"].(float64); ok {
		pipelineID := int64(pipelineIDFloat)
		opts.PipelineID = &pipelineID
	}

	// Extract ref (optional)
	if ref, ok := args["ref"].(string); ok && ref != "" {
		opts.Ref = ref
	}

	return opts, nil
}

// setupDownloadJobTraceTool creates and registers the download_job_trace tool.
func setupDownloadJobTraceTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	downloadJobTraceTool := mcp.NewTool("download_job_trace",
		mcp.WithDescription("Download the complete log/trace for a specific GitLab CI/CD job to a local file. "+
			"Returns job metadata and file information. "+
			"Useful for archiving logs, offline analysis, or automation workflows."),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name')"),
		),
		mcp.WithNumber("job_id",
			mcp.Required(),
			mcp.Description("Job ID to download trace for (required)"),
		),
		mcp.WithNumber("pipeline_id",
			mcp.Description("Optional: specific pipeline ID for context. If not provided, uses the latest pipeline."),
		),
		mcp.WithString("ref",
			mcp.Description("Optional: branch or tag name for finding the latest pipeline (e.g., 'main', 'develop'). "+
				"Only used when pipeline_id is not provided."),
		),
		mcp.WithString("output_path",
			mcp.Description("Optional: file path to save trace (default: './job_<id>_trace.log'). "+
				"Parent directories will be created if needed."),
		),
	)

	s.AddTool(downloadJobTraceTool, handleDownloadJobTraceRequest(appInstance, debugLogger))
}

// handleDownloadJobTraceRequest handles the download_job_trace tool request.
func handleDownloadJobTraceRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received download_job_trace tool request", "args", args)

		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		opts, err := extractDownloadJobTraceOptions(args, debugLogger)
		if err != nil {
			return mcp.NewToolResultError(err.Error()), nil
		}

		debugLogger.Debug("Processing download_job_trace request", "project_path", projectPath, "opts", opts)

		result, err := appInstance.DownloadJobTrace(projectPath, opts)
		if err != nil {
			debugLogger.Error("Failed to download job trace", "error", err, "project_path", projectPath)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to download job trace: %v", err)), nil
		}

		jsonData, err := json.Marshal(result)
		if err != nil {
			debugLogger.Error("Failed to marshal download result to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format download result response"), nil
		}

		debugLogger.Info("Successfully downloaded job trace",
			"job_id", opts.JobID,
			"file_path", result.FilePath,
			"file_size", result.FileSize)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

// extractDownloadJobTraceOptions extracts and validates options from MCP request arguments.
func extractDownloadJobTraceOptions(
	args map[string]any,
	debugLogger *slog.Logger,
) (*app.DownloadJobTraceOptions, error) {
	opts := &app.DownloadJobTraceOptions{}

	// Extract job_id (required)
	jobIDFloat, ok := args["job_id"].(float64)
	if !ok {
		debugLogger.Error("job_id is missing or not a number", "value", args["job_id"])
		return nil, ErrJobIDRequired
	}
	opts.JobID = int64(jobIDFloat)

	if opts.JobID <= 0 {
		return nil, fmt.Errorf("%w: got %d", ErrJobIDMustBePositive, opts.JobID)
	}

	// Extract pipeline_id (optional)
	if pipelineIDFloat, ok := args["pipeline_id"].(float64); ok {
		pipelineID := int64(pipelineIDFloat)
		opts.PipelineID = &pipelineID
	}

	// Extract ref (optional)
	if ref, ok := args["ref"].(string); ok && ref != "" {
		opts.Ref = ref
	}

	// Extract output_path (optional)
	if outputPath, ok := args["output_path"].(string); ok && outputPath != "" {
		opts.OutputPath = outputPath
	}

	return opts, nil
}

// setupAddIssueNoteTool creates and registers the add_issue_note tool.
func setupAddIssueNoteTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	addIssueNoteTool := mcp.NewTool("add_issue_note",
		mcp.WithDescription("Add a note/comment to an existing issue for a GitLab project by project path"),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name' or "+
				"'company/department/team/project'). Run 'git remote -v' to find the full path from the repository URL"),
		),
		mcp.WithNumber("issue_iid",
			mcp.Required(),
			mcp.Description("Issue internal ID (IID) to add note to"),
		),
		mcp.WithString("body",
			mcp.Required(),
			mcp.Description("Note/comment body text"),
		),
	)

	s.AddTool(addIssueNoteTool, handleAddIssueNoteRequest(appInstance, debugLogger))
}

// handleNoteRequest handles the add_issue_note tool request.
func handleNoteRequest(
	appInstance *app.App,
	debugLogger *slog.Logger,
) func(context.Context, mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received add_issue_note tool request", "args", args)

		// Extract project_path
		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		// Extract issue_iid (required)
		issueIIDFloat, ok := args["issue_iid"].(float64)
		if !ok {
			debugLogger.Error("issue_iid is missing or not a number", "value", args["issue_iid"])
			return mcp.NewToolResultError("issue_iid must be a number"), nil
		}
		issueIID := int64(issueIIDFloat)

		// Extract body (required)
		body, ok := args["body"].(string)
		if !ok || body == "" {
			debugLogger.Error("body is missing or not a string", "value", args["body"])
			return mcp.NewToolResultError("body must be a non-empty string"), nil
		}

		// Create options
		opts := &app.AddIssueNoteOptions{
			Body: body,
		}

		debugLogger.Debug("Processing add_issue_note request", "project_path", projectPath, "issue_iid", issueIID)

		// Call the app method
		note, err := appInstance.AddIssueNote(projectPath, issueIID, opts)
		if err != nil {
			debugLogger.Error("Failed to add issue note", "error", err, "project_path", projectPath, "issue_iid", issueIID)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to add issue note: %v", err)), nil
		}

		// Convert note to JSON
		jsonData, err := json.Marshal(note)
		if err != nil {
			debugLogger.Error("Failed to marshal note to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format note response"), nil
		}

		debugLogger.Info("Successfully added note to issue",
			"note_id", note.ID,
			"project_path", projectPath,
			"issue_iid", issueIID)
		return mcp.NewToolResultText(string(jsonData)), nil
	}
}

var handleAddIssueNoteRequest = handleNoteRequest

// setupProjectInfoTool creates a generic project info tool handler.
func setupProjectInfoTool(
	s *server.MCPServer,
	debugLogger *slog.Logger,
	toolName, toolDescription, actionLog, errorLog, successLog string,
	handler func(string) (*app.ProjectInfo, error),
) {
	tool := mcp.NewTool(toolName,
		mcp.WithDescription(toolDescription),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name' or "+
				"'company/department/team/project'). Run 'git remote -v' to find the full path from the repository URL"),
		),
	)

	s.AddTool(tool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		args := request.GetArguments()
		debugLogger.Debug("Received "+toolName+" tool request", "args", args)

		// Extract project_path
		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		debugLogger.Debug("Processing "+actionLog+" request", "project_path", projectPath)

		// Call the app method
		projectInfo, err := handler(projectPath)
		if err != nil {
			debugLogger.Error(errorLog, "error", err, "project_path", projectPath)
			return mcp.NewToolResultError(fmt.Sprintf(errorLog+": %v", err)), nil
		}

		// Convert to JSON
		jsonData, err := json.Marshal(projectInfo)
		if err != nil {
			debugLogger.Error("Failed to marshal project info to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format project info response"), nil
		}

		debugLogger.Info(successLog, "project_path", projectPath)
		return mcp.NewToolResultText(string(jsonData)), nil
	})
}

// setupGetProjectDescriptionTool creates and registers the get_project_description tool.
func setupGetProjectDescriptionTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	setupProjectInfoTool(
		s, debugLogger,
		"get_project_description",
		"Get the description of a GitLab project by project path",
		"get_project_description",
		"Failed to get project description",
		"Successfully retrieved project description",
		appInstance.GetProjectDescription,
	)
}

// setupUpdateProjectDescriptionTool creates and registers the update_project_description tool.
func setupUpdateProjectDescriptionTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	updateProjectDescriptionTool := mcp.NewTool("update_project_description",
		mcp.WithDescription("Update the description of a GitLab project by project path"),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name' or "+
				"'company/department/team/project'). Run 'git remote -v' to find the full path from the repository URL"),
		),
		mcp.WithString("description",
			mcp.Required(),
			mcp.Description("The new description for the project"),
		),
	)

	s.AddTool(updateProjectDescriptionTool, func(ctx context.Context, request mcp.CallToolRequest) (
		*mcp.CallToolResult, error,
	) {
		args := request.GetArguments()
		debugLogger.Debug("Received update_project_description tool request", "args", args)

		// Extract project_path
		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		// Extract description
		description, ok := args["description"].(string)
		if !ok {
			debugLogger.Error("description is not a valid string", "value", args["description"])
			return mcp.NewToolResultError("description must be a string"), nil
		}

		debugLogger.Debug("Processing update_project_description request", "project_path", projectPath)

		// Call the app method
		projectInfo, err := appInstance.UpdateProjectDescription(projectPath, description)
		if err != nil {
			debugLogger.Error("Failed to update project description", "error", err, "project_path", projectPath)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to update project description: %v", err)), nil
		}

		// Convert to JSON
		jsonData, err := json.Marshal(projectInfo)
		if err != nil {
			debugLogger.Error("Failed to marshal project info to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format project info response"), nil
		}

		debugLogger.Info("Successfully updated project description", "project_path", projectPath)
		return mcp.NewToolResultText(string(jsonData)), nil
	})
}

// setupGetProjectTopicsTool creates and registers the get_project_topics tool.
func setupGetProjectTopicsTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	setupProjectInfoTool(
		s, debugLogger,
		"get_project_topics",
		"Get the topics/tags of a GitLab project by project path",
		"get_project_topics",
		"Failed to get project topics",
		"Successfully retrieved project topics",
		appInstance.GetProjectTopics,
	)
}

// setupUpdateProjectTopicsTool creates and registers the update_project_topics tool.
func setupUpdateProjectTopicsTool(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger) {
	updateProjectTopicsTool := mcp.NewTool("update_project_topics",
		mcp.WithDescription("Update the topics/tags of a GitLab project (replaces all existing topics)"),
		mcp.WithString("project_path",
			mcp.Required(),
			mcp.Description("GitLab project path including all namespaces (e.g., 'namespace/project-name' or "+
				"'company/department/team/project'). Run 'git remote -v' to find the full path from the repository URL"),
		),
		mcp.WithArray("topics",
			mcp.Required(),
			mcp.Description("Array of topic strings to set for the project (replaces all existing topics)"),
		),
	)

	s.AddTool(updateProjectTopicsTool, func(ctx context.Context, request mcp.CallToolRequest) (
		*mcp.CallToolResult, error,
	) {
		args := request.GetArguments()
		debugLogger.Debug("Received update_project_topics tool request", "args", args)

		// Extract project_path
		projectPath, ok := args["project_path"].(string)
		if !ok || projectPath == "" {
			debugLogger.Error("project_path is not a valid string", "value", args["project_path"])
			return mcp.NewToolResultError("project_path must be a non-empty string"), nil
		}

		// Extract topics
		topicsInterface, ok := args["topics"].([]any)
		if !ok {
			debugLogger.Error("topics is not an array", "value", args["topics"])
			return mcp.NewToolResultError("topics must be an array of strings"), nil
		}

		// Convert interface array to string array
		topics := make([]string, 0, len(topicsInterface))
		for _, topic := range topicsInterface {
			if topicStr, ok := topic.(string); ok {
				topics = append(topics, topicStr)
			} else {
				debugLogger.Error("topic item is not a string", "value", topic)
				return mcp.NewToolResultError("all topics must be strings"), nil
			}
		}

		debugLogger.Debug("Processing update_project_topics request", "project_path", projectPath, "topics", topics)

		// Call the app method
		projectInfo, err := appInstance.UpdateProjectTopics(projectPath, topics)
		if err != nil {
			debugLogger.Error("Failed to update project topics", "error", err, "project_path", projectPath)
			return mcp.NewToolResultError(fmt.Sprintf("Failed to update project topics: %v", err)), nil
		}

		// Convert to JSON
		jsonData, err := json.Marshal(projectInfo)
		if err != nil {
			debugLogger.Error("Failed to marshal project info to JSON", "error", err)
			return mcp.NewToolResultError("Failed to format project info response"), nil
		}

		debugLogger.Info("Successfully updated project topics", "project_path", projectPath, "topics_count", len(topics))
		return mcp.NewToolResultText(string(jsonData)), nil
	})
}

func printHelp() {
	fmt.Printf(`GitLab MCP Server %s

A Model Context Protocol (MCP) server that provides GitLab integration tools for Claude Code.

USAGE:
    gitlab-mcp [OPTIONS]

OPTIONS:
    -h, --help     Show this help message
    -v, --version  Show version information

    Tool category flags (specify to disable categories):
      --no-issues          Disable issue management tools
      --no-labels          Disable label management tools
      --no-project-metadata
                           Disable project metadata tools
      --no-epics           Disable epic management tools
      --no-pipelines       Disable CI/CD pipeline tools

ENVIRONMENT VARIABLES:
    GITLAB_TOKEN   GitLab API personal access token (required)
    GITLAB_URI     GitLab instance URI (default: https://gitlab.com/)

DESCRIPTION:
    This MCP server provides the following tools for GitLab integration:

    • list_issues              - List issues for a GitLab project
    • create_issues            - Create new issues with metadata
    • update_issues            - Update existing issues
    • list_labels              - List project labels with filtering
    • add_issue_note           - Add notes/comments to existing issues
    • add_merge_request_note   - Add notes/comments to existing merge requests
    • create_merge_request     - Create new merge requests
    • get_project_description  - Get the description of a project
    • update_project_description - Update the project description
    • get_project_topics       - Get the topics/tags of a project
    • update_project_topics    - Update the project topics (replaces all)
    • list_epics               - List epics for a GitLab group (Premium/Ultimate)

    The server communicates via JSON-RPC 2.0 over stdin/stdout and is designed
    to be used with Claude Code's MCP architecture.

EXAMPLES:
    # Start with all tools (default)
    gitlab-mcp

    # Disable epics and labels
    gitlab-mcp --no-epics --no-labels

    # Enable only issues and project metadata
    gitlab-mcp --no-labels --no-epics --no-pipelines

    # Show help
    gitlab-mcp -h

    # Show version
    gitlab-mcp -v

For more information, visit: https://github.com/sgaunet/gitlab-mcp
`, version)
}

// handleCommandLineFlags processes command line arguments and exits if necessary.
func handleCommandLineFlags() *ToolCategoryFlags {
	var (
		showHelp        = flag.Bool("h", false, "Show help message")
		showHelpLong    = flag.Bool("help", false, "Show help message")
		showVersion     = flag.Bool("v", false, "Show version information")
		showVersionLong = flag.Bool("version", false, "Show version information")

		// Tool category flags (all default false = don't disable)
		noIssues          = flag.Bool("no-issues", false, "Disable issue management tools")
		noLabels          = flag.Bool("no-labels", false, "Disable label management tools")
		noProjectMetadata = flag.Bool("no-project-metadata", false, "Disable project metadata tools")
		noEpics           = flag.Bool("no-epics", false, "Disable epic management tools")
		noPipelines       = flag.Bool("no-pipelines", false, "Disable CI/CD pipeline tools")
		noMergeRequests   = flag.Bool("no-merge-requests", false, "Disable merge request management tools")
	)

	flag.Parse()

	// Handle help flags
	if *showHelp || *showHelpLong {
		printHelp()
		os.Exit(0)
	}

	// Handle version flags
	if *showVersion || *showVersionLong {
		fmt.Printf("%s\n", version)
		os.Exit(0)
	}

	// Return configuration with inverted logic (flags are negative)
	return &ToolCategoryFlags{
		Issues:          !*noIssues,
		Labels:          !*noLabels,
		ProjectMetadata: !*noProjectMetadata,
		Epics:           !*noEpics,
		Pipelines:       !*noPipelines,
		MergeRequests:   !*noMergeRequests,
	}
}

// initializeApp creates and configures the application instance.
func initializeApp() (*app.App, *slog.Logger) {
	// Initialize the app
	appInstance, err := app.New()
	if err != nil {
		log.Fatalf("Failed to initialize app: %v", err)
	}

	// Set debug logger
	debugLogger := logger.NewLogger("debug")
	appInstance.SetLogger(debugLogger)

	debugLogger.Info("Starting GitLab MCP Server", "version", version)

	// Validate connection
	if err := appInstance.ValidateConnection(); err != nil {
		log.Fatalf("Failed to validate GitLab connection: %v", err)
	}

	return appInstance, debugLogger
}

// extractCreateEpicParams extracts and validates parameters for create_epic.
func extractCreateEpicParams(
	args map[string]any,
	debugLogger *slog.Logger,
) (string, *app.CreateEpicOptions, *mcp.CallToolResult) {
	// Extract required parameters
	groupPath, ok := args["group_path"].(string)
	if !ok || groupPath == "" {
		debugLogger.Error("group_path is not a valid string", "value", args["group_path"])
		return "", nil, mcp.NewToolResultError("group_path must be a non-empty string")
	}

	title, ok := args["title"].(string)
	if !ok || title == "" {
		debugLogger.Error("title is not a valid string", "value", args["title"])
		return "", nil, mcp.NewToolResultError("title must be a non-empty string")
	}

	// Build options with required and optional parameters
	opts := buildCreateEpicOptions(title, args)

	return groupPath, opts, nil
}

// extractUpdateEpicParams extracts and validates parameters for update_epic.
func extractUpdateEpicParams(
	args map[string]any,
	debugLogger *slog.Logger,
) (string, int, *app.UpdateEpicOptions, *mcp.CallToolResult) {
	// Extract required parameters
	groupPath, ok := args["group_path"].(string)
	if !ok || groupPath == "" {
		debugLogger.Error("group_path is not a valid string", "value", args["group_path"])
		return "", 0, nil, mcp.NewToolResultError("group_path must be a non-empty string")
	}

	epicIIDFloat, ok := args["epic_iid"].(float64)
	if !ok {
		debugLogger.Error("epic_iid is not a valid number", "value", args["epic_iid"])
		return "", 0, nil, mcp.NewToolResultError("epic_iid must be a number")
	}
	epicIID := int(epicIIDFloat)
	if epicIID <= 0 {
		debugLogger.Error("epic_iid must be positive", "value", epicIID)
		return "", 0, nil, mcp.NewToolResultError("epic_iid must be a positive integer")
	}

	// Build options with optional parameters
	opts := buildUpdateEpicOptions(args)

	return groupPath, epicIID, opts, nil
}

// extractAddIssueToEpicParams extracts and validates add_issue_to_epic parameters.
func extractAddIssueToEpicParams(args map[string]any) (*app.AddIssueToEpicOptions, error) {
	// Extract group_path
	groupPath, ok := args["group_path"].(string)
	if !ok || groupPath == "" {
		return nil, ErrGroupPathRequired
	}

	// Extract epic_iid
	epicIIDFloat, ok := args["epic_iid"].(float64)
	if !ok {
		return nil, ErrEpicIIDRequired
	}
	epicIID := int(epicIIDFloat)
	if epicIID <= 0 {
		return nil, ErrEpicIIDMustBePositive
	}

	// Extract project_path
	projectPath, ok := args["project_path"].(string)
	if !ok || projectPath == "" {
		return nil, ErrProjectPathRequired
	}

	// Extract issue_iid
	issueIIDFloat, ok := args["issue_iid"].(float64)
	if !ok {
		return nil, ErrIssueIIDRequired
	}
	issueIID := int64(issueIIDFloat)
	if issueIID <= 0 {
		return nil, ErrIssueIIDMustBePositive
	}

	return &app.AddIssueToEpicOptions{
		GroupPath:   groupPath,
		EpicIID:     epicIID,
		ProjectPath: projectPath,
		IssueIID:    issueIID,
	}, nil
}

// buildCreateEpicOptions builds CreateEpicOptions from request arguments.
func buildCreateEpicOptions(title string, args map[string]any) *app.CreateEpicOptions {
	opts := &app.CreateEpicOptions{
		Title: title,
	}

	// Extract optional parameters
	if desc, ok := args["description"].(string); ok {
		opts.Description = desc
	}

	if labelsRaw, ok := args["labels"].([]any); ok {
		opts.Labels = extractStringArray(labelsRaw)
	}

	if startDate, ok := args["start_date"].(string); ok && startDate != "" {
		opts.StartDate = startDate
	}

	if dueDate, ok := args["due_date"].(string); ok && dueDate != "" {
		opts.DueDate = dueDate
	}

	if conf, ok := args["confidential"].(bool); ok {
		opts.Confidential = conf
	}

	return opts
}

// buildUpdateEpicOptions builds UpdateEpicOptions from request arguments.
func buildUpdateEpicOptions(args map[string]any) *app.UpdateEpicOptions {
	opts := &app.UpdateEpicOptions{}

	// Extract string fields
	extractUpdateEpicStringFields(opts, args)

	// Extract labels
	if labelsRaw, ok := args["labels"].([]any); ok {
		opts.Labels = extractStringArray(labelsRaw)
	}

	// Extract confidential flag
	extractUpdateEpicConfidential(opts, args)

	return opts
}

// extractUpdateEpicStringFields extracts string fields for epic update.
func extractUpdateEpicStringFields(opts *app.UpdateEpicOptions, args map[string]any) {
	extractUpdateEpicBasicFields(opts, args)
	extractUpdateEpicDateFields(opts, args)
}

// extractUpdateEpicBasicFields extracts basic string fields for epic update.
func extractUpdateEpicBasicFields(opts *app.UpdateEpicOptions, args map[string]any) {
	if title, ok := args["title"].(string); ok && title != "" {
		opts.Title = title
	}

	if desc, ok := args["description"].(string); ok && desc != "" {
		opts.Description = desc
	}

	if state, ok := args["state"].(string); ok && state != "" {
		opts.State = state
	}
}

// extractUpdateEpicDateFields extracts date fields for epic update.
func extractUpdateEpicDateFields(opts *app.UpdateEpicOptions, args map[string]any) {
	if startDate, ok := args["start_date"].(string); ok && startDate != "" {
		opts.StartDate = startDate
	}

	if dueDate, ok := args["due_date"].(string); ok && dueDate != "" {
		opts.DueDate = dueDate
	}
}

// extractUpdateEpicConfidential extracts the confidential flag for epic update.
func extractUpdateEpicConfidential(opts *app.UpdateEpicOptions, args map[string]any) {
	if conf, exists := args["confidential"]; exists {
		if confBool, ok := conf.(bool); ok {
			opts.Confidential = &confBool
		}
	}
}

// handleCreateEpicError handles errors from CreateGroupEpic.
func handleCreateEpicError(err error, groupPath string, debugLogger *slog.Logger) *mcp.CallToolResult {
	debugLogger.Error("Failed to create epic", "error", err, "group_path", groupPath)

	if errors.Is(err, app.ErrEpicsTierRequired) {
		return mcp.NewToolResultError(fmt.Sprintf(
			"Failed to create epic: %v\n\n"+
				"Epics are a GitLab Premium/Ultimate feature. "+
				"See: https://docs.gitlab.com/ee/user/group/epics/",
			err,
		))
	}

	return mcp.NewToolResultError(fmt.Sprintf("Failed to create epic: %v", err))
}

// extractStringArray extracts a string array from an interface array.
func extractStringArray(raw []any) []string {
	result := make([]string, 0, len(raw))
	for _, item := range raw {
		if str, ok := item.(string); ok {
			result = append(result, str)
		}
	}
	return result
}

// logEnabledCategories logs which tool categories are active at startup.
func logEnabledCategories(debugLogger *slog.Logger, flags *ToolCategoryFlags) {
	enabled := []string{}
	disabled := []string{}

	if flags.Issues {
		enabled = append(enabled, "issues")
	} else {
		disabled = append(disabled, "issues")
	}

	if flags.Labels {
		enabled = append(enabled, "labels")
	} else {
		disabled = append(disabled, "labels")
	}

	if flags.ProjectMetadata {
		enabled = append(enabled, "project-metadata")
	} else {
		disabled = append(disabled, "project-metadata")
	}

	if flags.Epics {
		enabled = append(enabled, "epics")
	} else {
		disabled = append(disabled, "epics")
	}

	if flags.Pipelines {
		enabled = append(enabled, "pipelines")
	} else {
		disabled = append(disabled, "pipelines")
	}

	if flags.MergeRequests {
		enabled = append(enabled, "merge-requests")
	} else {
		disabled = append(disabled, "merge-requests")
	}

	debugLogger.Info("Tool categories configuration",
		"enabled", strings.Join(enabled, ", "),
		"disabled", strings.Join(disabled, ", "),
	)

	// Also log to stderr for user visibility
	if len(disabled) > 0 {
		fmt.Fprintf(os.Stderr, "[INFO] Disabled tool categories: %s\n",
			strings.Join(disabled, ", "))
	}
}

func registerAllTools(s *server.MCPServer, appInstance *app.App, debugLogger *slog.Logger, flags *ToolCategoryFlags) {
	// Issues category (4 tools)
	if flags.Issues {
		setupListIssuesTool(s, appInstance, debugLogger)
		setupCreateIssueTool(s, appInstance, debugLogger)
		setupUpdateIssueTool(s, appInstance, debugLogger)
		setupAddIssueNoteTool(s, appInstance, debugLogger)
	}

	// Labels category (1 tool)
	if flags.Labels {
		setupListLabelsTool(s, appInstance, debugLogger)
	}

	// Project metadata category (4 tools)
	if flags.ProjectMetadata {
		setupGetProjectDescriptionTool(s, appInstance, debugLogger)
		setupUpdateProjectDescriptionTool(s, appInstance, debugLogger)
		setupGetProjectTopicsTool(s, appInstance, debugLogger)
		setupUpdateProjectTopicsTool(s, appInstance, debugLogger)
	}

	// Epics category (4 tools)
	if flags.Epics {
		setupListEpicsTool(s, appInstance, debugLogger)
		setupCreateEpicTool(s, appInstance, debugLogger)
		setupUpdateEpicTool(s, appInstance, debugLogger)
		setupAddIssueToEpicTool(s, appInstance, debugLogger)
	}

	// Pipelines category (4 tools)
	if flags.Pipelines {
		setupGetLatestPipelineTool(s, appInstance, debugLogger)
		setupListPipelineJobsTool(s, appInstance, debugLogger)
		setupGetJobLogTool(s, appInstance, debugLogger)
		setupDownloadJobTraceTool(s, appInstance, debugLogger)
	}

	// Merge Requests category (8 tools)
	if flags.MergeRequests {
		setupListMergeRequestsTool(s, appInstance, debugLogger)
		setupCreateMergeRequestTool(s, appInstance, debugLogger)
		setupGetMergeRequestTool(s, appInstance, debugLogger)
		setupUpdateMergeRequestTool(s, appInstance, debugLogger)
		setupMergeMergeRequestTool(s, appInstance, debugLogger)
		setupGetMergeRequestDiffTool(s, appInstance, debugLogger)
		setupApproveMergeRequestTool(s, appInstance, debugLogger)
		setupAddMergeRequestNoteTool(s, appInstance, debugLogger)
	}
}

func main() {
	flags := handleCommandLineFlags()
	appInstance, debugLogger := initializeApp()

	// Create MCP server
	s := server.NewMCPServer(
		"GitLab MCP Server",
		version,
		server.WithToolCapabilities(true),
		server.WithResourceCapabilities(true, false),
	)

	registerAllTools(s, appInstance, debugLogger, flags)
	logEnabledCategories(debugLogger, flags)

	// Start the stdio server
	if err := server.ServeStdio(s); err != nil {
		fmt.Fprintf(os.Stderr, "Server error: %v\n", err)
		os.Exit(1)
	}
}