darwin/arm64 & update s3 bucket

2026-04-26 02:03:30 +02:00 · 2021-08-26 18:15:51 -04:00
1875 changed files with 431045 additions and 17788 deletions
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -1,20 +0,0 @@
-{
-  "name": "Tea DevContainer",
-  "image": "mcr.microsoft.com/devcontainers/go:2.0-trixie",
-  "features": {
-    "ghcr.io/devcontainers/features/git-lfs:1.2.5": {}
-  },
-  "customizations": {
-    "vscode": {
-      "settings": {},
-      "extensions": [
-        "editorconfig.editorconfig",
-        "golang.go",
-        "stylelint.vscode-stylelint",
-        "DavidAnson.vscode-markdownlint",
-        "ms-azuretools.vscode-docker",
-        "GitHub.vscode-pull-request-github"
-      ]
-    }
-  }
-}
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,2 +0,0 @@
-Dockerfile
-tea
--- a/.drone.yml
+++ b/.drone.yml
@@ -0,0 +1,189 @@
+---
+kind: pipeline
+name: default
+
+platform:
+  os: linux
+  arch: amd64
+
+steps:
+- name: build
+  pull: always
+  image: golang:1.16
+  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.16
+  commands:
+  - make unit-test-coverage
+  settings:
+    group: test
+  when:
+    branch:
+    - master
+    event:
+    - push
+    - pull_request
+
+- name: release-test
+  image: golang:1.16
+  commands:
+  - make test
+  settings:
+    group: test
+  when:
+    branch:
+    - "release/*"
+    event:
+    - push
+    - pull_request
+
+- name: tag-test
+  pull: always
+  image: golang:1.16
+  commands:
+  - make test
+  settings:
+    group: test
+  when:
+    event:
+    - tag
+
+- name: static
+  image: golang:1.16
+  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: gitea-artifacts
+    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: gitea-artifacts
+    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: gitea-artifacts
+    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
--- a/.envrc
+++ b/.envrc
@@ -1 +0,0 @@
-use flake 
--- a/.gitea/issue_template/bug.md
+++ b/.gitea/issue_template/bug.md
@@ -1,30 +0,0 @@
---
-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)
-
-
--- a/.gitea/workflows/release-nightly.yml
+++ b/.gitea/workflows/release-nightly.yml
@@ -1,80 +0,0 @@
-name: goreleaser
-
-on:
-  push:
-    branches: [ main ]
-
-jobs:
-  goreleaser:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-      - run: git fetch --force --tags
-      - uses: actions/setup-go@v6
-        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: get SDK version
-        id: sdk_version
-        run: echo "version=$(go list -f '{{.Version}}' -m code.gitea.io/sdk/gitea)" >> "$GITHUB_OUTPUT"
-      - name: goreleaser
-        uses: goreleaser/goreleaser-action@v6
-        with:
-            distribution: goreleaser-pro
-            version: "~> v1"
-            args: release --nightly
-        env:
-          SDK_VERSION: ${{ steps.sdk_version.outputs.version }}
-          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@v6
-        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
--- a/.gitea/workflows/release-tag.yml
+++ b/.gitea/workflows/release-tag.yml
@@ -1,85 +0,0 @@
-name: goreleaser
-
-on: 
-  push:
-    tags:
-      - '*'
-
-jobs:
-  goreleaser:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-      - run: git fetch --force --tags
-      - uses: actions/setup-go@v6
-        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: get SDK version
-        id: sdk_version
-        run: echo "version=$(go list -f '{{.Version}}' -m code.gitea.io/sdk/gitea)" >> "$GITHUB_OUTPUT"
-      - name: goreleaser
-        uses: goreleaser/goreleaser-action@v6
-        with:
-            distribution: goreleaser-pro
-            version: "~> v1"
-            args: release
-        env:
-          SDK_VERSION: ${{ steps.sdk_version.outputs.version }}
-          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@v6
-        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: Get tag version without v
-        id: get_version
-        run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_ENV
-
-      - 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:${{ env.VERSION }}
--- a/.gitea/workflows/test-pr.yml
+++ b/.gitea/workflows/test-pr.yml
@@ -1,63 +0,0 @@
-name: check-and-test
-
-on:
-  - pull_request
-
-jobs:
-  #govulncheck_job:
-  #  runs-on: ubuntu-latest
-  #  name: Run govulncheck
-  #  steps:
-  #    - id: govulncheck
-  #      uses: golang/govulncheck-action@v1
-  #      with:
-  #        go-version-file: 'go.mod'
-  check-and-test:
-    runs-on: ubuntu-latest
-    env:
-      HTTP_PROXY: ""
-      GITEA_TEA_TEST_URL: "http://gitea:3000"
-      GITEA_TEA_TEST_USERNAME: "test01"
-      GITEA_TEA_TEST_PASSWORD: "test01"
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-go@v6
-        with:
-          go-version-file: 'go.mod'
-      - name: lint and build
-        run: |
-          make clean
-          make vet
-          make lint
-          make fmt-check
-          make docs-check
-          make build
-      - run: curl --noproxy "*" http://gitea:3000/api/v1/version # verify connection to instance
-      - name: test and coverage
-        run: |
-          make test
-          make unit-test-coverage
-    services:
-      gitea:
-        image: docker.gitea.com/gitea:1.25.4
-        cmd:
-          - bash
-          - -c
-          - >-
-            mkdir -p /tmp/conf/
-            && mkdir -p /tmp/data/
-            && echo "I_AM_BEING_UNSAFE_RUNNING_AS_ROOT = true" > /tmp/conf/app.ini
-            && echo "[security]" >> /tmp/conf/app.ini
-            && echo "INTERNAL_TOKEN = eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYmYiOjE1NTg4MzY4ODB9.LoKQyK5TN_0kMJFVHWUW0uDAyoGjDP6Mkup4ps2VJN4" >> /tmp/conf/app.ini
-            && echo "INSTALL_LOCK   = true" >> /tmp/conf/app.ini
-            && echo "SECRET_KEY     = 2crAW4UANgvLipDS6U5obRcFosjSJHQANll6MNfX7P0G3se3fKcCwwK3szPyGcbo" >> /tmp/conf/app.ini
-            && echo "PASSWORD_COMPLEXITY = off" >> /tmp/conf/app.ini
-            && echo "[database]" >> /tmp/conf/app.ini
-            && echo "DB_TYPE = sqlite3" >> /tmp/conf/app.ini
-            && echo "[repository]" >> /tmp/conf/app.ini
-            && echo "ROOT = /tmp/data/" >> /tmp/conf/app.ini
-            && echo "[server]" >> /tmp/conf/app.ini
-            && echo "ROOT_URL = http://gitea:3000" >> /tmp/conf/app.ini
-            && gitea migrate -c /tmp/conf/app.ini
-            && gitea admin user create --username=test01 --password=test01 --email=test01@gitea.io --admin=true --must-change-password=false --access-token -c /tmp/conf/app.ini
-            && gitea web -c /tmp/conf/app.ini
--- a/.gitignore
+++ b/.gitignore
@@ -1,19 +1,8 @@
-/tea
+tea
 /gitea-vet
-/gitea-vet.exe

 .idea/
 .history/
 dist/

 .vscode/
-vendor/
-
-coverage.out
-
-dist/
-
-# Nix-specific
-.direnv/
-result
-result-*
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,45 +0,0 @@
-version: "2"
-
-formatters:
-  enable:
-    - gofumpt
-
-linters:
-  default: none
-  enable:
-    - govet
-    - revive
-    - misspell
-    - ineffassign
-    - unused
-
-  settings:
-    revive:
-      rules:
-        - name: blank-imports
-        - name: context-as-argument
-        - name: context-keys-type
-        - name: dot-imports
-        - name: error-return
-        - name: error-strings
-        - name: error-naming
-        - name: exported
-        - name: if-return
-        - name: increment-decrement
-        - name: var-declaration
-        - name: range
-        - name: receiver-naming
-        - name: time-naming
-        - name: unexported-return
-        - name: indent-error-flow
-        - name: errorf
-
-    misspell:
-      locale: US
-      ignore-words:
-        - unknwon
-        - destory
-
-issues:
-  max-issues-per-linter: 0
-  max-same-issues: 0
--- a/.goreleaser.checksum.sh
+++ b/.goreleaser.checksum.sh
@@ -1,12 +0,0 @@
-#!/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
--- a/.goreleaser.yaml
+++ b/.goreleaser.yaml
@@ -1,122 +0,0 @@
-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: 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 "code.gitea.io/tea/modules/version.Version={{ trimprefix .Summary "v" }}" -X "code.gitea.io/tea/modules/version.Tags=" -X "code.gitea.io/tea/modules/version.SDK={{ .Env.SDK_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
--- a/.revive.toml
+++ b/.revive.toml
@@ -16,6 +16,7 @@ warningCode = 1
 [rule.increment-decrement]
 [rule.var-naming]
 [rule.var-declaration]
+[rule.package-comments]
 [rule.range]
 [rule.receiver-naming]
 [rule.time-naming]
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,78 +1,5 @@
 # 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
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -7,6 +7,7 @@
  - [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)
@@ -56,13 +57,27 @@ high-level discussions.

 ## Testing redux

-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.
+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).

 ## 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 Gitea's
+makes the change, even if they are an owner or a maintainer. We use Giteas'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
@@ -103,8 +118,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 command/flag options for `urfave/cli`
-  - subcommands are in a subpackage named after its parent command
+- `cmd`: only contains comand/flag options for `urfave/cli`
+  - subcomands are in a subpackage named after its parent comand
 - `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
@@ -160,7 +175,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/Gitea) #develop channel. The owners
+[Discord](https://discord.gg/NsatcWJ) #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
@@ -193,7 +208,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/Gitea) #general channel. Below are the
+[Discord](https://discord.gg/NsatcWJ) #general channel. Below are the
 words to speak:

 ```
@@ -221,8 +236,8 @@ Code that you contribute should use the standard copyright header:

 ```
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
 ```

 Files in the repository contain copyright from the year they are added
--- a/12
+++ b/12
@@ -1,12 +0,0 @@
-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" ]
--- a/FEATURE-COMPARISON.md
+++ b/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
--- a/1
+++ b/1
@@ -1,4 +1,5 @@
 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
--- a/144
+++ b/144
@@ -1,14 +1,30 @@
 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)

-GOFILES := $(shell find . -name "*.go" -type f ! -path "*/bindata.go")
+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

-# Tool packages with pinned versions
-GOFUMPT_PACKAGE ?= mvdan.cc/gofumpt@v0.9.2
-GOLANGCI_LINT_PACKAGE ?= github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.8.0
+GOFILES := $(shell find . -name "*.go" -type f ! -path "./vendor/*" ! -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))
@@ -17,109 +33,133 @@ else
 	ifneq ($(DRONE_BRANCH),)
 		VERSION ?= $(subst release/v,,$(DRONE_BRANCH))
 	else
-		VERSION ?= main
+		VERSION ?= master
 	endif
 	TEA_VERSION ?= $(shell git describe --tags --always | sed 's/-/+/' | sed 's/^v//')
 endif
-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/modules/version.Version=$(TEA_VERSION)" -X "code.gitea.io/tea/modules/version.Tags=$(TAGS)" -X "code.gitea.io/tea/modules/version.SDK=$(SDK)" -s -w
+LDFLAGS := -X "main.Version=$(TEA_VERSION)" -X "main.Tags=$(TAGS)"

-# override to allow passing additional goflags via make CLI
-override GOFLAGS := $(GOFLAGS) -tags '$(TAGS)' -ldflags '$(LDFLAGS)'
-
-PACKAGES ?= $(shell $(GO) list ./...)
+PACKAGES ?= $(shell $(GO) list ./... | grep -v /vendor/)
 SOURCES ?= $(shell find . -name "*.go" -type f)

-# OS specific vars.
+TAGS ?=
+
 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 -i ./...
+	$(GO) clean -mod=vendor -i ./...
 	rm -rf $(EXECUTABLE) $(DIST)

 .PHONY: fmt
 fmt:
-	$(GO) run $(GOFUMPT_PACKAGE) -w $(GOFILES)
+	$(GOFMT) -w $(GOFILES)

 .PHONY: vet
 vet:
 	# Default vet
-	$(GO) vet $(PACKAGES)
+	$(GO) vet -mod=vendor $(PACKAGES)
 	# Custom vet
-	$(GO) build code.gitea.io/gitea-vet
-	$(GO) vet -vettool=$(VET_TOOL) $(PACKAGES)
+	$(GO) build -mod=vendor code.gitea.io/gitea-vet
+	$(GO) vet -vettool=gitea-vet $(PACKAGES)

 .PHONY: lint
 lint:
-	$(GO) run $(GOLANGCI_LINT_PACKAGE) run
+	@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

-.PHONY: lint-fix
-lint-fix:
-	$(GO) run $(GOLANGCI_LINT_PACKAGE) run --fix
+.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)
+
+.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)

 .PHONY: fmt-check
 fmt-check:
-	# get all go files and run gofumpt on them
-	@diff=$$($(GO) run $(GOFUMPT_PACKAGE) -d $(GOFILES)); \
+	# get all go files and run go fmt on them
+	@diff=$$($(GOFMT) -d $(GOFILES)); \
 	if [ -n "$$diff" ]; then \
 		echo "Please run 'make fmt' and commit the result:"; \
 		echo "$${diff}"; \
 		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 -tags='sqlite sqlite_unlock_notify' $(PACKAGES)
+	$(GO) test -mod=vendor -tags='sqlite sqlite_unlock_notify' $(PACKAGES)

 .PHONY: unit-test-coverage
 unit-test-coverage:
-	$(GO) test -tags='sqlite sqlite_unlock_notify' -cover -coverprofile coverage.out $(PACKAGES) && echo "\n==>\033[32m Ok\033[m\n" || exit 1
+	$(GO) test -mod=vendor -tags='sqlite sqlite_unlock_notify' -cover -coverprofile coverage.out $(PACKAGES) && echo "\n==>\033[32m Ok\033[m\n" || exit 1

-.PHONY: tidy
-tidy:
-	$(GO) mod tidy
+.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: check
 check: test

 .PHONY: install
-install: $(SOURCES)
-	@echo "installing to $(shell $(GO) env GOPATH)/bin/$(EXECUTABLE)"
-	$(GO) install -v $(BUILDMODE) $(GOFLAGS)
+install: $(wildcard *.go)
+	$(GO) install -mod=vendor -v -tags '$(TAGS)' -ldflags '-s -w $(LDFLAGS)'

 .PHONY: build
 build: $(EXECUTABLE)

 $(EXECUTABLE): $(SOURCES)
-	$(GO) build $(BUILDMODE) $(GOFLAGS) -o $@
+	$(GO) build -mod=vendor $(GOFLAGS) $(EXTRA_GOFLAGS) -tags '$(TAGS)' -ldflags '-s -w $(LDFLAGS)' -o $@

-.PHONY: build-image
-build-image:
-	docker build --build-arg VERSION=$(TEA_VERSION) -t gitea/tea:$(TEA_VERSION_TAG) .
+.PHONY: release
+release: release-dirs release-os release-compress release-check

