Update release ci (#768)

Reviewed-on: https://gitea.com/gitea/tea/pulls/768

.devcontainer/devcontainer.json

@@ -0,0 +1,20 @@
+{
+  "name": "Tea DevContainer",
+  "image": "mcr.microsoft.com/devcontainers/go:1.24-bullseye",
+  "features": {
+    "ghcr.io/devcontainers/features/git-lfs:1.2.4": {}
+  },
+  "customizations": {
+    "vscode": {
+      "settings": {},
+      "extensions": [
+        "editorconfig.editorconfig",
+        "golang.go",
+        "stylelint.vscode-stylelint",
+        "DavidAnson.vscode-markdownlint",
+        "ms-azuretools.vscode-docker",
+        "GitHub.vscode-pull-request-github"
+      ]
+    }
+  }
+}

.dockerignore

@@ -0,0 +1,2 @@
+Dockerfile
+tea

.drone.yml

@@ -1,189 +0,0 @@
----
-kind: pipeline
-name: default
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: build
-  pull: always
-  image: golang:1.15
-  environment:
-      GOPROXY: https://goproxy.cn
-  commands:
-  - make clean
-  - make vet
-  - make lint
-  - make fmt-check
-  - make misspell-check
-  - make test-vendor
-  - make build
-  when:
-    event:
-    - push
-    - tag
-    - pull_request
-
-- name: unit-test
-  image: golang:1.15
-  commands:
-  - make unit-test-coverage
-  settings:
-    group: test
-  when:
-    branch:
-    - master
-    event:
-    - push
-    - pull_request
-
-- name: release-test
-  image: golang:1.15
-  commands:
-  - make test
-  settings:
-    group: test
-  when:
-    branch:
-    - "release/*"
-    event:
-    - push
-    - pull_request
-
-- name: tag-test
-  pull: always
-  image: golang:1.15
-  commands:
-  - make test
-  settings:
-    group: test
-  when:
-    event:
-    - tag
-
-- name: static
-  image: golang:1.15
-  environment:
-    GOPROXY: https://goproxy.cn
-  commands:
-  - export PATH=$PATH:$GOPATH/bin
-  - make release
-  when:
-    event:
-    - push
-    - tag
-
-- name: gpg-sign
-  pull: always
-  image: plugins/gpgsign:1
-  settings:
-    detach_sign: true
-    excludes:
-    - "dist/release/*.sha256"
-    files:
-    - "dist/release/*"
-  environment:
-    GPGSIGN_KEY:
-      from_secret: gpgsign_key
-    GPGSIGN_PASSPHRASE:
-      from_secret: gpgsign_passphrase
-  when:
-    event:
-    - push
-    - tag
-
-- name: tag-release
-  pull: always
-  image: plugins/s3:1
-  settings:
-    acl: public-read
-    bucket: releases
-    endpoint: https://storage.gitea.io
-    path_style: true
-    source: "dist/release/*"
-    strip_prefix: dist/release/
-    target: "/tea/${DRONE_TAG##v}"
-  environment:
-    AWS_ACCESS_KEY_ID:
-      from_secret: aws_access_key_id
-    AWS_SECRET_ACCESS_KEY:
-      from_secret: aws_secret_access_key
-  when:
-    event:
-    - tag
-
-- name: release-branch-release
-  pull: always
-  image: plugins/s3:1
-  settings:
-    acl: public-read
-    bucket: releases
-    endpoint: https://storage.gitea.io
-    path_style: true
-    source: "dist/release/*"
-    strip_prefix: dist/release/
-    target: "/tea/${DRONE_BRANCH##release/v}"
-  environment:
-    AWS_ACCESS_KEY_ID:
-      from_secret: aws_access_key_id
-    AWS_SECRET_ACCESS_KEY:
-      from_secret: aws_secret_access_key
-  when:
-    branch:
-    - "release/*"
-    event:
-    - push
-
-- name: release
-  pull: always
-  image: plugins/s3:1
-  settings:
-    acl: public-read
-    bucket: releases
-    endpoint: https://storage.gitea.io
-    path_style: true
-    source: "dist/release/*"
-    strip_prefix: dist/release/
-    target: /tea/master
-  environment:
-    AWS_ACCESS_KEY_ID:
-      from_secret: aws_access_key_id
-    AWS_SECRET_ACCESS_KEY:
-      from_secret: aws_secret_access_key
-  when:
-    branch:
-    - master
-    event:
-    - push
-
-- name: gitea
-  pull: always
-  image: plugins/gitea-release:1
-  settings:
-    files:
-    - "dist/release/*"
-    base_url: https://gitea.com
-    api_key:
-      from_secret: gitea_token
-  when:
-    event:
-    - tag
-
-- name: discord
-  pull: always
-  image: appleboy/drone-discord:1.0.0
-  environment:
-    DISCORD_WEBHOOK_ID:
-      from_secret: discord_webhook_id
-    DISCORD_WEBHOOK_TOKEN:
-      from_secret: discord_webhook_token
-  when:
-    event:
-    - push
-    - tag
-    - pull_request
-    status:
-    - changed
-    - failure

.envrc

@@ -0,0 +1 @@
+use flake 

.gitea/issue_template/bug.md

@@ -0,0 +1,30 @@
+---
+name: "Bug Report"
+about: "Use this template when reporting a bug, so you don't forget important information we'd ask for later."
+title: "Bug: "
+labels: 
+- kind/bug
+---
+
+### describe your environment
+- tea version used (`tea -v`):
+    - [ ] I also reproduced the issue [with the latest main build](https://dl.gitea.com/tea/main/)
+- Gitea version used:
+    - [ ] the issue only occurred after updating gitea recently
+- operating system:
+- I make use of...
+    - [ ] non-standard default branch names (no `main`,`master`, or `trunk`)
+    - [ ] .ssh/config or .gitconfig host aliases in my git remotes
+    - [ ] ssh_agent or similar
+    - [ ] non-standard ports for gitea and/or ssh
+    - [ ] something else that's likely to interact badly with tea: ...
+
+
+Please provide the output of `git remote -v` (if the issue is related to tea not finding resources on Gitea):
+```
+
+```
+
+### describe the issue (observed vs expected behaviour)
+
+

.gitea/workflows/release-nightly.yml

@@ -0,0 +1,76 @@
+name: goreleaser
+
+on:
+  push:
+    branches: [ main ]
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - run: git fetch --force --tags
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: "go.mod"
+      - name: import gpg
+        id: import_gpg
+        uses: crazy-max/ghaction-import-gpg@v6
+        with:
+          gpg_private_key: ${{ secrets.GPGSIGN_KEY }}
+          passphrase: ${{ secrets.GPGSIGN_PASSPHRASE }}
+      - name: goreleaser
+        uses: goreleaser/goreleaser-action@v6
+        with:
+            distribution: goreleaser-pro
+            version: "~> v1"
+            args: release --nightly
+        env:
+          GORELEASER_KEY: ${{ secrets.GORELEASER_KEY }}
+          AWS_REGION: ${{ secrets.AWS_REGION }}
+          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          S3_REGION: ${{ secrets.AWS_REGION }}
+          S3_BUCKET: ${{ secrets.AWS_BUCKET }}
+          GORELEASER_FORCE_TOKEN: 'gitea'
+          GPGSIGN_PASSPHRASE: ${{ secrets.GPGSIGN_PASSPHRASE }}
+          GPG_FINGERPRINT: ${{ steps.import_gpg.outputs.fingerprint }}
+          GITEA_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+  release-image:
+    runs-on: ubuntu-latest
+    env:
+      DOCKER_ORG: gitea
+      DOCKER_LATEST: nightly
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # all history for all branches and tags
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker BuildX
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        env:
+          ACTIONS_RUNTIME_TOKEN: '' # See https://gitea.com/gitea/act_runner/issues/119
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: |
+            linux/amd64
+            linux/arm64
+          push: true
+          tags: |
+            gitea/tea:latest

.gitea/workflows/release-tag.yml

@@ -0,0 +1,41 @@
+name: goreleaser
+
+on: 
+  push:
+    tags:
+      - '*'
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - run: git fetch --force --tags
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: 'go.mod'
+      - name: import gpg
+        id: import_gpg
+        uses: crazy-max/ghaction-import-gpg@v6
+        with:
+          gpg_private_key: ${{ secrets.GPGSIGN_KEY }}
+          passphrase: ${{ secrets.GPGSIGN_PASSPHRASE }}
+      - name: goreleaser
+        uses: goreleaser/goreleaser-action@v6
+        with:
+            distribution: goreleaser-pro
+            version: "~> v1"
+            args: release
+        env:
+          GORELEASER_KEY: ${{ secrets.GORELEASER_KEY }}
+          AWS_REGION: ${{ secrets.AWS_REGION }}
+          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          S3_REGION: ${{ secrets.AWS_REGION }}
+          S3_BUCKET: ${{ secrets.AWS_BUCKET }}
+          GORELEASER_FORCE_TOKEN: 'gitea'
+          GPGSIGN_PASSPHRASE: ${{ secrets.GPGSIGN_PASSPHRASE }}
+          GPG_FINGERPRINT: ${{ steps.import_gpg.outputs.fingerprint }}
+          GITEA_TOKEN: ${{ secrets.RELEASE_TOKEN }}

.gitea/workflows/test-pr.yml

@@ -0,0 +1,26 @@
+name: check-and-test
+
+on:
+  - pull_request
+
+jobs:
+  check-and-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: 'go.mod'
+      - name: lint and build
+        run: |
+          make clean
+          make vet
+          make lint
+          make fmt-check
+          make misspell-check
+          make docs-check
+          make build
+      - name: test and coverage
+        run: |
+          make test
+          make unit-test-coverage

.gitignore

@@ -1,6 +1,19 @@
-tea
+/tea
 /gitea-vet
+/gitea-vet.exe
 
 .idea/
 .history/
 dist/
+
+.vscode/
+vendor/
+
+coverage.out
+
+dist/
+
+# Nix-specific
+.direnv/
+result
+result-*

.goreleaser.checksum.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+set -e
+
+if [ -z "$1" ]; then
+  echo "usage: $0 <path>"
+  exit 1
+fi
+
+SUM=$(shasum -a 256 "$1" | cut -d' ' -f1)
+BASENAME=$(basename "$1")
+echo -n "${SUM}  ${BASENAME}" > "$1".sha256

.goreleaser.yaml

@@ -0,0 +1,124 @@
+before:
+  hooks:
+    - go mod tidy
+
+builds:
+- env:
+  - CGO_ENABLED=0
+  goos:
+  - darwin
+  - linux
+  - windows
+  - freebsd
+  goarch:
+  - amd64
+  - arm
+  - arm64
+  goarm:
+  - "5"
+  - "6"
+  - "7"
+  ignore:
+    - goos: darwin
+      goarch: arm
+    - goos: darwin
+      goarch: ppc64le
+    - goos: darwin
+      goarch: s390x
+    - goos: windows
+      goarch: ppc64le
+    - goos: windows
+      goarch: s390x
+    - goos: windows
+      goarch: arm
+      goarm: "5"
+    - goos: windows
+      goarch: arm
+      goarm: "6"
+    - goos: windows
+      goarch: arm
+      goarm: "7"
+    - goos: windows
+      goarch: arm64
+    - goos: freebsd
+      goarch: ppc64le
+    - goos: freebsd
+      goarch: s390x
+    - goos: freebsd
+      goarch: arm
+      goarm: "5"
+    - goos: freebsd
+      goarch: arm
+      goarm: "6"
+    - goos: freebsd
+      goarch: arm
+      goarm: "7"
+    - goos: freebsd
+      goarch: arm64
+  flags:
+  - -trimpath
+  ldflags:
+  - -s -w -X main.Version={{ .Version }}
+  binary: >-
+    {{ .ProjectName }}-
+    {{- .Version }}-
+    {{- .Os }}-
+    {{- if eq .Arch "amd64" }}amd64
+    {{- else if eq .Arch "amd64_v1" }}amd64
+    {{- else if eq .Arch "386" }}386
+    {{- else }}{{ .Arch }}{{ end }}
+    {{- if .Arm }}-{{ .Arm }}{{ end }}
+  no_unique_dist_dir: true
+  hooks:
+    post:
+      - cmd: xz -k -9 {{ .Path }}
+        dir: ./dist/
+      - cmd: sh .goreleaser.checksum.sh {{ .Path }}
+      - cmd: sh .goreleaser.checksum.sh {{ .Path }}.xz
+
+blobs:
+  -
+    provider: s3
+    bucket: "{{ .Env.S3_BUCKET }}"
+    region: "{{ .Env.S3_REGION }}"
+    folder: "tea/{{.Version}}"
+    extra_files:
+      - glob: ./**.xz
+      - glob: ./**.sha256
+
+archives:
+  - format: binary
+    name_template: "{{ .Binary }}"
+    allow_different_binary_count: true
+
+checksum:
+  name_template: 'checksums.txt'
+  extra_files:
+      - glob: ./**.xz
+
+force_token: gitea
+
+signs:
+  -
+    signature: "${artifact}.sig"
+    artifacts: checksum
+    stdin: '{{ .Env.GPGSIGN_PASSPHRASE }}'
+    args: ["--batch", "-u", "{{ .Env.GPG_FINGERPRINT }}", "--output", "${signature}", "--detach-sign", "${artifact}"]
+
+snapshot:
+  name_template: "{{ .Branch }}-devel"
+
+nightly:
+  name_template: "{{ .Branch }}"
+
+gitea_urls:
+  api: https://gitea.com/api/v1
+  download: https://gitea.com
+
+release:
+  extra_files:
+    - glob: ./**.xz
+    - glob: ./**.xz.sha256
+
+# yaml-language-server: $schema=https://goreleaser.com/static/schema-pro.json
+# vim: set ts=2 sw=2 tw=0 fo=cnqoj

.revive.toml

@@ -16,7 +16,6 @@ warningCode = 1
 [rule.increment-decrement]
 [rule.var-naming]
 [rule.var-declaration]
-[rule.package-comments]
 [rule.range]
 [rule.receiver-naming]
 [rule.time-naming]

CHANGELOG.md

@@ -1,5 +1,107 @@
 # Changelog
 
+## [v0.9.1](https://gitea.com/gitea/tea/releases/tag/v0.9.1) - 2023-02-15
+
+* BUGFIXES
+  * Print pull dont crash if it has TeamReviewRequests (#517)
+
+## [v0.9.0](https://gitea.com/gitea/tea/releases/tag/v0.9.0) - 2022-09-13
+
+* BREAKING
+  * Rename master branch to main (#495)
+  * Return RFC3339 UTC timestamps for machine-readable output (#470)
+* FEATURES
+  * Allow editing multiline prompts with external text editor (#429)
+  * Add `tea admin user list` (#427)
+  * Add `tea whoami` command (#426)
+  * Add `tea org create <name>` (#420)
+  * Add `tea clone` (#411)
+  * Add `tea repo fork` (#410)
+  * Add `tea repo create-from-template` (#408)
+* BUGFIXES
+  * Fetch all items where needed. (#475)
+  * Fix running in repos without remote (#472)
+  * Add TSV to machine-readable formats (#467)
+  * Fix create milestone with deadline bug (#462)
+  * Fix resolving of URLs in markdown (#401)
+* ENHANCEMENTS
+  * Don't emit ANSI sequences when not emitting to TTY for markdown (#491)
+  * Show more version info (#486)
+  * Add preference `flag_defaults.remote`, refactor (#466)
+  * Add `--fields` to notification & milestone listings (#422)
+  * PR listing: add --fields & expose additional fields (#415)
+  * Add more flags to `tea repo create` (#409)
+  * Implement more issue filters (#400)
+* MISC
+  * Simplify build & update installation instructions (#437)
+  * Clarify command descriptions when no arguments are taken (#496)
+  * Improve Documentation (#433)
+  * Use golang v1.18 and drop vendor folder (#478)
+  * Correct spelling of "wether" to "whether" in usage output (#453)
+
+## [v0.8.0](https://gitea.com/gitea/tea/releases/tag/v0.8.0) - 2021-09-22
+
+* BREAKING
+  * `tea notifications --all` has moved to `tea notifications --mine` (#389)
+  * `tea notifications` now only works with the context of a remote repo. (#389)
+    To run this outside of a local git dir, run either tea n `--mine` or `tea n --repo <my/repo>`
+* FEATURES
+  * Add `tea pr merge` (#348)
+* BUGFIXES
+  * Don't skip reading the local repo when `--repo` specifies a repo slug (#398)
+  * Fix adding login without token on private instances (#392)
+  * Correctly match login by ssh host with port (#391)
+  * Fix printing issue deadline (#388)
+  * Return useful error on wrong sshkey path (#374)
+  * Fix parsing of `--description` for issue/pr create (#371)
+  * Add missing flags (#369)
+  * Check negative limit command parameter (#358) (#359)
+  * Add missing flags to org & labels subcommands (#357)
+* ENHANCEMENTS
+  * Don't require a body for comment PR reviews (#399)
+  * Accept more main branch names for login detection (#396)
+  * Make local repo optional for `tea pr create`(#393)
+  * Notifications Add State Field (#384)
+  * Improve error messages (#370)
+  * Add tab completion for fish shell (#364)
+  * Text editor selection: follow unix defacto standards (#356)
+* MISC
+  * Update Dependencies (#390)
+
+## [v0.7.1](https://gitea.com/gitea/tea/releases/tag/v0.7.1) - 2021-08-27
+
+* BUILD
+  * Enable release builds for darwin/arm64 (#360)
+
+## [v0.7.0](https://gitea.com/gitea/tea/releases/tag/v0.7.0) - 2021-03-12
+
+* BREAKING
+  * `tea issue create`: move `-b` flag to `-d` (#331)
+  * Drop `tea notif` shorthand in favor of `tea n` (#307)
+* FEATURES
+  * Add commands for reviews (#315)
+  * Add `tea comment` and show comments of issues/pulls (#313)
+  * Add interactive mode for `tea milestone create` (#310)
+  * Add command to install shell completion (#309)
+  * Implement PR closing and reopening (#304)
+  * Add interactive mode for `tea issue create` (#302)
+* BUGFIXES
+  * Introduce workaround for missing pull head sha (#340)
+  * Don't exit if we can't find a local repo with a remote matching to a login (#336)
+  * Don't push before creating a pull (#334)
+  * InitCommand() robustness (#327)
+  * `tea comment`: handle piped stdin (#322)
+* ENHANCEMENTS
+  * Allow checking out PRs with deleted head branch (#341)
+  * Markdown renderer: detect terminal width, resolve relative URLs (#332)
+  * Add more issue / pr creation parameters (#331)
+  * Improve `tea time` (#319)
+  * `tea pr checkout`: dont create local branches (#314)
+  * Add `tea issues --fields`, allow printing labels (#312)
+  * Add more command shorthands (#307)
+  * Show PR CI status (#306)
+  * Make PR workflow helpers more robust (#300)
+
 ## [v0.6.0](https://gitea.com/gitea/tea/releases/tag/v0.6.0) - 2020-12-11
 
 * BREAKING

CONTRIBUTING.md

@@ -7,7 +7,6 @@
   - [Bug reports](#bug-reports)
   - [Discuss your design](#discuss-your-design)
   - [Testing redux](#testing-redux)
-  - [Vendoring](#vendoring)
   - [Code review](#code-review)
   - [Styleguide](#styleguide)
   - [Sign-off your work](#sign-off-your-work)
@@ -57,27 +56,13 @@ high-level discussions.
 
 ## Testing redux
 
-Before sending code out for review, run all the test by execting: `make test`
-Since TEA is an cli tool it should be obvious to test your feature localy first.
-
-## Vendoring
-
-We keep a cached copy of dependencies within the `vendor/` directory,
-managing updates via [dep](https://github.com/golang/dep).
-
-Pull requests should only include `vendor/` updates if they are part of
-the same change, be it a bugfix or a feature addition.
-
-The `vendor/` update needs to be justified as part of the PR description,
-and must be verified by the reviewers and/or merger to always reference
-an existing upstream commit.
-
-You can find more information on how to get started with it on the [dep project website](https://golang.github.io/dep/docs/introduction.html).
+Before sending code out for review, run all the test by executing: `make test`
+Since TEA is an cli tool it should be obvious to test your feature locally first.
 
 ## Code review
 
 Changes to TEA must be reviewed before they are accepted—no matter who
-makes the change, even if they are an owner or a maintainer. We use Giteas's
+makes the change, even if they are an owner or a maintainer. We use Gitea's
 pull request & review workflow to do that. Gitea ensure every PR is reviewed by at least 2 maintainers.
 
 Please try to make your pull request easy to review for us. And, please read
@@ -118,8 +103,8 @@ Some of the key points:
 - Always make sure that the help texts are properly set, and as concise as possible.
 
 ### Internal Module Structure
-- `cmd`: only contains comand/flag options for `urfave/cli`
-  - subcomands are in a subpackage named after its parent comand
+- `cmd`: only contains command/flag options for `urfave/cli`
+  - subcommands are in a subpackage named after its parent command
 - `modules/task`: contain func for doing something with gitea
   (e.g. create token by user/passwd)
 - `modules/print`: contain all functions that print to stdout
@@ -175,7 +160,7 @@ maintainers](MAINTAINERS). Every PR **MUST** be reviewed by at least
 two maintainers (or owners) before it can get merged. A maintainer
 should be a contributor of Gitea (or Gogs) and contributed at least
 4 accepted PRs. A contributor should apply as a maintainer in the
-[Discord](https://discord.gg/NsatcWJ) #develop channel. The owners
+[Discord](https://discord.gg/Gitea) #develop channel. The owners
 or the team maintainers may invite the contributor. A maintainer
 should spend some time on code reviews. If a maintainer has no
 time to do that, they should apply to leave the maintainers team
@@ -208,7 +193,7 @@ https://help.github.com/articles/securing-your-account-with-two-factor-authentic
 
 After the election, the new owners should proactively agree
 with our [CONTRIBUTING](CONTRIBUTING.md) requirements in the
-[Discord](https://discord.gg/NsatcWJ) #general channel. Below are the
+[Discord](https://discord.gg/Gitea) #general channel. Below are the
 words to speak:
 
 ```
@@ -236,8 +221,8 @@ Code that you contribute should use the standard copyright header:
 
 ```
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
+
 ```
 
 Files in the repository contain copyright from the year they are added

Dockerfile

@@ -0,0 +1,12 @@
+FROM docker.io/chainguard/go:latest AS build
+COPY . /build/
+WORKDIR /build
+RUN make build && mkdir -p /app/.config/tea
+
+FROM docker.io/chainguard/busybox:latest-glibc
+COPY --from=build /build/tea /bin/tea
+COPY --from=build --chown=65532:65532 /app /app
+VOLUME [ "/app" ]
+ENV HOME="/app"
+ENTRYPOINT ["/bin/sh", "-c"]
+CMD [ "tea" ]

FEATURE-COMPARISON.md

@@ -0,0 +1,63 @@
+# comparing git forge commandline interfaces
+
+[tea]: https://gitea.com/gitea/tea
+[sip]: https://gitea.com/jolheiser/sip
+[gitlab]: https://github.com/makkes/gitlab-cli
+[glab]: https://github.com/profclems/glab
+[gh]: https://cli.github.com
+
+last update: 2020-12-11
+
+## general
+/ | [tea][tea] | [sip][sip] | [gitlab][gitlab] | [gh][gh]
+-----------------------|:-----:|:-----:|:-----:|:-----:
+forge|gitea|gitea|gitlab|github
+official forge support|✓|✘|✘|✓
+dev status|adding features|maintenance||
+platform|any|any|any|any
+
+## philosophy
+/ | [tea][tea] | [sip][sip] | [gitlab][gitlab] | [gh][gh]
+-----------------------|:-----:|:-----:|:-----:|:-----:
+aims to replace git cli|✘|||✓
+works with decentralization in mind|✓|✓|✓|✘
+per-repo setup needed|✘||✓|✘
+workflow helpers|✓|||
+interactive mode |[(✓)](https://gitea.com/gitea/tea/issues?type=all&state=open&labels=&milestone=0&assignee=0&q=interactive)|✘| |✓
+programmatic mode|✓|||✓
+machine readable output|✓|||
+follows XDG spec|✓|||
+
+## features
+/ | [tea][tea] | [sip][sip] | [gitlab][gitlab] | [gh][gh]
+-----------------------|:-----:|:-----:|:-----:|:-----:
+open web UI|✓|||
+search repos|✓|||
+search issues|✘|✓||
+textual item search filter syntax|✘|✓||
+CRUD repos|[(✓)](https://gitea.com/gitea/tea/issues/239)|||
+CRUD issues|[(✓)](https://gitea.com/gitea/tea/issues/229)|||
+CRUD milestones|[(✓)](https://gitea.com/gitea/tea/issues/246)|||
+CRUD releases|✓|||
+CRUD labels|✓|||
+CRUD PRs|✓|||
+CRUD time tracking|✓|||x
+CRUD orgs|[(✓)](https://gitea.com/gitea/tea/issues/287)|||
+create PRs from local repo|✓|||
+create PRs from remote repo|✓|||
+code review|[u](https://gitea.com/gitea/tea/issues/131)|||
+merge PRs||||
+read comments|[u](https://gitea.com/gitea/tea/issues/172)|||
+post comments||||
+manage CI|✘|✘|✓|
+manage notifications|[(✓)]()|||
+administration|[u](https://gitea.com/gitea/tea/issues/161)|✘||✘
+markdown rendering|✓|||✓
+issue import/export|[u](https://gitea.com/gitea/tea/issues/132)|||
+checkout PRs|✓|||
+
+- ✓: supported
+- (✓): partial support
+- u: upcoming
+- ✘: not supported
+- ?: unknown

LICENSE

@@ -1,5 +1,4 @@
 Copyright (c) 2016 The Gitea Authors
-Copyright (c) 2015 The Gogs Authors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,31 +1,12 @@
 DIST := dist
-IMPORT := code.gitea.io/tea
-export GO111MODULE=on
-
 GO ?= go
-SED_INPLACE := sed -i
 SHASUM ?= shasum -a 256
 
 export PATH := $($(GO) env GOPATH)/bin:$(PATH)
 
-ifeq ($(OS), Windows_NT)
-	EXECUTABLE := tea.exe
-else
-	EXECUTABLE := tea
-	UNAME_S := $(shell uname -s)
-	ifeq ($(UNAME_S),Darwin)
-		SED_INPLACE := sed -i ''
-	endif
-endif
-
-GOFILES := $(shell find . -name "*.go" -type f ! -path "./vendor/*" ! -path "*/bindata.go")
+GOFILES := $(shell find . -name "*.go" -type f ! -path "*/bindata.go")
 GOFMT ?= gofmt -s
 
-GOFLAGS := -i -v
-EXTRA_GOFLAGS ?=
-
-MAKE_VERSION := $(shell make -v | head -n 1)
-
 ifneq ($(DRONE_TAG),)
 	VERSION ?= $(subst v,,$(DRONE_TAG))
 	TEA_VERSION ?= $(VERSION)
@@ -33,33 +14,37 @@ else
 	ifneq ($(DRONE_BRANCH),)
 		VERSION ?= $(subst release/v,,$(DRONE_BRANCH))
 	else
-		VERSION ?= master
+		VERSION ?= main
 	endif
 	TEA_VERSION ?= $(shell git describe --tags --always | sed 's/-/+/' | sed 's/^v//')
 endif
-
-LDFLAGS := -X "main.Version=$(TEA_VERSION)" -X "main.Tags=$(TAGS)"
-
-PACKAGES ?= $(shell $(GO) list ./... | grep -v /vendor/)
-SOURCES ?= $(shell find . -name "*.go" -type f)
+TEA_VERSION_TAG ?= $(shell sed 's/+/_/' <<< $(TEA_VERSION))
 
 TAGS ?=
+SDK ?= $(shell $(GO) list -f '{{.Version}}' -m code.gitea.io/sdk/gitea)
+LDFLAGS := -X "code.gitea.io/tea/cmd.Version=$(TEA_VERSION)" -X "code.gitea.io/tea/cmd.Tags=$(TAGS)" -X "code.gitea.io/tea/cmd.SDK=$(SDK)" -s -w
 
+# override to allow passing additional goflags via make CLI
+override GOFLAGS := $(GOFLAGS) -tags '$(TAGS)' -ldflags '$(LDFLAGS)'
+
+PACKAGES ?= $(shell $(GO) list ./...)
+SOURCES ?= $(shell find . -name "*.go" -type f)
+
+# OS specific vars.
 ifeq ($(OS), Windows_NT)
 	EXECUTABLE := tea.exe
+	VET_TOOL := gitea-vet.exe
 else
 	EXECUTABLE := tea
+	VET_TOOL := gitea-vet
 endif
 
-# $(call strip-suffix,filename)
-strip-suffix = $(firstword $(subst ., ,$(1)))
-
 .PHONY: all
 all: build
 
 .PHONY: clean
 clean:
-	$(GO) clean -mod=vendor -i ./...
+	$(GO) clean -i ./...
 	rm -rf $(EXECUTABLE) $(DIST)
 
 .PHONY: fmt
@@ -69,31 +54,22 @@ fmt:
 .PHONY: vet
 vet:
 	# Default vet
-	$(GO) vet -mod=vendor $(PACKAGES)
+	$(GO) vet $(PACKAGES)
 	# Custom vet
-	$(GO) build -mod=vendor code.gitea.io/gitea-vet
-	$(GO) vet -vettool=gitea-vet $(PACKAGES)
+	$(GO) build code.gitea.io/gitea-vet
+	$(GO) vet -vettool=$(VET_TOOL) $(PACKAGES)
 
 .PHONY: lint
-lint:
-	@hash revive > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		cd /tmp && $(GO) get -u github.com/mgechev/revive; \
-	fi
-	revive -config .revive.toml -exclude=./vendor/... ./... || exit 1
+lint: install-lint-tools
+	$(GO) run github.com/mgechev/revive@v1.3.2 -config .revive.toml ./... || exit 1
 
 .PHONY: misspell-check
-misspell-check:
-	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		cd /tmp && $(GO) get -u github.com/client9/misspell/cmd/misspell; \
-	fi
-	misspell -error -i unknwon,destory $(GOFILES)
+misspell-check: install-lint-tools
+	$(GO) run github.com/client9/misspell/cmd/misspell@latest -error -i unknwon,destory $(GOFILES)
 
 .PHONY: misspell
-misspell:
-	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		cd /tmp && $(GO) get -u github.com/client9/misspell/cmd/misspell; \
-	fi
-	misspell -w -i unknwon $(GOFILES)
+misspell: install-lint-tools
+	$(GO) run github.com/client9/misspell/cmd/misspell@latest -w -i unknwon $(GOFILES)
 
 .PHONY: fmt-check
 fmt-check:
@@ -105,61 +81,53 @@ fmt-check:
 		exit 1; \
 	fi;
 
+.PHONY: docs
+docs:
+	$(GO) run docs/docs.go --out docs/CLI.md
+
+.PHONY: docs-check
+docs-check:
+	@DIFF=$$($(GO) run docs/docs.go | diff docs/CLI.md -); \
+	if [ -n "$$DIFF" ]; then \
+		echo "Please run 'make docs' and commit the result:"; \
+		echo "$$DIFF"; \
+		exit 1; \
+	fi;
+
 .PHONY: test
 test:
-	$(GO) test -mod=vendor -tags='sqlite sqlite_unlock_notify' $(PACKAGES)
+	$(GO) test -tags='sqlite sqlite_unlock_notify' $(PACKAGES)
 
 .PHONY: unit-test-coverage
 unit-test-coverage:
-	$(GO) test -mod=vendor -tags='sqlite sqlite_unlock_notify' -cover -coverprofile coverage.out $(PACKAGES) && echo "\n==>\033[32m Ok\033[m\n" || exit 1
+	$(GO) test -tags='sqlite sqlite_unlock_notify' -cover -coverprofile coverage.out $(PACKAGES) && echo "\n==>\033[32m Ok\033[m\n" || exit 1
 
-.PHONY: vendor
-vendor:
-	$(GO) mod tidy && $(GO) mod vendor
-
-.PHONY: test-vendor
-test-vendor: vendor
-	@diff=$$(git diff vendor/); \
-	if [ -n "$$diff" ]; then \
-		echo "Please run 'make vendor' and commit the result:"; \
-		echo "$${diff}"; \
-		exit 1; \
-	fi;
+.PHONY: tidy
+tidy:
+	$(GO) mod tidy
 
 .PHONY: check
 check: test
 
 .PHONY: install
-install: $(wildcard *.go)
-	$(GO) install -mod=vendor -v -tags '$(TAGS)' -ldflags '-s -w $(LDFLAGS)'
+install: $(SOURCES)
+	@echo "installing to $(shell $(GO) env GOPATH)/bin/$(EXECUTABLE)"
+	$(GO) install -v $(BUILDMODE) $(GOFLAGS)
 
 .PHONY: build
 build: $(EXECUTABLE)
 
 $(EXECUTABLE): $(SOURCES)
-	$(GO) build -mod=vendor $(GOFLAGS) $(EXTRA_GOFLAGS) -tags '$(TAGS)' -ldflags '-s -w $(LDFLAGS)' -o $@
+	$(GO) build $(BUILDMODE) $(GOFLAGS) -o $@
 
-.PHONY: release
-release: release-dirs release-os release-compress release-check
+.PHONY: build-image
+build-image:
+	docker build --build-arg VERSION=$(TEA_VERSION) -t gitea/tea:$(TEA_VERSION_TAG) .
 
-.PHONY: release-dirs
-release-dirs:
-	mkdir -p $(DIST)/binaries $(DIST)/release
-
-.PHONY: release-os
-release-os:
-	@hash gox > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		cd /tmp && $(GO) get -u github.com/mitchellh/gox; \
+install-lint-tools:
+	@hash revive > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) install github.com/mgechev/revive@v1.3.2; \
 	fi
-	CGO_ENABLED=0 gox -verbose -cgo=false -tags '$(TAGS)' -ldflags '-s -w $(LDFLAGS)' -osarch='!darwin/386 !darwin/arm64 !darwin/arm' -os="windows linux darwin" -arch="386 amd64 arm arm64" -output="$(DIST)/release/tea-$(VERSION)-{{.OS}}-{{.Arch}}"
-
-.PHONY: release-compress
-release-compress:
-	@hash gxz > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		GO111MODULE=off $(GO) get -u github.com/ulikunitz/xz/cmd/gxz; \
+	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) install github.com/client9/misspell/cmd/misspell@latest; \
 	fi
