Merge main into copilot/add-issue-creation-functionality

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

Author: Copilot

README.md

@@ -79,6 +79,8 @@ Usage:
   jira get-comments <issue-key> - Get comments of the specified JIRA issue
   jira add-comment <issue-key> <comment> - Add a comment to the specified JIRA issue
   jira attach-file <issue-key> <file-path> - Attach a file to the specified JIRA issue
+  jira assign-issue <issue-key> <assignee> - Assign an issue to a user
+  jira add-issue-to-sprint <issue-key> - Add an issue to the current sprint
   jira mcp-server - Start MCP server (Model Context Protocol)
 ```
 
@@ -138,6 +140,18 @@ jira attach-file PROJ-123 /path/to/document.pdf
 jira attach-file PROJ-456 ~/screenshots/bug-screenshot.png
 ```
 
+**Assign an issue:**
+```bash
+jira assign-issue PROJ-123 john.doe
+# Assigns the issue PROJ-123 to user john.doe
+```
+
+**Add an issue to the current sprint:**
+```bash
+jira add-issue-to-sprint PROJ-123
+# Adds the issue to the currently active sprint for its project
+```
+
 ### MCP Server Mode
 
 The MCP (Model Context Protocol) server allows AI assistants and other tools to interact with JIRA through a standardized JSON-RPC protocol over stdio. This enables seamless integration with AI coding assistants and other automation tools.
@@ -175,6 +189,8 @@ The server exposes the following tools:
 - `create_issue` - Create a new JIRA issue with specified project, issue type (Story/Bug/Task), title, description, and optional assignee
 - `list_issues` - List issues assigned to the current user that are unresolved and updated in the last 14 days
 - `attach_file` - Attach a file to a JIRA issue
+- `assign_issue` - Assign a JIRA issue to a user
+- `add_issue_to_sprint` - Add a JIRA issue to the current active sprint
 
 **Example usage from an AI assistant:**
 > "Get the details of issue PROJ-123 and add a comment saying the work is in progress."

main.go