+.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; \
+	fi
+	CGO_ENABLED=0 gox -verbose -cgo=false -tags '$(TAGS)' -ldflags '-s -w $(LDFLAGS)' -osarch='!darwin/386 !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; \
+	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;
--- a/README.md
+++ b/README.md
@@ -1,102 +1,72 @@
-# <img alt='tea logo' src='https://gitea.com/repo-avatars/550-80a3a8c2ab0e2c2d69f296b7f8582485' height="40"/> *T E A*
+# <img alt='' 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)
-[![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)
+[![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)

-## The official CLI for Gitea
+### The official CLI for Gitea

 ![demo gif](./demo.gif)

 ```
-NAME:
-  tea - command line tool to interact with Gitea
+   tea - command line tool to interact with Gitea
+   version 0.7.0-preview

-USAGE:
-  tea [global options] [command [command options]]
+ USAGE
+   tea command [subcommand] [command options] [arguments...]

-VERSION:
-  Version: 0.10.1+15-g8876fe3  golang: 1.25.0  go-sdk: v0.21.0
+ DESCRIPTION
+   tea is a productivity helper for Gitea.  It can be used to manage most entities on one
+   or multiple Gitea instances and provides local helpers like 'tea pull checkout'.
+   tea makes use of context provided by the repository in $PWD if available, but is still
+   usable independently of $PWD. Configuration is persisted in $XDG_CONFIG_HOME/tea.

-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'.
+ 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
+     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
+   HELPERS:
+     open, o                         Open something of the repository in web browser
+     notifications, notification, n  Show notifications
+   SETUP:
+     logins, login                  Log in to a Gitea server
+     logout                         Log out from a Gitea server
+     shellcompletion, autocomplete  Install shell completion for tea

-  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.
+ OPTIONS
+   --help, -h     show help (default: false)
+   --version, -v  print the version (default: false)

-COMMANDS:
-  help, h  Shows a list of commands or help for one command
+ EXAMPLES
+   tea login add                       # add a login once to get started

-  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
-    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
-    branches, branch, b               Consult branches
-    actions                           Manage repository actions (secrets, variables)
-    comment, c                        Add a comment to an issue / pr
-    webhooks, webhook                 Manage repository webhooks
+   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

-  HELPERS:
-    open, o                         Open something of the repository in web browser
-    notifications, notification, n  Show notifications
-    clone, C                        Clone a repository locally
+   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

-  MISCELLANEOUS:
-    whoami    Show current logged in user
-    admin, a  Operations requiring admin access on the Gitea instance
+   # send gitea desktop notifications every 5 minutes (bash + libnotify)
+   while :; do tea notifications --all -o simple | xargs -i notify-send {}; sleep 300; done

-  SETUP:
-    logins, login  Log in to a Gitea server
-    logout         Log out from a Gitea server
-
-GLOBAL OPTIONS:
-  --debug, --vvv  Enable debug mode (default: false)
-  --help, -h      show help
-  --version, -v   print the version
-
-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
-
-  tea actions secrets list            # list all repository action secrets
-  tea actions secrets create API_KEY  # create a new secret (will prompt for value)
-  tea actions variables list          # list all repository action variables
-  tea actions variables set API_URL https://api.example.com
-
-  tea webhooks list                   # list repository webhooks
-  tea webhooks list --org myorg       # list organization webhooks
-  tea webhooks create https://example.com/hook --events push,pull_request
-
-  # 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.
+ 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://gitea.io.
 ```

+- [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
@@ -104,90 +74,34 @@ ABOUT
 There are different ways to get `tea`:

 1. Install via your system package manager:
-    - macOS via `brew` (official):
+    - macOS via `brew` (gitea-maintained):
      ```sh
+      brew tap gitea/tap https://gitea.com/gitea/homebrew-gitea
      brew install tea
      ```
-    - arch linux ([tea](https://archlinux.org/packages/extra/x86_64/tea/), thirdparty)
+    - arch linux ([gitea-tea](https://aur.archlinux.org/packages/gitea-tea), 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)

-2. Use the prebuilt binaries from [dl.gitea.com](https://dl.gitea.com/tea/)
+2. Use the prebuilt binaries from [dl.gitea.io](https://dl.gitea.io/tea/)

-3. Install from source: [see *Compilation*](#compilation)
+3. Install from source (go 1.13 or newer is required):
+    ```sh
+    go get code.gitea.io/tea
+    go install code.gitea.io/tea
+    ```

-4. Docker: [Tea at docker hub](https://hub.docker.com/r/gitea/tea)
-
-### Log in to Gitea from tea
-
-Gitea can use many different authentication schemes, and not every authentication method will work with every Gitea deployment. When you are a Gitea instance administrator you can tweak your settings to fit your use case. For the method that is most likely to work with any Gitea deployment use the following steps:
-
-1. Open your Gitea instance in a web browser
-
-2. Log in to Gitea in your web browser. Any MFA, IDP, or whatever else should be available this way.
-
-3. In your "user settings", generate an application token with at least **user read** permissions. If you want to do anything useful with the token add additional permissions/scopes.
-
-4. Run `tea login add`, select **application token** authentication when asked for authentication type, and answer **yes** to the question if you have a token. Paste the generated token when asked for one.
-
-You should now be logged in to your gitea instance from tea.
-
-Since 0.10 Gitea supports the much simpler oauth workflow but oauth may not be available on all Gitea deployments, and gets much more complex when running tea on a remote system.
-
-### Shell completion
-
-If you installed from source or the package does not provide the completions with it you can add them yourself with `tea completion <shell>` command which is not visible in help. To generate the completions run one of the following commands depending on your shell.
-
-```shell
-# .bashrc
-source <(tea completion bash)
-
-# .zshrc
-source <(tea completion zsh)
-
-# fish
-tea completion fish > ~/.config/fish/completions/tea.fish
-
-# Powershell
-Output the script to path/to/autocomplete/tea.ps1 an run it.
-```
-
-### Man Page
-
-The hidden command `tea man` can be used to generate the `tea` man page.
-
-```shell
-# for bash or zsh
-man <(tea man)
-
-# for fish
-man (tea man | psub)
-
-# write man page to a file
-tea man --out ./tea.man
-```
+4. Docker (thirdparty): [tgerczei/tea](https://hub.docker.com/r/tgerczei/tea)

 ## Compilation

-Make sure you have a current go version installed (1.13 or newer).
+Make sure you have installed a current go version.
+To compile the sources yourself run the following:

- To compile the source yourself with the recommended flags & tags:
-  ```sh
-  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}
-  ```
+```sh
+git clone https://gitea.com/gitea/tea.git
+cd tea
+make
+```

 ## Contributing

@@ -195,6 +109,7 @@ 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.
--- a/build.go
+++ b/build.go
@@ -1,8 +1,7 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-//go:build vendor
-// +build vendor
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+//+build vendor

 package main

--- a/cmd/actions.go
+++ b/cmd/actions.go
@@ -1,47 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	stdctx "context"
-
-	"code.gitea.io/tea/cmd/actions"
-
-	"github.com/urfave/cli/v3"
-)
-
-// CmdActions represents the actions command for managing Gitea Actions
-var CmdActions = cli.Command{
-	Name:        "actions",
-	Aliases:     []string{"action"},
-	Category:    catEntities,
-	Usage:       "Manage repository actions",
-	Description: "Manage repository actions including secrets, variables, and workflow runs",
-	Action:      runActionsDefault,
-	Commands: []*cli.Command{
-		&actions.CmdActionsSecrets,
-		&actions.CmdActionsVariables,
-		&actions.CmdActionsRuns,
-		&actions.CmdActionsWorkflows,
-	},
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "repo",
-			Usage: "repository to operate on",
-		},
-		&cli.StringFlag{
-			Name:  "login",
-			Usage: "gitea login instance to use",
-		},
-		&cli.StringFlag{
-			Name:    "output",
-			Aliases: []string{"o"},
-			Usage:   "output format [table, csv, simple, tsv, yaml, json]",
-		},
-	},
-}
-
-func runActionsDefault(_ stdctx.Context, cmd *cli.Command) error {
-	return cli.ShowSubcommandHelp(cmd)
-}
--- a/cmd/actions/runs.go
+++ b/cmd/actions/runs.go
@@ -1,31 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package actions
-
-import (
-	stdctx "context"
-
-	"code.gitea.io/tea/cmd/actions/runs"
-
-	"github.com/urfave/cli/v3"
-)
-
-// CmdActionsRuns represents the actions runs command
-var CmdActionsRuns = cli.Command{
-	Name:        "runs",
-	Aliases:     []string{"run"},
-	Usage:       "Manage workflow runs",
-	Description: "List, view, and manage workflow runs for repository actions",
-	Action:      runRunsDefault,
-	Commands: []*cli.Command{
-		&runs.CmdRunsList,
-		&runs.CmdRunsView,
-		&runs.CmdRunsDelete,
-		&runs.CmdRunsLogs,
-	},
-}
-
-func runRunsDefault(ctx stdctx.Context, cmd *cli.Command) error {
-	return runs.RunRunsList(ctx, cmd)
-}
--- a/cmd/actions/runs/delete.go
+++ b/cmd/actions/runs/delete.go
@@ -1,65 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package runs
-
-import (
-	stdctx "context"
-	"fmt"
-	"strconv"
-
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/context"
-
-	"github.com/urfave/cli/v3"
-)
-
-// CmdRunsDelete represents a sub command to delete/cancel workflow runs
-var CmdRunsDelete = cli.Command{
-	Name:        "delete",
-	Aliases:     []string{"remove", "rm", "cancel"},
-	Usage:       "Delete or cancel a workflow run",
-	Description: "Delete (cancel) a workflow run from the repository",
-	ArgsUsage:   "<run-id>",
-	Action:      runRunsDelete,
-	Flags: append([]cli.Flag{
-		&cli.BoolFlag{
-			Name:    "confirm",
-			Aliases: []string{"y"},
-			Usage:   "confirm deletion without prompting",
-		},
-	}, flags.AllDefaultFlags...),
-}
-
-func runRunsDelete(ctx stdctx.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 0 {
-		return fmt.Errorf("run ID is required")
-	}
-
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	runIDStr := cmd.Args().First()
-	runID, err := strconv.ParseInt(runIDStr, 10, 64)
-	if err != nil {
-		return fmt.Errorf("invalid run ID: %s", runIDStr)
-	}
-
-	if !cmd.Bool("confirm") {
-		fmt.Printf("Are you sure you want to delete run %d? [y/N] ", runID)
-		var response string
-		fmt.Scanln(&response)
-		if response != "y" && response != "Y" && response != "yes" {
-			fmt.Println("Deletion canceled.")
-			return nil
-		}
-	}
-
-	_, err = client.DeleteRepoActionRun(c.Owner, c.Repo, runID)
-	if err != nil {
-		return fmt.Errorf("failed to delete run: %w", err)
-	}
-
-	fmt.Printf("Run %d deleted successfully\n", runID)
-	return nil
-}
--- a/cmd/actions/runs/list.go
+++ b/cmd/actions/runs/list.go
@@ -1,144 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package runs
-
-import (
-	stdctx "context"
-	"fmt"
-	"time"
-
-	"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"
-)
-
-// CmdRunsList represents a sub command to list workflow runs
-var CmdRunsList = cli.Command{
-	Name:        "list",
-	Aliases:     []string{"ls"},
-	Usage:       "List workflow runs",
-	Description: "List workflow runs for repository actions with optional filtering",
-	Action:      RunRunsList,
-	Flags: append([]cli.Flag{
-		&flags.PaginationPageFlag,
-		&flags.PaginationLimitFlag,
-		&cli.StringFlag{
-			Name:  "status",
-			Usage: "Filter by status (success, failure, pending, queued, in_progress, skipped, canceled)",
-		},
-		&cli.StringFlag{
-			Name:  "branch",
-			Usage: "Filter by branch name",
-		},
-		&cli.StringFlag{
-			Name:  "event",
-			Usage: "Filter by event type (push, pull_request, etc.)",
-		},
-		&cli.StringFlag{
-			Name:  "actor",
-			Usage: "Filter by actor username (who triggered the run)",
-		},
-		&cli.StringFlag{
-			Name:  "since",
-			Usage: "Show runs started after this time (e.g., '24h', '2024-01-01')",
-		},
-		&cli.StringFlag{
-			Name:  "until",
-			Usage: "Show runs started before this time (e.g., '2024-01-01')",
-		},
-	}, flags.AllDefaultFlags...),
-}
-
-// parseTimeFlag parses time flags like "24h" or "2024-01-01"
-func parseTimeFlag(value string) (time.Time, error) {
-	if value == "" {
-		return time.Time{}, nil
-	}
-
-	// Try parsing as duration (e.g., "24h", "168h")
-	if duration, err := time.ParseDuration(value); err == nil {
-		return time.Now().Add(-duration), nil
-	}
-
-	// Try parsing as date
-	formats := []string{
-		"2006-01-02",
-		"2006-01-02 15:04",
-		"2006-01-02T15:04:05",
-		time.RFC3339,
-	}
-
-	for _, format := range formats {
-		if t, err := time.Parse(format, value); err == nil {
-			return t, nil
-		}
-	}
-
-	return time.Time{}, fmt.Errorf("unable to parse time: %s", value)
-}
-
-// RunRunsList lists workflow runs
-func RunRunsList(ctx stdctx.Context, cmd *cli.Command) error {
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	// Parse time filters
-	since, err := parseTimeFlag(cmd.String("since"))
-	if err != nil {
-		return fmt.Errorf("invalid --since value: %w", err)
-	}
-
-	until, err := parseTimeFlag(cmd.String("until"))
-	if err != nil {
-		return fmt.Errorf("invalid --until value: %w", err)
-	}
-
-	// Build list options
-	listOpts := flags.GetListOptions()
-
-	runs, _, err := client.ListRepoActionRuns(c.Owner, c.Repo, gitea.ListRepoActionRunsOptions{
-		ListOptions: listOpts,
-		Status:      cmd.String("status"),
-		Branch:      cmd.String("branch"),
-		Event:       cmd.String("event"),
-		Actor:       cmd.String("actor"),
-	})
-	if err != nil {
-		return err
-	}
-
-	if runs == nil {
-		print.ActionRunsList(nil, c.Output)
-		return nil
-	}
-
-	// Filter by time if specified
-	filteredRuns := filterRunsByTime(runs.WorkflowRuns, since, until)
-
-	print.ActionRunsList(filteredRuns, c.Output)
-	return nil
-}
-
-// filterRunsByTime filters runs based on time range
-func filterRunsByTime(runs []*gitea.ActionWorkflowRun, since, until time.Time) []*gitea.ActionWorkflowRun {
-	if since.IsZero() && until.IsZero() {
-		return runs
-	}
-
-	var filtered []*gitea.ActionWorkflowRun
-	for _, run := range runs {
-		if !since.IsZero() && run.StartedAt.Before(since) {
-			continue
-		}
-		if !until.IsZero() && run.StartedAt.After(until) {
-			continue
-		}
-		filtered = append(filtered, run)
-	}
-
-	return filtered
-}
--- a/cmd/actions/runs/list_test.go
+++ b/cmd/actions/runs/list_test.go
@@ -1,77 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package runs
-
-import (
-	"testing"
-	"time"
-
-	"code.gitea.io/sdk/gitea"
-)
-
-func TestFilterRunsByTime(t *testing.T) {
-	now := time.Now()
-	runs := []*gitea.ActionWorkflowRun{
-		{ID: 1, StartedAt: now.Add(-1 * time.Hour)},
-		{ID: 2, StartedAt: now.Add(-2 * time.Hour)},
-		{ID: 3, StartedAt: now.Add(-3 * time.Hour)},
-		{ID: 4, StartedAt: now.Add(-4 * time.Hour)},
-		{ID: 5, StartedAt: now.Add(-5 * time.Hour)},
-	}
-
-	tests := []struct {
-		name     string
-		since    time.Time
-		until    time.Time
-		expected []int64
-	}{
-		{
-			name:     "no filter",
-			since:    time.Time{},
-			until:    time.Time{},
-			expected: []int64{1, 2, 3, 4, 5},
-		},
-		{
-			name:     "since 2.5 hours ago",
-			since:    now.Add(-150 * time.Minute),
-			until:    time.Time{},
-			expected: []int64{1, 2},
-		},
-		{
-			name:     "until 2.5 hours ago",
-			since:    time.Time{},
-			until:    now.Add(-150 * time.Minute),
-			expected: []int64{3, 4, 5},
-		},
-		{
-			name:     "between 2 and 4 hours ago",
-			since:    now.Add(-4 * time.Hour),
-			until:    now.Add(-2 * time.Hour),
-			expected: []int64{2, 3, 4},
-		},
-		{
-			name:     "filter excludes all",
-			since:    now.Add(-30 * time.Minute),
-			until:    time.Time{},
-			expected: []int64{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := filterRunsByTime(runs, tt.since, tt.until)
-
-			if len(result) != len(tt.expected) {
-				t.Errorf("filterRunsByTime() returned %d runs, want %d", len(result), len(tt.expected))
-				return
-			}
-
-			for i, run := range result {
-				if run.ID != tt.expected[i] {
-					t.Errorf("filterRunsByTime()[%d].ID = %d, want %d", i, run.ID, tt.expected[i])
-				}
-			}
-		})
-	}
-}
--- a/cmd/actions/runs/logs.go
+++ b/cmd/actions/runs/logs.go
@@ -1,169 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package runs
-
-import (
-	stdctx "context"
-	"fmt"
-	"strconv"
-	"time"
-
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/context"
-
-	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v3"
-)
-
-// CmdRunsLogs represents a sub command to view workflow run logs
-var CmdRunsLogs = cli.Command{
-	Name:        "logs",
-	Aliases:     []string{"log"},
-	Usage:       "View workflow run logs",
-	Description: "View logs for a workflow run or specific job",
-	ArgsUsage:   "<run-id>",
-	Action:      runRunsLogs,
-	Flags: append([]cli.Flag{
-		&cli.StringFlag{
-			Name:  "job",
-			Usage: "specific job ID to view logs for (if omitted, shows all jobs)",
-		},
-		&cli.BoolFlag{
-			Name:    "follow",
-			Aliases: []string{"f"},
-			Usage:   "follow log output (like tail -f), requires job to be in progress",
-		},
-	}, flags.AllDefaultFlags...),
-}
-
-func runRunsLogs(ctx stdctx.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 0 {
-		return fmt.Errorf("run ID is required")
-	}
-
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	runIDStr := cmd.Args().First()
-	runID, err := strconv.ParseInt(runIDStr, 10, 64)
-	if err != nil {
-		return fmt.Errorf("invalid run ID: %s", runIDStr)
-	}
-
-	// Check if follow mode is enabled
-	follow := cmd.Bool("follow")
-
-	// If specific job ID provided, fetch only that job's logs
-	jobIDStr := cmd.String("job")
-	if jobIDStr != "" {
-		jobID, err := strconv.ParseInt(jobIDStr, 10, 64)
-		if err != nil {
-			return fmt.Errorf("invalid job ID: %s", jobIDStr)
-		}
-
-		if follow {
-			return followJobLogs(client, c, jobID, "")
-		}
-
-		logs, _, err := client.GetRepoActionJobLogs(c.Owner, c.Repo, jobID)
-		if err != nil {
-			return fmt.Errorf("failed to get logs for job %d: %w", jobID, err)
-		}
-
-		fmt.Printf("Logs for job %d:\n", jobID)
-		fmt.Printf("---\n%s\n", string(logs))
-		return nil
-	}
-
-	// Otherwise, fetch all jobs and their logs
-	jobs, _, err := client.ListRepoActionRunJobs(c.Owner, c.Repo, runID, gitea.ListRepoActionJobsOptions{
-		ListOptions: flags.GetListOptions(),
-	})
-	if err != nil {
-		return fmt.Errorf("failed to get jobs: %w", err)
-	}
-
-	if len(jobs.Jobs) == 0 {
-		fmt.Printf("No jobs found for run %d\n", runID)
-		return nil
-	}
-
-	// If following and multiple jobs, require --job flag
-	if follow && len(jobs.Jobs) > 1 {
-		return fmt.Errorf("--follow requires --job when run has multiple jobs (found %d jobs)", len(jobs.Jobs))
-	}
-
-	// If following with single job, follow it
-	if follow && len(jobs.Jobs) == 1 {
-		return followJobLogs(client, c, jobs.Jobs[0].ID, jobs.Jobs[0].Name)
-	}
-
-	// Fetch logs for each job
-	for i, job := range jobs.Jobs {
-		if i > 0 {
-			fmt.Println()
-		}
-
-		fmt.Printf("Job: %s (ID: %d)\n", job.Name, job.ID)
-		fmt.Printf("Status: %s\n", job.Status)
-		fmt.Println("---")
-
-		logs, _, err := client.GetRepoActionJobLogs(c.Owner, c.Repo, job.ID)
-		if err != nil {
-			fmt.Printf("Error fetching logs: %v\n", err)
-			continue
-		}
-
-		fmt.Println(string(logs))
-	}
-
-	return nil
-}
-
-// followJobLogs continuously fetches and displays logs for a running job
-func followJobLogs(client *gitea.Client, c *context.TeaContext, jobID int64, jobName string) error {
-	var lastLogLength int
-
-	if jobName != "" {
-		fmt.Printf("Following logs for job '%s' (ID: %d) - press Ctrl+C to stop...\n", jobName, jobID)
-	} else {
-		fmt.Printf("Following logs for job %d (press Ctrl+C to stop)...\n", jobID)
-	}
-	fmt.Println("---")
-
-	for {
-		// Fetch job status
-		job, _, err := client.GetRepoActionJob(c.Owner, c.Repo, jobID)
-		if err != nil {
-			return fmt.Errorf("failed to get job: %w", err)
-		}
-
-		// Check if job is still running
-		isRunning := job.Status == "in_progress" || job.Status == "queued" || job.Status == "pending"
-
-		// Fetch logs
-		logs, _, err := client.GetRepoActionJobLogs(c.Owner, c.Repo, jobID)
-		if err != nil {
-			return fmt.Errorf("failed to get logs: %w", err)
-		}
-
-		// Display new content only
-		if len(logs) > lastLogLength {
-			newLogs := string(logs)[lastLogLength:]
-			fmt.Print(newLogs)
-			lastLogLength = len(logs)
-		}
-
-		// If job is complete, exit
-		if !isRunning {
-			fmt.Printf("\n---\nJob completed with status: %s\n", job.Status)
-			break
-		}
-
-		// Wait before next poll
-		time.Sleep(2 * time.Second)
-	}
-
-	return nil
-}
--- a/cmd/actions/runs/view.go
+++ b/cmd/actions/runs/view.go
@@ -1,75 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package runs
-
-import (
-	stdctx "context"
-	"fmt"
-	"strconv"
-
-	"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"
-)
-
-// CmdRunsView represents a sub command to view workflow run details
-var CmdRunsView = cli.Command{
-	Name:        "view",
-	Aliases:     []string{"show", "get"},
-	Usage:       "View workflow run details",
-	Description: "View details of a specific workflow run including jobs",
-	ArgsUsage:   "<run-id>",
-	Action:      runRunsView,
-	Flags: append([]cli.Flag{
-		&cli.BoolFlag{
-			Name:  "jobs",
-			Usage: "show jobs table",
-			Value: true,
-		},
-	}, flags.AllDefaultFlags...),
-}
-
-func runRunsView(ctx stdctx.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 0 {
-		return fmt.Errorf("run ID is required")
-	}
-
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	runIDStr := cmd.Args().First()
-	runID, err := strconv.ParseInt(runIDStr, 10, 64)
-	if err != nil {
-		return fmt.Errorf("invalid run ID: %s", runIDStr)
-	}
-
-	// Fetch run details
-	run, _, err := client.GetRepoActionRun(c.Owner, c.Repo, runID)
-	if err != nil {
-		return fmt.Errorf("failed to get run: %w", err)
-	}
-
-	// Print run details
-	print.ActionRunDetails(run)
-
-	// Fetch and print jobs if requested
-	if cmd.Bool("jobs") {
-		jobs, _, err := client.ListRepoActionRunJobs(c.Owner, c.Repo, runID, gitea.ListRepoActionJobsOptions{
-			ListOptions: flags.GetListOptions(),
-		})
-		if err != nil {
-			return fmt.Errorf("failed to get jobs: %w", err)
-		}
-
-		if jobs != nil && len(jobs.Jobs) > 0 {
-			fmt.Printf("\nJobs:\n\n")
-			print.ActionWorkflowJobsList(jobs.Jobs, c.Output)
-		}
-	}
-
-	return nil
-}
--- a/cmd/actions/secrets.go
+++ b/cmd/actions/secrets.go
@@ -1,30 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package actions
-
-import (
-	stdctx "context"
-
-	"code.gitea.io/tea/cmd/actions/secrets"
-
-	"github.com/urfave/cli/v3"
-)
-
-// CmdActionsSecrets represents the actions secrets command
-var CmdActionsSecrets = cli.Command{
-	Name:        "secrets",
-	Aliases:     []string{"secret"},
-	Usage:       "Manage repository action secrets",
-	Description: "Manage secrets used by repository actions and workflows",
-	Action:      runSecretsDefault,
-	Commands: []*cli.Command{
-		&secrets.CmdSecretsList,
-		&secrets.CmdSecretsCreate,
-		&secrets.CmdSecretsDelete,
-	},
-}
-
-func runSecretsDefault(ctx stdctx.Context, cmd *cli.Command) error {
-	return secrets.RunSecretsList(ctx, cmd)
-}
--- a/cmd/actions/secrets/create.go
+++ b/cmd/actions/secrets/create.go
@@ -1,69 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package secrets
-
-import (
-	stdctx "context"
-	"fmt"
-
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/context"
-	"code.gitea.io/tea/modules/utils"
-
-	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v3"
-)
-
-// CmdSecretsCreate represents a sub command to create action secrets
-var CmdSecretsCreate = cli.Command{
-	Name:        "create",
-	Aliases:     []string{"add", "set"},
-	Usage:       "Create an action secret",
-	Description: "Create a secret for use in repository actions and workflows",
-	ArgsUsage:   "<secret-name> [secret-value]",
-	Action:      runSecretsCreate,
-	Flags: append([]cli.Flag{
-		&cli.StringFlag{
-			Name:  "file",
-			Usage: "read secret value from file",
-		},
-		&cli.BoolFlag{
-			Name:  "stdin",
-			Usage: "read secret value from stdin",
-		},
-	}, flags.AllDefaultFlags...),
-}
-
-func runSecretsCreate(ctx stdctx.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 0 {
-		return fmt.Errorf("secret name is required")
-	}
-
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	secretName := cmd.Args().First()
-
-	// Read secret value using the utility
-	secretValue, err := utils.ReadValue(cmd, utils.ReadValueOptions{
-		ResourceName: "secret",
-		PromptMsg:    fmt.Sprintf("Enter secret value for '%s'", secretName),
-		Hidden:       true,
-		AllowEmpty:   false,
-	})
-	if err != nil {
-		return err
-	}
-
-	_, err = client.CreateRepoActionSecret(c.Owner, c.Repo, gitea.CreateSecretOption{
-		Name: secretName,
-		Data: secretValue,
-	})
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Secret '%s' created successfully\n", secretName)
-	return nil
-}
--- a/cmd/actions/secrets/create_test.go
+++ b/cmd/actions/secrets/create_test.go
@@ -1,56 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package secrets
-
-import (
-	"testing"
-)
-
-func TestGetSecretSourceArgs(t *testing.T) {
-	tests := []struct {
-		name    string
-		args    []string
-		wantErr bool
-	}{
-		{
-			name:    "valid args",
-			args:    []string{"VALID_SECRET", "secret_value"},
-			wantErr: false,
-		},
-		{
-			name:    "missing name",
-			args:    []string{},
-			wantErr: true,
-		},
-		{
-			name:    "too many args",
-			args:    []string{"SECRET_NAME", "value", "extra"},
-			wantErr: true,
-		},
-		{
-			name:    "invalid secret name",
-			args:    []string{"invalid_secret", "value"},
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Test argument validation only
-			if len(tt.args) == 0 {
-				if !tt.wantErr {
-					t.Error("Expected error for empty args")
-				}
-				return
-			}
-
-			if len(tt.args) > 2 {
-				if !tt.wantErr {
-					t.Error("Expected error for too many args")
-				}
-				return
-			}
-		})
-	}
-}
--- a/cmd/actions/secrets/delete.go
+++ b/cmd/actions/secrets/delete.go
@@ -1,60 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package secrets
-
-import (
-	stdctx "context"
-	"fmt"
-
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/context"
-
-	"github.com/urfave/cli/v3"
-)
-
-// CmdSecretsDelete represents a sub command to delete action secrets
-var CmdSecretsDelete = cli.Command{
-	Name:        "delete",
-	Aliases:     []string{"remove", "rm"},
-	Usage:       "Delete an action secret",
-	Description: "Delete a secret used by repository actions",
-	ArgsUsage:   "<secret-name>",
-	Action:      runSecretsDelete,
-	Flags: append([]cli.Flag{
-		&cli.BoolFlag{
-			Name:    "confirm",
-			Aliases: []string{"y"},
-			Usage:   "confirm deletion without prompting",
-		},
-	}, flags.AllDefaultFlags...),
-}
-
-func runSecretsDelete(ctx stdctx.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 0 {
-		return fmt.Errorf("secret name is required")
-	}
-
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	secretName := cmd.Args().First()
-
-	if !cmd.Bool("confirm") {
-		fmt.Printf("Are you sure you want to delete secret '%s'? [y/N] ", secretName)
-		var response string
-		fmt.Scanln(&response)
-		if response != "y" && response != "Y" && response != "yes" {
-			fmt.Println("Deletion canceled.")
-			return nil
-		}
-	}
-
-	_, err := client.DeleteRepoActionSecret(c.Owner, c.Repo, secretName)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Secret '%s' deleted successfully\n", secretName)
-	return nil
-}
--- a/cmd/actions/secrets/delete_test.go
+++ b/cmd/actions/secrets/delete_test.go
@@ -1,93 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package secrets
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestSecretsDeleteValidation(t *testing.T) {
-	tests := []struct {
-		name    string
-		args    []string
-		wantErr bool
-	}{
-		{
-			name:    "valid secret name",
-			args:    []string{"VALID_SECRET"},
-			wantErr: false,
-		},
-		{
-			name:    "no args",
-			args:    []string{},
-			wantErr: true,
-		},
-		{
-			name:    "too many args",
-			args:    []string{"SECRET1", "SECRET2"},
-			wantErr: true,
-		},
-		{
-			name:    "invalid secret name but client does not validate",
-			args:    []string{"invalid_secret"},
-			wantErr: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := validateDeleteArgs(tt.args)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("validateDeleteArgs() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestSecretsDeleteFlags(t *testing.T) {
-	cmd := CmdSecretsDelete
-
-	// Test command properties
-	if cmd.Name != "delete" {
-		t.Errorf("Expected command name 'delete', got %s", cmd.Name)
-	}
-
-	// Check that rm is one of the aliases
-	hasRmAlias := false
-	for _, alias := range cmd.Aliases {
-		if alias == "rm" {
-			hasRmAlias = true
-			break
-		}
-	}
-	if !hasRmAlias {
-		t.Error("Expected 'rm' to be one of the aliases for delete command")
-	}
-
-	if cmd.ArgsUsage != "<secret-name>" {
-		t.Errorf("Expected ArgsUsage '<secret-name>', got %s", cmd.ArgsUsage)
-	}
-
-	if cmd.Usage == "" {
-		t.Error("Delete command should have usage text")
-	}
-
-	if cmd.Description == "" {
-		t.Error("Delete command should have description")
-	}
-}
-
-// validateDeleteArgs validates arguments for the delete command
-func validateDeleteArgs(args []string) error {
-	if len(args) == 0 {
-		return fmt.Errorf("secret name is required")
-	}
-
-	if len(args) > 1 {
-		return fmt.Errorf("only one secret name allowed")
-	}
-
-	return nil
-}
--- a/cmd/actions/secrets/list.go
+++ b/cmd/actions/secrets/list.go
@@ -1,44 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package secrets
-
-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"
-)
-
-// CmdSecretsList represents a sub command to list action secrets
-var CmdSecretsList = cli.Command{
-	Name:        "list",
-	Aliases:     []string{"ls"},
-	Usage:       "List action secrets",
-	Description: "List secrets configured for repository actions",
-	Action:      RunSecretsList,
-	Flags: append([]cli.Flag{
-		&flags.PaginationPageFlag,
-		&flags.PaginationLimitFlag,
-	}, flags.AllDefaultFlags...),
-}
-
-// RunSecretsList list action secrets
-func RunSecretsList(ctx stdctx.Context, cmd *cli.Command) error {
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	secrets, _, err := client.ListRepoActionSecret(c.Owner, c.Repo, gitea.ListRepoActionSecretOption{
-		ListOptions: flags.GetListOptions(),
-	})
-	if err != nil {
-		return err
-	}
-
-	print.ActionSecretsList(secrets, c.Output)
-	return nil
-}
--- a/cmd/actions/secrets/list_test.go
+++ b/cmd/actions/secrets/list_test.go
@@ -1,63 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package secrets
-
-import (
-	"testing"
-)
-
-func TestSecretsListFlags(t *testing.T) {
-	cmd := CmdSecretsList
-
-	// Test that required flags exist
-	expectedFlags := []string{"output", "remote", "login", "repo"}
-
-	for _, flagName := range expectedFlags {
-		found := false
-		for _, flag := range cmd.Flags {
-			if flag.Names()[0] == flagName {
-				found = true
-				break
-			}
-		}
-
-		if !found {
-			t.Errorf("Expected flag %s not found in CmdSecretsList", flagName)
-		}
-	}
-
-	// Test command properties
-	if cmd.Name != "list" {
-		t.Errorf("Expected command name 'list', got %s", cmd.Name)
-	}
-
-	if len(cmd.Aliases) == 0 || cmd.Aliases[0] != "ls" {
-		t.Errorf("Expected alias 'ls' for list command")
-	}
-
-	if cmd.Usage == "" {
-		t.Error("List command should have usage text")
-	}
-
-	if cmd.Description == "" {
-		t.Error("List command should have description")
-	}
-}
-
-func TestSecretsListValidation(t *testing.T) {
-	// Basic validation that the command accepts the expected arguments
-	// More detailed testing would require mocking the Gitea client
-
-	// Test that list command doesn't require arguments
-	args := []string{}
-	if len(args) > 0 {
-		t.Error("List command should not require arguments")
-	}
-
-	// Test that extra arguments are ignored
-	extraArgs := []string{"extra", "args"}
-	if len(extraArgs) > 0 {
-		// This is fine - list commands typically ignore extra args
-	}
-}
--- a/cmd/actions/variables.go
+++ b/cmd/actions/variables.go
@@ -1,30 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package actions
-
-import (
-	stdctx "context"
-
-	"code.gitea.io/tea/cmd/actions/variables"
-
-	"github.com/urfave/cli/v3"
-)
-
-// CmdActionsVariables represents the actions variables command
-var CmdActionsVariables = cli.Command{
-	Name:        "variables",
-	Aliases:     []string{"variable", "vars", "var"},
-	Usage:       "Manage repository action variables",
-	Description: "Manage variables used by repository actions and workflows",
-	Action:      runVariablesDefault,
-	Commands: []*cli.Command{
-		&variables.CmdVariablesList,
-		&variables.CmdVariablesSet,
-		&variables.CmdVariablesDelete,
-	},
-}
-
-func runVariablesDefault(ctx stdctx.Context, cmd *cli.Command) error {
-	return variables.RunVariablesList(ctx, cmd)
-}
--- a/cmd/actions/variables/delete.go
+++ b/cmd/actions/variables/delete.go
@@ -1,60 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package variables
-
-import (
-	stdctx "context"
-	"fmt"
-
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/context"
-
-	"github.com/urfave/cli/v3"
-)
-
-// CmdVariablesDelete represents a sub command to delete action variables
-var CmdVariablesDelete = cli.Command{
-	Name:        "delete",
-	Aliases:     []string{"remove", "rm"},
-	Usage:       "Delete an action variable",
-	Description: "Delete a variable used by repository actions",
-	ArgsUsage:   "<variable-name>",
-	Action:      runVariablesDelete,
-	Flags: append([]cli.Flag{
-		&cli.BoolFlag{
-			Name:    "confirm",
-			Aliases: []string{"y"},
-			Usage:   "confirm deletion without prompting",
-		},
-	}, flags.AllDefaultFlags...),
-}
-
-func runVariablesDelete(ctx stdctx.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 0 {
-		return fmt.Errorf("variable name is required")
-	}
-
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	variableName := cmd.Args().First()
-
-	if !cmd.Bool("confirm") {
-		fmt.Printf("Are you sure you want to delete variable '%s'? [y/N] ", variableName)
-		var response string
-		fmt.Scanln(&response)
-		if response != "y" && response != "Y" && response != "yes" {
-			fmt.Println("Deletion canceled.")
-			return nil
-		}
-	}
-
-	_, err := client.DeleteRepoActionVariable(c.Owner, c.Repo, variableName)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Variable '%s' deleted successfully\n", variableName)
-	return nil
-}
--- a/cmd/actions/variables/delete_test.go
+++ b/cmd/actions/variables/delete_test.go
@@ -1,98 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package variables
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestVariablesDeleteValidation(t *testing.T) {
-	tests := []struct {
-		name    string
-		args    []string
-		wantErr bool
-	}{
-		{
-			name:    "valid variable name",
-			args:    []string{"VALID_VARIABLE"},
-			wantErr: false,
-		},
-		{
-			name:    "valid lowercase name",
-			args:    []string{"valid_variable"},
-			wantErr: false,
-		},
-		{
-			name:    "no args",
-			args:    []string{},
-			wantErr: true,
-		},
-		{
-			name:    "too many args",
-			args:    []string{"VARIABLE1", "VARIABLE2"},
-			wantErr: true,
-		},
-		{
-			name:    "invalid variable name",
-			args:    []string{"invalid-variable"},
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := validateVariableDeleteArgs(tt.args)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("validateVariableDeleteArgs() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestVariablesDeleteFlags(t *testing.T) {
-	cmd := CmdVariablesDelete
-
-	// Test command properties
-	if cmd.Name != "delete" {
-		t.Errorf("Expected command name 'delete', got %s", cmd.Name)
-	}
-
-	// Check that rm is one of the aliases
-	hasRmAlias := false
-	for _, alias := range cmd.Aliases {
-		if alias == "rm" {
-			hasRmAlias = true
-			break
-		}
-	}
-	if !hasRmAlias {
-		t.Error("Expected 'rm' to be one of the aliases for delete command")
-	}
-
-	if cmd.ArgsUsage != "<variable-name>" {
-		t.Errorf("Expected ArgsUsage '<variable-name>', got %s", cmd.ArgsUsage)
-	}
-
-	if cmd.Usage == "" {
-		t.Error("Delete command should have usage text")
-	}
-
-	if cmd.Description == "" {
-		t.Error("Delete command should have description")
-	}
-}
-
-// validateVariableDeleteArgs validates arguments for the delete command
-func validateVariableDeleteArgs(args []string) error {
-	if len(args) == 0 {
-		return fmt.Errorf("variable name is required")
-	}
-
-	if len(args) > 1 {
-		return fmt.Errorf("only one variable name allowed")
-	}
-
-	return validateVariableName(args[0])
-}
--- a/cmd/actions/variables/list.go
+++ b/cmd/actions/variables/list.go
@@ -1,55 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package variables
-
-import (
-	stdctx "context"
-	"fmt"
-
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/context"
-	"code.gitea.io/tea/modules/print"
-
-	"github.com/urfave/cli/v3"
-)
-
-// CmdVariablesList represents a sub command to list action variables
-var CmdVariablesList = cli.Command{
-	Name:        "list",
-	Aliases:     []string{"ls"},
-	Usage:       "List action variables",
-	Description: "List variables configured for repository actions",
-	Action:      RunVariablesList,
-	Flags: append([]cli.Flag{
-		&cli.StringFlag{
-			Name:  "name",
-			Usage: "show specific variable by name",
-		},
-	}, flags.AllDefaultFlags...),
-}
-
-// RunVariablesList list action variables
-func RunVariablesList(ctx stdctx.Context, cmd *cli.Command) error {
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	if name := cmd.String("name"); name != "" {
-		// Get specific variable
-		variable, _, err := client.GetRepoActionVariable(c.Owner, c.Repo, name)
-		if err != nil {
-			return err
-		}
-
-		print.ActionVariableDetails(variable)
-		return nil
-	}
-
-	// List all variables - Note: SDK doesn't have ListRepoActionVariables yet
-	// This is a limitation of the current SDK
-	fmt.Println("Note: Listing all variables is not yet supported by the Gitea SDK.")
-	fmt.Println("Use 'tea actions variables list --name <variable-name>' to get a specific variable.")
-	fmt.Println("You can also check your repository's Actions settings in the web interface.")
-
-	return nil
-}
--- a/cmd/actions/variables/list_test.go
+++ b/cmd/actions/variables/list_test.go
@@ -1,63 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package variables
-
-import (
-	"testing"
-)
-
-func TestVariablesListFlags(t *testing.T) {
-	cmd := CmdVariablesList
-
-	// Test that required flags exist
-	expectedFlags := []string{"output", "remote", "login", "repo"}
-
-	for _, flagName := range expectedFlags {
-		found := false
-		for _, flag := range cmd.Flags {
-			if flag.Names()[0] == flagName {
-				found = true
-				break
-			}
-		}
-
-		if !found {
-			t.Errorf("Expected flag %s not found in CmdVariablesList", flagName)
-		}
-	}
-
-	// Test command properties
-	if cmd.Name != "list" {
-		t.Errorf("Expected command name 'list', got %s", cmd.Name)
-	}
-
-	if len(cmd.Aliases) == 0 || cmd.Aliases[0] != "ls" {
-		t.Errorf("Expected alias 'ls' for list command")
-	}
-
-	if cmd.Usage == "" {
-		t.Error("List command should have usage text")
-	}
-
-	if cmd.Description == "" {
-		t.Error("List command should have description")
-	}
-}
-
-func TestVariablesListValidation(t *testing.T) {
-	// Basic validation that the command accepts the expected arguments
-	// More detailed testing would require mocking the Gitea client
-
-	// Test that list command doesn't require arguments
-	args := []string{}
-	if len(args) > 0 {
-		t.Error("List command should not require arguments")
-	}
-
-	// Test that extra arguments are ignored
-	extraArgs := []string{"extra", "args"}
-	if len(extraArgs) > 0 {
-		// This is fine - list commands typically ignore extra args
-	}
-}
--- a/cmd/actions/variables/set.go
+++ b/cmd/actions/variables/set.go
@@ -1,102 +0,0 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package variables
-
-import (
-	stdctx "context"
-	"fmt"
-	"regexp"
-
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/context"
-	"code.gitea.io/tea/modules/utils"
-
-	"github.com/urfave/cli/v3"
-)
-
-// CmdVariablesSet represents a sub command to set action variables
-var CmdVariablesSet = cli.Command{
-	Name:        "set",
-	Aliases:     []string{"create", "update"},
-	Usage:       "Set an action variable",
-	Description: "Set a variable for use in repository actions and workflows",
-	ArgsUsage:   "<variable-name> [variable-value]",
-	Action:      runVariablesSet,
-	Flags: append([]cli.Flag{
-		&cli.StringFlag{
-			Name:  "file",
-			Usage: "read variable value from file",
-		},
-		&cli.BoolFlag{
-			Name:  "stdin",
-			Usage: "read variable value from stdin",
-		},
-	}, flags.AllDefaultFlags...),
-}
-
-func runVariablesSet(ctx stdctx.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 0 {
-		return fmt.Errorf("variable name is required")
-	}
-
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	variableName := cmd.Args().First()
-	if err := validateVariableName(variableName); err != nil {
-		return err
-	}
-
-	// Read variable value using the utility
-	variableValue, err := utils.ReadValue(cmd, utils.ReadValueOptions{
-		ResourceName: "variable",
-		PromptMsg:    fmt.Sprintf("Enter variable value for '%s'", variableName),
-		Hidden:       false,
-		AllowEmpty:   false,
-	})
-	if err != nil {
-		return err
-	}
-
-	if err := validateVariableValue(variableValue); err != nil {
-		return err
-	}
-
-	_, err = client.CreateRepoActionVariable(c.Owner, c.Repo, variableName, variableValue)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Variable '%s' set successfully\n", variableName)
-	return nil
-}
-
-// validateVariableName validates that a variable name follows the required format
-func validateVariableName(name string) error {
-	if name == "" {
-		return fmt.Errorf("variable name cannot be empty")
-	}
-
-	// Variable names can contain letters (upper/lower), numbers, and underscores
-	// Cannot start with a number
-	// Cannot contain spaces or special characters (except underscore)
-	validPattern := regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
-	if !validPattern.MatchString(name) {
-		return fmt.Errorf("variable name must contain only letters, numbers, and underscores, and cannot start with a number")
-	}
-
-	return nil
-}
-
-// validateVariableValue validates that a variable value is acceptable
-func validateVariableValue(value string) error {
-	// Variables can be empty or contain whitespace, unlike secrets
-
-	// Check for maximum size (64KB limit)
-	if len(value) > 65536 {
-		return fmt.Errorf("variable value cannot exceed 64KB")
-	}
-
-	return nil
-}
--- a/cmd/actions/variables/set_test.go
+++ b/cmd/actions/variables/set_test.go
@@ -1,213 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package variables
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestValidateVariableName(t *testing.T) {
-	tests := []struct {
-		name    string
-		input   string
-		wantErr bool
-	}{
-		{
-			name:    "valid name",
-			input:   "VALID_VARIABLE_NAME",
-			wantErr: false,
-		},
-		{
-			name:    "valid name with numbers",
-			input:   "VARIABLE_123",
-			wantErr: false,
-		},
-		{
-			name:    "valid lowercase",
-			input:   "valid_variable",
-			wantErr: false,
-		},
-		{
-			name:    "valid mixed case",
-			input:   "Mixed_Case_Variable",
-			wantErr: false,
-		},
-		{
-			name:    "invalid - spaces",
-			input:   "INVALID VARIABLE",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - special chars",
-			input:   "INVALID-VARIABLE!",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - starts with number",
-			input:   "1INVALID",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - empty",
-			input:   "",
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := validateVariableName(tt.input)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("validateVariableName(%q) error = %v, wantErr %v", tt.input, err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestGetVariableSourceArgs(t *testing.T) {
-	tests := []struct {
-		name    string
-		args    []string
-		wantErr bool
-	}{
-		{
-			name:    "valid args",
-			args:    []string{"VALID_VARIABLE", "variable_value"},
-			wantErr: false,
-		},
-		{
-			name:    "valid lowercase",
-			args:    []string{"valid_variable", "value"},
-			wantErr: false,
-		},
-		{
-			name:    "missing name",
-			args:    []string{},
-			wantErr: true,
-		},
-		{
-			name:    "too many args",
-			args:    []string{"VARIABLE_NAME", "value", "extra"},
-			wantErr: true,
-		},
-		{
-			name:    "invalid variable name",
-			args:    []string{"invalid-variable", "value"},
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Test argument validation only
-			if len(tt.args) == 0 {
-				if !tt.wantErr {
-					t.Error("Expected error for empty args")
-				}
-				return
-			}
-
-			if len(tt.args) > 2 {
-				if !tt.wantErr {
-					t.Error("Expected error for too many args")
-				}
-				return
-			}
-
-			// Test variable name validation
-			err := validateVariableName(tt.args[0])
-			if (err != nil) != tt.wantErr {
-				t.Errorf("validateVariableName() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestVariableNameValidation(t *testing.T) {
-	// Test that variable names follow GitHub Actions/Gitea Actions conventions
-	validNames := []string{
-		"VALID_VARIABLE",
-		"API_URL",
-		"DATABASE_HOST",
-		"VARIABLE_123",
-		"mixed_Case_Variable",
-		"lowercase_variable",
-		"UPPERCASE_VARIABLE",
-	}
-
-	invalidNames := []string{
-		"Invalid-Dashes",
-		"INVALID SPACES",
-		"123_STARTS_WITH_NUMBER",
-		"",           // Empty
-		"INVALID!@#", // Special chars
-	}
-
-	for _, name := range validNames {
-		t.Run("valid_"+name, func(t *testing.T) {
-			err := validateVariableName(name)
-			if err != nil {
-				t.Errorf("validateVariableName(%q) should be valid, got error: %v", name, err)
-			}
-		})
-	}
-
-	for _, name := range invalidNames {
-		t.Run("invalid_"+name, func(t *testing.T) {
-			err := validateVariableName(name)
-			if err == nil {
-				t.Errorf("validateVariableName(%q) should be invalid, got no error", name)
-			}
-		})
-	}
-}
-
-func TestVariableValueValidation(t *testing.T) {
-	tests := []struct {
-		name    string
-		value   string
-		wantErr bool
-	}{
-		{
-			name:    "valid value",
-			value:   "variable123",
-			wantErr: false,
-		},
-		{
-			name:    "valid complex value",
-			value:   "https://api.example.com/v1",
-			wantErr: false,
-		},
-		{
-			name:    "valid multiline value",
-			value:   "line1\nline2\nline3",
-			wantErr: false,
-		},
-		{
-			name:    "empty value allowed",
-			value:   "",
-			wantErr: false, // Variables can be empty unlike secrets
-		},
-		{
-			name:    "whitespace only allowed",
-			value:   "   \t\n   ",
-			wantErr: false, // Variables can contain whitespace
-		},
-		{
-			name:    "very long value",
-			value:   strings.Repeat("a", 65537), // Over 64KB
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := validateVariableValue(tt.value)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("validateVariableValue() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
--- a/cmd/actions/workflows.go
+++ b/cmd/actions/workflows.go
@@ -1,28 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package actions
-
-import (
-	stdctx "context"
-
-	"code.gitea.io/tea/cmd/actions/workflows"
-
-	"github.com/urfave/cli/v3"
-)
-
-// CmdActionsWorkflows represents the actions workflows command
-var CmdActionsWorkflows = cli.Command{
-	Name:        "workflows",
-	Aliases:     []string{"workflow"},
-	Usage:       "Manage repository workflows",
-	Description: "List and manage repository action workflows",
-	Action:      runWorkflowsDefault,
-	Commands: []*cli.Command{
-		&workflows.CmdWorkflowsList,
-	},
-}
-
-func runWorkflowsDefault(ctx stdctx.Context, cmd *cli.Command) error {
-	return workflows.RunWorkflowsList(ctx, cmd)
-}
--- a/cmd/actions/workflows/list.go
+++ b/cmd/actions/workflows/list.go
@@ -1,86 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package workflows
-
-import (
-	stdctx "context"
-	"fmt"
-	"path/filepath"
-	"strings"
-
-	"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"
-)
-
-// CmdWorkflowsList represents a sub command to list workflows
-var CmdWorkflowsList = cli.Command{
-	Name:        "list",
-	Aliases:     []string{"ls"},
-	Usage:       "List repository workflows",
-	Description: "List workflow files in the repository with active/inactive status",
-	Action:      RunWorkflowsList,
-	Flags: append([]cli.Flag{
-		&flags.PaginationPageFlag,
-		&flags.PaginationLimitFlag,
-	}, flags.AllDefaultFlags...),
-}
-
-// RunWorkflowsList lists workflow files in the repository
-func RunWorkflowsList(ctx stdctx.Context, cmd *cli.Command) error {
-	c := context.InitCommand(cmd)
-	client := c.Login.Client()
-
-	// Try to list workflow files from .gitea/workflows directory
-	var workflows []*gitea.ContentsResponse
-
-	// Try .gitea/workflows first, then .github/workflows
-	workflowDir := ".gitea/workflows"
-	contents, _, err := client.ListContents(c.Owner, c.Repo, "", workflowDir)
-	if err != nil {
-		workflowDir = ".github/workflows"
-		contents, _, err = client.ListContents(c.Owner, c.Repo, "", workflowDir)
-		if err != nil {
-			fmt.Printf("No workflow files found\n")
-			return nil
-		}
-	}
-
-	// Filter for workflow files (.yml and .yaml)
-	for _, content := range contents {
-		if content.Type == "file" {
-			ext := strings.ToLower(filepath.Ext(content.Name))
-			if ext == ".yml" || ext == ".yaml" {
-				content.Path = workflowDir + "/" + content.Name
-				workflows = append(workflows, content)
-			}
-		}
-	}
-
-	if len(workflows) == 0 {
-		fmt.Printf("No workflow files found\n")
-		return nil
-	}
-
-	// Check which workflows have runs to determine active status
-	workflowStatus := make(map[string]bool)
-
-	// Get recent runs to check activity
-	runs, _, err := client.ListRepoActionRuns(c.Owner, c.Repo, gitea.ListRepoActionRunsOptions{
-		ListOptions: flags.GetListOptions(),
-	})
-	if err == nil && runs != nil {
-		for _, run := range runs.WorkflowRuns {
-			// Extract workflow file name from path
-			workflowFile := filepath.Base(run.Path)
-			workflowStatus[workflowFile] = true
-		}
-	}
-
-	print.WorkflowsList(workflows, workflowStatus, c.Output)
-	return nil
-}
--- a/cmd/admin.go
+++ b/cmd/admin.go
@@ -1,56 +0,0 @@
-// 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
-}
--- a/cmd/admin/users/list.go
+++ b/cmd/admin/users/list.go
@@ -1,55 +0,0 @@
-// 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: flags.GetListOptions(),
-	})
-	if err != nil {
-		return err
-	}
-
-	print.UserList(users, ctx.Output, fields)
-
-	return nil
-}
--- a/cmd/api.go
+++ b/cmd/api.go
@@ -1,274 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	stdctx "context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/api"
-	"code.gitea.io/tea/modules/context"
-
-	"github.com/urfave/cli/v3"
-	"golang.org/x/term"
-)
-
-// CmdApi represents the api command
-var CmdApi = cli.Command{
-	Name:  "api",
-	Usage: "Make an authenticated API request",
-	Description: `Makes an authenticated HTTP request to the Gitea API and prints the response.
-
-The endpoint argument is the path to the API endpoint, which will be prefixed
-with /api/v1/ if it doesn't start with /api/ or http(s)://.
-
-Placeholders like {owner} and {repo} in the endpoint will be replaced with
-values from the current repository context.
-
-Use -f for string fields and -F for typed fields (numbers, booleans, null).
-With -F, prefix value with @ to read from file (@- for stdin).`,
-	ArgsUsage: "<endpoint>",
-	Action:    runApi,
-	Flags: append([]cli.Flag{
-		&cli.StringFlag{
-			Name:    "method",
-			Aliases: []string{"X"},
-			Usage:   "HTTP method (GET, POST, PUT, PATCH, DELETE)",
-			Value:   "GET",
-		},
-		&cli.StringSliceFlag{
-			Name:    "field",
-			Aliases: []string{"f"},
-			Usage:   "Add a string field to the request body (key=value)",
-		},
-		&cli.StringSliceFlag{
-			Name:    "Field",
-			Aliases: []string{"F"},
-			Usage:   "Add a typed field to the request body (key=value, @file, or @- for stdin)",
-		},
-		&cli.StringSliceFlag{
-			Name:    "header",
-			Aliases: []string{"H"},
-			Usage:   "Add a custom header (key:value)",
-		},
-		&cli.BoolFlag{
-			Name:    "include",
-			Aliases: []string{"i"},
-			Usage:   "Include HTTP status and response headers in output (written to stderr)",
-		},
-		&cli.StringFlag{
-			Name:    "output",
-			Aliases: []string{"o"},
-			Usage:   "Write response body to file instead of stdout (use '-' for stdout)",
-		},
-	}, flags.LoginRepoFlags...),
-}
-
-func runApi(_ stdctx.Context, cmd *cli.Command) error {
-	ctx := context.InitCommand(cmd)
-
-	// Get the endpoint argument
-	if cmd.NArg() < 1 {
-		return fmt.Errorf("endpoint argument required")
-	}
-	endpoint := cmd.Args().First()
-
-	// Expand placeholders in endpoint
-	endpoint = expandPlaceholders(endpoint, ctx)
-
-	// Parse headers
-	headers := make(map[string]string)
-	for _, h := range cmd.StringSlice("header") {
-		parts := strings.SplitN(h, ":", 2)
-		if len(parts) != 2 {
-			return fmt.Errorf("invalid header format: %q (expected key:value)", h)
-		}
-		headers[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
-	}
-
-	// Build request body from fields
-	var body io.Reader
-	stringFields := cmd.StringSlice("field")
-	typedFields := cmd.StringSlice("Field")
-
-	if len(stringFields) > 0 || len(typedFields) > 0 {
-		bodyMap := make(map[string]any)
-
-		// Process string fields (-f)
-		for _, f := range stringFields {
-			parts := strings.SplitN(f, "=", 2)
-			if len(parts) != 2 {
-				return fmt.Errorf("invalid field format: %q (expected key=value)", f)
-			}
-			bodyMap[parts[0]] = parts[1]
-		}
-
-		// Process typed fields (-F)
-		for _, f := range typedFields {
-			parts := strings.SplitN(f, "=", 2)
-			if len(parts) != 2 {
-				return fmt.Errorf("invalid field format: %q (expected key=value)", f)
-			}
-			key := parts[0]
-			value := parts[1]
-
-			parsedValue, err := parseTypedValue(value)
-			if err != nil {
-				return fmt.Errorf("failed to parse field %q: %w", key, err)
-			}
-			bodyMap[key] = parsedValue
-		}
-
-		bodyBytes, err := json.Marshal(bodyMap)
-		if err != nil {
-			return fmt.Errorf("failed to encode request body: %w", err)
-		}
-		body = strings.NewReader(string(bodyBytes))
-	}
-
-	// Create API client and make request
-	client := api.NewClient(ctx.Login)
-	method := strings.ToUpper(cmd.String("method"))
-
-	resp, err := client.Do(method, endpoint, body, headers)
-	if err != nil {
-		return fmt.Errorf("request failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	// Print headers to stderr if requested (so redirects/pipes work correctly)
-	if cmd.Bool("include") {
-		fmt.Fprintf(os.Stderr, "%s %s\n", resp.Proto, resp.Status)
-		for key, values := range resp.Header {
-			for _, value := range values {
-				fmt.Fprintf(os.Stderr, "%s: %s\n", key, value)
-			}
-		}
-		fmt.Fprintln(os.Stderr)
-	}
-
-	// Determine output destination
-	outputPath := cmd.String("output")
-	forceStdout := outputPath == "-"
-	outputToStdout := outputPath == "" || forceStdout
-
-	// Check for binary output to terminal (skip warning if user explicitly forced stdout)
-	if outputToStdout && !forceStdout && term.IsTerminal(int(os.Stdout.Fd())) && !isTextContentType(resp.Header.Get("Content-Type")) {
-		fmt.Fprintln(os.Stderr, "Warning: Binary output detected. Use '-o <file>' to save to a file,")
-		fmt.Fprintln(os.Stderr, "or '-o -' to force output to terminal.")
-		return nil
-	}
-
-	var output io.Writer = os.Stdout
-	if !outputToStdout {
-		file, err := os.Create(outputPath)
-		if err != nil {
-			return fmt.Errorf("failed to create output file: %w", err)
-		}
-		defer file.Close()
-		output = file
-	}
-
-	// Copy response body to output
-	_, err = io.Copy(output, resp.Body)
-	if err != nil {
-		return fmt.Errorf("failed to read response: %w", err)
-	}
-
-	// Add newline for better terminal display
-	if outputToStdout && term.IsTerminal(int(os.Stdout.Fd())) {
-		fmt.Println()
-	}
-
-	return nil
-}
-
-// parseTypedValue parses a value for -F flag, handling:
-// - @filename: read content from file
-// - @-: read content from stdin
-// - true/false: boolean
-// - null: nil
-// - numbers: int or float
-// - otherwise: string
-func parseTypedValue(value string) (any, error) {
-	// Handle file references
-	if strings.HasPrefix(value, "@") {
-		filename := value[1:]
-		var content []byte
-		var err error
-
-		if filename == "-" {
-			content, err = io.ReadAll(os.Stdin)
-		} else {
-			content, err = os.ReadFile(filename)
-		}
-		if err != nil {
-			return nil, fmt.Errorf("failed to read %q: %w", value, err)
-		}
-		return strings.TrimSuffix(string(content), "\n"), nil
-	}
-
-	// Handle null
-	if value == "null" {
-		return nil, nil
-	}
-
-	// Handle booleans
-	if value == "true" {
-		return true, nil
-	}
-	if value == "false" {
-		return false, nil
-	}
-
-	// Handle integers
-	if i, err := strconv.ParseInt(value, 10, 64); err == nil {
-		return i, nil
-	}
-
-	// Handle floats
-	if f, err := strconv.ParseFloat(value, 64); err == nil {
-		return f, nil
-	}
-
-	// Default to string
-	return value, nil
-}
-
-// isTextContentType returns true if the content type indicates text data
-func isTextContentType(contentType string) bool {
-	if contentType == "" {
-		return true // assume text if unknown
-	}
-	contentType = strings.ToLower(strings.Split(contentType, ";")[0]) // strip charset
-
-	return strings.HasPrefix(contentType, "text/") ||
-		strings.Contains(contentType, "json") ||
-		strings.Contains(contentType, "xml") ||
-		strings.Contains(contentType, "javascript") ||
-		strings.Contains(contentType, "yaml") ||
-		strings.Contains(contentType, "toml")
-}
-
-// expandPlaceholders replaces {owner}, {repo}, and {branch} in the endpoint
-func expandPlaceholders(endpoint string, ctx *context.TeaContext) string {
-	endpoint = strings.ReplaceAll(endpoint, "{owner}", ctx.Owner)
-	endpoint = strings.ReplaceAll(endpoint, "{repo}", ctx.Repo)
-
-	// Get current branch if available
-	if ctx.LocalRepo != nil {
-		if branch, err := ctx.LocalRepo.Head(); err == nil {
-			branchName := branch.Name().Short()
-			endpoint = strings.ReplaceAll(endpoint, "{branch}", branchName)
-		}
-	}
-
-	return endpoint
-}
--- a/cmd/attachments.go
+++ b/cmd/attachments.go
@@ -1,28 +0,0 @@
-// 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,
-}
--- a/cmd/attachments/create.go
+++ b/cmd/attachments/create.go
@@ -1,65 +0,0 @@
-// 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
-}
--- a/cmd/attachments/delete.go
+++ b/cmd/attachments/delete.go
@@ -1,83 +0,0 @@
-// 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
-}
--- a/cmd/attachments/list.go
+++ b/cmd/attachments/list.go
@@ -1,75 +0,0 @@
-// 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: flags.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")
-}
--- a/cmd/autocomplete.go
+++ b/cmd/autocomplete.go
@@ -0,0 +1,106 @@
+// 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.
+
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+
+	"github.com/adrg/xdg"
+	"github.com/urfave/cli/v2"
+)
+
+// 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)",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "install",
+			Usage: "Persist in shell config instead of printing commands",
+		},
+	},
+	Action: runAutocompleteAdd,
+}
+
+func runAutocompleteAdd(ctx *cli.Context) error {
+	var remoteFile, localFile, cmds string
+	shell := ctx.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"
+
+	default:
+		return fmt.Errorf("Must specify valid shell type")
+	}
+
+	localPath, err := xdg.ConfigFile("tea/" + localFile)
+	if err != nil {
+		return err
+	}
+
+	cmds = fmt.Sprintf(cmds, localPath)
+
+	if err := saveAutoCompleteFile(remoteFile, localPath); err != nil {
+		return err
+	}
+
+	if ctx.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 saveAutoCompleteFile(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
+}
--- a/cmd/branches.go
+++ b/cmd/branches.go
@@ -1,38 +0,0 @@
-// 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)
-}
--- a/cmd/branches/list.go
+++ b/cmd/branches/list.go
@@ -1,73 +0,0 @@
-// 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: flags.GetListOptions(),
-	})
-	if err != nil {
-		return err
-	}
-
-	protections, _, err = ctx.Login.Client().ListBranchProtections(owner, ctx.Repo, gitea.ListBranchProtectionsOptions{
-		ListOptions: flags.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
-}
--- a/cmd/branches/protect.go
+++ b/cmd/branches/protect.go
@@ -1,102 +0,0 @@
-// 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
-}
--- a/cmd/categories.go
+++ b/cmd/categories.go
@@ -1,5 +1,6 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package cmd

@@ -7,5 +8,4 @@ var (
 	catSetup    = "SETUP"
 	catEntities = "ENTITIES"
 	catHelpers  = "HELPERS"
-	catMisc     = "MISCELLANEOUS"
 )
--- a/cmd/clone.go
+++ b/cmd/clone.go
@@ -1,93 +0,0 @@
-// 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/debug"
-	"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
-		repo  string
-	)
-
-	// parse first arg as repo specifier
-	repoSlug := args.Get(0)
-	url, err := git.ParseURL(repoSlug)
-	if err != nil {
-		return err
-	}
-
-	debug.Printf("Cloning repository %s into %s", url.String(), dir)
-
-	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)
-		}
-		debug.Printf("Matched login '%s' for host '%s'", login.Name, url.Host)
-	}
-
-	_, err = task.RepoClone(
-		dir,
-		login,
-		owner,
-		repo,
-		interact.PromptPassword,
-		teaCmd.Int("depth"),
-	)
-
-	return err
-}
--- a/cmd/cmd.go
+++ b/cmd/cmd.go
@@ -1,107 +0,0 @@
-// 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"
-
-	"code.gitea.io/tea/modules/version"
-	"github.com/urfave/cli/v3"
-)
-
-// 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:            version.Format(),
-		Commands: []*cli.Command{
-			&CmdLogin,
-			&CmdLogout,
-			&CmdWhoami,
-
-			&CmdIssues,
-			&CmdPulls,
-			&CmdLabels,
-			&CmdMilestones,
-			&CmdReleases,
-			&CmdTrackedTimes,
-			&CmdOrgs,
-			&CmdRepos,
-			&CmdBranches,
-			&CmdActions,
-			&CmdWebhooks,
-			&CmdAddComment,
-
-			&CmdOpen,
-			&CmdNotifications,
-			&CmdRepoClone,
-
-			&CmdAdmin,
-
-			&CmdApi,
-			&CmdGenerateManPage,
-		},
-		EnableShellCompletion: true,
-	}
-}
-
-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 = fmt.Sprintf("\033[1m%s\033[0m", `
-   {{.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.
-`
--- a/cmd/comment.go
+++ b/cmd/comment.go
@@ -1,26 +1,22 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package cmd

 import (
-	stdctx "context"
-	"errors"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"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/theme"
-	"code.gitea.io/tea/modules/utils"

 	"code.gitea.io/sdk/gitea"
-	"github.com/charmbracelet/huh"
-	"github.com/urfave/cli/v3"
+	"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/v2"
 )

 // CmdAddComment is the main command to operate with notifications
@@ -35,7 +31,7 @@ var CmdAddComment = cli.Command{
 	Flags:       flags.AllDefaultFlags,
 }

-func runAddComment(_ stdctx.Context, cmd *cli.Command) error {
+func runAddComment(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})

@@ -52,28 +48,19 @@ func runAddComment(_ stdctx.Context, cmd *cli.Command) error {
 	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 {
+		if bodyStdin, err := ioutil.ReadAll(ctx.App.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 := huh.NewForm(
-			huh.NewGroup(
-				huh.NewText().
-					Title("Comment(markdown):").
-					ExternalEditor(config.GetPreferences().Editor).
-					EditorExtension("md").
-					Value(&body),
-			),
-		).WithTheme(theme.GetTheme()).
-			Run(); err != nil {
+		if body, err = interact.PromptMultiline("Content"); err != nil {
 			return err
 		}
 	}

 	if len(body) == 0 {
-		return errors.New("no comment content provided")
+		return fmt.Errorf("No comment body provided")
 	}

 	client := ctx.Login.Client()
--- a/cmd/flags/csvflag.go
+++ b/cmd/flags/csvflag.go
@@ -1,52 +0,0 @@
-// 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
-}
--- a/cmd/flags/flags.go
+++ b/cmd/flags/flags.go
@@ -0,0 +1,205 @@
+// 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 (
+	"fmt"
+	"strings"
+
+	"code.gitea.io/sdk/gitea"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/task"
+	"code.gitea.io/tea/modules/utils"
+
+	"github.com/araddon/dateparse"
+	"github.com/urfave/cli/v2"
+)
+
+// 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. (csv, simple, table, tsv, yaml)",
+}
+
+// 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...)
+
+// IssuePREditFlags defines flags for properties of issues and PRs
+var IssuePREditFlags = append([]cli.Flag{
+	&cli.StringFlag{
+		Name:    "title",
+		Aliases: []string{"t"},
+	},
+	&cli.StringFlag{
+		Name:    "description",
+		Aliases: []string{"d"},
+	},
+	&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",
+	},
+	&cli.StringFlag{
+		Name:    "deadline",
+		Aliases: []string{"D"},
+		Usage:   "Deadline timestamp to assign",
+	},
+	&cli.StringFlag{
+		Name:    "milestone",
+		Aliases: []string{"m"},
+		Usage:   "Milestone to assign",
+	},
+}, LoginRepoFlags...)
+
+// GetIssuePREditFlags parses all IssuePREditFlags
+func GetIssuePREditFlags(ctx *context.TeaContext) (*gitea.CreateIssueOption, error) {
+	opts := gitea.CreateIssueOption{
+		Title:     ctx.String("title"),
+		Body:      ctx.String("body"),
+		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
+}
+
+// FieldsFlag generates a flag selecting printable fields.
+// To retrieve the value, use GetFields()
+func FieldsFlag(availableFields, defaultFields []string) *cli.StringFlag {
+	return &cli.StringFlag{
+		Name:    "fields",
+		Aliases: []string{"f"},
+		Usage: fmt.Sprintf(`Comma-separated list of fields to print. Available values:
+			%s
+		`, strings.Join(availableFields, ",")),
+		Value: strings.Join(defaultFields, ","),
+	}
+}
+
+// GetFields parses the values provided in a fields flag, and
+// optionally validates against valid values.
+func GetFields(ctx *cli.Context, validFields []string) ([]string, error) {
+	selection := strings.Split(ctx.String("fields"), ",")
+	if validFields != nil {
+		for _, field := range selection {
+			if !utils.Contains(validFields, field) {
+				return nil, fmt.Errorf("Invalid field '%s'", field)
+			}
+		}
+	}
+	return selection, nil
+}
--- a/cmd/flags/generic.go
+++ b/cmd/flags/generic.go
@@ -1,174 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package flags
-
-import (
-	"errors"
-
-	"code.gitea.io/sdk/gitea"
-	"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)",
-}
-
-var (
-	paging gitea.ListOptions
-	// ErrPage indicates that the provided page value is invalid (less than -1 or equal to 0).
-	ErrPage = errors.New("page cannot be smaller than 1")
-	// ErrLimit indicates that the provided limit value is invalid (negative).
-	ErrLimit = errors.New("limit cannot be negative")
-)
-
-// GetListOptions returns configured paging struct
-func GetListOptions() gitea.ListOptions {
-	return paging
-}
-
-// PaginationFlags provides all pagination related flags
-var PaginationFlags = []cli.Flag{
-	&PaginationPageFlag,
-	&PaginationLimitFlag,
-}
-
-// PaginationPageFlag provides flag for pagination options
-var PaginationPageFlag = cli.IntFlag{
-	Name:    "page",
-	Aliases: []string{"p"},
-	Usage:   "specify page",
-	Value:   1,
-	Validator: func(i int) error {
-		if i < 1 && i != -1 {
-			return ErrPage
-		}
-		return nil
-	},
-	Destination: &paging.Page,
-}
-
-// PaginationLimitFlag provides flag for pagination options
-var PaginationLimitFlag = cli.IntFlag{
-	Name:    "limit",
-	Aliases: []string{"lm"},
-	Usage:   "specify limit of items per page",
-	Value:   30,
-	Validator: func(i int) error {
-		if i < 0 {
-			return ErrLimit
-		}
-		return nil
-	},
-	Destination: &paging.PageSize,
-}
-
-// 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)
-}
-
-// ParseState parses a state string and returns the corresponding gitea.StateType
-func ParseState(stateStr string) (gitea.StateType, error) {
-	switch stateStr {
-	case "all":
-		return gitea.StateAll, nil
-	case "", "open":
-		return gitea.StateOpen, nil
-	case "closed":
-		return gitea.StateClosed, nil
-	default:
-		return "", errors.New("unknown state '" + stateStr + "'")
-	}
-}
-
-// ParseIssueKind parses a kind string and returns the corresponding gitea.IssueType.
-// If kindStr is empty, returns the provided defaultKind.
-func ParseIssueKind(kindStr string, defaultKind gitea.IssueType) (gitea.IssueType, error) {
-	switch kindStr {
-	case "":
-		return defaultKind, nil
-	case "all":
-		return gitea.IssueTypeAll, nil
-	case "issue", "issues":
-		return gitea.IssueTypeIssue, nil
-	case "pull", "pulls", "pr":
-		return gitea.IssueTypePull, nil
-	default:
-		return "", errors.New("unknown kind '" + kindStr + "'")
-	}
-}
--- a/cmd/flags/generic_test.go
+++ b/cmd/flags/generic_test.go
@@ -1,125 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package flags
-
-import (
-	"context"
-	"io"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/urfave/cli/v3"
-)
-
-func TestPaginationFlags(t *testing.T) {
-	var (
-		defaultPage  = PaginationPageFlag.Value
-		defaultLimit = PaginationLimitFlag.Value
-	)
-
-	cases := []struct {
-		name          string
-		args          []string
-		expectedPage  int
-		expectedLimit int
-	}{
-		{
-			name:          "no flags",
-			args:          []string{"test"},
-			expectedPage:  defaultPage,
-			expectedLimit: defaultLimit,
-		},
-		{
-			name:          "only paging",
-			args:          []string{"test", "--page", "5"},
-			expectedPage:  5,
-			expectedLimit: defaultLimit,
-		},
-		{
-			name:          "only limit",
-			args:          []string{"test", "--limit", "10"},
-			expectedPage:  defaultPage,
-			expectedLimit: 10,
-		},
-		{
-			name:          "only limit",
-			args:          []string{"test", "--limit", "10"},
-			expectedPage:  defaultPage,
-			expectedLimit: 10,
-		},
-		{
-			name:          "both flags",
-			args:          []string{"test", "--page", "2", "--limit", "20"},
-			expectedPage:  2,
-			expectedLimit: 20,
-		},
-		{ // TODO: Should no paging be applied as -1 or a separate flag? It's not obvious that page=-1 turns off paging and limit is ignored
-			name:          "no paging",
-			args:          []string{"test", "--limit", "20", "--page", "-1"},
-			expectedPage:  -1,
-			expectedLimit: 20,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			cmd := cli.Command{
-				Name: "test-paging",
-				Action: func(_ context.Context, cmd *cli.Command) error {
-					assert.Equal(t, tc.expectedPage, cmd.Int("page"))
-					assert.Equal(t, tc.expectedLimit, cmd.Int("limit"))
-					return nil
-				},
-				Flags: PaginationFlags,
-			}
-			err := cmd.Run(context.Background(), tc.args)
-			require.NoError(t, err)
-		})
-	}
-}
-
-func TestPaginationFailures(t *testing.T) {
-	cases := []struct {
-		name          string
-		args          []string
-		expectedError error
-	}{
-		{
-			name:          "negative limit",
-			args:          []string{"test", "--limit", "-10"},
-			expectedError: ErrLimit,
-		},
-		{
-			name:          "negative paging",
-			args:          []string{"test", "--page", "-2"},
-			expectedError: ErrPage,
-		},
-		{
-			name:          "zero paging",
-			args:          []string{"test", "--page", "0"},
-			expectedError: ErrPage,
-		},
-		{
-			// urfave does not validate all flags in one pass
-			name:          "negative paging and paging",
-			args:          []string{"test", "--page", "-2", "--limit", "-10"},
-			expectedError: ErrPage,
-		},
-	}
-
-	for _, tc := range cases {
-		cmd := cli.Command{
-			Name:      "test-paging",
-			Flags:     PaginationFlags,
-			Writer:    io.Discard,
-			ErrWriter: io.Discard,
-		}
-		t.Run(tc.name, func(t *testing.T) {
-			err := cmd.Run(context.Background(), tc.args)
-			require.ErrorContains(t, err, tc.expectedError.Error())
-			// require.ErrorIs(t, err, tc.expectedError)
-		})
-	}
-}
--- a/cmd/flags/issue_pr.go
+++ b/cmd/flags/issue_pr.go
@@ -1,238 +0,0 @@
-// 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
-}
--- a/cmd/issues.go
+++ b/cmd/issues.go
@@ -1,53 +1,21 @@
 // Copyright 2018 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package cmd

 import (
-	stdctx "context"
-	"encoding/json"
 	"fmt"
-	"time"

-	"code.gitea.io/sdk/gitea"
-	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/cmd/issues"
 	"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/v3"
+	"github.com/urfave/cli/v2"
 )

-type labelData struct {
-	Name        string `json:"name"`
-	Color       string `json:"color"`
-	Description string `json:"description"`
-}
-
-type issueData struct {
-	ID        int64           `json:"id"`
-	Index     int64           `json:"index"`
-	Title     string          `json:"title"`
-	State     gitea.StateType `json:"state"`
-	Created   time.Time       `json:"created"`
-	Labels    []labelData     `json:"labels"`
-	User      string          `json:"user"`
-	Body      string          `json:"body"`
-	Assignees []string        `json:"assignees"`
-	URL       string          `json:"url"`
-	ClosedAt  *time.Time      `json:"closedAt"`
-	Comments  []commentData   `json:"comments"`
-}
-
-type commentData struct {
-	ID      int64     `json:"id"`
-	Author  string    `json:"author"`
-	Created time.Time `json:"created"`
-	Body    string    `json:"body"`
-}
-
 // CmdIssues represents to login a gitea server.
 var CmdIssues = cli.Command{
 	Name:        "issues",
@@ -57,57 +25,40 @@ var CmdIssues = cli.Command{
 	Description: `Lists issues when called without argument. If issue index is provided, will show it in detail.`,
 	ArgsUsage:   "[<issue index>]",
 	Action:      runIssues,
-	Commands: []*cli.Command{
+	Subcommands: []*cli.Command{
 		&issues.CmdIssuesList,
 		&issues.CmdIssuesCreate,
-		&issues.CmdIssuesEdit,
 		&issues.CmdIssuesReopen,
 		&issues.CmdIssuesClose,
 	},
 	Flags: append([]cli.Flag{
 		&cli.BoolFlag{
 			Name:  "comments",
-			Usage: "Whether to display comments (will prompt if not provided & run interactively)",
+			Usage: "Wether to display comments (will prompt if not provided & run interactively)",
 		},
 	}, issues.CmdIssuesList.Flags...),
 }

-func runIssues(ctx stdctx.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 1 {
-		return runIssueDetail(ctx, cmd, cmd.Args().First())
+func runIssues(ctx *cli.Context) error {
+	if ctx.Args().Len() == 1 {
+		return runIssueDetail(ctx, ctx.Args().First())
 	}
-	return issues.RunIssuesList(ctx, cmd)
+	return issues.RunIssuesList(ctx)
 }

-func runIssueDetail(_ stdctx.Context, cmd *cli.Command, index string) error {
+func runIssueDetail(cmd *cli.Context, index string) error {
 	ctx := context.InitCommand(cmd)
-	if ctx.IsSet("owner") {
-		ctx.Owner = ctx.String("owner")
-	}
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})

 	idx, err := utils.ArgToIndex(index)
 	if err != nil {
 		return err
 	}
-	client := ctx.Login.Client()
-	issue, _, err := client.GetIssue(ctx.Owner, ctx.Repo, idx)
+	issue, _, err := ctx.Login.Client().GetIssue(ctx.Owner, ctx.Repo, idx)
 	if err != nil {
 		return err
 	}
-	reactions, _, err := client.GetIssueReactions(ctx.Owner, ctx.Repo, idx)
-	if err != nil {
-		return err
-	}
-
-	if ctx.IsSet("output") {
-		switch ctx.String("output") {
-		case "json":
-			return runIssueDetailAsJSON(ctx, issue)
-		}
-	}
-
-	print.IssueDetails(issue, reactions)
+	print.IssueDetails(issue)

 	if issue.Comments > 0 {
 		err = interact.ShowCommentsMaybeInteractive(ctx, idx, issue.Comments)
@@ -118,61 +69,3 @@ func runIssueDetail(_ stdctx.Context, cmd *cli.Command, index string) error {

 	return nil
 }
-
-func runIssueDetailAsJSON(ctx *context.TeaContext, issue *gitea.Issue) error {
-	c := ctx.Login.Client()
-	opts := gitea.ListIssueCommentOptions{ListOptions: flags.GetListOptions()}
-
-	labelSlice := make([]labelData, 0, len(issue.Labels))
-	for _, label := range issue.Labels {
-		labelSlice = append(labelSlice, labelData{label.Name, label.Color, label.Description})
-	}
-
-	assigneesSlice := make([]string, 0, len(issue.Assignees))
-	for _, assignee := range issue.Assignees {
-		assigneesSlice = append(assigneesSlice, assignee.UserName)
-	}
-
-	issueSlice := issueData{
-		ID:        issue.ID,
-		Index:     issue.Index,
-		Title:     issue.Title,
-		State:     issue.State,
-		Created:   issue.Created,
-		User:      issue.Poster.UserName,
-		Body:      issue.Body,
-		Labels:    labelSlice,
-		Assignees: assigneesSlice,
-		URL:       issue.HTMLURL,
-		ClosedAt:  issue.Closed,
-		Comments:  make([]commentData, 0),
-	}
-
-	if ctx.Bool("comments") {
-		comments, _, err := c.ListIssueComments(ctx.Owner, ctx.Repo, issue.Index, opts)
-		issueSlice.Comments = make([]commentData, 0, len(comments))
-
-		if err != nil {
-			return err
-		}
-
-		for _, comment := range comments {
-			issueSlice.Comments = append(issueSlice.Comments, commentData{
-				ID:      comment.ID,
-				Author:  comment.Poster.UserName,
-				Body:    comment.Body, // Selected Field
-				Created: comment.Created,
-			})
-		}
-
-	}
-
-	jsonData, err := json.MarshalIndent(issueSlice, "", "\t")
-	if err != nil {
-		return err
-	}
-
-	_, err = fmt.Fprintf(ctx.Writer, "%s\n", jsonData)
-
-	return err
-}
--- a/cmd/issues/close.go
+++ b/cmd/issues/close.go
@@ -1,10 +1,10 @@
 // Copyright 2018 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package issues

 import (
-	stdctx "context"
 	"fmt"

 	"code.gitea.io/tea/cmd/flags"
@@ -13,47 +13,40 @@ import (
 	"code.gitea.io/tea/modules/utils"

 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdIssuesClose represents a sub command of issues to close an issue
 var CmdIssuesClose = cli.Command{
 	Name:        "close",
-	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 {
-		s := gitea.StateClosed
-		return editIssueState(ctx, cmd, gitea.EditIssueOption{State: &s})
+	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 {
+		var s = gitea.StateClosed
+		return editIssueState(ctx, gitea.EditIssueOption{State: &s})
 	},
 	Flags: flags.AllDefaultFlags,
 }

 // editIssueState abstracts the arg parsing to edit the given issue
-func editIssueState(_ stdctx.Context, cmd *cli.Command, opts gitea.EditIssueOption) error {
+func editIssueState(cmd *cli.Context, opts gitea.EditIssueOption) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 	if ctx.Args().Len() == 0 {
-		return fmt.Errorf("missing required argument: %s", ctx.Command.ArgsUsage)
+		return fmt.Errorf(ctx.Command.ArgsUsage)
 	}

-	indices, err := utils.ArgsToIndices(ctx.Args().Slice())
+	index, err := utils.ArgToIndex(ctx.Args().First())
 	if err != nil {
 		return err
 	}

-	client := ctx.Login.Client()
-	for _, index := range indices {
-		issue, _, err := client.EditIssue(ctx.Owner, ctx.Repo, index, opts)
-		if err != nil {
-			return err
-		}
-
-		if len(indices) > 1 {
-			fmt.Println(issue.HTMLURL)
-		} else {
-			print.IssueDetails(issue, nil)
-		}
+	issue, _, err := ctx.Login.Client().EditIssue(ctx.Owner, ctx.Repo, index, opts)
+	if err != nil {
+		return err
 	}
+
+	print.IssueDetails(issue)
 	return nil
 }
--- a/cmd/issues/create.go
+++ b/cmd/issues/create.go
@@ -1,17 +1,16 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package issues

 import (
-	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/task"

-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdIssuesCreate represents a sub command of issues to create issue
@@ -20,24 +19,19 @@ var CmdIssuesCreate = cli.Command{
 	Aliases:     []string{"c"},
 	Usage:       "Create an issue on repository",
 	Description: `Create an issue on repository`,
-	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runIssuesCreate,
-	Flags:       flags.IssuePRCreateFlags,
+	Flags:       flags.IssuePREditFlags,
 }

-func runIssuesCreate(_ stdctx.Context, cmd *cli.Command) error {
+func runIssuesCreate(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})

-	if ctx.IsInteractiveMode() {
-		err := interact.CreateIssue(ctx.Login, ctx.Owner, ctx.Repo)
-		if err != nil && !interact.IsQuitting(err) {
-			return err
-		}
-		return nil
+	if ctx.NumFlags() == 0 {
+		return interact.CreateIssue(ctx.Login, ctx.Owner, ctx.Repo)
 	}

-	opts, err := flags.GetIssuePRCreateFlags(ctx)
+	opts, err := flags.GetIssuePREditFlags(ctx)
 	if err != nil {
 		return err
 	}
--- a/cmd/issues/edit.go
+++ b/cmd/issues/edit.go
@@ -1,75 +0,0 @@
-// 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.IsInteractiveMode() {
-			var err error
-			opts, err = interact.EditIssue(*ctx, opts.Index)
-			if err != nil {
-				if interact.IsQuitting(err) {
-					return nil // user quit
-				}
-				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
-}
--- a/cmd/issues/list.go
+++ b/cmd/issues/list.go
@@ -1,110 +1,58 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package issues

 import (
-	stdctx "context"
-	"time"
-
 	"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/araddon/dateparse"
-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

-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:        "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:       append([]cli.Flag{issueFieldsFlag}, flags.IssueListingFlags...),
+	Flags: append([]cli.Flag{
+		flags.FieldsFlag(print.IssueFields, []string{
+			"index", "title", "state", "author", "milestone", "labels",
+		}),
+	}, flags.IssuePRFlags...),
 }

 // RunIssuesList list issues
-func RunIssuesList(_ stdctx.Context, cmd *cli.Command) error {
+func RunIssuesList(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
+	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+
+	state := gitea.StateOpen
+	switch ctx.String("state") {
+	case "all":
+		state = gitea.StateAll
+	case "open":
+		state = gitea.StateOpen
+	case "closed":
+		state = gitea.StateClosed
+	}
+
+	issues, _, err := ctx.Login.Client().ListRepoIssues(ctx.Owner, ctx.Repo, gitea.ListIssueOption{
+		ListOptions: ctx.GetListOptions(),
+		State:       state,
+		Type:        gitea.IssueTypeIssue,
+	})

-	state, err := flags.ParseState(ctx.String("state"))
 	if err != nil {
 		return err
 	}

-	kind, err := flags.ParseIssueKind(ctx.String("kind"), gitea.IssueTypeIssue)
-	if err != nil {
-		return err
-	}
-
-	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: flags.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,
-		})
-		if err != nil {
-			return err
-		}
-	} else {
-		issues, _, err = ctx.Login.Client().ListIssues(gitea.ListIssueOption{
-			ListOptions: flags.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
-		}
-	}
-
-	fields, err := issueFieldsFlag.GetValues(cmd)
+	fields, err := flags.GetFields(cmd, print.IssueFields)
 	if err != nil {
 		return err
 	}
--- a/cmd/issues/reopen.go
+++ b/cmd/issues/reopen.go
@@ -1,27 +1,26 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package issues

 import (
-	"context"
-
 	"code.gitea.io/tea/cmd/flags"

 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdIssuesReopen represents a sub command of issues to open an issue
 var CmdIssuesReopen = cli.Command{
 	Name:        "reopen",
 	Aliases:     []string{"open"},
-	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 {
-		s := gitea.StateOpen
-		return editIssueState(ctx, cmd, gitea.EditIssueOption{State: &s})
+	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 {
+		var s = gitea.StateOpen
+		return editIssueState(ctx, gitea.EditIssueOption{State: &s})
 	},
 	Flags: flags.AllDefaultFlags,
 }
--- a/cmd/issues_test.go
+++ b/cmd/issues_test.go
@@ -1,341 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"bytes"
-	stdctx "context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"code.gitea.io/sdk/gitea"
-	"code.gitea.io/tea/cmd/flags"
-	"code.gitea.io/tea/modules/config"
-	"code.gitea.io/tea/modules/context"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/urfave/cli/v3"
-)
-
-const (
-	testOwner = "testOwner"
-	testRepo  = "testRepo"
-)
-
-func createTestIssue(comments int, isClosed bool) gitea.Issue {
-	issue := gitea.Issue{
-		ID:      42,
-		Index:   1,
-		Title:   "Test issue",
-		State:   gitea.StateOpen,
-		Body:    "This is a test",
-		Created: time.Date(2025, 31, 10, 23, 59, 59, 999999999, time.UTC),
-		Updated: time.Date(2025, 1, 11, 0, 0, 0, 0, time.UTC),
-		Labels: []*gitea.Label{
-			{
-				Name:        "example/Label1",
-				Color:       "very red",
-				Description: "This is an example label",
-			},
-			{
-				Name:        "example/Label2",
-				Color:       "hardly red",
-				Description: "This is another example label",
-			},
-		},
-		Comments: comments,
-		Poster: &gitea.User{
-			UserName: "testUser",
-		},
-		Assignees: []*gitea.User{
-			{UserName: "testUser"},
-			{UserName: "testUser3"},
-		},
-		HTMLURL: "<space holder>",
-		Closed:  nil, // 2025-11-10T21:20:19Z
-	}
-
-	if isClosed {
-		closed := time.Date(2025, 11, 10, 21, 20, 19, 0, time.UTC)
-		issue.Closed = &closed
-	}
-
-	if isClosed {
-		issue.State = gitea.StateClosed
-	} else {
-		issue.State = gitea.StateOpen
-	}
-
-	return issue
-}
-
-func createTestIssueComments(comments int) []gitea.Comment {
-	baseID := 900
-	var result []gitea.Comment
-
-	for commentID := 0; commentID < comments; commentID++ {
-		result = append(result, gitea.Comment{
-			ID: int64(baseID + commentID),
-			Poster: &gitea.User{
-				UserName: "Freddy",
-			},
-			Body: fmt.Sprintf("This is a test comment #%v", commentID),
-			Created: time.Date(2025, 11, 3, 12, 0, 0, 0, time.UTC).
-				Add(time.Duration(commentID) * time.Hour),
-		})
-	}
-
-	return result
-}
-
-func TestRunIssueDetailAsJSON(t *testing.T) {
-	type TestCase struct {
-		name         string
-		issue        gitea.Issue
-		comments     []gitea.Comment
-		flagComments bool
-	}
-
-	cmd := cli.Command{
-		Name: "t",
-		Flags: []cli.Flag{
-			&cli.BoolFlag{
-				Name:  "comments",
-				Value: false,
-			},
-			&cli.StringFlag{
-				Name:  "output",
-				Value: "json",
-			},
-		},
-	}
-
-	testContext := context.TeaContext{
-		Owner: testOwner,
-		Repo:  testRepo,
-		Login: &config.Login{
-			Name: "testLogin",
-			URL:  "http://127.0.0.1:8081",
-		},
-		Command: &cmd,
-	}
-
-	testCases := []TestCase{
-		{
-			name:         "Simple issue with no comments, no comments requested",
-			issue:        createTestIssue(0, true),
-			comments:     []gitea.Comment{},
-			flagComments: false,
-		},
-		{
-			name:         "Simple issue with no comments, comments requested",
-			issue:        createTestIssue(0, true),
-			comments:     []gitea.Comment{},
-			flagComments: true,
-		},
-		{
-			name:         "Simple issue with comments, no comments requested",
-			issue:        createTestIssue(2, true),
-			comments:     createTestIssueComments(2),
-			flagComments: false,
-		},
-		{
-			name:         "Simple issue with comments, comments requested",
-			issue:        createTestIssue(2, true),
-			comments:     createTestIssueComments(2),
-			flagComments: true,
-		},
-		{
-			name:         "Simple issue with comments, comments requested, not closed",
-			issue:        createTestIssue(2, false),
-			comments:     createTestIssueComments(2),
-			flagComments: true,
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				path := r.URL.Path
-				if path == fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/comments", testOwner, testRepo, testCase.issue.Index) {
-					jsonComments, err := json.Marshal(testCase.comments)
-					if err != nil {
-						require.NoError(t, err, "Testing setup failed: failed to marshal comments")
-					}
-					w.Header().Set("Content-Type", "application/json")
-					w.WriteHeader(http.StatusOK)
-					_, err = w.Write(jsonComments)
-					require.NoError(t, err, "Testing setup failed: failed to write out comments")
-				} else {
-					http.NotFound(w, r)
-				}
-			})
-
-			server := httptest.NewServer(handler)
-
-			testContext.Login.URL = server.URL
-			testCase.issue.HTMLURL = fmt.Sprintf("%s/%s/%s/issues/%d/", testContext.Login.URL, testOwner, testRepo, testCase.issue.Index)
-
-			var outBuffer bytes.Buffer
-			testContext.Writer = &outBuffer
-			var errBuffer bytes.Buffer
-			testContext.ErrWriter = &errBuffer
-
-			if testCase.flagComments {
-				_ = testContext.Command.Set("comments", "true")
-			} else {
-				_ = testContext.Command.Set("comments", "false")
-			}
-
-			err := runIssueDetailAsJSON(&testContext, &testCase.issue)
-
-			server.Close()
-
-			require.NoError(t, err, "Failed to run issue detail as JSON")
-
-			out := outBuffer.String()
-
-			require.NotEmpty(t, out, "Unexpected empty output from runIssueDetailAsJSON")
-
-			// setting expectations
-
-			var expectedLabels []labelData
-			expectedLabels = []labelData{}
-			for _, l := range testCase.issue.Labels {
-				expectedLabels = append(expectedLabels, labelData{
-					Name:        l.Name,
-					Color:       l.Color,
-					Description: l.Description,
-				})
-			}
-
-			var expectedAssignees []string
-			expectedAssignees = []string{}
-			for _, a := range testCase.issue.Assignees {
-				expectedAssignees = append(expectedAssignees, a.UserName)
-			}
-
-			var expectedClosedAt *time.Time
-			if testCase.issue.Closed != nil {
-				expectedClosedAt = testCase.issue.Closed
-			}
-
-			var expectedComments []commentData
-			expectedComments = []commentData{}
-			if testCase.flagComments {
-				for _, c := range testCase.comments {
-					expectedComments = append(expectedComments, commentData{
-						ID:      c.ID,
-						Author:  c.Poster.UserName,
-						Body:    c.Body,
-						Created: c.Created,
-					})
-				}
-			}
-
-			expected := issueData{
-				ID:        testCase.issue.ID,
-				Index:     testCase.issue.Index,
-				Title:     testCase.issue.Title,
-				State:     testCase.issue.State,
-				Created:   testCase.issue.Created,
-				User:      testCase.issue.Poster.UserName,
-				Body:      testCase.issue.Body,
-				URL:       testCase.issue.HTMLURL,
-				ClosedAt:  expectedClosedAt,
-				Labels:    expectedLabels,
-				Assignees: expectedAssignees,
-				Comments:  expectedComments,
-			}
-
-			// validating reality
-			var actual issueData
-			dec := json.NewDecoder(bytes.NewReader(outBuffer.Bytes()))
-			dec.DisallowUnknownFields()
-			err = dec.Decode(&actual)
-			require.NoError(t, err, "Failed to unmarshal output into struct")
-
-			assert.Equal(t, expected, actual, "Expected structs differ from expected one")
-		})
-	}
-}
-
-func TestRunIssueDetailUsesOwnerFlag(t *testing.T) {
-	issueIndex := int64(12)
-	expectedOwner := "overrideOwner"
-	expectedRepo := "overrideRepo"
-	issue := gitea.Issue{
-		ID:      99,
-		Index:   issueIndex,
-		Title:   "Owner override test",
-		State:   gitea.StateOpen,
-		Created: time.Date(2025, 11, 1, 10, 0, 0, 0, time.UTC),
-		Poster: &gitea.User{
-			UserName: "tester",
-		},
-		HTMLURL: "https://example.test/issues/12",
-	}
-
-	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d", expectedOwner, expectedRepo, issueIndex):
-			jsonIssue, err := json.Marshal(issue)
-			require.NoError(t, err, "Testing setup failed: failed to marshal issue")
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusOK)
-			_, err = w.Write(jsonIssue)
-			require.NoError(t, err, "Testing setup failed: failed to write issue")
-		case fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/reactions", expectedOwner, expectedRepo, issueIndex):
-			jsonReactions, err := json.Marshal([]gitea.Reaction{})
-			require.NoError(t, err, "Testing setup failed: failed to marshal reactions")
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusOK)
-			_, err = w.Write(jsonReactions)
-			require.NoError(t, err, "Testing setup failed: failed to write reactions")
-		default:
-			http.NotFound(w, r)
-		}
-	})
-
-	server := httptest.NewServer(handler)
-	defer server.Close()
-
-	config.SetConfigForTesting(config.LocalConfig{
-		Logins: []config.Login{{
-			Name:    "testLogin",
-			URL:     server.URL,
-			Token:   "token",
-			User:    "loginUser",
-			Default: true,
-		}},
-	})
-
-	cmd := cli.Command{
-		Name: "issues",
-		Flags: []cli.Flag{
-			&flags.LoginFlag,
-			&flags.RepoFlag,
-			&flags.RemoteFlag,
-			&flags.OutputFlag,
-			&cli.StringFlag{Name: "owner"},
-			&cli.BoolFlag{Name: "comments"},
-		},
-	}
-	var outBuffer bytes.Buffer
-	var errBuffer bytes.Buffer
-	cmd.Writer = &outBuffer
-	cmd.ErrWriter = &errBuffer
-	require.NoError(t, cmd.Set("login", "testLogin"))
-	require.NoError(t, cmd.Set("repo", expectedRepo))
-	require.NoError(t, cmd.Set("owner", expectedOwner))
-	require.NoError(t, cmd.Set("output", "json"))
-	require.NoError(t, cmd.Set("comments", "false"))
-
-	err := runIssueDetail(stdctx.Background(), &cmd, fmt.Sprintf("%d", issueIndex))
-	require.NoError(t, err, "Expected runIssueDetail to succeed")
-}
--- a/cmd/labels.go
+++ b/cmd/labels.go
@@ -1,14 +1,14 @@
 // Copyright 2019 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package cmd

 import (
-	"context"
 	"fmt"

 	"code.gitea.io/tea/cmd/labels"
-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLabels represents to operate repositories' labels.
@@ -18,24 +18,22 @@ var CmdLabels = cli.Command{
 	Category:    catEntities,
 	Usage:       "Manage issue labels",
 	Description: `Manage issue labels`,
-	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runLabels,
-	Commands: []*cli.Command{
+	Subcommands: []*cli.Command{
 		&labels.CmdLabelsList,
 		&labels.CmdLabelCreate,
 		&labels.CmdLabelUpdate,
 		&labels.CmdLabelDelete,
 	},
-	Flags: labels.CmdLabelsList.Flags,
 }

-func runLabels(ctx context.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 1 {
-		return runLabelsDetails(cmd)
+func runLabels(ctx *cli.Context) error {
+	if ctx.Args().Len() == 1 {
+		return runLabelsDetails(ctx)
 	}
-	return labels.RunLabelsList(ctx, cmd)
+	return labels.RunLabelsList(ctx)
 }

-func runLabelsDetails(cmd *cli.Command) error {
+func runLabelsDetails(ctx *cli.Context) error {
 	return fmt.Errorf("Not yet implemented")
 }
--- a/cmd/labels/create.go
+++ b/cmd/labels/create.go
@@ -1,20 +1,19 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package labels

 import (
 	"bufio"
-	stdctx "context"
 	"log"
 	"os"
 	"strings"

-	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/modules/context"

 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLabelCreate represents a sub command of labels to create label.
@@ -23,9 +22,8 @@ var CmdLabelCreate = cli.Command{
 	Aliases:     []string{"c"},
 	Usage:       "Create a label",
 	Description: `Create a label`,
-	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runLabelCreate,
-	Flags: append([]cli.Flag{
+	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:  "name",
 			Usage: "label name",
@@ -42,51 +40,48 @@ var CmdLabelCreate = cli.Command{
 			Name:  "file",
 			Usage: "indicate a label file",
 		},
-	}, flags.AllDefaultFlags...),
+	},
 }

-func runLabelCreate(_ stdctx.Context, cmd *cli.Command) error {
+func runLabelCreate(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})

 	labelFile := ctx.String("file")
+	var err error
 	if len(labelFile) == 0 {
-		_, _, err := ctx.Login.Client().CreateLabel(ctx.Owner, ctx.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"),
 		})
-		return err
-	}
-
-	f, err := os.Open(labelFile)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	scanner := bufio.NewScanner(f)
-	i := 1
-	for scanner.Scan() {
-		line := scanner.Text()
-		color, name, description := splitLabelLine(line)
-		if color == "" || name == "" {
-			log.Printf("Line %d ignored because lack of enough fields: %s\n", i, line)
-		} else {
-			_, _, err = ctx.Login.Client().CreateLabel(ctx.Owner, ctx.Repo, gitea.CreateLabelOption{
-				Name:        name,
-				Color:       color,
-				Description: description,
-			})
-			if err != nil {
-				return err
-			}
+	} else {
+		f, err := os.Open(labelFile)
+		if err != nil {
+			return err
 		}
+		defer f.Close()

-		i++
+		scanner := bufio.NewScanner(f)
+		var i = 1
+		for scanner.Scan() {
+			line := scanner.Text()
+			color, name, description := splitLabelLine(line)
+			if color == "" || name == "" {
+				log.Printf("Line %d ignored because lack of enough fields: %s\n", i, line)
+			} else {
+				_, _, err = ctx.Login.Client().CreateLabel(ctx.Owner, ctx.Repo, gitea.CreateLabelOption{
+					Name:        name,
+					Color:       color,
+					Description: description,
+				})
+			}
+
+			i++
+		}
 	}

-	return nil
+	return err
 }

 func splitLabelLine(line string) (string, string, string) {
--- a/cmd/labels/create_test.go
+++ b/cmd/labels/create_test.go
@@ -1,5 +1,6 @@
 // Copyright 2019 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package labels

@@ -20,7 +21,7 @@ func TestParseLabelLine(t *testing.T) {
 `

 	scanner := bufio.NewScanner(strings.NewReader(labels))
-	i := 1
+	var i = 1
 	for scanner.Scan() {
 		line := scanner.Text()
 		color, name, description := splitLabelLine(line)
--- a/cmd/labels/delete.go
+++ b/cmd/labels/delete.go
@@ -1,16 +1,13 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package labels

 import (
-	stdctx "context"
-	"fmt"
-
-	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/modules/context"

-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLabelDelete represents a sub command of labels to delete label.
@@ -19,35 +16,19 @@ var CmdLabelDelete = cli.Command{
 	Aliases:     []string{"rm"},
 	Usage:       "Delete a label",
 	Description: `Delete a label`,
-	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runLabelDelete,
-	Flags: append([]cli.Flag{
-		&cli.Int64Flag{
-			Name:     "id",
-			Usage:    "label id",
-			Required: true,
+	Flags: []cli.Flag{
+		&cli.IntFlag{
+			Name:  "id",
+			Usage: "label id",
 		},
-	}, flags.AllDefaultFlags...),
+	},
 }

-func runLabelDelete(_ stdctx.Context, cmd *cli.Command) error {
+func runLabelDelete(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})

-	labelID := ctx.Int64("id")
-	client := ctx.Login.Client()
-
-	// Verify the label exists first
-	label, _, err := client.GetRepoLabel(ctx.Owner, ctx.Repo, labelID)
-	if err != nil {
-		return fmt.Errorf("failed to get label %d: %w", labelID, err)
-	}
-
-	_, err = client.DeleteLabel(ctx.Owner, ctx.Repo, labelID)
-	if err != nil {
-		return fmt.Errorf("failed to delete label '%s' (id: %d): %w", label.Name, labelID, err)
-	}
-
-	fmt.Printf("Label '%s' (id: %d) deleted successfully\n", label.Name, labelID)
-	return nil
+	_, err := ctx.Login.Client().DeleteLabel(ctx.Owner, ctx.Repo, ctx.Int64("id"))
+	return err
 }
--- a/cmd/labels/list.go
+++ b/cmd/labels/list.go
@@ -1,18 +1,17 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package labels

 import (
-	stdctx "context"
-
 	"code.gitea.io/tea/cmd/flags"
 	"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/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLabelsList represents a sub command of labels to list labels
@@ -21,7 +20,6 @@ var CmdLabelsList = cli.Command{
 	Aliases:     []string{"ls"},
 	Usage:       "List labels",
 	Description: "List labels",
-	ArgsUsage:   " ", // command does not accept arguments
 	Action:      RunLabelsList,
 	Flags: append([]cli.Flag{
 		&cli.BoolFlag{
@@ -35,13 +33,13 @@ var CmdLabelsList = cli.Command{
 }

 // RunLabelsList list labels.
-func RunLabelsList(_ stdctx.Context, cmd *cli.Command) error {
+func RunLabelsList(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})

 	client := ctx.Login.Client()
 	labels, _, err := client.ListRepoLabels(ctx.Owner, ctx.Repo, gitea.ListLabelsOptions{
-		ListOptions: flags.GetListOptions(),
+		ListOptions: ctx.GetListOptions(),
 	})
 	if err != nil {
 		return err
--- a/cmd/labels/update.go
+++ b/cmd/labels/update.go
@@ -1,16 +1,14 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package labels

 import (
-	stdctx "context"
-
-	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/modules/context"

 	"code.gitea.io/sdk/gitea"
-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLabelUpdate represents a sub command of labels to update label.
@@ -18,10 +16,9 @@ var CmdLabelUpdate = cli.Command{
 	Name:        "update",
 	Usage:       "Update a label",
 	Description: `Update a label`,
-	ArgsUsage:   " ", // command does not accept arguments
 	Action:      runLabelUpdate,
-	Flags: append([]cli.Flag{
-		&cli.Int64Flag{
+	Flags: []cli.Flag{
+		&cli.IntFlag{
 			Name:  "id",
 			Usage: "label id",
 		},
@@ -37,10 +34,10 @@ var CmdLabelUpdate = cli.Command{
 			Name:  "description",
 			Usage: "label description",
 		},
-	}, flags.AllDefaultFlags...),
+	},
 }

-func runLabelUpdate(_ stdctx.Context, cmd *cli.Command) error {
+func runLabelUpdate(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})

@@ -67,6 +64,7 @@ func runLabelUpdate(_ stdctx.Context, cmd *cli.Command) error {
 		Color:       pColor,
 		Description: pDescription,
 	})
+
 	if err != nil {
 		return err
 	}
--- a/cmd/login.go
+++ b/cmd/login.go
@@ -1,17 +1,17 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package cmd

 import (
-	"context"
 	"fmt"

 	"code.gitea.io/tea/cmd/login"
 	"code.gitea.io/tea/modules/config"
 	"code.gitea.io/tea/modules/print"

-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLogin represents to login a gitea server.
@@ -23,22 +23,20 @@ var CmdLogin = cli.Command{
 	Description: `Log in to a Gitea server`,
 	ArgsUsage:   "[<login name>]",
 	Action:      runLogins,
-	Commands: []*cli.Command{
+	Subcommands: []*cli.Command{
 		&login.CmdLoginList,
 		&login.CmdLoginAdd,
 		&login.CmdLoginEdit,
 		&login.CmdLoginDelete,
 		&login.CmdLoginSetDefault,
-		&login.CmdLoginHelper,
-		&login.CmdLoginOAuthRefresh,
 	},
 }

-func runLogins(ctx context.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 1 {
-		return runLoginDetail(cmd.Args().First())
+func runLogins(ctx *cli.Context) error {
+	if ctx.Args().Len() == 1 {
+		return runLoginDetail(ctx.Args().First())
 	}
-	return login.RunLoginList(ctx, cmd)
+	return login.RunLoginList(ctx)
 }

 func runLoginDetail(name string) error {
--- a/cmd/login/add.go
+++ b/cmd/login/add.go
@@ -1,17 +1,14 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package login

 import (
-	"context"
-	"fmt"
-
-	"code.gitea.io/tea/modules/auth"
 	"code.gitea.io/tea/modules/interact"
 	"code.gitea.io/tea/modules/task"

-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLoginAdd represents to login a gitea server.
@@ -19,7 +16,6 @@ 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",
@@ -30,136 +26,56 @@ var CmdLoginAdd = cli.Command{
 			Name:    "url",
 			Aliases: []string{"u"},
 			Value:   "https://gitea.com",
-			Sources: cli.EnvVars("GITEA_SERVER_URL"),
+			EnvVars: []string{"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:   "",
-			Sources: cli.EnvVars("GITEA_SERVER_TOKEN"),
+			EnvVars: []string{"GITEA_SERVER_TOKEN"},
 			Usage:   "Access token. Can be obtained from Settings > Applications",
 		},
 		&cli.StringFlag{
 			Name:    "user",
 			Value:   "",
-			Sources: cli.EnvVars("GITEA_SERVER_USER"),
+			EnvVars: []string{"GITEA_SERVER_USER"},
 			Usage:   "User for basic auth (will create token)",
 		},
 		&cli.StringFlag{
 			Name:    "password",
 			Aliases: []string{"pwd"},
 			Value:   "",
-			Sources: cli.EnvVars("GITEA_SERVER_PASSWORD"),
+			EnvVars: []string{"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/certificate to use, overrides auto-discovery",
+			Usage:   "Path to a SSH key 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(_ context.Context, cmd *cli.Command) error {
+func runLoginAdd(ctx *cli.Context) error {
 	// if no args create login interactive
-	if cmd.NumFlags() == 0 {
-		if err := interact.CreateLogin(); err != nil && !interact.IsQuitting(err) {
-			return fmt.Errorf("error adding login: %w", err)
-		}
-		return nil
-	}
-
-	// 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
+	if ctx.NumFlags() == 0 {
+		return interact.CreateLogin()
 	}

 	// else use args to add login
 	return task.CreateLogin(
-		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"),
-	)
+		ctx.String("name"),
+		ctx.String("token"),
+		ctx.String("user"),
+		ctx.String("password"),
+		ctx.String("ssh-key"),
+		ctx.String("url"),
+		ctx.Bool("insecure"))
 }
--- a/cmd/login/default.go
+++ b/cmd/login/default.go
@@ -1,16 +1,16 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package login

 import (
-	"context"
 	"fmt"

 	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/modules/config"

-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLoginSetDefault represents to login a gitea server.
@@ -23,8 +23,8 @@ var CmdLoginSetDefault = cli.Command{
 	Flags:       []cli.Flag{&flags.OutputFlag},
 }

-func runLoginSetDefault(_ context.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 0 {
+func runLoginSetDefault(ctx *cli.Context) error {
+	if ctx.Args().Len() == 0 {
 		l, err := config.GetDefaultLogin()
 		if err != nil {
 			return err
@@ -33,6 +33,6 @@ func runLoginSetDefault(_ context.Context, cmd *cli.Command) error {
 		return nil
 	}

-	name := cmd.Args().First()
+	name := ctx.Args().First()
 	return config.SetDefaultLogin(name)
 }
--- a/cmd/login/delete.go
+++ b/cmd/login/delete.go
@@ -1,16 +1,16 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package login

 import (
-	"context"
 	"errors"
 	"log"

 	"code.gitea.io/tea/modules/config"

-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // 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(_ context.Context, cmd *cli.Command) error {
+func RunLoginDelete(ctx *cli.Context) error {
 	logins, err := config.GetLogins()
 	if err != nil {
 		log.Fatal(err)
@@ -32,8 +32,8 @@ func RunLoginDelete(_ context.Context, cmd *cli.Command) error {

 	var name string

-	if len(cmd.Args().First()) != 0 {
-		name = cmd.Args().First()
+	if len(ctx.Args().First()) != 0 {
+		name = ctx.Args().First()
 	} else if len(logins) == 1 {
 		name = logins[0].Name
 	} else {
--- a/cmd/login/edit.go
+++ b/cmd/login/edit.go
@@ -1,19 +1,15 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 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/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLoginEdit represents to login a gitea server.
@@ -22,20 +18,10 @@ var CmdLoginEdit = cli.Command{
 	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(_ 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())
-		}
-	}
+func runLoginEdit(_ *cli.Context) error {
 	return open.Start(config.GetConfigPath())
 }
--- a/cmd/login/helper.go
+++ b/cmd/login/helper.go
@@ -1,138 +0,0 @@
-// Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package login
-
-import (
-	"bufio"
-	"context"
-	"fmt"
-	"log"
-	"net/url"
-	"os"
-	"strings"
-
-	"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",
-			Flags: []cli.Flag{
-				&cli.StringFlag{
-					Name:    "login",
-					Aliases: []string{"l"},
-					Usage:   "Use a specific login",
-				},
-			},
-			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("Hostname is required")
-				} else if len(wants["protocol"]) == 0 {
-					wants["protocol"] = "http"
-				}
-
-				// Use --login flag if provided, otherwise fall back to host lookup
-				var userConfig *config.Login
-				if loginName := cmd.String("login"); loginName != "" {
-					userConfig = config.GetLoginByName(loginName)
-					if userConfig == nil {
-						log.Fatalf("Login '%s' not found", loginName)
-					}
-				} else {
-					userConfig = config.GetLoginByHost(wants["host"])
-					if userConfig == nil {
-						log.Fatalf("No login found for host '%s'", wants["host"])
-					}
-				}
-
-				if len(userConfig.Token) == 0 {
-					log.Fatal("User not set")
-				}
-
-				host, err := url.Parse(userConfig.URL)
-				if err != nil {
-					return err
-				}
-
-				// Refresh token if expired or near expiry (updates userConfig in place)
-				if err = userConfig.RefreshOAuthTokenIfNeeded(); err != nil {
-					return err
-				}
-
-				_, 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
-			},
-		},
-	},
-}
--- a/cmd/login/list.go
+++ b/cmd/login/list.go
@@ -1,16 +1,15 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package login

 import (
-	"context"
-
 	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/modules/config"
 	"code.gitea.io/tea/modules/print"

-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLoginList represents to login a gitea server.
@@ -19,13 +18,12 @@ var CmdLoginList = cli.Command{
 	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(_ context.Context, cmd *cli.Command) error {
+func RunLoginList(cmd *cli.Context) error {
 	logins, err := config.GetLogins()
 	if err != nil {
 		return err
--- a/cmd/login/oauth_refresh.go
+++ b/cmd/login/oauth_refresh.go
@@ -1,68 +0,0 @@
-// 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. If the refresh token is also expired, opens a browser for re-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)
-	}
-
-	// Try to refresh the token
-	err := auth.RefreshAccessToken(login)
-	if err == nil {
-		fmt.Printf("Successfully refreshed OAuth token for %s\n", loginName)
-		return nil
-	}
-
-	// Refresh failed - fall back to browser-based re-authentication
-	fmt.Printf("Token refresh failed: %s\n", err)
-	fmt.Println("Opening browser for re-authentication...")
-
-	if err := auth.ReauthenticateLogin(login); err != nil {
-		return fmt.Errorf("re-authentication failed: %s", err)
-	}
-
-	fmt.Printf("Successfully re-authenticated %s\n", loginName)
-	return nil
-}
--- a/cmd/logout.go
+++ b/cmd/logout.go
@@ -1,12 +1,13 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package cmd

 import (
 	"code.gitea.io/tea/cmd/login"

-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdLogout represents to logout a gitea server.
--- a/cmd/man.go
+++ b/cmd/man.go
@@ -1,62 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	docs "github.com/urfave/cli-docs/v3"
-	"github.com/urfave/cli/v3"
-)
-
-// DocRenderFlags are the flags for documentation generation, used by `./docs/docs.go` and the `generate-man-page` sub command
-var DocRenderFlags = []cli.Flag{
-	&cli.StringFlag{
-		Name:    "out",
-		Usage:   "Path to output docs to, otherwise prints to stdout",
-		Aliases: []string{"o"},
-	},
-}
-
-// CmdGenerateManPage is the sub command to generate the `tea` man page
-var CmdGenerateManPage = cli.Command{
-	Name:   "man",
-	Usage:  "Generate man page",
-	Hidden: true,
-	Flags:  DocRenderFlags,
-	Action: func(ctx context.Context, cmd *cli.Command) error {
-		return RenderDocs(cmd, cmd.Root(), docs.ToMan)
-	},
-}
-
-// RenderDocs renders the documentation for `target` using the supplied `render` function
-func RenderDocs(cmd, target *cli.Command, render func(*cli.Command) (string, error)) error {
-	out, err := render(target)
-	if err != nil {
-		return err
-	}
-	outPath := cmd.String("out")
-	if outPath == "" {
-		fmt.Print(out)
-		return nil
-	}
-
-	if err = os.MkdirAll(filepath.Dir(outPath), os.ModePerm); err != nil {
-		return err
-	}
-
-	fi, err := os.Create(outPath)
-	if err != nil {
-		return err
-	}
-	defer fi.Close()
-	if _, err = fi.WriteString(out); err != nil {
-		return err
-	}
-
-	return nil
-}
--- a/cmd/milestones.go
+++ b/cmd/milestones.go
@@ -1,15 +1,15 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package cmd

 import (
-	stdctx "context"
-
 	"code.gitea.io/tea/cmd/milestones"
 	"code.gitea.io/tea/modules/context"
 	"code.gitea.io/tea/modules/print"
-	"github.com/urfave/cli/v3"
+
+	"github.com/urfave/cli/v2"
 )

 // CmdMilestones represents to operate repositories milestones.
@@ -21,7 +21,7 @@ var CmdMilestones = cli.Command{
 	Description: `List and create milestones`,
 	ArgsUsage:   "[<milestone name>]",
 	Action:      runMilestones,
-	Commands: []*cli.Command{
+	Subcommands: []*cli.Command{
 		&milestones.CmdMilestonesList,
 		&milestones.CmdMilestonesCreate,
 		&milestones.CmdMilestonesClose,
@@ -32,14 +32,14 @@ var CmdMilestones = cli.Command{
 	Flags: milestones.CmdMilestonesList.Flags,
 }

-func runMilestones(ctx stdctx.Context, cmd *cli.Command) error {
-	if cmd.Args().Len() == 1 {
-		return runMilestoneDetail(ctx, cmd, cmd.Args().First())
+func runMilestones(ctx *cli.Context) error {
+	if ctx.Args().Len() == 1 {
+		return runMilestoneDetail(ctx, ctx.Args().First())
 	}
-	return milestones.RunMilestonesList(ctx, cmd)
+	return milestones.RunMilestonesList(ctx)
 }

-func runMilestoneDetail(_ stdctx.Context, cmd *cli.Command, name string) error {
+func runMilestoneDetail(cmd *cli.Context, name string) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 	client := ctx.Login.Client()
--- a/cmd/milestones/close.go
+++ b/cmd/milestones/close.go
@@ -1,26 +1,26 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package milestones

 import (
-	"context"
-
 	"code.gitea.io/tea/cmd/flags"
-	"github.com/urfave/cli/v3"
+
+	"github.com/urfave/cli/v2"
 )

 // CmdMilestonesClose represents a sub command of milestones to close an milestone
 var CmdMilestonesClose = cli.Command{
 	Name:        "close",
-	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)
+	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)
 		}
-		return editMilestoneStatus(ctx, cmd, true)
+		return editMilestoneStatus(ctx, true)
 	},
 	Flags: append([]cli.Flag{
 		&cli.BoolFlag{
--- a/cmd/milestones/create.go
+++ b/cmd/milestones/create.go
@@ -1,20 +1,20 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package milestones

 import (
 	"time"

-	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/sdk/gitea"
 	"github.com/araddon/dateparse"
-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdMilestonesCreate represents a sub command of milestones to create milestone
@@ -23,7 +23,6 @@ var CmdMilestonesCreate = cli.Command{
 	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{
@@ -49,14 +48,14 @@ var CmdMilestonesCreate = cli.Command{
 	}, flags.AllDefaultFlags...),
 }

-func runMilestonesCreate(_ stdctx.Context, cmd *cli.Command) error {
+func runMilestonesCreate(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)

 	date := ctx.String("deadline")
 	deadline := &time.Time{}
 	if date != "" {
 		t, err := dateparse.ParseAny(date)
-		if err != nil {
+		if err == nil {
 			return err
 		}
 		deadline = &t
@@ -67,11 +66,8 @@ func runMilestonesCreate(_ stdctx.Context, cmd *cli.Command) error {
 		state = gitea.StateClosed
 	}

-	if ctx.IsInteractiveMode() {
-		if err := interact.CreateMilestone(ctx.Login, ctx.Owner, ctx.Repo); err != nil && !interact.IsQuitting(err) {
-			return err
-		}
-		return nil
+	if ctx.NumFlags() == 0 {
+		return interact.CreateMilestone(ctx.Login, ctx.Owner, ctx.Repo)
 	}

 	return task.CreateMilestone(
--- a/cmd/milestones/delete.go
+++ b/cmd/milestones/delete.go
@@ -1,15 +1,14 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package milestones

 import (
-	stdctx "context"
-
 	"code.gitea.io/tea/cmd/flags"
 	"code.gitea.io/tea/modules/context"

-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdMilestonesDelete represents a sub command of milestones to delete an milestone
@@ -23,7 +22,7 @@ var CmdMilestonesDelete = cli.Command{
 	Flags:       flags.AllDefaultFlags,
 }

-func deleteMilestone(_ stdctx.Context, cmd *cli.Command) error {
+func deleteMilestone(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 	client := ctx.Login.Client()
--- a/cmd/milestones/issues.go
+++ b/cmd/milestones/issues.go
@@ -1,24 +1,20 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package milestones

 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"
-)

-var msIssuesFieldsFlag = flags.FieldsFlag(print.IssueFields, []string{
-	"index", "kind", "title", "state", "updated", "labels",
-})
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v2"
+)

 // CmdMilestonesIssues represents a sub command of milestones to manage issue/pull of an milestone
 var CmdMilestonesIssues = cli.Command{
@@ -28,7 +24,7 @@ var CmdMilestonesIssues = cli.Command{
 	Description: "manage issue/pull of an milestone",
 	ArgsUsage:   "<milestone name>",
 	Action:      runMilestoneIssueList,
-	Commands: []*cli.Command{
+	Subcommands: []*cli.Command{
 		&CmdMilestoneAddIssue,
 		&CmdMilestoneRemoveIssue,
 	},
@@ -44,7 +40,9 @@ var CmdMilestonesIssues = cli.Command{
 		},
 		&flags.PaginationPageFlag,
 		&flags.PaginationLimitFlag,
-		msIssuesFieldsFlag,
+		flags.FieldsFlag(print.IssueFields, []string{
+			"index", "kind", "title", "state", "updated", "labels",
+		}),
 	}, flags.AllDefaultFlags...),
 }

@@ -70,34 +68,40 @@ var CmdMilestoneRemoveIssue = cli.Command{
 	Flags:       flags.AllDefaultFlags,
 }

-func runMilestoneIssueList(_ stdctx.Context, cmd *cli.Command) error {
+func runMilestoneIssueList(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 	client := ctx.Login.Client()

-	state, err := flags.ParseState(ctx.String("state"))
-	if err != nil {
-		return err
+	state := gitea.StateOpen
+	switch ctx.String("state") {
+	case "all":
+		state = gitea.StateAll
+	case "closed":
+		state = gitea.StateClosed
 	}

-	kind, err := flags.ParseIssueKind(ctx.String("kind"), gitea.IssueTypeAll)
-	if err != nil {
-		return err
+	kind := gitea.IssueTypeAll
+	switch ctx.String("kind") {
+	case "issue":
+		kind = gitea.IssueTypeIssue
+	case "pull":
+		kind = gitea.IssueTypePull
 	}

 	if ctx.Args().Len() != 1 {
-		return fmt.Errorf("milestone name is required")
+		return fmt.Errorf("Must specify milestone name")
 	}

 	milestone := ctx.Args().First()
 	// make sure milestone exist
-	_, _, err = client.GetMilestoneByName(ctx.Owner, ctx.Repo, milestone)
+	_, _, err := client.GetMilestoneByName(ctx.Owner, ctx.Repo, milestone)
 	if err != nil {
 		return err
 	}

 	issues, _, err := client.ListRepoIssues(ctx.Owner, ctx.Repo, gitea.ListIssueOption{
-		ListOptions: flags.GetListOptions(),
+		ListOptions: ctx.GetListOptions(),
 		Milestones:  []string{milestone},
 		Type:        kind,
 		State:       state,
@@ -106,7 +110,7 @@ func runMilestoneIssueList(_ stdctx.Context, cmd *cli.Command) error {
 		return err
 	}

-	fields, err := msIssuesFieldsFlag.GetValues(cmd)
+	fields, err := flags.GetFields(cmd, print.IssueFields)
 	if err != nil {
 		return err
 	}
@@ -114,7 +118,7 @@ func runMilestoneIssueList(_ stdctx.Context, cmd *cli.Command) error {
 	return nil
 }

-func runMilestoneIssueAdd(_ stdctx.Context, cmd *cli.Command) error {
+func runMilestoneIssueAdd(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 	client := ctx.Login.Client()
@@ -132,19 +136,16 @@ func runMilestoneIssueAdd(_ stdctx.Context, cmd *cli.Command) error {
 	// make sure milestone exist
 	mile, _, err := client.GetMilestoneByName(ctx.Owner, ctx.Repo, mileName)
 	if err != nil {
-		return fmt.Errorf("failed to get milestone '%s': %w", mileName, err)
+		return err
 	}

 	_, _, err = client.EditIssue(ctx.Owner, ctx.Repo, idx, gitea.EditIssueOption{
 		Milestone: &mile.ID,
 	})
-	if err != nil {
-		return fmt.Errorf("failed to add issue #%d to milestone '%s': %w", idx, mileName, err)
-	}
-	return nil
+	return err
 }

-func runMilestoneIssueRemove(_ stdctx.Context, cmd *cli.Command) error {
+func runMilestoneIssueRemove(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
 	client := ctx.Login.Client()
@@ -156,28 +157,25 @@ func runMilestoneIssueRemove(_ stdctx.Context, cmd *cli.Command) error {
 	issueIndex := ctx.Args().Get(1)
 	idx, err := utils.ArgToIndex(issueIndex)
 	if err != nil {
-		return fmt.Errorf("invalid issue index '%s': %w", issueIndex, err)
+		return err
 	}

 	issue, _, err := client.GetIssue(ctx.Owner, ctx.Repo, idx)
 	if err != nil {
-		return fmt.Errorf("failed to get issue #%d: %w", idx, err)
+		return err
 	}

 	if issue.Milestone == nil {
-		return fmt.Errorf("issue #%d is not assigned to a milestone", idx)
+		return fmt.Errorf("issue is not assigned to a milestone")
 	}

 	if issue.Milestone.Title != mileName {
-		return fmt.Errorf("issue #%d is assigned to milestone '%s', not '%s'", idx, issue.Milestone.Title, mileName)
+		return fmt.Errorf("issue is not assigned to this milestone")
 	}

 	zero := int64(0)
 	_, _, err = client.EditIssue(ctx.Owner, ctx.Repo, idx, gitea.EditIssueOption{
 		Milestone: &zero,
 	})
-	if err != nil {
-		return fmt.Errorf("failed to remove issue #%d from milestone '%s': %w", idx, mileName, err)
-	}
-	return nil
+	return err
 }
--- a/cmd/milestones/list.go
+++ b/cmd/milestones/list.go
@@ -1,33 +1,26 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package milestones

 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"
+	"github.com/urfave/cli/v2"
 )

-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:        "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)",
@@ -39,32 +32,28 @@ var CmdMilestonesList = cli.Command{
 }

 // RunMilestonesList list milestones
-func RunMilestonesList(_ stdctx.Context, cmd *cli.Command) error {
+func RunMilestonesList(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})

-	fields, err := fieldsFlag.GetValues(cmd)
-	if err != nil {
-		return err
-	}
-
-	state, err := flags.ParseState(ctx.String("state"))
-	if err != nil {
-		return err
-	}
-	if state == gitea.StateAll && !cmd.IsSet("fields") {
-		fields = append(fields, "state")
+	state := gitea.StateOpen
+	switch ctx.String("state") {
+	case "all":
+		state = gitea.StateAll
+	case "closed":
+		state = gitea.StateClosed
 	}

 	client := ctx.Login.Client()
 	milestones, _, err := client.ListRepoMilestones(ctx.Owner, ctx.Repo, gitea.ListMilestoneOption{
-		ListOptions: flags.GetListOptions(),
+		ListOptions: ctx.GetListOptions(),
 		State:       state,
 	})
+
 	if err != nil {
 		return err
 	}

-	print.MilestonesList(milestones, ctx.Output, fields)
+	print.MilestonesList(milestones, ctx.Output, state)
 	return nil
 }
--- a/cmd/milestones/reopen.go
+++ b/cmd/milestones/reopen.go
@@ -1,61 +1,43 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package milestones

 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"
+	"github.com/urfave/cli/v2"
 )

 // CmdMilestonesReopen represents a sub command of milestones to open an milestone
 var CmdMilestonesReopen = cli.Command{
 	Name:        "reopen",
 	Aliases:     []string{"open"},
-	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)
+	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)
 	},
 	Flags: flags.AllDefaultFlags,
 }

-func editMilestoneStatus(_ stdctx.Context, cmd *cli.Command, close bool) error {
+func editMilestoneStatus(cmd *cli.Context, close bool) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
-	if ctx.Args().Len() == 0 {
-		return fmt.Errorf("missing required argument: %s", ctx.Command.ArgsUsage)
-	}
+	client := ctx.Login.Client()

 	state := gitea.StateOpen
 	if close {
 		state = gitea.StateClosed
 	}
+	_, _, err := client.EditMilestoneByName(ctx.Owner, ctx.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
+	return err
 }
--- a/cmd/notifications.go
+++ b/cmd/notifications.go
@@ -1,12 +1,16 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package cmd

 import (
-	"code.gitea.io/tea/cmd/notifications"
+	"code.gitea.io/tea/cmd/flags"
+	"code.gitea.io/tea/modules/context"
+	"code.gitea.io/tea/modules/print"

-	"github.com/urfave/cli/v3"
+	"code.gitea.io/sdk/gitea"
+	"github.com/urfave/cli/v2"
 )

 // CmdNotifications is the main command to operate with notifications
@@ -15,14 +19,65 @@ var CmdNotifications = cli.Command{
 	Aliases:     []string{"notification", "n"},
 	Category:    catHelpers,
 	Usage:       "Show notifications",
-	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,
-	},
-	Flags: notifications.CmdNotificationsList.Flags,
+	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",
+		},
+		&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(cmd *cli.Context) error {
+	var news []*gitea.NotificationThread
+	var err error
+
+	ctx := context.InitCommand(cmd)
+	client := ctx.Login.Client()
+
+	listOpts := ctx.GetListOptions()
+	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 = client.ListNotifications(gitea.ListNotificationOptions{
+			ListOptions: listOpts,
+			Status:      status,
+		})
+	} else {
+		ctx.Ensure(context.CtxRequirement{RemoteRepo: true})
+		news, _, err = client.ListRepoNotifications(ctx.Owner, ctx.Repo, gitea.ListNotificationOptions{
+			ListOptions: listOpts,
+			Status:      status,
+		})
+	}
+	if err != nil {
+		return err
+	}
+
+	print.NotificationsList(news, ctx.Output, ctx.Bool("all"))
+	return nil
 }
--- a/cmd/notifications/list.go
+++ b/cmd/notifications/list.go
@@ -1,107 +0,0 @@
-// 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 := flags.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
-}
--- a/cmd/notifications/mark_as.go
+++ b/cmd/notifications/mark_as.go
@@ -1,143 +0,0 @@
-// 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
-		}
-		// Use LatestCommentHTMLURL if available, otherwise fall back to HTMLURL
-		if n.Subject.LatestCommentHTMLURL != "" {
-			fmt.Println(n.Subject.LatestCommentHTMLURL)
-		} else {
-			fmt.Println(n.Subject.HTMLURL)
-		}
-		return nil
-	}
-
-	return err
-}
--- a/cmd/open.go
+++ b/cmd/open.go
@@ -1,10 +1,10 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package cmd

 import (
-	stdctx "context"
 	"path"
 	"strings"

@@ -13,7 +13,7 @@ import (
 	local_git "code.gitea.io/tea/modules/git"

 	"github.com/skratchdot/open-golang/open"
-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdOpen represents a sub command of issues to open issue on the web browser
@@ -27,7 +27,7 @@ var CmdOpen = cli.Command{
 	Flags:       append([]cli.Flag{}, flags.LoginRepoFlags...),
 }

-func runOpen(_ stdctx.Context, cmd *cli.Command) error {
+func runOpen(cmd *cli.Context) error {
 	ctx := context.InitCommand(cmd)
 	ctx.Ensure(context.CtxRequirement{RemoteRepo: true})

@@ -74,5 +74,6 @@ func runOpen(_ stdctx.Context, cmd *cli.Command) error {
 		suffix = number
 	}

-	return open.Run(path.Join(ctx.GetRemoteRepoHTMLURL(), suffix))
+	u := path.Join(ctx.Login.URL, ctx.Owner, ctx.Repo, suffix)
+	return open.Run(u)
 }
--- a/cmd/organizations.go
+++ b/cmd/organizations.go
@@ -1,16 +1,15 @@
 // Copyright 2019 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.

 package cmd

 import (
-	stdctx "context"
+	"fmt"

 	"code.gitea.io/tea/cmd/organizations"
-	"code.gitea.io/tea/modules/context"
-	"code.gitea.io/tea/modules/print"

-	"github.com/urfave/cli/v3"
+	"github.com/urfave/cli/v2"
 )

 // CmdOrgs represents handle organization
@@ -22,28 +21,19 @@ var CmdOrgs = cli.Command{
 	Description: "Show organization details",
 	ArgsUsage:   "[<organization>]",
 	Action:      runOrganizations,
-	Commands: []*cli.Command{
+	Subcommands: []*cli.Command{
 		&organizations.CmdOrganizationList,
-		&organizations.CmdOrganizationCreate,
 		&organizations.CmdOrganizationDelete,
 	},
-	Flags: organizations.CmdOrganizationList.Flags,
 }

-func runOrganizations(ctx stdctx.Context, cmd *cli.Command) error {
-	teaCtx := context.InitCommand(cmd)
-	if teaCtx.Args().Len() == 1 {
-		return runOrganizationDetail(teaCtx)
+func runOrganizations(ctx *cli.Context) error {
+	if ctx.Args().Len() == 1 {
+		return runOrganizationDetail(ctx.Args().First())
 	}
-	return organizations.RunOrganizationList(ctx, cmd)
+	return organizations.RunOrganizationList(ctx)
 }

-func runOrganizationDetail(ctx *context.TeaContext) error {
-	org, _, err := ctx.Login.Client().GetOrg(ctx.Args().First())
-	if err != nil {
-		return err
-	}
-
-	print.OrganizationDetails(org)
-	return nil
+func runOrganizationDetail(path string) error {
+	return fmt.Errorf("Not yet implemented")
 }
--- a/cmd/organizations/create.go
+++ b/cmd/organizations/create.go
@@ -1,90 +0,0 @@
-// 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("organization name is required")
-	}
-
-	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
-}
--- a/Show More
+++ b/Show More