-	cd $(DIST)/release/; for file in `find . -type f -name "*"`; do echo "compressing $${file}" && gxz -k -9 $${file}; done;
-
-.PHONY: release-check
-release-check:
-	cd $(DIST)/release/; for file in `find . -type f -name "*"`; do echo "checksumming $${file}" && $(SHASUM) `echo $${file} | sed 's/^..//'` > $${file}.sha256; done;

README.md

@@ -1,74 +1,127 @@
-# <img alt='' src='https://gitea.com/repo-avatars/550-80a3a8c2ab0e2c2d69f296b7f8582485' height="40"/> *T E A*
+# <img alt='tea logo' src='https://gitea.com/repo-avatars/550-80a3a8c2ab0e2c2d69f296b7f8582485' height="40"/> *T E A*
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT) [![Release](https://raster.shields.io/badge/dynamic/json.svg?label=release&url=https://gitea.com/api/v1/repos/gitea/tea/releases&query=$[0].tag_name)](https://gitea.com/gitea/tea/releases) [![Build Status](https://drone.gitea.com/api/badges/gitea/tea/status.svg)](https://drone.gitea.com/gitea/tea) [![Join the chat at https://img.shields.io/discord/322538954119184384.svg](https://img.shields.io/discord/322538954119184384.svg)](https://discord.gg/Gitea) [![Go Report Card](https://goreportcard.com/badge/code.gitea.io/tea)](https://goreportcard.com/report/code.gitea.io/tea) [![GoDoc](https://godoc.org/code.gitea.io/tea?status.svg)](https://godoc.org/code.gitea.io/tea)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Release](https://raster.shields.io/badge/dynamic/json.svg?label=release&url=https://gitea.com/api/v1/repos/gitea/tea/releases&query=$[0].tag_name)](https://gitea.com/gitea/tea/releases)
+[![Join the chat at https://img.shields.io/discord/322538954119184384.svg](https://img.shields.io/discord/322538954119184384.svg)](https://discord.gg/Gitea)
+[![Go Report Card](https://goreportcard.com/badge/code.gitea.io/tea)](https://goreportcard.com/report/code.gitea.io/tea) [![GoDoc](https://pkg.go.dev/badge/code.gitea.io/tea?status.svg)](https://godoc.org/code.gitea.io/tea)
+![Tea Release Status](https://gitea.com/gitea/tea/actions/workflows/release-nightly.yml/badge.svg)
 
-## The official CLI interface for gitea
+## The official CLI for Gitea
 
-Tea is a command line tool for interacting on one or more Gitea instances.
-It uses [code.gitea.io/sdk](https://code.gitea.io/sdk) and interacts with the Gitea API
+![demo gif](./demo.gif)
 
-![demo gif](https://dl.gitea.io/screenshots/tea_demo.gif)
+```
+   tea - command line tool to interact with Gitea
+   version 0.8.0-preview
+
+ USAGE
+   tea command [subcommand] [command options] [arguments...]
+
+ DESCRIPTION
+   tea is a productivity helper for Gitea. It can be used to manage most entities on
+   one or multiple Gitea instances & provides local helpers like 'tea pr checkout'.
+   
+   tea tries to make use of context provided by the repository in $PWD if available.
+   tea works best in a upstream/fork workflow, when the local main branch tracks the
+   upstream repo. tea assumes that local git state is published on the remote before
+   doing operations with tea.    Configuration is persisted in $XDG_CONFIG_HOME/tea.
+
+ COMMANDS
+   help, h  Shows a list of commands or help for one command
+   ENTITIES:
+     issues, issue, i                    List, create and update issues
+     pulls, pull, pr                     Manage and checkout pull requests
+     labels, label                       Manage issue labels
+     milestones, milestone, ms           List and create milestones
+     releases, release, r                Manage releases
+     release assets, release asset, r a  Manage release attachments
+     times, time, t                      Operate on tracked times of a repository's issues & pulls
+     organizations, organization, org    List, create, delete organizations
+     repos, repo                         Show repository details
+     comment, c                          Add a comment to an issue / pr
+   HELPERS:
+     open, o                         Open something of the repository in web browser
+     notifications, notification, n  Show notifications
+     clone, C                        Clone a repository locally
+   SETUP:
+     logins, login                  Log in to a Gitea server
+     logout                         Log out from a Gitea server
+     shellcompletion, autocomplete  Install shell completion for tea
+     whoami                         Show current logged in user
+
+ OPTIONS
+   --help, -h     show help (default: false)
+   --version, -v  print the version (default: false)
+
+ EXAMPLES
+   tea login add                       # add a login once to get started
+
+   tea pulls                           # list open pulls for the repo in $PWD
+   tea pulls --repo $HOME/foo          # list open pulls for the repo in $HOME/foo
+   tea pulls --remote upstream         # list open pulls for the repo pointed at by
+                                       # your local "upstream" git remote
+   # list open pulls for any gitea repo at the given login instance
+   tea pulls --repo gitea/tea --login gitea.com
+
+   tea milestone issues 0.7.0          # view open issues for milestone '0.7.0'
+   tea issue 189                       # view contents of issue 189
+   tea open 189                        # open web ui for issue 189
+   tea open milestones                 # open web ui for milestones
+
+   # send gitea desktop notifications every 5 minutes (bash + libnotify)
+   while :; do tea notifications --mine -o simple | xargs -i notify-send {}; sleep 300; done
+
+ ABOUT
+   Written & maintained by The Gitea Authors.
+   If you find a bug or want to contribute, we'll welcome you at https://gitea.com/gitea/tea.
+   More info about Gitea itself on https://about.gitea.com.
+```
+
+- [Compare features with other git forge CLIs](./FEATURE-COMPARISON.md)
+- tea uses [code.gitea.io/sdk](https://code.gitea.io/sdk) and interacts with the Gitea API.
 
 ## Installation
 
-You can use the prebuilt binaries from [dl.gitea.io](https://dl.gitea.io/tea/)
-
-To install from source, go 1.13 or newer is required:
+There are different ways to get `tea`:
 
+1. Install via your system package manager:
+    - macOS via `brew` (official):
       ```sh
-go get code.gitea.io/tea
-go install code.gitea.io/tea
-```
-
-If you have `brew` installed, you can install `tea` via:
-
-```sh
-brew tap gitea/tap https://gitea.com/gitea/homebrew-gitea
       brew install tea
       ```
+    - arch linux ([gitea-tea-git](https://aur.archlinux.org/packages/gitea-tea-git), thirdparty)
+    - alpine linux ([tea](https://pkgs.alpinelinux.org/packages?name=tea&branch=edge), thirdparty)
+    - Windows via `MSYS2` ([tea](https://packages.msys2.org/base/mingw-w64-tea), thirdparty)
 
-Distribution packages exist for: **alpinelinux ([tea](https://pkgs.alpinelinux.org/packages?name=tea&branch=edge))** and **archlinux ([gitea-tea](https://aur.archlinux.org/packages/gitea-tea))**
+2. Use the prebuilt binaries from [dl.gitea.com](https://dl.gitea.com/tea/)
 
-## Usage
+3. Install from source: [see *Compilation*](#compilation)
 
-First of all, you have to create a token on your `personal settings -> application` page of your gitea instance.
-Use this token to login with `tea`:
+4. Docker (thirdparty): [tgerczei/tea](https://hub.docker.com/r/tgerczei/tea)
 
-```sh
-tea login add --name=try --url=https://try.gitea.io --token=xxxxxx
-```
-
-Now you can use the following `tea` subcommands.
-Detailed usage information is available via `tea <command> --help`.
-
-```none
-login            Log in to a Gitea server
-logout           Log out from a Gitea server
-issues           List, create and update issues
-pulls            List, create, checkout and clean pull requests
-releases         List, create, update and delete releases
-repos            Operate with repositories
-labels           Manage issue labels
-times            Operate on tracked times of a repositorys issues and pulls
-open             Open something of the repository on web browser
-notifications    Show notifications
-milestones       List and create milestones
-organizations    List, create, delete organizations
-help, h          Shows a list of commands or help for one command
-```
-
-To fetch issues from different repos, use the `--remote` flag (when inside a gitea repository directory) or `--login` & `--repo` flags.
+5. asdf (thirdparty): [mvaldes14/asdf-tea](https://github.com/mvaldes14/asdf-tea)
 
 ## Compilation
 
-Make sure you have installed a current go version.
-To compile the sources yourself run the following:
+Make sure you have a current go version installed (1.13 or newer).
 
+- To compile the source yourself with the recommended flags & tags:
   ```sh
-git clone https://gitea.com/gitea/tea.git
+  git clone https://gitea.com/gitea/tea.git # or: tea clone gitea.com/gitea/tea ;)
   cd tea
   make
   ```
+  Note that GNU Make (gmake on OpenBSD) is required.
+  If you want to install the compiled program you have to execute the following command:
+  ```sh
+  make install
+  ```
+  This installs the binary into the "bin" folder inside of your GOPATH folder (`go env GOPATH`). It is possible that this folder isn't in your PATH Environment Variable. 
+
+- For a quick installation without `git` & `make`, set $version and exec:
+  ```sh
+  go install code.gitea.io/tea@${version}
+  ```
 
 ## Contributing
 
@@ -76,7 +129,6 @@ Fork -> Patch -> Push -> Pull Request
 
 - `make test` run testsuite
 - `make vet`  run checks (check the order of imports; preventing failure on CI pipeline beforehand)
-- `make vendor` when adding new dependencies
 - ... (for other development tasks, check the `Makefile`)
 
 **Please** read the [CONTRIBUTING](CONTRIBUTING.md) documentation, it will tell you about internal structures and concepts.

build.go

@@ -1,6 +1,7 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
+
+//go:build vendor
 // +build vendor
 
 package main

cmd/admin.go

@@ -0,0 +1,56 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	stdctx "context"
+
+	"code.gitea.io/tea/cmd/admin/users"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdAdmin represents the namespace of admin commands.
+// The command itself has no functionality, but hosts subcommands.
+var CmdAdmin = cli.Command{
+	Name:     "admin",
+	Usage:    "Operations requiring admin access on the Gitea instance",
+	Aliases:  []string{"a"},
+	Category: catMisc,
+	Action: func(_ stdctx.Context, cmd *cli.Command) error {
+		return cli.ShowSubcommandHelp(cmd)
+	},
+	Commands: []*cli.Command{
+		&cmdAdminUsers,
+	},
+}
+
+var cmdAdminUsers = cli.Command{
+	Name:    "users",
+	Aliases: []string{"u"},
+	Usage:   "Manage registered users",
+	Action: func(ctx stdctx.Context, cmd *cli.Command) error {
+		if cmd.Args().Len() == 1 {
+			return runAdminUserDetail(ctx, cmd, cmd.Args().First())
+		}
+		return users.RunUserList(ctx, cmd)
+	},
+	Commands: []*cli.Command{
+		&users.CmdUserList,
+	},
+	Flags: users.CmdUserList.Flags,
+}
+
+func runAdminUserDetail(_ stdctx.Context, cmd *cli.Command, u string) error {
+	ctx := context.InitCommand(cmd)
+	client := ctx.Login.Client()
+	user, _, err := client.GetUserInfo(u)
+	if err != nil {
+		return err
+	}
+
+	print.UserDetails(user)
+	return nil
+}

cmd/admin/users/list.go

@@ -0,0 +1,55 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package users
+
+import (
+	stdctx "context"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+var userFieldsFlag = flags.FieldsFlag(print.UserFields, []string{
+	"id", "login", "full_name", "email", "activated",
+})
+
+// CmdUserList represents a sub command of users to list users
+var CmdUserList = cli.Command{
+	Name:        "list",
+	Aliases:     []string{"ls"},
+	Usage:       "List Users",
+	Description: "List users",
+	Action:      RunUserList,
+	Flags: append([]cli.Flag{
+		userFieldsFlag,
+		&flags.PaginationPageFlag,
+		&flags.PaginationLimitFlag,
+	}, flags.AllDefaultFlags...),
+}
+
+// RunUserList list users
+func RunUserList(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+
+	fields, err := userFieldsFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
+
+	client := ctx.Login.Client()
+	users, _, err := client.AdminListUsers(gitea.AdminListUsersOptions{
+		ListOptions: ctx.GetListOptions(),
+	})
+	if err != nil {
+		return err
+	}
+
+	print.UserList(users, ctx.Output, fields)
+
+	return nil
+}

cmd/attachments.go

@@ -0,0 +1,28 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	"code.gitea.io/tea/cmd/attachments"
+	"code.gitea.io/tea/cmd/flags"
+
+	"github.com/urfave/cli/v3"
+)
+
+// CmdReleaseAttachments represents a release attachment (file attachment)
+var CmdReleaseAttachments = cli.Command{
+	Name:        "assets",
+	Aliases:     []string{"asset", "a"},
+	Category:    catEntities,
+	Usage:       "Manage release assets",
+	Description: "Manage release assets",
+	ArgsUsage:   " ", // command does not accept arguments
+	Action:      attachments.RunReleaseAttachmentList,
+	Commands: []*cli.Command{
+		&attachments.CmdReleaseAttachmentList,
+		&attachments.CmdReleaseAttachmentCreate,
+		&attachments.CmdReleaseAttachmentDelete,
+	},
+	Flags: flags.AllDefaultFlags,
+}

cmd/attachments/create.go

@@ -0,0 +1,65 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package attachments
+
+import (
+	stdctx "context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+
+	"github.com/urfave/cli/v3"
+)
+
+// CmdReleaseAttachmentCreate represents a sub command of Release Attachments to create a release attachment
+var CmdReleaseAttachmentCreate = cli.Command{
+	Name:        "create",
+	Aliases:     []string{"c"},
+	Usage:       "Create one or more release attachments",
+	Description: `Create one or more release attachments`,
+	ArgsUsage:   "<release-tag> <asset> [<asset>...]",
+	Action:      runReleaseAttachmentCreate,
+	Flags:       flags.AllDefaultFlags,
+}
+
+func runReleaseAttachmentCreate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
+
+	if ctx.Args().Len() < 2 {
+		return fmt.Errorf("No release tag or assets specified.\nUsage:\t%s", ctx.Command.UsageText)
+	}
+
+	tag := ctx.Args().First()
+	if len(tag) == 0 {
+		return fmt.Errorf("Release tag needed to create attachment")
+	}
+
+	release, err := getReleaseByTag(ctx.Owner, ctx.Repo, tag, client)
+	if err != nil {
+		return err
+	}
+
+	for _, asset := range ctx.Args().Slice()[1:] {
+		var file *os.File
+		if file, err = os.Open(asset); err != nil {
+			return err
+		}
+
+		filePath := filepath.Base(asset)
+
+		if _, _, err = ctx.Login.Client().CreateReleaseAttachment(ctx.Owner, ctx.Repo, release.ID, file, filePath); err != nil {
+			file.Close()
+			return err
+		}
+
+		file.Close()
+	}
+
+	return nil
+}

cmd/attachments/delete.go

@@ -0,0 +1,101 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package attachments
+
+import (
+	stdctx "context"
+	"fmt"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdReleaseAttachmentDelete represents a sub command of Release Attachments to delete a release attachment
+var CmdReleaseAttachmentDelete = cli.Command{
+	Name:        "delete",
+	Aliases:     []string{"rm"},
+	Usage:       "Delete one or more release attachments",
+	Description: `Delete one or more release attachments`,
+	ArgsUsage:   "<release tag> <attachment name> [<attachment name>...]",
+	Action:      runReleaseAttachmentDelete,
+	Flags: append([]cli.Flag{
+		&cli.BoolFlag{
+			Name:    "confirm",
+			Aliases: []string{"y"},
+			Usage:   "Confirm deletion (required)",
+		},
+	}, flags.AllDefaultFlags...),
+}
+
+func runReleaseAttachmentDelete(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
+
+	if ctx.Args().Len() < 2 {
+		return fmt.Errorf("No release tag or attachment names specified.\nUsage:\t%s", ctx.Command.UsageText)
+	}
+
+	tag := ctx.Args().First()
+	if len(tag) == 0 {
+		return fmt.Errorf("Release tag needed to delete attachment")
+	}
+
+	if !ctx.Bool("confirm") {
+		fmt.Println("Are you sure? Please confirm with -y or --confirm.")
+		return nil
+	}
+
+	release, err := getReleaseByTag(ctx.Owner, ctx.Repo, tag, client)
+	if err != nil {
+		return err
+	}
+
+	existing, _, err := client.ListReleaseAttachments(ctx.Owner, ctx.Repo, release.ID, gitea.ListReleaseAttachmentsOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
+	})
+	if err != nil {
+		return err
+	}
+
+	for _, name := range ctx.Args().Slice()[1:] {
+		var attachment *gitea.Attachment
+		for _, a := range existing {
+			if a.Name == name {
+				attachment = a
+			}
+		}
+		if attachment == nil {
+			return fmt.Errorf("Release does not have attachment named '%s'", name)
+		}
+
+		_, err = client.DeleteReleaseAttachment(ctx.Owner, ctx.Repo, release.ID, attachment.ID)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func getReleaseAttachmentByName(owner, repo string, release int64, name string, client *gitea.Client) (*gitea.Attachment, error) {
+	al, _, err := client.ListReleaseAttachments(owner, repo, release, gitea.ListReleaseAttachmentsOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
+	})
+	if err != nil {
+		return nil, err
+	}
+	if len(al) == 0 {
+		return nil, fmt.Errorf("Release does not have any attachments")
+	}
+	for _, a := range al {
+		if a.Name == name {
+			return a, nil
+		}
+	}
+	return nil, fmt.Errorf("Attachment does not exist")
+}

cmd/attachments/list.go

@@ -0,0 +1,75 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package attachments
+
+import (
+	stdctx "context"
+	"fmt"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdReleaseAttachmentList represents a sub command of release attachment to list release attachments
+var CmdReleaseAttachmentList = cli.Command{
+	Name:        "list",
+	Aliases:     []string{"ls"},
+	Usage:       "List Release Attachments",
+	Description: "List Release Attachments",
+	ArgsUsage:   "<release-tag>", // command does not accept arguments
+	Action:      RunReleaseAttachmentList,
+	Flags: append([]cli.Flag{
+		&flags.PaginationPageFlag,
+		&flags.PaginationLimitFlag,
+	}, flags.AllDefaultFlags...),
+}
+
+// RunReleaseAttachmentList list release attachments
+func RunReleaseAttachmentList(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
+
+	tag := ctx.Args().First()
+	if len(tag) == 0 {
+		return fmt.Errorf("Release tag needed to list attachments")
+	}
+
+	release, err := getReleaseByTag(ctx.Owner, ctx.Repo, tag, client)
+	if err != nil {
+		return err
+	}
+
+	attachments, _, err := ctx.Login.Client().ListReleaseAttachments(ctx.Owner, ctx.Repo, release.ID, gitea.ListReleaseAttachmentsOptions{
+		ListOptions: ctx.GetListOptions(),
+	})
+	if err != nil {
+		return err
+	}
+
+	print.ReleaseAttachmentsList(attachments, ctx.Output)
+	return nil
+}
+
+func getReleaseByTag(owner, repo, tag string, client *gitea.Client) (*gitea.Release, error) {
+	rl, _, err := client.ListReleases(owner, repo, gitea.ListReleasesOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
+	})
+	if err != nil {
+		return nil, err
+	}
+	if len(rl) == 0 {
+		return nil, fmt.Errorf("Repo does not have any release")
+	}
+	for _, r := range rl {
+		if r.TagName == tag {
+			return r, nil
+		}
+	}
+	return nil, fmt.Errorf("Release tag does not exist")
+}

cmd/autocomplete.go

@@ -0,0 +1,138 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+
+	"github.com/adrg/xdg"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdAutocomplete manages autocompletion
+var CmdAutocomplete = cli.Command{
+	Name:        "shellcompletion",
+	Aliases:     []string{"autocomplete"},
+	Category:    catSetup,
+	Usage:       "Install shell completion for tea",
+	Description: "Install shell completion for tea",
+	ArgsUsage:   "<shell type> (bash, zsh, powershell, fish)",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "install",
+			Usage: "Persist in shell config instead of printing commands",
+		},
+	},
+	Action: runAutocompleteAdd,
+}
+
+func runAutocompleteAdd(_ context.Context, cmd *cli.Command) error {
+	var remoteFile, localFile, cmds string
+	shell := cmd.Args().First()
+
+	switch shell {
+	case "zsh":
+		remoteFile = "contrib/autocomplete.zsh"
+		localFile = "autocomplete.zsh"
+		cmds = "echo 'PROG=tea _CLI_ZSH_AUTOCOMPLETE_HACK=1 source \"%s\"' >> ~/.zshrc && source ~/.zshrc"
+
+	case "bash":
+		remoteFile = "contrib/autocomplete.sh"
+		localFile = "autocomplete.sh"
+		cmds = "echo 'PROG=tea source \"%s\"' >> ~/.bashrc && source ~/.bashrc"
+
+	case "powershell":
+		remoteFile = "contrib/autocomplete.ps1"
+		localFile = "tea.ps1"
+		cmds = "\"& %s\" >> $profile"
+
+	case "fish":
+		// fish is different, in that urfave/cli provides a generator for the shell script needed.
+		// this also means that the fish completion can become out of sync with the tea binary!
+		// writing to this directory suffices, as fish reads files there on startup, no cmds needed.
+		return writeFishAutoCompleteFile(cmd)
+
+	default:
+		return fmt.Errorf("Must specify valid %s", cmd.ArgsUsage)
+	}
+
+	localPath, err := xdg.ConfigFile("tea/" + localFile)
+	if err != nil {
+		return err
+	}
+
+	cmds = fmt.Sprintf(cmds, localPath)
+	if err = writeRemoteAutoCompleteFile(remoteFile, localPath); err != nil {
+		return err
+	}
+
+	if cmd.Bool("install") {
+		fmt.Println("Installing in your shellrc")
+		installer := exec.Command(shell, "-c", cmds)
+		if shell == "powershell" {
+			installer = exec.Command("powershell.exe", "-Command", cmds)
+		}
+		out, err := installer.CombinedOutput()
+		if err != nil {
+			return fmt.Errorf("Couldn't run the commands: %s %s", err, out)
+		}
+	} else {
+		fmt.Println("\n# Run the following commands to install autocompletion (or use --install)")
+		fmt.Println(cmds)
+	}
+
+	return nil
+}
+
+func writeRemoteAutoCompleteFile(file, destPath string) error {
+	url := fmt.Sprintf("https://gitea.com/gitea/tea/raw/branch/master/%s", file)
+	fmt.Println("Fetching " + url)
+
+	res, err := http.Get(url)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	writer, err := os.Create(destPath)
+	if err != nil {
+		return err
+	}
+	defer writer.Close()
+
+	_, err = io.Copy(writer, res.Body)
+	return err
+}
+
+func writeFishAutoCompleteFile(cmd *cli.Command) error {
+	// NOTE: to make sure this file is in sync with tea commands, we'd need to
+	//   - check if the file exists
+	//   - if it does, check if the tea version that wrote it is the currently running version
+	//   - if not, rewrite the file
+	//   on each application run
+	// NOTE: this generates a completion that also suggests file names, which looks kinda messy..
+	script, err := cmd.ToFishCompletion()
+	if err != nil {
+		return err
+	}
+
+	localPath, err := xdg.ConfigFile("fish/conf.d/tea_completion.fish")
+	if err != nil {
+		return err
+	}
+	writer, err := os.Create(localPath)
+	if err != nil {
+		return err
+	}
+	if _, err = io.WriteString(writer, script); err != nil {
+		return err
+	}
+	fmt.Printf("Installed tab completion to %s\n", localPath)
+	return nil
+}

cmd/branches.go

@@ -0,0 +1,38 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	"context"
+
+	"code.gitea.io/tea/cmd/branches"
+
+	"github.com/urfave/cli/v3"
+)
+
+// CmdBranches represents to login a gitea server.
+var CmdBranches = cli.Command{
+	Name:        "branches",
+	Aliases:     []string{"branch", "b"},
+	Category:    catEntities,
+	Usage:       "Consult branches",
+	Description: `Lists branches when called without argument. If a branch is provided, will show it in detail.`,
+	ArgsUsage:   "[<branch name>]",
+	Action:      runBranches,
+	Commands: []*cli.Command{
+		&branches.CmdBranchesList,
+		&branches.CmdBranchesProtect,
+		&branches.CmdBranchesUnprotect,
+	},
+	Flags: append([]cli.Flag{
+		&cli.BoolFlag{
+			Name:  "comments",
+			Usage: "Whether to display comments (will prompt if not provided & run interactively)",
+		},
+	}, branches.CmdBranchesList.Flags...),
+}
+
+func runBranches(ctx context.Context, cmd *cli.Command) error {
+	return branches.RunBranchesList(ctx, cmd)
+}

cmd/branches/list.go

@@ -0,0 +1,75 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package branches
+
+import (
+	stdctx "context"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+var branchFieldsFlag = flags.FieldsFlag(print.BranchFields, []string{
+	"name", "protected", "user-can-merge", "user-can-push",
+})
+
+// CmdBranchesListFlags Flags for command list
+var CmdBranchesListFlags = append([]cli.Flag{
+	branchFieldsFlag,
+	&flags.PaginationPageFlag,
+	&flags.PaginationLimitFlag,
+}, flags.AllDefaultFlags...)
+
+// CmdBranchesList represents a sub command of branches to list branches
+var CmdBranchesList = cli.Command{
+	Name:        "list",
+	Aliases:     []string{"ls"},
+	Usage:       "List branches of the repository",
+	Description: `List branches of the repository`,
+	ArgsUsage:   " ", // command does not accept arguments
+	Action:      RunBranchesList,
+	Flags:       CmdBranchesListFlags,
+}
+
+// RunBranchesList list branches
+func RunBranchesList(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+
+	owner := ctx.Owner
+	if ctx.IsSet("owner") {
+		owner = ctx.String("owner")
+	}
+
+	var branches []*gitea.Branch
+	var protections []*gitea.BranchProtection
+	var err error
+	branches, _, err = ctx.Login.Client().ListRepoBranches(owner, ctx.Repo, gitea.ListRepoBranchesOptions{
+		ListOptions: ctx.GetListOptions(),
+	})
+
+	if err != nil {
+		return err
+	}
+
+	protections, _, err = ctx.Login.Client().ListBranchProtections(owner, ctx.Repo, gitea.ListBranchProtectionsOptions{
+		ListOptions: ctx.GetListOptions(),
+	})
+
+	if err != nil {
+		return err
+	}
+
+	fields, err := branchFieldsFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
+
+	print.BranchesList(branches, protections, ctx.Output, fields)
+	return nil
+}

cmd/branches/protect.go

@@ -0,0 +1,102 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package branches
+
+import (
+	stdctx "context"
+	"fmt"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdBranchesProtectFlags Flags for command protect/unprotect
+var CmdBranchesProtectFlags = append([]cli.Flag{
+	branchFieldsFlag,
+	&flags.PaginationPageFlag,
+	&flags.PaginationLimitFlag,
+}, flags.AllDefaultFlags...)
+
+// CmdBranchesProtect represents a sub command of branches to protect a branch
+var CmdBranchesProtect = cli.Command{
+	Name:        "protect",
+	Aliases:     []string{"P"},
+	Usage:       "Protect branches",
+	Description: `Block actions push/merge on specified branches`,
+	ArgsUsage:   "<branch>",
+	Action:      RunBranchesProtect,
+	Flags:       CmdBranchesProtectFlags,
+}
+
+// CmdBranchesUnprotect represents a sub command of branches to protect a branch
+var CmdBranchesUnprotect = cli.Command{
+	Name:        "unprotect",
+	Aliases:     []string{"U"},
+	Usage:       "Unprotect branches",
+	Description: `Suppress existing protections on specified branches`,
+	ArgsUsage:   "<branch>",
+	Action:      RunBranchesProtect,
+	Flags:       CmdBranchesProtectFlags,
+}
+
+// RunBranchesProtect function to protect/unprotect a list of branches
+func RunBranchesProtect(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+
+	if !cmd.Args().Present() {
+		return fmt.Errorf("must specify at least one branch")
+	}
+
+	owner := ctx.Owner
+	if ctx.IsSet("owner") {
+		owner = ctx.String("owner")
+	}
+
+	for _, branch := range ctx.Args().Slice() {
+
+		var err error
+		command := ctx.Command.Name
+		if command == "protect" {
+			_, _, err = ctx.Login.Client().CreateBranchProtection(owner, ctx.Repo, gitea.CreateBranchProtectionOption{
+				BranchName:                    branch,
+				RuleName:                      "",
+				EnablePush:                    false,
+				EnablePushWhitelist:           false,
+				PushWhitelistUsernames:        []string{},
+				PushWhitelistTeams:            []string{},
+				PushWhitelistDeployKeys:       false,
+				EnableMergeWhitelist:          false,
+				MergeWhitelistUsernames:       []string{},
+				MergeWhitelistTeams:           []string{},
+				EnableStatusCheck:             false,
+				StatusCheckContexts:           []string{},
+				RequiredApprovals:             1,
+				EnableApprovalsWhitelist:      false,
+				ApprovalsWhitelistUsernames:   []string{},
+				ApprovalsWhitelistTeams:       []string{},
+				BlockOnRejectedReviews:        false,
+				BlockOnOfficialReviewRequests: false,
+				BlockOnOutdatedBranch:         false,
+				DismissStaleApprovals:         false,
+				RequireSignedCommits:          false,
+				ProtectedFilePatterns:         "",
+				UnprotectedFilePatterns:       "",
+			})
+		} else if command == "unprotect" {
+			_, err = ctx.Login.Client().DeleteBranchProtection(owner, ctx.Repo, branch)
+		} else {
+			return fmt.Errorf("command %s is not supported", command)
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

cmd/categories.go

@@ -0,0 +1,11 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+var (
+	catSetup    = "SETUP"
+	catEntities = "ENTITIES"
+	catHelpers  = "HELPERS"
+	catMisc     = "MISCELLANEOUS"
+)

cmd/clone.go

@@ -0,0 +1,89 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	stdctx "context"
+	"fmt"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/git"
+	"code.gitea.io/tea/modules/interact"
+	"code.gitea.io/tea/modules/task"
+	"code.gitea.io/tea/modules/utils"
+
+	"github.com/urfave/cli/v3"
+)
+
+// CmdRepoClone represents a sub command of repos to create a local copy
+var CmdRepoClone = cli.Command{
+	Name:    "clone",
+	Aliases: []string{"C"},
+	Usage:   "Clone a repository locally",
+	Description: `Clone a repository locally, without a local git installation required.
+The repo slug can be specified in different formats:
+	gitea/tea
+	tea
+	gitea.com/gitea/tea
+	git@gitea.com:gitea/tea
+	https://gitea.com/gitea/tea
+	ssh://gitea.com:22/gitea/tea
+When a host is specified in the repo-slug, it will override the login specified with --login.
+	`,
+	Category:  catHelpers,
+	Action:    runRepoClone,
+	ArgsUsage: "<repo-slug> [target dir]",
+	Flags: []cli.Flag{
+		&cli.IntFlag{
+			Name:    "depth",
+			Aliases: []string{"d"},
+			Usage:   "num commits to fetch, defaults to all",
+		},
+		&flags.LoginFlag,
+	},
+}
+
+func runRepoClone(ctx stdctx.Context, cmd *cli.Command) error {
+	teaCmd := context.InitCommand(cmd)
+
+	args := teaCmd.Args()
+	if args.Len() < 1 {
+		return cli.ShowCommandHelp(ctx, cmd, "clone")
+	}
+	dir := args.Get(1)
+
+	var (
+		login *config.Login = teaCmd.Login
+		owner string        = teaCmd.Login.User
+		repo  string
+	)
+
+	// parse first arg as repo specifier
+	repoSlug := args.Get(0)
+	url, err := git.ParseURL(repoSlug)
+	if err != nil {
+		return err
+	}
+
+	owner, repo = utils.GetOwnerAndRepo(url.Path, login.User)
+	if url.Host != "" {
+		login = config.GetLoginByHost(url.Host)
+		if login == nil {
+			return fmt.Errorf("No login configured matching host '%s', run `tea login add` first", url.Host)
+		}
+	}
+
+	_, err = task.RepoClone(
+		dir,
+		login,
+		owner,
+		repo,
+		interact.PromptPassword,
+		teaCmd.Int("depth"),
+	)
+
+	return err
+}

cmd/cmd.go

@@ -0,0 +1,133 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+// Tea is command line tool for Gitea.
+package cmd // import "code.gitea.io/tea"
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+
+	"github.com/urfave/cli/v3"
+)
+
+// Version holds the current tea version
+var Version = "development"
+
+// Tags holds the build tags used
+var Tags = ""
+
+// SDK holds the sdk version from go.mod
+var SDK = ""
+
+// App creates and returns a tea Command with all subcommands set
+// it was separated from main so docs can be generated for it
+func App() *cli.Command {
+	// make parsing tea --version easier, by printing /just/ the version string
+	cli.VersionPrinter = func(c *cli.Command) { fmt.Fprintln(c.Writer, c.Version) }
+
+	return &cli.Command{
+		Name:               "tea",
+		Usage:              "command line tool to interact with Gitea",
+		Description:        appDescription,
+		CustomHelpTemplate: helpTemplate,
+		Version:            formatVersion(),
+		Commands: []*cli.Command{
+			&CmdLogin,
+			&CmdLogout,
+			&CmdAutocomplete,
+			&CmdWhoami,
+
+			&CmdIssues,
+			&CmdPulls,
+			&CmdLabels,
+			&CmdMilestones,
+			&CmdReleases,
+			&CmdTrackedTimes,
+			&CmdOrgs,
+			&CmdRepos,
+			&CmdBranches,
+			&CmdAddComment,
+
+			&CmdOpen,
+			&CmdNotifications,
+			&CmdRepoClone,
+
+			&CmdAdmin,
+		},
+		EnableShellCompletion: true,
+	}
+}
+
+func formatVersion() string {
+	version := fmt.Sprintf("Version: %s\tgolang: %s",
+		bold(Version),
+		strings.ReplaceAll(runtime.Version(), "go", ""))
+
+	if len(Tags) != 0 {
+		version += fmt.Sprintf("\tbuilt with: %s", strings.Replace(Tags, " ", ", ", -1))
+	}
+
+	if len(SDK) != 0 {
+		version += fmt.Sprintf("\tgo-sdk: %s", SDK)
+	}
+
+	return version
+}
+
+var appDescription = `tea is a productivity helper for Gitea. It can be used to manage most entities on
+one or multiple Gitea instances & provides local helpers like 'tea pr checkout'.
+
+tea tries to make use of context provided by the repository in $PWD if available.
+tea works best in a upstream/fork workflow, when the local main branch tracks the
+upstream repo. tea assumes that local git state is published on the remote before
+doing operations with tea.    Configuration is persisted in $XDG_CONFIG_HOME/tea.
+`
+
+var helpTemplate = bold(`
+   {{.Name}}{{if .Usage}} - {{.Usage}}{{end}}`) + `
+   {{if .Version}}{{if not .HideVersion}}version {{.Version}}{{end}}{{end}}
+
+ USAGE
+   {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}}{{if .Commands}} command [subcommand] [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}{{if .Description}}
+
+ DESCRIPTION
+   {{.Description | nindent 3 | trim}}{{end}}{{if .VisibleCommands}}
+
+ COMMANDS{{range .VisibleCategories}}{{if .Name}}
+   {{.Name}}:{{range .VisibleCommands}}
+     {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{else}}{{range .VisibleCommands}}
+   {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{end}}{{end}}{{end}}{{if .VisibleFlags}}
+
+ OPTIONS
+   {{range $index, $option := .VisibleFlags}}{{if $index}}
+   {{end}}{{$option}}{{end}}{{end}}
+
+ EXAMPLES
+   tea login add                       # add a login once to get started
+
+   tea pulls                           # list open pulls for the repo in $PWD
+   tea pulls --repo $HOME/foo          # list open pulls for the repo in $HOME/foo
+   tea pulls --remote upstream         # list open pulls for the repo pointed at by
+                                       # your local "upstream" git remote
+   # list open pulls for any gitea repo at the given login instance
+   tea pulls --repo gitea/tea --login gitea.com
+
+   tea milestone issues 0.7.0          # view open issues for milestone '0.7.0'
+   tea issue 189                       # view contents of issue 189
+   tea open 189                        # open web ui for issue 189
+   tea open milestones                 # open web ui for milestones
+
+   # send gitea desktop notifications every 5 minutes (bash + libnotify)
+   while :; do tea notifications --mine -o simple | xargs -i notify-send {}; sleep 300; done
+
+ ABOUT
+   Written & maintained by The Gitea Authors.
+   If you find a bug or want to contribute, we'll welcome you at https://gitea.com/gitea/tea.
+   More info about Gitea itself on https://about.gitea.com.
+`
+
+func bold(t string) string {
+	return fmt.Sprintf("\033[1m%s\033[0m", t)
+}

cmd/comment.go

@@ -0,0 +1,83 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	stdctx "context"
+	"fmt"
+	"io"
+	"strings"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/interact"
+	"code.gitea.io/tea/modules/print"
+	"code.gitea.io/tea/modules/utils"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdAddComment is the main command to operate with notifications
+var CmdAddComment = cli.Command{
+	Name:        "comment",
+	Aliases:     []string{"c"},
+	Category:    catEntities,
+	Usage:       "Add a comment to an issue / pr",
+	Description: "Add a comment to an issue / pr",
+	ArgsUsage:   "<issue / pr index> [<comment body>]",
+	Action:      runAddComment,
+	Flags:       flags.AllDefaultFlags,
+}
+
+func runAddComment(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+
+	args := ctx.Args()
+	if args.Len() == 0 {
+		return fmt.Errorf("Please specify issue / pr index")
+	}
+
+	idx, err := utils.ArgToIndex(ctx.Args().First())
+	if err != nil {
+		return err
+	}
+
+	body := strings.Join(ctx.Args().Tail(), " ")
+	if interact.IsStdinPiped() {
+		// custom solution until https://github.com/AlecAivazis/survey/issues/328 is fixed
+		if bodyStdin, err := io.ReadAll(ctx.Reader); err != nil {
+			return err
+		} else if len(bodyStdin) != 0 {
+			body = strings.Join([]string{body, string(bodyStdin)}, "\n\n")
+		}
+	} else if len(body) == 0 {
+		if err = survey.AskOne(interact.NewMultiline(interact.Multiline{
+			Message:   "Comment:",
+			Syntax:    "md",
+			UseEditor: config.GetPreferences().Editor,
+		}), &body); err != nil {
+			return err
+		}
+	}
+
+	if len(body) == 0 {
+		return fmt.Errorf("No comment body provided")
+	}
+
+	client := ctx.Login.Client()
+	comment, _, err := client.CreateIssueComment(ctx.Owner, ctx.Repo, idx, gitea.CreateIssueCommentOption{
+		Body: body,
+	})
+	if err != nil {
+		return err
+	}
+
+	print.Comment(comment)
+
+	return nil
+}

cmd/flags/csvflag.go

@@ -0,0 +1,52 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package flags
+
+import (
+	"fmt"
+	"strings"
+
+	"code.gitea.io/tea/modules/utils"
+	"github.com/urfave/cli/v3"
+)
+
+// CsvFlag is a wrapper around cli.StringFlag, with an added GetValues() method
+// to retrieve comma separated string values as a slice.
+type CsvFlag struct {
+	cli.StringFlag
+	AvailableFields []string
+}
+
+// NewCsvFlag creates a CsvFlag, while setting its usage string and default values
+func NewCsvFlag(name, usage string, aliases, availableValues, defaults []string) *CsvFlag {
+	var availableDesc string
+	if len(availableValues) != 0 {
+		availableDesc = " Available values:"
+	}
+	return &CsvFlag{
+		AvailableFields: availableValues,
+		StringFlag: cli.StringFlag{
+			Name:    name,
+			Aliases: aliases,
+			Value:   strings.Join(defaults, ","),
+			Usage: fmt.Sprintf(`Comma-separated list of %s.%s
+			%s
+		`, usage, availableDesc, strings.Join(availableValues, ",")),
+		},
+	}
+}
+
+// GetValues returns the value of the flag, parsed as a commaseparated list
+func (f CsvFlag) GetValues(cmd *cli.Command) ([]string, error) {
+	val := cmd.String(f.Name)
+	selection := strings.Split(val, ",")
+	if f.AvailableFields != nil && val != "" {
+		for _, field := range selection {
+			if !utils.Contains(f.AvailableFields, field) {
+				return nil, fmt.Errorf("Invalid field '%s'", field)
+			}
+		}
+	}
+	return selection, nil
+}

cmd/flags/flags.go

@@ -1,124 +0,0 @@
-// Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package flags
-
-import (
-	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
-)
-
-// create global variables for global Flags to simplify
-// access to the options without requiring cli.Context
-var (
-	// GlobalLoginValue contain value of --login|-l arg
-	GlobalLoginValue string
-	// GlobalRepoValue contain value of --repo|-r arg
-	GlobalRepoValue string
-	// GlobalOutputValue contain value of --output|-o arg
-	GlobalOutputValue string
-	// GlobalRemoteValue contain value of --remote|-R arg
-	GlobalRemoteValue string
-)
-
-// LoginFlag provides flag to specify tea login profile
-var LoginFlag = cli.StringFlag{
-	Name:        "login",
-	Aliases:     []string{"l"},
-	Usage:       "Use a different Gitea login. Optional",
-	Destination: &GlobalLoginValue,
-}
-
-// RepoFlag provides flag to specify repository
-var RepoFlag = cli.StringFlag{
-	Name:        "repo",
-	Aliases:     []string{"r"},
-	Usage:       "Override local repository path or gitea repository slug to interact with. Optional",
-	Destination: &GlobalRepoValue,
-}
-
-// RemoteFlag provides flag to specify remote repository
-var RemoteFlag = cli.StringFlag{
-	Name:        "remote",
-	Aliases:     []string{"R"},
-	Usage:       "Discover Gitea login from remote. Optional",
-	Destination: &GlobalRemoteValue,
-}
-
-// OutputFlag provides flag to specify output type
-var OutputFlag = cli.StringFlag{
-	Name:        "output",
-	Aliases:     []string{"o"},
-	Usage:       "Output format. (csv, simple, table, tsv, yaml)",
-	Destination: &GlobalOutputValue,
-}
-
-// StateFlag provides flag to specify issue/pr state, defaulting to "open"
-var StateFlag = cli.StringFlag{
-	Name:        "state",
-	Usage:       "Filter by state (all|open|closed)",
-	DefaultText: "open",
-}
-
-// PaginationPageFlag provides flag for pagination options
-var PaginationPageFlag = cli.StringFlag{
-	Name:    "page",
-	Aliases: []string{"p"},
-	Usage:   "specify page, default is 1",
-}
-
-// PaginationLimitFlag provides flag for pagination options
-var PaginationLimitFlag = cli.StringFlag{
-	Name:    "limit",
-	Aliases: []string{"lm"},
-	Usage:   "specify limit of items per page",
-}
-
-// LoginOutputFlags defines login and output flags that should
-// added to all subcommands and appended to the flags of the
-// subcommand to work around issue and provide --login and --output:
-// https://github.com/urfave/cli/issues/585
-var LoginOutputFlags = []cli.Flag{
-	&LoginFlag,
-	&OutputFlag,
-}
-
-// LoginRepoFlags defines login and repo flags that should
-// be used for all subcommands and appended to the flags of
-// the subcommand to work around issue and provide --login and --repo:
-// https://github.com/urfave/cli/issues/585
-var LoginRepoFlags = []cli.Flag{
-	&LoginFlag,
-	&RepoFlag,
-	&RemoteFlag,
-}
-
-// AllDefaultFlags defines flags that should be available
-// for all subcommands working with dedicated repositories
-// to work around issue and provide --login, --repo and --output:
-// https://github.com/urfave/cli/issues/585
-var AllDefaultFlags = append([]cli.Flag{
-	&RepoFlag,
-	&RemoteFlag,
-}, LoginOutputFlags...)
-
-// IssuePRFlags defines flags that should be available on issue & pr listing flags.
-var IssuePRFlags = append([]cli.Flag{
-	&StateFlag,
-	&PaginationPageFlag,
-	&PaginationLimitFlag,
-}, AllDefaultFlags...)
-
-// GetListOptions return ListOptions based on PaginationFlags
-func GetListOptions(ctx *cli.Context) gitea.ListOptions {
-	page := ctx.Int("page")
-	limit := ctx.Int("limit")
-	if limit != 0 && page == 0 {
-		page = 1
-	}
-	return gitea.ListOptions{
-		Page:     page,
-		PageSize: limit,
-	}
-}

cmd/flags/generic.go

@@ -0,0 +1,105 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package flags
+
+import (
+	"github.com/urfave/cli/v3"
+)
+
+// LoginFlag provides flag to specify tea login profile
+var LoginFlag = cli.StringFlag{
+	Name:    "login",
+	Aliases: []string{"l"},
+	Usage:   "Use a different Gitea Login. Optional",
+}
+
+// RepoFlag provides flag to specify repository
+var RepoFlag = cli.StringFlag{
+	Name:    "repo",
+	Aliases: []string{"r"},
+	Usage:   "Override local repository path or gitea repository slug to interact with. Optional",
+}
+
+// RemoteFlag provides flag to specify remote repository
+var RemoteFlag = cli.StringFlag{
+	Name:    "remote",
+	Aliases: []string{"R"},
+	Usage:   "Discover Gitea login from remote. Optional",
+}
+
+// OutputFlag provides flag to specify output type
+var OutputFlag = cli.StringFlag{
+	Name:    "output",
+	Aliases: []string{"o"},
+	Usage:   "Output format. (simple, table, csv, tsv, yaml, json)",
+}
+
+// PaginationPageFlag provides flag for pagination options
+var PaginationPageFlag = cli.StringFlag{
+	Name:    "page",
+	Aliases: []string{"p"},
+	Usage:   "specify page, default is 1",
+}
+
+// PaginationLimitFlag provides flag for pagination options
+var PaginationLimitFlag = cli.StringFlag{
+	Name:    "limit",
+	Aliases: []string{"lm"},
+	Usage:   "specify limit of items per page",
+}
+
+// LoginOutputFlags defines login and output flags that should
+// added to all subcommands and appended to the flags of the
+// subcommand to work around issue and provide --login and --output:
+// https://github.com/urfave/cli/issues/585
+var LoginOutputFlags = []cli.Flag{
+	&LoginFlag,
+	&OutputFlag,
+}
+
+// LoginRepoFlags defines login and repo flags that should
+// be used for all subcommands and appended to the flags of
+// the subcommand to work around issue and provide --login and --repo:
+// https://github.com/urfave/cli/issues/585
+var LoginRepoFlags = []cli.Flag{
+	&LoginFlag,
+	&RepoFlag,
+	&RemoteFlag,
+}
+
+// AllDefaultFlags defines flags that should be available
+// for all subcommands working with dedicated repositories
+// to work around issue and provide --login, --repo and --output:
+// https://github.com/urfave/cli/issues/585
+var AllDefaultFlags = append([]cli.Flag{
+	&RepoFlag,
+	&RemoteFlag,
+}, LoginOutputFlags...)
+
+// NotificationFlags defines flags that should be available on notifications.
+var NotificationFlags = append([]cli.Flag{
+	NotificationStateFlag,
+	&cli.BoolFlag{
+		Name:    "mine",
+		Aliases: []string{"m"},
+		Usage:   "Show notifications across all your repositories instead of the current repository only",
+	},
+	&PaginationPageFlag,
+	&PaginationLimitFlag,
+}, AllDefaultFlags...)
+
+// NotificationStateFlag is a csv flag applied to all notification subcommands as filter
+var NotificationStateFlag = NewCsvFlag(
+	"states",
+	"notification states to filter by",
+	[]string{"s"},
+	[]string{"pinned", "unread", "read"},
+	[]string{"unread", "pinned"},
+)
+
+// FieldsFlag generates a flag selecting printable fields.
+// To retrieve the value, use f.GetValues()
+func FieldsFlag(availableFields, defaultFields []string) *CsvFlag {
+	return NewCsvFlag("fields", "fields to print", []string{"f"}, availableFields, defaultFields)
+}

cmd/flags/issue_pr.go

@@ -0,0 +1,238 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package flags
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"code.gitea.io/sdk/gitea"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/task"
+
+	"github.com/araddon/dateparse"
+	"github.com/urfave/cli/v3"
+)
+
+// StateFlag provides flag to specify issue/pr state, defaulting to "open"
+var StateFlag = cli.StringFlag{
+	Name:        "state",
+	Usage:       "Filter by state (all|open|closed)",
+	DefaultText: "open",
+}
+
+// MilestoneFilterFlag is a CSV flag used to filter issues by milestones
+var MilestoneFilterFlag = NewCsvFlag(
+	"milestones",
+	"milestones to match issues against",
+	[]string{"m"}, nil, nil)
+
+// LabelFilterFlag is a CSV flag used to filter issues by labels
+var LabelFilterFlag = NewCsvFlag(
+	"labels",
+	"labels to match issues against",
+	[]string{"L"}, nil, nil)
+
+// PRListingFlags defines flags that should be available on pr listing flags.
+var PRListingFlags = append([]cli.Flag{
+	&StateFlag,
+	&PaginationPageFlag,
+	&PaginationLimitFlag,
+}, AllDefaultFlags...)
+
+// IssueListingFlags defines flags that should be available on issue listing flags.
+var IssueListingFlags = append([]cli.Flag{
+	&StateFlag,
+	&cli.StringFlag{
+		Name:        "kind",
+		Aliases:     []string{"K"},
+		Usage:       "Whether to return `issues`, `pulls`, or `all` (you can use this to apply advanced search filters to PRs)",
+		DefaultText: "issues",
+	},
+	&cli.StringFlag{
+		Name:    "keyword",
+		Aliases: []string{"k"},
+		Usage:   "Filter by search string",
+	},
+	LabelFilterFlag,
+	MilestoneFilterFlag,
+	&cli.StringFlag{
+		Name:    "author",
+		Aliases: []string{"A"},
+	},
+	&cli.StringFlag{
+		Name:    "assignee",
+		Aliases: []string{"a"},
+	},
+	&cli.StringFlag{
+		Name:    "mentions",
+		Aliases: []string{"M"},
+	},
+	&cli.StringFlag{
+		Name:    "owner",
+		Aliases: []string{"org"},
+	},
+	&cli.StringFlag{
+		Name:    "from",
+		Aliases: []string{"F"},
+		Usage:   "Filter by activity after this date",
+	},
+	&cli.StringFlag{
+		Name:    "until",
+		Aliases: []string{"u"},
+		Usage:   "Filter by activity before this date",
+	},
+	&PaginationPageFlag,
+	&PaginationLimitFlag,
+}, AllDefaultFlags...)
+
+// issuePRFlags defines shared flags between flags IssuePRCreateFlags and IssuePREditFlags
+var issuePRFlags = append([]cli.Flag{
+	&cli.StringFlag{
+		Name:    "title",
+		Aliases: []string{"t"},
+	},
+	&cli.StringFlag{
+		Name:    "description",
+		Aliases: []string{"d"},
+	},
+	&cli.StringFlag{
+		Name:    "referenced-version",
+		Aliases: []string{"v"},
+		Usage:   "commit-hash or tag name to assign",
+	},
+	&cli.StringFlag{
+		Name:    "milestone",
+		Aliases: []string{"m"},
+		Usage:   "Milestone to assign",
+	},
+	&cli.StringFlag{
+		Name:    "deadline",
+		Aliases: []string{"D"},
+		Usage:   "Deadline timestamp to assign",
+	},
+}, LoginRepoFlags...)
+
+// IssuePRCreateFlags defines flags for creation of issues and PRs
+var IssuePRCreateFlags = append([]cli.Flag{
+	&cli.StringFlag{
+		Name:    "assignees",
+		Aliases: []string{"a"},
+		Usage:   "Comma-separated list of usernames to assign",
+	},
+	&cli.StringFlag{
+		Name:    "labels",
+		Aliases: []string{"L"},
+		Usage:   "Comma-separated list of labels to assign",
+	},
+}, issuePRFlags...)
+
+// GetIssuePRCreateFlags parses all IssuePREditFlags
+func GetIssuePRCreateFlags(ctx *context.TeaContext) (*gitea.CreateIssueOption, error) {
+	opts := gitea.CreateIssueOption{
+		Title:     ctx.String("title"),
+		Body:      ctx.String("description"),
+		Assignees: strings.Split(ctx.String("assignees"), ","),
+	}
+	var err error
+
+	date := ctx.String("deadline")
+	if date != "" {
+		t, err := dateparse.ParseAny(date)
+		if err != nil {
+			return nil, err
+		}
+		opts.Deadline = &t
+	}
+
+	client := ctx.Login.Client()
+
+	labelNames := strings.Split(ctx.String("labels"), ",")
+	if len(labelNames) != 0 {
+		if client == nil {
+			client = ctx.Login.Client()
+		}
+		if opts.Labels, err = task.ResolveLabelNames(client, ctx.Owner, ctx.Repo, labelNames); err != nil {
+			return nil, err
+		}
+	}
+
+	if milestoneName := ctx.String("milestone"); len(milestoneName) != 0 {
+		if client == nil {
+			client = ctx.Login.Client()
+		}
+		ms, _, err := client.GetMilestoneByName(ctx.Owner, ctx.Repo, milestoneName)
+		if err != nil {
+			return nil, fmt.Errorf("Milestone '%s' not found", milestoneName)
+		}
+		opts.Milestone = ms.ID
+	}
+
+	return &opts, nil
+}
+
+// IssuePREditFlags defines flags for editing properties of issues and PRs
+var IssuePREditFlags = append([]cli.Flag{
+	&cli.StringFlag{
+		Name:    "add-assignees",
+		Aliases: []string{"a"},
+		Usage:   "Comma-separated list of usernames to assign",
+	},
+	&cli.StringFlag{
+		Name:    "add-labels",
+		Aliases: []string{"L"},
+		Usage:   "Comma-separated list of labels to assign. Takes precedence over --remove-labels",
+	},
+	&cli.StringFlag{
+		Name:  "remove-labels",
+		Usage: "Comma-separated list of labels to remove",
+	},
+}, issuePRFlags...)
+
+// GetIssuePREditFlags parses all IssuePREditFlags
+func GetIssuePREditFlags(ctx *context.TeaContext) (*task.EditIssueOption, error) {
+	opts := task.EditIssueOption{}
+	if ctx.IsSet("title") {
+		val := ctx.String("title")
+		opts.Title = &val
+	}
+	if ctx.IsSet("description") {
+		val := ctx.String("description")
+		opts.Body = &val
+	}
+	if ctx.IsSet("referenced-version") {
+		val := ctx.String("referenced-version")
+		opts.Ref = &val
+	}
+	if ctx.IsSet("milestone") {
+		val := ctx.String("milestone")
+		opts.Milestone = &val
+	}
+	if ctx.IsSet("deadline") {
+		date := ctx.String("deadline")
+		if date == "" {
+			opts.Deadline = &time.Time{}
+		} else {
+			t, err := dateparse.ParseAny(date)
+			if err != nil {
+				return nil, err
+			}
+			opts.Deadline = &t
+		}
+	}
+	if ctx.IsSet("add-assignees") {
+		val := ctx.String("add-assignees")
+		opts.AddAssignees = strings.Split(val, ",")
+	}
+	if ctx.IsSet("add-labels") {
+		val := ctx.String("add-labels")
+		opts.AddLabels = strings.Split(val, ",")
+	}
+	if ctx.IsSet("remove-labels") {
+		val := ctx.String("remove-labels")
+		opts.RemoveLabels = strings.Split(val, ",")
+	}
+	return &opts, nil
+}

cmd/issues.go

@@ -1,54 +1,77 @@
 // Copyright 2018 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
 import (
-	"code.gitea.io/tea/cmd/flags"
+	stdctx "context"
+	"fmt"
+
 	"code.gitea.io/tea/cmd/issues"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/interact"
 	"code.gitea.io/tea/modules/print"
 	"code.gitea.io/tea/modules/utils"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdIssues represents to login a gitea server.
 var CmdIssues = cli.Command{
 	Name:        "issues",
-	Aliases:     []string{"issue"},
+	Aliases:     []string{"issue", "i"},
+	Category:    catEntities,
 	Usage:       "List, create and update issues",
-	Description: "List, create and update issues",
+	Description: `Lists issues when called without argument. If issue index is provided, will show it in detail.`,
 	ArgsUsage:   "[<issue index>]",
 	Action:      runIssues,
-	Subcommands: []*cli.Command{
+	Commands: []*cli.Command{
 		&issues.CmdIssuesList,
 		&issues.CmdIssuesCreate,
+		&issues.CmdIssuesEdit,
 		&issues.CmdIssuesReopen,
 		&issues.CmdIssuesClose,
 	},
-	Flags: flags.IssuePRFlags,
+	Flags: append([]cli.Flag{
+		&cli.BoolFlag{
+			Name:  "comments",
+			Usage: "Whether to display comments (will prompt if not provided & run interactively)",
+		},
+	}, issues.CmdIssuesList.Flags...),
 }
 
-func runIssues(ctx *cli.Context) error {
-	if ctx.Args().Len() == 1 {
-		return runIssueDetail(ctx.Args().First())
+func runIssues(ctx stdctx.Context, cmd *cli.Command) error {
+	if cmd.Args().Len() == 1 {
+		return runIssueDetail(ctx, cmd, cmd.Args().First())
 	}
-	return issues.RunIssuesList(ctx)
+	return issues.RunIssuesList(ctx, cmd)
 }
 
-func runIssueDetail(index string) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runIssueDetail(_ stdctx.Context, cmd *cli.Command, index string) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 
 	idx, err := utils.ArgToIndex(index)
 	if err != nil {
 		return err
 	}
-	issue, _, err := login.Client().GetIssue(owner, repo, idx)
+	client := ctx.Login.Client()
+	issue, _, err := client.GetIssue(ctx.Owner, ctx.Repo, idx)
 	if err != nil {
 		return err
 	}
-	print.IssueDetails(issue)
+	reactions, _, err := client.GetIssueReactions(ctx.Owner, ctx.Repo, idx)
+	if err != nil {
+		return err
+	}
+	print.IssueDetails(issue, reactions)
+
+	if issue.Comments > 0 {
+		err = interact.ShowCommentsMaybeInteractive(ctx, idx, issue.Comments)
+		if err != nil {
+			return fmt.Errorf("error loading comments: %v", err)
+		}
+	}
+
 	return nil
 }

cmd/issues/close.go

@@ -1,51 +1,59 @@
 // Copyright 2018 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package issues
 
 import (
-	"log"
+	stdctx "context"
+	"fmt"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/print"
 	"code.gitea.io/tea/modules/utils"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdIssuesClose represents a sub command of issues to close an issue
 var CmdIssuesClose = cli.Command{
 	Name:        "close",
-	Usage:       "Change state of an issue to 'closed'",
-	Description: `Change state of an issue to 'closed'`,
-	ArgsUsage:   "<issue index>",
-	Action: func(ctx *cli.Context) error {
+	Usage:       "Change state of one ore more issues to 'closed'",
+	Description: `Change state of one ore more issues to 'closed'`,
+	ArgsUsage:   "<issue index> [<issue index>...]",
+	Action: func(ctx stdctx.Context, cmd *cli.Command) error {
 		var s = gitea.StateClosed
-		return editIssueState(ctx, gitea.EditIssueOption{State: &s})
+		return editIssueState(ctx, cmd, gitea.EditIssueOption{State: &s})
 	},
 	Flags: flags.AllDefaultFlags,
 }
 
 // editIssueState abstracts the arg parsing to edit the given issue
-func editIssueState(ctx *cli.Context, opts gitea.EditIssueOption) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func editIssueState(_ stdctx.Context, cmd *cli.Command, opts gitea.EditIssueOption) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 	if ctx.Args().Len() == 0 {
-		log.Fatal(ctx.Command.ArgsUsage)
+		return fmt.Errorf(ctx.Command.ArgsUsage)
 	}
 
-	index, err := utils.ArgToIndex(ctx.Args().First())
+	indices, err := utils.ArgsToIndices(ctx.Args().Slice())
 	if err != nil {
 		return err
 	}
 
-	issue, _, err := login.Client().EditIssue(owner, repo, index, opts)
+	client := ctx.Login.Client()
+	for _, index := range indices {
+		issue, _, err := client.EditIssue(ctx.Owner, ctx.Repo, index, opts)
 		if err != nil {
 			return err
 		}
 
-	print.IssueDetails(issue)
+		if len(indices) > 1 {
+			fmt.Println(issue.HTMLURL)
+		} else {
+			print.IssueDetails(issue, nil)
+		}
+	}
 	return nil
 }

cmd/issues/create.go

@@ -1,61 +1,47 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package issues
 
 import (
-	"fmt"
-	"log"
+	stdctx "context"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
-	"code.gitea.io/tea/modules/print"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/interact"
+	"code.gitea.io/tea/modules/task"
 
-	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdIssuesCreate represents a sub command of issues to create issue
 var CmdIssuesCreate = cli.Command{
 	Name:        "create",
+	Aliases:     []string{"c"},
 	Usage:       "Create an issue on repository",
 	Description: `Create an issue on repository`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runIssuesCreate,
-	Flags: append([]cli.Flag{
-		&cli.StringFlag{
-			Name:    "title",
-			Aliases: []string{"t"},
-			Usage:   "issue title to create",
-		},
-		&cli.StringFlag{
-			Name:    "body",
-			Aliases: []string{"b"},
-			Usage:   "issue body to create",
-		},
-	}, flags.LoginRepoFlags...),
+	Flags:       flags.IssuePRCreateFlags,
 }
 
-func runIssuesCreate(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runIssuesCreate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 
-	issue, _, err := login.Client().CreateIssue(owner, repo, gitea.CreateIssueOption{
-		Title: ctx.String("title"),
-		Body:  ctx.String("body"),
-		// TODO:
-		//Assignee  string   `json:"assignee"`
-		//Assignees []string `json:"assignees"`
-		//Deadline *time.Time `json:"due_date"`
-		//Milestone int64 `json:"milestone"`
-		//Labels []int64 `json:"labels"`
-		//Closed bool    `json:"closed"`
-	})
+	if ctx.NumFlags() == 0 {
+		return interact.CreateIssue(ctx.Login, ctx.Owner, ctx.Repo)
+	}
 
+	opts, err := flags.GetIssuePRCreateFlags(ctx)
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
 
-	print.IssueDetails(issue)
-	fmt.Println(issue.HTMLURL)
-	return nil
+	return task.CreateIssue(
+		ctx.Login,
+		ctx.Owner,
+		ctx.Repo,
+		*opts,
+	)
 }

cmd/issues/edit.go

@@ -0,0 +1,72 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package issues
+
+import (
+	"fmt"
+
+	stdctx "context"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/interact"
+	"code.gitea.io/tea/modules/print"
+	"code.gitea.io/tea/modules/task"
+	"code.gitea.io/tea/modules/utils"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdIssuesEdit is the subcommand of issues to edit issues
+var CmdIssuesEdit = cli.Command{
+	Name:    "edit",
+	Aliases: []string{"e"},
+	Usage:   "Edit one or more issues",
+	Description: `Edit one or more issues. To unset a property again,
+use an empty string (eg. --milestone "").`,
+	ArgsUsage: "<idx> [<idx>...]",
+	Action:    runIssuesEdit,
+	Flags:     flags.IssuePREditFlags,
+}
+
+func runIssuesEdit(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+
+	if !cmd.Args().Present() {
+		return fmt.Errorf("must specify at least one issue index")
+	}
+
+	opts, err := flags.GetIssuePREditFlags(ctx)
+	if err != nil {
+		return err
+	}
+
+	indices, err := utils.ArgsToIndices(ctx.Args().Slice())
+	if err != nil {
+		return err
+	}
+
+	client := ctx.Login.Client()
+	for _, opts.Index = range indices {
+		if ctx.NumFlags() == 0 {
+			var err error
+			opts, err = interact.EditIssue(*ctx, opts.Index)
+			if err != nil {
+				return err
+			}
+		}
+
+		issue, err := task.EditIssue(ctx, client, *opts)
+		if err != nil {
+			return err
+		}
+		if ctx.Args().Len() > 1 {
+			fmt.Println(issue.HTMLURL)
+		} else {
+			print.IssueDetails(issue, nil)
+		}
+	}
+
+	return nil
+}

cmd/issues/list.go

@@ -1,54 +1,132 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package issues
 
 import (
-	"log"
+	stdctx "context"
+	"fmt"
+	"time"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/print"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/araddon/dateparse"
+	"github.com/urfave/cli/v3"
 )
 
+var issueFieldsFlag = flags.FieldsFlag(print.IssueFields, []string{
+	"index", "title", "state", "author", "milestone", "labels", "owner", "repo",
+})
+
 // CmdIssuesList represents a sub command of issues to list issues
 var CmdIssuesList = cli.Command{
-	Name:        "ls",
-	Aliases:     []string{"list"},
+	Name:        "list",
+	Aliases:     []string{"ls"},
 	Usage:       "List issues of the repository",
 	Description: `List issues of the repository`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      RunIssuesList,
-	Flags:       flags.IssuePRFlags,
+	Flags:       append([]cli.Flag{issueFieldsFlag}, flags.IssueListingFlags...),
 }
 
 // RunIssuesList list issues
-func RunIssuesList(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func RunIssuesList(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
 
 	state := gitea.StateOpen
 	switch ctx.String("state") {
 	case "all":
 		state = gitea.StateAll
-	case "open":
+	case "", "open":
 		state = gitea.StateOpen
 	case "closed":
 		state = gitea.StateClosed
+	default:
+		return fmt.Errorf("unknown state '%s'", ctx.String("state"))
 	}
 
-	issues, _, err := login.Client().ListRepoIssues(owner, repo, gitea.ListIssueOption{
-		ListOptions: flags.GetListOptions(ctx),
+	kind := gitea.IssueTypeIssue
+	switch ctx.String("kind") {
+	case "", "issues", "issue":
+		kind = gitea.IssueTypeIssue
+	case "pulls", "pull", "pr":
+		kind = gitea.IssueTypePull
+	case "all":
+		kind = gitea.IssueTypeAll
+	default:
+		return fmt.Errorf("unknown kind '%s'", ctx.String("kind"))
+	}
+
+	var err error
+	var from, until time.Time
+	if ctx.IsSet("from") {
+		from, err = dateparse.ParseLocal(ctx.String("from"))
+		if err != nil {
+			return err
+		}
+	}
+	if ctx.IsSet("until") {
+		until, err = dateparse.ParseLocal(ctx.String("until"))
+		if err != nil {
+			return err
+		}
+	}
+	owner := ctx.Owner
+	if ctx.IsSet("owner") {
+		owner = ctx.String("owner")
+	}
+
+	// ignore error, as we don't do any input validation on these flags
+	labels, _ := flags.LabelFilterFlag.GetValues(cmd)
+	milestones, _ := flags.MilestoneFilterFlag.GetValues(cmd)
+	var issues []*gitea.Issue
+	if ctx.Repo != "" {
+		issues, _, err = ctx.Login.Client().ListRepoIssues(owner, ctx.Repo, gitea.ListIssueOption{
+			ListOptions: ctx.GetListOptions(),
 			State:       state,
-		Type:        gitea.IssueTypeIssue,
+			Type:        kind,
+			KeyWord:     ctx.String("keyword"),
+			CreatedBy:   ctx.String("author"),
+			AssignedBy:  ctx.String("assigned-to"),
+			MentionedBy: ctx.String("mentions"),
+			Labels:      labels,
+			Milestones:  milestones,
+			Since:       from,
+			Before:      until,
 		})
 
 		if err != nil {
-		log.Fatal(err)
+			return err
+		}
+	} else {
+		issues, _, err = ctx.Login.Client().ListIssues(gitea.ListIssueOption{
+			ListOptions: ctx.GetListOptions(),
+			State:       state,
+			Type:        kind,
+			KeyWord:     ctx.String("keyword"),
+			CreatedBy:   ctx.String("author"),
+			AssignedBy:  ctx.String("assigned-to"),
+			MentionedBy: ctx.String("mentions"),
+			Labels:      labels,
+			Milestones:  milestones,
+			Since:       from,
+			Before:      until,
+			Owner:       owner,
+		})
+
+		if err != nil {
+			return err
+		}
 	}
 
-	print.IssuesList(issues, flags.GlobalOutputValue)
+	fields, err := issueFieldsFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
+
+	print.IssuesPullsList(issues, ctx.Output, fields)
 	return nil
 }

cmd/issues/reopen.go

@@ -1,26 +1,27 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package issues
 
 import (
+	"context"
+
 	"code.gitea.io/tea/cmd/flags"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdIssuesReopen represents a sub command of issues to open an issue
 var CmdIssuesReopen = cli.Command{
 	Name:        "reopen",
 	Aliases:     []string{"open"},
-	Usage:       "Change state of an issue to 'open'",
-	Description: `Change state of an issue to 'open'`,
-	ArgsUsage:   "<issue index>",
-	Action: func(ctx *cli.Context) error {
+	Usage:       "Change state of one or more issues to 'open'",
+	Description: `Change state of one or more issues to 'open'`,
+	ArgsUsage:   "<issue index> [<issue index>...]",
+	Action: func(ctx context.Context, cmd *cli.Command) error {
 		var s = gitea.StateOpen
-		return editIssueState(ctx, gitea.EditIssueOption{State: &s})
+		return editIssueState(ctx, cmd, gitea.EditIssueOption{State: &s})
 	},
 	Flags: flags.AllDefaultFlags,
 }

cmd/labels.go

@@ -1,39 +1,41 @@
 // Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
 import (
-	"log"
+	"context"
+	"fmt"
 
 	"code.gitea.io/tea/cmd/labels"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLabels represents to operate repositories' labels.
 var CmdLabels = cli.Command{
 	Name:        "labels",
 	Aliases:     []string{"label"},
+	Category:    catEntities,
 	Usage:       "Manage issue labels",
 	Description: `Manage issue labels`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runLabels,
-	Subcommands: []*cli.Command{
+	Commands: []*cli.Command{
 		&labels.CmdLabelsList,
 		&labels.CmdLabelCreate,
 		&labels.CmdLabelUpdate,
 		&labels.CmdLabelDelete,
 	},
+	Flags: labels.CmdLabelsList.Flags,
 }
 
-func runLabels(ctx *cli.Context) error {
-	if ctx.Args().Len() == 1 {
-		return runLabelsDetails(ctx)
+func runLabels(ctx context.Context, cmd *cli.Command) error {
+	if cmd.Args().Len() == 1 {
+		return runLabelsDetails(cmd)
 	}
-	return labels.RunLabelsList(ctx)
+	return labels.RunLabelsList(ctx, cmd)
 }
 
-func runLabelsDetails(ctx *cli.Context) error {
-	log.Fatal("Not yet implemented.")
-	return nil
+func runLabelsDetails(cmd *cli.Command) error {
+	return fmt.Errorf("Not yet implemented")
 }

cmd/labels/create.go

@@ -1,29 +1,31 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package labels
 
 import (
 	"bufio"
+	stdctx "context"
 	"log"
 	"os"
 	"strings"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLabelCreate represents a sub command of labels to create label.
 var CmdLabelCreate = cli.Command{
 	Name:        "create",
+	Aliases:     []string{"c"},
 	Usage:       "Create a label",
 	Description: `Create a label`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runLabelCreate,
-	Flags: []cli.Flag{
+	Flags: append([]cli.Flag{
 		&cli.StringFlag{
 			Name:  "name",
 			Usage: "label name",
@@ -40,16 +42,17 @@ var CmdLabelCreate = cli.Command{
 			Name:  "file",
 			Usage: "indicate a label file",
 		},
-	},
+	}, flags.AllDefaultFlags...),
 }
 
-func runLabelCreate(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runLabelCreate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 
 	labelFile := ctx.String("file")
 	var err error
 	if len(labelFile) == 0 {
-		_, _, err = login.Client().CreateLabel(owner, repo, gitea.CreateLabelOption{
+		_, _, err = ctx.Login.Client().CreateLabel(ctx.Owner, ctx.Repo, gitea.CreateLabelOption{
 			Name:        ctx.String("name"),
 			Color:       ctx.String("color"),
 			Description: ctx.String("description"),
@@ -69,7 +72,7 @@ func runLabelCreate(ctx *cli.Context) error {
 			if color == "" || name == "" {
 				log.Printf("Line %d ignored because lack of enough fields: %s\n", i, line)
 			} else {
-				_, _, err = login.Client().CreateLabel(owner, repo, gitea.CreateLabelOption{
+				_, _, err = ctx.Login.Client().CreateLabel(ctx.Owner, ctx.Repo, gitea.CreateLabelOption{
 					Name:        name,
 					Color:       color,
 					Description: description,
@@ -80,11 +83,7 @@ func runLabelCreate(ctx *cli.Context) error {
 		}
 	}
 
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	return nil
+	return err
 }
 
 func splitLabelLine(line string) (string, string, string) {

cmd/labels/create_test.go

@@ -1,6 +1,5 @@
 // Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package labels
 

cmd/labels/delete.go

@@ -1,39 +1,37 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package labels
 
 import (
-	"log"
+	stdctx "context"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLabelDelete represents a sub command of labels to delete label.
 var CmdLabelDelete = cli.Command{
 	Name:        "delete",
+	Aliases:     []string{"rm"},
 	Usage:       "Delete a label",
 	Description: `Delete a label`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runLabelDelete,
-	Flags: []cli.Flag{
+	Flags: append([]cli.Flag{
 		&cli.IntFlag{
 			Name:  "id",
 			Usage: "label id",
 		},
-	},
+	}, flags.AllDefaultFlags...),
 }
 
-func runLabelDelete(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runLabelDelete(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 
-	_, err := login.Client().DeleteLabel(owner, repo, ctx.Int64("id"))
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	return nil
+	_, err := ctx.Login.Client().DeleteLabel(ctx.Owner, ctx.Repo, ctx.Int64("id"))
+	return err
 }

cmd/labels/list.go

@@ -1,27 +1,27 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package labels
 
 import (
-	"log"
+	stdctx "context"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/print"
 	"code.gitea.io/tea/modules/task"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLabelsList represents a sub command of labels to list labels
 var CmdLabelsList = cli.Command{
-	Name:        "ls",
-	Aliases:     []string{"list"},
+	Name:        "list",
+	Aliases:     []string{"ls"},
 	Usage:       "List labels",
 	Description: "List labels",
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      RunLabelsList,
 	Flags: append([]cli.Flag{
 		&cli.BoolFlag{
@@ -35,18 +35,22 @@ var CmdLabelsList = cli.Command{
 }
 
 // RunLabelsList list labels.
-func RunLabelsList(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func RunLabelsList(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 
-	labels, _, err := login.Client().ListRepoLabels(owner, repo, gitea.ListLabelsOptions{ListOptions: flags.GetListOptions(ctx)})
+	client := ctx.Login.Client()
+	labels, _, err := client.ListRepoLabels(ctx.Owner, ctx.Repo, gitea.ListLabelsOptions{
+		ListOptions: ctx.GetListOptions(),
+	})
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
 
 	if ctx.IsSet("save") {
 		return task.LabelsExport(labels, ctx.String("save"))
 	}
 
-	print.LabelsList(labels, flags.GlobalOutputValue)
+	print.LabelsList(labels, ctx.Output)
 	return nil
 }

cmd/labels/update.go

@@ -1,17 +1,16 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package labels
 
 import (
-	"log"
+	stdctx "context"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLabelUpdate represents a sub command of labels to update label.
@@ -19,8 +18,9 @@ var CmdLabelUpdate = cli.Command{
 	Name:        "update",
 	Usage:       "Update a label",
 	Description: `Update a label`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runLabelUpdate,
-	Flags: []cli.Flag{
+	Flags: append([]cli.Flag{
 		&cli.IntFlag{
 			Name:  "id",
 			Usage: "label id",
@@ -37,11 +37,12 @@ var CmdLabelUpdate = cli.Command{
 			Name:  "description",
 			Usage: "label description",
 		},
-	},
+	}, flags.AllDefaultFlags...),
 }
 
-func runLabelUpdate(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runLabelUpdate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 
 	id := ctx.Int64("id")
 	var pName, pColor, pDescription *string
@@ -61,14 +62,14 @@ func runLabelUpdate(ctx *cli.Context) error {
 	}
 
 	var err error
-	_, _, err = login.Client().EditLabel(owner, repo, id, gitea.EditLabelOption{
+	_, _, err = ctx.Login.Client().EditLabel(ctx.Owner, ctx.Repo, id, gitea.EditLabelOption{
 		Name:        pName,
 		Color:       pColor,
 		Description: pDescription,
 	})
 
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
 
 	return nil

cmd/login.go

@@ -1,42 +1,44 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
 import (
+	"context"
 	"fmt"
 
-	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/cmd/login"
 	"code.gitea.io/tea/modules/config"
 	"code.gitea.io/tea/modules/print"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLogin represents to login a gitea server.
 var CmdLogin = cli.Command{
 	Name:        "logins",
 	Aliases:     []string{"login"},
+	Category:    catSetup,
 	Usage:       "Log in to a Gitea server",
 	Description: `Log in to a Gitea server`,
 	ArgsUsage:   "[<login name>]",
 	Action:      runLogins,
-	Subcommands: []*cli.Command{
+	Commands: []*cli.Command{
 		&login.CmdLoginList,
 		&login.CmdLoginAdd,
 		&login.CmdLoginEdit,
 		&login.CmdLoginDelete,
 		&login.CmdLoginSetDefault,
+		&login.CmdLoginHelper,
+		&login.CmdLoginOAuthRefresh,
 	},
 }
 
-func runLogins(ctx *cli.Context) error {
-	if ctx.Args().Len() == 1 {
-		return runLoginDetail(ctx.Args().First())
+func runLogins(ctx context.Context, cmd *cli.Command) error {
+	if cmd.Args().Len() == 1 {
+		return runLoginDetail(cmd.Args().First())
 	}
-	return login.RunLoginList(ctx)
+	return login.RunLoginList(ctx, cmd)
 }
 
 func runLoginDetail(name string) error {
@@ -46,6 +48,6 @@ func runLoginDetail(name string) error {
 		return nil
 	}
 
-	print.LoginDetails(l, flags.GlobalOutputValue)
+	print.LoginDetails(l)
 	return nil
 }

cmd/login/add.go

@@ -1,14 +1,16 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package login
 
 import (
+	"context"
+
+	"code.gitea.io/tea/modules/auth"
 	"code.gitea.io/tea/modules/interact"
 	"code.gitea.io/tea/modules/task"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLoginAdd represents to login a gitea server.
@@ -16,6 +18,7 @@ var CmdLoginAdd = cli.Command{
 	Name:        "add",
 	Usage:       "Add a Gitea login",
 	Description: `Add a Gitea login, without args it will create one interactively`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:    "name",
@@ -26,56 +29,133 @@ var CmdLoginAdd = cli.Command{
 			Name:    "url",
 			Aliases: []string{"u"},
 			Value:   "https://gitea.com",
-			EnvVars: []string{"GITEA_SERVER_URL"},
+			Sources: cli.EnvVars("GITEA_SERVER_URL"),
 			Usage:   "Server URL",
 		},
+		&cli.BoolFlag{
+			Name:    "no-version-check",
+			Aliases: []string{"nv"},
+			Usage:   "Do not check version of Gitea instance",
+		},
 		&cli.StringFlag{
 			Name:    "token",
 			Aliases: []string{"t"},
 			Value:   "",
-			EnvVars: []string{"GITEA_SERVER_TOKEN"},
+			Sources: cli.EnvVars("GITEA_SERVER_TOKEN"),
 			Usage:   "Access token. Can be obtained from Settings > Applications",
 		},
 		&cli.StringFlag{
 			Name:    "user",
 			Value:   "",
-			EnvVars: []string{"GITEA_SERVER_USER"},
+			Sources: cli.EnvVars("GITEA_SERVER_USER"),
 			Usage:   "User for basic auth (will create token)",
 		},
 		&cli.StringFlag{
 			Name:    "password",
 			Aliases: []string{"pwd"},
 			Value:   "",
-			EnvVars: []string{"GITEA_SERVER_PASSWORD"},
+			Sources: cli.EnvVars("GITEA_SERVER_PASSWORD"),
 			Usage:   "Password for basic auth (will create token)",
 		},
+		&cli.StringFlag{
+			Name:    "otp",
+			Sources: cli.EnvVars("GITEA_SERVER_OTP"),
+			Usage:   "OTP token for auth, if necessary",
+		},
+		&cli.StringFlag{
+			Name:    "scopes",
+			Sources: cli.EnvVars("GITEA_SCOPES"),
+			Usage:   "Token scopes to add when creating a new token, separated by a comma",
+		},
 		&cli.StringFlag{
 			Name:    "ssh-key",
 			Aliases: []string{"s"},
-			Usage:   "Path to a SSH key to use, overrides auto-discovery",
+			Usage:   "Path to a SSH key/certificate to use, overrides auto-discovery",
 		},
 		&cli.BoolFlag{
 			Name:    "insecure",
 			Aliases: []string{"i"},
 			Usage:   "Disable TLS verification",
 		},
+		&cli.StringFlag{
+			Name:    "ssh-agent-principal",
+			Aliases: []string{"c"},
+			Usage:   "Use SSH certificate with specified principal to login (needs a running ssh-agent with certificate loaded)",
+		},
+		&cli.StringFlag{
+			Name:    "ssh-agent-key",
+			Aliases: []string{"a"},
+			Usage:   "Use SSH public key or SSH fingerprint to login (needs a running ssh-agent with ssh key loaded)",
+		},
+		&cli.BoolFlag{
+			Name:    "helper",
+			Aliases: []string{"j"},
+			Usage:   "Add helper",
+		},
+		&cli.BoolFlag{
+			Name:    "oauth",
+			Aliases: []string{"o"},
+			Usage:   "Use interactive OAuth2 flow for authentication",
+		},
+		&cli.StringFlag{
+			Name:  "client-id",
+			Usage: "OAuth client ID (for use with --oauth)",
+		},
+		&cli.StringFlag{
+			Name:  "redirect-url",
+			Usage: "OAuth redirect URL (for use with --oauth)",
+		},
 	},
 	Action: runLoginAdd,
 }
 
-func runLoginAdd(ctx *cli.Context) error {
+func runLoginAdd(_ context.Context, cmd *cli.Command) error {
 	// if no args create login interactive
-	if ctx.NumFlags() == 0 {
+	if cmd.NumFlags() == 0 {
 		return interact.CreateLogin()
 	}
 
+	// if OAuth flag is provided, use OAuth2 PKCE flow
+	if cmd.Bool("oauth") {
+		opts := auth.OAuthOptions{
+			Name:     cmd.String("name"),
+			URL:      cmd.String("url"),
+			Insecure: cmd.Bool("insecure"),
+		}
+
+		// Only set clientID if provided
+		if cmd.String("client-id") != "" {
+			opts.ClientID = cmd.String("client-id")
+		}
+
+		// Only set redirect URL if provided
+		if cmd.String("redirect-url") != "" {
+			opts.RedirectURL = cmd.String("redirect-url")
+		}
+
+		return auth.OAuthLoginWithFullOptions(opts)
+	}
+
+	sshAgent := false
+	if cmd.String("ssh-agent-key") != "" || cmd.String("ssh-agent-principal") != "" {
+		sshAgent = true
+	}
+
 	// else use args to add login
 	return task.CreateLogin(
-		ctx.String("name"),
-		ctx.String("token"),
-		ctx.String("user"),
-		ctx.String("password"),
-		ctx.String("ssh-key"),
-		ctx.String("url"),
-		ctx.Bool("insecure"))
+		cmd.String("name"),
+		cmd.String("token"),
+		cmd.String("user"),
+		cmd.String("password"),
+		cmd.String("otp"),
+		cmd.String("scopes"),
+		cmd.String("ssh-key"),
+		cmd.String("url"),
+		cmd.String("ssh-agent-principal"),
+		cmd.String("ssh-agent-key"),
+		cmd.Bool("insecure"),
+		sshAgent,
+		!cmd.Bool("no-version-check"),
+		cmd.Bool("helper"),
+	)
 }

cmd/login/default.go

@@ -1,16 +1,16 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package login
 
 import (
+	"context"
 	"fmt"
 
 	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/modules/config"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLoginSetDefault represents to login a gitea server.
@@ -23,8 +23,8 @@ var CmdLoginSetDefault = cli.Command{
 	Flags:       []cli.Flag{&flags.OutputFlag},
 }
 
-func runLoginSetDefault(ctx *cli.Context) error {
-	if ctx.Args().Len() == 0 {
+func runLoginSetDefault(_ context.Context, cmd *cli.Command) error {
+	if cmd.Args().Len() == 0 {
 		l, err := config.GetDefaultLogin()
 		if err != nil {
 			return err
@@ -33,6 +33,6 @@ func runLoginSetDefault(ctx *cli.Context) error {
 		return nil
 	}
 
-	name := ctx.Args().First()
+	name := cmd.Args().First()
 	return config.SetDefaultLogin(name)
 }

cmd/login/delete.go

@@ -1,16 +1,16 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package login
 
 import (
+	"context"
 	"errors"
 	"log"
 
 	"code.gitea.io/tea/modules/config"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLoginDelete is a command to delete a login
@@ -24,7 +24,7 @@ var CmdLoginDelete = cli.Command{
 }
 
 // RunLoginDelete runs the action of a login delete command
-func RunLoginDelete(ctx *cli.Context) error {
+func RunLoginDelete(_ context.Context, cmd *cli.Command) error {
 	logins, err := config.GetLogins()
 	if err != nil {
 		log.Fatal(err)
@@ -32,8 +32,8 @@ func RunLoginDelete(ctx *cli.Context) error {
 
 	var name string
 
-	if len(ctx.Args().First()) != 0 {
-		name = ctx.Args().First()
+	if len(cmd.Args().First()) != 0 {
+		name = cmd.Args().First()
 	} else if len(logins) == 1 {
 		name = logins[0].Name
 	} else {

cmd/login/edit.go

@@ -1,26 +1,41 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package login
 
 import (
+	"context"
+	"log"
+	"os"
+	"os/exec"
+
 	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/modules/config"
 
 	"github.com/skratchdot/open-golang/open"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLoginEdit represents to login a gitea server.
 var CmdLoginEdit = cli.Command{
 	Name:        "edit",
+	Aliases:     []string{"e"},
 	Usage:       "Edit Gitea logins",
 	Description: `Edit Gitea logins`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runLoginEdit,
 	Flags:       []cli.Flag{&flags.OutputFlag},
 }
 
-func runLoginEdit(_ *cli.Context) error {
+func runLoginEdit(_ context.Context, _ *cli.Command) error {
+	if e, ok := os.LookupEnv("EDITOR"); ok && e != "" {
+		cmd := exec.Command(e, config.GetConfigPath())
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			log.Fatal(err.Error())
+		}
+	}
 	return open.Start(config.GetConfigPath())
 }

cmd/login/helper.go

@@ -0,0 +1,131 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package login
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"log"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+
+	"code.gitea.io/tea/modules/auth"
+	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/task"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdLoginHelper represents to login a gitea helper.
+var CmdLoginHelper = cli.Command{
+	Name:        "helper",
+	Aliases:     []string{"git-credential"},
+	Usage:       "Git helper",
+	Description: `Git helper`,
+	Hidden:      true,
+	Commands: []*cli.Command{
+		{
+			Name:        "store",
+			Description: "Command drops",
+			Aliases:     []string{"erase"},
+			Action: func(_ context.Context, _ *cli.Command) error {
+				return nil
+			},
+		},
+		{
+			Name:        "setup",
+			Description: "Setup helper to tea authenticate",
+			Action: func(_ context.Context, _ *cli.Command) error {
+				logins, err := config.GetLogins()
+				if err != nil {
+					return err
+				}
+				for _, login := range logins {
+					added, err := task.SetupHelper(login)
+					if err != nil {
+						return err
+					} else if added {
+						fmt.Printf("Added \"%s\"\n", login.Name)
+					} else {
+						fmt.Printf("\"%s\" has already been added!\n", login.Name)
+					}
+				}
+				return nil
+			},
+		},
+		{
+			Name:        "get",
+			Description: "Get token to auth",
+			Action: func(_ context.Context, cmd *cli.Command) error {
+				wants := map[string]string{}
+				s := bufio.NewScanner(os.Stdin)
+				for s.Scan() {
+					line := s.Text()
+					if line == "" {
+						break
+					}
+					parts := strings.SplitN(line, "=", 2)
+					if len(parts) < 2 {
+						continue
+					}
+					key, value := parts[0], parts[1]
+					if key == "url" {
+						u, err := url.Parse(value)
+						if err != nil {
+							return err
+						}
+						wants["protocol"] = u.Scheme
+						wants["host"] = u.Host
+						wants["path"] = u.Path
+						wants["username"] = u.User.Username()
+						wants["password"], _ = u.User.Password()
+					} else {
+						wants[key] = value
+					}
+				}
+
+				if len(wants["host"]) == 0 {
+					log.Fatal("Require hostname")
+				} else if len(wants["protocol"]) == 0 {
+					wants["protocol"] = "http"
+				}
+
+				userConfig := config.GetLoginByHost(wants["host"])
+				if userConfig == nil {
+					log.Fatal("host not exists")
+				} else if len(userConfig.Token) == 0 {
+					log.Fatal("User no set")
+				}
+
+				host, err := url.Parse(userConfig.URL)
+				if err != nil {
+					return err
+				}
+
+				if userConfig.TokenExpiry > 0 && time.Now().Unix() > userConfig.TokenExpiry {
+					// Token is expired, refresh it
+					err = auth.RefreshAccessToken(userConfig)
+					if err != nil {
+						return err
+					}
+
+					// Once token is refreshed, get the latest from the updated config
+					refreshedConfig := config.GetLoginByHost(wants["host"])
+					if refreshedConfig != nil {
+						userConfig = refreshedConfig
+					}
+				}
+
+				_, err = fmt.Fprintf(os.Stdout, "protocol=%s\nhost=%s\nusername=%s\npassword=%s\n", host.Scheme, host.Host, userConfig.User, userConfig.Token)
+				if err != nil {
+					return err
+				}
+
+				return nil
+			},
+		},
+	},
+}

cmd/login/list.go

@@ -1,36 +1,35 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package login
 
 import (
-	"log"
+	"context"
 
 	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/modules/config"
 	"code.gitea.io/tea/modules/print"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLoginList represents to login a gitea server.
 var CmdLoginList = cli.Command{
-	Name:        "ls",
-	Aliases:     []string{"list"},
+	Name:        "list",
+	Aliases:     []string{"ls"},
 	Usage:       "List Gitea logins",
 	Description: `List Gitea logins`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      RunLoginList,
 	Flags:       []cli.Flag{&flags.OutputFlag},
 }
 
 // RunLoginList list all logins
-func RunLoginList(_ *cli.Context) error {
+func RunLoginList(_ context.Context, cmd *cli.Command) error {
 	logins, err := config.GetLogins()
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
-
-	print.LoginsList(logins, flags.GlobalOutputValue)
+	print.LoginsList(logins, cmd.String("output"))
 	return nil
 }

cmd/login/oauth_refresh.go

@@ -0,0 +1,59 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package login
+
+import (
+	"context"
+	"fmt"
+
+	"code.gitea.io/tea/modules/auth"
+	"code.gitea.io/tea/modules/config"
+
+	"github.com/urfave/cli/v3"
+)
+
+// CmdLoginOAuthRefresh represents a command to refresh an OAuth token
+var CmdLoginOAuthRefresh = cli.Command{
+	Name:        "oauth-refresh",
+	Usage:       "Refresh an OAuth token",
+	Description: "Manually refresh an expired OAuth token. Usually only used when troubleshooting authentication.",
+	ArgsUsage:   "[<login name>]",
+	Action:      runLoginOAuthRefresh,
+}
+
+func runLoginOAuthRefresh(_ context.Context, cmd *cli.Command) error {
+	var loginName string
+
+	// Get login name from args or use default
+	if cmd.Args().Len() > 0 {
+		loginName = cmd.Args().First()
+	} else {
+		// Get default login
+		login, err := config.GetDefaultLogin()
+		if err != nil {
+			return fmt.Errorf("no login specified and no default login found: %s", err)
+		}
+		loginName = login.Name
+	}
+
+	// Get the login from config
+	login := config.GetLoginByName(loginName)
+	if login == nil {
+		return fmt.Errorf("login '%s' not found", loginName)
+	}
+
+	// Check if the login has a refresh token
+	if login.RefreshToken == "" {
+		return fmt.Errorf("login '%s' does not have a refresh token. It may have been created using a different authentication method", loginName)
+	}
+
+	// Refresh the token
+	err := auth.RefreshAccessToken(login)
+	if err != nil {
+		return fmt.Errorf("failed to refresh token: %s", err)
+	}
+
+	fmt.Printf("Successfully refreshed OAuth token for %s\n", loginName)
+	return nil
+}

cmd/logout.go

@@ -1,18 +1,18 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
 import (
 	"code.gitea.io/tea/cmd/login"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdLogout represents to logout a gitea server.
 var CmdLogout = cli.Command{
 	Name:        "logout",
+	Category:    catSetup,
 	Usage:       "Log out from a Gitea server",
 	Description: `Log out from a Gitea server`,
 	ArgsUsage:   "<login name>",

cmd/milestones.go

@@ -1,27 +1,27 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
 import (
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/cmd/milestones"
-	"code.gitea.io/tea/modules/config"
-	"code.gitea.io/tea/modules/print"
+	stdctx "context"
 
-	"github.com/urfave/cli/v2"
+	"code.gitea.io/tea/cmd/milestones"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdMilestones represents to operate repositories milestones.
 var CmdMilestones = cli.Command{
 	Name:        "milestones",
 	Aliases:     []string{"milestone", "ms"},
+	Category:    catEntities,
 	Usage:       "List and create milestones",
 	Description: `List and create milestones`,
 	ArgsUsage:   "[<milestone name>]",
 	Action:      runMilestones,
-	Subcommands: []*cli.Command{
+	Commands: []*cli.Command{
 		&milestones.CmdMilestonesList,
 		&milestones.CmdMilestonesCreate,
 		&milestones.CmdMilestonesClose,
@@ -29,21 +29,22 @@ var CmdMilestones = cli.Command{
 		&milestones.CmdMilestonesReopen,
 		&milestones.CmdMilestonesIssues,
 	},
-	Flags: flags.AllDefaultFlags,
+	Flags: milestones.CmdMilestonesList.Flags,
 }
 
-func runMilestones(ctx *cli.Context) error {
-	if ctx.Args().Len() == 1 {
-		return runMilestoneDetail(ctx.Args().First())
+func runMilestones(ctx stdctx.Context, cmd *cli.Command) error {
+	if cmd.Args().Len() == 1 {
+		return runMilestoneDetail(ctx, cmd, cmd.Args().First())
 	}
-	return milestones.RunMilestonesList(ctx)
+	return milestones.RunMilestonesList(ctx, cmd)
 }
 
-func runMilestoneDetail(name string) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
+func runMilestoneDetail(_ stdctx.Context, cmd *cli.Command, name string) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
 
-	milestone, _, err := client.GetMilestoneByName(owner, repo, name)
+	milestone, _, err := client.GetMilestoneByName(ctx.Owner, ctx.Repo, name)
 	if err != nil {
 		return err
 	}

cmd/milestones/close.go

@@ -1,26 +1,26 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package milestones
 
 import (
-	"code.gitea.io/tea/cmd/flags"
+	"context"
 
-	"github.com/urfave/cli/v2"
+	"code.gitea.io/tea/cmd/flags"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdMilestonesClose represents a sub command of milestones to close an milestone
 var CmdMilestonesClose = cli.Command{
 	Name:        "close",
-	Usage:       "Change state of an milestone to 'closed'",
-	Description: `Change state of an milestone to 'closed'`,
-	ArgsUsage:   "<milestone name>",
-	Action: func(ctx *cli.Context) error {
-		if ctx.Bool("force") {
-			return deleteMilestone(ctx)
+	Usage:       "Change state of one or more milestones to 'closed'",
+	Description: `Change state of one or more milestones to 'closed'`,
+	ArgsUsage:   "<milestone name> [<milestone name>...]",
+	Action: func(ctx context.Context, cmd *cli.Command) error {
+		if cmd.Bool("force") {
+			return deleteMilestone(ctx, cmd)
 		}
-		return editMilestoneStatus(ctx, true)
+		return editMilestoneStatus(ctx, cmd, true)
 	},
 	Flags: append([]cli.Flag{
 		&cli.BoolFlag{

cmd/milestones/create.go

@@ -1,26 +1,29 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package milestones
 
 import (
-	"fmt"
-	"log"
+	"time"
 
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
-	"code.gitea.io/tea/modules/print"
+	stdctx "context"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/interact"
+	"code.gitea.io/tea/modules/task"
+	"github.com/araddon/dateparse"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdMilestonesCreate represents a sub command of milestones to create milestone
 var CmdMilestonesCreate = cli.Command{
 	Name:        "create",
+	Aliases:     []string{"c"},
 	Usage:       "Create an milestone on repository",
 	Description: `Create an milestone on repository`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runMilestonesCreate,
 	Flags: append([]cli.Flag{
 		&cli.StringFlag{
@@ -33,6 +36,11 @@ var CmdMilestonesCreate = cli.Command{
 			Aliases: []string{"d"},
 			Usage:   "milestone description to create",
 		},
+		&cli.StringFlag{
+			Name:    "deadline",
+			Aliases: []string{"expires", "x"},
+			Usage:   "set milestone deadline (default is no due date)",
+		},
 		&cli.StringFlag{
 			Name:        "state",
 			Usage:       "set milestone state (default is open)",
@@ -41,13 +49,17 @@ var CmdMilestonesCreate = cli.Command{
 	}, flags.AllDefaultFlags...),
 }
 
-func runMilestonesCreate(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runMilestonesCreate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
 
-	title := ctx.String("title")
-	if len(title) == 0 {
-		fmt.Printf("Title is required\n")
-		return nil
+	date := ctx.String("deadline")
+	deadline := &time.Time{}
+	if date != "" {
+		t, err := dateparse.ParseAny(date)
+		if err != nil {
+			return err
+		}
+		deadline = &t
 	}
 
 	state := gitea.StateOpen
@@ -55,15 +67,17 @@ func runMilestonesCreate(ctx *cli.Context) error {
 		state = gitea.StateClosed
 	}
 
-	mile, _, err := login.Client().CreateMilestone(owner, repo, gitea.CreateMilestoneOption{
-		Title:       title,
-		Description: ctx.String("description"),
-		State:       state,
-	})
-	if err != nil {
-		log.Fatal(err)
+	if ctx.NumFlags() == 0 {
+		return interact.CreateMilestone(ctx.Login, ctx.Owner, ctx.Repo)
 	}
 
-	print.MilestoneDetails(mile)
-	return nil
+	return task.CreateMilestone(
+		ctx.Login,
+		ctx.Owner,
+		ctx.Repo,
+		ctx.String("title"),
+		ctx.String("description"),
+		deadline,
+		state,
+	)
 }

cmd/milestones/delete.go

@@ -1,14 +1,15 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package milestones
 
 import (
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	stdctx "context"
 
-	"github.com/urfave/cli/v2"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+
+	"github.com/urfave/cli/v3"
 )
 
 // CmdMilestonesDelete represents a sub command of milestones to delete an milestone
@@ -22,10 +23,11 @@ var CmdMilestonesDelete = cli.Command{
 	Flags:       flags.AllDefaultFlags,
 }
 
-func deleteMilestone(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
+func deleteMilestone(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
 
-	_, err := client.DeleteMilestoneByName(owner, repo, ctx.Args().First())
+	_, err := client.DeleteMilestoneByName(ctx.Owner, ctx.Repo, ctx.Args().First())
 	return err
 }

cmd/milestones/issues.go

@@ -1,21 +1,25 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package milestones
 
 import (
 	"fmt"
 
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
-	"code.gitea.io/tea/modules/print"
-	"code.gitea.io/tea/modules/utils"
+	stdctx "context"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+	"code.gitea.io/tea/modules/utils"
+	"github.com/urfave/cli/v3"
 )
 
+var msIssuesFieldsFlag = flags.FieldsFlag(print.IssueFields, []string{
+	"index", "kind", "title", "state", "updated", "labels",
+})
+
 // CmdMilestonesIssues represents a sub command of milestones to manage issue/pull of an milestone
 var CmdMilestonesIssues = cli.Command{
 	Name:        "issues",
@@ -24,7 +28,7 @@ var CmdMilestonesIssues = cli.Command{
 	Description: "manage issue/pull of an milestone",
 	ArgsUsage:   "<milestone name>",
 	Action:      runMilestoneIssueList,
-	Subcommands: []*cli.Command{
+	Commands: []*cli.Command{
 		&CmdMilestoneAddIssue,
 		&CmdMilestoneRemoveIssue,
 	},
@@ -40,6 +44,7 @@ var CmdMilestonesIssues = cli.Command{
 		},
 		&flags.PaginationPageFlag,
 		&flags.PaginationLimitFlag,
+		msIssuesFieldsFlag,
 	}, flags.AllDefaultFlags...),
 }
 
@@ -65,9 +70,10 @@ var CmdMilestoneRemoveIssue = cli.Command{
 	Flags:       flags.AllDefaultFlags,
 }
 
-func runMilestoneIssueList(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
+func runMilestoneIssueList(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
 
 	state := gitea.StateOpen
 	switch ctx.String("state") {
@@ -91,13 +97,13 @@ func runMilestoneIssueList(ctx *cli.Context) error {
 
 	milestone := ctx.Args().First()
 	// make sure milestone exist
-	_, _, err := client.GetMilestoneByName(owner, repo, milestone)
+	_, _, err := client.GetMilestoneByName(ctx.Owner, ctx.Repo, milestone)
 	if err != nil {
 		return err
 	}
 
-	issues, _, err := client.ListRepoIssues(owner, repo, gitea.ListIssueOption{
-		ListOptions: flags.GetListOptions(ctx),
+	issues, _, err := client.ListRepoIssues(ctx.Owner, ctx.Repo, gitea.ListIssueOption{
+		ListOptions: ctx.GetListOptions(),
 		Milestones:  []string{milestone},
 		Type:        kind,
 		State:       state,
@@ -106,13 +112,18 @@ func runMilestoneIssueList(ctx *cli.Context) error {
 		return err
 	}
 
-	print.IssuesPullsList(issues, flags.GlobalOutputValue)
+	fields, err := msIssuesFieldsFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
+	print.IssuesPullsList(issues, ctx.Output, fields)
 	return nil
 }
 
-func runMilestoneIssueAdd(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
+func runMilestoneIssueAdd(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
 	if ctx.Args().Len() != 2 {
 		return fmt.Errorf("need two arguments")
 	}
@@ -125,20 +136,21 @@ func runMilestoneIssueAdd(ctx *cli.Context) error {
 	}
 
 	// make sure milestone exist
-	mile, _, err := client.GetMilestoneByName(owner, repo, mileName)
+	mile, _, err := client.GetMilestoneByName(ctx.Owner, ctx.Repo, mileName)
 	if err != nil {
 		return err
 	}
 
-	_, _, err = client.EditIssue(owner, repo, idx, gitea.EditIssueOption{
+	_, _, err = client.EditIssue(ctx.Owner, ctx.Repo, idx, gitea.EditIssueOption{
 		Milestone: &mile.ID,
 	})
 	return err
 }
 
-func runMilestoneIssueRemove(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
+func runMilestoneIssueRemove(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
 	if ctx.Args().Len() != 2 {
 		return fmt.Errorf("need two arguments")
 	}
@@ -150,7 +162,7 @@ func runMilestoneIssueRemove(ctx *cli.Context) error {
 		return err
 	}
 
-	issue, _, err := client.GetIssue(owner, repo, idx)
+	issue, _, err := client.GetIssue(ctx.Owner, ctx.Repo, idx)
 	if err != nil {
 		return err
 	}
@@ -164,7 +176,7 @@ func runMilestoneIssueRemove(ctx *cli.Context) error {
 	}
 
 	zero := int64(0)
-	_, _, err = client.EditIssue(owner, repo, idx, gitea.EditIssueOption{
+	_, _, err = client.EditIssue(ctx.Owner, ctx.Repo, idx, gitea.EditIssueOption{
 		Milestone: &zero,
 	})
 	return err

cmd/milestones/list.go

@@ -1,28 +1,33 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package milestones
 
 import (
-	"log"
+	stdctx "context"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/print"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
+var fieldsFlag = flags.FieldsFlag(print.MilestoneFields, []string{
+	"title", "items", "duedate",
+})
+
 // CmdMilestonesList represents a sub command of milestones to list milestones
 var CmdMilestonesList = cli.Command{
-	Name:        "ls",
-	Aliases:     []string{"list"},
+	Name:        "list",
+	Aliases:     []string{"ls"},
 	Usage:       "List milestones of the repository",
 	Description: `List milestones of the repository`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      RunMilestonesList,
 	Flags: append([]cli.Flag{
+		fieldsFlag,
 		&cli.StringFlag{
 			Name:        "state",
 			Usage:       "Filter by milestone state (all|open|closed)",
@@ -34,26 +39,36 @@ var CmdMilestonesList = cli.Command{
 }
 
 // RunMilestonesList list milestones
-func RunMilestonesList(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func RunMilestonesList(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+
+	fields, err := fieldsFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
 
 	state := gitea.StateOpen
 	switch ctx.String("state") {
 	case "all":
 		state = gitea.StateAll
+		if !cmd.IsSet("fields") { // add to default fields
+			fields = append(fields, "state")
+		}
 	case "closed":
 		state = gitea.StateClosed
 	}
 
-	milestones, _, err := login.Client().ListRepoMilestones(owner, repo, gitea.ListMilestoneOption{
-		ListOptions: flags.GetListOptions(ctx),
+	client := ctx.Login.Client()
+	milestones, _, err := client.ListRepoMilestones(ctx.Owner, ctx.Repo, gitea.ListMilestoneOption{
+		ListOptions: ctx.GetListOptions(),
 		State:       state,
 	})
 
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
 
-	print.MilestonesList(milestones, flags.GlobalOutputValue, state)
+	print.MilestonesList(milestones, ctx.Output, fields)
 	return nil
 }

cmd/milestones/reopen.go

@@ -1,42 +1,61 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package milestones
 
 import (
+	stdctx "context"
+	"fmt"
+
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdMilestonesReopen represents a sub command of milestones to open an milestone
 var CmdMilestonesReopen = cli.Command{
 	Name:        "reopen",
 	Aliases:     []string{"open"},
-	Usage:       "Change state of an milestone to 'open'",
-	Description: `Change state of an milestone to 'open'`,
-	ArgsUsage:   "<milestone name>",
-	Action: func(ctx *cli.Context) error {
-		return editMilestoneStatus(ctx, false)
+	Usage:       "Change state of one or more milestones to 'open'",
+	Description: `Change state of one or more milestones to 'open'`,
+	ArgsUsage:   "<milestone name> [<milestone name> ...]",
+	Action: func(ctx stdctx.Context, cmd *cli.Command) error {
+		return editMilestoneStatus(ctx, cmd, false)
 	},
 	Flags: flags.AllDefaultFlags,
 }
 
-func editMilestoneStatus(ctx *cli.Context, close bool) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
+func editMilestoneStatus(_ stdctx.Context, cmd *cli.Command, close bool) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	if ctx.Args().Len() == 0 {
+		return fmt.Errorf(ctx.Command.ArgsUsage)
+	}
 
 	state := gitea.StateOpen
 	if close {
 		state = gitea.StateClosed
 	}
-	_, _, err := client.EditMilestoneByName(owner, repo, ctx.Args().First(), gitea.EditMilestoneOption{
-		State: &state,
-		Title: ctx.Args().First(),
-	})
 
+	client := ctx.Login.Client()
+	for _, ms := range ctx.Args().Slice() {
+		opts := gitea.EditMilestoneOption{
+			State: &state,
+			Title: ms,
+		}
+		milestone, _, err := client.EditMilestoneByName(ctx.Owner, ctx.Repo, ms, opts)
+		if err != nil {
 			return err
 		}
+
+		if ctx.Args().Len() > 1 {
+			fmt.Printf("%s/milestone/%d\n", ctx.GetRemoteRepoHTMLURL(), milestone.ID)
+		} else {
+			print.MilestoneDetails(milestone)
+		}
+	}
+	return nil
+}

cmd/notifications.go

@@ -1,82 +1,28 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
 import (
-	"log"
+	"code.gitea.io/tea/cmd/notifications"
 
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
-	"code.gitea.io/tea/modules/print"
-
-	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdNotifications is the main command to operate with notifications
 var CmdNotifications = cli.Command{
 	Name:        "notifications",
-	Aliases:     []string{"notification", "notif"},
+	Aliases:     []string{"notification", "n"},
+	Category:    catHelpers,
 	Usage:       "Show notifications",
-	Description: "Show notifications, by default based of the current repo and unread one",
-	Action:      runNotifications,
-	Flags: append([]cli.Flag{
-		&cli.BoolFlag{
-			Name:    "all",
-			Aliases: []string{"a"},
-			Usage:   "show all notifications of related gitea instance",
+	Description: "Show notifications, by default based on the current repo if available",
+	Action:      notifications.RunNotificationsList,
+	Commands: []*cli.Command{
+		&notifications.CmdNotificationsList,
+		&notifications.CmdNotificationsMarkRead,
+		&notifications.CmdNotificationsMarkUnread,
+		&notifications.CmdNotificationsMarkPinned,
+		&notifications.CmdNotificationsUnpin,
 	},
-		&cli.BoolFlag{
-			Name:    "read",
-			Aliases: []string{"rd"},
-			Usage:   "show read notifications instead unread",
-		},
-		&cli.BoolFlag{
-			Name:    "pinned",
-			Aliases: []string{"pd"},
-			Usage:   "show pinned notifications instead unread",
-		},
-		&flags.PaginationPageFlag,
-		&flags.PaginationLimitFlag,
-	}, flags.AllDefaultFlags...),
-}
-
-func runNotifications(ctx *cli.Context) error {
-	var news []*gitea.NotificationThread
-	var err error
-
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-
-	listOpts := flags.GetListOptions(ctx)
-	if listOpts.Page == 0 {
-		listOpts.Page = 1
-	}
-
-	var status []gitea.NotifyStatus
-	if ctx.Bool("read") {
-		status = []gitea.NotifyStatus{gitea.NotifyStatusRead}
-	}
-	if ctx.Bool("pinned") {
-		status = append(status, gitea.NotifyStatusPinned)
-	}
-
-	if ctx.Bool("all") {
-		news, _, err = login.Client().ListNotifications(gitea.ListNotificationOptions{
-			ListOptions: listOpts,
-			Status:      status,
-		})
-	} else {
-		news, _, err = login.Client().ListRepoNotifications(owner, repo, gitea.ListNotificationOptions{
-			ListOptions: listOpts,
-			Status:      status,
-		})
-	}
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	print.NotificationsList(news, flags.GlobalOutputValue, ctx.Bool("all"))
-	return nil
+	Flags: notifications.CmdNotificationsList.Flags,
 }

cmd/notifications/list.go

@@ -0,0 +1,107 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package notifications
+
+import (
+	stdctx "context"
+	"log"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+var notifyFieldsFlag = flags.FieldsFlag(print.NotificationFields, []string{
+	"id", "status", "index", "type", "state", "title",
+})
+
+var notifyTypeFlag = flags.NewCsvFlag("types", "subject types to filter by", []string{"t"},
+	[]string{"issue", "pull", "repository", "commit"}, nil)
+
+// CmdNotificationsList represents a sub command of notifications to list notifications
+var CmdNotificationsList = cli.Command{
+	Name:        "ls",
+	Aliases:     []string{"list"},
+	Usage:       "List notifications",
+	Description: `List notifications`,
+	ArgsUsage:   " ", // command does not accept arguments
+	Action:      RunNotificationsList,
+	Flags: append([]cli.Flag{
+		notifyFieldsFlag,
+		notifyTypeFlag,
+	}, flags.NotificationFlags...),
+}
+
+// RunNotificationsList list notifications
+func RunNotificationsList(ctx stdctx.Context, cmd *cli.Command) error {
+	var states []gitea.NotifyStatus
+	statesStr, err := flags.NotificationStateFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
+	for _, s := range statesStr {
+		states = append(states, gitea.NotifyStatus(s))
+	}
+
+	var types []gitea.NotifySubjectType
+	typesStr, err := notifyTypeFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
+	for _, t := range typesStr {
+		types = append(types, gitea.NotifySubjectType(t))
+	}
+
+	return listNotifications(ctx, cmd, states, types)
+}
+
+// listNotifications will get the notifications based on status and subject type
+func listNotifications(_ stdctx.Context, cmd *cli.Command, status []gitea.NotifyStatus, subjects []gitea.NotifySubjectType) error {
+	var news []*gitea.NotificationThread
+	var err error
+
+	ctx := context.InitCommand(cmd)
+	client := ctx.Login.Client()
+	all := ctx.Bool("mine")
+
+	// This enforces pagination (see https://github.com/go-gitea/gitea/issues/16733)
+	listOpts := ctx.GetListOptions()
+	if listOpts.Page == 0 {
+		listOpts.Page = 1
+	}
+
+	fields, err := notifyFieldsFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
+
+	if all {
+		// add repository to the default fields
+		if !cmd.IsSet("fields") {
+			fields = append(fields, "repository")
+		}
+
+		news, _, err = client.ListNotifications(gitea.ListNotificationOptions{
+			ListOptions:  listOpts,
+			Status:       status,
+			SubjectTypes: subjects,
+		})
+	} else {
+		ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+		news, _, err = client.ListRepoNotifications(ctx.Owner, ctx.Repo, gitea.ListNotificationOptions{
+			ListOptions:  listOpts,
+			Status:       status,
+			SubjectTypes: subjects,
+		})
+	}
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	print.NotificationsList(news, ctx.Output, fields)
+	return nil
+}

cmd/notifications/mark_as.go

@@ -0,0 +1,139 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package notifications
+
+import (
+	stdctx "context"
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/utils"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdNotificationsMarkRead represents a sub command of notifications to list read notifications
+var CmdNotificationsMarkRead = cli.Command{
+	Name:        "read",
+	Aliases:     []string{"r"},
+	Usage:       "Mark all filtered or a specific notification as read",
+	Description: "Mark all filtered or a specific notification as read",
+	ArgsUsage:   "[all | <notification id>]",
+	Flags:       flags.NotificationFlags,
+	Action: func(_ stdctx.Context, cmd *cli.Command) error {
+		ctx := context.InitCommand(cmd)
+		filter, err := flags.NotificationStateFlag.GetValues(cmd)
+		if err != nil {
+			return err
+		}
+		if !ctx.IsSet(flags.NotificationStateFlag.Name) {
+			filter = []string{string(gitea.NotifyStatusUnread)}
+		}
+		return markNotificationAs(ctx, filter, gitea.NotifyStatusRead)
+	},
+}
+
+// CmdNotificationsMarkUnread will mark notifications as unread.
+var CmdNotificationsMarkUnread = cli.Command{
+	Name:        "unread",
+	Aliases:     []string{"u"},
+	Usage:       "Mark all filtered or a specific notification as unread",
+	Description: "Mark all filtered or a specific notification as unread",
+	ArgsUsage:   "[all | <notification id>]",
+	Flags:       flags.NotificationFlags,
+	Action: func(_ stdctx.Context, cmd *cli.Command) error {
+		ctx := context.InitCommand(cmd)
+		filter, err := flags.NotificationStateFlag.GetValues(cmd)
+		if err != nil {
+			return err
+		}
+		if !ctx.IsSet(flags.NotificationStateFlag.Name) {
+			filter = []string{string(gitea.NotifyStatusRead)}
+		}
+		return markNotificationAs(ctx, filter, gitea.NotifyStatusUnread)
+	},
+}
+
+// CmdNotificationsMarkPinned will mark notifications as unread.
+var CmdNotificationsMarkPinned = cli.Command{
+	Name:        "pin",
+	Aliases:     []string{"p"},
+	Usage:       "Mark all filtered or a specific notification as pinned",
+	Description: "Mark all filtered or a specific notification as pinned",
+	ArgsUsage:   "[all | <notification id>]",
+	Flags:       flags.NotificationFlags,
+	Action: func(_ stdctx.Context, cmd *cli.Command) error {
+		ctx := context.InitCommand(cmd)
+		filter, err := flags.NotificationStateFlag.GetValues(cmd)
+		if err != nil {
+			return err
+		}
+		if !ctx.IsSet(flags.NotificationStateFlag.Name) {
+			filter = []string{string(gitea.NotifyStatusUnread)}
+		}
+		return markNotificationAs(ctx, filter, gitea.NotifyStatusPinned)
+	},
+}
+
+// CmdNotificationsUnpin will mark pinned notifications as unread.
+var CmdNotificationsUnpin = cli.Command{
+	Name:        "unpin",
+	Usage:       "Unpin all pinned or a specific notification",
+	Description: "Marks all pinned or a specific notification as read",
+	ArgsUsage:   "[all | <notification id>]",
+	Flags:       flags.NotificationFlags,
+	Action: func(_ stdctx.Context, cmd *cli.Command) error {
+		ctx := context.InitCommand(cmd)
+		filter := []string{string(gitea.NotifyStatusPinned)}
+		// NOTE: we implicitly mark it as read, to match web UI semantics. marking as unread might be more useful?
+		return markNotificationAs(ctx, filter, gitea.NotifyStatusRead)
+	},
+}
+
+func markNotificationAs(cmd *context.TeaContext, filterStates []string, targetState gitea.NotifyStatus) (err error) {
+	client := cmd.Login.Client()
+	subject := cmd.Args().First()
+	allRepos := cmd.Bool("mine")
+
+	states := []gitea.NotifyStatus{}
+	for _, s := range filterStates {
+		states = append(states, gitea.NotifyStatus(s))
+	}
+
+	switch subject {
+	case "", "all":
+		opts := gitea.MarkNotificationOptions{Status: states, ToStatus: targetState}
+
+		if allRepos {
+			_, _, err = client.ReadNotifications(opts)
+		} else {
+			cmd.Ensure(context.CtxRequirement{RemoteRepo: true})
+			_, _, err = client.ReadRepoNotifications(cmd.Owner, cmd.Repo, opts)
+		}
+
+		// TODO: print all affected notification subject URLs
+		// (not supported by API currently, https://github.com/go-gitea/gitea/issues/16797)
+
+	default:
+		id, err := utils.ArgToIndex(subject)
+		if err != nil {
+			return err
+		}
+		_, _, err = client.ReadNotification(id, targetState)
+		if err != nil {
+			return err
+		}
+
+		n, _, err := client.GetNotification(id)
+		if err != nil {
+			return err
+		}
+		// FIXME: this is an API URL, we want to display a web ui link..
+		fmt.Println(n.Subject.URL)
+		return nil
+	}
+
+	return err
+}

cmd/open.go

@@ -1,33 +1,35 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
 import (
-	"log"
+	stdctx "context"
 	"path"
 	"strings"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	local_git "code.gitea.io/tea/modules/git"
 
 	"github.com/skratchdot/open-golang/open"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdOpen represents a sub command of issues to open issue on the web browser
 var CmdOpen = cli.Command{
 	Name:        "open",
-	Usage:       "Open something of the repository on web browser",
-	Description: `Open something of the repository on web browser`,
+	Aliases:     []string{"o"},
+	Category:    catHelpers,
+	Usage:       "Open something of the repository in web browser",
+	Description: `Open something of the repository in web browser`,
 	Action:      runOpen,
 	Flags:       append([]cli.Flag{}, flags.LoginRepoFlags...),
 }
 
-func runOpen(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runOpen(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 
 	var suffix string
 	number := ctx.Args().Get(0)
@@ -41,12 +43,11 @@ func runOpen(ctx *cli.Context) error {
 	case strings.EqualFold(number, "commits"):
 		repo, err := local_git.RepoForWorkdir()
 		if err != nil {
-			log.Fatal(err)
+			return err
 		}
 		b, err := repo.Head()
 		if err != nil {
-			log.Fatal(err)
-			return nil
+			return err
 		}
 		name := b.Name()
 		switch {
@@ -73,11 +74,5 @@ func runOpen(ctx *cli.Context) error {
 		suffix = number
 	}
 
-	u := path.Join(login.URL, owner, repo, suffix)
-	err := open.Run(u)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	return nil
+	return open.Run(path.Join(ctx.GetRemoteRepoHTMLURL(), suffix))
 }

cmd/organizations.go

@@ -1,40 +1,49 @@
 // Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
 import (
-	"log"
+	stdctx "context"
 
 	"code.gitea.io/tea/cmd/organizations"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdOrgs represents handle organization
 var CmdOrgs = cli.Command{
 	Name:        "organizations",
 	Aliases:     []string{"organization", "org"},
+	Category:    catEntities,
 	Usage:       "List, create, delete organizations",
 	Description: "Show organization details",
 	ArgsUsage:   "[<organization>]",
 	Action:      runOrganizations,
-	Subcommands: []*cli.Command{
+	Commands: []*cli.Command{
 		&organizations.CmdOrganizationList,
+		&organizations.CmdOrganizationCreate,
 		&organizations.CmdOrganizationDelete,
 	},
+	Flags: organizations.CmdOrganizationList.Flags,
 }
 
-func runOrganizations(ctx *cli.Context) error {
-	if ctx.Args().Len() == 1 {
-		return runOrganizationDetail(ctx.Args().First())
+func runOrganizations(ctx stdctx.Context, cmd *cli.Command) error {
+	teaCtx := context.InitCommand(cmd)
+	if teaCtx.Args().Len() == 1 {
+		return runOrganizationDetail(teaCtx)
 	}
-	return organizations.RunOrganizationList(ctx)
+	return organizations.RunOrganizationList(ctx, cmd)
 }
 
-func runOrganizationDetail(path string) error {
+func runOrganizationDetail(ctx *context.TeaContext) error {
+	org, _, err := ctx.Login.Client().GetOrg(ctx.Args().First())
+	if err != nil {
+		return err
+	}
 
-	log.Fatal("Not yet implemented.")
+	print.OrganizationDetails(org)
 	return nil
 }

cmd/organizations/create.go

@@ -0,0 +1,90 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package organizations
+
+import (
+	"fmt"
+
+	stdctx "context"
+
+	"code.gitea.io/sdk/gitea"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdOrganizationCreate represents a sub command of organizations to delete a given user organization
+var CmdOrganizationCreate = cli.Command{
+	Name:        "create",
+	Aliases:     []string{"c"},
+	Usage:       "Create an organization",
+	Description: "Create an organization",
+	Action:      RunOrganizationCreate,
+	ArgsUsage:   "<organization name>",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:    "name",
+			Aliases: []string{"n"},
+		},
+		&cli.StringFlag{
+			Name:    "description",
+			Aliases: []string{"d"},
+		},
+		&cli.StringFlag{
+			Name:    "website",
+			Aliases: []string{"w"},
+		},
+		&cli.StringFlag{
+			Name:    "location",
+			Aliases: []string{"L"},
+		},
+		&cli.StringFlag{
+			Name:    "visibility",
+			Aliases: []string{"v"},
+		},
+		&cli.BoolFlag{
+			Name: "repo-admins-can-change-team-access",
+		},
+		&flags.LoginFlag,
+	},
+}
+
+// RunOrganizationCreate sets up a new organization
+func RunOrganizationCreate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+
+	if ctx.Args().Len() < 1 {
+		return fmt.Errorf("You have to specify the organization name you want to create")
+	}
+
+	var visibility gitea.VisibleType
+	switch ctx.String("visibility") {
+	case "", "public":
+		visibility = gitea.VisibleTypePublic
+	case "private":
+		visibility = gitea.VisibleTypePrivate
+	case "limited":
+		visibility = gitea.VisibleTypeLimited
+	default:
+		return fmt.Errorf("unknown visibility '%s'", ctx.String("visibility"))
+	}
+
+	org, _, err := ctx.Login.Client().CreateOrg(gitea.CreateOrgOption{
+		Name: ctx.Args().First(),
+		// FullName: , // not really meaningful for orgs (not displayed in webui, use description instead?)
+		Description:               ctx.String("description"),
+		Website:                   ctx.String("website"),
+		Location:                  ctx.String("location"),
+		RepoAdminChangeTeamAccess: ctx.Bool("repo-admins-can-change-team-access"),
+		Visibility:                visibility,
+	})
+	if err != nil {
+		return err
+	}
+
+	print.OrganizationDetails(org)
+
+	return err
+}

cmd/organizations/delete.go

@@ -1,15 +1,15 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package organizations
 
 import (
-	"log"
+	stdctx "context"
+	"fmt"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
-	"github.com/urfave/cli/v2"
+	"code.gitea.io/tea/modules/context"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdOrganizationDelete represents a sub command of organizations to delete a given user organization
@@ -20,23 +20,25 @@ var CmdOrganizationDelete = cli.Command{
 	Description: "Delete users organizations",
 	ArgsUsage:   "<organization name>",
 	Action:      RunOrganizationDelete,
+	Flags: []cli.Flag{
+		&flags.LoginFlag,
+		&flags.RemoteFlag,
+	},
 }
 
 // RunOrganizationDelete delete user organization
-func RunOrganizationDelete(ctx *cli.Context) error {
-	login, _, _ := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func RunOrganizationDelete(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
 
-	client := login.Client()
+	client := ctx.Login.Client()
 
 	if ctx.Args().Len() < 1 {
-		log.Fatal("You have to specify the organization name you want to delete.")
-		return nil
+		return fmt.Errorf("You have to specify the organization name you want to delete")
 	}
 
 	response, err := client.DeleteOrg(ctx.Args().First())
 	if response != nil && response.StatusCode == 404 {
-		log.Fatal("The given organization does not exist.")
-		return nil
+		return fmt.Errorf("The given organization does not exist")
 	}
 
 	return err

cmd/organizations/list.go

@@ -1,26 +1,25 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package organizations
 
 import (
-	"log"
-
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
-	"code.gitea.io/tea/modules/print"
+	stdctx "context"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdOrganizationList represents a sub command of organizations to list users organizations
 var CmdOrganizationList = cli.Command{
-	Name:        "ls",
-	Aliases:     []string{"list"},
+	Name:        "list",
+	Aliases:     []string{"ls"},
 	Usage:       "List Organizations",
 	Description: "List users organizations",
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      RunOrganizationList,
 	Flags: append([]cli.Flag{
 		&flags.PaginationPageFlag,
@@ -29,17 +28,18 @@ var CmdOrganizationList = cli.Command{
 }
 
 // RunOrganizationList list user organizations
-func RunOrganizationList(ctx *cli.Context) error {
-	login, _, _ := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func RunOrganizationList(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	client := ctx.Login.Client()
 
-	client := login.Client()
-
-	userOrganizations, _, err := client.ListUserOrgs(login.User, gitea.ListOrgsOptions{ListOptions: flags.GetListOptions(ctx)})
+	userOrganizations, _, err := client.ListUserOrgs(ctx.Login.User, gitea.ListOrgsOptions{
+		ListOptions: ctx.GetListOptions(),
+	})
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
 
-	print.OrganizationsList(userOrganizations, flags.GlobalOutputValue)
+	print.OrganizationsList(userOrganizations, ctx.Output)
 
 	return nil
 }

cmd/pulls.go

@@ -1,64 +1,96 @@
 // Copyright 2018 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
 import (
+	stdctx "context"
 	"fmt"
 
-	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/cmd/pulls"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/interact"
 	"code.gitea.io/tea/modules/print"
 	"code.gitea.io/tea/modules/utils"
+	"code.gitea.io/tea/modules/workaround"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdPulls is the main command to operate on PRs
 var CmdPulls = cli.Command{
 	Name:        "pulls",
 	Aliases:     []string{"pull", "pr"},
-	Usage:       "List, create, checkout and clean pull requests",
-	Description: `List, create, checkout and clean pull requests`,
+	Category:    catEntities,
+	Usage:       "Manage and checkout pull requests",
+	Description: `Lists PRs when called without argument. If PR index is provided, will show it in detail.`,
 	ArgsUsage:   "[<pull index>]",
 	Action:      runPulls,
-	Flags:       flags.IssuePRFlags,
-	Subcommands: []*cli.Command{
+	Flags: append([]cli.Flag{
+		&cli.BoolFlag{
+			Name:  "comments",
+			Usage: "Whether to display comments (will prompt if not provided & run interactively)",
+		},
+	}, pulls.CmdPullsList.Flags...),
+	Commands: []*cli.Command{
 		&pulls.CmdPullsList,
 		&pulls.CmdPullsCheckout,
 		&pulls.CmdPullsClean,
 		&pulls.CmdPullsCreate,
+		&pulls.CmdPullsClose,
+		&pulls.CmdPullsReopen,
+		&pulls.CmdPullsReview,
+		&pulls.CmdPullsApprove,
+		&pulls.CmdPullsReject,
+		&pulls.CmdPullsMerge,
 	},
 }
 
-func runPulls(ctx *cli.Context) error {
-	if ctx.Args().Len() == 1 {
-		return runPullDetail(ctx.Args().First())
+func runPulls(ctx stdctx.Context, cmd *cli.Command) error {
+	if cmd.Args().Len() == 1 {
+		return runPullDetail(ctx, cmd, cmd.Args().First())
 	}
-	return pulls.RunPullsList(ctx)
+	return pulls.RunPullsList(ctx, cmd)
 }
 
-func runPullDetail(index string) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runPullDetail(_ stdctx.Context, cmd *cli.Command, index string) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 	idx, err := utils.ArgToIndex(index)
 	if err != nil {
 		return err
 	}
 
-	client := login.Client()
-	pr, _, err := client.GetPullRequest(owner, repo, idx)
+	client := ctx.Login.Client()
+	pr, _, err := client.GetPullRequest(ctx.Owner, ctx.Repo, idx)
 	if err != nil {
 		return err
 	}
+	if err := workaround.FixPullHeadSha(client, pr); err != nil {
+		return err
+	}
 
-	reviews, _, err := client.ListPullReviews(owner, repo, idx, gitea.ListPullReviewsOptions{})
+	reviews, _, err := client.ListPullReviews(ctx.Owner, ctx.Repo, idx, gitea.ListPullReviewsOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
+	})
 	if err != nil {
 		fmt.Printf("error while loading reviews: %v\n", err)
 	}
 
-	print.PullDetails(pr, reviews)
+	ci, _, err := client.GetCombinedStatus(ctx.Owner, ctx.Repo, pr.Head.Sha)
+	if err != nil {
+		fmt.Printf("error while loading CI: %v\n", err)
+	}
+
+	print.PullDetails(pr, reviews, ci)
+
+	if pr.Comments > 0 {
+		err = interact.ShowCommentsMaybeInteractive(ctx, idx, pr.Comments)
+		if err != nil {
+			fmt.Printf("error loading comments: %v\n", err)
+		}
+	}
+
 	return nil
 }

cmd/pulls/approve.go

@@ -0,0 +1,45 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package pulls
+
+import (
+	"fmt"
+	"strings"
+
+	stdctx "context"
+
+	"code.gitea.io/sdk/gitea"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/task"
+	"code.gitea.io/tea/modules/utils"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdPullsApprove approves a PR
+var CmdPullsApprove = cli.Command{
+	Name:        "approve",
+	Aliases:     []string{"lgtm", "a"},
+	Usage:       "Approve a pull request",
+	Description: "Approve a pull request",
+	ArgsUsage:   "<pull index> [<comment>]",
+	Action: func(_ stdctx.Context, cmd *cli.Command) error {
+		ctx := context.InitCommand(cmd)
+		ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+
+		if ctx.Args().Len() == 0 {
+			return fmt.Errorf("Must specify a PR index")
+		}
+
+		idx, err := utils.ArgToIndex(ctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		comment := strings.Join(ctx.Args().Tail(), " ")
+
+		return task.CreatePullReview(ctx, idx, gitea.ReviewStateApproved, comment, nil)
+	},
+	Flags: flags.AllDefaultFlags,
+}

cmd/pulls/checkout.go

@@ -1,40 +1,51 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package pulls
 
 import (
-	"log"
+	stdctx "context"
+	"fmt"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/interact"
 	"code.gitea.io/tea/modules/task"
 	"code.gitea.io/tea/modules/utils"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdPullsCheckout is a command to locally checkout the given PR
 var CmdPullsCheckout = cli.Command{
 	Name:        "checkout",
+	Aliases:     []string{"co"},
 	Usage:       "Locally check out the given PR",
 	Description: `Locally check out the given PR`,
 	Action:      runPullsCheckout,
 	ArgsUsage:   "<pull index>",
-	Flags:       flags.AllDefaultFlags,
+	Flags: append([]cli.Flag{
+		&cli.BoolFlag{
+			Name:    "branch",
+			Aliases: []string{"b"},
+			Usage:   "Create a local branch if it doesn't exist yet",
+		},
+	}, flags.AllDefaultFlags...),
 }
 
-func runPullsCheckout(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runPullsCheckout(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{
+		LocalRepo:  true,
+		RemoteRepo: true,
+	})
 	if ctx.Args().Len() != 1 {
-		log.Fatal("Must specify a PR index")
+		return fmt.Errorf("Must specify a PR index")
 	}
 	idx, err := utils.ArgToIndex(ctx.Args().First())
 	if err != nil {
 		return err
 	}
 
-	return task.PullCheckout(login, owner, repo, idx, interact.PromptPassword)
+	return task.PullCheckout(ctx.Login, ctx.Owner, ctx.Repo, ctx.Bool("branch"), idx, interact.PromptPassword)
 }

cmd/pulls/clean.go

@@ -1,19 +1,19 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package pulls
 
 import (
 	"fmt"
 
+	stdctx "context"
+
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/interact"
 	"code.gitea.io/tea/modules/task"
 	"code.gitea.io/tea/modules/utils"
-
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdPullsClean removes the remote and local feature branches, if a PR is merged.
@@ -31,8 +31,9 @@ var CmdPullsClean = cli.Command{
 	}, flags.AllDefaultFlags...),
 }
 
-func runPullsClean(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runPullsClean(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{LocalRepo: true})
 	if ctx.Args().Len() != 1 {
 		return fmt.Errorf("Must specify a PR index")
 	}
@@ -42,5 +43,5 @@ func runPullsClean(ctx *cli.Context) error {
 		return err
 	}
 
-	return task.PullClean(login, owner, repo, idx, ctx.Bool("ignore-sha"), interact.PromptPassword)
+	return task.PullClean(ctx.Login, ctx.Owner, ctx.Repo, idx, ctx.Bool("ignore-sha"), interact.PromptPassword)
 }

cmd/pulls/close.go

@@ -0,0 +1,26 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package pulls
+
+import (
+	"context"
+
+	"code.gitea.io/tea/cmd/flags"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdPullsClose closes a given open pull request
+var CmdPullsClose = cli.Command{
+	Name:        "close",
+	Usage:       "Change state of one or more pull requests to 'closed'",
+	Description: `Change state of one or more pull requests to 'closed'`,
+	ArgsUsage:   "<pull index> [<pull index>...]",
+	Action: func(ctx context.Context, cmd *cli.Command) error {
+		var s = gitea.StateClosed
+		return editPullState(ctx, cmd, gitea.EditPullRequestOption{State: &s})
+	},
+	Flags: flags.AllDefaultFlags,
+}

cmd/pulls/create.go

@@ -1,63 +1,63 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package pulls
 
 import (
+	stdctx "context"
+
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/interact"
 	"code.gitea.io/tea/modules/task"
-
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdPullsCreate creates a pull request
 var CmdPullsCreate = cli.Command{
 	Name:        "create",
+	Aliases:     []string{"c"},
 	Usage:       "Create a pull-request",
-	Description: "Create a pull-request",
+	Description: "Create a pull-request in the current repo",
 	Action:      runPullsCreate,
 	Flags: append([]cli.Flag{
 		&cli.StringFlag{
 			Name:  "head",
-			Usage: "Set head branch (default is current one)",
+			Usage: "Branch name of the PR source (default is current one). To specify a different head repo, use <user>:<branch>",
 		},
 		&cli.StringFlag{
 			Name:    "base",
 			Aliases: []string{"b"},
-			Usage:   "Set base branch (default is default branch)",
+			Usage:   "Branch name of the PR target (default is repos default branch)",
 		},
-		&cli.StringFlag{
-			Name:    "title",
-			Aliases: []string{"t"},
-			Usage:   "Set title of pull (default is head branch name)",
+		&cli.BoolFlag{
+			Name:    "allow-maintainer-edits",
+			Aliases: []string{"edits"},
+			Usage:   "Enable maintainers to push to the base branch of created pull",
+			Value:   true,
 		},
-		&cli.StringFlag{
-			Name:    "description",
-			Aliases: []string{"d"},
-			Usage:   "Set body of new pull",
-		},
-	}, flags.AllDefaultFlags...),
+	}, flags.IssuePRCreateFlags...),
 }
 
-func runPullsCreate(ctx *cli.Context) error {
-	login, ownerArg, repoArg := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runPullsCreate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
 
 	// no args -> interactive mode
 	if ctx.NumFlags() == 0 {
-		return interact.CreatePull(login, ownerArg, repoArg)
+		return interact.CreatePull(ctx)
 	}
 
 	// else use args to create PR
+	opts, err := flags.GetIssuePRCreateFlags(ctx)
+	if err != nil {
+		return err
+	}
+
 	return task.CreatePull(
-		login,
-		ownerArg,
-		repoArg,
+		ctx,
 		ctx.String("base"),
 		ctx.String("head"),
-		ctx.String("title"),
-		ctx.String("description"),
+		ctx.Bool("allow-maintainer-edits"),
+		opts,
 	)
 }

cmd/pulls/edit.go

@@ -0,0 +1,45 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package pulls
+
+import (
+	stdctx "context"
+	"fmt"
+
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+	"code.gitea.io/tea/modules/utils"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+// editPullState abstracts the arg parsing to edit the given pull request
+func editPullState(_ stdctx.Context, cmd *cli.Command, opts gitea.EditPullRequestOption) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	if ctx.Args().Len() == 0 {
+		return fmt.Errorf("Please provide a Pull Request index")
+	}
+
+	indices, err := utils.ArgsToIndices(ctx.Args().Slice())
+	if err != nil {
+		return err
+	}
+
+	client := ctx.Login.Client()
+	for _, index := range indices {
+		pr, _, err := client.EditPullRequest(ctx.Owner, ctx.Repo, index, opts)
+		if err != nil {
+			return err
+		}
+
+		if len(indices) > 1 {
+			fmt.Println(pr.HTMLURL)
+		} else {
+			print.PullDetails(pr, nil, nil)
+		}
+	}
+	return nil
+}

cmd/pulls/list.go

@@ -1,33 +1,37 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package pulls
 
 import (
-	"log"
-
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
-	"code.gitea.io/tea/modules/print"
+	stdctx "context"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+	"github.com/urfave/cli/v3"
 )
 
+var pullFieldsFlag = flags.FieldsFlag(print.PullFields, []string{
+	"index", "title", "state", "author", "milestone", "updated", "labels",
+})
+
 // CmdPullsList represents a sub command of issues to list pulls
 var CmdPullsList = cli.Command{
-	Name:        "ls",
-	Aliases:     []string{"list"},
+	Name:        "list",
+	Aliases:     []string{"ls"},
 	Usage:       "List pull requests of the repository",
 	Description: `List pull requests of the repository`,
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      RunPullsList,
-	Flags:       flags.IssuePRFlags,
+	Flags:       append([]cli.Flag{pullFieldsFlag}, flags.PRListingFlags...),
 }
 
 // RunPullsList return list of pulls
-func RunPullsList(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func RunPullsList(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 
 	state := gitea.StateOpen
 	switch ctx.String("state") {
@@ -39,14 +43,19 @@ func RunPullsList(ctx *cli.Context) error {
 		state = gitea.StateClosed
 	}
 
-	prs, _, err := login.Client().ListRepoPullRequests(owner, repo, gitea.ListPullRequestsOptions{
+	prs, _, err := ctx.Login.Client().ListRepoPullRequests(ctx.Owner, ctx.Repo, gitea.ListPullRequestsOptions{
 		State: state,
 	})
 
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
 
-	print.PullsList(prs, flags.GlobalOutputValue)
+	fields, err := pullFieldsFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
+
+	print.PullsList(prs, ctx.Output, fields)
 	return nil
 }

cmd/pulls/merge.go

@@ -0,0 +1,63 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package pulls
+
+import (
+	stdctx "context"
+
+	"code.gitea.io/sdk/gitea"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/interact"
+	"code.gitea.io/tea/modules/task"
+	"code.gitea.io/tea/modules/utils"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdPullsMerge merges a PR
+var CmdPullsMerge = cli.Command{
+	Name:        "merge",
+	Aliases:     []string{"m"},
+	Usage:       "Merge a pull request",
+	Description: "Merge a pull request",
+	ArgsUsage:   "<pull index>",
+	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.StringFlag{
+			Name:    "title",
+			Aliases: []string{"t"},
+			Usage:   "Merge commit title",
+		},
+		&cli.StringFlag{
+			Name:    "message",
+			Aliases: []string{"m"},
+			Usage:   "Merge commit message",
+		},
+	}, flags.AllDefaultFlags...),
+	Action: func(_ stdctx.Context, cmd *cli.Command) error {
+		ctx := context.InitCommand(cmd)
+		ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+
+		if ctx.Args().Len() != 1 {
+			// If no PR index is provided, try interactive mode
+			return interact.MergePull(ctx)
+		}
+
+		idx, err := utils.ArgToIndex(ctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		return task.PullMerge(ctx.Login, ctx.Owner, ctx.Repo, idx, gitea.MergePullRequestOption{
+			Style:   gitea.MergeStyle(ctx.String("style")),
+			Title:   ctx.String("title"),
+			Message: ctx.String("message"),
+		})
+	},
+}

cmd/pulls/reject.go

@@ -0,0 +1,44 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package pulls
+
+import (
+	stdctx "context"
+	"fmt"
+	"strings"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/task"
+	"code.gitea.io/tea/modules/utils"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdPullsReject requests changes to a PR
+var CmdPullsReject = cli.Command{
+	Name:        "reject",
+	Usage:       "Request changes to a pull request",
+	Description: "Request changes to a pull request",
+	ArgsUsage:   "<pull index> <reason>",
+	Action: func(_ stdctx.Context, cmd *cli.Command) error {
+		ctx := context.InitCommand(cmd)
+		ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+
+		if ctx.Args().Len() < 2 {
+			return fmt.Errorf("Must specify a PR index and comment")
+		}
+
+		idx, err := utils.ArgToIndex(ctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		comment := strings.Join(ctx.Args().Tail(), " ")
+
+		return task.CreatePullReview(ctx, idx, gitea.ReviewStateRequestChanges, comment, nil)
+	},
+	Flags: flags.AllDefaultFlags,
+}

cmd/pulls/reopen.go

@@ -0,0 +1,27 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package pulls
+
+import (
+	"context"
+
+	"code.gitea.io/tea/cmd/flags"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdPullsReopen reopens a given closed pull request
+var CmdPullsReopen = cli.Command{
+	Name:        "reopen",
+	Aliases:     []string{"open"},
+	Usage:       "Change state of one or more pull requests to 'open'",
+	Description: `Change state of one or more pull requests to 'open'`,
+	ArgsUsage:   "<pull index> [<pull index>...]",
+	Action: func(ctx context.Context, cmd *cli.Command) error {
+		var s = gitea.StateOpen
+		return editPullState(ctx, cmd, gitea.EditPullRequestOption{State: &s})
+	},
+	Flags: flags.AllDefaultFlags,
+}

cmd/pulls/review.go

@@ -0,0 +1,40 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package pulls
+
+import (
+	stdctx "context"
+	"fmt"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/interact"
+	"code.gitea.io/tea/modules/utils"
+
+	"github.com/urfave/cli/v3"
+)
+
+// CmdPullsReview starts an interactive review session
+var CmdPullsReview = cli.Command{
+	Name:        "review",
+	Usage:       "Interactively review a pull request",
+	Description: "Interactively review a pull request",
+	ArgsUsage:   "<pull index>",
+	Action: func(_ stdctx.Context, cmd *cli.Command) error {
+		ctx := context.InitCommand(cmd)
+		ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+
+		if ctx.Args().Len() != 1 {
+			return fmt.Errorf("Must specify a PR index")
+		}
+
+		idx, err := utils.ArgToIndex(ctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		return interact.ReviewPull(ctx, idx)
+	},
+	Flags: flags.AllDefaultFlags,
+}

cmd/releases.go

@@ -1,6 +1,5 @@
 // Copyright 2018 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
@@ -8,22 +7,25 @@ import (
 	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/cmd/releases"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdReleases represents to login a gitea server.
 // ToDo: ReleaseDetails
 var CmdReleases = cli.Command{
 	Name:        "releases",
-	Aliases:     []string{"release"},
+	Aliases:     []string{"release", "r"},
+	Category:    catEntities,
 	Usage:       "Manage releases",
 	Description: "Manage releases",
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      releases.RunReleasesList,
-	Subcommands: []*cli.Command{
+	Commands: []*cli.Command{
 		&releases.CmdReleaseList,
 		&releases.CmdReleaseCreate,
 		&releases.CmdReleaseDelete,
 		&releases.CmdReleaseEdit,
+		&CmdReleaseAttachments,
 	},
 	Flags: flags.AllDefaultFlags,
 }

cmd/releases/create.go

@@ -1,37 +1,38 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package releases
 
 import (
+	stdctx "context"
 	"fmt"
-	"log"
 	"net/http"
 	"os"
 	"path/filepath"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdReleaseCreate represents a sub command of Release to create release
 var CmdReleaseCreate = cli.Command{
 	Name:        "create",
+	Aliases:     []string{"c"},
 	Usage:       "Create a release",
-	Description: `Create a release`,
+	Description: `Create a release for a new or existing git tag`,
+	ArgsUsage:   "[<tag>]",
 	Action:      runReleaseCreate,
 	Flags: append([]cli.Flag{
 		&cli.StringFlag{
 			Name:  "tag",
-			Usage: "Tag name",
+			Usage: "Tag name. If the tag does not exist yet, it will be created by Gitea",
 		},
 		&cli.StringFlag{
 			Name:  "target",
-			Usage: "Target refs, branch name or commit id",
+			Usage: "Target branch name or commit hash. Defaults to the default branch of the repo",
 		},
 		&cli.StringFlag{
 			Name:    "title",
@@ -43,6 +44,11 @@ var CmdReleaseCreate = cli.Command{
 			Aliases: []string{"n"},
 			Usage:   "Release notes",
 		},
+		&cli.StringFlag{
+			Name:    "note-file",
+			Aliases: []string{"f"},
+			Usage:   "Release notes file name. If set, --note is ignored.",
+		},
 		&cli.BoolFlag{
 			Name:    "draft",
 			Aliases: []string{"d"},
@@ -56,43 +62,60 @@ var CmdReleaseCreate = cli.Command{
 		&cli.StringSliceFlag{
 			Name:    "asset",
 			Aliases: []string{"a"},
-			Usage:   "List of files to attach",
+			Usage:   "Path to file attachment. Can be specified multiple times",
 		},
 	}, flags.AllDefaultFlags...),
 }
 
-func runReleaseCreate(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func runReleaseCreate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 
-	release, resp, err := login.Client().CreateRelease(owner, repo, gitea.CreateReleaseOption{
-		TagName:      ctx.String("tag"),
+	tag := ctx.String("tag")
+	if cmd.Args().Present() {
+		if len(tag) != 0 {
+			return fmt.Errorf("ambiguous arguments: provide tagname via --tag or argument, but not both")
+		}
+		tag = cmd.Args().First()
+	}
+
+	notestring := ctx.String("note")
+	notefile := ctx.String("note-file")
+	if notefile != "" {
+		notebytes, err := os.ReadFile(notefile)
+		if err != nil {
+			return fmt.Errorf("unable to read the note file")
+		}
+		notestring = string(notebytes)
+	}
+
+	release, resp, err := ctx.Login.Client().CreateRelease(ctx.Owner, ctx.Repo, gitea.CreateReleaseOption{
+		TagName:      tag,
 		Target:       ctx.String("target"),
 		Title:        ctx.String("title"),
-		Note:         ctx.String("note"),
+		Note:         notestring,
 		IsDraft:      ctx.Bool("draft"),
 		IsPrerelease: ctx.Bool("prerelease"),
 	})
-
 	if err != nil {
 		if resp != nil && resp.StatusCode == http.StatusConflict {
-			fmt.Println("error: There already is a release for this tag")
-			return nil
+			return fmt.Errorf("There already is a release for this tag")
 		}
-		log.Fatal(err)
+		return err
 	}
 
 	for _, asset := range ctx.StringSlice("asset") {
 		var file *os.File
 
 		if file, err = os.Open(asset); err != nil {
-			log.Fatal(err)
+			return err
 		}
 
 		filePath := filepath.Base(asset)
 
-		if _, _, err = login.Client().CreateReleaseAttachment(owner, repo, release.ID, file, filePath); err != nil {
+		if _, _, err = ctx.Login.Client().CreateReleaseAttachment(ctx.Owner, ctx.Repo, release.ID, file, filePath); err != nil {
 			file.Close()
-			log.Fatal(err)
+			return err
 		}
 
 		file.Close()

cmd/releases/delete.go

@@ -1,24 +1,25 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package releases
 
 import (
+	stdctx "context"
 	"fmt"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdReleaseDelete represents a sub command of Release to delete a release
 var CmdReleaseDelete = cli.Command{
 	Name:        "delete",
-	Usage:       "Delete a release",
-	Description: `Delete a release`,
-	ArgsUsage:   "<release tag>",
+	Aliases:     []string{"rm"},
+	Usage:       "Delete one or more releases",
+	Description: `Delete one or more releases`,
+	ArgsUsage:   "<release tag> [<release tag>...]",
 	Action:      runReleaseDelete,
 	Flags: append([]cli.Flag{
 		&cli.BoolFlag{
@@ -33,13 +34,13 @@ var CmdReleaseDelete = cli.Command{
 	}, flags.AllDefaultFlags...),
 }
 
-func runReleaseDelete(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
+func runReleaseDelete(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
 
-	tag := ctx.Args().First()
-	if len(tag) == 0 {
-		fmt.Println("Release tag needed to delete")
+	if !ctx.Args().Present() {
+		fmt.Println("Release tag needed to edit")
 		return nil
 	}
 
@@ -48,23 +49,21 @@ func runReleaseDelete(ctx *cli.Context) error {
 		return nil
 	}
 
-	release, err := getReleaseByTag(owner, repo, tag, client)
+	for _, tag := range ctx.Args().Slice() {
+		release, err := getReleaseByTag(ctx.Owner, ctx.Repo, tag, client)
 		if err != nil {
 			return err
 		}
-	if release == nil {
-		return nil
-	}
-
-	_, err = client.DeleteRelease(owner, repo, release.ID)
+		_, err = client.DeleteRelease(ctx.Owner, ctx.Repo, release.ID)
 		if err != nil {
 			return err
 		}
 
 		if ctx.Bool("delete-tag") {
-		_, err = client.DeleteReleaseTag(owner, repo, tag)
+			_, err = client.DeleteTag(ctx.Owner, ctx.Repo, tag)
 			return err
 		}
+	}
 
 	return nil
 }

cmd/releases/edit.go

@@ -1,6 +1,5 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package releases
 
@@ -8,19 +7,21 @@ import (
 	"fmt"
 	"strings"
 
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	stdctx "context"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdReleaseEdit represents a sub command of Release to edit releases
 var CmdReleaseEdit = cli.Command{
 	Name:        "edit",
-	Usage:       "Edit a release",
-	Description: `Edit a release`,
-	ArgsUsage:   "<release tag>",
+	Aliases:     []string{"e"},
+	Usage:       "Edit one or more releases",
+	Description: `Edit one or more releases`,
+	ArgsUsage:   "<release tag> [<release tag>...]",
 	Action:      runReleaseEdit,
 	Flags: append([]cli.Flag{
 		&cli.StringFlag{
@@ -56,23 +57,10 @@ var CmdReleaseEdit = cli.Command{
 	}, flags.AllDefaultFlags...),
 }
 
-func runReleaseEdit(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
-
-	tag := ctx.Args().First()
-	if len(tag) == 0 {
-		fmt.Println("Release tag needed to edit")
-		return nil
-	}
-
-	release, err := getReleaseByTag(owner, repo, tag, client)
-	if err != nil {
-		return err
-	}
-	if release == nil {
-		return nil
-	}
+func runReleaseEdit(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
 
 	var isDraft, isPre *bool
 	if ctx.IsSet("draft") {
@@ -82,7 +70,18 @@ func runReleaseEdit(ctx *cli.Context) error {
 		isPre = gitea.OptionalBool(strings.ToLower(ctx.String("prerelease"))[:1] == "t")
 	}
 
-	_, _, err = client.EditRelease(owner, repo, release.ID, gitea.EditReleaseOption{
+	if !ctx.Args().Present() {
+		fmt.Println("Release tag needed to edit")
+		return nil
+	}
+
+	for _, tag := range ctx.Args().Slice() {
+		release, err := getReleaseByTag(ctx.Owner, ctx.Repo, tag, client)
+		if err != nil {
+			return err
+		}
+
+		_, _, err = client.EditRelease(ctx.Owner, ctx.Repo, release.ID, gitea.EditReleaseOption{
 			TagName:      ctx.String("tag"),
 			Target:       ctx.String("target"),
 			Title:        ctx.String("title"),
@@ -90,5 +89,9 @@ func runReleaseEdit(ctx *cli.Context) error {
 			IsDraft:      isDraft,
 			IsPrerelease: isPre,
 		})
+		if err != nil {
 			return err
 		}
+	}
+	return nil
+}

cmd/releases/list.go

@@ -1,27 +1,27 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package releases
 
 import (
+	stdctx "context"
 	"fmt"
-	"log"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/print"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdReleaseList represents a sub command of Release to list releases
 var CmdReleaseList = cli.Command{
-	Name:        "ls",
-	Aliases:     []string{"list"},
+	Name:        "list",
+	Aliases:     []string{"ls"},
 	Usage:       "List Releases",
 	Description: "List Releases",
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      RunReleasesList,
 	Flags: append([]cli.Flag{
 		&flags.PaginationPageFlag,
@@ -30,32 +30,35 @@ var CmdReleaseList = cli.Command{
 }
 
 // RunReleasesList list releases
-func RunReleasesList(ctx *cli.Context) error {
-	login, owner, repo := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
+func RunReleasesList(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 
-	releases, _, err := login.Client().ListReleases(owner, repo, gitea.ListReleasesOptions{ListOptions: flags.GetListOptions(ctx)})
+	releases, _, err := ctx.Login.Client().ListReleases(ctx.Owner, ctx.Repo, gitea.ListReleasesOptions{
+		ListOptions: ctx.GetListOptions(),
+	})
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
 
-	print.ReleasesList(releases, flags.GlobalOutputValue)
+	print.ReleasesList(releases, ctx.Output)
 	return nil
 }
 
 func getReleaseByTag(owner, repo, tag string, client *gitea.Client) (*gitea.Release, error) {
-	rl, _, err := client.ListReleases(owner, repo, gitea.ListReleasesOptions{})
+	rl, _, err := client.ListReleases(owner, repo, gitea.ListReleasesOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
+	})
 	if err != nil {
 		return nil, err
 	}
 	if len(rl) == 0 {
-		fmt.Println("Repo does not have any release")
-		return nil, nil
+		return nil, fmt.Errorf("Repo does not have any release")
 	}
 	for _, r := range rl {
 		if r.TagName == tag {
 			return r, nil
 		}
 	}
-	fmt.Println("Release tag does not exist")
-	return nil, nil
+	return nil, fmt.Errorf("Release tag does not exist")
 }

cmd/repos.go

@@ -1,52 +1,57 @@
 // Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package cmd
 
 import (
-	"code.gitea.io/tea/cmd/flags"
+	stdctx "context"
+
 	"code.gitea.io/tea/cmd/repos"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/print"
 	"code.gitea.io/tea/modules/utils"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdRepos represents to login a gitea server.
 var CmdRepos = cli.Command{
 	Name:        "repos",
 	Aliases:     []string{"repo"},
+	Category:    catEntities,
 	Usage:       "Show repository details",
 	Description: "Show repository details",
 	ArgsUsage:   "[<repo owner>/<repo name>]",
 	Action:      runRepos,
-	Subcommands: []*cli.Command{
+	Commands: []*cli.Command{
 		&repos.CmdReposList,
 		&repos.CmdReposSearch,
 		&repos.CmdRepoCreate,
+		&repos.CmdRepoCreateFromTemplate,
+		&repos.CmdRepoFork,
+		&repos.CmdRepoMigrate,
+		&repos.CmdRepoRm,
 	},
 	Flags: repos.CmdReposListFlags,
 }
 
-func runRepos(ctx *cli.Context) error {
-	if ctx.Args().Len() == 1 {
-		return runRepoDetail(ctx.Args().First())
+func runRepos(ctx stdctx.Context, cmd *cli.Command) error {
+	if cmd.Args().Len() == 1 {
+		return runRepoDetail(ctx, cmd, cmd.Args().First())
 	}
-	return repos.RunReposList(ctx)
+	return repos.RunReposList(ctx, cmd)
 }
 
-func runRepoDetail(path string) error {
-	login, ownerFallback, _ := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
-	repoOwner, repoName := utils.GetOwnerAndRepo(path, ownerFallback)
+func runRepoDetail(_ stdctx.Context, cmd *cli.Command, path string) error {
+	ctx := context.InitCommand(cmd)
+	client := ctx.Login.Client()
+	repoOwner, repoName := utils.GetOwnerAndRepo(path, ctx.Owner)
 	repo, _, err := client.GetRepo(repoOwner, repoName)
 	if err != nil {
 		return err
 	}
-	topics, _, err := client.ListRepoTopics(repo.Owner.UserName, repo.Name, gitea.ListRepoTopicsOptions{})
+	topics, _, err := client.ListRepoTopics(repoOwner, repoName, gitea.ListRepoTopicsOptions{})
 	if err != nil {
 		return err
 	}

cmd/repos/create.go

@@ -1,18 +1,18 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package repos
 
 import (
+	stdctx "context"
 	"fmt"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/print"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdRepoCreate represents a sub command of repos to create one
@@ -21,6 +21,7 @@ var CmdRepoCreate = cli.Command{
 	Aliases:     []string{"c"},
 	Usage:       "Create a repository",
 	Description: "Create a repository",
+	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runRepoCreate,
 	Flags: append([]cli.Flag{
 		&cli.StringFlag{
@@ -79,16 +80,39 @@ var CmdRepoCreate = cli.Command{
 			Required: false,
 			Usage:    "use custom default branch (need --init)",
 		},
+		&cli.BoolFlag{
+			Name:  "template",
+			Usage: "make repo a template repo",
+		},
+		&cli.StringFlag{
+			Name:  "trustmodel",
+			Usage: "select trust model (committer,collaborator,collaborator+committer)",
+		},
 	}, flags.LoginOutputFlags...),
 }
 
-func runRepoCreate(ctx *cli.Context) error {
-	login, _, _ := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
+func runRepoCreate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	client := ctx.Login.Client()
 	var (
 		repo       *gitea.Repository
 		err        error
+		trustmodel gitea.TrustModel
 	)
+
+	if ctx.IsSet("trustmodel") {
+		switch ctx.String("trustmodel") {
+		case "committer":
+			trustmodel = gitea.TrustModelCommitter
+		case "collaborator":
+			trustmodel = gitea.TrustModelCollaborator
+		case "collaborator+committer":
+			trustmodel = gitea.TrustModelCollaboratorCommitter
+		default:
+			return fmt.Errorf("unknown trustmodel type '%s'", ctx.String("trustmodel"))
+		}
+	}
+
 	opts := gitea.CreateRepoOption{
 		Name:          ctx.String("name"),
 		Description:   ctx.String("description"),
@@ -99,6 +123,8 @@ func runRepoCreate(ctx *cli.Context) error {
 		License:       ctx.String("license"),
 		Readme:        ctx.String("readme"),
 		DefaultBranch: ctx.String("branch"),
+		Template:      ctx.Bool("template"),
+		TrustModel:    trustmodel,
 	}
 	if len(ctx.String("owner")) != 0 {
 		repo, _, err = client.CreateOrgRepo(ctx.String("owner"), opts)

cmd/repos/create_from_template.go

@@ -0,0 +1,121 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package repos
+
+import (
+	"fmt"
+
+	stdctx "context"
+
+	"code.gitea.io/sdk/gitea"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+	"code.gitea.io/tea/modules/utils"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdRepoCreateFromTemplate represents a sub command of repos to generate one from a template repo
+var CmdRepoCreateFromTemplate = cli.Command{
+	Name:        "create-from-template",
+	Aliases:     []string{"ct"},
+	Usage:       "Create a repository based on an existing template",
+	Description: "Create a repository based on an existing template",
+	Action:      runRepoCreateFromTemplate,
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:     "template",
+			Aliases:  []string{"t"},
+			Required: true,
+			Usage:    "source template to copy from",
+		},
+		&cli.StringFlag{
+			Name:     "name",
+			Aliases:  []string{"n"},
+			Required: true,
+			Usage:    "name of new repo",
+		},
+		&cli.StringFlag{
+			Name:    "owner",
+			Aliases: []string{"O"},
+			Usage:   "name of repo owner",
+		},
+		&cli.BoolFlag{
+			Name:  "private",
+			Usage: "make new repo private",
+		},
+		&cli.StringFlag{
+			Name:    "description",
+			Aliases: []string{"desc"},
+			Usage:   "add custom description to repo",
+		},
+		&cli.BoolFlag{
+			Name:  "content",
+			Value: true,
+			Usage: "copy git content from template",
+		},
+		&cli.BoolFlag{
+			Name:  "githooks",
+			Value: true,
+			Usage: "copy git hooks from template",
+		},
+		&cli.BoolFlag{
+			Name:  "avatar",
+			Value: true,
+			Usage: "copy repo avatar from template",
+		},
+		&cli.BoolFlag{
+			Name:  "labels",
+			Value: true,
+			Usage: "copy repo labels from template",
+		},
+		&cli.BoolFlag{
+			Name:  "topics",
+			Value: true,
+			Usage: "copy topics from template",
+		},
+		&cli.BoolFlag{
+			Name:  "webhooks",
+			Usage: "copy webhooks from template",
+		},
+	}, flags.LoginOutputFlags...),
+}
+
+func runRepoCreateFromTemplate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	client := ctx.Login.Client()
+
+	templateOwner, templateRepo := utils.GetOwnerAndRepo(ctx.String("template"), ctx.Login.User)
+	owner := ctx.Login.User
+	if ctx.IsSet("owner") {
+		owner = ctx.String("owner")
+	}
+
+	opts := gitea.CreateRepoFromTemplateOption{
+		Name:        ctx.String("name"),
+		Owner:       owner,
+		Description: ctx.String("description"),
+		Private:     ctx.Bool("private"),
+		GitContent:  ctx.Bool("content"),
+		GitHooks:    ctx.Bool("githooks"),
+		Avatar:      ctx.Bool("avatar"),
+		Labels:      ctx.Bool("labels"),
+		Topics:      ctx.Bool("topics"),
+		Webhooks:    ctx.Bool("webhooks"),
+	}
+
+	repo, _, err := client.CreateRepoFromTemplate(templateOwner, templateRepo, opts)
+	if err != nil {
+		return err
+	}
+
+	topics, _, err := client.ListRepoTopics(repo.Owner.UserName, repo.Name, gitea.ListRepoTopicsOptions{})
+	if err != nil {
+		return err
+	}
+	print.RepoDetails(repo, topics)
+
+	fmt.Printf("%s\n", repo.HTMLURL)
+	return nil
+}

cmd/repos/delete.go

@@ -0,0 +1,86 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package repos
+
+import (
+	stdctx "context"
+	"fmt"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdRepoRm represents a sub command of repos to delete an existing repo
+var CmdRepoRm = cli.Command{
+	Name:        "delete",
+	Aliases:     []string{"rm"},
+	Usage:       "Delete an existing repository",
+	Description: "Removes a repository from Create a repository from an existing repo",
+	ArgsUsage:   " ", // command does not accept arguments
+	Action:      runRepoDelete,
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:     "name",
+			Aliases:  []string{""},
+			Required: true,
+			Usage:    "name of the repo",
+		},
+		&cli.StringFlag{
+			Name:     "owner",
+			Aliases:  []string{"O"},
+			Required: false,
+			Usage:    "owner of the repo",
+		},
+		&cli.BoolFlag{
+			Name:     "force",
+			Aliases:  []string{"f"},
+			Required: false,
+			Value:    false,
+			Usage:    "Force the deletion and don't ask for confirmation",
+		},
+	}, flags.LoginOutputFlags...),
+}
+
+func runRepoDelete(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+
+	client := ctx.Login.Client()
+
+	var owner string
+	if ctx.IsSet("owner") {
+		owner = ctx.String("owner")
+
+	} else {
+		owner = ctx.Login.User
+	}
+
+	repoName := ctx.String("name")
+
+	repoSlug := fmt.Sprintf("%s/%s", owner, repoName)
+
+	if !ctx.Bool("force") {
+		var enteredRepoSlug string
+		promptRepoName := &survey.Input{
+			Message: fmt.Sprintf("Confirm the deletion of the repository '%s' by typing its name: ", repoSlug),
+		}
+		if err := survey.AskOne(promptRepoName, &enteredRepoSlug, survey.WithValidator(survey.Required)); err != nil {
+			return err
+		}
+
+		if enteredRepoSlug != repoSlug {
+			return fmt.Errorf("Entered wrong repository name '%s', expected '%s'", enteredRepoSlug, repoSlug)
+		}
+	}
+
+	_, err := client.DeleteRepo(owner, repoName)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Successfully deleted %s/%s\n", owner, repoName)
+	return nil
+}

cmd/repos/flags.go

@@ -1,33 +1,15 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package repos
 
 import (
 	"fmt"
-	"strings"
-
-	"code.gitea.io/tea/modules/print"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
-// printFieldsFlag provides a selection of fields to print
-var printFieldsFlag = cli.StringFlag{
-	Name:    "fields",
-	Aliases: []string{"f"},
-	Usage: fmt.Sprintf(`Comma-separated list of fields to print. Available values:
-		%s
-	 `, strings.Join(print.RepoFields, ",")),
-	Value: "owner,name,type,ssh",
-}
-
-func getFields(ctx *cli.Context) []string {
-	return strings.Split(ctx.String("fields"), ",")
-}
-
 var typeFilterFlag = cli.StringFlag{
 	Name:     "type",
 	Aliases:  []string{"T"},
@@ -35,8 +17,8 @@ var typeFilterFlag = cli.StringFlag{
 	Usage:    "Filter by type: fork, mirror, source",
 }
 
-func getTypeFilter(ctx *cli.Context) (filter gitea.RepoType, err error) {
-	t := ctx.String("type")
+func getTypeFilter(cmd *cli.Command) (filter gitea.RepoType, err error) {
+	t := cmd.String("type")
 	filter = gitea.RepoTypeNone
 	switch t {
 	case "":

cmd/repos/fork.go

@@ -0,0 +1,59 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package repos
+
+import (
+	stdctx "context"
+	"fmt"
+
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdRepoFork represents a sub command of repos to fork an existing repo
+var CmdRepoFork = cli.Command{
+	Name:        "fork",
+	Aliases:     []string{"f"},
+	Usage:       "Fork an existing repository",
+	Description: "Create a repository from an existing repo",
+	ArgsUsage:   " ", // command does not accept arguments
+	Action:      runRepoFork,
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:    "owner",
+			Aliases: []string{"O"},
+			Usage:   "name of fork's owner, defaults to current user",
+		},
+	}, flags.LoginRepoFlags...),
+}
+
+func runRepoFork(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+	client := ctx.Login.Client()
+
+	opts := gitea.CreateForkOption{}
+	if ctx.IsSet("owner") {
+		owner := ctx.String("owner")
+		opts.Organization = &owner
+	}
+
+	repo, _, err := client.CreateFork(ctx.Owner, ctx.Repo, opts)
+	if err != nil {
+		return err
+	}
+
+	topics, _, err := client.ListRepoTopics(repo.Owner.UserName, repo.Name, gitea.ListRepoTopicsOptions{})
+	if err != nil {
+		return err
+	}
+	print.RepoDetails(repo, topics)
+
+	fmt.Printf("%s\n", repo.HTMLURL)
+	return nil
+}

cmd/repos/list.go

@@ -1,18 +1,23 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package repos
 
 import (
+	stdctx "context"
+
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/print"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
+var repoFieldsFlag = flags.FieldsFlag(print.RepoFields, []string{
+	"owner", "name", "type", "ssh",
+})
+
 // CmdReposListFlags contains all flags needed for repo listing
 var CmdReposListFlags = append([]cli.Flag{
 	&cli.BoolFlag{
@@ -27,7 +32,7 @@ var CmdReposListFlags = append([]cli.Flag{
 		Required: false,
 		Usage:    "List your starred repos instead",
 	},
-	&printFieldsFlag,
+	repoFieldsFlag,
 	&typeFilterFlag,
 	&flags.PaginationPageFlag,
 	&flags.PaginationLimitFlag,
@@ -35,8 +40,8 @@ var CmdReposListFlags = append([]cli.Flag{
 
 // CmdReposList represents a sub command of repos to list them
 var CmdReposList = cli.Command{
-	Name:        "ls",
-	Aliases:     []string{"list"},
+	Name:        "list",
+	Aliases:     []string{"ls"},
 	Usage:       "List repositories you have access to",
 	Description: "List repositories you have access to",
 	Action:      RunReposList,
@@ -44,30 +49,30 @@ var CmdReposList = cli.Command{
 }
 
 // RunReposList list repositories
-func RunReposList(ctx *cli.Context) error {
-	login, _, _ := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
+func RunReposList(_ stdctx.Context, cmd *cli.Command) error {
+	teaCmd := context.InitCommand(cmd)
+	client := teaCmd.Login.Client()
 
-	typeFilter, err := getTypeFilter(ctx)
+	typeFilter, err := getTypeFilter(cmd)
 	if err != nil {
 		return err
 	}
 
 	var rps []*gitea.Repository
-	if ctx.Bool("starred") {
+	if teaCmd.Bool("starred") {
 		user, _, err := client.GetMyUserInfo()
 		if err != nil {
 			return err
 		}
 		rps, _, err = client.SearchRepos(gitea.SearchRepoOptions{
-			ListOptions:     flags.GetListOptions(ctx),
+			ListOptions:     teaCmd.GetListOptions(),
 			StarredByUserID: user.ID,
 		})
-	} else if ctx.Bool("watched") {
+	} else if teaCmd.Bool("watched") {
 		rps, _, err = client.GetMyWatchedRepos() // TODO: this does not expose pagination..
 	} else {
 		rps, _, err = client.ListMyRepos(gitea.ListReposOptions{
-			ListOptions: flags.GetListOptions(ctx),
+			ListOptions: teaCmd.GetListOptions(),
 		})
 	}
 
@@ -80,7 +85,12 @@ func RunReposList(ctx *cli.Context) error {
 		reposFiltered = filterReposByType(rps, typeFilter)
 	}
 
-	print.ReposList(reposFiltered, flags.GlobalOutputValue, getFields(ctx))
+	fields, err := repoFieldsFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
+
+	print.ReposList(reposFiltered, teaCmd.Output, fields)
 	return nil
 }
 

cmd/repos/migrate.go

@@ -0,0 +1,173 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package repos
+
+import (
+	"fmt"
+
+	stdctx "context"
+
+	"code.gitea.io/sdk/gitea"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"
+	"github.com/urfave/cli/v3"
+)
+
+// CmdRepoMigrate represents a sub command of repos to migrate one
+var CmdRepoMigrate = cli.Command{
+	Name:        "migrate",
+	Aliases:     []string{"m"},
+	Usage:       "Migrate a repository",
+	Description: "Migrate a repository and or mirror it.",
+	ArgsUsage:   " ", // command does not accept arguments
+	Action:      runRepoMigrate,
+	Flags: append([]cli.Flag{
+		&cli.StringFlag{
+			Name:     "name",
+			Usage:    "Name of the repository",
+			Required: true,
+		},
+		&cli.StringFlag{
+			Name:     "owner",
+			Usage:    "Owner of the repository",
+			Required: true,
+		},
+		&cli.StringFlag{
+			Name:     "clone-url",
+			Usage:    "Clone URL of the repository",
+			Required: true,
+		},
+		&cli.StringFlag{
+			Name: "service",
+			Usage: string("Service to migrate from. Supported services are: " + gitea.GitServicePlain +
+				", " + gitea.GitServiceGitea + ", " + gitea.GitServiceGitlab + ", " + gitea.GitServiceGogs),
+			Required: true,
+		},
+		&cli.BoolFlag{
+			Name:  "mirror",
+			Usage: "Mirror the repository",
+		},
+		&cli.BoolFlag{
+			Name:  "private",
+			Usage: "Make the repository private",
+		},
+		&cli.BoolFlag{
+			Name:  "template",
+			Usage: "Make the repository a template",
+		},
+		&cli.BoolFlag{
+			Name:  "wiki",
+			Usage: "Copy the wiki",
+		},
+		&cli.BoolFlag{
+			Name:  "issues",
+			Usage: "Copy the issues",
+		},
+		&cli.BoolFlag{
+			Name:  "labels",
+			Usage: "Copy the lables",
+		},
+		&cli.BoolFlag{
+			Name:  "pull-requests",
+			Usage: "Copy the pull requests",
+		},
+		&cli.BoolFlag{
+			Name:  "releases",
+			Usage: "Copy the releases",
+		},
+		&cli.BoolFlag{
+			Name:  "milestones",
+			Usage: "Copy the milestones",
+		},
+		&cli.StringFlag{
+			Name:  "mirror-interval",
+			Usage: "Interval to mirror the repository.",
+		},
+		&cli.BoolFlag{
+			Name:  "lfs",
+			Usage: "Copy the LFS objects",
+		},
+		&cli.StringFlag{
+			Name:  "lfs-endpoint",
+			Usage: "LFS endpoint to use",
+		},
+		&cli.StringFlag{
+			Name:  "auth-user",
+			Usage: "Username to use for authentication.",
+		},
+		&cli.StringFlag{
+			Name:  "auth-password",
+			Usage: "Password to use for authentication.",
+		},
+		&cli.StringFlag{
+			Name:  "auth-token",
+			Usage: "Token to use for authentication.",
+		},
+	}, flags.LoginOutputFlags...),
+}
+
+func runRepoMigrate(_ stdctx.Context, cmd *cli.Command) error {
+	ctx := context.InitCommand(cmd)
+	client := ctx.Login.Client()
+	var (
+		repo    *gitea.Repository
+		err     error
+		service gitea.GitServiceType
+	)
+
+	if ctx.IsSet("service") {
+		switch ctx.String("service") {
+		case "git":
+			service = gitea.GitServicePlain
+		case "gitea":
+			service = gitea.GitServiceGitea
+		case "gitlab":
+			service = gitea.GitServiceGitlab
+		case "gogs":
+			service = gitea.GitServiceGogs
+		case "github":
+			service = gitea.GitServiceGithub
+		default:
+			return fmt.Errorf("unknown git service type '%s'", ctx.String("service"))
+		}
+	}
+
+	opts := gitea.MigrateRepoOption{
+		RepoName:       ctx.String("name"),
+		RepoOwner:      ctx.String("owner"),
+		CloneAddr:      ctx.String("clone-url"),
+		Service:        service,
+		AuthUsername:   ctx.String("auth-user"),
+		AuthPassword:   ctx.String("auth-password"),
+		AuthToken:      ctx.String("auth-token"),
+		Mirror:         ctx.Bool("mirror"),
+		Private:        ctx.Bool("private"),
+		Description:    ctx.String("description"),
+		Wiki:           ctx.Bool("wiki"),
+		Milestones:     ctx.Bool("milestones"),
+		Labels:         ctx.Bool("labels"),
+		Issues:         ctx.Bool("issues"),
+		PullRequests:   ctx.Bool("pull-requests"),
+		Releases:       ctx.Bool("releases"),
+		MirrorInterval: ctx.String("mirror-interval"),
+		LFS:            ctx.Bool("lfs"),
+		LFSEndpoint:    ctx.String("lfs-endpoint"),
+	}
+
+	repo, _, err = client.MigrateRepo(opts)
+
+	if err != nil {
+		return err
+	}
+
+	topics, _, err := client.ListRepoTopics(repo.Owner.UserName, repo.Name, gitea.ListRepoTopicsOptions{})
+	if err != nil {
+		return err
+	}
+	print.RepoDetails(repo, topics)
+
+	fmt.Printf("%s\n", repo.HTMLURL)
+	return nil
+}

cmd/repos/search.go

@@ -1,19 +1,19 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
 
 package repos
 
 import (
-	"log"
+	stdctx "context"
+	"fmt"
 	"strings"
 
 	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
+	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/print"
 
 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v3"
 )
 
 // CmdReposSearch represents a sub command of repos to find them
@@ -50,28 +50,28 @@ var CmdReposSearch = cli.Command{
 			Required: false,
 			Usage:    "Filter archived repos (true|false)",
 		},
-		&printFieldsFlag,
+		repoFieldsFlag,
 		&flags.PaginationPageFlag,
 		&flags.PaginationLimitFlag,
 	}, flags.LoginOutputFlags...),
 }
 
-func runReposSearch(ctx *cli.Context) error {
-	login, _, _ := config.InitCommand(flags.GlobalRepoValue, flags.GlobalLoginValue, flags.GlobalRemoteValue)
-	client := login.Client()
+func runReposSearch(_ stdctx.Context, cmd *cli.Command) error {
+	teaCmd := context.InitCommand(cmd)
+	client := teaCmd.Login.Client()
 
 	var ownerID int64
-	if ctx.IsSet("owner") {
+	if teaCmd.IsSet("owner") {
 		// test if owner is a organisation
-		org, _, err := client.GetOrg(ctx.String("owner"))
+		org, _, err := client.GetOrg(teaCmd.String("owner"))
 		if err != nil {
 			// HACK: the client does not return a response on 404, so we can't check res.StatusCode
 			if err.Error() != "404 Not Found" {
-				log.Fatal("could not find owner: ", err)
+				return fmt.Errorf("Could not find owner: %s", err)
 			}
 
 			// if owner is no org, its a user
-			user, _, err := client.GetUserInfo(ctx.String("owner"))
+			user, _, err := client.GetUserInfo(teaCmd.String("owner"))
 			if err != nil {
 				return err
 			}
@@ -82,25 +82,25 @@ func runReposSearch(ctx *cli.Context) error {
 	}
 
 	var isArchived *bool
-	if ctx.IsSet("archived") {
-		archived := strings.ToLower(ctx.String("archived"))[:1] == "t"
+	if teaCmd.IsSet("archived") {
+		archived := strings.ToLower(teaCmd.String("archived"))[:1] == "t"
 		isArchived = &archived
 	}
 
 	var isPrivate *bool
-	if ctx.IsSet("private") {
-		private := strings.ToLower(ctx.String("private"))[:1] == "t"
+	if teaCmd.IsSet("private") {
+		private := strings.ToLower(teaCmd.String("private"))[:1] == "t"
 		isPrivate = &private
 	}
 
-	mode, err := getTypeFilter(ctx)
+	mode, err := getTypeFilter(cmd)
 	if err != nil {
 		return err
 	}
 
 	var keyword string
-	if ctx.Args().Present() {
-		keyword = strings.Join(ctx.Args().Slice(), " ")
+	if teaCmd.Args().Present() {
+		keyword = strings.Join(teaCmd.Args().Slice(), " ")
 	}
 
 	user, _, err := client.GetMyUserInfo()
@@ -109,20 +109,24 @@ func runReposSearch(ctx *cli.Context) error {
 	}
 
 	rps, _, err := client.SearchRepos(gitea.SearchRepoOptions{
-		ListOptions:          flags.GetListOptions(ctx),
+		ListOptions:          teaCmd.GetListOptions(),
 		OwnerID:              ownerID,
 		IsPrivate:            isPrivate,
 		IsArchived:           isArchived,
 		Type:                 mode,
 		Keyword:              keyword,
 		KeywordInDescription: true,
-		KeywordIsTopic:       ctx.Bool("topic"),
+		KeywordIsTopic:       teaCmd.Bool("topic"),
 		PrioritizedByOwnerID: user.ID,
 	})
 	if err != nil {
 		return err
 	}
 
-	print.ReposList(rps, flags.GlobalOutputValue, getFields(ctx))
+	fields, err := repoFieldsFlag.GetValues(cmd)
+	if err != nil {
+		return err
+	}
+	print.ReposList(rps, teaCmd.Output, fields)
 	return nil
 }