@@ -39,6 +39,8 @@ func main() {
 		fmt.Fprintln(w, "  jira get-comments <issue-key> - Get comments of the specified JIRA issue")
 		fmt.Fprintln(w, "  jira add-comment <issue-key> <comment> - Add a comment to the specified JIRA issue")
 		fmt.Fprintln(w, "  jira attach-file <issue-key> <file-path> - Attach a file to the specified JIRA issue")
+		fmt.Fprintln(w, "  jira assign-issue <issue-key> <assignee> - Assign an issue to a user")
+		fmt.Fprintln(w, "  jira add-issue-to-sprint <issue-key> - Add an issue to the current sprint")
 		fmt.Fprintln(w, "  jira mcp-server - Start MCP server (stdio transport)")
 		fmt.Fprintln(w)
 		fmt.Fprintln(w, "Options:")
@@ -123,6 +125,21 @@ func run(ctx context.Context, args []string) error {
 		return executeCommand(ctx, func(ctx context.Context) error {
 			return attachFile(ctx, filePath)
 		})
+	case "assign-issue":
+		if len(args) < 3 {
+			return fmt.Errorf("usage: jira assign-issue <issue-key> <assignee>")
+		}
+		issueKey = args[1]
+		assignee := args[2]
+		return executeCommand(ctx, func(ctx context.Context) error {
+			return assignIssue(ctx, assignee)
+		})
+	case "add-issue-to-sprint":
+		if len(args) < 2 {
+			return fmt.Errorf("usage: jira add-issue-to-sprint <issue-key>")
+		}
+		issueKey = args[1]
+		return executeCommand(ctx, addIssueToSprint)
 	case "mcp-server":
 		return runMCPServer(ctx)
 	default:
@@ -441,3 +458,68 @@ func attachFile(ctx context.Context, filePath string) error {
 
 	return nil
 }
+
+// assignIssue assigns an issue to a user
+func assignIssue(ctx context.Context, assignee string) error {
+	// Create a User object with the assignee name
+	user := &jira.User{
+		Name: assignee,
+	}
+
+	// Update the assignee
+	_, err := client.Issue.UpdateAssigneeWithContext(ctx, issueKey, user)
+	if err != nil {
+		return fmt.Errorf("failed to assign issue: %w", err)
+	}
+
+	fmt.Printf("Successfully assigned issue %s to %s\n", issueKey, assignee)
+	return nil
+}
+
+// addIssueToSprint adds an issue to the current sprint
+func addIssueToSprint(ctx context.Context) error {
+	// First, get the issue to find its project/board
+	issue, _, err := client.Issue.GetWithContext(ctx, issueKey, nil)
+	if err != nil {
+		return fmt.Errorf("failed to get issue: %w", err)
+	}
+
+	// Get all boards to find the one that contains this issue's project
+	boards, _, err := client.Board.GetAllBoardsWithContext(ctx, &jira.BoardListOptions{
+		ProjectKeyOrID: issue.Fields.Project.Key,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to get boards: %w", err)
+	}
+
+	if len(boards.Values) == 0 {
+		return fmt.Errorf("no boards found for project %s", issue.Fields.Project.Key)
+	}
+
+	// Use the first board (typically the main board for the project)
+	boardID := boards.Values[0].ID
+
+	// Get all sprints for this board
+	sprints, _, err := client.Board.GetAllSprintsWithOptionsWithContext(ctx, boardID, &jira.GetAllSprintsOptions{
+		State: "active",
+	})
+	if err != nil {
+		return fmt.Errorf("failed to get sprints: %w", err)
+	}
+
+	if len(sprints.Values) == 0 {
+		return fmt.Errorf("no active sprint found for board %d", boardID)
+	}
+
+	// Use the first active sprint
+	sprintID := sprints.Values[0].ID
+
+	// Move the issue to the sprint
+	_, err = client.Sprint.MoveIssuesToSprintWithContext(ctx, sprintID, []string{issueKey})
+	if err != nil {
+		return fmt.Errorf("failed to add issue to sprint: %w", err)
+	}
+
+	fmt.Printf("Successfully added issue %s to sprint %s (ID: %d)\n", issueKey, sprints.Values[0].Name, sprintID)
+	return nil
+}

mcp.go

@@ -154,6 +154,34 @@ func runMCPServer(ctx context.Context) error {
 		return attachFileHandler(ctx, api, request)
 	})
 
+	// Add assign-issue tool
+	assignIssueTool := mcp.NewTool("assign_issue",
+		mcp.WithDescription("Assign a JIRA issue to a user"),
+		mcp.WithString("issue_key",
+			mcp.Required(),
+			mcp.Description("JIRA issue key (e.g., 'PROJ-123')"),
+		),
+		mcp.WithString("assignee",
+			mcp.Required(),
+			mcp.Description("Username of the assignee"),
+		),
+	)
+	s.AddTool(assignIssueTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		return assignIssueHandler(ctx, api, request)
+	})
+
+	// Add add-issue-to-sprint tool
+	addIssueToSprintTool := mcp.NewTool("add_issue_to_sprint",
+		mcp.WithDescription("Add a JIRA issue to the current active sprint"),
+		mcp.WithString("issue_key",
+			mcp.Required(),
+			mcp.Description("JIRA issue key (e.g., 'PROJ-123')"),
+		),
+	)
+	s.AddTool(addIssueToSprintTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		return addIssueToSprintHandler(ctx, api, request)
+	})
+
 	// Start the stdio server
 	return server.ServeStdio(s)
 }
@@ -416,3 +444,79 @@ func attachFileHandler(ctx context.Context, client *jira.Client, request mcp.Cal
 
 	return mcp.NewToolResultText(fmt.Sprintf("Successfully attached file to issue %s", issueKey)), nil
 }
