diff --git a/cmd/pulls.go b/cmd/pulls.go index 4f732c05..0c8b6e46 100644 --- a/cmd/pulls.go +++ b/cmd/pulls.go @@ -82,6 +82,7 @@ var CmdPulls = cli.Command{ &pulls.CmdPullsReviewComments, &pulls.CmdPullsResolve, &pulls.CmdPullsUnresolve, + &pulls.CmdPullsStack, }, } diff --git a/cmd/pulls/stack.go b/cmd/pulls/stack.go new file mode 100644 index 00000000..89af4e61 --- /dev/null +++ b/cmd/pulls/stack.go @@ -0,0 +1,31 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package pulls + +import ( + stdctx "context" + + "gitea.dev/tea/cmd/pulls/stack" + + "github.com/urfave/cli/v3" +) + +// CmdPullsStack represents the stack command to manage pull request stacks +var CmdPullsStack = cli.Command{ + Name: "stack", + Usage: "Manage pull request stacks", + Description: "List, show, push, restack, and merge pull request stacks", + Action: runPullsStackDefault, + Commands: []*cli.Command{ + &stack.CmdStackList, + &stack.CmdStackShow, + &stack.CmdStackPush, + &stack.CmdStackRestack, + &stack.CmdStackMerge, + }, +} + +func runPullsStackDefault(ctx stdctx.Context, cmd *cli.Command) error { + return stack.RunStackList(ctx, cmd) +} diff --git a/cmd/pulls/stack/list.go b/cmd/pulls/stack/list.go new file mode 100644 index 00000000..3f062825 --- /dev/null +++ b/cmd/pulls/stack/list.go @@ -0,0 +1,53 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package stack + +import ( + stdctx "context" + + "gitea.dev/tea/cmd/flags" + "gitea.dev/tea/modules/context" + "gitea.dev/tea/modules/print" + "gitea.dev/tea/modules/task" + + "github.com/urfave/cli/v3" +) + +var stackFieldsFlag = flags.FieldsFlag(print.PullStackFields, []string{ + "id", "title", "base", "state", "entries", +}) + +// CmdStackList represents a sub command to list pull request stacks +var CmdStackList = cli.Command{ + Name: "list", + Aliases: []string{"ls"}, + Usage: "List pull request stacks of the repository", + Description: "List pull request stacks of the repository", + ArgsUsage: " ", // command does not accept arguments + Action: RunStackList, + Flags: append([]cli.Flag{stackFieldsFlag}, flags.AllDefaultFlags...), +} + +// RunStackList lists pull request stacks of the repository +func RunStackList(requestCtx stdctx.Context, cmd *cli.Command) error { + ctx, err := context.InitCommand(cmd) + if err != nil { + return err + } + if err := ctx.Ensure(context.CtxRequirement{RemoteRepo: true}); err != nil { + return err + } + + stacks, err := task.ListPullStacks(requestCtx, ctx.Login, ctx.Owner, ctx.Repo) + if err != nil { + return err + } + + fields, err := stackFieldsFlag.GetValues(cmd) + if err != nil { + return err + } + + return print.PullStacksList(stacks, ctx.Output, fields) +} diff --git a/cmd/pulls/stack/list_test.go b/cmd/pulls/stack/list_test.go new file mode 100644 index 00000000..f150307f --- /dev/null +++ b/cmd/pulls/stack/list_test.go @@ -0,0 +1,43 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package stack + +import ( + "os" + "testing" + + "github.com/stretchr/testify/require" + "github.com/urfave/cli/v3" + + "gitea.dev/tea/modules/config" +) + +func TestRunStackListRequiresRepoContext(t *testing.T) { + oldWd, err := os.Getwd() + require.NoError(t, err) + + require.NoError(t, os.Chdir(t.TempDir())) + t.Cleanup(func() { + require.NoError(t, os.Chdir(oldWd)) + }) + + config.SetConfigForTesting(config.LocalConfig{ + Logins: []config.Login{{ + Name: "test", + URL: "https://gitea.example.com", + Token: "token", + User: "tester", + Default: true, + }}, + }) + + cmd := &cli.Command{ + Name: CmdStackList.Name, + Flags: CmdStackList.Flags, + } + require.NoError(t, cmd.Set("login", "test")) + + err = RunStackList(t.Context(), cmd) + require.ErrorContains(t, err, "remote repository required") +} diff --git a/cmd/pulls/stack/merge.go b/cmd/pulls/stack/merge.go new file mode 100644 index 00000000..bd309aa3 --- /dev/null +++ b/cmd/pulls/stack/merge.go @@ -0,0 +1,73 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package stack + +import ( + stdctx "context" + "fmt" + + "gitea.dev/tea/cmd/flags" + "gitea.dev/tea/modules/context" + "gitea.dev/tea/modules/task" + "gitea.dev/tea/modules/utils" + + "github.com/urfave/cli/v3" +) + +// CmdStackMerge represents a sub command to merge a pull request stack in order +var CmdStackMerge = cli.Command{ + Name: "merge", + Aliases: []string{"m"}, + Usage: "Merge a pull request stack in order", + Description: "Merge every pull request of a stack in order, bottom first", + ArgsUsage: "", + Action: RunStackMerge, + Flags: append([]cli.Flag{ + &cli.StringFlag{ + Name: "style", + Aliases: []string{"s"}, + Usage: "Kind of merge to perform: merge, rebase, squash, rebase-merge", + Value: "merge", + }, + &cli.BoolFlag{ + Name: "wait-for-ci", + Usage: "Schedule the merge to run once required checks pass, instead of merging immediately", + }, + }, flags.AllDefaultFlags...), +} + +// RunStackMerge merges every pull request of a stack in order +func RunStackMerge(requestCtx stdctx.Context, cmd *cli.Command) error { + if cmd.Args().Len() != 1 { + return fmt.Errorf("stack id is required") + } + id, err := utils.ArgToIndex(cmd.Args().First()) + if err != nil { + return err + } + + ctx, err := context.InitCommand(cmd) + if err != nil { + return err + } + if err := ctx.Ensure(context.CtxRequirement{RemoteRepo: true}); err != nil { + return err + } + + result, queued, err := task.MergePullStack(requestCtx, ctx.Login, ctx.Owner, ctx.Repo, id, + cmd.String("style"), cmd.Bool("wait-for-ci")) + if queued { + fmt.Fprintf(ctx.Writer, "merge for stack #%d scheduled\n", id) + return nil + } + if err != nil { + if result != nil { + return fmt.Errorf("merged %d pull request(s) before failing: %w", result.Merged, err) + } + return err + } + + fmt.Fprintf(ctx.Writer, "merged %d pull request(s) of stack #%d\n", result.Merged, id) + return nil +} diff --git a/cmd/pulls/stack/merge_test.go b/cmd/pulls/stack/merge_test.go new file mode 100644 index 00000000..dc3ed13b --- /dev/null +++ b/cmd/pulls/stack/merge_test.go @@ -0,0 +1,32 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package stack + +import ( + "context" + "testing" + + "gitea.dev/tea/modules/config" + + "github.com/stretchr/testify/assert" +) + +func TestStackMergeRequiresStackID(t *testing.T) { + config.SetConfigForTesting(config.LocalConfig{ + Logins: []config.Login{{ + Name: "testLogin", + URL: "https://gitea.example.com", + Token: "test-token", + User: "testUser", + Default: true, + }}, + }) + t.Cleanup(func() { + config.SetConfigForTesting(config.LocalConfig{}) + }) + + cmd := CmdStackMerge + err := cmd.Run(context.Background(), []string{"merge", "--login", "testLogin", "--repo", "user/repo"}) + assert.ErrorContains(t, err, "stack id is required") +} diff --git a/cmd/pulls/stack/push.go b/cmd/pulls/stack/push.go new file mode 100644 index 00000000..e30a80d7 --- /dev/null +++ b/cmd/pulls/stack/push.go @@ -0,0 +1,69 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package stack + +import ( + stdctx "context" + "fmt" + + "gitea.dev/tea/cmd/flags" + "gitea.dev/tea/modules/context" + "gitea.dev/tea/modules/print" + pullstack "gitea.dev/tea/modules/stack" + "gitea.dev/tea/modules/task" + "gitea.dev/tea/modules/utils" + + "github.com/urfave/cli/v3" +) + +// CmdStackPush represents a sub command to link a pull request onto a stack +var CmdStackPush = cli.Command{ + Name: "push", + Usage: "Link a pull request onto a stack", + Description: "Link a child pull request onto its parent, creating a new stack or extending an existing one with --stack", + ArgsUsage: " ", + Action: RunStackPush, + Flags: append([]cli.Flag{ + &cli.Int64Flag{ + Name: "stack", + Usage: "id of an existing stack to append the pull requests to, instead of creating a new stack", + }, + }, flags.AllDefaultFlags...), +} + +// RunStackPush links a parent and a child pull request into a stack +func RunStackPush(requestCtx stdctx.Context, cmd *cli.Command) error { + if cmd.Args().Len() != 2 { + return fmt.Errorf("parent index and child index are required") + } + parentIndex, err := utils.ArgToIndex(cmd.Args().Get(0)) + if err != nil { + return err + } + childIndex, err := utils.ArgToIndex(cmd.Args().Get(1)) + if err != nil { + return err + } + + ctx, err := context.InitCommand(cmd) + if err != nil { + return err + } + if err := ctx.Ensure(context.CtxRequirement{RemoteRepo: true}); err != nil { + return err + } + + var s *pullstack.Stack + if stackID := cmd.Int64("stack"); stackID != 0 { + s, err = task.AddPullStackEntry(requestCtx, ctx.Login, ctx.Owner, ctx.Repo, stackID, parentIndex, childIndex) + } else { + s, err = task.CreatePullStack(requestCtx, ctx.Login, ctx.Owner, ctx.Repo, parentIndex, childIndex) + } + if err != nil { + return err + } + + print.PullStackDetail(s) + return nil +} diff --git a/cmd/pulls/stack/push_test.go b/cmd/pulls/stack/push_test.go new file mode 100644 index 00000000..21a6e033 --- /dev/null +++ b/cmd/pulls/stack/push_test.go @@ -0,0 +1,63 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package stack + +import ( + "context" + "testing" + + "gitea.dev/tea/modules/config" + + "github.com/stretchr/testify/assert" +) + +func TestStackPush(t *testing.T) { + config.SetConfigForTesting(config.LocalConfig{ + Logins: []config.Login{{ + Name: "testLogin", + URL: "https://gitea.example.com", + Token: "test-token", + User: "testUser", + Default: true, + }}, + }) + t.Cleanup(func() { + config.SetConfigForTesting(config.LocalConfig{}) + }) + + tests := []struct { + name string + args []string + errContains string + }{ + { + name: "no arguments", + args: []string{}, + errContains: "parent index and child index are required", + }, + { + name: "missing child index", + args: []string{"1"}, + errContains: "parent index and child index are required", + }, + { + name: "non-numeric parent index", + args: []string{"abc", "2"}, + errContains: "", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cmd := CmdStackPush + args := append([]string{"push"}, tt.args...) + args = append(args, "--login", "testLogin", "--repo", "user/repo") + err := cmd.Run(context.Background(), args) + assert.Error(t, err) + if tt.errContains != "" { + assert.Contains(t, err.Error(), tt.errContains) + } + }) + } +} diff --git a/cmd/pulls/stack/restack.go b/cmd/pulls/stack/restack.go new file mode 100644 index 00000000..05aeaf86 --- /dev/null +++ b/cmd/pulls/stack/restack.go @@ -0,0 +1,52 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package stack + +import ( + stdctx "context" + "fmt" + + "gitea.dev/tea/cmd/flags" + "gitea.dev/tea/modules/context" + "gitea.dev/tea/modules/task" + "gitea.dev/tea/modules/utils" + + "github.com/urfave/cli/v3" +) + +// CmdStackRestack represents a sub command to queue a stack restack +var CmdStackRestack = cli.Command{ + Name: "restack", + Usage: "Queue a pull request stack restack", + Description: "Retarget every open pull request above a merged one in the stack onto its parent's new base", + ArgsUsage: "", + Action: RunStackRestack, + Flags: flags.AllDefaultFlags, +} + +// RunStackRestack queues a restack of a pull request stack +func RunStackRestack(requestCtx stdctx.Context, cmd *cli.Command) error { + if cmd.Args().Len() != 1 { + return fmt.Errorf("stack id is required") + } + id, err := utils.ArgToIndex(cmd.Args().First()) + if err != nil { + return err + } + + ctx, err := context.InitCommand(cmd) + if err != nil { + return err + } + if err := ctx.Ensure(context.CtxRequirement{RemoteRepo: true}); err != nil { + return err + } + + if err := task.RestackPullStack(requestCtx, ctx.Login, ctx.Owner, ctx.Repo, id); err != nil { + return err + } + + fmt.Fprintf(ctx.Writer, "restack for stack #%d queued\n", id) + return nil +} diff --git a/cmd/pulls/stack/restack_test.go b/cmd/pulls/stack/restack_test.go new file mode 100644 index 00000000..7aab714f --- /dev/null +++ b/cmd/pulls/stack/restack_test.go @@ -0,0 +1,32 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package stack + +import ( + "context" + "testing" + + "gitea.dev/tea/modules/config" + + "github.com/stretchr/testify/assert" +) + +func TestStackRestackRequiresStackID(t *testing.T) { + config.SetConfigForTesting(config.LocalConfig{ + Logins: []config.Login{{ + Name: "testLogin", + URL: "https://gitea.example.com", + Token: "test-token", + User: "testUser", + Default: true, + }}, + }) + t.Cleanup(func() { + config.SetConfigForTesting(config.LocalConfig{}) + }) + + cmd := CmdStackRestack + err := cmd.Run(context.Background(), []string{"restack", "--login", "testLogin", "--repo", "user/repo"}) + assert.ErrorContains(t, err, "stack id is required") +} diff --git a/cmd/pulls/stack/show.go b/cmd/pulls/stack/show.go new file mode 100644 index 00000000..17cefbd9 --- /dev/null +++ b/cmd/pulls/stack/show.go @@ -0,0 +1,62 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package stack + +import ( + stdctx "context" + "encoding/json" + "fmt" + + "gitea.dev/tea/cmd/flags" + "gitea.dev/tea/modules/context" + "gitea.dev/tea/modules/print" + "gitea.dev/tea/modules/task" + "gitea.dev/tea/modules/utils" + + "github.com/urfave/cli/v3" +) + +// CmdStackShow represents a sub command to show a pull request stack +var CmdStackShow = cli.Command{ + Name: "show", + Aliases: []string{"get"}, + Usage: "Show a pull request stack", + Description: "Show a pull request stack, its base branch and its ordered pull requests", + ArgsUsage: "", + Action: RunStackShow, + Flags: flags.AllDefaultFlags, +} + +// RunStackShow shows a pull request stack +func RunStackShow(requestCtx stdctx.Context, cmd *cli.Command) error { + if cmd.Args().Len() != 1 { + return fmt.Errorf("stack id is required") + } + id, err := utils.ArgToIndex(cmd.Args().First()) + if err != nil { + return err + } + + ctx, err := context.InitCommand(cmd) + if err != nil { + return err + } + if err := ctx.Ensure(context.CtxRequirement{RemoteRepo: true}); err != nil { + return err + } + + s, err := task.GetPullStack(requestCtx, ctx.Login, ctx.Owner, ctx.Repo, id) + if err != nil { + return err + } + + if ctx.String("output") == "json" { + encoder := json.NewEncoder(ctx.Writer) + encoder.SetIndent("", "\t") + return encoder.Encode(s) + } + + print.PullStackDetail(s) + return nil +} diff --git a/cmd/pulls/stack/show_test.go b/cmd/pulls/stack/show_test.go new file mode 100644 index 00000000..ee8b16dd --- /dev/null +++ b/cmd/pulls/stack/show_test.go @@ -0,0 +1,51 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package stack + +import ( + "context" + "testing" + + "gitea.dev/tea/modules/config" + + "github.com/stretchr/testify/assert" +) + +func TestStackShowRequiresStackID(t *testing.T) { + config.SetConfigForTesting(config.LocalConfig{ + Logins: []config.Login{{ + Name: "testLogin", + URL: "https://gitea.example.com", + Token: "test-token", + User: "testUser", + Default: true, + }}, + }) + t.Cleanup(func() { + config.SetConfigForTesting(config.LocalConfig{}) + }) + + cmd := CmdStackShow + err := cmd.Run(context.Background(), []string{"show", "--login", "testLogin", "--repo", "user/repo"}) + assert.ErrorContains(t, err, "stack id is required") +} + +func TestStackShowRejectsInvalidStackID(t *testing.T) { + config.SetConfigForTesting(config.LocalConfig{ + Logins: []config.Login{{ + Name: "testLogin", + URL: "https://gitea.example.com", + Token: "test-token", + User: "testUser", + Default: true, + }}, + }) + t.Cleanup(func() { + config.SetConfigForTesting(config.LocalConfig{}) + }) + + cmd := CmdStackShow + err := cmd.Run(context.Background(), []string{"show", "notanumber", "--login", "testLogin", "--repo", "user/repo"}) + assert.Error(t, err) +} diff --git a/modules/api/client.go b/modules/api/client.go index 2892dd7c..7d8ff643 100644 --- a/modules/api/client.go +++ b/modules/api/client.go @@ -4,6 +4,7 @@ package api import ( + "context" "crypto/tls" "fmt" "io" @@ -43,13 +44,18 @@ func NewClient(login *config.Login) *Client { // Do executes an HTTP request with authentication headers func (c *Client) Do(method, endpoint string, body io.Reader, headers map[string]string) (*http.Response, error) { + return c.DoContext(context.Background(), method, endpoint, body, headers) +} + +// DoContext executes an HTTP request with authentication headers, bound to ctx +func (c *Client) DoContext(ctx context.Context, method, endpoint string, body io.Reader, headers map[string]string) (*http.Response, error) { // Build the full URL reqURL, err := c.buildURL(endpoint) if err != nil { return nil, err } - req, err := http.NewRequest(method, reqURL, body) + req, err := http.NewRequestWithContext(ctx, method, reqURL, body) if err != nil { return nil, fmt.Errorf("failed to create request: %w", err) } diff --git a/modules/print/pull_stack.go b/modules/print/pull_stack.go new file mode 100644 index 00000000..6089c404 --- /dev/null +++ b/modules/print/pull_stack.go @@ -0,0 +1,71 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package print + +import ( + "fmt" + "strings" + + "gitea.dev/tea/modules/stack" +) + +// PullStackFields are all available fields to print with PullStacksList() +var PullStackFields = []string{ + "id", + "title", + "base", + "state", + "auto-restack", + "entries", +} + +// PullStacksList prints a listing of pull request stacks +func PullStacksList(stacks []*stack.Stack, output string, fields []string) error { + printables := make([]printable, len(stacks)) + for i, s := range stacks { + printables[i] = &printablePullStack{s} + } + t := tableFromItems(fields, printables, isMachineReadable(output)) + return t.print(output) +} + +type printablePullStack struct { + *stack.Stack +} + +func (x printablePullStack) FormatField(field string, machineReadable bool) string { + switch field { + case "id": + return fmt.Sprintf("%d", x.ID) + case "title": + return x.Title + case "base": + return x.BaseBranch + case "state": + return x.State + case "auto-restack": + return formatBoolean(x.AutoRestack, !machineReadable) + case "entries": + return fmt.Sprintf("%d", len(x.Entries)) + } + return "" +} + +// PullStackDetail prints a pull request stack, bottom entry first, rendered to stdout +func PullStackDetail(s *stack.Stack) { + out := fmt.Sprintf( + "# Stack #%d: %s (%s)\nbase: **%s**\tauto-restack: %s\n\n", + s.ID, s.Title, s.State, s.BaseBranch, formatBoolean(s.AutoRestack, true), + ) + + for _, entry := range s.Entries { + if entry.ParentPullID == 0 { + out += fmt.Sprintf("- #%d (%s)\n", entry.PullID, entry.State) + } else { + out += fmt.Sprintf("- #%d <- #%d (%s)\n", entry.PullID, entry.ParentPullID, entry.State) + } + } + + outputMarkdown(strings.TrimRight(out, "\n")+"\n", "") +} diff --git a/modules/print/pull_stack_test.go b/modules/print/pull_stack_test.go new file mode 100644 index 00000000..8d65434b --- /dev/null +++ b/modules/print/pull_stack_test.go @@ -0,0 +1,61 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package print + +import ( + "bytes" + "encoding/json" + "testing" + + "gitea.dev/tea/modules/stack" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestPullStacksListJSON(t *testing.T) { + stacks := []*stack.Stack{ + { + ID: 1, Title: "feat: base", BaseBranch: "main", State: "open", AutoRestack: true, + Entries: []stack.Entry{{PullID: 10}, {PullID: 11}}, + }, + } + + buf := &bytes.Buffer{} + tbl := tableFromItems( + PullStackFields, + []printable{&printablePullStack{stacks[0]}}, + true, + ) + require.NoError(t, tbl.fprint(buf, "json")) + + var result []map[string]string + require.NoError(t, json.Unmarshal(buf.Bytes(), &result)) + require.Len(t, result, 1) + assert.Equal(t, "1", result[0]["id"]) + assert.Equal(t, "feat: base", result[0]["title"]) + assert.Equal(t, "main", result[0]["base"]) + assert.Equal(t, "open", result[0]["state"]) + assert.Equal(t, "true", result[0]["auto-restack"]) + assert.Equal(t, "2", result[0]["entries"]) +} + +func TestPullStackDetailShowsEntries(t *testing.T) { + s := &stack.Stack{ + ID: 3, Title: "feat: base", BaseBranch: "main", State: "open", AutoRestack: true, + Entries: []stack.Entry{ + {PullID: 10, Position: 0, State: "merged"}, + {PullID: 11, ParentPullID: 10, Position: 1, State: "open"}, + }, + } + + out := captureStdout(t, func() { + PullStackDetail(s) + }) + + assert.Contains(t, out, "feat: base") + assert.Contains(t, out, "main") + assert.Contains(t, out, "#10") + assert.Contains(t, out, "#11") +} diff --git a/modules/stack/stack.go b/modules/stack/stack.go new file mode 100644 index 00000000..51fde06d --- /dev/null +++ b/modules/stack/stack.go @@ -0,0 +1,33 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +// Package stack holds the data types shared between the pull request stack API +// client (modules/task) and its output formatting (modules/print). +package stack + +// Entry is one pull request participating in a pull request stack. +type Entry struct { + PullID int64 `json:"pull_id"` + ParentPullID int64 `json:"parent_pull_id"` + Position int `json:"position"` + State string `json:"state"` + LastRestackedSHA string `json:"last_restacked_sha"` +} + +// Stack is a same-repository chain of pull requests, bottom first. +type Stack struct { + ID int64 `json:"id"` + RepoID int64 `json:"repo_id"` + OwnerID int64 `json:"owner_id"` + Title string `json:"title"` + BaseBranch string `json:"base_branch"` + State string `json:"state"` + AutoRestack bool `json:"auto_restack"` + Entries []Entry `json:"entries"` +} + +// MergeResult reports how many pull requests of a stack were merged. +type MergeResult struct { + Merged int64 `json:"merged"` + Error string `json:"error,omitempty"` +} diff --git a/modules/task/pull_stack.go b/modules/task/pull_stack.go new file mode 100644 index 00000000..2f50b289 --- /dev/null +++ b/modules/task/pull_stack.go @@ -0,0 +1,168 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package task + +import ( + "bytes" + stdctx "context" + "encoding/json" + "fmt" + "io" + "net/http" + + "gitea.dev/tea/modules/api" + "gitea.dev/tea/modules/config" + "gitea.dev/tea/modules/stack" +) + +func stackAPIError(resp *http.Response) error { + data, err := io.ReadAll(resp.Body) + if err != nil { + return fmt.Errorf("body read on HTTP error %d: %w", resp.StatusCode, err) + } + + var errBody struct { + Message string `json:"message"` + } + if err := json.Unmarshal(data, &errBody); err == nil && errBody.Message != "" { + return fmt.Errorf("%s", errBody.Message) + } + return fmt.Errorf("%s: %s", resp.Status, string(data)) +} + +func decodeStackResponse(resp *http.Response, wantStatus int, out any) error { + defer func() { _ = resp.Body.Close() }() + + if resp.StatusCode != wantStatus { + return stackAPIError(resp) + } + if out == nil { + return nil + } + return json.NewDecoder(resp.Body).Decode(out) +} + +// pullStackLinkOption links a parent and a child pull request in the same repository. +type pullStackLinkOption struct { + ParentIndex int64 `json:"parent_index"` + ChildIndex int64 `json:"child_index"` +} + +func postStackJSON(ctx stdctx.Context, login *config.Login, endpoint string, body any, wantStatus int, out any) error { + client := api.NewClient(login) + + var reader io.Reader + if body != nil { + encoded, err := json.Marshal(body) + if err != nil { + return err + } + reader = bytes.NewReader(encoded) + } + + resp, err := client.DoContext(ctx, http.MethodPost, endpoint, reader, nil) + if err != nil { + return err + } + return decodeStackResponse(resp, wantStatus, out) +} + +// ListPullStacks lists the pull request stacks of a repository. +func ListPullStacks(ctx stdctx.Context, login *config.Login, owner, repo string) ([]*stack.Stack, error) { + client := api.NewClient(login) + resp, err := client.DoContext(ctx, http.MethodGet, fmt.Sprintf("/repos/%s/%s/stacks", owner, repo), nil, nil) + if err != nil { + return nil, err + } + + var stacks []*stack.Stack + if err := decodeStackResponse(resp, http.StatusOK, &stacks); err != nil { + return nil, err + } + return stacks, nil +} + +// GetPullStack retrieves one stack with its ordered pull requests. +func GetPullStack(ctx stdctx.Context, login *config.Login, owner, repo string, id int64) (*stack.Stack, error) { + client := api.NewClient(login) + resp, err := client.DoContext(ctx, http.MethodGet, fmt.Sprintf("/repos/%s/%s/stacks/%d", owner, repo, id), nil, nil) + if err != nil { + return nil, err + } + + var s stack.Stack + if err := decodeStackResponse(resp, http.StatusOK, &s); err != nil { + return nil, err + } + return &s, nil +} + +// CreatePullStack explicitly links two same-repository pull requests, forming a new stack. +func CreatePullStack(ctx stdctx.Context, login *config.Login, owner, repo string, parentIndex, childIndex int64) (*stack.Stack, error) { + var s stack.Stack + err := postStackJSON(ctx, login, fmt.Sprintf("/repos/%s/%s/stacks", owner, repo), + pullStackLinkOption{ParentIndex: parentIndex, ChildIndex: childIndex}, http.StatusCreated, &s) + if err != nil { + return nil, err + } + return &s, nil +} + +// AddPullStackEntry appends one pull request to the tip of an existing stack. +func AddPullStackEntry(ctx stdctx.Context, login *config.Login, owner, repo string, id, parentIndex, childIndex int64) (*stack.Stack, error) { + var s stack.Stack + err := postStackJSON(ctx, login, fmt.Sprintf("/repos/%s/%s/stacks/%d/entries", owner, repo, id), + pullStackLinkOption{ParentIndex: parentIndex, ChildIndex: childIndex}, http.StatusCreated, &s) + if err != nil { + return nil, err + } + return &s, nil +} + +// RestackPullStack queues a restack of every entry above the merged pull request in the stack. +func RestackPullStack(ctx stdctx.Context, login *config.Login, owner, repo string, id int64) error { + client := api.NewClient(login) + resp, err := client.DoContext(ctx, http.MethodPost, fmt.Sprintf("/repos/%s/%s/stacks/%d/restack", owner, repo, id), nil, nil) + if err != nil { + return err + } + return decodeStackResponse(resp, http.StatusAccepted, nil) +} + +type pullStackMergeOption struct { + Style string `json:"style"` + WaitForCI bool `json:"wait_for_ci"` +} + +// MergePullStack merges every pull request of a stack in order. If waitForCI is set, the merge is +// scheduled instead of applied immediately and MergePullStack returns with queued=true. Otherwise +// it returns the number of pull requests merged; a non-nil error means the merge stopped partway, +// with result.Merged reporting how many pull requests succeeded before that. +func MergePullStack(ctx stdctx.Context, login *config.Login, owner, repo string, id int64, style string, waitForCI bool) (result *stack.MergeResult, queued bool, err error) { + client := api.NewClient(login) + encoded, err := json.Marshal(pullStackMergeOption{Style: style, WaitForCI: waitForCI}) + if err != nil { + return nil, false, err + } + + resp, err := client.DoContext(ctx, http.MethodPost, fmt.Sprintf("/repos/%s/%s/stacks/%d/merge", owner, repo, id), + bytes.NewReader(encoded), nil) + if err != nil { + return nil, false, err + } + defer func() { _ = resp.Body.Close() }() + + if resp.StatusCode == http.StatusAccepted { + return nil, true, nil + } + + var body stack.MergeResult + if decodeErr := json.NewDecoder(resp.Body).Decode(&body); decodeErr != nil { + return nil, false, fmt.Errorf("%s: failed to decode response: %w", resp.Status, decodeErr) + } + if resp.StatusCode != http.StatusOK { + return &body, false, fmt.Errorf("%s", body.Error) + } + return &body, false, nil +} diff --git a/modules/task/pull_stack_test.go b/modules/task/pull_stack_test.go new file mode 100644 index 00000000..bd8906d8 --- /dev/null +++ b/modules/task/pull_stack_test.go @@ -0,0 +1,229 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package task + +import ( + "io" + "net/http" + "net/http/httptest" + "testing" + + "gitea.dev/tea/modules/config" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestListPullStacks(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + assert.Equal(t, http.MethodGet, r.Method) + assert.Equal(t, "/api/v1/repos/owner/repo/stacks", r.URL.Path) + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`[{"id":1,"repo_id":2,"owner_id":3,"title":"feat: base","base_branch":"main","state":"open","auto_restack":true,"entries":[{"pull_id":10,"parent_pull_id":0,"position":0,"state":"open","last_restacked_sha":"abc"}]}]`)) + })) + defer server.Close() + + stacks, err := ListPullStacks(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo") + require.NoError(t, err) + require.Len(t, stacks, 1) + assert.Equal(t, int64(1), stacks[0].ID) + assert.Equal(t, "feat: base", stacks[0].Title) + assert.Equal(t, "main", stacks[0].BaseBranch) + assert.True(t, stacks[0].AutoRestack) + require.Len(t, stacks[0].Entries, 1) + assert.Equal(t, int64(10), stacks[0].Entries[0].PullID) +} + +func TestGetPullStack(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + assert.Equal(t, http.MethodGet, r.Method) + assert.Equal(t, "/api/v1/repos/owner/repo/stacks/7", r.URL.Path) + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"id":7,"repo_id":2,"owner_id":3,"title":"feat: base","base_branch":"main","state":"open","auto_restack":false,"entries":[]}`)) + })) + defer server.Close() + + stack, err := GetPullStack(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo", 7) + require.NoError(t, err) + assert.Equal(t, int64(7), stack.ID) + assert.Equal(t, "open", stack.State) +} + +func TestGetPullStackNotFound(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotFound) + _, _ = w.Write([]byte(`{"message":"stack does not exist"}`)) + })) + defer server.Close() + + _, err := GetPullStack(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo", 7) + require.Error(t, err) + assert.Equal(t, "stack does not exist", err.Error()) +} + +func TestCreatePullStack(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + assert.Equal(t, http.MethodPost, r.Method) + assert.Equal(t, "/api/v1/repos/owner/repo/stacks", r.URL.Path) + body, err := io.ReadAll(r.Body) + require.NoError(t, err) + assert.JSONEq(t, `{"parent_index":1,"child_index":2}`, string(body)) + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusCreated) + _, _ = w.Write([]byte(`{"id":9,"repo_id":2,"owner_id":3,"title":"feat: base","base_branch":"main","state":"open","auto_restack":true,"entries":[]}`)) + })) + defer server.Close() + + stack, err := CreatePullStack(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo", 1, 2) + require.NoError(t, err) + assert.Equal(t, int64(9), stack.ID) +} + +func TestCreatePullStackConflict(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusBadRequest) + _, _ = w.Write([]byte(`{"message":"parent_index and child_index are required"}`)) + })) + defer server.Close() + + _, err := CreatePullStack(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo", 0, 2) + require.Error(t, err) + assert.Equal(t, "parent_index and child_index are required", err.Error()) +} + +func TestAddPullStackEntry(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + assert.Equal(t, http.MethodPost, r.Method) + assert.Equal(t, "/api/v1/repos/owner/repo/stacks/5/entries", r.URL.Path) + body, err := io.ReadAll(r.Body) + require.NoError(t, err) + assert.JSONEq(t, `{"parent_index":2,"child_index":3}`, string(body)) + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusCreated) + _, _ = w.Write([]byte(`{"id":5,"repo_id":2,"owner_id":3,"title":"feat: base","base_branch":"main","state":"open","auto_restack":true,"entries":[]}`)) + })) + defer server.Close() + + stack, err := AddPullStackEntry(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo", 5, 2, 3) + require.NoError(t, err) + assert.Equal(t, int64(5), stack.ID) +} + +func TestRestackPullStack(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + assert.Equal(t, http.MethodPost, r.Method) + assert.Equal(t, "/api/v1/repos/owner/repo/stacks/4/restack", r.URL.Path) + w.WriteHeader(http.StatusAccepted) + })) + defer server.Close() + + err := RestackPullStack(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo", 4) + require.NoError(t, err) +} + +func TestRestackPullStackConflict(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusConflict) + _, _ = w.Write([]byte(`{"message":"stack is not open"}`)) + })) + defer server.Close() + + err := RestackPullStack(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo", 4) + require.Error(t, err) + assert.Equal(t, "stack is not open", err.Error()) +} + +func TestMergePullStack(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + assert.Equal(t, http.MethodPost, r.Method) + assert.Equal(t, "/api/v1/repos/owner/repo/stacks/6/merge", r.URL.Path) + body, err := io.ReadAll(r.Body) + require.NoError(t, err) + assert.JSONEq(t, `{"style":"squash","wait_for_ci":false}`, string(body)) + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"merged":3}`)) + })) + defer server.Close() + + result, queued, err := MergePullStack(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo", 6, "squash", false) + require.NoError(t, err) + assert.False(t, queued) + require.NotNil(t, result) + assert.Equal(t, int64(3), result.Merged) +} + +func TestMergePullStackQueued(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + body, err := io.ReadAll(r.Body) + require.NoError(t, err) + assert.JSONEq(t, `{"style":"merge","wait_for_ci":true}`, string(body)) + w.WriteHeader(http.StatusAccepted) + })) + defer server.Close() + + result, queued, err := MergePullStack(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo", 6, "merge", true) + require.NoError(t, err) + assert.True(t, queued) + assert.Nil(t, result) +} + +func TestMergePullStackPartialFailure(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusConflict) + _, _ = w.Write([]byte(`{"merged":1,"error":"PR #4 is not mergeable"}`)) + })) + defer server.Close() + + result, queued, err := MergePullStack(t.Context(), &config.Login{ + Name: "test", + URL: server.URL, + Token: "secret-token", + }, "owner", "repo", 6, "merge", false) + require.Error(t, err) + assert.Equal(t, "PR #4 is not mergeable", err.Error()) + assert.False(t, queued) + require.NotNil(t, result) + assert.Equal(t, int64(1), result.Merged) +}