+
+func assignIssueHandler(ctx context.Context, client *jira.Client, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	issueKey, err := request.RequireString("issue_key")
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("Missing or invalid 'issue_key' argument: %v", err)), nil
+	}
+
+	assignee, err := request.RequireString("assignee")
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("Missing or invalid 'assignee' argument: %v", err)), nil
+	}
+
+	// Create a User object with the assignee name
+	user := &jira.User{
+		Name: assignee,
+	}
+
+	// Update the assignee
+	_, err = client.Issue.UpdateAssigneeWithContext(ctx, issueKey, user)
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("Failed to assign issue: %v", err)), nil
+	}
+
+	return mcp.NewToolResultText(fmt.Sprintf("Successfully assigned issue %s to %s", issueKey, assignee)), nil
+}
+
+func addIssueToSprintHandler(ctx context.Context, client *jira.Client, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	issueKey, err := request.RequireString("issue_key")
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("Missing or invalid 'issue_key' argument: %v", err)), nil
+	}
+
+	// First, get the issue to find its project/board
+	issue, _, err := client.Issue.GetWithContext(ctx, issueKey, nil)
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("Failed to get issue: %v", err)), nil
+	}
+
+	// Get all boards to find the one that contains this issue's project
+	boards, _, err := client.Board.GetAllBoardsWithContext(ctx, &jira.BoardListOptions{
+		ProjectKeyOrID: issue.Fields.Project.Key,
+	})
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("Failed to get boards: %v", err)), nil
+	}
+
+	if len(boards.Values) == 0 {
+		return mcp.NewToolResultError(fmt.Sprintf("No boards found for project %s", issue.Fields.Project.Key)), nil
+	}
+
+	// Use the first board (typically the main board for the project)
+	boardID := boards.Values[0].ID
+
+	// Get all sprints for this board
+	sprints, _, err := client.Board.GetAllSprintsWithOptionsWithContext(ctx, boardID, &jira.GetAllSprintsOptions{
+		State: "active",
+	})
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("Failed to get sprints: %v", err)), nil
+	}
+
+	if len(sprints.Values) == 0 {
+		return mcp.NewToolResultError(fmt.Sprintf("No active sprint found for board %d", boardID)), nil
+	}
+
+	// Use the first active sprint
+	sprintID := sprints.Values[0].ID
+
+	// Move the issue to the sprint
+	_, err = client.Sprint.MoveIssuesToSprintWithContext(ctx, sprintID, []string{issueKey})
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("Failed to add issue to sprint: %v", err)), nil
+	}
+
+	return mcp.NewToolResultText(fmt.Sprintf("Successfully added issue %s to sprint %s (ID: %d)", issueKey, sprints.Values[0].Name, sprintID)), nil
+}

mcp_test.go

@@ -109,6 +109,41 @@ func TestRun_AttachFileNonExistentFile(t *testing.T) {
 	}
 }
 
+func TestRun_AssignIssueMissingArgs(t *testing.T) {
+	ctx := context.Background()
+
+	// Test with no arguments
+	err := run(ctx, []string{"assign-issue"})
+	if err == nil {
+		t.Error("Expected error for missing arguments, got nil")
+	}
+	if !strings.Contains(err.Error(), "usage: jira assign-issue") {
+		t.Errorf("Expected usage error, got: %v", err)
+	}
+
+	// Test with only issue key
+	err = run(ctx, []string{"assign-issue", "TEST-123"})
+	if err == nil {
+		t.Error("Expected error for missing assignee, got nil")
+	}
+	if !strings.Contains(err.Error(), "usage: jira assign-issue") {
+		t.Errorf("Expected usage error, got: %v", err)
+	}
+}
+
+func TestRun_AddIssueToSprintMissingArgs(t *testing.T) {
+	ctx := context.Background()
+
+	// Test with no arguments
+	err := run(ctx, []string{"add-issue-to-sprint"})
+	if err == nil {
+		t.Error("Expected error for missing arguments, got nil")
+	}
+	if !strings.Contains(err.Error(), "usage: jira add-issue-to-sprint") {
+		t.Errorf("Expected usage error, got: %v", err)
+	}
+}
+
 func TestRun_CreateIssueMissingArgs(t *testing.T) {
 	ctx := context.Background()